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/tty.h> 21#include <linux/ioport.h> 22#include <linux/init.h> 23#include <linux/serial.h> 24#include <linux/console.h> 25#include <linux/delay.h> /* for udelay */ 26#include <linux/device.h> 27#include <asm/io.h> 28#include <asm/irq.h> 29#include <asm/parisc-device.h> 30 31#ifdef CONFIG_MAGIC_SYSRQ 32#include <linux/sysrq.h> 33#define SUPPORT_SYSRQ 34#endif 35 36#include <linux/serial_core.h> 37 38#define MUX_OFFSET 0x800 39#define MUX_LINE_OFFSET 0x80 40 41#define MUX_FIFO_SIZE 255 42#define MUX_POLL_DELAY (30 * HZ / 1000) 43 44#define IO_DATA_REG_OFFSET 0x3c 45#define IO_DCOUNT_REG_OFFSET 0x40 46 47#define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000) 48#define MUX_STATUS(status) ((status & 0xF000) == 0x8000) 49#define MUX_BREAK(status) ((status & 0xF000) == 0x2000) 50 51#define MUX_NR 256 52static unsigned int port_cnt __read_mostly; 53struct mux_port { 54 struct uart_port port; 55 int enabled; 56}; 57static struct mux_port mux_ports[MUX_NR]; 58 59static struct uart_driver mux_driver = { 60 .owner = THIS_MODULE, 61 .driver_name = "ttyB", 62 .dev_name = "ttyB", 63 .major = MUX_MAJOR, 64 .minor = 0, 65 .nr = MUX_NR, 66}; 67 68static struct timer_list mux_timer; 69 70#define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET) 71#define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET) 72 73/** 74 * get_mux_port_count - Get the number of available ports on the Mux. 75 * @dev: The parisc device. 76 * 77 * This function is used to determine the number of ports the Mux 78 * supports. The IODC data reports the number of ports the Mux 79 * can support, but there are cases where not all the Mux ports 80 * are connected. This function can override the IODC and 81 * return the true port count. 82 */ 83static int __init get_mux_port_count(struct parisc_device *dev) 84{ 85 int status; 86 u8 iodc_data[32]; 87 unsigned long bytecnt; 88 89 /* If this is the built-in Mux for the K-Class (Eole CAP/MUX), 90 * we only need to allocate resources for 1 port since the 91 * other 7 ports are not connected. 92 */ 93 if(dev->id.hversion == 0x15) 94 return 1; 95 96 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32); 97 BUG_ON(status != PDC_OK); 98 99 /* Return the number of ports specified in the iodc data. */ 100 return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8; 101} 102 103/** 104 * mux_tx_empty - Check if the transmitter fifo is empty. 105 * @port: Ptr to the uart_port. 106 * 107 * This function test if the transmitter fifo for the port 108 * described by 'port' is empty. If it is empty, this function 109 * should return TIOCSER_TEMT, otherwise return 0. 110 */ 111static unsigned int mux_tx_empty(struct uart_port *port) 112{ 113 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT; 114} 115 116/** 117 * mux_set_mctrl - Set the current state of the modem control inputs. 118 * @ports: Ptr to the uart_port. 119 * @mctrl: Modem control bits. 120 * 121 * The Serial MUX does not support CTS, DCD or DSR so this function 122 * is ignored. 123 */ 124static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl) 125{ 126} 127 128/** 129 * mux_get_mctrl - Returns the current state of modem control inputs. 130 * @port: Ptr to the uart_port. 131 * 132 * The Serial MUX does not support CTS, DCD or DSR so these lines are 133 * treated as permanently active. 134 */ 135static unsigned int mux_get_mctrl(struct uart_port *port) 136{ 137 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS; 138} 139 140/** 141 * mux_stop_tx - Stop transmitting characters. 142 * @port: Ptr to the uart_port. 143 * 144 * The Serial MUX does not support this function. 145 */ 146static void mux_stop_tx(struct uart_port *port) 147{ 148} 149 150/** 151 * mux_start_tx - Start transmitting characters. 152 * @port: Ptr to the uart_port. 153 * 154 * The Serial Mux does not support this function. 155 */ 156static void mux_start_tx(struct uart_port *port) 157{ 158} 159 160/** 161 * mux_stop_rx - Stop receiving characters. 162 * @port: Ptr to the uart_port. 163 * 164 * The Serial Mux does not support this function. 165 */ 166static void mux_stop_rx(struct uart_port *port) 167{ 168} 169 170/** 171 * mux_enable_ms - Enable modum status interrupts. 172 * @port: Ptr to the uart_port. 173 * 174 * The Serial Mux does not support this function. 175 */ 176static void mux_enable_ms(struct uart_port *port) 177{ 178} 179 180/** 181 * mux_break_ctl - Control the transmitssion of a break signal. 182 * @port: Ptr to the uart_port. 183 * @break_state: Raise/Lower the break signal. 184 * 185 * The Serial Mux does not support this function. 186 */ 187static void mux_break_ctl(struct uart_port *port, int break_state) 188{ 189} 190 191/** 192 * mux_write - Write chars to the mux fifo. 193 * @port: Ptr to the uart_port. 194 * 195 * This function writes all the data from the uart buffer to 196 * the mux fifo. 197 */ 198static void mux_write(struct uart_port *port) 199{ 200 int count; 201 struct circ_buf *xmit = &port->state->xmit; 202 203 if(port->x_char) { 204 UART_PUT_CHAR(port, port->x_char); 205 port->icount.tx++; 206 port->x_char = 0; 207 return; 208 } 209 210 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) { 211 mux_stop_tx(port); 212 return; 213 } 214 215 count = (port->fifosize) - UART_GET_FIFO_CNT(port); 216 do { 217 UART_PUT_CHAR(port, xmit->buf[xmit->tail]); 218 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 219 port->icount.tx++; 220 if(uart_circ_empty(xmit)) 221 break; 222 223 } while(--count > 0); 224 225 while(UART_GET_FIFO_CNT(port)) 226 udelay(1); 227 228 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 229 uart_write_wakeup(port); 230 231 if (uart_circ_empty(xmit)) 232 mux_stop_tx(port); 233} 234 235/** 236 * mux_read - Read chars from the mux fifo. 237 * @port: Ptr to the uart_port. 238 * 239 * This reads all available data from the mux's fifo and pushes 240 * the data to the tty layer. 241 */ 242static void mux_read(struct uart_port *port) 243{ 244 int data; 245 struct tty_struct *tty = port->state->port.tty; 246 __u32 start_count = port->icount.rx; 247 248 while(1) { 249 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET); 250 251 if (MUX_STATUS(data)) 252 continue; 253 254 if (MUX_EOFIFO(data)) 255 break; 256 257 port->icount.rx++; 258 259 if (MUX_BREAK(data)) { 260 port->icount.brk++; 261 if(uart_handle_break(port)) 262 continue; 263 } 264 265 if (uart_handle_sysrq_char(port, data & 0xffu)) 266 continue; 267 268 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL); 269 } 270 271 if (start_count != port->icount.rx) { 272 tty_flip_buffer_push(tty); 273 } 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 */ 283static 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 */ 295static 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 */ 308static void 309mux_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 */ 321static 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 */ 333static 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 */ 345static 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 */ 361static 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 */ 374static 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 */ 388static 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 405static 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 420static int mux_console_setup(struct console *co, char *options) 421{ 422 return 0; 423} 424 425struct tty_driver *mux_console_device(struct console *co, int *index) 426{ 427 *index = co->index; 428 return mux_driver.tty_driver; 429} 430 431static 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 445static 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 */ 471static 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 = NO_IRQ; 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 522static int __devexit 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 */ 555static 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 561static struct parisc_device_id mux_tbl[] = { 562 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D }, 563 { 0, } 564}; 565 566MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl); 567MODULE_DEVICE_TABLE(parisc, mux_tbl); 568 569static struct parisc_driver builtin_serial_mux_driver = { 570 .name = "builtin_serial_mux", 571 .id_table = builtin_mux_tbl, 572 .probe = mux_probe, 573 .remove = __devexit_p(mux_remove), 574}; 575 576static struct parisc_driver serial_mux_driver = { 577 .name = "serial_mux", 578 .id_table = mux_tbl, 579 .probe = mux_probe, 580 .remove = __devexit_p(mux_remove), 581}; 582 583/** 584 * mux_init - Serial MUX initialization procedure. 585 * 586 * Register the Serial MUX driver. 587 */ 588static 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 */ 612static void __exit mux_exit(void) 613{ 614 /* Delete the Mux timer. */ 615 if(port_cnt > 0) { 616 del_timer(&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 627module_init(mux_init); 628module_exit(mux_exit); 629 630MODULE_AUTHOR("Ryan Bradetich"); 631MODULE_DESCRIPTION("Serial MUX driver"); 632MODULE_LICENSE("GPL"); 633MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR); 634