serial.c 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Generic serial GNSS receiver driver
  4. *
  5. * Copyright (C) 2018 Johan Hovold <johan@kernel.org>
  6. */
  7. #include <linux/errno.h>
  8. #include <linux/gnss.h>
  9. #include <linux/init.h>
  10. #include <linux/kernel.h>
  11. #include <linux/module.h>
  12. #include <linux/of.h>
  13. #include <linux/pm.h>
  14. #include <linux/pm_runtime.h>
  15. #include <linux/sched.h>
  16. #include <linux/serdev.h>
  17. #include <linux/slab.h>
  18. #include "serial.h"
  19. static int gnss_serial_open(struct gnss_device *gdev)
  20. {
  21. struct gnss_serial *gserial = gnss_get_drvdata(gdev);
  22. struct serdev_device *serdev = gserial->serdev;
  23. int ret;
  24. ret = serdev_device_open(serdev);
  25. if (ret)
  26. return ret;
  27. serdev_device_set_baudrate(serdev, gserial->speed);
  28. serdev_device_set_flow_control(serdev, false);
  29. ret = pm_runtime_get_sync(&serdev->dev);
  30. if (ret < 0) {
  31. pm_runtime_put_noidle(&serdev->dev);
  32. goto err_close;
  33. }
  34. return 0;
  35. err_close:
  36. serdev_device_close(serdev);
  37. return ret;
  38. }
  39. static void gnss_serial_close(struct gnss_device *gdev)
  40. {
  41. struct gnss_serial *gserial = gnss_get_drvdata(gdev);
  42. struct serdev_device *serdev = gserial->serdev;
  43. serdev_device_close(serdev);
  44. pm_runtime_put(&serdev->dev);
  45. }
  46. static int gnss_serial_write_raw(struct gnss_device *gdev,
  47. const unsigned char *buf, size_t count)
  48. {
  49. struct gnss_serial *gserial = gnss_get_drvdata(gdev);
  50. struct serdev_device *serdev = gserial->serdev;
  51. int ret;
  52. /* write is only buffered synchronously */
  53. ret = serdev_device_write(serdev, buf, count, MAX_SCHEDULE_TIMEOUT);
  54. if (ret < 0 || ret < count)
  55. return ret;
  56. /* FIXME: determine if interrupted? */
  57. serdev_device_wait_until_sent(serdev, 0);
  58. return count;
  59. }
  60. static const struct gnss_operations gnss_serial_gnss_ops = {
  61. .open = gnss_serial_open,
  62. .close = gnss_serial_close,
  63. .write_raw = gnss_serial_write_raw,
  64. };
  65. static int gnss_serial_receive_buf(struct serdev_device *serdev,
  66. const unsigned char *buf, size_t count)
  67. {
  68. struct gnss_serial *gserial = serdev_device_get_drvdata(serdev);
  69. struct gnss_device *gdev = gserial->gdev;
  70. return gnss_insert_raw(gdev, buf, count);
  71. }
  72. static const struct serdev_device_ops gnss_serial_serdev_ops = {
  73. .receive_buf = gnss_serial_receive_buf,
  74. .write_wakeup = serdev_device_write_wakeup,
  75. };
  76. static int gnss_serial_set_power(struct gnss_serial *gserial,
  77. enum gnss_serial_pm_state state)
  78. {
  79. if (!gserial->ops || !gserial->ops->set_power)
  80. return 0;
  81. return gserial->ops->set_power(gserial, state);
  82. }
  83. /*
  84. * FIXME: need to provide subdriver defaults or separate dt parsing from
  85. * allocation.
  86. */
  87. static int gnss_serial_parse_dt(struct serdev_device *serdev)
  88. {
  89. struct gnss_serial *gserial = serdev_device_get_drvdata(serdev);
  90. struct device_node *node = serdev->dev.of_node;
  91. u32 speed = 4800;
  92. of_property_read_u32(node, "current-speed", &speed);
  93. gserial->speed = speed;
  94. return 0;
  95. }
  96. struct gnss_serial *gnss_serial_allocate(struct serdev_device *serdev,
  97. size_t data_size)
  98. {
  99. struct gnss_serial *gserial;
  100. struct gnss_device *gdev;
  101. int ret;
  102. gserial = kzalloc(sizeof(*gserial) + data_size, GFP_KERNEL);
  103. if (!gserial)
  104. return ERR_PTR(-ENOMEM);
  105. gdev = gnss_allocate_device(&serdev->dev);
  106. if (!gdev) {
  107. ret = -ENOMEM;
  108. goto err_free_gserial;
  109. }
  110. gdev->ops = &gnss_serial_gnss_ops;
  111. gnss_set_drvdata(gdev, gserial);
  112. gserial->serdev = serdev;
  113. gserial->gdev = gdev;
  114. serdev_device_set_drvdata(serdev, gserial);
  115. serdev_device_set_client_ops(serdev, &gnss_serial_serdev_ops);
  116. ret = gnss_serial_parse_dt(serdev);
  117. if (ret)
  118. goto err_put_device;
  119. return gserial;
  120. err_put_device:
  121. gnss_put_device(gserial->gdev);
  122. err_free_gserial:
  123. kfree(gserial);
  124. return ERR_PTR(ret);
  125. }
  126. EXPORT_SYMBOL_GPL(gnss_serial_allocate);
  127. void gnss_serial_free(struct gnss_serial *gserial)
  128. {
  129. gnss_put_device(gserial->gdev);
  130. kfree(gserial);
  131. };
  132. EXPORT_SYMBOL_GPL(gnss_serial_free);
  133. int gnss_serial_register(struct gnss_serial *gserial)
  134. {
  135. struct serdev_device *serdev = gserial->serdev;
  136. int ret;
  137. if (IS_ENABLED(CONFIG_PM)) {
  138. pm_runtime_enable(&serdev->dev);
  139. } else {
  140. ret = gnss_serial_set_power(gserial, GNSS_SERIAL_ACTIVE);
  141. if (ret < 0)
  142. return ret;
  143. }
  144. ret = gnss_register_device(gserial->gdev);
  145. if (ret)
  146. goto err_disable_rpm;
  147. return 0;
  148. err_disable_rpm:
  149. if (IS_ENABLED(CONFIG_PM))
  150. pm_runtime_disable(&serdev->dev);
  151. else
  152. gnss_serial_set_power(gserial, GNSS_SERIAL_OFF);
  153. return ret;
  154. }
  155. EXPORT_SYMBOL_GPL(gnss_serial_register);
  156. void gnss_serial_deregister(struct gnss_serial *gserial)
  157. {
  158. struct serdev_device *serdev = gserial->serdev;
  159. gnss_deregister_device(gserial->gdev);
  160. if (IS_ENABLED(CONFIG_PM))
  161. pm_runtime_disable(&serdev->dev);
  162. else
  163. gnss_serial_set_power(gserial, GNSS_SERIAL_OFF);
  164. }
  165. EXPORT_SYMBOL_GPL(gnss_serial_deregister);
  166. #ifdef CONFIG_PM
  167. static int gnss_serial_runtime_suspend(struct device *dev)
  168. {
  169. struct gnss_serial *gserial = dev_get_drvdata(dev);
  170. return gnss_serial_set_power(gserial, GNSS_SERIAL_STANDBY);
  171. }
  172. static int gnss_serial_runtime_resume(struct device *dev)
  173. {
  174. struct gnss_serial *gserial = dev_get_drvdata(dev);
  175. return gnss_serial_set_power(gserial, GNSS_SERIAL_ACTIVE);
  176. }
  177. #endif /* CONFIG_PM */
  178. static int gnss_serial_prepare(struct device *dev)
  179. {
  180. if (pm_runtime_suspended(dev))
  181. return 1;
  182. return 0;
  183. }
  184. #ifdef CONFIG_PM_SLEEP
  185. static int gnss_serial_suspend(struct device *dev)
  186. {
  187. struct gnss_serial *gserial = dev_get_drvdata(dev);
  188. int ret = 0;
  189. /*
  190. * FIXME: serdev currently lacks support for managing the underlying
  191. * device's wakeup settings. A workaround would be to close the serdev
  192. * device here if it is open.
  193. */
  194. if (!pm_runtime_suspended(dev))
  195. ret = gnss_serial_set_power(gserial, GNSS_SERIAL_STANDBY);
  196. return ret;
  197. }
  198. static int gnss_serial_resume(struct device *dev)
  199. {
  200. struct gnss_serial *gserial = dev_get_drvdata(dev);
  201. int ret = 0;
  202. if (!pm_runtime_suspended(dev))
  203. ret = gnss_serial_set_power(gserial, GNSS_SERIAL_ACTIVE);
  204. return ret;
  205. }
  206. #endif /* CONFIG_PM_SLEEP */
  207. const struct dev_pm_ops gnss_serial_pm_ops = {
  208. .prepare = gnss_serial_prepare,
  209. SET_SYSTEM_SLEEP_PM_OPS(gnss_serial_suspend, gnss_serial_resume)
  210. SET_RUNTIME_PM_OPS(gnss_serial_runtime_suspend, gnss_serial_runtime_resume, NULL)
  211. };
  212. EXPORT_SYMBOL_GPL(gnss_serial_pm_ops);
  213. MODULE_AUTHOR("Johan Hovold <johan@kernel.org>");
  214. MODULE_DESCRIPTION("Generic serial GNSS receiver driver");
  215. MODULE_LICENSE("GPL v2");