drivers/pwm/pwm-sti.c

   1 /*
   2  * PWM device driver for ST SoCs.
   3  * Author: Ajit Pal Singh <ajitpal.singh@st.com>
   4  *
   5  * Copyright (C) 2013-2014 STMicroelectronics (R&D) Limited
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  */
  12
  13 #include <linux/clk.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/math64.h>
  16 #include <linux/mfd/syscon.h>
  17 #include <linux/module.h>
  18 #include <linux/of.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/pwm.h>
  21 #include <linux/regmap.h>
  22 #include <linux/sched.h>
  23 #include <linux/slab.h>
  24 #include <linux/time.h>
  25 #include <linux/wait.h>
  26
  27 #define PWM_OUT_VAL(x)  (0x00 + (4 * (x))) /* Device's Duty Cycle register */
  28 #define PWM_CPT_VAL(x)  (0x10 + (4 * (x))) /* Capture value */
  29 #define PWM_CPT_EDGE(x) (0x30 + (4 * (x))) /* Edge to capture on */
  30
  31 #define STI_PWM_CTRL            0x50    /* Control/Config register */
  32 #define STI_INT_EN              0x54    /* Interrupt Enable/Disable register */
  33 #define STI_INT_STA             0x58    /* Interrupt Status register */
  34 #define PWM_INT_ACK                     0x5c
  35 #define PWM_PRESCALE_LOW_MASK           0x0f
  36 #define PWM_PRESCALE_HIGH_MASK          0xf0
  37 #define PWM_CPT_EDGE_MASK               0x03
  38 #define PWM_INT_ACK_MASK                0x1ff
  39
  40 #define STI_MAX_CPT_DEVS                4
  41 #define CPT_DC_MAX                      0xff
  42
  43 /* Regfield IDs */
  44 enum {
  45         /* Bits in PWM_CTRL*/
  46         PWMCLK_PRESCALE_LOW,
  47         PWMCLK_PRESCALE_HIGH,
  48         CPTCLK_PRESCALE,
  49
  50         PWM_OUT_EN,
  51         PWM_CPT_EN,
  52
  53         PWM_CPT_INT_EN,
  54         PWM_CPT_INT_STAT,
  55
  56         /* Keep last */
  57         MAX_REGFIELDS
  58 };
  59
  60 /* Each capture input can be programmed to detect rising-edge, falling-edge,
  61  * either edge or neither egde
  62  */
  63 enum sti_cpt_edge {
  64         CPT_EDGE_DISABLED,
  65         CPT_EDGE_RISING,
  66         CPT_EDGE_FALLING,
  67         CPT_EDGE_BOTH,
  68 };
  69
  70 struct sti_cpt_ddata {
  71         u32 snapshot[3];
  72         unsigned int index;
  73         struct mutex lock;
  74         wait_queue_head_t wait;
  75 };
  76
  77 struct sti_pwm_compat_data {
  78         const struct reg_field *reg_fields;
  79         unsigned int pwm_num_devs;
  80         unsigned int cpt_num_devs;
  81         unsigned int max_pwm_cnt;
  82         unsigned int max_prescale;
  83 };
  84
  85 struct sti_pwm_chip {
  86         struct device *dev;
  87         struct clk *pwm_clk;
  88         struct clk *cpt_clk;
  89         struct regmap *regmap;
  90         struct sti_pwm_compat_data *cdata;
  91         struct regmap_field *prescale_low;
  92         struct regmap_field *prescale_high;
  93         struct regmap_field *pwm_out_en;
  94         struct regmap_field *pwm_cpt_int_en;
  95         struct pwm_chip chip;
  96         struct pwm_device *cur;
  97         unsigned long configured;
  98         unsigned int en_count;
  99         struct mutex sti_pwm_lock; /* To sync between enable/disable calls */
 100         void __iomem *mmio;
 101 };
 102
 103 static const struct reg_field sti_pwm_regfields[MAX_REGFIELDS] = {
 104         [PWMCLK_PRESCALE_LOW]   = REG_FIELD(STI_PWM_CTRL, 0, 3),
 105         [PWMCLK_PRESCALE_HIGH]  = REG_FIELD(STI_PWM_CTRL, 11, 14),
 106         [CPTCLK_PRESCALE]       = REG_FIELD(STI_PWM_CTRL, 4, 8),
 107         [PWM_OUT_EN]            = REG_FIELD(STI_PWM_CTRL, 9, 9),
 108         [PWM_CPT_EN]            = REG_FIELD(STI_PWM_CTRL, 10, 10),
 109         [PWM_CPT_INT_EN]        = REG_FIELD(STI_INT_EN, 1, 4),
 110         [PWM_CPT_INT_STAT]      = REG_FIELD(STI_INT_STA, 1, 4),
 111 };
 112
 113 static inline struct sti_pwm_chip *to_sti_pwmchip(struct pwm_chip *chip)
 114 {
 115         return container_of(chip, struct sti_pwm_chip, chip);
 116 }
 117
 118 /*
 119  * Calculate the prescaler value corresponding to the period.
 120  */
 121 static int sti_pwm_get_prescale(struct sti_pwm_chip *pc, unsigned long period,
 122                                 unsigned int *prescale)
 123 {
 124         struct sti_pwm_compat_data *cdata = pc->cdata;
 125         unsigned long clk_rate;
 126         unsigned long val;
 127         unsigned int ps;
 128
 129         clk_rate = clk_get_rate(pc->pwm_clk);
 130         if (!clk_rate) {
 131                 dev_err(pc->dev, "failed to get clock rate\n");
 132                 return -EINVAL;
 133         }
 134
 135         /*
 136          * prescale = ((period_ns * clk_rate) / (10^9 * (max_pwm_count + 1)) - 1
 137          */
 138         val = NSEC_PER_SEC / clk_rate;
 139         val *= cdata->max_pwm_cnt + 1;
 140
 141         if (period % val) {
 142                 return -EINVAL;
 143         } else {
 144                 ps  = period / val - 1;
 145                 if (ps > cdata->max_prescale)
 146                         return -EINVAL;
 147         }
 148         *prescale = ps;
 149
 150         return 0;
 151 }
 152
 153 /*
 154  * For STiH4xx PWM IP, the PWM period is fixed to 256 local clock cycles.
 155  * The only way to change the period (apart from changing the PWM input clock)
 156  * is to change the PWM clock prescaler.
 157  * The prescaler is of 8 bits, so 256 prescaler values and hence
 158  * 256 possible period values are supported (for a particular clock rate).
 159  * The requested period will be applied only if it matches one of these
 160  * 256 values.
 161  */
 162 static int sti_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
 163                          int duty_ns, int period_ns)
 164 {
 165         struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
 166         struct sti_pwm_compat_data *cdata = pc->cdata;
 167         struct pwm_device *cur = pc->cur;
 168         struct device *dev = pc->dev;
 169         unsigned int prescale = 0, pwmvalx;
 170         int ret;
 171         unsigned int ncfg;
 172         bool period_same = false;
 173
 174         ncfg = hweight_long(pc->configured);
 175         if (ncfg)
 176                 period_same = (period_ns == pwm_get_period(cur));
 177
 178         /* Allow configuration changes if one of the
 179          * following conditions satisfy.
 180          * 1. No devices have been configured.
 181          * 2. Only one device has been configured and the new request
 182          *    is for the same device.
 183          * 3. Only one device has been configured and the new request is
 184          *    for a new device and period of the new device is same as
 185          *    the current configured period.
 186          * 4. More than one devices are configured and period of the new
 187          *    requestis the same as the current period.
 188          */
 189         if (!ncfg ||
 190             ((ncfg == 1) && (pwm->hwpwm == cur->hwpwm)) ||
 191             ((ncfg == 1) && (pwm->hwpwm != cur->hwpwm) && period_same) ||
 192             ((ncfg > 1) && period_same)) {
 193                 /* Enable clock before writing to PWM registers. */
 194                 ret = clk_enable(pc->pwm_clk);
 195                 if (ret)
 196                         return ret;
 197
 198                 ret = clk_enable(pc->cpt_clk);
 199                 if (ret)
 200                         return ret;
 201
 202                 if (!period_same) {
 203                         ret = sti_pwm_get_prescale(pc, period_ns, &prescale);
 204                         if (ret)
 205                                 goto clk_dis;
 206
 207                         ret =
 208                         regmap_field_write(pc->prescale_low,
 209                                            prescale & PWM_PRESCALE_LOW_MASK);
 210                         if (ret)
 211                                 goto clk_dis;
 212
 213                         ret =
 214                         regmap_field_write(pc->prescale_high,
 215                                 (prescale & PWM_PRESCALE_HIGH_MASK) >> 4);
 216                         if (ret)
 217                                 goto clk_dis;
 218                 }
 219
 220                 /*
 221                  * When PWMVal == 0, PWM pulse = 1 local clock cycle.
 222                  * When PWMVal == max_pwm_count,
 223                  * PWM pulse = (max_pwm_count + 1) local cycles,
 224                  * that is continuous pulse: signal never goes low.
 225                  */
 226                 pwmvalx = cdata->max_pwm_cnt * duty_ns / period_ns;
 227
 228                 ret = regmap_write(pc->regmap,
 229                                    PWM_OUT_VAL(pwm->hwpwm), pwmvalx);
 230                 if (ret)
 231                         goto clk_dis;
 232
 233                 ret = regmap_field_write(pc->pwm_cpt_int_en, 0);
 234
 235                 set_bit(pwm->hwpwm, &pc->configured);
 236                 pc->cur = pwm;
 237
 238                 dev_dbg(dev, "prescale:%u, period:%i, duty:%i, pwmvalx:%u\n",
 239                         prescale, period_ns, duty_ns, pwmvalx);
 240         } else {
 241                 return -EINVAL;
 242         }
 243
 244 clk_dis:
 245         clk_disable(pc->pwm_clk);
 246         clk_disable(pc->cpt_clk);
 247         return ret;
 248 }
 249
 250 static int sti_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 251 {
 252         struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
 253         struct device *dev = pc->dev;
 254         int ret = 0;
 255
 256         /*
 257          * Since we have a common enable for all PWM devices,
 258          * do not enable if already enabled.
 259          */
 260         mutex_lock(&pc->sti_pwm_lock);
 261         if (!pc->en_count) {
 262                 ret = clk_enable(pc->pwm_clk);
 263                 if (ret)
 264                         goto out;
 265
 266                 ret = clk_enable(pc->cpt_clk);
 267                 if (ret)
 268                         goto out;
 269
 270                 ret = regmap_field_write(pc->pwm_out_en, 1);
 271                 if (ret) {
 272                         dev_err(dev, "failed to enable PWM device:%d\n",
 273                                 pwm->hwpwm);
 274                         goto out;
 275                 }
 276         }
 277         pc->en_count++;
 278 out:
 279         mutex_unlock(&pc->sti_pwm_lock);
 280         return ret;
 281 }
 282
 283 static void sti_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
 284 {
 285         struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
 286
 287         mutex_lock(&pc->sti_pwm_lock);
 288         if (--pc->en_count) {
 289                 mutex_unlock(&pc->sti_pwm_lock);
 290                 return;
 291         }
 292         regmap_field_write(pc->pwm_out_en, 0);
 293
 294         clk_disable(pc->pwm_clk);
 295         clk_disable(pc->cpt_clk);
 296         mutex_unlock(&pc->sti_pwm_lock);
 297 }
 298
 299 static void sti_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
 300 {
 301         struct sti_pwm_chip *pc = to_sti_pwmchip(chip);
 302
 303         clear_bit(pwm->hwpwm, &pc->configured);
 304 }
 305
 306 static const struct pwm_ops sti_pwm_ops = {
 307         .config = sti_pwm_config,
 308         .enable = sti_pwm_enable,
 309         .disable = sti_pwm_disable,
 310         .free = sti_pwm_free,
 311         .owner = THIS_MODULE,
 312 };
 313
 314 static int sti_pwm_probe_dt(struct sti_pwm_chip *pc)
 315 {
 316         struct device *dev = pc->dev;
 317         const struct reg_field *reg_fields;
 318         struct device_node *np = dev->of_node;
 319         struct sti_pwm_compat_data *cdata = pc->cdata;
 320         u32 num_devs;
 321         int ret;
 322
 323         ret = of_property_read_u32(np, "st,pwm-num-chan", &num_devs);
 324         if (!ret)
 325                 cdata->pwm_num_devs = num_devs;
 326
 327         ret = of_property_read_u32(np, "st,capture-num-chan", &num_devs);
 328         if (!ret)
 329                 cdata->cpt_num_devs = num_devs;
 330
 331         reg_fields = cdata->reg_fields;
 332
 333         pc->prescale_low = devm_regmap_field_alloc(dev, pc->regmap,
 334                                         reg_fields[PWMCLK_PRESCALE_LOW]);
 335         if (IS_ERR(pc->prescale_low))
 336                 return PTR_ERR(pc->prescale_low);
 337
 338         pc->prescale_high = devm_regmap_field_alloc(dev, pc->regmap,
 339                                         reg_fields[PWMCLK_PRESCALE_HIGH]);
 340         if (IS_ERR(pc->prescale_high))
 341                 return PTR_ERR(pc->prescale_high);
 342
 343
 344         pc->pwm_out_en = devm_regmap_field_alloc(dev, pc->regmap,
 345                                                  reg_fields[PWM_OUT_EN]);
 346         if (IS_ERR(pc->pwm_out_en))
 347                 return PTR_ERR(pc->pwm_out_en);
 348
 349         pc->pwm_cpt_int_en = devm_regmap_field_alloc(dev, pc->regmap,
 350                                                  reg_fields[PWM_CPT_INT_EN]);
 351         if (IS_ERR(pc->pwm_cpt_int_en))
 352                 return PTR_ERR(pc->pwm_cpt_int_en);
 353
 354         return 0;
 355 }
 356
 357 static const struct regmap_config sti_pwm_regmap_config = {
 358         .reg_bits = 32,
 359         .val_bits = 32,
 360         .reg_stride = 4,
 361 };
 362
 363 static int sti_pwm_probe(struct platform_device *pdev)
 364 {
 365         struct device *dev = &pdev->dev;
 366         struct sti_pwm_compat_data *cdata;
 367         struct sti_pwm_chip *pc;
 368         struct resource *res;
 369         unsigned int i;
 370         int ret;
 371
 372         pc = devm_kzalloc(dev, sizeof(*pc), GFP_KERNEL);
 373         if (!pc)
 374                 return -ENOMEM;
 375
 376         cdata = devm_kzalloc(dev, sizeof(*cdata), GFP_KERNEL);
 377         if (!cdata)
 378                 return -ENOMEM;
 379
 380         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 381
 382         pc->mmio = devm_ioremap_resource(dev, res);
 383         if (IS_ERR(pc->mmio))
 384                 return PTR_ERR(pc->mmio);
 385
 386         pc->regmap = devm_regmap_init_mmio(dev, pc->mmio,
 387                                            &sti_pwm_regmap_config);
 388         if (IS_ERR(pc->regmap))
 389                 return PTR_ERR(pc->regmap);
 390
 391         /*
 392          * Setup PWM data with default values: some values could be replaced
 393          * with specific ones provided from Device Tree.
 394          */
 395         cdata->reg_fields   = &sti_pwm_regfields[0];
 396         cdata->max_prescale = 0xff;
 397         cdata->max_pwm_cnt  = 255;
 398         cdata->pwm_num_devs = 1;
 399         cdata->cpt_num_devs = 0;
 400
 401         pc->cdata = cdata;
 402         pc->dev = dev;
 403         pc->en_count = 0;
 404         mutex_init(&pc->sti_pwm_lock);
 405
 406         ret = sti_pwm_probe_dt(pc);
 407         if (ret)
 408                 return ret;
 409
 410         pc->pwm_clk = of_clk_get_by_name(dev->of_node, "pwm");
 411         if (IS_ERR(pc->pwm_clk)) {
 412                 dev_err(dev, "failed to get PWM clock\n");
 413                 return PTR_ERR(pc->pwm_clk);
 414         }
 415
 416         ret = clk_prepare(pc->pwm_clk);
 417         if (ret) {
 418                 dev_err(dev, "failed to prepare clock\n");
 419                 return ret;
 420         }
 421
 422         pc->cpt_clk = of_clk_get_by_name(dev->of_node, "capture");
 423         if (IS_ERR(pc->cpt_clk)) {
 424                 dev_err(dev, "failed to get PWM capture clock\n");
 425                 return PTR_ERR(pc->cpt_clk);
 426         }
 427
 428         ret = clk_prepare(pc->cpt_clk);
 429         if (ret) {
 430                 dev_err(dev, "failed to prepare clock\n");
 431                 return ret;
 432         }
 433
 434         pc->chip.dev = dev;
 435         pc->chip.ops = &sti_pwm_ops;
 436         pc->chip.base = -1;
 437         pc->chip.npwm = pc->cdata->pwm_num_devs;
 438         pc->chip.can_sleep = true;
 439
 440         ret = pwmchip_add(&pc->chip);
 441         if (ret < 0) {
 442                 clk_unprepare(pc->pwm_clk);
 443                 clk_unprepare(pc->cpt_clk);
 444                 return ret;
 445         }
 446
 447         for (i = 0; i < cdata->cpt_num_devs; i++) {
 448                 struct sti_cpt_ddata *ddata;
 449
 450                 ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL);
 451                 if (!ddata)
 452                         return -ENOMEM;
 453
 454                 init_waitqueue_head(&ddata->wait);
 455                 mutex_init(&ddata->lock);
 456
 457                 pwm_set_chip_data(&pc->chip.pwms[i], ddata);
 458         }
 459
 460         platform_set_drvdata(pdev, pc);
 461
 462         return 0;
 463 }
 464
 465 static int sti_pwm_remove(struct platform_device *pdev)
 466 {
 467         struct sti_pwm_chip *pc = platform_get_drvdata(pdev);
 468         unsigned int i;
 469
 470         for (i = 0; i < pc->cdata->pwm_num_devs; i++)
 471                 pwm_disable(&pc->chip.pwms[i]);
 472
 473         clk_unprepare(pc->pwm_clk);
 474         clk_unprepare(pc->cpt_clk);
 475
 476         return pwmchip_remove(&pc->chip);
 477 }
 478
 479 static const struct of_device_id sti_pwm_of_match[] = {
 480         { .compatible = "st,sti-pwm", },
 481         { /* sentinel */ }
 482 };
 483 MODULE_DEVICE_TABLE(of, sti_pwm_of_match);
 484
 485 static struct platform_driver sti_pwm_driver = {
 486         .driver = {
 487                 .name = "sti-pwm",
 488                 .of_match_table = sti_pwm_of_match,
 489         },
 490         .probe = sti_pwm_probe,
 491         .remove = sti_pwm_remove,
 492 };
 493 module_platform_driver(sti_pwm_driver);
 494
 495 MODULE_AUTHOR("Ajit Pal Singh <ajitpal.singh@st.com>");
 496 MODULE_DESCRIPTION("STMicroelectronics ST PWM driver");
 497 MODULE_LICENSE("GPL");