Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/drivers/serial/dz.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 19576 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 19576 byte(s)
Tag kernel26-2.6.12-alx-r9
1 | /* |
2 | * dz.c: Serial port driver for DECStations equiped |
3 | * with the DZ chipset. |
4 | * |
5 | * Copyright (C) 1998 Olivier A. D. Lebaillif |
6 | * |
7 | * Email: olivier.lebaillif@ifrsys.com |
8 | * |
9 | * [31-AUG-98] triemer |
10 | * Changed IRQ to use Harald's dec internals interrupts.h |
11 | * removed base_addr code - moving address assignment to setup.c |
12 | * Changed name of dz_init to rs_init to be consistent with tc code |
13 | * [13-NOV-98] triemer fixed code to receive characters |
14 | * after patches by harald to irq code. |
15 | * [09-JAN-99] triemer minor fix for schedule - due to removal of timeout |
16 | * field from "current" - somewhere between 2.1.121 and 2.1.131 |
17 | Qua Jun 27 15:02:26 BRT 2001 |
18 | * [27-JUN-2001] Arnaldo Carvalho de Melo <acme@conectiva.com.br> - cleanups |
19 | * |
20 | * Parts (C) 1999 David Airlie, airlied@linux.ie |
21 | * [07-SEP-99] Bugfixes |
22 | * |
23 | * [06-Jan-2002] Russell King <rmk@arm.linux.org.uk> |
24 | * Converted to new serial core |
25 | */ |
26 | |
27 | #undef DEBUG_DZ |
28 | |
29 | #include <linux/config.h> |
30 | #include <linux/module.h> |
31 | #include <linux/interrupt.h> |
32 | #include <linux/init.h> |
33 | #include <linux/console.h> |
34 | #include <linux/tty.h> |
35 | #include <linux/tty_flip.h> |
36 | #include <linux/serial_core.h> |
37 | #include <linux/serial.h> |
38 | |
39 | #include <asm/bootinfo.h> |
40 | #include <asm/dec/interrupts.h> |
41 | #include <asm/dec/kn01.h> |
42 | #include <asm/dec/kn02.h> |
43 | #include <asm/dec/machtype.h> |
44 | #include <asm/dec/prom.h> |
45 | #include <asm/irq.h> |
46 | #include <asm/system.h> |
47 | #include <asm/uaccess.h> |
48 | |
49 | #define CONSOLE_LINE (3) /* for definition of struct console */ |
50 | |
51 | #include "dz.h" |
52 | |
53 | #define DZ_INTR_DEBUG 1 |
54 | |
55 | static char *dz_name = "DECstation DZ serial driver version "; |
56 | static char *dz_version = "1.02"; |
57 | |
58 | struct dz_port { |
59 | struct uart_port port; |
60 | unsigned int cflag; |
61 | }; |
62 | |
63 | static struct dz_port dz_ports[DZ_NB_PORT]; |
64 | |
65 | #ifdef DEBUG_DZ |
66 | /* |
67 | * debugging code to send out chars via prom |
68 | */ |
69 | static void debug_console(const char *s, int count) |
70 | { |
71 | unsigned i; |
72 | |
73 | for (i = 0; i < count; i++) { |
74 | if (*s == 10) |
75 | prom_printf("%c", 13); |
76 | prom_printf("%c", *s++); |
77 | } |
78 | } |
79 | #endif |
80 | |
81 | /* |
82 | * ------------------------------------------------------------ |
83 | * dz_in () and dz_out () |
84 | * |
85 | * These routines are used to access the registers of the DZ |
86 | * chip, hiding relocation differences between implementation. |
87 | * ------------------------------------------------------------ |
88 | */ |
89 | |
90 | static inline unsigned short dz_in(struct dz_port *dport, unsigned offset) |
91 | { |
92 | volatile unsigned short *addr = |
93 | (volatile unsigned short *) (dport->port.membase + offset); |
94 | return *addr; |
95 | } |
96 | |
97 | static inline void dz_out(struct dz_port *dport, unsigned offset, |
98 | unsigned short value) |
99 | { |
100 | volatile unsigned short *addr = |
101 | (volatile unsigned short *) (dport->port.membase + offset); |
102 | *addr = value; |
103 | } |
104 | |
105 | /* |
106 | * ------------------------------------------------------------ |
107 | * rs_stop () and rs_start () |
108 | * |
109 | * These routines are called before setting or resetting |
110 | * tty->stopped. They enable or disable transmitter interrupts, |
111 | * as necessary. |
112 | * ------------------------------------------------------------ |
113 | */ |
114 | |
115 | static void dz_stop_tx(struct uart_port *uport, unsigned int tty_stop) |
116 | { |
117 | struct dz_port *dport = (struct dz_port *)uport; |
118 | unsigned short tmp, mask = 1 << dport->port.line; |
119 | unsigned long flags; |
120 | |
121 | spin_lock_irqsave(&dport->port.lock, flags); |
122 | tmp = dz_in(dport, DZ_TCR); /* read the TX flag */ |
123 | tmp &= ~mask; /* clear the TX flag */ |
124 | dz_out(dport, DZ_TCR, tmp); |
125 | spin_unlock_irqrestore(&dport->port.lock, flags); |
126 | } |
127 | |
128 | static void dz_start_tx(struct uart_port *uport, unsigned int tty_start) |
129 | { |
130 | struct dz_port *dport = (struct dz_port *)uport; |
131 | unsigned short tmp, mask = 1 << dport->port.line; |
132 | unsigned long flags; |
133 | |
134 | spin_lock_irqsave(&dport->port.lock, flags); |
135 | tmp = dz_in(dport, DZ_TCR); /* read the TX flag */ |
136 | tmp |= mask; /* set the TX flag */ |
137 | dz_out(dport, DZ_TCR, tmp); |
138 | spin_unlock_irqrestore(&dport->port.lock, flags); |
139 | } |
140 | |
141 | static void dz_stop_rx(struct uart_port *uport) |
142 | { |
143 | struct dz_port *dport = (struct dz_port *)uport; |
144 | unsigned long flags; |
145 | |
146 | spin_lock_irqsave(&dport->port.lock, flags); |
147 | dport->cflag &= ~DZ_CREAD; |
148 | dz_out(dport, DZ_LPR, dport->cflag); |
149 | spin_unlock_irqrestore(&dport->port.lock, flags); |
150 | } |
151 | |
152 | static void dz_enable_ms(struct uart_port *port) |
153 | { |
154 | /* nothing to do */ |
155 | } |
156 | |
157 | /* |
158 | * ------------------------------------------------------------ |
159 | * Here starts the interrupt handling routines. All of the |
160 | * following subroutines are declared as inline and are folded |
161 | * into dz_interrupt. They were separated out for readability's |
162 | * sake. |
163 | * |
164 | * Note: rs_interrupt() is a "fast" interrupt, which means that it |
165 | * runs with interrupts turned off. People who may want to modify |
166 | * rs_interrupt() should try to keep the interrupt handler as fast as |
167 | * possible. After you are done making modifications, it is not a bad |
168 | * idea to do: |
169 | * |
170 | * make drivers/serial/dz.s |
171 | * |
172 | * and look at the resulting assemble code in dz.s. |
173 | * |
174 | * ------------------------------------------------------------ |
175 | */ |
176 | |
177 | /* |
178 | * ------------------------------------------------------------ |
179 | * receive_char () |
180 | * |
181 | * This routine deals with inputs from any lines. |
182 | * ------------------------------------------------------------ |
183 | */ |
184 | static inline void dz_receive_chars(struct dz_port *dport) |
185 | { |
186 | struct tty_struct *tty = NULL; |
187 | struct uart_icount *icount; |
188 | int ignore = 0; |
189 | unsigned short status, tmp; |
190 | unsigned char ch, flag; |
191 | |
192 | /* this code is going to be a problem... |
193 | the call to tty_flip_buffer is going to need |
194 | to be rethought... |
195 | */ |
196 | do { |
197 | status = dz_in(dport, DZ_RBUF); |
198 | |
199 | /* punt so we don't get duplicate characters */ |
200 | if (!(status & DZ_DVAL)) |
201 | goto ignore_char; |
202 | |
203 | |
204 | ch = UCHAR(status); /* grab the char */ |
205 | flag = TTY_NORMAL; |
206 | |
207 | #if 0 |
208 | if (info->is_console) { |
209 | if (ch == 0) |
210 | return; /* it's a break ... */ |
211 | } |
212 | #endif |
213 | |
214 | tty = dport->port.info->tty;/* now tty points to the proper dev */ |
215 | icount = &dport->port.icount; |
216 | |
217 | if (!tty) |
218 | break; |
219 | if (tty->flip.count >= TTY_FLIPBUF_SIZE) |
220 | break; |
221 | |
222 | icount->rx++; |
223 | |
224 | /* keep track of the statistics */ |
225 | if (status & (DZ_OERR | DZ_FERR | DZ_PERR)) { |
226 | if (status & DZ_PERR) /* parity error */ |
227 | icount->parity++; |
228 | else if (status & DZ_FERR) /* frame error */ |
229 | icount->frame++; |
230 | if (status & DZ_OERR) /* overrun error */ |
231 | icount->overrun++; |
232 | |
233 | /* check to see if we should ignore the character |
234 | and mask off conditions that should be ignored |
235 | */ |
236 | |
237 | if (status & dport->port.ignore_status_mask) { |
238 | if (++ignore > 100) |
239 | break; |
240 | goto ignore_char; |
241 | } |
242 | /* mask off the error conditions we want to ignore */ |
243 | tmp = status & dport->port.read_status_mask; |
244 | |
245 | if (tmp & DZ_PERR) { |
246 | flag = TTY_PARITY; |
247 | #ifdef DEBUG_DZ |
248 | debug_console("PERR\n", 5); |
249 | #endif |
250 | } else if (tmp & DZ_FERR) { |
251 | flag = TTY_FRAME; |
252 | #ifdef DEBUG_DZ |
253 | debug_console("FERR\n", 5); |
254 | #endif |
255 | } |
256 | if (tmp & DZ_OERR) { |
257 | #ifdef DEBUG_DZ |
258 | debug_console("OERR\n", 5); |
259 | #endif |
260 | tty_insert_flip_char(tty, ch, flag); |
261 | ch = 0; |
262 | flag = TTY_OVERRUN; |
263 | } |
264 | } |
265 | tty_insert_flip_char(tty, ch, flag); |
266 | ignore_char: |
267 | } while (status & DZ_DVAL); |
268 | |
269 | if (tty) |
270 | tty_flip_buffer_push(tty); |
271 | } |
272 | |
273 | /* |
274 | * ------------------------------------------------------------ |
275 | * transmit_char () |
276 | * |
277 | * This routine deals with outputs to any lines. |
278 | * ------------------------------------------------------------ |
279 | */ |
280 | static inline void dz_transmit_chars(struct dz_port *dport) |
281 | { |
282 | struct circ_buf *xmit = &dport->port.info->xmit; |
283 | unsigned char tmp; |
284 | |
285 | if (dport->port.x_char) { /* XON/XOFF chars */ |
286 | dz_out(dport, DZ_TDR, dport->port.x_char); |
287 | dport->port.icount.tx++; |
288 | dport->port.x_char = 0; |
289 | return; |
290 | } |
291 | /* if nothing to do or stopped or hardware stopped */ |
292 | if (uart_circ_empty(xmit) || uart_tx_stopped(&dport->port)) { |
293 | dz_stop_tx(&dport->port, 0); |
294 | return; |
295 | } |
296 | |
297 | /* |
298 | * if something to do ... (rember the dz has no output fifo so we go |
299 | * one char at a time :-< |
300 | */ |
301 | tmp = xmit->buf[xmit->tail]; |
302 | xmit->tail = (xmit->tail + 1) & (DZ_XMIT_SIZE - 1); |
303 | dz_out(dport, DZ_TDR, tmp); |
304 | dport->port.icount.tx++; |
305 | |
306 | if (uart_circ_chars_pending(xmit) < DZ_WAKEUP_CHARS) |
307 | uart_write_wakeup(&dport->port); |
308 | |
309 | /* Are we done */ |
310 | if (uart_circ_empty(xmit)) |
311 | dz_stop_tx(&dport->port, 0); |
312 | } |
313 | |
314 | /* |
315 | * ------------------------------------------------------------ |
316 | * check_modem_status () |
317 | * |
318 | * Only valid for the MODEM line duh ! |
319 | * ------------------------------------------------------------ |
320 | */ |
321 | static inline void check_modem_status(struct dz_port *dport) |
322 | { |
323 | unsigned short status; |
324 | |
325 | /* if not ne modem line just return */ |
326 | if (dport->port.line != DZ_MODEM) |
327 | return; |
328 | |
329 | status = dz_in(dport, DZ_MSR); |
330 | |
331 | /* it's easy, since DSR2 is the only bit in the register */ |
332 | if (status) |
333 | dport->port.icount.dsr++; |
334 | } |
335 | |
336 | /* |
337 | * ------------------------------------------------------------ |
338 | * dz_interrupt () |
339 | * |
340 | * this is the main interrupt routine for the DZ chip. |
341 | * It deals with the multiple ports. |
342 | * ------------------------------------------------------------ |
343 | */ |
344 | static irqreturn_t dz_interrupt(int irq, void *dev, struct pt_regs *regs) |
345 | { |
346 | struct dz_port *dport; |
347 | unsigned short status; |
348 | |
349 | /* get the reason why we just got an irq */ |
350 | status = dz_in((struct dz_port *)dev, DZ_CSR); |
351 | dport = &dz_ports[LINE(status)]; |
352 | |
353 | if (status & DZ_RDONE) |
354 | dz_receive_chars(dport); |
355 | |
356 | if (status & DZ_TRDY) |
357 | dz_transmit_chars(dport); |
358 | |
359 | /* FIXME: what about check modem status??? --rmk */ |
360 | |
361 | return IRQ_HANDLED; |
362 | } |
363 | |
364 | /* |
365 | * ------------------------------------------------------------------- |
366 | * Here ends the DZ interrupt routines. |
367 | * ------------------------------------------------------------------- |
368 | */ |
369 | |
370 | static unsigned int dz_get_mctrl(struct uart_port *uport) |
371 | { |
372 | struct dz_port *dport = (struct dz_port *)uport; |
373 | unsigned int mctrl = TIOCM_CAR | TIOCM_DSR | TIOCM_CTS; |
374 | |
375 | if (dport->port.line == DZ_MODEM) { |
376 | /* |
377 | * CHECKME: This is a guess from the other code... --rmk |
378 | */ |
379 | if (dz_in(dport, DZ_MSR) & DZ_MODEM_DSR) |
380 | mctrl &= ~TIOCM_DSR; |
381 | } |
382 | |
383 | return mctrl; |
384 | } |
385 | |
386 | static void dz_set_mctrl(struct uart_port *uport, unsigned int mctrl) |
387 | { |
388 | struct dz_port *dport = (struct dz_port *)uport; |
389 | unsigned short tmp; |
390 | |
391 | if (dport->port.line == DZ_MODEM) { |
392 | tmp = dz_in(dport, DZ_TCR); |
393 | if (mctrl & TIOCM_DTR) |
394 | tmp &= ~DZ_MODEM_DTR; |
395 | else |
396 | tmp |= DZ_MODEM_DTR; |
397 | dz_out(dport, DZ_TCR, tmp); |
398 | } |
399 | } |
400 | |
401 | /* |
402 | * ------------------------------------------------------------------- |
403 | * startup () |
404 | * |
405 | * various initialization tasks |
406 | * ------------------------------------------------------------------- |
407 | */ |
408 | static int dz_startup(struct uart_port *uport) |
409 | { |
410 | struct dz_port *dport = (struct dz_port *)uport; |
411 | unsigned long flags; |
412 | unsigned short tmp; |
413 | |
414 | /* The dz lines for the mouse/keyboard must be |
415 | * opened using their respective drivers. |
416 | */ |
417 | if ((dport->port.line == DZ_KEYBOARD) || |
418 | (dport->port.line == DZ_MOUSE)) |
419 | return -ENODEV; |
420 | |
421 | spin_lock_irqsave(&dport->port.lock, flags); |
422 | |
423 | /* enable the interrupt and the scanning */ |
424 | tmp = dz_in(dport, DZ_CSR); |
425 | tmp |= DZ_RIE | DZ_TIE | DZ_MSE; |
426 | dz_out(dport, DZ_CSR, tmp); |
427 | |
428 | spin_unlock_irqrestore(&dport->port.lock, flags); |
429 | |
430 | return 0; |
431 | } |
432 | |
433 | /* |
434 | * ------------------------------------------------------------------- |
435 | * shutdown () |
436 | * |
437 | * This routine will shutdown a serial port; interrupts are disabled, and |
438 | * DTR is dropped if the hangup on close termio flag is on. |
439 | * ------------------------------------------------------------------- |
440 | */ |
441 | static void dz_shutdown(struct uart_port *uport) |
442 | { |
443 | dz_stop_tx(uport, 0); |
444 | } |
445 | |
446 | /* |
447 | * get_lsr_info - get line status register info |
448 | * |
449 | * Purpose: Let user call ioctl() to get info when the UART physically |
450 | * is emptied. On bus types like RS485, the transmitter must |
451 | * release the bus after transmitting. This must be done when |
452 | * the transmit shift register is empty, not be done when the |
453 | * transmit holding register is empty. This functionality |
454 | * allows an RS485 driver to be written in user space. |
455 | */ |
456 | static unsigned int dz_tx_empty(struct uart_port *uport) |
457 | { |
458 | struct dz_port *dport = (struct dz_port *)uport; |
459 | unsigned short status = dz_in(dport, DZ_LPR); |
460 | |
461 | /* FIXME: this appears to be obviously broken --rmk. */ |
462 | return status ? TIOCSER_TEMT : 0; |
463 | } |
464 | |
465 | static void dz_break_ctl(struct uart_port *uport, int break_state) |
466 | { |
467 | struct dz_port *dport = (struct dz_port *)uport; |
468 | unsigned long flags; |
469 | unsigned short tmp, mask = 1 << uport->line; |
470 | |
471 | spin_lock_irqsave(&uport->lock, flags); |
472 | tmp = dz_in(dport, DZ_TCR); |
473 | if (break_state) |
474 | tmp |= mask; |
475 | else |
476 | tmp &= ~mask; |
477 | dz_out(dport, DZ_TCR, tmp); |
478 | spin_unlock_irqrestore(&uport->lock, flags); |
479 | } |
480 | |
481 | static void dz_set_termios(struct uart_port *uport, struct termios *termios, |
482 | struct termios *old_termios) |
483 | { |
484 | struct dz_port *dport = (struct dz_port *)uport; |
485 | unsigned long flags; |
486 | unsigned int cflag, baud; |
487 | |
488 | cflag = dport->port.line; |
489 | |
490 | switch (termios->c_cflag & CSIZE) { |
491 | case CS5: |
492 | cflag |= DZ_CS5; |
493 | break; |
494 | case CS6: |
495 | cflag |= DZ_CS6; |
496 | break; |
497 | case CS7: |
498 | cflag |= DZ_CS7; |
499 | break; |
500 | case CS8: |
501 | default: |
502 | cflag |= DZ_CS8; |
503 | } |
504 | |
505 | if (termios->c_cflag & CSTOPB) |
506 | cflag |= DZ_CSTOPB; |
507 | if (termios->c_cflag & PARENB) |
508 | cflag |= DZ_PARENB; |
509 | if (termios->c_cflag & PARODD) |
510 | cflag |= DZ_PARODD; |
511 | |
512 | baud = uart_get_baud_rate(uport, termios, old_termios, 50, 9600); |
513 | switch (baud) { |
514 | case 50: |
515 | cflag |= DZ_B50; |
516 | break; |
517 | case 75: |
518 | cflag |= DZ_B75; |
519 | break; |
520 | case 110: |
521 | cflag |= DZ_B110; |
522 | break; |
523 | case 134: |
524 | cflag |= DZ_B134; |
525 | break; |
526 | case 150: |
527 | cflag |= DZ_B150; |
528 | break; |
529 | case 300: |
530 | cflag |= DZ_B300; |
531 | break; |
532 | case 600: |
533 | cflag |= DZ_B600; |
534 | break; |
535 | case 1200: |
536 | cflag |= DZ_B1200; |
537 | break; |
538 | case 1800: |
539 | cflag |= DZ_B1800; |
540 | break; |
541 | case 2000: |
542 | cflag |= DZ_B2000; |
543 | break; |
544 | case 2400: |
545 | cflag |= DZ_B2400; |
546 | break; |
547 | case 3600: |
548 | cflag |= DZ_B3600; |
549 | break; |
550 | case 4800: |
551 | cflag |= DZ_B4800; |
552 | break; |
553 | case 7200: |
554 | cflag |= DZ_B7200; |
555 | break; |
556 | case 9600: |
557 | default: |
558 | cflag |= DZ_B9600; |
559 | } |
560 | |
561 | if (termios->c_cflag & CREAD) |
562 | cflag |= DZ_RXENAB; |
563 | |
564 | spin_lock_irqsave(&dport->port.lock, flags); |
565 | |
566 | dz_out(dport, DZ_LPR, cflag); |
567 | dport->cflag = cflag; |
568 | |
569 | /* setup accept flag */ |
570 | dport->port.read_status_mask = DZ_OERR; |
571 | if (termios->c_iflag & INPCK) |
572 | dport->port.read_status_mask |= DZ_FERR | DZ_PERR; |
573 | |
574 | /* characters to ignore */ |
575 | uport->ignore_status_mask = 0; |
576 | if (termios->c_iflag & IGNPAR) |
577 | dport->port.ignore_status_mask |= DZ_FERR | DZ_PERR; |
578 | |
579 | spin_unlock_irqrestore(&dport->port.lock, flags); |
580 | } |
581 | |
582 | static const char *dz_type(struct uart_port *port) |
583 | { |
584 | return "DZ"; |
585 | } |
586 | |
587 | static void dz_release_port(struct uart_port *port) |
588 | { |
589 | /* nothing to do */ |
590 | } |
591 | |
592 | static int dz_request_port(struct uart_port *port) |
593 | { |
594 | return 0; |
595 | } |
596 | |
597 | static void dz_config_port(struct uart_port *port, int flags) |
598 | { |
599 | if (flags & UART_CONFIG_TYPE) |
600 | port->type = PORT_DZ; |
601 | } |
602 | |
603 | /* |
604 | * verify the new serial_struct (for TIOCSSERIAL). |
605 | */ |
606 | static int dz_verify_port(struct uart_port *port, struct serial_struct *ser) |
607 | { |
608 | int ret = 0; |
609 | if (ser->type != PORT_UNKNOWN && ser->type != PORT_DZ) |
610 | ret = -EINVAL; |
611 | if (ser->irq != port->irq) |
612 | ret = -EINVAL; |
613 | return ret; |
614 | } |
615 | |
616 | static struct uart_ops dz_ops = { |
617 | .tx_empty = dz_tx_empty, |
618 | .get_mctrl = dz_get_mctrl, |
619 | .set_mctrl = dz_set_mctrl, |
620 | .stop_tx = dz_stop_tx, |
621 | .start_tx = dz_start_tx, |
622 | .stop_rx = dz_stop_rx, |
623 | .enable_ms = dz_enable_ms, |
624 | .break_ctl = dz_break_ctl, |
625 | .startup = dz_startup, |
626 | .shutdown = dz_shutdown, |
627 | .set_termios = dz_set_termios, |
628 | .type = dz_type, |
629 | .release_port = dz_release_port, |
630 | .request_port = dz_request_port, |
631 | .config_port = dz_config_port, |
632 | .verify_port = dz_verify_port, |
633 | }; |
634 | |
635 | static void __init dz_init_ports(void) |
636 | { |
637 | static int first = 1; |
638 | struct dz_port *dport; |
639 | unsigned long base; |
640 | int i; |
641 | |
642 | if (!first) |
643 | return; |
644 | first = 0; |
645 | |
646 | if (mips_machtype == MACH_DS23100 || |
647 | mips_machtype == MACH_DS5100) |
648 | base = (unsigned long) KN01_DZ11_BASE; |
649 | else |
650 | base = (unsigned long) KN02_DZ11_BASE; |
651 | |
652 | for (i = 0, dport = dz_ports; i < DZ_NB_PORT; i++, dport++) { |
653 | spin_lock_init(&dport->port.lock); |
654 | dport->port.membase = (char *) base; |
655 | dport->port.iotype = SERIAL_IO_PORT; |
656 | dport->port.irq = dec_interrupt[DEC_IRQ_DZ11]; |
657 | dport->port.line = i; |
658 | dport->port.fifosize = 1; |
659 | dport->port.ops = &dz_ops; |
660 | dport->port.flags = UPF_BOOT_AUTOCONF; |
661 | } |
662 | } |
663 | |
664 | static void dz_reset(struct dz_port *dport) |
665 | { |
666 | dz_out(dport, DZ_CSR, DZ_CLR); |
667 | |
668 | while (dz_in(dport, DZ_CSR) & DZ_CLR); |
669 | /* FIXME: cpu_relax? */ |
670 | |
671 | iob(); |
672 | |
673 | /* enable scanning */ |
674 | dz_out(dport, DZ_CSR, DZ_MSE); |
675 | } |
676 | |
677 | #ifdef CONFIG_SERIAL_DZ_CONSOLE |
678 | static void dz_console_put_char(struct dz_port *dport, unsigned char ch) |
679 | { |
680 | unsigned long flags; |
681 | int loops = 2500; |
682 | unsigned short tmp = ch; |
683 | /* this code sends stuff out to serial device - spinning its |
684 | wheels and waiting. */ |
685 | |
686 | spin_lock_irqsave(&dport->port.lock, flags); |
687 | |
688 | /* spin our wheels */ |
689 | while (((dz_in(dport, DZ_CSR) & DZ_TRDY) != DZ_TRDY) && loops--) |
690 | /* FIXME: cpu_relax, udelay? --rmk */ |
691 | ; |
692 | |
693 | /* Actually transmit the character. */ |
694 | dz_out(dport, DZ_TDR, tmp); |
695 | |
696 | spin_unlock_irqrestore(&dport->port.lock, flags); |
697 | } |
698 | /* |
699 | * ------------------------------------------------------------------- |
700 | * dz_console_print () |
701 | * |
702 | * dz_console_print is registered for printk. |
703 | * The console must be locked when we get here. |
704 | * ------------------------------------------------------------------- |
705 | */ |
706 | static void dz_console_print(struct console *cons, |
707 | const char *str, |
708 | unsigned int count) |
709 | { |
710 | struct dz_port *dport = &dz_ports[CONSOLE_LINE]; |
711 | #ifdef DEBUG_DZ |
712 | prom_printf((char *) str); |
713 | #endif |
714 | while (count--) { |
715 | if (*str == '\n') |
716 | dz_console_put_char(dport, '\r'); |
717 | dz_console_put_char(dport, *str++); |
718 | } |
719 | } |
720 | |
721 | static int __init dz_console_setup(struct console *co, char *options) |
722 | { |
723 | struct dz_port *dport = &dz_ports[CONSOLE_LINE]; |
724 | int baud = 9600; |
725 | int bits = 8; |
726 | int parity = 'n'; |
727 | int flow = 'n'; |
728 | int ret; |
729 | unsigned short mask, tmp; |
730 | |
731 | if (options) |
732 | uart_parse_options(options, &baud, &parity, &bits, &flow); |
733 | |
734 | dz_reset(dport); |
735 | |
736 | ret = uart_set_options(&dport->port, co, baud, parity, bits, flow); |
737 | if (ret == 0) { |
738 | mask = 1 << dport->port.line; |
739 | tmp = dz_in(dport, DZ_TCR); /* read the TX flag */ |
740 | if (!(tmp & mask)) { |
741 | tmp |= mask; /* set the TX flag */ |
742 | dz_out(dport, DZ_TCR, tmp); |
743 | } |
744 | } |
745 | |
746 | return ret; |
747 | } |
748 | |
749 | static struct console dz_sercons = |
750 | { |
751 | .name = "ttyS", |
752 | .write = dz_console_print, |
753 | .device = uart_console_device, |
754 | .setup = dz_console_setup, |
755 | .flags = CON_CONSDEV | CON_PRINTBUFFER, |
756 | .index = CONSOLE_LINE, |
757 | }; |
758 | |
759 | void __init dz_serial_console_init(void) |
760 | { |
761 | dz_init_ports(); |
762 | |
763 | register_console(&dz_sercons); |
764 | } |
765 | |
766 | #define SERIAL_DZ_CONSOLE &dz_sercons |
767 | #else |
768 | #define SERIAL_DZ_CONSOLE NULL |
769 | #endif /* CONFIG_SERIAL_DZ_CONSOLE */ |
770 | |
771 | static struct uart_driver dz_reg = { |
772 | .owner = THIS_MODULE, |
773 | .driver_name = "serial", |
774 | #ifdef CONFIG_DEVFS |
775 | .dev_name = "tts/%d", |
776 | #else |
777 | .dev_name = "ttyS%d", |
778 | #endif |
779 | .major = TTY_MAJOR, |
780 | .minor = 64, |
781 | .nr = DZ_NB_PORT, |
782 | .cons = SERIAL_DZ_CONSOLE, |
783 | }; |
784 | |
785 | int __init dz_init(void) |
786 | { |
787 | unsigned long flags; |
788 | int ret, i; |
789 | |
790 | printk("%s%s\n", dz_name, dz_version); |
791 | |
792 | dz_init_ports(); |
793 | |
794 | save_flags(flags); |
795 | cli(); |
796 | |
797 | #ifndef CONFIG_SERIAL_DZ_CONSOLE |
798 | /* reset the chip */ |
799 | dz_reset(&dz_ports[0]); |
800 | #endif |
801 | |
802 | /* order matters here... the trick is that flags |
803 | is updated... in request_irq - to immediatedly obliterate |
804 | it is unwise. */ |
805 | restore_flags(flags); |
806 | |
807 | if (request_irq(dz_ports[0].port.irq, dz_interrupt, |
808 | SA_INTERRUPT, "DZ", &dz_ports[0])) |
809 | panic("Unable to register DZ interrupt"); |
810 | |
811 | ret = uart_register_driver(&dz_reg); |
812 | if (ret != 0) |
813 | return ret; |
814 | |
815 | for (i = 0; i < DZ_NB_PORT; i++) |
816 | uart_add_one_port(&dz_reg, &dz_ports[i].port); |
817 | |
818 | return ret; |
819 | } |
820 | |
821 | MODULE_DESCRIPTION("DECstation DZ serial driver"); |
822 | MODULE_LICENSE("GPL"); |