Merge branch 'master'
[linux-2.6] / drivers / 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/config.h>
20 #include <linux/module.h>
21 #include <linux/tty.h>
22 #include <linux/ioport.h>
23 #include <linux/init.h>
24 #include <linux/serial.h>
25 #include <linux/console.h>
26 #include <linux/slab.h>
27 #include <linux/delay.h> /* for udelay */
28 #include <linux/device.h>
29 #include <asm/io.h>
30 #include <asm/irq.h>
31 #include <asm/parisc-device.h>
32
33 #ifdef CONFIG_MAGIC_SYSRQ
34 #include <linux/sysrq.h>
35 #define SUPPORT_SYSRQ
36 #endif
37
38 #include <linux/serial_core.h>
39
40 #define MUX_OFFSET 0x800
41 #define MUX_LINE_OFFSET 0x80
42
43 #define MUX_FIFO_SIZE 255
44 #define MUX_POLL_DELAY (30 * HZ / 1000)
45
46 #define IO_DATA_REG_OFFSET 0x3c
47 #define IO_DCOUNT_REG_OFFSET 0x40
48
49 #define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
50 #define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
51 #define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
52
53 #define MUX_NR 256
54 static unsigned int port_cnt = 0;
55 static struct uart_port mux_ports[MUX_NR];
56
57 static struct uart_driver mux_driver = {
58         .owner = THIS_MODULE,
59         .driver_name = "ttyB",
60         .dev_name = "ttyB",
61         .major = MUX_MAJOR,
62         .minor = 0,
63         .nr = MUX_NR,
64 };
65
66 static struct timer_list mux_timer;
67
68 #define UART_PUT_CHAR(p, c) __raw_writel((c), (unsigned long)(p)->membase + IO_DATA_REG_OFFSET)
69 #define UART_GET_FIFO_CNT(p) __raw_readl((unsigned long)(p)->membase + IO_DCOUNT_REG_OFFSET)
70 #define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8
71
72 /**
73  * mux_tx_empty - Check if the transmitter fifo is empty.
74  * @port: Ptr to the uart_port.
75  *
76  * This function test if the transmitter fifo for the port
77  * described by 'port' is empty.  If it is empty, this function
78  * should return TIOCSER_TEMT, otherwise return 0.
79  */
80 static unsigned int mux_tx_empty(struct uart_port *port)
81 {
82         unsigned int cnt = __raw_readl((unsigned long)port->membase 
83                                 + IO_DCOUNT_REG_OFFSET);
84
85         return cnt ? 0 : TIOCSER_TEMT;
86
87
88 /**
89  * mux_set_mctrl - Set the current state of the modem control inputs.
90  * @ports: Ptr to the uart_port.
91  * @mctrl: Modem control bits.
92  *
93  * The Serial MUX does not support CTS, DCD or DSR so this function
94  * is ignored.
95  */
96 static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
97 {
98 }
99
100 /**
101  * mux_get_mctrl - Returns the current state of modem control inputs.
102  * @port: Ptr to the uart_port.
103  *
104  * The Serial MUX does not support CTS, DCD or DSR so these lines are
105  * treated as permanently active.
106  */
107 static unsigned int mux_get_mctrl(struct uart_port *port)
108
109         return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
110 }
111
112 /**
113  * mux_stop_tx - Stop transmitting characters.
114  * @port: Ptr to the uart_port.
115  *
116  * The Serial MUX does not support this function.
117  */
118 static void mux_stop_tx(struct uart_port *port)
119 {
120 }
121
122 /**
123  * mux_start_tx - Start transmitting characters.
124  * @port: Ptr to the uart_port.
125  *
126  * The Serial Mux does not support this function.
127  */
128 static void mux_start_tx(struct uart_port *port)
129 {
130 }
131
132 /**
133  * mux_stop_rx - Stop receiving characters.
134  * @port: Ptr to the uart_port.
135  *
136  * The Serial Mux does not support this function.
137  */
138 static void mux_stop_rx(struct uart_port *port)
139 {
140 }
141
142 /**
143  * mux_enable_ms - Enable modum status interrupts.
144  * @port: Ptr to the uart_port.
145  *
146  * The Serial Mux does not support this function.
147  */
148 static void mux_enable_ms(struct uart_port *port)
149 {
150 }
151
152 /**
153  * mux_break_ctl - Control the transmitssion of a break signal.
154  * @port: Ptr to the uart_port.
155  * @break_state: Raise/Lower the break signal.
156  *
157  * The Serial Mux does not support this function.
158  */
159 static void mux_break_ctl(struct uart_port *port, int break_state)
160 {
161 }
162
163 /**
164  * mux_write - Write chars to the mux fifo.
165  * @port: Ptr to the uart_port.
166  *
167  * This function writes all the data from the uart buffer to
168  * the mux fifo.
169  */
170 static void mux_write(struct uart_port *port)
171 {
172         int count;
173         struct circ_buf *xmit = &port->info->xmit;
174
175         if(port->x_char) {
176                 UART_PUT_CHAR(port, port->x_char);
177                 port->icount.tx++;
178                 port->x_char = 0;
179                 return;
180         }
181
182         if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
183                 mux_stop_tx(port);
184                 return;
185         }
186
187         count = (port->fifosize) - UART_GET_FIFO_CNT(port);
188         do {
189                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
190                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
191                 port->icount.tx++;
192                 if(uart_circ_empty(xmit))
193                         break;
194
195         } while(--count > 0);
196
197         while(UART_GET_FIFO_CNT(port)) 
198                 udelay(1);
199
200         if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
201                 uart_write_wakeup(port);
202
203         if (uart_circ_empty(xmit))
204                 mux_stop_tx(port);
205 }
206
207 /**
208  * mux_read - Read chars from the mux fifo.
209  * @port: Ptr to the uart_port.
210  *
211  * This reads all available data from the mux's fifo and pushes
212  * the data to the tty layer.
213  */
214 static void mux_read(struct uart_port *port)
215 {
216         int data;
217         struct tty_struct *tty = port->info->tty;
218         __u32 start_count = port->icount.rx;
219
220         while(1) {
221                 data = __raw_readl((unsigned long)port->membase
222                                                 + IO_DATA_REG_OFFSET);
223
224                 if (MUX_STATUS(data))
225                         continue;
226
227                 if (MUX_EOFIFO(data))
228                         break;
229
230                 if (tty->flip.count >= TTY_FLIPBUF_SIZE)
231                         continue;
232
233                 *tty->flip.char_buf_ptr = data & 0xffu;
234                 *tty->flip.flag_buf_ptr = TTY_NORMAL;
235                 port->icount.rx++;
236
237                 if (MUX_BREAK(data)) {
238                         port->icount.brk++;
239                         if(uart_handle_break(port))
240                                 continue;
241                 }
242
243                 if (uart_handle_sysrq_char(port, data & 0xffu, NULL))
244                         continue;
245
246                 tty->flip.flag_buf_ptr++;
247                 tty->flip.char_buf_ptr++;
248                 tty->flip.count++;
249         }
250         
251         if (start_count != port->icount.rx) {
252                 tty_flip_buffer_push(tty);
253         }
254 }
255
256 /**
257  * mux_startup - Initialize the port.
258  * @port: Ptr to the uart_port.
259  *
260  * Grab any resources needed for this port and start the
261  * mux timer.
262  */
263 static int mux_startup(struct uart_port *port)
264 {
265         mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
266         return 0;
267 }
268
269 /**
270  * mux_shutdown - Disable the port.
271  * @port: Ptr to the uart_port.
272  *
273  * Release any resources needed for the port.
274  */
275 static void mux_shutdown(struct uart_port *port)
276 {
277 }
278
279 /**
280  * mux_set_termios - Chane port parameters.
281  * @port: Ptr to the uart_port.
282  * @termios: new termios settings.
283  * @old: old termios settings.
284  *
285  * The Serial Mux does not support this function.
286  */
287 static void
288 mux_set_termios(struct uart_port *port, struct termios *termios,
289                 struct termios *old)
290 {
291 }
292
293 /**
294  * mux_type - Describe the port.
295  * @port: Ptr to the uart_port.
296  *
297  * Return a pointer to a string constant describing the
298  * specified port.
299  */
300 static const char *mux_type(struct uart_port *port)
301 {
302         return "Mux";
303 }
304
305 /**
306  * mux_release_port - Release memory and IO regions.
307  * @port: Ptr to the uart_port.
308  * 
309  * Release any memory and IO region resources currently in use by
310  * the port.
311  */
312 static void mux_release_port(struct uart_port *port)
313 {
314 }
315
316 /**
317  * mux_request_port - Request memory and IO regions.
318  * @port: Ptr to the uart_port.
319  *
320  * Request any memory and IO region resources required by the port.
321  * If any fail, no resources should be registered when this function
322  * returns, and it should return -EBUSY on failure.
323  */
324 static int mux_request_port(struct uart_port *port)
325 {
326         return 0;
327 }
328
329 /**
330  * mux_config_port - Perform port autoconfiguration.
331  * @port: Ptr to the uart_port.
332  * @type: Bitmask of required configurations.
333  *
334  * Perform any autoconfiguration steps for the port.  This functino is
335  * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
336  * [Note: This is required for now because of a bug in the Serial core.
337  *  rmk has already submitted a patch to linus, should be available for
338  *  2.5.47.]
339  */
340 static void mux_config_port(struct uart_port *port, int type)
341 {
342         port->type = PORT_MUX;
343 }
344
345 /**
346  * mux_verify_port - Verify the port information.
347  * @port: Ptr to the uart_port.
348  * @ser: Ptr to the serial information.
349  *
350  * Verify the new serial port information contained within serinfo is
351  * suitable for this port type.
352  */
353 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
354 {
355         if(port->membase == NULL)
356                 return -EINVAL;
357
358         return 0;
359 }
360
361 /**
362  * mux_drv_poll - Mux poll function.
363  * @unused: Unused variable
364  *
365  * This function periodically polls the Serial MUX to check for new data.
366  */
367 static void mux_poll(unsigned long unused)
368 {  
369         int i;
370
371         for(i = 0; i < port_cnt; ++i) {
372                 if(!mux_ports[i].info)
373                         continue;
374
375                 mux_read(&mux_ports[i]);
376                 mux_write(&mux_ports[i]);
377         }
378
379         mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
380 }
381
382
383 #ifdef CONFIG_SERIAL_MUX_CONSOLE
384 static void mux_console_write(struct console *co, const char *s, unsigned count)
385 {
386         while(count--)
387                 pdc_iodc_putc(*s++);
388 }
389
390 static int mux_console_setup(struct console *co, char *options)
391 {
392         return 0;
393 }
394
395 struct tty_driver *mux_console_device(struct console *co, int *index)
396 {
397         *index = co->index;
398         return mux_driver.tty_driver;
399 }
400
401 static struct console mux_console = {
402         .name =         "ttyB",
403         .write =        mux_console_write,
404         .device =       mux_console_device,
405         .setup =        mux_console_setup,
406         .flags =        CON_ENABLED | CON_PRINTBUFFER,
407         .index =        0,
408 };
409
410 #define MUX_CONSOLE     &mux_console
411 #else
412 #define MUX_CONSOLE     NULL
413 #endif
414
415 static struct uart_ops mux_pops = {
416         .tx_empty =             mux_tx_empty,
417         .set_mctrl =            mux_set_mctrl,
418         .get_mctrl =            mux_get_mctrl,
419         .stop_tx =              mux_stop_tx,
420         .start_tx =             mux_start_tx,
421         .stop_rx =              mux_stop_rx,
422         .enable_ms =            mux_enable_ms,
423         .break_ctl =            mux_break_ctl,
424         .startup =              mux_startup,
425         .shutdown =             mux_shutdown,
426         .set_termios =          mux_set_termios,
427         .type =                 mux_type,
428         .release_port =         mux_release_port,
429         .request_port =         mux_request_port,
430         .config_port =          mux_config_port,
431         .verify_port =          mux_verify_port,
432 };
433
434 /**
435  * mux_probe - Determine if the Serial Mux should claim this device.
436  * @dev: The parisc device.
437  *
438  * Deterimine if the Serial Mux should claim this chip (return 0)
439  * or not (return 1).
440  */
441 static int __init mux_probe(struct parisc_device *dev)
442 {
443         int i, status, ports;
444         u8 iodc_data[32];
445         unsigned long bytecnt;
446         struct uart_port *port;
447
448         status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
449         if(status != PDC_OK) {
450                 printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
451                 return 1;
452         }
453
454         ports = GET_MUX_PORTS(iodc_data);
455         printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);
456
457         if(!port_cnt) {
458                 mux_driver.cons = MUX_CONSOLE;
459
460                 status = uart_register_driver(&mux_driver);
461                 if(status) {
462                         printk(KERN_ERR "Serial mux: Unable to register driver.\n");
463                         return 1;
464                 }
465
466                 init_timer(&mux_timer);
467                 mux_timer.function = mux_poll;
468         }
469
470         for(i = 0; i < ports; ++i, ++port_cnt) {
471                 port = &mux_ports[port_cnt];
472                 port->iobase    = 0;
473                 port->mapbase   = dev->hpa.start + MUX_OFFSET +
474                                                 (i * MUX_LINE_OFFSET);
475                 port->membase   = ioremap(port->mapbase, MUX_LINE_OFFSET);
476                 port->iotype    = SERIAL_IO_MEM;
477                 port->type      = PORT_MUX;
478                 port->irq       = NO_IRQ;
479                 port->uartclk   = 0;
480                 port->fifosize  = MUX_FIFO_SIZE;
481                 port->ops       = &mux_pops;
482                 port->flags     = UPF_BOOT_AUTOCONF;
483                 port->line      = port_cnt;
484                 spin_lock_init(&port->lock);
485                 status = uart_add_one_port(&mux_driver, port);
486                 BUG_ON(status);
487         }
488
489 #ifdef CONFIG_SERIAL_MUX_CONSOLE
490         register_console(&mux_console);
491 #endif
492         return 0;
493 }
494
495 static struct parisc_device_id mux_tbl[] = {
496         { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
497         { 0, }
498 };
499
500 MODULE_DEVICE_TABLE(parisc, mux_tbl);
501
502 static struct parisc_driver serial_mux_driver = {
503         .name =         "serial_mux",
504         .id_table =     mux_tbl,
505         .probe =        mux_probe,
506 };
507
508 /**
509  * mux_init - Serial MUX initalization procedure.
510  *
511  * Register the Serial MUX driver.
512  */
513 static int __init mux_init(void)
514 {
515         return register_parisc_driver(&serial_mux_driver);
516 }
517
518 /**
519  * mux_exit - Serial MUX cleanup procedure.
520  *
521  * Unregister the Serial MUX driver from the tty layer.
522  */
523 static void __exit mux_exit(void)
524 {
525         int i;
526
527         for (i = 0; i < port_cnt; i++) {
528                 uart_remove_one_port(&mux_driver, &mux_ports[i]);
529         }
530
531         uart_unregister_driver(&mux_driver);
532 }
533
534 module_init(mux_init);
535 module_exit(mux_exit);
536
537 MODULE_AUTHOR("Ryan Bradetich");
538 MODULE_DESCRIPTION("Serial MUX driver");
539 MODULE_LICENSE("GPL");
540 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);