serdev.h 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342
  1. /* SPDX-License-Identifier: GPL-2.0-only */
  2. /*
  3. * Copyright (C) 2016-2017 Linaro Ltd., Rob Herring <robh@kernel.org>
  4. */
  5. #ifndef _LINUX_SERDEV_H
  6. #define _LINUX_SERDEV_H
  7. #include <linux/types.h>
  8. #include <linux/device.h>
  9. #include <linux/termios.h>
  10. #include <linux/delay.h>
  11. struct serdev_controller;
  12. struct serdev_device;
  13. /*
  14. * serdev device structures
  15. */
  16. /**
  17. * struct serdev_device_ops - Callback operations for a serdev device
  18. * @receive_buf: Function called with data received from device;
  19. * returns number of bytes accepted; may sleep.
  20. * @write_wakeup: Function called when ready to transmit more data; must
  21. * not sleep.
  22. */
  23. struct serdev_device_ops {
  24. int (*receive_buf)(struct serdev_device *, const unsigned char *, size_t);
  25. void (*write_wakeup)(struct serdev_device *);
  26. };
  27. /**
  28. * struct serdev_device - Basic representation of an serdev device
  29. * @dev: Driver model representation of the device.
  30. * @nr: Device number on serdev bus.
  31. * @ctrl: serdev controller managing this device.
  32. * @ops: Device operations.
  33. * @write_comp Completion used by serdev_device_write() internally
  34. * @write_lock Lock to serialize access when writing data
  35. */
  36. struct serdev_device {
  37. struct device dev;
  38. int nr;
  39. struct serdev_controller *ctrl;
  40. const struct serdev_device_ops *ops;
  41. struct completion write_comp;
  42. struct mutex write_lock;
  43. };
  44. static inline struct serdev_device *to_serdev_device(struct device *d)
  45. {
  46. return container_of(d, struct serdev_device, dev);
  47. }
  48. /**
  49. * struct serdev_device_driver - serdev slave device driver
  50. * @driver: serdev device drivers should initialize name field of this
  51. * structure.
  52. * @probe: binds this driver to a serdev device.
  53. * @remove: unbinds this driver from the serdev device.
  54. */
  55. struct serdev_device_driver {
  56. struct device_driver driver;
  57. int (*probe)(struct serdev_device *);
  58. void (*remove)(struct serdev_device *);
  59. };
  60. static inline struct serdev_device_driver *to_serdev_device_driver(struct device_driver *d)
  61. {
  62. return container_of(d, struct serdev_device_driver, driver);
  63. }
  64. enum serdev_parity {
  65. SERDEV_PARITY_NONE,
  66. SERDEV_PARITY_EVEN,
  67. SERDEV_PARITY_ODD,
  68. };
  69. /*
  70. * serdev controller structures
  71. */
  72. struct serdev_controller_ops {
  73. int (*write_buf)(struct serdev_controller *, const unsigned char *, size_t);
  74. void (*write_flush)(struct serdev_controller *);
  75. int (*write_room)(struct serdev_controller *);
  76. int (*open)(struct serdev_controller *);
  77. void (*close)(struct serdev_controller *);
  78. void (*set_flow_control)(struct serdev_controller *, bool);
  79. int (*set_parity)(struct serdev_controller *, enum serdev_parity);
  80. unsigned int (*set_baudrate)(struct serdev_controller *, unsigned int);
  81. void (*wait_until_sent)(struct serdev_controller *, long);
  82. int (*get_tiocm)(struct serdev_controller *);
  83. int (*set_tiocm)(struct serdev_controller *, unsigned int, unsigned int);
  84. };
  85. /**
  86. * struct serdev_controller - interface to the serdev controller
  87. * @dev: Driver model representation of the device.
  88. * @nr: number identifier for this controller/bus.
  89. * @serdev: Pointer to slave device for this controller.
  90. * @ops: Controller operations.
  91. */
  92. struct serdev_controller {
  93. struct device dev;
  94. unsigned int nr;
  95. struct serdev_device *serdev;
  96. const struct serdev_controller_ops *ops;
  97. };
  98. static inline struct serdev_controller *to_serdev_controller(struct device *d)
  99. {
  100. return container_of(d, struct serdev_controller, dev);
  101. }
  102. static inline void *serdev_device_get_drvdata(const struct serdev_device *serdev)
  103. {
  104. return dev_get_drvdata(&serdev->dev);
  105. }
  106. static inline void serdev_device_set_drvdata(struct serdev_device *serdev, void *data)
  107. {
  108. dev_set_drvdata(&serdev->dev, data);
  109. }
  110. /**
  111. * serdev_device_put() - decrement serdev device refcount
  112. * @serdev serdev device.
  113. */
  114. static inline void serdev_device_put(struct serdev_device *serdev)
  115. {
  116. if (serdev)
  117. put_device(&serdev->dev);
  118. }
  119. static inline void serdev_device_set_client_ops(struct serdev_device *serdev,
  120. const struct serdev_device_ops *ops)
  121. {
  122. serdev->ops = ops;
  123. }
  124. static inline
  125. void *serdev_controller_get_drvdata(const struct serdev_controller *ctrl)
  126. {
  127. return ctrl ? dev_get_drvdata(&ctrl->dev) : NULL;
  128. }
  129. static inline void serdev_controller_set_drvdata(struct serdev_controller *ctrl,
  130. void *data)
  131. {
  132. dev_set_drvdata(&ctrl->dev, data);
  133. }
  134. /**
  135. * serdev_controller_put() - decrement controller refcount
  136. * @ctrl serdev controller.
  137. */
  138. static inline void serdev_controller_put(struct serdev_controller *ctrl)
  139. {
  140. if (ctrl)
  141. put_device(&ctrl->dev);
  142. }
  143. struct serdev_device *serdev_device_alloc(struct serdev_controller *);
  144. int serdev_device_add(struct serdev_device *);
  145. void serdev_device_remove(struct serdev_device *);
  146. struct serdev_controller *serdev_controller_alloc(struct device *, size_t);
  147. int serdev_controller_add_platform(struct serdev_controller *, bool);
  148. void serdev_controller_remove(struct serdev_controller *);
  149. /**
  150. * serdev_controller_add() - Add an serdev controller
  151. * @ctrl: controller to be registered.
  152. *
  153. * Register a controller previously allocated via serdev_controller_alloc() with
  154. * the serdev core.
  155. */
  156. static inline int serdev_controller_add(struct serdev_controller *ctrl)
  157. {
  158. return serdev_controller_add_platform(ctrl, false);
  159. }
  160. static inline void serdev_controller_write_wakeup(struct serdev_controller *ctrl)
  161. {
  162. struct serdev_device *serdev = ctrl->serdev;
  163. if (!serdev || !serdev->ops->write_wakeup)
  164. return;
  165. serdev->ops->write_wakeup(serdev);
  166. }
  167. static inline int serdev_controller_receive_buf(struct serdev_controller *ctrl,
  168. const unsigned char *data,
  169. size_t count)
  170. {
  171. struct serdev_device *serdev = ctrl->serdev;
  172. if (!serdev || !serdev->ops->receive_buf)
  173. return 0;
  174. return serdev->ops->receive_buf(serdev, data, count);
  175. }
  176. #if IS_ENABLED(CONFIG_SERIAL_DEV_BUS)
  177. int serdev_device_open(struct serdev_device *);
  178. void serdev_device_close(struct serdev_device *);
  179. int devm_serdev_device_open(struct device *, struct serdev_device *);
  180. unsigned int serdev_device_set_baudrate(struct serdev_device *, unsigned int);
  181. void serdev_device_set_flow_control(struct serdev_device *, bool);
  182. int serdev_device_write_buf(struct serdev_device *, const unsigned char *, size_t);
  183. void serdev_device_wait_until_sent(struct serdev_device *, long);
  184. int serdev_device_get_tiocm(struct serdev_device *);
  185. int serdev_device_set_tiocm(struct serdev_device *, int, int);
  186. void serdev_device_write_wakeup(struct serdev_device *);
  187. int serdev_device_write(struct serdev_device *, const unsigned char *, size_t, long);
  188. void serdev_device_write_flush(struct serdev_device *);
  189. int serdev_device_write_room(struct serdev_device *);
  190. /*
  191. * serdev device driver functions
  192. */
  193. int __serdev_device_driver_register(struct serdev_device_driver *, struct module *);
  194. #define serdev_device_driver_register(sdrv) \
  195. __serdev_device_driver_register(sdrv, THIS_MODULE)
  196. /**
  197. * serdev_device_driver_unregister() - unregister an serdev client driver
  198. * @sdrv: the driver to unregister
  199. */
  200. static inline void serdev_device_driver_unregister(struct serdev_device_driver *sdrv)
  201. {
  202. if (sdrv)
  203. driver_unregister(&sdrv->driver);
  204. }
  205. #define module_serdev_device_driver(__serdev_device_driver) \
  206. module_driver(__serdev_device_driver, serdev_device_driver_register, \
  207. serdev_device_driver_unregister)
  208. #else
  209. static inline int serdev_device_open(struct serdev_device *sdev)
  210. {
  211. return -ENODEV;
  212. }
  213. static inline void serdev_device_close(struct serdev_device *sdev) {}
  214. static inline unsigned int serdev_device_set_baudrate(struct serdev_device *sdev, unsigned int baudrate)
  215. {
  216. return 0;
  217. }
  218. static inline void serdev_device_set_flow_control(struct serdev_device *sdev, bool enable) {}
  219. static inline int serdev_device_write_buf(struct serdev_device *serdev,
  220. const unsigned char *buf,
  221. size_t count)
  222. {
  223. return -ENODEV;
  224. }
  225. static inline void serdev_device_wait_until_sent(struct serdev_device *sdev, long timeout) {}
  226. static inline int serdev_device_get_tiocm(struct serdev_device *serdev)
  227. {
  228. return -ENOTSUPP;
  229. }
  230. static inline int serdev_device_set_tiocm(struct serdev_device *serdev, int set, int clear)
  231. {
  232. return -ENOTSUPP;
  233. }
  234. static inline int serdev_device_write(struct serdev_device *sdev, const unsigned char *buf,
  235. size_t count, unsigned long timeout)
  236. {
  237. return -ENODEV;
  238. }
  239. static inline void serdev_device_write_flush(struct serdev_device *sdev) {}
  240. static inline int serdev_device_write_room(struct serdev_device *sdev)
  241. {
  242. return 0;
  243. }
  244. #define serdev_device_driver_register(x)
  245. #define serdev_device_driver_unregister(x)
  246. #endif /* CONFIG_SERIAL_DEV_BUS */
  247. static inline bool serdev_device_get_cts(struct serdev_device *serdev)
  248. {
  249. int status = serdev_device_get_tiocm(serdev);
  250. return !!(status & TIOCM_CTS);
  251. }
  252. static inline int serdev_device_wait_for_cts(struct serdev_device *serdev, bool state, int timeout_ms)
  253. {
  254. unsigned long timeout;
  255. bool signal;
  256. timeout = jiffies + msecs_to_jiffies(timeout_ms);
  257. while (time_is_after_jiffies(timeout)) {
  258. signal = serdev_device_get_cts(serdev);
  259. if (signal == state)
  260. return 0;
  261. usleep_range(1000, 2000);
  262. }
  263. return -ETIMEDOUT;
  264. }
  265. static inline int serdev_device_set_rts(struct serdev_device *serdev, bool enable)
  266. {
  267. if (enable)
  268. return serdev_device_set_tiocm(serdev, TIOCM_RTS, 0);
  269. else
  270. return serdev_device_set_tiocm(serdev, 0, TIOCM_RTS);
  271. }
  272. int serdev_device_set_parity(struct serdev_device *serdev,
  273. enum serdev_parity parity);
  274. /*
  275. * serdev hooks into TTY core
  276. */
  277. struct tty_port;
  278. struct tty_driver;
  279. #ifdef CONFIG_SERIAL_DEV_CTRL_TTYPORT
  280. struct device *serdev_tty_port_register(struct tty_port *port,
  281. struct device *parent,
  282. struct tty_driver *drv, int idx);
  283. int serdev_tty_port_unregister(struct tty_port *port);
  284. #else
  285. static inline struct device *serdev_tty_port_register(struct tty_port *port,
  286. struct device *parent,
  287. struct tty_driver *drv, int idx)
  288. {
  289. return ERR_PTR(-ENODEV);
  290. }
  291. static inline int serdev_tty_port_unregister(struct tty_port *port)
  292. {
  293. return -ENODEV;
  294. }
  295. #endif /* CONFIG_SERIAL_DEV_CTRL_TTYPORT */
  296. #endif /*_LINUX_SERDEV_H */