1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Serial core port device driver 4 * 5 * Copyright (C) 2023 Texas Instruments Incorporated - https://www.ti.com/ 6 * Author: Tony Lindgren <tony@atomide.com> 7 */ 8 9 #include <linux/device.h> 10 #include <linux/module.h> 11 #include <linux/of.h> 12 #include <linux/platform_device.h> 13 #include <linux/pm_runtime.h> 14 #include <linux/pnp.h> 15 #include <linux/property.h> 16 #include <linux/serial_core.h> 17 #include <linux/spinlock.h> 18 19 #include "serial_base.h" 20 21 #define SERIAL_PORT_AUTOSUSPEND_DELAY_MS 500 22 23 /* Only considers pending TX for now. Caller must take care of locking */ 24 static int __serial_port_busy(struct uart_port *port) 25 { 26 return !uart_tx_stopped(port) && 27 !kfifo_is_empty(&port->state->port.xmit_fifo); 28 } 29 30 static int serial_port_runtime_resume(struct device *dev) 31 { 32 struct serial_port_device *port_dev = to_serial_base_port_device(dev); 33 struct uart_port *port; 34 unsigned long flags; 35 36 port = port_dev->port; 37 38 if (port->flags & UPF_DEAD) 39 goto out; 40 41 /* Flush any pending TX for the port */ 42 uart_port_lock_irqsave(port, &flags); 43 if (!port_dev->tx_enabled) 44 goto unlock; 45 if (__serial_port_busy(port)) 46 port->ops->start_tx(port); 47 48 unlock: 49 uart_port_unlock_irqrestore(port, flags); 50 51 out: 52 pm_runtime_mark_last_busy(dev); 53 54 return 0; 55 } 56 57 static int serial_port_runtime_suspend(struct device *dev) 58 { 59 struct serial_port_device *port_dev = to_serial_base_port_device(dev); 60 struct uart_port *port = port_dev->port; 61 unsigned long flags; 62 bool busy; 63 64 if (port->flags & UPF_DEAD) 65 return 0; 66 67 /* 68 * Nothing to do on pm_runtime_force_suspend(), see 69 * DEFINE_RUNTIME_DEV_PM_OPS. 70 */ 71 if (!pm_runtime_enabled(dev)) 72 return 0; 73 74 uart_port_lock_irqsave(port, &flags); 75 if (!port_dev->tx_enabled) { 76 uart_port_unlock_irqrestore(port, flags); 77 return 0; 78 } 79 80 busy = __serial_port_busy(port); 81 if (busy) 82 port->ops->start_tx(port); 83 uart_port_unlock_irqrestore(port, flags); 84 85 if (busy) 86 pm_runtime_mark_last_busy(dev); 87 88 return busy ? -EBUSY : 0; 89 } 90 91 static void serial_base_port_set_tx(struct uart_port *port, 92 struct serial_port_device *port_dev, 93 bool enabled) 94 { 95 unsigned long flags; 96 97 uart_port_lock_irqsave(port, &flags); 98 port_dev->tx_enabled = enabled; 99 uart_port_unlock_irqrestore(port, flags); 100 } 101 102 void serial_base_port_startup(struct uart_port *port) 103 { 104 struct serial_port_device *port_dev = port->port_dev; 105 106 serial_base_port_set_tx(port, port_dev, true); 107 } 108 109 void serial_base_port_shutdown(struct uart_port *port) 110 { 111 struct serial_port_device *port_dev = port->port_dev; 112 113 serial_base_port_set_tx(port, port_dev, false); 114 } 115 116 static DEFINE_RUNTIME_DEV_PM_OPS(serial_port_pm, 117 serial_port_runtime_suspend, 118 serial_port_runtime_resume, NULL); 119 120 static int serial_port_probe(struct device *dev) 121 { 122 pm_runtime_enable(dev); 123 pm_runtime_set_autosuspend_delay(dev, SERIAL_PORT_AUTOSUSPEND_DELAY_MS); 124 pm_runtime_use_autosuspend(dev); 125 126 return 0; 127 } 128 129 static int serial_port_remove(struct device *dev) 130 { 131 pm_runtime_dont_use_autosuspend(dev); 132 pm_runtime_disable(dev); 133 134 return 0; 135 } 136 137 /* 138 * Serial core port device init functions. Note that the physical serial 139 * port device driver may not have completed probe at this point. 140 */ 141 int uart_add_one_port(struct uart_driver *drv, struct uart_port *port) 142 { 143 return serial_ctrl_register_port(drv, port); 144 } 145 EXPORT_SYMBOL(uart_add_one_port); 146 147 void uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) 148 { 149 serial_ctrl_unregister_port(drv, port); 150 } 151 EXPORT_SYMBOL(uart_remove_one_port); 152 153 /** 154 * __uart_read_properties - read firmware properties of the given UART port 155 * @port: corresponding port 156 * @use_defaults: apply defaults (when %true) or validate the values (when %false) 157 * 158 * The following device properties are supported: 159 * - clock-frequency (optional) 160 * - fifo-size (optional) 161 * - no-loopback-test (optional) 162 * - reg-shift (defaults may apply) 163 * - reg-offset (value may be validated) 164 * - reg-io-width (defaults may apply or value may be validated) 165 * - interrupts (OF only) 166 * - serial [alias ID] (OF only) 167 * 168 * If the port->dev is of struct platform_device type the interrupt line 169 * will be retrieved via platform_get_irq() call against that device. 170 * Otherwise it will be assigned by fwnode_irq_get() call. In both cases 171 * the index 0 of the resource is used. 172 * 173 * The caller is responsible to initialize the following fields of the @port 174 * ->dev (must be valid) 175 * ->flags 176 * ->iobase 177 * ->mapbase 178 * ->mapsize 179 * ->regshift (if @use_defaults is false) 180 * before calling this function. Alternatively the above mentioned fields 181 * may be zeroed, in such case the only ones, that have associated properties 182 * found, will be set to the respective values. 183 * 184 * If no error happened, the ->irq, ->mapbase, ->mapsize will be altered. 185 * The ->iotype is always altered. 186 * 187 * When @use_defaults is true and the respective property is not found 188 * the following values will be applied: 189 * ->regshift = 0 190 * In this case IRQ must be provided, otherwise an error will be returned. 191 * 192 * When @use_defaults is false and the respective property is found 193 * the following values will be validated: 194 * - reg-io-width (->iotype) 195 * - reg-offset (->mapsize against ->mapbase) 196 * 197 * Returns: 0 on success or negative errno on failure 198 */ 199 static int __uart_read_properties(struct uart_port *port, bool use_defaults) 200 { 201 struct device *dev = port->dev; 202 u32 value; 203 int ret; 204 205 /* Read optional UART functional clock frequency */ 206 device_property_read_u32(dev, "clock-frequency", &port->uartclk); 207 208 /* Read the registers alignment (default: 8-bit) */ 209 ret = device_property_read_u32(dev, "reg-shift", &value); 210 if (ret) 211 port->regshift = use_defaults ? 0 : port->regshift; 212 else 213 port->regshift = value; 214 215 /* Read the registers I/O access type (default: MMIO 8-bit) */ 216 ret = device_property_read_u32(dev, "reg-io-width", &value); 217 if (ret) { 218 port->iotype = port->iobase ? UPIO_PORT : UPIO_MEM; 219 } else { 220 switch (value) { 221 case 1: 222 port->iotype = UPIO_MEM; 223 break; 224 case 2: 225 port->iotype = UPIO_MEM16; 226 break; 227 case 4: 228 port->iotype = device_is_big_endian(dev) ? UPIO_MEM32BE : UPIO_MEM32; 229 break; 230 default: 231 port->iotype = UPIO_UNKNOWN; 232 break; 233 } 234 } 235 236 if (!use_defaults && port->iotype == UPIO_UNKNOWN) { 237 dev_err(dev, "Unsupported reg-io-width (%u)\n", value); 238 return -EINVAL; 239 } 240 241 /* Read the address mapping base offset (default: no offset) */ 242 ret = device_property_read_u32(dev, "reg-offset", &value); 243 if (ret) 244 value = 0; 245 246 /* Check for shifted address mapping overflow */ 247 if (!use_defaults && port->mapsize < value) { 248 dev_err(dev, "reg-offset %u exceeds region size %pa\n", value, &port->mapsize); 249 return -EINVAL; 250 } 251 252 port->mapbase += value; 253 port->mapsize -= value; 254 255 /* Read optional FIFO size */ 256 device_property_read_u32(dev, "fifo-size", &port->fifosize); 257 258 if (device_property_read_bool(dev, "no-loopback-test")) 259 port->flags |= UPF_SKIP_TEST; 260 261 /* Get index of serial line, if found in DT aliases */ 262 ret = of_alias_get_id(dev_of_node(dev), "serial"); 263 if (ret >= 0) 264 port->line = ret; 265 266 if (dev_is_platform(dev)) 267 ret = platform_get_irq(to_platform_device(dev), 0); 268 else if (dev_is_pnp(dev)) { 269 ret = pnp_irq(to_pnp_dev(dev), 0); 270 if (ret < 0) 271 ret = -ENXIO; 272 } else 273 ret = fwnode_irq_get(dev_fwnode(dev), 0); 274 if (ret == -EPROBE_DEFER) 275 return ret; 276 if (ret > 0) 277 port->irq = ret; 278 else if (use_defaults) 279 /* By default IRQ support is mandatory */ 280 return ret; 281 else 282 port->irq = 0; 283 284 port->flags |= UPF_SHARE_IRQ; 285 286 return 0; 287 } 288 289 int uart_read_port_properties(struct uart_port *port) 290 { 291 return __uart_read_properties(port, true); 292 } 293 EXPORT_SYMBOL_GPL(uart_read_port_properties); 294 295 int uart_read_and_validate_port_properties(struct uart_port *port) 296 { 297 return __uart_read_properties(port, false); 298 } 299 EXPORT_SYMBOL_GPL(uart_read_and_validate_port_properties); 300 301 static struct device_driver serial_port_driver = { 302 .name = "port", 303 .suppress_bind_attrs = true, 304 .probe = serial_port_probe, 305 .remove = serial_port_remove, 306 .pm = pm_ptr(&serial_port_pm), 307 }; 308 309 int serial_base_port_init(void) 310 { 311 return serial_base_driver_register(&serial_port_driver); 312 } 313 314 void serial_base_port_exit(void) 315 { 316 serial_base_driver_unregister(&serial_port_driver); 317 } 318 319 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>"); 320 MODULE_DESCRIPTION("Serial controller port driver"); 321 MODULE_LICENSE("GPL"); 322