ia64/linux-2.6.18-xen.hg

view drivers/char/rocket.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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 */
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 */
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
49 #define ROCKET_PARANOIA_CHECK
50 #define ROCKET_DISABLE_SIMUSAGE
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
64 #define POLL_PERIOD HZ/100 /* Polling period .01 seconds (10ms) */
66 /****** Kernel includes ******/
68 #ifdef MODVERSIONS
69 #include <config/modversions.h>
70 #endif
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>
99 /****** RocketPort includes ******/
101 #include "rocket_int.h"
102 #include "rocket.h"
104 #define ROCKET_VERSION "2.09"
105 #define ROCKET_DATE "12-June-2003"
107 /****** RocketPort Local Variables ******/
109 static struct tty_driver *rocket_driver;
111 static struct rocket_version driver_version = {
112 ROCKET_VERSION, ROCKET_DATE
113 };
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;
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 };
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;
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 */
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 };
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 };
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 };
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 };
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 };
212 static Byte_t sBitMapClrTbl[8] = {
213 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f
214 };
216 static Byte_t sBitMapSetTbl[8] = {
217 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
218 };
220 static int sClockPrescale = 0x14;
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;
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);
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,...");
290 static int rp_init(void);
291 static void rp_cleanup_module(void);
293 module_init(rp_init);
294 module_exit(rp_cleanup_module);
297 MODULE_LICENSE("Dual BSD/GPL");
299 /*************************************************************************/
300 /* Module code starts here */
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 }
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;
328 unsigned char *cbuf;
330 ToRecv = sGetRxCnt(cp);
331 #ifdef ROCKET_DEBUG_INTR
332 printk(KERN_INFO "rp_do_receive(%d)...", ToRecv);
333 #endif
334 if (ToRecv == 0)
335 return;
337 /*
338 * if status indicates there are errored characters in the
339 * FIFO, then enter status mode (a word in FIFO holds
340 * character and status).
341 */
342 if (ChanStatus & (RXFOVERFL | RXBREAK | RXFRAME | RXPARITY)) {
343 if (!(ChanStatus & STATMODE)) {
344 #ifdef ROCKET_DEBUG_RECEIVE
345 printk(KERN_INFO "Entering STATMODE...");
346 #endif
347 ChanStatus |= STATMODE;
348 sEnRxStatusMode(cp);
349 }
350 }
352 /*
353 * if we previously entered status mode, then read down the
354 * FIFO one word at a time, pulling apart the character and
355 * the status. Update error counters depending on status
356 */
357 if (ChanStatus & STATMODE) {
358 #ifdef ROCKET_DEBUG_RECEIVE
359 printk(KERN_INFO "Ignore %x, read %x...", info->ignore_status_mask,
360 info->read_status_mask);
361 #endif
362 while (ToRecv) {
363 char flag;
365 CharNStat = sInW(sGetTxRxDataIO(cp));
366 #ifdef ROCKET_DEBUG_RECEIVE
367 printk(KERN_INFO "%x...", CharNStat);
368 #endif
369 if (CharNStat & STMBREAKH)
370 CharNStat &= ~(STMFRAMEH | STMPARITYH);
371 if (CharNStat & info->ignore_status_mask) {
372 ToRecv--;
373 continue;
374 }
375 CharNStat &= info->read_status_mask;
376 if (CharNStat & STMBREAKH)
377 flag = TTY_BREAK;
378 else if (CharNStat & STMPARITYH)
379 flag = TTY_PARITY;
380 else if (CharNStat & STMFRAMEH)
381 flag = TTY_FRAME;
382 else if (CharNStat & STMRCVROVRH)
383 flag = TTY_OVERRUN;
384 else
385 flag = TTY_NORMAL;
386 tty_insert_flip_char(tty, CharNStat & 0xff, flag);
387 ToRecv--;
388 }
390 /*
391 * after we've emptied the FIFO in status mode, turn
392 * status mode back off
393 */
394 if (sGetRxCnt(cp) == 0) {
395 #ifdef ROCKET_DEBUG_RECEIVE
396 printk(KERN_INFO "Status mode off.\n");
397 #endif
398 sDisRxStatusMode(cp);
399 }
400 } else {
401 /*
402 * we aren't in status mode, so read down the FIFO two
403 * characters at time by doing repeated word IO
404 * transfer.
405 */
406 space = tty_prepare_flip_string(tty, &cbuf, ToRecv);
407 if (space < ToRecv) {
408 #ifdef ROCKET_DEBUG_RECEIVE
409 printk(KERN_INFO "rp_do_receive:insufficient space ToRecv=%d space=%d\n", ToRecv, space);
410 #endif
411 if (space <= 0)
412 return;
413 ToRecv = space;
414 }
415 wRecv = ToRecv >> 1;
416 if (wRecv)
417 sInStrW(sGetTxRxDataIO(cp), (unsigned short *) cbuf, wRecv);
418 if (ToRecv & 1)
419 cbuf[ToRecv - 1] = sInB(sGetTxRxDataIO(cp));
420 }
421 /* Push the data up to the tty layer */
422 tty_flip_buffer_push(tty);
423 }
425 /*
426 * Serial port transmit data function. Called from the timer polling loop as a
427 * result of a bit set in xmit_flags[], indicating data (from the tty layer) is ready
428 * to be sent out the serial port. Data is buffered in rp_table[line].xmit_buf, it is
429 * moved to the port's xmit FIFO. *info is critical data, protected by spinlocks.
430 */
431 static void rp_do_transmit(struct r_port *info)
432 {
433 int c;
434 CHANNEL_t *cp = &info->channel;
435 struct tty_struct *tty;
436 unsigned long flags;
438 #ifdef ROCKET_DEBUG_INTR
439 printk(KERN_INFO "rp_do_transmit ");
440 #endif
441 if (!info)
442 return;
443 if (!info->tty) {
444 printk(KERN_INFO "rp: WARNING rp_do_transmit called with info->tty==NULL\n");
445 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
446 return;
447 }
449 spin_lock_irqsave(&info->slock, flags);
450 tty = info->tty;
451 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
453 /* Loop sending data to FIFO until done or FIFO full */
454 while (1) {
455 if (tty->stopped || tty->hw_stopped)
456 break;
457 c = min(info->xmit_fifo_room, min(info->xmit_cnt, XMIT_BUF_SIZE - info->xmit_tail));
458 if (c <= 0 || info->xmit_fifo_room <= 0)
459 break;
460 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) (info->xmit_buf + info->xmit_tail), c / 2);
461 if (c & 1)
462 sOutB(sGetTxRxDataIO(cp), info->xmit_buf[info->xmit_tail + c - 1]);
463 info->xmit_tail += c;
464 info->xmit_tail &= XMIT_BUF_SIZE - 1;
465 info->xmit_cnt -= c;
466 info->xmit_fifo_room -= c;
467 #ifdef ROCKET_DEBUG_INTR
468 printk(KERN_INFO "tx %d chars...", c);
469 #endif
470 }
472 if (info->xmit_cnt == 0)
473 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
475 if (info->xmit_cnt < WAKEUP_CHARS) {
476 tty_wakeup(tty);
477 wake_up_interruptible(&tty->write_wait);
478 #ifdef ROCKETPORT_HAVE_POLL_WAIT
479 wake_up_interruptible(&tty->poll_wait);
480 #endif
481 }
483 spin_unlock_irqrestore(&info->slock, flags);
485 #ifdef ROCKET_DEBUG_INTR
486 printk(KERN_INFO "(%d,%d,%d,%d)...", info->xmit_cnt, info->xmit_head,
487 info->xmit_tail, info->xmit_fifo_room);
488 #endif
489 }
491 /*
492 * Called when a serial port signals it has read data in it's RX FIFO.
493 * It checks what interrupts are pending and services them, including
494 * receiving serial data.
495 */
496 static void rp_handle_port(struct r_port *info)
497 {
498 CHANNEL_t *cp;
499 struct tty_struct *tty;
500 unsigned int IntMask, ChanStatus;
502 if (!info)
503 return;
505 if ((info->flags & ROCKET_INITIALIZED) == 0) {
506 printk(KERN_INFO "rp: WARNING: rp_handle_port called with info->flags & NOT_INIT\n");
507 return;
508 }
509 if (!info->tty) {
510 printk(KERN_INFO "rp: WARNING: rp_handle_port called with info->tty==NULL\n");
511 return;
512 }
513 cp = &info->channel;
514 tty = info->tty;
516 IntMask = sGetChanIntID(cp) & info->intmask;
517 #ifdef ROCKET_DEBUG_INTR
518 printk(KERN_INFO "rp_interrupt %02x...", IntMask);
519 #endif
520 ChanStatus = sGetChanStatus(cp);
521 if (IntMask & RXF_TRIG) { /* Rx FIFO trigger level */
522 rp_do_receive(info, tty, cp, ChanStatus);
523 }
524 if (IntMask & DELTA_CD) { /* CD change */
525 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_INTR) || defined(ROCKET_DEBUG_HANGUP))
526 printk(KERN_INFO "ttyR%d CD now %s...", info->line,
527 (ChanStatus & CD_ACT) ? "on" : "off");
528 #endif
529 if (!(ChanStatus & CD_ACT) && info->cd_status) {
530 #ifdef ROCKET_DEBUG_HANGUP
531 printk(KERN_INFO "CD drop, calling hangup.\n");
532 #endif
533 tty_hangup(tty);
534 }
535 info->cd_status = (ChanStatus & CD_ACT) ? 1 : 0;
536 wake_up_interruptible(&info->open_wait);
537 }
538 #ifdef ROCKET_DEBUG_INTR
539 if (IntMask & DELTA_CTS) { /* CTS change */
540 printk(KERN_INFO "CTS change...\n");
541 }
542 if (IntMask & DELTA_DSR) { /* DSR change */
543 printk(KERN_INFO "DSR change...\n");
544 }
545 #endif
546 }
548 /*
549 * The top level polling routine. Repeats every 1/100 HZ (10ms).
550 */
551 static void rp_do_poll(unsigned long dummy)
552 {
553 CONTROLLER_t *ctlp;
554 int ctrl, aiop, ch, line, i;
555 unsigned int xmitmask;
556 unsigned int CtlMask;
557 unsigned char AiopMask;
558 Word_t bit;
560 /* Walk through all the boards (ctrl's) */
561 for (ctrl = 0; ctrl < max_board; ctrl++) {
562 if (rcktpt_io_addr[ctrl] <= 0)
563 continue;
565 /* Get a ptr to the board's control struct */
566 ctlp = sCtlNumToCtlPtr(ctrl);
568 /* Get the interupt status from the board */
569 #ifdef CONFIG_PCI
570 if (ctlp->BusType == isPCI)
571 CtlMask = sPCIGetControllerIntStatus(ctlp);
572 else
573 #endif
574 CtlMask = sGetControllerIntStatus(ctlp);
576 /* Check if any AIOP read bits are set */
577 for (aiop = 0; CtlMask; aiop++) {
578 bit = ctlp->AiopIntrBits[aiop];
579 if (CtlMask & bit) {
580 CtlMask &= ~bit;
581 AiopMask = sGetAiopIntStatus(ctlp, aiop);
583 /* Check if any port read bits are set */
584 for (ch = 0; AiopMask; AiopMask >>= 1, ch++) {
585 if (AiopMask & 1) {
587 /* Get the line number (/dev/ttyRx number). */
588 /* Read the data from the port. */
589 line = GetLineNumber(ctrl, aiop, ch);
590 rp_handle_port(rp_table[line]);
591 }
592 }
593 }
594 }
596 xmitmask = xmit_flags[ctrl];
598 /*
599 * xmit_flags contains bit-significant flags, indicating there is data
600 * to xmit on the port. Bit 0 is port 0 on this board, bit 1 is port
601 * 1, ... (32 total possible). The variable i has the aiop and ch
602 * numbers encoded in it (port 0-7 are aiop0, 8-15 are aiop1, etc).
603 */
604 if (xmitmask) {
605 for (i = 0; i < rocketModel[ctrl].numPorts; i++) {
606 if (xmitmask & (1 << i)) {
607 aiop = (i & 0x18) >> 3;
608 ch = i & 0x07;
609 line = GetLineNumber(ctrl, aiop, ch);
610 rp_do_transmit(rp_table[line]);
611 }
612 }
613 }
614 }
616 /*
617 * Reset the timer so we get called at the next clock tick (10ms).
618 */
619 if (atomic_read(&rp_num_ports_open))
620 mod_timer(&rocket_timer, jiffies + POLL_PERIOD);
621 }
623 /*
624 * Initializes the r_port structure for a port, as well as enabling the port on
625 * the board.
626 * Inputs: board, aiop, chan numbers
627 */
628 static void init_r_port(int board, int aiop, int chan, struct pci_dev *pci_dev)
629 {
630 unsigned rocketMode;
631 struct r_port *info;
632 int line;
633 CONTROLLER_T *ctlp;
635 /* Get the next available line number */
636 line = SetLineNumber(board, aiop, chan);
638 ctlp = sCtlNumToCtlPtr(board);
640 /* Get a r_port struct for the port, fill it in and save it globally, indexed by line number */
641 info = kmalloc(sizeof (struct r_port), GFP_KERNEL);
642 if (!info) {
643 printk(KERN_INFO "Couldn't allocate info struct for line #%d\n", line);
644 return;
645 }
646 memset(info, 0, sizeof (struct r_port));
648 info->magic = RPORT_MAGIC;
649 info->line = line;
650 info->ctlp = ctlp;
651 info->board = board;
652 info->aiop = aiop;
653 info->chan = chan;
654 info->closing_wait = 3000;
655 info->close_delay = 50;
656 init_waitqueue_head(&info->open_wait);
657 init_waitqueue_head(&info->close_wait);
658 info->flags &= ~ROCKET_MODE_MASK;
659 switch (pc104[board][line]) {
660 case 422:
661 info->flags |= ROCKET_MODE_RS422;
662 break;
663 case 485:
664 info->flags |= ROCKET_MODE_RS485;
665 break;
666 case 232:
667 default:
668 info->flags |= ROCKET_MODE_RS232;
669 break;
670 }
672 info->intmask = RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR;
673 if (sInitChan(ctlp, &info->channel, aiop, chan) == 0) {
674 printk(KERN_INFO "RocketPort sInitChan(%d, %d, %d) failed!\n", board, aiop, chan);
675 kfree(info);
676 return;
677 }
679 rocketMode = info->flags & ROCKET_MODE_MASK;
681 if ((info->flags & ROCKET_RTS_TOGGLE) || (rocketMode == ROCKET_MODE_RS485))
682 sEnRTSToggle(&info->channel);
683 else
684 sDisRTSToggle(&info->channel);
686 if (ctlp->boardType == ROCKET_TYPE_PC104) {
687 switch (rocketMode) {
688 case ROCKET_MODE_RS485:
689 sSetInterfaceMode(&info->channel, InterfaceModeRS485);
690 break;
691 case ROCKET_MODE_RS422:
692 sSetInterfaceMode(&info->channel, InterfaceModeRS422);
693 break;
694 case ROCKET_MODE_RS232:
695 default:
696 if (info->flags & ROCKET_RTS_TOGGLE)
697 sSetInterfaceMode(&info->channel, InterfaceModeRS232T);
698 else
699 sSetInterfaceMode(&info->channel, InterfaceModeRS232);
700 break;
701 }
702 }
703 spin_lock_init(&info->slock);
704 sema_init(&info->write_sem, 1);
705 rp_table[line] = info;
706 if (pci_dev)
707 tty_register_device(rocket_driver, line, &pci_dev->dev);
708 }
710 /*
711 * Configures a rocketport port according to its termio settings. Called from
712 * user mode into the driver (exception handler). *info CD manipulation is spinlock protected.
713 */
714 static void configure_r_port(struct r_port *info,
715 struct termios *old_termios)
716 {
717 unsigned cflag;
718 unsigned long flags;
719 unsigned rocketMode;
720 int bits, baud, divisor;
721 CHANNEL_t *cp;
723 if (!info->tty || !info->tty->termios)
724 return;
725 cp = &info->channel;
726 cflag = info->tty->termios->c_cflag;
728 /* Byte size and parity */
729 if ((cflag & CSIZE) == CS8) {
730 sSetData8(cp);
731 bits = 10;
732 } else {
733 sSetData7(cp);
734 bits = 9;
735 }
736 if (cflag & CSTOPB) {
737 sSetStop2(cp);
738 bits++;
739 } else {
740 sSetStop1(cp);
741 }
743 if (cflag & PARENB) {
744 sEnParity(cp);
745 bits++;
746 if (cflag & PARODD) {
747 sSetOddParity(cp);
748 } else {
749 sSetEvenParity(cp);
750 }
751 } else {
752 sDisParity(cp);
753 }
755 /* baud rate */
756 baud = tty_get_baud_rate(info->tty);
757 if (!baud)
758 baud = 9600;
759 divisor = ((rp_baud_base[info->board] + (baud >> 1)) / baud) - 1;
760 if ((divisor >= 8192 || divisor < 0) && old_termios) {
761 info->tty->termios->c_cflag &= ~CBAUD;
762 info->tty->termios->c_cflag |=
763 (old_termios->c_cflag & CBAUD);
764 baud = tty_get_baud_rate(info->tty);
765 if (!baud)
766 baud = 9600;
767 divisor = (rp_baud_base[info->board] / baud) - 1;
768 }
769 if (divisor >= 8192 || divisor < 0) {
770 baud = 9600;
771 divisor = (rp_baud_base[info->board] / baud) - 1;
772 }
773 info->cps = baud / bits;
774 sSetBaud(cp, divisor);
776 if (cflag & CRTSCTS) {
777 info->intmask |= DELTA_CTS;
778 sEnCTSFlowCtl(cp);
779 } else {
780 info->intmask &= ~DELTA_CTS;
781 sDisCTSFlowCtl(cp);
782 }
783 if (cflag & CLOCAL) {
784 info->intmask &= ~DELTA_CD;
785 } else {
786 spin_lock_irqsave(&info->slock, flags);
787 if (sGetChanStatus(cp) & CD_ACT)
788 info->cd_status = 1;
789 else
790 info->cd_status = 0;
791 info->intmask |= DELTA_CD;
792 spin_unlock_irqrestore(&info->slock, flags);
793 }
795 /*
796 * Handle software flow control in the board
797 */
798 #ifdef ROCKET_SOFT_FLOW
799 if (I_IXON(info->tty)) {
800 sEnTxSoftFlowCtl(cp);
801 if (I_IXANY(info->tty)) {
802 sEnIXANY(cp);
803 } else {
804 sDisIXANY(cp);
805 }
806 sSetTxXONChar(cp, START_CHAR(info->tty));
807 sSetTxXOFFChar(cp, STOP_CHAR(info->tty));
808 } else {
809 sDisTxSoftFlowCtl(cp);
810 sDisIXANY(cp);
811 sClrTxXOFF(cp);
812 }
813 #endif
815 /*
816 * Set up ignore/read mask words
817 */
818 info->read_status_mask = STMRCVROVRH | 0xFF;
819 if (I_INPCK(info->tty))
820 info->read_status_mask |= STMFRAMEH | STMPARITYH;
821 if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
822 info->read_status_mask |= STMBREAKH;
824 /*
825 * Characters to ignore
826 */
827 info->ignore_status_mask = 0;
828 if (I_IGNPAR(info->tty))
829 info->ignore_status_mask |= STMFRAMEH | STMPARITYH;
830 if (I_IGNBRK(info->tty)) {
831 info->ignore_status_mask |= STMBREAKH;
832 /*
833 * If we're ignoring parity and break indicators,
834 * ignore overruns too. (For real raw support).
835 */
836 if (I_IGNPAR(info->tty))
837 info->ignore_status_mask |= STMRCVROVRH;
838 }
840 rocketMode = info->flags & ROCKET_MODE_MASK;
842 if ((info->flags & ROCKET_RTS_TOGGLE)
843 || (rocketMode == ROCKET_MODE_RS485))
844 sEnRTSToggle(cp);
845 else
846 sDisRTSToggle(cp);
848 sSetRTS(&info->channel);
850 if (cp->CtlP->boardType == ROCKET_TYPE_PC104) {
851 switch (rocketMode) {
852 case ROCKET_MODE_RS485:
853 sSetInterfaceMode(cp, InterfaceModeRS485);
854 break;
855 case ROCKET_MODE_RS422:
856 sSetInterfaceMode(cp, InterfaceModeRS422);
857 break;
858 case ROCKET_MODE_RS232:
859 default:
860 if (info->flags & ROCKET_RTS_TOGGLE)
861 sSetInterfaceMode(cp, InterfaceModeRS232T);
862 else
863 sSetInterfaceMode(cp, InterfaceModeRS232);
864 break;
865 }
866 }
867 }
869 /* info->count is considered critical, protected by spinlocks. */
870 static int block_til_ready(struct tty_struct *tty, struct file *filp,
871 struct r_port *info)
872 {
873 DECLARE_WAITQUEUE(wait, current);
874 int retval;
875 int do_clocal = 0, extra_count = 0;
876 unsigned long flags;
878 /*
879 * If the device is in the middle of being closed, then block
880 * until it's done, and then try again.
881 */
882 if (tty_hung_up_p(filp))
883 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
884 if (info->flags & ROCKET_CLOSING) {
885 interruptible_sleep_on(&info->close_wait);
886 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
887 }
889 /*
890 * If non-blocking mode is set, or the port is not enabled,
891 * then make the check up front and then exit.
892 */
893 if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
894 info->flags |= ROCKET_NORMAL_ACTIVE;
895 return 0;
896 }
897 if (tty->termios->c_cflag & CLOCAL)
898 do_clocal = 1;
900 /*
901 * Block waiting for the carrier detect and the line to become free. While we are in
902 * this loop, info->count is dropped by one, so that rp_close() knows when to free things.
903 * We restore it upon exit, either normal or abnormal.
904 */
905 retval = 0;
906 add_wait_queue(&info->open_wait, &wait);
907 #ifdef ROCKET_DEBUG_OPEN
908 printk(KERN_INFO "block_til_ready before block: ttyR%d, count = %d\n", info->line, info->count);
909 #endif
910 spin_lock_irqsave(&info->slock, flags);
912 #ifdef ROCKET_DISABLE_SIMUSAGE
913 info->flags |= ROCKET_NORMAL_ACTIVE;
914 #else
915 if (!tty_hung_up_p(filp)) {
916 extra_count = 1;
917 info->count--;
918 }
919 #endif
920 info->blocked_open++;
922 spin_unlock_irqrestore(&info->slock, flags);
924 while (1) {
925 if (tty->termios->c_cflag & CBAUD) {
926 sSetDTR(&info->channel);
927 sSetRTS(&info->channel);
928 }
929 set_current_state(TASK_INTERRUPTIBLE);
930 if (tty_hung_up_p(filp) || !(info->flags & ROCKET_INITIALIZED)) {
931 if (info->flags & ROCKET_HUP_NOTIFY)
932 retval = -EAGAIN;
933 else
934 retval = -ERESTARTSYS;
935 break;
936 }
937 if (!(info->flags & ROCKET_CLOSING) && (do_clocal || (sGetChanStatusLo(&info->channel) & CD_ACT)))
938 break;
939 if (signal_pending(current)) {
940 retval = -ERESTARTSYS;
941 break;
942 }
943 #ifdef ROCKET_DEBUG_OPEN
944 printk(KERN_INFO "block_til_ready blocking: ttyR%d, count = %d, flags=0x%0x\n",
945 info->line, info->count, info->flags);
946 #endif
947 schedule(); /* Don't hold spinlock here, will hang PC */
948 }
949 current->state = TASK_RUNNING;
950 remove_wait_queue(&info->open_wait, &wait);
952 spin_lock_irqsave(&info->slock, flags);
954 if (extra_count)
955 info->count++;
956 info->blocked_open--;
958 spin_unlock_irqrestore(&info->slock, flags);
960 #ifdef ROCKET_DEBUG_OPEN
961 printk(KERN_INFO "block_til_ready after blocking: ttyR%d, count = %d\n",
962 info->line, info->count);
963 #endif
964 if (retval)
965 return retval;
966 info->flags |= ROCKET_NORMAL_ACTIVE;
967 return 0;
968 }
970 /*
971 * Exception handler that opens a serial port. Creates xmit_buf storage, fills in
972 * port's r_port struct. Initializes the port hardware.
973 */
974 static int rp_open(struct tty_struct *tty, struct file *filp)
975 {
976 struct r_port *info;
977 int line = 0, retval;
978 CHANNEL_t *cp;
979 unsigned long page;
981 line = TTY_GET_LINE(tty);
982 if ((line < 0) || (line >= MAX_RP_PORTS) || ((info = rp_table[line]) == NULL))
983 return -ENXIO;
985 page = __get_free_page(GFP_KERNEL);
986 if (!page)
987 return -ENOMEM;
989 if (info->flags & ROCKET_CLOSING) {
990 interruptible_sleep_on(&info->close_wait);
991 free_page(page);
992 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
993 }
995 /*
996 * We must not sleep from here until the port is marked fully in use.
997 */
998 if (info->xmit_buf)
999 free_page(page);
1000 else
1001 info->xmit_buf = (unsigned char *) page;
1003 tty->driver_data = info;
1004 info->tty = tty;
1006 if (info->count++ == 0) {
1007 atomic_inc(&rp_num_ports_open);
1009 #ifdef ROCKET_DEBUG_OPEN
1010 printk(KERN_INFO "rocket mod++ = %d...", atomic_read(&rp_num_ports_open));
1011 #endif
1013 #ifdef ROCKET_DEBUG_OPEN
1014 printk(KERN_INFO "rp_open ttyR%d, count=%d\n", info->line, info->count);
1015 #endif
1017 /*
1018 * Info->count is now 1; so it's safe to sleep now.
1019 */
1020 info->session = current->signal->session;
1021 info->pgrp = process_group(current);
1023 if ((info->flags & ROCKET_INITIALIZED) == 0) {
1024 cp = &info->channel;
1025 sSetRxTrigger(cp, TRIG_1);
1026 if (sGetChanStatus(cp) & CD_ACT)
1027 info->cd_status = 1;
1028 else
1029 info->cd_status = 0;
1030 sDisRxStatusMode(cp);
1031 sFlushRxFIFO(cp);
1032 sFlushTxFIFO(cp);
1034 sEnInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1035 sSetRxTrigger(cp, TRIG_1);
1037 sGetChanStatus(cp);
1038 sDisRxStatusMode(cp);
1039 sClrTxXOFF(cp);
1041 sDisCTSFlowCtl(cp);
1042 sDisTxSoftFlowCtl(cp);
1044 sEnRxFIFO(cp);
1045 sEnTransmit(cp);
1047 info->flags |= ROCKET_INITIALIZED;
1049 /*
1050 * Set up the tty->alt_speed kludge
1051 */
1052 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_HI)
1053 info->tty->alt_speed = 57600;
1054 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_VHI)
1055 info->tty->alt_speed = 115200;
1056 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_SHI)
1057 info->tty->alt_speed = 230400;
1058 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_WARP)
1059 info->tty->alt_speed = 460800;
1061 configure_r_port(info, NULL);
1062 if (tty->termios->c_cflag & CBAUD) {
1063 sSetDTR(cp);
1064 sSetRTS(cp);
1067 /* Starts (or resets) the maint polling loop */
1068 mod_timer(&rocket_timer, jiffies + POLL_PERIOD);
1070 retval = block_til_ready(tty, filp, info);
1071 if (retval) {
1072 #ifdef ROCKET_DEBUG_OPEN
1073 printk(KERN_INFO "rp_open returning after block_til_ready with %d\n", retval);
1074 #endif
1075 return retval;
1077 return 0;
1080 /*
1081 * Exception handler that closes a serial port. info->count is considered critical.
1082 */
1083 static void rp_close(struct tty_struct *tty, struct file *filp)
1085 struct r_port *info = (struct r_port *) tty->driver_data;
1086 unsigned long flags;
1087 int timeout;
1088 CHANNEL_t *cp;
1090 if (rocket_paranoia_check(info, "rp_close"))
1091 return;
1093 #ifdef ROCKET_DEBUG_OPEN
1094 printk(KERN_INFO "rp_close ttyR%d, count = %d\n", info->line, info->count);
1095 #endif
1097 if (tty_hung_up_p(filp))
1098 return;
1099 spin_lock_irqsave(&info->slock, flags);
1101 if ((tty->count == 1) && (info->count != 1)) {
1102 /*
1103 * Uh, oh. tty->count is 1, which means that the tty
1104 * structure will be freed. Info->count should always
1105 * be one in these conditions. If it's greater than
1106 * one, we've got real problems, since it means the
1107 * serial port won't be shutdown.
1108 */
1109 printk(KERN_INFO "rp_close: bad serial port count; tty->count is 1, "
1110 "info->count is %d\n", info->count);
1111 info->count = 1;
1113 if (--info->count < 0) {
1114 printk(KERN_INFO "rp_close: bad serial port count for ttyR%d: %d\n",
1115 info->line, info->count);
1116 info->count = 0;
1118 if (info->count) {
1119 spin_unlock_irqrestore(&info->slock, flags);
1120 return;
1122 info->flags |= ROCKET_CLOSING;
1123 spin_unlock_irqrestore(&info->slock, flags);
1125 cp = &info->channel;
1127 /*
1128 * Notify the line discpline to only process XON/XOFF characters
1129 */
1130 tty->closing = 1;
1132 /*
1133 * If transmission was throttled by the application request,
1134 * just flush the xmit buffer.
1135 */
1136 if (tty->flow_stopped)
1137 rp_flush_buffer(tty);
1139 /*
1140 * Wait for the transmit buffer to clear
1141 */
1142 if (info->closing_wait != ROCKET_CLOSING_WAIT_NONE)
1143 tty_wait_until_sent(tty, info->closing_wait);
1144 /*
1145 * Before we drop DTR, make sure the UART transmitter
1146 * has completely drained; this is especially
1147 * important if there is a transmit FIFO!
1148 */
1149 timeout = (sGetTxCnt(cp) + 1) * HZ / info->cps;
1150 if (timeout == 0)
1151 timeout = 1;
1152 rp_wait_until_sent(tty, timeout);
1153 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1155 sDisTransmit(cp);
1156 sDisInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1157 sDisCTSFlowCtl(cp);
1158 sDisTxSoftFlowCtl(cp);
1159 sClrTxXOFF(cp);
1160 sFlushRxFIFO(cp);
1161 sFlushTxFIFO(cp);
1162 sClrRTS(cp);
1163 if (C_HUPCL(tty))
1164 sClrDTR(cp);
1166 if (TTY_DRIVER_FLUSH_BUFFER_EXISTS(tty))
1167 TTY_DRIVER_FLUSH_BUFFER(tty);
1169 tty_ldisc_flush(tty);
1171 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1173 if (info->blocked_open) {
1174 if (info->close_delay) {
1175 msleep_interruptible(jiffies_to_msecs(info->close_delay));
1177 wake_up_interruptible(&info->open_wait);
1178 } else {
1179 if (info->xmit_buf) {
1180 free_page((unsigned long) info->xmit_buf);
1181 info->xmit_buf = NULL;
1184 info->flags &= ~(ROCKET_INITIALIZED | ROCKET_CLOSING | ROCKET_NORMAL_ACTIVE);
1185 tty->closing = 0;
1186 wake_up_interruptible(&info->close_wait);
1187 atomic_dec(&rp_num_ports_open);
1189 #ifdef ROCKET_DEBUG_OPEN
1190 printk(KERN_INFO "rocket mod-- = %d...", atomic_read(&rp_num_ports_open));
1191 printk(KERN_INFO "rp_close ttyR%d complete shutdown\n", info->line);
1192 #endif
1196 static void rp_set_termios(struct tty_struct *tty,
1197 struct termios *old_termios)
1199 struct r_port *info = (struct r_port *) tty->driver_data;
1200 CHANNEL_t *cp;
1201 unsigned cflag;
1203 if (rocket_paranoia_check(info, "rp_set_termios"))
1204 return;
1206 cflag = tty->termios->c_cflag;
1208 if (cflag == old_termios->c_cflag)
1209 return;
1211 /*
1212 * This driver doesn't support CS5 or CS6
1213 */
1214 if (((cflag & CSIZE) == CS5) || ((cflag & CSIZE) == CS6))
1215 tty->termios->c_cflag =
1216 ((cflag & ~CSIZE) | (old_termios->c_cflag & CSIZE));
1218 configure_r_port(info, old_termios);
1220 cp = &info->channel;
1222 /* Handle transition to B0 status */
1223 if ((old_termios->c_cflag & CBAUD) && !(tty->termios->c_cflag & CBAUD)) {
1224 sClrDTR(cp);
1225 sClrRTS(cp);
1228 /* Handle transition away from B0 status */
1229 if (!(old_termios->c_cflag & CBAUD) && (tty->termios->c_cflag & CBAUD)) {
1230 if (!tty->hw_stopped || !(tty->termios->c_cflag & CRTSCTS))
1231 sSetRTS(cp);
1232 sSetDTR(cp);
1235 if ((old_termios->c_cflag & CRTSCTS) && !(tty->termios->c_cflag & CRTSCTS)) {
1236 tty->hw_stopped = 0;
1237 rp_start(tty);
1241 static void rp_break(struct tty_struct *tty, int break_state)
1243 struct r_port *info = (struct r_port *) tty->driver_data;
1244 unsigned long flags;
1246 if (rocket_paranoia_check(info, "rp_break"))
1247 return;
1249 spin_lock_irqsave(&info->slock, flags);
1250 if (break_state == -1)
1251 sSendBreak(&info->channel);
1252 else
1253 sClrBreak(&info->channel);
1254 spin_unlock_irqrestore(&info->slock, flags);
1257 /*
1258 * sGetChanRI used to be a macro in rocket_int.h. When the functionality for
1259 * the UPCI boards was added, it was decided to make this a function because
1260 * the macro was getting too complicated. All cases except the first one
1261 * (UPCIRingInd) are taken directly from the original macro.
1262 */
1263 static int sGetChanRI(CHANNEL_T * ChP)
1265 CONTROLLER_t *CtlP = ChP->CtlP;
1266 int ChanNum = ChP->ChanNum;
1267 int RingInd = 0;
1269 if (CtlP->UPCIRingInd)
1270 RingInd = !(sInB(CtlP->UPCIRingInd) & sBitMapSetTbl[ChanNum]);
1271 else if (CtlP->AltChanRingIndicator)
1272 RingInd = sInB((ByteIO_t) (ChP->ChanStat + 8)) & DSR_ACT;
1273 else if (CtlP->boardType == ROCKET_TYPE_PC104)
1274 RingInd = !(sInB(CtlP->AiopIO[3]) & sBitMapSetTbl[ChanNum]);
1276 return RingInd;
1279 /********************************************************************************************/
1280 /* Here are the routines used by rp_ioctl. These are all called from exception handlers. */
1282 /*
1283 * Returns the state of the serial modem control lines. These next 2 functions
1284 * are the way kernel versions > 2.5 handle modem control lines rather than IOCTLs.
1285 */
1286 static int rp_tiocmget(struct tty_struct *tty, struct file *file)
1288 struct r_port *info = (struct r_port *)tty->driver_data;
1289 unsigned int control, result, ChanStatus;
1291 ChanStatus = sGetChanStatusLo(&info->channel);
1292 control = info->channel.TxControl[3];
1293 result = ((control & SET_RTS) ? TIOCM_RTS : 0) |
1294 ((control & SET_DTR) ? TIOCM_DTR : 0) |
1295 ((ChanStatus & CD_ACT) ? TIOCM_CAR : 0) |
1296 (sGetChanRI(&info->channel) ? TIOCM_RNG : 0) |
1297 ((ChanStatus & DSR_ACT) ? TIOCM_DSR : 0) |
1298 ((ChanStatus & CTS_ACT) ? TIOCM_CTS : 0);
1300 return result;
1303 /*
1304 * Sets the modem control lines
1305 */
1306 static int rp_tiocmset(struct tty_struct *tty, struct file *file,
1307 unsigned int set, unsigned int clear)
1309 struct r_port *info = (struct r_port *)tty->driver_data;
1311 if (set & TIOCM_RTS)
1312 info->channel.TxControl[3] |= SET_RTS;
1313 if (set & TIOCM_DTR)
1314 info->channel.TxControl[3] |= SET_DTR;
1315 if (clear & TIOCM_RTS)
1316 info->channel.TxControl[3] &= ~SET_RTS;
1317 if (clear & TIOCM_DTR)
1318 info->channel.TxControl[3] &= ~SET_DTR;
1320 sOutDW(info->channel.IndexAddr, *(DWord_t *) & (info->channel.TxControl[0]));
1321 return 0;
1324 static int get_config(struct r_port *info, struct rocket_config __user *retinfo)
1326 struct rocket_config tmp;
1328 if (!retinfo)
1329 return -EFAULT;
1330 memset(&tmp, 0, sizeof (tmp));
1331 tmp.line = info->line;
1332 tmp.flags = info->flags;
1333 tmp.close_delay = info->close_delay;
1334 tmp.closing_wait = info->closing_wait;
1335 tmp.port = rcktpt_io_addr[(info->line >> 5) & 3];
1337 if (copy_to_user(retinfo, &tmp, sizeof (*retinfo)))
1338 return -EFAULT;
1339 return 0;
1342 static int set_config(struct r_port *info, struct rocket_config __user *new_info)
1344 struct rocket_config new_serial;
1346 if (copy_from_user(&new_serial, new_info, sizeof (new_serial)))
1347 return -EFAULT;
1349 if (!capable(CAP_SYS_ADMIN))
1351 if ((new_serial.flags & ~ROCKET_USR_MASK) != (info->flags & ~ROCKET_USR_MASK))
1352 return -EPERM;
1353 info->flags = ((info->flags & ~ROCKET_USR_MASK) | (new_serial.flags & ROCKET_USR_MASK));
1354 configure_r_port(info, NULL);
1355 return 0;
1358 info->flags = ((info->flags & ~ROCKET_FLAGS) | (new_serial.flags & ROCKET_FLAGS));
1359 info->close_delay = new_serial.close_delay;
1360 info->closing_wait = new_serial.closing_wait;
1362 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_HI)
1363 info->tty->alt_speed = 57600;
1364 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_VHI)
1365 info->tty->alt_speed = 115200;
1366 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_SHI)
1367 info->tty->alt_speed = 230400;
1368 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_WARP)
1369 info->tty->alt_speed = 460800;
1371 configure_r_port(info, NULL);
1372 return 0;
1375 /*
1376 * This function fills in a rocket_ports struct with information
1377 * about what boards/ports are in the system. This info is passed
1378 * to user space. See setrocket.c where the info is used to create
1379 * the /dev/ttyRx ports.
1380 */
1381 static int get_ports(struct r_port *info, struct rocket_ports __user *retports)
1383 struct rocket_ports tmp;
1384 int board;
1386 if (!retports)
1387 return -EFAULT;
1388 memset(&tmp, 0, sizeof (tmp));
1389 tmp.tty_major = rocket_driver->major;
1391 for (board = 0; board < 4; board++) {
1392 tmp.rocketModel[board].model = rocketModel[board].model;
1393 strcpy(tmp.rocketModel[board].modelString, rocketModel[board].modelString);
1394 tmp.rocketModel[board].numPorts = rocketModel[board].numPorts;
1395 tmp.rocketModel[board].loadrm2 = rocketModel[board].loadrm2;
1396 tmp.rocketModel[board].startingPortNumber = rocketModel[board].startingPortNumber;
1398 if (copy_to_user(retports, &tmp, sizeof (*retports)))
1399 return -EFAULT;
1400 return 0;
1403 static int reset_rm2(struct r_port *info, void __user *arg)
1405 int reset;
1407 if (copy_from_user(&reset, arg, sizeof (int)))
1408 return -EFAULT;
1409 if (reset)
1410 reset = 1;
1412 if (rcktpt_type[info->board] != ROCKET_TYPE_MODEMII &&
1413 rcktpt_type[info->board] != ROCKET_TYPE_MODEMIII)
1414 return -EINVAL;
1416 if (info->ctlp->BusType == isISA)
1417 sModemReset(info->ctlp, info->chan, reset);
1418 else
1419 sPCIModemReset(info->ctlp, info->chan, reset);
1421 return 0;
1424 static int get_version(struct r_port *info, struct rocket_version __user *retvers)
1426 if (copy_to_user(retvers, &driver_version, sizeof (*retvers)))
1427 return -EFAULT;
1428 return 0;
1431 /* IOCTL call handler into the driver */
1432 static int rp_ioctl(struct tty_struct *tty, struct file *file,
1433 unsigned int cmd, unsigned long arg)
1435 struct r_port *info = (struct r_port *) tty->driver_data;
1436 void __user *argp = (void __user *)arg;
1438 if (cmd != RCKP_GET_PORTS && rocket_paranoia_check(info, "rp_ioctl"))
1439 return -ENXIO;
1441 switch (cmd) {
1442 case RCKP_GET_STRUCT:
1443 if (copy_to_user(argp, info, sizeof (struct r_port)))
1444 return -EFAULT;
1445 return 0;
1446 case RCKP_GET_CONFIG:
1447 return get_config(info, argp);
1448 case RCKP_SET_CONFIG:
1449 return set_config(info, argp);
1450 case RCKP_GET_PORTS:
1451 return get_ports(info, argp);
1452 case RCKP_RESET_RM2:
1453 return reset_rm2(info, argp);
1454 case RCKP_GET_VERSION:
1455 return get_version(info, argp);
1456 default:
1457 return -ENOIOCTLCMD;
1459 return 0;
1462 static void rp_send_xchar(struct tty_struct *tty, char ch)
1464 struct r_port *info = (struct r_port *) tty->driver_data;
1465 CHANNEL_t *cp;
1467 if (rocket_paranoia_check(info, "rp_send_xchar"))
1468 return;
1470 cp = &info->channel;
1471 if (sGetTxCnt(cp))
1472 sWriteTxPrioByte(cp, ch);
1473 else
1474 sWriteTxByte(sGetTxRxDataIO(cp), ch);
1477 static void rp_throttle(struct tty_struct *tty)
1479 struct r_port *info = (struct r_port *) tty->driver_data;
1480 CHANNEL_t *cp;
1482 #ifdef ROCKET_DEBUG_THROTTLE
1483 printk(KERN_INFO "throttle %s: %d....\n", tty->name,
1484 tty->ldisc.chars_in_buffer(tty));
1485 #endif
1487 if (rocket_paranoia_check(info, "rp_throttle"))
1488 return;
1490 cp = &info->channel;
1491 if (I_IXOFF(tty))
1492 rp_send_xchar(tty, STOP_CHAR(tty));
1494 sClrRTS(&info->channel);
1497 static void rp_unthrottle(struct tty_struct *tty)
1499 struct r_port *info = (struct r_port *) tty->driver_data;
1500 CHANNEL_t *cp;
1501 #ifdef ROCKET_DEBUG_THROTTLE
1502 printk(KERN_INFO "unthrottle %s: %d....\n", tty->name,
1503 tty->ldisc.chars_in_buffer(tty));
1504 #endif
1506 if (rocket_paranoia_check(info, "rp_throttle"))
1507 return;
1509 cp = &info->channel;
1510 if (I_IXOFF(tty))
1511 rp_send_xchar(tty, START_CHAR(tty));
1513 sSetRTS(&info->channel);
1516 /*
1517 * ------------------------------------------------------------
1518 * rp_stop() and rp_start()
1520 * This routines are called before setting or resetting tty->stopped.
1521 * They enable or disable transmitter interrupts, as necessary.
1522 * ------------------------------------------------------------
1523 */
1524 static void rp_stop(struct tty_struct *tty)
1526 struct r_port *info = (struct r_port *) tty->driver_data;
1528 #ifdef ROCKET_DEBUG_FLOW
1529 printk(KERN_INFO "stop %s: %d %d....\n", tty->name,
1530 info->xmit_cnt, info->xmit_fifo_room);
1531 #endif
1533 if (rocket_paranoia_check(info, "rp_stop"))
1534 return;
1536 if (sGetTxCnt(&info->channel))
1537 sDisTransmit(&info->channel);
1540 static void rp_start(struct tty_struct *tty)
1542 struct r_port *info = (struct r_port *) tty->driver_data;
1544 #ifdef ROCKET_DEBUG_FLOW
1545 printk(KERN_INFO "start %s: %d %d....\n", tty->name,
1546 info->xmit_cnt, info->xmit_fifo_room);
1547 #endif
1549 if (rocket_paranoia_check(info, "rp_stop"))
1550 return;
1552 sEnTransmit(&info->channel);
1553 set_bit((info->aiop * 8) + info->chan,
1554 (void *) &xmit_flags[info->board]);
1557 /*
1558 * rp_wait_until_sent() --- wait until the transmitter is empty
1559 */
1560 static void rp_wait_until_sent(struct tty_struct *tty, int timeout)
1562 struct r_port *info = (struct r_port *) tty->driver_data;
1563 CHANNEL_t *cp;
1564 unsigned long orig_jiffies;
1565 int check_time, exit_time;
1566 int txcnt;
1568 if (rocket_paranoia_check(info, "rp_wait_until_sent"))
1569 return;
1571 cp = &info->channel;
1573 orig_jiffies = jiffies;
1574 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1575 printk(KERN_INFO "In RP_wait_until_sent(%d) (jiff=%lu)...", timeout,
1576 jiffies);
1577 printk(KERN_INFO "cps=%d...", info->cps);
1578 #endif
1579 while (1) {
1580 txcnt = sGetTxCnt(cp);
1581 if (!txcnt) {
1582 if (sGetChanStatusLo(cp) & TXSHRMT)
1583 break;
1584 check_time = (HZ / info->cps) / 5;
1585 } else {
1586 check_time = HZ * txcnt / info->cps;
1588 if (timeout) {
1589 exit_time = orig_jiffies + timeout - jiffies;
1590 if (exit_time <= 0)
1591 break;
1592 if (exit_time < check_time)
1593 check_time = exit_time;
1595 if (check_time == 0)
1596 check_time = 1;
1597 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1598 printk(KERN_INFO "txcnt = %d (jiff=%lu,check=%d)...", txcnt, jiffies, check_time);
1599 #endif
1600 msleep_interruptible(jiffies_to_msecs(check_time));
1601 if (signal_pending(current))
1602 break;
1604 current->state = TASK_RUNNING;
1605 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1606 printk(KERN_INFO "txcnt = %d (jiff=%lu)...done\n", txcnt, jiffies);
1607 #endif
1610 /*
1611 * rp_hangup() --- called by tty_hangup() when a hangup is signaled.
1612 */
1613 static void rp_hangup(struct tty_struct *tty)
1615 CHANNEL_t *cp;
1616 struct r_port *info = (struct r_port *) tty->driver_data;
1618 if (rocket_paranoia_check(info, "rp_hangup"))
1619 return;
1621 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_HANGUP))
1622 printk(KERN_INFO "rp_hangup of ttyR%d...", info->line);
1623 #endif
1624 rp_flush_buffer(tty);
1625 if (info->flags & ROCKET_CLOSING)
1626 return;
1627 if (info->count)
1628 atomic_dec(&rp_num_ports_open);
1629 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1631 info->count = 0;
1632 info->flags &= ~ROCKET_NORMAL_ACTIVE;
1633 info->tty = NULL;
1635 cp = &info->channel;
1636 sDisRxFIFO(cp);
1637 sDisTransmit(cp);
1638 sDisInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1639 sDisCTSFlowCtl(cp);
1640 sDisTxSoftFlowCtl(cp);
1641 sClrTxXOFF(cp);
1642 info->flags &= ~ROCKET_INITIALIZED;
1644 wake_up_interruptible(&info->open_wait);
1647 /*
1648 * Exception handler - write char routine. The RocketPort driver uses a
1649 * double-buffering strategy, with the twist that if the in-memory CPU
1650 * buffer is empty, and there's space in the transmit FIFO, the
1651 * writing routines will write directly to transmit FIFO.
1652 * Write buffer and counters protected by spinlocks
1653 */
1654 static void rp_put_char(struct tty_struct *tty, unsigned char ch)
1656 struct r_port *info = (struct r_port *) tty->driver_data;
1657 CHANNEL_t *cp;
1658 unsigned long flags;
1660 if (rocket_paranoia_check(info, "rp_put_char"))
1661 return;
1663 /* Grab the port write semaphore, locking out other processes that try to write to this port */
1664 down(&info->write_sem);
1666 #ifdef ROCKET_DEBUG_WRITE
1667 printk(KERN_INFO "rp_put_char %c...", ch);
1668 #endif
1670 spin_lock_irqsave(&info->slock, flags);
1671 cp = &info->channel;
1673 if (!tty->stopped && !tty->hw_stopped && info->xmit_fifo_room == 0)
1674 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1676 if (tty->stopped || tty->hw_stopped || info->xmit_fifo_room == 0 || info->xmit_cnt != 0) {
1677 info->xmit_buf[info->xmit_head++] = ch;
1678 info->xmit_head &= XMIT_BUF_SIZE - 1;
1679 info->xmit_cnt++;
1680 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1681 } else {
1682 sOutB(sGetTxRxDataIO(cp), ch);
1683 info->xmit_fifo_room--;
1685 spin_unlock_irqrestore(&info->slock, flags);
1686 up(&info->write_sem);
1689 /*
1690 * Exception handler - write routine, called when user app writes to the device.
1691 * A per port write semaphore is used to protect from another process writing to
1692 * this port at the same time. This other process could be running on the other CPU
1693 * or get control of the CPU if the copy_from_user() blocks due to a page fault (swapped out).
1694 * Spinlocks protect the info xmit members.
1695 */
1696 static int rp_write(struct tty_struct *tty,
1697 const unsigned char *buf, int count)
1699 struct r_port *info = (struct r_port *) tty->driver_data;
1700 CHANNEL_t *cp;
1701 const unsigned char *b;
1702 int c, retval = 0;
1703 unsigned long flags;
1705 if (count <= 0 || rocket_paranoia_check(info, "rp_write"))
1706 return 0;
1708 down_interruptible(&info->write_sem);
1710 #ifdef ROCKET_DEBUG_WRITE
1711 printk(KERN_INFO "rp_write %d chars...", count);
1712 #endif
1713 cp = &info->channel;
1715 if (!tty->stopped && !tty->hw_stopped && info->xmit_fifo_room < count)
1716 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1718 /*
1719 * If the write queue for the port is empty, and there is FIFO space, stuff bytes
1720 * into FIFO. Use the write queue for temp storage.
1721 */
1722 if (!tty->stopped && !tty->hw_stopped && info->xmit_cnt == 0 && info->xmit_fifo_room > 0) {
1723 c = min(count, info->xmit_fifo_room);
1724 b = buf;
1726 /* Push data into FIFO, 2 bytes at a time */
1727 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) b, c / 2);
1729 /* If there is a byte remaining, write it */
1730 if (c & 1)
1731 sOutB(sGetTxRxDataIO(cp), b[c - 1]);
1733 retval += c;
1734 buf += c;
1735 count -= c;
1737 spin_lock_irqsave(&info->slock, flags);
1738 info->xmit_fifo_room -= c;
1739 spin_unlock_irqrestore(&info->slock, flags);
1742 /* If count is zero, we wrote it all and are done */
1743 if (!count)
1744 goto end;
1746 /* Write remaining data into the port's xmit_buf */
1747 while (1) {
1748 if (info->tty == 0) /* Seemingly obligatory check... */
1749 goto end;
1751 c = min(count, min(XMIT_BUF_SIZE - info->xmit_cnt - 1, XMIT_BUF_SIZE - info->xmit_head));
1752 if (c <= 0)
1753 break;
1755 b = buf;
1756 memcpy(info->xmit_buf + info->xmit_head, b, c);
1758 spin_lock_irqsave(&info->slock, flags);
1759 info->xmit_head =
1760 (info->xmit_head + c) & (XMIT_BUF_SIZE - 1);
1761 info->xmit_cnt += c;
1762 spin_unlock_irqrestore(&info->slock, flags);
1764 buf += c;
1765 count -= c;
1766 retval += c;
1769 if ((retval > 0) && !tty->stopped && !tty->hw_stopped)
1770 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1772 end:
1773 if (info->xmit_cnt < WAKEUP_CHARS) {
1774 tty_wakeup(tty);
1775 wake_up_interruptible(&tty->write_wait);
1776 #ifdef ROCKETPORT_HAVE_POLL_WAIT
1777 wake_up_interruptible(&tty->poll_wait);
1778 #endif
1780 up(&info->write_sem);
1781 return retval;
1784 /*
1785 * Return the number of characters that can be sent. We estimate
1786 * only using the in-memory transmit buffer only, and ignore the
1787 * potential space in the transmit FIFO.
1788 */
1789 static int rp_write_room(struct tty_struct *tty)
1791 struct r_port *info = (struct r_port *) tty->driver_data;
1792 int ret;
1794 if (rocket_paranoia_check(info, "rp_write_room"))
1795 return 0;
1797 ret = XMIT_BUF_SIZE - info->xmit_cnt - 1;
1798 if (ret < 0)
1799 ret = 0;
1800 #ifdef ROCKET_DEBUG_WRITE
1801 printk(KERN_INFO "rp_write_room returns %d...", ret);
1802 #endif
1803 return ret;
1806 /*
1807 * Return the number of characters in the buffer. Again, this only
1808 * counts those characters in the in-memory transmit buffer.
1809 */
1810 static int rp_chars_in_buffer(struct tty_struct *tty)
1812 struct r_port *info = (struct r_port *) tty->driver_data;
1813 CHANNEL_t *cp;
1815 if (rocket_paranoia_check(info, "rp_chars_in_buffer"))
1816 return 0;
1818 cp = &info->channel;
1820 #ifdef ROCKET_DEBUG_WRITE
1821 printk(KERN_INFO "rp_chars_in_buffer returns %d...", info->xmit_cnt);
1822 #endif
1823 return info->xmit_cnt;
1826 /*
1827 * Flushes the TX fifo for a port, deletes data in the xmit_buf stored in the
1828 * r_port struct for the port. Note that spinlock are used to protect info members,
1829 * do not call this function if the spinlock is already held.
1830 */
1831 static void rp_flush_buffer(struct tty_struct *tty)
1833 struct r_port *info = (struct r_port *) tty->driver_data;
1834 CHANNEL_t *cp;
1835 unsigned long flags;
1837 if (rocket_paranoia_check(info, "rp_flush_buffer"))
1838 return;
1840 spin_lock_irqsave(&info->slock, flags);
1841 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1842 spin_unlock_irqrestore(&info->slock, flags);
1844 wake_up_interruptible(&tty->write_wait);
1845 #ifdef ROCKETPORT_HAVE_POLL_WAIT
1846 wake_up_interruptible(&tty->poll_wait);
1847 #endif
1848 tty_wakeup(tty);
1850 cp = &info->channel;
1851 sFlushTxFIFO(cp);
1854 #ifdef CONFIG_PCI
1856 /*
1857 * Called when a PCI card is found. Retrieves and stores model information,
1858 * init's aiopic and serial port hardware.
1859 * Inputs: i is the board number (0-n)
1860 */
1861 static __init int register_PCI(int i, struct pci_dev *dev)
1863 int num_aiops, aiop, max_num_aiops, num_chan, chan;
1864 unsigned int aiopio[MAX_AIOPS_PER_BOARD];
1865 char *str, *board_type;
1866 CONTROLLER_t *ctlp;
1868 int fast_clock = 0;
1869 int altChanRingIndicator = 0;
1870 int ports_per_aiop = 8;
1871 int ret;
1872 unsigned int class_rev;
1873 WordIO_t ConfigIO = 0;
1874 ByteIO_t UPCIRingInd = 0;
1876 if (!dev || pci_enable_device(dev))
1877 return 0;
1879 rcktpt_io_addr[i] = pci_resource_start(dev, 0);
1880 ret = pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
1882 if (ret) {
1883 printk(KERN_INFO " Error during register_PCI(), unable to read config dword \n");
1884 return 0;
1887 rcktpt_type[i] = ROCKET_TYPE_NORMAL;
1888 rocketModel[i].loadrm2 = 0;
1889 rocketModel[i].startingPortNumber = nextLineNumber;
1891 /* Depending on the model, set up some config variables */
1892 switch (dev->device) {
1893 case PCI_DEVICE_ID_RP4QUAD:
1894 str = "Quadcable";
1895 max_num_aiops = 1;
1896 ports_per_aiop = 4;
1897 rocketModel[i].model = MODEL_RP4QUAD;
1898 strcpy(rocketModel[i].modelString, "RocketPort 4 port w/quad cable");
1899 rocketModel[i].numPorts = 4;
1900 break;
1901 case PCI_DEVICE_ID_RP8OCTA:
1902 str = "Octacable";
1903 max_num_aiops = 1;
1904 rocketModel[i].model = MODEL_RP8OCTA;
1905 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/octa cable");
1906 rocketModel[i].numPorts = 8;
1907 break;
1908 case PCI_DEVICE_ID_URP8OCTA:
1909 str = "Octacable";
1910 max_num_aiops = 1;
1911 rocketModel[i].model = MODEL_UPCI_RP8OCTA;
1912 strcpy(rocketModel[i].modelString, "RocketPort UPCI 8 port w/octa cable");
1913 rocketModel[i].numPorts = 8;
1914 break;
1915 case PCI_DEVICE_ID_RP8INTF:
1916 str = "8";
1917 max_num_aiops = 1;
1918 rocketModel[i].model = MODEL_RP8INTF;
1919 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/external I/F");
1920 rocketModel[i].numPorts = 8;
1921 break;
1922 case PCI_DEVICE_ID_URP8INTF:
1923 str = "8";
1924 max_num_aiops = 1;
1925 rocketModel[i].model = MODEL_UPCI_RP8INTF;
1926 strcpy(rocketModel[i].modelString, "RocketPort UPCI 8 port w/external I/F");
1927 rocketModel[i].numPorts = 8;
1928 break;
1929 case PCI_DEVICE_ID_RP8J:
1930 str = "8J";
1931 max_num_aiops = 1;
1932 rocketModel[i].model = MODEL_RP8J;
1933 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/RJ11 connectors");
1934 rocketModel[i].numPorts = 8;
1935 break;
1936 case PCI_DEVICE_ID_RP4J:
1937 str = "4J";
1938 max_num_aiops = 1;
1939 ports_per_aiop = 4;
1940 rocketModel[i].model = MODEL_RP4J;
1941 strcpy(rocketModel[i].modelString, "RocketPort 4 port w/RJ45 connectors");
1942 rocketModel[i].numPorts = 4;
1943 break;
1944 case PCI_DEVICE_ID_RP8SNI:
1945 str = "8 (DB78 Custom)";
1946 max_num_aiops = 1;
1947 rocketModel[i].model = MODEL_RP8SNI;
1948 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/ custom DB78");
1949 rocketModel[i].numPorts = 8;
1950 break;
1951 case PCI_DEVICE_ID_RP16SNI:
1952 str = "16 (DB78 Custom)";
1953 max_num_aiops = 2;
1954 rocketModel[i].model = MODEL_RP16SNI;
1955 strcpy(rocketModel[i].modelString, "RocketPort 16 port w/ custom DB78");
1956 rocketModel[i].numPorts = 16;
1957 break;
1958 case PCI_DEVICE_ID_RP16INTF:
1959 str = "16";
1960 max_num_aiops = 2;
1961 rocketModel[i].model = MODEL_RP16INTF;
1962 strcpy(rocketModel[i].modelString, "RocketPort 16 port w/external I/F");
1963 rocketModel[i].numPorts = 16;
1964 break;
1965 case PCI_DEVICE_ID_URP16INTF:
1966 str = "16";
1967 max_num_aiops = 2;
1968 rocketModel[i].model = MODEL_UPCI_RP16INTF;
1969 strcpy(rocketModel[i].modelString, "RocketPort UPCI 16 port w/external I/F");
1970 rocketModel[i].numPorts = 16;
1971 break;
1972 case PCI_DEVICE_ID_CRP16INTF:
1973 str = "16";
1974 max_num_aiops = 2;
1975 rocketModel[i].model = MODEL_CPCI_RP16INTF;
1976 strcpy(rocketModel[i].modelString, "RocketPort Compact PCI 16 port w/external I/F");
1977 rocketModel[i].numPorts = 16;
1978 break;
1979 case PCI_DEVICE_ID_RP32INTF:
1980 str = "32";
1981 max_num_aiops = 4;
1982 rocketModel[i].model = MODEL_RP32INTF;
1983 strcpy(rocketModel[i].modelString, "RocketPort 32 port w/external I/F");
1984 rocketModel[i].numPorts = 32;
1985 break;
1986 case PCI_DEVICE_ID_URP32INTF:
1987 str = "32";
1988 max_num_aiops = 4;
1989 rocketModel[i].model = MODEL_UPCI_RP32INTF;
1990 strcpy(rocketModel[i].modelString, "RocketPort UPCI 32 port w/external I/F");
1991 rocketModel[i].numPorts = 32;
1992 break;
1993 case PCI_DEVICE_ID_RPP4:
1994 str = "Plus Quadcable";
1995 max_num_aiops = 1;
1996 ports_per_aiop = 4;
1997 altChanRingIndicator++;
1998 fast_clock++;
1999 rocketModel[i].model = MODEL_RPP4;
2000 strcpy(rocketModel[i].modelString, "RocketPort Plus 4 port");
2001 rocketModel[i].numPorts = 4;
2002 break;
2003 case PCI_DEVICE_ID_RPP8:
2004 str = "Plus Octacable";
2005 max_num_aiops = 2;
2006 ports_per_aiop = 4;
2007 altChanRingIndicator++;
2008 fast_clock++;
2009 rocketModel[i].model = MODEL_RPP8;
2010 strcpy(rocketModel[i].modelString, "RocketPort Plus 8 port");
2011 rocketModel[i].numPorts = 8;
2012 break;
2013 case PCI_DEVICE_ID_RP2_232:
2014 str = "Plus 2 (RS-232)";
2015 max_num_aiops = 1;
2016 ports_per_aiop = 2;
2017 altChanRingIndicator++;
2018 fast_clock++;
2019 rocketModel[i].model = MODEL_RP2_232;
2020 strcpy(rocketModel[i].modelString, "RocketPort Plus 2 port RS232");
2021 rocketModel[i].numPorts = 2;
2022 break;
2023 case PCI_DEVICE_ID_RP2_422:
2024 str = "Plus 2 (RS-422)";
2025 max_num_aiops = 1;
2026 ports_per_aiop = 2;
2027 altChanRingIndicator++;
2028 fast_clock++;
2029 rocketModel[i].model = MODEL_RP2_422;
2030 strcpy(rocketModel[i].modelString, "RocketPort Plus 2 port RS422");
2031 rocketModel[i].numPorts = 2;
2032 break;
2033 case PCI_DEVICE_ID_RP6M:
2035 max_num_aiops = 1;
2036 ports_per_aiop = 6;
2037 str = "6-port";
2039 /* If class_rev is 1, the rocketmodem flash must be loaded. If it is 2 it is a "socketed" version. */
2040 if ((class_rev & 0xFF) == 1) {
2041 rcktpt_type[i] = ROCKET_TYPE_MODEMII;
2042 rocketModel[i].loadrm2 = 1;
2043 } else {
2044 rcktpt_type[i] = ROCKET_TYPE_MODEM;
2047 rocketModel[i].model = MODEL_RP6M;
2048 strcpy(rocketModel[i].modelString, "RocketModem 6 port");
2049 rocketModel[i].numPorts = 6;
2050 break;
2051 case PCI_DEVICE_ID_RP4M:
2052 max_num_aiops = 1;
2053 ports_per_aiop = 4;
2054 str = "4-port";
2055 if ((class_rev & 0xFF) == 1) {
2056 rcktpt_type[i] = ROCKET_TYPE_MODEMII;
2057 rocketModel[i].loadrm2 = 1;
2058 } else {
2059 rcktpt_type[i] = ROCKET_TYPE_MODEM;
2062 rocketModel[i].model = MODEL_RP4M;
2063 strcpy(rocketModel[i].modelString, "RocketModem 4 port");
2064 rocketModel[i].numPorts = 4;
2065 break;
2066 default:
2067 str = "(unknown/unsupported)";
2068 max_num_aiops = 0;
2069 break;
2072 /*
2073 * Check for UPCI boards.
2074 */
2076 switch (dev->device) {
2077 case PCI_DEVICE_ID_URP32INTF:
2078 case PCI_DEVICE_ID_URP8INTF:
2079 case PCI_DEVICE_ID_URP16INTF:
2080 case PCI_DEVICE_ID_CRP16INTF:
2081 case PCI_DEVICE_ID_URP8OCTA:
2082 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2083 ConfigIO = pci_resource_start(dev, 1);
2084 if (dev->device == PCI_DEVICE_ID_URP8OCTA) {
2085 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2087 /*
2088 * Check for octa or quad cable.
2089 */
2090 if (!
2091 (sInW(ConfigIO + _PCI_9030_GPIO_CTRL) &
2092 PCI_GPIO_CTRL_8PORT)) {
2093 str = "Quadcable";
2094 ports_per_aiop = 4;
2095 rocketModel[i].numPorts = 4;
2098 break;
2099 case PCI_DEVICE_ID_UPCI_RM3_8PORT:
2100 str = "8 ports";
2101 max_num_aiops = 1;
2102 rocketModel[i].model = MODEL_UPCI_RM3_8PORT;
2103 strcpy(rocketModel[i].modelString, "RocketModem III 8 port");
2104 rocketModel[i].numPorts = 8;
2105 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2106 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2107 ConfigIO = pci_resource_start(dev, 1);
2108 rcktpt_type[i] = ROCKET_TYPE_MODEMIII;
2109 break;
2110 case PCI_DEVICE_ID_UPCI_RM3_4PORT:
2111 str = "4 ports";
2112 max_num_aiops = 1;
2113 rocketModel[i].model = MODEL_UPCI_RM3_4PORT;
2114 strcpy(rocketModel[i].modelString, "RocketModem III 4 port");
2115 rocketModel[i].numPorts = 4;
2116 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2117 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2118 ConfigIO = pci_resource_start(dev, 1);
2119 rcktpt_type[i] = ROCKET_TYPE_MODEMIII;
2120 break;
2121 default:
2122 break;
2125 switch (rcktpt_type[i]) {
2126 case ROCKET_TYPE_MODEM:
2127 board_type = "RocketModem";
2128 break;
2129 case ROCKET_TYPE_MODEMII:
2130 board_type = "RocketModem II";
2131 break;
2132 case ROCKET_TYPE_MODEMIII:
2133 board_type = "RocketModem III";
2134 break;
2135 default:
2136 board_type = "RocketPort";
2137 break;
2140 if (fast_clock) {
2141 sClockPrescale = 0x12; /* mod 2 (divide by 3) */
2142 rp_baud_base[i] = 921600;
2143 } else {
2144 /*
2145 * If support_low_speed is set, use the slow clock
2146 * prescale, which supports 50 bps
2147 */
2148 if (support_low_speed) {
2149 /* mod 9 (divide by 10) prescale */
2150 sClockPrescale = 0x19;
2151 rp_baud_base[i] = 230400;
2152 } else {
2153 /* mod 4 (devide by 5) prescale */
2154 sClockPrescale = 0x14;
2155 rp_baud_base[i] = 460800;
2159 for (aiop = 0; aiop < max_num_aiops; aiop++)
2160 aiopio[aiop] = rcktpt_io_addr[i] + (aiop * 0x40);
2161 ctlp = sCtlNumToCtlPtr(i);
2162 num_aiops = sPCIInitController(ctlp, i, aiopio, max_num_aiops, ConfigIO, 0, FREQ_DIS, 0, altChanRingIndicator, UPCIRingInd);
2163 for (aiop = 0; aiop < max_num_aiops; aiop++)
2164 ctlp->AiopNumChan[aiop] = ports_per_aiop;
2166 printk("Comtrol PCI controller #%d ID 0x%x found in bus:slot:fn %s at address %04lx, "
2167 "%d AIOP(s) (%s)\n", i, dev->device, pci_name(dev),
2168 rcktpt_io_addr[i], num_aiops, rocketModel[i].modelString);
2169 printk(KERN_INFO "Installing %s, creating /dev/ttyR%d - %ld\n",
2170 rocketModel[i].modelString,
2171 rocketModel[i].startingPortNumber,
2172 rocketModel[i].startingPortNumber +
2173 rocketModel[i].numPorts - 1);
2175 if (num_aiops <= 0) {
2176 rcktpt_io_addr[i] = 0;
2177 return (0);
2179 is_PCI[i] = 1;
2181 /* Reset the AIOPIC, init the serial ports */
2182 for (aiop = 0; aiop < num_aiops; aiop++) {
2183 sResetAiopByNum(ctlp, aiop);
2184 num_chan = ports_per_aiop;
2185 for (chan = 0; chan < num_chan; chan++)
2186 init_r_port(i, aiop, chan, dev);
2189 /* Rocket modems must be reset */
2190 if ((rcktpt_type[i] == ROCKET_TYPE_MODEM) ||
2191 (rcktpt_type[i] == ROCKET_TYPE_MODEMII) ||
2192 (rcktpt_type[i] == ROCKET_TYPE_MODEMIII)) {
2193 num_chan = ports_per_aiop;
2194 for (chan = 0; chan < num_chan; chan++)
2195 sPCIModemReset(ctlp, chan, 1);
2196 mdelay(500);
2197 for (chan = 0; chan < num_chan; chan++)
2198 sPCIModemReset(ctlp, chan, 0);
2199 mdelay(500);
2200 rmSpeakerReset(ctlp, rocketModel[i].model);
2202 return (1);
2205 /*
2206 * Probes for PCI cards, inits them if found
2207 * Input: board_found = number of ISA boards already found, or the
2208 * starting board number
2209 * Returns: Number of PCI boards found
2210 */
2211 static int __init init_PCI(int boards_found)
2213 struct pci_dev *dev = NULL;
2214 int count = 0;
2216 /* Work through the PCI device list, pulling out ours */
2217 while ((dev = pci_find_device(PCI_VENDOR_ID_RP, PCI_ANY_ID, dev))) {
2218 if (register_PCI(count + boards_found, dev))
2219 count++;
2221 return (count);
2224 #endif /* CONFIG_PCI */
2226 /*
2227 * Probes for ISA cards
2228 * Input: i = the board number to look for
2229 * Returns: 1 if board found, 0 else
2230 */
2231 static int __init init_ISA(int i)
2233 int num_aiops, num_chan = 0, total_num_chan = 0;
2234 int aiop, chan;
2235 unsigned int aiopio[MAX_AIOPS_PER_BOARD];
2236 CONTROLLER_t *ctlp;
2237 char *type_string;
2239 /* If io_addr is zero, no board configured */
2240 if (rcktpt_io_addr[i] == 0)
2241 return (0);
2243 /* Reserve the IO region */
2244 if (!request_region(rcktpt_io_addr[i], 64, "Comtrol RocketPort")) {
2245 printk(KERN_INFO "Unable to reserve IO region for configured ISA RocketPort at address 0x%lx, board not installed...\n", rcktpt_io_addr[i]);
2246 rcktpt_io_addr[i] = 0;
2247 return (0);
2250 ctlp = sCtlNumToCtlPtr(i);
2252 ctlp->boardType = rcktpt_type[i];
2254 switch (rcktpt_type[i]) {
2255 case ROCKET_TYPE_PC104:
2256 type_string = "(PC104)";
2257 break;
2258 case ROCKET_TYPE_MODEM:
2259 type_string = "(RocketModem)";
2260 break;
2261 case ROCKET_TYPE_MODEMII:
2262 type_string = "(RocketModem II)";
2263 break;
2264 default:
2265 type_string = "";
2266 break;
2269 /*
2270 * If support_low_speed is set, use the slow clock prescale,
2271 * which supports 50 bps
2272 */
2273 if (support_low_speed) {
2274 sClockPrescale = 0x19; /* mod 9 (divide by 10) prescale */
2275 rp_baud_base[i] = 230400;
2276 } else {
2277 sClockPrescale = 0x14; /* mod 4 (devide by 5) prescale */
2278 rp_baud_base[i] = 460800;
2281 for (aiop = 0; aiop < MAX_AIOPS_PER_BOARD; aiop++)
2282 aiopio[aiop] = rcktpt_io_addr[i] + (aiop * 0x400);
2284 num_aiops = sInitController(ctlp, i, controller + (i * 0x400), aiopio, MAX_AIOPS_PER_BOARD, 0, FREQ_DIS, 0);
2286 if (ctlp->boardType == ROCKET_TYPE_PC104) {
2287 sEnAiop(ctlp, 2); /* only one AIOPIC, but these */
2288 sEnAiop(ctlp, 3); /* CSels used for other stuff */
2291 /* If something went wrong initing the AIOP's release the ISA IO memory */
2292 if (num_aiops <= 0) {
2293 release_region(rcktpt_io_addr[i], 64);
2294 rcktpt_io_addr[i] = 0;
2295 return (0);
2298 rocketModel[i].startingPortNumber = nextLineNumber;
2300 for (aiop = 0; aiop < num_aiops; aiop++) {
2301 sResetAiopByNum(ctlp, aiop);
2302 sEnAiop(ctlp, aiop);
2303 num_chan = sGetAiopNumChan(ctlp, aiop);
2304 total_num_chan += num_chan;
2305 for (chan = 0; chan < num_chan; chan++)
2306 init_r_port(i, aiop, chan, NULL);
2308 is_PCI[i] = 0;
2309 if ((rcktpt_type[i] == ROCKET_TYPE_MODEM) || (rcktpt_type[i] == ROCKET_TYPE_MODEMII)) {
2310 num_chan = sGetAiopNumChan(ctlp, 0);
2311 total_num_chan = num_chan;
2312 for (chan = 0; chan < num_chan; chan++)
2313 sModemReset(ctlp, chan, 1);
2314 mdelay(500);
2315 for (chan = 0; chan < num_chan; chan++)
2316 sModemReset(ctlp, chan, 0);
2317 mdelay(500);
2318 strcpy(rocketModel[i].modelString, "RocketModem ISA");
2319 } else {
2320 strcpy(rocketModel[i].modelString, "RocketPort ISA");
2322 rocketModel[i].numPorts = total_num_chan;
2323 rocketModel[i].model = MODEL_ISA;
2325 printk(KERN_INFO "RocketPort ISA card #%d found at 0x%lx - %d AIOPs %s\n",
2326 i, rcktpt_io_addr[i], num_aiops, type_string);
2328 printk(KERN_INFO "Installing %s, creating /dev/ttyR%d - %ld\n",
2329 rocketModel[i].modelString,
2330 rocketModel[i].startingPortNumber,
2331 rocketModel[i].startingPortNumber +
2332 rocketModel[i].numPorts - 1);
2334 return (1);
2337 static struct tty_operations rocket_ops = {
2338 .open = rp_open,
2339 .close = rp_close,
2340 .write = rp_write,
2341 .put_char = rp_put_char,
2342 .write_room = rp_write_room,
2343 .chars_in_buffer = rp_chars_in_buffer,
2344 .flush_buffer = rp_flush_buffer,
2345 .ioctl = rp_ioctl,
2346 .throttle = rp_throttle,
2347 .unthrottle = rp_unthrottle,
2348 .set_termios = rp_set_termios,
2349 .stop = rp_stop,
2350 .start = rp_start,
2351 .hangup = rp_hangup,
2352 .break_ctl = rp_break,
2353 .send_xchar = rp_send_xchar,
2354 .wait_until_sent = rp_wait_until_sent,
2355 .tiocmget = rp_tiocmget,
2356 .tiocmset = rp_tiocmset,
2357 };
2359 /*
2360 * The module "startup" routine; it's run when the module is loaded.
2361 */
2362 static int __init rp_init(void)
2364 int retval, pci_boards_found, isa_boards_found, i;
2366 printk(KERN_INFO "RocketPort device driver module, version %s, %s\n",
2367 ROCKET_VERSION, ROCKET_DATE);
2369 rocket_driver = alloc_tty_driver(MAX_RP_PORTS);
2370 if (!rocket_driver)
2371 return -ENOMEM;
2373 /*
2374 * Set up the timer channel.
2375 */
2376 init_timer(&rocket_timer);
2377 rocket_timer.function = rp_do_poll;
2379 /*
2380 * Initialize the array of pointers to our own internal state
2381 * structures.
2382 */
2383 memset(rp_table, 0, sizeof (rp_table));
2384 memset(xmit_flags, 0, sizeof (xmit_flags));
2386 for (i = 0; i < MAX_RP_PORTS; i++)
2387 lineNumbers[i] = 0;
2388 nextLineNumber = 0;
2389 memset(rocketModel, 0, sizeof (rocketModel));
2391 /*
2392 * If board 1 is non-zero, there is at least one ISA configured. If controller is
2393 * zero, use the default controller IO address of board1 + 0x40.
2394 */
2395 if (board1) {
2396 if (controller == 0)
2397 controller = board1 + 0x40;
2398 } else {
2399 controller = 0; /* Used as a flag, meaning no ISA boards */
2402 /* If an ISA card is configured, reserve the 4 byte IO space for the Mudbac controller */
2403 if (controller && (!request_region(controller, 4, "Comtrol RocketPort"))) {
2404 printk(KERN_INFO "Unable to reserve IO region for first configured ISA RocketPort controller 0x%lx. Driver exiting \n", controller);
2405 return -EBUSY;
2408 /* Store ISA variable retrieved from command line or .conf file. */
2409 rcktpt_io_addr[0] = board1;
2410 rcktpt_io_addr[1] = board2;
2411 rcktpt_io_addr[2] = board3;
2412 rcktpt_io_addr[3] = board4;
2414 rcktpt_type[0] = modem1 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2415 rcktpt_type[0] = pc104_1[0] ? ROCKET_TYPE_PC104 : rcktpt_type[0];
2416 rcktpt_type[1] = modem2 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2417 rcktpt_type[1] = pc104_2[0] ? ROCKET_TYPE_PC104 : rcktpt_type[1];
2418 rcktpt_type[2] = modem3 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2419 rcktpt_type[2] = pc104_3[0] ? ROCKET_TYPE_PC104 : rcktpt_type[2];
2420 rcktpt_type[3] = modem4 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2421 rcktpt_type[3] = pc104_4[0] ? ROCKET_TYPE_PC104 : rcktpt_type[3];
2423 /*
2424 * Set up the tty driver structure and then register this
2425 * driver with the tty layer.
2426 */
2428 rocket_driver->owner = THIS_MODULE;
2429 rocket_driver->flags = TTY_DRIVER_DYNAMIC_DEV;
2430 rocket_driver->name = "ttyR";
2431 rocket_driver->driver_name = "Comtrol RocketPort";
2432 rocket_driver->major = TTY_ROCKET_MAJOR;
2433 rocket_driver->minor_start = 0;
2434 rocket_driver->type = TTY_DRIVER_TYPE_SERIAL;
2435 rocket_driver->subtype = SERIAL_TYPE_NORMAL;
2436 rocket_driver->init_termios = tty_std_termios;
2437 rocket_driver->init_termios.c_cflag =
2438 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2439 #ifdef ROCKET_SOFT_FLOW
2440 rocket_driver->flags |= TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2441 #endif
2442 tty_set_operations(rocket_driver, &rocket_ops);
2444 retval = tty_register_driver(rocket_driver);
2445 if (retval < 0) {
2446 printk(KERN_INFO "Couldn't install tty RocketPort driver (error %d)\n", -retval);
2447 put_tty_driver(rocket_driver);
2448 return -1;
2451 #ifdef ROCKET_DEBUG_OPEN
2452 printk(KERN_INFO "RocketPort driver is major %d\n", rocket_driver.major);
2453 #endif
2455 /*
2456 * OK, let's probe each of the controllers looking for boards. Any boards found
2457 * will be initialized here.
2458 */
2459 isa_boards_found = 0;
2460 pci_boards_found = 0;
2462 for (i = 0; i < NUM_BOARDS; i++) {
2463 if (init_ISA(i))
2464 isa_boards_found++;
2467 #ifdef CONFIG_PCI
2468 if (isa_boards_found < NUM_BOARDS)
2469 pci_boards_found = init_PCI(isa_boards_found);
2470 #endif
2472 max_board = pci_boards_found + isa_boards_found;
2474 if (max_board == 0) {
2475 printk(KERN_INFO "No rocketport ports found; unloading driver.\n");
2476 del_timer_sync(&rocket_timer);
2477 tty_unregister_driver(rocket_driver);
2478 put_tty_driver(rocket_driver);
2479 return -ENXIO;
2482 return 0;
2486 static void rp_cleanup_module(void)
2488 int retval;
2489 int i;
2491 del_timer_sync(&rocket_timer);
2493 retval = tty_unregister_driver(rocket_driver);
2494 if (retval)
2495 printk(KERN_INFO "Error %d while trying to unregister "
2496 "rocketport driver\n", -retval);
2497 put_tty_driver(rocket_driver);
2499 for (i = 0; i < MAX_RP_PORTS; i++)
2500 kfree(rp_table[i]);
2502 for (i = 0; i < NUM_BOARDS; i++) {
2503 if (rcktpt_io_addr[i] <= 0 || is_PCI[i])
2504 continue;
2505 release_region(rcktpt_io_addr[i], 64);
2507 if (controller)
2508 release_region(controller, 4);
2511 /***************************************************************************
2512 Function: sInitController
2513 Purpose: Initialization of controller global registers and controller
2514 structure.
2515 Call: sInitController(CtlP,CtlNum,MudbacIO,AiopIOList,AiopIOListSize,
2516 IRQNum,Frequency,PeriodicOnly)
2517 CONTROLLER_T *CtlP; Ptr to controller structure
2518 int CtlNum; Controller number
2519 ByteIO_t MudbacIO; Mudbac base I/O address.
2520 ByteIO_t *AiopIOList; List of I/O addresses for each AIOP.
2521 This list must be in the order the AIOPs will be found on the
2522 controller. Once an AIOP in the list is not found, it is
2523 assumed that there are no more AIOPs on the controller.
2524 int AiopIOListSize; Number of addresses in AiopIOList
2525 int IRQNum; Interrupt Request number. Can be any of the following:
2526 0: Disable global interrupts
2527 3: IRQ 3
2528 4: IRQ 4
2529 5: IRQ 5
2530 9: IRQ 9
2531 10: IRQ 10
2532 11: IRQ 11
2533 12: IRQ 12
2534 15: IRQ 15
2535 Byte_t Frequency: A flag identifying the frequency
2536 of the periodic interrupt, can be any one of the following:
2537 FREQ_DIS - periodic interrupt disabled
2538 FREQ_137HZ - 137 Hertz
2539 FREQ_69HZ - 69 Hertz
2540 FREQ_34HZ - 34 Hertz
2541 FREQ_17HZ - 17 Hertz
2542 FREQ_9HZ - 9 Hertz
2543 FREQ_4HZ - 4 Hertz
2544 If IRQNum is set to 0 the Frequency parameter is
2545 overidden, it is forced to a value of FREQ_DIS.
2546 int PeriodicOnly: 1 if all interrupts except the periodic
2547 interrupt are to be blocked.
2548 0 is both the periodic interrupt and
2549 other channel interrupts are allowed.
2550 If IRQNum is set to 0 the PeriodicOnly parameter is
2551 overidden, it is forced to a value of 0.
2552 Return: int: Number of AIOPs on the controller, or CTLID_NULL if controller
2553 initialization failed.
2555 Comments:
2556 If periodic interrupts are to be disabled but AIOP interrupts
2557 are allowed, set Frequency to FREQ_DIS and PeriodicOnly to 0.
2559 If interrupts are to be completely disabled set IRQNum to 0.
2561 Setting Frequency to FREQ_DIS and PeriodicOnly to 1 is an
2562 invalid combination.
2564 This function performs initialization of global interrupt modes,
2565 but it does not actually enable global interrupts. To enable
2566 and disable global interrupts use functions sEnGlobalInt() and
2567 sDisGlobalInt(). Enabling of global interrupts is normally not
2568 done until all other initializations are complete.
2570 Even if interrupts are globally enabled, they must also be
2571 individually enabled for each channel that is to generate
2572 interrupts.
2574 Warnings: No range checking on any of the parameters is done.
2576 No context switches are allowed while executing this function.
2578 After this function all AIOPs on the controller are disabled,
2579 they can be enabled with sEnAiop().
2580 */
2581 static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
2582 ByteIO_t * AiopIOList, int AiopIOListSize,
2583 int IRQNum, Byte_t Frequency, int PeriodicOnly)
2585 int i;
2586 ByteIO_t io;
2587 int done;
2589 CtlP->AiopIntrBits = aiop_intr_bits;
2590 CtlP->AltChanRingIndicator = 0;
2591 CtlP->CtlNum = CtlNum;
2592 CtlP->CtlID = CTLID_0001; /* controller release 1 */
2593 CtlP->BusType = isISA;
2594 CtlP->MBaseIO = MudbacIO;
2595 CtlP->MReg1IO = MudbacIO + 1;
2596 CtlP->MReg2IO = MudbacIO + 2;
2597 CtlP->MReg3IO = MudbacIO + 3;
2598 #if 1
2599 CtlP->MReg2 = 0; /* interrupt disable */
2600 CtlP->MReg3 = 0; /* no periodic interrupts */
2601 #else
2602 if (sIRQMap[IRQNum] == 0) { /* interrupts globally disabled */
2603 CtlP->MReg2 = 0; /* interrupt disable */
2604 CtlP->MReg3 = 0; /* no periodic interrupts */
2605 } else {
2606 CtlP->MReg2 = sIRQMap[IRQNum]; /* set IRQ number */
2607 CtlP->MReg3 = Frequency; /* set frequency */
2608 if (PeriodicOnly) { /* periodic interrupt only */
2609 CtlP->MReg3 |= PERIODIC_ONLY;
2612 #endif
2613 sOutB(CtlP->MReg2IO, CtlP->MReg2);
2614 sOutB(CtlP->MReg3IO, CtlP->MReg3);
2615 sControllerEOI(CtlP); /* clear EOI if warm init */
2616 /* Init AIOPs */
2617 CtlP->NumAiop = 0;
2618 for (i = done = 0; i < AiopIOListSize; i++) {
2619 io = AiopIOList[i];
2620 CtlP->AiopIO[i] = (WordIO_t) io;
2621 CtlP->AiopIntChanIO[i] = io + _INT_CHAN;
2622 sOutB(CtlP->MReg2IO, CtlP->MReg2 | (i & 0x03)); /* AIOP index */
2623 sOutB(MudbacIO, (Byte_t) (io >> 6)); /* set up AIOP I/O in MUDBAC */
2624 if (done)
2625 continue;
2626 sEnAiop(CtlP, i); /* enable the AIOP */
2627 CtlP->AiopID[i] = sReadAiopID(io); /* read AIOP ID */
2628 if (CtlP->AiopID[i] == AIOPID_NULL) /* if AIOP does not exist */
2629 done = 1; /* done looking for AIOPs */
2630 else {
2631 CtlP->AiopNumChan[i] = sReadAiopNumChan((WordIO_t) io); /* num channels in AIOP */
2632 sOutW((WordIO_t) io + _INDX_ADDR, _CLK_PRE); /* clock prescaler */
2633 sOutB(io + _INDX_DATA, sClockPrescale);
2634 CtlP->NumAiop++; /* bump count of AIOPs */
2636 sDisAiop(CtlP, i); /* disable AIOP */
2639 if (CtlP->NumAiop == 0)
2640 return (-1);
2641 else
2642 return (CtlP->NumAiop);
2645 /***************************************************************************
2646 Function: sPCIInitController
2647 Purpose: Initialization of controller global registers and controller
2648 structure.
2649 Call: sPCIInitController(CtlP,CtlNum,AiopIOList,AiopIOListSize,
2650 IRQNum,Frequency,PeriodicOnly)
2651 CONTROLLER_T *CtlP; Ptr to controller structure
2652 int CtlNum; Controller number
2653 ByteIO_t *AiopIOList; List of I/O addresses for each AIOP.
2654 This list must be in the order the AIOPs will be found on the
2655 controller. Once an AIOP in the list is not found, it is
2656 assumed that there are no more AIOPs on the controller.
2657 int AiopIOListSize; Number of addresses in AiopIOList
2658 int IRQNum; Interrupt Request number. Can be any of the following:
2659 0: Disable global interrupts
2660 3: IRQ 3
2661 4: IRQ 4
2662 5: IRQ 5
2663 9: IRQ 9
2664 10: IRQ 10
2665 11: IRQ 11
2666 12: IRQ 12
2667 15: IRQ 15
2668 Byte_t Frequency: A flag identifying the frequency
2669 of the periodic interrupt, can be any one of the following:
2670 FREQ_DIS - periodic interrupt disabled
2671 FREQ_137HZ - 137 Hertz
2672 FREQ_69HZ - 69 Hertz
2673 FREQ_34HZ - 34 Hertz
2674 FREQ_17HZ - 17 Hertz
2675 FREQ_9HZ - 9 Hertz
2676 FREQ_4HZ - 4 Hertz
2677 If IRQNum is set to 0 the Frequency parameter is
2678 overidden, it is forced to a value of FREQ_DIS.
2679 int PeriodicOnly: 1 if all interrupts except the periodic
2680 interrupt are to be blocked.
2681 0 is both the periodic interrupt and
2682 other channel interrupts are allowed.
2683 If IRQNum is set to 0 the PeriodicOnly parameter is
2684 overidden, it is forced to a value of 0.
2685 Return: int: Number of AIOPs on the controller, or CTLID_NULL if controller
2686 initialization failed.
2688 Comments:
2689 If periodic interrupts are to be disabled but AIOP interrupts
2690 are allowed, set Frequency to FREQ_DIS and PeriodicOnly to 0.
2692 If interrupts are to be completely disabled set IRQNum to 0.
2694 Setting Frequency to FREQ_DIS and PeriodicOnly to 1 is an
2695 invalid combination.
2697 This function performs initialization of global interrupt modes,
2698 but it does not actually enable global interrupts. To enable
2699 and disable global interrupts use functions sEnGlobalInt() and
2700 sDisGlobalInt(). Enabling of global interrupts is normally not
2701 done until all other initializations are complete.
2703 Even if interrupts are globally enabled, they must also be
2704 individually enabled for each channel that is to generate
2705 interrupts.
2707 Warnings: No range checking on any of the parameters is done.
2709 No context switches are allowed while executing this function.
2711 After this function all AIOPs on the controller are disabled,
2712 they can be enabled with sEnAiop().
2713 */
2714 static int sPCIInitController(CONTROLLER_T * CtlP, int CtlNum,
2715 ByteIO_t * AiopIOList, int AiopIOListSize,
2716 WordIO_t ConfigIO, int IRQNum, Byte_t Frequency,
2717 int PeriodicOnly, int altChanRingIndicator,
2718 int UPCIRingInd)
2720 int i;
2721 ByteIO_t io;
2723 CtlP->AltChanRingIndicator = altChanRingIndicator;
2724 CtlP->UPCIRingInd = UPCIRingInd;
2725 CtlP->CtlNum = CtlNum;
2726 CtlP->CtlID = CTLID_0001; /* controller release 1 */
2727 CtlP->BusType = isPCI; /* controller release 1 */
2729 if (ConfigIO) {
2730 CtlP->isUPCI = 1;
2731 CtlP->PCIIO = ConfigIO + _PCI_9030_INT_CTRL;
2732 CtlP->PCIIO2 = ConfigIO + _PCI_9030_GPIO_CTRL;
2733 CtlP->AiopIntrBits = upci_aiop_intr_bits;
2734 } else {
2735 CtlP->isUPCI = 0;
2736 CtlP->PCIIO =
2737 (WordIO_t) ((ByteIO_t) AiopIOList[0] + _PCI_INT_FUNC);
2738 CtlP->AiopIntrBits = aiop_intr_bits;
2741 sPCIControllerEOI(CtlP); /* clear EOI if warm init */
2742 /* Init AIOPs */
2743 CtlP->NumAiop = 0;
2744 for (i = 0; i < AiopIOListSize; i++) {
2745 io = AiopIOList[i];
2746 CtlP->AiopIO[i] = (WordIO_t) io;
2747 CtlP->AiopIntChanIO[i] = io + _INT_CHAN;
2749 CtlP->AiopID[i] = sReadAiopID(io); /* read AIOP ID */
2750 if (CtlP->AiopID[i] == AIOPID_NULL) /* if AIOP does not exist */
2751 break; /* done looking for AIOPs */
2753 CtlP->AiopNumChan[i] = sReadAiopNumChan((WordIO_t) io); /* num channels in AIOP */
2754 sOutW((WordIO_t) io + _INDX_ADDR, _CLK_PRE); /* clock prescaler */
2755 sOutB(io + _INDX_DATA, sClockPrescale);
2756 CtlP->NumAiop++; /* bump count of AIOPs */
2759 if (CtlP->NumAiop == 0)
2760 return (-1);
2761 else
2762 return (CtlP->NumAiop);
2765 /***************************************************************************
2766 Function: sReadAiopID
2767 Purpose: Read the AIOP idenfication number directly from an AIOP.
2768 Call: sReadAiopID(io)
2769 ByteIO_t io: AIOP base I/O address
2770 Return: int: Flag AIOPID_XXXX if a valid AIOP is found, where X
2771 is replace by an identifying number.
2772 Flag AIOPID_NULL if no valid AIOP is found
2773 Warnings: No context switches are allowed while executing this function.
2775 */
2776 static int sReadAiopID(ByteIO_t io)
2778 Byte_t AiopID; /* ID byte from AIOP */
2780 sOutB(io + _CMD_REG, RESET_ALL); /* reset AIOP */
2781 sOutB(io + _CMD_REG, 0x0);
2782 AiopID = sInW(io + _CHN_STAT0) & 0x07;
2783 if (AiopID == 0x06)
2784 return (1);
2785 else /* AIOP does not exist */
2786 return (-1);
2789 /***************************************************************************
2790 Function: sReadAiopNumChan
2791 Purpose: Read the number of channels available in an AIOP directly from
2792 an AIOP.
2793 Call: sReadAiopNumChan(io)
2794 WordIO_t io: AIOP base I/O address
2795 Return: int: The number of channels available
2796 Comments: The number of channels is determined by write/reads from identical
2797 offsets within the SRAM address spaces for channels 0 and 4.
2798 If the channel 4 space is mirrored to channel 0 it is a 4 channel
2799 AIOP, otherwise it is an 8 channel.
2800 Warnings: No context switches are allowed while executing this function.
2801 */
2802 static int sReadAiopNumChan(WordIO_t io)
2804 Word_t x;
2805 static Byte_t R[4] = { 0x00, 0x00, 0x34, 0x12 };
2807 /* write to chan 0 SRAM */
2808 sOutDW((DWordIO_t) io + _INDX_ADDR, *((DWord_t *) & R[0]));
2809 sOutW(io + _INDX_ADDR, 0); /* read from SRAM, chan 0 */
2810 x = sInW(io + _INDX_DATA);
2811 sOutW(io + _INDX_ADDR, 0x4000); /* read from SRAM, chan 4 */
2812 if (x != sInW(io + _INDX_DATA)) /* if different must be 8 chan */
2813 return (8);
2814 else
2815 return (4);
2818 /***************************************************************************
2819 Function: sInitChan
2820 Purpose: Initialization of a channel and channel structure
2821 Call: sInitChan(CtlP,ChP,AiopNum,ChanNum)
2822 CONTROLLER_T *CtlP; Ptr to controller structure
2823 CHANNEL_T *ChP; Ptr to channel structure
2824 int AiopNum; AIOP number within controller
2825 int ChanNum; Channel number within AIOP
2826 Return: int: 1 if initialization succeeded, 0 if it fails because channel
2827 number exceeds number of channels available in AIOP.
2828 Comments: This function must be called before a channel can be used.
2829 Warnings: No range checking on any of the parameters is done.
2831 No context switches are allowed while executing this function.
2832 */
2833 static int sInitChan(CONTROLLER_T * CtlP, CHANNEL_T * ChP, int AiopNum,
2834 int ChanNum)
2836 int i;
2837 WordIO_t AiopIO;
2838 WordIO_t ChIOOff;
2839 Byte_t *ChR;
2840 Word_t ChOff;
2841 static Byte_t R[4];
2842 int brd9600;
2844 if (ChanNum >= CtlP->AiopNumChan[AiopNum])
2845 return 0; /* exceeds num chans in AIOP */
2847 /* Channel, AIOP, and controller identifiers */
2848 ChP->CtlP = CtlP;
2849 ChP->ChanID = CtlP->AiopID[AiopNum];
2850 ChP->AiopNum = AiopNum;
2851 ChP->ChanNum = ChanNum;
2853 /* Global direct addresses */
2854 AiopIO = CtlP->AiopIO[AiopNum];
2855 ChP->Cmd = (ByteIO_t) AiopIO + _CMD_REG;
2856 ChP->IntChan = (ByteIO_t) AiopIO + _INT_CHAN;
2857 ChP->IntMask = (ByteIO_t) AiopIO + _INT_MASK;
2858 ChP->IndexAddr = (DWordIO_t) AiopIO + _INDX_ADDR;
2859 ChP->IndexData = AiopIO + _INDX_DATA;
2861 /* Channel direct addresses */
2862 ChIOOff = AiopIO + ChP->ChanNum * 2;
2863 ChP->TxRxData = ChIOOff + _TD0;
2864 ChP->ChanStat = ChIOOff + _CHN_STAT0;
2865 ChP->TxRxCount = ChIOOff + _FIFO_CNT0;
2866 ChP->IntID = (ByteIO_t) AiopIO + ChP->ChanNum + _INT_ID0;
2868 /* Initialize the channel from the RData array */
2869 for (i = 0; i < RDATASIZE; i += 4) {
2870 R[0] = RData[i];
2871 R[1] = RData[i + 1] + 0x10 * ChanNum;
2872 R[2] = RData[i + 2];
2873 R[3] = RData[i + 3];
2874 sOutDW(ChP->IndexAddr, *((DWord_t *) & R[0]));
2877 ChR = ChP->R;
2878 for (i = 0; i < RREGDATASIZE; i += 4) {
2879 ChR[i] = RRegData[i];
2880 ChR[i + 1] = RRegData[i + 1] + 0x10 * ChanNum;
2881 ChR[i + 2] = RRegData[i + 2];
2882 ChR[i + 3] = RRegData[i + 3];
2885 /* Indexed registers */
2886 ChOff = (Word_t) ChanNum *0x1000;
2888 if (sClockPrescale == 0x14)
2889 brd9600 = 47;
2890 else
2891 brd9600 = 23;
2893 ChP->BaudDiv[0] = (Byte_t) (ChOff + _BAUD);
2894 ChP->BaudDiv[1] = (Byte_t) ((ChOff + _BAUD) >> 8);
2895 ChP->BaudDiv[2] = (Byte_t) brd9600;
2896 ChP->BaudDiv[3] = (Byte_t) (brd9600 >> 8);
2897 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->BaudDiv[0]);
2899 ChP->TxControl[0] = (Byte_t) (ChOff + _TX_CTRL);
2900 ChP->TxControl[1] = (Byte_t) ((ChOff + _TX_CTRL) >> 8);
2901 ChP->TxControl[2] = 0;
2902 ChP->TxControl[3] = 0;
2903 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxControl[0]);
2905 ChP->RxControl[0] = (Byte_t) (ChOff + _RX_CTRL);
2906 ChP->RxControl[1] = (Byte_t) ((ChOff + _RX_CTRL) >> 8);
2907 ChP->RxControl[2] = 0;
2908 ChP->RxControl[3] = 0;
2909 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->RxControl[0]);
2911 ChP->TxEnables[0] = (Byte_t) (ChOff + _TX_ENBLS);
2912 ChP->TxEnables[1] = (Byte_t) ((ChOff + _TX_ENBLS) >> 8);
2913 ChP->TxEnables[2] = 0;
2914 ChP->TxEnables[3] = 0;
2915 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxEnables[0]);
2917 ChP->TxCompare[0] = (Byte_t) (ChOff + _TXCMP1);
2918 ChP->TxCompare[1] = (Byte_t) ((ChOff + _TXCMP1) >> 8);
2919 ChP->TxCompare[2] = 0;
2920 ChP->TxCompare[3] = 0;
2921 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxCompare[0]);
2923 ChP->TxReplace1[0] = (Byte_t) (ChOff + _TXREP1B1);
2924 ChP->TxReplace1[1] = (Byte_t) ((ChOff + _TXREP1B1) >> 8);
2925 ChP->TxReplace1[2] = 0;
2926 ChP->TxReplace1[3] = 0;
2927 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxReplace1[0]);
2929 ChP->TxReplace2[0] = (Byte_t) (ChOff + _TXREP2);
2930 ChP->TxReplace2[1] = (Byte_t) ((ChOff + _TXREP2) >> 8);
2931 ChP->TxReplace2[2] = 0;
2932 ChP->TxReplace2[3] = 0;
2933 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxReplace2[0]);
2935 ChP->TxFIFOPtrs = ChOff + _TXF_OUTP;
2936 ChP->TxFIFO = ChOff + _TX_FIFO;
2938 sOutB(ChP->Cmd, (Byte_t) ChanNum | RESTXFCNT); /* apply reset Tx FIFO count */
2939 sOutB(ChP->Cmd, (Byte_t) ChanNum); /* remove reset Tx FIFO count */
2940 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxFIFOPtrs); /* clear Tx in/out ptrs */
2941 sOutW(ChP->IndexData, 0);
2942 ChP->RxFIFOPtrs = ChOff + _RXF_OUTP;
2943 ChP->RxFIFO = ChOff + _RX_FIFO;
2945 sOutB(ChP->Cmd, (Byte_t) ChanNum | RESRXFCNT); /* apply reset Rx FIFO count */
2946 sOutB(ChP->Cmd, (Byte_t) ChanNum); /* remove reset Rx FIFO count */
2947 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs); /* clear Rx out ptr */
2948 sOutW(ChP->IndexData, 0);
2949 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs + 2); /* clear Rx in ptr */
2950 sOutW(ChP->IndexData, 0);
2951 ChP->TxPrioCnt = ChOff + _TXP_CNT;
2952 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxPrioCnt);
2953 sOutB(ChP->IndexData, 0);
2954 ChP->TxPrioPtr = ChOff + _TXP_PNTR;
2955 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxPrioPtr);
2956 sOutB(ChP->IndexData, 0);
2957 ChP->TxPrioBuf = ChOff + _TXP_BUF;
2958 sEnRxProcessor(ChP); /* start the Rx processor */
2960 return 1;
2963 /***************************************************************************
2964 Function: sStopRxProcessor
2965 Purpose: Stop the receive processor from processing a channel.
2966 Call: sStopRxProcessor(ChP)
2967 CHANNEL_T *ChP; Ptr to channel structure
2969 Comments: The receive processor can be started again with sStartRxProcessor().
2970 This function causes the receive processor to skip over the
2971 stopped channel. It does not stop it from processing other channels.
2973 Warnings: No context switches are allowed while executing this function.
2975 Do not leave the receive processor stopped for more than one
2976 character time.
2978 After calling this function a delay of 4 uS is required to ensure
2979 that the receive processor is no longer processing this channel.
2980 */
2981 static void sStopRxProcessor(CHANNEL_T * ChP)
2983 Byte_t R[4];
2985 R[0] = ChP->R[0];
2986 R[1] = ChP->R[1];
2987 R[2] = 0x0a;
2988 R[3] = ChP->R[3];
2989 sOutDW(ChP->IndexAddr, *(DWord_t *) & R[0]);
2992 /***************************************************************************
2993 Function: sFlushRxFIFO
2994 Purpose: Flush the Rx FIFO
2995 Call: sFlushRxFIFO(ChP)
2996 CHANNEL_T *ChP; Ptr to channel structure
2997 Return: void
2998 Comments: To prevent data from being enqueued or dequeued in the Tx FIFO
2999 while it is being flushed the receive processor is stopped
3000 and the transmitter is disabled. After these operations a
3001 4 uS delay is done before clearing the pointers to allow
3002 the receive processor to stop. These items are handled inside
3003 this function.
3004 Warnings: No context switches are allowed while executing this function.
3005 */
3006 static void sFlushRxFIFO(CHANNEL_T * ChP)
3008 int i;
3009 Byte_t Ch; /* channel number within AIOP */
3010 int RxFIFOEnabled; /* 1 if Rx FIFO enabled */
3012 if (sGetRxCnt(ChP) == 0) /* Rx FIFO empty */
3013 return; /* don't need to flush */
3015 RxFIFOEnabled = 0;
3016 if (ChP->R[0x32] == 0x08) { /* Rx FIFO is enabled */
3017 RxFIFOEnabled = 1;
3018 sDisRxFIFO(ChP); /* disable it */
3019 for (i = 0; i < 2000 / 200; i++) /* delay 2 uS to allow proc to disable FIFO */
3020 sInB(ChP->IntChan); /* depends on bus i/o timing */
3022 sGetChanStatus(ChP); /* clear any pending Rx errors in chan stat */
3023 Ch = (Byte_t) sGetChanNum(ChP);
3024 sOutB(ChP->Cmd, Ch | RESRXFCNT); /* apply reset Rx FIFO count */
3025 sOutB(ChP->Cmd, Ch); /* remove reset Rx FIFO count */
3026 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs); /* clear Rx out ptr */
3027 sOutW(ChP->IndexData, 0);
3028 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs + 2); /* clear Rx in ptr */
3029 sOutW(ChP->IndexData, 0);
3030 if (RxFIFOEnabled)
3031 sEnRxFIFO(ChP); /* enable Rx FIFO */
3034 /***************************************************************************
3035 Function: sFlushTxFIFO
3036 Purpose: Flush the Tx FIFO
3037 Call: sFlushTxFIFO(ChP)
3038 CHANNEL_T *ChP; Ptr to channel structure
3039 Return: void
3040 Comments: To prevent data from being enqueued or dequeued in the Tx FIFO
3041 while it is being flushed the receive processor is stopped
3042 and the transmitter is disabled. After these operations a
3043 4 uS delay is done before clearing the pointers to allow
3044 the receive processor to stop. These items are handled inside
3045 this function.
3046 Warnings: No context switches are allowed while executing this function.
3047 */
3048 static void sFlushTxFIFO(CHANNEL_T * ChP)
3050 int i;
3051 Byte_t Ch; /* channel number within AIOP */
3052 int TxEnabled; /* 1 if transmitter enabled */
3054 if (sGetTxCnt(ChP) == 0) /* Tx FIFO empty */
3055 return; /* don't need to flush */
3057 TxEnabled = 0;
3058 if (ChP->TxControl[3] & TX_ENABLE) {
3059 TxEnabled = 1;
3060 sDisTransmit(ChP); /* disable transmitter */
3062 sStopRxProcessor(ChP); /* stop Rx processor */
3063 for (i = 0; i < 4000 / 200; i++) /* delay 4 uS to allow proc to stop */
3064 sInB(ChP->IntChan); /* depends on bus i/o timing */
3065 Ch = (Byte_t) sGetChanNum(ChP);
3066 sOutB(ChP->Cmd, Ch | RESTXFCNT); /* apply reset Tx FIFO count */
3067 sOutB(ChP->Cmd, Ch); /* remove reset Tx FIFO count */
3068 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxFIFOPtrs); /* clear Tx in/out ptrs */
3069 sOutW(ChP->IndexData, 0);
3070 if (TxEnabled)
3071 sEnTransmit(ChP); /* enable transmitter */
3072 sStartRxProcessor(ChP); /* restart Rx processor */
3075 /***************************************************************************
3076 Function: sWriteTxPrioByte
3077 Purpose: Write a byte of priority transmit data to a channel
3078 Call: sWriteTxPrioByte(ChP,Data)
3079 CHANNEL_T *ChP; Ptr to channel structure
3080 Byte_t Data; The transmit data byte
3082 Return: int: 1 if the bytes is successfully written, otherwise 0.
3084 Comments: The priority byte is transmitted before any data in the Tx FIFO.
3086 Warnings: No context switches are allowed while executing this function.
3087 */
3088 static int sWriteTxPrioByte(CHANNEL_T * ChP, Byte_t Data)
3090 Byte_t DWBuf[4]; /* buffer for double word writes */
3091 Word_t *WordPtr; /* must be far because Win SS != DS */
3092 register DWordIO_t IndexAddr;
3094 if (sGetTxCnt(ChP) > 1) { /* write it to Tx priority buffer */
3095 IndexAddr = ChP->IndexAddr;
3096 sOutW((WordIO_t) IndexAddr, ChP->TxPrioCnt); /* get priority buffer status */
3097 if (sInB((ByteIO_t) ChP->IndexData) & PRI_PEND) /* priority buffer busy */
3098 return (0); /* nothing sent */
3100 WordPtr = (Word_t *) (&DWBuf[0]);
3101 *WordPtr = ChP->TxPrioBuf; /* data byte address */
3103 DWBuf[2] = Data; /* data byte value */
3104 sOutDW(IndexAddr, *((DWord_t *) (&DWBuf[0]))); /* write it out */
3106 *WordPtr = ChP->TxPrioCnt; /* Tx priority count address */
3108 DWBuf[2] = PRI_PEND + 1; /* indicate 1 byte pending */
3109 DWBuf[3] = 0; /* priority buffer pointer */
3110 sOutDW(IndexAddr, *((DWord_t *) (&DWBuf[0]))); /* write it out */
3111 } else { /* write it to Tx FIFO */
3113 sWriteTxByte(sGetTxRxDataIO(ChP), Data);
3115 return (1); /* 1 byte sent */
3118 /***************************************************************************
3119 Function: sEnInterrupts
3120 Purpose: Enable one or more interrupts for a channel
3121 Call: sEnInterrupts(ChP,Flags)
3122 CHANNEL_T *ChP; Ptr to channel structure
3123 Word_t Flags: Interrupt enable flags, can be any combination
3124 of the following flags:
3125 TXINT_EN: Interrupt on Tx FIFO empty
3126 RXINT_EN: Interrupt on Rx FIFO at trigger level (see
3127 sSetRxTrigger())
3128 SRCINT_EN: Interrupt on SRC (Special Rx Condition)
3129 MCINT_EN: Interrupt on modem input change
3130 CHANINT_EN: Allow channel interrupt signal to the AIOP's
3131 Interrupt Channel Register.
3132 Return: void
3133 Comments: If an interrupt enable flag is set in Flags, that interrupt will be
3134 enabled. If an interrupt enable flag is not set in Flags, that
3135 interrupt will not be changed. Interrupts can be disabled with
3136 function sDisInterrupts().
3138 This function sets the appropriate bit for the channel in the AIOP's
3139 Interrupt Mask Register if the CHANINT_EN flag is set. This allows
3140 this channel's bit to be set in the AIOP's Interrupt Channel Register.
3142 Interrupts must also be globally enabled before channel interrupts
3143 will be passed on to the host. This is done with function
3144 sEnGlobalInt().
3146 In some cases it may be desirable to disable interrupts globally but
3147 enable channel interrupts. This would allow the global interrupt
3148 status register to be used to determine which AIOPs need service.
3149 */
3150 static void sEnInterrupts(CHANNEL_T * ChP, Word_t Flags)
3152 Byte_t Mask; /* Interrupt Mask Register */
3154 ChP->RxControl[2] |=
3155 ((Byte_t) Flags & (RXINT_EN | SRCINT_EN | MCINT_EN));
3157 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->RxControl[0]);
3159 ChP->TxControl[2] |= ((Byte_t) Flags & TXINT_EN);
3161 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxControl[0]);
3163 if (Flags & CHANINT_EN) {
3164 Mask = sInB(ChP->IntMask) | sBitMapSetTbl[ChP->ChanNum];
3165 sOutB(ChP->IntMask, Mask);
3169 /***************************************************************************
3170 Function: sDisInterrupts
3171 Purpose: Disable one or more interrupts for a channel
3172 Call: sDisInterrupts(ChP,Flags)
3173 CHANNEL_T *ChP; Ptr to channel structure
3174 Word_t Flags: Interrupt flags, can be any combination
3175 of the following flags:
3176 TXINT_EN: Interrupt on Tx FIFO empty
3177 RXINT_EN: Interrupt on Rx FIFO at trigger level (see
3178 sSetRxTrigger())
3179 SRCINT_EN: Interrupt on SRC (Special Rx Condition)
3180 MCINT_EN: Interrupt on modem input change
3181 CHANINT_EN: Disable channel interrupt signal to the
3182 AIOP's Interrupt Channel Register.
3183 Return: void
3184 Comments: If an interrupt flag is set in Flags, that interrupt will be
3185 disabled. If an interrupt flag is not set in Flags, that
3186 interrupt will not be changed. Interrupts can be enabled with
3187 function sEnInterrupts().
3189 This function clears the appropriate bit for the channel in the AIOP's
3190 Interrupt Mask Register if the CHANINT_EN flag is set. This blocks
3191 this channel's bit from being set in the AIOP's Interrupt Channel
3192 Register.
3193 */
3194 static void sDisInterrupts(CHANNEL_T * ChP, Word_t Flags)
3196 Byte_t Mask; /* Interrupt Mask Register */
3198 ChP->RxControl[2] &=
3199 ~((Byte_t) Flags & (RXINT_EN | SRCINT_EN | MCINT_EN));
3200 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->RxControl[0]);
3201 ChP->TxControl[2] &= ~((Byte_t) Flags & TXINT_EN);
3202 sOutDW(ChP->IndexAddr, *(DWord_t *) & ChP->TxControl[0]);
3204 if (Flags & CHANINT_EN) {
3205 Mask = sInB(ChP->IntMask) & sBitMapClrTbl[ChP->ChanNum];
3206 sOutB(ChP->IntMask, Mask);
3210 static void sSetInterfaceMode(CHANNEL_T * ChP, Byte_t mode)
3212 sOutB(ChP->CtlP->AiopIO[2], (mode & 0x18) | ChP->ChanNum);
3215 /*
3216 * Not an official SSCI function, but how to reset RocketModems.
3217 * ISA bus version
3218 */
3219 static void sModemReset(CONTROLLER_T * CtlP, int chan, int on)
3221 ByteIO_t addr;
3222 Byte_t val;
3224 addr = CtlP->AiopIO[0] + 0x400;
3225 val = sInB(CtlP->MReg3IO);
3226 /* if AIOP[1] is not enabled, enable it */
3227 if ((val & 2) == 0) {
3228 val = sInB(CtlP->MReg2IO);
3229 sOutB(CtlP->MReg2IO, (val & 0xfc) | (1 & 0x03));
3230 sOutB(CtlP->MBaseIO, (unsigned char) (addr >> 6));
3233 sEnAiop(CtlP, 1);
3234 if (!on)
3235 addr += 8;
3236 sOutB(addr + chan, 0); /* apply or remove reset */
3237 sDisAiop(CtlP, 1);
3240 /*
3241 * Not an official SSCI function, but how to reset RocketModems.
3242 * PCI bus version
3243 */
3244 static void sPCIModemReset(CONTROLLER_T * CtlP, int chan, int on)
3246 ByteIO_t addr;
3248 addr = CtlP->AiopIO[0] + 0x40; /* 2nd AIOP */
3249 if (!on)
3250 addr += 8;
3251 sOutB(addr + chan, 0); /* apply or remove reset */
3254 /* Resets the speaker controller on RocketModem II and III devices */
3255 static void rmSpeakerReset(CONTROLLER_T * CtlP, unsigned long model)
3257 ByteIO_t addr;
3259 /* RocketModem II speaker control is at the 8th port location of offset 0x40 */
3260 if ((model == MODEL_RP4M) || (model == MODEL_RP6M)) {
3261 addr = CtlP->AiopIO[0] + 0x4F;
3262 sOutB(addr, 0);
3265 /* RocketModem III speaker control is at the 1st port location of offset 0x80 */
3266 if ((model == MODEL_UPCI_RM3_8PORT)
3267 || (model == MODEL_UPCI_RM3_4PORT)) {
3268 addr = CtlP->AiopIO[0] + 0x88;
3269 sOutB(addr, 0);
3273 /* Returns the line number given the controller (board), aiop and channel number */
3274 static unsigned char GetLineNumber(int ctrl, int aiop, int ch)
3276 return lineNumbers[(ctrl << 5) | (aiop << 3) | ch];
3279 /*
3280 * Stores the line number associated with a given controller (board), aiop
3281 * and channel number.
3282 * Returns: The line number assigned
3283 */
3284 static unsigned char SetLineNumber(int ctrl, int aiop, int ch)
3286 lineNumbers[(ctrl << 5) | (aiop << 3) | ch] = nextLineNumber++;
3287 return (nextLineNumber - 1);