1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Serial Port driver for Aspeed VUART device 4 * 5 * Copyright (C) 2016 Jeremy Kerr <jk@ozlabs.org>, IBM Corp. 6 * Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>, IBM Corp. 7 */ 8 #include <linux/device.h> 9 #include <linux/module.h> 10 #include <linux/of_address.h> 11 #include <linux/of_irq.h> 12 #include <linux/of_platform.h> 13 #include <linux/regmap.h> 14 #include <linux/mfd/syscon.h> 15 #include <linux/tty.h> 16 #include <linux/tty_flip.h> 17 #include <linux/clk.h> 18 19 #include "8250.h" 20 21 #define ASPEED_VUART_GCRA 0x20 22 #define ASPEED_VUART_GCRA_VUART_EN BIT(0) 23 #define ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY BIT(1) 24 #define ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD BIT(5) 25 #define ASPEED_VUART_GCRB 0x24 26 #define ASPEED_VUART_GCRB_HOST_SIRQ_MASK GENMASK(7, 4) 27 #define ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT 4 28 #define ASPEED_VUART_ADDRL 0x28 29 #define ASPEED_VUART_ADDRH 0x2c 30 31 #define ASPEED_VUART_DEFAULT_LPC_ADDR 0x3f8 32 #define ASPEED_VUART_DEFAULT_SIRQ 4 33 #define ASPEED_VUART_DEFAULT_SIRQ_POLARITY IRQ_TYPE_LEVEL_LOW 34 35 struct aspeed_vuart { 36 struct device *dev; 37 int line; 38 struct timer_list unthrottle_timer; 39 struct uart_8250_port *port; 40 }; 41 42 /* 43 * If we fill the tty flip buffers, we throttle the data ready interrupt 44 * to prevent dropped characters. This timeout defines how long we wait 45 * to (conditionally, depending on buffer state) unthrottle. 46 */ 47 static const int unthrottle_timeout = HZ/10; 48 49 /* 50 * The VUART is basically two UART 'front ends' connected by their FIFO 51 * (no actual serial line in between). One is on the BMC side (management 52 * controller) and one is on the host CPU side. 53 * 54 * It allows the BMC to provide to the host a "UART" that pipes into 55 * the BMC itself and can then be turned by the BMC into a network console 56 * of some sort for example. 57 * 58 * This driver is for the BMC side. The sysfs files allow the BMC 59 * userspace which owns the system configuration policy, to specify 60 * at what IO port and interrupt number the host side will appear 61 * to the host on the Host <-> BMC LPC bus. It could be different on a 62 * different system (though most of them use 3f8/4). 63 */ 64 65 static inline u8 aspeed_vuart_readb(struct aspeed_vuart *vuart, u8 reg) 66 { 67 return readb(vuart->port->port.membase + reg); 68 } 69 70 static inline void aspeed_vuart_writeb(struct aspeed_vuart *vuart, u8 val, u8 reg) 71 { 72 writeb(val, vuart->port->port.membase + reg); 73 } 74 75 static ssize_t lpc_address_show(struct device *dev, 76 struct device_attribute *attr, char *buf) 77 { 78 struct aspeed_vuart *vuart = dev_get_drvdata(dev); 79 u16 addr; 80 81 addr = (aspeed_vuart_readb(vuart, ASPEED_VUART_ADDRH) << 8) | 82 (aspeed_vuart_readb(vuart, ASPEED_VUART_ADDRL)); 83 84 return sysfs_emit(buf, "0x%x\n", addr); 85 } 86 87 static int aspeed_vuart_set_lpc_address(struct aspeed_vuart *vuart, u32 addr) 88 { 89 if (addr > U16_MAX) 90 return -EINVAL; 91 92 aspeed_vuart_writeb(vuart, addr >> 8, ASPEED_VUART_ADDRH); 93 aspeed_vuart_writeb(vuart, addr >> 0, ASPEED_VUART_ADDRL); 94 95 return 0; 96 } 97 98 static ssize_t lpc_address_store(struct device *dev, 99 struct device_attribute *attr, 100 const char *buf, size_t count) 101 { 102 struct aspeed_vuart *vuart = dev_get_drvdata(dev); 103 u32 val; 104 int err; 105 106 err = kstrtou32(buf, 0, &val); 107 if (err) 108 return err; 109 110 err = aspeed_vuart_set_lpc_address(vuart, val); 111 return err ? : count; 112 } 113 114 static DEVICE_ATTR_RW(lpc_address); 115 116 static ssize_t sirq_show(struct device *dev, 117 struct device_attribute *attr, char *buf) 118 { 119 struct aspeed_vuart *vuart = dev_get_drvdata(dev); 120 u8 reg; 121 122 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRB); 123 reg &= ASPEED_VUART_GCRB_HOST_SIRQ_MASK; 124 reg >>= ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT; 125 126 return sysfs_emit(buf, "%u\n", reg); 127 } 128 129 static int aspeed_vuart_set_sirq(struct aspeed_vuart *vuart, u32 sirq) 130 { 131 u8 reg; 132 133 if (sirq > (ASPEED_VUART_GCRB_HOST_SIRQ_MASK >> ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT)) 134 return -EINVAL; 135 136 sirq <<= ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT; 137 sirq &= ASPEED_VUART_GCRB_HOST_SIRQ_MASK; 138 139 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRB); 140 reg &= ~ASPEED_VUART_GCRB_HOST_SIRQ_MASK; 141 reg |= sirq; 142 aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRB); 143 144 return 0; 145 } 146 147 static ssize_t sirq_store(struct device *dev, struct device_attribute *attr, 148 const char *buf, size_t count) 149 { 150 struct aspeed_vuart *vuart = dev_get_drvdata(dev); 151 unsigned long val; 152 int err; 153 154 err = kstrtoul(buf, 0, &val); 155 if (err) 156 return err; 157 158 err = aspeed_vuart_set_sirq(vuart, val); 159 return err ? : count; 160 } 161 162 static DEVICE_ATTR_RW(sirq); 163 164 static ssize_t sirq_polarity_show(struct device *dev, 165 struct device_attribute *attr, char *buf) 166 { 167 struct aspeed_vuart *vuart = dev_get_drvdata(dev); 168 u8 reg; 169 170 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA); 171 reg &= ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY; 172 173 return sysfs_emit(buf, "%u\n", reg ? 1 : 0); 174 } 175 176 static void aspeed_vuart_set_sirq_polarity(struct aspeed_vuart *vuart, 177 bool polarity) 178 { 179 u8 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA); 180 181 if (polarity) 182 reg |= ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY; 183 else 184 reg &= ~ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY; 185 186 aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA); 187 } 188 189 static ssize_t sirq_polarity_store(struct device *dev, 190 struct device_attribute *attr, 191 const char *buf, size_t count) 192 { 193 struct aspeed_vuart *vuart = dev_get_drvdata(dev); 194 unsigned long val; 195 int err; 196 197 err = kstrtoul(buf, 0, &val); 198 if (err) 199 return err; 200 201 aspeed_vuart_set_sirq_polarity(vuart, val != 0); 202 203 return count; 204 } 205 206 static DEVICE_ATTR_RW(sirq_polarity); 207 208 static struct attribute *aspeed_vuart_attrs[] = { 209 &dev_attr_sirq.attr, 210 &dev_attr_sirq_polarity.attr, 211 &dev_attr_lpc_address.attr, 212 NULL, 213 }; 214 215 static const struct attribute_group aspeed_vuart_attr_group = { 216 .attrs = aspeed_vuart_attrs, 217 }; 218 219 static void aspeed_vuart_set_enabled(struct aspeed_vuart *vuart, bool enabled) 220 { 221 u8 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA); 222 223 if (enabled) 224 reg |= ASPEED_VUART_GCRA_VUART_EN; 225 else 226 reg &= ~ASPEED_VUART_GCRA_VUART_EN; 227 228 aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA); 229 } 230 231 static void aspeed_vuart_set_host_tx_discard(struct aspeed_vuart *vuart, 232 bool discard) 233 { 234 u8 reg; 235 236 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA); 237 238 /* If the DISABLE_HOST_TX_DISCARD bit is set, discard is disabled */ 239 if (!discard) 240 reg |= ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD; 241 else 242 reg &= ~ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD; 243 244 aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA); 245 } 246 247 static int aspeed_vuart_startup(struct uart_port *uart_port) 248 { 249 struct uart_8250_port *uart_8250_port = up_to_u8250p(uart_port); 250 struct aspeed_vuart *vuart = uart_8250_port->port.private_data; 251 int rc; 252 253 rc = serial8250_do_startup(uart_port); 254 if (rc) 255 return rc; 256 257 aspeed_vuart_set_host_tx_discard(vuart, false); 258 259 return 0; 260 } 261 262 static void aspeed_vuart_shutdown(struct uart_port *uart_port) 263 { 264 struct uart_8250_port *uart_8250_port = up_to_u8250p(uart_port); 265 struct aspeed_vuart *vuart = uart_8250_port->port.private_data; 266 267 aspeed_vuart_set_host_tx_discard(vuart, true); 268 269 serial8250_do_shutdown(uart_port); 270 } 271 272 static void __aspeed_vuart_set_throttle(struct uart_8250_port *up, 273 bool throttle) 274 { 275 unsigned char irqs = UART_IER_RLSI | UART_IER_RDI; 276 277 /* Port locked to synchronize UART_IER access against the console. */ 278 lockdep_assert_held_once(&up->port.lock); 279 280 up->ier &= ~irqs; 281 if (!throttle) 282 up->ier |= irqs; 283 serial_out(up, UART_IER, up->ier); 284 } 285 static void aspeed_vuart_set_throttle(struct uart_port *port, bool throttle) 286 { 287 struct uart_8250_port *up = up_to_u8250p(port); 288 unsigned long flags; 289 290 uart_port_lock_irqsave(port, &flags); 291 __aspeed_vuart_set_throttle(up, throttle); 292 uart_port_unlock_irqrestore(port, flags); 293 } 294 295 static void aspeed_vuart_throttle(struct uart_port *port) 296 { 297 aspeed_vuart_set_throttle(port, true); 298 } 299 300 static void aspeed_vuart_unthrottle(struct uart_port *port) 301 { 302 aspeed_vuart_set_throttle(port, false); 303 } 304 305 static void aspeed_vuart_unthrottle_exp(struct timer_list *timer) 306 { 307 struct aspeed_vuart *vuart = from_timer(vuart, timer, unthrottle_timer); 308 struct uart_8250_port *up = vuart->port; 309 310 if (!tty_buffer_space_avail(&up->port.state->port)) { 311 mod_timer(&vuart->unthrottle_timer, 312 jiffies + unthrottle_timeout); 313 return; 314 } 315 316 aspeed_vuart_unthrottle(&up->port); 317 } 318 319 /* 320 * Custom interrupt handler to manage finer-grained flow control. Although we 321 * have throttle/unthrottle callbacks, we've seen that the VUART device can 322 * deliver characters faster than the ldisc has a chance to check buffer space 323 * against the throttle threshold. This results in dropped characters before 324 * the throttle. 325 * 326 * We do this by checking for flip buffer space before RX. If we have no space, 327 * throttle now and schedule an unthrottle for later, once the ldisc has had 328 * a chance to drain the buffers. 329 */ 330 static int aspeed_vuart_handle_irq(struct uart_port *port) 331 { 332 struct uart_8250_port *up = up_to_u8250p(port); 333 unsigned int iir, lsr; 334 unsigned long flags; 335 unsigned int space, count; 336 337 iir = serial_port_in(port, UART_IIR); 338 339 if (iir & UART_IIR_NO_INT) 340 return 0; 341 342 uart_port_lock_irqsave(port, &flags); 343 344 lsr = serial_port_in(port, UART_LSR); 345 346 if (lsr & (UART_LSR_DR | UART_LSR_BI)) { 347 space = tty_buffer_space_avail(&port->state->port); 348 349 if (!space) { 350 /* throttle and schedule an unthrottle later */ 351 struct aspeed_vuart *vuart = port->private_data; 352 __aspeed_vuart_set_throttle(up, true); 353 354 if (!timer_pending(&vuart->unthrottle_timer)) 355 mod_timer(&vuart->unthrottle_timer, 356 jiffies + unthrottle_timeout); 357 358 } else { 359 count = min(space, 256U); 360 361 do { 362 serial8250_read_char(up, lsr); 363 lsr = serial_in(up, UART_LSR); 364 if (--count == 0) 365 break; 366 } while (lsr & (UART_LSR_DR | UART_LSR_BI)); 367 368 tty_flip_buffer_push(&port->state->port); 369 } 370 } 371 372 serial8250_modem_status(up); 373 if (lsr & UART_LSR_THRE) 374 serial8250_tx_chars(up); 375 376 uart_unlock_and_check_sysrq_irqrestore(port, flags); 377 378 return 1; 379 } 380 381 static void aspeed_vuart_auto_configure_sirq_polarity( 382 struct aspeed_vuart *vuart, struct device_node *syscon_np, 383 u32 reg_offset, u32 reg_mask) 384 { 385 struct regmap *regmap; 386 u32 value; 387 388 regmap = syscon_node_to_regmap(syscon_np); 389 if (IS_ERR(regmap)) { 390 dev_warn(vuart->dev, 391 "could not get regmap for aspeed,sirq-polarity-sense\n"); 392 return; 393 } 394 if (regmap_read(regmap, reg_offset, &value)) { 395 dev_warn(vuart->dev, "could not read hw strap table\n"); 396 return; 397 } 398 399 aspeed_vuart_set_sirq_polarity(vuart, (value & reg_mask) == 0); 400 } 401 402 static int aspeed_vuart_map_irq_polarity(u32 dt) 403 { 404 switch (dt) { 405 case IRQ_TYPE_LEVEL_LOW: 406 return 0; 407 case IRQ_TYPE_LEVEL_HIGH: 408 return 1; 409 default: 410 return -EINVAL; 411 } 412 } 413 414 static int aspeed_vuart_probe(struct platform_device *pdev) 415 { 416 struct of_phandle_args sirq_polarity_sense_args; 417 struct device *dev = &pdev->dev; 418 struct uart_8250_port port; 419 struct aspeed_vuart *vuart; 420 struct device_node *np; 421 struct resource *res; 422 int rc, sirq_polarity; 423 u32 prop, sirq[2]; 424 struct clk *vclk; 425 426 np = pdev->dev.of_node; 427 428 vuart = devm_kzalloc(&pdev->dev, sizeof(*vuart), GFP_KERNEL); 429 if (!vuart) 430 return -ENOMEM; 431 432 vuart->dev = &pdev->dev; 433 timer_setup(&vuart->unthrottle_timer, aspeed_vuart_unthrottle_exp, 0); 434 435 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 436 if (!res) 437 return -EINVAL; 438 439 memset(&port, 0, sizeof(port)); 440 port.port.private_data = vuart; 441 port.port.mapbase = res->start; 442 port.port.mapsize = resource_size(res); 443 port.port.startup = aspeed_vuart_startup; 444 port.port.shutdown = aspeed_vuart_shutdown; 445 port.port.throttle = aspeed_vuart_throttle; 446 port.port.unthrottle = aspeed_vuart_unthrottle; 447 port.port.status = UPSTAT_SYNC_FIFO; 448 port.port.dev = &pdev->dev; 449 port.port.has_sysrq = IS_ENABLED(CONFIG_SERIAL_8250_CONSOLE); 450 port.port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP | UPF_FIXED_PORT | UPF_FIXED_TYPE | 451 UPF_NO_THRE_TEST; 452 port.bugs |= UART_BUG_TXRACE; 453 454 rc = sysfs_create_group(&vuart->dev->kobj, &aspeed_vuart_attr_group); 455 if (rc < 0) 456 return rc; 457 458 rc = uart_read_port_properties(&port.port); 459 if (rc) 460 goto err_sysfs_remove; 461 462 /* Get clk rate through clk driver if present */ 463 if (!port.port.uartclk) { 464 vclk = devm_clk_get_enabled(dev, NULL); 465 if (IS_ERR(vclk)) { 466 rc = dev_err_probe(dev, PTR_ERR(vclk), "clk or clock-frequency not defined\n"); 467 goto err_sysfs_remove; 468 } 469 470 port.port.uartclk = clk_get_rate(vclk); 471 } 472 473 /* If current-speed was set, then try not to change it. */ 474 if (of_property_read_u32(np, "current-speed", &prop) == 0) 475 port.port.custom_divisor = port.port.uartclk / (16 * prop); 476 477 port.port.handle_irq = aspeed_vuart_handle_irq; 478 port.port.type = PORT_ASPEED_VUART; 479 480 if (port.port.fifosize) 481 port.capabilities = UART_CAP_FIFO; 482 483 if (of_property_read_bool(np, "auto-flow-control")) 484 port.capabilities |= UART_CAP_AFE; 485 486 rc = serial8250_register_8250_port(&port); 487 if (rc < 0) 488 goto err_sysfs_remove; 489 490 vuart->line = rc; 491 vuart->port = serial8250_get_port(vuart->line); 492 493 rc = of_parse_phandle_with_fixed_args( 494 np, "aspeed,sirq-polarity-sense", 2, 0, 495 &sirq_polarity_sense_args); 496 if (rc < 0) { 497 dev_dbg(&pdev->dev, 498 "aspeed,sirq-polarity-sense property not found\n"); 499 } else { 500 aspeed_vuart_auto_configure_sirq_polarity( 501 vuart, sirq_polarity_sense_args.np, 502 sirq_polarity_sense_args.args[0], 503 BIT(sirq_polarity_sense_args.args[1])); 504 of_node_put(sirq_polarity_sense_args.np); 505 } 506 507 rc = of_property_read_u32(np, "aspeed,lpc-io-reg", &prop); 508 if (rc < 0) 509 prop = ASPEED_VUART_DEFAULT_LPC_ADDR; 510 511 rc = aspeed_vuart_set_lpc_address(vuart, prop); 512 if (rc < 0) { 513 dev_err_probe(dev, rc, "invalid value in aspeed,lpc-io-reg property\n"); 514 goto err_sysfs_remove; 515 } 516 517 rc = of_property_read_u32_array(np, "aspeed,lpc-interrupts", sirq, 2); 518 if (rc < 0) { 519 sirq[0] = ASPEED_VUART_DEFAULT_SIRQ; 520 sirq[1] = ASPEED_VUART_DEFAULT_SIRQ_POLARITY; 521 } 522 523 rc = aspeed_vuart_set_sirq(vuart, sirq[0]); 524 if (rc < 0) { 525 dev_err_probe(dev, rc, "invalid sirq number in aspeed,lpc-interrupts property\n"); 526 goto err_sysfs_remove; 527 } 528 529 sirq_polarity = aspeed_vuart_map_irq_polarity(sirq[1]); 530 if (sirq_polarity < 0) { 531 rc = dev_err_probe(dev, sirq_polarity, 532 "invalid sirq polarity in aspeed,lpc-interrupts property\n"); 533 goto err_sysfs_remove; 534 } 535 536 aspeed_vuart_set_sirq_polarity(vuart, sirq_polarity); 537 538 aspeed_vuart_set_enabled(vuart, true); 539 aspeed_vuart_set_host_tx_discard(vuart, true); 540 platform_set_drvdata(pdev, vuart); 541 542 return 0; 543 544 err_sysfs_remove: 545 sysfs_remove_group(&vuart->dev->kobj, &aspeed_vuart_attr_group); 546 return rc; 547 } 548 549 static void aspeed_vuart_remove(struct platform_device *pdev) 550 { 551 struct aspeed_vuart *vuart = platform_get_drvdata(pdev); 552 553 del_timer_sync(&vuart->unthrottle_timer); 554 aspeed_vuart_set_enabled(vuart, false); 555 serial8250_unregister_port(vuart->line); 556 sysfs_remove_group(&vuart->dev->kobj, &aspeed_vuart_attr_group); 557 } 558 559 static const struct of_device_id aspeed_vuart_table[] = { 560 { .compatible = "aspeed,ast2400-vuart" }, 561 { .compatible = "aspeed,ast2500-vuart" }, 562 { }, 563 }; 564 MODULE_DEVICE_TABLE(of, aspeed_vuart_table); 565 566 static struct platform_driver aspeed_vuart_driver = { 567 .driver = { 568 .name = "aspeed-vuart", 569 .of_match_table = aspeed_vuart_table, 570 }, 571 .probe = aspeed_vuart_probe, 572 .remove = aspeed_vuart_remove, 573 }; 574 575 module_platform_driver(aspeed_vuart_driver); 576 577 MODULE_AUTHOR("Jeremy Kerr <jk@ozlabs.org>"); 578 MODULE_LICENSE("GPL"); 579 MODULE_DESCRIPTION("Driver for Aspeed VUART device"); 580