projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] TTY layer buffering revamp
[deliverable/linux.git] / drivers / char / rocket.c
1 /*
2 * RocketPort device driver for Linux
3 *
4 * Written by Theodore Ts'o, 1995, 1996, 1997, 1998, 1999, 2000.
5 *
6 * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2003 by Comtrol, Inc.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of the
11 * License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 /*
24 * Kernel Synchronization:
25 *
26 * This driver has 2 kernel control paths - exception handlers (calls into the driver
27 * from user mode) and the timer bottom half (tasklet). This is a polled driver, interrupts
28 * are not used.
29 *
30 * Critical data:
31 * - rp_table[], accessed through passed "info" pointers, is a global (static) array of
32 * serial port state information and the xmit_buf circular buffer. Protected by
33 * a per port spinlock.
34 * - xmit_flags[], an array of ints indexed by line (port) number, indicating that there
35 * is data to be transmitted. Protected by atomic bit operations.
36 * - rp_num_ports, int indicating number of open ports, protected by atomic operations.
37 *
38 * rp_write() and rp_write_char() functions use a per port semaphore to protect against
39 * simultaneous access to the same port by more than one process.
40 */
41
42 /****** Defines ******/
43 #ifdef PCI_NUM_RESOURCES
44 #define PCI_BASE_ADDRESS(dev, r) ((dev)->resource[r].start)
45 #else
46 #define PCI_BASE_ADDRESS(dev, r) ((dev)->base_address[r])
47 #endif
48
49 #define ROCKET_PARANOIA_CHECK
50 #define ROCKET_DISABLE_SIMUSAGE
51
52 #undef ROCKET_SOFT_FLOW
53 #undef ROCKET_DEBUG_OPEN
54 #undef ROCKET_DEBUG_INTR
55 #undef ROCKET_DEBUG_WRITE
56 #undef ROCKET_DEBUG_FLOW
57 #undef ROCKET_DEBUG_THROTTLE
58 #undef ROCKET_DEBUG_WAIT_UNTIL_SENT
59 #undef ROCKET_DEBUG_RECEIVE
60 #undef ROCKET_DEBUG_HANGUP
61 #undef REV_PCI_ORDER
62 #undef ROCKET_DEBUG_IO
63
64 #define POLL_PERIOD HZ/100 /* Polling period .01 seconds (10ms) */
65
66 /****** Kernel includes ******/
67
68 #ifdef MODVERSIONS
69 #include <config/modversions.h>
70 #endif
71
72 #include <linux/module.h>
73 #include <linux/errno.h>
74 #include <linux/major.h>
75 #include <linux/kernel.h>
76 #include <linux/signal.h>
77 #include <linux/slab.h>
78 #include <linux/mm.h>
79 #include <linux/sched.h>
80 #include <linux/timer.h>
81 #include <linux/interrupt.h>
82 #include <linux/tty.h>
83 #include <linux/tty_driver.h>
84 #include <linux/tty_flip.h>
85 #include <linux/string.h>
86 #include <linux/fcntl.h>
87 #include <linux/ptrace.h>
88 #include <linux/ioport.h>
89 #include <linux/delay.h>
90 #include <linux/wait.h>
91 #include <linux/pci.h>
92 #include <asm/uaccess.h>
93 #include <asm/atomic.h>
94 #include <linux/bitops.h>
95 #include <linux/spinlock.h>
96 #include <asm/semaphore.h>
97 #include <linux/init.h>
98
99 /****** RocketPort includes ******/
100
101 #include "rocket_int.h"
102 #include "rocket.h"
103
104 #define ROCKET_VERSION "2.09"
105 #define ROCKET_DATE "12-June-2003"
106
107 /****** RocketPort Local Variables ******/
108
109 static struct tty_driver *rocket_driver;
110
111 static struct rocket_version driver_version = {
112 ROCKET_VERSION, ROCKET_DATE
113 };
114
115 static struct r_port *rp_table[MAX_RP_PORTS]; /* The main repository of serial port state information. */
116 static unsigned int xmit_flags[NUM_BOARDS]; /* Bit significant, indicates port had data to transmit. */
117 /* eg. Bit 0 indicates port 0 has xmit data, ... */
118 static atomic_t rp_num_ports_open; /* Number of serial ports open */
119 static struct timer_list rocket_timer;
120
121 static unsigned long board1; /* ISA addresses, retrieved from rocketport.conf */
122 static unsigned long board2;
123 static unsigned long board3;
124 static unsigned long board4;
125 static unsigned long controller;
126 static int support_low_speed;
127 static unsigned long modem1;
128 static unsigned long modem2;
129 static unsigned long modem3;
130 static unsigned long modem4;
131 static unsigned long pc104_1[8];
132 static unsigned long pc104_2[8];
133 static unsigned long pc104_3[8];
134 static unsigned long pc104_4[8];
135 static unsigned long *pc104[4] = { pc104_1, pc104_2, pc104_3, pc104_4 };
136
137 static int rp_baud_base[NUM_BOARDS]; /* Board config info (Someday make a per-board structure) */
138 static unsigned long rcktpt_io_addr[NUM_BOARDS];
139 static int rcktpt_type[NUM_BOARDS];
140 static int is_PCI[NUM_BOARDS];
141 static rocketModel_t rocketModel[NUM_BOARDS];
142 static int max_board;
143
144 /*
145 * The following arrays define the interrupt bits corresponding to each AIOP.
146 * These bits are different between the ISA and regular PCI boards and the
147 * Universal PCI boards.
148 */
149
150 static Word_t aiop_intr_bits[AIOP_CTL_SIZE] = {
151 AIOP_INTR_BIT_0,
152 AIOP_INTR_BIT_1,
153 AIOP_INTR_BIT_2,
154 AIOP_INTR_BIT_3
155 };
156
157 static Word_t upci_aiop_intr_bits[AIOP_CTL_SIZE] = {
158 UPCI_AIOP_INTR_BIT_0,
159 UPCI_AIOP_INTR_BIT_1,
160 UPCI_AIOP_INTR_BIT_2,
161 UPCI_AIOP_INTR_BIT_3
162 };
163
164 static Byte_t RData[RDATASIZE] = {
165 0x00, 0x09, 0xf6, 0x82,
166 0x02, 0x09, 0x86, 0xfb,
167 0x04, 0x09, 0x00, 0x0a,
168 0x06, 0x09, 0x01, 0x0a,
169 0x08, 0x09, 0x8a, 0x13,
170 0x0a, 0x09, 0xc5, 0x11,
171 0x0c, 0x09, 0x86, 0x85,
172 0x0e, 0x09, 0x20, 0x0a,
173 0x10, 0x09, 0x21, 0x0a,
174 0x12, 0x09, 0x41, 0xff,
175 0x14, 0x09, 0x82, 0x00,
176 0x16, 0x09, 0x82, 0x7b,
177 0x18, 0x09, 0x8a, 0x7d,
178 0x1a, 0x09, 0x88, 0x81,
179 0x1c, 0x09, 0x86, 0x7a,
180 0x1e, 0x09, 0x84, 0x81,
181 0x20, 0x09, 0x82, 0x7c,
182 0x22, 0x09, 0x0a, 0x0a
183 };
184
185 static Byte_t RRegData[RREGDATASIZE] = {
186 0x00, 0x09, 0xf6, 0x82, /* 00: Stop Rx processor */
187 0x08, 0x09, 0x8a, 0x13, /* 04: Tx software flow control */
188 0x0a, 0x09, 0xc5, 0x11, /* 08: XON char */
189 0x0c, 0x09, 0x86, 0x85, /* 0c: XANY */
190 0x12, 0x09, 0x41, 0xff, /* 10: Rx mask char */
191 0x14, 0x09, 0x82, 0x00, /* 14: Compare/Ignore #0 */
192 0x16, 0x09, 0x82, 0x7b, /* 18: Compare #1 */
193 0x18, 0x09, 0x8a, 0x7d, /* 1c: Compare #2 */
194 0x1a, 0x09, 0x88, 0x81, /* 20: Interrupt #1 */
195 0x1c, 0x09, 0x86, 0x7a, /* 24: Ignore/Replace #1 */
196 0x1e, 0x09, 0x84, 0x81, /* 28: Interrupt #2 */
197 0x20, 0x09, 0x82, 0x7c, /* 2c: Ignore/Replace #2 */
198 0x22, 0x09, 0x0a, 0x0a /* 30: Rx FIFO Enable */
199 };
200
201 static CONTROLLER_T sController[CTL_SIZE] = {
202 {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
203 {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}},
204 {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
205 {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}},
206 {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
207 {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}},
208 {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
209 {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}}
210 };
211
212 static Byte_t sBitMapClrTbl[8] = {
213 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f
214 };
215
216 static Byte_t sBitMapSetTbl[8] = {
217 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
218 };
219
220 static int sClockPrescale = 0x14;
221
222 /*
223 * Line number is the ttySIx number (x), the Minor number. We
224 * assign them sequentially, starting at zero. The following
225 * array keeps track of the line number assigned to a given board/aiop/channel.
226 */
227 static unsigned char lineNumbers[MAX_RP_PORTS];
228 static unsigned long nextLineNumber;
229
230 /***** RocketPort Static Prototypes *********/
231 static int __init init_ISA(int i);
232 static void rp_wait_until_sent(struct tty_struct *tty, int timeout);
233 static void rp_flush_buffer(struct tty_struct *tty);
234 static void rmSpeakerReset(CONTROLLER_T * CtlP, unsigned long model);
235 static unsigned char GetLineNumber(int ctrl, int aiop, int ch);
236 static unsigned char SetLineNumber(int ctrl, int aiop, int ch);
237 static void rp_start(struct tty_struct *tty);
238 static int sInitChan(CONTROLLER_T * CtlP, CHANNEL_T * ChP, int AiopNum,
239 int ChanNum);
240 static void sSetInterfaceMode(CHANNEL_T * ChP, Byte_t mode);
241 static void sFlushRxFIFO(CHANNEL_T * ChP);
242 static void sFlushTxFIFO(CHANNEL_T * ChP);
243 static void sEnInterrupts(CHANNEL_T * ChP, Word_t Flags);
244 static void sDisInterrupts(CHANNEL_T * ChP, Word_t Flags);
245 static void sModemReset(CONTROLLER_T * CtlP, int chan, int on);
246 static void sPCIModemReset(CONTROLLER_T * CtlP, int chan, int on);
247 static int sWriteTxPrioByte(CHANNEL_T * ChP, Byte_t Data);
248 static int sPCIInitController(CONTROLLER_T * CtlP, int CtlNum,
249 ByteIO_t * AiopIOList, int AiopIOListSize,
250 WordIO_t ConfigIO, int IRQNum, Byte_t Frequency,
251 int PeriodicOnly, int altChanRingIndicator,
252 int UPCIRingInd);
253 static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
254 ByteIO_t * AiopIOList, int AiopIOListSize,
255 int IRQNum, Byte_t Frequency, int PeriodicOnly);
256 static int sReadAiopID(ByteIO_t io);
257 static int sReadAiopNumChan(WordIO_t io);
258
259 MODULE_AUTHOR("Theodore Ts'o");
260 MODULE_DESCRIPTION("Comtrol RocketPort driver");
261 module_param(board1, ulong, 0);
262 MODULE_PARM_DESC(board1, "I/O port for (ISA) board #1");
263 module_param(board2, ulong, 0);
264 MODULE_PARM_DESC(board2, "I/O port for (ISA) board #2");
265 module_param(board3, ulong, 0);
266 MODULE_PARM_DESC(board3, "I/O port for (ISA) board #3");
267 module_param(board4, ulong, 0);
268 MODULE_PARM_DESC(board4, "I/O port for (ISA) board #4");
269 module_param(controller, ulong, 0);
270 MODULE_PARM_DESC(controller, "I/O port for (ISA) rocketport controller");
271 module_param(support_low_speed, bool, 0);
272 MODULE_PARM_DESC(support_low_speed, "1 means support 50 baud, 0 means support 460400 baud");
273 module_param(modem1, ulong, 0);
274 MODULE_PARM_DESC(modem1, "1 means (ISA) board #1 is a RocketModem");
275 module_param(modem2, ulong, 0);
276 MODULE_PARM_DESC(modem2, "1 means (ISA) board #2 is a RocketModem");
277 module_param(modem3, ulong, 0);
278 MODULE_PARM_DESC(modem3, "1 means (ISA) board #3 is a RocketModem");
279 module_param(modem4, ulong, 0);
280 MODULE_PARM_DESC(modem4, "1 means (ISA) board #4 is a RocketModem");
281 module_param_array(pc104_1, ulong, NULL, 0);
282 MODULE_PARM_DESC(pc104_1, "set interface types for ISA(PC104) board #1 (e.g. pc104_1=232,232,485,485,...");
283 module_param_array(pc104_2, ulong, NULL, 0);
284 MODULE_PARM_DESC(pc104_2, "set interface types for ISA(PC104) board #2 (e.g. pc104_2=232,232,485,485,...");
285 module_param_array(pc104_3, ulong, NULL, 0);
286 MODULE_PARM_DESC(pc104_3, "set interface types for ISA(PC104) board #3 (e.g. pc104_3=232,232,485,485,...");
287 module_param_array(pc104_4, ulong, NULL, 0);
288 MODULE_PARM_DESC(pc104_4, "set interface types for ISA(PC104) board #4 (e.g. pc104_4=232,232,485,485,...");
289
290 static int rp_init(void);
291 static void rp_cleanup_module(void);
292
293 module_init(rp_init);
294 module_exit(rp_cleanup_module);
295
296
297 MODULE_LICENSE("Dual BSD/GPL");
298
299 /*************************************************************************/
300 /* Module code starts here */
301
302 static inline int rocket_paranoia_check(struct r_port *info,
303 const char *routine)
304 {
305 #ifdef ROCKET_PARANOIA_CHECK
306 if (!info)
307 return 1;
308 if (info->magic != RPORT_MAGIC) {
309 printk(KERN_INFO "Warning: bad magic number for rocketport struct in %s\n",
310 routine);
311 return 1;
312 }
313 #endif
314 return 0;
315 }
316
317
318 /* Serial port receive data function. Called (from timer poll) when an AIOPIC signals
319 * that receive data is present on a serial port. Pulls data from FIFO, moves it into the
320 * tty layer.
321 */
322 static void rp_do_receive(struct r_port *info,
323 struct tty_struct *tty,
324 CHANNEL_t * cp, unsigned int ChanStatus)
325 {
326 unsigned int CharNStat;
327 int ToRecv, wRecv, space = 0, count;
328 unsigned char *cbuf, *chead;
329 char *fbuf, *fhead;
330 struct tty_ldisc *ld;
331
332 ld = tty_ldisc_ref(tty);
333
334 ToRecv = sGetRxCnt(cp);
335 space = tty->receive_room;
336 if (space > 2 * TTY_FLIPBUF_SIZE)
337 space = 2 * TTY_FLIPBUF_SIZE;
338 count = 0;
339 #ifdef ROCKET_DEBUG_INTR
340 printk(KERN_INFO "rp_do_receive(%d, %d)...", ToRecv, space);
341 #endif
342
343 /*
344 * determine how many we can actually read in. If we can't
345 * read any in then we have a software overrun condition.
346 */
347 if (ToRecv > space)
348 ToRecv = space;
349
350 ToRecv = tty_prepare_flip_string_flags(tty, &chead, &fhead, ToRecv);
351 if (ToRecv <= 0)
352 goto done;
353
354 cbuf = chead;
355 fbuf = fhead;
356
357 /*
358 * if status indicates there are errored characters in the
359 * FIFO, then enter status mode (a word in FIFO holds
360 * character and status).
361 */
362 if (ChanStatus & (RXFOVERFL | RXBREAK | RXFRAME | RXPARITY)) {
363 if (!(ChanStatus & STATMODE)) {
364 #ifdef ROCKET_DEBUG_RECEIVE
365 printk(KERN_INFO "Entering STATMODE...");
366 #endif
367 ChanStatus |= STATMODE;
368 sEnRxStatusMode(cp);
369 }
370 }
371
372 /*
373 * if we previously entered status mode, then read down the
374 * FIFO one word at a time, pulling apart the character and
375 * the status. Update error counters depending on status
376 */
377 if (ChanStatus & STATMODE) {
378 #ifdef ROCKET_DEBUG_RECEIVE
379 printk(KERN_INFO "Ignore %x, read %x...", info->ignore_status_mask,
380 info->read_status_mask);
381 #endif
382 while (ToRecv) {
383 CharNStat = sInW(sGetTxRxDataIO(cp));
384 #ifdef ROCKET_DEBUG_RECEIVE
385 printk(KERN_INFO "%x...", CharNStat);
386 #endif
387 if (CharNStat & STMBREAKH)
388 CharNStat &= ~(STMFRAMEH | STMPARITYH);
389 if (CharNStat & info->ignore_status_mask) {
390 ToRecv--;
391 continue;
392 }
393 CharNStat &= info->read_status_mask;
394 if (CharNStat & STMBREAKH)
395 *fbuf++ = TTY_BREAK;
396 else if (CharNStat & STMPARITYH)
397 *fbuf++ = TTY_PARITY;
398 else if (CharNStat & STMFRAMEH)
399 *fbuf++ = TTY_FRAME;
400 else if (CharNStat & STMRCVROVRH)
401 *fbuf++ = TTY_OVERRUN;
402 else
403 *fbuf++ = TTY_NORMAL;
404 *cbuf++ = CharNStat & 0xff;
405 count++;
406 ToRecv--;
407 }
408
409 /*
410 * after we've emptied the FIFO in status mode, turn
411 * status mode back off
412 */
413 if (sGetRxCnt(cp) == 0) {
414 #ifdef ROCKET_DEBUG_RECEIVE
415 printk(KERN_INFO "Status mode off.\n");
416 #endif
417 sDisRxStatusMode(cp);
418 }
419 } else {
420 /*
421 * we aren't in status mode, so read down the FIFO two
422 * characters at time by doing repeated word IO
423 * transfer.
424 */
425 wRecv = ToRecv >> 1;
426 if (wRecv)
427 sInStrW(sGetTxRxDataIO(cp), (unsigned short *) cbuf, wRecv);
428 if (ToRecv & 1)
429 cbuf[ToRecv - 1] = sInB(sGetTxRxDataIO(cp));
430 memset(fbuf, TTY_NORMAL, ToRecv);
431 cbuf += ToRecv;
432 fbuf += ToRecv;
433 count += ToRecv;
434 }
435 /* Push the data up to the tty layer */
436 ld->receive_buf(tty, cbuf, fbuf, count);
437 done:
438 tty_ldisc_deref(ld);
439 }
440
441 /*
442 * Serial port transmit data function. Called from the timer polling loop as a
443 * result of a bit set in xmit_flags[], indicating data (from the tty layer) is ready
444 * to be sent out the serial port. Data is buffered in rp_table[line].xmit_buf, it is
445 * moved to the port's xmit FIFO. *info is critical data, protected by spinlocks.
446 */
447 static void rp_do_transmit(struct r_port *info)
448 {
449 int c;
450 CHANNEL_t *cp = &info->channel;
451 struct tty_struct *tty;
452 unsigned long flags;
453
454 #ifdef ROCKET_DEBUG_INTR
455 printk(KERN_INFO "rp_do_transmit ");
456 #endif
457 if (!info)
458 return;
459 if (!info->tty) {
460 printk(KERN_INFO "rp: WARNING rp_do_transmit called with info->tty==NULL\n");
461 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
462 return;
463 }
464
465 spin_lock_irqsave(&info->slock, flags);
466 tty = info->tty;
467 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
468
469 /* Loop sending data to FIFO until done or FIFO full */
470 while (1) {
471 if (tty->stopped || tty->hw_stopped)
472 break;
473 c = min(info->xmit_fifo_room, min(info->xmit_cnt, XMIT_BUF_SIZE - info->xmit_tail));
474 if (c <= 0 || info->xmit_fifo_room <= 0)
475 break;
476 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) (info->xmit_buf + info->xmit_tail), c / 2);
477 if (c & 1)
478 sOutB(sGetTxRxDataIO(cp), info->xmit_buf[info->xmit_tail + c - 1]);
479 info->xmit_tail += c;
480 info->xmit_tail &= XMIT_BUF_SIZE - 1;
481 info->xmit_cnt -= c;
482 info->xmit_fifo_room -= c;
483 #ifdef ROCKET_DEBUG_INTR
484 printk(KERN_INFO "tx %d chars...", c);
485 #endif
486 }
487
488 if (info->xmit_cnt == 0)
489 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
490
491 if (info->xmit_cnt < WAKEUP_CHARS) {
492 tty_wakeup(tty);
493 wake_up_interruptible(&tty->write_wait);
494 #ifdef ROCKETPORT_HAVE_POLL_WAIT
495 wake_up_interruptible(&tty->poll_wait);
496 #endif
497 }
498
499 spin_unlock_irqrestore(&info->slock, flags);
500
501 #ifdef ROCKET_DEBUG_INTR
502 printk(KERN_INFO "(%d,%d,%d,%d)...", info->xmit_cnt, info->xmit_head,
503 info->xmit_tail, info->xmit_fifo_room);
504 #endif
505 }
506
507 /*
508 * Called when a serial port signals it has read data in it's RX FIFO.
509 * It checks what interrupts are pending and services them, including
510 * receiving serial data.
511 */
512 static void rp_handle_port(struct r_port *info)
513 {
514 CHANNEL_t *cp;
515 struct tty_struct *tty;
516 unsigned int IntMask, ChanStatus;
517
518 if (!info)
519 return;
520
521 if ((info->flags & ROCKET_INITIALIZED) == 0) {
522 printk(KERN_INFO "rp: WARNING: rp_handle_port called with info->flags & NOT_INIT\n");
523 return;
524 }
525 if (!info->tty) {
526 printk(KERN_INFO "rp: WARNING: rp_handle_port called with info->tty==NULL\n");
527 return;
528 }
529 cp = &info->channel;
530 tty = info->tty;
531
532 IntMask = sGetChanIntID(cp) & info->intmask;
533 #ifdef ROCKET_DEBUG_INTR
534 printk(KERN_INFO "rp_interrupt %02x...", IntMask);
535 #endif
536 ChanStatus = sGetChanStatus(cp);
537 if (IntMask & RXF_TRIG) { /* Rx FIFO trigger level */
538 rp_do_receive(info, tty, cp, ChanStatus);
539 }
540 if (IntMask & DELTA_CD) { /* CD change */
541 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_INTR) || defined(ROCKET_DEBUG_HANGUP))
542 printk(KERN_INFO "ttyR%d CD now %s...", info->line,
543 (ChanStatus & CD_ACT) ? "on" : "off");
544 #endif
545 if (!(ChanStatus & CD_ACT) && info->cd_status) {
546 #ifdef ROCKET_DEBUG_HANGUP
547 printk(KERN_INFO "CD drop, calling hangup.\n");
548 #endif
549 tty_hangup(tty);
550 }
551 info->cd_status = (ChanStatus & CD_ACT) ? 1 : 0;
552 wake_up_interruptible(&info->open_wait);
553 }
554 #ifdef ROCKET_DEBUG_INTR
555 if (IntMask & DELTA_CTS) { /* CTS change */
556 printk(KERN_INFO "CTS change...\n");
557 }
558 if (IntMask & DELTA_DSR) { /* DSR change */
559 printk(KERN_INFO "DSR change...\n");
560 }
561 #endif
562 }
563
564 /*
565 * The top level polling routine. Repeats every 1/100 HZ (10ms).
566 */
567 static void rp_do_poll(unsigned long dummy)
568 {
569 CONTROLLER_t *ctlp;
570 int ctrl, aiop, ch, line, i;
571 unsigned int xmitmask;
572 unsigned int CtlMask;
573 unsigned char AiopMask;
574 Word_t bit;
575
576 /* Walk through all the boards (ctrl's) */
577 for (ctrl = 0; ctrl < max_board; ctrl++) {
578 if (rcktpt_io_addr[ctrl] <= 0)
579 continue;
580
581 /* Get a ptr to the board's control struct */
582 ctlp = sCtlNumToCtlPtr(ctrl);
583
584 /* Get the interupt status from the board */
585 #ifdef CONFIG_PCI
586 if (ctlp->BusType == isPCI)
587 CtlMask = sPCIGetControllerIntStatus(ctlp);
588 else
589 #endif
590 CtlMask = sGetControllerIntStatus(ctlp);
591
592 /* Check if any AIOP read bits are set */
593 for (aiop = 0; CtlMask; aiop++) {
594 bit = ctlp->AiopIntrBits[aiop];
595 if (CtlMask & bit) {
596 CtlMask &= ~bit;
597 AiopMask = sGetAiopIntStatus(ctlp, aiop);
598
599 /* Check if any port read bits are set */
600 for (ch = 0; AiopMask; AiopMask >>= 1, ch++) {
601 if (AiopMask & 1) {
602
603 /* Get the line number (/dev/ttyRx number). */
604 /* Read the data from the port. */
605 line = GetLineNumber(ctrl, aiop, ch);
606 rp_handle_port(rp_table[line]);
607 }
608 }
609 }
610 }
611
612 xmitmask = xmit_flags[ctrl];
613
614 /*
615 * xmit_flags contains bit-significant flags, indicating there is data
616 * to xmit on the port. Bit 0 is port 0 on this board, bit 1 is port
617 * 1, ... (32 total possible). The variable i has the aiop and ch
618 * numbers encoded in it (port 0-7 are aiop0, 8-15 are aiop1, etc).
619 */
620 if (xmitmask) {
621 for (i = 0; i < rocketModel[ctrl].numPorts; i++) {
622 if (xmitmask & (1 << i)) {
623 aiop = (i & 0x18) >> 3;
624 ch = i & 0x07;
625 line = GetLineNumber(ctrl, aiop, ch);
626 rp_do_transmit(rp_table[line]);
627 }
628 }
629 }
630 }
631
632 /*
633 * Reset the timer so we get called at the next clock tick (10ms).
634 */
635 if (atomic_read(&rp_num_ports_open))
636 mod_timer(&rocket_timer, jiffies + POLL_PERIOD);
637 }
638
639 /*
640 * Initializes the r_port structure for a port, as well as enabling the port on
641 * the board.
642 * Inputs: board, aiop, chan numbers
643 */
644 static void init_r_port(int board, int aiop, int chan, struct pci_dev *pci_dev)
645 {
646 unsigned rocketMode;
647 struct r_port *info;
648 int line;
649 CONTROLLER_T *ctlp;
650
651 /* Get the next available line number */
652 line = SetLineNumber(board, aiop, chan);
653
654 ctlp = sCtlNumToCtlPtr(board);
655
656 /* Get a r_port struct for the port, fill it in and save it globally, indexed by line number */
657 info = kmalloc(sizeof (struct r_port), GFP_KERNEL);
658 if (!info) {
659 printk(KERN_INFO "Couldn't allocate info struct for line #%d\n", line);
660 return;
661 }
662 memset(info, 0, sizeof (struct r_port));
663
664 info->magic = RPORT_MAGIC;
665 info->line = line;
666 info->ctlp = ctlp;
667 info->board = board;
668 info->aiop = aiop;
669 info->chan = chan;
670 info->closing_wait = 3000;
671 info->close_delay = 50;
672 init_waitqueue_head(&info->open_wait);
673 init_waitqueue_head(&info->close_wait);
674 info->flags &= ~ROCKET_MODE_MASK;
675 switch (pc104[board][line]) {
676 case 422:
677 info->flags |= ROCKET_MODE_RS422;
678 break;
679 case 485:
680 info->flags |= ROCKET_MODE_RS485;
681 break;
682 case 232:
683 default:
684 info->flags |= ROCKET_MODE_RS232;
685 break;
686 }
687
688 info->intmask = RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR;
689 if (sInitChan(ctlp, &info->channel, aiop, chan) == 0) {
690 printk(KERN_INFO "RocketPort sInitChan(%d, %d, %d) failed!\n", board, aiop, chan);
691 kfree(info);
692 return;
693 }
694
695 rocketMode = info->flags & ROCKET_MODE_MASK;
696
697 if ((info->flags & ROCKET_RTS_TOGGLE) || (rocketMode == ROCKET_MODE_RS485))
698 sEnRTSToggle(&info->channel);
699 else
700 sDisRTSToggle(&info->channel);
701
702 if (ctlp->boardType == ROCKET_TYPE_PC104) {
703 switch (rocketMode) {
704 case ROCKET_MODE_RS485:
705 sSetInterfaceMode(&info->channel, InterfaceModeRS485);
706 break;
707 case ROCKET_MODE_RS422:
708 sSetInterfaceMode(&info->channel, InterfaceModeRS422);
709 break;
710 case ROCKET_MODE_RS232:
711 default:
712 if (info->flags & ROCKET_RTS_TOGGLE)
713 sSetInterfaceMode(&info->channel, InterfaceModeRS232T);
714 else
715 sSetInterfaceMode(&info->channel, InterfaceModeRS232);
716 break;
717 }
718 }
719 spin_lock_init(&info->slock);
720 sema_init(&info->write_sem, 1);
721 rp_table[line] = info;
722 if (pci_dev)
723 tty_register_device(rocket_driver, line, &pci_dev->dev);
724 }
725
726 /*
727 * Configures a rocketport port according to its termio settings. Called from
728 * user mode into the driver (exception handler). *info CD manipulation is spinlock protected.
729 */
730 static void configure_r_port(struct r_port *info,
731 struct termios *old_termios)
732 {
733 unsigned cflag;
734 unsigned long flags;
735 unsigned rocketMode;
736 int bits, baud, divisor;
737 CHANNEL_t *cp;
738
739 if (!info->tty || !info->tty->termios)
740 return;
741 cp = &info->channel;
742 cflag = info->tty->termios->c_cflag;
743
744 /* Byte size and parity */
745 if ((cflag & CSIZE) == CS8) {
746 sSetData8(cp);
747 bits = 10;
748 } else {
749 sSetData7(cp);
750 bits = 9;
751 }
752 if (cflag & CSTOPB) {
753 sSetStop2(cp);
754 bits++;
755 } else {
756 sSetStop1(cp);
757 }
758
759 if (cflag & PARENB) {
760 sEnParity(cp);
761 bits++;
762 if (cflag & PARODD) {
763 sSetOddParity(cp);
764 } else {
765 sSetEvenParity(cp);
766 }
767 } else {
768 sDisParity(cp);
769 }
770
771 /* baud rate */
772 baud = tty_get_baud_rate(info->tty);
773 if (!baud)
774 baud = 9600;
775 divisor = ((rp_baud_base[info->board] + (baud >> 1)) / baud) - 1;
776 if ((divisor >= 8192 || divisor < 0) && old_termios) {
777 info->tty->termios->c_cflag &= ~CBAUD;
778 info->tty->termios->c_cflag |=
779 (old_termios->c_cflag & CBAUD);
780 baud = tty_get_baud_rate(info->tty);
781 if (!baud)
782 baud = 9600;
783 divisor = (rp_baud_base[info->board] / baud) - 1;
784 }
785 if (divisor >= 8192 || divisor < 0) {
786 baud = 9600;
787 divisor = (rp_baud_base[info->board] / baud) - 1;
788 }
789 info->cps = baud / bits;
790 sSetBaud(cp, divisor);
791
792 if (cflag & CRTSCTS) {
793 info->intmask |= DELTA_CTS;
794 sEnCTSFlowCtl(cp);
795 } else {
796 info->intmask &= ~DELTA_CTS;
797 sDisCTSFlowCtl(cp);
798 }
799 if (cflag & CLOCAL) {
800 info->intmask &= ~DELTA_CD;
801 } else {
802 spin_lock_irqsave(&info->slock, flags);
803 if (sGetChanStatus(cp) & CD_ACT)
804 info->cd_status = 1;
805 else
806 info->cd_status = 0;
807 info->intmask |= DELTA_CD;
808 spin_unlock_irqrestore(&info->slock, flags);
809 }
810
811 /*
812 * Handle software flow control in the board
813 */
814 #ifdef ROCKET_SOFT_FLOW
815 if (I_IXON(info->tty)) {
816 sEnTxSoftFlowCtl(cp);
817 if (I_IXANY(info->tty)) {
818 sEnIXANY(cp);
819 } else {
820 sDisIXANY(cp);
821 }
822 sSetTxXONChar(cp, START_CHAR(info->tty));
823 sSetTxXOFFChar(cp, STOP_CHAR(info->tty));
824 } else {
825 sDisTxSoftFlowCtl(cp);
826 sDisIXANY(cp);
827 sClrTxXOFF(cp);
828 }
829 #endif
830
831 /*
832 * Set up ignore/read mask words
833 */
834 info->read_status_mask = STMRCVROVRH | 0xFF;
835 if (I_INPCK(info->tty))
836 info->read_status_mask |= STMFRAMEH | STMPARITYH;
837 if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
838 info->read_status_mask |= STMBREAKH;
839
840 /*
841 * Characters to ignore
842 */
843 info->ignore_status_mask = 0;
844 if (I_IGNPAR(info->tty))
845 info->ignore_status_mask |= STMFRAMEH | STMPARITYH;
846 if (I_IGNBRK(info->tty)) {
847 info->ignore_status_mask |= STMBREAKH;
848 /*
849 * If we're ignoring parity and break indicators,
850 * ignore overruns too. (For real raw support).
851 */
852 if (I_IGNPAR(info->tty))
853 info->ignore_status_mask |= STMRCVROVRH;
854 }
855
856 rocketMode = info->flags & ROCKET_MODE_MASK;
857
858 if ((info->flags & ROCKET_RTS_TOGGLE)
859 || (rocketMode == ROCKET_MODE_RS485))
860 sEnRTSToggle(cp);
861 else
862 sDisRTSToggle(cp);
863
864 sSetRTS(&info->channel);
865
866 if (cp->CtlP->boardType == ROCKET_TYPE_PC104) {
867 switch (rocketMode) {
868 case ROCKET_MODE_RS485:
869 sSetInterfaceMode(cp, InterfaceModeRS485);
870 break;
871 case ROCKET_MODE_RS422:
872 sSetInterfaceMode(cp, InterfaceModeRS422);
873 break;
874 case ROCKET_MODE_RS232:
875 default:
876 if (info->flags & ROCKET_RTS_TOGGLE)
877 sSetInterfaceMode(cp, InterfaceModeRS232T);
878 else
879 sSetInterfaceMode(cp, InterfaceModeRS232);
880 break;
881 }
882 }
883 }
884
885 /* info->count is considered critical, protected by spinlocks. */
886 static int block_til_ready(struct tty_struct *tty, struct file *filp,
887 struct r_port *info)
888 {
889 DECLARE_WAITQUEUE(wait, current);
890 int retval;
891 int do_clocal = 0, extra_count = 0;
892 unsigned long flags;
893
894 /*
895 * If the device is in the middle of being closed, then block
896 * until it's done, and then try again.
897 */
898 if (tty_hung_up_p(filp))
899 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
900 if (info->flags & ROCKET_CLOSING) {
901 interruptible_sleep_on(&info->close_wait);
902 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
903 }
904
905 /*
906 * If non-blocking mode is set, or the port is not enabled,
907 * then make the check up front and then exit.
908 */
909 if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
910 info->flags |= ROCKET_NORMAL_ACTIVE;
911 return 0;
912 }
913 if (tty->termios->c_cflag & CLOCAL)
914 do_clocal = 1;
915
916 /*
917 * Block waiting for the carrier detect and the line to become free. While we are in
918 * this loop, info->count is dropped by one, so that rp_close() knows when to free things.
919 * We restore it upon exit, either normal or abnormal.
920 */
921 retval = 0;
922 add_wait_queue(&info->open_wait, &wait);
923 #ifdef ROCKET_DEBUG_OPEN
924 printk(KERN_INFO "block_til_ready before block: ttyR%d, count = %d\n", info->line, info->count);
925 #endif
926 spin_lock_irqsave(&info->slock, flags);
927
928 #ifdef ROCKET_DISABLE_SIMUSAGE
929 info->flags |= ROCKET_NORMAL_ACTIVE;
930 #else
931 if (!tty_hung_up_p(filp)) {
932 extra_count = 1;
933 info->count--;
934 }
935 #endif
936 info->blocked_open++;
937
938 spin_unlock_irqrestore(&info->slock, flags);
939
940 while (1) {
941 if (tty->termios->c_cflag & CBAUD) {
942 sSetDTR(&info->channel);
943 sSetRTS(&info->channel);
944 }
945 set_current_state(TASK_INTERRUPTIBLE);
946 if (tty_hung_up_p(filp) || !(info->flags & ROCKET_INITIALIZED)) {
947 if (info->flags & ROCKET_HUP_NOTIFY)
948 retval = -EAGAIN;
949 else
950 retval = -ERESTARTSYS;
951 break;
952 }
953 if (!(info->flags & ROCKET_CLOSING) && (do_clocal || (sGetChanStatusLo(&info->channel) & CD_ACT)))
954 break;
955 if (signal_pending(current)) {
956 retval = -ERESTARTSYS;
957 break;
958 }
959 #ifdef ROCKET_DEBUG_OPEN
960 printk(KERN_INFO "block_til_ready blocking: ttyR%d, count = %d, flags=0x%0x\n",
961 info->line, info->count, info->flags);
962 #endif
963 schedule(); /* Don't hold spinlock here, will hang PC */
964 }
965 current->state = TASK_RUNNING;
966 remove_wait_queue(&info->open_wait, &wait);
967
968 spin_lock_irqsave(&info->slock, flags);
969
970 if (extra_count)
971 info->count++;
972 info->blocked_open--;
973
974 spin_unlock_irqrestore(&info->slock, flags);
975
976 #ifdef ROCKET_DEBUG_OPEN
977 printk(KERN_INFO "block_til_ready after blocking: ttyR%d, count = %d\n",
978 info->line, info->count);
979 #endif
980 if (retval)
981 return retval;
982 info->flags |= ROCKET_NORMAL_ACTIVE;
983 return 0;
984 }
985
986 /*
987 * Exception handler that opens a serial port. Creates xmit_buf storage, fills in
988 * port's r_port struct. Initializes the port hardware.
989 */
990 static int rp_open(struct tty_struct *tty, struct file *filp)
991 {
992 struct r_port *info;
993 int line = 0, retval;
994 CHANNEL_t *cp;
995 unsigned long page;
996
997 line = TTY_GET_LINE(tty);
998 if ((line < 0) || (line >= MAX_RP_PORTS) || ((info = rp_table[line]) == NULL))
999 return -ENXIO;
1000
1001 page = __get_free_page(GFP_KERNEL);
1002 if (!page)
1003 return -ENOMEM;
1004
1005 if (info->flags & ROCKET_CLOSING) {
1006 interruptible_sleep_on(&info->close_wait);
1007 free_page(page);
1008 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
1009 }
1010
1011 /*
1012 * We must not sleep from here until the port is marked fully in use.
1013 */
1014 if (info->xmit_buf)
1015 free_page(page);
1016 else
1017 info->xmit_buf = (unsigned char *) page;
1018
1019 tty->driver_data = info;
1020 info->tty = tty;
1021
1022 if (info->count++ == 0) {
1023 atomic_inc(&rp_num_ports_open);
1024
1025 #ifdef ROCKET_DEBUG_OPEN
1026 printk(KERN_INFO "rocket mod++ = %d...", atomic_read(&rp_num_ports_open));
1027 #endif
1028 }
1029 #ifdef ROCKET_DEBUG_OPEN
1030 printk(KERN_INFO "rp_open ttyR%d, count=%d\n", info->line, info->count);
1031 #endif
1032
1033 /*
1034 * Info->count is now 1; so it's safe to sleep now.
1035 */
1036 info->session = current->signal->session;
1037 info->pgrp = process_group(current);
1038
1039 if ((info->flags & ROCKET_INITIALIZED) == 0) {
1040 cp = &info->channel;
1041 sSetRxTrigger(cp, TRIG_1);
1042 if (sGetChanStatus(cp) & CD_ACT)
1043 info->cd_status = 1;
1044 else
1045 info->cd_status = 0;
1046 sDisRxStatusMode(cp);
1047 sFlushRxFIFO(cp);
1048 sFlushTxFIFO(cp);
1049
1050 sEnInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1051 sSetRxTrigger(cp, TRIG_1);
1052
1053 sGetChanStatus(cp);
1054 sDisRxStatusMode(cp);
1055 sClrTxXOFF(cp);
1056
1057 sDisCTSFlowCtl(cp);
1058 sDisTxSoftFlowCtl(cp);
1059
1060 sEnRxFIFO(cp);
1061 sEnTransmit(cp);
1062
1063 info->flags |= ROCKET_INITIALIZED;
1064
1065 /*
1066 * Set up the tty->alt_speed kludge
1067 */
1068 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_HI)
1069 info->tty->alt_speed = 57600;
1070 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_VHI)
1071 info->tty->alt_speed = 115200;
1072 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_SHI)
1073 info->tty->alt_speed = 230400;
1074 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_WARP)
1075 info->tty->alt_speed = 460800;
1076
1077 configure_r_port(info, NULL);
1078 if (tty->termios->c_cflag & CBAUD) {
1079 sSetDTR(cp);
1080 sSetRTS(cp);
1081 }
1082 }
1083 /* Starts (or resets) the maint polling loop */
1084 mod_timer(&rocket_timer, jiffies + POLL_PERIOD);
1085
1086 retval = block_til_ready(tty, filp, info);
1087 if (retval) {
1088 #ifdef ROCKET_DEBUG_OPEN
1089 printk(KERN_INFO "rp_open returning after block_til_ready with %d\n", retval);
1090 #endif
1091 return retval;
1092 }
1093 return 0;
1094 }
1095
1096 /*
1097 * Exception handler that closes a serial port. info->count is considered critical.
1098 */
1099 static void rp_close(struct tty_struct *tty, struct file *filp)
1100 {
1101 struct r_port *info = (struct r_port *) tty->driver_data;
1102 unsigned long flags;
1103 int timeout;
1104 CHANNEL_t *cp;
1105
1106 if (rocket_paranoia_check(info, "rp_close"))
1107 return;
1108
1109 #ifdef ROCKET_DEBUG_OPEN
1110 printk(KERN_INFO "rp_close ttyR%d, count = %d\n", info->line, info->count);
1111 #endif
1112
1113 if (tty_hung_up_p(filp))
1114 return;
1115 spin_lock_irqsave(&info->slock, flags);
1116
1117 if ((tty->count == 1) && (info->count != 1)) {
1118 /*
1119 * Uh, oh. tty->count is 1, which means that the tty
1120 * structure will be freed. Info->count should always
1121 * be one in these conditions. If it's greater than
1122 * one, we've got real problems, since it means the
1123 * serial port won't be shutdown.
1124 */
1125 printk(KERN_INFO "rp_close: bad serial port count; tty->count is 1, "
1126 "info->count is %d\n", info->count);
1127 info->count = 1;
1128 }
1129 if (--info->count < 0) {
1130 printk(KERN_INFO "rp_close: bad serial port count for ttyR%d: %d\n",
1131 info->line, info->count);
1132 info->count = 0;
1133 }
1134 if (info->count) {
1135 spin_unlock_irqrestore(&info->slock, flags);
1136 return;
1137 }
1138 info->flags |= ROCKET_CLOSING;
1139 spin_unlock_irqrestore(&info->slock, flags);
1140
1141 cp = &info->channel;
1142
1143 /*
1144 * Notify the line discpline to only process XON/XOFF characters
1145 */
1146 tty->closing = 1;
1147
1148 /*
1149 * If transmission was throttled by the application request,
1150 * just flush the xmit buffer.
1151 */
1152 if (tty->flow_stopped)
1153 rp_flush_buffer(tty);
1154
1155 /*
1156 * Wait for the transmit buffer to clear
1157 */
1158 if (info->closing_wait != ROCKET_CLOSING_WAIT_NONE)
1159 tty_wait_until_sent(tty, info->closing_wait);
1160 /*
1161 * Before we drop DTR, make sure the UART transmitter
1162 * has completely drained; this is especially
1163 * important if there is a transmit FIFO!
1164 */
1165 timeout = (sGetTxCnt(cp) + 1) * HZ / info->cps;
1166 if (timeout == 0)
1167 timeout = 1;
1168 rp_wait_until_sent(tty, timeout);
1169 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1170
1171 sDisTransmit(cp);
1172 sDisInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1173 sDisCTSFlowCtl(cp);
1174 sDisTxSoftFlowCtl(cp);
1175 sClrTxXOFF(cp);
1176 sFlushRxFIFO(cp);
1177 sFlushTxFIFO(cp);
1178 sClrRTS(cp);
1179 if (C_HUPCL(tty))
1180 sClrDTR(cp);
1181
1182 if (TTY_DRIVER_FLUSH_BUFFER_EXISTS(tty))
1183 TTY_DRIVER_FLUSH_BUFFER(tty);
1184
1185 tty_ldisc_flush(tty);
1186
1187 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1188
1189 if (info->blocked_open) {
1190 if (info->close_delay) {
1191 msleep_interruptible(jiffies_to_msecs(info->close_delay));
1192 }
1193 wake_up_interruptible(&info->open_wait);
1194 } else {
1195 if (info->xmit_buf) {
1196 free_page((unsigned long) info->xmit_buf);
1197 info->xmit_buf = NULL;
1198 }
1199 }
1200 info->flags &= ~(ROCKET_INITIALIZED | ROCKET_CLOSING | ROCKET_NORMAL_ACTIVE);
1201 tty->closing = 0;
1202 wake_up_interruptible(&info->close_wait);
1203 atomic_dec(&rp_num_ports_open);
1204
1205 #ifdef ROCKET_DEBUG_OPEN
1206 printk(KERN_INFO "rocket mod-- = %d...", atomic_read(&rp_num_ports_open));
1207 printk(KERN_INFO "rp_close ttyR%d complete shutdown\n", info->line);
1208 #endif
1209
1210 }
1211
1212 static void rp_set_termios(struct tty_struct *tty,
1213 struct termios *old_termios)
1214 {
1215 struct r_port *info = (struct r_port *) tty->driver_data;
1216 CHANNEL_t *cp;
1217 unsigned cflag;
1218
1219 if (rocket_paranoia_check(info, "rp_set_termios"))
1220 return;
1221
1222 cflag = tty->termios->c_cflag;
1223
1224 if (cflag == old_termios->c_cflag)
1225 return;
1226
1227 /*
1228 * This driver doesn't support CS5 or CS6
1229 */
1230 if (((cflag & CSIZE) == CS5) || ((cflag & CSIZE) == CS6))
1231 tty->termios->c_cflag =
1232 ((cflag & ~CSIZE) | (old_termios->c_cflag & CSIZE));
1233
1234 configure_r_port(info, old_termios);
1235
1236 cp = &info->channel;
1237
1238 /* Handle transition to B0 status */
1239 if ((old_termios->c_cflag & CBAUD) && !(tty->termios->c_cflag & CBAUD)) {
1240 sClrDTR(cp);
1241 sClrRTS(cp);
1242 }
1243
1244 /* Handle transition away from B0 status */
1245 if (!(old_termios->c_cflag & CBAUD) && (tty->termios->c_cflag & CBAUD)) {
1246 if (!tty->hw_stopped || !(tty->termios->c_cflag & CRTSCTS))
1247 sSetRTS(cp);
1248 sSetDTR(cp);
1249 }
1250
1251 if ((old_termios->c_cflag & CRTSCTS) && !(tty->termios->c_cflag & CRTSCTS)) {
1252 tty->hw_stopped = 0;
1253 rp_start(tty);
1254 }
1255 }
1256
1257 static void rp_break(struct tty_struct *tty, int break_state)
1258 {
1259 struct r_port *info = (struct r_port *) tty->driver_data;
1260 unsigned long flags;
1261
1262 if (rocket_paranoia_check(info, "rp_break"))
1263 return;
1264
1265 spin_lock_irqsave(&info->slock, flags);
1266 if (break_state == -1)
1267 sSendBreak(&info->channel);
1268 else
1269 sClrBreak(&info->channel);
1270 spin_unlock_irqrestore(&info->slock, flags);
1271 }
1272
1273 /*
1274 * sGetChanRI used to be a macro in rocket_int.h. When the functionality for
1275 * the UPCI boards was added, it was decided to make this a function because
1276 * the macro was getting too complicated. All cases except the first one
1277 * (UPCIRingInd) are taken directly from the original macro.
1278 */
1279 static int sGetChanRI(CHANNEL_T * ChP)
1280 {
1281 CONTROLLER_t *CtlP = ChP->CtlP;
1282 int ChanNum = ChP->ChanNum;
1283 int RingInd = 0;
1284
1285 if (CtlP->UPCIRingInd)
1286 RingInd = !(sInB(CtlP->UPCIRingInd) & sBitMapSetTbl[ChanNum]);
1287 else if (CtlP->AltChanRingIndicator)
1288 RingInd = sInB((ByteIO_t) (ChP->ChanStat + 8)) & DSR_ACT;
1289 else if (CtlP->boardType == ROCKET_TYPE_PC104)
1290 RingInd = !(sInB(CtlP->AiopIO[3]) & sBitMapSetTbl[ChanNum]);
1291
1292 return RingInd;
1293 }
1294
1295 /********************************************************************************************/
1296 /* Here are the routines used by rp_ioctl. These are all called from exception handlers. */
1297
1298 /*
1299 * Returns the state of the serial modem control lines. These next 2 functions
1300 * are the way kernel versions > 2.5 handle modem control lines rather than IOCTLs.
1301 */
1302 static int rp_tiocmget(struct tty_struct *tty, struct file *file)
1303 {
1304 struct r_port *info = (struct r_port *)tty->driver_data;
1305 unsigned int control, result, ChanStatus;
1306
1307 ChanStatus = sGetChanStatusLo(&info->channel);
1308 control = info->channel.TxControl[3];
1309 result = ((control & SET_RTS) ? TIOCM_RTS : 0) |
1310 ((control & SET_DTR) ? TIOCM_DTR : 0) |
1311 ((ChanStatus & CD_ACT) ? TIOCM_CAR : 0) |
1312 (sGetChanRI(&info->channel) ? TIOCM_RNG : 0) |
1313 ((ChanStatus & DSR_ACT) ? TIOCM_DSR : 0) |
1314 ((ChanStatus & CTS_ACT) ? TIOCM_CTS : 0);
1315
1316 return result;
1317 }
1318
1319 /*
1320 * Sets the modem control lines
1321 */
1322 static int rp_tiocmset(struct tty_struct *tty, struct file *file,
1323 unsigned int set, unsigned int clear)
1324 {
1325 struct r_port *info = (struct r_port *)tty->driver_data;
1326
1327 if (set & TIOCM_RTS)
1328 info->channel.TxControl[3] |= SET_RTS;
1329 if (set & TIOCM_DTR)
1330 info->channel.TxControl[3] |= SET_DTR;
1331 if (clear & TIOCM_RTS)
1332 info->channel.TxControl[3] &= ~SET_RTS;
1333 if (clear & TIOCM_DTR)
1334 info->channel.TxControl[3] &= ~SET_DTR;
1335
1336 sOutDW(info->channel.IndexAddr, *(DWord_t *) & (info->channel.TxControl[0]));
1337 return 0;
1338 }
1339
1340 static int get_config(struct r_port *info, struct rocket_config __user *retinfo)
1341 {
1342 struct rocket_config tmp;
1343
1344 if (!retinfo)
1345 return -EFAULT;
1346 memset(&tmp, 0, sizeof (tmp));
1347 tmp.line = info->line;
1348 tmp.flags = info->flags;
1349 tmp.close_delay = info->close_delay;
1350 tmp.closing_wait = info->closing_wait;
1351 tmp.port = rcktpt_io_addr[(info->line >> 5) & 3];
1352
1353 if (copy_to_user(retinfo, &tmp, sizeof (*retinfo)))
1354 return -EFAULT;
1355 return 0;
1356 }
1357
1358 static int set_config(struct r_port *info, struct rocket_config __user *new_info)
1359 {
1360 struct rocket_config new_serial;
1361
1362 if (copy_from_user(&new_serial, new_info, sizeof (new_serial)))
1363 return -EFAULT;
1364
1365 if (!capable(CAP_SYS_ADMIN))
1366 {
1367 if ((new_serial.flags & ~ROCKET_USR_MASK) != (info->flags & ~ROCKET_USR_MASK))
1368 return -EPERM;
1369 info->flags = ((info->flags & ~ROCKET_USR_MASK) | (new_serial.flags & ROCKET_USR_MASK));
1370 configure_r_port(info, NULL);
1371 return 0;
1372 }
1373
1374 info->flags = ((info->flags & ~ROCKET_FLAGS) | (new_serial.flags & ROCKET_FLAGS));
1375 info->close_delay = new_serial.close_delay;
1376 info->closing_wait = new_serial.closing_wait;
1377
1378 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_HI)
1379 info->tty->alt_speed = 57600;
1380 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_VHI)
1381 info->tty->alt_speed = 115200;
1382 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_SHI)
1383 info->tty->alt_speed = 230400;
1384 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_WARP)
1385 info->tty->alt_speed = 460800;
1386
1387 configure_r_port(info, NULL);
1388 return 0;
1389 }
1390
1391 /*
1392 * This function fills in a rocket_ports struct with information
1393 * about what boards/ports are in the system. This info is passed
1394 * to user space. See setrocket.c where the info is used to create
1395 * the /dev/ttyRx ports.
1396 */
1397 static int get_ports(struct r_port *info, struct rocket_ports __user *retports)
1398 {
1399 struct rocket_ports tmp;
1400 int board;
1401
1402 if (!retports)
1403 return -EFAULT;
1404 memset(&tmp, 0, sizeof (tmp));
1405 tmp.tty_major = rocket_driver->major;
1406
1407 for (board = 0; board < 4; board++) {
1408 tmp.rocketModel[board].model = rocketModel[board].model;
1409 strcpy(tmp.rocketModel[board].modelString, rocketModel[board].modelString);
1410 tmp.rocketModel[board].numPorts = rocketModel[board].numPorts;
1411 tmp.rocketModel[board].loadrm2 = rocketModel[board].loadrm2;
1412 tmp.rocketModel[board].startingPortNumber = rocketModel[board].startingPortNumber;
1413 }
1414 if (copy_to_user(retports, &tmp, sizeof (*retports)))
1415 return -EFAULT;
1416 return 0;
1417 }
1418
1419 static int reset_rm2(struct r_port *info, void __user *arg)
1420 {
1421 int reset;
1422
1423 if (copy_from_user(&reset, arg, sizeof (int)))
1424 return -EFAULT;
1425 if (reset)
1426 reset = 1;
1427
1428 if (rcktpt_type[info->board] != ROCKET_TYPE_MODEMII &&
1429 rcktpt_type[info->board] != ROCKET_TYPE_MODEMIII)
1430 return -EINVAL;
1431
1432 if (info->ctlp->BusType == isISA)
1433 sModemReset(info->ctlp, info->chan, reset);
1434 else
1435 sPCIModemReset(info->ctlp, info->chan, reset);
1436
1437 return 0;
1438 }
1439
1440 static int get_version(struct r_port *info, struct rocket_version __user *retvers)
1441 {
1442 if (copy_to_user(retvers, &driver_version, sizeof (*retvers)))
1443 return -EFAULT;
1444 return 0;
1445 }
1446
1447 /* IOCTL call handler into the driver */
1448 static int rp_ioctl(struct tty_struct *tty, struct file *file,
1449 unsigned int cmd, unsigned long arg)
1450 {
1451 struct r_port *info = (struct r_port *) tty->driver_data;
1452 void __user *argp = (void __user *)arg;
1453
1454 if (cmd != RCKP_GET_PORTS && rocket_paranoia_check(info, "rp_ioctl"))
1455 return -ENXIO;
1456
1457 switch (cmd) {
1458 case RCKP_GET_STRUCT:
1459 if (copy_to_user(argp, info, sizeof (struct r_port)))
1460 return -EFAULT;
1461 return 0;
1462 case RCKP_GET_CONFIG:
1463 return get_config(info, argp);
1464 case RCKP_SET_CONFIG:
1465 return set_config(info, argp);
1466 case RCKP_GET_PORTS:
1467 return get_ports(info, argp);
1468 case RCKP_RESET_RM2:
1469 return reset_rm2(info, argp);
1470 case RCKP_GET_VERSION:
1471 return get_version(info, argp);
1472 default:
1473 return -ENOIOCTLCMD;
1474 }
1475 return 0;
1476 }
1477
1478 static void rp_send_xchar(struct tty_struct *tty, char ch)
1479 {
1480 struct r_port *info = (struct r_port *) tty->driver_data;
1481 CHANNEL_t *cp;
1482
1483 if (rocket_paranoia_check(info, "rp_send_xchar"))
1484 return;
1485
1486 cp = &info->channel;
1487 if (sGetTxCnt(cp))
1488 sWriteTxPrioByte(cp, ch);
1489 else
1490 sWriteTxByte(sGetTxRxDataIO(cp), ch);
1491 }
1492
1493 static void rp_throttle(struct tty_struct *tty)
1494 {
1495 struct r_port *info = (struct r_port *) tty->driver_data;
1496 CHANNEL_t *cp;
1497
1498 #ifdef ROCKET_DEBUG_THROTTLE
1499 printk(KERN_INFO "throttle %s: %d....\n", tty->name,
1500 tty->ldisc.chars_in_buffer(tty));
1501 #endif
1502
1503 if (rocket_paranoia_check(info, "rp_throttle"))
1504 return;
1505
1506 cp = &info->channel;
1507 if (I_IXOFF(tty))
1508 rp_send_xchar(tty, STOP_CHAR(tty));
1509
1510 sClrRTS(&info->channel);
1511 }
1512
1513 static void rp_unthrottle(struct tty_struct *tty)
1514 {
1515 struct r_port *info = (struct r_port *) tty->driver_data;
1516 CHANNEL_t *cp;
1517 #ifdef ROCKET_DEBUG_THROTTLE
1518 printk(KERN_INFO "unthrottle %s: %d....\n", tty->name,
1519 tty->ldisc.chars_in_buffer(tty));
1520 #endif
1521
1522 if (rocket_paranoia_check(info, "rp_throttle"))
1523 return;
1524
1525 cp = &info->channel;
1526 if (I_IXOFF(tty))
1527 rp_send_xchar(tty, START_CHAR(tty));
1528
1529 sSetRTS(&info->channel);
1530 }
1531
1532 /*
1533 * ------------------------------------------------------------
1534 * rp_stop() and rp_start()
1535 *
1536 * This routines are called before setting or resetting tty->stopped.
1537 * They enable or disable transmitter interrupts, as necessary.
1538 * ------------------------------------------------------------
1539 */
1540 static void rp_stop(struct tty_struct *tty)
1541 {
1542 struct r_port *info = (struct r_port *) tty->driver_data;
1543
1544 #ifdef ROCKET_DEBUG_FLOW
1545 printk(KERN_INFO "stop %s: %d %d....\n", tty->name,
1546 info->xmit_cnt, info->xmit_fifo_room);
1547 #endif
1548
1549 if (rocket_paranoia_check(info, "rp_stop"))
1550 return;
1551
1552 if (sGetTxCnt(&info->channel))
1553 sDisTransmit(&info->channel);
1554 }
1555
1556 static void rp_start(struct tty_struct *tty)
1557 {
1558 struct r_port *info = (struct r_port *) tty->driver_data;
1559
1560 #ifdef ROCKET_DEBUG_FLOW
1561 printk(KERN_INFO "start %s: %d %d....\n", tty->name,
1562 info->xmit_cnt, info->xmit_fifo_room);
1563 #endif
1564
1565 if (rocket_paranoia_check(info, "rp_stop"))
1566 return;
1567
1568 sEnTransmit(&info->channel);
1569 set_bit((info->aiop * 8) + info->chan,
1570 (void *) &xmit_flags[info->board]);
1571 }
1572
1573 /*
1574 * rp_wait_until_sent() --- wait until the transmitter is empty
1575 */
1576 static void rp_wait_until_sent(struct tty_struct *tty, int timeout)
1577 {
1578 struct r_port *info = (struct r_port *) tty->driver_data;
1579 CHANNEL_t *cp;
1580 unsigned long orig_jiffies;
1581 int check_time, exit_time;
1582 int txcnt;
1583
1584 if (rocket_paranoia_check(info, "rp_wait_until_sent"))
1585 return;
1586
1587 cp = &info->channel;
1588
1589 orig_jiffies = jiffies;
1590 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1591 printk(KERN_INFO "In RP_wait_until_sent(%d) (jiff=%lu)...", timeout,
1592 jiffies);
1593 printk(KERN_INFO "cps=%d...", info->cps);
1594 #endif
1595 while (1) {
1596 txcnt = sGetTxCnt(cp);
1597 if (!txcnt) {
1598 if (sGetChanStatusLo(cp) & TXSHRMT)
1599 break;
1600 check_time = (HZ / info->cps) / 5;
1601 } else {
1602 check_time = HZ * txcnt / info->cps;
1603 }
1604 if (timeout) {
1605 exit_time = orig_jiffies + timeout - jiffies;
1606 if (exit_time <= 0)
1607 break;
1608 if (exit_time < check_time)
1609 check_time = exit_time;
1610 }
1611 if (check_time == 0)
1612 check_time = 1;
1613 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1614 printk(KERN_INFO "txcnt = %d (jiff=%lu,check=%d)...", txcnt, jiffies, check_time);
1615 #endif
1616 msleep_interruptible(jiffies_to_msecs(check_time));
1617 if (signal_pending(current))
1618 break;
1619 }
1620 current->state = TASK_RUNNING;
1621 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1622 printk(KERN_INFO "txcnt = %d (jiff=%lu)...done\n", txcnt, jiffies);
1623 #endif
1624 }
1625
1626 /*
1627 * rp_hangup() --- called by tty_hangup() when a hangup is signaled.
1628 */
1629 static void rp_hangup(struct tty_struct *tty)
1630 {
1631 CHANNEL_t *cp;
1632 struct r_port *info = (struct r_port *) tty->driver_data;
1633
1634 if (rocket_paranoia_check(info, "rp_hangup"))
1635 return;
1636
1637 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_HANGUP))
1638 printk(KERN_INFO "rp_hangup of ttyR%d...", info->line);
1639 #endif
1640 rp_flush_buffer(tty);
1641 if (info->flags & ROCKET_CLOSING)
1642 return;
1643 if (info->count)
1644 atomic_dec(&rp_num_ports_open);
1645 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1646
1647 info->count = 0;
1648 info->flags &= ~ROCKET_NORMAL_ACTIVE;
1649 info->tty = NULL;
1650
1651 cp = &info->channel;
1652 sDisRxFIFO(cp);
1653 sDisTransmit(cp);
1654 sDisInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1655 sDisCTSFlowCtl(cp);
1656 sDisTxSoftFlowCtl(cp);
1657 sClrTxXOFF(cp);
1658 info->flags &= ~ROCKET_INITIALIZED;
1659
1660 wake_up_interruptible(&info->open_wait);
1661 }
1662
1663 /*
1664 * Exception handler - write char routine. The RocketPort driver uses a
1665 * double-buffering strategy, with the twist that if the in-memory CPU
1666 * buffer is empty, and there's space in the transmit FIFO, the
1667 * writing routines will write directly to transmit FIFO.
1668 * Write buffer and counters protected by spinlocks
1669 */
1670 static void rp_put_char(struct tty_struct *tty, unsigned char ch)
1671 {
1672 struct r_port *info = (struct r_port *) tty->driver_data;
1673 CHANNEL_t *cp;
1674 unsigned long flags;
1675
1676 if (rocket_paranoia_check(info, "rp_put_char"))
1677 return;
1678
1679 /* Grab the port write semaphore, locking out other processes that try to write to this port */
1680 down(&info->write_sem);
1681
1682 #ifdef ROCKET_DEBUG_WRITE
1683 printk(KERN_INFO "rp_put_char %c...", ch);
1684 #endif
1685
1686 spin_lock_irqsave(&info->slock, flags);
1687 cp = &info->channel;
1688
1689 if (!tty->stopped && !tty->hw_stopped && info->xmit_fifo_room == 0)
1690 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1691
1692 if (tty->stopped || tty->hw_stopped || info->xmit_fifo_room == 0 || info->xmit_cnt != 0) {
1693 info->xmit_buf[info->xmit_head++] = ch;
1694 info->xmit_head &= XMIT_BUF_SIZE - 1;
1695 info->xmit_cnt++;
1696 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1697 } else {
1698 sOutB(sGetTxRxDataIO(cp), ch);
1699 info->xmit_fifo_room--;
1700 }
1701 spin_unlock_irqrestore(&info->slock, flags);
1702 up(&info->write_sem);
1703 }
1704
1705 /*
1706 * Exception handler - write routine, called when user app writes to the device.
1707 * A per port write semaphore is used to protect from another process writing to
1708 * this port at the same time. This other process could be running on the other CPU
1709 * or get control of the CPU if the copy_from_user() blocks due to a page fault (swapped out).
1710 * Spinlocks protect the info xmit members.
1711 */
1712 static int rp_write(struct tty_struct *tty,
1713 const unsigned char *buf, int count)
1714 {
1715 struct r_port *info = (struct r_port *) tty->driver_data;
1716 CHANNEL_t *cp;
1717 const unsigned char *b;
1718 int c, retval = 0;
1719 unsigned long flags;
1720
1721 if (count <= 0 || rocket_paranoia_check(info, "rp_write"))
1722 return 0;
1723
1724 down_interruptible(&info->write_sem);
1725
1726 #ifdef ROCKET_DEBUG_WRITE
1727 printk(KERN_INFO "rp_write %d chars...", count);
1728 #endif
1729 cp = &info->channel;
1730
1731 if (!tty->stopped && !tty->hw_stopped && info->xmit_fifo_room < count)
1732 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1733
1734 /*
1735 * If the write queue for the port is empty, and there is FIFO space, stuff bytes
1736 * into FIFO. Use the write queue for temp storage.
1737 */
1738 if (!tty->stopped && !tty->hw_stopped && info->xmit_cnt == 0 && info->xmit_fifo_room > 0) {
1739 c = min(count, info->xmit_fifo_room);
1740 b = buf;
1741
1742 /* Push data into FIFO, 2 bytes at a time */
1743 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) b, c / 2);
1744
1745 /* If there is a byte remaining, write it */
1746 if (c & 1)
1747 sOutB(sGetTxRxDataIO(cp), b[c - 1]);
1748
1749 retval += c;
1750 buf += c;
1751 count -= c;
1752
1753 spin_lock_irqsave(&info->slock, flags);
1754 info->xmit_fifo_room -= c;
1755 spin_unlock_irqrestore(&info->slock, flags);
1756 }
1757
1758 /* If count is zero, we wrote it all and are done */
1759 if (!count)
1760 goto end;
1761
1762 /* Write remaining data into the port's xmit_buf */
1763 while (1) {
1764 if (info->tty == 0) /* Seemingly obligatory check... */
1765 goto end;
1766
1767 c = min(count, min(XMIT_BUF_SIZE - info->xmit_cnt - 1, XMIT_BUF_SIZE - info->xmit_head));
1768 if (c <= 0)
1769 break;
1770
1771 b = buf;
1772 memcpy(info->xmit_buf + info->xmit_head, b, c);
1773
1774 spin_lock_irqsave(&info->slock, flags);
1775 info->xmit_head =
1776 (info->xmit_head + c) & (XMIT_BUF_SIZE - 1);
1777 info->xmit_cnt += c;
1778 spin_unlock_irqrestore(&info->slock, flags);
1779
1780 buf += c;
1781 count -= c;
1782 retval += c;
1783 }
1784
1785 if ((retval > 0) && !tty->stopped && !tty->hw_stopped)
1786 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1787
1788 end:
1789 if (info->xmit_cnt < WAKEUP_CHARS) {
1790 tty_wakeup(tty);
1791 wake_up_interruptible(&tty->write_wait);
1792 #ifdef ROCKETPORT_HAVE_POLL_WAIT
1793 wake_up_interruptible(&tty->poll_wait);
1794 #endif
1795 }
1796 up(&info->write_sem);
1797 return retval;
1798 }
1799
1800 /*
1801 * Return the number of characters that can be sent. We estimate
1802 * only using the in-memory transmit buffer only, and ignore the
1803 * potential space in the transmit FIFO.
1804 */
1805 static int rp_write_room(struct tty_struct *tty)
1806 {
1807 struct r_port *info = (struct r_port *) tty->driver_data;
1808 int ret;
1809
1810 if (rocket_paranoia_check(info, "rp_write_room"))
1811 return 0;
1812
1813 ret = XMIT_BUF_SIZE - info->xmit_cnt - 1;
1814 if (ret < 0)
1815 ret = 0;
1816 #ifdef ROCKET_DEBUG_WRITE
1817 printk(KERN_INFO "rp_write_room returns %d...", ret);
1818 #endif
1819 return ret;
1820 }
1821
1822 /*
1823 * Return the number of characters in the buffer. Again, this only
1824 * counts those characters in the in-memory transmit buffer.
1825 */
1826 static int rp_chars_in_buffer(struct tty_struct *tty)
1827 {
1828 struct r_port *info = (struct r_port *) tty->driver_data;
1829 CHANNEL_t *cp;
1830
1831 if (rocket_paranoia_check(info, "rp_chars_in_buffer"))
1832 return 0;
1833
1834 cp = &info->channel;
1835
1836 #ifdef ROCKET_DEBUG_WRITE
1837 printk(KERN_INFO "rp_chars_in_buffer returns %d...", info->xmit_cnt);
1838 #endif
1839 return info->xmit_cnt;
1840 }
1841
1842 /*
1843 * Flushes the TX fifo for a port, deletes data in the xmit_buf stored in the
1844 * r_port struct for the port. Note that spinlock are used to protect info members,
1845 * do not call this function if the spinlock is already held.
1846 */
1847 static void rp_flush_buffer(struct tty_struct *tty)
1848 {
1849 struct r_port *info = (struct r_port *) tty->driver_data;
1850 CHANNEL_t *cp;
1851 unsigned long flags;
1852
1853 if (rocket_paranoia_check(info, "rp_flush_buffer"))
1854 return;
1855
1856 spin_lock_irqsave(&info->slock, flags);
1857 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1858 spin_unlock_irqrestore(&info->slock, flags);
1859
1860 wake_up_interruptible(&tty->write_wait);
1861 #ifdef ROCKETPORT_HAVE_POLL_WAIT
1862 wake_up_interruptible(&tty->poll_wait);
1863 #endif
1864 tty_wakeup(tty);
1865
1866 cp = &info->channel;
1867 sFlushTxFIFO(cp);
1868 }
1869
1870 #ifdef CONFIG_PCI
1871
1872 /*
1873 * Called when a PCI card is found. Retrieves and stores model information,
1874 * init's aiopic and serial port hardware.
1875 * Inputs: i is the board number (0-n)
1876 */
1877 static __init int register_PCI(int i, struct pci_dev *dev)
1878 {
1879 int num_aiops, aiop, max_num_aiops, num_chan, chan;
1880 unsigned int aiopio[MAX_AIOPS_PER_BOARD];
1881 char *str, *board_type;
1882 CONTROLLER_t *ctlp;
1883
1884 int fast_clock = 0;
1885 int altChanRingIndicator = 0;
1886 int ports_per_aiop = 8;
1887 int ret;
1888 unsigned int class_rev;
1889 WordIO_t ConfigIO = 0;
1890 ByteIO_t UPCIRingInd = 0;
1891
1892 if (!dev || pci_enable_device(dev))
1893 return 0;
1894
1895 rcktpt_io_addr[i] = pci_resource_start(dev, 0);
1896 ret = pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
1897
1898 if (ret) {
1899 printk(KERN_INFO " Error during register_PCI(), unable to read config dword \n");
1900 return 0;
1901 }
1902
1903 rcktpt_type[i] = ROCKET_TYPE_NORMAL;
1904 rocketModel[i].loadrm2 = 0;
1905 rocketModel[i].startingPortNumber = nextLineNumber;
1906
1907 /* Depending on the model, set up some config variables */
1908 switch (dev->device) {
1909 case PCI_DEVICE_ID_RP4QUAD:
1910 str = "Quadcable";
1911 max_num_aiops = 1;
1912 ports_per_aiop = 4;
1913 rocketModel[i].model = MODEL_RP4QUAD;
1914 strcpy(rocketModel[i].modelString, "RocketPort 4 port w/quad cable");
1915 rocketModel[i].numPorts = 4;
1916 break;
1917 case PCI_DEVICE_ID_RP8OCTA:
1918 str = "Octacable";
1919 max_num_aiops = 1;
1920 rocketModel[i].model = MODEL_RP8OCTA;
1921 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/octa cable");
1922 rocketModel[i].numPorts = 8;
1923 break;
1924 case PCI_DEVICE_ID_URP8OCTA:
1925 str = "Octacable";
1926 max_num_aiops = 1;
1927 rocketModel[i].model = MODEL_UPCI_RP8OCTA;
1928 strcpy(rocketModel[i].modelString, "RocketPort UPCI 8 port w/octa cable");
1929 rocketModel[i].numPorts = 8;
1930 break;
1931 case PCI_DEVICE_ID_RP8INTF:
1932 str = "8";
1933 max_num_aiops = 1;
1934 rocketModel[i].model = MODEL_RP8INTF;
1935 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/external I/F");
1936 rocketModel[i].numPorts = 8;
1937 break;
1938 case PCI_DEVICE_ID_URP8INTF:
1939 str = "8";
1940 max_num_aiops = 1;
1941 rocketModel[i].model = MODEL_UPCI_RP8INTF;
1942 strcpy(rocketModel[i].modelString, "RocketPort UPCI 8 port w/external I/F");
1943 rocketModel[i].numPorts = 8;
1944 break;
1945 case PCI_DEVICE_ID_RP8J:
1946 str = "8J";
1947 max_num_aiops = 1;
1948 rocketModel[i].model = MODEL_RP8J;
1949 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/RJ11 connectors");
1950 rocketModel[i].numPorts = 8;
1951 break;
1952 case PCI_DEVICE_ID_RP4J:
1953 str = "4J";
1954 max_num_aiops = 1;
1955 ports_per_aiop = 4;
1956 rocketModel[i].model = MODEL_RP4J;
1957 strcpy(rocketModel[i].modelString, "RocketPort 4 port w/RJ45 connectors");
1958 rocketModel[i].numPorts = 4;
1959 break;
1960 case PCI_DEVICE_ID_RP8SNI:
1961 str = "8 (DB78 Custom)";
1962 max_num_aiops = 1;
1963 rocketModel[i].model = MODEL_RP8SNI;
1964 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/ custom DB78");
1965 rocketModel[i].numPorts = 8;
1966 break;
1967 case PCI_DEVICE_ID_RP16SNI:
1968 str = "16 (DB78 Custom)";
1969 max_num_aiops = 2;
1970 rocketModel[i].model = MODEL_RP16SNI;
1971 strcpy(rocketModel[i].modelString, "RocketPort 16 port w/ custom DB78");
1972 rocketModel[i].numPorts = 16;
1973 break;
1974 case PCI_DEVICE_ID_RP16INTF:
1975 str = "16";
1976 max_num_aiops = 2;
1977 rocketModel[i].model = MODEL_RP16INTF;
1978 strcpy(rocketModel[i].modelString, "RocketPort 16 port w/external I/F");
1979 rocketModel[i].numPorts = 16;
1980 break;
1981 case PCI_DEVICE_ID_URP16INTF:
1982 str = "16";
1983 max_num_aiops = 2;
1984 rocketModel[i].model = MODEL_UPCI_RP16INTF;
1985 strcpy(rocketModel[i].modelString, "RocketPort UPCI 16 port w/external I/F");
1986 rocketModel[i].numPorts = 16;
1987 break;
1988 case PCI_DEVICE_ID_CRP16INTF:
1989 str = "16";
1990 max_num_aiops = 2;
1991 rocketModel[i].model = MODEL_CPCI_RP16INTF;
1992 strcpy(rocketModel[i].modelString, "RocketPort Compact PCI 16 port w/external I/F");
1993 rocketModel[i].numPorts = 16;
1994 break;
1995 case PCI_DEVICE_ID_RP32INTF:
1996 str = "32";
1997 max_num_aiops = 4;
1998 rocketModel[i].model = MODEL_RP32INTF;
1999 strcpy(rocketModel[i].modelString, "RocketPort 32 port w/external I/F");
2000 rocketModel[i].numPorts = 32;
2001 break;
2002 case PCI_DEVICE_ID_URP32INTF:
2003 str = "32";
2004 max_num_aiops = 4;
2005 rocketModel[i].model = MODEL_UPCI_RP32INTF;
2006 strcpy(rocketModel[i].modelString, "RocketPort UPCI 32 port w/external I/F");
2007 rocketModel[i].numPorts = 32;
2008 break;
2009 case PCI_DEVICE_ID_RPP4:
2010 str = "Plus Quadcable";
2011 max_num_aiops = 1;
2012 ports_per_aiop = 4;
2013 altChanRingIndicator++;
2014 fast_clock++;
2015 rocketModel[i].model = MODEL_RPP4;
2016 strcpy(rocketModel[i].modelString, "RocketPort Plus 4 port");
2017 rocketModel[i].numPorts = 4;
2018 break;
2019 case PCI_DEVICE_ID_RPP8:
2020 str = "Plus Octacable";
2021 max_num_aiops = 2;
2022 ports_per_aiop = 4;
2023 altChanRingIndicator++;
2024 fast_clock++;
2025 rocketModel[i].model = MODEL_RPP8;
2026 strcpy(rocketModel[i].modelString, "RocketPort Plus 8 port");
2027 rocketModel[i].numPorts = 8;
2028 break;
2029 case PCI_DEVICE_ID_RP2_232:
2030 str = "Plus 2 (RS-232)";
2031 max_num_aiops = 1;
2032 ports_per_aiop = 2;
2033 altChanRingIndicator++;
2034 fast_clock++;
2035 rocketModel[i].model = MODEL_RP2_232;
2036 strcpy(rocketModel[i].modelString, "RocketPort Plus 2 port RS232");
2037 rocketModel[i].numPorts = 2;
2038 break;
2039 case PCI_DEVICE_ID_RP2_422:
2040 str = "Plus 2 (RS-422)";
2041 max_num_aiops = 1;
2042 ports_per_aiop = 2;
2043 altChanRingIndicator++;
2044 fast_clock++;
2045 rocketModel[i].model = MODEL_RP2_422;
2046 strcpy(rocketModel[i].modelString, "RocketPort Plus 2 port RS422");
2047 rocketModel[i].numPorts = 2;
2048 break;
2049 case PCI_DEVICE_ID_RP6M:
2050
2051 max_num_aiops = 1;
2052 ports_per_aiop = 6;
2053 str = "6-port";
2054
2055 /* If class_rev is 1, the rocketmodem flash must be loaded. If it is 2 it is a "socketed" version. */
2056 if ((class_rev & 0xFF) == 1) {
2057 rcktpt_type[i] = ROCKET_TYPE_MODEMII;
2058 rocketModel[i].loadrm2 = 1;
2059 } else {
2060 rcktpt_type[i] = ROCKET_TYPE_MODEM;
2061 }
2062
2063 rocketModel[i].model = MODEL_RP6M;
2064 strcpy(rocketModel[i].modelString, "RocketModem 6 port");
2065 rocketModel[i].numPorts = 6;
2066 break;
2067 case PCI_DEVICE_ID_RP4M:
2068 max_num_aiops = 1;
2069 ports_per_aiop = 4;
2070 str = "4-port";
2071 if ((class_rev & 0xFF) == 1) {
2072 rcktpt_type[i] = ROCKET_TYPE_MODEMII;
2073 rocketModel[i].loadrm2 = 1;
2074 } else {
2075 rcktpt_type[i] = ROCKET_TYPE_MODEM;
2076 }
2077
2078 rocketModel[i].model = MODEL_RP4M;
2079 strcpy(rocketModel[i].modelString, "RocketModem 4 port");
2080 rocketModel[i].numPorts = 4;
2081 break;
2082 default:
2083 str = "(unknown/unsupported)";
2084 max_num_aiops = 0;
2085 break;
2086 }
2087
2088 /*
2089 * Check for UPCI boards.
2090 */
2091
2092 switch (dev->device) {
2093 case PCI_DEVICE_ID_URP32INTF:
2094 case PCI_DEVICE_ID_URP8INTF:
2095 case PCI_DEVICE_ID_URP16INTF:
2096 case PCI_DEVICE_ID_CRP16INTF:
2097 case PCI_DEVICE_ID_URP8OCTA:
2098 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2099 ConfigIO = pci_resource_start(dev, 1);
2100 if (dev->device == PCI_DEVICE_ID_URP8OCTA) {
2101 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2102
2103 /*
2104 * Check for octa or quad cable.
2105 */
2106 if (!
2107 (sInW(ConfigIO + _PCI_9030_GPIO_CTRL) &
2108 PCI_GPIO_CTRL_8PORT)) {
2109 str = "Quadcable";
2110 ports_per_aiop = 4;
2111 rocketModel[i].numPorts = 4;
2112 }
2113 }
2114 break;
2115 case PCI_DEVICE_ID_UPCI_RM3_8PORT:
2116 str = "8 ports";
2117 max_num_aiops = 1;
2118 rocketModel[i].model = MODEL_UPCI_RM3_8PORT;
2119 strcpy(rocketModel[i].modelString, "RocketModem III 8 port");
2120 rocketModel[i].numPorts = 8;
2121 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2122 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2123 ConfigIO = pci_resource_start(dev, 1);
2124 rcktpt_type[i] = ROCKET_TYPE_MODEMIII;
2125 break;
2126 case PCI_DEVICE_ID_UPCI_RM3_4PORT:
2127 str = "4 ports";
2128 max_num_aiops = 1;
2129 rocketModel[i].model = MODEL_UPCI_RM3_4PORT;
2130 strcpy(rocketModel[i].modelString, "RocketModem III 4 port");
2131 rocketModel[i].numPorts = 4;
2132 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2133 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2134 ConfigIO = pci_resource_start(dev, 1);
2135 rcktpt_type[i] = ROCKET_TYPE_MODEMIII;
2136 break;
2137 default:
2138 break;
2139 }
2140
2141 switch (rcktpt_type[i]) {
2142 case ROCKET_TYPE_MODEM:
2143 board_type = "RocketModem";
2144 break;
2145 case ROCKET_TYPE_MODEMII:
2146 board_type = "RocketModem II";
2147 break;
2148 case ROCKET_TYPE_MODEMIII:
2149 board_type = "RocketModem III";
2150 break;
2151 default:
2152 board_type = "RocketPort";
2153 break;
2154 }
2155
2156 if (fast_clock) {
2157 sClockPrescale = 0x12; /* mod 2 (divide by 3) */
2158 rp_baud_base[i] = 921600;
2159 } else {
2160 /*
2161 * If support_low_speed is set, use the slow clock
2162 * prescale, which supports 50 bps
2163 */
2164 if (support_low_speed) {
2165 /* mod 9 (divide by 10) prescale */
2166 sClockPrescale = 0x19;
2167 rp_baud_base[i] = 230400;
2168 } else {
2169 /* mod 4 (devide by 5) prescale */
2170 sClockPrescale = 0x14;
2171 rp_baud_base[i] = 460800;
2172 }
2173 }
2174
2175 for (aiop = 0; aiop < max_num_aiops; aiop++)
2176 aiopio[aiop] = rcktpt_io_addr[i] + (aiop * 0x40);
2177 ctlp = sCtlNumToCtlPtr(i);
2178 num_aiops = sPCIInitController(ctlp, i, aiopio, max_num_aiops, ConfigIO, 0, FREQ_DIS, 0, altChanRingIndicator, UPCIRingInd);
2179 for (aiop = 0; aiop < max_num_aiops; aiop++)
2180 ctlp->AiopNumChan[aiop] = ports_per_aiop;
2181
2182 printk("Comtrol PCI controller #%d ID 0x%x found in bus:slot:fn %s at address %04lx, "
2183 "%d AIOP(s) (%s)\n", i, dev->device, pci_name(dev),
2184 rcktpt_io_addr[i], num_aiops, rocketModel[i].modelString);
2185 printk(KERN_INFO "Installing %s, creating /dev/ttyR%d - %ld\n",
2186 rocketModel[i].modelString,
2187 rocketModel[i].startingPortNumber,
2188 rocketModel[i].startingPortNumber +
2189 rocketModel[i].numPorts - 1);
2190
2191 if (num_aiops <= 0) {
2192 rcktpt_io_addr[i] = 0;
2193 return (0);
2194 }
2195 is_PCI[i] = 1;
2196
2197 /* Reset the AIOPIC, init the serial ports */
2198 for (aiop = 0; aiop < num_aiops; aiop++) {
2199 sResetAiopByNum(ctlp, aiop);
2200 num_chan = ports_per_aiop;
2201 for (chan = 0; chan < num_chan; chan++)
2202 init_r_port(i, aiop, chan, dev);
2203 }
2204
2205 /* Rocket modems must be reset */
2206 if ((rcktpt_type[i] == ROCKET_TYPE_MODEM) ||
2207 (rcktpt_type[i] == ROCKET_TYPE_MODEMII) ||
2208 (rcktpt_type[i] == ROCKET_TYPE_MODEMIII)) {
2209 num_chan = ports_per_aiop;
2210 for (chan = 0; chan < num_chan; chan++)
2211 sPCIModemReset(ctlp, chan, 1);
2212 mdelay(500);
2213 for (chan = 0; chan < num_chan; chan++)
2214 sPCIModemReset(ctlp, chan, 0);
2215 mdelay(500);
2216 rmSpeakerReset(ctlp, rocketModel[i].model);
2217 }
2218 return (1);
2219 }
2220
2221 /*
2222 * Probes for PCI cards, inits them if found
2223 * Input: board_found = number of ISA boards already found, or the
2224 * starting board number
2225 * Returns: Number of PCI boards found
2226 */
2227 static int __init init_PCI(int boards_found)
2228 {
2229 struct pci_dev *dev = NULL;
2230 int count = 0;
2231
2232 /* Work through the PCI device list, pulling out ours */
2233 while ((dev = pci_find_device(PCI_VENDOR_ID_RP, PCI_ANY_ID, dev))) {
2234 if (register_PCI(count + boards_found, dev))
2235 count++;
2236 }
2237 return (count);
2238 }
2239
2240 #endif /* CONFIG_PCI */
2241
2242 /*
2243 * Probes for ISA cards
2244 * Input: i = the board number to look for
2245 * Returns: 1 if board found, 0 else
2246 */
2247 static int __init init_ISA(int i)
2248 {
2249 int num_aiops, num_chan = 0, total_num_chan = 0;
2250 int aiop, chan;
2251 unsigned int aiopio[MAX_AIOPS_PER_BOARD];
2252 CONTROLLER_t *ctlp;
2253 char *type_string;
2254
2255 /* If io_addr is zero, no board configured */
2256 if (rcktpt_io_addr[i] == 0)
2257 return (0);
2258
2259 /* Reserve the IO region */
2260 if (!request_region(rcktpt_io_addr[i], 64, "Comtrol RocketPort")) {
2261 printk(KERN_INFO "Unable to reserve IO region for configured ISA RocketPort at address 0x%lx, board not installed...\n", rcktpt_io_addr[i]);
2262 rcktpt_io_addr[i] = 0;
2263 return (0);
2264 }
2265
2266 ctlp = sCtlNumToCtlPtr(i);
2267
2268 ctlp->boardType = rcktpt_type[i];
2269
2270 switch (rcktpt_type[i]) {
2271 case ROCKET_TYPE_PC104:
2272 type_string = "(PC104)";
2273 break;
2274 case ROCKET_TYPE_MODEM:
2275 type_string = "(RocketModem)";
2276 break;
2277 case ROCKET_TYPE_MODEMII:
2278 type_string = "(RocketModem II)";
2279 break;
2280 default:
2281 type_string = "";
2282 break;
2283 }
2284
2285 /*
2286 * If support_low_speed is set, use the slow clock prescale,
2287 * which supports 50 bps
2288 */
2289 if (support_low_speed) {
2290 sClockPrescale = 0x19; /* mod 9 (divide by 10) prescale */
2291 rp_baud_base[i] = 230400;
2292 } else {
2293 sClockPrescale = 0x14; /* mod 4 (devide by 5) prescale */
2294 rp_baud_base[i] = 460800;
2295 }
2296
2297 for (aiop = 0; aiop < MAX_AIOPS_PER_BOARD; aiop++)
2298 aiopio[aiop] = rcktpt_io_addr[i] + (aiop * 0x400);
2299
2300 num_aiops = sInitController(ctlp, i, controller + (i * 0x400), aiopio, MAX_AIOPS_PER_BOARD, 0, FREQ_DIS, 0);
2301
2302 if (ctlp->boardType == ROCKET_TYPE_PC104) {
2303 sEnAiop(ctlp, 2); /* only one AIOPIC, but these */
2304 sEnAiop(ctlp, 3); /* CSels used for other stuff */
2305 }
2306
2307 /* If something went wrong initing the AIOP's release the ISA IO memory */
2308 if (num_aiops <= 0) {
2309 release_region(rcktpt_io_addr[i], 64);
2310 rcktpt_io_addr[i] = 0;
2311 return (0);
2312 }
2313
2314 rocketModel[i].startingPortNumber = nextLineNumber;
2315
2316 for (aiop = 0; aiop < num_aiops; aiop++) {
2317 sResetAiopByNum(ctlp, aiop);
2318 sEnAiop(ctlp, aiop);
2319 num_chan = sGetAiopNumChan(ctlp, aiop);
2320 total_num_chan += num_chan;
2321 for (chan = 0; chan < num_chan; chan++)
2322 init_r_port(i, aiop, chan, NULL);
2323 }
2324 is_PCI[i] = 0;
2325 if ((rcktpt_type[i] == ROCKET_TYPE_MODEM) || (rcktpt_type[i] == ROCKET_TYPE_MODEMII)) {
2326 num_chan = sGetAiopNumChan(ctlp, 0);
2327 total_num_chan = num_chan;
2328 for (chan = 0; chan < num_chan; chan++)
2329 sModemReset(ctlp, chan, 1);
2330 mdelay(500);
2331 for (chan = 0; chan < num_chan; chan++)
2332 sModemReset(ctlp, chan, 0);
2333 mdelay(500);
2334 strcpy(rocketModel[i].modelString, "RocketModem ISA");
2335 } else {
2336 strcpy(rocketModel[i].modelString, "RocketPort ISA");
2337 }
2338 rocketModel[i].numPorts = total_num_chan;
2339 rocketModel[i].model = MODEL_ISA;
2340
2341 printk(KERN_INFO "RocketPort ISA card #%d found at 0x%lx - %d AIOPs %s\n",
2342 i, rcktpt_io_addr[i], num_aiops, type_string);
2343
2344 printk(KERN_INFO "Installing %s, creating /dev/ttyR%d - %ld\n",
2345 rocketModel[i].modelString,
2346 rocketModel[i].startingPortNumber,
2347 rocketModel[i].startingPortNumber +
2348 rocketModel[i].numPorts - 1);
2349
2350 return (1);
2351 }
2352
2353 static struct tty_operations rocket_ops = {
2354 .open = rp_open,
2355 .close = rp_close,
2356 .write = rp_write,
2357 .put_char = rp_put_char,
2358 .write_room = rp_write_room,
2359 .chars_in_buffer = rp_chars_in_buffer,
2360 .flush_buffer = rp_flush_buffer,
2361 .ioctl = rp_ioctl,
2362 .throttle = rp_throttle,
2363 .unthrottle = rp_unthrottle,
2364 .set_termios = rp_set_termios,
2365 .stop = rp_stop,
2366 .start = rp_start,
2367 .hangup = rp_hangup,
2368 .break_ctl = rp_break,
2369 .send_xchar = rp_send_xchar,
2370 .wait_until_sent = rp_wait_until_sent,
2371 .tiocmget = rp_tiocmget,
2372 .tiocmset = rp_tiocmset,
2373 };
2374
2375 /*
2376 * The module "startup" routine; it's run when the module is loaded.
2377 */
2378 static int __init rp_init(void)
2379 {
2380 int retval, pci_boards_found, isa_boards_found, i;
2381
2382 printk(KERN_INFO "RocketPort device driver module, version %s, %s\n",
2383 ROCKET_VERSION, ROCKET_DATE);
2384
2385 rocket_driver = alloc_tty_driver(MAX_RP_PORTS);
2386 if (!rocket_driver)
2387 return -ENOMEM;
2388
2389 /*
2390 * Set up the timer channel.
2391 */
2392 init_timer(&rocket_timer);
2393 rocket_timer.function = rp_do_poll;
2394
2395 /*
2396 * Initialize the array of pointers to our own internal state
2397 * structures.
2398 */
2399 memset(rp_table, 0, sizeof (rp_table));
2400 memset(xmit_flags, 0, sizeof (xmit_flags));
2401
2402 for (i = 0; i < MAX_RP_PORTS; i++)
2403 lineNumbers[i] = 0;
2404 nextLineNumber = 0;
2405 memset(rocketModel, 0, sizeof (rocketModel));
2406
2407 /*
2408 * If board 1 is non-zero, there is at least one ISA configured. If controller is
2409 * zero, use the default controller IO address of board1 + 0x40.
2410 */
2411 if (board1) {
2412 if (controller == 0)
2413 controller = board1 + 0x40;
2414 } else {
2415 controller = 0; /* Used as a flag, meaning no ISA boards */
2416 }
2417
2418 /* If an ISA card is configured, reserve the 4 byte IO space for the Mudbac controller */
2419 if (controller && (!request_region(controller, 4, "Comtrol RocketPort"))) {
2420 printk(KERN_INFO "Unable to reserve IO region for first configured ISA RocketPort controller 0x%lx. Driver exiting \n", controller);
2421 return -EBUSY;
2422 }
2423
2424 /* Store ISA variable retrieved from command line or .conf file. */
2425 rcktpt_io_addr[0] = board1;
2426 rcktpt_io_addr[1] = board2;
2427 rcktpt_io_addr[2] = board3;
2428 rcktpt_io_addr[3] = board4;
2429
2430 rcktpt_type[0] = modem1 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2431 rcktpt_type[0] = pc104_1[0] ? ROCKET_TYPE_PC104 : rcktpt_type[0];
2432 rcktpt_type[1] = modem2 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2433 rcktpt_type[1] = pc104_2[0] ? ROCKET_TYPE_PC104 : rcktpt_type[1];
2434 rcktpt_type[2] = modem3 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2435 rcktpt_type[2] = pc104_3[0] ? ROCKET_TYPE_PC104 : rcktpt_type[2];
2436 rcktpt_type[3] = modem4 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2437 rcktpt_type[3] = pc104_4[0] ? ROCKET_TYPE_PC104 : rcktpt_type[3];
2438
2439 /*
2440 * Set up the tty driver structure and then register this
2441 * driver with the tty layer.
2442 */
2443
2444 rocket_driver->owner = THIS_MODULE;
2445 rocket_driver->flags = TTY_DRIVER_NO_DEVFS;
2446 rocket_driver->devfs_name = "tts/R";
2447 rocket_driver->name = "ttyR";
2448 rocket_driver->driver_name = "Comtrol RocketPort";
2449 rocket_driver->major = TTY_ROCKET_MAJOR;
2450 rocket_driver->minor_start = 0;
2451 rocket_driver->type = TTY_DRIVER_TYPE_SERIAL;
2452 rocket_driver->subtype = SERIAL_TYPE_NORMAL;
2453 rocket_driver->init_termios = tty_std_termios;
2454 rocket_driver->init_termios.c_cflag =
2455 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2456 #ifdef ROCKET_SOFT_FLOW
2457 rocket_driver->flags |= TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
2458 #endif
2459 tty_set_operations(rocket_driver, &rocket_ops);
2460
2461 retval = tty_register_driver(rocket_driver);
2462 if (retval < 0) {
2463 printk(KERN_INFO "Couldn't install tty RocketPort driver (error %d)\n", -retval);
2464 put_tty_driver(rocket_driver);
2465 return -1;
2466 }
2467
2468 #ifdef ROCKET_DEBUG_OPEN
2469 printk(KERN_INFO "RocketPort driver is major %d\n", rocket_driver.major);
2470 #endif
2471
2472 /*
2473 * OK, let's probe each of the controllers looking for boards. Any boards found
2474 * will be initialized here.
2475 */
2476 isa_boards_found = 0;
2477 pci_boards_found = 0;
2478
2479 for (i = 0; i < NUM_BOARDS; i++) {
2480 if (init_ISA(i))
2481 isa_boards_found++;
2482 }
2483
2484 #ifdef CONFIG_PCI
2485 if (isa_boards_found < NUM_BOARDS)
2486 pci_boards_found = init_PCI(isa_boards_found);
2487 #endif
2488
2489 max_board = pci_boards_found + isa_boards_found;
2490
2491 if (max_board == 0) {
2492 printk(KERN_INFO "No rocketport ports found; unloading driver.\n");
2493 del_timer_sync(&rocket_timer);
2494 tty_unregister_driver(rocket_driver);
2495 put_tty_driver(rocket_driver);
2496 return -ENXIO;
2497 }
2498
2499 return 0;
2500 }
2501
2502
2503 static void rp_cleanup_module(void)
2504 {
2505 int retval;
2506 int i;
2507
2508 del_timer_sync(&rocket_timer);
2509
2510 retval = tty_unregister_driver(rocket_driver);
2511 if (retval)
2512 printk(KERN_INFO "Error %d while trying to unregister "
2513 "rocketport driver\n", -retval);
2514 put_tty_driver(rocket_driver);
2515
2516 for (i = 0; i < MAX_RP_PORTS; i++)
2517 kfree(rp_table[i]);
2518
2519 for (i = 0; i < NUM_BOARDS; i++) {
2520 if (rcktpt_io_addr[i] <= 0 || is_PCI[i])
2521 continue;
2522 release_region(rcktpt_io_addr[i], 64);
2523 }
2524 if (controller)
2525 release_region(controller, 4);
2526 }
2527
2528 /***************************************************************************
2529 Function: sInitController
2530 Purpose: Initialization of controller global registers and controller
2531 structure.
2532 Call: sInitController(CtlP,CtlNum,MudbacIO,AiopIOList,AiopIOListSize,
2533 IRQNum,Frequency,PeriodicOnly)
2534 CONTROLLER_T *CtlP; Ptr to controller structure
2535 int CtlNum; Controller number
2536 ByteIO_t MudbacIO; Mudbac base I/O address.
2537 ByteIO_t *AiopIOList; List of I/O addresses for each AIOP.
2538 This list must be in the order the AIOPs will be found on the
2539 controller. Once an AIOP in the list is not found, it is
2540 assumed that there are no more AIOPs on the controller.
2541 int AiopIOListSize; Number of addresses in AiopIOList
2542 int IRQNum; Interrupt Request number. Can be any of the following:
2543 0: Disable global interrupts
2544 3: IRQ 3
2545 4: IRQ 4
2546 5: IRQ 5
2547 9: IRQ 9
2548 10: IRQ 10
2549 11: IRQ 11
2550 12: IRQ 12
2551 15: IRQ 15
2552 Byte_t Frequency: A flag identifying the frequency
2553 of the periodic interrupt, can be any one of the following:
2554 FREQ_DIS - periodic interrupt disabled
2555 FREQ_137HZ - 137 Hertz
2556 FREQ_69HZ - 69 Hertz
2557 FREQ_34HZ - 34 Hertz
2558 FREQ_17HZ - 17 Hertz
2559 FREQ_9HZ - 9 Hertz
2560 FREQ_4HZ - 4 Hertz
2561 If IRQNum is set to 0 the Frequency parameter is
2562 overidden, it is forced to a value of FREQ_DIS.
2563 int PeriodicOnly: 1 if all interrupts except the periodic
2564 interrupt are to be blocked.
2565 0 is both the periodic interrupt and
2566 other channel interrupts are allowed.
2567 If IRQNum is set to 0 the PeriodicOnly parameter is
2568 overidden, it is forced to a value of 0.
2569 Return: int: Number of AIOPs on the controller, or CTLID_NULL if controller
2570 initialization failed.
2571
2572 Comments:
2573 If periodic interrupts are to be disabled but AIOP interrupts
2574 are allowed, set Frequency to FREQ_DIS and PeriodicOnly to 0.
2575
2576 If interrupts are to be completely disabled set IRQNum to 0.
2577
2578 Setting Frequency to FREQ_DIS and PeriodicOnly to 1 is an
2579 invalid combination.
2580
2581 This function performs initialization of global interrupt modes,
2582 but it does not actually enable global interrupts. To enable
2583 and disable global interrupts use functions sEnGlobalInt() and
2584 sDisGlobalInt(). Enabling of global interrupts is normally not
2585 done until all other initializations are complete.
2586
2587 Even if interrupts are globally enabled, they must also be
2588 individually enabled for each channel that is to generate
2589 interrupts.
2590
2591 Warnings: No range checking on any of the parameters is done.
2592
2593 No context switches are allowed while executing this function.
2594
2595 After this function all AIOPs on the controller are disabled,
2596 they can be enabled with sEnAiop().
2597 */
2598 static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
2599 ByteIO_t * AiopIOList, int AiopIOListSize,
2600 int IRQNum, Byte_t Frequency, int PeriodicOnly)
2601 {
2602 int i;
2603 ByteIO_t io;
2604 int done;
2605
2606 CtlP->AiopIntrBits = aiop_intr_bits;
2607 CtlP->AltChanRingIndicator = 0;
2608 CtlP->CtlNum = CtlNum;
2609 CtlP->CtlID = CTLID_0001; /* controller release 1 */
2610 CtlP->BusType = isISA;
2611 CtlP->MBaseIO = MudbacIO;
2612 CtlP->MReg1IO = MudbacIO + 1;
2613 CtlP->MReg2IO = MudbacIO + 2;
2614 CtlP->MReg3IO = MudbacIO + 3;
2615 #if 1
2616 CtlP->MReg2 = 0; /* interrupt disable */
2617 CtlP->MReg3 = 0; /* no periodic interrupts */
2618 #else
2619 if (sIRQMap[IRQNum] == 0) { /* interrupts globally disabled */
2620 CtlP->MReg2 = 0; /* interrupt disable */
2621 CtlP->MReg3 = 0; /* no periodic interrupts */
2622 } else {
2623 CtlP->MReg2 = sIRQMap[IRQNum]; /* set IRQ number */
2624 CtlP->MReg3 = Frequency; /* set frequency */
2625 if (PeriodicOnly) { /* periodic interrupt only */
2626 CtlP->MReg3 |= PERIODIC_ONLY;
2627 }
2628 }
2629 #endif
2630 sOutB(CtlP->MReg2IO, CtlP->MReg2);
2631 sOutB(CtlP->MReg3IO, CtlP->MReg3);
2632 sControllerEOI(CtlP); /* clear EOI if warm init */
2633 /* Init AIOPs */
2634 CtlP->NumAiop = 0;
2635 for (i = done = 0; i < AiopIOListSize; i++) {
2636 io = AiopIOList[i];
2637 CtlP->AiopIO[i] = (WordIO_t) io;
2638 CtlP->AiopIntChanIO[i] = io + _INT_CHAN;
2639 sOutB(CtlP->MReg2IO, CtlP->MReg2 | (i & 0x03)); /* AIOP index */
2640 sOutB(MudbacIO, (Byte_t) (io >> 6)); /* set up AIOP I/O in MUDBAC */
2641 if (done)
2642 continue;
2643 sEnAiop(CtlP, i); /* enable the AIOP */
2644 CtlP->AiopID[i] = sReadAiopID(io); /* read AIOP ID */
2645 if (CtlP->AiopID[i] == AIOPID_NULL) /* if AIOP does not exist */
2646 done = 1; /* done looking for AIOPs */
2647 else {
2648 CtlP->AiopNumChan[i] = sReadAiopNumChan((WordIO_t) io); /* num channels in AIOP */
2649 sOutW((WordIO_t) io + _INDX_ADDR, _CLK_PRE); /* clock prescaler */
2650 sOutB(io + _INDX_DATA, sClockPrescale);
2651 CtlP->NumAiop++; /* bump count of AIOPs */
2652 }
2653 sDisAiop(CtlP, i); /* disable AIOP */
2654 }
2655
2656 if (CtlP->NumAiop == 0)
2657 return (-1);
2658 else
2659 return (CtlP->NumAiop);
2660 }
2661
2662 /***************************************************************************
2663 Function: sPCIInitController
2664 Purpose: Initialization of controller global registers and controller
2665 structure.
2666 Call: sPCIInitController(CtlP,CtlNum,AiopIOList,AiopIOListSize,
2667 IRQNum,Frequency,PeriodicOnly)
2668 CONTROLLER_T *CtlP; Ptr to controller structure
2669 int CtlNum; Controller number
2670 ByteIO_t *AiopIOList; List of I/O addresses for each AIOP.
2671 This list must be in the order the AIOPs will be found on the
2672 controller. Once an AIOP in the list is not found, it is
2673 assumed that there are no more AIOPs on the controller.
2674 int AiopIOListSize; Number of addresses in AiopIOList
2675 int IRQNum; Interrupt Request number. Can be any of the following:
2676 0: Disable global interrupts
2677 3: IRQ 3
2678 4: IRQ 4
2679 5: IRQ 5
2680 9: IRQ 9
2681 10: IRQ 10
2682 11: IRQ 11
2683 12: IRQ 12
2684 15: IRQ 15
2685 Byte_t Frequency: A flag identifying the frequency
2686 of the periodic interrupt, can be any one of the following:
2687 FREQ_DIS - periodic interrupt disabled
2688 FREQ_137HZ - 137 Hertz
2689 FREQ_69HZ - 69 Hertz
2690 FREQ_34HZ - 34 Hertz
2691 FREQ_17HZ - 17 Hertz
2692 FREQ_9HZ - 9 Hertz
2693 FREQ_4HZ - 4 Hertz
2694 If IRQNum is set to 0 the Frequency parameter is
2695 overidden, it is forced to a value of FREQ_DIS.
2696 int PeriodicOnly: 1 if all interrupts except the periodic
2697 interrupt are to be blocked.
2698 0 is both the periodic interrupt and
2699 other channel interrupts are allowed.
2700 If IRQNum is set to 0 the PeriodicOnly parameter is
2701 overidden, it is forced to a value of 0.
2702 Return: int: Number of AIOPs on the controller, or CTLID_NULL if controller
2703 initialization failed.
2704
2705 Comments:
2706 If periodic interrupts are to be disabled but AIOP interrupts
2707 are allowed, set Frequency to FREQ_DIS and PeriodicOnly to 0.
2708
2709 If interrupts are to be completely disabled set IRQNum to 0.
2710
2711 Setting Frequency to FREQ_DIS and PeriodicOnly to 1 is an
2712 invalid combination.
2713
2714 This function performs initialization of global interrupt modes,
2715 but it does not actually enable global interrupts. To enable
2716 and disable global interrupts use functions sEnGlobalInt() and
2717 sDisGlobalInt(). Enabling of global interrupts is normally not
2718 done until all other initializations are complete.
2719
2720 Even if interrupts are globally enabled, they must also be
2721 individually enabled for each channel that is to generate
2722 interrupts.
2723
2724 Warnings: No range checking on any of the parameters is done.
2725
2726 No context switches are allowed while executing this function.
2727
2728 After this function all AIOPs on the controller are disabled,
2729 they can be enabled with sEnAiop().
2730 */
2731 static int sPCIInitController(CONTROLLER_T * CtlP, int CtlNum,
2732 ByteIO_t * AiopIOList, int AiopIOListSize,
2733 WordIO_t ConfigIO, int IRQNum, Byte_t Frequency,
2734 int PeriodicOnly, int altChanRingIndicator,
2735 int UPCIRingInd)
2736 {
2737 int i;
2738 ByteIO_t io;
2739
2740 CtlP->AltChanRingIndicator = altChanRingIndicator;
2741 CtlP->UPCIRingInd = UPCIRingInd;
2742 CtlP->CtlNum = CtlNum;
2743 CtlP->CtlID = CTLID_0001; /* controller release 1 */
2744 CtlP->BusType = isPCI; /* controller release 1 */
2745
2746 if (ConfigIO) {
2747 CtlP->isUPCI = 1;
2748 CtlP->PCIIO = ConfigIO + _PCI_9030_INT_CTRL;
2749 CtlP->PCIIO2 = ConfigIO + _PCI_9030_GPIO_CTRL;
2750 CtlP->AiopIntrBits = upci_aiop_intr_bits;
2751 } else {
2752 CtlP->isUPCI = 0;
2753 CtlP->PCIIO =
2754 (WordIO_t) ((ByteIO_t) AiopIOList[0] + _PCI_INT_FUNC);
2755 CtlP->AiopIntrBits = aiop_intr_bits;
2756 }
2757
2758 sPCIControllerEOI(CtlP); /* clear EOI if warm init */
2759 /* Init AIOPs */
2760 CtlP->NumAiop = 0;
2761 for (i = 0; i < AiopIOListSize; i++) {
2762 io = AiopIOList[i];
2763 CtlP->AiopIO[i] = (WordIO_t) io;
2764 CtlP->AiopIntChanIO[i] = io + _INT_CHAN;
2765
2766 CtlP->AiopID[i] = sReadAiopID(io); /* read AIOP ID */
2767 if (CtlP->AiopID[i] == AIOPID_NULL) /* if AIOP does not exist */
2768 break; /* done looking for AIOPs */
2769
2770 CtlP->AiopNumChan[i] = sReadAiopNumChan((WordIO_t) io); /* num channels in AIOP */
2771 sOutW((WordIO_t) io + _INDX_ADDR, _CLK_PRE); /* clock prescaler */
2772 sOutB(io + _INDX_DATA, sClockPrescale);
2773 CtlP->NumAiop++; /* bump count of AIOPs */
2774 }
2775
2776 if (CtlP->NumAiop == 0)
2777 return (-1);
2778 else
2779 return (CtlP->NumAiop);
2780 }
2781
2782 /***************************************************************************
2783 Function: sReadAiopID
2784 Purpose: Read the AIOP idenfication number directly from an AIOP.
2785 Call: sReadAiopID(io)
2786 ByteIO_t io: AIOP base I/O address
2787 Return: int: Flag AIOPID_XXXX if a valid AIOP is found, where X
2788 is replace by an identifying number.
2789 Flag AIOPID_NULL if no valid AIOP is found
2790 Warnings: No context switches are allowed while executing this function.
2791
2792 */
2793 static int sReadAiopID(ByteIO_t io)
2794 {
2795 Byte_t AiopID; /* ID byte from AIOP */
2796
2797 sOutB(io + _CMD_REG, RESET_ALL); /* reset AIOP */
2798 sOutB(io + _CMD_REG, 0x0);
2799 AiopID = sInW(io + _CHN_STAT0) & 0x07;
2800 if (AiopID == 0x06)
2801 return (1);
2802 else /* AIOP does not exist */
2803 return (-1);
2804 }
2805
2806 /***************************************************************************
2807 Function: sReadAiopNumChan
2808 Purpose: Read the number of channels available in an AIOP directly from
2809 an AIOP.
2810 Call: sReadAiopNumChan(io)
2811 WordIO_t io: AIOP base I/O address
2812 Return: int: The number of channels available
2813 Comments: The number of channels is determined by write/reads from identical
2814 offsets within the SRAM address spaces for channels 0 and 4.
2815 If the channel 4 space is mirrored to channel 0 it is a 4 channel
2816 AIOP, otherwise it is an 8 channel.
2817 Warnings: No context switches are allowed while executing this function.
2818 */
2819 static int sReadAiopNumChan(WordIO_t io)
2820 {
2821 Word_t x;
2822 static Byte_t R[4] = { 0x00, 0x00, 0x34, 0x12 };
2823
2824 /* write to chan 0 SRAM */
2825 sOutDW((DWordIO_t) io + _INDX_ADDR, *((DWord_t *) & R[0]));
2826 sOutW(io + _INDX_ADDR, 0); /* read from SRAM, chan 0 */
2827 x = sInW(io + _INDX_DATA);
2828 sOutW(io + _INDX_ADDR, 0x4000); /* read from SRAM, chan 4 */
2829 if (x != sInW(io + _INDX_DATA)) /* if different must be 8 chan */
2830 return (8);
2831 else
2832 return (4);
2833 }
2834
2835 /***************************************************************************
2836 Function: sInitChan
2837 Purpose: Initialization of a channel and channel structure
2838 Call: sInitChan(CtlP,ChP,AiopNum,ChanNum)
2839 CONTROLLER_T *CtlP; Ptr to controller structure
2840 CHANNEL_T *ChP; Ptr to channel structure
2841 int AiopNum; AIOP number within controller
2842 int ChanNum; Channel number within AIOP
2843 Return: int: 1 if initialization succeeded, 0 if it fails because channel
2844 number exceeds number of channels available in AIOP.
2845 Comments: This function must be called before a channel can be used.
2846 Warnings: No range checking on any of the parameters is done.
2847
2848 No context switches are allowed while executing this function.
2849 */
2850 static int sInitChan(CONTROLLER_T * CtlP, CHANNEL_T * ChP, int AiopNum,
2851 int ChanNum)
2852 {
2853 int i;
2854 WordIO_t AiopIO;
2855 WordIO_t ChIOOff;
2856 Byte_t *ChR;
2857 Word_t ChOff;
2858 static Byte_t R[4];
2859 int brd9600;
2860
2861 if (ChanNum >= CtlP->AiopNumChan[AiopNum])
2862 return 0; /* exceeds num chans in AIOP */
2863
2864 /* Channel, AIOP, and controller identifiers */
2865 ChP->CtlP = CtlP;
2866 ChP->ChanID = CtlP->AiopID[AiopNum];
2867 ChP->AiopNum = AiopNum;
2868 ChP->ChanNum = ChanNum;
2869
2870 /* Global direct addresses */
2871 AiopIO = CtlP->AiopIO[AiopNum];
2872 ChP->Cmd = (ByteIO_t) AiopIO + _CMD_REG;
2873 ChP->IntChan = (ByteIO_t) AiopIO + _INT_CHAN;
2874 ChP->IntMask = (ByteIO_t) AiopIO + _INT_MASK;
2875 ChP->IndexAddr = (DWordIO_t) AiopIO + _INDX_ADDR;
2876 ChP->IndexData = AiopIO + _INDX_DATA;
2877
2878 /* Channel direct addresses */
2879 ChIOOff = AiopIO + ChP->ChanNum * 2;
2880 ChP->TxRxData = ChIOOff + _TD0;
2881 ChP->ChanStat = ChIOOff + _CHN_STAT0;
2882 ChP->TxRxCount = ChIOOff + _FIFO_CNT0;
2883 ChP->IntID = (ByteIO_t) AiopIO + ChP->ChanNum + _INT_ID0;
2884
2885 /* Initialize the channel from the RData array */
2886 for (i = 0; i < RDATASIZE; i += 4) {
2887 R[0] = RData[i];
2888 R[1] = RData[i + 1] + 0x10 * ChanNum;
2889 R[2] = RData[i + 2];
2890 R[3] = RData[i + 3];
2891 sOutDW(ChP->IndexAddr, *((DWord_t *) & R[0]));
2892 }
2893
2894 ChR = ChP->R;
2895 for (i = 0; i < RREGDATASIZE; i += 4) {
2896 ChR[i] = RRegData[i];
2897 ChR[i + 1] = RRegData[i + 1] + 0x10 * ChanNum;
2898 ChR[i + 2] = RRegData[i + 2];
2899 ChR[i + 3] = RRegData[i + 3];
2900 }
2901
2902 /* Indexed registers */
2903 ChOff = (Word_t) ChanNum *0x1000;
2904
2905 if (sClockPrescale == 0x14)
2906 brd9600 = 47;
2907 else
2908 brd9600 = 23;
2909
2910 ChP->BaudDiv[0] = (Byte_t) (ChOff + _BAUD);
2911 ChP->BaudDiv[1] = (Byte_t) ((ChOff + _BAUD) >> 8);
2912 ChP->BaudDiv[2] = (Byte_t) brd9600;
2913 ChP->BaudDiv[3] = (Byte_t) (brd9600 >> 8);
2914 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->BaudDiv[0]);
2915
2916 ChP->TxControl[0] = (Byte_t) (ChOff + _TX_CTRL);
2917 ChP->TxControl[1] = (Byte_t) ((ChOff + _TX_CTRL) >> 8);
2918 ChP->TxControl[2] = 0;
2919 ChP->TxControl[3] = 0;
2920 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxControl[0]);
2921
2922 ChP->RxControl[0] = (Byte_t) (ChOff + _RX_CTRL);
2923 ChP->RxControl[1] = (Byte_t) ((ChOff + _RX_CTRL) >> 8);
2924 ChP->RxControl[2] = 0;
2925 ChP->RxControl[3] = 0;
2926 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->RxControl[0]);
2927
2928 ChP->TxEnables[0] = (Byte_t) (ChOff + _TX_ENBLS);
2929 ChP->TxEnables[1] = (Byte_t) ((ChOff + _TX_ENBLS) >> 8);
2930 ChP->TxEnables[2] = 0;
2931 ChP->TxEnables[3] = 0;
2932 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxEnables[0]);
2933
2934 ChP->TxCompare[0] = (Byte_t) (ChOff + _TXCMP1);
2935 ChP->TxCompare[1] = (Byte_t) ((ChOff + _TXCMP1) >> 8);
2936 ChP->TxCompare[2] = 0;
2937 ChP->TxCompare[3] = 0;
2938 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxCompare[0]);
2939
2940 ChP->TxReplace1[0] = (Byte_t) (ChOff + _TXREP1B1);
2941 ChP->TxReplace1[1] = (Byte_t) ((ChOff + _TXREP1B1) >> 8);
2942 ChP->TxReplace1[2] = 0;
2943 ChP->TxReplace1[3] = 0;
2944 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxReplace1[0]);
2945
2946 ChP->TxReplace2[0] = (Byte_t) (ChOff + _TXREP2);
2947 ChP->TxReplace2[1] = (Byte_t) ((ChOff + _TXREP2) >> 8);
2948 ChP->TxReplace2[2] = 0;
2949 ChP->TxReplace2[3] = 0;
2950 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxReplace2[0]);
2951
2952 ChP->TxFIFOPtrs = ChOff + _TXF_OUTP;
2953 ChP->TxFIFO = ChOff + _TX_FIFO;
2954
2955 sOutB(ChP->Cmd, (Byte_t) ChanNum | RESTXFCNT); /* apply reset Tx FIFO count */
2956 sOutB(ChP->Cmd, (Byte_t) ChanNum); /* remove reset Tx FIFO count */
2957 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxFIFOPtrs); /* clear Tx in/out ptrs */
2958 sOutW(ChP->IndexData, 0);
2959 ChP->RxFIFOPtrs = ChOff + _RXF_OUTP;
2960 ChP->RxFIFO = ChOff + _RX_FIFO;
2961
2962 sOutB(ChP->Cmd, (Byte_t) ChanNum | RESRXFCNT); /* apply reset Rx FIFO count */
2963 sOutB(ChP->Cmd, (Byte_t) ChanNum); /* remove reset Rx FIFO count */
2964 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs); /* clear Rx out ptr */
2965 sOutW(ChP->IndexData, 0);
2966 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs + 2); /* clear Rx in ptr */
2967 sOutW(ChP->IndexData, 0);
2968 ChP->TxPrioCnt = ChOff + _TXP_CNT;
2969 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxPrioCnt);
2970 sOutB(ChP->IndexData, 0);
2971 ChP->TxPrioPtr = ChOff + _TXP_PNTR;
2972 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxPrioPtr);
2973 sOutB(ChP->IndexData, 0);
2974 ChP->TxPrioBuf = ChOff + _TXP_BUF;
2975 sEnRxProcessor(ChP); /* start the Rx processor */
2976
2977 return 1;
2978 }
2979
2980 /***************************************************************************
2981 Function: sStopRxProcessor
2982 Purpose: Stop the receive processor from processing a channel.
2983 Call: sStopRxProcessor(ChP)
2984 CHANNEL_T *ChP; Ptr to channel structure
2985
2986 Comments: The receive processor can be started again with sStartRxProcessor().
2987 This function causes the receive processor to skip over the
2988 stopped channel. It does not stop it from processing other channels.
2989
2990 Warnings: No context switches are allowed while executing this function.
2991
2992 Do not leave the receive processor stopped for more than one
2993 character time.
2994
2995 After calling this function a delay of 4 uS is required to ensure
2996 that the receive processor is no longer processing this channel.
2997 */
2998 static void sStopRxProcessor(CHANNEL_T * ChP)
2999 {
3000 Byte_t R[4];
3001
3002 R[0] = ChP->R[0];
3003 R[1] = ChP->R[1];
3004 R[2] = 0x0a;
3005 R[3] = ChP->R[3];
3006 sOutDW(ChP->IndexAddr, *(DWord_t *) & R[0]);
3007 }
3008
3009 /***************************************************************************
3010 Function: sFlushRxFIFO
3011 Purpose: Flush the Rx FIFO
3012 Call: sFlushRxFIFO(ChP)
3013 CHANNEL_T *ChP; Ptr to channel structure
3014 Return: void
3015 Comments: To prevent data from being enqueued or dequeued in the Tx FIFO
3016 while it is being flushed the receive processor is stopped
3017 and the transmitter is disabled. After these operations a
3018 4 uS delay is done before clearing the pointers to allow
3019 the receive processor to stop. These items are handled inside
3020 this function.
3021 Warnings: No context switches are allowed while executing this function.
3022 */
3023 static void sFlushRxFIFO(CHANNEL_T * ChP)
3024 {
3025 int i;
3026 Byte_t Ch; /* channel number within AIOP */
3027 int RxFIFOEnabled; /* 1 if Rx FIFO enabled */
3028
3029 if (sGetRxCnt(ChP) == 0) /* Rx FIFO empty */
3030 return; /* don't need to flush */
3031
3032 RxFIFOEnabled = 0;
3033 if (ChP->R[0x32] == 0x08) { /* Rx FIFO is enabled */
3034 RxFIFOEnabled = 1;
3035 sDisRxFIFO(ChP); /* disable it */
3036 for (i = 0; i < 2000 / 200; i++) /* delay 2 uS to allow proc to disable FIFO */
3037 sInB(ChP->IntChan); /* depends on bus i/o timing */
3038 }
3039 sGetChanStatus(ChP); /* clear any pending Rx errors in chan stat */
3040 Ch = (Byte_t) sGetChanNum(ChP);
3041 sOutB(ChP->Cmd, Ch | RESRXFCNT); /* apply reset Rx FIFO count */
3042 sOutB(ChP->Cmd, Ch); /* remove reset Rx FIFO count */
3043 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs); /* clear Rx out ptr */
3044 sOutW(ChP->IndexData, 0);
3045 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs + 2); /* clear Rx in ptr */
3046 sOutW(ChP->IndexData, 0);
3047 if (RxFIFOEnabled)
3048 sEnRxFIFO(ChP); /* enable Rx FIFO */
3049 }
3050
3051 /***************************************************************************
3052 Function: sFlushTxFIFO
3053 Purpose: Flush the Tx FIFO
3054 Call: sFlushTxFIFO(ChP)
3055 CHANNEL_T *ChP; Ptr to channel structure
3056 Return: void
3057 Comments: To prevent data from being enqueued or dequeued in the Tx FIFO
3058 while it is being flushed the receive processor is stopped
3059 and the transmitter is disabled. After these operations a
3060 4 uS delay is done before clearing the pointers to allow
3061 the receive processor to stop. These items are handled inside
3062 this function.
3063 Warnings: No context switches are allowed while executing this function.
3064 */
3065 static void sFlushTxFIFO(CHANNEL_T * ChP)
3066 {
3067 int i;
3068 Byte_t Ch; /* channel number within AIOP */
3069 int TxEnabled; /* 1 if transmitter enabled */
3070
3071 if (sGetTxCnt(ChP) == 0) /* Tx FIFO empty */
3072 return; /* don't need to flush */
3073
3074 TxEnabled = 0;
3075 if (ChP->TxControl[3] & TX_ENABLE) {
3076 TxEnabled = 1;
3077 sDisTransmit(ChP); /* disable transmitter */
3078 }
3079 sStopRxProcessor(ChP); /* stop Rx processor */
3080 for (i = 0; i < 4000 / 200; i++) /* delay 4 uS to allow proc to stop */
3081 sInB(ChP->IntChan); /* depends on bus i/o timing */
3082 Ch = (Byte_t) sGetChanNum(ChP);
3083 sOutB(ChP->Cmd, Ch | RESTXFCNT); /* apply reset Tx FIFO count */
3084 sOutB(ChP->Cmd, Ch); /* remove reset Tx FIFO count */
3085 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxFIFOPtrs); /* clear Tx in/out ptrs */
3086 sOutW(ChP->IndexData, 0);
3087 if (TxEnabled)
3088 sEnTransmit(ChP); /* enable transmitter */
3089 sStartRxProcessor(ChP); /* restart Rx processor */
3090 }
3091
3092 /***************************************************************************
3093 Function: sWriteTxPrioByte
3094 Purpose: Write a byte of priority transmit data to a channel
3095 Call: sWriteTxPrioByte(ChP,Data)
3096 CHANNEL_T *ChP; Ptr to channel structure
3097 Byte_t Data; The transmit data byte
3098
3099 Return: int: 1 if the bytes is successfully written, otherwise 0.
3100
3101 Comments: The priority byte is transmitted before any data in the Tx FIFO.
3102
3103 Warnings: No context switches are allowed while executing this function.
3104 */
3105 static int sWriteTxPrioByte(CHANNEL_T * ChP, Byte_t Data)
3106 {
3107 Byte_t DWBuf[4]; /* buffer for double word writes */
3108 Word_t *WordPtr; /* must be far because Win SS != DS */
3109 register DWordIO_t IndexAddr;
3110
3111 if (sGetTxCnt(ChP) > 1) { /* write it to Tx priority buffer */
3112 IndexAddr = ChP->IndexAddr;
3113 sOutW((WordIO_t) IndexAddr, ChP->TxPrioCnt); /* get priority buffer status */
3114 if (sInB((ByteIO_t) ChP->IndexData) & PRI_PEND) /* priority buffer busy */
3115 return (0); /* nothing sent */
3116
3117 WordPtr = (Word_t *) (&DWBuf[0]);
3118 *WordPtr = ChP->TxPrioBuf; /* data byte address */
3119
3120 DWBuf[2] = Data; /* data byte value */
3121 sOutDW(IndexAddr, *((DWord_t *) (&DWBuf[0]))); /* write it out */
3122
3123 *WordPtr = ChP->TxPrioCnt; /* Tx priority count address */
3124
3125 DWBuf[2] = PRI_PEND + 1; /* indicate 1 byte pending */
3126 DWBuf[3] = 0; /* priority buffer pointer */
3127 sOutDW(IndexAddr, *((DWord_t *) (&DWBuf[0]))); /* write it out */
3128 } else { /* write it to Tx FIFO */
3129
3130 sWriteTxByte(sGetTxRxDataIO(ChP), Data);
3131 }
3132 return (1); /* 1 byte sent */
3133 }
3134
3135 /***************************************************************************
3136 Function: sEnInterrupts
3137 Purpose: Enable one or more interrupts for a channel
3138 Call: sEnInterrupts(ChP,Flags)
3139 CHANNEL_T *ChP; Ptr to channel structure
3140 Word_t Flags: Interrupt enable flags, can be any combination
3141 of the following flags:
3142 TXINT_EN: Interrupt on Tx FIFO empty
3143 RXINT_EN: Interrupt on Rx FIFO at trigger level (see
3144 sSetRxTrigger())
3145 SRCINT_EN: Interrupt on SRC (Special Rx Condition)
3146 MCINT_EN: Interrupt on modem input change
3147 CHANINT_EN: Allow channel interrupt signal to the AIOP's
3148 Interrupt Channel Register.
3149 Return: void
3150 Comments: If an interrupt enable flag is set in Flags, that interrupt will be
3151 enabled. If an interrupt enable flag is not set in Flags, that
3152 interrupt will not be changed. Interrupts can be disabled with
3153 function sDisInterrupts().
3154
3155 This function sets the appropriate bit for the channel in the AIOP's
3156 Interrupt Mask Register if the CHANINT_EN flag is set. This allows
3157 this channel's bit to be set in the AIOP's Interrupt Channel Register.
3158
3159 Interrupts must also be globally enabled before channel interrupts
3160 will be passed on to the host. This is done with function
3161 sEnGlobalInt().
3162
3163 In some cases it may be desirable to disable interrupts globally but
3164 enable channel interrupts. This would allow the global interrupt
3165 status register to be used to determine which AIOPs need service.
3166 */
3167 static void sEnInterrupts(CHANNEL_T * ChP, Word_t Flags)
3168 {
3169 Byte_t Mask; /* Interrupt Mask Register */
3170
3171 ChP->RxControl[2] |=
3172 ((Byte_t) Flags & (RXINT_EN | SRCINT_EN | MCINT_EN));
3173
3174 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->RxControl[0]);
3175
3176 ChP->TxControl[2] |= ((Byte_t) Flags & TXINT_EN);
3177
3178 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxControl[0]);
3179
3180 if (Flags & CHANINT_EN) {
3181 Mask = sInB(ChP->IntMask) | sBitMapSetTbl[ChP->ChanNum];
3182 sOutB(ChP->IntMask, Mask);
3183 }
3184 }
3185
3186 /***************************************************************************
3187 Function: sDisInterrupts
3188 Purpose: Disable one or more interrupts for a channel
3189 Call: sDisInterrupts(ChP,Flags)
3190 CHANNEL_T *ChP; Ptr to channel structure
3191 Word_t Flags: Interrupt flags, can be any combination
3192 of the following flags:
3193 TXINT_EN: Interrupt on Tx FIFO empty
3194 RXINT_EN: Interrupt on Rx FIFO at trigger level (see
3195 sSetRxTrigger())
3196 SRCINT_EN: Interrupt on SRC (Special Rx Condition)
3197 MCINT_EN: Interrupt on modem input change
3198 CHANINT_EN: Disable channel interrupt signal to the
3199 AIOP's Interrupt Channel Register.
3200 Return: void
3201 Comments: If an interrupt flag is set in Flags, that interrupt will be
3202 disabled. If an interrupt flag is not set in Flags, that
3203 interrupt will not be changed. Interrupts can be enabled with
3204 function sEnInterrupts().
3205
3206 This function clears the appropriate bit for the channel in the AIOP's
3207 Interrupt Mask Register if the CHANINT_EN flag is set. This blocks
3208 this channel's bit from being set in the AIOP's Interrupt Channel
3209 Register.
3210 */
3211 static void sDisInterrupts(CHANNEL_T * ChP, Word_t Flags)
3212 {
3213 Byte_t Mask; /* Interrupt Mask Register */
3214
3215 ChP->RxControl[2] &=
3216 ~((Byte_t) Flags & (RXINT_EN | SRCINT_EN | MCINT_EN));
3217 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->RxControl[0]);
3218 ChP->TxControl[2] &= ~((Byte_t) Flags & TXINT_EN);
3219 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxControl[0]);
3220
3221 if (Flags & CHANINT_EN) {
3222 Mask = sInB(ChP->IntMask) & sBitMapClrTbl[ChP->ChanNum];
3223 sOutB(ChP->IntMask, Mask);
3224 }
3225 }
3226
3227 static void sSetInterfaceMode(CHANNEL_T * ChP, Byte_t mode)
3228 {
3229 sOutB(ChP->CtlP->AiopIO[2], (mode & 0x18) | ChP->ChanNum);
3230 }
3231
3232 /*
3233 * Not an official SSCI function, but how to reset RocketModems.
3234 * ISA bus version
3235 */
3236 static void sModemReset(CONTROLLER_T * CtlP, int chan, int on)
3237 {
3238 ByteIO_t addr;
3239 Byte_t val;
3240
3241 addr = CtlP->AiopIO[0] + 0x400;
3242 val = sInB(CtlP->MReg3IO);
3243 /* if AIOP[1] is not enabled, enable it */
3244 if ((val & 2) == 0) {
3245 val = sInB(CtlP->MReg2IO);
3246 sOutB(CtlP->MReg2IO, (val & 0xfc) | (1 & 0x03));
3247 sOutB(CtlP->MBaseIO, (unsigned char) (addr >> 6));
3248 }
3249
3250 sEnAiop(CtlP, 1);
3251 if (!on)
3252 addr += 8;
3253 sOutB(addr + chan, 0); /* apply or remove reset */
3254 sDisAiop(CtlP, 1);
3255 }
3256
3257 /*
3258 * Not an official SSCI function, but how to reset RocketModems.
3259 * PCI bus version
3260 */
3261 static void sPCIModemReset(CONTROLLER_T * CtlP, int chan, int on)
3262 {
3263 ByteIO_t addr;
3264
3265 addr = CtlP->AiopIO[0] + 0x40; /* 2nd AIOP */
3266 if (!on)
3267 addr += 8;
3268 sOutB(addr + chan, 0); /* apply or remove reset */
3269 }
3270
3271 /* Resets the speaker controller on RocketModem II and III devices */
3272 static void rmSpeakerReset(CONTROLLER_T * CtlP, unsigned long model)
3273 {
3274 ByteIO_t addr;
3275
3276 /* RocketModem II speaker control is at the 8th port location of offset 0x40 */
3277 if ((model == MODEL_RP4M) || (model == MODEL_RP6M)) {
3278 addr = CtlP->AiopIO[0] + 0x4F;
3279 sOutB(addr, 0);
3280 }
3281
3282 /* RocketModem III speaker control is at the 1st port location of offset 0x80 */
3283 if ((model == MODEL_UPCI_RM3_8PORT)
3284 || (model == MODEL_UPCI_RM3_4PORT)) {
3285 addr = CtlP->AiopIO[0] + 0x88;
3286 sOutB(addr, 0);
3287 }
3288 }
3289
3290 /* Returns the line number given the controller (board), aiop and channel number */
3291 static unsigned char GetLineNumber(int ctrl, int aiop, int ch)
3292 {
3293 return lineNumbers[(ctrl << 5) | (aiop << 3) | ch];
3294 }
3295
3296 /*
3297 * Stores the line number associated with a given controller (board), aiop
3298 * and channel number.
3299 * Returns: The line number assigned
3300 */
3301 static unsigned char SetLineNumber(int ctrl, int aiop, int ch)
3302 {
3303 lineNumbers[(ctrl << 5) | (aiop << 3) | ch] = nextLineNumber++;
3304 return (nextLineNumber - 1);
3305 }
Linux kernel - Deliverables
This page took 0.099542 seconds and 5 git commands to generate.