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