ia64/linux-2.6.18-xen.hg

view drivers/serial/mux.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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 */
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>
32 #ifdef CONFIG_MAGIC_SYSRQ
33 #include <linux/sysrq.h>
34 #define SUPPORT_SYSRQ
35 #endif
37 #include <linux/serial_core.h>
39 #define MUX_OFFSET 0x800
40 #define MUX_LINE_OFFSET 0x80
42 #define MUX_FIFO_SIZE 255
43 #define MUX_POLL_DELAY (30 * HZ / 1000)
45 #define IO_DATA_REG_OFFSET 0x3c
46 #define IO_DCOUNT_REG_OFFSET 0x40
48 #define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
49 #define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
50 #define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
52 #define MUX_NR 256
53 static unsigned int port_cnt __read_mostly;
54 static struct uart_port mux_ports[MUX_NR];
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 };
65 static struct timer_list mux_timer;
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
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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;
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 }
178 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
179 mux_stop_tx(port);
180 return;
181 }
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;
191 } while(--count > 0);
193 while(UART_GET_FIFO_CNT(port))
194 udelay(1);
196 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
197 uart_write_wakeup(port);
199 if (uart_circ_empty(xmit))
200 mux_stop_tx(port);
201 }
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;
216 while(1) {
217 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
219 if (MUX_STATUS(data))
220 continue;
222 if (MUX_EOFIFO(data))
223 break;
225 port->icount.rx++;
227 if (MUX_BREAK(data)) {
228 port->icount.brk++;
229 if(uart_handle_break(port))
230 continue;
231 }
233 if (uart_handle_sysrq_char(port, data & 0xffu, NULL))
234 continue;
236 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
237 }
239 if (start_count != port->icount.rx) {
240 tty_flip_buffer_push(tty);
241 }
242 }
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 }
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 }
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 termios *termios,
277 struct termios *old)
278 {
279 }
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 }
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 }
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 }
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 }
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;
346 return 0;
347 }
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;
359 for(i = 0; i < port_cnt; ++i) {
360 if(!mux_ports[i].info)
361 continue;
363 mux_read(&mux_ports[i]);
364 mux_write(&mux_ports[i]);
365 }
367 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
368 }
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 }
378 static int mux_console_setup(struct console *co, char *options)
379 {
380 return 0;
381 }
383 struct tty_driver *mux_console_device(struct console *co, int *index)
384 {
385 *index = co->index;
386 return mux_driver.tty_driver;
387 }
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 };
398 #define MUX_CONSOLE &mux_console
399 #else
400 #define MUX_CONSOLE NULL
401 #endif
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 };
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;
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 }
442 ports = GET_MUX_PORTS(iodc_data);
443 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);
445 if(!port_cnt) {
446 mux_driver.cons = MUX_CONSOLE;
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 }
454 init_timer(&mux_timer);
455 mux_timer.function = mux_poll;
456 }
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;
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 }
484 #ifdef CONFIG_SERIAL_MUX_CONSOLE
485 register_console(&mux_console);
486 #endif
487 return 0;
488 }
490 static struct parisc_device_id mux_tbl[] = {
491 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
492 { 0, }
493 };
495 MODULE_DEVICE_TABLE(parisc, mux_tbl);
497 static struct parisc_driver serial_mux_driver = {
498 .name = "serial_mux",
499 .id_table = mux_tbl,
500 .probe = mux_probe,
501 };
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 }
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;
522 for (i = 0; i < port_cnt; i++) {
523 uart_remove_one_port(&mux_driver, &mux_ports[i]);
524 }
526 uart_unregister_driver(&mux_driver);
527 }
529 module_init(mux_init);
530 module_exit(mux_exit);
532 MODULE_AUTHOR("Ryan Bradetich");
533 MODULE_DESCRIPTION("Serial MUX driver");
534 MODULE_LICENSE("GPL");
535 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);