drivers/misc/ep93xx_pwm.c

   1 /*
   2  *  Simple PWM driver for EP93XX
   3  *
   4  *      (c) Copyright 2009  Matthieu Crapet <mcrapet@gmail.com>
   5  *      (c) Copyright 2009  H Hartley Sweeten <hsweeten@visionengravers.com>
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License
   9  *      as published by the Free Software Foundation; either version
  10  *      2 of the License, or (at your option) any later version.
  11  *
  12  *  EP9307 has only one channel:
  13  *    - PWMOUT
  14  *
  15  *  EP9301/02/12/15 have two channels:
  16  *    - PWMOUT
  17  *    - PWMOUT1 (alternate function for EGPIO14)
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/slab.h>
  23 #include <linux/clk.h>
  24 #include <linux/err.h>
  25 #include <linux/io.h>
  26
  27 #include <mach/platform.h>
  28
  29 #define EP93XX_PWMx_TERM_COUNT  0x00
  30 #define EP93XX_PWMx_DUTY_CYCLE  0x04
  31 #define EP93XX_PWMx_ENABLE      0x08
  32 #define EP93XX_PWMx_INVERT      0x0C
  33
  34 #define EP93XX_PWM_MAX_COUNT    0xFFFF
  35
  36 struct ep93xx_pwm {
  37         void __iomem    *mmio_base;
  38         struct clk      *clk;
  39         u32             duty_percent;
  40 };
  41
  42 static inline int ep93xx_pwm_is_enabled(struct ep93xx_pwm *pwm)
  43 {
  44         return readl(pwm->mmio_base + EP93XX_PWMx_ENABLE) & 0x1;
  45 }
  46
  47 static inline int ep93xx_pwm_is_inverted(struct ep93xx_pwm *pwm)
  48 {
  49         return readl(pwm->mmio_base + EP93XX_PWMx_INVERT) & 0x1;
  50 }
  51
  52 /*
  53  * /sys/devices/platform/ep93xx-pwm.N
  54  *   /min_freq      read-only   minimum pwm output frequency
  55  *   /max_req       read-only   maximum pwm output frequency
  56  *   /freq          read-write  pwm output frequency (0 = disable output)
  57  *   /duty_percent  read-write  pwm duty cycle percent (1..99)
  58  *   /invert        read-write  invert pwm output
  59  */
  60
  61 static ssize_t ep93xx_pwm_get_min_freq(struct device *dev,
  62                 struct device_attribute *attr, char *buf)
  63 {
  64         struct platform_device *pdev = to_platform_device(dev);
  65         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  66         unsigned long rate = clk_get_rate(pwm->clk);
  67
  68         return sprintf(buf, "%ld\n", rate / (EP93XX_PWM_MAX_COUNT + 1));
  69 }
  70
  71 static ssize_t ep93xx_pwm_get_max_freq(struct device *dev,
  72                 struct device_attribute *attr, char *buf)
  73 {
  74         struct platform_device *pdev = to_platform_device(dev);
  75         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  76         unsigned long rate = clk_get_rate(pwm->clk);
  77
  78         return sprintf(buf, "%ld\n", rate / 2);
  79 }
  80
  81 static ssize_t ep93xx_pwm_get_freq(struct device *dev,
  82                 struct device_attribute *attr, char *buf)
  83 {
  84         struct platform_device *pdev = to_platform_device(dev);
  85         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  86
  87         if (ep93xx_pwm_is_enabled(pwm)) {
  88                 unsigned long rate = clk_get_rate(pwm->clk);
  89                 u16 term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
  90
  91                 return sprintf(buf, "%ld\n", rate / (term + 1));
  92         } else {
  93                 return sprintf(buf, "disabled\n");
  94         }
  95 }
  96
  97 static ssize_t ep93xx_pwm_set_freq(struct device *dev,
  98                 struct device_attribute *attr, const char *buf, size_t count)
  99 {
 100         struct platform_device *pdev = to_platform_device(dev);
 101         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
 102         long val;
 103         int err;
 104
 105         err = strict_strtol(buf, 10, &val);
 106         if (err)
 107                 return -EINVAL;
 108
 109         if (val == 0) {
 110                 writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
 111         } else if (val <= (clk_get_rate(pwm->clk) / 2)) {
 112                 u32 term, duty;
 113
 114                 val = (clk_get_rate(pwm->clk) / val) - 1;
 115                 if (val > EP93XX_PWM_MAX_COUNT)
 116                         val = EP93XX_PWM_MAX_COUNT;
 117                 if (val < 1)
 118                         val = 1;
 119
 120                 term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
 121                 duty = ((val + 1) * pwm->duty_percent / 100) - 1;
 122
 123                 /* If pwm is running, order is important */
 124                 if (val > term) {
 125                         writel(val, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
 126                         writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
 127                 } else {
 128                         writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
 129                         writel(val, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
 130                 }
 131
 132                 if (!ep93xx_pwm_is_enabled(pwm))
 133                         writel(0x1, pwm->mmio_base + EP93XX_PWMx_ENABLE);
 134         } else {
 135                 return -EINVAL;
 136         }
 137
 138         return count;
 139 }
 140
 141 static ssize_t ep93xx_pwm_get_duty_percent(struct device *dev,
 142                 struct device_attribute *attr, char *buf)
 143 {
 144         struct platform_device *pdev = to_platform_device(dev);
 145         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
 146
 147         return sprintf(buf, "%d\n", pwm->duty_percent);
 148 }
 149
 150 static ssize_t ep93xx_pwm_set_duty_percent(struct device *dev,
 151                 struct device_attribute *attr, const char *buf, size_t count)
 152 {
 153         struct platform_device *pdev = to_platform_device(dev);
 154         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
 155         long val;
 156         int err;
 157
 158         err = strict_strtol(buf, 10, &val);
 159         if (err)
 160                 return -EINVAL;
 161
 162         if (val > 0 && val < 100) {
 163                 u32 term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
 164                 u32 duty = ((term + 1) * val / 100) - 1;
 165
 166                 writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
 167                 pwm->duty_percent = val;
 168                 return count;
 169         }
 170
 171         return -EINVAL;
 172 }
 173
 174 static ssize_t ep93xx_pwm_get_invert(struct device *dev,
 175                 struct device_attribute *attr, char *buf)
 176 {
 177         struct platform_device *pdev = to_platform_device(dev);
 178         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
 179
 180         return sprintf(buf, "%d\n", ep93xx_pwm_is_inverted(pwm));
 181 }
 182
 183 static ssize_t ep93xx_pwm_set_invert(struct device *dev,
 184                 struct device_attribute *attr, const char *buf, size_t count)
 185 {
 186         struct platform_device *pdev = to_platform_device(dev);
 187         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
 188         long val;
 189         int err;
 190
 191         err = strict_strtol(buf, 10, &val);
 192         if (err)
 193                 return -EINVAL;
 194
 195         if (val == 0)
 196                 writel(0x0, pwm->mmio_base + EP93XX_PWMx_INVERT);
 197         else if (val == 1)
 198                 writel(0x1, pwm->mmio_base + EP93XX_PWMx_INVERT);
 199         else
 200                 return -EINVAL;
 201
 202         return count;
 203 }
 204
 205 static DEVICE_ATTR(min_freq, S_IRUGO, ep93xx_pwm_get_min_freq, NULL);
 206 static DEVICE_ATTR(max_freq, S_IRUGO, ep93xx_pwm_get_max_freq, NULL);
 207 static DEVICE_ATTR(freq, S_IWUSR | S_IRUGO,
 208                    ep93xx_pwm_get_freq, ep93xx_pwm_set_freq);
 209 static DEVICE_ATTR(duty_percent, S_IWUSR | S_IRUGO,
 210                    ep93xx_pwm_get_duty_percent, ep93xx_pwm_set_duty_percent);
 211 static DEVICE_ATTR(invert, S_IWUSR | S_IRUGO,
 212                    ep93xx_pwm_get_invert, ep93xx_pwm_set_invert);
 213
 214 static struct attribute *ep93xx_pwm_attrs[] = {
 215         &dev_attr_min_freq.attr,
 216         &dev_attr_max_freq.attr,
 217         &dev_attr_freq.attr,
 218         &dev_attr_duty_percent.attr,
 219         &dev_attr_invert.attr,
 220         NULL
 221 };
 222
 223 static const struct attribute_group ep93xx_pwm_sysfs_files = {
 224         .attrs  = ep93xx_pwm_attrs,
 225 };
 226
 227 static int __init ep93xx_pwm_probe(struct platform_device *pdev)
 228 {
 229         struct ep93xx_pwm *pwm;
 230         struct resource *res;
 231         int ret;
 232
 233         pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL);
 234         if (!pwm)
 235                 return -ENOMEM;
 236
 237         pwm->clk = devm_clk_get(&pdev->dev, "pwm_clk");
 238         if (IS_ERR(pwm->clk))
 239                 return PTR_ERR(pwm->clk);
 240
 241         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 242         pwm->mmio_base = devm_ioremap_resource(&pdev->dev, res);
 243         if (IS_ERR(pwm->mmio_base))
 244                 return PTR_ERR(pwm->mmio_base);
 245
 246         ret = ep93xx_pwm_acquire_gpio(pdev);
 247         if (ret)
 248                 return ret;
 249
 250         ret = sysfs_create_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
 251         if (ret) {
 252                 ep93xx_pwm_release_gpio(pdev);
 253                 return ret;
 254         }
 255
 256         pwm->duty_percent = 50;
 257
 258         /* disable pwm at startup. Avoids zero value. */
 259         writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
 260         writel(EP93XX_PWM_MAX_COUNT, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
 261         writel(EP93XX_PWM_MAX_COUNT/2, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
 262
 263         clk_enable(pwm->clk);
 264
 265         platform_set_drvdata(pdev, pwm);
 266         return 0;
 267 }
 268
 269 static int __exit ep93xx_pwm_remove(struct platform_device *pdev)
 270 {
 271         struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
 272
 273         writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
 274         clk_disable(pwm->clk);
 275         sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
 276         ep93xx_pwm_release_gpio(pdev);
 277
 278         return 0;
 279 }
 280
 281 static struct platform_driver ep93xx_pwm_driver = {
 282         .driver         = {
 283                 .name   = "ep93xx-pwm",
 284                 .owner  = THIS_MODULE,
 285         },
 286         .remove         = __exit_p(ep93xx_pwm_remove),
 287 };
 288
 289 module_platform_driver_probe(ep93xx_pwm_driver, ep93xx_pwm_probe);
 290
 291 MODULE_AUTHOR("Matthieu Crapet <mcrapet@gmail.com>, "
 292               "H Hartley Sweeten <hsweeten@visionengravers.com>");
 293 MODULE_DESCRIPTION("EP93xx PWM driver");
 294 MODULE_LICENSE("GPL");
 295 MODULE_ALIAS("platform:ep93xx-pwm");