GNU Linux-libre 4.9.309-gnu1
[releases.git] / drivers / tty / serial / mux.c
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_break_ctl - Control the transmitssion of a break signal.
173  * @port: Ptr to the uart_port.
174  * @break_state: Raise/Lower the break signal.
175  *
176  * The Serial Mux does not support this function.
177  */
178 static void mux_break_ctl(struct uart_port *port, int break_state)
179 {
180 }
181
182 /**
183  * mux_write - Write chars to the mux fifo.
184  * @port: Ptr to the uart_port.
185  *
186  * This function writes all the data from the uart buffer to
187  * the mux fifo.
188  */
189 static void mux_write(struct uart_port *port)
190 {
191         int count;
192         struct circ_buf *xmit = &port->state->xmit;
193
194         if(port->x_char) {
195                 UART_PUT_CHAR(port, port->x_char);
196                 port->icount.tx++;
197                 port->x_char = 0;
198                 return;
199         }
200
201         if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
202                 mux_stop_tx(port);
203                 return;
204         }
205
206         count = (port->fifosize) - UART_GET_FIFO_CNT(port);
207         do {
208                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
209                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
210                 port->icount.tx++;
211                 if(uart_circ_empty(xmit))
212                         break;
213
214         } while(--count > 0);
215
216         while(UART_GET_FIFO_CNT(port)) 
217                 udelay(1);
218
219         if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
220                 uart_write_wakeup(port);
221
222         if (uart_circ_empty(xmit))
223                 mux_stop_tx(port);
224 }
225
226 /**
227  * mux_read - Read chars from the mux fifo.
228  * @port: Ptr to the uart_port.
229  *
230  * This reads all available data from the mux's fifo and pushes
231  * the data to the tty layer.
232  */
233 static void mux_read(struct uart_port *port)
234 {
235         struct tty_port *tport = &port->state->port;
236         int data;
237         __u32 start_count = port->icount.rx;
238
239         while(1) {
240                 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
241
242                 if (MUX_STATUS(data))
243                         continue;
244
245                 if (MUX_EOFIFO(data))
246                         break;
247
248                 port->icount.rx++;
249
250                 if (MUX_BREAK(data)) {
251                         port->icount.brk++;
252                         if(uart_handle_break(port))
253                                 continue;
254                 }
255
256                 if (uart_handle_sysrq_char(port, data & 0xffu))
257                         continue;
258
259                 tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL);
260         }
261         
262         if (start_count != port->icount.rx)
263                 tty_flip_buffer_push(tport);
264 }
265
266 /**
267  * mux_startup - Initialize the port.
268  * @port: Ptr to the uart_port.
269  *
270  * Grab any resources needed for this port and start the
271  * mux timer.
272  */
273 static int mux_startup(struct uart_port *port)
274 {
275         mux_ports[port->line].enabled = 1;
276         return 0;
277 }
278
279 /**
280  * mux_shutdown - Disable the port.
281  * @port: Ptr to the uart_port.
282  *
283  * Release any resources needed for the port.
284  */
285 static void mux_shutdown(struct uart_port *port)
286 {
287         mux_ports[port->line].enabled = 0;
288 }
289
290 /**
291  * mux_set_termios - Chane port parameters.
292  * @port: Ptr to the uart_port.
293  * @termios: new termios settings.
294  * @old: old termios settings.
295  *
296  * The Serial Mux does not support this function.
297  */
298 static void
299 mux_set_termios(struct uart_port *port, struct ktermios *termios,
300                 struct ktermios *old)
301 {
302 }
303
304 /**
305  * mux_type - Describe the port.
306  * @port: Ptr to the uart_port.
307  *
308  * Return a pointer to a string constant describing the
309  * specified port.
310  */
311 static const char *mux_type(struct uart_port *port)
312 {
313         return "Mux";
314 }
315
316 /**
317  * mux_release_port - Release memory and IO regions.
318  * @port: Ptr to the uart_port.
319  * 
320  * Release any memory and IO region resources currently in use by
321  * the port.
322  */
323 static void mux_release_port(struct uart_port *port)
324 {
325 }
326
327 /**
328  * mux_request_port - Request memory and IO regions.
329  * @port: Ptr to the uart_port.
330  *
331  * Request any memory and IO region resources required by the port.
332  * If any fail, no resources should be registered when this function
333  * returns, and it should return -EBUSY on failure.
334  */
335 static int mux_request_port(struct uart_port *port)
336 {
337         return 0;
338 }
339
340 /**
341  * mux_config_port - Perform port autoconfiguration.
342  * @port: Ptr to the uart_port.
343  * @type: Bitmask of required configurations.
344  *
345  * Perform any autoconfiguration steps for the port.  This function is
346  * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
347  * [Note: This is required for now because of a bug in the Serial core.
348  *  rmk has already submitted a patch to linus, should be available for
349  *  2.5.47.]
350  */
351 static void mux_config_port(struct uart_port *port, int type)
352 {
353         port->type = PORT_MUX;
354 }
355
356 /**
357  * mux_verify_port - Verify the port information.
358  * @port: Ptr to the uart_port.
359  * @ser: Ptr to the serial information.
360  *
361  * Verify the new serial port information contained within serinfo is
362  * suitable for this port type.
363  */
364 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
365 {
366         if(port->membase == NULL)
367                 return -EINVAL;
368
369         return 0;
370 }
371
372 /**
373  * mux_drv_poll - Mux poll function.
374  * @unused: Unused variable
375  *
376  * This function periodically polls the Serial MUX to check for new data.
377  */
378 static void mux_poll(unsigned long unused)
379 {  
380         int i;
381
382         for(i = 0; i < port_cnt; ++i) {
383                 if(!mux_ports[i].enabled)
384                         continue;
385
386                 mux_read(&mux_ports[i].port);
387                 mux_write(&mux_ports[i].port);
388         }
389
390         mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
391 }
392
393
394 #ifdef CONFIG_SERIAL_MUX_CONSOLE
395 static void mux_console_write(struct console *co, const char *s, unsigned count)
396 {
397         /* Wait until the FIFO drains. */
398         while(UART_GET_FIFO_CNT(&mux_ports[0].port))
399                 udelay(1);
400
401         while(count--) {
402                 if(*s == '\n') {
403                         UART_PUT_CHAR(&mux_ports[0].port, '\r');
404                 }
405                 UART_PUT_CHAR(&mux_ports[0].port, *s++);
406         }
407
408 }
409
410 static int mux_console_setup(struct console *co, char *options)
411 {
412         return 0;
413 }
414
415 static struct console mux_console = {
416         .name =         "ttyB",
417         .write =        mux_console_write,
418         .device =       uart_console_device,
419         .setup =        mux_console_setup,
420         .flags =        CON_ENABLED | CON_PRINTBUFFER,
421         .index =        0,
422         .data =         &mux_driver,
423 };
424
425 #define MUX_CONSOLE     &mux_console
426 #else
427 #define MUX_CONSOLE     NULL
428 #endif
429
430 static struct uart_ops mux_pops = {
431         .tx_empty =             mux_tx_empty,
432         .set_mctrl =            mux_set_mctrl,
433         .get_mctrl =            mux_get_mctrl,
434         .stop_tx =              mux_stop_tx,
435         .start_tx =             mux_start_tx,
436         .stop_rx =              mux_stop_rx,
437         .break_ctl =            mux_break_ctl,
438         .startup =              mux_startup,
439         .shutdown =             mux_shutdown,
440         .set_termios =          mux_set_termios,
441         .type =                 mux_type,
442         .release_port =         mux_release_port,
443         .request_port =         mux_request_port,
444         .config_port =          mux_config_port,
445         .verify_port =          mux_verify_port,
446 };
447
448 /**
449  * mux_probe - Determine if the Serial Mux should claim this device.
450  * @dev: The parisc device.
451  *
452  * Deterimine if the Serial Mux should claim this chip (return 0)
453  * or not (return 1).
454  */
455 static int __init mux_probe(struct parisc_device *dev)
456 {
457         int i, status;
458
459         int port_count = get_mux_port_count(dev);
460         printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);
461
462         dev_set_drvdata(&dev->dev, (void *)(long)port_count);
463         request_mem_region(dev->hpa.start + MUX_OFFSET,
464                            port_count * MUX_LINE_OFFSET, "Mux");
465
466         if(!port_cnt) {
467                 mux_driver.cons = MUX_CONSOLE;
468
469                 status = uart_register_driver(&mux_driver);
470                 if(status) {
471                         printk(KERN_ERR "Serial mux: Unable to register driver.\n");
472                         return 1;
473                 }
474         }
475
476         for(i = 0; i < port_count; ++i, ++port_cnt) {
477                 struct uart_port *port = &mux_ports[port_cnt].port;
478                 port->iobase    = 0;
479                 port->mapbase   = dev->hpa.start + MUX_OFFSET +
480                                                 (i * MUX_LINE_OFFSET);
481                 port->membase   = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
482                 port->iotype    = UPIO_MEM;
483                 port->type      = PORT_MUX;
484                 port->irq       = 0;
485                 port->uartclk   = 0;
486                 port->fifosize  = MUX_FIFO_SIZE;
487                 port->ops       = &mux_pops;
488                 port->flags     = UPF_BOOT_AUTOCONF;
489                 port->line      = port_cnt;
490
491                 /* The port->timeout needs to match what is present in
492                  * uart_wait_until_sent in serial_core.c.  Otherwise
493                  * the time spent in msleep_interruptable will be very
494                  * long, causing the appearance of a console hang.
495                  */
496                 port->timeout   = HZ / 50;
497                 spin_lock_init(&port->lock);
498
499                 status = uart_add_one_port(&mux_driver, port);
500                 BUG_ON(status);
501         }
502
503         return 0;
504 }
505
506 static int mux_remove(struct parisc_device *dev)
507 {
508         int i, j;
509         int port_count = (long)dev_get_drvdata(&dev->dev);
510
511         /* Find Port 0 for this card in the mux_ports list. */
512         for(i = 0; i < port_cnt; ++i) {
513                 if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
514                         break;
515         }
516         BUG_ON(i + port_count > port_cnt);
517
518         /* Release the resources associated with each port on the device. */
519         for(j = 0; j < port_count; ++j, ++i) {
520                 struct uart_port *port = &mux_ports[i].port;
521
522                 uart_remove_one_port(&mux_driver, port);
523                 if(port->membase)
524                         iounmap(port->membase);
525         }
526
527         release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
528         return 0;
529 }
530
531 /* Hack.  This idea was taken from the 8250_gsc.c on how to properly order
532  * the serial port detection in the proper order.   The idea is we always
533  * want the builtin mux to be detected before addin mux cards, so we
534  * specifically probe for the builtin mux cards first.
535  *
536  * This table only contains the parisc_device_id of known builtin mux
537  * devices.  All other mux cards will be detected by the generic mux_tbl.
538  */
539 static struct parisc_device_id builtin_mux_tbl[] = {
540         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
541         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
542         { 0, }
543 };
544
545 static struct parisc_device_id mux_tbl[] = {
546         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
547         { 0, }
548 };
549
550 MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
551 MODULE_DEVICE_TABLE(parisc, mux_tbl);
552
553 static struct parisc_driver builtin_serial_mux_driver = {
554         .name =         "builtin_serial_mux",
555         .id_table =     builtin_mux_tbl,
556         .probe =        mux_probe,
557         .remove =       mux_remove,
558 };
559
560 static struct parisc_driver serial_mux_driver = {
561         .name =         "serial_mux",
562         .id_table =     mux_tbl,
563         .probe =        mux_probe,
564         .remove =       mux_remove,
565 };
566
567 /**
568  * mux_init - Serial MUX initialization procedure.
569  *
570  * Register the Serial MUX driver.
571  */
572 static int __init mux_init(void)
573 {
574         register_parisc_driver(&builtin_serial_mux_driver);
575         register_parisc_driver(&serial_mux_driver);
576
577         if(port_cnt > 0) {
578                 /* Start the Mux timer */
579                 init_timer(&mux_timer);
580                 mux_timer.function = mux_poll;
581                 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
582
583 #ifdef CONFIG_SERIAL_MUX_CONSOLE
584                 register_console(&mux_console);
585 #endif
586         }
587
588         return 0;
589 }
590
591 /**
592  * mux_exit - Serial MUX cleanup procedure.
593  *
594  * Unregister the Serial MUX driver from the tty layer.
595  */
596 static void __exit mux_exit(void)
597 {
598         /* Delete the Mux timer. */
599         if(port_cnt > 0) {
600                 del_timer_sync(&mux_timer);
601 #ifdef CONFIG_SERIAL_MUX_CONSOLE
602                 unregister_console(&mux_console);
603 #endif
604         }
605
606         unregister_parisc_driver(&builtin_serial_mux_driver);
607         unregister_parisc_driver(&serial_mux_driver);
608         uart_unregister_driver(&mux_driver);
609 }
610
611 module_init(mux_init);
612 module_exit(mux_exit);
613
614 MODULE_AUTHOR("Ryan Bradetich");
615 MODULE_DESCRIPTION("Serial MUX driver");
616 MODULE_LICENSE("GPL");
617 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);