/drivers/misc/ep93xx_pwm.c

http://github.com/mirrors/linux · C · 286 lines · 206 code · 52 blank · 28 comment · 27 complexity · 27ee4cd10fc656d492dafee751ced4c6 MD5 · raw file

  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. #include <linux/module.h>
  20. #include <linux/platform_device.h>
  21. #include <linux/slab.h>
  22. #include <linux/clk.h>
  23. #include <linux/err.h>
  24. #include <linux/io.h>
  25. #include <mach/platform.h>
  26. #define EP93XX_PWMx_TERM_COUNT 0x00
  27. #define EP93XX_PWMx_DUTY_CYCLE 0x04
  28. #define EP93XX_PWMx_ENABLE 0x08
  29. #define EP93XX_PWMx_INVERT 0x0C
  30. #define EP93XX_PWM_MAX_COUNT 0xFFFF
  31. struct ep93xx_pwm {
  32. void __iomem *mmio_base;
  33. struct clk *clk;
  34. u32 duty_percent;
  35. };
  36. /*
  37. * /sys/devices/platform/ep93xx-pwm.N
  38. * /min_freq read-only minimum pwm output frequency
  39. * /max_req read-only maximum pwm output frequency
  40. * /freq read-write pwm output frequency (0 = disable output)
  41. * /duty_percent read-write pwm duty cycle percent (1..99)
  42. * /invert read-write invert pwm output
  43. */
  44. static ssize_t ep93xx_pwm_get_min_freq(struct device *dev,
  45. struct device_attribute *attr, char *buf)
  46. {
  47. struct platform_device *pdev = to_platform_device(dev);
  48. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  49. unsigned long rate = clk_get_rate(pwm->clk);
  50. return sprintf(buf, "%ld\n", rate / (EP93XX_PWM_MAX_COUNT + 1));
  51. }
  52. static ssize_t ep93xx_pwm_get_max_freq(struct device *dev,
  53. struct device_attribute *attr, char *buf)
  54. {
  55. struct platform_device *pdev = to_platform_device(dev);
  56. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  57. unsigned long rate = clk_get_rate(pwm->clk);
  58. return sprintf(buf, "%ld\n", rate / 2);
  59. }
  60. static ssize_t ep93xx_pwm_get_freq(struct device *dev,
  61. struct device_attribute *attr, char *buf)
  62. {
  63. struct platform_device *pdev = to_platform_device(dev);
  64. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  65. if (readl(pwm->mmio_base + EP93XX_PWMx_ENABLE) & 0x1) {
  66. unsigned long rate = clk_get_rate(pwm->clk);
  67. u16 term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
  68. return sprintf(buf, "%ld\n", rate / (term + 1));
  69. } else {
  70. return sprintf(buf, "disabled\n");
  71. }
  72. }
  73. static ssize_t ep93xx_pwm_set_freq(struct device *dev,
  74. struct device_attribute *attr, const char *buf, size_t count)
  75. {
  76. struct platform_device *pdev = to_platform_device(dev);
  77. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  78. long val;
  79. int err;
  80. err = kstrtol(buf, 10, &val);
  81. if (err)
  82. return -EINVAL;
  83. if (val == 0) {
  84. writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
  85. } else if (val <= (clk_get_rate(pwm->clk) / 2)) {
  86. u32 term, duty;
  87. val = (clk_get_rate(pwm->clk) / val) - 1;
  88. if (val > EP93XX_PWM_MAX_COUNT)
  89. val = EP93XX_PWM_MAX_COUNT;
  90. if (val < 1)
  91. val = 1;
  92. term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
  93. duty = ((val + 1) * pwm->duty_percent / 100) - 1;
  94. /* If pwm is running, order is important */
  95. if (val > term) {
  96. writel(val, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
  97. writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
  98. } else {
  99. writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
  100. writel(val, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
  101. }
  102. if (!readl(pwm->mmio_base + EP93XX_PWMx_ENABLE) & 0x1)
  103. writel(0x1, pwm->mmio_base + EP93XX_PWMx_ENABLE);
  104. } else {
  105. return -EINVAL;
  106. }
  107. return count;
  108. }
  109. static ssize_t ep93xx_pwm_get_duty_percent(struct device *dev,
  110. struct device_attribute *attr, char *buf)
  111. {
  112. struct platform_device *pdev = to_platform_device(dev);
  113. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  114. return sprintf(buf, "%d\n", pwm->duty_percent);
  115. }
  116. static ssize_t ep93xx_pwm_set_duty_percent(struct device *dev,
  117. struct device_attribute *attr, const char *buf, size_t count)
  118. {
  119. struct platform_device *pdev = to_platform_device(dev);
  120. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  121. long val;
  122. int err;
  123. err = kstrtol(buf, 10, &val);
  124. if (err)
  125. return -EINVAL;
  126. if (val > 0 && val < 100) {
  127. u32 term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
  128. u32 duty = ((term + 1) * val / 100) - 1;
  129. writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
  130. pwm->duty_percent = val;
  131. return count;
  132. }
  133. return -EINVAL;
  134. }
  135. static ssize_t ep93xx_pwm_get_invert(struct device *dev,
  136. struct device_attribute *attr, char *buf)
  137. {
  138. struct platform_device *pdev = to_platform_device(dev);
  139. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  140. int inverted = readl(pwm->mmio_base + EP93XX_PWMx_INVERT) & 0x1;
  141. return sprintf(buf, "%d\n", inverted);
  142. }
  143. static ssize_t ep93xx_pwm_set_invert(struct device *dev,
  144. struct device_attribute *attr, const char *buf, size_t count)
  145. {
  146. struct platform_device *pdev = to_platform_device(dev);
  147. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  148. long val;
  149. int err;
  150. err = kstrtol(buf, 10, &val);
  151. if (err)
  152. return -EINVAL;
  153. if (val == 0)
  154. writel(0x0, pwm->mmio_base + EP93XX_PWMx_INVERT);
  155. else if (val == 1)
  156. writel(0x1, pwm->mmio_base + EP93XX_PWMx_INVERT);
  157. else
  158. return -EINVAL;
  159. return count;
  160. }
  161. static DEVICE_ATTR(min_freq, S_IRUGO, ep93xx_pwm_get_min_freq, NULL);
  162. static DEVICE_ATTR(max_freq, S_IRUGO, ep93xx_pwm_get_max_freq, NULL);
  163. static DEVICE_ATTR(freq, S_IWUSR | S_IRUGO,
  164. ep93xx_pwm_get_freq, ep93xx_pwm_set_freq);
  165. static DEVICE_ATTR(duty_percent, S_IWUSR | S_IRUGO,
  166. ep93xx_pwm_get_duty_percent, ep93xx_pwm_set_duty_percent);
  167. static DEVICE_ATTR(invert, S_IWUSR | S_IRUGO,
  168. ep93xx_pwm_get_invert, ep93xx_pwm_set_invert);
  169. static struct attribute *ep93xx_pwm_attrs[] = {
  170. &dev_attr_min_freq.attr,
  171. &dev_attr_max_freq.attr,
  172. &dev_attr_freq.attr,
  173. &dev_attr_duty_percent.attr,
  174. &dev_attr_invert.attr,
  175. NULL
  176. };
  177. static const struct attribute_group ep93xx_pwm_sysfs_files = {
  178. .attrs = ep93xx_pwm_attrs,
  179. };
  180. static int ep93xx_pwm_probe(struct platform_device *pdev)
  181. {
  182. struct ep93xx_pwm *pwm;
  183. struct resource *res;
  184. int ret;
  185. pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL);
  186. if (!pwm)
  187. return -ENOMEM;
  188. pwm->clk = devm_clk_get(&pdev->dev, "pwm_clk");
  189. if (IS_ERR(pwm->clk))
  190. return PTR_ERR(pwm->clk);
  191. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  192. pwm->mmio_base = devm_ioremap_resource(&pdev->dev, res);
  193. if (IS_ERR(pwm->mmio_base))
  194. return PTR_ERR(pwm->mmio_base);
  195. ret = ep93xx_pwm_acquire_gpio(pdev);
  196. if (ret)
  197. return ret;
  198. ret = sysfs_create_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
  199. if (ret) {
  200. ep93xx_pwm_release_gpio(pdev);
  201. return ret;
  202. }
  203. pwm->duty_percent = 50;
  204. /* disable pwm at startup. Avoids zero value. */
  205. writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
  206. writel(EP93XX_PWM_MAX_COUNT, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
  207. writel(EP93XX_PWM_MAX_COUNT/2, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
  208. clk_enable(pwm->clk);
  209. platform_set_drvdata(pdev, pwm);
  210. return 0;
  211. }
  212. static int ep93xx_pwm_remove(struct platform_device *pdev)
  213. {
  214. struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
  215. writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
  216. clk_disable(pwm->clk);
  217. sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
  218. ep93xx_pwm_release_gpio(pdev);
  219. return 0;
  220. }
  221. static struct platform_driver ep93xx_pwm_driver = {
  222. .driver = {
  223. .name = "ep93xx-pwm",
  224. .owner = THIS_MODULE,
  225. },
  226. .probe = ep93xx_pwm_probe,
  227. .remove = ep93xx_pwm_remove,
  228. };
  229. module_platform_driver(ep93xx_pwm_driver);
  230. MODULE_AUTHOR("Matthieu Crapet <mcrapet@gmail.com>, "
  231. "H Hartley Sweeten <hsweeten@visionengravers.com>");
  232. MODULE_DESCRIPTION("EP93xx PWM driver");
  233. MODULE_LICENSE("GPL");
  234. MODULE_ALIAS("platform:ep93xx-pwm");