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