arch/arm/plat-mxc/pwm.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/err.h>
  15 #include <linux/clk.h>
  16 #include <linux/io.h>
  17 #include <linux/pwm.h>
  18 #include <mach/hardware.h>
  19
  20
  21 /* i.MX1 and i.MX21 share the same PWM function block: */
  22
  23 #define MX1_PWMC    0x00   /* PWM Control Register */
  24 #define MX1_PWMS    0x04   /* PWM Sample Register */
  25 #define MX1_PWMP    0x08   /* PWM Period Register */
  26
  27
  28 /* i.MX27, i.MX31, i.MX35 share the same PWM function block: */
  29
  30 #define MX3_PWMCR                 0x00    /* PWM Control Register */
  31 #define MX3_PWMSAR                0x0C    /* PWM Sample Register */
  32 #define MX3_PWMPR                 0x10    /* PWM Period Register */
  33 #define MX3_PWMCR_PRESCALER(x)    (((x - 1) & 0xFFF) << 4)
  34 #define MX3_PWMCR_CLKSRC_IPG_HIGH (2 << 16)
  35 #define MX3_PWMCR_EN              (1 << 0)
  36
  37
  38
  39 struct pwm_device {
  40         struct list_head        node;
  41         struct platform_device *pdev;
  42
  43         const char      *label;
  44         struct clk      *clk;
  45
  46         int             clk_enabled;
  47         void __iomem    *mmio_base;
  48
  49         unsigned int    use_count;
  50         unsigned int    pwm_id;
  51 };
  52
  53 int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
  54 {
  55         if (pwm == NULL || period_ns == 0 || duty_ns > period_ns)
  56                 return -EINVAL;
  57
  58         if (cpu_is_mx27() || cpu_is_mx3()) {
  59                 unsigned long long c;
  60                 unsigned long period_cycles, duty_cycles, prescale;
  61                 c = clk_get_rate(pwm->clk);
  62                 c = c * period_ns;
  63                 do_div(c, 1000000000);
  64                 period_cycles = c;
  65
  66                 prescale = period_cycles / 0x10000 + 1;
  67
  68                 period_cycles /= prescale;
  69                 c = (unsigned long long)period_cycles * duty_ns;
  70                 do_div(c, period_ns);
  71                 duty_cycles = c;
  72
  73                 writel(duty_cycles, pwm->mmio_base + MX3_PWMSAR);
  74                 writel(period_cycles, pwm->mmio_base + MX3_PWMPR);
  75                 writel(MX3_PWMCR_PRESCALER(prescale - 1) |
  76                         MX3_PWMCR_CLKSRC_IPG_HIGH | MX3_PWMCR_EN,
  77                         pwm->mmio_base + MX3_PWMCR);
  78         } else if (cpu_is_mx1() || cpu_is_mx21()) {
  79                 /* The PWM subsystem allows for exact frequencies. However,
  80                  * I cannot connect a scope on my device to the PWM line and
  81                  * thus cannot provide the program the PWM controller
  82                  * exactly. Instead, I'm relying on the fact that the
  83                  * Bootloader (u-boot or WinCE+haret) has programmed the PWM
  84                  * function group already. So I'll just modify the PWM sample
  85                  * register to follow the ratio of duty_ns vs. period_ns
  86                  * accordingly.
  87                  *
  88                  * This is good enought for programming the brightness of
  89                  * the LCD backlight.
  90                  *
  91                  * The real implementation would divide PERCLK[0] first by
  92                  * both the prescaler (/1 .. /128) and then by CLKSEL
  93                  * (/2 .. /16).
  94                  */
  95                 u32 max = readl(pwm->mmio_base + MX1_PWMP);
  96                 u32 p = max * duty_ns / period_ns;
  97                 writel(max - p, pwm->mmio_base + MX1_PWMS);
  98         } else {
  99                 BUG();
 100         }
 101
 102         return 0;
 103 }
 104 EXPORT_SYMBOL(pwm_config);
 105
 106 int pwm_enable(struct pwm_device *pwm)
 107 {
 108         int rc = 0;
 109
 110         if (!pwm->clk_enabled) {
 111                 rc = clk_enable(pwm->clk);
 112                 if (!rc)
 113                         pwm->clk_enabled = 1;
 114         }
 115         return rc;
 116 }
 117 EXPORT_SYMBOL(pwm_enable);
 118
 119 void pwm_disable(struct pwm_device *pwm)
 120 {
 121         if (pwm->clk_enabled) {
 122                 clk_disable(pwm->clk);
 123                 pwm->clk_enabled = 0;
 124         }
 125 }
 126 EXPORT_SYMBOL(pwm_disable);
 127
 128 static DEFINE_MUTEX(pwm_lock);
 129 static LIST_HEAD(pwm_list);
 130
 131 struct pwm_device *pwm_request(int pwm_id, const char *label)
 132 {
 133         struct pwm_device *pwm;
 134         int found = 0;
 135
 136         mutex_lock(&pwm_lock);
 137
 138         list_for_each_entry(pwm, &pwm_list, node) {
 139                 if (pwm->pwm_id == pwm_id) {
 140                         found = 1;
 141                         break;
 142                 }
 143         }
 144
 145         if (found) {
 146                 if (pwm->use_count == 0) {
 147                         pwm->use_count++;
 148                         pwm->label = label;
 149                 } else
 150                         pwm = ERR_PTR(-EBUSY);
 151         } else
 152                 pwm = ERR_PTR(-ENOENT);
 153
 154         mutex_unlock(&pwm_lock);
 155         return pwm;
 156 }
 157 EXPORT_SYMBOL(pwm_request);
 158
 159 void pwm_free(struct pwm_device *pwm)
 160 {
 161         mutex_lock(&pwm_lock);
 162
 163         if (pwm->use_count) {
 164                 pwm->use_count--;
 165                 pwm->label = NULL;
 166         } else
 167                 pr_warning("PWM device already freed\n");
 168
 169         mutex_unlock(&pwm_lock);
 170 }
 171 EXPORT_SYMBOL(pwm_free);
 172
 173 static int __devinit mxc_pwm_probe(struct platform_device *pdev)
 174 {
 175         struct pwm_device *pwm;
 176         struct resource *r;
 177         int ret = 0;
 178
 179         pwm = kzalloc(sizeof(struct pwm_device), GFP_KERNEL);
 180         if (pwm == NULL) {
 181                 dev_err(&pdev->dev, "failed to allocate memory\n");
 182                 return -ENOMEM;
 183         }
 184
 185         pwm->clk = clk_get(&pdev->dev, "pwm");
 186
 187         if (IS_ERR(pwm->clk)) {
 188                 ret = PTR_ERR(pwm->clk);
 189                 goto err_free;
 190         }
 191
 192         pwm->clk_enabled = 0;
 193
 194         pwm->use_count = 0;
 195         pwm->pwm_id = pdev->id;
 196         pwm->pdev = pdev;
 197
 198         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 199         if (r == NULL) {
 200                 dev_err(&pdev->dev, "no memory resource defined\n");
 201                 ret = -ENODEV;
 202                 goto err_free_clk;
 203         }
 204
 205         r = request_mem_region(r->start, r->end - r->start + 1, pdev->name);
 206         if (r == NULL) {
 207                 dev_err(&pdev->dev, "failed to request memory resource\n");
 208                 ret = -EBUSY;
 209                 goto err_free_clk;
 210         }
 211
 212         pwm->mmio_base = ioremap(r->start, r->end - r->start + 1);
 213         if (pwm->mmio_base == NULL) {
 214                 dev_err(&pdev->dev, "failed to ioremap() registers\n");
 215                 ret = -ENODEV;
 216                 goto err_free_mem;
 217         }
 218
 219         mutex_lock(&pwm_lock);
 220         list_add_tail(&pwm->node, &pwm_list);
 221         mutex_unlock(&pwm_lock);
 222
 223         platform_set_drvdata(pdev, pwm);
 224         return 0;
 225
 226 err_free_mem:
 227         release_mem_region(r->start, r->end - r->start + 1);
 228 err_free_clk:
 229         clk_put(pwm->clk);
 230 err_free:
 231         kfree(pwm);
 232         return ret;
 233 }
 234
 235 static int __devexit mxc_pwm_remove(struct platform_device *pdev)
 236 {
 237         struct pwm_device *pwm;
 238         struct resource *r;
 239
 240         pwm = platform_get_drvdata(pdev);
 241         if (pwm == NULL)
 242                 return -ENODEV;
 243
 244         mutex_lock(&pwm_lock);
 245         list_del(&pwm->node);
 246         mutex_unlock(&pwm_lock);
 247
 248         iounmap(pwm->mmio_base);
 249
 250         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 251         release_mem_region(r->start, r->end - r->start + 1);
 252
 253         clk_put(pwm->clk);
 254
 255         kfree(pwm);
 256         return 0;
 257 }
 258
 259 static struct platform_driver mxc_pwm_driver = {
 260         .driver         = {
 261                 .name   = "mxc_pwm",
 262         },
 263         .probe          = mxc_pwm_probe,
 264         .remove         = __devexit_p(mxc_pwm_remove),
 265 };
 266
 267 static int __init mxc_pwm_init(void)
 268 {
 269         return platform_driver_register(&mxc_pwm_driver);
 270 }
 271 arch_initcall(mxc_pwm_init);
 272
 273 static void __exit mxc_pwm_exit(void)
 274 {
 275         platform_driver_unregister(&mxc_pwm_driver);
 276 }
 277 module_exit(mxc_pwm_exit);
 278
 279 MODULE_LICENSE("GPL v2");
 280 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");