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