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 /* 80 * serdev controller structures 81 */ 82 struct serdev_controller_ops { 83 int (*write_buf)(struct serdev_controller *, const unsigned char *, size_t); 84 void (*write_flush)(struct serdev_controller *); 85 int (*write_room)(struct serdev_controller *); 86 int (*open)(struct serdev_controller *); 87 void (*close)(struct serdev_controller *); 88 void (*set_flow_control)(struct serdev_controller *, bool); 89 unsigned int (*set_baudrate)(struct serdev_controller *, unsigned int); 90 void (*wait_until_sent)(struct serdev_controller *, long); 91 int (*get_tiocm)(struct serdev_controller *); 92 int (*set_tiocm)(struct serdev_controller *, unsigned int, unsigned int); 93 }; 94 95 /** 96 * struct serdev_controller - interface to the serdev controller 97 * @dev: Driver model representation of the device. 98 * @nr: number identifier for this controller/bus. 99 * @serdev: Pointer to slave device for this controller. 100 * @ops: Controller operations. 101 */ 102 struct serdev_controller { 103 struct device dev; 104 unsigned int nr; 105 struct serdev_device *serdev; 106 const struct serdev_controller_ops *ops; 107 }; 108 109 static inline struct serdev_controller *to_serdev_controller(struct device *d) 110 { 111 return container_of(d, struct serdev_controller, dev); 112 } 113 114 static inline void *serdev_device_get_drvdata(const struct serdev_device *serdev) 115 { 116 return dev_get_drvdata(&serdev->dev); 117 } 118 119 static inline void serdev_device_set_drvdata(struct serdev_device *serdev, void *data) 120 { 121 dev_set_drvdata(&serdev->dev, data); 122 } 123 124 /** 125 * serdev_device_put() - decrement serdev device refcount 126 * @serdev serdev device. 127 */ 128 static inline void serdev_device_put(struct serdev_device *serdev) 129 { 130 if (serdev) 131 put_device(&serdev->dev); 132 } 133 134 static inline void serdev_device_set_client_ops(struct serdev_device *serdev, 135 const struct serdev_device_ops *ops) 136 { 137 serdev->ops = ops; 138 } 139 140 static inline 141 void *serdev_controller_get_drvdata(const struct serdev_controller *ctrl) 142 { 143 return ctrl ? dev_get_drvdata(&ctrl->dev) : NULL; 144 } 145 146 static inline void serdev_controller_set_drvdata(struct serdev_controller *ctrl, 147 void *data) 148 { 149 dev_set_drvdata(&ctrl->dev, data); 150 } 151 152 /** 153 * serdev_controller_put() - decrement controller refcount 154 * @ctrl serdev controller. 155 */ 156 static inline void serdev_controller_put(struct serdev_controller *ctrl) 157 { 158 if (ctrl) 159 put_device(&ctrl->dev); 160 } 161 162 struct serdev_device *serdev_device_alloc(struct serdev_controller *); 163 int serdev_device_add(struct serdev_device *); 164 void serdev_device_remove(struct serdev_device *); 165 166 struct serdev_controller *serdev_controller_alloc(struct device *, size_t); 167 int serdev_controller_add(struct serdev_controller *); 168 void serdev_controller_remove(struct serdev_controller *); 169 170 static inline void serdev_controller_write_wakeup(struct serdev_controller *ctrl) 171 { 172 struct serdev_device *serdev = ctrl->serdev; 173 174 if (!serdev || !serdev->ops->write_wakeup) 175 return; 176 177 serdev->ops->write_wakeup(serdev); 178 } 179 180 static inline int serdev_controller_receive_buf(struct serdev_controller *ctrl, 181 const unsigned char *data, 182 size_t count) 183 { 184 struct serdev_device *serdev = ctrl->serdev; 185 186 if (!serdev || !serdev->ops->receive_buf) 187 return -EINVAL; 188 189 return serdev->ops->receive_buf(serdev, data, count); 190 } 191 192 #if IS_ENABLED(CONFIG_SERIAL_DEV_BUS) 193 194 int serdev_device_open(struct serdev_device *); 195 void serdev_device_close(struct serdev_device *); 196 int devm_serdev_device_open(struct device *, struct serdev_device *); 197 unsigned int serdev_device_set_baudrate(struct serdev_device *, unsigned int); 198 void serdev_device_set_flow_control(struct serdev_device *, bool); 199 int serdev_device_write_buf(struct serdev_device *, const unsigned char *, size_t); 200 void serdev_device_wait_until_sent(struct serdev_device *, long); 201 int serdev_device_get_tiocm(struct serdev_device *); 202 int serdev_device_set_tiocm(struct serdev_device *, int, int); 203 void serdev_device_write_wakeup(struct serdev_device *); 204 int serdev_device_write(struct serdev_device *, const unsigned char *, size_t, unsigned long); 205 void serdev_device_write_flush(struct serdev_device *); 206 int serdev_device_write_room(struct serdev_device *); 207 208 /* 209 * serdev device driver functions 210 */ 211 int __serdev_device_driver_register(struct serdev_device_driver *, struct module *); 212 #define serdev_device_driver_register(sdrv) \ 213 __serdev_device_driver_register(sdrv, THIS_MODULE) 214 215 /** 216 * serdev_device_driver_unregister() - unregister an serdev client driver 217 * @sdrv: the driver to unregister 218 */ 219 static inline void serdev_device_driver_unregister(struct serdev_device_driver *sdrv) 220 { 221 if (sdrv) 222 driver_unregister(&sdrv->driver); 223 } 224 225 #define module_serdev_device_driver(__serdev_device_driver) \ 226 module_driver(__serdev_device_driver, serdev_device_driver_register, \ 227 serdev_device_driver_unregister) 228 229 #else 230 231 static inline int serdev_device_open(struct serdev_device *sdev) 232 { 233 return -ENODEV; 234 } 235 static inline void serdev_device_close(struct serdev_device *sdev) {} 236 static inline unsigned int serdev_device_set_baudrate(struct serdev_device *sdev, unsigned int baudrate) 237 { 238 return 0; 239 } 240 static inline void serdev_device_set_flow_control(struct serdev_device *sdev, bool enable) {} 241 static inline int serdev_device_write_buf(struct serdev_device *serdev, 242 const unsigned char *buf, 243 size_t count) 244 { 245 return -ENODEV; 246 } 247 static inline void serdev_device_wait_until_sent(struct serdev_device *sdev, long timeout) {} 248 static inline int serdev_device_get_tiocm(struct serdev_device *serdev) 249 { 250 return -ENOTSUPP; 251 } 252 static inline int serdev_device_set_tiocm(struct serdev_device *serdev, int set, int clear) 253 { 254 return -ENOTSUPP; 255 } 256 static inline int serdev_device_write(struct serdev_device *sdev, const unsigned char *buf, 257 size_t count, unsigned long timeout) 258 { 259 return -ENODEV; 260 } 261 static inline void serdev_device_write_flush(struct serdev_device *sdev) {} 262 static inline int serdev_device_write_room(struct serdev_device *sdev) 263 { 264 return 0; 265 } 266 267 #define serdev_device_driver_register(x) 268 #define serdev_device_driver_unregister(x) 269 270 #endif /* CONFIG_SERIAL_DEV_BUS */ 271 272 static inline bool serdev_device_get_cts(struct serdev_device *serdev) 273 { 274 int status = serdev_device_get_tiocm(serdev); 275 return !!(status & TIOCM_CTS); 276 } 277 278 static inline int serdev_device_wait_for_cts(struct serdev_device *serdev, bool state, int timeout_ms) 279 { 280 unsigned long timeout; 281 bool signal; 282 283 timeout = jiffies + msecs_to_jiffies(timeout_ms); 284 while (time_is_after_jiffies(timeout)) { 285 signal = serdev_device_get_cts(serdev); 286 if (signal == state) 287 return 0; 288 usleep_range(1000, 2000); 289 } 290 291 return -ETIMEDOUT; 292 } 293 294 static inline int serdev_device_set_rts(struct serdev_device *serdev, bool enable) 295 { 296 if (enable) 297 return serdev_device_set_tiocm(serdev, TIOCM_RTS, 0); 298 else 299 return serdev_device_set_tiocm(serdev, 0, TIOCM_RTS); 300 } 301 302 /* 303 * serdev hooks into TTY core 304 */ 305 struct tty_port; 306 struct tty_driver; 307 308 #ifdef CONFIG_SERIAL_DEV_CTRL_TTYPORT 309 struct device *serdev_tty_port_register(struct tty_port *port, 310 struct device *parent, 311 struct tty_driver *drv, int idx); 312 int serdev_tty_port_unregister(struct tty_port *port); 313 #else 314 static inline struct device *serdev_tty_port_register(struct tty_port *port, 315 struct device *parent, 316 struct tty_driver *drv, int idx) 317 { 318 return ERR_PTR(-ENODEV); 319 } 320 static inline int serdev_tty_port_unregister(struct tty_port *port) 321 { 322 return -ENODEV; 323 } 324 #endif /* CONFIG_SERIAL_DEV_CTRL_TTYPORT */ 325 326 #endif /*_LINUX_SERDEV_H */ 327