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