?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf, x86: Add Intel SandyBridge CPU support
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / char / serial167.c
blob748c3b0ecd89413f4bbe918e783bb042fcb02d1a
1 /*
2 * linux/drivers/char/serial167.c
3 *
4 * Driver for MVME166/7 board serial ports, which are via a CD2401.
5 * Based very much on cyclades.c.
6 *
7 * MVME166/7 work by Richard Hirst [richard@sleepie.demon.co.uk]
8 *
9 * ==============================================================
10 *
11 * static char rcsid[] =
12 * "$Revision: 1.36.1.4 $$Date: 1995/03/29 06:14:14 $";
13 *
14 * linux/kernel/cyclades.c
15 *
16 * Maintained by Marcio Saito (cyclades@netcom.com) and
17 * Randolph Bentson (bentson@grieg.seaslug.org)
18 *
19 * Much of the design and some of the code came from serial.c
20 * which was copyright (C) 1991, 1992 Linus Torvalds. It was
21 * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
22 * and then fixed as suggested by Michael K. Johnson 12/12/92.
23 *
24 * This version does not support shared irq's.
25 *
26 * $Log: cyclades.c,v $
27 * Revision 1.36.1.4 1995/03/29 06:14:14 bentson
28 * disambiguate between Cyclom-16Y and Cyclom-32Ye;
29 *
30 * Changes:
31 *
32 * 200 lines of changes record removed - RGH 11-10-95, starting work on
33 * converting this to drive serial ports on mvme166 (cd2401).
34 *
35 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 2000/08/25
36 * - get rid of verify_area
37 * - use get_user to access memory from userspace in set_threshold,
38 * set_default_threshold and set_timeout
39 * - don't use the panic function in serial167_init
40 * - do resource release on failure on serial167_init
41 * - include missing restore_flags in mvme167_serial_console_setup
42 *
43 * Kars de Jong <jongk@linux-m68k.org> - 2004/09/06
44 * - replace bottom half handler with task queue handler
45 */
46
47 #include <linux/errno.h>
48 #include <linux/signal.h>
49 #include <linux/sched.h>
50 #include <linux/timer.h>
51 #include <linux/tty.h>
52 #include <linux/interrupt.h>
53 #include <linux/serial.h>
54 #include <linux/serialP.h>
55 #include <linux/string.h>
56 #include <linux/fcntl.h>
57 #include <linux/ptrace.h>
58 #include <linux/serial167.h>
59 #include <linux/delay.h>
60 #include <linux/major.h>
61 #include <linux/mm.h>
62 #include <linux/console.h>
63 #include <linux/module.h>
64 #include <linux/bitops.h>
65 #include <linux/tty_flip.h>
66 #include <linux/gfp.h>
67
68 #include <asm/system.h>
69 #include <asm/io.h>
70 #include <asm/mvme16xhw.h>
71 #include <asm/bootinfo.h>
72 #include <asm/setup.h>
73
74 #include <linux/types.h>
75 #include <linux/kernel.h>
76
77 #include <asm/uaccess.h>
78 #include <linux/init.h>
79
80 #define SERIAL_PARANOIA_CHECK
81 #undef SERIAL_DEBUG_OPEN
82 #undef SERIAL_DEBUG_THROTTLE
83 #undef SERIAL_DEBUG_OTHER
84 #undef SERIAL_DEBUG_IO
85 #undef SERIAL_DEBUG_COUNT
86 #undef SERIAL_DEBUG_DTR
87 #undef CYCLOM_16Y_HACK
88 #define CYCLOM_ENABLE_MONITORING
89
90 #define WAKEUP_CHARS 256
91
92 #define STD_COM_FLAGS (0)
93
94 static struct tty_driver *cy_serial_driver;
95 extern int serial_console;
96 static struct cyclades_port *serial_console_info = NULL;
97 static unsigned int serial_console_cflag = 0;
98 u_char initial_console_speed;
99
100 /* Base address of cd2401 chip on mvme166/7 */
101
102 #define BASE_ADDR (0xfff45000)
103 #define pcc2chip ((volatile u_char *)0xfff42000)
104 #define PccSCCMICR 0x1d
105 #define PccSCCTICR 0x1e
106 #define PccSCCRICR 0x1f
107 #define PccTPIACKR 0x25
108 #define PccRPIACKR 0x27
109 #define PccIMLR 0x3f
110
111 /* This is the per-port data structure */
112 struct cyclades_port cy_port[] = {
113 /* CARD# */
114 {-1}, /* ttyS0 */
115 {-1}, /* ttyS1 */
116 {-1}, /* ttyS2 */
117 {-1}, /* ttyS3 */
118 };
119
120 #define NR_PORTS ARRAY_SIZE(cy_port)
121
122 /*
123 * This is used to look up the divisor speeds and the timeouts
124 * We're normally limited to 15 distinct baud rates. The extra
125 * are accessed via settings in info->flags.
126 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
127 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
128 * HI VHI
129 */
130 static int baud_table[] = {
131 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
132 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
133 0
134 };
135
136 #if 0
137 static char baud_co[] = { /* 25 MHz clock option table */
138 /* value => 00 01 02 03 04 */
139 /* divide by 8 32 128 512 2048 */
140 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
141 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
142 };
143
144 static char baud_bpr[] = { /* 25 MHz baud rate period table */
145 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
146 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
147 };
148 #endif
149
150 /* I think 166 brd clocks 2401 at 20MHz.... */
151
152 /* These values are written directly to tcor, and >> 5 for writing to rcor */
153 static u_char baud_co[] = { /* 20 MHz clock option table */
154 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x60, 0x60, 0x40,
155 0x40, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
156 };
157
158 /* These values written directly to tbpr/rbpr */
159 static u_char baud_bpr[] = { /* 20 MHz baud rate period table */
160 0x00, 0xc0, 0x80, 0x58, 0x6c, 0x40, 0xc0, 0x81, 0x40, 0x81,
161 0x57, 0x40, 0x81, 0x40, 0x81, 0x40, 0x2b, 0x20, 0x15, 0x10
162 };
163
164 static u_char baud_cor4[] = { /* receive threshold */
165 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
166 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07
167 };
168
169 static void shutdown(struct cyclades_port *);
170 static int startup(struct cyclades_port *);
171 static void cy_throttle(struct tty_struct *);
172 static void cy_unthrottle(struct tty_struct *);
173 static void config_setup(struct cyclades_port *);
174 #ifdef CYCLOM_SHOW_STATUS
175 static void show_status(int);
176 #endif
177
178 /*
179 * I have my own version of udelay(), as it is needed when initialising
180 * the chip, before the delay loop has been calibrated. Should probably
181 * reference one of the vmechip2 or pccchip2 counter for an accurate
182 * delay, but this wild guess will do for now.
183 */
184
185 void my_udelay(long us)
186 {
187 u_char x;
188 volatile u_char *p = &x;
189 int i;
190
191 while (us--)
192 for (i = 100; i; i--)
193 x |= *p;
194 }
195
196 static inline int serial_paranoia_check(struct cyclades_port *info, char *name,
197 const char *routine)
198 {
199 #ifdef SERIAL_PARANOIA_CHECK
200 if (!info) {
201 printk("Warning: null cyclades_port for (%s) in %s\n", name,
202 routine);
203 return 1;
204 }
205
206 if (info < &cy_port[0] || info >= &cy_port[NR_PORTS]) {
207 printk("Warning: cyclades_port out of range for (%s) in %s\n",
208 name, routine);
209 return 1;
210 }
211
212 if (info->magic != CYCLADES_MAGIC) {
213 printk("Warning: bad magic number for serial struct (%s) in "
214 "%s\n", name, routine);
215 return 1;
216 }
217 #endif
218 return 0;
219 } /* serial_paranoia_check */
220
221 #if 0
222 /* The following diagnostic routines allow the driver to spew
223 information on the screen, even (especially!) during interrupts.
224 */
225 void SP(char *data)
226 {
227 unsigned long flags;
228 local_irq_save(flags);
229 printk(KERN_EMERG "%s", data);
230 local_irq_restore(flags);
231 }
232
233 char scrn[2];
234 void CP(char data)
235 {
236 unsigned long flags;
237 local_irq_save(flags);
238 scrn[0] = data;
239 printk(KERN_EMERG "%c", scrn);
240 local_irq_restore(flags);
241 } /* CP */
242
243 void CP1(int data)
244 {
245 (data < 10) ? CP(data + '0') : CP(data + 'A' - 10);
246 } /* CP1 */
247 void CP2(int data)
248 {
249 CP1((data >> 4) & 0x0f);
250 CP1(data & 0x0f);
251 } /* CP2 */
252 void CP4(int data)
253 {
254 CP2((data >> 8) & 0xff);
255 CP2(data & 0xff);
256 } /* CP4 */
257 void CP8(long data)
258 {
259 CP4((data >> 16) & 0xffff);
260 CP4(data & 0xffff);
261 } /* CP8 */
262 #endif
263
264 /* This routine waits up to 1000 micro-seconds for the previous
265 command to the Cirrus chip to complete and then issues the
266 new command. An error is returned if the previous command
267 didn't finish within the time limit.
268 */
269 u_short write_cy_cmd(volatile u_char * base_addr, u_char cmd)
270 {
271 unsigned long flags;
272 volatile int i;
273
274 local_irq_save(flags);
275 /* Check to see that the previous command has completed */
276 for (i = 0; i < 100; i++) {
277 if (base_addr[CyCCR] == 0) {
278 break;
279 }
280 my_udelay(10L);
281 }
282 /* if the CCR never cleared, the previous command
283 didn't finish within the "reasonable time" */
284 if (i == 10) {
285 local_irq_restore(flags);
286 return (-1);
287 }
288
289 /* Issue the new command */
290 base_addr[CyCCR] = cmd;
291 local_irq_restore(flags);
292 return (0);
293 } /* write_cy_cmd */
294
295 /* cy_start and cy_stop provide software output flow control as a
296 function of XON/XOFF, software CTS, and other such stuff. */
297
298 static void cy_stop(struct tty_struct *tty)
299 {
300 struct cyclades_port *info = tty->driver_data;
301 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
302 int channel;
303 unsigned long flags;
304
305 #ifdef SERIAL_DEBUG_OTHER
306 printk("cy_stop %s\n", tty->name); /* */
307 #endif
308
309 if (serial_paranoia_check(info, tty->name, "cy_stop"))
310 return;
311
312 channel = info->line;
313
314 local_irq_save(flags);
315 base_addr[CyCAR] = (u_char) (channel); /* index channel */
316 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
317 local_irq_restore(flags);
318 } /* cy_stop */
319
320 static void cy_start(struct tty_struct *tty)
321 {
322 struct cyclades_port *info = tty->driver_data;
323 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
324 int channel;
325 unsigned long flags;
326
327 #ifdef SERIAL_DEBUG_OTHER
328 printk("cy_start %s\n", tty->name); /* */
329 #endif
330
331 if (serial_paranoia_check(info, tty->name, "cy_start"))
332 return;
333
334 channel = info->line;
335
336 local_irq_save(flags);
337 base_addr[CyCAR] = (u_char) (channel);
338 base_addr[CyIER] |= CyTxMpty;
339 local_irq_restore(flags);
340 } /* cy_start */
341
342 /* The real interrupt service routines are called
343 whenever the card wants its hand held--chars
344 received, out buffer empty, modem change, etc.
345 */
346 static irqreturn_t cd2401_rxerr_interrupt(int irq, void *dev_id)
347 {
348 struct tty_struct *tty;
349 struct cyclades_port *info;
350 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
351 unsigned char err, rfoc;
352 int channel;
353 char data;
354
355 /* determine the channel and change to that context */
356 channel = (u_short) (base_addr[CyLICR] >> 2);
357 info = &cy_port[channel];
358 info->last_active = jiffies;
359
360 if ((err = base_addr[CyRISR]) & CyTIMEOUT) {
361 /* This is a receive timeout interrupt, ignore it */
362 base_addr[CyREOIR] = CyNOTRANS;
363 return IRQ_HANDLED;
364 }
365
366 /* Read a byte of data if there is any - assume the error
367 * is associated with this character */
368
369 if ((rfoc = base_addr[CyRFOC]) != 0)
370 data = base_addr[CyRDR];
371 else
372 data = 0;
373
374 /* if there is nowhere to put the data, discard it */
375 if (info->tty == 0) {
376 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
377 return IRQ_HANDLED;
378 } else { /* there is an open port for this data */
379 tty = info->tty;
380 if (err & info->ignore_status_mask) {
381 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
382 return IRQ_HANDLED;
383 }
384 if (tty_buffer_request_room(tty, 1) != 0) {
385 if (err & info->read_status_mask) {
386 if (err & CyBREAK) {
387 tty_insert_flip_char(tty, data,
388 TTY_BREAK);
389 if (info->flags & ASYNC_SAK) {
390 do_SAK(tty);
391 }
392 } else if (err & CyFRAME) {
393 tty_insert_flip_char(tty, data,
394 TTY_FRAME);
395 } else if (err & CyPARITY) {
396 tty_insert_flip_char(tty, data,
397 TTY_PARITY);
398 } else if (err & CyOVERRUN) {
399 tty_insert_flip_char(tty, 0,
400 TTY_OVERRUN);
401 /*
402 If the flip buffer itself is
403 overflowing, we still lose
404 the next incoming character.
405 */
406 if (tty_buffer_request_room(tty, 1) !=
407 0) {
408 tty_insert_flip_char(tty, data,
409 TTY_FRAME);
410 }
411 /* These two conditions may imply */
412 /* a normal read should be done. */
413 /* else if(data & CyTIMEOUT) */
414 /* else if(data & CySPECHAR) */
415 } else {
416 tty_insert_flip_char(tty, 0,
417 TTY_NORMAL);
418 }
419 } else {
420 tty_insert_flip_char(tty, data, TTY_NORMAL);
421 }
422 } else {
423 /* there was a software buffer overrun
424 and nothing could be done about it!!! */
425 }
426 }
427 tty_schedule_flip(tty);
428 /* end of service */
429 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
430 return IRQ_HANDLED;
431 } /* cy_rxerr_interrupt */
432
433 static irqreturn_t cd2401_modem_interrupt(int irq, void *dev_id)
434 {
435 struct cyclades_port *info;
436 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
437 int channel;
438 int mdm_change;
439 int mdm_status;
440
441 /* determine the channel and change to that context */
442 channel = (u_short) (base_addr[CyLICR] >> 2);
443 info = &cy_port[channel];
444 info->last_active = jiffies;
445
446 mdm_change = base_addr[CyMISR];
447 mdm_status = base_addr[CyMSVR1];
448
449 if (info->tty == 0) { /* nowhere to put the data, ignore it */
450 ;
451 } else {
452 if ((mdm_change & CyDCD)
453 && (info->flags & ASYNC_CHECK_CD)) {
454 if (mdm_status & CyDCD) {
455 /* CP('!'); */
456 wake_up_interruptible(&info->open_wait);
457 } else {
458 /* CP('@'); */
459 tty_hangup(info->tty);
460 wake_up_interruptible(&info->open_wait);
461 info->flags &= ~ASYNC_NORMAL_ACTIVE;
462 }
463 }
464 if ((mdm_change & CyCTS)
465 && (info->flags & ASYNC_CTS_FLOW)) {
466 if (info->tty->stopped) {
467 if (mdm_status & CyCTS) {
468 /* !!! cy_start isn't used because... */
469 info->tty->stopped = 0;
470 base_addr[CyIER] |= CyTxMpty;
471 tty_wakeup(info->tty);
472 }
473 } else {
474 if (!(mdm_status & CyCTS)) {
475 /* !!! cy_stop isn't used because... */
476 info->tty->stopped = 1;
477 base_addr[CyIER] &=
478 ~(CyTxMpty | CyTxRdy);
479 }
480 }
481 }
482 if (mdm_status & CyDSR) {
483 }
484 }
485 base_addr[CyMEOIR] = 0;
486 return IRQ_HANDLED;
487 } /* cy_modem_interrupt */
488
489 static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id)
490 {
491 struct cyclades_port *info;
492 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
493 int channel;
494 int char_count, saved_cnt;
495 int outch;
496
497 /* determine the channel and change to that context */
498 channel = (u_short) (base_addr[CyLICR] >> 2);
499
500 /* validate the port number (as configured and open) */
501 if ((channel < 0) || (NR_PORTS <= channel)) {
502 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
503 base_addr[CyTEOIR] = CyNOTRANS;
504 return IRQ_HANDLED;
505 }
506 info = &cy_port[channel];
507 info->last_active = jiffies;
508 if (info->tty == 0) {
509 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
510 base_addr[CyTEOIR] = CyNOTRANS;
511 return IRQ_HANDLED;
512 }
513
514 /* load the on-chip space available for outbound data */
515 saved_cnt = char_count = base_addr[CyTFTC];
516
517 if (info->x_char) { /* send special char */
518 outch = info->x_char;
519 base_addr[CyTDR] = outch;
520 char_count--;
521 info->x_char = 0;
522 }
523
524 if (info->x_break) {
525 /* The Cirrus chip requires the "Embedded Transmit
526 Commands" of start break, delay, and end break
527 sequences to be sent. The duration of the
528 break is given in TICs, which runs at HZ
529 (typically 100) and the PPR runs at 200 Hz,
530 so the delay is duration * 200/HZ, and thus a
531 break can run from 1/100 sec to about 5/4 sec.
532 Need to check these values - RGH 141095.
533 */
534 base_addr[CyTDR] = 0; /* start break */
535 base_addr[CyTDR] = 0x81;
536 base_addr[CyTDR] = 0; /* delay a bit */
537 base_addr[CyTDR] = 0x82;
538 base_addr[CyTDR] = info->x_break * 200 / HZ;
539 base_addr[CyTDR] = 0; /* terminate break */
540 base_addr[CyTDR] = 0x83;
541 char_count -= 7;
542 info->x_break = 0;
543 }
544
545 while (char_count > 0) {
546 if (!info->xmit_cnt) {
547 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
548 break;
549 }
550 if (info->xmit_buf == 0) {
551 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
552 break;
553 }
554 if (info->tty->stopped || info->tty->hw_stopped) {
555 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
556 break;
557 }
558 /* Because the Embedded Transmit Commands have been
559 enabled, we must check to see if the escape
560 character, NULL, is being sent. If it is, we
561 must ensure that there is room for it to be
562 doubled in the output stream. Therefore we
563 no longer advance the pointer when the character
564 is fetched, but rather wait until after the check
565 for a NULL output character. (This is necessary
566 because there may not be room for the two chars
567 needed to send a NULL.
568 */
569 outch = info->xmit_buf[info->xmit_tail];
570 if (outch) {
571 info->xmit_cnt--;
572 info->xmit_tail = (info->xmit_tail + 1)
573 & (PAGE_SIZE - 1);
574 base_addr[CyTDR] = outch;
575 char_count--;
576 } else {
577 if (char_count > 1) {
578 info->xmit_cnt--;
579 info->xmit_tail = (info->xmit_tail + 1)
580 & (PAGE_SIZE - 1);
581 base_addr[CyTDR] = outch;
582 base_addr[CyTDR] = 0;
583 char_count--;
584 char_count--;
585 } else {
586 break;
587 }
588 }
589 }
590
591 if (info->xmit_cnt < WAKEUP_CHARS)
592 tty_wakeup(info->tty);
593
594 base_addr[CyTEOIR] = (char_count != saved_cnt) ? 0 : CyNOTRANS;
595 return IRQ_HANDLED;
596 } /* cy_tx_interrupt */
597
598 static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
599 {
600 struct tty_struct *tty;
601 struct cyclades_port *info;
602 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
603 int channel;
604 char data;
605 int char_count;
606 int save_cnt;
607
608 /* determine the channel and change to that context */
609 channel = (u_short) (base_addr[CyLICR] >> 2);
610 info = &cy_port[channel];
611 info->last_active = jiffies;
612 save_cnt = char_count = base_addr[CyRFOC];
613
614 /* if there is nowhere to put the data, discard it */
615 if (info->tty == 0) {
616 while (char_count--) {
617 data = base_addr[CyRDR];
618 }
619 } else { /* there is an open port for this data */
620 tty = info->tty;
621 /* load # characters available from the chip */
622
623 #ifdef CYCLOM_ENABLE_MONITORING
624 ++info->mon.int_count;
625 info->mon.char_count += char_count;
626 if (char_count > info->mon.char_max)
627 info->mon.char_max = char_count;
628 info->mon.char_last = char_count;
629 #endif
630 while (char_count--) {
631 data = base_addr[CyRDR];
632 tty_insert_flip_char(tty, data, TTY_NORMAL);
633 #ifdef CYCLOM_16Y_HACK
634 udelay(10L);
635 #endif
636 }
637 tty_schedule_flip(tty);
638 }
639 /* end of service */
640 base_addr[CyREOIR] = save_cnt ? 0 : CyNOTRANS;
641 return IRQ_HANDLED;
642 } /* cy_rx_interrupt */
643
644 /* This is called whenever a port becomes active;
645 interrupts are enabled and DTR & RTS are turned on.
646 */
647 static int startup(struct cyclades_port *info)
648 {
649 unsigned long flags;
650 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
651 int channel;
652
653 if (info->flags & ASYNC_INITIALIZED) {
654 return 0;
655 }
656
657 if (!info->type) {
658 if (info->tty) {
659 set_bit(TTY_IO_ERROR, &info->tty->flags);
660 }
661 return 0;
662 }
663 if (!info->xmit_buf) {
664 info->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
665 if (!info->xmit_buf) {
666 return -ENOMEM;
667 }
668 }
669
670 config_setup(info);
671
672 channel = info->line;
673
674 #ifdef SERIAL_DEBUG_OPEN
675 printk("startup channel %d\n", channel);
676 #endif
677
678 local_irq_save(flags);
679 base_addr[CyCAR] = (u_char) channel;
680 write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
681
682 base_addr[CyCAR] = (u_char) channel; /* !!! Is this needed? */
683 base_addr[CyMSVR1] = CyRTS;
684 /* CP('S');CP('1'); */
685 base_addr[CyMSVR2] = CyDTR;
686
687 #ifdef SERIAL_DEBUG_DTR
688 printk("cyc: %d: raising DTR\n", __LINE__);
689 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
690 base_addr[CyMSVR2]);
691 #endif
692
693 base_addr[CyIER] |= CyRxData;
694 info->flags |= ASYNC_INITIALIZED;
695
696 if (info->tty) {
697 clear_bit(TTY_IO_ERROR, &info->tty->flags);
698 }
699 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
700
701 local_irq_restore(flags);
702
703 #ifdef SERIAL_DEBUG_OPEN
704 printk(" done\n");
705 #endif
706 return 0;
707 } /* startup */
708
709 void start_xmit(struct cyclades_port *info)
710 {
711 unsigned long flags;
712 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
713 int channel;
714
715 channel = info->line;
716 local_irq_save(flags);
717 base_addr[CyCAR] = channel;
718 base_addr[CyIER] |= CyTxMpty;
719 local_irq_restore(flags);
720 } /* start_xmit */
721
722 /*
723 * This routine shuts down a serial port; interrupts are disabled,
724 * and DTR is dropped if the hangup on close termio flag is on.
725 */
726 static void shutdown(struct cyclades_port *info)
727 {
728 unsigned long flags;
729 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
730 int channel;
731
732 if (!(info->flags & ASYNC_INITIALIZED)) {
733 /* CP('$'); */
734 return;
735 }
736
737 channel = info->line;
738
739 #ifdef SERIAL_DEBUG_OPEN
740 printk("shutdown channel %d\n", channel);
741 #endif
742
743 /* !!! REALLY MUST WAIT FOR LAST CHARACTER TO BE
744 SENT BEFORE DROPPING THE LINE !!! (Perhaps
745 set some flag that is read when XMTY happens.)
746 Other choices are to delay some fixed interval
747 or schedule some later processing.
748 */
749 local_irq_save(flags);
750 if (info->xmit_buf) {
751 free_page((unsigned long)info->xmit_buf);
752 info->xmit_buf = NULL;
753 }
754
755 base_addr[CyCAR] = (u_char) channel;
756 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
757 base_addr[CyMSVR1] = 0;
758 /* CP('C');CP('1'); */
759 base_addr[CyMSVR2] = 0;
760 #ifdef SERIAL_DEBUG_DTR
761 printk("cyc: %d: dropping DTR\n", __LINE__);
762 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
763 base_addr[CyMSVR2]);
764 #endif
765 }
766 write_cy_cmd(base_addr, CyDIS_RCVR);
767 /* it may be appropriate to clear _XMIT at
768 some later date (after testing)!!! */
769
770 if (info->tty) {
771 set_bit(TTY_IO_ERROR, &info->tty->flags);
772 }
773 info->flags &= ~ASYNC_INITIALIZED;
774 local_irq_restore(flags);
775
776 #ifdef SERIAL_DEBUG_OPEN
777 printk(" done\n");
778 #endif
779 } /* shutdown */
780
781 /*
782 * This routine finds or computes the various line characteristics.
783 */
784 static void config_setup(struct cyclades_port *info)
785 {
786 unsigned long flags;
787 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
788 int channel;
789 unsigned cflag;
790 int i;
791 unsigned char ti, need_init_chan = 0;
792
793 if (!info->tty || !info->tty->termios) {
794 return;
795 }
796 if (info->line == -1) {
797 return;
798 }
799 cflag = info->tty->termios->c_cflag;
800
801 /* baud rate */
802 i = cflag & CBAUD;
803 #ifdef CBAUDEX
804 /* Starting with kernel 1.1.65, there is direct support for
805 higher baud rates. The following code supports those
806 changes. The conditional aspect allows this driver to be
807 used for earlier as well as later kernel versions. (The
808 mapping is slightly different from serial.c because there
809 is still the possibility of supporting 75 kbit/sec with
810 the Cyclades board.)
811 */
812 if (i & CBAUDEX) {
813 if (i == B57600)
814 i = 16;
815 else if (i == B115200)
816 i = 18;
817 #ifdef B78600
818 else if (i == B78600)
819 i = 17;
820 #endif
821 else
822 info->tty->termios->c_cflag &= ~CBAUDEX;
823 }
824 #endif
825 if (i == 15) {
826 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
827 i += 1;
828 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
829 i += 3;
830 }
831 /* Don't ever change the speed of the console port. It will
832 * run at the speed specified in bootinfo, or at 19.2K */
833 /* Actually, it should run at whatever speed 166Bug was using */
834 /* Note info->timeout isn't used at present */
835 if (info != serial_console_info) {
836 info->tbpr = baud_bpr[i]; /* Tx BPR */
837 info->tco = baud_co[i]; /* Tx CO */
838 info->rbpr = baud_bpr[i]; /* Rx BPR */
839 info->rco = baud_co[i] >> 5; /* Rx CO */
840 if (baud_table[i] == 134) {
841 info->timeout =
842 (info->xmit_fifo_size * HZ * 30 / 269) + 2;
843 /* get it right for 134.5 baud */
844 } else if (baud_table[i]) {
845 info->timeout =
846 (info->xmit_fifo_size * HZ * 15 / baud_table[i]) +
847 2;
848 /* this needs to be propagated into the card info */
849 } else {
850 info->timeout = 0;
851 }
852 }
853 /* By tradition (is it a standard?) a baud rate of zero
854 implies the line should be/has been closed. A bit
855 later in this routine such a test is performed. */
856
857 /* byte size and parity */
858 info->cor7 = 0;
859 info->cor6 = 0;
860 info->cor5 = 0;
861 info->cor4 = (info->default_threshold ? info->default_threshold : baud_cor4[i]); /* receive threshold */
862 /* Following two lines added 101295, RGH. */
863 /* It is obviously wrong to access CyCORx, and not info->corx here,
864 * try and remember to fix it later! */
865 channel = info->line;
866 base_addr[CyCAR] = (u_char) channel;
867 if (C_CLOCAL(info->tty)) {
868 if (base_addr[CyIER] & CyMdmCh)
869 base_addr[CyIER] &= ~CyMdmCh; /* without modem intr */
870 /* ignore 1->0 modem transitions */
871 if (base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD))
872 base_addr[CyCOR4] &= ~(CyDSR | CyCTS | CyDCD);
873 /* ignore 0->1 modem transitions */
874 if (base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD))
875 base_addr[CyCOR5] &= ~(CyDSR | CyCTS | CyDCD);
876 } else {
877 if ((base_addr[CyIER] & CyMdmCh) != CyMdmCh)
878 base_addr[CyIER] |= CyMdmCh; /* with modem intr */
879 /* act on 1->0 modem transitions */
880 if ((base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD)) !=
881 (CyDSR | CyCTS | CyDCD))
882 base_addr[CyCOR4] |= CyDSR | CyCTS | CyDCD;
883 /* act on 0->1 modem transitions */
884 if ((base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD)) !=
885 (CyDSR | CyCTS | CyDCD))
886 base_addr[CyCOR5] |= CyDSR | CyCTS | CyDCD;
887 }
888 info->cor3 = (cflag & CSTOPB) ? Cy_2_STOP : Cy_1_STOP;
889 info->cor2 = CyETC;
890 switch (cflag & CSIZE) {
891 case CS5:
892 info->cor1 = Cy_5_BITS;
893 break;
894 case CS6:
895 info->cor1 = Cy_6_BITS;
896 break;
897 case CS7:
898 info->cor1 = Cy_7_BITS;
899 break;
900 case CS8:
901 info->cor1 = Cy_8_BITS;
902 break;
903 }
904 if (cflag & PARENB) {
905 if (cflag & PARODD) {
906 info->cor1 |= CyPARITY_O;
907 } else {
908 info->cor1 |= CyPARITY_E;
909 }
910 } else {
911 info->cor1 |= CyPARITY_NONE;
912 }
913
914 /* CTS flow control flag */
915 #if 0
916 /* Don't complcate matters for now! RGH 141095 */
917 if (cflag & CRTSCTS) {
918 info->flags |= ASYNC_CTS_FLOW;
919 info->cor2 |= CyCtsAE;
920 } else {
921 info->flags &= ~ASYNC_CTS_FLOW;
922 info->cor2 &= ~CyCtsAE;
923 }
924 #endif
925 if (cflag & CLOCAL)
926 info->flags &= ~ASYNC_CHECK_CD;
927 else
928 info->flags |= ASYNC_CHECK_CD;
929
930 /***********************************************
931 The hardware option, CyRtsAO, presents RTS when
932 the chip has characters to send. Since most modems
933 use RTS as reverse (inbound) flow control, this
934 option is not used. If inbound flow control is
935 necessary, DTR can be programmed to provide the
936 appropriate signals for use with a non-standard
937 cable. Contact Marcio Saito for details.
938 ***********************************************/
939
940 channel = info->line;
941
942 local_irq_save(flags);
943 base_addr[CyCAR] = (u_char) channel;
944
945 /* CyCMR set once only in mvme167_init_serial() */
946 if (base_addr[CyLICR] != channel << 2)
947 base_addr[CyLICR] = channel << 2;
948 if (base_addr[CyLIVR] != 0x5c)
949 base_addr[CyLIVR] = 0x5c;
950
951 /* tx and rx baud rate */
952
953 if (base_addr[CyCOR1] != info->cor1)
954 need_init_chan = 1;
955 if (base_addr[CyTCOR] != info->tco)
956 base_addr[CyTCOR] = info->tco;
957 if (base_addr[CyTBPR] != info->tbpr)
958 base_addr[CyTBPR] = info->tbpr;
959 if (base_addr[CyRCOR] != info->rco)
960 base_addr[CyRCOR] = info->rco;
961 if (base_addr[CyRBPR] != info->rbpr)
962 base_addr[CyRBPR] = info->rbpr;
963
964 /* set line characteristics according configuration */
965
966 if (base_addr[CySCHR1] != START_CHAR(info->tty))
967 base_addr[CySCHR1] = START_CHAR(info->tty);
968 if (base_addr[CySCHR2] != STOP_CHAR(info->tty))
969 base_addr[CySCHR2] = STOP_CHAR(info->tty);
970 if (base_addr[CySCRL] != START_CHAR(info->tty))
971 base_addr[CySCRL] = START_CHAR(info->tty);
972 if (base_addr[CySCRH] != START_CHAR(info->tty))
973 base_addr[CySCRH] = START_CHAR(info->tty);
974 if (base_addr[CyCOR1] != info->cor1)
975 base_addr[CyCOR1] = info->cor1;
976 if (base_addr[CyCOR2] != info->cor2)
977 base_addr[CyCOR2] = info->cor2;
978 if (base_addr[CyCOR3] != info->cor3)
979 base_addr[CyCOR3] = info->cor3;
980 if (base_addr[CyCOR4] != info->cor4)
981 base_addr[CyCOR4] = info->cor4;
982 if (base_addr[CyCOR5] != info->cor5)
983 base_addr[CyCOR5] = info->cor5;
984 if (base_addr[CyCOR6] != info->cor6)
985 base_addr[CyCOR6] = info->cor6;
986 if (base_addr[CyCOR7] != info->cor7)
987 base_addr[CyCOR7] = info->cor7;
988
989 if (need_init_chan)
990 write_cy_cmd(base_addr, CyINIT_CHAN);
991
992 base_addr[CyCAR] = (u_char) channel; /* !!! Is this needed? */
993
994 /* 2ms default rx timeout */
995 ti = info->default_timeout ? info->default_timeout : 0x02;
996 if (base_addr[CyRTPRL] != ti)
997 base_addr[CyRTPRL] = ti;
998 if (base_addr[CyRTPRH] != 0)
999 base_addr[CyRTPRH] = 0;
1000
1001 /* Set up RTS here also ????? RGH 141095 */
1002 if (i == 0) { /* baud rate is zero, turn off line */
1003 if ((base_addr[CyMSVR2] & CyDTR) == CyDTR)
1004 base_addr[CyMSVR2] = 0;
1005 #ifdef SERIAL_DEBUG_DTR
1006 printk("cyc: %d: dropping DTR\n", __LINE__);
1007 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1008 base_addr[CyMSVR2]);
1009 #endif
1010 } else {
1011 if ((base_addr[CyMSVR2] & CyDTR) != CyDTR)
1012 base_addr[CyMSVR2] = CyDTR;
1013 #ifdef SERIAL_DEBUG_DTR
1014 printk("cyc: %d: raising DTR\n", __LINE__);
1015 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1016 base_addr[CyMSVR2]);
1017 #endif
1018 }
1019
1020 if (info->tty) {
1021 clear_bit(TTY_IO_ERROR, &info->tty->flags);
1022 }
1023
1024 local_irq_restore(flags);
1025
1026 } /* config_setup */
1027
1028 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1029 {
1030 struct cyclades_port *info = tty->driver_data;
1031 unsigned long flags;
1032
1033 #ifdef SERIAL_DEBUG_IO
1034 printk("cy_put_char %s(0x%02x)\n", tty->name, ch);
1035 #endif
1036
1037 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1038 return 0;
1039
1040 if (!info->xmit_buf)
1041 return 0;
1042
1043 local_irq_save(flags);
1044 if (info->xmit_cnt >= PAGE_SIZE - 1) {
1045 local_irq_restore(flags);
1046 return 0;
1047 }
1048
1049 info->xmit_buf[info->xmit_head++] = ch;
1050 info->xmit_head &= PAGE_SIZE - 1;
1051 info->xmit_cnt++;
1052 local_irq_restore(flags);
1053 return 1;
1054 } /* cy_put_char */
1055
1056 static void cy_flush_chars(struct tty_struct *tty)
1057 {
1058 struct cyclades_port *info = tty->driver_data;
1059 unsigned long flags;
1060 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1061 int channel;
1062
1063 #ifdef SERIAL_DEBUG_IO
1064 printk("cy_flush_chars %s\n", tty->name); /* */
1065 #endif
1066
1067 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1068 return;
1069
1070 if (info->xmit_cnt <= 0 || tty->stopped
1071 || tty->hw_stopped || !info->xmit_buf)
1072 return;
1073
1074 channel = info->line;
1075
1076 local_irq_save(flags);
1077 base_addr[CyCAR] = channel;
1078 base_addr[CyIER] |= CyTxMpty;
1079 local_irq_restore(flags);
1080 } /* cy_flush_chars */
1081
1082 /* This routine gets called when tty_write has put something into
1083 the write_queue. If the port is not already transmitting stuff,
1084 start it off by enabling interrupts. The interrupt service
1085 routine will then ensure that the characters are sent. If the
1086 port is already active, there is no need to kick it.
1087 */
1088 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1089 {
1090 struct cyclades_port *info = tty->driver_data;
1091 unsigned long flags;
1092 int c, total = 0;
1093
1094 #ifdef SERIAL_DEBUG_IO
1095 printk("cy_write %s\n", tty->name); /* */
1096 #endif
1097
1098 if (serial_paranoia_check(info, tty->name, "cy_write")) {
1099 return 0;
1100 }
1101
1102 if (!info->xmit_buf) {
1103 return 0;
1104 }
1105
1106 while (1) {
1107 local_irq_save(flags);
1108 c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
1109 SERIAL_XMIT_SIZE - info->xmit_head));
1110 if (c <= 0) {
1111 local_irq_restore(flags);
1112 break;
1113 }
1114
1115 memcpy(info->xmit_buf + info->xmit_head, buf, c);
1116 info->xmit_head =
1117 (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
1118 info->xmit_cnt += c;
1119 local_irq_restore(flags);
1120
1121 buf += c;
1122 count -= c;
1123 total += c;
1124 }
1125
1126 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
1127 start_xmit(info);
1128 }
1129 return total;
1130 } /* cy_write */
1131
1132 static int cy_write_room(struct tty_struct *tty)
1133 {
1134 struct cyclades_port *info = tty->driver_data;
1135 int ret;
1136
1137 #ifdef SERIAL_DEBUG_IO
1138 printk("cy_write_room %s\n", tty->name); /* */
1139 #endif
1140
1141 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1142 return 0;
1143 ret = PAGE_SIZE - info->xmit_cnt - 1;
1144 if (ret < 0)
1145 ret = 0;
1146 return ret;
1147 } /* cy_write_room */
1148
1149 static int cy_chars_in_buffer(struct tty_struct *tty)
1150 {
1151 struct cyclades_port *info = tty->driver_data;
1152
1153 #ifdef SERIAL_DEBUG_IO
1154 printk("cy_chars_in_buffer %s %d\n", tty->name, info->xmit_cnt); /* */
1155 #endif
1156
1157 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1158 return 0;
1159
1160 return info->xmit_cnt;
1161 } /* cy_chars_in_buffer */
1162
1163 static void cy_flush_buffer(struct tty_struct *tty)
1164 {
1165 struct cyclades_port *info = tty->driver_data;
1166 unsigned long flags;
1167
1168 #ifdef SERIAL_DEBUG_IO
1169 printk("cy_flush_buffer %s\n", tty->name); /* */
1170 #endif
1171
1172 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1173 return;
1174 local_irq_save(flags);
1175 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1176 local_irq_restore(flags);
1177 tty_wakeup(tty);
1178 } /* cy_flush_buffer */
1179
1180 /* This routine is called by the upper-layer tty layer to signal
1181 that incoming characters should be throttled or that the
1182 throttle should be released.
1183 */
1184 static void cy_throttle(struct tty_struct *tty)
1185 {
1186 struct cyclades_port *info = tty->driver_data;
1187 unsigned long flags;
1188 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1189 int channel;
1190
1191 #ifdef SERIAL_DEBUG_THROTTLE
1192 char buf[64];
1193
1194 printk("throttle %s: %d....\n", tty_name(tty, buf),
1195 tty->ldisc.chars_in_buffer(tty));
1196 printk("cy_throttle %s\n", tty->name);
1197 #endif
1198
1199 if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1200 return;
1201 }
1202
1203 if (I_IXOFF(tty)) {
1204 info->x_char = STOP_CHAR(tty);
1205 /* Should use the "Send Special Character" feature!!! */
1206 }
1207
1208 channel = info->line;
1209
1210 local_irq_save(flags);
1211 base_addr[CyCAR] = (u_char) channel;
1212 base_addr[CyMSVR1] = 0;
1213 local_irq_restore(flags);
1214 } /* cy_throttle */
1215
1216 static void cy_unthrottle(struct tty_struct *tty)
1217 {
1218 struct cyclades_port *info = tty->driver_data;
1219 unsigned long flags;
1220 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1221 int channel;
1222
1223 #ifdef SERIAL_DEBUG_THROTTLE
1224 char buf[64];
1225
1226 printk("throttle %s: %d....\n", tty_name(tty, buf),
1227 tty->ldisc.chars_in_buffer(tty));
1228 printk("cy_unthrottle %s\n", tty->name);
1229 #endif
1230
1231 if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1232 return;
1233 }
1234
1235 if (I_IXOFF(tty)) {
1236 info->x_char = START_CHAR(tty);
1237 /* Should use the "Send Special Character" feature!!! */
1238 }
1239
1240 channel = info->line;
1241
1242 local_irq_save(flags);
1243 base_addr[CyCAR] = (u_char) channel;
1244 base_addr[CyMSVR1] = CyRTS;
1245 local_irq_restore(flags);
1246 } /* cy_unthrottle */
1247
1248 static int
1249 get_serial_info(struct cyclades_port *info,
1250 struct serial_struct __user * retinfo)
1251 {
1252 struct serial_struct tmp;
1253
1254 /* CP('g'); */
1255 if (!retinfo)
1256 return -EFAULT;
1257 memset(&tmp, 0, sizeof(tmp));
1258 tmp.type = info->type;
1259 tmp.line = info->line;
1260 tmp.port = info->line;
1261 tmp.irq = 0;
1262 tmp.flags = info->flags;
1263 tmp.baud_base = 0; /*!!! */
1264 tmp.close_delay = info->close_delay;
1265 tmp.custom_divisor = 0; /*!!! */
1266 tmp.hub6 = 0; /*!!! */
1267 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
1268 } /* get_serial_info */
1269
1270 static int
1271 set_serial_info(struct cyclades_port *info,
1272 struct serial_struct __user * new_info)
1273 {
1274 struct serial_struct new_serial;
1275 struct cyclades_port old_info;
1276
1277 /* CP('s'); */
1278 if (!new_info)
1279 return -EFAULT;
1280 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
1281 return -EFAULT;
1282 old_info = *info;
1283
1284 if (!capable(CAP_SYS_ADMIN)) {
1285 if ((new_serial.close_delay != info->close_delay) ||
1286 ((new_serial.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK) !=
1287 (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK)))
1288 return -EPERM;
1289 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
1290 (new_serial.flags & ASYNC_USR_MASK));
1291 goto check_and_exit;
1292 }
1293
1294 /*
1295 * OK, past this point, all the error checking has been done.
1296 * At this point, we start making changes.....
1297 */
1298
1299 info->flags = ((info->flags & ~ASYNC_FLAGS) |
1300 (new_serial.flags & ASYNC_FLAGS));
1301 info->close_delay = new_serial.close_delay;
1302
1303 check_and_exit:
1304 if (info->flags & ASYNC_INITIALIZED) {
1305 config_setup(info);
1306 return 0;
1307 }
1308 return startup(info);
1309 } /* set_serial_info */
1310
1311 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
1312 {
1313 struct cyclades_port *info = tty->driver_data;
1314 int channel;
1315 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1316 unsigned long flags;
1317 unsigned char status;
1318
1319 channel = info->line;
1320
1321 local_irq_save(flags);
1322 base_addr[CyCAR] = (u_char) channel;
1323 status = base_addr[CyMSVR1] | base_addr[CyMSVR2];
1324 local_irq_restore(flags);
1325
1326 return ((status & CyRTS) ? TIOCM_RTS : 0)
1327 | ((status & CyDTR) ? TIOCM_DTR : 0)
1328 | ((status & CyDCD) ? TIOCM_CAR : 0)
1329 | ((status & CyDSR) ? TIOCM_DSR : 0)
1330 | ((status & CyCTS) ? TIOCM_CTS : 0);
1331 } /* cy_tiocmget */
1332
1333 static int
1334 cy_tiocmset(struct tty_struct *tty, struct file *file,
1335 unsigned int set, unsigned int clear)
1336 {
1337 struct cyclades_port *info = tty->driver_data;
1338 int channel;
1339 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1340 unsigned long flags;
1341
1342 channel = info->line;
1343
1344 if (set & TIOCM_RTS) {
1345 local_irq_save(flags);
1346 base_addr[CyCAR] = (u_char) channel;
1347 base_addr[CyMSVR1] = CyRTS;
1348 local_irq_restore(flags);
1349 }
1350 if (set & TIOCM_DTR) {
1351 local_irq_save(flags);
1352 base_addr[CyCAR] = (u_char) channel;
1353 /* CP('S');CP('2'); */
1354 base_addr[CyMSVR2] = CyDTR;
1355 #ifdef SERIAL_DEBUG_DTR
1356 printk("cyc: %d: raising DTR\n", __LINE__);
1357 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1358 base_addr[CyMSVR2]);
1359 #endif
1360 local_irq_restore(flags);
1361 }
1362
1363 if (clear & TIOCM_RTS) {
1364 local_irq_save(flags);
1365 base_addr[CyCAR] = (u_char) channel;
1366 base_addr[CyMSVR1] = 0;
1367 local_irq_restore(flags);
1368 }
1369 if (clear & TIOCM_DTR) {
1370 local_irq_save(flags);
1371 base_addr[CyCAR] = (u_char) channel;
1372 /* CP('C');CP('2'); */
1373 base_addr[CyMSVR2] = 0;
1374 #ifdef SERIAL_DEBUG_DTR
1375 printk("cyc: %d: dropping DTR\n", __LINE__);
1376 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1377 base_addr[CyMSVR2]);
1378 #endif
1379 local_irq_restore(flags);
1380 }
1381
1382 return 0;
1383 } /* set_modem_info */
1384
1385 static void send_break(struct cyclades_port *info, int duration)
1386 { /* Let the transmit ISR take care of this (since it
1387 requires stuffing characters into the output stream).
1388 */
1389 info->x_break = duration;
1390 if (!info->xmit_cnt) {
1391 start_xmit(info);
1392 }
1393 } /* send_break */
1394
1395 static int
1396 get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
1397 {
1398
1399 if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
1400 return -EFAULT;
1401 info->mon.int_count = 0;
1402 info->mon.char_count = 0;
1403 info->mon.char_max = 0;
1404 info->mon.char_last = 0;
1405 return 0;
1406 }
1407
1408 static int set_threshold(struct cyclades_port *info, unsigned long __user * arg)
1409 {
1410 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1411 unsigned long value;
1412 int channel;
1413
1414 if (get_user(value, arg))
1415 return -EFAULT;
1416
1417 channel = info->line;
1418 info->cor4 &= ~CyREC_FIFO;
1419 info->cor4 |= value & CyREC_FIFO;
1420 base_addr[CyCOR4] = info->cor4;
1421 return 0;
1422 }
1423
1424 static int
1425 get_threshold(struct cyclades_port *info, unsigned long __user * value)
1426 {
1427 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1428 int channel;
1429 unsigned long tmp;
1430
1431 channel = info->line;
1432
1433 tmp = base_addr[CyCOR4] & CyREC_FIFO;
1434 return put_user(tmp, value);
1435 }
1436
1437 static int
1438 set_default_threshold(struct cyclades_port *info, unsigned long __user * arg)
1439 {
1440 unsigned long value;
1441
1442 if (get_user(value, arg))
1443 return -EFAULT;
1444
1445 info->default_threshold = value & 0x0f;
1446 return 0;
1447 }
1448
1449 static int
1450 get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
1451 {
1452 return put_user(info->default_threshold, value);
1453 }
1454
1455 static int set_timeout(struct cyclades_port *info, unsigned long __user * arg)
1456 {
1457 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1458 int channel;
1459 unsigned long value;
1460
1461 if (get_user(value, arg))
1462 return -EFAULT;
1463
1464 channel = info->line;
1465
1466 base_addr[CyRTPRL] = value & 0xff;
1467 base_addr[CyRTPRH] = (value >> 8) & 0xff;
1468 return 0;
1469 }
1470
1471 static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
1472 {
1473 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1474 int channel;
1475 unsigned long tmp;
1476
1477 channel = info->line;
1478
1479 tmp = base_addr[CyRTPRL];
1480 return put_user(tmp, value);
1481 }
1482
1483 static int set_default_timeout(struct cyclades_port *info, unsigned long value)
1484 {
1485 info->default_timeout = value & 0xff;
1486 return 0;
1487 }
1488
1489 static int
1490 get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
1491 {
1492 return put_user(info->default_timeout, value);
1493 }
1494
1495 static int
1496 cy_ioctl(struct tty_struct *tty, struct file *file,
1497 unsigned int cmd, unsigned long arg)
1498 {
1499 struct cyclades_port *info = tty->driver_data;
1500 int ret_val = 0;
1501 void __user *argp = (void __user *)arg;
1502
1503 #ifdef SERIAL_DEBUG_OTHER
1504 printk("cy_ioctl %s, cmd = %x arg = %lx\n", tty->name, cmd, arg); /* */
1505 #endif
1506
1507 tty_lock();
1508
1509 switch (cmd) {
1510 case CYGETMON:
1511 ret_val = get_mon_info(info, argp);
1512 break;
1513 case CYGETTHRESH:
1514 ret_val = get_threshold(info, argp);
1515 break;
1516 case CYSETTHRESH:
1517 ret_val = set_threshold(info, argp);
1518 break;
1519 case CYGETDEFTHRESH:
1520 ret_val = get_default_threshold(info, argp);
1521 break;
1522 case CYSETDEFTHRESH:
1523 ret_val = set_default_threshold(info, argp);
1524 break;
1525 case CYGETTIMEOUT:
1526 ret_val = get_timeout(info, argp);
1527 break;
1528 case CYSETTIMEOUT:
1529 ret_val = set_timeout(info, argp);
1530 break;
1531 case CYGETDEFTIMEOUT:
1532 ret_val = get_default_timeout(info, argp);
1533 break;
1534 case CYSETDEFTIMEOUT:
1535 ret_val = set_default_timeout(info, (unsigned long)arg);
1536 break;
1537 case TCSBRK: /* SVID version: non-zero arg --> no break */
1538 ret_val = tty_check_change(tty);
1539 if (ret_val)
1540 break;
1541 tty_wait_until_sent(tty, 0);
1542 if (!arg)
1543 send_break(info, HZ / 4); /* 1/4 second */
1544 break;
1545 case TCSBRKP: /* support for POSIX tcsendbreak() */
1546 ret_val = tty_check_change(tty);
1547 if (ret_val)
1548 break;
1549 tty_wait_until_sent(tty, 0);
1550 send_break(info, arg ? arg * (HZ / 10) : HZ / 4);
1551 break;
1552
1553 /* The following commands are incompletely implemented!!! */
1554 case TIOCGSERIAL:
1555 ret_val = get_serial_info(info, argp);
1556 break;
1557 case TIOCSSERIAL:
1558 ret_val = set_serial_info(info, argp);
1559 break;
1560 default:
1561 ret_val = -ENOIOCTLCMD;
1562 }
1563 tty_unlock();
1564
1565 #ifdef SERIAL_DEBUG_OTHER
1566 printk("cy_ioctl done\n");
1567 #endif
1568
1569 return ret_val;
1570 } /* cy_ioctl */
1571
1572 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1573 {
1574 struct cyclades_port *info = tty->driver_data;
1575
1576 #ifdef SERIAL_DEBUG_OTHER
1577 printk("cy_set_termios %s\n", tty->name);
1578 #endif
1579
1580 if (tty->termios->c_cflag == old_termios->c_cflag)
1581 return;
1582 config_setup(info);
1583
1584 if ((old_termios->c_cflag & CRTSCTS) &&
1585 !(tty->termios->c_cflag & CRTSCTS)) {
1586 tty->stopped = 0;
1587 cy_start(tty);
1588 }
1589 #ifdef tytso_patch_94Nov25_1726
1590 if (!(old_termios->c_cflag & CLOCAL) &&
1591 (tty->termios->c_cflag & CLOCAL))
1592 wake_up_interruptible(&info->open_wait);
1593 #endif
1594 } /* cy_set_termios */
1595
1596 static void cy_close(struct tty_struct *tty, struct file *filp)
1597 {
1598 struct cyclades_port *info = tty->driver_data;
1599
1600 /* CP('C'); */
1601 #ifdef SERIAL_DEBUG_OTHER
1602 printk("cy_close %s\n", tty->name);
1603 #endif
1604
1605 if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
1606 return;
1607 }
1608 #ifdef SERIAL_DEBUG_OPEN
1609 printk("cy_close %s, count = %d\n", tty->name, info->count);
1610 #endif
1611
1612 if ((tty->count == 1) && (info->count != 1)) {
1613 /*
1614 * Uh, oh. tty->count is 1, which means that the tty
1615 * structure will be freed. Info->count should always
1616 * be one in these conditions. If it's greater than
1617 * one, we've got real problems, since it means the
1618 * serial port won't be shutdown.
1619 */
1620 printk("cy_close: bad serial port count; tty->count is 1, "
1621 "info->count is %d\n", info->count);
1622 info->count = 1;
1623 }
1624 #ifdef SERIAL_DEBUG_COUNT
1625 printk("cyc: %d: decrementing count to %d\n", __LINE__,
1626 info->count - 1);
1627 #endif
1628 if (--info->count < 0) {
1629 printk("cy_close: bad serial port count for ttys%d: %d\n",
1630 info->line, info->count);
1631 #ifdef SERIAL_DEBUG_COUNT
1632 printk("cyc: %d: setting count to 0\n", __LINE__);
1633 #endif
1634 info->count = 0;
1635 }
1636 if (info->count)
1637 return;
1638 info->flags |= ASYNC_CLOSING;
1639 if (info->flags & ASYNC_INITIALIZED)
1640 tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
1641 shutdown(info);
1642 cy_flush_buffer(tty);
1643 tty_ldisc_flush(tty);
1644 info->tty = NULL;
1645 if (info->blocked_open) {
1646 if (info->close_delay) {
1647 msleep_interruptible(jiffies_to_msecs
1648 (info->close_delay));
1649 }
1650 wake_up_interruptible(&info->open_wait);
1651 }
1652 info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1653 wake_up_interruptible(&info->close_wait);
1654
1655 #ifdef SERIAL_DEBUG_OTHER
1656 printk("cy_close done\n");
1657 #endif
1658 } /* cy_close */
1659
1660 /*
1661 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
1662 */
1663 void cy_hangup(struct tty_struct *tty)
1664 {
1665 struct cyclades_port *info = tty->driver_data;
1666
1667 #ifdef SERIAL_DEBUG_OTHER
1668 printk("cy_hangup %s\n", tty->name); /* */
1669 #endif
1670
1671 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
1672 return;
1673
1674 shutdown(info);
1675 #if 0
1676 info->event = 0;
1677 info->count = 0;
1678 #ifdef SERIAL_DEBUG_COUNT
1679 printk("cyc: %d: setting count to 0\n", __LINE__);
1680 #endif
1681 info->tty = 0;
1682 #endif
1683 info->flags &= ~ASYNC_NORMAL_ACTIVE;
1684 wake_up_interruptible(&info->open_wait);
1685 } /* cy_hangup */
1686
1687 /*
1688 * ------------------------------------------------------------
1689 * cy_open() and friends
1690 * ------------------------------------------------------------
1691 */
1692
1693 static int
1694 block_til_ready(struct tty_struct *tty, struct file *filp,
1695 struct cyclades_port *info)
1696 {
1697 DECLARE_WAITQUEUE(wait, current);
1698 unsigned long flags;
1699 int channel;
1700 int retval;
1701 volatile u_char *base_addr = (u_char *) BASE_ADDR;
1702
1703 /*
1704 * If the device is in the middle of being closed, then block
1705 * until it's done, and then try again.
1706 */
1707 if (info->flags & ASYNC_CLOSING) {
1708 interruptible_sleep_on(&info->close_wait);
1709 if (info->flags & ASYNC_HUP_NOTIFY) {
1710 return -EAGAIN;
1711 } else {
1712 return -ERESTARTSYS;
1713 }
1714 }
1715
1716 /*
1717 * If non-blocking mode is set, then make the check up front
1718 * and then exit.
1719 */
1720 if (filp->f_flags & O_NONBLOCK) {
1721 info->flags |= ASYNC_NORMAL_ACTIVE;
1722 return 0;
1723 }
1724
1725 /*
1726 * Block waiting for the carrier detect and the line to become
1727 * free (i.e., not in use by the callout). While we are in
1728 * this loop, info->count is dropped by one, so that
1729 * cy_close() knows when to free things. We restore it upon
1730 * exit, either normal or abnormal.
1731 */
1732 retval = 0;
1733 add_wait_queue(&info->open_wait, &wait);
1734 #ifdef SERIAL_DEBUG_OPEN
1735 printk("block_til_ready before block: %s, count = %d\n",
1736 tty->name, info->count);
1737 /**/
1738 #endif
1739 info->count--;
1740 #ifdef SERIAL_DEBUG_COUNT
1741 printk("cyc: %d: decrementing count to %d\n", __LINE__, info->count);
1742 #endif
1743 info->blocked_open++;
1744
1745 channel = info->line;
1746
1747 while (1) {
1748 local_irq_save(flags);
1749 base_addr[CyCAR] = (u_char) channel;
1750 base_addr[CyMSVR1] = CyRTS;
1751 /* CP('S');CP('4'); */
1752 base_addr[CyMSVR2] = CyDTR;
1753 #ifdef SERIAL_DEBUG_DTR
1754 printk("cyc: %d: raising DTR\n", __LINE__);
1755 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1756 base_addr[CyMSVR2]);
1757 #endif
1758 local_irq_restore(flags);
1759 set_current_state(TASK_INTERRUPTIBLE);
1760 if (tty_hung_up_p(filp)
1761 || !(info->flags & ASYNC_INITIALIZED)) {
1762 if (info->flags & ASYNC_HUP_NOTIFY) {
1763 retval = -EAGAIN;
1764 } else {
1765 retval = -ERESTARTSYS;
1766 }
1767 break;
1768 }
1769 local_irq_save(flags);
1770 base_addr[CyCAR] = (u_char) channel;
1771 /* CP('L');CP1(1 && C_CLOCAL(tty)); CP1(1 && (base_addr[CyMSVR1] & CyDCD) ); */
1772 if (!(info->flags & ASYNC_CLOSING)
1773 && (C_CLOCAL(tty)
1774 || (base_addr[CyMSVR1] & CyDCD))) {
1775 local_irq_restore(flags);
1776 break;
1777 }
1778 local_irq_restore(flags);
1779 if (signal_pending(current)) {
1780 retval = -ERESTARTSYS;
1781 break;
1782 }
1783 #ifdef SERIAL_DEBUG_OPEN
1784 printk("block_til_ready blocking: %s, count = %d\n",
1785 tty->name, info->count);
1786 /**/
1787 #endif
1788 tty_unlock();
1789 schedule();
1790 tty_lock();
1791 }
1792 __set_current_state(TASK_RUNNING);
1793 remove_wait_queue(&info->open_wait, &wait);
1794 if (!tty_hung_up_p(filp)) {
1795 info->count++;
1796 #ifdef SERIAL_DEBUG_COUNT
1797 printk("cyc: %d: incrementing count to %d\n", __LINE__,
1798 info->count);
1799 #endif
1800 }
1801 info->blocked_open--;
1802 #ifdef SERIAL_DEBUG_OPEN
1803 printk("block_til_ready after blocking: %s, count = %d\n",
1804 tty->name, info->count);
1805 /**/
1806 #endif
1807 if (retval)
1808 return retval;
1809 info->flags |= ASYNC_NORMAL_ACTIVE;
1810 return 0;
1811 } /* block_til_ready */
1812
1813 /*
1814 * This routine is called whenever a serial port is opened. It
1815 * performs the serial-specific initialization for the tty structure.
1816 */
1817 int cy_open(struct tty_struct *tty, struct file *filp)
1818 {
1819 struct cyclades_port *info;
1820 int retval, line;
1821
1822 /* CP('O'); */
1823 line = tty->index;
1824 if ((line < 0) || (NR_PORTS <= line)) {
1825 return -ENODEV;
1826 }
1827 info = &cy_port[line];
1828 if (info->line < 0) {
1829 return -ENODEV;
1830 }
1831 #ifdef SERIAL_DEBUG_OTHER
1832 printk("cy_open %s\n", tty->name); /* */
1833 #endif
1834 if (serial_paranoia_check(info, tty->name, "cy_open")) {
1835 return -ENODEV;
1836 }
1837 #ifdef SERIAL_DEBUG_OPEN
1838 printk("cy_open %s, count = %d\n", tty->name, info->count);
1839 /**/
1840 #endif
1841 info->count++;
1842 #ifdef SERIAL_DEBUG_COUNT
1843 printk("cyc: %d: incrementing count to %d\n", __LINE__, info->count);
1844 #endif
1845 tty->driver_data = info;
1846 info->tty = tty;
1847
1848 /*
1849 * Start up serial port
1850 */
1851 retval = startup(info);
1852 if (retval) {
1853 return retval;
1854 }
1855
1856 retval = block_til_ready(tty, filp, info);
1857 if (retval) {
1858 #ifdef SERIAL_DEBUG_OPEN
1859 printk("cy_open returning after block_til_ready with %d\n",
1860 retval);
1861 #endif
1862 return retval;
1863 }
1864 #ifdef SERIAL_DEBUG_OPEN
1865 printk("cy_open done\n");
1866 /**/
1867 #endif
1868 return 0;
1869 } /* cy_open */
1870
1871 /*
1872 * ---------------------------------------------------------------------
1873 * serial167_init() and friends
1874 *
1875 * serial167_init() is called at boot-time to initialize the serial driver.
1876 * ---------------------------------------------------------------------
1877 */
1878
1879 /*
1880 * This routine prints out the appropriate serial driver version
1881 * number, and identifies which options were configured into this
1882 * driver.
1883 */
1884 static void show_version(void)
1885 {
1886 printk("MVME166/167 cd2401 driver\n");
1887 } /* show_version */
1888
1889 /* initialize chips on card -- return number of valid
1890 chips (which is number of ports/4) */
1891
1892 /*
1893 * This initialises the hardware to a reasonable state. It should
1894 * probe the chip first so as to copy 166-Bug setup as a default for
1895 * port 0. It initialises CMR to CyASYNC; that is never done again, so
1896 * as to limit the number of CyINIT_CHAN commands in normal running.
1897 *
1898 * ... I wonder what I should do if this fails ...
1899 */
1900
1901 void mvme167_serial_console_setup(int cflag)
1902 {
1903 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1904 int ch;
1905 u_char spd;
1906 u_char rcor, rbpr, badspeed = 0;
1907 unsigned long flags;
1908
1909 local_irq_save(flags);
1910
1911 /*
1912 * First probe channel zero of the chip, to see what speed has
1913 * been selected.
1914 */
1915
1916 base_addr[CyCAR] = 0;
1917
1918 rcor = base_addr[CyRCOR] << 5;
1919 rbpr = base_addr[CyRBPR];
1920
1921 for (spd = 0; spd < sizeof(baud_bpr); spd++)
1922 if (rbpr == baud_bpr[spd] && rcor == baud_co[spd])
1923 break;
1924 if (spd >= sizeof(baud_bpr)) {
1925 spd = 14; /* 19200 */
1926 badspeed = 1; /* Failed to identify speed */
1927 }
1928 initial_console_speed = spd;
1929
1930 /* OK, we have chosen a speed, now reset and reinitialise */
1931
1932 my_udelay(20000L); /* Allow time for any active o/p to complete */
1933 if (base_addr[CyCCR] != 0x00) {
1934 local_irq_restore(flags);
1935 /* printk(" chip is never idle (CCR != 0)\n"); */
1936 return;
1937 }
1938
1939 base_addr[CyCCR] = CyCHIP_RESET; /* Reset the chip */
1940 my_udelay(1000L);
1941
1942 if (base_addr[CyGFRCR] == 0x00) {
1943 local_irq_restore(flags);
1944 /* printk(" chip is not responding (GFRCR stayed 0)\n"); */
1945 return;
1946 }
1947
1948 /*
1949 * System clock is 20Mhz, divided by 2048, so divide by 10 for a 1.0ms
1950 * tick
1951 */
1952
1953 base_addr[CyTPR] = 10;
1954
1955 base_addr[CyPILR1] = 0x01; /* Interrupt level for modem change */
1956 base_addr[CyPILR2] = 0x02; /* Interrupt level for tx ints */
1957 base_addr[CyPILR3] = 0x03; /* Interrupt level for rx ints */
1958
1959 /*
1960 * Attempt to set up all channels to something reasonable, and
1961 * bang out a INIT_CHAN command. We should then be able to limit
1962 * the amount of fiddling we have to do in normal running.
1963 */
1964
1965 for (ch = 3; ch >= 0; ch--) {
1966 base_addr[CyCAR] = (u_char) ch;
1967 base_addr[CyIER] = 0;
1968 base_addr[CyCMR] = CyASYNC;
1969 base_addr[CyLICR] = (u_char) ch << 2;
1970 base_addr[CyLIVR] = 0x5c;
1971 base_addr[CyTCOR] = baud_co[spd];
1972 base_addr[CyTBPR] = baud_bpr[spd];
1973 base_addr[CyRCOR] = baud_co[spd] >> 5;
1974 base_addr[CyRBPR] = baud_bpr[spd];
1975 base_addr[CySCHR1] = 'Q' & 0x1f;
1976 base_addr[CySCHR2] = 'X' & 0x1f;
1977 base_addr[CySCRL] = 0;
1978 base_addr[CySCRH] = 0;
1979 base_addr[CyCOR1] = Cy_8_BITS | CyPARITY_NONE;
1980 base_addr[CyCOR2] = 0;
1981 base_addr[CyCOR3] = Cy_1_STOP;
1982 base_addr[CyCOR4] = baud_cor4[spd];
1983 base_addr[CyCOR5] = 0;
1984 base_addr[CyCOR6] = 0;
1985 base_addr[CyCOR7] = 0;
1986 base_addr[CyRTPRL] = 2;
1987 base_addr[CyRTPRH] = 0;
1988 base_addr[CyMSVR1] = 0;
1989 base_addr[CyMSVR2] = 0;
1990 write_cy_cmd(base_addr, CyINIT_CHAN | CyDIS_RCVR | CyDIS_XMTR);
1991 }
1992
1993 /*
1994 * Now do specials for channel zero....
1995 */
1996
1997 base_addr[CyMSVR1] = CyRTS;
1998 base_addr[CyMSVR2] = CyDTR;
1999 base_addr[CyIER] = CyRxData;
2000 write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
2001
2002 local_irq_restore(flags);
2003
2004 my_udelay(20000L); /* Let it all settle down */
2005
2006 printk("CD2401 initialised, chip is rev 0x%02x\n", base_addr[CyGFRCR]);
2007 if (badspeed)
2008 printk
2009 (" WARNING: Failed to identify line speed, rcor=%02x,rbpr=%02x\n",
2010 rcor >> 5, rbpr);
2011 } /* serial_console_init */
2012
2013 static const struct tty_operations cy_ops = {
2014 .open = cy_open,
2015 .close = cy_close,
2016 .write = cy_write,
2017 .put_char = cy_put_char,
2018 .flush_chars = cy_flush_chars,
2019 .write_room = cy_write_room,
2020 .chars_in_buffer = cy_chars_in_buffer,
2021 .flush_buffer = cy_flush_buffer,
2022 .ioctl = cy_ioctl,
2023 .throttle = cy_throttle,
2024 .unthrottle = cy_unthrottle,
2025 .set_termios = cy_set_termios,
2026 .stop = cy_stop,
2027 .start = cy_start,
2028 .hangup = cy_hangup,
2029 .tiocmget = cy_tiocmget,
2030 .tiocmset = cy_tiocmset,
2031 };
2032
2033 /* The serial driver boot-time initialization code!
2034 Hardware I/O ports are mapped to character special devices on a
2035 first found, first allocated manner. That is, this code searches
2036 for Cyclom cards in the system. As each is found, it is probed
2037 to discover how many chips (and thus how many ports) are present.
2038 These ports are mapped to the tty ports 64 and upward in monotonic
2039 fashion. If an 8-port card is replaced with a 16-port card, the
2040 port mapping on a following card will shift.
2041
2042 This approach is different from what is used in the other serial
2043 device driver because the Cyclom is more properly a multiplexer,
2044 not just an aggregation of serial ports on one card.
2045
2046 If there are more cards with more ports than have been statically
2047 allocated above, a warning is printed and the extra ports are ignored.
2048 */
2049 static int __init serial167_init(void)
2050 {
2051 struct cyclades_port *info;
2052 int ret = 0;
2053 int good_ports = 0;
2054 int port_num = 0;
2055 int index;
2056 int DefSpeed;
2057 #ifdef notyet
2058 struct sigaction sa;
2059 #endif
2060
2061 if (!(mvme16x_config & MVME16x_CONFIG_GOT_CD2401))
2062 return 0;
2063
2064 cy_serial_driver = alloc_tty_driver(NR_PORTS);
2065 if (!cy_serial_driver)
2066 return -ENOMEM;
2067
2068 #if 0
2069 scrn[1] = '\0';
2070 #endif
2071
2072 show_version();
2073
2074 /* Has "console=0,9600n8" been used in bootinfo to change speed? */
2075 if (serial_console_cflag)
2076 DefSpeed = serial_console_cflag & 0017;
2077 else {
2078 DefSpeed = initial_console_speed;
2079 serial_console_info = &cy_port[0];
2080 serial_console_cflag = DefSpeed | CS8;
2081 #if 0
2082 serial_console = 64; /*callout_driver.minor_start */
2083 #endif
2084 }
2085
2086 /* Initialize the tty_driver structure */
2087
2088 cy_serial_driver->owner = THIS_MODULE;
2089 cy_serial_driver->name = "ttyS";
2090 cy_serial_driver->major = TTY_MAJOR;
2091 cy_serial_driver->minor_start = 64;
2092 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
2093 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
2094 cy_serial_driver->init_termios = tty_std_termios;
2095 cy_serial_driver->init_termios.c_cflag =
2096 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2097 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW;
2098 tty_set_operations(cy_serial_driver, &cy_ops);
2099
2100 ret = tty_register_driver(cy_serial_driver);
2101 if (ret) {
2102 printk(KERN_ERR "Couldn't register MVME166/7 serial driver\n");
2103 put_tty_driver(cy_serial_driver);
2104 return ret;
2105 }
2106
2107 port_num = 0;
2108 info = cy_port;
2109 for (index = 0; index < 1; index++) {
2110
2111 good_ports = 4;
2112
2113 if (port_num < NR_PORTS) {
2114 while (good_ports-- && port_num < NR_PORTS) {
2115 /*** initialize port ***/
2116 info->magic = CYCLADES_MAGIC;
2117 info->type = PORT_CIRRUS;
2118 info->card = index;
2119 info->line = port_num;
2120 info->flags = STD_COM_FLAGS;
2121 info->tty = NULL;
2122 info->xmit_fifo_size = 12;
2123 info->cor1 = CyPARITY_NONE | Cy_8_BITS;
2124 info->cor2 = CyETC;
2125 info->cor3 = Cy_1_STOP;
2126 info->cor4 = 0x08; /* _very_ small receive threshold */
2127 info->cor5 = 0;
2128 info->cor6 = 0;
2129 info->cor7 = 0;
2130 info->tbpr = baud_bpr[DefSpeed]; /* Tx BPR */
2131 info->tco = baud_co[DefSpeed]; /* Tx CO */
2132 info->rbpr = baud_bpr[DefSpeed]; /* Rx BPR */
2133 info->rco = baud_co[DefSpeed] >> 5; /* Rx CO */
2134 info->close_delay = 0;
2135 info->x_char = 0;
2136 info->count = 0;
2137 #ifdef SERIAL_DEBUG_COUNT
2138 printk("cyc: %d: setting count to 0\n",
2139 __LINE__);
2140 #endif
2141 info->blocked_open = 0;
2142 info->default_threshold = 0;
2143 info->default_timeout = 0;
2144 init_waitqueue_head(&info->open_wait);
2145 init_waitqueue_head(&info->close_wait);
2146 /* info->session */
2147 /* info->pgrp */
2148 /*** !!!!!!!! this may expose new bugs !!!!!!!!! *********/
2149 info->read_status_mask =
2150 CyTIMEOUT | CySPECHAR | CyBREAK | CyPARITY |
2151 CyFRAME | CyOVERRUN;
2152 /* info->timeout */
2153
2154 printk("ttyS%d ", info->line);
2155 port_num++;
2156 info++;
2157 if (!(port_num & 7)) {
2158 printk("\n ");
2159 }
2160 }
2161 }
2162 printk("\n");
2163 }
2164 while (port_num < NR_PORTS) {
2165 info->line = -1;
2166 port_num++;
2167 info++;
2168 }
2169
2170 ret = request_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt, 0,
2171 "cd2401_errors", cd2401_rxerr_interrupt);
2172 if (ret) {
2173 printk(KERN_ERR "Could't get cd2401_errors IRQ");
2174 goto cleanup_serial_driver;
2175 }
2176
2177 ret = request_irq(MVME167_IRQ_SER_MODEM, cd2401_modem_interrupt, 0,
2178 "cd2401_modem", cd2401_modem_interrupt);
2179 if (ret) {
2180 printk(KERN_ERR "Could't get cd2401_modem IRQ");
2181 goto cleanup_irq_cd2401_errors;
2182 }
2183
2184 ret = request_irq(MVME167_IRQ_SER_TX, cd2401_tx_interrupt, 0,
2185 "cd2401_txints", cd2401_tx_interrupt);
2186 if (ret) {
2187 printk(KERN_ERR "Could't get cd2401_txints IRQ");
2188 goto cleanup_irq_cd2401_modem;
2189 }
2190
2191 ret = request_irq(MVME167_IRQ_SER_RX, cd2401_rx_interrupt, 0,
2192 "cd2401_rxints", cd2401_rx_interrupt);
2193 if (ret) {
2194 printk(KERN_ERR "Could't get cd2401_rxints IRQ");
2195 goto cleanup_irq_cd2401_txints;
2196 }
2197
2198 /* Now we have registered the interrupt handlers, allow the interrupts */
2199
2200 pcc2chip[PccSCCMICR] = 0x15; /* Serial ints are level 5 */
2201 pcc2chip[PccSCCTICR] = 0x15;
2202 pcc2chip[PccSCCRICR] = 0x15;
2203
2204 pcc2chip[PccIMLR] = 3; /* Allow PCC2 ints above 3!? */
2205
2206 return 0;
2207 cleanup_irq_cd2401_txints:
2208 free_irq(MVME167_IRQ_SER_TX, cd2401_tx_interrupt);
2209 cleanup_irq_cd2401_modem:
2210 free_irq(MVME167_IRQ_SER_MODEM, cd2401_modem_interrupt);
2211 cleanup_irq_cd2401_errors:
2212 free_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt);
2213 cleanup_serial_driver:
2214 if (tty_unregister_driver(cy_serial_driver))
2215 printk(KERN_ERR
2216 "Couldn't unregister MVME166/7 serial driver\n");
2217 put_tty_driver(cy_serial_driver);
2218 return ret;
2219 } /* serial167_init */
2220
2221 module_init(serial167_init);
2222
2223 #ifdef CYCLOM_SHOW_STATUS
2224 static void show_status(int line_num)
2225 {
2226 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2227 int channel;
2228 struct cyclades_port *info;
2229 unsigned long flags;
2230
2231 info = &cy_port[line_num];
2232 channel = info->line;
2233 printk(" channel %d\n", channel);
2234 /**/ printk(" cy_port\n");
2235 printk(" card line flags = %d %d %x\n",
2236 info->card, info->line, info->flags);
2237 printk
2238 (" *tty read_status_mask timeout xmit_fifo_size = %lx %x %x %x\n",
2239 (long)info->tty, info->read_status_mask, info->timeout,
2240 info->xmit_fifo_size);
2241 printk(" cor1,cor2,cor3,cor4,cor5,cor6,cor7 = %x %x %x %x %x %x %x\n",
2242 info->cor1, info->cor2, info->cor3, info->cor4, info->cor5,
2243 info->cor6, info->cor7);
2244 printk(" tbpr,tco,rbpr,rco = %d %d %d %d\n", info->tbpr, info->tco,
2245 info->rbpr, info->rco);
2246 printk(" close_delay event count = %d %d %d\n", info->close_delay,
2247 info->event, info->count);
2248 printk(" x_char blocked_open = %x %x\n", info->x_char,
2249 info->blocked_open);
2250 printk(" open_wait = %lx %lx %lx\n", (long)info->open_wait);
2251
2252 local_irq_save(flags);
2253
2254 /* Global Registers */
2255
2256 printk(" CyGFRCR %x\n", base_addr[CyGFRCR]);
2257 printk(" CyCAR %x\n", base_addr[CyCAR]);
2258 printk(" CyRISR %x\n", base_addr[CyRISR]);
2259 printk(" CyTISR %x\n", base_addr[CyTISR]);
2260 printk(" CyMISR %x\n", base_addr[CyMISR]);
2261 printk(" CyRIR %x\n", base_addr[CyRIR]);
2262 printk(" CyTIR %x\n", base_addr[CyTIR]);
2263 printk(" CyMIR %x\n", base_addr[CyMIR]);
2264 printk(" CyTPR %x\n", base_addr[CyTPR]);
2265
2266 base_addr[CyCAR] = (u_char) channel;
2267
2268 /* Virtual Registers */
2269
2270 #if 0
2271 printk(" CyRIVR %x\n", base_addr[CyRIVR]);
2272 printk(" CyTIVR %x\n", base_addr[CyTIVR]);
2273 printk(" CyMIVR %x\n", base_addr[CyMIVR]);
2274 printk(" CyMISR %x\n", base_addr[CyMISR]);
2275 #endif
2276
2277 /* Channel Registers */
2278
2279 printk(" CyCCR %x\n", base_addr[CyCCR]);
2280 printk(" CyIER %x\n", base_addr[CyIER]);
2281 printk(" CyCOR1 %x\n", base_addr[CyCOR1]);
2282 printk(" CyCOR2 %x\n", base_addr[CyCOR2]);
2283 printk(" CyCOR3 %x\n", base_addr[CyCOR3]);
2284 printk(" CyCOR4 %x\n", base_addr[CyCOR4]);
2285 printk(" CyCOR5 %x\n", base_addr[CyCOR5]);
2286 #if 0
2287 printk(" CyCCSR %x\n", base_addr[CyCCSR]);
2288 printk(" CyRDCR %x\n", base_addr[CyRDCR]);
2289 #endif
2290 printk(" CySCHR1 %x\n", base_addr[CySCHR1]);
2291 printk(" CySCHR2 %x\n", base_addr[CySCHR2]);
2292 #if 0
2293 printk(" CySCHR3 %x\n", base_addr[CySCHR3]);
2294 printk(" CySCHR4 %x\n", base_addr[CySCHR4]);
2295 printk(" CySCRL %x\n", base_addr[CySCRL]);
2296 printk(" CySCRH %x\n", base_addr[CySCRH]);
2297 printk(" CyLNC %x\n", base_addr[CyLNC]);
2298 printk(" CyMCOR1 %x\n", base_addr[CyMCOR1]);
2299 printk(" CyMCOR2 %x\n", base_addr[CyMCOR2]);
2300 #endif
2301 printk(" CyRTPRL %x\n", base_addr[CyRTPRL]);
2302 printk(" CyRTPRH %x\n", base_addr[CyRTPRH]);
2303 printk(" CyMSVR1 %x\n", base_addr[CyMSVR1]);
2304 printk(" CyMSVR2 %x\n", base_addr[CyMSVR2]);
2305 printk(" CyRBPR %x\n", base_addr[CyRBPR]);
2306 printk(" CyRCOR %x\n", base_addr[CyRCOR]);
2307 printk(" CyTBPR %x\n", base_addr[CyTBPR]);
2308 printk(" CyTCOR %x\n", base_addr[CyTCOR]);
2309
2310 local_irq_restore(flags);
2311 } /* show_status */
2312 #endif
2313
2314 #if 0
2315 /* Dummy routine in mvme16x/config.c for now */
2316
2317 /* Serial console setup. Called from linux/init/main.c */
2318
2319 void console_setup(char *str, int *ints)
2320 {
2321 char *s;
2322 int baud, bits, parity;
2323 int cflag = 0;
2324
2325 /* Sanity check. */
2326 if (ints[0] > 3 || ints[1] > 3)
2327 return;
2328
2329 /* Get baud, bits and parity */
2330 baud = 2400;
2331 bits = 8;
2332 parity = 'n';
2333 if (ints[2])
2334 baud = ints[2];
2335 if ((s = strchr(str, ','))) {
2336 do {
2337 s++;
2338 } while (*s >= '0' && *s <= '9');
2339 if (*s)
2340 parity = *s++;
2341 if (*s)
2342 bits = *s - '0';
2343 }
2344
2345 /* Now construct a cflag setting. */
2346 switch (baud) {
2347 case 1200:
2348 cflag |= B1200;
2349 break;
2350 case 9600:
2351 cflag |= B9600;
2352 break;
2353 case 19200:
2354 cflag |= B19200;
2355 break;
2356 case 38400:
2357 cflag |= B38400;
2358 break;
2359 case 2400:
2360 default:
2361 cflag |= B2400;
2362 break;
2363 }
2364 switch (bits) {
2365 case 7:
2366 cflag |= CS7;
2367 break;
2368 default:
2369 case 8:
2370 cflag |= CS8;
2371 break;
2372 }
2373 switch (parity) {
2374 case 'o':
2375 case 'O':
2376 cflag |= PARODD;
2377 break;
2378 case 'e':
2379 case 'E':
2380 cflag |= PARENB;
2381 break;
2382 }
2383
2384 serial_console_info = &cy_port[ints[1]];
2385 serial_console_cflag = cflag;
2386 serial_console = ints[1] + 64; /*callout_driver.minor_start */
2387 }
2388 #endif
2389
2390 /*
2391 * The following is probably out of date for 2.1.x serial console stuff.
2392 *
2393 * The console is registered early on from arch/m68k/kernel/setup.c, and
2394 * it therefore relies on the chip being setup correctly by 166-Bug. This
2395 * seems reasonable, as the serial port has been used to invoke the system
2396 * boot. It also means that this function must not rely on any data
2397 * initialisation performed by serial167_init() etc.
2398 *
2399 * Of course, once the console has been registered, we had better ensure
2400 * that serial167_init() doesn't leave the chip non-functional.
2401 *
2402 * The console must be locked when we get here.
2403 */
2404
2405 void serial167_console_write(struct console *co, const char *str,
2406 unsigned count)
2407 {
2408 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2409 unsigned long flags;
2410 volatile u_char sink;
2411 u_char ier;
2412 int port;
2413 u_char do_lf = 0;
2414 int i = 0;
2415
2416 local_irq_save(flags);
2417
2418 /* Ensure transmitter is enabled! */
2419
2420 port = 0;
2421 base_addr[CyCAR] = (u_char) port;
2422 while (base_addr[CyCCR])
2423 ;
2424 base_addr[CyCCR] = CyENB_XMTR;
2425
2426 ier = base_addr[CyIER];
2427 base_addr[CyIER] = CyTxMpty;
2428
2429 while (1) {
2430 if (pcc2chip[PccSCCTICR] & 0x20) {
2431 /* We have a Tx int. Acknowledge it */
2432 sink = pcc2chip[PccTPIACKR];
2433 if ((base_addr[CyLICR] >> 2) == port) {
2434 if (i == count) {
2435 /* Last char of string is now output */
2436 base_addr[CyTEOIR] = CyNOTRANS;
2437 break;
2438 }
2439 if (do_lf) {
2440 base_addr[CyTDR] = '\n';
2441 str++;
2442 i++;
2443 do_lf = 0;
2444 } else if (*str == '\n') {
2445 base_addr[CyTDR] = '\r';
2446 do_lf = 1;
2447 } else {
2448 base_addr[CyTDR] = *str++;
2449 i++;
2450 }
2451 base_addr[CyTEOIR] = 0;
2452 } else
2453 base_addr[CyTEOIR] = CyNOTRANS;
2454 }
2455 }
2456
2457 base_addr[CyIER] = ier;
2458
2459 local_irq_restore(flags);
2460 }
2461
2462 static struct tty_driver *serial167_console_device(struct console *c,
2463 int *index)
2464 {
2465 *index = c->index;
2466 return cy_serial_driver;
2467 }
2468
2469 static struct console sercons = {
2470 .name = "ttyS",
2471 .write = serial167_console_write,
2472 .device = serial167_console_device,
2473 .flags = CON_PRINTBUFFER,
2474 .index = -1,
2475 };
2476
2477 static int __init serial167_console_init(void)
2478 {
2479 if (vme_brdtype == VME_TYPE_MVME166 ||
2480 vme_brdtype == VME_TYPE_MVME167 ||
2481 vme_brdtype == VME_TYPE_MVME177) {
2482 mvme167_serial_console_setup(0);
2483 register_console(&sercons);
2484 }
2485 return 0;
2486 }
2487
2488 console_initcall(serial167_console_init);
2489
2490 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree