1// SPDX-License-Identifier: GPL-2.0+ 2/* 3** mux.c: 4** serial driver for the Mux console found in some PA-RISC servers. 5** 6** (c) Copyright 2002 Ryan Bradetich 7** (c) Copyright 2002 Hewlett-Packard Company 8** 9** This Driver currently only supports the console (port 0) on the MUX. 10** Additional work will be needed on this driver to enable the full 11** functionality of the MUX. 12** 13*/ 14 15#include <linux/module.h> 16#include <linux/ioport.h> 17#include <linux/init.h> 18#include <linux/serial.h> 19#include <linux/tty.h> 20#include <linux/tty_flip.h> 21#include <linux/console.h> 22#include <linux/delay.h> /* for udelay */ 23#include <linux/device.h> 24#include <linux/io.h> 25#include <asm/irq.h> 26#include <asm/parisc-device.h> 27 28#include <linux/sysrq.h> 29#include <linux/serial_core.h> 30 31#define MUX_OFFSET 0x800 32#define MUX_LINE_OFFSET 0x80 33 34#define MUX_FIFO_SIZE 255 35#define MUX_POLL_DELAY (30 * HZ / 1000) 36 37#define IO_DATA_REG_OFFSET 0x3c 38#define IO_DCOUNT_REG_OFFSET 0x40 39 40#define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000) 41#define MUX_STATUS(status) ((status & 0xF000) == 0x8000) 42#define MUX_BREAK(status) ((status & 0xF000) == 0x2000) 43 44#define MUX_NR 256 45static unsigned int port_cnt __read_mostly; 46struct mux_port { 47 struct uart_port port; 48 int enabled; 49}; 50static struct mux_port mux_ports[MUX_NR]; 51 52static struct uart_driver mux_driver = { 53 .owner = THIS_MODULE, 54 .driver_name = "ttyB", 55 .dev_name = "ttyB", 56 .major = MUX_MAJOR, 57 .minor = 0, 58 .nr = MUX_NR, 59}; 60 61static struct timer_list mux_timer; 62 63#define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET) 64#define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET) 65 66/** 67 * get_mux_port_count - Get the number of available ports on the Mux. 68 * @dev: The parisc device. 69 * 70 * This function is used to determine the number of ports the Mux 71 * supports. The IODC data reports the number of ports the Mux 72 * can support, but there are cases where not all the Mux ports 73 * are connected. This function can override the IODC and 74 * return the true port count. 75 */ 76static int __init get_mux_port_count(struct parisc_device *dev) 77{ 78 int status; 79 u8 iodc_data[32]; 80 unsigned long bytecnt; 81 82 /* If this is the built-in Mux for the K-Class (Eole CAP/MUX), 83 * we only need to allocate resources for 1 port since the 84 * other 7 ports are not connected. 85 */ 86 if(dev->id.hversion == 0x15) 87 return 1; 88 89 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32); 90 BUG_ON(status != PDC_OK); 91 92 /* Return the number of ports specified in the iodc data. */ 93 return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8; 94} 95 96/** 97 * mux_tx_empty - Check if the transmitter fifo is empty. 98 * @port: Ptr to the uart_port. 99 * 100 * This function test if the transmitter fifo for the port 101 * described by 'port' is empty. If it is empty, this function 102 * should return TIOCSER_TEMT, otherwise return 0. 103 */ 104static unsigned int mux_tx_empty(struct uart_port *port) 105{ 106 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT; 107} 108 109/** 110 * mux_set_mctrl - Set the current state of the modem control inputs. 111 * @ports: Ptr to the uart_port. 112 * @mctrl: Modem control bits. 113 * 114 * The Serial MUX does not support CTS, DCD or DSR so this function 115 * is ignored. 116 */ 117static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl) 118{ 119} 120 121/** 122 * mux_get_mctrl - Returns the current state of modem control inputs. 123 * @port: Ptr to the uart_port. 124 * 125 * The Serial MUX does not support CTS, DCD or DSR so these lines are 126 * treated as permanently active. 127 */ 128static unsigned int mux_get_mctrl(struct uart_port *port) 129{ 130 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS; 131} 132 133/** 134 * mux_stop_tx - Stop transmitting characters. 135 * @port: Ptr to the uart_port. 136 * 137 * The Serial MUX does not support this function. 138 */ 139static void mux_stop_tx(struct uart_port *port) 140{ 141} 142 143/** 144 * mux_start_tx - Start transmitting characters. 145 * @port: Ptr to the uart_port. 146 * 147 * The Serial Mux does not support this function. 148 */ 149static void mux_start_tx(struct uart_port *port) 150{ 151} 152 153/** 154 * mux_stop_rx - Stop receiving characters. 155 * @port: Ptr to the uart_port. 156 * 157 * The Serial Mux does not support this function. 158 */ 159static void mux_stop_rx(struct uart_port *port) 160{ 161} 162 163/** 164 * mux_break_ctl - Control the transmitssion of a break signal. 165 * @port: Ptr to the uart_port. 166 * @break_state: Raise/Lower the break signal. 167 * 168 * The Serial Mux does not support this function. 169 */ 170static void mux_break_ctl(struct uart_port *port, int break_state) 171{ 172} 173 174static void mux_tx_done(struct uart_port *port) 175{ 176 /* FIXME js: really needs to wait? */ 177 while (UART_GET_FIFO_CNT(port)) 178 udelay(1); 179} 180 181/** 182 * mux_write - Write chars to the mux fifo. 183 * @port: Ptr to the uart_port. 184 * 185 * This function writes all the data from the uart buffer to 186 * the mux fifo. 187 */ 188static void mux_write(struct uart_port *port) 189{ 190 u8 ch; 191 192 uart_port_tx_limited(port, ch, 193 port->fifosize - UART_GET_FIFO_CNT(port), 194 true, 195 UART_PUT_CHAR(port, ch), 196 mux_tx_done(port)); 197} 198 199/** 200 * mux_read - Read chars from the mux fifo. 201 * @port: Ptr to the uart_port. 202 * 203 * This reads all available data from the mux's fifo and pushes 204 * the data to the tty layer. 205 */ 206static void mux_read(struct uart_port *port) 207{ 208 struct tty_port *tport = &port->state->port; 209 int data; 210 __u32 start_count = port->icount.rx; 211 212 while(1) { 213 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET); 214 215 if (MUX_STATUS(data)) 216 continue; 217 218 if (MUX_EOFIFO(data)) 219 break; 220 221 port->icount.rx++; 222 223 if (MUX_BREAK(data)) { 224 port->icount.brk++; 225 if(uart_handle_break(port)) 226 continue; 227 } 228 229 if (uart_handle_sysrq_char(port, data & 0xffu)) 230 continue; 231 232 tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL); 233 } 234 235 if (start_count != port->icount.rx) 236 tty_flip_buffer_push(tport); 237} 238 239/** 240 * mux_startup - Initialize the port. 241 * @port: Ptr to the uart_port. 242 * 243 * Grab any resources needed for this port and start the 244 * mux timer. 245 */ 246static int mux_startup(struct uart_port *port) 247{ 248 mux_ports[port->line].enabled = 1; 249 return 0; 250} 251 252/** 253 * mux_shutdown - Disable the port. 254 * @port: Ptr to the uart_port. 255 * 256 * Release any resources needed for the port. 257 */ 258static void mux_shutdown(struct uart_port *port) 259{ 260 mux_ports[port->line].enabled = 0; 261} 262 263/** 264 * mux_set_termios - Chane port parameters. 265 * @port: Ptr to the uart_port. 266 * @termios: new termios settings. 267 * @old: old termios settings. 268 * 269 * The Serial Mux does not support this function. 270 */ 271static void 272mux_set_termios(struct uart_port *port, struct ktermios *termios, 273 const struct ktermios *old) 274{ 275} 276 277/** 278 * mux_type - Describe the port. 279 * @port: Ptr to the uart_port. 280 * 281 * Return a pointer to a string constant describing the 282 * specified port. 283 */ 284static const char *mux_type(struct uart_port *port) 285{ 286 return "Mux"; 287} 288 289/** 290 * mux_release_port - Release memory and IO regions. 291 * @port: Ptr to the uart_port. 292 * 293 * Release any memory and IO region resources currently in use by 294 * the port. 295 */ 296static void mux_release_port(struct uart_port *port) 297{ 298} 299 300/** 301 * mux_request_port - Request memory and IO regions. 302 * @port: Ptr to the uart_port. 303 * 304 * Request any memory and IO region resources required by the port. 305 * If any fail, no resources should be registered when this function 306 * returns, and it should return -EBUSY on failure. 307 */ 308static int mux_request_port(struct uart_port *port) 309{ 310 return 0; 311} 312 313/** 314 * mux_config_port - Perform port autoconfiguration. 315 * @port: Ptr to the uart_port. 316 * @type: Bitmask of required configurations. 317 * 318 * Perform any autoconfiguration steps for the port. This function is 319 * called if the UPF_BOOT_AUTOCONF flag is specified for the port. 320 * [Note: This is required for now because of a bug in the Serial core. 321 * rmk has already submitted a patch to linus, should be available for 322 * 2.5.47.] 323 */ 324static void mux_config_port(struct uart_port *port, int type) 325{ 326 port->type = PORT_MUX; 327} 328 329/** 330 * mux_verify_port - Verify the port information. 331 * @port: Ptr to the uart_port. 332 * @ser: Ptr to the serial information. 333 * 334 * Verify the new serial port information contained within serinfo is 335 * suitable for this port type. 336 */ 337static int mux_verify_port(struct uart_port *port, struct serial_struct *ser) 338{ 339 if(port->membase == NULL) 340 return -EINVAL; 341 342 return 0; 343} 344 345/** 346 * mux_drv_poll - Mux poll function. 347 * @unused: Unused variable 348 * 349 * This function periodically polls the Serial MUX to check for new data. 350 */ 351static void mux_poll(struct timer_list *unused) 352{ 353 int i; 354 355 for(i = 0; i < port_cnt; ++i) { 356 if(!mux_ports[i].enabled) 357 continue; 358 359 mux_read(&mux_ports[i].port); 360 mux_write(&mux_ports[i].port); 361 } 362 363 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY); 364} 365 366 367#ifdef CONFIG_SERIAL_MUX_CONSOLE 368static void mux_console_write(struct console *co, const char *s, unsigned count) 369{ 370 /* Wait until the FIFO drains. */ 371 while(UART_GET_FIFO_CNT(&mux_ports[0].port)) 372 udelay(1); 373 374 while(count--) { 375 if(*s == '\n') { 376 UART_PUT_CHAR(&mux_ports[0].port, '\r'); 377 } 378 UART_PUT_CHAR(&mux_ports[0].port, *s++); 379 } 380 381} 382 383static int mux_console_setup(struct console *co, char *options) 384{ 385 return 0; 386} 387 388static struct console mux_console = { 389 .name = "ttyB", 390 .write = mux_console_write, 391 .device = uart_console_device, 392 .setup = mux_console_setup, 393 .flags = CON_ENABLED | CON_PRINTBUFFER, 394 .index = 0, 395 .data = &mux_driver, 396}; 397 398#define MUX_CONSOLE &mux_console 399#else 400#define MUX_CONSOLE NULL 401#endif 402 403static const struct uart_ops mux_pops = { 404 .tx_empty = mux_tx_empty, 405 .set_mctrl = mux_set_mctrl, 406 .get_mctrl = mux_get_mctrl, 407 .stop_tx = mux_stop_tx, 408 .start_tx = mux_start_tx, 409 .stop_rx = mux_stop_rx, 410 .break_ctl = mux_break_ctl, 411 .startup = mux_startup, 412 .shutdown = mux_shutdown, 413 .set_termios = mux_set_termios, 414 .type = mux_type, 415 .release_port = mux_release_port, 416 .request_port = mux_request_port, 417 .config_port = mux_config_port, 418 .verify_port = mux_verify_port, 419}; 420 421/** 422 * mux_probe - Determine if the Serial Mux should claim this device. 423 * @dev: The parisc device. 424 * 425 * Deterimine if the Serial Mux should claim this chip (return 0) 426 * or not (return 1). 427 */ 428static int __init mux_probe(struct parisc_device *dev) 429{ 430 int i, status; 431 432 int port_count = get_mux_port_count(dev); 433 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count); 434 435 dev_set_drvdata(&dev->dev, (void *)(long)port_count); 436 request_mem_region(dev->hpa.start + MUX_OFFSET, 437 port_count * MUX_LINE_OFFSET, "Mux"); 438 439 if(!port_cnt) { 440 mux_driver.cons = MUX_CONSOLE; 441 442 status = uart_register_driver(&mux_driver); 443 if(status) { 444 printk(KERN_ERR "Serial mux: Unable to register driver.\n"); 445 return 1; 446 } 447 } 448 449 for(i = 0; i < port_count; ++i, ++port_cnt) { 450 struct uart_port *port = &mux_ports[port_cnt].port; 451 port->iobase = 0; 452 port->mapbase = dev->hpa.start + MUX_OFFSET + 453 (i * MUX_LINE_OFFSET); 454 port->membase = ioremap(port->mapbase, MUX_LINE_OFFSET); 455 port->iotype = UPIO_MEM; 456 port->type = PORT_MUX; 457 port->irq = 0; 458 port->uartclk = 0; 459 port->fifosize = MUX_FIFO_SIZE; 460 port->ops = &mux_pops; 461 port->flags = UPF_BOOT_AUTOCONF; 462 port->line = port_cnt; 463 port->has_sysrq = IS_ENABLED(CONFIG_SERIAL_MUX_CONSOLE); 464 465 spin_lock_init(&port->lock); 466 467 status = uart_add_one_port(&mux_driver, port); 468 BUG_ON(status); 469 } 470 471 return 0; 472} 473 474static void __exit mux_remove(struct parisc_device *dev) 475{ 476 int i, j; 477 int port_count = (long)dev_get_drvdata(&dev->dev); 478 479 /* Find Port 0 for this card in the mux_ports list. */ 480 for(i = 0; i < port_cnt; ++i) { 481 if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET) 482 break; 483 } 484 BUG_ON(i + port_count > port_cnt); 485 486 /* Release the resources associated with each port on the device. */ 487 for(j = 0; j < port_count; ++j, ++i) { 488 struct uart_port *port = &mux_ports[i].port; 489 490 uart_remove_one_port(&mux_driver, port); 491 if(port->membase) 492 iounmap(port->membase); 493 } 494 495 release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET); 496} 497 498/* Hack. This idea was taken from the 8250_gsc.c on how to properly order 499 * the serial port detection in the proper order. The idea is we always 500 * want the builtin mux to be detected before addin mux cards, so we 501 * specifically probe for the builtin mux cards first. 502 * 503 * This table only contains the parisc_device_id of known builtin mux 504 * devices. All other mux cards will be detected by the generic mux_tbl. 505 */ 506static const struct parisc_device_id builtin_mux_tbl[] __initconst = { 507 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */ 508 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */ 509 { 0, } 510}; 511 512static const struct parisc_device_id mux_tbl[] __initconst = { 513 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D }, 514 { 0, } 515}; 516 517MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl); 518MODULE_DEVICE_TABLE(parisc, mux_tbl); 519 520static struct parisc_driver builtin_serial_mux_driver __refdata = { 521 .name = "builtin_serial_mux", 522 .id_table = builtin_mux_tbl, 523 .probe = mux_probe, 524 .remove = __exit_p(mux_remove), 525}; 526 527static struct parisc_driver serial_mux_driver __refdata = { 528 .name = "serial_mux", 529 .id_table = mux_tbl, 530 .probe = mux_probe, 531 .remove = __exit_p(mux_remove), 532}; 533 534/** 535 * mux_init - Serial MUX initialization procedure. 536 * 537 * Register the Serial MUX driver. 538 */ 539static int __init mux_init(void) 540{ 541 register_parisc_driver(&builtin_serial_mux_driver); 542 register_parisc_driver(&serial_mux_driver); 543 544 if(port_cnt > 0) { 545 /* Start the Mux timer */ 546 timer_setup(&mux_timer, mux_poll, 0); 547 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY); 548 549#ifdef CONFIG_SERIAL_MUX_CONSOLE 550 register_console(&mux_console); 551#endif 552 } 553 554 return 0; 555} 556 557/** 558 * mux_exit - Serial MUX cleanup procedure. 559 * 560 * Unregister the Serial MUX driver from the tty layer. 561 */ 562static void __exit mux_exit(void) 563{ 564 /* Delete the Mux timer. */ 565 if(port_cnt > 0) { 566 del_timer_sync(&mux_timer); 567#ifdef CONFIG_SERIAL_MUX_CONSOLE 568 unregister_console(&mux_console); 569#endif 570 } 571 572 unregister_parisc_driver(&builtin_serial_mux_driver); 573 unregister_parisc_driver(&serial_mux_driver); 574 uart_unregister_driver(&mux_driver); 575} 576 577module_init(mux_init); 578module_exit(mux_exit); 579 580MODULE_AUTHOR("Ryan Bradetich"); 581MODULE_DESCRIPTION("Serial MUX driver"); 582MODULE_LICENSE("GPL"); 583MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR); 584