3 * (c) 1999 by Computone Corporation
5 ********************************************************************************
7 * PACKAGE: Linux tty Device Driver for IntelliPort family of multiport
8 * serial I/O controllers.
10 * DESCRIPTION: Mainline code for the device driver
12 *******************************************************************************/
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.
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
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.
31 // 1.2.12 /\/\|=mhw=|\/\/
32 // Cleaned up some remove queue cut and paste errors
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/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
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.
52 // Four box EX was barfing on >128k kmalloc, made structure smaller by
53 // reducing output buffer size
56 // Device file system support (MHW)
60 // Reload of ip2 without unloading ip2main hangs system on cat of /proc/modules
64 // DCD was not reported when CLOCAL was set on call to TIOCMGET
67 // TIOCMGET requests and waits for status return
68 // No DSS interrupts enabled except for DCD when needed
70 // For internal use only
72 //#define IP2DEBUG_INIT
73 //#define IP2DEBUG_OPEN
74 //#define IP2DEBUG_WRITE
75 //#define IP2DEBUG_READ
76 //#define IP2DEBUG_IOCTL
77 //#define IP2DEBUG_IPL
79 //#define IP2DEBUG_TRACE
85 #include <linux/config.h>
87 #include <linux/ctype.h>
88 #include <linux/string.h>
89 #include <linux/fcntl.h>
90 #include <linux/errno.h>
91 #include <linux/module.h>
92 #include <linux/signal.h>
93 #include <linux/sched.h>
94 #include <linux/devfs_fs_kernel.h>
95 #include <linux/timer.h>
96 #include <linux/interrupt.h>
97 #include <linux/pci.h>
99 #include <linux/slab.h>
100 #include <linux/major.h>
101 #include <linux/wait.h>
102 #include <linux/device.h>
104 #include <linux/tty.h>
105 #include <linux/tty_flip.h>
106 #include <linux/termios.h>
107 #include <linux/tty_driver.h>
108 #include <linux/serial.h>
109 #include <linux/ptrace.h>
110 #include <linux/ioport.h>
112 #include <linux/cdk.h>
113 #include <linux/comstats.h>
114 #include <linux/delay.h>
115 #include <linux/bitops.h>
117 #include <asm/system.h>
121 #include <linux/vmalloc.h>
122 #include <linux/init.h>
123 #include <asm/serial.h>
125 #include <asm/uaccess.h>
127 #include "./ip2/ip2types.h"
128 #include "./ip2/ip2trace.h"
129 #include "./ip2/ip2ioctl.h"
130 #include "./ip2/ip2.h"
131 #include "./ip2/i2ellis.h"
132 #include "./ip2/i2lib.h"
138 #include <linux/proc_fs.h>
140 static int ip2_read_procmem(char *, char **, off_t, int);
141 int ip2_read_proc(char *, char **, off_t, int, int *, void * );
143 /********************/
144 /* Type Definitions */
145 /********************/
151 /* String constants to identify ourselves */
152 static char *pcName = "Computone IntelliPort Plus multiport driver";
153 static char *pcVersion = "1.2.14";
155 /* String constants for port names */
156 static char *pcDriver_name = "ip2";
157 static char *pcIpl = "ip2ipl";
159 /* Serial subtype definitions */
160 #define SERIAL_TYPE_NORMAL 1
162 // cheezy kludge or genius - you decide?
163 int ip2_loadmain(int *, int *, unsigned char *, int);
164 static unsigned char *Fip_firmware;
165 static int Fip_firmware_size;
167 /***********************/
168 /* Function Prototypes */
169 /***********************/
171 /* Global module entry functions */
173 /* Private (static) functions */
174 static int ip2_open(PTTY, struct file *);
175 static void ip2_close(PTTY, struct file *);
176 static int ip2_write(PTTY, int, const unsigned char *, int);
177 static void ip2_putchar(PTTY, unsigned char);
178 static void ip2_flush_chars(PTTY);
179 static int ip2_write_room(PTTY);
180 static int ip2_chars_in_buf(PTTY);
181 static void ip2_flush_buffer(PTTY);
182 static int ip2_ioctl(PTTY, struct file *, UINT, ULONG);
183 static void ip2_set_termios(PTTY, struct termios *);
184 static void ip2_set_line_discipline(PTTY);
185 static void ip2_throttle(PTTY);
186 static void ip2_unthrottle(PTTY);
187 static void ip2_stop(PTTY);
188 static void ip2_start(PTTY);
189 static void ip2_hangup(PTTY);
190 static int ip2_tiocmget(struct tty_struct *tty, struct file *file);
191 static int ip2_tiocmset(struct tty_struct *tty, struct file *file,
192 unsigned int set, unsigned int clear);
194 static void set_irq(int, int);
195 static void ip2_interrupt_bh(i2eBordStrPtr pB);
196 static irqreturn_t ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs);
197 static void ip2_poll(unsigned long arg);
198 static inline void service_all_boards(void);
199 static void do_input(void *p);
200 static void do_status(void *p);
202 static void ip2_wait_until_sent(PTTY,int);
204 static void set_params (i2ChanStrPtr, struct termios *);
205 static int set_modem_info(i2ChanStrPtr, unsigned int, unsigned int *);
206 static int get_serial_info(i2ChanStrPtr, struct serial_struct __user *);
207 static int set_serial_info(i2ChanStrPtr, struct serial_struct __user *);
209 static ssize_t ip2_ipl_read(struct file *, char __user *, size_t, loff_t *);
210 static ssize_t ip2_ipl_write(struct file *, const char __user *, size_t, loff_t *);
211 static int ip2_ipl_ioctl(struct inode *, struct file *, UINT, ULONG);
212 static int ip2_ipl_open(struct inode *, struct file *);
214 static int DumpTraceBuffer(char __user *, int);
215 static int DumpFifoBuffer( char __user *, int);
217 static void ip2_init_board(int);
218 static unsigned short find_eisa_board(int);
224 static struct tty_driver *ip2_tty_driver;
226 /* Here, then is a table of board pointers which the interrupt routine should
227 * scan through to determine who it must service.
229 static unsigned short i2nBoards; // Number of boards here
231 static i2eBordStrPtr i2BoardPtrTable[IP2_MAX_BOARDS];
233 static i2ChanStrPtr DevTable[IP2_MAX_PORTS];
234 //DevTableMem just used to save addresses for kfree
235 static void *DevTableMem[IP2_MAX_BOARDS];
237 /* This is the driver descriptor for the ip2ipl device, which is used to
238 * download the loadware to the boards.
240 static struct file_operations ip2_ipl = {
241 .owner = THIS_MODULE,
242 .read = ip2_ipl_read,
243 .write = ip2_ipl_write,
244 .ioctl = ip2_ipl_ioctl,
245 .open = ip2_ipl_open,
248 static unsigned long irq_counter = 0;
249 static unsigned long bh_counter = 0;
251 // Use immediate queue to service interrupts
253 //#define USE_IQ // PCI&2.2 needs work
255 /* The timer_list entry for our poll routine. If interrupt operation is not
256 * selected, the board is serviced periodically to see if anything needs doing.
258 #define POLL_TIMEOUT (jiffies + 1)
259 static struct timer_list PollTimer = TIMER_INITIALIZER(ip2_poll, 0, 0);
262 #ifdef IP2DEBUG_TRACE
263 /* Trace (debug) buffer data */
264 #define TRACEMAX 1000
265 static unsigned long tracebuf[TRACEMAX];
266 static int tracestuff;
267 static int tracestrip;
268 static int tracewrap;
275 #if defined(MODULE) && defined(IP2DEBUG_OPEN)
276 #define DBG_CNT(s) printk(KERN_DEBUG "(%s): [%x] refc=%d, ttyc=%d, modc=%x -> %s\n", \
277 tty->name,(pCh->flags),ip2_tty_driver->refcount, \
278 tty->count,/*GET_USE_COUNT(module)*/0,s)
287 #include "./ip2/i2ellis.c" /* Extremely low-level interface services */
288 #include "./ip2/i2cmd.c" /* Standard loadware command definitions */
289 #include "./ip2/i2lib.c" /* High level interface services */
291 /* Configuration area for modprobe */
293 MODULE_AUTHOR("Doug McNash");
294 MODULE_DESCRIPTION("Computone IntelliPort Plus Driver");
296 static int poll_only = 0;
299 static int Eisa_slot;
302 static char rirqs[IP2_MAX_BOARDS];
303 static int Valid_Irqs[] = { 3, 4, 5, 7, 10, 11, 12, 15, 0};
305 /* for sysfs class support */
306 static struct class_simple *ip2_class;
308 // Some functions to keep track of what irq's we have
311 is_valid_irq(int irq)
315 while ((*i != 0) && (*i != irq)) {
322 mark_requested_irq( char irq )
324 rirqs[iindx++] = irq;
329 clear_requested_irq( char irq )
332 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
333 if (rirqs[i] == irq) {
343 have_requested_irq( char irq )
345 // array init to zeros so 0 irq will not be requested as a side effect
347 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
354 /******************************************************************************/
355 /* Function: init_module() */
356 /* Parameters: None */
357 /* Returns: Success (0) */
360 /* This is a required entry point for an installable module. It simply calls */
361 /* the driver initialisation function and returns what it returns. */
362 /******************************************************************************/
368 printk (KERN_DEBUG "Loading module ...\n" );
374 /******************************************************************************/
375 /* Function: cleanup_module() */
376 /* Parameters: None */
377 /* Returns: Nothing */
380 /* This is a required entry point for an installable module. It has to return */
381 /* the device and the driver to a passive state. It should not be necessary */
382 /* to reset the board fully, especially as the loadware is downloaded */
383 /* externally rather than in the driver. We just want to disable the board */
384 /* and clear the loadware to a reset state. To allow this there has to be a */
385 /* way to detect whether the board has the loadware running at init time to */
386 /* handle subsequent installations of the driver. All memory allocated by the */
387 /* driver should be returned since it may be unloaded from memory. */
388 /******************************************************************************/
397 printk (KERN_DEBUG "Unloading %s: version %s\n", pcName, pcVersion );
399 /* Stop poll timer if we had one. */
401 del_timer ( &PollTimer );
405 /* Reset the boards we have. */
406 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
407 if ( i2BoardPtrTable[i] ) {
408 iiReset( i2BoardPtrTable[i] );
412 /* The following is done at most once, if any boards were installed. */
413 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
414 if ( i2BoardPtrTable[i] ) {
415 iiResetDelay( i2BoardPtrTable[i] );
416 /* free io addresses and Tibet */
417 release_region( ip2config.addr[i], 8 );
418 class_simple_device_remove(MKDEV(IP2_IPL_MAJOR, 4 * i));
419 devfs_remove("ip2/ipl%d", i);
420 class_simple_device_remove(MKDEV(IP2_IPL_MAJOR, 4 * i + 1));
421 devfs_remove("ip2/stat%d", i);
423 /* Disable and remove interrupt handler. */
424 if ( (ip2config.irq[i] > 0) && have_requested_irq(ip2config.irq[i]) ) {
425 free_irq ( ip2config.irq[i], (void *)&pcName);
426 clear_requested_irq( ip2config.irq[i]);
429 class_simple_destroy(ip2_class);
431 if ( ( err = tty_unregister_driver ( ip2_tty_driver ) ) ) {
432 printk(KERN_ERR "IP2: failed to unregister tty driver (%d)\n", err);
434 put_tty_driver(ip2_tty_driver);
435 if ( ( err = unregister_chrdev ( IP2_IPL_MAJOR, pcIpl ) ) ) {
436 printk(KERN_ERR "IP2: failed to unregister IPL driver (%d)\n", err);
438 remove_proc_entry("ip2mem", &proc_root);
441 for (i = 0; i < IP2_MAX_BOARDS; i++) {
444 if (ip2config.type[i] == PCI && ip2config.pci_dev[i]) {
445 pci_disable_device(ip2config.pci_dev[i]);
446 ip2config.pci_dev[i] = NULL;
449 if ((pB = i2BoardPtrTable[i]) != 0 ) {
451 i2BoardPtrTable[i] = NULL;
453 if ((DevTableMem[i]) != NULL ) {
454 kfree ( DevTableMem[i] );
455 DevTableMem[i] = NULL;
459 /* Cleanup the iiEllis subsystem. */
462 printk (KERN_DEBUG "IP2 Unloaded\n" );
467 static struct tty_operations ip2_ops = {
471 .put_char = ip2_putchar,
472 .flush_chars = ip2_flush_chars,
473 .write_room = ip2_write_room,
474 .chars_in_buffer = ip2_chars_in_buf,
475 .flush_buffer = ip2_flush_buffer,
477 .throttle = ip2_throttle,
478 .unthrottle = ip2_unthrottle,
479 .set_termios = ip2_set_termios,
480 .set_ldisc = ip2_set_line_discipline,
483 .hangup = ip2_hangup,
484 .read_proc = ip2_read_proc,
485 .tiocmget = ip2_tiocmget,
486 .tiocmset = ip2_tiocmset,
489 /******************************************************************************/
490 /* Function: ip2_loadmain() */
491 /* Parameters: irq, io from command line of insmod et. al. */
492 /* pointer to fip firmware and firmware size for boards */
493 /* Returns: Success (0) */
496 /* This was the required entry point for all drivers (now in ip2.c) */
497 /* It performs all */
498 /* initialisation of the devices and driver structures, and registers itself */
499 /* with the relevant kernel modules. */
500 /******************************************************************************/
501 /* SA_INTERRUPT- if set blocks all interrupts else only this line */
502 /* SA_SHIRQ - for shared irq PCI or maybe EISA only */
503 /* SA_RANDOM - can be source for cert. random number generators */
504 #define IP2_SA_FLAGS 0
507 ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
513 i2eBordStrPtr pB = NULL;
516 ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0 );
518 /* process command line arguments to modprobe or
519 insmod i.e. iop & irqp */
520 /* irqp and iop should ALWAYS be specified now... But we check
521 them individually just to be sure, anyways... */
522 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
524 ip2config.addr[i] = iop[i];
527 ip2config.irq[i] = irqp[i];
529 ip2config.irq[i] = 0;
531 // This is a little bit of a hack. If poll_only=1 on command
532 // line back in ip2.c OR all IRQs on all specified boards are
533 // explicitly set to 0, then drop to poll only mode and override
534 // PCI or EISA interrupts. This superceeds the old hack of
535 // triggering if all interrupts were zero (like da default).
536 // Still a hack but less prone to random acts of terrorism.
538 // What we really should do, now that the IRQ default is set
539 // to -1, is to use 0 as a hard coded, do not probe.
542 poll_only |= irqp[i];
546 poll_only = !poll_only;
548 Fip_firmware = firmware;
549 Fip_firmware_size = firmsize;
551 /* Announce our presence */
552 printk( KERN_INFO "%s version %s\n", pcName, pcVersion );
554 // ip2 can be unloaded and reloaded for no good reason
555 // we can't let that happen here or bad things happen
556 // second load hoses board but not system - fixme later
558 printk( KERN_INFO "Still loaded\n" );
563 ip2_tty_driver = alloc_tty_driver(IP2_MAX_PORTS);
567 /* Initialise the iiEllis subsystem. */
570 /* Initialize arrays. */
571 memset( i2BoardPtrTable, 0, sizeof i2BoardPtrTable );
572 memset( DevTable, 0, sizeof DevTable );
574 /* Initialise all the boards we can find (up to the maximum). */
575 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
576 switch ( ip2config.addr[i] ) {
577 case 0: /* skip this slot even if card is present */
580 /* ISA address must be specified */
581 if ( (ip2config.addr[i] < 0x100) || (ip2config.addr[i] > 0x3f8) ) {
582 printk ( KERN_ERR "IP2: Bad ISA board %d address %x\n",
583 i, ip2config.addr[i] );
584 ip2config.addr[i] = 0;
586 ip2config.type[i] = ISA;
588 /* Check for valid irq argument, set for polling if invalid */
589 if (ip2config.irq[i] && !is_valid_irq(ip2config.irq[i])) {
590 printk(KERN_ERR "IP2: Bad IRQ(%d) specified\n",ip2config.irq[i]);
591 ip2config.irq[i] = 0;// 0 is polling and is valid in that sense
598 struct pci_dev *pci_dev_i = NULL;
599 pci_dev_i = pci_find_device(PCI_VENDOR_ID_COMPUTONE,
600 PCI_DEVICE_ID_COMPUTONE_IP2EX, pci_dev_i);
601 if (pci_dev_i != NULL) {
604 if (pci_enable_device(pci_dev_i)) {
605 printk( KERN_ERR "IP2: can't enable PCI device at %s\n",
606 pci_name(pci_dev_i));
609 ip2config.type[i] = PCI;
610 ip2config.pci_dev[i] = pci_dev_i;
612 pci_read_config_dword(pci_dev_i, PCI_BASE_ADDRESS_1, &addr);
614 ip2config.addr[i]=(USHORT)(addr&0xfffe);
616 printk( KERN_ERR "IP2: PCI I/O address error\n");
619 // If the PCI BIOS assigned it, lets try and use it. If we
620 // can't acquire it or it screws up, deal with it then.
622 // if (!is_valid_irq(pci_irq)) {
623 // printk( KERN_ERR "IP2: Bad PCI BIOS IRQ(%d)\n",pci_irq);
626 ip2config.irq[i] = pci_dev_i->irq;
627 } else { // ann error
628 ip2config.addr[i] = 0;
629 if (status == PCIBIOS_DEVICE_NOT_FOUND) {
630 printk( KERN_ERR "IP2: PCI board %d not found\n", i );
632 printk( KERN_ERR "IP2: PCI error 0x%x \n", status );
637 printk( KERN_ERR "IP2: PCI card specified but PCI support not\n");
638 printk( KERN_ERR "IP2: configured in this kernel.\n");
639 printk( KERN_ERR "IP2: Recompile kernel with CONFIG_PCI defined!\n");
640 #endif /* CONFIG_PCI */
643 if ( (ip2config.addr[i] = find_eisa_board( Eisa_slot + 1 )) != 0) {
644 /* Eisa_irq set as side effect, boo */
645 ip2config.type[i] = EISA;
647 ip2config.irq[i] = Eisa_irq;
651 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
652 if ( ip2config.addr[i] ) {
653 pB = kmalloc( sizeof(i2eBordStr), GFP_KERNEL);
655 i2BoardPtrTable[i] = pB;
656 memset( pB, 0, sizeof(i2eBordStr) );
657 iiSetAddress( pB, ip2config.addr[i], ii2DelayTimer );
660 printk(KERN_ERR "IP2: board memory allocation error\n");
664 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
665 if ( ( pB = i2BoardPtrTable[i] ) != NULL ) {
670 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
671 if ( i2BoardPtrTable[i] != NULL ) {
676 ip2trace (ITRC_NO_PORT, ITRC_INIT, 2, 0 );
678 ip2_tty_driver->owner = THIS_MODULE;
679 ip2_tty_driver->name = "ttyF";
680 ip2_tty_driver->devfs_name = "tts/F";
681 ip2_tty_driver->driver_name = pcDriver_name;
682 ip2_tty_driver->major = IP2_TTY_MAJOR;
683 ip2_tty_driver->minor_start = 0;
684 ip2_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
685 ip2_tty_driver->subtype = SERIAL_TYPE_NORMAL;
686 ip2_tty_driver->init_termios = tty_std_termios;
687 ip2_tty_driver->init_termios.c_cflag = B9600|CS8|CREAD|HUPCL|CLOCAL;
688 ip2_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
689 tty_set_operations(ip2_tty_driver, &ip2_ops);
691 ip2trace (ITRC_NO_PORT, ITRC_INIT, 3, 0 );
693 /* Register the tty devices. */
694 if ( ( err = tty_register_driver ( ip2_tty_driver ) ) ) {
695 printk(KERN_ERR "IP2: failed to register tty driver (%d)\n", err);
696 put_tty_driver(ip2_tty_driver);
699 /* Register the IPL driver. */
700 if ( ( err = register_chrdev ( IP2_IPL_MAJOR, pcIpl, &ip2_ipl ) ) ) {
701 printk(KERN_ERR "IP2: failed to register IPL device (%d)\n", err );
703 /* create the sysfs class */
704 ip2_class = class_simple_create(THIS_MODULE, "ip2");
705 if (IS_ERR(ip2_class)) {
706 err = PTR_ERR(ip2_class);
710 /* Register the read_procmem thing */
711 if (!create_proc_info_entry("ip2mem",0,&proc_root,ip2_read_procmem)) {
712 printk(KERN_ERR "IP2: failed to register read_procmem\n");
715 ip2trace (ITRC_NO_PORT, ITRC_INIT, 4, 0 );
716 /* Register the interrupt handler or poll handler, depending upon the
717 * specified interrupt.
720 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
721 if ( 0 == ip2config.addr[i] ) {
725 if ( NULL != ( pB = i2BoardPtrTable[i] ) ) {
726 class_simple_device_add(ip2_class, MKDEV(IP2_IPL_MAJOR,
727 4 * i), NULL, "ipl%d", i);
728 err = devfs_mk_cdev(MKDEV(IP2_IPL_MAJOR, 4 * i),
729 S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR,
732 class_simple_device_remove(MKDEV(IP2_IPL_MAJOR,
737 class_simple_device_add(ip2_class, MKDEV(IP2_IPL_MAJOR,
738 4 * i + 1), NULL, "stat%d", i);
739 err = devfs_mk_cdev(MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
740 S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR,
743 class_simple_device_remove(MKDEV(IP2_IPL_MAJOR,
748 for ( box = 0; box < ABS_MAX_BOXES; ++box )
750 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
752 if ( pB->i2eChannelMap[box] & (1 << j) )
754 tty_register_device(ip2_tty_driver,
755 j + ABS_BIGGEST_BOX *
756 (box+i*ABS_MAX_BOXES), NULL);
763 // Poll only forces driver to only use polling and
764 // to ignore the probed PCI or EISA interrupts.
765 ip2config.irq[i] = CIR_POLL;
767 if ( ip2config.irq[i] == CIR_POLL ) {
770 PollTimer.expires = POLL_TIMEOUT;
771 add_timer ( &PollTimer );
773 printk( KERN_INFO "IP2: polling\n");
776 if (have_requested_irq(ip2config.irq[i]))
778 rc = request_irq( ip2config.irq[i], ip2_interrupt,
779 IP2_SA_FLAGS | (ip2config.type[i] == PCI ? SA_SHIRQ : 0),
780 pcName, (void *)&pcName);
782 printk(KERN_ERR "IP2: an request_irq failed: error %d\n",rc);
783 ip2config.irq[i] = CIR_POLL;
784 printk( KERN_INFO "IP2: Polling %ld/sec.\n",
785 (POLL_TIMEOUT - jiffies));
788 mark_requested_irq(ip2config.irq[i]);
789 /* Initialise the interrupt handler bottom half (aka slih). */
792 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
793 if ( i2BoardPtrTable[i] ) {
794 set_irq( i, ip2config.irq[i] ); /* set and enable board interrupt */
798 ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_RETURN, 0 );
802 class_simple_destroy(ip2_class);
804 unregister_chrdev(IP2_IPL_MAJOR, "ip2");
809 EXPORT_SYMBOL(ip2_loadmain);
811 /******************************************************************************/
812 /* Function: ip2_init_board() */
813 /* Parameters: Index of board in configuration structure */
814 /* Returns: Success (0) */
817 /* This function initializes the specified board. The loadware is copied to */
818 /* the board, the channel structures are initialized, and the board details */
819 /* are reported on the console. */
820 /******************************************************************************/
822 ip2_init_board( int boardnum )
825 int nports = 0, nboxes = 0;
827 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
829 if ( !iiInitialize ( pB ) ) {
830 printk ( KERN_ERR "IP2: Failed to initialize board at 0x%x, error %d\n",
831 pB->i2eBase, pB->i2eError );
834 printk(KERN_INFO "IP2: Board %d: addr=0x%x irq=%d\n", boardnum + 1,
835 ip2config.addr[boardnum], ip2config.irq[boardnum] );
837 if (!request_region( ip2config.addr[boardnum], 8, pcName )) {
838 printk(KERN_ERR "IP2: bad addr=0x%x\n", ip2config.addr[boardnum]);
842 if ( iiDownloadAll ( pB, (loadHdrStrPtr)Fip_firmware, 1, Fip_firmware_size )
844 printk ( KERN_ERR "IP2: failed to download loadware\n" );
845 goto err_release_region;
847 printk ( KERN_INFO "IP2: fv=%d.%d.%d lv=%d.%d.%d\n",
848 pB->i2ePom.e.porVersion,
849 pB->i2ePom.e.porRevision,
850 pB->i2ePom.e.porSubRev, pB->i2eLVersion,
851 pB->i2eLRevision, pB->i2eLSub );
854 switch ( pB->i2ePom.e.porID & ~POR_ID_RESERVED ) {
857 printk( KERN_ERR "IP2: Unknown board type, ID = %x\n",
858 pB->i2ePom.e.porID );
860 goto err_release_region;
863 case POR_ID_II_4: /* IntelliPort-II, ISA-4 (4xRJ45) */
864 printk ( KERN_INFO "IP2: ISA-4\n" );
868 case POR_ID_II_8: /* IntelliPort-II, 8-port using standard brick. */
869 printk ( KERN_INFO "IP2: ISA-8 std\n" );
873 case POR_ID_II_8R: /* IntelliPort-II, 8-port using RJ11's (no CTS) */
874 printk ( KERN_INFO "IP2: ISA-8 RJ11\n" );
878 case POR_ID_FIIEX: /* IntelliPort IIEX */
880 int portnum = IP2_PORTS_PER_BOARD * boardnum;
883 for( box = 0; box < ABS_MAX_BOXES; ++box ) {
884 if ( pB->i2eChannelMap[box] != 0 ) {
887 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
888 if ( pB->i2eChannelMap[box] & 1<< i ) {
893 DevTableMem[boardnum] = pCh =
894 kmalloc( sizeof(i2ChanStr) * nports, GFP_KERNEL );
896 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
897 goto err_release_region;
899 if ( !i2InitChannels( pB, nports, pCh ) ) {
900 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
902 goto err_release_region;
904 pB->i2eChannelPtr = &DevTable[portnum];
905 pB->i2eChannelCnt = ABS_MOST_PORTS;
907 for( box = 0; box < ABS_MAX_BOXES; ++box, portnum += ABS_BIGGEST_BOX ) {
908 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
909 if ( pB->i2eChannelMap[box] & (1 << i) ) {
910 DevTable[portnum + i] = pCh;
911 pCh->port_index = portnum + i;
916 printk(KERN_INFO "IP2: EX box=%d ports=%d %d bit\n",
917 nboxes, nports, pB->i2eDataWidth16 ? 16 : 8 );
921 DevTableMem[boardnum] = pCh =
922 kmalloc ( sizeof (i2ChanStr) * nports, GFP_KERNEL );
924 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
925 goto err_release_region;
927 pB->i2eChannelPtr = pCh;
928 pB->i2eChannelCnt = nports;
929 if ( !i2InitChannels( pB, nports, pCh ) ) {
930 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
932 goto err_release_region;
934 pB->i2eChannelPtr = &DevTable[IP2_PORTS_PER_BOARD * boardnum];
936 for( i = 0; i < pB->i2eChannelCnt; ++i ) {
937 DevTable[IP2_PORTS_PER_BOARD * boardnum + i] = pCh;
938 pCh->port_index = (IP2_PORTS_PER_BOARD * boardnum) + i;
942 INIT_WORK(&pB->tqueue_interrupt, (void(*)(void*)) ip2_interrupt_bh, pB);
946 release_region(ip2config.addr[boardnum], 8);
949 i2BoardPtrTable[boardnum] = NULL;
953 /******************************************************************************/
954 /* Function: find_eisa_board ( int start_slot ) */
955 /* Parameters: First slot to check */
956 /* Returns: Address of EISA IntelliPort II controller */
959 /* This function searches for an EISA IntelliPort controller, starting */
960 /* from the specified slot number. If the motherboard is not identified as an */
961 /* EISA motherboard, or no valid board ID is selected it returns 0. Otherwise */
962 /* it returns the base address of the controller. */
963 /******************************************************************************/
964 static unsigned short __init
965 find_eisa_board( int start_slot )
968 unsigned int idm = 0;
969 unsigned int idp = 0;
970 unsigned int base = 0;
977 * First a check for an EISA motherboard, which we do by comparing the
978 * EISA ID registers for the system board and the first couple of slots.
979 * No slot ID should match the system board ID, but on an ISA or PCI
980 * machine the odds are that an empty bus will return similar values for
984 value = (inb(i) << 24) + (inb(i+1) << 16) + (inb(i+2) << 8) + inb(i+3);
985 for( i = 0x1c80; i <= 0x4c80; i += 0x1000 ) {
986 j = (inb(i)<<24)+(inb(i+1)<<16)+(inb(i+2)<<8)+inb(i+3);
992 * OK, so we are inclined to believe that this is an EISA machine. Find
993 * an IntelliPort controller.
995 for( i = start_slot; i < 16; i++ ) {
997 idm = (inb(base + 0xc80) << 8) | (inb(base + 0xc81) & 0xff);
998 idp = (inb(base + 0xc82) << 8) | (inb(base + 0xc83) & 0xff);
1000 if ( idm == 0x0e8e ) {
1001 if ( idp == 0x0281 || idp == 0x0218 ) {
1003 } else if ( idp == 0x0282 || idp == 0x0283 ) {
1004 ismine = 3; /* Can do edge-trigger */
1015 /* It's some sort of EISA card, but at what address is it configured? */
1017 setup_address = base + 0xc88;
1018 value = inb(base + 0xc86);
1019 setup_irq = (value & 8) ? Valid_Irqs[value & 7] : 0;
1021 if ( (ismine & 2) && !(value & 0x10) ) {
1022 ismine = 1; /* Could be edging, but not */
1025 if ( Eisa_irq == 0 ) {
1026 Eisa_irq = setup_irq;
1027 } else if ( Eisa_irq != setup_irq ) {
1028 printk ( KERN_ERR "IP2: EISA irq mismatch between EISA controllers\n" );
1031 #ifdef IP2DEBUG_INIT
1032 printk(KERN_DEBUG "Computone EISA board in slot %d, I.D. 0x%x%x, Address 0x%x",
1033 base >> 12, idm, idp, setup_address);
1035 printk(KERN_DEBUG ", Interrupt %d %s\n",
1036 setup_irq, (ismine & 2) ? "(edge)" : "(level)");
1038 printk(KERN_DEBUG ", (polled)\n");
1041 return setup_address;
1044 /******************************************************************************/
1045 /* Function: set_irq() */
1046 /* Parameters: index to board in board table */
1048 /* Returns: Success (0) */
1051 /******************************************************************************/
1053 set_irq( int boardnum, int boardIrq )
1055 unsigned char tempCommand[16];
1056 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
1057 unsigned long flags;
1060 * Notify the boards they may generate interrupts. This is done by
1061 * sending an in-line command to channel 0 on each board. This is why
1062 * the channels have to be defined already. For each board, if the
1063 * interrupt has never been defined, we must do so NOW, directly, since
1064 * board will not send flow control or even give an interrupt until this
1065 * is done. If polling we must send 0 as the interrupt parameter.
1068 // We will get an interrupt here at the end of this function
1070 iiDisableMailIrq(pB);
1072 /* We build up the entire packet header. */
1073 CHANNEL_OF(tempCommand) = 0;
1074 PTYPE_OF(tempCommand) = PTYPE_INLINE;
1075 CMD_COUNT_OF(tempCommand) = 2;
1076 (CMD_OF(tempCommand))[0] = CMDVALUE_IRQ;
1077 (CMD_OF(tempCommand))[1] = boardIrq;
1079 * Write to FIFO; don't bother to adjust fifo capacity for this, since
1080 * board will respond almost immediately after SendMail hit.
1082 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1083 iiWriteBuf(pB, tempCommand, 4);
1084 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1085 pB->i2eUsingIrq = boardIrq;
1086 pB->i2eOutMailWaiting |= MB_OUT_STUFFED;
1088 /* Need to update number of boards before you enable mailbox int */
1091 CHANNEL_OF(tempCommand) = 0;
1092 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1093 CMD_COUNT_OF(tempCommand) = 6;
1094 (CMD_OF(tempCommand))[0] = 88; // SILO
1095 (CMD_OF(tempCommand))[1] = 64; // chars
1096 (CMD_OF(tempCommand))[2] = 32; // ms
1098 (CMD_OF(tempCommand))[3] = 28; // MAX_BLOCK
1099 (CMD_OF(tempCommand))[4] = 64; // chars
1101 (CMD_OF(tempCommand))[5] = 87; // HW_TEST
1102 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1103 iiWriteBuf(pB, tempCommand, 8);
1104 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1106 CHANNEL_OF(tempCommand) = 0;
1107 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1108 CMD_COUNT_OF(tempCommand) = 1;
1109 (CMD_OF(tempCommand))[0] = 84; /* get BOX_IDS */
1110 iiWriteBuf(pB, tempCommand, 3);
1113 // enable heartbeat for test porpoises
1114 CHANNEL_OF(tempCommand) = 0;
1115 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1116 CMD_COUNT_OF(tempCommand) = 2;
1117 (CMD_OF(tempCommand))[0] = 44; /* get ping */
1118 (CMD_OF(tempCommand))[1] = 200; /* 200 ms */
1119 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1120 iiWriteBuf(pB, tempCommand, 4);
1121 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1124 iiEnableMailIrq(pB);
1125 iiSendPendingMail(pB);
1128 /******************************************************************************/
1129 /* Interrupt Handler Section */
1130 /******************************************************************************/
1133 service_all_boards(void)
1138 /* Service every board on the list */
1139 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
1140 pB = i2BoardPtrTable[i];
1142 i2ServiceBoard( pB );
1148 /******************************************************************************/
1149 /* Function: ip2_interrupt_bh(pB) */
1150 /* Parameters: pB - pointer to the board structure */
1151 /* Returns: Nothing */
1154 /* Service the board in a bottom half interrupt handler and then */
1155 /* reenable the board's interrupts if it has an IRQ number */
1157 /******************************************************************************/
1159 ip2_interrupt_bh(i2eBordStrPtr pB)
1161 // pB better well be set or we have a problem! We can only get
1162 // here from the IMMEDIATE queue. Here, we process the boards.
1163 // Checking pB doesn't cost much and it saves us from the sanity checkers.
1168 i2ServiceBoard( pB );
1169 if( pB->i2eUsingIrq ) {
1170 // Re-enable his interrupts
1171 iiEnableMailIrq(pB);
1177 /******************************************************************************/
1178 /* Function: ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs) */
1179 /* Parameters: irq - interrupt number */
1180 /* pointer to optional device ID structure */
1181 /* pointer to register structure */
1182 /* Returns: Nothing */
1186 /* Our task here is simply to identify each board which needs servicing. */
1187 /* If we are queuing then, queue it to be serviced, and disable its irq */
1188 /* mask otherwise process the board directly. */
1190 /* We could queue by IRQ but that just complicates things on both ends */
1191 /* with very little gain in performance (how many instructions does */
1192 /* it take to iterate on the immediate queue). */
1195 /******************************************************************************/
1197 ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1203 ip2trace (ITRC_NO_PORT, ITRC_INTR, 99, 1, irq );
1205 /* Service just the boards on the list using this irq */
1206 for( i = 0; i < i2nBoards; ++i ) {
1207 pB = i2BoardPtrTable[i];
1209 // Only process those boards which match our IRQ.
1210 // IRQ = 0 for polled boards, we won't poll "IRQ" boards
1212 if ( pB && (pB->i2eUsingIrq == irq) ) {
1216 if (NO_MAIL_HERE != ( pB->i2eStartMail = iiGetMail(pB))) {
1217 // Disable his interrupt (will be enabled when serviced)
1218 // This is mostly to protect from reentrancy.
1219 iiDisableMailIrq(pB);
1221 // Park the board on the immediate queue for processing.
1222 schedule_work(&pB->tqueue_interrupt);
1224 // Make sure the immediate queue is flagged to fire.
1227 // We are using immediate servicing here. This sucks and can
1228 // cause all sorts of havoc with ppp and others. The failsafe
1229 // check on iiSendPendingMail could also throw a hairball.
1230 i2ServiceBoard( pB );
1231 #endif /* USE_IQI */
1237 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1238 return IRQ_RETVAL(handled);
1241 /******************************************************************************/
1242 /* Function: ip2_poll(unsigned long arg) */
1244 /* Returns: Nothing */
1247 /* This function calls the library routine i2ServiceBoard for each board in */
1248 /* the board table. This is used instead of the interrupt routine when polled */
1249 /* mode is specified. */
1250 /******************************************************************************/
1252 ip2_poll(unsigned long arg)
1254 ip2trace (ITRC_NO_PORT, ITRC_INTR, 100, 0 );
1256 TimerOn = 0; // it's the truth but not checked in service
1258 // Just polled boards, IRQ = 0 will hit all non-interrupt boards.
1259 // It will NOT poll boards handled by hard interrupts.
1260 // The issue of queued BH interrups is handled in ip2_interrupt().
1261 ip2_interrupt(0, NULL, NULL);
1263 PollTimer.expires = POLL_TIMEOUT;
1264 add_timer( &PollTimer );
1267 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1270 static void do_input(void *p)
1272 i2ChanStrPtr pCh = p;
1273 unsigned long flags;
1275 ip2trace(CHANN, ITRC_INPUT, 21, 0 );
1278 if ( pCh->pTTY != NULL ) {
1279 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1280 if (!pCh->throttled && (pCh->Ibuf_stuff != pCh->Ibuf_strip)) {
1281 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1284 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1286 ip2trace(CHANN, ITRC_INPUT, 22, 0 );
1288 i2InputFlush( pCh );
1292 // code duplicated from n_tty (ldisc)
1293 static inline void isig(int sig, struct tty_struct *tty, int flush)
1296 kill_pg(tty->pgrp, sig, 1);
1297 if (flush || !L_NOFLSH(tty)) {
1298 if ( tty->ldisc.flush_buffer )
1299 tty->ldisc.flush_buffer(tty);
1300 i2InputFlush( tty->driver_data );
1304 static void do_status(void *p)
1306 i2ChanStrPtr pCh = p;
1309 status = i2GetStatus( pCh, (I2_BRK|I2_PAR|I2_FRA|I2_OVR) );
1311 ip2trace (CHANN, ITRC_STATUS, 21, 1, status );
1313 if (pCh->pTTY && (status & (I2_BRK|I2_PAR|I2_FRA|I2_OVR)) ) {
1314 if ( (status & I2_BRK) ) {
1315 // code duplicated from n_tty (ldisc)
1316 if (I_IGNBRK(pCh->pTTY))
1318 if (I_BRKINT(pCh->pTTY)) {
1319 isig(SIGINT, pCh->pTTY, 1);
1322 wake_up_interruptible(&pCh->pTTY->read_wait);
1324 #ifdef NEVER_HAPPENS_AS_SETUP_XXX
1325 // and can't work because we don't know the_char
1326 // as the_char is reported on a separate path
1327 // The intelligent board does this stuff as setup
1329 char brkf = TTY_NORMAL;
1330 unsigned char brkc = '\0';
1332 if ( (status & I2_BRK) ) {
1336 else if (status & I2_PAR) {
1339 } else if (status & I2_FRA) {
1342 } else if (status & I2_OVR) {
1346 tmp = pCh->pTTY->real_raw;
1347 pCh->pTTY->real_raw = 0;
1348 pCh->pTTY->ldisc.receive_buf( pCh->pTTY, &brkc, &brkf, 1 );
1349 pCh->pTTY->real_raw = tmp;
1351 #endif /* NEVER_HAPPENS_AS_SETUP_XXX */
1355 if ( status & (I2_DDCD | I2_DDSR | I2_DCTS | I2_DRI) ) {
1356 wake_up_interruptible(&pCh->delta_msr_wait);
1358 if ( (pCh->flags & ASYNC_CHECK_CD) && (status & I2_DDCD) ) {
1359 if ( status & I2_DCD ) {
1361 wake_up_interruptible ( &pCh->open_wait );
1364 if (pCh->pTTY && (!(pCh->pTTY->termios->c_cflag & CLOCAL)) ) {
1365 tty_hangup( pCh->pTTY );
1371 ip2trace (CHANN, ITRC_STATUS, 26, 0 );
1374 /******************************************************************************/
1375 /* Device Open/Close/Ioctl Entry Point Section */
1376 /******************************************************************************/
1378 /******************************************************************************/
1379 /* Function: open_sanity_check() */
1380 /* Parameters: Pointer to tty structure */
1381 /* Pointer to file structure */
1382 /* Returns: Success or failure */
1385 /* Verifies the structure magic numbers and cross links. */
1386 /******************************************************************************/
1387 #ifdef IP2DEBUG_OPEN
1389 open_sanity_check( i2ChanStrPtr pCh, i2eBordStrPtr pBrd )
1391 if ( pBrd->i2eValid != I2E_MAGIC ) {
1392 printk(KERN_ERR "IP2: invalid board structure\n" );
1393 } else if ( pBrd != pCh->pMyBord ) {
1394 printk(KERN_ERR "IP2: board structure pointer mismatch (%p)\n",
1396 } else if ( pBrd->i2eChannelCnt < pCh->port_index ) {
1397 printk(KERN_ERR "IP2: bad device index (%d)\n", pCh->port_index );
1398 } else if (&((i2ChanStrPtr)pBrd->i2eChannelPtr)[pCh->port_index] != pCh) {
1400 printk(KERN_INFO "IP2: all pointers check out!\n" );
1406 /******************************************************************************/
1407 /* Function: ip2_open() */
1408 /* Parameters: Pointer to tty structure */
1409 /* Pointer to file structure */
1410 /* Returns: Success or failure */
1412 /* Description: (MANDATORY) */
1413 /* A successful device open has to run a gauntlet of checks before it */
1414 /* completes. After some sanity checking and pointer setup, the function */
1415 /* blocks until all conditions are satisfied. It then initialises the port to */
1416 /* the default characteristics and returns. */
1417 /******************************************************************************/
1419 ip2_open( PTTY tty, struct file *pFile )
1424 i2ChanStrPtr pCh = DevTable[tty->index];
1426 ip2trace (tty->index, ITRC_OPEN, ITRC_ENTER, 0 );
1428 if ( pCh == NULL ) {
1431 /* Setup pointer links in device and tty structures */
1433 tty->driver_data = pCh;
1435 #ifdef IP2DEBUG_OPEN
1437 "IP2:open(tty=%p,pFile=%p):dev=%s,ch=%d,idx=%d\n",
1438 tty, pFile, tty->name, pCh->infl.hd.i2sChannel, pCh->port_index);
1439 open_sanity_check ( pCh, pCh->pMyBord );
1442 i2QueueCommands(PTYPE_INLINE, pCh, 100, 3, CMD_DTRUP,CMD_RTSUP,CMD_DCD_REP);
1443 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1444 serviceOutgoingFifo( pCh->pMyBord );
1446 /* Block here until the port is ready (per serial and istallion) */
1448 * 1. If the port is in the middle of closing wait for the completion
1449 * and then return the appropriate error.
1451 init_waitqueue_entry(&wait, current);
1452 add_wait_queue(&pCh->close_wait, &wait);
1453 set_current_state( TASK_INTERRUPTIBLE );
1455 if ( tty_hung_up_p(pFile) || ( pCh->flags & ASYNC_CLOSING )) {
1456 if ( pCh->flags & ASYNC_CLOSING ) {
1459 if ( tty_hung_up_p(pFile) ) {
1460 set_current_state( TASK_RUNNING );
1461 remove_wait_queue(&pCh->close_wait, &wait);
1462 return( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS;
1465 set_current_state( TASK_RUNNING );
1466 remove_wait_queue(&pCh->close_wait, &wait);
1469 * 3. Handle a non-blocking open of a normal port.
1471 if ( (pFile->f_flags & O_NONBLOCK) || (tty->flags & (1<<TTY_IO_ERROR) )) {
1472 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1476 * 4. Now loop waiting for the port to be free and carrier present
1479 if ( tty->termios->c_cflag & CLOCAL )
1482 #ifdef IP2DEBUG_OPEN
1483 printk(KERN_DEBUG "OpenBlock: do_clocal = %d\n", do_clocal);
1488 init_waitqueue_entry(&wait, current);
1489 add_wait_queue(&pCh->open_wait, &wait);
1492 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
1493 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1494 set_current_state( TASK_INTERRUPTIBLE );
1495 serviceOutgoingFifo( pCh->pMyBord );
1496 if ( tty_hung_up_p(pFile) ) {
1497 set_current_state( TASK_RUNNING );
1498 remove_wait_queue(&pCh->open_wait, &wait);
1499 return ( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EBUSY : -ERESTARTSYS;
1501 if (!(pCh->flags & ASYNC_CLOSING) &&
1502 (do_clocal || (pCh->dataSetIn & I2_DCD) )) {
1507 #ifdef IP2DEBUG_OPEN
1508 printk(KERN_DEBUG "ASYNC_CLOSING = %s\n",
1509 (pCh->flags & ASYNC_CLOSING)?"True":"False");
1510 printk(KERN_DEBUG "OpenBlock: waiting for CD or signal\n");
1512 ip2trace (CHANN, ITRC_OPEN, 3, 2, 0,
1513 (pCh->flags & ASYNC_CLOSING) );
1514 /* check for signal */
1515 if (signal_pending(current)) {
1516 rc = (( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS);
1521 set_current_state( TASK_RUNNING );
1522 remove_wait_queue(&pCh->open_wait, &wait);
1524 --pCh->wopen; //why count?
1526 ip2trace (CHANN, ITRC_OPEN, 4, 0 );
1531 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1535 /* first open - Assign termios structure to port */
1536 if ( tty->count == 1 ) {
1537 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1538 /* Now we must send the termios settings to the loadware */
1539 set_params( pCh, NULL );
1543 * Now set any i2lib options. These may go away if the i2lib code ends
1544 * up rolled into the mainline.
1546 pCh->channelOptions |= CO_NBLOCK_WRITE;
1548 #ifdef IP2DEBUG_OPEN
1549 printk (KERN_DEBUG "IP2: open completed\n" );
1551 serviceOutgoingFifo( pCh->pMyBord );
1553 ip2trace (CHANN, ITRC_OPEN, ITRC_RETURN, 0 );
1558 /******************************************************************************/
1559 /* Function: ip2_close() */
1560 /* Parameters: Pointer to tty structure */
1561 /* Pointer to file structure */
1562 /* Returns: Nothing */
1567 /******************************************************************************/
1569 ip2_close( PTTY tty, struct file *pFile )
1571 i2ChanStrPtr pCh = tty->driver_data;
1577 ip2trace (CHANN, ITRC_CLOSE, ITRC_ENTER, 0 );
1579 #ifdef IP2DEBUG_OPEN
1580 printk(KERN_DEBUG "IP2:close %s:\n",tty->name);
1583 if ( tty_hung_up_p ( pFile ) ) {
1585 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 2 );
1589 if ( tty->count > 1 ) { /* not the last close */
1591 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 3 );
1595 pCh->flags |= ASYNC_CLOSING; // last close actually
1599 if (pCh->ClosingWaitTime != ASYNC_CLOSING_WAIT_NONE) {
1601 * Before we drop DTR, make sure the transmitter has completely drained.
1602 * This uses an timeout, after which the close
1605 ip2_wait_until_sent(tty, pCh->ClosingWaitTime );
1608 * At this point we stop accepting input. Here we flush the channel
1609 * input buffer which will allow the board to send up more data. Any
1610 * additional input is tossed at interrupt/poll time.
1612 i2InputFlush( pCh );
1614 /* disable DSS reporting */
1615 i2QueueCommands(PTYPE_INLINE, pCh, 100, 4,
1616 CMD_DCD_NREP, CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1617 if ( !tty || (tty->termios->c_cflag & HUPCL) ) {
1618 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
1619 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1620 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1623 serviceOutgoingFifo ( pCh->pMyBord );
1625 if ( tty->driver->flush_buffer )
1626 tty->driver->flush_buffer(tty);
1627 if ( tty->ldisc.flush_buffer )
1628 tty->ldisc.flush_buffer(tty);
1634 if (pCh->ClosingDelay) {
1635 msleep_interruptible(jiffies_to_msecs(pCh->ClosingDelay));
1637 wake_up_interruptible(&pCh->open_wait);
1640 pCh->flags &=~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1641 wake_up_interruptible(&pCh->close_wait);
1643 #ifdef IP2DEBUG_OPEN
1644 DBG_CNT("ip2_close: after wakeups--");
1648 ip2trace (CHANN, ITRC_CLOSE, ITRC_RETURN, 1, 1 );
1653 /******************************************************************************/
1654 /* Function: ip2_hangup() */
1655 /* Parameters: Pointer to tty structure */
1656 /* Returns: Nothing */
1661 /******************************************************************************/
1663 ip2_hangup ( PTTY tty )
1665 i2ChanStrPtr pCh = tty->driver_data;
1671 ip2trace (CHANN, ITRC_HANGUP, ITRC_ENTER, 0 );
1673 ip2_flush_buffer(tty);
1675 /* disable DSS reporting */
1677 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_DCD_NREP);
1678 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1679 if ( (tty->termios->c_cflag & HUPCL) ) {
1680 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 2, CMD_RTSDN, CMD_DTRDN);
1681 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1682 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1684 i2QueueCommands(PTYPE_INLINE, pCh, 1, 3,
1685 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1686 serviceOutgoingFifo ( pCh->pMyBord );
1688 wake_up_interruptible ( &pCh->delta_msr_wait );
1690 pCh->flags &= ~ASYNC_NORMAL_ACTIVE;
1692 wake_up_interruptible ( &pCh->open_wait );
1694 ip2trace (CHANN, ITRC_HANGUP, ITRC_RETURN, 0 );
1697 /******************************************************************************/
1698 /******************************************************************************/
1699 /* Device Output Section */
1700 /******************************************************************************/
1701 /******************************************************************************/
1703 /******************************************************************************/
1704 /* Function: ip2_write() */
1705 /* Parameters: Pointer to tty structure */
1706 /* Flag denoting data is in user (1) or kernel (0) space */
1707 /* Pointer to data */
1708 /* Number of bytes to write */
1709 /* Returns: Number of bytes actually written */
1711 /* Description: (MANDATORY) */
1714 /******************************************************************************/
1716 ip2_write( PTTY tty, int user, const unsigned char *pData, int count)
1718 i2ChanStrPtr pCh = tty->driver_data;
1720 unsigned long flags;
1722 ip2trace (CHANN, ITRC_WRITE, ITRC_ENTER, 2, count, -1 );
1724 /* Flush out any buffered data left over from ip2_putchar() calls. */
1725 ip2_flush_chars( tty );
1727 /* This is the actual move bit. Make sure it does what we need!!!!! */
1728 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1729 bytesSent = i2Output( pCh, pData, count, user );
1730 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1732 ip2trace (CHANN, ITRC_WRITE, ITRC_RETURN, 1, bytesSent );
1734 return bytesSent > 0 ? bytesSent : 0;
1737 /******************************************************************************/
1738 /* Function: ip2_putchar() */
1739 /* Parameters: Pointer to tty structure */
1740 /* Character to write */
1741 /* Returns: Nothing */
1746 /******************************************************************************/
1748 ip2_putchar( PTTY tty, unsigned char ch )
1750 i2ChanStrPtr pCh = tty->driver_data;
1751 unsigned long flags;
1753 // ip2trace (CHANN, ITRC_PUTC, ITRC_ENTER, 1, ch );
1755 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1756 pCh->Pbuf[pCh->Pbuf_stuff++] = ch;
1757 if ( pCh->Pbuf_stuff == sizeof pCh->Pbuf ) {
1758 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1759 ip2_flush_chars( tty );
1761 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1763 // ip2trace (CHANN, ITRC_PUTC, ITRC_RETURN, 1, ch );
1766 /******************************************************************************/
1767 /* Function: ip2_flush_chars() */
1768 /* Parameters: Pointer to tty structure */
1769 /* Returns: Nothing */
1773 /******************************************************************************/
1775 ip2_flush_chars( PTTY tty )
1778 i2ChanStrPtr pCh = tty->driver_data;
1779 unsigned long flags;
1781 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1782 if ( pCh->Pbuf_stuff ) {
1784 // ip2trace (CHANN, ITRC_PUTC, 10, 1, strip );
1787 // We may need to restart i2Output if it does not fullfill this request
1789 strip = i2Output( pCh, pCh->Pbuf, pCh->Pbuf_stuff, 0 );
1790 if ( strip != pCh->Pbuf_stuff ) {
1791 memmove( pCh->Pbuf, &pCh->Pbuf[strip], pCh->Pbuf_stuff - strip );
1793 pCh->Pbuf_stuff -= strip;
1795 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1798 /******************************************************************************/
1799 /* Function: ip2_write_room() */
1800 /* Parameters: Pointer to tty structure */
1801 /* Returns: Number of bytes that the driver can accept */
1805 /******************************************************************************/
1807 ip2_write_room ( PTTY tty )
1810 i2ChanStrPtr pCh = tty->driver_data;
1811 unsigned long flags;
1813 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1814 bytesFree = i2OutputFree( pCh ) - pCh->Pbuf_stuff;
1815 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1817 ip2trace (CHANN, ITRC_WRITE, 11, 1, bytesFree );
1819 return ((bytesFree > 0) ? bytesFree : 0);
1822 /******************************************************************************/
1823 /* Function: ip2_chars_in_buf() */
1824 /* Parameters: Pointer to tty structure */
1825 /* Returns: Number of bytes queued for transmission */
1830 /******************************************************************************/
1832 ip2_chars_in_buf ( PTTY tty )
1834 i2ChanStrPtr pCh = tty->driver_data;
1836 unsigned long flags;
1838 ip2trace (CHANN, ITRC_WRITE, 12, 1, pCh->Obuf_char_count + pCh->Pbuf_stuff );
1840 #ifdef IP2DEBUG_WRITE
1841 printk (KERN_DEBUG "IP2: chars in buffer = %d (%d,%d)\n",
1842 pCh->Obuf_char_count + pCh->Pbuf_stuff,
1843 pCh->Obuf_char_count, pCh->Pbuf_stuff );
1845 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1846 rc = pCh->Obuf_char_count;
1847 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1848 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1849 rc += pCh->Pbuf_stuff;
1850 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1854 /******************************************************************************/
1855 /* Function: ip2_flush_buffer() */
1856 /* Parameters: Pointer to tty structure */
1857 /* Returns: Nothing */
1862 /******************************************************************************/
1864 ip2_flush_buffer( PTTY tty )
1866 i2ChanStrPtr pCh = tty->driver_data;
1867 unsigned long flags;
1869 ip2trace (CHANN, ITRC_FLUSH, ITRC_ENTER, 0 );
1871 #ifdef IP2DEBUG_WRITE
1872 printk (KERN_DEBUG "IP2: flush buffer\n" );
1874 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1875 pCh->Pbuf_stuff = 0;
1876 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1877 i2FlushOutput( pCh );
1880 ip2trace (CHANN, ITRC_FLUSH, ITRC_RETURN, 0 );
1884 /******************************************************************************/
1885 /* Function: ip2_wait_until_sent() */
1886 /* Parameters: Pointer to tty structure */
1887 /* Timeout for wait. */
1888 /* Returns: Nothing */
1891 /* This function is used in place of the normal tty_wait_until_sent, which */
1892 /* only waits for the driver buffers to be empty (or rather, those buffers */
1893 /* reported by chars_in_buffer) which doesn't work for IP2 due to the */
1894 /* indeterminate number of bytes buffered on the board. */
1895 /******************************************************************************/
1897 ip2_wait_until_sent ( PTTY tty, int timeout )
1900 i2ChanStrPtr pCh = tty->driver_data;
1902 tty_wait_until_sent(tty, timeout );
1903 if ( (i = timeout - (jiffies -i)) > 0)
1904 i2DrainOutput( pCh, i );
1907 /******************************************************************************/
1908 /******************************************************************************/
1909 /* Device Input Section */
1910 /******************************************************************************/
1911 /******************************************************************************/
1913 /******************************************************************************/
1914 /* Function: ip2_throttle() */
1915 /* Parameters: Pointer to tty structure */
1916 /* Returns: Nothing */
1921 /******************************************************************************/
1923 ip2_throttle ( PTTY tty )
1925 i2ChanStrPtr pCh = tty->driver_data;
1927 #ifdef IP2DEBUG_READ
1928 printk (KERN_DEBUG "IP2: throttle\n" );
1931 * Signal the poll/interrupt handlers not to forward incoming data to
1932 * the line discipline. This will cause the buffers to fill up in the
1933 * library and thus cause the library routines to send the flow control
1939 /******************************************************************************/
1940 /* Function: ip2_unthrottle() */
1941 /* Parameters: Pointer to tty structure */
1942 /* Returns: Nothing */
1947 /******************************************************************************/
1949 ip2_unthrottle ( PTTY tty )
1951 i2ChanStrPtr pCh = tty->driver_data;
1952 unsigned long flags;
1954 #ifdef IP2DEBUG_READ
1955 printk (KERN_DEBUG "IP2: unthrottle\n" );
1958 /* Pass incoming data up to the line discipline again. */
1960 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1961 serviceOutgoingFifo( pCh->pMyBord );
1962 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1963 if ( pCh->Ibuf_stuff != pCh->Ibuf_strip ) {
1964 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1965 #ifdef IP2DEBUG_READ
1966 printk (KERN_DEBUG "i2Input called from unthrottle\n" );
1970 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1974 ip2_start ( PTTY tty )
1976 i2ChanStrPtr pCh = DevTable[tty->index];
1978 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1979 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_UNSUSPEND);
1980 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_RESUME);
1981 #ifdef IP2DEBUG_WRITE
1982 printk (KERN_DEBUG "IP2: start tx\n" );
1987 ip2_stop ( PTTY tty )
1989 i2ChanStrPtr pCh = DevTable[tty->index];
1991 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_SUSPEND);
1992 #ifdef IP2DEBUG_WRITE
1993 printk (KERN_DEBUG "IP2: stop tx\n" );
1997 /******************************************************************************/
1998 /* Device Ioctl Section */
1999 /******************************************************************************/
2001 static int ip2_tiocmget(struct tty_struct *tty, struct file *file)
2003 i2ChanStrPtr pCh = DevTable[tty->index];
2010 FIXME - the following code is causing a NULL pointer dereference in
2011 2.3.51 in an interrupt handler. It's suppose to prompt the board
2012 to return the DSS signal status immediately. Why doesn't it do
2013 the same thing in 2.2.14?
2016 /* This thing is still busted in the 1.2.12 driver on 2.4.x
2017 and even hoses the serial console so the oops can be trapped.
2020 #ifdef ENABLE_DSSNOW
2021 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DSS_NOW);
2023 init_waitqueue_entry(&wait, current);
2024 add_wait_queue(&pCh->dss_now_wait, &wait);
2025 set_current_state( TASK_INTERRUPTIBLE );
2027 serviceOutgoingFifo( pCh->pMyBord );
2031 set_current_state( TASK_RUNNING );
2032 remove_wait_queue(&pCh->dss_now_wait, &wait);
2034 if (signal_pending(current)) {
2038 return ((pCh->dataSetOut & I2_RTS) ? TIOCM_RTS : 0)
2039 | ((pCh->dataSetOut & I2_DTR) ? TIOCM_DTR : 0)
2040 | ((pCh->dataSetIn & I2_DCD) ? TIOCM_CAR : 0)
2041 | ((pCh->dataSetIn & I2_RI) ? TIOCM_RNG : 0)
2042 | ((pCh->dataSetIn & I2_DSR) ? TIOCM_DSR : 0)
2043 | ((pCh->dataSetIn & I2_CTS) ? TIOCM_CTS : 0);
2046 static int ip2_tiocmset(struct tty_struct *tty, struct file *file,
2047 unsigned int set, unsigned int clear)
2049 i2ChanStrPtr pCh = DevTable[tty->index];
2054 if (set & TIOCM_RTS) {
2055 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSUP);
2056 pCh->dataSetOut |= I2_RTS;
2058 if (set & TIOCM_DTR) {
2059 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRUP);
2060 pCh->dataSetOut |= I2_DTR;
2063 if (clear & TIOCM_RTS) {
2064 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSDN);
2065 pCh->dataSetOut &= ~I2_RTS;
2067 if (clear & TIOCM_DTR) {
2068 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRDN);
2069 pCh->dataSetOut &= ~I2_DTR;
2071 serviceOutgoingFifo( pCh->pMyBord );
2075 /******************************************************************************/
2076 /* Function: ip2_ioctl() */
2077 /* Parameters: Pointer to tty structure */
2078 /* Pointer to file structure */
2081 /* Returns: Success or failure */
2086 /******************************************************************************/
2088 ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
2091 i2ChanStrPtr pCh = DevTable[tty->index];
2092 struct async_icount cprev, cnow; /* kernel counter temps */
2093 struct serial_icounter_struct __user *p_cuser;
2095 unsigned long flags;
2096 void __user *argp = (void __user *)arg;
2098 if ( pCh == NULL ) {
2102 ip2trace (CHANN, ITRC_IOCTL, ITRC_ENTER, 2, cmd, arg );
2104 #ifdef IP2DEBUG_IOCTL
2105 printk(KERN_DEBUG "IP2: ioctl cmd (%x), arg (%lx)\n", cmd, arg );
2111 ip2trace (CHANN, ITRC_IOCTL, 2, 1, rc );
2113 rc = get_serial_info(pCh, argp);
2120 ip2trace (CHANN, ITRC_IOCTL, 3, 1, rc );
2122 rc = set_serial_info(pCh, argp);
2128 rc = tty_check_change(tty);
2133 //return -ENOIOCTLCMD;
2136 //return -ENOIOCTLCMD;
2139 if (STOP_CHAR(tty) != __DISABLED_CHAR) {
2140 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2141 CMD_XMIT_NOW(STOP_CHAR(tty)));
2145 if (START_CHAR(tty) != __DISABLED_CHAR) {
2146 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2147 CMD_XMIT_NOW(START_CHAR(tty)));
2155 case TCSBRK: /* SVID version: non-zero arg --> no break */
2156 rc = tty_check_change(tty);
2158 ip2trace (CHANN, ITRC_IOCTL, 4, 1, rc );
2161 ip2_wait_until_sent(tty,0);
2163 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SEND_BRK(250));
2164 serviceOutgoingFifo( pCh->pMyBord );
2169 case TCSBRKP: /* support for POSIX tcsendbreak() */
2170 rc = tty_check_change(tty);
2172 ip2trace (CHANN, ITRC_IOCTL, 5, 1, rc );
2175 ip2_wait_until_sent(tty,0);
2176 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2177 CMD_SEND_BRK(arg ? arg*100 : 250));
2178 serviceOutgoingFifo ( pCh->pMyBord );
2184 ip2trace (CHANN, ITRC_IOCTL, 6, 1, rc );
2186 rc = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
2193 ip2trace (CHANN, ITRC_IOCTL, 7, 1, rc );
2195 rc = get_user(arg,(unsigned long __user *) argp);
2198 tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL)
2199 | (arg ? CLOCAL : 0));
2204 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change - mask
2205 * passed in arg for lines of interest (use |'ed TIOCM_RNG/DSR/CD/CTS
2206 * for masking). Caller should use TIOCGICOUNT to see which one it was
2209 save_flags(flags);cli();
2210 cprev = pCh->icount; /* note the counters on entry */
2211 restore_flags(flags);
2212 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 4,
2213 CMD_DCD_REP, CMD_CTS_REP, CMD_DSR_REP, CMD_RI_REP);
2214 init_waitqueue_entry(&wait, current);
2215 add_wait_queue(&pCh->delta_msr_wait, &wait);
2216 set_current_state( TASK_INTERRUPTIBLE );
2218 serviceOutgoingFifo( pCh->pMyBord );
2220 ip2trace (CHANN, ITRC_IOCTL, 10, 0 );
2224 ip2trace (CHANN, ITRC_IOCTL, 11, 0 );
2226 /* see if a signal did it */
2227 if (signal_pending(current)) {
2231 save_flags(flags);cli();
2232 cnow = pCh->icount; /* atomic copy */
2233 restore_flags(flags);
2234 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2235 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
2236 rc = -EIO; /* no change => rc */
2239 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2240 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2241 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2242 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
2248 set_current_state( TASK_RUNNING );
2249 remove_wait_queue(&pCh->delta_msr_wait, &wait);
2251 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 3,
2252 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
2253 if ( ! (pCh->flags & ASYNC_CHECK_CD)) {
2254 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DCD_NREP);
2256 serviceOutgoingFifo( pCh->pMyBord );
2261 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2262 * Return: write counters to the user passed counter struct
2263 * NB: both 1->0 and 0->1 transitions are counted except for RI where
2264 * only 0->1 is counted. The controller is quite capable of counting
2265 * both, but this done to preserve compatibility with the standard
2269 ip2trace (CHANN, ITRC_IOCTL, 11, 1, rc );
2271 save_flags(flags);cli();
2273 restore_flags(flags);
2275 rc = put_user(cnow.cts, &p_cuser->cts);
2276 rc = put_user(cnow.dsr, &p_cuser->dsr);
2277 rc = put_user(cnow.rng, &p_cuser->rng);
2278 rc = put_user(cnow.dcd, &p_cuser->dcd);
2279 rc = put_user(cnow.rx, &p_cuser->rx);
2280 rc = put_user(cnow.tx, &p_cuser->tx);
2281 rc = put_user(cnow.frame, &p_cuser->frame);
2282 rc = put_user(cnow.overrun, &p_cuser->overrun);
2283 rc = put_user(cnow.parity, &p_cuser->parity);
2284 rc = put_user(cnow.brk, &p_cuser->brk);
2285 rc = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
2289 * The rest are not supported by this driver. By returning -ENOIOCTLCMD they
2290 * will be passed to the line discipline for it to handle.
2296 case TIOCSERGSTRUCT:
2297 case TIOCSERGETMULTI:
2298 case TIOCSERSETMULTI:
2301 ip2trace (CHANN, ITRC_IOCTL, 12, 0 );
2307 ip2trace (CHANN, ITRC_IOCTL, ITRC_RETURN, 0 );
2312 /******************************************************************************/
2313 /* Function: GetSerialInfo() */
2314 /* Parameters: Pointer to channel structure */
2315 /* Pointer to old termios structure */
2316 /* Returns: Nothing */
2319 /* This is to support the setserial command, and requires processing of the */
2320 /* standard Linux serial structure. */
2321 /******************************************************************************/
2323 get_serial_info ( i2ChanStrPtr pCh, struct serial_struct __user *retinfo )
2325 struct serial_struct tmp;
2327 memset ( &tmp, 0, sizeof(tmp) );
2328 tmp.type = pCh->pMyBord->channelBtypes.bid_value[(pCh->port_index & (IP2_PORTS_PER_BOARD-1))/16];
2329 if (BID_HAS_654(tmp.type)) {
2330 tmp.type = PORT_16650;
2332 tmp.type = PORT_CIRRUS;
2334 tmp.line = pCh->port_index;
2335 tmp.port = pCh->pMyBord->i2eBase;
2336 tmp.irq = ip2config.irq[pCh->port_index/64];
2337 tmp.flags = pCh->flags;
2338 tmp.baud_base = pCh->BaudBase;
2339 tmp.close_delay = pCh->ClosingDelay;
2340 tmp.closing_wait = pCh->ClosingWaitTime;
2341 tmp.custom_divisor = pCh->BaudDivisor;
2342 return copy_to_user(retinfo,&tmp,sizeof(*retinfo));
2345 /******************************************************************************/
2346 /* Function: SetSerialInfo() */
2347 /* Parameters: Pointer to channel structure */
2348 /* Pointer to old termios structure */
2349 /* Returns: Nothing */
2352 /* This function provides support for setserial, which uses the TIOCSSERIAL */
2353 /* ioctl. Not all setserial parameters are relevant. If the user attempts to */
2354 /* change the IRQ, address or type of the port the ioctl fails. */
2355 /******************************************************************************/
2357 set_serial_info( i2ChanStrPtr pCh, struct serial_struct __user *new_info )
2359 struct serial_struct ns;
2360 int old_flags, old_baud_divisor;
2362 if (copy_from_user(&ns, new_info, sizeof (ns)))
2366 * We don't allow setserial to change IRQ, board address, type or baud
2367 * base. Also line nunber as such is meaningless but we use it for our
2368 * array index so it is fixed also.
2370 if ( (ns.irq != ip2config.irq[pCh->port_index])
2371 || ((int) ns.port != ((int) (pCh->pMyBord->i2eBase)))
2372 || (ns.baud_base != pCh->BaudBase)
2373 || (ns.line != pCh->port_index) ) {
2377 old_flags = pCh->flags;
2378 old_baud_divisor = pCh->BaudDivisor;
2380 if ( !capable(CAP_SYS_ADMIN) ) {
2381 if ( ( ns.close_delay != pCh->ClosingDelay ) ||
2382 ( (ns.flags & ~ASYNC_USR_MASK) !=
2383 (pCh->flags & ~ASYNC_USR_MASK) ) ) {
2387 pCh->flags = (pCh->flags & ~ASYNC_USR_MASK) |
2388 (ns.flags & ASYNC_USR_MASK);
2389 pCh->BaudDivisor = ns.custom_divisor;
2391 pCh->flags = (pCh->flags & ~ASYNC_FLAGS) |
2392 (ns.flags & ASYNC_FLAGS);
2393 pCh->BaudDivisor = ns.custom_divisor;
2394 pCh->ClosingDelay = ns.close_delay * HZ/100;
2395 pCh->ClosingWaitTime = ns.closing_wait * HZ/100;
2398 if ( ( (old_flags & ASYNC_SPD_MASK) != (pCh->flags & ASYNC_SPD_MASK) )
2399 || (old_baud_divisor != pCh->BaudDivisor) ) {
2400 // Invalidate speed and reset parameters
2401 set_params( pCh, NULL );
2407 /******************************************************************************/
2408 /* Function: ip2_set_termios() */
2409 /* Parameters: Pointer to tty structure */
2410 /* Pointer to old termios structure */
2411 /* Returns: Nothing */
2416 /******************************************************************************/
2418 ip2_set_termios( PTTY tty, struct termios *old_termios )
2420 i2ChanStrPtr pCh = (i2ChanStrPtr)tty->driver_data;
2422 #ifdef IP2DEBUG_IOCTL
2423 printk (KERN_DEBUG "IP2: set termios %p\n", old_termios );
2426 set_params( pCh, old_termios );
2429 /******************************************************************************/
2430 /* Function: ip2_set_line_discipline() */
2431 /* Parameters: Pointer to tty structure */
2432 /* Returns: Nothing */
2434 /* Description: Does nothing */
2437 /******************************************************************************/
2439 ip2_set_line_discipline ( PTTY tty )
2441 #ifdef IP2DEBUG_IOCTL
2442 printk (KERN_DEBUG "IP2: set line discipline\n" );
2445 ip2trace (((i2ChanStrPtr)tty->driver_data)->port_index, ITRC_IOCTL, 16, 0 );
2449 /******************************************************************************/
2450 /* Function: SetLine Characteristics() */
2451 /* Parameters: Pointer to channel structure */
2452 /* Returns: Nothing */
2455 /* This routine is called to update the channel structure with the new line */
2456 /* characteristics, and send the appropriate commands to the board when they */
2458 /******************************************************************************/
2460 set_params( i2ChanStrPtr pCh, struct termios *o_tios )
2462 tcflag_t cflag, iflag, lflag;
2463 char stop_char, start_char;
2464 struct termios dummy;
2466 lflag = pCh->pTTY->termios->c_lflag;
2467 cflag = pCh->pTTY->termios->c_cflag;
2468 iflag = pCh->pTTY->termios->c_iflag;
2470 if (o_tios == NULL) {
2471 dummy.c_lflag = ~lflag;
2472 dummy.c_cflag = ~cflag;
2473 dummy.c_iflag = ~iflag;
2478 switch ( cflag & CBAUD ) {
2480 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
2481 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
2482 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
2483 pCh->pTTY->termios->c_cflag |= (CBAUD & o_tios->c_cflag);
2488 * This is the speed that is overloaded with all the other high
2489 * speeds, depending upon the flag settings.
2491 if ( ( pCh->flags & ASYNC_SPD_MASK ) == ASYNC_SPD_HI ) {
2492 pCh->speed = CBR_57600;
2493 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI ) {
2494 pCh->speed = CBR_115200;
2495 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST ) {
2496 pCh->speed = CBR_C1;
2498 pCh->speed = CBR_38400;
2501 case B50: pCh->speed = CBR_50; break;
2502 case B75: pCh->speed = CBR_75; break;
2503 case B110: pCh->speed = CBR_110; break;
2504 case B134: pCh->speed = CBR_134; break;
2505 case B150: pCh->speed = CBR_150; break;
2506 case B200: pCh->speed = CBR_200; break;
2507 case B300: pCh->speed = CBR_300; break;
2508 case B600: pCh->speed = CBR_600; break;
2509 case B1200: pCh->speed = CBR_1200; break;
2510 case B1800: pCh->speed = CBR_1800; break;
2511 case B2400: pCh->speed = CBR_2400; break;
2512 case B4800: pCh->speed = CBR_4800; break;
2513 case B9600: pCh->speed = CBR_9600; break;
2514 case B19200: pCh->speed = CBR_19200; break;
2515 case B57600: pCh->speed = CBR_57600; break;
2516 case B115200: pCh->speed = CBR_115200; break;
2517 case B153600: pCh->speed = CBR_153600; break;
2518 case B230400: pCh->speed = CBR_230400; break;
2519 case B307200: pCh->speed = CBR_307200; break;
2520 case B460800: pCh->speed = CBR_460800; break;
2521 case B921600: pCh->speed = CBR_921600; break;
2522 default: pCh->speed = CBR_9600; break;
2524 if ( pCh->speed == CBR_C1 ) {
2525 // Process the custom speed parameters.
2526 int bps = pCh->BaudBase / pCh->BaudDivisor;
2527 if ( bps == 921600 ) {
2528 pCh->speed = CBR_921600;
2531 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_BAUD_DEF1(bps) );
2534 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_SETBAUD(pCh->speed));
2536 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
2537 pCh->dataSetOut |= (I2_DTR | I2_RTS);
2539 if ( (CSTOPB & cflag) ^ (CSTOPB & o_tios->c_cflag))
2541 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2542 CMD_SETSTOP( ( cflag & CSTOPB ) ? CST_2 : CST_1));
2544 if (((PARENB|PARODD) & cflag) ^ ((PARENB|PARODD) & o_tios->c_cflag))
2546 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2548 (cflag & PARENB ? (cflag & PARODD ? CSP_OD : CSP_EV) : CSP_NP)
2552 /* byte size and parity */
2553 if ( (CSIZE & cflag)^(CSIZE & o_tios->c_cflag))
2556 switch ( cflag & CSIZE ) {
2557 case CS5: datasize = CSZ_5; break;
2558 case CS6: datasize = CSZ_6; break;
2559 case CS7: datasize = CSZ_7; break;
2560 case CS8: datasize = CSZ_8; break;
2561 default: datasize = CSZ_5; break; /* as per serial.c */
2563 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1, CMD_SETBITS(datasize) );
2565 /* Process CTS flow control flag setting */
2566 if ( (cflag & CRTSCTS) ) {
2567 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2568 2, CMD_CTSFL_ENAB, CMD_RTSFL_ENAB);
2570 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2571 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
2574 // Process XON/XOFF flow control flags settings
2576 stop_char = STOP_CHAR(pCh->pTTY);
2577 start_char = START_CHAR(pCh->pTTY);
2579 //////////// can't be \000
2580 if (stop_char == __DISABLED_CHAR )
2582 stop_char = ~__DISABLED_CHAR;
2584 if (start_char == __DISABLED_CHAR )
2586 start_char = ~__DISABLED_CHAR;
2588 /////////////////////////////////
2590 if ( o_tios->c_cc[VSTART] != start_char )
2592 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXON(start_char));
2593 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXON(start_char));
2595 if ( o_tios->c_cc[VSTOP] != stop_char )
2597 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXOFF(stop_char));
2598 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXOFF(stop_char));
2600 if (stop_char == __DISABLED_CHAR )
2602 stop_char = ~__DISABLED_CHAR; //TEST123
2605 if ((iflag & (IXOFF))^(o_tios->c_iflag & (IXOFF)))
2607 if ( iflag & IXOFF ) { // Enable XOFF output flow control
2608 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_XON));
2609 } else { // Disable XOFF output flow control
2611 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_NONE));
2614 if (start_char == __DISABLED_CHAR )
2618 if ((iflag & (IXON|IXANY)) ^ (o_tios->c_iflag & (IXON|IXANY)))
2620 if ( iflag & IXON ) {
2621 if ( iflag & IXANY ) { // Enable XON/XANY output flow control
2622 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XANY));
2623 } else { // Enable XON output flow control
2624 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XON));
2626 } else { // Disable XON output flow control
2628 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_NONE));
2631 if ( (iflag & ISTRIP) ^ ( o_tios->c_iflag & (ISTRIP)) )
2633 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2634 CMD_ISTRIP_OPT((iflag & ISTRIP ? 1 : 0)));
2636 if ( (iflag & INPCK) ^ ( o_tios->c_iflag & (INPCK)) )
2638 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2639 CMD_PARCHK((iflag & INPCK) ? CPK_ENAB : CPK_DSAB));
2642 if ( (iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR))
2643 ^ ( o_tios->c_iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR)) )
2648 if ( iflag & IGNBRK ) { /* Ignore breaks altogether */
2649 /* Ignore breaks altogether */
2650 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_NREP);
2652 if ( iflag & BRKINT ) {
2653 if ( iflag & PARMRK ) {
2654 brkrpt = 0x0a; // exception an inline triple
2656 brkrpt = 0x1a; // exception and NULL
2658 brkrpt |= 0x04; // flush input
2660 if ( iflag & PARMRK ) {
2661 brkrpt = 0x0b; //POSIX triple \0377 \0 \0
2663 brkrpt = 0x01; // Null only
2666 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_REP(brkrpt));
2669 if (iflag & IGNPAR) {
2671 /* would be 2 for not cirrus bug */
2672 /* would be 0x20 cept for cirrus bug */
2674 if ( iflag & PARMRK ) {
2676 * Replace error characters with 3-byte sequence (\0377,\0,char)
2679 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_ISTRIP_OPT((char)0));
2684 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SET_ERROR(parrpt));
2686 if (cflag & CLOCAL) {
2687 // Status reporting fails for DCD if this is off
2688 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_NREP);
2689 pCh->flags &= ~ASYNC_CHECK_CD;
2691 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_REP);
2692 pCh->flags |= ASYNC_CHECK_CD;
2696 do_flags_thing: // This is a test, we don't do the flags thing
2698 if ( (cflag & CRTSCTS) ) {
2699 cflag |= 014000000000;
2701 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1,
2702 CMD_UNIX_FLAGS(iflag,cflag,lflag));
2706 i2DrainOutput( pCh, 100 );
2709 /******************************************************************************/
2710 /* IPL Device Section */
2711 /******************************************************************************/
2713 /******************************************************************************/
2714 /* Function: ip2_ipl_read() */
2715 /* Parameters: Pointer to device inode */
2716 /* Pointer to file structure */
2717 /* Pointer to data */
2718 /* Number of bytes to read */
2719 /* Returns: Success or failure */
2721 /* Description: Ugly */
2724 /******************************************************************************/
2728 ip2_ipl_read(struct file *pFile, char __user *pData, size_t count, loff_t *off )
2730 unsigned int minor = iminor(pFile->f_dentry->d_inode);
2734 printk (KERN_DEBUG "IP2IPL: read %p, %d bytes\n", pData, count );
2738 case 0: // IPL device
2741 case 1: // Status dump
2744 case 2: // Ping device
2747 case 3: // Trace device
2748 rc = DumpTraceBuffer ( pData, count );
2750 case 4: // Trace device
2751 rc = DumpFifoBuffer ( pData, count );
2761 DumpFifoBuffer ( char __user *pData, int count )
2765 rc = copy_to_user(pData, DBGBuf, count);
2767 printk(KERN_DEBUG "Last index %d\n", I );
2770 #endif /* DEBUG_FIFO */
2775 DumpTraceBuffer ( char __user *pData, int count )
2777 #ifdef IP2DEBUG_TRACE
2781 int *pIndex = (int __user *)pData;
2783 if ( count < (sizeof(int) * 6) ) {
2786 rc = put_user(tracewrap, pIndex );
2787 rc = put_user(TRACEMAX, ++pIndex );
2788 rc = put_user(tracestrip, ++pIndex );
2789 rc = put_user(tracestuff, ++pIndex );
2790 pData += sizeof(int) * 6;
2791 count -= sizeof(int) * 6;
2793 dumpcount = tracestuff - tracestrip;
2794 if ( dumpcount < 0 ) {
2795 dumpcount += TRACEMAX;
2797 if ( dumpcount > count ) {
2800 chunk = TRACEMAX - tracestrip;
2801 if ( dumpcount > chunk ) {
2802 rc = copy_to_user(pData, &tracebuf[tracestrip],
2803 chunk * sizeof(tracebuf[0]) );
2804 pData += chunk * sizeof(tracebuf[0]);
2806 chunk = dumpcount - chunk;
2810 rc = copy_to_user(pData, &tracebuf[tracestrip],
2811 chunk * sizeof(tracebuf[0]) );
2812 tracestrip += chunk;
2815 rc = put_user(tracestrip, ++pIndex );
2816 rc = put_user(tracestuff, ++pIndex );
2824 /******************************************************************************/
2825 /* Function: ip2_ipl_write() */
2827 /* Pointer to file structure */
2828 /* Pointer to data */
2829 /* Number of bytes to write */
2830 /* Returns: Success or failure */
2835 /******************************************************************************/
2837 ip2_ipl_write(struct file *pFile, const char __user *pData, size_t count, loff_t *off)
2840 printk (KERN_DEBUG "IP2IPL: write %p, %d bytes\n", pData, count );
2845 /******************************************************************************/
2846 /* Function: ip2_ipl_ioctl() */
2847 /* Parameters: Pointer to device inode */
2848 /* Pointer to file structure */
2851 /* Returns: Success or failure */
2856 /******************************************************************************/
2858 ip2_ipl_ioctl ( struct inode *pInode, struct file *pFile, UINT cmd, ULONG arg )
2860 unsigned int iplminor = iminor(pInode);
2862 void __user *argp = (void __user *)arg;
2863 ULONG __user *pIndex = argp;
2864 i2eBordStrPtr pB = i2BoardPtrTable[iplminor / 4];
2868 printk (KERN_DEBUG "IP2IPL: ioctl cmd %d, arg %ld\n", cmd, arg );
2871 switch ( iplminor ) {
2872 case 0: // IPL device
2875 case 1: // Status dump
2880 case 64: /* Driver - ip2stat */
2881 rc = put_user(ip2_tty_driver->refcount, pIndex++ );
2882 rc = put_user(irq_counter, pIndex++ );
2883 rc = put_user(bh_counter, pIndex++ );
2886 case 65: /* Board - ip2stat */
2888 rc = copy_to_user(argp, pB, sizeof(i2eBordStr));
2889 rc = put_user(INB(pB->i2eStatus),
2890 (ULONG __user *)(arg + (ULONG)(&pB->i2eStatus) - (ULONG)pB ) );
2897 if (cmd < IP2_MAX_PORTS) {
2898 pCh = DevTable[cmd];
2901 rc = copy_to_user(argp, pCh, sizeof(i2ChanStr));
2911 case 2: // Ping device
2914 case 3: // Trace device
2916 rc = put_user(iiSendPendingMail, pIndex++ );
2917 rc = put_user(i2InitChannels, pIndex++ );
2918 rc = put_user(i2QueueNeeds, pIndex++ );
2919 rc = put_user(i2QueueCommands, pIndex++ );
2920 rc = put_user(i2GetStatus, pIndex++ );
2921 rc = put_user(i2Input, pIndex++ );
2922 rc = put_user(i2InputFlush, pIndex++ );
2923 rc = put_user(i2Output, pIndex++ );
2924 rc = put_user(i2FlushOutput, pIndex++ );
2925 rc = put_user(i2DrainWakeup, pIndex++ );
2926 rc = put_user(i2DrainOutput, pIndex++ );
2927 rc = put_user(i2OutputFree, pIndex++ );
2928 rc = put_user(i2StripFifo, pIndex++ );
2929 rc = put_user(i2StuffFifoBypass, pIndex++ );
2930 rc = put_user(i2StuffFifoFlow, pIndex++ );
2931 rc = put_user(i2StuffFifoInline, pIndex++ );
2932 rc = put_user(i2ServiceBoard, pIndex++ );
2933 rc = put_user(serviceOutgoingFifo, pIndex++ );
2934 // rc = put_user(ip2_init, pIndex++ );
2935 rc = put_user(ip2_init_board, pIndex++ );
2936 rc = put_user(find_eisa_board, pIndex++ );
2937 rc = put_user(set_irq, pIndex++ );
2938 rc = put_user(ip2_interrupt, pIndex++ );
2939 rc = put_user(ip2_poll, pIndex++ );
2940 rc = put_user(service_all_boards, pIndex++ );
2941 rc = put_user(do_input, pIndex++ );
2942 rc = put_user(do_status, pIndex++ );
2943 #ifndef IP2DEBUG_OPEN
2944 rc = put_user(0, pIndex++ );
2946 rc = put_user(open_sanity_check, pIndex++ );
2948 rc = put_user(ip2_open, pIndex++ );
2949 rc = put_user(ip2_close, pIndex++ );
2950 rc = put_user(ip2_hangup, pIndex++ );
2951 rc = put_user(ip2_write, pIndex++ );
2952 rc = put_user(ip2_putchar, pIndex++ );
2953 rc = put_user(ip2_flush_chars, pIndex++ );
2954 rc = put_user(ip2_write_room, pIndex++ );
2955 rc = put_user(ip2_chars_in_buf, pIndex++ );
2956 rc = put_user(ip2_flush_buffer, pIndex++ );
2958 //rc = put_user(ip2_wait_until_sent, pIndex++ );
2959 rc = put_user(0, pIndex++ );
2961 rc = put_user(ip2_throttle, pIndex++ );
2962 rc = put_user(ip2_unthrottle, pIndex++ );
2963 rc = put_user(ip2_ioctl, pIndex++ );
2964 rc = put_user(0, pIndex++ );
2965 rc = put_user(get_serial_info, pIndex++ );
2966 rc = put_user(set_serial_info, pIndex++ );
2967 rc = put_user(ip2_set_termios, pIndex++ );
2968 rc = put_user(ip2_set_line_discipline, pIndex++ );
2969 rc = put_user(set_params, pIndex++ );
2983 /******************************************************************************/
2984 /* Function: ip2_ipl_open() */
2985 /* Parameters: Pointer to device inode */
2986 /* Pointer to file structure */
2987 /* Returns: Success or failure */
2992 /******************************************************************************/
2994 ip2_ipl_open( struct inode *pInode, struct file *pFile )
2996 unsigned int iplminor = iminor(pInode);
3001 printk (KERN_DEBUG "IP2IPL: open\n" );
3005 // These are the IPL devices
3012 // These are the status devices
3019 // These are the debug devices
3024 pB = i2BoardPtrTable[iplminor / 4];
3025 pCh = (i2ChanStrPtr) pB->i2eChannelPtr;
3028 // This is the trace device
3034 /******************************************************************************/
3035 /* Function: ip2_read_procmem */
3038 /* Returns: Length of output */
3041 /* Supplies some driver operating parameters */
3042 /* Not real useful unless your debugging the fifo */
3044 /******************************************************************************/
3046 #define LIMIT (PAGE_SIZE - 120)
3049 ip2_read_procmem(char *buf, char **start, off_t offset, int len)
3058 #define FMTLINE "%3d: 0x%08x 0x%08x 0%011o 0%011o\n"
3059 #define FMTLIN2 " 0x%04x 0x%04x tx flow 0x%x\n"
3060 #define FMTLIN3 " 0x%04x 0x%04x rc flow\n"
3062 len += sprintf(buf+len,"\n");
3064 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3065 pB = i2BoardPtrTable[i];
3067 len += sprintf(buf+len,"board %d:\n",i);
3068 len += sprintf(buf+len,"\tFifo rem: %d mty: %x outM %x\n",
3069 pB->i2eFifoRemains,pB->i2eWaitingForEmptyFifo,pB->i2eOutMailWaiting);
3073 len += sprintf(buf+len,"#: tty flags, port flags, cflags, iflags\n");
3074 for (i=0; i < IP2_MAX_PORTS; i++) {
3080 if (tty && tty->count) {
3081 len += sprintf(buf+len,FMTLINE,i,(int)tty->flags,pCh->flags,
3082 tty->termios->c_cflag,tty->termios->c_iflag);
3084 len += sprintf(buf+len,FMTLIN2,
3085 pCh->outfl.asof,pCh->outfl.room,pCh->channelNeeds);
3086 len += sprintf(buf+len,FMTLIN3,pCh->infl.asof,pCh->infl.room);
3094 * This is the handler for /proc/tty/driver/ip2
3096 * This stretch of code has been largely plagerized from at least three
3097 * different sources including ip2mkdev.c and a couple of other drivers.
3098 * The bugs are all mine. :-) =mhw=
3100 int ip2_read_proc(char *page, char **start, off_t off,
3101 int count, int *eof, void *data)
3111 len += sprintf(page, "ip2info: 1.0 driver: %s\n", pcVersion );
3112 len += sprintf(page+len, "Driver: SMajor=%d CMajor=%d IMajor=%d MaxBoards=%d MaxBoxes=%d MaxPorts=%d\n",
3113 IP2_TTY_MAJOR, IP2_CALLOUT_MAJOR, IP2_IPL_MAJOR,
3114 IP2_MAX_BOARDS, ABS_MAX_BOXES, ABS_BIGGEST_BOX);
3116 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3117 /* This need to be reset for a board by board count... */
3119 pB = i2BoardPtrTable[i];
3121 switch( pB->i2ePom.e.porID & ~POR_ID_RESERVED )
3124 len += sprintf( page+len, "Board %d: EX ports=", i );
3125 for( box = 0; box < ABS_MAX_BOXES; ++box )
3129 if( pB->i2eChannelMap[box] != 0 ) ++boxes;
3130 for( j = 0; j < ABS_BIGGEST_BOX; ++j )
3132 if( pB->i2eChannelMap[box] & 1<< j ) {
3136 len += sprintf( page+len, "%d,", ports );
3140 --len; /* Backup over that last comma */
3142 len += sprintf( page+len, " boxes=%d width=%d", boxes, pB->i2eDataWidth16 ? 16 : 8 );
3146 len += sprintf(page+len, "Board %d: ISA-4 ports=4 boxes=1", i );
3151 len += sprintf(page+len, "Board %d: ISA-8-std ports=8 boxes=1", i );
3156 len += sprintf(page+len, "Board %d: ISA-8-RJ11 ports=8 boxes=1", i );
3161 len += sprintf(page+len, "Board %d: unknown", i );
3162 /* Don't try and probe for minor numbers */
3167 /* Don't try and probe for minor numbers */
3168 len += sprintf(page+len, "Board %d: vacant", i );
3173 len += sprintf(page+len, " minors=" );
3175 for ( box = 0; box < ABS_MAX_BOXES; ++box )
3177 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
3179 if ( pB->i2eChannelMap[box] & (1 << j) )
3181 len += sprintf (page+len,"%d,",
3182 j + ABS_BIGGEST_BOX *
3183 (box+i*ABS_MAX_BOXES));
3188 page[ len - 1 ] = '\n'; /* Overwrite that last comma */
3190 len += sprintf (page+len,"\n" );
3193 if (len+begin > off+count)
3195 if (len+begin < off) {
3201 if (i >= IP2_MAX_BOARDS)
3203 if (off >= len+begin)
3206 *start = page + (off-begin);
3207 return ((count < begin+len-off) ? count : begin+len-off);
3210 /******************************************************************************/
3211 /* Function: ip2trace() */
3212 /* Parameters: Value to add to trace buffer */
3213 /* Returns: Nothing */
3218 /******************************************************************************/
3219 #ifdef IP2DEBUG_TRACE
3221 ip2trace (unsigned short pn, unsigned char cat, unsigned char label, unsigned long codes, ...)
3224 unsigned long *pCode = &codes;
3225 union ip2breadcrumb bc;
3229 tracebuf[tracestuff++] = jiffies;
3230 if ( tracestuff == TRACEMAX ) {
3233 if ( tracestuff == tracestrip ) {
3234 if ( ++tracestrip == TRACEMAX ) {
3240 bc.hdr.port = 0xff & pn;
3242 bc.hdr.codes = (unsigned char)( codes & 0xff );
3243 bc.hdr.label = label;
3244 tracebuf[tracestuff++] = bc.value;
3247 if ( tracestuff == TRACEMAX ) {
3250 if ( tracestuff == tracestrip ) {
3251 if ( ++tracestrip == TRACEMAX ) {
3260 tracebuf[tracestuff++] = *++pCode;
3266 MODULE_LICENSE("GPL");