?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] w1: Make w1 connector notifications depend on connector.
[linux-2.6/verdex.git] / drivers / serial / sunsu.c
blob4cdb610cdd374cf218bcd5ca40928723bd37f6e4
1 /* $Id: su.c,v 1.55 2002/01/08 16:00:16 davem Exp $
2 * su.c: Small serial driver for keyboard/mouse interface on sparc32/PCI
3 *
4 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
5 * Copyright (C) 1998-1999 Pete Zaitcev (zaitcev@yahoo.com)
6 *
7 * This is mainly a variation of 8250.c, credits go to authors mentioned
8 * therein. In fact this driver should be merged into the generic 8250.c
9 * infrastructure perhaps using a 8250_sparc.c module.
10 *
11 * Fixed to use tty_get_baud_rate().
12 * Theodore Ts'o <tytso@mit.edu>, 2001-Oct-12
13 *
14 * Converted to new 2.5.x UART layer.
15 * David S. Miller (davem@redhat.com), 2002-Jul-29
16 */
17
18 #include <linux/config.h>
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
22 #include <linux/spinlock.h>
23 #include <linux/errno.h>
24 #include <linux/tty.h>
25 #include <linux/tty_flip.h>
26 #include <linux/major.h>
27 #include <linux/string.h>
28 #include <linux/ptrace.h>
29 #include <linux/ioport.h>
30 #include <linux/circ_buf.h>
31 #include <linux/serial.h>
32 #include <linux/sysrq.h>
33 #include <linux/console.h>
34 #ifdef CONFIG_SERIO
35 #include <linux/serio.h>
36 #endif
37 #include <linux/serial_reg.h>
38 #include <linux/init.h>
39 #include <linux/delay.h>
40
41 #include <asm/io.h>
42 #include <asm/irq.h>
43 #include <asm/oplib.h>
44 #include <asm/ebus.h>
45 #ifdef CONFIG_SPARC64
46 #include <asm/isa.h>
47 #endif
48
49 #if defined(CONFIG_SERIAL_SUNSU_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
50 #define SUPPORT_SYSRQ
51 #endif
52
53 #include <linux/serial_core.h>
54
55 #include "suncore.h"
56
57 /* We are on a NS PC87303 clocked with 24.0 MHz, which results
58 * in a UART clock of 1.8462 MHz.
59 */
60 #define SU_BASE_BAUD (1846200 / 16)
61
62 enum su_type { SU_PORT_NONE, SU_PORT_MS, SU_PORT_KBD, SU_PORT_PORT };
63 static char *su_typev[] = { "su(???)", "su(mouse)", "su(kbd)", "su(serial)" };
64
65 /*
66 * Here we define the default xmit fifo size used for each type of UART.
67 */
68 static const struct serial_uart_config uart_config[PORT_MAX_8250+1] = {
69 { "unknown", 1, 0 },
70 { "8250", 1, 0 },
71 { "16450", 1, 0 },
72 { "16550", 1, 0 },
73 { "16550A", 16, UART_CLEAR_FIFO | UART_USE_FIFO },
74 { "Cirrus", 1, 0 },
75 { "ST16650", 1, UART_CLEAR_FIFO | UART_STARTECH },
76 { "ST16650V2", 32, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
77 { "TI16750", 64, UART_CLEAR_FIFO | UART_USE_FIFO },
78 { "Startech", 1, 0 },
79 { "16C950/954", 128, UART_CLEAR_FIFO | UART_USE_FIFO },
80 { "ST16654", 64, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
81 { "XR16850", 128, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
82 { "RSA", 2048, UART_CLEAR_FIFO | UART_USE_FIFO }
83 };
84
85 struct uart_sunsu_port {
86 struct uart_port port;
87 unsigned char acr;
88 unsigned char ier;
89 unsigned short rev;
90 unsigned char lcr;
91 unsigned int lsr_break_flag;
92 unsigned int cflag;
93
94 /* Probing information. */
95 enum su_type su_type;
96 unsigned int type_probed; /* XXX Stupid */
97 int port_node;
98
99 #ifdef CONFIG_SERIO
100 struct serio *serio;
101 int serio_open;
102 #endif
103 };
104
105 static unsigned int serial_in(struct uart_sunsu_port *up, int offset)
106 {
107 offset <<= up->port.regshift;
108
109 switch (up->port.iotype) {
110 case UPIO_HUB6:
111 outb(up->port.hub6 - 1 + offset, up->port.iobase);
112 return inb(up->port.iobase + 1);
113
114 case UPIO_MEM:
115 return readb(up->port.membase + offset);
116
117 default:
118 return inb(up->port.iobase + offset);
119 }
120 }
121
122 static void serial_out(struct uart_sunsu_port *up, int offset, int value)
123 {
124 #ifndef CONFIG_SPARC64
125 /*
126 * MrCoffee has weird schematics: IRQ4 & P10(?) pins of SuperIO are
127 * connected with a gate then go to SlavIO. When IRQ4 goes tristated
128 * gate outputs a logical one. Since we use level triggered interrupts
129 * we have lockup and watchdog reset. We cannot mask IRQ because
130 * keyboard shares IRQ with us (Word has it as Bob Smelik's design).
131 * This problem is similar to what Alpha people suffer, see serial.c.
132 */
133 if (offset == UART_MCR)
134 value |= UART_MCR_OUT2;
135 #endif
136 offset <<= up->port.regshift;
137
138 switch (up->port.iotype) {
139 case UPIO_HUB6:
140 outb(up->port.hub6 - 1 + offset, up->port.iobase);
141 outb(value, up->port.iobase + 1);
142 break;
143
144 case UPIO_MEM:
145 writeb(value, up->port.membase + offset);
146 break;
147
148 default:
149 outb(value, up->port.iobase + offset);
150 }
151 }
152
153 /*
154 * We used to support using pause I/O for certain machines. We
155 * haven't supported this for a while, but just in case it's badly
156 * needed for certain old 386 machines, I've left these #define's
157 * in....
158 */
159 #define serial_inp(up, offset) serial_in(up, offset)
160 #define serial_outp(up, offset, value) serial_out(up, offset, value)
161
162
163 /*
164 * For the 16C950
165 */
166 static void serial_icr_write(struct uart_sunsu_port *up, int offset, int value)
167 {
168 serial_out(up, UART_SCR, offset);
169 serial_out(up, UART_ICR, value);
170 }
171
172 #if 0 /* Unused currently */
173 static unsigned int serial_icr_read(struct uart_sunsu_port *up, int offset)
174 {
175 unsigned int value;
176
177 serial_icr_write(up, UART_ACR, up->acr | UART_ACR_ICRRD);
178 serial_out(up, UART_SCR, offset);
179 value = serial_in(up, UART_ICR);
180 serial_icr_write(up, UART_ACR, up->acr);
181
182 return value;
183 }
184 #endif
185
186 #ifdef CONFIG_SERIAL_8250_RSA
187 /*
188 * Attempts to turn on the RSA FIFO. Returns zero on failure.
189 * We set the port uart clock rate if we succeed.
190 */
191 static int __enable_rsa(struct uart_sunsu_port *up)
192 {
193 unsigned char mode;
194 int result;
195
196 mode = serial_inp(up, UART_RSA_MSR);
197 result = mode & UART_RSA_MSR_FIFO;
198
199 if (!result) {
200 serial_outp(up, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO);
201 mode = serial_inp(up, UART_RSA_MSR);
202 result = mode & UART_RSA_MSR_FIFO;
203 }
204
205 if (result)
206 up->port.uartclk = SERIAL_RSA_BAUD_BASE * 16;
207
208 return result;
209 }
210
211 static void enable_rsa(struct uart_sunsu_port *up)
212 {
213 if (up->port.type == PORT_RSA) {
214 if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) {
215 spin_lock_irq(&up->port.lock);
216 __enable_rsa(up);
217 spin_unlock_irq(&up->port.lock);
218 }
219 if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16)
220 serial_outp(up, UART_RSA_FRR, 0);
221 }
222 }
223
224 /*
225 * Attempts to turn off the RSA FIFO. Returns zero on failure.
226 * It is unknown why interrupts were disabled in here. However,
227 * the caller is expected to preserve this behaviour by grabbing
228 * the spinlock before calling this function.
229 */
230 static void disable_rsa(struct uart_sunsu_port *up)
231 {
232 unsigned char mode;
233 int result;
234
235 if (up->port.type == PORT_RSA &&
236 up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) {
237 spin_lock_irq(&up->port.lock);
238
239 mode = serial_inp(up, UART_RSA_MSR);
240 result = !(mode & UART_RSA_MSR_FIFO);
241
242 if (!result) {
243 serial_outp(up, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO);
244 mode = serial_inp(up, UART_RSA_MSR);
245 result = !(mode & UART_RSA_MSR_FIFO);
246 }
247
248 if (result)
249 up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
250 spin_unlock_irq(&up->port.lock);
251 }
252 }
253 #endif /* CONFIG_SERIAL_8250_RSA */
254
255 static inline void __stop_tx(struct uart_sunsu_port *p)
256 {
257 if (p->ier & UART_IER_THRI) {
258 p->ier &= ~UART_IER_THRI;
259 serial_out(p, UART_IER, p->ier);
260 }
261 }
262
263 static void sunsu_stop_tx(struct uart_port *port)
264 {
265 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
266
267 __stop_tx(up);
268
269 /*
270 * We really want to stop the transmitter from sending.
271 */
272 if (up->port.type == PORT_16C950) {
273 up->acr |= UART_ACR_TXDIS;
274 serial_icr_write(up, UART_ACR, up->acr);
275 }
276 }
277
278 static void sunsu_start_tx(struct uart_port *port)
279 {
280 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
281
282 if (!(up->ier & UART_IER_THRI)) {
283 up->ier |= UART_IER_THRI;
284 serial_out(up, UART_IER, up->ier);
285 }
286
287 /*
288 * Re-enable the transmitter if we disabled it.
289 */
290 if (up->port.type == PORT_16C950 && up->acr & UART_ACR_TXDIS) {
291 up->acr &= ~UART_ACR_TXDIS;
292 serial_icr_write(up, UART_ACR, up->acr);
293 }
294 }
295
296 static void sunsu_stop_rx(struct uart_port *port)
297 {
298 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
299
300 up->ier &= ~UART_IER_RLSI;
301 up->port.read_status_mask &= ~UART_LSR_DR;
302 serial_out(up, UART_IER, up->ier);
303 }
304
305 static void sunsu_enable_ms(struct uart_port *port)
306 {
307 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
308 unsigned long flags;
309
310 spin_lock_irqsave(&up->port.lock, flags);
311 up->ier |= UART_IER_MSI;
312 serial_out(up, UART_IER, up->ier);
313 spin_unlock_irqrestore(&up->port.lock, flags);
314 }
315
316 static struct tty_struct *
317 receive_chars(struct uart_sunsu_port *up, unsigned char *status, struct pt_regs *regs)
318 {
319 struct tty_struct *tty = up->port.info->tty;
320 unsigned char ch, flag;
321 int max_count = 256;
322 int saw_console_brk = 0;
323
324 do {
325 ch = serial_inp(up, UART_RX);
326 flag = TTY_NORMAL;
327 up->port.icount.rx++;
328
329 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
330 UART_LSR_FE | UART_LSR_OE))) {
331 /*
332 * For statistics only
333 */
334 if (*status & UART_LSR_BI) {
335 *status &= ~(UART_LSR_FE | UART_LSR_PE);
336 up->port.icount.brk++;
337 if (up->port.cons != NULL &&
338 up->port.line == up->port.cons->index)
339 saw_console_brk = 1;
340 /*
341 * We do the SysRQ and SAK checking
342 * here because otherwise the break
343 * may get masked by ignore_status_mask
344 * or read_status_mask.
345 */
346 if (uart_handle_break(&up->port))
347 goto ignore_char;
348 } else if (*status & UART_LSR_PE)
349 up->port.icount.parity++;
350 else if (*status & UART_LSR_FE)
351 up->port.icount.frame++;
352 if (*status & UART_LSR_OE)
353 up->port.icount.overrun++;
354
355 /*
356 * Mask off conditions which should be ingored.
357 */
358 *status &= up->port.read_status_mask;
359
360 if (up->port.cons != NULL &&
361 up->port.line == up->port.cons->index) {
362 /* Recover the break flag from console xmit */
363 *status |= up->lsr_break_flag;
364 up->lsr_break_flag = 0;
365 }
366
367 if (*status & UART_LSR_BI) {
368 flag = TTY_BREAK;
369 } else if (*status & UART_LSR_PE)
370 flag = TTY_PARITY;
371 else if (*status & UART_LSR_FE)
372 flag = TTY_FRAME;
373 }
374 if (uart_handle_sysrq_char(&up->port, ch, regs))
375 goto ignore_char;
376 if ((*status & up->port.ignore_status_mask) == 0)
377 tty_insert_flip_char(tty, ch, flag);
378 if (*status & UART_LSR_OE)
379 /*
380 * Overrun is special, since it's reported
381 * immediately, and doesn't affect the current
382 * character.
383 */
384 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
385 ignore_char:
386 *status = serial_inp(up, UART_LSR);
387 } while ((*status & UART_LSR_DR) && (max_count-- > 0));
388
389 if (saw_console_brk)
390 sun_do_break();
391
392 return tty;
393 }
394
395 static void transmit_chars(struct uart_sunsu_port *up)
396 {
397 struct circ_buf *xmit = &up->port.info->xmit;
398 int count;
399
400 if (up->port.x_char) {
401 serial_outp(up, UART_TX, up->port.x_char);
402 up->port.icount.tx++;
403 up->port.x_char = 0;
404 return;
405 }
406 if (uart_tx_stopped(&up->port)) {
407 sunsu_stop_tx(&up->port);
408 return;
409 }
410 if (uart_circ_empty(xmit)) {
411 __stop_tx(up);
412 return;
413 }
414
415 count = up->port.fifosize;
416 do {
417 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
418 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
419 up->port.icount.tx++;
420 if (uart_circ_empty(xmit))
421 break;
422 } while (--count > 0);
423
424 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
425 uart_write_wakeup(&up->port);
426
427 if (uart_circ_empty(xmit))
428 __stop_tx(up);
429 }
430
431 static void check_modem_status(struct uart_sunsu_port *up)
432 {
433 int status;
434
435 status = serial_in(up, UART_MSR);
436
437 if ((status & UART_MSR_ANY_DELTA) == 0)
438 return;
439
440 if (status & UART_MSR_TERI)
441 up->port.icount.rng++;
442 if (status & UART_MSR_DDSR)
443 up->port.icount.dsr++;
444 if (status & UART_MSR_DDCD)
445 uart_handle_dcd_change(&up->port, status & UART_MSR_DCD);
446 if (status & UART_MSR_DCTS)
447 uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
448
449 wake_up_interruptible(&up->port.info->delta_msr_wait);
450 }
451
452 static irqreturn_t sunsu_serial_interrupt(int irq, void *dev_id, struct pt_regs *regs)
453 {
454 struct uart_sunsu_port *up = dev_id;
455 unsigned long flags;
456 unsigned char status;
457
458 spin_lock_irqsave(&up->port.lock, flags);
459
460 do {
461 struct tty_struct *tty;
462
463 status = serial_inp(up, UART_LSR);
464 tty = NULL;
465 if (status & UART_LSR_DR)
466 tty = receive_chars(up, &status, regs);
467 check_modem_status(up);
468 if (status & UART_LSR_THRE)
469 transmit_chars(up);
470
471 spin_unlock_irqrestore(&up->port.lock, flags);
472
473 if (tty)
474 tty_flip_buffer_push(tty);
475
476 spin_lock_irqsave(&up->port.lock, flags);
477
478 } while (!(serial_in(up, UART_IIR) & UART_IIR_NO_INT));
479
480 spin_unlock_irqrestore(&up->port.lock, flags);
481
482 return IRQ_HANDLED;
483 }
484
485 /* Separate interrupt handling path for keyboard/mouse ports. */
486
487 static void
488 sunsu_change_speed(struct uart_port *port, unsigned int cflag,
489 unsigned int iflag, unsigned int quot);
490
491 static void sunsu_change_mouse_baud(struct uart_sunsu_port *up)
492 {
493 unsigned int cur_cflag = up->cflag;
494 int quot, new_baud;
495
496 up->cflag &= ~CBAUD;
497 up->cflag |= suncore_mouse_baud_cflag_next(cur_cflag, &new_baud);
498
499 quot = up->port.uartclk / (16 * new_baud);
500
501 sunsu_change_speed(&up->port, up->cflag, 0, quot);
502 }
503
504 static void receive_kbd_ms_chars(struct uart_sunsu_port *up, struct pt_regs *regs, int is_break)
505 {
506 do {
507 unsigned char ch = serial_inp(up, UART_RX);
508
509 /* Stop-A is handled by drivers/char/keyboard.c now. */
510 if (up->su_type == SU_PORT_KBD) {
511 #ifdef CONFIG_SERIO
512 serio_interrupt(up->serio, ch, 0, regs);
513 #endif
514 } else if (up->su_type == SU_PORT_MS) {
515 int ret = suncore_mouse_baud_detection(ch, is_break);
516
517 switch (ret) {
518 case 2:
519 sunsu_change_mouse_baud(up);
520 /* fallthru */
521 case 1:
522 break;
523
524 case 0:
525 #ifdef CONFIG_SERIO
526 serio_interrupt(up->serio, ch, 0, regs);
527 #endif
528 break;
529 };
530 }
531 } while (serial_in(up, UART_LSR) & UART_LSR_DR);
532 }
533
534 static irqreturn_t sunsu_kbd_ms_interrupt(int irq, void *dev_id, struct pt_regs *regs)
535 {
536 struct uart_sunsu_port *up = dev_id;
537
538 if (!(serial_in(up, UART_IIR) & UART_IIR_NO_INT)) {
539 unsigned char status = serial_inp(up, UART_LSR);
540
541 if ((status & UART_LSR_DR) || (status & UART_LSR_BI))
542 receive_kbd_ms_chars(up, regs,
543 (status & UART_LSR_BI) != 0);
544 }
545
546 return IRQ_HANDLED;
547 }
548
549 static unsigned int sunsu_tx_empty(struct uart_port *port)
550 {
551 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
552 unsigned long flags;
553 unsigned int ret;
554
555 spin_lock_irqsave(&up->port.lock, flags);
556 ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
557 spin_unlock_irqrestore(&up->port.lock, flags);
558
559 return ret;
560 }
561
562 static unsigned int sunsu_get_mctrl(struct uart_port *port)
563 {
564 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
565 unsigned char status;
566 unsigned int ret;
567
568 status = serial_in(up, UART_MSR);
569
570 ret = 0;
571 if (status & UART_MSR_DCD)
572 ret |= TIOCM_CAR;
573 if (status & UART_MSR_RI)
574 ret |= TIOCM_RNG;
575 if (status & UART_MSR_DSR)
576 ret |= TIOCM_DSR;
577 if (status & UART_MSR_CTS)
578 ret |= TIOCM_CTS;
579 return ret;
580 }
581
582 static void sunsu_set_mctrl(struct uart_port *port, unsigned int mctrl)
583 {
584 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
585 unsigned char mcr = 0;
586
587 if (mctrl & TIOCM_RTS)
588 mcr |= UART_MCR_RTS;
589 if (mctrl & TIOCM_DTR)
590 mcr |= UART_MCR_DTR;
591 if (mctrl & TIOCM_OUT1)
592 mcr |= UART_MCR_OUT1;
593 if (mctrl & TIOCM_OUT2)
594 mcr |= UART_MCR_OUT2;
595 if (mctrl & TIOCM_LOOP)
596 mcr |= UART_MCR_LOOP;
597
598 serial_out(up, UART_MCR, mcr);
599 }
600
601 static void sunsu_break_ctl(struct uart_port *port, int break_state)
602 {
603 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
604 unsigned long flags;
605
606 spin_lock_irqsave(&up->port.lock, flags);
607 if (break_state == -1)
608 up->lcr |= UART_LCR_SBC;
609 else
610 up->lcr &= ~UART_LCR_SBC;
611 serial_out(up, UART_LCR, up->lcr);
612 spin_unlock_irqrestore(&up->port.lock, flags);
613 }
614
615 static int sunsu_startup(struct uart_port *port)
616 {
617 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
618 unsigned long flags;
619 int retval;
620
621 if (up->port.type == PORT_16C950) {
622 /* Wake up and initialize UART */
623 up->acr = 0;
624 serial_outp(up, UART_LCR, 0xBF);
625 serial_outp(up, UART_EFR, UART_EFR_ECB);
626 serial_outp(up, UART_IER, 0);
627 serial_outp(up, UART_LCR, 0);
628 serial_icr_write(up, UART_CSR, 0); /* Reset the UART */
629 serial_outp(up, UART_LCR, 0xBF);
630 serial_outp(up, UART_EFR, UART_EFR_ECB);
631 serial_outp(up, UART_LCR, 0);
632 }
633
634 #ifdef CONFIG_SERIAL_8250_RSA
635 /*
636 * If this is an RSA port, see if we can kick it up to the
637 * higher speed clock.
638 */
639 enable_rsa(up);
640 #endif
641
642 /*
643 * Clear the FIFO buffers and disable them.
644 * (they will be reenabled in set_termios())
645 */
646 if (uart_config[up->port.type].flags & UART_CLEAR_FIFO) {
647 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
648 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO |
649 UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
650 serial_outp(up, UART_FCR, 0);
651 }
652
653 /*
654 * Clear the interrupt registers.
655 */
656 (void) serial_inp(up, UART_LSR);
657 (void) serial_inp(up, UART_RX);
658 (void) serial_inp(up, UART_IIR);
659 (void) serial_inp(up, UART_MSR);
660
661 /*
662 * At this point, there's no way the LSR could still be 0xff;
663 * if it is, then bail out, because there's likely no UART
664 * here.
665 */
666 if (!(up->port.flags & UPF_BUGGY_UART) &&
667 (serial_inp(up, UART_LSR) == 0xff)) {
668 printk("ttyS%d: LSR safety check engaged!\n", up->port.line);
669 return -ENODEV;
670 }
671
672 if (up->su_type != SU_PORT_PORT) {
673 retval = request_irq(up->port.irq, sunsu_kbd_ms_interrupt,
674 SA_SHIRQ, su_typev[up->su_type], up);
675 } else {
676 retval = request_irq(up->port.irq, sunsu_serial_interrupt,
677 SA_SHIRQ, su_typev[up->su_type], up);
678 }
679 if (retval) {
680 printk("su: Cannot register IRQ %d\n", up->port.irq);
681 return retval;
682 }
683
684 /*
685 * Now, initialize the UART
686 */
687 serial_outp(up, UART_LCR, UART_LCR_WLEN8);
688
689 spin_lock_irqsave(&up->port.lock, flags);
690
691 up->port.mctrl |= TIOCM_OUT2;
692
693 sunsu_set_mctrl(&up->port, up->port.mctrl);
694 spin_unlock_irqrestore(&up->port.lock, flags);
695
696 /*
697 * Finally, enable interrupts. Note: Modem status interrupts
698 * are set via set_termios(), which will be occurring imminently
699 * anyway, so we don't enable them here.
700 */
701 up->ier = UART_IER_RLSI | UART_IER_RDI;
702 serial_outp(up, UART_IER, up->ier);
703
704 if (up->port.flags & UPF_FOURPORT) {
705 unsigned int icp;
706 /*
707 * Enable interrupts on the AST Fourport board
708 */
709 icp = (up->port.iobase & 0xfe0) | 0x01f;
710 outb_p(0x80, icp);
711 (void) inb_p(icp);
712 }
713
714 /*
715 * And clear the interrupt registers again for luck.
716 */
717 (void) serial_inp(up, UART_LSR);
718 (void) serial_inp(up, UART_RX);
719 (void) serial_inp(up, UART_IIR);
720 (void) serial_inp(up, UART_MSR);
721
722 return 0;
723 }
724
725 static void sunsu_shutdown(struct uart_port *port)
726 {
727 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
728 unsigned long flags;
729
730 /*
731 * Disable interrupts from this port
732 */
733 up->ier = 0;
734 serial_outp(up, UART_IER, 0);
735
736 spin_lock_irqsave(&up->port.lock, flags);
737 if (up->port.flags & UPF_FOURPORT) {
738 /* reset interrupts on the AST Fourport board */
739 inb((up->port.iobase & 0xfe0) | 0x1f);
740 up->port.mctrl |= TIOCM_OUT1;
741 } else
742 up->port.mctrl &= ~TIOCM_OUT2;
743
744 sunsu_set_mctrl(&up->port, up->port.mctrl);
745 spin_unlock_irqrestore(&up->port.lock, flags);
746
747 /*
748 * Disable break condition and FIFOs
749 */
750 serial_out(up, UART_LCR, serial_inp(up, UART_LCR) & ~UART_LCR_SBC);
751 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO |
752 UART_FCR_CLEAR_RCVR |
753 UART_FCR_CLEAR_XMIT);
754 serial_outp(up, UART_FCR, 0);
755
756 #ifdef CONFIG_SERIAL_8250_RSA
757 /*
758 * Reset the RSA board back to 115kbps compat mode.
759 */
760 disable_rsa(up);
761 #endif
762
763 /*
764 * Read data port to reset things.
765 */
766 (void) serial_in(up, UART_RX);
767
768 free_irq(up->port.irq, up);
769 }
770
771 static void
772 sunsu_change_speed(struct uart_port *port, unsigned int cflag,
773 unsigned int iflag, unsigned int quot)
774 {
775 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
776 unsigned char cval, fcr = 0;
777 unsigned long flags;
778
779 switch (cflag & CSIZE) {
780 case CS5:
781 cval = 0x00;
782 break;
783 case CS6:
784 cval = 0x01;
785 break;
786 case CS7:
787 cval = 0x02;
788 break;
789 default:
790 case CS8:
791 cval = 0x03;
792 break;
793 }
794
795 if (cflag & CSTOPB)
796 cval |= 0x04;
797 if (cflag & PARENB)
798 cval |= UART_LCR_PARITY;
799 if (!(cflag & PARODD))
800 cval |= UART_LCR_EPAR;
801 #ifdef CMSPAR
802 if (cflag & CMSPAR)
803 cval |= UART_LCR_SPAR;
804 #endif
805
806 /*
807 * Work around a bug in the Oxford Semiconductor 952 rev B
808 * chip which causes it to seriously miscalculate baud rates
809 * when DLL is 0.
810 */
811 if ((quot & 0xff) == 0 && up->port.type == PORT_16C950 &&
812 up->rev == 0x5201)
813 quot ++;
814
815 if (uart_config[up->port.type].flags & UART_USE_FIFO) {
816 if ((up->port.uartclk / quot) < (2400 * 16))
817 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
818 #ifdef CONFIG_SERIAL_8250_RSA
819 else if (up->port.type == PORT_RSA)
820 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_14;
821 #endif
822 else
823 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
824 }
825 if (up->port.type == PORT_16750)
826 fcr |= UART_FCR7_64BYTE;
827
828 /*
829 * Ok, we're now changing the port state. Do it with
830 * interrupts disabled.
831 */
832 spin_lock_irqsave(&up->port.lock, flags);
833
834 /*
835 * Update the per-port timeout.
836 */
837 uart_update_timeout(port, cflag, (port->uartclk / (16 * quot)));
838
839 up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
840 if (iflag & INPCK)
841 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
842 if (iflag & (BRKINT | PARMRK))
843 up->port.read_status_mask |= UART_LSR_BI;
844
845 /*
846 * Characteres to ignore
847 */
848 up->port.ignore_status_mask = 0;
849 if (iflag & IGNPAR)
850 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
851 if (iflag & IGNBRK) {
852 up->port.ignore_status_mask |= UART_LSR_BI;
853 /*
854 * If we're ignoring parity and break indicators,
855 * ignore overruns too (for real raw support).
856 */
857 if (iflag & IGNPAR)
858 up->port.ignore_status_mask |= UART_LSR_OE;
859 }
860
861 /*
862 * ignore all characters if CREAD is not set
863 */
864 if ((cflag & CREAD) == 0)
865 up->port.ignore_status_mask |= UART_LSR_DR;
866
867 /*
868 * CTS flow control flag and modem status interrupts
869 */
870 up->ier &= ~UART_IER_MSI;
871 if (UART_ENABLE_MS(&up->port, cflag))
872 up->ier |= UART_IER_MSI;
873
874 serial_out(up, UART_IER, up->ier);
875
876 if (uart_config[up->port.type].flags & UART_STARTECH) {
877 serial_outp(up, UART_LCR, 0xBF);
878 serial_outp(up, UART_EFR, cflag & CRTSCTS ? UART_EFR_CTS :0);
879 }
880 serial_outp(up, UART_LCR, cval | UART_LCR_DLAB);/* set DLAB */
881 serial_outp(up, UART_DLL, quot & 0xff); /* LS of divisor */
882 serial_outp(up, UART_DLM, quot >> 8); /* MS of divisor */
883 if (up->port.type == PORT_16750)
884 serial_outp(up, UART_FCR, fcr); /* set fcr */
885 serial_outp(up, UART_LCR, cval); /* reset DLAB */
886 up->lcr = cval; /* Save LCR */
887 if (up->port.type != PORT_16750) {
888 if (fcr & UART_FCR_ENABLE_FIFO) {
889 /* emulated UARTs (Lucent Venus 167x) need two steps */
890 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
891 }
892 serial_outp(up, UART_FCR, fcr); /* set fcr */
893 }
894
895 up->cflag = cflag;
896
897 spin_unlock_irqrestore(&up->port.lock, flags);
898 }
899
900 static void
901 sunsu_set_termios(struct uart_port *port, struct termios *termios,
902 struct termios *old)
903 {
904 unsigned int baud, quot;
905
906 /*
907 * Ask the core to calculate the divisor for us.
908 */
909 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
910 quot = uart_get_divisor(port, baud);
911
912 sunsu_change_speed(port, termios->c_cflag, termios->c_iflag, quot);
913 }
914
915 static void sunsu_release_port(struct uart_port *port)
916 {
917 }
918
919 static int sunsu_request_port(struct uart_port *port)
920 {
921 return 0;
922 }
923
924 static void sunsu_config_port(struct uart_port *port, int flags)
925 {
926 struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
927
928 if (flags & UART_CONFIG_TYPE) {
929 /*
930 * We are supposed to call autoconfig here, but this requires
931 * splitting all the OBP probing crap from the UART probing.
932 * We'll do it when we kill sunsu.c altogether.
933 */
934 port->type = up->type_probed; /* XXX */
935 }
936 }
937
938 static int
939 sunsu_verify_port(struct uart_port *port, struct serial_struct *ser)
940 {
941 return -EINVAL;
942 }
943
944 static const char *
945 sunsu_type(struct uart_port *port)
946 {
947 int type = port->type;
948
949 if (type >= ARRAY_SIZE(uart_config))
950 type = 0;
951 return uart_config[type].name;
952 }
953
954 static struct uart_ops sunsu_pops = {
955 .tx_empty = sunsu_tx_empty,
956 .set_mctrl = sunsu_set_mctrl,
957 .get_mctrl = sunsu_get_mctrl,
958 .stop_tx = sunsu_stop_tx,
959 .start_tx = sunsu_start_tx,
960 .stop_rx = sunsu_stop_rx,
961 .enable_ms = sunsu_enable_ms,
962 .break_ctl = sunsu_break_ctl,
963 .startup = sunsu_startup,
964 .shutdown = sunsu_shutdown,
965 .set_termios = sunsu_set_termios,
966 .type = sunsu_type,
967 .release_port = sunsu_release_port,
968 .request_port = sunsu_request_port,
969 .config_port = sunsu_config_port,
970 .verify_port = sunsu_verify_port,
971 };
972
973 #define UART_NR 4
974
975 static struct uart_sunsu_port sunsu_ports[UART_NR];
976
977 #ifdef CONFIG_SERIO
978
979 static DEFINE_SPINLOCK(sunsu_serio_lock);
980
981 static int sunsu_serio_write(struct serio *serio, unsigned char ch)
982 {
983 struct uart_sunsu_port *up = serio->port_data;
984 unsigned long flags;
985 int lsr;
986
987 spin_lock_irqsave(&sunsu_serio_lock, flags);
988
989 do {
990 lsr = serial_in(up, UART_LSR);
991 } while (!(lsr & UART_LSR_THRE));
992
993 /* Send the character out. */
994 serial_out(up, UART_TX, ch);
995
996 spin_unlock_irqrestore(&sunsu_serio_lock, flags);
997
998 return 0;
999 }
1000
1001 static int sunsu_serio_open(struct serio *serio)
1002 {
1003 struct uart_sunsu_port *up = serio->port_data;
1004 unsigned long flags;
1005 int ret;
1006
1007 spin_lock_irqsave(&sunsu_serio_lock, flags);
1008 if (!up->serio_open) {
1009 up->serio_open = 1;
1010 ret = 0;
1011 } else
1012 ret = -EBUSY;
1013 spin_unlock_irqrestore(&sunsu_serio_lock, flags);
1014
1015 return ret;
1016 }
1017
1018 static void sunsu_serio_close(struct serio *serio)
1019 {
1020 struct uart_sunsu_port *up = serio->port_data;
1021 unsigned long flags;
1022
1023 spin_lock_irqsave(&sunsu_serio_lock, flags);
1024 up->serio_open = 0;
1025 spin_unlock_irqrestore(&sunsu_serio_lock, flags);
1026 }
1027
1028 #endif /* CONFIG_SERIO */
1029
1030 static void sunsu_autoconfig(struct uart_sunsu_port *up)
1031 {
1032 unsigned char status1, status2, scratch, scratch2, scratch3;
1033 unsigned char save_lcr, save_mcr;
1034 struct linux_ebus_device *dev = NULL;
1035 struct linux_ebus *ebus;
1036 #ifdef CONFIG_SPARC64
1037 struct sparc_isa_bridge *isa_br;
1038 struct sparc_isa_device *isa_dev;
1039 #endif
1040 #ifndef CONFIG_SPARC64
1041 struct linux_prom_registers reg0;
1042 #endif
1043 unsigned long flags;
1044
1045 if (!up->port_node || !up->su_type)
1046 return;
1047
1048 up->type_probed = PORT_UNKNOWN;
1049 up->port.iotype = UPIO_MEM;
1050
1051 /*
1052 * First we look for Ebus-bases su's
1053 */
1054 for_each_ebus(ebus) {
1055 for_each_ebusdev(dev, ebus) {
1056 if (dev->prom_node == up->port_node) {
1057 /*
1058 * The EBus is broken on sparc; it delivers
1059 * virtual addresses in resources. Oh well...
1060 * This is correct on sparc64, though.
1061 */
1062 up->port.membase = (char *) dev->resource[0].start;
1063 /*
1064 * This is correct on both architectures.
1065 */
1066 up->port.mapbase = dev->resource[0].start;
1067 up->port.irq = dev->irqs[0];
1068 goto ebus_done;
1069 }
1070 }
1071 }
1072
1073 #ifdef CONFIG_SPARC64
1074 for_each_isa(isa_br) {
1075 for_each_isadev(isa_dev, isa_br) {
1076 if (isa_dev->prom_node == up->port_node) {
1077 /* Same on sparc64. Cool architecure... */
1078 up->port.membase = (char *) isa_dev->resource.start;
1079 up->port.mapbase = isa_dev->resource.start;
1080 up->port.irq = isa_dev->irq;
1081 goto ebus_done;
1082 }
1083 }
1084 }
1085 #endif
1086
1087 #ifdef CONFIG_SPARC64
1088 /*
1089 * Not on Ebus, bailing.
1090 */
1091 return;
1092 #else
1093 /*
1094 * Not on Ebus, must be OBIO.
1095 */
1096 if (prom_getproperty(up->port_node, "reg",
1097 (char *)&reg0, sizeof(reg0)) == -1) {
1098 prom_printf("sunsu: no \"reg\" property\n");
1099 return;
1100 }
1101 prom_apply_obio_ranges(&reg0, 1);
1102 if (reg0.which_io != 0) { /* Just in case... */
1103 prom_printf("sunsu: bus number nonzero: 0x%x:%x\n",
1104 reg0.which_io, reg0.phys_addr);
1105 return;
1106 }
1107 up->port.mapbase = reg0.phys_addr;
1108 if ((up->port.membase = ioremap(reg0.phys_addr, reg0.reg_size)) == 0) {
1109 prom_printf("sunsu: Cannot map registers.\n");
1110 return;
1111 }
1112
1113 /*
1114 * 0x20 is sun4m thing, Dave Redman heritage.
1115 * See arch/sparc/kernel/irq.c.
1116 */
1117 #define IRQ_4M(n) ((n)|0x20)
1118
1119 /*
1120 * There is no intr property on MrCoffee, so hardwire it.
1121 */
1122 up->port.irq = IRQ_4M(13);
1123 #endif
1124
1125 ebus_done:
1126
1127 spin_lock_irqsave(&up->port.lock, flags);
1128
1129 if (!(up->port.flags & UPF_BUGGY_UART)) {
1130 /*
1131 * Do a simple existence test first; if we fail this, there's
1132 * no point trying anything else.
1133 *
1134 * 0x80 is used as a nonsense port to prevent against false
1135 * positives due to ISA bus float. The assumption is that
1136 * 0x80 is a non-existent port; which should be safe since
1137 * include/asm/io.h also makes this assumption.
1138 */
1139 scratch = serial_inp(up, UART_IER);
1140 serial_outp(up, UART_IER, 0);
1141 #ifdef __i386__
1142 outb(0xff, 0x080);
1143 #endif
1144 scratch2 = serial_inp(up, UART_IER);
1145 serial_outp(up, UART_IER, 0x0f);
1146 #ifdef __i386__
1147 outb(0, 0x080);
1148 #endif
1149 scratch3 = serial_inp(up, UART_IER);
1150 serial_outp(up, UART_IER, scratch);
1151 if (scratch2 != 0 || scratch3 != 0x0F)
1152 goto out; /* We failed; there's nothing here */
1153 }
1154
1155 save_mcr = serial_in(up, UART_MCR);
1156 save_lcr = serial_in(up, UART_LCR);
1157
1158 /*
1159 * Check to see if a UART is really there. Certain broken
1160 * internal modems based on the Rockwell chipset fail this
1161 * test, because they apparently don't implement the loopback
1162 * test mode. So this test is skipped on the COM 1 through
1163 * COM 4 ports. This *should* be safe, since no board
1164 * manufacturer would be stupid enough to design a board
1165 * that conflicts with COM 1-4 --- we hope!
1166 */
1167 if (!(up->port.flags & UPF_SKIP_TEST)) {
1168 serial_outp(up, UART_MCR, UART_MCR_LOOP | 0x0A);
1169 status1 = serial_inp(up, UART_MSR) & 0xF0;
1170 serial_outp(up, UART_MCR, save_mcr);
1171 if (status1 != 0x90)
1172 goto out; /* We failed loopback test */
1173 }
1174 serial_outp(up, UART_LCR, 0xBF); /* set up for StarTech test */
1175 serial_outp(up, UART_EFR, 0); /* EFR is the same as FCR */
1176 serial_outp(up, UART_LCR, 0);
1177 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1178 scratch = serial_in(up, UART_IIR) >> 6;
1179 switch (scratch) {
1180 case 0:
1181 up->port.type = PORT_16450;
1182 break;
1183 case 1:
1184 up->port.type = PORT_UNKNOWN;
1185 break;
1186 case 2:
1187 up->port.type = PORT_16550;
1188 break;
1189 case 3:
1190 up->port.type = PORT_16550A;
1191 break;
1192 }
1193 if (up->port.type == PORT_16550A) {
1194 /* Check for Startech UART's */
1195 serial_outp(up, UART_LCR, UART_LCR_DLAB);
1196 if (serial_in(up, UART_EFR) == 0) {
1197 up->port.type = PORT_16650;
1198 } else {
1199 serial_outp(up, UART_LCR, 0xBF);
1200 if (serial_in(up, UART_EFR) == 0)
1201 up->port.type = PORT_16650V2;
1202 }
1203 }
1204 if (up->port.type == PORT_16550A) {
1205 /* Check for TI 16750 */
1206 serial_outp(up, UART_LCR, save_lcr | UART_LCR_DLAB);
1207 serial_outp(up, UART_FCR,
1208 UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
1209 scratch = serial_in(up, UART_IIR) >> 5;
1210 if (scratch == 7) {
1211 /*
1212 * If this is a 16750, and not a cheap UART
1213 * clone, then it should only go into 64 byte
1214 * mode if the UART_FCR7_64BYTE bit was set
1215 * while UART_LCR_DLAB was latched.
1216 */
1217 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1218 serial_outp(up, UART_LCR, 0);
1219 serial_outp(up, UART_FCR,
1220 UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
1221 scratch = serial_in(up, UART_IIR) >> 5;
1222 if (scratch == 6)
1223 up->port.type = PORT_16750;
1224 }
1225 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1226 }
1227 serial_outp(up, UART_LCR, save_lcr);
1228 if (up->port.type == PORT_16450) {
1229 scratch = serial_in(up, UART_SCR);
1230 serial_outp(up, UART_SCR, 0xa5);
1231 status1 = serial_in(up, UART_SCR);
1232 serial_outp(up, UART_SCR, 0x5a);
1233 status2 = serial_in(up, UART_SCR);
1234 serial_outp(up, UART_SCR, scratch);
1235
1236 if ((status1 != 0xa5) || (status2 != 0x5a))
1237 up->port.type = PORT_8250;
1238 }
1239
1240 up->port.fifosize = uart_config[up->port.type].dfl_xmit_fifo_size;
1241
1242 if (up->port.type == PORT_UNKNOWN)
1243 goto out;
1244 up->type_probed = up->port.type; /* XXX */
1245
1246 /*
1247 * Reset the UART.
1248 */
1249 #ifdef CONFIG_SERIAL_8250_RSA
1250 if (up->port.type == PORT_RSA)
1251 serial_outp(up, UART_RSA_FRR, 0);
1252 #endif
1253 serial_outp(up, UART_MCR, save_mcr);
1254 serial_outp(up, UART_FCR, (UART_FCR_ENABLE_FIFO |
1255 UART_FCR_CLEAR_RCVR |
1256 UART_FCR_CLEAR_XMIT));
1257 serial_outp(up, UART_FCR, 0);
1258 (void)serial_in(up, UART_RX);
1259 serial_outp(up, UART_IER, 0);
1260
1261 out:
1262 spin_unlock_irqrestore(&up->port.lock, flags);
1263 }
1264
1265 static struct uart_driver sunsu_reg = {
1266 .owner = THIS_MODULE,
1267 .driver_name = "serial",
1268 .devfs_name = "tts/",
1269 .dev_name = "ttyS",
1270 .major = TTY_MAJOR,
1271 };
1272
1273 static int __init sunsu_kbd_ms_init(struct uart_sunsu_port *up, int channel)
1274 {
1275 int quot, baud;
1276 #ifdef CONFIG_SERIO
1277 struct serio *serio;
1278 #endif
1279
1280 spin_lock_init(&up->port.lock);
1281 up->port.line = channel;
1282 up->port.type = PORT_UNKNOWN;
1283 up->port.uartclk = (SU_BASE_BAUD * 16);
1284
1285 if (up->su_type == SU_PORT_KBD) {
1286 up->cflag = B1200 | CS8 | CLOCAL | CREAD;
1287 baud = 1200;
1288 } else {
1289 up->cflag = B4800 | CS8 | CLOCAL | CREAD;
1290 baud = 4800;
1291 }
1292 quot = up->port.uartclk / (16 * baud);
1293
1294 sunsu_autoconfig(up);
1295 if (up->port.type == PORT_UNKNOWN)
1296 return -1;
1297
1298 printk(KERN_INFO "su%d at 0x%p (irq = %d) is a %s\n",
1299 channel,
1300 up->port.membase, up->port.irq,
1301 sunsu_type(&up->port));
1302
1303 #ifdef CONFIG_SERIO
1304 up->serio = serio = kmalloc(sizeof(struct serio), GFP_KERNEL);
1305 if (serio) {
1306 memset(serio, 0, sizeof(*serio));
1307
1308 serio->port_data = up;
1309
1310 serio->id.type = SERIO_RS232;
1311 if (up->su_type == SU_PORT_KBD) {
1312 serio->id.proto = SERIO_SUNKBD;
1313 strlcpy(serio->name, "sukbd", sizeof(serio->name));
1314 } else {
1315 serio->id.proto = SERIO_SUN;
1316 serio->id.extra = 1;
1317 strlcpy(serio->name, "sums", sizeof(serio->name));
1318 }
1319 strlcpy(serio->phys, (channel == 0 ? "su/serio0" : "su/serio1"),
1320 sizeof(serio->phys));
1321
1322 serio->write = sunsu_serio_write;
1323 serio->open = sunsu_serio_open;
1324 serio->close = sunsu_serio_close;
1325
1326 serio_register_port(serio);
1327 } else {
1328 printk(KERN_WARNING "su%d: not enough memory for serio port\n",
1329 channel);
1330 }
1331 #endif
1332
1333 sunsu_change_speed(&up->port, up->cflag, 0, quot);
1334
1335 sunsu_startup(&up->port);
1336 return 0;
1337 }
1338
1339 /*
1340 * ------------------------------------------------------------
1341 * Serial console driver
1342 * ------------------------------------------------------------
1343 */
1344
1345 #ifdef CONFIG_SERIAL_SUNSU_CONSOLE
1346
1347 #define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
1348
1349 /*
1350 * Wait for transmitter & holding register to empty
1351 */
1352 static __inline__ void wait_for_xmitr(struct uart_sunsu_port *up)
1353 {
1354 unsigned int status, tmout = 10000;
1355
1356 /* Wait up to 10ms for the character(s) to be sent. */
1357 do {
1358 status = serial_in(up, UART_LSR);
1359
1360 if (status & UART_LSR_BI)
1361 up->lsr_break_flag = UART_LSR_BI;
1362
1363 if (--tmout == 0)
1364 break;
1365 udelay(1);
1366 } while ((status & BOTH_EMPTY) != BOTH_EMPTY);
1367
1368 /* Wait up to 1s for flow control if necessary */
1369 if (up->port.flags & UPF_CONS_FLOW) {
1370 tmout = 1000000;
1371 while (--tmout &&
1372 ((serial_in(up, UART_MSR) & UART_MSR_CTS) == 0))
1373 udelay(1);
1374 }
1375 }
1376
1377 static void sunsu_console_putchar(struct uart_port *port, int ch)
1378 {
1379 struct uart_sunsu_port *up = (struct uart_sunsu_port *)port;
1380
1381 wait_for_xmitr(up);
1382 serial_out(up, UART_TX, ch);
1383 }
1384
1385 /*
1386 * Print a string to the serial port trying not to disturb
1387 * any possible real use of the port...
1388 */
1389 static void sunsu_console_write(struct console *co, const char *s,
1390 unsigned int count)
1391 {
1392 struct uart_sunsu_port *up = &sunsu_ports[co->index];
1393 unsigned int ier;
1394
1395 /*
1396 * First save the UER then disable the interrupts
1397 */
1398 ier = serial_in(up, UART_IER);
1399 serial_out(up, UART_IER, 0);
1400
1401 uart_console_write(&up->port, s, count, sunsu_console_putchar);
1402
1403 /*
1404 * Finally, wait for transmitter to become empty
1405 * and restore the IER
1406 */
1407 wait_for_xmitr(up);
1408 serial_out(up, UART_IER, ier);
1409 }
1410
1411 /*
1412 * Setup initial baud/bits/parity. We do two things here:
1413 * - construct a cflag setting for the first su_open()
1414 * - initialize the serial port
1415 * Return non-zero if we didn't find a serial port.
1416 */
1417 static int sunsu_console_setup(struct console *co, char *options)
1418 {
1419 struct uart_port *port;
1420 int baud = 9600;
1421 int bits = 8;
1422 int parity = 'n';
1423 int flow = 'n';
1424
1425 printk("Console: ttyS%d (SU)\n",
1426 (sunsu_reg.minor - 64) + co->index);
1427
1428 /*
1429 * Check whether an invalid uart number has been specified, and
1430 * if so, search for the first available port that does have
1431 * console support.
1432 */
1433 if (co->index >= UART_NR)
1434 co->index = 0;
1435 port = &sunsu_ports[co->index].port;
1436
1437 /*
1438 * Temporary fix.
1439 */
1440 spin_lock_init(&port->lock);
1441
1442 if (options)
1443 uart_parse_options(options, &baud, &parity, &bits, &flow);
1444
1445 return uart_set_options(port, co, baud, parity, bits, flow);
1446 }
1447
1448 static struct console sunsu_cons = {
1449 .name = "ttyS",
1450 .write = sunsu_console_write,
1451 .device = uart_console_device,
1452 .setup = sunsu_console_setup,
1453 .flags = CON_PRINTBUFFER,
1454 .index = -1,
1455 .data = &sunsu_reg,
1456 };
1457
1458 /*
1459 * Register console.
1460 */
1461
1462 static inline struct console *SUNSU_CONSOLE(void)
1463 {
1464 int i;
1465
1466 if (con_is_present())
1467 return NULL;
1468
1469 for (i = 0; i < UART_NR; i++) {
1470 int this_minor = sunsu_reg.minor + i;
1471
1472 if ((this_minor - 64) == (serial_console - 1))
1473 break;
1474 }
1475 if (i == UART_NR)
1476 return NULL;
1477 if (sunsu_ports[i].port_node == 0)
1478 return NULL;
1479
1480 sunsu_cons.index = i;
1481
1482 return &sunsu_cons;
1483 }
1484 #else
1485 #define SUNSU_CONSOLE() (NULL)
1486 #define sunsu_serial_console_init() do { } while (0)
1487 #endif
1488
1489 static int __init sunsu_serial_init(void)
1490 {
1491 int instance, ret, i;
1492
1493 /* How many instances do we need? */
1494 instance = 0;
1495 for (i = 0; i < UART_NR; i++) {
1496 struct uart_sunsu_port *up = &sunsu_ports[i];
1497
1498 if (up->su_type == SU_PORT_MS ||
1499 up->su_type == SU_PORT_KBD)
1500 continue;
1501
1502 spin_lock_init(&up->port.lock);
1503 up->port.flags |= UPF_BOOT_AUTOCONF;
1504 up->port.type = PORT_UNKNOWN;
1505 up->port.uartclk = (SU_BASE_BAUD * 16);
1506
1507 sunsu_autoconfig(up);
1508 if (up->port.type == PORT_UNKNOWN)
1509 continue;
1510
1511 up->port.line = instance++;
1512 up->port.ops = &sunsu_pops;
1513 }
1514
1515 sunsu_reg.minor = sunserial_current_minor;
1516
1517 sunsu_reg.nr = instance;
1518
1519 ret = uart_register_driver(&sunsu_reg);
1520 if (ret < 0)
1521 return ret;
1522
1523 sunsu_reg.tty_driver->name_base = sunsu_reg.minor - 64;
1524
1525 sunserial_current_minor += instance;
1526
1527 sunsu_reg.cons = SUNSU_CONSOLE();
1528
1529 for (i = 0; i < UART_NR; i++) {
1530 struct uart_sunsu_port *up = &sunsu_ports[i];
1531
1532 /* Do not register Keyboard/Mouse lines with UART
1533 * layer.
1534 */
1535 if (up->su_type == SU_PORT_MS ||
1536 up->su_type == SU_PORT_KBD)
1537 continue;
1538
1539 if (up->port.type == PORT_UNKNOWN)
1540 continue;
1541
1542 uart_add_one_port(&sunsu_reg, &up->port);
1543 }
1544
1545 return 0;
1546 }
1547
1548 static int su_node_ok(int node, char *name, int namelen)
1549 {
1550 if (strncmp(name, "su", namelen) == 0 ||
1551 strncmp(name, "su_pnp", namelen) == 0)
1552 return 1;
1553
1554 if (strncmp(name, "serial", namelen) == 0) {
1555 char compat[32];
1556 int clen;
1557
1558 /* Is it _really_ a 'su' device? */
1559 clen = prom_getproperty(node, "compatible", compat, sizeof(compat));
1560 if (clen > 0) {
1561 if (strncmp(compat, "sab82532", 8) == 0) {
1562 /* Nope, Siemens serial, not for us. */
1563 return 0;
1564 }
1565 }
1566 return 1;
1567 }
1568
1569 return 0;
1570 }
1571
1572 #define SU_PROPSIZE 128
1573
1574 /*
1575 * Scan status structure.
1576 * "prop" is a local variable but it eats stack to keep it in each
1577 * stack frame of a recursive procedure.
1578 */
1579 struct su_probe_scan {
1580 int msnode, kbnode; /* PROM nodes for mouse and keyboard */
1581 int msx, kbx; /* minors for mouse and keyboard */
1582 int devices; /* scan index */
1583 char prop[SU_PROPSIZE];
1584 };
1585
1586 /*
1587 * We have several platforms which present 'su' in different parts
1588 * of the device tree. 'su' may be found under obio, ebus, isa and pci.
1589 * We walk over the tree and find them wherever PROM hides them.
1590 */
1591 static void __init su_probe_any(struct su_probe_scan *t, int sunode)
1592 {
1593 struct uart_sunsu_port *up;
1594 int len;
1595
1596 if (t->devices >= UART_NR)
1597 return;
1598
1599 for (; sunode != 0; sunode = prom_getsibling(sunode)) {
1600 len = prom_getproperty(sunode, "name", t->prop, SU_PROPSIZE);
1601 if (len <= 1)
1602 continue; /* Broken PROM node */
1603
1604 if (su_node_ok(sunode, t->prop, len)) {
1605 up = &sunsu_ports[t->devices];
1606 if (t->kbnode != 0 && sunode == t->kbnode) {
1607 t->kbx = t->devices;
1608 up->su_type = SU_PORT_KBD;
1609 } else if (t->msnode != 0 && sunode == t->msnode) {
1610 t->msx = t->devices;
1611 up->su_type = SU_PORT_MS;
1612 } else {
1613 #ifdef CONFIG_SPARC64
1614 /*
1615 * Do not attempt to use the truncated
1616 * keyboard/mouse ports as serial ports
1617 * on Ultras with PC keyboard attached.
1618 */
1619 if (prom_getbool(sunode, "mouse"))
1620 continue;
1621 if (prom_getbool(sunode, "keyboard"))
1622 continue;
1623 #endif
1624 up->su_type = SU_PORT_PORT;
1625 }
1626 up->port_node = sunode;
1627 ++t->devices;
1628 } else {
1629 su_probe_any(t, prom_getchild(sunode));
1630 }
1631 }
1632 }
1633
1634 static int __init sunsu_probe(void)
1635 {
1636 int node;
1637 int len;
1638 struct su_probe_scan scan;
1639
1640 /*
1641 * First, we scan the tree.
1642 */
1643 scan.devices = 0;
1644 scan.msx = -1;
1645 scan.kbx = -1;
1646 scan.kbnode = 0;
1647 scan.msnode = 0;
1648
1649 /*
1650 * Get the nodes for keyboard and mouse from 'aliases'...
1651 */
1652 node = prom_getchild(prom_root_node);
1653 node = prom_searchsiblings(node, "aliases");
1654 if (node != 0) {
1655 len = prom_getproperty(node, "keyboard", scan.prop, SU_PROPSIZE);
1656 if (len > 0) {
1657 scan.prop[len] = 0;
1658 scan.kbnode = prom_finddevice(scan.prop);
1659 }
1660
1661 len = prom_getproperty(node, "mouse", scan.prop, SU_PROPSIZE);
1662 if (len > 0) {
1663 scan.prop[len] = 0;
1664 scan.msnode = prom_finddevice(scan.prop);
1665 }
1666 }
1667
1668 su_probe_any(&scan, prom_getchild(prom_root_node));
1669
1670 /*
1671 * Second, we process the special case of keyboard and mouse.
1672 *
1673 * Currently if we got keyboard and mouse hooked to "su" ports
1674 * we do not use any possible remaining "su" as a serial port.
1675 * Thus, we ignore values of .msx and .kbx, then compact ports.
1676 */
1677 if (scan.msx != -1 && scan.kbx != -1) {
1678 sunsu_ports[0].su_type = SU_PORT_MS;
1679 sunsu_ports[0].port_node = scan.msnode;
1680 sunsu_kbd_ms_init(&sunsu_ports[0], 0);
1681
1682 sunsu_ports[1].su_type = SU_PORT_KBD;
1683 sunsu_ports[1].port_node = scan.kbnode;
1684 sunsu_kbd_ms_init(&sunsu_ports[1], 1);
1685
1686 return 0;
1687 }
1688
1689 if (scan.msx != -1 || scan.kbx != -1) {
1690 printk("sunsu_probe: cannot match keyboard and mouse, confused\n");
1691 return -ENODEV;
1692 }
1693
1694 if (scan.devices == 0)
1695 return -ENODEV;
1696
1697 /*
1698 * Console must be initiated after the generic initialization.
1699 */
1700 sunsu_serial_init();
1701
1702 return 0;
1703 }
1704
1705 static void __exit sunsu_exit(void)
1706 {
1707 int i, saw_uart;
1708
1709 saw_uart = 0;
1710 for (i = 0; i < UART_NR; i++) {
1711 struct uart_sunsu_port *up = &sunsu_ports[i];
1712
1713 if (up->su_type == SU_PORT_MS ||
1714 up->su_type == SU_PORT_KBD) {
1715 #ifdef CONFIG_SERIO
1716 if (up->serio) {
1717 serio_unregister_port(up->serio);
1718 up->serio = NULL;
1719 }
1720 #endif
1721 } else if (up->port.type != PORT_UNKNOWN) {
1722 uart_remove_one_port(&sunsu_reg, &up->port);
1723 saw_uart++;
1724 }
1725 }
1726
1727 if (saw_uart)
1728 uart_unregister_driver(&sunsu_reg);
1729 }
1730
1731 module_init(sunsu_probe);
1732 module_exit(sunsu_exit);
1733 MODULE_LICENSE("GPL");
Verdex Pro support