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