1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * Copyright (C) 2016-2017 Linaro Ltd., Rob Herring <[email protected]> 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 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 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 111 static inline struct serdev_controller *to_serdev_controller(struct device *d) 112 { 113 return container_of(d, struct serdev_controller, dev); 114 } 115 116 static inline void *serdev_device_get_drvdata(const struct serdev_device *serdev) 117 { 118 return dev_get_drvdata(&serdev->dev); 119 } 120 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 */ 130 static inline void serdev_device_put(struct serdev_device *serdev) 131 { 132 if (serdev) 133 put_device(&serdev->dev); 134 } 135 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 143 void *serdev_controller_get_drvdata(const struct serdev_controller *ctrl) 144 { 145 return ctrl ? dev_get_drvdata(&ctrl->dev) : NULL; 146 } 147 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 */ 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 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 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 */ 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 233 static inline int serdev_device_open(struct serdev_device *sdev) 234 { 235 return -ENODEV; 236 } 237 static inline void serdev_device_close(struct serdev_device *sdev) {} 238 static inline unsigned int serdev_device_set_baudrate(struct serdev_device *sdev, unsigned int baudrate) 239 { 240 return 0; 241 } 242 static inline void serdev_device_set_flow_control(struct serdev_device *sdev, bool enable) {} 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 } 249 static inline void serdev_device_wait_until_sent(struct serdev_device *sdev, long timeout) {} 250 static inline int serdev_device_get_tiocm(struct serdev_device *serdev) 251 { 252 return -ENOTSUPP; 253 } 254 static inline int serdev_device_set_tiocm(struct serdev_device *serdev, int set, int clear) 255 { 256 return -ENOTSUPP; 257 } 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 } 263 static inline void serdev_device_write_flush(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 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 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 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 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 } 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 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