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