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 <tony@atomide.com> 7 * 8 * The serial core bus manages the serial core controller instances. 9 */ 10 11 #include <linux/cleanup.h> 12 #include <linux/container_of.h> 13 #include <linux/device.h> 14 #include <linux/idr.h> 15 #include <linux/module.h> 16 #include <linux/serial_core.h> 17 #include <linux/slab.h> 18 #include <linux/spinlock.h> 19 20 #include "serial_base.h" 21 22 static bool serial_base_initialized; 23 24 static const struct device_type serial_ctrl_type = { 25 .name = "ctrl", 26 }; 27 28 static const struct device_type serial_port_type = { 29 .name = "port", 30 }; 31 32 static int serial_base_match(struct device *dev, const struct device_driver *drv) 33 { 34 if (dev->type == &serial_ctrl_type && 35 str_has_prefix(drv->name, serial_ctrl_type.name)) 36 return 1; 37 38 if (dev->type == &serial_port_type && 39 str_has_prefix(drv->name, serial_port_type.name)) 40 return 1; 41 42 return 0; 43 } 44 45 static const struct bus_type serial_base_bus_type = { 46 .name = "serial-base", 47 .match = serial_base_match, 48 }; 49 50 int serial_base_driver_register(struct device_driver *driver) 51 { 52 driver->bus = &serial_base_bus_type; 53 54 return driver_register(driver); 55 } 56 57 void serial_base_driver_unregister(struct device_driver *driver) 58 { 59 driver_unregister(driver); 60 } 61 62 static int serial_base_device_init(struct uart_port *port, 63 struct device *dev, 64 struct device *parent_dev, 65 const struct device_type *type, 66 void (*release)(struct device *dev), 67 unsigned int ctrl_id, 68 unsigned int port_id) 69 { 70 device_initialize(dev); 71 dev->type = type; 72 dev->parent = parent_dev; 73 dev->bus = &serial_base_bus_type; 74 dev->release = release; 75 device_set_of_node_from_dev(dev, parent_dev); 76 77 if (!serial_base_initialized) { 78 dev_dbg(port->dev, "uart_add_one_port() called before arch_initcall()?\n"); 79 return -EPROBE_DEFER; 80 } 81 82 if (type == &serial_ctrl_type) 83 return dev_set_name(dev, "%s:%d", dev_name(port->dev), ctrl_id); 84 85 if (type == &serial_port_type) 86 return dev_set_name(dev, "%s:%d.%d", dev_name(port->dev), 87 ctrl_id, port_id); 88 89 return -EINVAL; 90 } 91 92 static void serial_base_ctrl_release(struct device *dev) 93 { 94 struct serial_ctrl_device *ctrl_dev = to_serial_base_ctrl_device(dev); 95 96 kfree(ctrl_dev); 97 } 98 99 void serial_base_ctrl_device_remove(struct serial_ctrl_device *ctrl_dev) 100 { 101 if (!ctrl_dev) 102 return; 103 104 device_del(&ctrl_dev->dev); 105 put_device(&ctrl_dev->dev); 106 } 107 108 struct serial_ctrl_device *serial_base_ctrl_add(struct uart_port *port, 109 struct device *parent) 110 { 111 struct serial_ctrl_device *ctrl_dev; 112 int err; 113 114 ctrl_dev = kzalloc(sizeof(*ctrl_dev), GFP_KERNEL); 115 if (!ctrl_dev) 116 return ERR_PTR(-ENOMEM); 117 118 ida_init(&ctrl_dev->port_ida); 119 120 err = serial_base_device_init(port, &ctrl_dev->dev, 121 parent, &serial_ctrl_type, 122 serial_base_ctrl_release, 123 port->ctrl_id, 0); 124 if (err) 125 goto err_put_device; 126 127 err = device_add(&ctrl_dev->dev); 128 if (err) 129 goto err_put_device; 130 131 return ctrl_dev; 132 133 err_put_device: 134 put_device(&ctrl_dev->dev); 135 136 return ERR_PTR(err); 137 } 138 139 static void serial_base_port_release(struct device *dev) 140 { 141 struct serial_port_device *port_dev = to_serial_base_port_device(dev); 142 143 kfree(port_dev); 144 } 145 146 struct serial_port_device *serial_base_port_add(struct uart_port *port, 147 struct serial_ctrl_device *ctrl_dev) 148 { 149 struct serial_port_device *port_dev; 150 int min = 0, max = -1; /* Use -1 for max to apply IDA defaults */ 151 int err; 152 153 port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL); 154 if (!port_dev) 155 return ERR_PTR(-ENOMEM); 156 157 /* Device driver specified port_id vs automatic assignment? */ 158 if (port->port_id) { 159 min = port->port_id; 160 max = port->port_id; 161 } 162 163 err = ida_alloc_range(&ctrl_dev->port_ida, min, max, GFP_KERNEL); 164 if (err < 0) { 165 kfree(port_dev); 166 return ERR_PTR(err); 167 } 168 169 port->port_id = err; 170 171 err = serial_base_device_init(port, &port_dev->dev, 172 &ctrl_dev->dev, &serial_port_type, 173 serial_base_port_release, 174 port->ctrl_id, port->port_id); 175 if (err) 176 goto err_put_device; 177 178 port_dev->port = port; 179 180 err = device_add(&port_dev->dev); 181 if (err) 182 goto err_put_device; 183 184 return port_dev; 185 186 err_put_device: 187 put_device(&port_dev->dev); 188 ida_free(&ctrl_dev->port_ida, port->port_id); 189 190 return ERR_PTR(err); 191 } 192 193 void serial_base_port_device_remove(struct serial_port_device *port_dev) 194 { 195 struct serial_ctrl_device *ctrl_dev; 196 struct device *parent; 197 198 if (!port_dev) 199 return; 200 201 parent = port_dev->dev.parent; 202 ctrl_dev = to_serial_base_ctrl_device(parent); 203 204 device_del(&port_dev->dev); 205 ida_free(&ctrl_dev->port_ida, port_dev->port->port_id); 206 put_device(&port_dev->dev); 207 } 208 209 #ifdef CONFIG_SERIAL_CORE_CONSOLE 210 211 /** 212 * serial_base_match_and_update_preferred_console - Match and update a preferred console 213 * @drv: Serial port device driver 214 * @port: Serial port instance 215 * 216 * Tries to match and update the preferred console for a serial port for 217 * the kernel command line option console=DEVNAME:0.0. 218 * 219 * Cannot be called early for ISA ports, depends on struct device. 220 * 221 * Return: 0 on success, negative error code on failure. 222 */ 223 int serial_base_match_and_update_preferred_console(struct uart_driver *drv, 224 struct uart_port *port) 225 { 226 const char *port_match __free(kfree) = NULL; 227 int ret; 228 229 port_match = kasprintf(GFP_KERNEL, "%s:%d.%d", dev_name(port->dev), 230 port->ctrl_id, port->port_id); 231 if (!port_match) 232 return -ENOMEM; 233 234 ret = match_devname_and_update_preferred_console(port_match, 235 drv->dev_name, 236 port->line); 237 if (ret == -ENOENT) 238 return 0; 239 240 return ret; 241 } 242 243 #endif 244 245 static int serial_base_init(void) 246 { 247 int ret; 248 249 ret = bus_register(&serial_base_bus_type); 250 if (ret) 251 return ret; 252 253 ret = serial_base_ctrl_init(); 254 if (ret) 255 goto err_bus_unregister; 256 257 ret = serial_base_port_init(); 258 if (ret) 259 goto err_ctrl_exit; 260 261 serial_base_initialized = true; 262 263 return 0; 264 265 err_ctrl_exit: 266 serial_base_ctrl_exit(); 267 268 err_bus_unregister: 269 bus_unregister(&serial_base_bus_type); 270 271 return ret; 272 } 273 arch_initcall(serial_base_init); 274 275 static void serial_base_exit(void) 276 { 277 serial_base_port_exit(); 278 serial_base_ctrl_exit(); 279 bus_unregister(&serial_base_bus_type); 280 } 281 module_exit(serial_base_exit); 282 283 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>"); 284 MODULE_DESCRIPTION("Serial core bus"); 285 MODULE_LICENSE("GPL"); 286