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_info(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 = {
 221         .enable = imx_pwm_enable,
 222         .disable = imx_pwm_disable,
 223         .config = imx_pwm_config,
 224         .owner = THIS_MODULE,
 225 };
 226
 227 struct imx_pwm_data {
 228         int (*config)(struct pwm_chip *chip,
 229                 struct pwm_device *pwm, int duty_ns, int period_ns);
 230         void (*set_enable)(struct pwm_chip *chip, bool enable);
 231         unsigned output_polarity:1;
 232 };
 233
 234 static struct imx_pwm_data imx_pwm_data_v1 = {
 235         .config = imx_pwm_config_v1,
 236         .set_enable = imx_pwm_set_enable_v1,
 237 };
 238
 239 static struct imx_pwm_data imx_pwm_data_v2 = {
 240         .config = imx_pwm_config_v2,
 241         .set_enable = imx_pwm_set_enable_v2,
 242         .output_polarity = 1,
 243 };
 244
 245 static const struct of_device_id imx_pwm_dt_ids[] = {
 246         { .compatible = "fsl,imx1-pwm", .data = &imx_pwm_data_v1, },
 247         { .compatible = "fsl,imx27-pwm", .data = &imx_pwm_data_v2, },
 248         { /* sentinel */ }
 249 };
 250 MODULE_DEVICE_TABLE(of, imx_pwm_dt_ids);
 251
 252 static int imx_pwm_probe(struct platform_device *pdev)
 253 {
 254         const struct of_device_id *of_id =
 255                         of_match_device(imx_pwm_dt_ids, &pdev->dev);
 256         const struct imx_pwm_data *data;
 257         struct imx_chip *imx;
 258         struct resource *r;
 259         int ret = 0;
 260
 261         if (!of_id)
 262                 return -ENODEV;
 263
 264         imx = devm_kzalloc(&pdev->dev, sizeof(*imx), GFP_KERNEL);
 265         if (imx == NULL) {
 266                 dev_err(&pdev->dev, "failed to allocate memory\n");
 267                 return -ENOMEM;
 268         }
 269
 270         imx->clk_per = devm_clk_get(&pdev->dev, "per");
 271         if (IS_ERR(imx->clk_per)) {
 272                 dev_err(&pdev->dev, "getting per clock failed with %ld\n",
 273                                 PTR_ERR(imx->clk_per));
 274                 return PTR_ERR(imx->clk_per);
 275         }
 276
 277         imx->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
 278         if (IS_ERR(imx->clk_ipg)) {
 279                 dev_err(&pdev->dev, "getting ipg clock failed with %ld\n",
 280                                 PTR_ERR(imx->clk_ipg));
 281                 return PTR_ERR(imx->clk_ipg);
 282         }
 283
 284         imx->chip.ops = &imx_pwm_ops;
 285         imx->chip.dev = &pdev->dev;
 286         imx->chip.base = -1;
 287         imx->chip.npwm = 1;
 288
 289         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 290         imx->mmio_base = devm_ioremap_resource(&pdev->dev, r);
 291         if (IS_ERR(imx->mmio_base))
 292                 return PTR_ERR(imx->mmio_base);
 293
 294         data = of_id->data;
 295         if (data->output_polarity) {
 296                 dev_info(&pdev->dev, "PWM supports output inversion\n");
 297                 imx_pwm_ops.set_polarity = imx_pwm_set_polarity;
 298                 imx->chip.of_xlate = of_pwm_xlate_with_flags;
 299                 imx->chip.of_pwm_n_cells = 3;
 300         }
 301
 302         imx->config = data->config;
 303         imx->set_enable = data->set_enable;
 304
 305         ret = pwmchip_add(&imx->chip);
 306         if (ret < 0)
 307                 return ret;
 308
 309         platform_set_drvdata(pdev, imx);
 310         return 0;
 311 }
 312
 313 static int imx_pwm_remove(struct platform_device *pdev)
 314 {
 315         struct imx_chip *imx;
 316
 317         imx = platform_get_drvdata(pdev);
 318         if (imx == NULL)
 319                 return -ENODEV;
 320
 321         return pwmchip_remove(&imx->chip);
 322 }
 323
 324 static struct platform_driver imx_pwm_driver = {
 325         .driver         = {
 326                 .name   = "imx-pwm",
 327                 .owner = THIS_MODULE,
 328                 .of_match_table = imx_pwm_dt_ids,
 329         },
 330         .probe          = imx_pwm_probe,
 331         .remove         = imx_pwm_remove,
 332 };
 333
 334 module_platform_driver(imx_pwm_driver);
 335
 336 MODULE_LICENSE("GPL v2");
 337 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");