drivers/pwm/pwm-imx.c

   1 /*
   2  * simple driver for PWM (Pulse Width Modulator) controller
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * Derived from pxa PWM driver by eric miao <eric.miao@marvell.com>
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/kernel.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/slab.h>
  15 #include <linux/err.h>
  16 #include <linux/clk.h>
  17 #include <linux/io.h>
  18 #include <linux/pwm.h>
  19 #include <linux/of.h>
  20 #include <linux/of_device.h>
  21
  22 /* i.MX1 and i.MX21 share the same PWM function block: */
  23
  24 #define MX1_PWMC    0x00   /* PWM Control Register */
  25 #define MX1_PWMS    0x04   /* PWM Sample Register */
  26 #define MX1_PWMP    0x08   /* PWM Period Register */
  27
  28 #define MX1_PWMC_EN                     (1 << 4)
  29
  30 /* i.MX27, i.MX31, i.MX35 share the same PWM function block: */
  31
  32 #define MX3_PWMCR                       0x00      /* PWM Control Register */
  33 #define MX3_PWMSAR                      0x0C      /* PWM Sample Register */
  34 #define MX3_PWMPR                       0x10      /* PWM Period Register */
  35 #define MX3_PWMCR_PRESCALER(x)          ((((x) - 1) & 0xFFF) << 4)
  36 #define MX3_PWMCR_DOZEEN                (1 << 24)
  37 #define MX3_PWMCR_WAITEN                (1 << 23)
  38 #define MX3_PWMCR_DBGEN                 (1 << 22)
  39 #define MX3_PWMCR_POUTC                 (1 << 18)
  40 #define MX3_PWMCR_CLKSRC_IPG_HIGH       (2 << 16)
  41 #define MX3_PWMCR_CLKSRC_IPG            (1 << 16)
  42 #define MX3_PWMCR_EN                    (1 << 0)
  43
  44 struct imx_chip {
  45         struct clk      *clk_per;
  46         struct clk      *clk_ipg;
  47
  48         void __iomem    *mmio_base;
  49
  50         struct pwm_chip chip;
  51
  52         int (*config)(struct pwm_chip *chip,
  53                 struct pwm_device *pwm, int duty_ns, int period_ns);
  54         void (*set_enable)(struct pwm_chip *chip, bool enable);
  55 };
  56
  57 #define to_imx_chip(chip)       container_of(chip, struct imx_chip, chip)
  58
  59 static int imx_pwm_config_v1(struct pwm_chip *chip,
  60                 struct pwm_device *pwm, int duty_ns, int period_ns)
  61 {
  62         struct imx_chip *imx = to_imx_chip(chip);
  63
  64         /*
  65          * The PWM subsystem allows for exact frequencies. However,
  66          * I cannot connect a scope on my device to the PWM line and
  67          * thus cannot provide the program the PWM controller
  68          * exactly. Instead, I'm relying on the fact that the
  69          * Bootloader (u-boot or WinCE+haret) has programmed the PWM
  70          * function group already. So I'll just modify the PWM sample
  71          * register to follow the ratio of duty_ns vs. period_ns
  72          * accordingly.
  73          *
  74          * This is good enough for programming the brightness of
  75          * the LCD backlight.
  76          *
  77          * The real implementation would divide PERCLK[0] first by
  78          * both the prescaler (/1 .. /128) and then by CLKSEL
  79          * (/2 .. /16).
  80          */
  81         u32 max = readl(imx->mmio_base + MX1_PWMP);
  82         u32 p = max * duty_ns / period_ns;
  83         writel(max - p, imx->mmio_base + MX1_PWMS);
  84
  85         return 0;
  86 }
  87
  88 static void imx_pwm_set_enable_v1(struct pwm_chip *chip, bool enable)
  89 {
  90         struct imx_chip *imx = to_imx_chip(chip);
  91         u32 val;
  92
  93         val = readl(imx->mmio_base + MX1_PWMC);
  94
  95         if (enable)
  96                 val |= MX1_PWMC_EN;
  97         else
  98                 val &= ~MX1_PWMC_EN;
  99
 100         writel(val, imx->mmio_base + MX1_PWMC);
 101 }
 102
 103 static int imx_pwm_config_v2(struct pwm_chip *chip,
 104                 struct pwm_device *pwm, int duty_ns, int period_ns)
 105 {
 106         struct imx_chip *imx = to_imx_chip(chip);
 107         unsigned long long c;
 108         unsigned long period_cycles, duty_cycles, prescale;
 109         u32 cr;
 110
 111         c = clk_get_rate(imx->clk_per);
 112         c = c * period_ns;
 113         do_div(c, 1000000000);
 114         period_cycles = c;
 115
 116         prescale = period_cycles / 0x10000 + 1;
 117
 118         period_cycles /= prescale;
 119         c = (unsigned long long)period_cycles * duty_ns;
 120         do_div(c, period_ns);
 121         duty_cycles = c;
 122
 123         /*
 124          * according to imx pwm RM, the real period value should be
 125          * PERIOD value in PWMPR plus 2.
 126          */
 127         if (period_cycles > 2)
 128                 period_cycles -= 2;
 129         else
 130                 period_cycles = 0;
 131
 132         writel(duty_cycles, imx->mmio_base + MX3_PWMSAR);
 133         writel(period_cycles, imx->mmio_base + MX3_PWMPR);
 134
 135         cr = MX3_PWMCR_PRESCALER(prescale) |
 136                 MX3_PWMCR_DOZEEN | MX3_PWMCR_WAITEN |
 137                 MX3_PWMCR_DBGEN | MX3_PWMCR_CLKSRC_IPG_HIGH;
 138
 139         if (test_bit(PWMF_ENABLED, &pwm->flags))
 140                 cr |= MX3_PWMCR_EN;
 141         if (pwm->polarity == PWM_POLARITY_INVERSED)
 142                 cr |= MX3_PWMCR_POUTC;
 143
 144         writel(cr, imx->mmio_base + MX3_PWMCR);
 145
 146         return 0;
 147 }
 148
 149 static void imx_pwm_set_enable_v2(struct pwm_chip *chip, bool enable)
 150 {
 151         struct imx_chip *imx = to_imx_chip(chip);
 152         u32 val;
 153
 154         val = readl(imx->mmio_base + MX3_PWMCR);
 155
 156         if (enable)
 157                 val |= MX3_PWMCR_EN;
 158         else
 159                 val &= ~MX3_PWMCR_EN;
 160
 161         if (chip->pwms[0].polarity == PWM_POLARITY_INVERSED)
 162                 val |= MX3_PWMCR_POUTC;
 163         else
 164                 val &= ~MX3_PWMCR_POUTC;
 165
 166         writel(val, imx->mmio_base + MX3_PWMCR);
 167 }
 168
 169 static int imx_pwm_config(struct pwm_chip *chip,
 170                 struct pwm_device *pwm, int duty_ns, int period_ns)
 171 {
 172         struct imx_chip *imx = to_imx_chip(chip);
 173         int ret;
 174
 175         ret = clk_prepare_enable(imx->clk_ipg);
 176         if (ret)
 177                 return ret;
 178
 179         ret = imx->config(chip, pwm, duty_ns, period_ns);
 180
 181         clk_disable_unprepare(imx->clk_ipg);
 182
 183         return ret;
 184 }
 185
 186 static int imx_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 187 {
 188         struct imx_chip *imx = to_imx_chip(chip);
 189         int ret;
 190
 191         ret = clk_prepare_enable(imx->clk_per);
 192         if (ret)
 193                 return ret;
 194
 195         imx->set_enable(chip, true);
 196
 197         return 0;
 198 }
 199
 200 static void imx_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
 201 {
 202         struct imx_chip *imx = to_imx_chip(chip);
 203
 204         imx->set_enable(chip, false);
 205
 206         clk_disable_unprepare(imx->clk_per);
 207 }
 208
 209 static int imx_pwm_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,
 210                                 enum pwm_polarity polarity)
 211 {
 212         struct imx_chip *imx = to_imx_chip(chip);
 213
 214         dev_dbg(imx->chip.dev, "%s: polarity set to %s\n", __func__,
 215                 polarity == PWM_POLARITY_INVERSED ? "inverted" : "normal");
 216
 217         return 0;
 218 }
 219
 220 static struct pwm_ops imx_pwm_ops_v1 = {
 221         .enable = imx_pwm_enable,
 222         .disable = imx_pwm_disable,
 223         .config = imx_pwm_config,
 224         .owner = THIS_MODULE,
 225 };
 226
 227 static struct pwm_ops imx_pwm_ops_v2 = {
 228         .enable = imx_pwm_enable,
 229         .disable = imx_pwm_disable,
 230         .set_polarity = imx_pwm_set_polarity,
 231         .config = imx_pwm_config,
 232         .owner = THIS_MODULE,
 233 };
 234
 235 struct imx_pwm_data {
 236         int (*config)(struct pwm_chip *chip,
 237                 struct pwm_device *pwm, int duty_ns, int period_ns);
 238         void (*set_enable)(struct pwm_chip *chip, bool enable);
 239         struct pwm_ops *pwm_ops;
 240 };
 241
 242 static struct imx_pwm_data imx_pwm_data_v1 = {
 243         .config = imx_pwm_config_v1,
 244         .set_enable = imx_pwm_set_enable_v1,
 245         .pwm_ops = &imx_pwm_ops_v1,
 246 };
 247
 248 static struct imx_pwm_data imx_pwm_data_v2 = {
 249         .config = imx_pwm_config_v2,
 250         .set_enable = imx_pwm_set_enable_v2,
 251         .pwm_ops = &imx_pwm_ops_v2,
 252 };
 253
 254 static const struct of_device_id imx_pwm_dt_ids[] = {
 255         { .compatible = "fsl,imx1-pwm", .data = &imx_pwm_data_v1, },
 256         { .compatible = "fsl,imx27-pwm", .data = &imx_pwm_data_v2, },
 257         { /* sentinel */ }
 258 };
 259 MODULE_DEVICE_TABLE(of, imx_pwm_dt_ids);
 260
 261 static int imx_pwm_probe(struct platform_device *pdev)
 262 {
 263         const struct of_device_id *of_id =
 264                         of_match_device(imx_pwm_dt_ids, &pdev->dev);
 265         const struct imx_pwm_data *data;
 266         struct imx_chip *imx;
 267         struct resource *r;
 268         int ret = 0;
 269
 270         if (!of_id)
 271                 return -ENODEV;
 272
 273         data = of_id->data;
 274         if (data->pwm_ops->set_polarity)
 275                 dev_dbg(&pdev->dev, "PWM supports output inversion\n");
 276
 277         imx = devm_kzalloc(&pdev->dev, sizeof(*imx), GFP_KERNEL);
 278         if (imx == NULL)
 279                 return -ENOMEM;
 280
 281         imx->clk_per = devm_clk_get(&pdev->dev, "per");
 282         if (IS_ERR(imx->clk_per)) {
 283                 dev_err(&pdev->dev, "getting per clock failed with %ld\n",
 284                                 PTR_ERR(imx->clk_per));
 285                 return PTR_ERR(imx->clk_per);
 286         }
 287
 288         imx->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
 289         if (IS_ERR(imx->clk_ipg)) {
 290                 dev_err(&pdev->dev, "getting ipg clock failed with %ld\n",
 291                                 PTR_ERR(imx->clk_ipg));
 292                 return PTR_ERR(imx->clk_ipg);
 293         }
 294
 295         imx->chip.ops = data->pwm_ops;
 296         imx->chip.dev = &pdev->dev;
 297         imx->chip.base = -1;
 298         imx->chip.npwm = 1;
 299
 300         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 301         imx->mmio_base = devm_ioremap_resource(&pdev->dev, r);
 302         if (IS_ERR(imx->mmio_base))
 303                 return PTR_ERR(imx->mmio_base);
 304
 305         imx->config = data->config;
 306         imx->set_enable = data->set_enable;
 307
 308         ret = pwmchip_add(&imx->chip);
 309         if (ret < 0)
 310                 return ret;
 311
 312         platform_set_drvdata(pdev, imx);
 313         return 0;
 314 }
 315
 316 static int imx_pwm_remove(struct platform_device *pdev)
 317 {
 318         struct imx_chip *imx;
 319
 320         imx = platform_get_drvdata(pdev);
 321         if (imx == NULL)
 322                 return -ENODEV;
 323
 324         return pwmchip_remove(&imx->chip);
 325 }
 326
 327 static struct platform_driver imx_pwm_driver = {
 328         .driver         = {
 329                 .name   = "imx-pwm",
 330                 .owner = THIS_MODULE,
 331                 .of_match_table = imx_pwm_dt_ids,
 332         },
 333         .probe          = imx_pwm_probe,
 334         .remove         = imx_pwm_remove,
 335 };
 336
 337 module_platform_driver(imx_pwm_driver);
 338
 339 MODULE_LICENSE("GPL v2");
 340 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");