?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlwifi: introduce host commands callbacks
[linux/fpc-iii.git] / drivers / char / ip2 / ip2main.c
blobb1d6cad84282e3960f974c9d41df0a4ed8c64500
1 /*
2 *
3 * (c) 1999 by Computone Corporation
4 *
5 ********************************************************************************
6 *
7 * PACKAGE: Linux tty Device Driver for IntelliPort family of multiport
8 * serial I/O controllers.
9 *
10 * DESCRIPTION: Mainline code for the device driver
11 *
12 *******************************************************************************/
13 // ToDo:
14 //
15 // Fix the immediate DSS_NOW problem.
16 // Work over the channel stats return logic in ip2_ipl_ioctl so they
17 // make sense for all 256 possible channels and so the user space
18 // utilities will compile and work properly.
19 //
20 // Done:
21 //
22 // 1.2.14 /\/\|=mhw=|\/\/
23 // Added bounds checking to ip2_ipl_ioctl to avoid potential terroristic acts.
24 // Changed the definition of ip2trace to be more consistent with kernel style
25 // Thanks to Andreas Dilger <adilger@turbolabs.com> for these updates
26 //
27 // 1.2.13 /\/\|=mhw=|\/\/
28 // DEVFS: Renamed ttf/{n} to tts/F{n} and cuf/{n} to cua/F{n} to conform
29 // to agreed devfs serial device naming convention.
30 //
31 // 1.2.12 /\/\|=mhw=|\/\/
32 // Cleaned up some remove queue cut and paste errors
33 //
34 // 1.2.11 /\/\|=mhw=|\/\/
35 // Clean up potential NULL pointer dereferences
36 // Clean up devfs registration
37 // Add kernel command line parsing for io and irq
38 // Compile defaults for io and irq are now set in ip2.c not ip2.h!
39 // Reworked poll_only hack for explicit parameter setting
40 // You must now EXPLICITLY set poll_only = 1 or set all irqs to 0
41 // Merged ip2_loadmain and old_ip2_init
42 // Converted all instances of interruptible_sleep_on into queue calls
43 // Most of these had no race conditions but better to clean up now
44 //
45 // 1.2.10 /\/\|=mhw=|\/\/
46 // Fixed the bottom half interrupt handler and enabled USE_IQI
47 // to split the interrupt handler into a formal top-half / bottom-half
48 // Fixed timing window on high speed processors that queued messages to
49 // the outbound mail fifo faster than the board could handle.
50 //
51 // 1.2.9
52 // Four box EX was barfing on >128k kmalloc, made structure smaller by
53 // reducing output buffer size
54 //
55 // 1.2.8
56 // Device file system support (MHW)
57 //
58 // 1.2.7
59 // Fixed
60 // Reload of ip2 without unloading ip2main hangs system on cat of /proc/modules
61 //
62 // 1.2.6
63 //Fixes DCD problems
64 // DCD was not reported when CLOCAL was set on call to TIOCMGET
65 //
66 //Enhancements:
67 // TIOCMGET requests and waits for status return
68 // No DSS interrupts enabled except for DCD when needed
69 //
70 // For internal use only
71 //
72 //#define IP2DEBUG_INIT
73 //#define IP2DEBUG_OPEN
74 //#define IP2DEBUG_WRITE
75 //#define IP2DEBUG_READ
76 //#define IP2DEBUG_IOCTL
77 //#define IP2DEBUG_IPL
78
79 //#define IP2DEBUG_TRACE
80 //#define DEBUG_FIFO
81
82 /************/
83 /* Includes */
84 /************/
85
86 #include <linux/ctype.h>
87 #include <linux/string.h>
88 #include <linux/fcntl.h>
89 #include <linux/errno.h>
90 #include <linux/module.h>
91 #include <linux/signal.h>
92 #include <linux/sched.h>
93 #include <linux/timer.h>
94 #include <linux/interrupt.h>
95 #include <linux/pci.h>
96 #include <linux/mm.h>
97 #include <linux/slab.h>
98 #include <linux/major.h>
99 #include <linux/wait.h>
100 #include <linux/device.h>
101
102 #include <linux/tty.h>
103 #include <linux/tty_flip.h>
104 #include <linux/termios.h>
105 #include <linux/tty_driver.h>
106 #include <linux/serial.h>
107 #include <linux/ptrace.h>
108 #include <linux/ioport.h>
109
110 #include <linux/cdk.h>
111 #include <linux/comstats.h>
112 #include <linux/delay.h>
113 #include <linux/bitops.h>
114
115 #include <asm/system.h>
116 #include <asm/io.h>
117 #include <asm/irq.h>
118
119 #include <linux/vmalloc.h>
120 #include <linux/init.h>
121
122 #include <asm/uaccess.h>
123
124 #include "ip2types.h"
125 #include "ip2trace.h"
126 #include "ip2ioctl.h"
127 #include "ip2.h"
128 #include "i2ellis.h"
129 #include "i2lib.h"
130
131 /*****************
132 * /proc/ip2mem *
133 *****************/
134
135 #include <linux/proc_fs.h>
136
137 static int ip2_read_procmem(char *, char **, off_t, int);
138 static int ip2_read_proc(char *, char **, off_t, int, int *, void * );
139
140 /********************/
141 /* Type Definitions */
142 /********************/
143
144 /*************/
145 /* Constants */
146 /*************/
147
148 /* String constants to identify ourselves */
149 static char *pcName = "Computone IntelliPort Plus multiport driver";
150 static char *pcVersion = "1.2.14";
151
152 /* String constants for port names */
153 static char *pcDriver_name = "ip2";
154 static char *pcIpl = "ip2ipl";
155
156 // cheezy kludge or genius - you decide?
157 int ip2_loadmain(int *, int *, unsigned char *, int);
158 static unsigned char *Fip_firmware;
159 static int Fip_firmware_size;
160
161 /***********************/
162 /* Function Prototypes */
163 /***********************/
164
165 /* Global module entry functions */
166
167 /* Private (static) functions */
168 static int ip2_open(PTTY, struct file *);
169 static void ip2_close(PTTY, struct file *);
170 static int ip2_write(PTTY, const unsigned char *, int);
171 static void ip2_putchar(PTTY, unsigned char);
172 static void ip2_flush_chars(PTTY);
173 static int ip2_write_room(PTTY);
174 static int ip2_chars_in_buf(PTTY);
175 static void ip2_flush_buffer(PTTY);
176 static int ip2_ioctl(PTTY, struct file *, UINT, ULONG);
177 static void ip2_set_termios(PTTY, struct ktermios *);
178 static void ip2_set_line_discipline(PTTY);
179 static void ip2_throttle(PTTY);
180 static void ip2_unthrottle(PTTY);
181 static void ip2_stop(PTTY);
182 static void ip2_start(PTTY);
183 static void ip2_hangup(PTTY);
184 static int ip2_tiocmget(struct tty_struct *tty, struct file *file);
185 static int ip2_tiocmset(struct tty_struct *tty, struct file *file,
186 unsigned int set, unsigned int clear);
187
188 static void set_irq(int, int);
189 static void ip2_interrupt_bh(struct work_struct *work);
190 static irqreturn_t ip2_interrupt(int irq, void *dev_id);
191 static void ip2_poll(unsigned long arg);
192 static inline void service_all_boards(void);
193 static void do_input(struct work_struct *);
194 static void do_status(struct work_struct *);
195
196 static void ip2_wait_until_sent(PTTY,int);
197
198 static void set_params (i2ChanStrPtr, struct ktermios *);
199 static int get_serial_info(i2ChanStrPtr, struct serial_struct __user *);
200 static int set_serial_info(i2ChanStrPtr, struct serial_struct __user *);
201
202 static ssize_t ip2_ipl_read(struct file *, char __user *, size_t, loff_t *);
203 static ssize_t ip2_ipl_write(struct file *, const char __user *, size_t, loff_t *);
204 static int ip2_ipl_ioctl(struct inode *, struct file *, UINT, ULONG);
205 static int ip2_ipl_open(struct inode *, struct file *);
206
207 static int DumpTraceBuffer(char __user *, int);
208 static int DumpFifoBuffer( char __user *, int);
209
210 static void ip2_init_board(int);
211 static unsigned short find_eisa_board(int);
212
213 /***************/
214 /* Static Data */
215 /***************/
216
217 static struct tty_driver *ip2_tty_driver;
218
219 /* Here, then is a table of board pointers which the interrupt routine should
220 * scan through to determine who it must service.
221 */
222 static unsigned short i2nBoards; // Number of boards here
223
224 static i2eBordStrPtr i2BoardPtrTable[IP2_MAX_BOARDS];
225
226 static i2ChanStrPtr DevTable[IP2_MAX_PORTS];
227 //DevTableMem just used to save addresses for kfree
228 static void *DevTableMem[IP2_MAX_BOARDS];
229
230 /* This is the driver descriptor for the ip2ipl device, which is used to
231 * download the loadware to the boards.
232 */
233 static const struct file_operations ip2_ipl = {
234 .owner = THIS_MODULE,
235 .read = ip2_ipl_read,
236 .write = ip2_ipl_write,
237 .ioctl = ip2_ipl_ioctl,
238 .open = ip2_ipl_open,
239 };
240
241 static unsigned long irq_counter = 0;
242 static unsigned long bh_counter = 0;
243
244 // Use immediate queue to service interrupts
245 #define USE_IQI
246 //#define USE_IQ // PCI&2.2 needs work
247
248 /* The timer_list entry for our poll routine. If interrupt operation is not
249 * selected, the board is serviced periodically to see if anything needs doing.
250 */
251 #define POLL_TIMEOUT (jiffies + 1)
252 static DEFINE_TIMER(PollTimer, ip2_poll, 0, 0);
253 static char TimerOn;
254
255 #ifdef IP2DEBUG_TRACE
256 /* Trace (debug) buffer data */
257 #define TRACEMAX 1000
258 static unsigned long tracebuf[TRACEMAX];
259 static int tracestuff;
260 static int tracestrip;
261 static int tracewrap;
262 #endif
263
264 /**********/
265 /* Macros */
266 /**********/
267
268 #if defined(MODULE) && defined(IP2DEBUG_OPEN)
269 #define DBG_CNT(s) printk(KERN_DEBUG "(%s): [%x] refc=%d, ttyc=%d, modc=%x -> %s\n", \
270 tty->name,(pCh->flags),ip2_tty_driver->refcount, \
271 tty->count,/*GET_USE_COUNT(module)*/0,s)
272 #else
273 #define DBG_CNT(s)
274 #endif
275
276 /********/
277 /* Code */
278 /********/
279
280 #include "i2ellis.c" /* Extremely low-level interface services */
281 #include "i2cmd.c" /* Standard loadware command definitions */
282 #include "i2lib.c" /* High level interface services */
283
284 /* Configuration area for modprobe */
285
286 MODULE_AUTHOR("Doug McNash");
287 MODULE_DESCRIPTION("Computone IntelliPort Plus Driver");
288
289 static int poll_only = 0;
290
291 static int Eisa_irq;
292 static int Eisa_slot;
293
294 static int iindx;
295 static char rirqs[IP2_MAX_BOARDS];
296 static int Valid_Irqs[] = { 3, 4, 5, 7, 10, 11, 12, 15, 0};
297
298 /* for sysfs class support */
299 static struct class *ip2_class;
300
301 // Some functions to keep track of what irq's we have
302
303 static int
304 is_valid_irq(int irq)
305 {
306 int *i = Valid_Irqs;
307
308 while ((*i != 0) && (*i != irq)) {
309 i++;
310 }
311 return (*i);
312 }
313
314 static void
315 mark_requested_irq( char irq )
316 {
317 rirqs[iindx++] = irq;
318 }
319
320 #ifdef MODULE
321 static int
322 clear_requested_irq( char irq )
323 {
324 int i;
325 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
326 if (rirqs[i] == irq) {
327 rirqs[i] = 0;
328 return 1;
329 }
330 }
331 return 0;
332 }
333 #endif
334
335 static int
336 have_requested_irq( char irq )
337 {
338 // array init to zeros so 0 irq will not be requested as a side effect
339 int i;
340 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
341 if (rirqs[i] == irq)
342 return 1;
343 }
344 return 0;
345 }
346
347 /******************************************************************************/
348 /* Function: init_module() */
349 /* Parameters: None */
350 /* Returns: Success (0) */
351 /* */
352 /* Description: */
353 /* This is a required entry point for an installable module. It simply calls */
354 /* the driver initialisation function and returns what it returns. */
355 /******************************************************************************/
356 #ifdef MODULE
357 int
358 init_module(void)
359 {
360 #ifdef IP2DEBUG_INIT
361 printk (KERN_DEBUG "Loading module ...\n" );
362 #endif
363 return 0;
364 }
365 #endif /* MODULE */
366
367 /******************************************************************************/
368 /* Function: cleanup_module() */
369 /* Parameters: None */
370 /* Returns: Nothing */
371 /* */
372 /* Description: */
373 /* This is a required entry point for an installable module. It has to return */
374 /* the device and the driver to a passive state. It should not be necessary */
375 /* to reset the board fully, especially as the loadware is downloaded */
376 /* externally rather than in the driver. We just want to disable the board */
377 /* and clear the loadware to a reset state. To allow this there has to be a */
378 /* way to detect whether the board has the loadware running at init time to */
379 /* handle subsequent installations of the driver. All memory allocated by the */
380 /* driver should be returned since it may be unloaded from memory. */
381 /******************************************************************************/
382 #ifdef MODULE
383 void
384 cleanup_module(void)
385 {
386 int err;
387 int i;
388
389 #ifdef IP2DEBUG_INIT
390 printk (KERN_DEBUG "Unloading %s: version %s\n", pcName, pcVersion );
391 #endif
392 /* Stop poll timer if we had one. */
393 if ( TimerOn ) {
394 del_timer ( &PollTimer );
395 TimerOn = 0;
396 }
397
398 /* Reset the boards we have. */
399 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
400 if ( i2BoardPtrTable[i] ) {
401 iiReset( i2BoardPtrTable[i] );
402 }
403 }
404
405 /* The following is done at most once, if any boards were installed. */
406 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
407 if ( i2BoardPtrTable[i] ) {
408 iiResetDelay( i2BoardPtrTable[i] );
409 /* free io addresses and Tibet */
410 release_region( ip2config.addr[i], 8 );
411 device_destroy(ip2_class, MKDEV(IP2_IPL_MAJOR, 4 * i));
412 device_destroy(ip2_class, MKDEV(IP2_IPL_MAJOR, 4 * i + 1));
413 }
414 /* Disable and remove interrupt handler. */
415 if ( (ip2config.irq[i] > 0) && have_requested_irq(ip2config.irq[i]) ) {
416 free_irq ( ip2config.irq[i], (void *)&pcName);
417 clear_requested_irq( ip2config.irq[i]);
418 }
419 }
420 class_destroy(ip2_class);
421 if ( ( err = tty_unregister_driver ( ip2_tty_driver ) ) ) {
422 printk(KERN_ERR "IP2: failed to unregister tty driver (%d)\n", err);
423 }
424 put_tty_driver(ip2_tty_driver);
425 unregister_chrdev(IP2_IPL_MAJOR, pcIpl);
426 remove_proc_entry("ip2mem", &proc_root);
427
428 // free memory
429 for (i = 0; i < IP2_MAX_BOARDS; i++) {
430 void *pB;
431 #ifdef CONFIG_PCI
432 if (ip2config.type[i] == PCI && ip2config.pci_dev[i]) {
433 pci_disable_device(ip2config.pci_dev[i]);
434 pci_dev_put(ip2config.pci_dev[i]);
435 ip2config.pci_dev[i] = NULL;
436 }
437 #endif
438 if ((pB = i2BoardPtrTable[i]) != 0 ) {
439 kfree ( pB );
440 i2BoardPtrTable[i] = NULL;
441 }
442 if ((DevTableMem[i]) != NULL ) {
443 kfree ( DevTableMem[i] );
444 DevTableMem[i] = NULL;
445 }
446 }
447
448 /* Cleanup the iiEllis subsystem. */
449 iiEllisCleanup();
450 #ifdef IP2DEBUG_INIT
451 printk (KERN_DEBUG "IP2 Unloaded\n" );
452 #endif
453 }
454 #endif /* MODULE */
455
456 static const struct tty_operations ip2_ops = {
457 .open = ip2_open,
458 .close = ip2_close,
459 .write = ip2_write,
460 .put_char = ip2_putchar,
461 .flush_chars = ip2_flush_chars,
462 .write_room = ip2_write_room,
463 .chars_in_buffer = ip2_chars_in_buf,
464 .flush_buffer = ip2_flush_buffer,
465 .ioctl = ip2_ioctl,
466 .throttle = ip2_throttle,
467 .unthrottle = ip2_unthrottle,
468 .set_termios = ip2_set_termios,
469 .set_ldisc = ip2_set_line_discipline,
470 .stop = ip2_stop,
471 .start = ip2_start,
472 .hangup = ip2_hangup,
473 .read_proc = ip2_read_proc,
474 .tiocmget = ip2_tiocmget,
475 .tiocmset = ip2_tiocmset,
476 };
477
478 /******************************************************************************/
479 /* Function: ip2_loadmain() */
480 /* Parameters: irq, io from command line of insmod et. al. */
481 /* pointer to fip firmware and firmware size for boards */
482 /* Returns: Success (0) */
483 /* */
484 /* Description: */
485 /* This was the required entry point for all drivers (now in ip2.c) */
486 /* It performs all */
487 /* initialisation of the devices and driver structures, and registers itself */
488 /* with the relevant kernel modules. */
489 /******************************************************************************/
490 /* IRQF_DISABLED - if set blocks all interrupts else only this line */
491 /* IRQF_SHARED - for shared irq PCI or maybe EISA only */
492 /* SA_RANDOM - can be source for cert. random number generators */
493 #define IP2_SA_FLAGS 0
494
495 int
496 ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
497 {
498 int i, j, box;
499 int err = 0;
500 static int loaded;
501 i2eBordStrPtr pB = NULL;
502 int rc = -1;
503 static struct pci_dev *pci_dev_i = NULL;
504
505 ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0 );
506
507 /* process command line arguments to modprobe or
508 insmod i.e. iop & irqp */
509 /* irqp and iop should ALWAYS be specified now... But we check
510 them individually just to be sure, anyways... */
511 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
512 if (iop) {
513 ip2config.addr[i] = iop[i];
514 if (irqp) {
515 if( irqp[i] >= 0 ) {
516 ip2config.irq[i] = irqp[i];
517 } else {
518 ip2config.irq[i] = 0;
519 }
520 // This is a little bit of a hack. If poll_only=1 on command
521 // line back in ip2.c OR all IRQs on all specified boards are
522 // explicitly set to 0, then drop to poll only mode and override
523 // PCI or EISA interrupts. This superceeds the old hack of
524 // triggering if all interrupts were zero (like da default).
525 // Still a hack but less prone to random acts of terrorism.
526 //
527 // What we really should do, now that the IRQ default is set
528 // to -1, is to use 0 as a hard coded, do not probe.
529 //
530 // /\/\|=mhw=|\/\/
531 poll_only |= irqp[i];
532 }
533 }
534 }
535 poll_only = !poll_only;
536
537 Fip_firmware = firmware;
538 Fip_firmware_size = firmsize;
539
540 /* Announce our presence */
541 printk( KERN_INFO "%s version %s\n", pcName, pcVersion );
542
543 // ip2 can be unloaded and reloaded for no good reason
544 // we can't let that happen here or bad things happen
545 // second load hoses board but not system - fixme later
546 if (loaded) {
547 printk( KERN_INFO "Still loaded\n" );
548 return 0;
549 }
550 loaded++;
551
552 ip2_tty_driver = alloc_tty_driver(IP2_MAX_PORTS);
553 if (!ip2_tty_driver)
554 return -ENOMEM;
555
556 /* Initialise the iiEllis subsystem. */
557 iiEllisInit();
558
559 /* Initialize arrays. */
560 memset( i2BoardPtrTable, 0, sizeof i2BoardPtrTable );
561 memset( DevTable, 0, sizeof DevTable );
562
563 /* Initialise all the boards we can find (up to the maximum). */
564 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
565 switch ( ip2config.addr[i] ) {
566 case 0: /* skip this slot even if card is present */
567 break;
568 default: /* ISA */
569 /* ISA address must be specified */
570 if ( (ip2config.addr[i] < 0x100) || (ip2config.addr[i] > 0x3f8) ) {
571 printk ( KERN_ERR "IP2: Bad ISA board %d address %x\n",
572 i, ip2config.addr[i] );
573 ip2config.addr[i] = 0;
574 } else {
575 ip2config.type[i] = ISA;
576
577 /* Check for valid irq argument, set for polling if invalid */
578 if (ip2config.irq[i] && !is_valid_irq(ip2config.irq[i])) {
579 printk(KERN_ERR "IP2: Bad IRQ(%d) specified\n",ip2config.irq[i]);
580 ip2config.irq[i] = 0;// 0 is polling and is valid in that sense
581 }
582 }
583 break;
584 case PCI:
585 #ifdef CONFIG_PCI
586 {
587 int status;
588
589 pci_dev_i = pci_get_device(PCI_VENDOR_ID_COMPUTONE,
590 PCI_DEVICE_ID_COMPUTONE_IP2EX, pci_dev_i);
591 if (pci_dev_i != NULL) {
592 unsigned int addr;
593
594 if (pci_enable_device(pci_dev_i)) {
595 printk( KERN_ERR "IP2: can't enable PCI device at %s\n",
596 pci_name(pci_dev_i));
597 break;
598 }
599 ip2config.type[i] = PCI;
600 ip2config.pci_dev[i] = pci_dev_get(pci_dev_i);
601 status =
602 pci_read_config_dword(pci_dev_i, PCI_BASE_ADDRESS_1, &addr);
603 if ( addr & 1 ) {
604 ip2config.addr[i]=(USHORT)(addr&0xfffe);
605 } else {
606 printk( KERN_ERR "IP2: PCI I/O address error\n");
607 }
608
609 // If the PCI BIOS assigned it, lets try and use it. If we
610 // can't acquire it or it screws up, deal with it then.
611
612 // if (!is_valid_irq(pci_irq)) {
613 // printk( KERN_ERR "IP2: Bad PCI BIOS IRQ(%d)\n",pci_irq);
614 // pci_irq = 0;
615 // }
616 ip2config.irq[i] = pci_dev_i->irq;
617 } else { // ann error
618 ip2config.addr[i] = 0;
619 printk(KERN_ERR "IP2: PCI board %d not found\n", i);
620 }
621 }
622 #else
623 printk( KERN_ERR "IP2: PCI card specified but PCI support not\n");
624 printk( KERN_ERR "IP2: configured in this kernel.\n");
625 printk( KERN_ERR "IP2: Recompile kernel with CONFIG_PCI defined!\n");
626 #endif /* CONFIG_PCI */
627 break;
628 case EISA:
629 if ( (ip2config.addr[i] = find_eisa_board( Eisa_slot + 1 )) != 0) {
630 /* Eisa_irq set as side effect, boo */
631 ip2config.type[i] = EISA;
632 }
633 ip2config.irq[i] = Eisa_irq;
634 break;
635 } /* switch */
636 } /* for */
637 if (pci_dev_i)
638 pci_dev_put(pci_dev_i);
639
640 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
641 if ( ip2config.addr[i] ) {
642 pB = kzalloc(sizeof(i2eBordStr), GFP_KERNEL);
643 if (pB) {
644 i2BoardPtrTable[i] = pB;
645 iiSetAddress( pB, ip2config.addr[i], ii2DelayTimer );
646 iiReset( pB );
647 } else {
648 printk(KERN_ERR "IP2: board memory allocation error\n");
649 }
650 }
651 }
652 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
653 if ( ( pB = i2BoardPtrTable[i] ) != NULL ) {
654 iiResetDelay( pB );
655 break;
656 }
657 }
658 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
659 if ( i2BoardPtrTable[i] != NULL ) {
660 ip2_init_board( i );
661 }
662 }
663
664 ip2trace (ITRC_NO_PORT, ITRC_INIT, 2, 0 );
665
666 ip2_tty_driver->owner = THIS_MODULE;
667 ip2_tty_driver->name = "ttyF";
668 ip2_tty_driver->driver_name = pcDriver_name;
669 ip2_tty_driver->major = IP2_TTY_MAJOR;
670 ip2_tty_driver->minor_start = 0;
671 ip2_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
672 ip2_tty_driver->subtype = SERIAL_TYPE_NORMAL;
673 ip2_tty_driver->init_termios = tty_std_termios;
674 ip2_tty_driver->init_termios.c_cflag = B9600|CS8|CREAD|HUPCL|CLOCAL;
675 ip2_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
676 tty_set_operations(ip2_tty_driver, &ip2_ops);
677
678 ip2trace (ITRC_NO_PORT, ITRC_INIT, 3, 0 );
679
680 /* Register the tty devices. */
681 if ( ( err = tty_register_driver ( ip2_tty_driver ) ) ) {
682 printk(KERN_ERR "IP2: failed to register tty driver (%d)\n", err);
683 put_tty_driver(ip2_tty_driver);
684 return -EINVAL;
685 } else
686 /* Register the IPL driver. */
687 if ( ( err = register_chrdev ( IP2_IPL_MAJOR, pcIpl, &ip2_ipl ) ) ) {
688 printk(KERN_ERR "IP2: failed to register IPL device (%d)\n", err );
689 } else {
690 /* create the sysfs class */
691 ip2_class = class_create(THIS_MODULE, "ip2");
692 if (IS_ERR(ip2_class)) {
693 err = PTR_ERR(ip2_class);
694 goto out_chrdev;
695 }
696 }
697 /* Register the read_procmem thing */
698 if (!create_proc_info_entry("ip2mem",0,&proc_root,ip2_read_procmem)) {
699 printk(KERN_ERR "IP2: failed to register read_procmem\n");
700 } else {
701
702 ip2trace (ITRC_NO_PORT, ITRC_INIT, 4, 0 );
703 /* Register the interrupt handler or poll handler, depending upon the
704 * specified interrupt.
705 */
706
707 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
708 if ( 0 == ip2config.addr[i] ) {
709 continue;
710 }
711
712 if ( NULL != ( pB = i2BoardPtrTable[i] ) ) {
713 device_create(ip2_class, NULL,
714 MKDEV(IP2_IPL_MAJOR, 4 * i),
715 "ipl%d", i);
716 device_create(ip2_class, NULL,
717 MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
718 "stat%d", i);
719
720 for ( box = 0; box < ABS_MAX_BOXES; ++box )
721 {
722 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
723 {
724 if ( pB->i2eChannelMap[box] & (1 << j) )
725 {
726 tty_register_device(ip2_tty_driver,
727 j + ABS_BIGGEST_BOX *
728 (box+i*ABS_MAX_BOXES), NULL);
729 }
730 }
731 }
732 }
733
734 if (poll_only) {
735 // Poll only forces driver to only use polling and
736 // to ignore the probed PCI or EISA interrupts.
737 ip2config.irq[i] = CIR_POLL;
738 }
739 if ( ip2config.irq[i] == CIR_POLL ) {
740 retry:
741 if (!TimerOn) {
742 PollTimer.expires = POLL_TIMEOUT;
743 add_timer ( &PollTimer );
744 TimerOn = 1;
745 printk( KERN_INFO "IP2: polling\n");
746 }
747 } else {
748 if (have_requested_irq(ip2config.irq[i]))
749 continue;
750 rc = request_irq( ip2config.irq[i], ip2_interrupt,
751 IP2_SA_FLAGS | (ip2config.type[i] == PCI ? IRQF_SHARED : 0),
752 pcName, i2BoardPtrTable[i]);
753 if (rc) {
754 printk(KERN_ERR "IP2: an request_irq failed: error %d\n",rc);
755 ip2config.irq[i] = CIR_POLL;
756 printk( KERN_INFO "IP2: Polling %ld/sec.\n",
757 (POLL_TIMEOUT - jiffies));
758 goto retry;
759 }
760 mark_requested_irq(ip2config.irq[i]);
761 /* Initialise the interrupt handler bottom half (aka slih). */
762 }
763 }
764 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
765 if ( i2BoardPtrTable[i] ) {
766 set_irq( i, ip2config.irq[i] ); /* set and enable board interrupt */
767 }
768 }
769 }
770 ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_RETURN, 0 );
771 goto out;
772
773 out_chrdev:
774 unregister_chrdev(IP2_IPL_MAJOR, "ip2");
775 out:
776 return err;
777 }
778
779 EXPORT_SYMBOL(ip2_loadmain);
780
781 /******************************************************************************/
782 /* Function: ip2_init_board() */
783 /* Parameters: Index of board in configuration structure */
784 /* Returns: Success (0) */
785 /* */
786 /* Description: */
787 /* This function initializes the specified board. The loadware is copied to */
788 /* the board, the channel structures are initialized, and the board details */
789 /* are reported on the console. */
790 /******************************************************************************/
791 static void
792 ip2_init_board( int boardnum )
793 {
794 int i;
795 int nports = 0, nboxes = 0;
796 i2ChanStrPtr pCh;
797 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
798
799 if ( !iiInitialize ( pB ) ) {
800 printk ( KERN_ERR "IP2: Failed to initialize board at 0x%x, error %d\n",
801 pB->i2eBase, pB->i2eError );
802 goto err_initialize;
803 }
804 printk(KERN_INFO "IP2: Board %d: addr=0x%x irq=%d\n", boardnum + 1,
805 ip2config.addr[boardnum], ip2config.irq[boardnum] );
806
807 if (!request_region( ip2config.addr[boardnum], 8, pcName )) {
808 printk(KERN_ERR "IP2: bad addr=0x%x\n", ip2config.addr[boardnum]);
809 goto err_initialize;
810 }
811
812 if ( iiDownloadAll ( pB, (loadHdrStrPtr)Fip_firmware, 1, Fip_firmware_size )
813 != II_DOWN_GOOD ) {
814 printk ( KERN_ERR "IP2: failed to download loadware\n" );
815 goto err_release_region;
816 } else {
817 printk ( KERN_INFO "IP2: fv=%d.%d.%d lv=%d.%d.%d\n",
818 pB->i2ePom.e.porVersion,
819 pB->i2ePom.e.porRevision,
820 pB->i2ePom.e.porSubRev, pB->i2eLVersion,
821 pB->i2eLRevision, pB->i2eLSub );
822 }
823
824 switch ( pB->i2ePom.e.porID & ~POR_ID_RESERVED ) {
825
826 default:
827 printk( KERN_ERR "IP2: Unknown board type, ID = %x\n",
828 pB->i2ePom.e.porID );
829 nports = 0;
830 goto err_release_region;
831 break;
832
833 case POR_ID_II_4: /* IntelliPort-II, ISA-4 (4xRJ45) */
834 printk ( KERN_INFO "IP2: ISA-4\n" );
835 nports = 4;
836 break;
837
838 case POR_ID_II_8: /* IntelliPort-II, 8-port using standard brick. */
839 printk ( KERN_INFO "IP2: ISA-8 std\n" );
840 nports = 8;
841 break;
842
843 case POR_ID_II_8R: /* IntelliPort-II, 8-port using RJ11's (no CTS) */
844 printk ( KERN_INFO "IP2: ISA-8 RJ11\n" );
845 nports = 8;
846 break;
847
848 case POR_ID_FIIEX: /* IntelliPort IIEX */
849 {
850 int portnum = IP2_PORTS_PER_BOARD * boardnum;
851 int box;
852
853 for( box = 0; box < ABS_MAX_BOXES; ++box ) {
854 if ( pB->i2eChannelMap[box] != 0 ) {
855 ++nboxes;
856 }
857 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
858 if ( pB->i2eChannelMap[box] & 1<< i ) {
859 ++nports;
860 }
861 }
862 }
863 DevTableMem[boardnum] = pCh =
864 kmalloc( sizeof(i2ChanStr) * nports, GFP_KERNEL );
865 if ( !pCh ) {
866 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
867 goto err_release_region;
868 }
869 if ( !i2InitChannels( pB, nports, pCh ) ) {
870 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
871 kfree ( pCh );
872 goto err_release_region;
873 }
874 pB->i2eChannelPtr = &DevTable[portnum];
875 pB->i2eChannelCnt = ABS_MOST_PORTS;
876
877 for( box = 0; box < ABS_MAX_BOXES; ++box, portnum += ABS_BIGGEST_BOX ) {
878 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
879 if ( pB->i2eChannelMap[box] & (1 << i) ) {
880 DevTable[portnum + i] = pCh;
881 pCh->port_index = portnum + i;
882 pCh++;
883 }
884 }
885 }
886 printk(KERN_INFO "IP2: EX box=%d ports=%d %d bit\n",
887 nboxes, nports, pB->i2eDataWidth16 ? 16 : 8 );
888 }
889 goto ex_exit;
890 }
891 DevTableMem[boardnum] = pCh =
892 kmalloc ( sizeof (i2ChanStr) * nports, GFP_KERNEL );
893 if ( !pCh ) {
894 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
895 goto err_release_region;
896 }
897 pB->i2eChannelPtr = pCh;
898 pB->i2eChannelCnt = nports;
899 if ( !i2InitChannels( pB, nports, pCh ) ) {
900 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
901 kfree ( pCh );
902 goto err_release_region;
903 }
904 pB->i2eChannelPtr = &DevTable[IP2_PORTS_PER_BOARD * boardnum];
905
906 for( i = 0; i < pB->i2eChannelCnt; ++i ) {
907 DevTable[IP2_PORTS_PER_BOARD * boardnum + i] = pCh;
908 pCh->port_index = (IP2_PORTS_PER_BOARD * boardnum) + i;
909 pCh++;
910 }
911 ex_exit:
912 INIT_WORK(&pB->tqueue_interrupt, ip2_interrupt_bh);
913 return;
914
915 err_release_region:
916 release_region(ip2config.addr[boardnum], 8);
917 err_initialize:
918 kfree ( pB );
919 i2BoardPtrTable[boardnum] = NULL;
920 return;
921 }
922
923 /******************************************************************************/
924 /* Function: find_eisa_board ( int start_slot ) */
925 /* Parameters: First slot to check */
926 /* Returns: Address of EISA IntelliPort II controller */
927 /* */
928 /* Description: */
929 /* This function searches for an EISA IntelliPort controller, starting */
930 /* from the specified slot number. If the motherboard is not identified as an */
931 /* EISA motherboard, or no valid board ID is selected it returns 0. Otherwise */
932 /* it returns the base address of the controller. */
933 /******************************************************************************/
934 static unsigned short
935 find_eisa_board( int start_slot )
936 {
937 int i, j;
938 unsigned int idm = 0;
939 unsigned int idp = 0;
940 unsigned int base = 0;
941 unsigned int value;
942 int setup_address;
943 int setup_irq;
944 int ismine = 0;
945
946 /*
947 * First a check for an EISA motherboard, which we do by comparing the
948 * EISA ID registers for the system board and the first couple of slots.
949 * No slot ID should match the system board ID, but on an ISA or PCI
950 * machine the odds are that an empty bus will return similar values for
951 * each slot.
952 */
953 i = 0x0c80;
954 value = (inb(i) << 24) + (inb(i+1) << 16) + (inb(i+2) << 8) + inb(i+3);
955 for( i = 0x1c80; i <= 0x4c80; i += 0x1000 ) {
956 j = (inb(i)<<24)+(inb(i+1)<<16)+(inb(i+2)<<8)+inb(i+3);
957 if ( value == j )
958 return 0;
959 }
960
961 /*
962 * OK, so we are inclined to believe that this is an EISA machine. Find
963 * an IntelliPort controller.
964 */
965 for( i = start_slot; i < 16; i++ ) {
966 base = i << 12;
967 idm = (inb(base + 0xc80) << 8) | (inb(base + 0xc81) & 0xff);
968 idp = (inb(base + 0xc82) << 8) | (inb(base + 0xc83) & 0xff);
969 ismine = 0;
970 if ( idm == 0x0e8e ) {
971 if ( idp == 0x0281 || idp == 0x0218 ) {
972 ismine = 1;
973 } else if ( idp == 0x0282 || idp == 0x0283 ) {
974 ismine = 3; /* Can do edge-trigger */
975 }
976 if ( ismine ) {
977 Eisa_slot = i;
978 break;
979 }
980 }
981 }
982 if ( !ismine )
983 return 0;
984
985 /* It's some sort of EISA card, but at what address is it configured? */
986
987 setup_address = base + 0xc88;
988 value = inb(base + 0xc86);
989 setup_irq = (value & 8) ? Valid_Irqs[value & 7] : 0;
990
991 if ( (ismine & 2) && !(value & 0x10) ) {
992 ismine = 1; /* Could be edging, but not */
993 }
994
995 if ( Eisa_irq == 0 ) {
996 Eisa_irq = setup_irq;
997 } else if ( Eisa_irq != setup_irq ) {
998 printk ( KERN_ERR "IP2: EISA irq mismatch between EISA controllers\n" );
999 }
1000
1001 #ifdef IP2DEBUG_INIT
1002 printk(KERN_DEBUG "Computone EISA board in slot %d, I.D. 0x%x%x, Address 0x%x",
1003 base >> 12, idm, idp, setup_address);
1004 if ( Eisa_irq ) {
1005 printk(KERN_DEBUG ", Interrupt %d %s\n",
1006 setup_irq, (ismine & 2) ? "(edge)" : "(level)");
1007 } else {
1008 printk(KERN_DEBUG ", (polled)\n");
1009 }
1010 #endif
1011 return setup_address;
1012 }
1013
1014 /******************************************************************************/
1015 /* Function: set_irq() */
1016 /* Parameters: index to board in board table */
1017 /* IRQ to use */
1018 /* Returns: Success (0) */
1019 /* */
1020 /* Description: */
1021 /******************************************************************************/
1022 static void
1023 set_irq( int boardnum, int boardIrq )
1024 {
1025 unsigned char tempCommand[16];
1026 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
1027 unsigned long flags;
1028
1029 /*
1030 * Notify the boards they may generate interrupts. This is done by
1031 * sending an in-line command to channel 0 on each board. This is why
1032 * the channels have to be defined already. For each board, if the
1033 * interrupt has never been defined, we must do so NOW, directly, since
1034 * board will not send flow control or even give an interrupt until this
1035 * is done. If polling we must send 0 as the interrupt parameter.
1036 */
1037
1038 // We will get an interrupt here at the end of this function
1039
1040 iiDisableMailIrq(pB);
1041
1042 /* We build up the entire packet header. */
1043 CHANNEL_OF(tempCommand) = 0;
1044 PTYPE_OF(tempCommand) = PTYPE_INLINE;
1045 CMD_COUNT_OF(tempCommand) = 2;
1046 (CMD_OF(tempCommand))[0] = CMDVALUE_IRQ;
1047 (CMD_OF(tempCommand))[1] = boardIrq;
1048 /*
1049 * Write to FIFO; don't bother to adjust fifo capacity for this, since
1050 * board will respond almost immediately after SendMail hit.
1051 */
1052 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1053 iiWriteBuf(pB, tempCommand, 4);
1054 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1055 pB->i2eUsingIrq = boardIrq;
1056 pB->i2eOutMailWaiting |= MB_OUT_STUFFED;
1057
1058 /* Need to update number of boards before you enable mailbox int */
1059 ++i2nBoards;
1060
1061 CHANNEL_OF(tempCommand) = 0;
1062 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1063 CMD_COUNT_OF(tempCommand) = 6;
1064 (CMD_OF(tempCommand))[0] = 88; // SILO
1065 (CMD_OF(tempCommand))[1] = 64; // chars
1066 (CMD_OF(tempCommand))[2] = 32; // ms
1067
1068 (CMD_OF(tempCommand))[3] = 28; // MAX_BLOCK
1069 (CMD_OF(tempCommand))[4] = 64; // chars
1070
1071 (CMD_OF(tempCommand))[5] = 87; // HW_TEST
1072 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1073 iiWriteBuf(pB, tempCommand, 8);
1074 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1075
1076 CHANNEL_OF(tempCommand) = 0;
1077 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1078 CMD_COUNT_OF(tempCommand) = 1;
1079 (CMD_OF(tempCommand))[0] = 84; /* get BOX_IDS */
1080 iiWriteBuf(pB, tempCommand, 3);
1081
1082 #ifdef XXX
1083 // enable heartbeat for test porpoises
1084 CHANNEL_OF(tempCommand) = 0;
1085 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1086 CMD_COUNT_OF(tempCommand) = 2;
1087 (CMD_OF(tempCommand))[0] = 44; /* get ping */
1088 (CMD_OF(tempCommand))[1] = 200; /* 200 ms */
1089 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1090 iiWriteBuf(pB, tempCommand, 4);
1091 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1092 #endif
1093
1094 iiEnableMailIrq(pB);
1095 iiSendPendingMail(pB);
1096 }
1097
1098 /******************************************************************************/
1099 /* Interrupt Handler Section */
1100 /******************************************************************************/
1101
1102 static inline void
1103 service_all_boards(void)
1104 {
1105 int i;
1106 i2eBordStrPtr pB;
1107
1108 /* Service every board on the list */
1109 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
1110 pB = i2BoardPtrTable[i];
1111 if ( pB ) {
1112 i2ServiceBoard( pB );
1113 }
1114 }
1115 }
1116
1117
1118 /******************************************************************************/
1119 /* Function: ip2_interrupt_bh(work) */
1120 /* Parameters: work - pointer to the board structure */
1121 /* Returns: Nothing */
1122 /* */
1123 /* Description: */
1124 /* Service the board in a bottom half interrupt handler and then */
1125 /* reenable the board's interrupts if it has an IRQ number */
1126 /* */
1127 /******************************************************************************/
1128 static void
1129 ip2_interrupt_bh(struct work_struct *work)
1130 {
1131 i2eBordStrPtr pB = container_of(work, i2eBordStr, tqueue_interrupt);
1132 // pB better well be set or we have a problem! We can only get
1133 // here from the IMMEDIATE queue. Here, we process the boards.
1134 // Checking pB doesn't cost much and it saves us from the sanity checkers.
1135
1136 bh_counter++;
1137
1138 if ( pB ) {
1139 i2ServiceBoard( pB );
1140 if( pB->i2eUsingIrq ) {
1141 // Re-enable his interrupts
1142 iiEnableMailIrq(pB);
1143 }
1144 }
1145 }
1146
1147
1148 /******************************************************************************/
1149 /* Function: ip2_interrupt(int irq, void *dev_id) */
1150 /* Parameters: irq - interrupt number */
1151 /* pointer to optional device ID structure */
1152 /* Returns: Nothing */
1153 /* */
1154 /* Description: */
1155 /* */
1156 /* Our task here is simply to identify each board which needs servicing. */
1157 /* If we are queuing then, queue it to be serviced, and disable its irq */
1158 /* mask otherwise process the board directly. */
1159 /* */
1160 /* We could queue by IRQ but that just complicates things on both ends */
1161 /* with very little gain in performance (how many instructions does */
1162 /* it take to iterate on the immediate queue). */
1163 /* */
1164 /* */
1165 /******************************************************************************/
1166 static void
1167 ip2_irq_work(i2eBordStrPtr pB)
1168 {
1169 #ifdef USE_IQI
1170 if (NO_MAIL_HERE != ( pB->i2eStartMail = iiGetMail(pB))) {
1171 // Disable his interrupt (will be enabled when serviced)
1172 // This is mostly to protect from reentrancy.
1173 iiDisableMailIrq(pB);
1174
1175 // Park the board on the immediate queue for processing.
1176 schedule_work(&pB->tqueue_interrupt);
1177
1178 // Make sure the immediate queue is flagged to fire.
1179 }
1180 #else
1181
1182 // We are using immediate servicing here. This sucks and can
1183 // cause all sorts of havoc with ppp and others. The failsafe
1184 // check on iiSendPendingMail could also throw a hairball.
1185
1186 i2ServiceBoard( pB );
1187
1188 #endif /* USE_IQI */
1189 }
1190
1191 static void
1192 ip2_polled_interrupt(void)
1193 {
1194 int i;
1195 i2eBordStrPtr pB;
1196 const int irq = 0;
1197
1198 ip2trace (ITRC_NO_PORT, ITRC_INTR, 99, 1, irq );
1199
1200 /* Service just the boards on the list using this irq */
1201 for( i = 0; i < i2nBoards; ++i ) {
1202 pB = i2BoardPtrTable[i];
1203
1204 // Only process those boards which match our IRQ.
1205 // IRQ = 0 for polled boards, we won't poll "IRQ" boards
1206
1207 if ( pB && (pB->i2eUsingIrq == irq) ) {
1208 ip2_irq_work(pB);
1209 }
1210 }
1211
1212 ++irq_counter;
1213
1214 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1215 }
1216
1217 static irqreturn_t
1218 ip2_interrupt(int irq, void *dev_id)
1219 {
1220 i2eBordStrPtr pB = dev_id;
1221
1222 ip2trace (ITRC_NO_PORT, ITRC_INTR, 99, 1, pB->i2eUsingIrq );
1223
1224 ip2_irq_work(pB);
1225
1226 ++irq_counter;
1227
1228 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1229 return IRQ_HANDLED;
1230 }
1231
1232 /******************************************************************************/
1233 /* Function: ip2_poll(unsigned long arg) */
1234 /* Parameters: ? */
1235 /* Returns: Nothing */
1236 /* */
1237 /* Description: */
1238 /* This function calls the library routine i2ServiceBoard for each board in */
1239 /* the board table. This is used instead of the interrupt routine when polled */
1240 /* mode is specified. */
1241 /******************************************************************************/
1242 static void
1243 ip2_poll(unsigned long arg)
1244 {
1245 ip2trace (ITRC_NO_PORT, ITRC_INTR, 100, 0 );
1246
1247 TimerOn = 0; // it's the truth but not checked in service
1248
1249 // Just polled boards, IRQ = 0 will hit all non-interrupt boards.
1250 // It will NOT poll boards handled by hard interrupts.
1251 // The issue of queued BH interrupts is handled in ip2_interrupt().
1252 ip2_polled_interrupt();
1253
1254 PollTimer.expires = POLL_TIMEOUT;
1255 add_timer( &PollTimer );
1256 TimerOn = 1;
1257
1258 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1259 }
1260
1261 static void do_input(struct work_struct *work)
1262 {
1263 i2ChanStrPtr pCh = container_of(work, i2ChanStr, tqueue_input);
1264 unsigned long flags;
1265
1266 ip2trace(CHANN, ITRC_INPUT, 21, 0 );
1267
1268 // Data input
1269 if ( pCh->pTTY != NULL ) {
1270 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1271 if (!pCh->throttled && (pCh->Ibuf_stuff != pCh->Ibuf_strip)) {
1272 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1273 i2Input( pCh );
1274 } else
1275 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1276 } else {
1277 ip2trace(CHANN, ITRC_INPUT, 22, 0 );
1278
1279 i2InputFlush( pCh );
1280 }
1281 }
1282
1283 // code duplicated from n_tty (ldisc)
1284 static inline void isig(int sig, struct tty_struct *tty, int flush)
1285 {
1286 if (tty->pgrp)
1287 kill_pgrp(tty->pgrp, sig, 1);
1288 if (flush || !L_NOFLSH(tty)) {
1289 if ( tty->ldisc.flush_buffer )
1290 tty->ldisc.flush_buffer(tty);
1291 i2InputFlush( tty->driver_data );
1292 }
1293 }
1294
1295 static void do_status(struct work_struct *work)
1296 {
1297 i2ChanStrPtr pCh = container_of(work, i2ChanStr, tqueue_status);
1298 int status;
1299
1300 status = i2GetStatus( pCh, (I2_BRK|I2_PAR|I2_FRA|I2_OVR) );
1301
1302 ip2trace (CHANN, ITRC_STATUS, 21, 1, status );
1303
1304 if (pCh->pTTY && (status & (I2_BRK|I2_PAR|I2_FRA|I2_OVR)) ) {
1305 if ( (status & I2_BRK) ) {
1306 // code duplicated from n_tty (ldisc)
1307 if (I_IGNBRK(pCh->pTTY))
1308 goto skip_this;
1309 if (I_BRKINT(pCh->pTTY)) {
1310 isig(SIGINT, pCh->pTTY, 1);
1311 goto skip_this;
1312 }
1313 wake_up_interruptible(&pCh->pTTY->read_wait);
1314 }
1315 #ifdef NEVER_HAPPENS_AS_SETUP_XXX
1316 // and can't work because we don't know the_char
1317 // as the_char is reported on a separate path
1318 // The intelligent board does this stuff as setup
1319 {
1320 char brkf = TTY_NORMAL;
1321 unsigned char brkc = '\0';
1322 unsigned char tmp;
1323 if ( (status & I2_BRK) ) {
1324 brkf = TTY_BREAK;
1325 brkc = '\0';
1326 }
1327 else if (status & I2_PAR) {
1328 brkf = TTY_PARITY;
1329 brkc = the_char;
1330 } else if (status & I2_FRA) {
1331 brkf = TTY_FRAME;
1332 brkc = the_char;
1333 } else if (status & I2_OVR) {
1334 brkf = TTY_OVERRUN;
1335 brkc = the_char;
1336 }
1337 tmp = pCh->pTTY->real_raw;
1338 pCh->pTTY->real_raw = 0;
1339 pCh->pTTY->ldisc.receive_buf( pCh->pTTY, &brkc, &brkf, 1 );
1340 pCh->pTTY->real_raw = tmp;
1341 }
1342 #endif /* NEVER_HAPPENS_AS_SETUP_XXX */
1343 }
1344 skip_this:
1345
1346 if ( status & (I2_DDCD | I2_DDSR | I2_DCTS | I2_DRI) ) {
1347 wake_up_interruptible(&pCh->delta_msr_wait);
1348
1349 if ( (pCh->flags & ASYNC_CHECK_CD) && (status & I2_DDCD) ) {
1350 if ( status & I2_DCD ) {
1351 if ( pCh->wopen ) {
1352 wake_up_interruptible ( &pCh->open_wait );
1353 }
1354 } else {
1355 if (pCh->pTTY && (!(pCh->pTTY->termios->c_cflag & CLOCAL)) ) {
1356 tty_hangup( pCh->pTTY );
1357 }
1358 }
1359 }
1360 }
1361
1362 ip2trace (CHANN, ITRC_STATUS, 26, 0 );
1363 }
1364
1365 /******************************************************************************/
1366 /* Device Open/Close/Ioctl Entry Point Section */
1367 /******************************************************************************/
1368
1369 /******************************************************************************/
1370 /* Function: open_sanity_check() */
1371 /* Parameters: Pointer to tty structure */
1372 /* Pointer to file structure */
1373 /* Returns: Success or failure */
1374 /* */
1375 /* Description: */
1376 /* Verifies the structure magic numbers and cross links. */
1377 /******************************************************************************/
1378 #ifdef IP2DEBUG_OPEN
1379 static void
1380 open_sanity_check( i2ChanStrPtr pCh, i2eBordStrPtr pBrd )
1381 {
1382 if ( pBrd->i2eValid != I2E_MAGIC ) {
1383 printk(KERN_ERR "IP2: invalid board structure\n" );
1384 } else if ( pBrd != pCh->pMyBord ) {
1385 printk(KERN_ERR "IP2: board structure pointer mismatch (%p)\n",
1386 pCh->pMyBord );
1387 } else if ( pBrd->i2eChannelCnt < pCh->port_index ) {
1388 printk(KERN_ERR "IP2: bad device index (%d)\n", pCh->port_index );
1389 } else if (&((i2ChanStrPtr)pBrd->i2eChannelPtr)[pCh->port_index] != pCh) {
1390 } else {
1391 printk(KERN_INFO "IP2: all pointers check out!\n" );
1392 }
1393 }
1394 #endif
1395
1396
1397 /******************************************************************************/
1398 /* Function: ip2_open() */
1399 /* Parameters: Pointer to tty structure */
1400 /* Pointer to file structure */
1401 /* Returns: Success or failure */
1402 /* */
1403 /* Description: (MANDATORY) */
1404 /* A successful device open has to run a gauntlet of checks before it */
1405 /* completes. After some sanity checking and pointer setup, the function */
1406 /* blocks until all conditions are satisfied. It then initialises the port to */
1407 /* the default characteristics and returns. */
1408 /******************************************************************************/
1409 static int
1410 ip2_open( PTTY tty, struct file *pFile )
1411 {
1412 wait_queue_t wait;
1413 int rc = 0;
1414 int do_clocal = 0;
1415 i2ChanStrPtr pCh = DevTable[tty->index];
1416
1417 ip2trace (tty->index, ITRC_OPEN, ITRC_ENTER, 0 );
1418
1419 if ( pCh == NULL ) {
1420 return -ENODEV;
1421 }
1422 /* Setup pointer links in device and tty structures */
1423 pCh->pTTY = tty;
1424 tty->driver_data = pCh;
1425
1426 #ifdef IP2DEBUG_OPEN
1427 printk(KERN_DEBUG \
1428 "IP2:open(tty=%p,pFile=%p):dev=%s,ch=%d,idx=%d\n",
1429 tty, pFile, tty->name, pCh->infl.hd.i2sChannel, pCh->port_index);
1430 open_sanity_check ( pCh, pCh->pMyBord );
1431 #endif
1432
1433 i2QueueCommands(PTYPE_INLINE, pCh, 100, 3, CMD_DTRUP,CMD_RTSUP,CMD_DCD_REP);
1434 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1435 serviceOutgoingFifo( pCh->pMyBord );
1436
1437 /* Block here until the port is ready (per serial and istallion) */
1438 /*
1439 * 1. If the port is in the middle of closing wait for the completion
1440 * and then return the appropriate error.
1441 */
1442 init_waitqueue_entry(&wait, current);
1443 add_wait_queue(&pCh->close_wait, &wait);
1444 set_current_state( TASK_INTERRUPTIBLE );
1445
1446 if ( tty_hung_up_p(pFile) || ( pCh->flags & ASYNC_CLOSING )) {
1447 if ( pCh->flags & ASYNC_CLOSING ) {
1448 schedule();
1449 }
1450 if ( tty_hung_up_p(pFile) ) {
1451 set_current_state( TASK_RUNNING );
1452 remove_wait_queue(&pCh->close_wait, &wait);
1453 return( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS;
1454 }
1455 }
1456 set_current_state( TASK_RUNNING );
1457 remove_wait_queue(&pCh->close_wait, &wait);
1458
1459 /*
1460 * 3. Handle a non-blocking open of a normal port.
1461 */
1462 if ( (pFile->f_flags & O_NONBLOCK) || (tty->flags & (1<<TTY_IO_ERROR) )) {
1463 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1464 goto noblock;
1465 }
1466 /*
1467 * 4. Now loop waiting for the port to be free and carrier present
1468 * (if required).
1469 */
1470 if ( tty->termios->c_cflag & CLOCAL )
1471 do_clocal = 1;
1472
1473 #ifdef IP2DEBUG_OPEN
1474 printk(KERN_DEBUG "OpenBlock: do_clocal = %d\n", do_clocal);
1475 #endif
1476
1477 ++pCh->wopen;
1478
1479 init_waitqueue_entry(&wait, current);
1480 add_wait_queue(&pCh->open_wait, &wait);
1481
1482 for(;;) {
1483 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
1484 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1485 set_current_state( TASK_INTERRUPTIBLE );
1486 serviceOutgoingFifo( pCh->pMyBord );
1487 if ( tty_hung_up_p(pFile) ) {
1488 set_current_state( TASK_RUNNING );
1489 remove_wait_queue(&pCh->open_wait, &wait);
1490 return ( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EBUSY : -ERESTARTSYS;
1491 }
1492 if (!(pCh->flags & ASYNC_CLOSING) &&
1493 (do_clocal || (pCh->dataSetIn & I2_DCD) )) {
1494 rc = 0;
1495 break;
1496 }
1497
1498 #ifdef IP2DEBUG_OPEN
1499 printk(KERN_DEBUG "ASYNC_CLOSING = %s\n",
1500 (pCh->flags & ASYNC_CLOSING)?"True":"False");
1501 printk(KERN_DEBUG "OpenBlock: waiting for CD or signal\n");
1502 #endif
1503 ip2trace (CHANN, ITRC_OPEN, 3, 2, 0,
1504 (pCh->flags & ASYNC_CLOSING) );
1505 /* check for signal */
1506 if (signal_pending(current)) {
1507 rc = (( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS);
1508 break;
1509 }
1510 schedule();
1511 }
1512 set_current_state( TASK_RUNNING );
1513 remove_wait_queue(&pCh->open_wait, &wait);
1514
1515 --pCh->wopen; //why count?
1516
1517 ip2trace (CHANN, ITRC_OPEN, 4, 0 );
1518
1519 if (rc != 0 ) {
1520 return rc;
1521 }
1522 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1523
1524 noblock:
1525
1526 /* first open - Assign termios structure to port */
1527 if ( tty->count == 1 ) {
1528 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1529 /* Now we must send the termios settings to the loadware */
1530 set_params( pCh, NULL );
1531 }
1532
1533 /*
1534 * Now set any i2lib options. These may go away if the i2lib code ends
1535 * up rolled into the mainline.
1536 */
1537 pCh->channelOptions |= CO_NBLOCK_WRITE;
1538
1539 #ifdef IP2DEBUG_OPEN
1540 printk (KERN_DEBUG "IP2: open completed\n" );
1541 #endif
1542 serviceOutgoingFifo( pCh->pMyBord );
1543
1544 ip2trace (CHANN, ITRC_OPEN, ITRC_RETURN, 0 );
1545
1546 return 0;
1547 }
1548
1549 /******************************************************************************/
1550 /* Function: ip2_close() */
1551 /* Parameters: Pointer to tty structure */
1552 /* Pointer to file structure */
1553 /* Returns: Nothing */
1554 /* */
1555 /* Description: */
1556 /* */
1557 /* */
1558 /******************************************************************************/
1559 static void
1560 ip2_close( PTTY tty, struct file *pFile )
1561 {
1562 i2ChanStrPtr pCh = tty->driver_data;
1563
1564 if ( !pCh ) {
1565 return;
1566 }
1567
1568 ip2trace (CHANN, ITRC_CLOSE, ITRC_ENTER, 0 );
1569
1570 #ifdef IP2DEBUG_OPEN
1571 printk(KERN_DEBUG "IP2:close %s:\n",tty->name);
1572 #endif
1573
1574 if ( tty_hung_up_p ( pFile ) ) {
1575
1576 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 2 );
1577
1578 return;
1579 }
1580 if ( tty->count > 1 ) { /* not the last close */
1581
1582 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 3 );
1583
1584 return;
1585 }
1586 pCh->flags |= ASYNC_CLOSING; // last close actually
1587
1588 tty->closing = 1;
1589
1590 if (pCh->ClosingWaitTime != ASYNC_CLOSING_WAIT_NONE) {
1591 /*
1592 * Before we drop DTR, make sure the transmitter has completely drained.
1593 * This uses an timeout, after which the close
1594 * completes.
1595 */
1596 ip2_wait_until_sent(tty, pCh->ClosingWaitTime );
1597 }
1598 /*
1599 * At this point we stop accepting input. Here we flush the channel
1600 * input buffer which will allow the board to send up more data. Any
1601 * additional input is tossed at interrupt/poll time.
1602 */
1603 i2InputFlush( pCh );
1604
1605 /* disable DSS reporting */
1606 i2QueueCommands(PTYPE_INLINE, pCh, 100, 4,
1607 CMD_DCD_NREP, CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1608 if ( !tty || (tty->termios->c_cflag & HUPCL) ) {
1609 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
1610 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1611 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1612 }
1613
1614 serviceOutgoingFifo ( pCh->pMyBord );
1615
1616 if ( tty->driver->flush_buffer )
1617 tty->driver->flush_buffer(tty);
1618 if ( tty->ldisc.flush_buffer )
1619 tty->ldisc.flush_buffer(tty);
1620 tty->closing = 0;
1621
1622 pCh->pTTY = NULL;
1623
1624 if (pCh->wopen) {
1625 if (pCh->ClosingDelay) {
1626 msleep_interruptible(jiffies_to_msecs(pCh->ClosingDelay));
1627 }
1628 wake_up_interruptible(&pCh->open_wait);
1629 }
1630
1631 pCh->flags &=~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1632 wake_up_interruptible(&pCh->close_wait);
1633
1634 #ifdef IP2DEBUG_OPEN
1635 DBG_CNT("ip2_close: after wakeups--");
1636 #endif
1637
1638
1639 ip2trace (CHANN, ITRC_CLOSE, ITRC_RETURN, 1, 1 );
1640
1641 return;
1642 }
1643
1644 /******************************************************************************/
1645 /* Function: ip2_hangup() */
1646 /* Parameters: Pointer to tty structure */
1647 /* Returns: Nothing */
1648 /* */
1649 /* Description: */
1650 /* */
1651 /* */
1652 /******************************************************************************/
1653 static void
1654 ip2_hangup ( PTTY tty )
1655 {
1656 i2ChanStrPtr pCh = tty->driver_data;
1657
1658 if( !pCh ) {
1659 return;
1660 }
1661
1662 ip2trace (CHANN, ITRC_HANGUP, ITRC_ENTER, 0 );
1663
1664 ip2_flush_buffer(tty);
1665
1666 /* disable DSS reporting */
1667
1668 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_DCD_NREP);
1669 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1670 if ( (tty->termios->c_cflag & HUPCL) ) {
1671 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 2, CMD_RTSDN, CMD_DTRDN);
1672 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1673 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1674 }
1675 i2QueueCommands(PTYPE_INLINE, pCh, 1, 3,
1676 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1677 serviceOutgoingFifo ( pCh->pMyBord );
1678
1679 wake_up_interruptible ( &pCh->delta_msr_wait );
1680
1681 pCh->flags &= ~ASYNC_NORMAL_ACTIVE;
1682 pCh->pTTY = NULL;
1683 wake_up_interruptible ( &pCh->open_wait );
1684
1685 ip2trace (CHANN, ITRC_HANGUP, ITRC_RETURN, 0 );
1686 }
1687
1688 /******************************************************************************/
1689 /******************************************************************************/
1690 /* Device Output Section */
1691 /******************************************************************************/
1692 /******************************************************************************/
1693
1694 /******************************************************************************/
1695 /* Function: ip2_write() */
1696 /* Parameters: Pointer to tty structure */
1697 /* Flag denoting data is in user (1) or kernel (0) space */
1698 /* Pointer to data */
1699 /* Number of bytes to write */
1700 /* Returns: Number of bytes actually written */
1701 /* */
1702 /* Description: (MANDATORY) */
1703 /* */
1704 /* */
1705 /******************************************************************************/
1706 static int
1707 ip2_write( PTTY tty, const unsigned char *pData, int count)
1708 {
1709 i2ChanStrPtr pCh = tty->driver_data;
1710 int bytesSent = 0;
1711 unsigned long flags;
1712
1713 ip2trace (CHANN, ITRC_WRITE, ITRC_ENTER, 2, count, -1 );
1714
1715 /* Flush out any buffered data left over from ip2_putchar() calls. */
1716 ip2_flush_chars( tty );
1717
1718 /* This is the actual move bit. Make sure it does what we need!!!!! */
1719 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1720 bytesSent = i2Output( pCh, pData, count);
1721 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1722
1723 ip2trace (CHANN, ITRC_WRITE, ITRC_RETURN, 1, bytesSent );
1724
1725 return bytesSent > 0 ? bytesSent : 0;
1726 }
1727
1728 /******************************************************************************/
1729 /* Function: ip2_putchar() */
1730 /* Parameters: Pointer to tty structure */
1731 /* Character to write */
1732 /* Returns: Nothing */
1733 /* */
1734 /* Description: */
1735 /* */
1736 /* */
1737 /******************************************************************************/
1738 static void
1739 ip2_putchar( PTTY tty, unsigned char ch )
1740 {
1741 i2ChanStrPtr pCh = tty->driver_data;
1742 unsigned long flags;
1743
1744 // ip2trace (CHANN, ITRC_PUTC, ITRC_ENTER, 1, ch );
1745
1746 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1747 pCh->Pbuf[pCh->Pbuf_stuff++] = ch;
1748 if ( pCh->Pbuf_stuff == sizeof pCh->Pbuf ) {
1749 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1750 ip2_flush_chars( tty );
1751 } else
1752 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1753
1754 // ip2trace (CHANN, ITRC_PUTC, ITRC_RETURN, 1, ch );
1755 }
1756
1757 /******************************************************************************/
1758 /* Function: ip2_flush_chars() */
1759 /* Parameters: Pointer to tty structure */
1760 /* Returns: Nothing */
1761 /* */
1762 /* Description: */
1763 /* */
1764 /******************************************************************************/
1765 static void
1766 ip2_flush_chars( PTTY tty )
1767 {
1768 int strip;
1769 i2ChanStrPtr pCh = tty->driver_data;
1770 unsigned long flags;
1771
1772 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1773 if ( pCh->Pbuf_stuff ) {
1774
1775 // ip2trace (CHANN, ITRC_PUTC, 10, 1, strip );
1776
1777 //
1778 // We may need to restart i2Output if it does not fullfill this request
1779 //
1780 strip = i2Output( pCh, pCh->Pbuf, pCh->Pbuf_stuff);
1781 if ( strip != pCh->Pbuf_stuff ) {
1782 memmove( pCh->Pbuf, &pCh->Pbuf[strip], pCh->Pbuf_stuff - strip );
1783 }
1784 pCh->Pbuf_stuff -= strip;
1785 }
1786 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1787 }
1788
1789 /******************************************************************************/
1790 /* Function: ip2_write_room() */
1791 /* Parameters: Pointer to tty structure */
1792 /* Returns: Number of bytes that the driver can accept */
1793 /* */
1794 /* Description: */
1795 /* */
1796 /******************************************************************************/
1797 static int
1798 ip2_write_room ( PTTY tty )
1799 {
1800 int bytesFree;
1801 i2ChanStrPtr pCh = tty->driver_data;
1802 unsigned long flags;
1803
1804 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1805 bytesFree = i2OutputFree( pCh ) - pCh->Pbuf_stuff;
1806 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1807
1808 ip2trace (CHANN, ITRC_WRITE, 11, 1, bytesFree );
1809
1810 return ((bytesFree > 0) ? bytesFree : 0);
1811 }
1812
1813 /******************************************************************************/
1814 /* Function: ip2_chars_in_buf() */
1815 /* Parameters: Pointer to tty structure */
1816 /* Returns: Number of bytes queued for transmission */
1817 /* */
1818 /* Description: */
1819 /* */
1820 /* */
1821 /******************************************************************************/
1822 static int
1823 ip2_chars_in_buf ( PTTY tty )
1824 {
1825 i2ChanStrPtr pCh = tty->driver_data;
1826 int rc;
1827 unsigned long flags;
1828
1829 ip2trace (CHANN, ITRC_WRITE, 12, 1, pCh->Obuf_char_count + pCh->Pbuf_stuff );
1830
1831 #ifdef IP2DEBUG_WRITE
1832 printk (KERN_DEBUG "IP2: chars in buffer = %d (%d,%d)\n",
1833 pCh->Obuf_char_count + pCh->Pbuf_stuff,
1834 pCh->Obuf_char_count, pCh->Pbuf_stuff );
1835 #endif
1836 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1837 rc = pCh->Obuf_char_count;
1838 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1839 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1840 rc += pCh->Pbuf_stuff;
1841 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1842 return rc;
1843 }
1844
1845 /******************************************************************************/
1846 /* Function: ip2_flush_buffer() */
1847 /* Parameters: Pointer to tty structure */
1848 /* Returns: Nothing */
1849 /* */
1850 /* Description: */
1851 /* */
1852 /* */
1853 /******************************************************************************/
1854 static void
1855 ip2_flush_buffer( PTTY tty )
1856 {
1857 i2ChanStrPtr pCh = tty->driver_data;
1858 unsigned long flags;
1859
1860 ip2trace (CHANN, ITRC_FLUSH, ITRC_ENTER, 0 );
1861
1862 #ifdef IP2DEBUG_WRITE
1863 printk (KERN_DEBUG "IP2: flush buffer\n" );
1864 #endif
1865 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1866 pCh->Pbuf_stuff = 0;
1867 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1868 i2FlushOutput( pCh );
1869 ip2_owake(tty);
1870
1871 ip2trace (CHANN, ITRC_FLUSH, ITRC_RETURN, 0 );
1872
1873 }
1874
1875 /******************************************************************************/
1876 /* Function: ip2_wait_until_sent() */
1877 /* Parameters: Pointer to tty structure */
1878 /* Timeout for wait. */
1879 /* Returns: Nothing */
1880 /* */
1881 /* Description: */
1882 /* This function is used in place of the normal tty_wait_until_sent, which */
1883 /* only waits for the driver buffers to be empty (or rather, those buffers */
1884 /* reported by chars_in_buffer) which doesn't work for IP2 due to the */
1885 /* indeterminate number of bytes buffered on the board. */
1886 /******************************************************************************/
1887 static void
1888 ip2_wait_until_sent ( PTTY tty, int timeout )
1889 {
1890 int i = jiffies;
1891 i2ChanStrPtr pCh = tty->driver_data;
1892
1893 tty_wait_until_sent(tty, timeout );
1894 if ( (i = timeout - (jiffies -i)) > 0)
1895 i2DrainOutput( pCh, i );
1896 }
1897
1898 /******************************************************************************/
1899 /******************************************************************************/
1900 /* Device Input Section */
1901 /******************************************************************************/
1902 /******************************************************************************/
1903
1904 /******************************************************************************/
1905 /* Function: ip2_throttle() */
1906 /* Parameters: Pointer to tty structure */
1907 /* Returns: Nothing */
1908 /* */
1909 /* Description: */
1910 /* */
1911 /* */
1912 /******************************************************************************/
1913 static void
1914 ip2_throttle ( PTTY tty )
1915 {
1916 i2ChanStrPtr pCh = tty->driver_data;
1917
1918 #ifdef IP2DEBUG_READ
1919 printk (KERN_DEBUG "IP2: throttle\n" );
1920 #endif
1921 /*
1922 * Signal the poll/interrupt handlers not to forward incoming data to
1923 * the line discipline. This will cause the buffers to fill up in the
1924 * library and thus cause the library routines to send the flow control
1925 * stuff.
1926 */
1927 pCh->throttled = 1;
1928 }
1929
1930 /******************************************************************************/
1931 /* Function: ip2_unthrottle() */
1932 /* Parameters: Pointer to tty structure */
1933 /* Returns: Nothing */
1934 /* */
1935 /* Description: */
1936 /* */
1937 /* */
1938 /******************************************************************************/
1939 static void
1940 ip2_unthrottle ( PTTY tty )
1941 {
1942 i2ChanStrPtr pCh = tty->driver_data;
1943 unsigned long flags;
1944
1945 #ifdef IP2DEBUG_READ
1946 printk (KERN_DEBUG "IP2: unthrottle\n" );
1947 #endif
1948
1949 /* Pass incoming data up to the line discipline again. */
1950 pCh->throttled = 0;
1951 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1952 serviceOutgoingFifo( pCh->pMyBord );
1953 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1954 if ( pCh->Ibuf_stuff != pCh->Ibuf_strip ) {
1955 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1956 #ifdef IP2DEBUG_READ
1957 printk (KERN_DEBUG "i2Input called from unthrottle\n" );
1958 #endif
1959 i2Input( pCh );
1960 } else
1961 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1962 }
1963
1964 static void
1965 ip2_start ( PTTY tty )
1966 {
1967 i2ChanStrPtr pCh = DevTable[tty->index];
1968
1969 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1970 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_UNSUSPEND);
1971 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_RESUME);
1972 #ifdef IP2DEBUG_WRITE
1973 printk (KERN_DEBUG "IP2: start tx\n" );
1974 #endif
1975 }
1976
1977 static void
1978 ip2_stop ( PTTY tty )
1979 {
1980 i2ChanStrPtr pCh = DevTable[tty->index];
1981
1982 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_SUSPEND);
1983 #ifdef IP2DEBUG_WRITE
1984 printk (KERN_DEBUG "IP2: stop tx\n" );
1985 #endif
1986 }
1987
1988 /******************************************************************************/
1989 /* Device Ioctl Section */
1990 /******************************************************************************/
1991
1992 static int ip2_tiocmget(struct tty_struct *tty, struct file *file)
1993 {
1994 i2ChanStrPtr pCh = DevTable[tty->index];
1995 #ifdef ENABLE_DSSNOW
1996 wait_queue_t wait;
1997 #endif
1998
1999 if (pCh == NULL)
2000 return -ENODEV;
2001
2002 /*
2003 FIXME - the following code is causing a NULL pointer dereference in
2004 2.3.51 in an interrupt handler. It's suppose to prompt the board
2005 to return the DSS signal status immediately. Why doesn't it do
2006 the same thing in 2.2.14?
2007 */
2008
2009 /* This thing is still busted in the 1.2.12 driver on 2.4.x
2010 and even hoses the serial console so the oops can be trapped.
2011 /\/\|=mhw=|\/\/ */
2012
2013 #ifdef ENABLE_DSSNOW
2014 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DSS_NOW);
2015
2016 init_waitqueue_entry(&wait, current);
2017 add_wait_queue(&pCh->dss_now_wait, &wait);
2018 set_current_state( TASK_INTERRUPTIBLE );
2019
2020 serviceOutgoingFifo( pCh->pMyBord );
2021
2022 schedule();
2023
2024 set_current_state( TASK_RUNNING );
2025 remove_wait_queue(&pCh->dss_now_wait, &wait);
2026
2027 if (signal_pending(current)) {
2028 return -EINTR;
2029 }
2030 #endif
2031 return ((pCh->dataSetOut & I2_RTS) ? TIOCM_RTS : 0)
2032 | ((pCh->dataSetOut & I2_DTR) ? TIOCM_DTR : 0)
2033 | ((pCh->dataSetIn & I2_DCD) ? TIOCM_CAR : 0)
2034 | ((pCh->dataSetIn & I2_RI) ? TIOCM_RNG : 0)
2035 | ((pCh->dataSetIn & I2_DSR) ? TIOCM_DSR : 0)
2036 | ((pCh->dataSetIn & I2_CTS) ? TIOCM_CTS : 0);
2037 }
2038
2039 static int ip2_tiocmset(struct tty_struct *tty, struct file *file,
2040 unsigned int set, unsigned int clear)
2041 {
2042 i2ChanStrPtr pCh = DevTable[tty->index];
2043
2044 if (pCh == NULL)
2045 return -ENODEV;
2046
2047 if (set & TIOCM_RTS) {
2048 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSUP);
2049 pCh->dataSetOut |= I2_RTS;
2050 }
2051 if (set & TIOCM_DTR) {
2052 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRUP);
2053 pCh->dataSetOut |= I2_DTR;
2054 }
2055
2056 if (clear & TIOCM_RTS) {
2057 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSDN);
2058 pCh->dataSetOut &= ~I2_RTS;
2059 }
2060 if (clear & TIOCM_DTR) {
2061 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRDN);
2062 pCh->dataSetOut &= ~I2_DTR;
2063 }
2064 serviceOutgoingFifo( pCh->pMyBord );
2065 return 0;
2066 }
2067
2068 /******************************************************************************/
2069 /* Function: ip2_ioctl() */
2070 /* Parameters: Pointer to tty structure */
2071 /* Pointer to file structure */
2072 /* Command */
2073 /* Argument */
2074 /* Returns: Success or failure */
2075 /* */
2076 /* Description: */
2077 /* */
2078 /* */
2079 /******************************************************************************/
2080 static int
2081 ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
2082 {
2083 wait_queue_t wait;
2084 i2ChanStrPtr pCh = DevTable[tty->index];
2085 i2eBordStrPtr pB;
2086 struct async_icount cprev, cnow; /* kernel counter temps */
2087 struct serial_icounter_struct __user *p_cuser;
2088 int rc = 0;
2089 unsigned long flags;
2090 void __user *argp = (void __user *)arg;
2091
2092 if ( pCh == NULL )
2093 return -ENODEV;
2094
2095 pB = pCh->pMyBord;
2096
2097 ip2trace (CHANN, ITRC_IOCTL, ITRC_ENTER, 2, cmd, arg );
2098
2099 #ifdef IP2DEBUG_IOCTL
2100 printk(KERN_DEBUG "IP2: ioctl cmd (%x), arg (%lx)\n", cmd, arg );
2101 #endif
2102
2103 switch(cmd) {
2104 case TIOCGSERIAL:
2105
2106 ip2trace (CHANN, ITRC_IOCTL, 2, 1, rc );
2107
2108 rc = get_serial_info(pCh, argp);
2109 if (rc)
2110 return rc;
2111 break;
2112
2113 case TIOCSSERIAL:
2114
2115 ip2trace (CHANN, ITRC_IOCTL, 3, 1, rc );
2116
2117 rc = set_serial_info(pCh, argp);
2118 if (rc)
2119 return rc;
2120 break;
2121
2122 case TCXONC:
2123 rc = tty_check_change(tty);
2124 if (rc)
2125 return rc;
2126 switch (arg) {
2127 case TCOOFF:
2128 //return -ENOIOCTLCMD;
2129 break;
2130 case TCOON:
2131 //return -ENOIOCTLCMD;
2132 break;
2133 case TCIOFF:
2134 if (STOP_CHAR(tty) != __DISABLED_CHAR) {
2135 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2136 CMD_XMIT_NOW(STOP_CHAR(tty)));
2137 }
2138 break;
2139 case TCION:
2140 if (START_CHAR(tty) != __DISABLED_CHAR) {
2141 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2142 CMD_XMIT_NOW(START_CHAR(tty)));
2143 }
2144 break;
2145 default:
2146 return -EINVAL;
2147 }
2148 return 0;
2149
2150 case TCSBRK: /* SVID version: non-zero arg --> no break */
2151 rc = tty_check_change(tty);
2152
2153 ip2trace (CHANN, ITRC_IOCTL, 4, 1, rc );
2154
2155 if (!rc) {
2156 ip2_wait_until_sent(tty,0);
2157 if (!arg) {
2158 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SEND_BRK(250));
2159 serviceOutgoingFifo( pCh->pMyBord );
2160 }
2161 }
2162 break;
2163
2164 case TCSBRKP: /* support for POSIX tcsendbreak() */
2165 rc = tty_check_change(tty);
2166
2167 ip2trace (CHANN, ITRC_IOCTL, 5, 1, rc );
2168
2169 if (!rc) {
2170 ip2_wait_until_sent(tty,0);
2171 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2172 CMD_SEND_BRK(arg ? arg*100 : 250));
2173 serviceOutgoingFifo ( pCh->pMyBord );
2174 }
2175 break;
2176
2177 case TIOCGSOFTCAR:
2178
2179 ip2trace (CHANN, ITRC_IOCTL, 6, 1, rc );
2180
2181 rc = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
2182 if (rc)
2183 return rc;
2184 break;
2185
2186 case TIOCSSOFTCAR:
2187
2188 ip2trace (CHANN, ITRC_IOCTL, 7, 1, rc );
2189
2190 rc = get_user(arg,(unsigned long __user *) argp);
2191 if (rc)
2192 return rc;
2193 tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL)
2194 | (arg ? CLOCAL : 0));
2195
2196 break;
2197
2198 /*
2199 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change - mask
2200 * passed in arg for lines of interest (use |'ed TIOCM_RNG/DSR/CD/CTS
2201 * for masking). Caller should use TIOCGICOUNT to see which one it was
2202 */
2203 case TIOCMIWAIT:
2204 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
2205 cprev = pCh->icount; /* note the counters on entry */
2206 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
2207 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 4,
2208 CMD_DCD_REP, CMD_CTS_REP, CMD_DSR_REP, CMD_RI_REP);
2209 init_waitqueue_entry(&wait, current);
2210 add_wait_queue(&pCh->delta_msr_wait, &wait);
2211 set_current_state( TASK_INTERRUPTIBLE );
2212
2213 serviceOutgoingFifo( pCh->pMyBord );
2214 for(;;) {
2215 ip2trace (CHANN, ITRC_IOCTL, 10, 0 );
2216
2217 schedule();
2218
2219 ip2trace (CHANN, ITRC_IOCTL, 11, 0 );
2220
2221 /* see if a signal did it */
2222 if (signal_pending(current)) {
2223 rc = -ERESTARTSYS;
2224 break;
2225 }
2226 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
2227 cnow = pCh->icount; /* atomic copy */
2228 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
2229 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2230 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
2231 rc = -EIO; /* no change => rc */
2232 break;
2233 }
2234 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2235 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2236 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2237 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
2238 rc = 0;
2239 break;
2240 }
2241 cprev = cnow;
2242 }
2243 set_current_state( TASK_RUNNING );
2244 remove_wait_queue(&pCh->delta_msr_wait, &wait);
2245
2246 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 3,
2247 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
2248 if ( ! (pCh->flags & ASYNC_CHECK_CD)) {
2249 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DCD_NREP);
2250 }
2251 serviceOutgoingFifo( pCh->pMyBord );
2252 return rc;
2253 break;
2254
2255 /*
2256 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2257 * Return: write counters to the user passed counter struct
2258 * NB: both 1->0 and 0->1 transitions are counted except for RI where
2259 * only 0->1 is counted. The controller is quite capable of counting
2260 * both, but this done to preserve compatibility with the standard
2261 * serial driver.
2262 */
2263 case TIOCGICOUNT:
2264 ip2trace (CHANN, ITRC_IOCTL, 11, 1, rc );
2265
2266 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
2267 cnow = pCh->icount;
2268 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
2269 p_cuser = argp;
2270 rc = put_user(cnow.cts, &p_cuser->cts);
2271 rc = put_user(cnow.dsr, &p_cuser->dsr);
2272 rc = put_user(cnow.rng, &p_cuser->rng);
2273 rc = put_user(cnow.dcd, &p_cuser->dcd);
2274 rc = put_user(cnow.rx, &p_cuser->rx);
2275 rc = put_user(cnow.tx, &p_cuser->tx);
2276 rc = put_user(cnow.frame, &p_cuser->frame);
2277 rc = put_user(cnow.overrun, &p_cuser->overrun);
2278 rc = put_user(cnow.parity, &p_cuser->parity);
2279 rc = put_user(cnow.brk, &p_cuser->brk);
2280 rc = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
2281 break;
2282
2283 /*
2284 * The rest are not supported by this driver. By returning -ENOIOCTLCMD they
2285 * will be passed to the line discipline for it to handle.
2286 */
2287 case TIOCSERCONFIG:
2288 case TIOCSERGWILD:
2289 case TIOCSERGETLSR:
2290 case TIOCSERSWILD:
2291 case TIOCSERGSTRUCT:
2292 case TIOCSERGETMULTI:
2293 case TIOCSERSETMULTI:
2294
2295 default:
2296 ip2trace (CHANN, ITRC_IOCTL, 12, 0 );
2297
2298 rc = -ENOIOCTLCMD;
2299 break;
2300 }
2301
2302 ip2trace (CHANN, ITRC_IOCTL, ITRC_RETURN, 0 );
2303
2304 return rc;
2305 }
2306
2307 /******************************************************************************/
2308 /* Function: GetSerialInfo() */
2309 /* Parameters: Pointer to channel structure */
2310 /* Pointer to old termios structure */
2311 /* Returns: Nothing */
2312 /* */
2313 /* Description: */
2314 /* This is to support the setserial command, and requires processing of the */
2315 /* standard Linux serial structure. */
2316 /******************************************************************************/
2317 static int
2318 get_serial_info ( i2ChanStrPtr pCh, struct serial_struct __user *retinfo )
2319 {
2320 struct serial_struct tmp;
2321
2322 memset ( &tmp, 0, sizeof(tmp) );
2323 tmp.type = pCh->pMyBord->channelBtypes.bid_value[(pCh->port_index & (IP2_PORTS_PER_BOARD-1))/16];
2324 if (BID_HAS_654(tmp.type)) {
2325 tmp.type = PORT_16650;
2326 } else {
2327 tmp.type = PORT_CIRRUS;
2328 }
2329 tmp.line = pCh->port_index;
2330 tmp.port = pCh->pMyBord->i2eBase;
2331 tmp.irq = ip2config.irq[pCh->port_index/64];
2332 tmp.flags = pCh->flags;
2333 tmp.baud_base = pCh->BaudBase;
2334 tmp.close_delay = pCh->ClosingDelay;
2335 tmp.closing_wait = pCh->ClosingWaitTime;
2336 tmp.custom_divisor = pCh->BaudDivisor;
2337 return copy_to_user(retinfo,&tmp,sizeof(*retinfo));
2338 }
2339
2340 /******************************************************************************/
2341 /* Function: SetSerialInfo() */
2342 /* Parameters: Pointer to channel structure */
2343 /* Pointer to old termios structure */
2344 /* Returns: Nothing */
2345 /* */
2346 /* Description: */
2347 /* This function provides support for setserial, which uses the TIOCSSERIAL */
2348 /* ioctl. Not all setserial parameters are relevant. If the user attempts to */
2349 /* change the IRQ, address or type of the port the ioctl fails. */
2350 /******************************************************************************/
2351 static int
2352 set_serial_info( i2ChanStrPtr pCh, struct serial_struct __user *new_info )
2353 {
2354 struct serial_struct ns;
2355 int old_flags, old_baud_divisor;
2356
2357 if (copy_from_user(&ns, new_info, sizeof (ns)))
2358 return -EFAULT;
2359
2360 /*
2361 * We don't allow setserial to change IRQ, board address, type or baud
2362 * base. Also line nunber as such is meaningless but we use it for our
2363 * array index so it is fixed also.
2364 */
2365 if ( (ns.irq != ip2config.irq[pCh->port_index])
2366 || ((int) ns.port != ((int) (pCh->pMyBord->i2eBase)))
2367 || (ns.baud_base != pCh->BaudBase)
2368 || (ns.line != pCh->port_index) ) {
2369 return -EINVAL;
2370 }
2371
2372 old_flags = pCh->flags;
2373 old_baud_divisor = pCh->BaudDivisor;
2374
2375 if ( !capable(CAP_SYS_ADMIN) ) {
2376 if ( ( ns.close_delay != pCh->ClosingDelay ) ||
2377 ( (ns.flags & ~ASYNC_USR_MASK) !=
2378 (pCh->flags & ~ASYNC_USR_MASK) ) ) {
2379 return -EPERM;
2380 }
2381
2382 pCh->flags = (pCh->flags & ~ASYNC_USR_MASK) |
2383 (ns.flags & ASYNC_USR_MASK);
2384 pCh->BaudDivisor = ns.custom_divisor;
2385 } else {
2386 pCh->flags = (pCh->flags & ~ASYNC_FLAGS) |
2387 (ns.flags & ASYNC_FLAGS);
2388 pCh->BaudDivisor = ns.custom_divisor;
2389 pCh->ClosingDelay = ns.close_delay * HZ/100;
2390 pCh->ClosingWaitTime = ns.closing_wait * HZ/100;
2391 }
2392
2393 if ( ( (old_flags & ASYNC_SPD_MASK) != (pCh->flags & ASYNC_SPD_MASK) )
2394 || (old_baud_divisor != pCh->BaudDivisor) ) {
2395 // Invalidate speed and reset parameters
2396 set_params( pCh, NULL );
2397 }
2398
2399 return 0;
2400 }
2401
2402 /******************************************************************************/
2403 /* Function: ip2_set_termios() */
2404 /* Parameters: Pointer to tty structure */
2405 /* Pointer to old termios structure */
2406 /* Returns: Nothing */
2407 /* */
2408 /* Description: */
2409 /* */
2410 /* */
2411 /******************************************************************************/
2412 static void
2413 ip2_set_termios( PTTY tty, struct ktermios *old_termios )
2414 {
2415 i2ChanStrPtr pCh = (i2ChanStrPtr)tty->driver_data;
2416
2417 #ifdef IP2DEBUG_IOCTL
2418 printk (KERN_DEBUG "IP2: set termios %p\n", old_termios );
2419 #endif
2420
2421 set_params( pCh, old_termios );
2422 }
2423
2424 /******************************************************************************/
2425 /* Function: ip2_set_line_discipline() */
2426 /* Parameters: Pointer to tty structure */
2427 /* Returns: Nothing */
2428 /* */
2429 /* Description: Does nothing */
2430 /* */
2431 /* */
2432 /******************************************************************************/
2433 static void
2434 ip2_set_line_discipline ( PTTY tty )
2435 {
2436 #ifdef IP2DEBUG_IOCTL
2437 printk (KERN_DEBUG "IP2: set line discipline\n" );
2438 #endif
2439
2440 ip2trace (((i2ChanStrPtr)tty->driver_data)->port_index, ITRC_IOCTL, 16, 0 );
2441
2442 }
2443
2444 /******************************************************************************/
2445 /* Function: SetLine Characteristics() */
2446 /* Parameters: Pointer to channel structure */
2447 /* Returns: Nothing */
2448 /* */
2449 /* Description: */
2450 /* This routine is called to update the channel structure with the new line */
2451 /* characteristics, and send the appropriate commands to the board when they */
2452 /* change. */
2453 /******************************************************************************/
2454 static void
2455 set_params( i2ChanStrPtr pCh, struct ktermios *o_tios )
2456 {
2457 tcflag_t cflag, iflag, lflag;
2458 char stop_char, start_char;
2459 struct ktermios dummy;
2460
2461 lflag = pCh->pTTY->termios->c_lflag;
2462 cflag = pCh->pTTY->termios->c_cflag;
2463 iflag = pCh->pTTY->termios->c_iflag;
2464
2465 if (o_tios == NULL) {
2466 dummy.c_lflag = ~lflag;
2467 dummy.c_cflag = ~cflag;
2468 dummy.c_iflag = ~iflag;
2469 o_tios = &dummy;
2470 }
2471
2472 {
2473 switch ( cflag & CBAUD ) {
2474 case B0:
2475 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
2476 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
2477 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
2478 pCh->pTTY->termios->c_cflag |= (CBAUD & o_tios->c_cflag);
2479 goto service_it;
2480 break;
2481 case B38400:
2482 /*
2483 * This is the speed that is overloaded with all the other high
2484 * speeds, depending upon the flag settings.
2485 */
2486 if ( ( pCh->flags & ASYNC_SPD_MASK ) == ASYNC_SPD_HI ) {
2487 pCh->speed = CBR_57600;
2488 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI ) {
2489 pCh->speed = CBR_115200;
2490 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST ) {
2491 pCh->speed = CBR_C1;
2492 } else {
2493 pCh->speed = CBR_38400;
2494 }
2495 break;
2496 case B50: pCh->speed = CBR_50; break;
2497 case B75: pCh->speed = CBR_75; break;
2498 case B110: pCh->speed = CBR_110; break;
2499 case B134: pCh->speed = CBR_134; break;
2500 case B150: pCh->speed = CBR_150; break;
2501 case B200: pCh->speed = CBR_200; break;
2502 case B300: pCh->speed = CBR_300; break;
2503 case B600: pCh->speed = CBR_600; break;
2504 case B1200: pCh->speed = CBR_1200; break;
2505 case B1800: pCh->speed = CBR_1800; break;
2506 case B2400: pCh->speed = CBR_2400; break;
2507 case B4800: pCh->speed = CBR_4800; break;
2508 case B9600: pCh->speed = CBR_9600; break;
2509 case B19200: pCh->speed = CBR_19200; break;
2510 case B57600: pCh->speed = CBR_57600; break;
2511 case B115200: pCh->speed = CBR_115200; break;
2512 case B153600: pCh->speed = CBR_153600; break;
2513 case B230400: pCh->speed = CBR_230400; break;
2514 case B307200: pCh->speed = CBR_307200; break;
2515 case B460800: pCh->speed = CBR_460800; break;
2516 case B921600: pCh->speed = CBR_921600; break;
2517 default: pCh->speed = CBR_9600; break;
2518 }
2519 if ( pCh->speed == CBR_C1 ) {
2520 // Process the custom speed parameters.
2521 int bps = pCh->BaudBase / pCh->BaudDivisor;
2522 if ( bps == 921600 ) {
2523 pCh->speed = CBR_921600;
2524 } else {
2525 bps = bps/10;
2526 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_BAUD_DEF1(bps) );
2527 }
2528 }
2529 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_SETBAUD(pCh->speed));
2530
2531 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
2532 pCh->dataSetOut |= (I2_DTR | I2_RTS);
2533 }
2534 if ( (CSTOPB & cflag) ^ (CSTOPB & o_tios->c_cflag))
2535 {
2536 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2537 CMD_SETSTOP( ( cflag & CSTOPB ) ? CST_2 : CST_1));
2538 }
2539 if (((PARENB|PARODD) & cflag) ^ ((PARENB|PARODD) & o_tios->c_cflag))
2540 {
2541 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2542 CMD_SETPAR(
2543 (cflag & PARENB ? (cflag & PARODD ? CSP_OD : CSP_EV) : CSP_NP)
2544 )
2545 );
2546 }
2547 /* byte size and parity */
2548 if ( (CSIZE & cflag)^(CSIZE & o_tios->c_cflag))
2549 {
2550 int datasize;
2551 switch ( cflag & CSIZE ) {
2552 case CS5: datasize = CSZ_5; break;
2553 case CS6: datasize = CSZ_6; break;
2554 case CS7: datasize = CSZ_7; break;
2555 case CS8: datasize = CSZ_8; break;
2556 default: datasize = CSZ_5; break; /* as per serial.c */
2557 }
2558 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1, CMD_SETBITS(datasize) );
2559 }
2560 /* Process CTS flow control flag setting */
2561 if ( (cflag & CRTSCTS) ) {
2562 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2563 2, CMD_CTSFL_ENAB, CMD_RTSFL_ENAB);
2564 } else {
2565 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2566 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
2567 }
2568 //
2569 // Process XON/XOFF flow control flags settings
2570 //
2571 stop_char = STOP_CHAR(pCh->pTTY);
2572 start_char = START_CHAR(pCh->pTTY);
2573
2574 //////////// can't be \000
2575 if (stop_char == __DISABLED_CHAR )
2576 {
2577 stop_char = ~__DISABLED_CHAR;
2578 }
2579 if (start_char == __DISABLED_CHAR )
2580 {
2581 start_char = ~__DISABLED_CHAR;
2582 }
2583 /////////////////////////////////
2584
2585 if ( o_tios->c_cc[VSTART] != start_char )
2586 {
2587 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXON(start_char));
2588 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXON(start_char));
2589 }
2590 if ( o_tios->c_cc[VSTOP] != stop_char )
2591 {
2592 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXOFF(stop_char));
2593 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXOFF(stop_char));
2594 }
2595 if (stop_char == __DISABLED_CHAR )
2596 {
2597 stop_char = ~__DISABLED_CHAR; //TEST123
2598 goto no_xoff;
2599 }
2600 if ((iflag & (IXOFF))^(o_tios->c_iflag & (IXOFF)))
2601 {
2602 if ( iflag & IXOFF ) { // Enable XOFF output flow control
2603 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_XON));
2604 } else { // Disable XOFF output flow control
2605 no_xoff:
2606 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_NONE));
2607 }
2608 }
2609 if (start_char == __DISABLED_CHAR )
2610 {
2611 goto no_xon;
2612 }
2613 if ((iflag & (IXON|IXANY)) ^ (o_tios->c_iflag & (IXON|IXANY)))
2614 {
2615 if ( iflag & IXON ) {
2616 if ( iflag & IXANY ) { // Enable XON/XANY output flow control
2617 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XANY));
2618 } else { // Enable XON output flow control
2619 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XON));
2620 }
2621 } else { // Disable XON output flow control
2622 no_xon:
2623 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_NONE));
2624 }
2625 }
2626 if ( (iflag & ISTRIP) ^ ( o_tios->c_iflag & (ISTRIP)) )
2627 {
2628 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2629 CMD_ISTRIP_OPT((iflag & ISTRIP ? 1 : 0)));
2630 }
2631 if ( (iflag & INPCK) ^ ( o_tios->c_iflag & (INPCK)) )
2632 {
2633 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2634 CMD_PARCHK((iflag & INPCK) ? CPK_ENAB : CPK_DSAB));
2635 }
2636
2637 if ( (iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR))
2638 ^ ( o_tios->c_iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR)) )
2639 {
2640 char brkrpt = 0;
2641 char parrpt = 0;
2642
2643 if ( iflag & IGNBRK ) { /* Ignore breaks altogether */
2644 /* Ignore breaks altogether */
2645 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_NREP);
2646 } else {
2647 if ( iflag & BRKINT ) {
2648 if ( iflag & PARMRK ) {
2649 brkrpt = 0x0a; // exception an inline triple
2650 } else {
2651 brkrpt = 0x1a; // exception and NULL
2652 }
2653 brkrpt |= 0x04; // flush input
2654 } else {
2655 if ( iflag & PARMRK ) {
2656 brkrpt = 0x0b; //POSIX triple \0377 \0 \0
2657 } else {
2658 brkrpt = 0x01; // Null only
2659 }
2660 }
2661 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_REP(brkrpt));
2662 }
2663
2664 if (iflag & IGNPAR) {
2665 parrpt = 0x20;
2666 /* would be 2 for not cirrus bug */
2667 /* would be 0x20 cept for cirrus bug */
2668 } else {
2669 if ( iflag & PARMRK ) {
2670 /*
2671 * Replace error characters with 3-byte sequence (\0377,\0,char)
2672 */
2673 parrpt = 0x04 ;
2674 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_ISTRIP_OPT((char)0));
2675 } else {
2676 parrpt = 0x03;
2677 }
2678 }
2679 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SET_ERROR(parrpt));
2680 }
2681 if (cflag & CLOCAL) {
2682 // Status reporting fails for DCD if this is off
2683 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_NREP);
2684 pCh->flags &= ~ASYNC_CHECK_CD;
2685 } else {
2686 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_REP);
2687 pCh->flags |= ASYNC_CHECK_CD;
2688 }
2689
2690 service_it:
2691 i2DrainOutput( pCh, 100 );
2692 }
2693
2694 /******************************************************************************/
2695 /* IPL Device Section */
2696 /******************************************************************************/
2697
2698 /******************************************************************************/
2699 /* Function: ip2_ipl_read() */
2700 /* Parameters: Pointer to device inode */
2701 /* Pointer to file structure */
2702 /* Pointer to data */
2703 /* Number of bytes to read */
2704 /* Returns: Success or failure */
2705 /* */
2706 /* Description: Ugly */
2707 /* */
2708 /* */
2709 /******************************************************************************/
2710
2711 static
2712 ssize_t
2713 ip2_ipl_read(struct file *pFile, char __user *pData, size_t count, loff_t *off )
2714 {
2715 unsigned int minor = iminor(pFile->f_path.dentry->d_inode);
2716 int rc = 0;
2717
2718 #ifdef IP2DEBUG_IPL
2719 printk (KERN_DEBUG "IP2IPL: read %p, %d bytes\n", pData, count );
2720 #endif
2721
2722 switch( minor ) {
2723 case 0: // IPL device
2724 rc = -EINVAL;
2725 break;
2726 case 1: // Status dump
2727 rc = -EINVAL;
2728 break;
2729 case 2: // Ping device
2730 rc = -EINVAL;
2731 break;
2732 case 3: // Trace device
2733 rc = DumpTraceBuffer ( pData, count );
2734 break;
2735 case 4: // Trace device
2736 rc = DumpFifoBuffer ( pData, count );
2737 break;
2738 default:
2739 rc = -ENODEV;
2740 break;
2741 }
2742 return rc;
2743 }
2744
2745 static int
2746 DumpFifoBuffer ( char __user *pData, int count )
2747 {
2748 #ifdef DEBUG_FIFO
2749 int rc;
2750 rc = copy_to_user(pData, DBGBuf, count);
2751
2752 printk(KERN_DEBUG "Last index %d\n", I );
2753
2754 return count;
2755 #endif /* DEBUG_FIFO */
2756 return 0;
2757 }
2758
2759 static int
2760 DumpTraceBuffer ( char __user *pData, int count )
2761 {
2762 #ifdef IP2DEBUG_TRACE
2763 int rc;
2764 int dumpcount;
2765 int chunk;
2766 int *pIndex = (int __user *)pData;
2767
2768 if ( count < (sizeof(int) * 6) ) {
2769 return -EIO;
2770 }
2771 rc = put_user(tracewrap, pIndex );
2772 rc = put_user(TRACEMAX, ++pIndex );
2773 rc = put_user(tracestrip, ++pIndex );
2774 rc = put_user(tracestuff, ++pIndex );
2775 pData += sizeof(int) * 6;
2776 count -= sizeof(int) * 6;
2777
2778 dumpcount = tracestuff - tracestrip;
2779 if ( dumpcount < 0 ) {
2780 dumpcount += TRACEMAX;
2781 }
2782 if ( dumpcount > count ) {
2783 dumpcount = count;
2784 }
2785 chunk = TRACEMAX - tracestrip;
2786 if ( dumpcount > chunk ) {
2787 rc = copy_to_user(pData, &tracebuf[tracestrip],
2788 chunk * sizeof(tracebuf[0]) );
2789 pData += chunk * sizeof(tracebuf[0]);
2790 tracestrip = 0;
2791 chunk = dumpcount - chunk;
2792 } else {
2793 chunk = dumpcount;
2794 }
2795 rc = copy_to_user(pData, &tracebuf[tracestrip],
2796 chunk * sizeof(tracebuf[0]) );
2797 tracestrip += chunk;
2798 tracewrap = 0;
2799
2800 rc = put_user(tracestrip, ++pIndex );
2801 rc = put_user(tracestuff, ++pIndex );
2802
2803 return dumpcount;
2804 #else
2805 return 0;
2806 #endif
2807 }
2808
2809 /******************************************************************************/
2810 /* Function: ip2_ipl_write() */
2811 /* Parameters: */
2812 /* Pointer to file structure */
2813 /* Pointer to data */
2814 /* Number of bytes to write */
2815 /* Returns: Success or failure */
2816 /* */
2817 /* Description: */
2818 /* */
2819 /* */
2820 /******************************************************************************/
2821 static ssize_t
2822 ip2_ipl_write(struct file *pFile, const char __user *pData, size_t count, loff_t *off)
2823 {
2824 #ifdef IP2DEBUG_IPL
2825 printk (KERN_DEBUG "IP2IPL: write %p, %d bytes\n", pData, count );
2826 #endif
2827 return 0;
2828 }
2829
2830 /******************************************************************************/
2831 /* Function: ip2_ipl_ioctl() */
2832 /* Parameters: Pointer to device inode */
2833 /* Pointer to file structure */
2834 /* Command */
2835 /* Argument */
2836 /* Returns: Success or failure */
2837 /* */
2838 /* Description: */
2839 /* */
2840 /* */
2841 /******************************************************************************/
2842 static int
2843 ip2_ipl_ioctl ( struct inode *pInode, struct file *pFile, UINT cmd, ULONG arg )
2844 {
2845 unsigned int iplminor = iminor(pInode);
2846 int rc = 0;
2847 void __user *argp = (void __user *)arg;
2848 ULONG __user *pIndex = argp;
2849 i2eBordStrPtr pB = i2BoardPtrTable[iplminor / 4];
2850 i2ChanStrPtr pCh;
2851
2852 #ifdef IP2DEBUG_IPL
2853 printk (KERN_DEBUG "IP2IPL: ioctl cmd %d, arg %ld\n", cmd, arg );
2854 #endif
2855
2856 switch ( iplminor ) {
2857 case 0: // IPL device
2858 rc = -EINVAL;
2859 break;
2860 case 1: // Status dump
2861 case 5:
2862 case 9:
2863 case 13:
2864 switch ( cmd ) {
2865 case 64: /* Driver - ip2stat */
2866 rc = put_user(ip2_tty_driver->refcount, pIndex++ );
2867 rc = put_user(irq_counter, pIndex++ );
2868 rc = put_user(bh_counter, pIndex++ );
2869 break;
2870
2871 case 65: /* Board - ip2stat */
2872 if ( pB ) {
2873 rc = copy_to_user(argp, pB, sizeof(i2eBordStr));
2874 rc = put_user(INB(pB->i2eStatus),
2875 (ULONG __user *)(arg + (ULONG)(&pB->i2eStatus) - (ULONG)pB ) );
2876 } else {
2877 rc = -ENODEV;
2878 }
2879 break;
2880
2881 default:
2882 if (cmd < IP2_MAX_PORTS) {
2883 pCh = DevTable[cmd];
2884 if ( pCh )
2885 {
2886 rc = copy_to_user(argp, pCh, sizeof(i2ChanStr));
2887 } else {
2888 rc = -ENODEV;
2889 }
2890 } else {
2891 rc = -EINVAL;
2892 }
2893 }
2894 break;
2895
2896 case 2: // Ping device
2897 rc = -EINVAL;
2898 break;
2899 case 3: // Trace device
2900 /*
2901 * akpm: This used to write a whole bunch of function addresses
2902 * to userspace, which generated lots of put_user() warnings.
2903 * I killed it all. Just return "success" and don't do
2904 * anything.
2905 */
2906 if (cmd == 1)
2907 rc = 0;
2908 else
2909 rc = -EINVAL;
2910 break;
2911
2912 default:
2913 rc = -ENODEV;
2914 break;
2915 }
2916 return rc;
2917 }
2918
2919 /******************************************************************************/
2920 /* Function: ip2_ipl_open() */
2921 /* Parameters: Pointer to device inode */
2922 /* Pointer to file structure */
2923 /* Returns: Success or failure */
2924 /* */
2925 /* Description: */
2926 /* */
2927 /* */
2928 /******************************************************************************/
2929 static int
2930 ip2_ipl_open( struct inode *pInode, struct file *pFile )
2931 {
2932 unsigned int iplminor = iminor(pInode);
2933 i2eBordStrPtr pB;
2934 i2ChanStrPtr pCh;
2935
2936 #ifdef IP2DEBUG_IPL
2937 printk (KERN_DEBUG "IP2IPL: open\n" );
2938 #endif
2939
2940 switch(iplminor) {
2941 // These are the IPL devices
2942 case 0:
2943 case 4:
2944 case 8:
2945 case 12:
2946 break;
2947
2948 // These are the status devices
2949 case 1:
2950 case 5:
2951 case 9:
2952 case 13:
2953 break;
2954
2955 // These are the debug devices
2956 case 2:
2957 case 6:
2958 case 10:
2959 case 14:
2960 pB = i2BoardPtrTable[iplminor / 4];
2961 pCh = (i2ChanStrPtr) pB->i2eChannelPtr;
2962 break;
2963
2964 // This is the trace device
2965 case 3:
2966 break;
2967 }
2968 return 0;
2969 }
2970 /******************************************************************************/
2971 /* Function: ip2_read_procmem */
2972 /* Parameters: */
2973 /* */
2974 /* Returns: Length of output */
2975 /* */
2976 /* Description: */
2977 /* Supplies some driver operating parameters */
2978 /* Not real useful unless your debugging the fifo */
2979 /* */
2980 /******************************************************************************/
2981
2982 #define LIMIT (PAGE_SIZE - 120)
2983
2984 static int
2985 ip2_read_procmem(char *buf, char **start, off_t offset, int len)
2986 {
2987 i2eBordStrPtr pB;
2988 i2ChanStrPtr pCh;
2989 PTTY tty;
2990 int i;
2991
2992 len = 0;
2993
2994 #define FMTLINE "%3d: 0x%08x 0x%08x 0%011o 0%011o\n"
2995 #define FMTLIN2 " 0x%04x 0x%04x tx flow 0x%x\n"
2996 #define FMTLIN3 " 0x%04x 0x%04x rc flow\n"
2997
2998 len += sprintf(buf+len,"\n");
2999
3000 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3001 pB = i2BoardPtrTable[i];
3002 if ( pB ) {
3003 len += sprintf(buf+len,"board %d:\n",i);
3004 len += sprintf(buf+len,"\tFifo rem: %d mty: %x outM %x\n",
3005 pB->i2eFifoRemains,pB->i2eWaitingForEmptyFifo,pB->i2eOutMailWaiting);
3006 }
3007 }
3008
3009 len += sprintf(buf+len,"#: tty flags, port flags, cflags, iflags\n");
3010 for (i=0; i < IP2_MAX_PORTS; i++) {
3011 if (len > LIMIT)
3012 break;
3013 pCh = DevTable[i];
3014 if (pCh) {
3015 tty = pCh->pTTY;
3016 if (tty && tty->count) {
3017 len += sprintf(buf+len,FMTLINE,i,(int)tty->flags,pCh->flags,
3018 tty->termios->c_cflag,tty->termios->c_iflag);
3019
3020 len += sprintf(buf+len,FMTLIN2,
3021 pCh->outfl.asof,pCh->outfl.room,pCh->channelNeeds);
3022 len += sprintf(buf+len,FMTLIN3,pCh->infl.asof,pCh->infl.room);
3023 }
3024 }
3025 }
3026 return len;
3027 }
3028
3029 /*
3030 * This is the handler for /proc/tty/driver/ip2
3031 *
3032 * This stretch of code has been largely plagerized from at least three
3033 * different sources including ip2mkdev.c and a couple of other drivers.
3034 * The bugs are all mine. :-) =mhw=
3035 */
3036 static int ip2_read_proc(char *page, char **start, off_t off,
3037 int count, int *eof, void *data)
3038 {
3039 int i, j, box;
3040 int len = 0;
3041 int boxes = 0;
3042 int ports = 0;
3043 int tports = 0;
3044 off_t begin = 0;
3045 i2eBordStrPtr pB;
3046
3047 len += sprintf(page, "ip2info: 1.0 driver: %s\n", pcVersion );
3048 len += sprintf(page+len, "Driver: SMajor=%d CMajor=%d IMajor=%d MaxBoards=%d MaxBoxes=%d MaxPorts=%d\n",
3049 IP2_TTY_MAJOR, IP2_CALLOUT_MAJOR, IP2_IPL_MAJOR,
3050 IP2_MAX_BOARDS, ABS_MAX_BOXES, ABS_BIGGEST_BOX);
3051
3052 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3053 /* This need to be reset for a board by board count... */
3054 boxes = 0;
3055 pB = i2BoardPtrTable[i];
3056 if( pB ) {
3057 switch( pB->i2ePom.e.porID & ~POR_ID_RESERVED )
3058 {
3059 case POR_ID_FIIEX:
3060 len += sprintf( page+len, "Board %d: EX ports=", i );
3061 for( box = 0; box < ABS_MAX_BOXES; ++box )
3062 {
3063 ports = 0;
3064
3065 if( pB->i2eChannelMap[box] != 0 ) ++boxes;
3066 for( j = 0; j < ABS_BIGGEST_BOX; ++j )
3067 {
3068 if( pB->i2eChannelMap[box] & 1<< j ) {
3069 ++ports;
3070 }
3071 }
3072 len += sprintf( page+len, "%d,", ports );
3073 tports += ports;
3074 }
3075
3076 --len; /* Backup over that last comma */
3077
3078 len += sprintf( page+len, " boxes=%d width=%d", boxes, pB->i2eDataWidth16 ? 16 : 8 );
3079 break;
3080
3081 case POR_ID_II_4:
3082 len += sprintf(page+len, "Board %d: ISA-4 ports=4 boxes=1", i );
3083 tports = ports = 4;
3084 break;
3085
3086 case POR_ID_II_8:
3087 len += sprintf(page+len, "Board %d: ISA-8-std ports=8 boxes=1", i );
3088 tports = ports = 8;
3089 break;
3090
3091 case POR_ID_II_8R:
3092 len += sprintf(page+len, "Board %d: ISA-8-RJ11 ports=8 boxes=1", i );
3093 tports = ports = 8;
3094 break;
3095
3096 default:
3097 len += sprintf(page+len, "Board %d: unknown", i );
3098 /* Don't try and probe for minor numbers */
3099 tports = ports = 0;
3100 }
3101
3102 } else {
3103 /* Don't try and probe for minor numbers */
3104 len += sprintf(page+len, "Board %d: vacant", i );
3105 tports = ports = 0;
3106 }
3107
3108 if( tports ) {
3109 len += sprintf(page+len, " minors=" );
3110
3111 for ( box = 0; box < ABS_MAX_BOXES; ++box )
3112 {
3113 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
3114 {
3115 if ( pB->i2eChannelMap[box] & (1 << j) )
3116 {
3117 len += sprintf (page+len,"%d,",
3118 j + ABS_BIGGEST_BOX *
3119 (box+i*ABS_MAX_BOXES));
3120 }
3121 }
3122 }
3123
3124 page[ len - 1 ] = '\n'; /* Overwrite that last comma */
3125 } else {
3126 len += sprintf (page+len,"\n" );
3127 }
3128
3129 if (len+begin > off+count)
3130 break;
3131 if (len+begin < off) {
3132 begin += len;
3133 len = 0;
3134 }
3135 }
3136
3137 if (i >= IP2_MAX_BOARDS)
3138 *eof = 1;
3139 if (off >= len+begin)
3140 return 0;
3141
3142 *start = page + (off-begin);
3143 return ((count < begin+len-off) ? count : begin+len-off);
3144 }
3145
3146 /******************************************************************************/
3147 /* Function: ip2trace() */
3148 /* Parameters: Value to add to trace buffer */
3149 /* Returns: Nothing */
3150 /* */
3151 /* Description: */
3152 /* */
3153 /* */
3154 /******************************************************************************/
3155 #ifdef IP2DEBUG_TRACE
3156 void
3157 ip2trace (unsigned short pn, unsigned char cat, unsigned char label, unsigned long codes, ...)
3158 {
3159 long flags;
3160 unsigned long *pCode = &codes;
3161 union ip2breadcrumb bc;
3162 i2ChanStrPtr pCh;
3163
3164
3165 tracebuf[tracestuff++] = jiffies;
3166 if ( tracestuff == TRACEMAX ) {
3167 tracestuff = 0;
3168 }
3169 if ( tracestuff == tracestrip ) {
3170 if ( ++tracestrip == TRACEMAX ) {
3171 tracestrip = 0;
3172 }
3173 ++tracewrap;
3174 }
3175
3176 bc.hdr.port = 0xff & pn;
3177 bc.hdr.cat = cat;
3178 bc.hdr.codes = (unsigned char)( codes & 0xff );
3179 bc.hdr.label = label;
3180 tracebuf[tracestuff++] = bc.value;
3181
3182 for (;;) {
3183 if ( tracestuff == TRACEMAX ) {
3184 tracestuff = 0;
3185 }
3186 if ( tracestuff == tracestrip ) {
3187 if ( ++tracestrip == TRACEMAX ) {
3188 tracestrip = 0;
3189 }
3190 ++tracewrap;
3191 }
3192
3193 if ( !codes-- )
3194 break;
3195
3196 tracebuf[tracestuff++] = *++pCode;
3197 }
3198 }
3199 #endif
3200
3201
3202 MODULE_LICENSE("GPL");
3203
3204 static struct pci_device_id ip2main_pci_tbl[] __devinitdata = {
3205 { PCI_DEVICE(PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_IP2EX) },
3206 { }
3207 };
3208
3209 MODULE_DEVICE_TABLE(pci, ip2main_pci_tbl);
Linux with added FPC-III support