include/linux/serdev.h

   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
  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 */