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