arch/arm/plat-pxa/pwm.c

   1 /*
   2  * linux/arch/arm/mach-pxa/pwm.c
   3  *
   4  * simple driver for PWM (Pulse Width Modulator) controller
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * 2008-02-13   initial version
  11  *              eric miao <eric.miao@marvell.com>
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/err.h>
  18 #include <linux/clk.h>
  19 #include <linux/io.h>
  20 #include <linux/pwm.h>
  21
  22 #include <asm/div64.h>
  23
  24 #define HAS_SECONDARY_PWM       0x10
  25 #define PWM_ID_BASE(d)          ((d) & 0xf)
  26
  27 static const struct platform_device_id pwm_id_table[] = {
  28         /*   PWM    has_secondary_pwm? */
  29         { "pxa25x-pwm", 0 },
  30         { "pxa27x-pwm", 0 | HAS_SECONDARY_PWM },
  31         { "pxa168-pwm", 1 },
  32         { "pxa910-pwm", 1 },
  33         { },
  34 };
  35 MODULE_DEVICE_TABLE(platform, pwm_id_table);
  36
  37 /* PWM registers and bits definitions */
  38 #define PWMCR           (0x00)
  39 #define PWMDCR          (0x04)
  40 #define PWMPCR          (0x08)
  41
  42 #define PWMCR_SD        (1 << 6)
  43 #define PWMDCR_FD       (1 << 10)
  44
  45 struct pwm_device {
  46         struct list_head        node;
  47         struct pwm_device       *secondary;
  48         struct platform_device  *pdev;
  49
  50         const char      *label;
  51         struct clk      *clk;
  52         int             clk_enabled;
  53         void __iomem    *mmio_base;
  54
  55         unsigned int    use_count;
  56         unsigned int    pwm_id;
  57 };
  58
  59 /*
  60  * period_ns = 10^9 * (PRESCALE + 1) * (PV + 1) / PWM_CLK_RATE
  61  * duty_ns   = 10^9 * (PRESCALE + 1) * DC / PWM_CLK_RATE
  62  */
  63 int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
  64 {
  65         unsigned long long c;
  66         unsigned long period_cycles, prescale, pv, dc;
  67
  68         if (pwm == NULL || period_ns == 0 || duty_ns > period_ns)
  69                 return -EINVAL;
  70
  71         c = clk_get_rate(pwm->clk);
  72         c = c * period_ns;
  73         do_div(c, 1000000000);
  74         period_cycles = c;
  75
  76         if (period_cycles < 1)
  77                 period_cycles = 1;
  78         prescale = (period_cycles - 1) / 1024;
  79         pv = period_cycles / (prescale + 1) - 1;
  80
  81         if (prescale > 63)
  82                 return -EINVAL;
  83
  84         if (duty_ns == period_ns)
  85                 dc = PWMDCR_FD;
  86         else
  87                 dc = (pv + 1) * duty_ns / period_ns;
  88
  89         /* NOTE: the clock to PWM has to be enabled first
  90          * before writing to the registers
  91          */
  92         clk_enable(pwm->clk);
  93         __raw_writel(prescale, pwm->mmio_base + PWMCR);
  94         __raw_writel(dc, pwm->mmio_base + PWMDCR);
  95         __raw_writel(pv, pwm->mmio_base + PWMPCR);
  96         clk_disable(pwm->clk);
  97
  98         return 0;
  99 }
 100 EXPORT_SYMBOL(pwm_config);
 101
 102 int pwm_enable(struct pwm_device *pwm)
 103 {
 104         int rc = 0;
 105
 106         if (!pwm->clk_enabled) {
 107                 rc = clk_enable(pwm->clk);
 108                 if (!rc)
 109                         pwm->clk_enabled = 1;
 110         }
 111         return rc;
 112 }
 113 EXPORT_SYMBOL(pwm_enable);
 114
 115 void pwm_disable(struct pwm_device *pwm)
 116 {
 117         if (pwm->clk_enabled) {
 118                 clk_disable(pwm->clk);
 119                 pwm->clk_enabled = 0;
 120         }
 121 }
 122 EXPORT_SYMBOL(pwm_disable);
 123
 124 static DEFINE_MUTEX(pwm_lock);
 125 static LIST_HEAD(pwm_list);
 126
 127 struct pwm_device *pwm_request(int pwm_id, const char *label)
 128 {
 129         struct pwm_device *pwm;
 130         int found = 0;
 131
 132         mutex_lock(&pwm_lock);
 133
 134         list_for_each_entry(pwm, &pwm_list, node) {
 135                 if (pwm->pwm_id == pwm_id) {
 136                         found = 1;
 137                         break;
 138                 }
 139         }
 140
 141         if (found) {
 142                 if (pwm->use_count == 0) {
 143                         pwm->use_count++;
 144                         pwm->label = label;
 145                 } else
 146                         pwm = ERR_PTR(-EBUSY);
 147         } else
 148                 pwm = ERR_PTR(-ENOENT);
 149
 150         mutex_unlock(&pwm_lock);
 151         return pwm;
 152 }
 153 EXPORT_SYMBOL(pwm_request);
 154
 155 void pwm_free(struct pwm_device *pwm)
 156 {
 157         mutex_lock(&pwm_lock);
 158
 159         if (pwm->use_count) {
 160                 pwm->use_count--;
 161                 pwm->label = NULL;
 162         } else
 163                 pr_warning("PWM device already freed\n");
 164
 165         mutex_unlock(&pwm_lock);
 166 }
 167 EXPORT_SYMBOL(pwm_free);
 168
 169 static inline void __add_pwm(struct pwm_device *pwm)
 170 {
 171         mutex_lock(&pwm_lock);
 172         list_add_tail(&pwm->node, &pwm_list);
 173         mutex_unlock(&pwm_lock);
 174 }
 175
 176 static int __devinit pwm_probe(struct platform_device *pdev)
 177 {
 178         struct platform_device_id *id = platform_get_device_id(pdev);
 179         struct pwm_device *pwm, *secondary = NULL;
 180         struct resource *r;
 181         int ret = 0;
 182
 183         pwm = kzalloc(sizeof(struct pwm_device), GFP_KERNEL);
 184         if (pwm == NULL) {
 185                 dev_err(&pdev->dev, "failed to allocate memory\n");
 186                 return -ENOMEM;
 187         }
 188
 189         pwm->clk = clk_get(&pdev->dev, NULL);
 190         if (IS_ERR(pwm->clk)) {
 191                 ret = PTR_ERR(pwm->clk);
 192                 goto err_free;
 193         }
 194         pwm->clk_enabled = 0;
 195
 196         pwm->use_count = 0;
 197         pwm->pwm_id = PWM_ID_BASE(id->driver_data) + pdev->id;
 198         pwm->pdev = pdev;
 199
 200         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 201         if (r == NULL) {
 202                 dev_err(&pdev->dev, "no memory resource defined\n");
 203                 ret = -ENODEV;
 204                 goto err_free_clk;
 205         }
 206
 207         r = request_mem_region(r->start, resource_size(r), pdev->name);
 208         if (r == NULL) {
 209                 dev_err(&pdev->dev, "failed to request memory resource\n");
 210                 ret = -EBUSY;
 211                 goto err_free_clk;
 212         }
 213
 214         pwm->mmio_base = ioremap(r->start, resource_size(r));
 215         if (pwm->mmio_base == NULL) {
 216                 dev_err(&pdev->dev, "failed to ioremap() registers\n");
 217                 ret = -ENODEV;
 218                 goto err_free_mem;
 219         }
 220
 221         if (id->driver_data & HAS_SECONDARY_PWM) {
 222                 secondary = kzalloc(sizeof(struct pwm_device), GFP_KERNEL);
 223                 if (secondary == NULL) {
 224                         ret = -ENOMEM;
 225                         goto err_free_mem;
 226                 }
 227
 228                 *secondary = *pwm;
 229                 pwm->secondary = secondary;
 230
 231                 /* registers for the second PWM has offset of 0x10 */
 232                 secondary->mmio_base = pwm->mmio_base + 0x10;
 233                 secondary->pwm_id = pdev->id + 2;
 234         }
 235
 236         __add_pwm(pwm);
 237         if (secondary)
 238                 __add_pwm(secondary);
 239
 240         platform_set_drvdata(pdev, pwm);
 241         return 0;
 242
 243 err_free_mem:
 244         release_mem_region(r->start, resource_size(r));
 245 err_free_clk:
 246         clk_put(pwm->clk);
 247 err_free:
 248         kfree(pwm);
 249         return ret;
 250 }
 251
 252 static int __devexit pwm_remove(struct platform_device *pdev)
 253 {
 254         struct pwm_device *pwm;
 255         struct resource *r;
 256
 257         pwm = platform_get_drvdata(pdev);
 258         if (pwm == NULL)
 259                 return -ENODEV;
 260
 261         mutex_lock(&pwm_lock);
 262
 263         if (pwm->secondary) {
 264                 list_del(&pwm->secondary->node);
 265                 kfree(pwm->secondary);
 266         }
 267
 268         list_del(&pwm->node);
 269         mutex_unlock(&pwm_lock);
 270
 271         iounmap(pwm->mmio_base);
 272
 273         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 274         release_mem_region(r->start, resource_size(r));
 275
 276         clk_put(pwm->clk);
 277         kfree(pwm);
 278         return 0;
 279 }
 280
 281 static struct platform_driver pwm_driver = {
 282         .driver         = {
 283                 .name   = "pxa25x-pwm",
 284                 .owner  = THIS_MODULE,
 285         },
 286         .probe          = pwm_probe,
 287         .remove         = __devexit_p(pwm_remove),
 288         .id_table       = pwm_id_table,
 289 };
 290
 291 static int __init pwm_init(void)
 292 {
 293         return platform_driver_register(&pwm_driver);
 294 }
 295 arch_initcall(pwm_init);
 296
 297 static void __exit pwm_exit(void)
 298 {
 299         platform_driver_unregister(&pwm_driver);
 300 }
 301 module_exit(pwm_exit);
 302
 303 MODULE_LICENSE("GPL v2");