drivers/pwm/pwm-lp3943.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * TI/National Semiconductor LP3943 PWM driver
   4  *
   5  * Copyright 2013 Texas Instruments
   6  *
   7  * Author: Milo Kim <milo.kim@ti.com>
   8  */
   9
  10 #include <linux/err.h>
  11 #include <linux/mfd/lp3943.h>
  12 #include <linux/module.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/pwm.h>
  15 #include <linux/slab.h>
  16
  17 #define LP3943_MAX_DUTY                 255
  18 #define LP3943_MIN_PERIOD               6250
  19 #define LP3943_MAX_PERIOD               1600000
  20
  21 struct lp3943_pwm {
  22         struct pwm_chip chip;
  23         struct lp3943 *lp3943;
  24         struct lp3943_platform_data *pdata;
  25 };
  26
  27 static inline struct lp3943_pwm *to_lp3943_pwm(struct pwm_chip *_chip)
  28 {
  29         return container_of(_chip, struct lp3943_pwm, chip);
  30 }
  31
  32 static struct lp3943_pwm_map *
  33 lp3943_pwm_request_map(struct lp3943_pwm *lp3943_pwm, int hwpwm)
  34 {
  35         struct lp3943_platform_data *pdata = lp3943_pwm->pdata;
  36         struct lp3943 *lp3943 = lp3943_pwm->lp3943;
  37         struct lp3943_pwm_map *pwm_map;
  38         int i, offset;
  39
  40         pwm_map = kzalloc(sizeof(*pwm_map), GFP_KERNEL);
  41         if (!pwm_map)
  42                 return ERR_PTR(-ENOMEM);
  43
  44         pwm_map->output = pdata->pwms[hwpwm]->output;
  45         pwm_map->num_outputs = pdata->pwms[hwpwm]->num_outputs;
  46
  47         for (i = 0; i < pwm_map->num_outputs; i++) {
  48                 offset = pwm_map->output[i];
  49
  50                 /* Return an error if the pin is already assigned */
  51                 if (test_and_set_bit(offset, &lp3943->pin_used)) {
  52                         kfree(pwm_map);
  53                         return ERR_PTR(-EBUSY);
  54                 }
  55         }
  56
  57         return pwm_map;
  58 }
  59
  60 static int lp3943_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
  61 {
  62         struct lp3943_pwm *lp3943_pwm = to_lp3943_pwm(chip);
  63         struct lp3943_pwm_map *pwm_map;
  64
  65         pwm_map = lp3943_pwm_request_map(lp3943_pwm, pwm->hwpwm);
  66         if (IS_ERR(pwm_map))
  67                 return PTR_ERR(pwm_map);
  68
  69         return pwm_set_chip_data(pwm, pwm_map);
  70 }
  71
  72 static void lp3943_pwm_free_map(struct lp3943_pwm *lp3943_pwm,
  73                                 struct lp3943_pwm_map *pwm_map)
  74 {
  75         struct lp3943 *lp3943 = lp3943_pwm->lp3943;
  76         int i, offset;
  77
  78         for (i = 0; i < pwm_map->num_outputs; i++) {
  79                 offset = pwm_map->output[i];
  80                 clear_bit(offset, &lp3943->pin_used);
  81         }
  82
  83         kfree(pwm_map);
  84 }
  85
  86 static void lp3943_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
  87 {
  88         struct lp3943_pwm *lp3943_pwm = to_lp3943_pwm(chip);
  89         struct lp3943_pwm_map *pwm_map = pwm_get_chip_data(pwm);
  90
  91         lp3943_pwm_free_map(lp3943_pwm, pwm_map);
  92 }
  93
  94 static int lp3943_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
  95                              u64 duty_ns, u64 period_ns)
  96 {
  97         struct lp3943_pwm *lp3943_pwm = to_lp3943_pwm(chip);
  98         struct lp3943 *lp3943 = lp3943_pwm->lp3943;
  99         u8 val, reg_duty, reg_prescale;
 100         int err;
 101
 102         /*
 103          * How to configure the LP3943 PWMs
 104          *
 105          * 1) Period = 6250 ~ 1600000
 106          * 2) Prescale = period / 6250 -1
 107          * 3) Duty = input duty
 108          *
 109          * Prescale and duty are register values
 110          */
 111
 112         if (pwm->hwpwm == 0) {
 113                 reg_prescale = LP3943_REG_PRESCALE0;
 114                 reg_duty     = LP3943_REG_PWM0;
 115         } else {
 116                 reg_prescale = LP3943_REG_PRESCALE1;
 117                 reg_duty     = LP3943_REG_PWM1;
 118         }
 119
 120         /*
 121          * Note that after this clamping, period_ns fits into an int. This is
 122          * helpful because we can resort to integer division below instead of
 123          * the (more expensive) 64 bit division.
 124          */
 125         period_ns = clamp(period_ns, (u64)LP3943_MIN_PERIOD, (u64)LP3943_MAX_PERIOD);
 126         val       = (u8)((int)period_ns / LP3943_MIN_PERIOD - 1);
 127
 128         err = lp3943_write_byte(lp3943, reg_prescale, val);
 129         if (err)
 130                 return err;
 131
 132         duty_ns = min(duty_ns, period_ns);
 133         val = (u8)((int)duty_ns * LP3943_MAX_DUTY / (int)period_ns);
 134
 135         return lp3943_write_byte(lp3943, reg_duty, val);
 136 }
 137
 138 static int lp3943_pwm_set_mode(struct lp3943_pwm *lp3943_pwm,
 139                                struct lp3943_pwm_map *pwm_map,
 140                                u8 val)
 141 {
 142         struct lp3943 *lp3943 = lp3943_pwm->lp3943;
 143         const struct lp3943_reg_cfg *mux = lp3943->mux_cfg;
 144         int i, index, err;
 145
 146         for (i = 0; i < pwm_map->num_outputs; i++) {
 147                 index = pwm_map->output[i];
 148                 err = lp3943_update_bits(lp3943, mux[index].reg,
 149                                          mux[index].mask,
 150                                          val << mux[index].shift);
 151                 if (err)
 152                         return err;
 153         }
 154
 155         return 0;
 156 }
 157
 158 static int lp3943_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 159 {
 160         struct lp3943_pwm *lp3943_pwm = to_lp3943_pwm(chip);
 161         struct lp3943_pwm_map *pwm_map = pwm_get_chip_data(pwm);
 162         u8 val;
 163
 164         if (pwm->hwpwm == 0)
 165                 val = LP3943_DIM_PWM0;
 166         else
 167                 val = LP3943_DIM_PWM1;
 168
 169         /*
 170          * Each PWM generator is set to control any of outputs of LP3943.
 171          * To enable/disable the PWM, these output pins should be configured.
 172          */
 173
 174         return lp3943_pwm_set_mode(lp3943_pwm, pwm_map, val);
 175 }
 176
 177 static void lp3943_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
 178 {
 179         struct lp3943_pwm *lp3943_pwm = to_lp3943_pwm(chip);
 180         struct lp3943_pwm_map *pwm_map = pwm_get_chip_data(pwm);
 181
 182         /*
 183          * LP3943 outputs are open-drain, so the pin should be configured
 184          * when the PWM is disabled.
 185          */
 186
 187         lp3943_pwm_set_mode(lp3943_pwm, pwm_map, LP3943_GPIO_OUT_HIGH);
 188 }
 189
 190 static int lp3943_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
 191                             const struct pwm_state *state)
 192 {
 193         int err;
 194
 195         if (state->polarity != PWM_POLARITY_NORMAL)
 196                 return -EINVAL;
 197
 198         if (!state->enabled) {
 199                 if (pwm->state.enabled)
 200                         lp3943_pwm_disable(chip, pwm);
 201                 return 0;
 202         }
 203
 204         err = lp3943_pwm_config(chip, pwm, state->duty_cycle, state->period);
 205         if (err)
 206                 return err;
 207
 208         if (!pwm->state.enabled)
 209                 err = lp3943_pwm_enable(chip, pwm);
 210
 211         return err;
 212 }
 213
 214 static const struct pwm_ops lp3943_pwm_ops = {
 215         .request        = lp3943_pwm_request,
 216         .free           = lp3943_pwm_free,
 217         .apply          = lp3943_pwm_apply,
 218         .owner          = THIS_MODULE,
 219 };
 220
 221 static int lp3943_pwm_parse_dt(struct device *dev,
 222                                struct lp3943_pwm *lp3943_pwm)
 223 {
 224         static const char * const name[] = { "ti,pwm0", "ti,pwm1", };
 225         struct device_node *node = dev->of_node;
 226         struct lp3943_platform_data *pdata;
 227         struct lp3943_pwm_map *pwm_map;
 228         enum lp3943_pwm_output *output;
 229         int i, err, proplen, count = 0;
 230         u32 num_outputs;
 231
 232         if (!node)
 233                 return -EINVAL;
 234
 235         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 236         if (!pdata)
 237                 return -ENOMEM;
 238
 239         /*
 240          * Read the output map configuration from the device tree.
 241          * Each of the two PWM generators can drive zero or more outputs.
 242          */
 243
 244         for (i = 0; i < LP3943_NUM_PWMS; i++) {
 245                 if (!of_get_property(node, name[i], &proplen))
 246                         continue;
 247
 248                 num_outputs = proplen / sizeof(u32);
 249                 if (num_outputs == 0)
 250                         continue;
 251
 252                 output = devm_kcalloc(dev, num_outputs, sizeof(*output),
 253                                       GFP_KERNEL);
 254                 if (!output)
 255                         return -ENOMEM;
 256
 257                 err = of_property_read_u32_array(node, name[i], output,
 258                                                  num_outputs);
 259                 if (err)
 260                         return err;
 261
 262                 pwm_map = devm_kzalloc(dev, sizeof(*pwm_map), GFP_KERNEL);
 263                 if (!pwm_map)
 264                         return -ENOMEM;
 265
 266                 pwm_map->output = output;
 267                 pwm_map->num_outputs = num_outputs;
 268                 pdata->pwms[i] = pwm_map;
 269
 270                 count++;
 271         }
 272
 273         if (count == 0)
 274                 return -ENODATA;
 275
 276         lp3943_pwm->pdata = pdata;
 277         return 0;
 278 }
 279
 280 static int lp3943_pwm_probe(struct platform_device *pdev)
 281 {
 282         struct lp3943 *lp3943 = dev_get_drvdata(pdev->dev.parent);
 283         struct lp3943_pwm *lp3943_pwm;
 284         int ret;
 285
 286         lp3943_pwm = devm_kzalloc(&pdev->dev, sizeof(*lp3943_pwm), GFP_KERNEL);
 287         if (!lp3943_pwm)
 288                 return -ENOMEM;
 289
 290         lp3943_pwm->pdata = lp3943->pdata;
 291         if (!lp3943_pwm->pdata) {
 292                 if (IS_ENABLED(CONFIG_OF))
 293                         ret = lp3943_pwm_parse_dt(&pdev->dev, lp3943_pwm);
 294                 else
 295                         ret = -ENODEV;
 296
 297                 if (ret)
 298                         return ret;
 299         }
 300
 301         lp3943_pwm->lp3943 = lp3943;
 302         lp3943_pwm->chip.dev = &pdev->dev;
 303         lp3943_pwm->chip.ops = &lp3943_pwm_ops;
 304         lp3943_pwm->chip.npwm = LP3943_NUM_PWMS;
 305
 306         return devm_pwmchip_add(&pdev->dev, &lp3943_pwm->chip);
 307 }
 308
 309 #ifdef CONFIG_OF
 310 static const struct of_device_id lp3943_pwm_of_match[] = {
 311         { .compatible = "ti,lp3943-pwm", },
 312         { }
 313 };
 314 MODULE_DEVICE_TABLE(of, lp3943_pwm_of_match);
 315 #endif
 316
 317 static struct platform_driver lp3943_pwm_driver = {
 318         .probe = lp3943_pwm_probe,
 319         .driver = {
 320                 .name = "lp3943-pwm",
 321                 .of_match_table = of_match_ptr(lp3943_pwm_of_match),
 322         },
 323 };
 324 module_platform_driver(lp3943_pwm_driver);
 325
 326 MODULE_DESCRIPTION("LP3943 PWM driver");
 327 MODULE_ALIAS("platform:lp3943-pwm");
 328 MODULE_AUTHOR("Milo Kim");
 329 MODULE_LICENSE("GPL");