drivers/tty/serial/serial_base_bus.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Serial base bus layer for controllers
   4  *
   5  * Copyright (C) 2023 Texas Instruments Incorporated - https://www.ti.com/
   6  * Author: Tony Lindgren <[email protected]>
   7  *
   8  * The serial core bus manages the serial core controller instances.
   9  */
  10
  11 #include <linux/container_of.h>
  12 #include <linux/device.h>
  13 #include <linux/idr.h>
  14 #include <linux/module.h>
  15 #include <linux/serial_core.h>
  16 #include <linux/slab.h>
  17 #include <linux/spinlock.h>
  18
  19 #include "serial_base.h"
  20
  21 static bool serial_base_initialized;
  22
  23 static const struct device_type serial_ctrl_type = {
  24         .name = "ctrl",
  25 };
  26
  27 static const struct device_type serial_port_type = {
  28         .name = "port",
  29 };
  30
  31 static int serial_base_match(struct device *dev, struct device_driver *drv)
  32 {
  33         if (dev->type == &serial_ctrl_type &&
  34             str_has_prefix(drv->name, serial_ctrl_type.name))
  35                 return 1;
  36
  37         if (dev->type == &serial_port_type &&
  38             str_has_prefix(drv->name, serial_port_type.name))
  39                 return 1;
  40
  41         return 0;
  42 }
  43
  44 static struct bus_type serial_base_bus_type = {
  45         .name = "serial-base",
  46         .match = serial_base_match,
  47 };
  48
  49 int serial_base_driver_register(struct device_driver *driver)
  50 {
  51         driver->bus = &serial_base_bus_type;
  52
  53         return driver_register(driver);
  54 }
  55
  56 void serial_base_driver_unregister(struct device_driver *driver)
  57 {
  58         driver_unregister(driver);
  59 }
  60
  61 static int serial_base_device_init(struct uart_port *port,
  62                                    struct device *dev,
  63                                    struct device *parent_dev,
  64                                    const struct device_type *type,
  65                                    void (*release)(struct device *dev),
  66                                    unsigned int ctrl_id,
  67                                    unsigned int port_id)
  68 {
  69         device_initialize(dev);
  70         dev->type = type;
  71         dev->parent = parent_dev;
  72         dev->bus = &serial_base_bus_type;
  73         dev->release = release;
  74
  75         if (!serial_base_initialized) {
  76                 dev_dbg(port->dev, "uart_add_one_port() called before arch_initcall()?\n");
  77                 return -EPROBE_DEFER;
  78         }
  79
  80         if (type == &serial_ctrl_type)
  81                 return dev_set_name(dev, "%s:%d", dev_name(port->dev), ctrl_id);
  82
  83         if (type == &serial_port_type)
  84                 return dev_set_name(dev, "%s:%d.%d", dev_name(port->dev),
  85                                     ctrl_id, port_id);
  86
  87         return -EINVAL;
  88 }
  89
  90 static void serial_base_ctrl_release(struct device *dev)
  91 {
  92         struct serial_ctrl_device *ctrl_dev = to_serial_base_ctrl_device(dev);
  93
  94         kfree(ctrl_dev);
  95 }
  96
  97 void serial_base_ctrl_device_remove(struct serial_ctrl_device *ctrl_dev)
  98 {
  99         if (!ctrl_dev)
 100                 return;
 101
 102         device_del(&ctrl_dev->dev);
 103         put_device(&ctrl_dev->dev);
 104 }
 105
 106 struct serial_ctrl_device *serial_base_ctrl_add(struct uart_port *port,
 107                                                 struct device *parent)
 108 {
 109         struct serial_ctrl_device *ctrl_dev;
 110         int err;
 111
 112         ctrl_dev = kzalloc(sizeof(*ctrl_dev), GFP_KERNEL);
 113         if (!ctrl_dev)
 114                 return ERR_PTR(-ENOMEM);
 115
 116         ida_init(&ctrl_dev->port_ida);
 117
 118         err = serial_base_device_init(port, &ctrl_dev->dev,
 119                                       parent, &serial_ctrl_type,
 120                                       serial_base_ctrl_release,
 121                                       port->ctrl_id, 0);
 122         if (err)
 123                 goto err_put_device;
 124
 125         err = device_add(&ctrl_dev->dev);
 126         if (err)
 127                 goto err_put_device;
 128
 129         return ctrl_dev;
 130
 131 err_put_device:
 132         put_device(&ctrl_dev->dev);
 133
 134         return ERR_PTR(err);
 135 }
 136
 137 static void serial_base_port_release(struct device *dev)
 138 {
 139         struct serial_port_device *port_dev = to_serial_base_port_device(dev);
 140
 141         kfree(port_dev);
 142 }
 143
 144 struct serial_port_device *serial_base_port_add(struct uart_port *port,
 145                                                 struct serial_ctrl_device *ctrl_dev)
 146 {
 147         struct serial_port_device *port_dev;
 148         int min = 0, max = -1;  /* Use -1 for max to apply IDA defaults */
 149         int err;
 150
 151         port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
 152         if (!port_dev)
 153                 return ERR_PTR(-ENOMEM);
 154
 155         /* Device driver specified port_id vs automatic assignment? */
 156         if (port->port_id) {
 157                 min = port->port_id;
 158                 max = port->port_id;
 159         }
 160
 161         err = ida_alloc_range(&ctrl_dev->port_ida, min, max, GFP_KERNEL);
 162         if (err < 0) {
 163                 kfree(port_dev);
 164                 return ERR_PTR(err);
 165         }
 166
 167         port->port_id = err;
 168
 169         err = serial_base_device_init(port, &port_dev->dev,
 170                                       &ctrl_dev->dev, &serial_port_type,
 171                                       serial_base_port_release,
 172                                       port->ctrl_id, port->port_id);
 173         if (err)
 174                 goto err_put_device;
 175
 176         port_dev->port = port;
 177
 178         err = device_add(&port_dev->dev);
 179         if (err)
 180                 goto err_put_device;
 181
 182         return port_dev;
 183
 184 err_put_device:
 185         put_device(&port_dev->dev);
 186         ida_free(&ctrl_dev->port_ida, port->port_id);
 187
 188         return ERR_PTR(err);
 189 }
 190
 191 void serial_base_port_device_remove(struct serial_port_device *port_dev)
 192 {
 193         struct serial_ctrl_device *ctrl_dev;
 194         struct device *parent;
 195
 196         if (!port_dev)
 197                 return;
 198
 199         parent = port_dev->dev.parent;
 200         ctrl_dev = to_serial_base_ctrl_device(parent);
 201
 202         device_del(&port_dev->dev);
 203         ida_free(&ctrl_dev->port_ida, port_dev->port->port_id);
 204         put_device(&port_dev->dev);
 205 }
 206
 207 static int serial_base_init(void)
 208 {
 209         int ret;
 210
 211         ret = bus_register(&serial_base_bus_type);
 212         if (ret)
 213                 return ret;
 214
 215         ret = serial_base_ctrl_init();
 216         if (ret)
 217                 goto err_bus_unregister;
 218
 219         ret = serial_base_port_init();
 220         if (ret)
 221                 goto err_ctrl_exit;
 222
 223         serial_base_initialized = true;
 224
 225         return 0;
 226
 227 err_ctrl_exit:
 228         serial_base_ctrl_exit();
 229
 230 err_bus_unregister:
 231         bus_unregister(&serial_base_bus_type);
 232
 233         return ret;
 234 }
 235 arch_initcall(serial_base_init);
 236
 237 static void serial_base_exit(void)
 238 {
 239         serial_base_port_exit();
 240         serial_base_ctrl_exit();
 241         bus_unregister(&serial_base_bus_type);
 242 }
 243 module_exit(serial_base_exit);
 244
 245 MODULE_AUTHOR("Tony Lindgren <[email protected]>");
 246 MODULE_DESCRIPTION("Serial core bus");
 247 MODULE_LICENSE("GPL");