pwm.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278
  1. /*
  2. * linux/arch/unicore32/kernel/pwm.c
  3. *
  4. * Code specific to PKUnity SoC and UniCore ISA
  5. *
  6. * Maintained by GUAN Xue-tao <gxt@mprc.pku.edu.cn>
  7. * Copyright (C) 2001-2010 Guan Xuetao
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License version 2 as
  11. * published by the Free Software Foundation.
  12. */
  13. #include <linux/module.h>
  14. #include <linux/kernel.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/slab.h>
  17. #include <linux/err.h>
  18. #include <linux/clk.h>
  19. #include <linux/io.h>
  20. #include <linux/pwm.h>
  21. #include <asm/div64.h>
  22. #include <mach/hardware.h>
  23. struct pwm_device {
  24. struct list_head node;
  25. struct platform_device *pdev;
  26. void __iomem *base;
  27. const char *label;
  28. struct clk *clk;
  29. int clk_enabled;
  30. unsigned int use_count;
  31. unsigned int pwm_id;
  32. };
  33. /*
  34. * period_ns = 10^9 * (PRESCALE + 1) * (PV + 1) / PWM_CLK_RATE
  35. * duty_ns = 10^9 * (PRESCALE + 1) * DC / PWM_CLK_RATE
  36. */
  37. int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
  38. {
  39. unsigned long long c;
  40. unsigned long period_cycles, prescale, pv, dc;
  41. if (pwm == NULL || period_ns == 0 || duty_ns > period_ns)
  42. return -EINVAL;
  43. c = clk_get_rate(pwm->clk);
  44. c = c * period_ns;
  45. do_div(c, 1000000000);
  46. period_cycles = c;
  47. if (period_cycles < 1)
  48. period_cycles = 1;
  49. prescale = (period_cycles - 1) / 1024;
  50. pv = period_cycles / (prescale + 1) - 1;
  51. if (prescale > 63)
  52. return -EINVAL;
  53. if (duty_ns == period_ns)
  54. dc = OST_PWMDCCR_FDCYCLE;
  55. else
  56. dc = (pv + 1) * duty_ns / period_ns;
  57. /* NOTE: the clock to PWM has to be enabled first
  58. * before writing to the registers
  59. */
  60. clk_enable(pwm->clk);
  61. writel(prescale, pwm->base + OST_PWM_PWCR);
  62. writel(pv - dc, pwm->base + OST_PWM_DCCR);
  63. writel(pv, pwm->base + OST_PWM_PCR);
  64. clk_disable(pwm->clk);
  65. return 0;
  66. }
  67. EXPORT_SYMBOL(pwm_config);
  68. int pwm_enable(struct pwm_device *pwm)
  69. {
  70. int rc = 0;
  71. if (!pwm->clk_enabled) {
  72. rc = clk_enable(pwm->clk);
  73. if (!rc)
  74. pwm->clk_enabled = 1;
  75. }
  76. return rc;
  77. }
  78. EXPORT_SYMBOL(pwm_enable);
  79. void pwm_disable(struct pwm_device *pwm)
  80. {
  81. if (pwm->clk_enabled) {
  82. clk_disable(pwm->clk);
  83. pwm->clk_enabled = 0;
  84. }
  85. }
  86. EXPORT_SYMBOL(pwm_disable);
  87. static DEFINE_MUTEX(pwm_lock);
  88. static LIST_HEAD(pwm_list);
  89. struct pwm_device *pwm_request(int pwm_id, const char *label)
  90. {
  91. struct pwm_device *pwm;
  92. int found = 0;
  93. mutex_lock(&pwm_lock);
  94. list_for_each_entry(pwm, &pwm_list, node) {
  95. if (pwm->pwm_id == pwm_id) {
  96. found = 1;
  97. break;
  98. }
  99. }
  100. if (found) {
  101. if (pwm->use_count == 0) {
  102. pwm->use_count++;
  103. pwm->label = label;
  104. } else
  105. pwm = ERR_PTR(-EBUSY);
  106. } else
  107. pwm = ERR_PTR(-ENOENT);
  108. mutex_unlock(&pwm_lock);
  109. return pwm;
  110. }
  111. EXPORT_SYMBOL(pwm_request);
  112. void pwm_free(struct pwm_device *pwm)
  113. {
  114. mutex_lock(&pwm_lock);
  115. if (pwm->use_count) {
  116. pwm->use_count--;
  117. pwm->label = NULL;
  118. } else
  119. pr_warning("PWM device already freed\n");
  120. mutex_unlock(&pwm_lock);
  121. }
  122. EXPORT_SYMBOL(pwm_free);
  123. static inline void __add_pwm(struct pwm_device *pwm)
  124. {
  125. mutex_lock(&pwm_lock);
  126. list_add_tail(&pwm->node, &pwm_list);
  127. mutex_unlock(&pwm_lock);
  128. }
  129. static struct pwm_device *pwm_probe(struct platform_device *pdev,
  130. unsigned int pwm_id, struct pwm_device *parent_pwm)
  131. {
  132. struct pwm_device *pwm;
  133. struct resource *r;
  134. int ret = 0;
  135. pwm = kzalloc(sizeof(struct pwm_device), GFP_KERNEL);
  136. if (pwm == NULL) {
  137. dev_err(&pdev->dev, "failed to allocate memory\n");
  138. return ERR_PTR(-ENOMEM);
  139. }
  140. pwm->clk = clk_get(NULL, "OST_CLK");
  141. if (IS_ERR(pwm->clk)) {
  142. ret = PTR_ERR(pwm->clk);
  143. goto err_free;
  144. }
  145. pwm->clk_enabled = 0;
  146. pwm->use_count = 0;
  147. pwm->pwm_id = pwm_id;
  148. pwm->pdev = pdev;
  149. r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  150. if (r == NULL) {
  151. dev_err(&pdev->dev, "no memory resource defined\n");
  152. ret = -ENODEV;
  153. goto err_free_clk;
  154. }
  155. r = request_mem_region(r->start, resource_size(r), pdev->name);
  156. if (r == NULL) {
  157. dev_err(&pdev->dev, "failed to request memory resource\n");
  158. ret = -EBUSY;
  159. goto err_free_clk;
  160. }
  161. pwm->base = ioremap_nocache(r->start, resource_size(r));
  162. if (pwm->base == NULL) {
  163. dev_err(&pdev->dev, "failed to remap memory resource\n");
  164. ret = -EADDRNOTAVAIL;
  165. goto err_release_mem;
  166. }
  167. __add_pwm(pwm);
  168. platform_set_drvdata(pdev, pwm);
  169. return pwm;
  170. err_release_mem:
  171. release_mem_region(r->start, resource_size(r));
  172. err_free_clk:
  173. clk_put(pwm->clk);
  174. err_free:
  175. kfree(pwm);
  176. return ERR_PTR(ret);
  177. }
  178. static int __devinit puv3_pwm_probe(struct platform_device *pdev)
  179. {
  180. struct pwm_device *pwm = pwm_probe(pdev, pdev->id, NULL);
  181. if (IS_ERR(pwm))
  182. return PTR_ERR(pwm);
  183. return 0;
  184. }
  185. static int __devexit pwm_remove(struct platform_device *pdev)
  186. {
  187. struct pwm_device *pwm;
  188. struct resource *r;
  189. pwm = platform_get_drvdata(pdev);
  190. if (pwm == NULL)
  191. return -ENODEV;
  192. mutex_lock(&pwm_lock);
  193. list_del(&pwm->node);
  194. mutex_unlock(&pwm_lock);
  195. iounmap(pwm->base);
  196. r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  197. release_mem_region(r->start, resource_size(r));
  198. clk_put(pwm->clk);
  199. kfree(pwm);
  200. return 0;
  201. }
  202. static struct platform_driver puv3_pwm_driver = {
  203. .driver = {
  204. .name = "PKUnity-v3-PWM",
  205. },
  206. .probe = puv3_pwm_probe,
  207. .remove = __devexit_p(pwm_remove),
  208. };
  209. static int __init pwm_init(void)
  210. {
  211. int ret = 0;
  212. ret = platform_driver_register(&puv3_pwm_driver);
  213. if (ret) {
  214. printk(KERN_ERR "failed to register puv3_pwm_driver\n");
  215. return ret;
  216. }
  217. return ret;
  218. }
  219. arch_initcall(pwm_init);
  220. static void __exit pwm_exit(void)
  221. {
  222. platform_driver_unregister(&puv3_pwm_driver);
  223. }
  224. module_exit(pwm_exit);
  225. MODULE_LICENSE("GPL v2");