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