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>
116 #include <asm/system.h>
119 #include <asm/bitops.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 current->state = TASK_INTERRUPTIBLE;
1636 schedule_timeout(pCh->ClosingDelay);
1638 wake_up_interruptible(&pCh->open_wait);
1641 pCh->flags &=~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1642 wake_up_interruptible(&pCh->close_wait);
1644 #ifdef IP2DEBUG_OPEN
1645 DBG_CNT("ip2_close: after wakeups--");
1649 ip2trace (CHANN, ITRC_CLOSE, ITRC_RETURN, 1, 1 );
1654 /******************************************************************************/
1655 /* Function: ip2_hangup() */
1656 /* Parameters: Pointer to tty structure */
1657 /* Returns: Nothing */
1662 /******************************************************************************/
1664 ip2_hangup ( PTTY tty )
1666 i2ChanStrPtr pCh = tty->driver_data;
1672 ip2trace (CHANN, ITRC_HANGUP, ITRC_ENTER, 0 );
1674 ip2_flush_buffer(tty);
1676 /* disable DSS reporting */
1678 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_DCD_NREP);
1679 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1680 if ( (tty->termios->c_cflag & HUPCL) ) {
1681 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 2, CMD_RTSDN, CMD_DTRDN);
1682 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1683 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1685 i2QueueCommands(PTYPE_INLINE, pCh, 1, 3,
1686 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1687 serviceOutgoingFifo ( pCh->pMyBord );
1689 wake_up_interruptible ( &pCh->delta_msr_wait );
1691 pCh->flags &= ~ASYNC_NORMAL_ACTIVE;
1693 wake_up_interruptible ( &pCh->open_wait );
1695 ip2trace (CHANN, ITRC_HANGUP, ITRC_RETURN, 0 );
1698 /******************************************************************************/
1699 /******************************************************************************/
1700 /* Device Output Section */
1701 /******************************************************************************/
1702 /******************************************************************************/
1704 /******************************************************************************/
1705 /* Function: ip2_write() */
1706 /* Parameters: Pointer to tty structure */
1707 /* Flag denoting data is in user (1) or kernel (0) space */
1708 /* Pointer to data */
1709 /* Number of bytes to write */
1710 /* Returns: Number of bytes actually written */
1712 /* Description: (MANDATORY) */
1715 /******************************************************************************/
1717 ip2_write( PTTY tty, int user, const unsigned char *pData, int count)
1719 i2ChanStrPtr pCh = tty->driver_data;
1721 unsigned long flags;
1723 ip2trace (CHANN, ITRC_WRITE, ITRC_ENTER, 2, count, -1 );
1725 /* Flush out any buffered data left over from ip2_putchar() calls. */
1726 ip2_flush_chars( tty );
1728 /* This is the actual move bit. Make sure it does what we need!!!!! */
1729 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1730 bytesSent = i2Output( pCh, pData, count, user );
1731 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1733 ip2trace (CHANN, ITRC_WRITE, ITRC_RETURN, 1, bytesSent );
1735 return bytesSent > 0 ? bytesSent : 0;
1738 /******************************************************************************/
1739 /* Function: ip2_putchar() */
1740 /* Parameters: Pointer to tty structure */
1741 /* Character to write */
1742 /* Returns: Nothing */
1747 /******************************************************************************/
1749 ip2_putchar( PTTY tty, unsigned char ch )
1751 i2ChanStrPtr pCh = tty->driver_data;
1752 unsigned long flags;
1754 // ip2trace (CHANN, ITRC_PUTC, ITRC_ENTER, 1, ch );
1756 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1757 pCh->Pbuf[pCh->Pbuf_stuff++] = ch;
1758 if ( pCh->Pbuf_stuff == sizeof pCh->Pbuf ) {
1759 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1760 ip2_flush_chars( tty );
1762 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1764 // ip2trace (CHANN, ITRC_PUTC, ITRC_RETURN, 1, ch );
1767 /******************************************************************************/
1768 /* Function: ip2_flush_chars() */
1769 /* Parameters: Pointer to tty structure */
1770 /* Returns: Nothing */
1774 /******************************************************************************/
1776 ip2_flush_chars( PTTY tty )
1779 i2ChanStrPtr pCh = tty->driver_data;
1780 unsigned long flags;
1782 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1783 if ( pCh->Pbuf_stuff ) {
1785 // ip2trace (CHANN, ITRC_PUTC, 10, 1, strip );
1788 // We may need to restart i2Output if it does not fullfill this request
1790 strip = i2Output( pCh, pCh->Pbuf, pCh->Pbuf_stuff, 0 );
1791 if ( strip != pCh->Pbuf_stuff ) {
1792 memmove( pCh->Pbuf, &pCh->Pbuf[strip], pCh->Pbuf_stuff - strip );
1794 pCh->Pbuf_stuff -= strip;
1796 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1799 /******************************************************************************/
1800 /* Function: ip2_write_room() */
1801 /* Parameters: Pointer to tty structure */
1802 /* Returns: Number of bytes that the driver can accept */
1806 /******************************************************************************/
1808 ip2_write_room ( PTTY tty )
1811 i2ChanStrPtr pCh = tty->driver_data;
1812 unsigned long flags;
1814 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1815 bytesFree = i2OutputFree( pCh ) - pCh->Pbuf_stuff;
1816 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1818 ip2trace (CHANN, ITRC_WRITE, 11, 1, bytesFree );
1820 return ((bytesFree > 0) ? bytesFree : 0);
1823 /******************************************************************************/
1824 /* Function: ip2_chars_in_buf() */
1825 /* Parameters: Pointer to tty structure */
1826 /* Returns: Number of bytes queued for transmission */
1831 /******************************************************************************/
1833 ip2_chars_in_buf ( PTTY tty )
1835 i2ChanStrPtr pCh = tty->driver_data;
1837 unsigned long flags;
1839 ip2trace (CHANN, ITRC_WRITE, 12, 1, pCh->Obuf_char_count + pCh->Pbuf_stuff );
1841 #ifdef IP2DEBUG_WRITE
1842 printk (KERN_DEBUG "IP2: chars in buffer = %d (%d,%d)\n",
1843 pCh->Obuf_char_count + pCh->Pbuf_stuff,
1844 pCh->Obuf_char_count, pCh->Pbuf_stuff );
1846 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1847 rc = pCh->Obuf_char_count;
1848 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1849 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1850 rc += pCh->Pbuf_stuff;
1851 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1855 /******************************************************************************/
1856 /* Function: ip2_flush_buffer() */
1857 /* Parameters: Pointer to tty structure */
1858 /* Returns: Nothing */
1863 /******************************************************************************/
1865 ip2_flush_buffer( PTTY tty )
1867 i2ChanStrPtr pCh = tty->driver_data;
1868 unsigned long flags;
1870 ip2trace (CHANN, ITRC_FLUSH, ITRC_ENTER, 0 );
1872 #ifdef IP2DEBUG_WRITE
1873 printk (KERN_DEBUG "IP2: flush buffer\n" );
1875 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1876 pCh->Pbuf_stuff = 0;
1877 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1878 i2FlushOutput( pCh );
1881 ip2trace (CHANN, ITRC_FLUSH, ITRC_RETURN, 0 );
1885 /******************************************************************************/
1886 /* Function: ip2_wait_until_sent() */
1887 /* Parameters: Pointer to tty structure */
1888 /* Timeout for wait. */
1889 /* Returns: Nothing */
1892 /* This function is used in place of the normal tty_wait_until_sent, which */
1893 /* only waits for the driver buffers to be empty (or rather, those buffers */
1894 /* reported by chars_in_buffer) which doesn't work for IP2 due to the */
1895 /* indeterminate number of bytes buffered on the board. */
1896 /******************************************************************************/
1898 ip2_wait_until_sent ( PTTY tty, int timeout )
1901 i2ChanStrPtr pCh = tty->driver_data;
1903 tty_wait_until_sent(tty, timeout );
1904 if ( (i = timeout - (jiffies -i)) > 0)
1905 i2DrainOutput( pCh, i );
1908 /******************************************************************************/
1909 /******************************************************************************/
1910 /* Device Input Section */
1911 /******************************************************************************/
1912 /******************************************************************************/
1914 /******************************************************************************/
1915 /* Function: ip2_throttle() */
1916 /* Parameters: Pointer to tty structure */
1917 /* Returns: Nothing */
1922 /******************************************************************************/
1924 ip2_throttle ( PTTY tty )
1926 i2ChanStrPtr pCh = tty->driver_data;
1928 #ifdef IP2DEBUG_READ
1929 printk (KERN_DEBUG "IP2: throttle\n" );
1932 * Signal the poll/interrupt handlers not to forward incoming data to
1933 * the line discipline. This will cause the buffers to fill up in the
1934 * library and thus cause the library routines to send the flow control
1940 /******************************************************************************/
1941 /* Function: ip2_unthrottle() */
1942 /* Parameters: Pointer to tty structure */
1943 /* Returns: Nothing */
1948 /******************************************************************************/
1950 ip2_unthrottle ( PTTY tty )
1952 i2ChanStrPtr pCh = tty->driver_data;
1953 unsigned long flags;
1955 #ifdef IP2DEBUG_READ
1956 printk (KERN_DEBUG "IP2: unthrottle\n" );
1959 /* Pass incoming data up to the line discipline again. */
1961 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1962 serviceOutgoingFifo( pCh->pMyBord );
1963 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1964 if ( pCh->Ibuf_stuff != pCh->Ibuf_strip ) {
1965 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1966 #ifdef IP2DEBUG_READ
1967 printk (KERN_DEBUG "i2Input called from unthrottle\n" );
1971 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1975 ip2_start ( PTTY tty )
1977 i2ChanStrPtr pCh = DevTable[tty->index];
1979 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1980 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_UNSUSPEND);
1981 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_RESUME);
1982 #ifdef IP2DEBUG_WRITE
1983 printk (KERN_DEBUG "IP2: start tx\n" );
1988 ip2_stop ( PTTY tty )
1990 i2ChanStrPtr pCh = DevTable[tty->index];
1992 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_SUSPEND);
1993 #ifdef IP2DEBUG_WRITE
1994 printk (KERN_DEBUG "IP2: stop tx\n" );
1998 /******************************************************************************/
1999 /* Device Ioctl Section */
2000 /******************************************************************************/
2002 static int ip2_tiocmget(struct tty_struct *tty, struct file *file)
2004 i2ChanStrPtr pCh = DevTable[tty->index];
2011 FIXME - the following code is causing a NULL pointer dereference in
2012 2.3.51 in an interrupt handler. It's suppose to prompt the board
2013 to return the DSS signal status immediately. Why doesn't it do
2014 the same thing in 2.2.14?
2017 /* This thing is still busted in the 1.2.12 driver on 2.4.x
2018 and even hoses the serial console so the oops can be trapped.
2021 #ifdef ENABLE_DSSNOW
2022 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DSS_NOW);
2024 init_waitqueue_entry(&wait, current);
2025 add_wait_queue(&pCh->dss_now_wait, &wait);
2026 set_current_state( TASK_INTERRUPTIBLE );
2028 serviceOutgoingFifo( pCh->pMyBord );
2032 set_current_state( TASK_RUNNING );
2033 remove_wait_queue(&pCh->dss_now_wait, &wait);
2035 if (signal_pending(current)) {
2039 return ((pCh->dataSetOut & I2_RTS) ? TIOCM_RTS : 0)
2040 | ((pCh->dataSetOut & I2_DTR) ? TIOCM_DTR : 0)
2041 | ((pCh->dataSetIn & I2_DCD) ? TIOCM_CAR : 0)
2042 | ((pCh->dataSetIn & I2_RI) ? TIOCM_RNG : 0)
2043 | ((pCh->dataSetIn & I2_DSR) ? TIOCM_DSR : 0)
2044 | ((pCh->dataSetIn & I2_CTS) ? TIOCM_CTS : 0);
2047 static int ip2_tiocmset(struct tty_struct *tty, struct file *file,
2048 unsigned int set, unsigned int clear)
2050 i2ChanStrPtr pCh = DevTable[tty->index];
2055 if (set & TIOCM_RTS) {
2056 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSUP);
2057 pCh->dataSetOut |= I2_RTS;
2059 if (set & TIOCM_DTR) {
2060 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRUP);
2061 pCh->dataSetOut |= I2_DTR;
2064 if (clear & TIOCM_RTS) {
2065 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSDN);
2066 pCh->dataSetOut &= ~I2_RTS;
2068 if (clear & TIOCM_DTR) {
2069 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRDN);
2070 pCh->dataSetOut &= ~I2_DTR;
2072 serviceOutgoingFifo( pCh->pMyBord );
2076 /******************************************************************************/
2077 /* Function: ip2_ioctl() */
2078 /* Parameters: Pointer to tty structure */
2079 /* Pointer to file structure */
2082 /* Returns: Success or failure */
2087 /******************************************************************************/
2089 ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
2092 i2ChanStrPtr pCh = DevTable[tty->index];
2093 struct async_icount cprev, cnow; /* kernel counter temps */
2094 struct serial_icounter_struct __user *p_cuser;
2096 unsigned long flags;
2097 void __user *argp = (void __user *)arg;
2099 if ( pCh == NULL ) {
2103 ip2trace (CHANN, ITRC_IOCTL, ITRC_ENTER, 2, cmd, arg );
2105 #ifdef IP2DEBUG_IOCTL
2106 printk(KERN_DEBUG "IP2: ioctl cmd (%x), arg (%lx)\n", cmd, arg );
2112 ip2trace (CHANN, ITRC_IOCTL, 2, 1, rc );
2114 rc = get_serial_info(pCh, argp);
2121 ip2trace (CHANN, ITRC_IOCTL, 3, 1, rc );
2123 rc = set_serial_info(pCh, argp);
2129 rc = tty_check_change(tty);
2134 //return -ENOIOCTLCMD;
2137 //return -ENOIOCTLCMD;
2140 if (STOP_CHAR(tty) != __DISABLED_CHAR) {
2141 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2142 CMD_XMIT_NOW(STOP_CHAR(tty)));
2146 if (START_CHAR(tty) != __DISABLED_CHAR) {
2147 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2148 CMD_XMIT_NOW(START_CHAR(tty)));
2156 case TCSBRK: /* SVID version: non-zero arg --> no break */
2157 rc = tty_check_change(tty);
2159 ip2trace (CHANN, ITRC_IOCTL, 4, 1, rc );
2162 ip2_wait_until_sent(tty,0);
2164 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SEND_BRK(250));
2165 serviceOutgoingFifo( pCh->pMyBord );
2170 case TCSBRKP: /* support for POSIX tcsendbreak() */
2171 rc = tty_check_change(tty);
2173 ip2trace (CHANN, ITRC_IOCTL, 5, 1, rc );
2176 ip2_wait_until_sent(tty,0);
2177 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2178 CMD_SEND_BRK(arg ? arg*100 : 250));
2179 serviceOutgoingFifo ( pCh->pMyBord );
2185 ip2trace (CHANN, ITRC_IOCTL, 6, 1, rc );
2187 rc = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
2194 ip2trace (CHANN, ITRC_IOCTL, 7, 1, rc );
2196 rc = get_user(arg,(unsigned long __user *) argp);
2199 tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL)
2200 | (arg ? CLOCAL : 0));
2205 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change - mask
2206 * passed in arg for lines of interest (use |'ed TIOCM_RNG/DSR/CD/CTS
2207 * for masking). Caller should use TIOCGICOUNT to see which one it was
2210 save_flags(flags);cli();
2211 cprev = pCh->icount; /* note the counters on entry */
2212 restore_flags(flags);
2213 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 4,
2214 CMD_DCD_REP, CMD_CTS_REP, CMD_DSR_REP, CMD_RI_REP);
2215 init_waitqueue_entry(&wait, current);
2216 add_wait_queue(&pCh->delta_msr_wait, &wait);
2217 set_current_state( TASK_INTERRUPTIBLE );
2219 serviceOutgoingFifo( pCh->pMyBord );
2221 ip2trace (CHANN, ITRC_IOCTL, 10, 0 );
2225 ip2trace (CHANN, ITRC_IOCTL, 11, 0 );
2227 /* see if a signal did it */
2228 if (signal_pending(current)) {
2232 save_flags(flags);cli();
2233 cnow = pCh->icount; /* atomic copy */
2234 restore_flags(flags);
2235 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2236 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
2237 rc = -EIO; /* no change => rc */
2240 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2241 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2242 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2243 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
2249 set_current_state( TASK_RUNNING );
2250 remove_wait_queue(&pCh->delta_msr_wait, &wait);
2252 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 3,
2253 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
2254 if ( ! (pCh->flags & ASYNC_CHECK_CD)) {
2255 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DCD_NREP);
2257 serviceOutgoingFifo( pCh->pMyBord );
2262 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2263 * Return: write counters to the user passed counter struct
2264 * NB: both 1->0 and 0->1 transitions are counted except for RI where
2265 * only 0->1 is counted. The controller is quite capable of counting
2266 * both, but this done to preserve compatibility with the standard
2270 ip2trace (CHANN, ITRC_IOCTL, 11, 1, rc );
2272 save_flags(flags);cli();
2274 restore_flags(flags);
2276 rc = put_user(cnow.cts, &p_cuser->cts);
2277 rc = put_user(cnow.dsr, &p_cuser->dsr);
2278 rc = put_user(cnow.rng, &p_cuser->rng);
2279 rc = put_user(cnow.dcd, &p_cuser->dcd);
2280 rc = put_user(cnow.rx, &p_cuser->rx);
2281 rc = put_user(cnow.tx, &p_cuser->tx);
2282 rc = put_user(cnow.frame, &p_cuser->frame);
2283 rc = put_user(cnow.overrun, &p_cuser->overrun);
2284 rc = put_user(cnow.parity, &p_cuser->parity);
2285 rc = put_user(cnow.brk, &p_cuser->brk);
2286 rc = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
2290 * The rest are not supported by this driver. By returning -ENOIOCTLCMD they
2291 * will be passed to the line discipline for it to handle.
2297 case TIOCSERGSTRUCT:
2298 case TIOCSERGETMULTI:
2299 case TIOCSERSETMULTI:
2302 ip2trace (CHANN, ITRC_IOCTL, 12, 0 );
2308 ip2trace (CHANN, ITRC_IOCTL, ITRC_RETURN, 0 );
2313 /******************************************************************************/
2314 /* Function: GetSerialInfo() */
2315 /* Parameters: Pointer to channel structure */
2316 /* Pointer to old termios structure */
2317 /* Returns: Nothing */
2320 /* This is to support the setserial command, and requires processing of the */
2321 /* standard Linux serial structure. */
2322 /******************************************************************************/
2324 get_serial_info ( i2ChanStrPtr pCh, struct serial_struct __user *retinfo )
2326 struct serial_struct tmp;
2328 memset ( &tmp, 0, sizeof(tmp) );
2329 tmp.type = pCh->pMyBord->channelBtypes.bid_value[(pCh->port_index & (IP2_PORTS_PER_BOARD-1))/16];
2330 if (BID_HAS_654(tmp.type)) {
2331 tmp.type = PORT_16650;
2333 tmp.type = PORT_CIRRUS;
2335 tmp.line = pCh->port_index;
2336 tmp.port = pCh->pMyBord->i2eBase;
2337 tmp.irq = ip2config.irq[pCh->port_index/64];
2338 tmp.flags = pCh->flags;
2339 tmp.baud_base = pCh->BaudBase;
2340 tmp.close_delay = pCh->ClosingDelay;
2341 tmp.closing_wait = pCh->ClosingWaitTime;
2342 tmp.custom_divisor = pCh->BaudDivisor;
2343 return copy_to_user(retinfo,&tmp,sizeof(*retinfo));
2346 /******************************************************************************/
2347 /* Function: SetSerialInfo() */
2348 /* Parameters: Pointer to channel structure */
2349 /* Pointer to old termios structure */
2350 /* Returns: Nothing */
2353 /* This function provides support for setserial, which uses the TIOCSSERIAL */
2354 /* ioctl. Not all setserial parameters are relevant. If the user attempts to */
2355 /* change the IRQ, address or type of the port the ioctl fails. */
2356 /******************************************************************************/
2358 set_serial_info( i2ChanStrPtr pCh, struct serial_struct __user *new_info )
2360 struct serial_struct ns;
2361 int old_flags, old_baud_divisor;
2363 if (copy_from_user(&ns, new_info, sizeof (ns)))
2367 * We don't allow setserial to change IRQ, board address, type or baud
2368 * base. Also line nunber as such is meaningless but we use it for our
2369 * array index so it is fixed also.
2371 if ( (ns.irq != ip2config.irq[pCh->port_index])
2372 || ((int) ns.port != ((int) (pCh->pMyBord->i2eBase)))
2373 || (ns.baud_base != pCh->BaudBase)
2374 || (ns.line != pCh->port_index) ) {
2378 old_flags = pCh->flags;
2379 old_baud_divisor = pCh->BaudDivisor;
2381 if ( !capable(CAP_SYS_ADMIN) ) {
2382 if ( ( ns.close_delay != pCh->ClosingDelay ) ||
2383 ( (ns.flags & ~ASYNC_USR_MASK) !=
2384 (pCh->flags & ~ASYNC_USR_MASK) ) ) {
2388 pCh->flags = (pCh->flags & ~ASYNC_USR_MASK) |
2389 (ns.flags & ASYNC_USR_MASK);
2390 pCh->BaudDivisor = ns.custom_divisor;
2392 pCh->flags = (pCh->flags & ~ASYNC_FLAGS) |
2393 (ns.flags & ASYNC_FLAGS);
2394 pCh->BaudDivisor = ns.custom_divisor;
2395 pCh->ClosingDelay = ns.close_delay * HZ/100;
2396 pCh->ClosingWaitTime = ns.closing_wait * HZ/100;
2399 if ( ( (old_flags & ASYNC_SPD_MASK) != (pCh->flags & ASYNC_SPD_MASK) )
2400 || (old_baud_divisor != pCh->BaudDivisor) ) {
2401 // Invalidate speed and reset parameters
2402 set_params( pCh, NULL );
2408 /******************************************************************************/
2409 /* Function: ip2_set_termios() */
2410 /* Parameters: Pointer to tty structure */
2411 /* Pointer to old termios structure */
2412 /* Returns: Nothing */
2417 /******************************************************************************/
2419 ip2_set_termios( PTTY tty, struct termios *old_termios )
2421 i2ChanStrPtr pCh = (i2ChanStrPtr)tty->driver_data;
2423 #ifdef IP2DEBUG_IOCTL
2424 printk (KERN_DEBUG "IP2: set termios %p\n", old_termios );
2427 set_params( pCh, old_termios );
2430 /******************************************************************************/
2431 /* Function: ip2_set_line_discipline() */
2432 /* Parameters: Pointer to tty structure */
2433 /* Returns: Nothing */
2435 /* Description: Does nothing */
2438 /******************************************************************************/
2440 ip2_set_line_discipline ( PTTY tty )
2442 #ifdef IP2DEBUG_IOCTL
2443 printk (KERN_DEBUG "IP2: set line discipline\n" );
2446 ip2trace (((i2ChanStrPtr)tty->driver_data)->port_index, ITRC_IOCTL, 16, 0 );
2450 /******************************************************************************/
2451 /* Function: SetLine Characteristics() */
2452 /* Parameters: Pointer to channel structure */
2453 /* Returns: Nothing */
2456 /* This routine is called to update the channel structure with the new line */
2457 /* characteristics, and send the appropriate commands to the board when they */
2459 /******************************************************************************/
2461 set_params( i2ChanStrPtr pCh, struct termios *o_tios )
2463 tcflag_t cflag, iflag, lflag;
2464 char stop_char, start_char;
2465 struct termios dummy;
2467 lflag = pCh->pTTY->termios->c_lflag;
2468 cflag = pCh->pTTY->termios->c_cflag;
2469 iflag = pCh->pTTY->termios->c_iflag;
2471 if (o_tios == NULL) {
2472 dummy.c_lflag = ~lflag;
2473 dummy.c_cflag = ~cflag;
2474 dummy.c_iflag = ~iflag;
2479 switch ( cflag & CBAUD ) {
2481 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
2482 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
2483 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
2484 pCh->pTTY->termios->c_cflag |= (CBAUD & o_tios->c_cflag);
2489 * This is the speed that is overloaded with all the other high
2490 * speeds, depending upon the flag settings.
2492 if ( ( pCh->flags & ASYNC_SPD_MASK ) == ASYNC_SPD_HI ) {
2493 pCh->speed = CBR_57600;
2494 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI ) {
2495 pCh->speed = CBR_115200;
2496 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST ) {
2497 pCh->speed = CBR_C1;
2499 pCh->speed = CBR_38400;
2502 case B50: pCh->speed = CBR_50; break;
2503 case B75: pCh->speed = CBR_75; break;
2504 case B110: pCh->speed = CBR_110; break;
2505 case B134: pCh->speed = CBR_134; break;
2506 case B150: pCh->speed = CBR_150; break;
2507 case B200: pCh->speed = CBR_200; break;
2508 case B300: pCh->speed = CBR_300; break;
2509 case B600: pCh->speed = CBR_600; break;
2510 case B1200: pCh->speed = CBR_1200; break;
2511 case B1800: pCh->speed = CBR_1800; break;
2512 case B2400: pCh->speed = CBR_2400; break;
2513 case B4800: pCh->speed = CBR_4800; break;
2514 case B9600: pCh->speed = CBR_9600; break;
2515 case B19200: pCh->speed = CBR_19200; break;
2516 case B57600: pCh->speed = CBR_57600; break;
2517 case B115200: pCh->speed = CBR_115200; break;
2518 case B153600: pCh->speed = CBR_153600; break;
2519 case B230400: pCh->speed = CBR_230400; break;
2520 case B307200: pCh->speed = CBR_307200; break;
2521 case B460800: pCh->speed = CBR_460800; break;
2522 case B921600: pCh->speed = CBR_921600; break;
2523 default: pCh->speed = CBR_9600; break;
2525 if ( pCh->speed == CBR_C1 ) {
2526 // Process the custom speed parameters.
2527 int bps = pCh->BaudBase / pCh->BaudDivisor;
2528 if ( bps == 921600 ) {
2529 pCh->speed = CBR_921600;
2532 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_BAUD_DEF1(bps) );
2535 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_SETBAUD(pCh->speed));
2537 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
2538 pCh->dataSetOut |= (I2_DTR | I2_RTS);
2540 if ( (CSTOPB & cflag) ^ (CSTOPB & o_tios->c_cflag))
2542 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2543 CMD_SETSTOP( ( cflag & CSTOPB ) ? CST_2 : CST_1));
2545 if (((PARENB|PARODD) & cflag) ^ ((PARENB|PARODD) & o_tios->c_cflag))
2547 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2549 (cflag & PARENB ? (cflag & PARODD ? CSP_OD : CSP_EV) : CSP_NP)
2553 /* byte size and parity */
2554 if ( (CSIZE & cflag)^(CSIZE & o_tios->c_cflag))
2557 switch ( cflag & CSIZE ) {
2558 case CS5: datasize = CSZ_5; break;
2559 case CS6: datasize = CSZ_6; break;
2560 case CS7: datasize = CSZ_7; break;
2561 case CS8: datasize = CSZ_8; break;
2562 default: datasize = CSZ_5; break; /* as per serial.c */
2564 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1, CMD_SETBITS(datasize) );
2566 /* Process CTS flow control flag setting */
2567 if ( (cflag & CRTSCTS) ) {
2568 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2569 2, CMD_CTSFL_ENAB, CMD_RTSFL_ENAB);
2571 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2572 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
2575 // Process XON/XOFF flow control flags settings
2577 stop_char = STOP_CHAR(pCh->pTTY);
2578 start_char = START_CHAR(pCh->pTTY);
2580 //////////// can't be \000
2581 if (stop_char == __DISABLED_CHAR )
2583 stop_char = ~__DISABLED_CHAR;
2585 if (start_char == __DISABLED_CHAR )
2587 start_char = ~__DISABLED_CHAR;
2589 /////////////////////////////////
2591 if ( o_tios->c_cc[VSTART] != start_char )
2593 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXON(start_char));
2594 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXON(start_char));
2596 if ( o_tios->c_cc[VSTOP] != stop_char )
2598 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXOFF(stop_char));
2599 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXOFF(stop_char));
2601 if (stop_char == __DISABLED_CHAR )
2603 stop_char = ~__DISABLED_CHAR; //TEST123
2606 if ((iflag & (IXOFF))^(o_tios->c_iflag & (IXOFF)))
2608 if ( iflag & IXOFF ) { // Enable XOFF output flow control
2609 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_XON));
2610 } else { // Disable XOFF output flow control
2612 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_NONE));
2615 if (start_char == __DISABLED_CHAR )
2619 if ((iflag & (IXON|IXANY)) ^ (o_tios->c_iflag & (IXON|IXANY)))
2621 if ( iflag & IXON ) {
2622 if ( iflag & IXANY ) { // Enable XON/XANY output flow control
2623 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XANY));
2624 } else { // Enable XON output flow control
2625 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XON));
2627 } else { // Disable XON output flow control
2629 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_NONE));
2632 if ( (iflag & ISTRIP) ^ ( o_tios->c_iflag & (ISTRIP)) )
2634 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2635 CMD_ISTRIP_OPT((iflag & ISTRIP ? 1 : 0)));
2637 if ( (iflag & INPCK) ^ ( o_tios->c_iflag & (INPCK)) )
2639 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2640 CMD_PARCHK((iflag & INPCK) ? CPK_ENAB : CPK_DSAB));
2643 if ( (iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR))
2644 ^ ( o_tios->c_iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR)) )
2649 if ( iflag & IGNBRK ) { /* Ignore breaks altogether */
2650 /* Ignore breaks altogether */
2651 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_NREP);
2653 if ( iflag & BRKINT ) {
2654 if ( iflag & PARMRK ) {
2655 brkrpt = 0x0a; // exception an inline triple
2657 brkrpt = 0x1a; // exception and NULL
2659 brkrpt |= 0x04; // flush input
2661 if ( iflag & PARMRK ) {
2662 brkrpt = 0x0b; //POSIX triple \0377 \0 \0
2664 brkrpt = 0x01; // Null only
2667 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_REP(brkrpt));
2670 if (iflag & IGNPAR) {
2672 /* would be 2 for not cirrus bug */
2673 /* would be 0x20 cept for cirrus bug */
2675 if ( iflag & PARMRK ) {
2677 * Replace error characters with 3-byte sequence (\0377,\0,char)
2680 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_ISTRIP_OPT((char)0));
2685 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SET_ERROR(parrpt));
2687 if (cflag & CLOCAL) {
2688 // Status reporting fails for DCD if this is off
2689 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_NREP);
2690 pCh->flags &= ~ASYNC_CHECK_CD;
2692 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_REP);
2693 pCh->flags |= ASYNC_CHECK_CD;
2697 do_flags_thing: // This is a test, we don't do the flags thing
2699 if ( (cflag & CRTSCTS) ) {
2700 cflag |= 014000000000;
2702 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1,
2703 CMD_UNIX_FLAGS(iflag,cflag,lflag));
2707 i2DrainOutput( pCh, 100 );
2710 /******************************************************************************/
2711 /* IPL Device Section */
2712 /******************************************************************************/
2714 /******************************************************************************/
2715 /* Function: ip2_ipl_read() */
2716 /* Parameters: Pointer to device inode */
2717 /* Pointer to file structure */
2718 /* Pointer to data */
2719 /* Number of bytes to read */
2720 /* Returns: Success or failure */
2722 /* Description: Ugly */
2725 /******************************************************************************/
2729 ip2_ipl_read(struct file *pFile, char __user *pData, size_t count, loff_t *off )
2731 unsigned int minor = iminor(pFile->f_dentry->d_inode);
2735 printk (KERN_DEBUG "IP2IPL: read %p, %d bytes\n", pData, count );
2739 case 0: // IPL device
2742 case 1: // Status dump
2745 case 2: // Ping device
2748 case 3: // Trace device
2749 rc = DumpTraceBuffer ( pData, count );
2751 case 4: // Trace device
2752 rc = DumpFifoBuffer ( pData, count );
2762 DumpFifoBuffer ( char __user *pData, int count )
2766 rc = copy_to_user(pData, DBGBuf, count);
2768 printk(KERN_DEBUG "Last index %d\n", I );
2771 #endif /* DEBUG_FIFO */
2776 DumpTraceBuffer ( char __user *pData, int count )
2778 #ifdef IP2DEBUG_TRACE
2782 int *pIndex = (int __user *)pData;
2784 if ( count < (sizeof(int) * 6) ) {
2787 rc = put_user(tracewrap, pIndex );
2788 rc = put_user(TRACEMAX, ++pIndex );
2789 rc = put_user(tracestrip, ++pIndex );
2790 rc = put_user(tracestuff, ++pIndex );
2791 pData += sizeof(int) * 6;
2792 count -= sizeof(int) * 6;
2794 dumpcount = tracestuff - tracestrip;
2795 if ( dumpcount < 0 ) {
2796 dumpcount += TRACEMAX;
2798 if ( dumpcount > count ) {
2801 chunk = TRACEMAX - tracestrip;
2802 if ( dumpcount > chunk ) {
2803 rc = copy_to_user(pData, &tracebuf[tracestrip],
2804 chunk * sizeof(tracebuf[0]) );
2805 pData += chunk * sizeof(tracebuf[0]);
2807 chunk = dumpcount - chunk;
2811 rc = copy_to_user(pData, &tracebuf[tracestrip],
2812 chunk * sizeof(tracebuf[0]) );
2813 tracestrip += chunk;
2816 rc = put_user(tracestrip, ++pIndex );
2817 rc = put_user(tracestuff, ++pIndex );
2825 /******************************************************************************/
2826 /* Function: ip2_ipl_write() */
2828 /* Pointer to file structure */
2829 /* Pointer to data */
2830 /* Number of bytes to write */
2831 /* Returns: Success or failure */
2836 /******************************************************************************/
2838 ip2_ipl_write(struct file *pFile, const char __user *pData, size_t count, loff_t *off)
2841 printk (KERN_DEBUG "IP2IPL: write %p, %d bytes\n", pData, count );
2846 /******************************************************************************/
2847 /* Function: ip2_ipl_ioctl() */
2848 /* Parameters: Pointer to device inode */
2849 /* Pointer to file structure */
2852 /* Returns: Success or failure */
2857 /******************************************************************************/
2859 ip2_ipl_ioctl ( struct inode *pInode, struct file *pFile, UINT cmd, ULONG arg )
2861 unsigned int iplminor = iminor(pInode);
2863 void __user *argp = (void __user *)arg;
2864 ULONG __user *pIndex = argp;
2865 i2eBordStrPtr pB = i2BoardPtrTable[iplminor / 4];
2869 printk (KERN_DEBUG "IP2IPL: ioctl cmd %d, arg %ld\n", cmd, arg );
2872 switch ( iplminor ) {
2873 case 0: // IPL device
2876 case 1: // Status dump
2881 case 64: /* Driver - ip2stat */
2882 rc = put_user(ip2_tty_driver->refcount, pIndex++ );
2883 rc = put_user(irq_counter, pIndex++ );
2884 rc = put_user(bh_counter, pIndex++ );
2887 case 65: /* Board - ip2stat */
2889 rc = copy_to_user(argp, pB, sizeof(i2eBordStr));
2890 rc = put_user(INB(pB->i2eStatus),
2891 (ULONG __user *)(arg + (ULONG)(&pB->i2eStatus) - (ULONG)pB ) );
2898 if (cmd < IP2_MAX_PORTS) {
2899 pCh = DevTable[cmd];
2902 rc = copy_to_user(argp, pCh, sizeof(i2ChanStr));
2912 case 2: // Ping device
2915 case 3: // Trace device
2917 rc = put_user(iiSendPendingMail, pIndex++ );
2918 rc = put_user(i2InitChannels, pIndex++ );
2919 rc = put_user(i2QueueNeeds, pIndex++ );
2920 rc = put_user(i2QueueCommands, pIndex++ );
2921 rc = put_user(i2GetStatus, pIndex++ );
2922 rc = put_user(i2Input, pIndex++ );
2923 rc = put_user(i2InputFlush, pIndex++ );
2924 rc = put_user(i2Output, pIndex++ );
2925 rc = put_user(i2FlushOutput, pIndex++ );
2926 rc = put_user(i2DrainWakeup, pIndex++ );
2927 rc = put_user(i2DrainOutput, pIndex++ );
2928 rc = put_user(i2OutputFree, pIndex++ );
2929 rc = put_user(i2StripFifo, pIndex++ );
2930 rc = put_user(i2StuffFifoBypass, pIndex++ );
2931 rc = put_user(i2StuffFifoFlow, pIndex++ );
2932 rc = put_user(i2StuffFifoInline, pIndex++ );
2933 rc = put_user(i2ServiceBoard, pIndex++ );
2934 rc = put_user(serviceOutgoingFifo, pIndex++ );
2935 // rc = put_user(ip2_init, pIndex++ );
2936 rc = put_user(ip2_init_board, pIndex++ );
2937 rc = put_user(find_eisa_board, pIndex++ );
2938 rc = put_user(set_irq, pIndex++ );
2939 rc = put_user(ip2_interrupt, pIndex++ );
2940 rc = put_user(ip2_poll, pIndex++ );
2941 rc = put_user(service_all_boards, pIndex++ );
2942 rc = put_user(do_input, pIndex++ );
2943 rc = put_user(do_status, pIndex++ );
2944 #ifndef IP2DEBUG_OPEN
2945 rc = put_user(0, pIndex++ );
2947 rc = put_user(open_sanity_check, pIndex++ );
2949 rc = put_user(ip2_open, pIndex++ );
2950 rc = put_user(ip2_close, pIndex++ );
2951 rc = put_user(ip2_hangup, pIndex++ );
2952 rc = put_user(ip2_write, pIndex++ );
2953 rc = put_user(ip2_putchar, pIndex++ );
2954 rc = put_user(ip2_flush_chars, pIndex++ );
2955 rc = put_user(ip2_write_room, pIndex++ );
2956 rc = put_user(ip2_chars_in_buf, pIndex++ );
2957 rc = put_user(ip2_flush_buffer, pIndex++ );
2959 //rc = put_user(ip2_wait_until_sent, pIndex++ );
2960 rc = put_user(0, pIndex++ );
2962 rc = put_user(ip2_throttle, pIndex++ );
2963 rc = put_user(ip2_unthrottle, pIndex++ );
2964 rc = put_user(ip2_ioctl, pIndex++ );
2965 rc = put_user(0, pIndex++ );
2966 rc = put_user(get_serial_info, pIndex++ );
2967 rc = put_user(set_serial_info, pIndex++ );
2968 rc = put_user(ip2_set_termios, pIndex++ );
2969 rc = put_user(ip2_set_line_discipline, pIndex++ );
2970 rc = put_user(set_params, pIndex++ );
2984 /******************************************************************************/
2985 /* Function: ip2_ipl_open() */
2986 /* Parameters: Pointer to device inode */
2987 /* Pointer to file structure */
2988 /* Returns: Success or failure */
2993 /******************************************************************************/
2995 ip2_ipl_open( struct inode *pInode, struct file *pFile )
2997 unsigned int iplminor = iminor(pInode);
3002 printk (KERN_DEBUG "IP2IPL: open\n" );
3006 // These are the IPL devices
3013 // These are the status devices
3020 // These are the debug devices
3025 pB = i2BoardPtrTable[iplminor / 4];
3026 pCh = (i2ChanStrPtr) pB->i2eChannelPtr;
3029 // This is the trace device
3035 /******************************************************************************/
3036 /* Function: ip2_read_procmem */
3039 /* Returns: Length of output */
3042 /* Supplies some driver operating parameters */
3043 /* Not real useful unless your debugging the fifo */
3045 /******************************************************************************/
3047 #define LIMIT (PAGE_SIZE - 120)
3050 ip2_read_procmem(char *buf, char **start, off_t offset, int len)
3059 #define FMTLINE "%3d: 0x%08x 0x%08x 0%011o 0%011o\n"
3060 #define FMTLIN2 " 0x%04x 0x%04x tx flow 0x%x\n"
3061 #define FMTLIN3 " 0x%04x 0x%04x rc flow\n"
3063 len += sprintf(buf+len,"\n");
3065 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3066 pB = i2BoardPtrTable[i];
3068 len += sprintf(buf+len,"board %d:\n",i);
3069 len += sprintf(buf+len,"\tFifo rem: %d mty: %x outM %x\n",
3070 pB->i2eFifoRemains,pB->i2eWaitingForEmptyFifo,pB->i2eOutMailWaiting);
3074 len += sprintf(buf+len,"#: tty flags, port flags, cflags, iflags\n");
3075 for (i=0; i < IP2_MAX_PORTS; i++) {
3081 if (tty && tty->count) {
3082 len += sprintf(buf+len,FMTLINE,i,(int)tty->flags,pCh->flags,
3083 tty->termios->c_cflag,tty->termios->c_iflag);
3085 len += sprintf(buf+len,FMTLIN2,
3086 pCh->outfl.asof,pCh->outfl.room,pCh->channelNeeds);
3087 len += sprintf(buf+len,FMTLIN3,pCh->infl.asof,pCh->infl.room);
3095 * This is the handler for /proc/tty/driver/ip2
3097 * This stretch of code has been largely plagerized from at least three
3098 * different sources including ip2mkdev.c and a couple of other drivers.
3099 * The bugs are all mine. :-) =mhw=
3101 int ip2_read_proc(char *page, char **start, off_t off,
3102 int count, int *eof, void *data)
3112 len += sprintf(page, "ip2info: 1.0 driver: %s\n", pcVersion );
3113 len += sprintf(page+len, "Driver: SMajor=%d CMajor=%d IMajor=%d MaxBoards=%d MaxBoxes=%d MaxPorts=%d\n",
3114 IP2_TTY_MAJOR, IP2_CALLOUT_MAJOR, IP2_IPL_MAJOR,
3115 IP2_MAX_BOARDS, ABS_MAX_BOXES, ABS_BIGGEST_BOX);
3117 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3118 /* This need to be reset for a board by board count... */
3120 pB = i2BoardPtrTable[i];
3122 switch( pB->i2ePom.e.porID & ~POR_ID_RESERVED )
3125 len += sprintf( page+len, "Board %d: EX ports=", i );
3126 for( box = 0; box < ABS_MAX_BOXES; ++box )
3130 if( pB->i2eChannelMap[box] != 0 ) ++boxes;
3131 for( j = 0; j < ABS_BIGGEST_BOX; ++j )
3133 if( pB->i2eChannelMap[box] & 1<< j ) {
3137 len += sprintf( page+len, "%d,", ports );
3141 --len; /* Backup over that last comma */
3143 len += sprintf( page+len, " boxes=%d width=%d", boxes, pB->i2eDataWidth16 ? 16 : 8 );
3147 len += sprintf(page+len, "Board %d: ISA-4 ports=4 boxes=1", i );
3152 len += sprintf(page+len, "Board %d: ISA-8-std ports=8 boxes=1", i );
3157 len += sprintf(page+len, "Board %d: ISA-8-RJ11 ports=8 boxes=1", i );
3162 len += sprintf(page+len, "Board %d: unknown", i );
3163 /* Don't try and probe for minor numbers */
3168 /* Don't try and probe for minor numbers */
3169 len += sprintf(page+len, "Board %d: vacant", i );
3174 len += sprintf(page+len, " minors=" );
3176 for ( box = 0; box < ABS_MAX_BOXES; ++box )
3178 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
3180 if ( pB->i2eChannelMap[box] & (1 << j) )
3182 len += sprintf (page+len,"%d,",
3183 j + ABS_BIGGEST_BOX *
3184 (box+i*ABS_MAX_BOXES));
3189 page[ len - 1 ] = '\n'; /* Overwrite that last comma */
3191 len += sprintf (page+len,"\n" );
3194 if (len+begin > off+count)
3196 if (len+begin < off) {
3202 if (i >= IP2_MAX_BOARDS)
3204 if (off >= len+begin)
3207 *start = page + (off-begin);
3208 return ((count < begin+len-off) ? count : begin+len-off);
3211 /******************************************************************************/
3212 /* Function: ip2trace() */
3213 /* Parameters: Value to add to trace buffer */
3214 /* Returns: Nothing */
3219 /******************************************************************************/
3220 #ifdef IP2DEBUG_TRACE
3222 ip2trace (unsigned short pn, unsigned char cat, unsigned char label, unsigned long codes, ...)
3225 unsigned long *pCode = &codes;
3226 union ip2breadcrumb bc;
3230 tracebuf[tracestuff++] = jiffies;
3231 if ( tracestuff == TRACEMAX ) {
3234 if ( tracestuff == tracestrip ) {
3235 if ( ++tracestrip == TRACEMAX ) {
3241 bc.hdr.port = 0xff & pn;
3243 bc.hdr.codes = (unsigned char)( codes & 0xff );
3244 bc.hdr.label = label;
3245 tracebuf[tracestuff++] = bc.value;
3248 if ( tracestuff == TRACEMAX ) {
3251 if ( tracestuff == tracestrip ) {
3252 if ( ++tracestrip == TRACEMAX ) {
3261 tracebuf[tracestuff++] = *++pCode;
3267 MODULE_LICENSE("GPL");