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