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