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++) {
443 if ((pB = i2BoardPtrTable[i]) != 0 ) {
445 i2BoardPtrTable[i] = NULL;
447 if ((DevTableMem[i]) != NULL ) {
448 kfree ( DevTableMem[i] );
449 DevTableMem[i] = NULL;
453 /* Cleanup the iiEllis subsystem. */
456 printk (KERN_DEBUG "IP2 Unloaded\n" );
461 static struct tty_operations ip2_ops = {
465 .put_char = ip2_putchar,
466 .flush_chars = ip2_flush_chars,
467 .write_room = ip2_write_room,
468 .chars_in_buffer = ip2_chars_in_buf,
469 .flush_buffer = ip2_flush_buffer,
471 .throttle = ip2_throttle,
472 .unthrottle = ip2_unthrottle,
473 .set_termios = ip2_set_termios,
474 .set_ldisc = ip2_set_line_discipline,
477 .hangup = ip2_hangup,
478 .read_proc = ip2_read_proc,
479 .tiocmget = ip2_tiocmget,
480 .tiocmset = ip2_tiocmset,
483 /******************************************************************************/
484 /* Function: ip2_loadmain() */
485 /* Parameters: irq, io from command line of insmod et. al. */
486 /* pointer to fip firmware and firmware size for boards */
487 /* Returns: Success (0) */
490 /* This was the required entry point for all drivers (now in ip2.c) */
491 /* It performs all */
492 /* initialisation of the devices and driver structures, and registers itself */
493 /* with the relevant kernel modules. */
494 /******************************************************************************/
495 /* SA_INTERRUPT- if set blocks all interrupts else only this line */
496 /* SA_SHIRQ - for shared irq PCI or maybe EISA only */
497 /* SA_RANDOM - can be source for cert. random number generators */
498 #define IP2_SA_FLAGS 0
501 ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
507 i2eBordStrPtr pB = NULL;
510 ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0 );
512 /* process command line arguments to modprobe or
513 insmod i.e. iop & irqp */
514 /* irqp and iop should ALWAYS be specified now... But we check
515 them individually just to be sure, anyways... */
516 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
518 ip2config.addr[i] = iop[i];
521 ip2config.irq[i] = irqp[i];
523 ip2config.irq[i] = 0;
525 // This is a little bit of a hack. If poll_only=1 on command
526 // line back in ip2.c OR all IRQs on all specified boards are
527 // explicitly set to 0, then drop to poll only mode and override
528 // PCI or EISA interrupts. This superceeds the old hack of
529 // triggering if all interrupts were zero (like da default).
530 // Still a hack but less prone to random acts of terrorism.
532 // What we really should do, now that the IRQ default is set
533 // to -1, is to use 0 as a hard coded, do not probe.
536 poll_only |= irqp[i];
540 poll_only = !poll_only;
542 Fip_firmware = firmware;
543 Fip_firmware_size = firmsize;
545 /* Announce our presence */
546 printk( KERN_INFO "%s version %s\n", pcName, pcVersion );
548 // ip2 can be unloaded and reloaded for no good reason
549 // we can't let that happen here or bad things happen
550 // second load hoses board but not system - fixme later
552 printk( KERN_INFO "Still loaded\n" );
557 ip2_tty_driver = alloc_tty_driver(IP2_MAX_PORTS);
561 /* Initialise the iiEllis subsystem. */
564 /* Initialize arrays. */
565 memset( i2BoardPtrTable, 0, sizeof i2BoardPtrTable );
566 memset( DevTable, 0, sizeof DevTable );
568 /* Initialise all the boards we can find (up to the maximum). */
569 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
570 switch ( ip2config.addr[i] ) {
571 case 0: /* skip this slot even if card is present */
574 /* ISA address must be specified */
575 if ( (ip2config.addr[i] < 0x100) || (ip2config.addr[i] > 0x3f8) ) {
576 printk ( KERN_ERR "IP2: Bad ISA board %d address %x\n",
577 i, ip2config.addr[i] );
578 ip2config.addr[i] = 0;
580 ip2config.type[i] = ISA;
582 /* Check for valid irq argument, set for polling if invalid */
583 if (ip2config.irq[i] && !is_valid_irq(ip2config.irq[i])) {
584 printk(KERN_ERR "IP2: Bad IRQ(%d) specified\n",ip2config.irq[i]);
585 ip2config.irq[i] = 0;// 0 is polling and is valid in that sense
592 struct pci_dev *pci_dev_i = NULL;
593 pci_dev_i = pci_find_device(PCI_VENDOR_ID_COMPUTONE,
594 PCI_DEVICE_ID_COMPUTONE_IP2EX, pci_dev_i);
595 if (pci_dev_i != NULL) {
597 unsigned char pci_irq;
599 ip2config.type[i] = PCI;
601 pci_read_config_dword(pci_dev_i, PCI_BASE_ADDRESS_1, &addr);
603 ip2config.addr[i]=(USHORT)(addr&0xfffe);
605 printk( KERN_ERR "IP2: PCI I/O address error\n");
608 pci_read_config_byte(pci_dev_i, PCI_INTERRUPT_LINE, &pci_irq);
610 // If the PCI BIOS assigned it, lets try and use it. If we
611 // can't acquire it or it screws up, deal with it then.
613 // if (!is_valid_irq(pci_irq)) {
614 // printk( KERN_ERR "IP2: Bad PCI BIOS IRQ(%d)\n",pci_irq);
617 ip2config.irq[i] = pci_irq;
618 } else { // ann error
619 ip2config.addr[i] = 0;
620 if (status == PCIBIOS_DEVICE_NOT_FOUND) {
621 printk( KERN_ERR "IP2: PCI board %d not found\n", i );
623 printk( KERN_ERR "IP2: PCI error 0x%x \n", status );
628 printk( KERN_ERR "IP2: PCI card specified but PCI support not\n");
629 printk( KERN_ERR "IP2: configured in this kernel.\n");
630 printk( KERN_ERR "IP2: Recompile kernel with CONFIG_PCI defined!\n");
631 #endif /* CONFIG_PCI */
634 if ( (ip2config.addr[i] = find_eisa_board( Eisa_slot + 1 )) != 0) {
635 /* Eisa_irq set as side effect, boo */
636 ip2config.type[i] = EISA;
638 ip2config.irq[i] = Eisa_irq;
642 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
643 if ( ip2config.addr[i] ) {
644 pB = kmalloc( sizeof(i2eBordStr), GFP_KERNEL);
646 i2BoardPtrTable[i] = pB;
647 memset( pB, 0, sizeof(i2eBordStr) );
648 iiSetAddress( pB, ip2config.addr[i], ii2DelayTimer );
651 printk(KERN_ERR "IP2: board memory allocation error\n");
655 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
656 if ( ( pB = i2BoardPtrTable[i] ) != NULL ) {
661 for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
662 if ( i2BoardPtrTable[i] != NULL ) {
667 ip2trace (ITRC_NO_PORT, ITRC_INIT, 2, 0 );
669 ip2_tty_driver->owner = THIS_MODULE;
670 ip2_tty_driver->name = "ttyF";
671 ip2_tty_driver->devfs_name = "tts/F";
672 ip2_tty_driver->driver_name = pcDriver_name;
673 ip2_tty_driver->major = IP2_TTY_MAJOR;
674 ip2_tty_driver->minor_start = 0;
675 ip2_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
676 ip2_tty_driver->subtype = SERIAL_TYPE_NORMAL;
677 ip2_tty_driver->init_termios = tty_std_termios;
678 ip2_tty_driver->init_termios.c_cflag = B9600|CS8|CREAD|HUPCL|CLOCAL;
679 ip2_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
680 tty_set_operations(ip2_tty_driver, &ip2_ops);
682 ip2trace (ITRC_NO_PORT, ITRC_INIT, 3, 0 );
684 /* Register the tty devices. */
685 if ( ( err = tty_register_driver ( ip2_tty_driver ) ) ) {
686 printk(KERN_ERR "IP2: failed to register tty driver (%d)\n", err);
687 put_tty_driver(ip2_tty_driver);
690 /* Register the IPL driver. */
691 if ( ( err = register_chrdev ( IP2_IPL_MAJOR, pcIpl, &ip2_ipl ) ) ) {
692 printk(KERN_ERR "IP2: failed to register IPL device (%d)\n", err );
694 /* create the sysfs class */
695 ip2_class = class_simple_create(THIS_MODULE, "ip2");
696 if (IS_ERR(ip2_class)) {
697 err = PTR_ERR(ip2_class);
701 /* Register the read_procmem thing */
702 if (!create_proc_info_entry("ip2mem",0,&proc_root,ip2_read_procmem)) {
703 printk(KERN_ERR "IP2: failed to register read_procmem\n");
706 ip2trace (ITRC_NO_PORT, ITRC_INIT, 4, 0 );
707 /* Register the interrupt handler or poll handler, depending upon the
708 * specified interrupt.
711 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
712 if ( 0 == ip2config.addr[i] ) {
716 if ( NULL != ( pB = i2BoardPtrTable[i] ) ) {
717 class_simple_device_add(ip2_class, MKDEV(IP2_IPL_MAJOR,
718 4 * i), NULL, "ipl%d", i);
719 err = devfs_mk_cdev(MKDEV(IP2_IPL_MAJOR, 4 * i),
720 S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR,
723 class_simple_device_remove(MKDEV(IP2_IPL_MAJOR,
728 class_simple_device_add(ip2_class, MKDEV(IP2_IPL_MAJOR,
729 4 * i + 1), NULL, "stat%d", i);
730 err = devfs_mk_cdev(MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
731 S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR,
734 class_simple_device_remove(MKDEV(IP2_IPL_MAJOR,
739 for ( box = 0; box < ABS_MAX_BOXES; ++box )
741 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
743 if ( pB->i2eChannelMap[box] & (1 << j) )
745 tty_register_device(ip2_tty_driver,
746 j + ABS_BIGGEST_BOX *
747 (box+i*ABS_MAX_BOXES), NULL);
754 // Poll only forces driver to only use polling and
755 // to ignore the probed PCI or EISA interrupts.
756 ip2config.irq[i] = CIR_POLL;
758 if ( ip2config.irq[i] == CIR_POLL ) {
761 PollTimer.expires = POLL_TIMEOUT;
762 add_timer ( &PollTimer );
764 printk( KERN_INFO "IP2: polling\n");
767 if (have_requested_irq(ip2config.irq[i]))
769 rc = request_irq( ip2config.irq[i], ip2_interrupt,
770 IP2_SA_FLAGS | (ip2config.type[i] == PCI ? SA_SHIRQ : 0),
771 pcName, (void *)&pcName);
773 printk(KERN_ERR "IP2: an request_irq failed: error %d\n",rc);
774 ip2config.irq[i] = CIR_POLL;
775 printk( KERN_INFO "IP2: Polling %ld/sec.\n",
776 (POLL_TIMEOUT - jiffies));
779 mark_requested_irq(ip2config.irq[i]);
780 /* Initialise the interrupt handler bottom half (aka slih). */
783 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
784 if ( i2BoardPtrTable[i] ) {
785 set_irq( i, ip2config.irq[i] ); /* set and enable board interrupt */
789 ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_RETURN, 0 );
793 class_simple_destroy(ip2_class);
795 unregister_chrdev(IP2_IPL_MAJOR, "ip2");
800 EXPORT_SYMBOL(ip2_loadmain);
802 /******************************************************************************/
803 /* Function: ip2_init_board() */
804 /* Parameters: Index of board in configuration structure */
805 /* Returns: Success (0) */
808 /* This function initializes the specified board. The loadware is copied to */
809 /* the board, the channel structures are initialized, and the board details */
810 /* are reported on the console. */
811 /******************************************************************************/
813 ip2_init_board( int boardnum )
816 int nports = 0, nboxes = 0;
818 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
820 if ( !iiInitialize ( pB ) ) {
821 printk ( KERN_ERR "IP2: Failed to initialize board at 0x%x, error %d\n",
822 pB->i2eBase, pB->i2eError );
825 printk(KERN_INFO "IP2: Board %d: addr=0x%x irq=%d\n", boardnum + 1,
826 ip2config.addr[boardnum], ip2config.irq[boardnum] );
828 if (!request_region( ip2config.addr[boardnum], 8, pcName )) {
829 printk(KERN_ERR "IP2: bad addr=0x%x\n", ip2config.addr[boardnum]);
833 if ( iiDownloadAll ( pB, (loadHdrStrPtr)Fip_firmware, 1, Fip_firmware_size )
835 printk ( KERN_ERR "IP2: failed to download loadware\n" );
836 goto err_release_region;
838 printk ( KERN_INFO "IP2: fv=%d.%d.%d lv=%d.%d.%d\n",
839 pB->i2ePom.e.porVersion,
840 pB->i2ePom.e.porRevision,
841 pB->i2ePom.e.porSubRev, pB->i2eLVersion,
842 pB->i2eLRevision, pB->i2eLSub );
845 switch ( pB->i2ePom.e.porID & ~POR_ID_RESERVED ) {
848 printk( KERN_ERR "IP2: Unknown board type, ID = %x\n",
849 pB->i2ePom.e.porID );
851 goto err_release_region;
854 case POR_ID_II_4: /* IntelliPort-II, ISA-4 (4xRJ45) */
855 printk ( KERN_INFO "IP2: ISA-4\n" );
859 case POR_ID_II_8: /* IntelliPort-II, 8-port using standard brick. */
860 printk ( KERN_INFO "IP2: ISA-8 std\n" );
864 case POR_ID_II_8R: /* IntelliPort-II, 8-port using RJ11's (no CTS) */
865 printk ( KERN_INFO "IP2: ISA-8 RJ11\n" );
869 case POR_ID_FIIEX: /* IntelliPort IIEX */
871 int portnum = IP2_PORTS_PER_BOARD * boardnum;
874 for( box = 0; box < ABS_MAX_BOXES; ++box ) {
875 if ( pB->i2eChannelMap[box] != 0 ) {
878 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
879 if ( pB->i2eChannelMap[box] & 1<< i ) {
884 DevTableMem[boardnum] = pCh =
885 kmalloc( sizeof(i2ChanStr) * nports, GFP_KERNEL );
887 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
888 goto err_release_region;
890 if ( !i2InitChannels( pB, nports, pCh ) ) {
891 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
893 goto err_release_region;
895 pB->i2eChannelPtr = &DevTable[portnum];
896 pB->i2eChannelCnt = ABS_MOST_PORTS;
898 for( box = 0; box < ABS_MAX_BOXES; ++box, portnum += ABS_BIGGEST_BOX ) {
899 for( i = 0; i < ABS_BIGGEST_BOX; ++i ) {
900 if ( pB->i2eChannelMap[box] & (1 << i) ) {
901 DevTable[portnum + i] = pCh;
902 pCh->port_index = portnum + i;
907 printk(KERN_INFO "IP2: EX box=%d ports=%d %d bit\n",
908 nboxes, nports, pB->i2eDataWidth16 ? 16 : 8 );
912 DevTableMem[boardnum] = pCh =
913 kmalloc ( sizeof (i2ChanStr) * nports, GFP_KERNEL );
915 printk ( KERN_ERR "IP2: (i2_init_channel:) Out of memory.\n");
916 goto err_release_region;
918 pB->i2eChannelPtr = pCh;
919 pB->i2eChannelCnt = nports;
920 if ( !i2InitChannels( pB, nports, pCh ) ) {
921 printk(KERN_ERR "IP2: i2InitChannels failed: %d\n",pB->i2eError);
923 goto err_release_region;
925 pB->i2eChannelPtr = &DevTable[IP2_PORTS_PER_BOARD * boardnum];
927 for( i = 0; i < pB->i2eChannelCnt; ++i ) {
928 DevTable[IP2_PORTS_PER_BOARD * boardnum + i] = pCh;
929 pCh->port_index = (IP2_PORTS_PER_BOARD * boardnum) + i;
933 INIT_WORK(&pB->tqueue_interrupt, (void(*)(void*)) ip2_interrupt_bh, pB);
937 release_region(ip2config.addr[boardnum], 8);
940 i2BoardPtrTable[boardnum] = NULL;
944 /******************************************************************************/
945 /* Function: find_eisa_board ( int start_slot ) */
946 /* Parameters: First slot to check */
947 /* Returns: Address of EISA IntelliPort II controller */
950 /* This function searches for an EISA IntelliPort controller, starting */
951 /* from the specified slot number. If the motherboard is not identified as an */
952 /* EISA motherboard, or no valid board ID is selected it returns 0. Otherwise */
953 /* it returns the base address of the controller. */
954 /******************************************************************************/
955 static unsigned short __init
956 find_eisa_board( int start_slot )
959 unsigned int idm = 0;
960 unsigned int idp = 0;
961 unsigned int base = 0;
968 * First a check for an EISA motherboard, which we do by comparing the
969 * EISA ID registers for the system board and the first couple of slots.
970 * No slot ID should match the system board ID, but on an ISA or PCI
971 * machine the odds are that an empty bus will return similar values for
975 value = (inb(i) << 24) + (inb(i+1) << 16) + (inb(i+2) << 8) + inb(i+3);
976 for( i = 0x1c80; i <= 0x4c80; i += 0x1000 ) {
977 j = (inb(i)<<24)+(inb(i+1)<<16)+(inb(i+2)<<8)+inb(i+3);
983 * OK, so we are inclined to believe that this is an EISA machine. Find
984 * an IntelliPort controller.
986 for( i = start_slot; i < 16; i++ ) {
988 idm = (inb(base + 0xc80) << 8) | (inb(base + 0xc81) & 0xff);
989 idp = (inb(base + 0xc82) << 8) | (inb(base + 0xc83) & 0xff);
991 if ( idm == 0x0e8e ) {
992 if ( idp == 0x0281 || idp == 0x0218 ) {
994 } else if ( idp == 0x0282 || idp == 0x0283 ) {
995 ismine = 3; /* Can do edge-trigger */
1006 /* It's some sort of EISA card, but at what address is it configured? */
1008 setup_address = base + 0xc88;
1009 value = inb(base + 0xc86);
1010 setup_irq = (value & 8) ? Valid_Irqs[value & 7] : 0;
1012 if ( (ismine & 2) && !(value & 0x10) ) {
1013 ismine = 1; /* Could be edging, but not */
1016 if ( Eisa_irq == 0 ) {
1017 Eisa_irq = setup_irq;
1018 } else if ( Eisa_irq != setup_irq ) {
1019 printk ( KERN_ERR "IP2: EISA irq mismatch between EISA controllers\n" );
1022 #ifdef IP2DEBUG_INIT
1023 printk(KERN_DEBUG "Computone EISA board in slot %d, I.D. 0x%x%x, Address 0x%x",
1024 base >> 12, idm, idp, setup_address);
1026 printk(KERN_DEBUG ", Interrupt %d %s\n",
1027 setup_irq, (ismine & 2) ? "(edge)" : "(level)");
1029 printk(KERN_DEBUG ", (polled)\n");
1032 return setup_address;
1035 /******************************************************************************/
1036 /* Function: set_irq() */
1037 /* Parameters: index to board in board table */
1039 /* Returns: Success (0) */
1042 /******************************************************************************/
1044 set_irq( int boardnum, int boardIrq )
1046 unsigned char tempCommand[16];
1047 i2eBordStrPtr pB = i2BoardPtrTable[boardnum];
1048 unsigned long flags;
1051 * Notify the boards they may generate interrupts. This is done by
1052 * sending an in-line command to channel 0 on each board. This is why
1053 * the channels have to be defined already. For each board, if the
1054 * interrupt has never been defined, we must do so NOW, directly, since
1055 * board will not send flow control or even give an interrupt until this
1056 * is done. If polling we must send 0 as the interrupt parameter.
1059 // We will get an interrupt here at the end of this function
1061 iiDisableMailIrq(pB);
1063 /* We build up the entire packet header. */
1064 CHANNEL_OF(tempCommand) = 0;
1065 PTYPE_OF(tempCommand) = PTYPE_INLINE;
1066 CMD_COUNT_OF(tempCommand) = 2;
1067 (CMD_OF(tempCommand))[0] = CMDVALUE_IRQ;
1068 (CMD_OF(tempCommand))[1] = boardIrq;
1070 * Write to FIFO; don't bother to adjust fifo capacity for this, since
1071 * board will respond almost immediately after SendMail hit.
1073 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1074 iiWriteBuf(pB, tempCommand, 4);
1075 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1076 pB->i2eUsingIrq = boardIrq;
1077 pB->i2eOutMailWaiting |= MB_OUT_STUFFED;
1079 /* Need to update number of boards before you enable mailbox int */
1082 CHANNEL_OF(tempCommand) = 0;
1083 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1084 CMD_COUNT_OF(tempCommand) = 6;
1085 (CMD_OF(tempCommand))[0] = 88; // SILO
1086 (CMD_OF(tempCommand))[1] = 64; // chars
1087 (CMD_OF(tempCommand))[2] = 32; // ms
1089 (CMD_OF(tempCommand))[3] = 28; // MAX_BLOCK
1090 (CMD_OF(tempCommand))[4] = 64; // chars
1092 (CMD_OF(tempCommand))[5] = 87; // HW_TEST
1093 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1094 iiWriteBuf(pB, tempCommand, 8);
1095 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1097 CHANNEL_OF(tempCommand) = 0;
1098 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1099 CMD_COUNT_OF(tempCommand) = 1;
1100 (CMD_OF(tempCommand))[0] = 84; /* get BOX_IDS */
1101 iiWriteBuf(pB, tempCommand, 3);
1104 // enable heartbeat for test porpoises
1105 CHANNEL_OF(tempCommand) = 0;
1106 PTYPE_OF(tempCommand) = PTYPE_BYPASS;
1107 CMD_COUNT_OF(tempCommand) = 2;
1108 (CMD_OF(tempCommand))[0] = 44; /* get ping */
1109 (CMD_OF(tempCommand))[1] = 200; /* 200 ms */
1110 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1111 iiWriteBuf(pB, tempCommand, 4);
1112 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1115 iiEnableMailIrq(pB);
1116 iiSendPendingMail(pB);
1119 /******************************************************************************/
1120 /* Interrupt Handler Section */
1121 /******************************************************************************/
1124 service_all_boards(void)
1129 /* Service every board on the list */
1130 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
1131 pB = i2BoardPtrTable[i];
1133 i2ServiceBoard( pB );
1139 /******************************************************************************/
1140 /* Function: ip2_interrupt_bh(pB) */
1141 /* Parameters: pB - pointer to the board structure */
1142 /* Returns: Nothing */
1145 /* Service the board in a bottom half interrupt handler and then */
1146 /* reenable the board's interrupts if it has an IRQ number */
1148 /******************************************************************************/
1150 ip2_interrupt_bh(i2eBordStrPtr pB)
1152 // pB better well be set or we have a problem! We can only get
1153 // here from the IMMEDIATE queue. Here, we process the boards.
1154 // Checking pB doesn't cost much and it saves us from the sanity checkers.
1159 i2ServiceBoard( pB );
1160 if( pB->i2eUsingIrq ) {
1161 // Re-enable his interrupts
1162 iiEnableMailIrq(pB);
1168 /******************************************************************************/
1169 /* Function: ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs) */
1170 /* Parameters: irq - interrupt number */
1171 /* pointer to optional device ID structure */
1172 /* pointer to register structure */
1173 /* Returns: Nothing */
1177 /* Our task here is simply to identify each board which needs servicing. */
1178 /* If we are queuing then, queue it to be serviced, and disable its irq */
1179 /* mask otherwise process the board directly. */
1181 /* We could queue by IRQ but that just complicates things on both ends */
1182 /* with very little gain in performance (how many instructions does */
1183 /* it take to iterate on the immediate queue). */
1186 /******************************************************************************/
1188 ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1194 ip2trace (ITRC_NO_PORT, ITRC_INTR, 99, 1, irq );
1196 /* Service just the boards on the list using this irq */
1197 for( i = 0; i < i2nBoards; ++i ) {
1198 pB = i2BoardPtrTable[i];
1200 // Only process those boards which match our IRQ.
1201 // IRQ = 0 for polled boards, we won't poll "IRQ" boards
1203 if ( pB && (pB->i2eUsingIrq == irq) ) {
1207 if (NO_MAIL_HERE != ( pB->i2eStartMail = iiGetMail(pB))) {
1208 // Disable his interrupt (will be enabled when serviced)
1209 // This is mostly to protect from reentrancy.
1210 iiDisableMailIrq(pB);
1212 // Park the board on the immediate queue for processing.
1213 schedule_work(&pB->tqueue_interrupt);
1215 // Make sure the immediate queue is flagged to fire.
1218 // We are using immediate servicing here. This sucks and can
1219 // cause all sorts of havoc with ppp and others. The failsafe
1220 // check on iiSendPendingMail could also throw a hairball.
1221 i2ServiceBoard( pB );
1222 #endif /* USE_IQI */
1228 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1229 return IRQ_RETVAL(handled);
1232 /******************************************************************************/
1233 /* Function: ip2_poll(unsigned long arg) */
1235 /* Returns: Nothing */
1238 /* This function calls the library routine i2ServiceBoard for each board in */
1239 /* the board table. This is used instead of the interrupt routine when polled */
1240 /* mode is specified. */
1241 /******************************************************************************/
1243 ip2_poll(unsigned long arg)
1245 ip2trace (ITRC_NO_PORT, ITRC_INTR, 100, 0 );
1247 TimerOn = 0; // it's the truth but not checked in service
1249 // Just polled boards, IRQ = 0 will hit all non-interrupt boards.
1250 // It will NOT poll boards handled by hard interrupts.
1251 // The issue of queued BH interrups is handled in ip2_interrupt().
1252 ip2_interrupt(0, NULL, NULL);
1254 PollTimer.expires = POLL_TIMEOUT;
1255 add_timer( &PollTimer );
1258 ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
1261 static void do_input(void *p)
1263 i2ChanStrPtr pCh = p;
1264 unsigned long flags;
1266 ip2trace(CHANN, ITRC_INPUT, 21, 0 );
1269 if ( pCh->pTTY != NULL ) {
1270 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1271 if (!pCh->throttled && (pCh->Ibuf_stuff != pCh->Ibuf_strip)) {
1272 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1275 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1277 ip2trace(CHANN, ITRC_INPUT, 22, 0 );
1279 i2InputFlush( pCh );
1283 // code duplicated from n_tty (ldisc)
1284 static inline void isig(int sig, struct tty_struct *tty, int flush)
1287 kill_pg(tty->pgrp, sig, 1);
1288 if (flush || !L_NOFLSH(tty)) {
1289 if ( tty->ldisc.flush_buffer )
1290 tty->ldisc.flush_buffer(tty);
1291 i2InputFlush( tty->driver_data );
1295 static void do_status(void *p)
1297 i2ChanStrPtr pCh = p;
1300 status = i2GetStatus( pCh, (I2_BRK|I2_PAR|I2_FRA|I2_OVR) );
1302 ip2trace (CHANN, ITRC_STATUS, 21, 1, status );
1304 if (pCh->pTTY && (status & (I2_BRK|I2_PAR|I2_FRA|I2_OVR)) ) {
1305 if ( (status & I2_BRK) ) {
1306 // code duplicated from n_tty (ldisc)
1307 if (I_IGNBRK(pCh->pTTY))
1309 if (I_BRKINT(pCh->pTTY)) {
1310 isig(SIGINT, pCh->pTTY, 1);
1313 wake_up_interruptible(&pCh->pTTY->read_wait);
1315 #ifdef NEVER_HAPPENS_AS_SETUP_XXX
1316 // and can't work because we don't know the_char
1317 // as the_char is reported on a separate path
1318 // The intelligent board does this stuff as setup
1320 char brkf = TTY_NORMAL;
1321 unsigned char brkc = '\0';
1323 if ( (status & I2_BRK) ) {
1327 else if (status & I2_PAR) {
1330 } else if (status & I2_FRA) {
1333 } else if (status & I2_OVR) {
1337 tmp = pCh->pTTY->real_raw;
1338 pCh->pTTY->real_raw = 0;
1339 pCh->pTTY->ldisc.receive_buf( pCh->pTTY, &brkc, &brkf, 1 );
1340 pCh->pTTY->real_raw = tmp;
1342 #endif /* NEVER_HAPPENS_AS_SETUP_XXX */
1346 if ( status & (I2_DDCD | I2_DDSR | I2_DCTS | I2_DRI) ) {
1347 wake_up_interruptible(&pCh->delta_msr_wait);
1349 if ( (pCh->flags & ASYNC_CHECK_CD) && (status & I2_DDCD) ) {
1350 if ( status & I2_DCD ) {
1352 wake_up_interruptible ( &pCh->open_wait );
1355 if (pCh->pTTY && (!(pCh->pTTY->termios->c_cflag & CLOCAL)) ) {
1356 tty_hangup( pCh->pTTY );
1362 ip2trace (CHANN, ITRC_STATUS, 26, 0 );
1365 /******************************************************************************/
1366 /* Device Open/Close/Ioctl Entry Point Section */
1367 /******************************************************************************/
1369 /******************************************************************************/
1370 /* Function: open_sanity_check() */
1371 /* Parameters: Pointer to tty structure */
1372 /* Pointer to file structure */
1373 /* Returns: Success or failure */
1376 /* Verifies the structure magic numbers and cross links. */
1377 /******************************************************************************/
1378 #ifdef IP2DEBUG_OPEN
1380 open_sanity_check( i2ChanStrPtr pCh, i2eBordStrPtr pBrd )
1382 if ( pBrd->i2eValid != I2E_MAGIC ) {
1383 printk(KERN_ERR "IP2: invalid board structure\n" );
1384 } else if ( pBrd != pCh->pMyBord ) {
1385 printk(KERN_ERR "IP2: board structure pointer mismatch (%p)\n",
1387 } else if ( pBrd->i2eChannelCnt < pCh->port_index ) {
1388 printk(KERN_ERR "IP2: bad device index (%d)\n", pCh->port_index );
1389 } else if (&((i2ChanStrPtr)pBrd->i2eChannelPtr)[pCh->port_index] != pCh) {
1391 printk(KERN_INFO "IP2: all pointers check out!\n" );
1397 /******************************************************************************/
1398 /* Function: ip2_open() */
1399 /* Parameters: Pointer to tty structure */
1400 /* Pointer to file structure */
1401 /* Returns: Success or failure */
1403 /* Description: (MANDATORY) */
1404 /* A successful device open has to run a gauntlet of checks before it */
1405 /* completes. After some sanity checking and pointer setup, the function */
1406 /* blocks until all conditions are satisfied. It then initialises the port to */
1407 /* the default characteristics and returns. */
1408 /******************************************************************************/
1410 ip2_open( PTTY tty, struct file *pFile )
1415 i2ChanStrPtr pCh = DevTable[tty->index];
1417 ip2trace (tty->index, ITRC_OPEN, ITRC_ENTER, 0 );
1419 if ( pCh == NULL ) {
1422 /* Setup pointer links in device and tty structures */
1424 tty->driver_data = pCh;
1426 #ifdef IP2DEBUG_OPEN
1428 "IP2:open(tty=%p,pFile=%p):dev=%s,ch=%d,idx=%d\n",
1429 tty, pFile, tty->name, pCh->infl.hd.i2sChannel, pCh->port_index);
1430 open_sanity_check ( pCh, pCh->pMyBord );
1433 i2QueueCommands(PTYPE_INLINE, pCh, 100, 3, CMD_DTRUP,CMD_RTSUP,CMD_DCD_REP);
1434 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1435 serviceOutgoingFifo( pCh->pMyBord );
1437 /* Block here until the port is ready (per serial and istallion) */
1439 * 1. If the port is in the middle of closing wait for the completion
1440 * and then return the appropriate error.
1442 init_waitqueue_entry(&wait, current);
1443 add_wait_queue(&pCh->close_wait, &wait);
1444 set_current_state( TASK_INTERRUPTIBLE );
1446 if ( tty_hung_up_p(pFile) || ( pCh->flags & ASYNC_CLOSING )) {
1447 if ( pCh->flags & ASYNC_CLOSING ) {
1450 if ( tty_hung_up_p(pFile) ) {
1451 set_current_state( TASK_RUNNING );
1452 remove_wait_queue(&pCh->close_wait, &wait);
1453 return( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS;
1456 set_current_state( TASK_RUNNING );
1457 remove_wait_queue(&pCh->close_wait, &wait);
1460 * 3. Handle a non-blocking open of a normal port.
1462 if ( (pFile->f_flags & O_NONBLOCK) || (tty->flags & (1<<TTY_IO_ERROR) )) {
1463 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1467 * 4. Now loop waiting for the port to be free and carrier present
1470 if ( tty->termios->c_cflag & CLOCAL )
1473 #ifdef IP2DEBUG_OPEN
1474 printk(KERN_DEBUG "OpenBlock: do_clocal = %d\n", do_clocal);
1479 init_waitqueue_entry(&wait, current);
1480 add_wait_queue(&pCh->open_wait, &wait);
1483 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
1484 pCh->dataSetOut |= (I2_DTR | I2_RTS);
1485 set_current_state( TASK_INTERRUPTIBLE );
1486 serviceOutgoingFifo( pCh->pMyBord );
1487 if ( tty_hung_up_p(pFile) ) {
1488 set_current_state( TASK_RUNNING );
1489 remove_wait_queue(&pCh->open_wait, &wait);
1490 return ( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EBUSY : -ERESTARTSYS;
1492 if (!(pCh->flags & ASYNC_CLOSING) &&
1493 (do_clocal || (pCh->dataSetIn & I2_DCD) )) {
1498 #ifdef IP2DEBUG_OPEN
1499 printk(KERN_DEBUG "ASYNC_CLOSING = %s\n",
1500 (pCh->flags & ASYNC_CLOSING)?"True":"False");
1501 printk(KERN_DEBUG "OpenBlock: waiting for CD or signal\n");
1503 ip2trace (CHANN, ITRC_OPEN, 3, 2, 0,
1504 (pCh->flags & ASYNC_CLOSING) );
1505 /* check for signal */
1506 if (signal_pending(current)) {
1507 rc = (( pCh->flags & ASYNC_HUP_NOTIFY ) ? -EAGAIN : -ERESTARTSYS);
1512 set_current_state( TASK_RUNNING );
1513 remove_wait_queue(&pCh->open_wait, &wait);
1515 --pCh->wopen; //why count?
1517 ip2trace (CHANN, ITRC_OPEN, 4, 0 );
1522 pCh->flags |= ASYNC_NORMAL_ACTIVE;
1526 /* first open - Assign termios structure to port */
1527 if ( tty->count == 1 ) {
1528 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1529 /* Now we must send the termios settings to the loadware */
1530 set_params( pCh, NULL );
1534 * Now set any i2lib options. These may go away if the i2lib code ends
1535 * up rolled into the mainline.
1537 pCh->channelOptions |= CO_NBLOCK_WRITE;
1539 #ifdef IP2DEBUG_OPEN
1540 printk (KERN_DEBUG "IP2: open completed\n" );
1542 serviceOutgoingFifo( pCh->pMyBord );
1544 ip2trace (CHANN, ITRC_OPEN, ITRC_RETURN, 0 );
1549 /******************************************************************************/
1550 /* Function: ip2_close() */
1551 /* Parameters: Pointer to tty structure */
1552 /* Pointer to file structure */
1553 /* Returns: Nothing */
1558 /******************************************************************************/
1560 ip2_close( PTTY tty, struct file *pFile )
1562 i2ChanStrPtr pCh = tty->driver_data;
1568 ip2trace (CHANN, ITRC_CLOSE, ITRC_ENTER, 0 );
1570 #ifdef IP2DEBUG_OPEN
1571 printk(KERN_DEBUG "IP2:close %s:\n",tty->name);
1574 if ( tty_hung_up_p ( pFile ) ) {
1576 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 2 );
1580 if ( tty->count > 1 ) { /* not the last close */
1582 ip2trace (CHANN, ITRC_CLOSE, 2, 1, 3 );
1586 pCh->flags |= ASYNC_CLOSING; // last close actually
1590 if (pCh->ClosingWaitTime != ASYNC_CLOSING_WAIT_NONE) {
1592 * Before we drop DTR, make sure the transmitter has completely drained.
1593 * This uses an timeout, after which the close
1596 ip2_wait_until_sent(tty, pCh->ClosingWaitTime );
1599 * At this point we stop accepting input. Here we flush the channel
1600 * input buffer which will allow the board to send up more data. Any
1601 * additional input is tossed at interrupt/poll time.
1603 i2InputFlush( pCh );
1605 /* disable DSS reporting */
1606 i2QueueCommands(PTYPE_INLINE, pCh, 100, 4,
1607 CMD_DCD_NREP, CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1608 if ( !tty || (tty->termios->c_cflag & HUPCL) ) {
1609 i2QueueCommands(PTYPE_INLINE, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
1610 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1611 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1614 serviceOutgoingFifo ( pCh->pMyBord );
1616 if ( tty->driver->flush_buffer )
1617 tty->driver->flush_buffer(tty);
1618 if ( tty->ldisc.flush_buffer )
1619 tty->ldisc.flush_buffer(tty);
1625 if (pCh->ClosingDelay) {
1626 current->state = TASK_INTERRUPTIBLE;
1627 schedule_timeout(pCh->ClosingDelay);
1629 wake_up_interruptible(&pCh->open_wait);
1632 pCh->flags &=~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1633 wake_up_interruptible(&pCh->close_wait);
1635 #ifdef IP2DEBUG_OPEN
1636 DBG_CNT("ip2_close: after wakeups--");
1640 ip2trace (CHANN, ITRC_CLOSE, ITRC_RETURN, 1, 1 );
1645 /******************************************************************************/
1646 /* Function: ip2_hangup() */
1647 /* Parameters: Pointer to tty structure */
1648 /* Returns: Nothing */
1653 /******************************************************************************/
1655 ip2_hangup ( PTTY tty )
1657 i2ChanStrPtr pCh = tty->driver_data;
1663 ip2trace (CHANN, ITRC_HANGUP, ITRC_ENTER, 0 );
1665 ip2_flush_buffer(tty);
1667 /* disable DSS reporting */
1669 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_DCD_NREP);
1670 i2QueueCommands(PTYPE_INLINE, pCh, 0, 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
1671 if ( (tty->termios->c_cflag & HUPCL) ) {
1672 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 2, CMD_RTSDN, CMD_DTRDN);
1673 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
1674 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
1676 i2QueueCommands(PTYPE_INLINE, pCh, 1, 3,
1677 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
1678 serviceOutgoingFifo ( pCh->pMyBord );
1680 wake_up_interruptible ( &pCh->delta_msr_wait );
1682 pCh->flags &= ~ASYNC_NORMAL_ACTIVE;
1684 wake_up_interruptible ( &pCh->open_wait );
1686 ip2trace (CHANN, ITRC_HANGUP, ITRC_RETURN, 0 );
1689 /******************************************************************************/
1690 /******************************************************************************/
1691 /* Device Output Section */
1692 /******************************************************************************/
1693 /******************************************************************************/
1695 /******************************************************************************/
1696 /* Function: ip2_write() */
1697 /* Parameters: Pointer to tty structure */
1698 /* Flag denoting data is in user (1) or kernel (0) space */
1699 /* Pointer to data */
1700 /* Number of bytes to write */
1701 /* Returns: Number of bytes actually written */
1703 /* Description: (MANDATORY) */
1706 /******************************************************************************/
1708 ip2_write( PTTY tty, int user, const unsigned char *pData, int count)
1710 i2ChanStrPtr pCh = tty->driver_data;
1712 unsigned long flags;
1714 ip2trace (CHANN, ITRC_WRITE, ITRC_ENTER, 2, count, -1 );
1716 /* Flush out any buffered data left over from ip2_putchar() calls. */
1717 ip2_flush_chars( tty );
1719 /* This is the actual move bit. Make sure it does what we need!!!!! */
1720 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1721 bytesSent = i2Output( pCh, pData, count, user );
1722 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1724 ip2trace (CHANN, ITRC_WRITE, ITRC_RETURN, 1, bytesSent );
1726 return bytesSent > 0 ? bytesSent : 0;
1729 /******************************************************************************/
1730 /* Function: ip2_putchar() */
1731 /* Parameters: Pointer to tty structure */
1732 /* Character to write */
1733 /* Returns: Nothing */
1738 /******************************************************************************/
1740 ip2_putchar( PTTY tty, unsigned char ch )
1742 i2ChanStrPtr pCh = tty->driver_data;
1743 unsigned long flags;
1745 // ip2trace (CHANN, ITRC_PUTC, ITRC_ENTER, 1, ch );
1747 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1748 pCh->Pbuf[pCh->Pbuf_stuff++] = ch;
1749 if ( pCh->Pbuf_stuff == sizeof pCh->Pbuf ) {
1750 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1751 ip2_flush_chars( tty );
1753 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1755 // ip2trace (CHANN, ITRC_PUTC, ITRC_RETURN, 1, ch );
1758 /******************************************************************************/
1759 /* Function: ip2_flush_chars() */
1760 /* Parameters: Pointer to tty structure */
1761 /* Returns: Nothing */
1765 /******************************************************************************/
1767 ip2_flush_chars( PTTY tty )
1770 i2ChanStrPtr pCh = tty->driver_data;
1771 unsigned long flags;
1773 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1774 if ( pCh->Pbuf_stuff ) {
1776 // ip2trace (CHANN, ITRC_PUTC, 10, 1, strip );
1779 // We may need to restart i2Output if it does not fullfill this request
1781 strip = i2Output( pCh, pCh->Pbuf, pCh->Pbuf_stuff, 0 );
1782 if ( strip != pCh->Pbuf_stuff ) {
1783 memmove( pCh->Pbuf, &pCh->Pbuf[strip], pCh->Pbuf_stuff - strip );
1785 pCh->Pbuf_stuff -= strip;
1787 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1790 /******************************************************************************/
1791 /* Function: ip2_write_room() */
1792 /* Parameters: Pointer to tty structure */
1793 /* Returns: Number of bytes that the driver can accept */
1797 /******************************************************************************/
1799 ip2_write_room ( PTTY tty )
1802 i2ChanStrPtr pCh = tty->driver_data;
1803 unsigned long flags;
1805 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1806 bytesFree = i2OutputFree( pCh ) - pCh->Pbuf_stuff;
1807 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1809 ip2trace (CHANN, ITRC_WRITE, 11, 1, bytesFree );
1811 return ((bytesFree > 0) ? bytesFree : 0);
1814 /******************************************************************************/
1815 /* Function: ip2_chars_in_buf() */
1816 /* Parameters: Pointer to tty structure */
1817 /* Returns: Number of bytes queued for transmission */
1822 /******************************************************************************/
1824 ip2_chars_in_buf ( PTTY tty )
1826 i2ChanStrPtr pCh = tty->driver_data;
1828 unsigned long flags;
1830 ip2trace (CHANN, ITRC_WRITE, 12, 1, pCh->Obuf_char_count + pCh->Pbuf_stuff );
1832 #ifdef IP2DEBUG_WRITE
1833 printk (KERN_DEBUG "IP2: chars in buffer = %d (%d,%d)\n",
1834 pCh->Obuf_char_count + pCh->Pbuf_stuff,
1835 pCh->Obuf_char_count, pCh->Pbuf_stuff );
1837 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1838 rc = pCh->Obuf_char_count;
1839 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1840 READ_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1841 rc += pCh->Pbuf_stuff;
1842 READ_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1846 /******************************************************************************/
1847 /* Function: ip2_flush_buffer() */
1848 /* Parameters: Pointer to tty structure */
1849 /* Returns: Nothing */
1854 /******************************************************************************/
1856 ip2_flush_buffer( PTTY tty )
1858 i2ChanStrPtr pCh = tty->driver_data;
1859 unsigned long flags;
1861 ip2trace (CHANN, ITRC_FLUSH, ITRC_ENTER, 0 );
1863 #ifdef IP2DEBUG_WRITE
1864 printk (KERN_DEBUG "IP2: flush buffer\n" );
1866 WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
1867 pCh->Pbuf_stuff = 0;
1868 WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
1869 i2FlushOutput( pCh );
1872 ip2trace (CHANN, ITRC_FLUSH, ITRC_RETURN, 0 );
1876 /******************************************************************************/
1877 /* Function: ip2_wait_until_sent() */
1878 /* Parameters: Pointer to tty structure */
1879 /* Timeout for wait. */
1880 /* Returns: Nothing */
1883 /* This function is used in place of the normal tty_wait_until_sent, which */
1884 /* only waits for the driver buffers to be empty (or rather, those buffers */
1885 /* reported by chars_in_buffer) which doesn't work for IP2 due to the */
1886 /* indeterminate number of bytes buffered on the board. */
1887 /******************************************************************************/
1889 ip2_wait_until_sent ( PTTY tty, int timeout )
1892 i2ChanStrPtr pCh = tty->driver_data;
1894 tty_wait_until_sent(tty, timeout );
1895 if ( (i = timeout - (jiffies -i)) > 0)
1896 i2DrainOutput( pCh, i );
1899 /******************************************************************************/
1900 /******************************************************************************/
1901 /* Device Input Section */
1902 /******************************************************************************/
1903 /******************************************************************************/
1905 /******************************************************************************/
1906 /* Function: ip2_throttle() */
1907 /* Parameters: Pointer to tty structure */
1908 /* Returns: Nothing */
1913 /******************************************************************************/
1915 ip2_throttle ( PTTY tty )
1917 i2ChanStrPtr pCh = tty->driver_data;
1919 #ifdef IP2DEBUG_READ
1920 printk (KERN_DEBUG "IP2: throttle\n" );
1923 * Signal the poll/interrupt handlers not to forward incoming data to
1924 * the line discipline. This will cause the buffers to fill up in the
1925 * library and thus cause the library routines to send the flow control
1931 /******************************************************************************/
1932 /* Function: ip2_unthrottle() */
1933 /* Parameters: Pointer to tty structure */
1934 /* Returns: Nothing */
1939 /******************************************************************************/
1941 ip2_unthrottle ( PTTY tty )
1943 i2ChanStrPtr pCh = tty->driver_data;
1944 unsigned long flags;
1946 #ifdef IP2DEBUG_READ
1947 printk (KERN_DEBUG "IP2: unthrottle\n" );
1950 /* Pass incoming data up to the line discipline again. */
1952 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1953 serviceOutgoingFifo( pCh->pMyBord );
1954 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags)
1955 if ( pCh->Ibuf_stuff != pCh->Ibuf_strip ) {
1956 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1957 #ifdef IP2DEBUG_READ
1958 printk (KERN_DEBUG "i2Input called from unthrottle\n" );
1962 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags)
1966 ip2_start ( PTTY tty )
1968 i2ChanStrPtr pCh = DevTable[tty->index];
1970 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_RESUME);
1971 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_UNSUSPEND);
1972 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_RESUME);
1973 #ifdef IP2DEBUG_WRITE
1974 printk (KERN_DEBUG "IP2: start tx\n" );
1979 ip2_stop ( PTTY tty )
1981 i2ChanStrPtr pCh = DevTable[tty->index];
1983 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_SUSPEND);
1984 #ifdef IP2DEBUG_WRITE
1985 printk (KERN_DEBUG "IP2: stop tx\n" );
1989 /******************************************************************************/
1990 /* Device Ioctl Section */
1991 /******************************************************************************/
1993 static int ip2_tiocmget(struct tty_struct *tty, struct file *file)
1995 i2ChanStrPtr pCh = DevTable[tty->index];
2002 FIXME - the following code is causing a NULL pointer dereference in
2003 2.3.51 in an interrupt handler. It's suppose to prompt the board
2004 to return the DSS signal status immediately. Why doesn't it do
2005 the same thing in 2.2.14?
2008 /* This thing is still busted in the 1.2.12 driver on 2.4.x
2009 and even hoses the serial console so the oops can be trapped.
2012 #ifdef ENABLE_DSSNOW
2013 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DSS_NOW);
2015 init_waitqueue_entry(&wait, current);
2016 add_wait_queue(&pCh->dss_now_wait, &wait);
2017 set_current_state( TASK_INTERRUPTIBLE );
2019 serviceOutgoingFifo( pCh->pMyBord );
2023 set_current_state( TASK_RUNNING );
2024 remove_wait_queue(&pCh->dss_now_wait, &wait);
2026 if (signal_pending(current)) {
2030 return ((pCh->dataSetOut & I2_RTS) ? TIOCM_RTS : 0)
2031 | ((pCh->dataSetOut & I2_DTR) ? TIOCM_DTR : 0)
2032 | ((pCh->dataSetIn & I2_DCD) ? TIOCM_CAR : 0)
2033 | ((pCh->dataSetIn & I2_RI) ? TIOCM_RNG : 0)
2034 | ((pCh->dataSetIn & I2_DSR) ? TIOCM_DSR : 0)
2035 | ((pCh->dataSetIn & I2_CTS) ? TIOCM_CTS : 0);
2038 static int ip2_tiocmset(struct tty_struct *tty, struct file *file,
2039 unsigned int set, unsigned int clear)
2041 i2ChanStrPtr pCh = DevTable[tty->index];
2046 if (set & TIOCM_RTS) {
2047 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSUP);
2048 pCh->dataSetOut |= I2_RTS;
2050 if (set & TIOCM_DTR) {
2051 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRUP);
2052 pCh->dataSetOut |= I2_DTR;
2055 if (clear & TIOCM_RTS) {
2056 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_RTSDN);
2057 pCh->dataSetOut &= ~I2_RTS;
2059 if (clear & TIOCM_DTR) {
2060 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DTRDN);
2061 pCh->dataSetOut &= ~I2_DTR;
2063 serviceOutgoingFifo( pCh->pMyBord );
2067 /******************************************************************************/
2068 /* Function: ip2_ioctl() */
2069 /* Parameters: Pointer to tty structure */
2070 /* Pointer to file structure */
2073 /* Returns: Success or failure */
2078 /******************************************************************************/
2080 ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
2083 i2ChanStrPtr pCh = DevTable[tty->index];
2084 struct async_icount cprev, cnow; /* kernel counter temps */
2085 struct serial_icounter_struct __user *p_cuser;
2087 unsigned long flags;
2088 void __user *argp = (void __user *)arg;
2090 if ( pCh == NULL ) {
2094 ip2trace (CHANN, ITRC_IOCTL, ITRC_ENTER, 2, cmd, arg );
2096 #ifdef IP2DEBUG_IOCTL
2097 printk(KERN_DEBUG "IP2: ioctl cmd (%x), arg (%lx)\n", cmd, arg );
2103 ip2trace (CHANN, ITRC_IOCTL, 2, 1, rc );
2105 rc = get_serial_info(pCh, argp);
2112 ip2trace (CHANN, ITRC_IOCTL, 3, 1, rc );
2114 rc = set_serial_info(pCh, argp);
2120 rc = tty_check_change(tty);
2125 //return -ENOIOCTLCMD;
2128 //return -ENOIOCTLCMD;
2131 if (STOP_CHAR(tty) != __DISABLED_CHAR) {
2132 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2133 CMD_XMIT_NOW(STOP_CHAR(tty)));
2137 if (START_CHAR(tty) != __DISABLED_CHAR) {
2138 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 1,
2139 CMD_XMIT_NOW(START_CHAR(tty)));
2147 case TCSBRK: /* SVID version: non-zero arg --> no break */
2148 rc = tty_check_change(tty);
2150 ip2trace (CHANN, ITRC_IOCTL, 4, 1, rc );
2153 ip2_wait_until_sent(tty,0);
2155 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SEND_BRK(250));
2156 serviceOutgoingFifo( pCh->pMyBord );
2161 case TCSBRKP: /* support for POSIX tcsendbreak() */
2162 rc = tty_check_change(tty);
2164 ip2trace (CHANN, ITRC_IOCTL, 5, 1, rc );
2167 ip2_wait_until_sent(tty,0);
2168 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2169 CMD_SEND_BRK(arg ? arg*100 : 250));
2170 serviceOutgoingFifo ( pCh->pMyBord );
2176 ip2trace (CHANN, ITRC_IOCTL, 6, 1, rc );
2178 rc = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
2185 ip2trace (CHANN, ITRC_IOCTL, 7, 1, rc );
2187 rc = get_user(arg,(unsigned long __user *) argp);
2190 tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL)
2191 | (arg ? CLOCAL : 0));
2196 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change - mask
2197 * passed in arg for lines of interest (use |'ed TIOCM_RNG/DSR/CD/CTS
2198 * for masking). Caller should use TIOCGICOUNT to see which one it was
2201 save_flags(flags);cli();
2202 cprev = pCh->icount; /* note the counters on entry */
2203 restore_flags(flags);
2204 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 4,
2205 CMD_DCD_REP, CMD_CTS_REP, CMD_DSR_REP, CMD_RI_REP);
2206 init_waitqueue_entry(&wait, current);
2207 add_wait_queue(&pCh->delta_msr_wait, &wait);
2208 set_current_state( TASK_INTERRUPTIBLE );
2210 serviceOutgoingFifo( pCh->pMyBord );
2212 ip2trace (CHANN, ITRC_IOCTL, 10, 0 );
2216 ip2trace (CHANN, ITRC_IOCTL, 11, 0 );
2218 /* see if a signal did it */
2219 if (signal_pending(current)) {
2223 save_flags(flags);cli();
2224 cnow = pCh->icount; /* atomic copy */
2225 restore_flags(flags);
2226 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2227 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
2228 rc = -EIO; /* no change => rc */
2231 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2232 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2233 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2234 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
2240 set_current_state( TASK_RUNNING );
2241 remove_wait_queue(&pCh->delta_msr_wait, &wait);
2243 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 3,
2244 CMD_CTS_NREP, CMD_DSR_NREP, CMD_RI_NREP);
2245 if ( ! (pCh->flags & ASYNC_CHECK_CD)) {
2246 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DCD_NREP);
2248 serviceOutgoingFifo( pCh->pMyBord );
2253 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2254 * Return: write counters to the user passed counter struct
2255 * NB: both 1->0 and 0->1 transitions are counted except for RI where
2256 * only 0->1 is counted. The controller is quite capable of counting
2257 * both, but this done to preserve compatibility with the standard
2261 ip2trace (CHANN, ITRC_IOCTL, 11, 1, rc );
2263 save_flags(flags);cli();
2265 restore_flags(flags);
2267 rc = put_user(cnow.cts, &p_cuser->cts);
2268 rc = put_user(cnow.dsr, &p_cuser->dsr);
2269 rc = put_user(cnow.rng, &p_cuser->rng);
2270 rc = put_user(cnow.dcd, &p_cuser->dcd);
2271 rc = put_user(cnow.rx, &p_cuser->rx);
2272 rc = put_user(cnow.tx, &p_cuser->tx);
2273 rc = put_user(cnow.frame, &p_cuser->frame);
2274 rc = put_user(cnow.overrun, &p_cuser->overrun);
2275 rc = put_user(cnow.parity, &p_cuser->parity);
2276 rc = put_user(cnow.brk, &p_cuser->brk);
2277 rc = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
2281 * The rest are not supported by this driver. By returning -ENOIOCTLCMD they
2282 * will be passed to the line discipline for it to handle.
2288 case TIOCSERGSTRUCT:
2289 case TIOCSERGETMULTI:
2290 case TIOCSERSETMULTI:
2293 ip2trace (CHANN, ITRC_IOCTL, 12, 0 );
2299 ip2trace (CHANN, ITRC_IOCTL, ITRC_RETURN, 0 );
2304 /******************************************************************************/
2305 /* Function: GetSerialInfo() */
2306 /* Parameters: Pointer to channel structure */
2307 /* Pointer to old termios structure */
2308 /* Returns: Nothing */
2311 /* This is to support the setserial command, and requires processing of the */
2312 /* standard Linux serial structure. */
2313 /******************************************************************************/
2315 get_serial_info ( i2ChanStrPtr pCh, struct serial_struct __user *retinfo )
2317 struct serial_struct tmp;
2319 memset ( &tmp, 0, sizeof(tmp) );
2320 tmp.type = pCh->pMyBord->channelBtypes.bid_value[(pCh->port_index & (IP2_PORTS_PER_BOARD-1))/16];
2321 if (BID_HAS_654(tmp.type)) {
2322 tmp.type = PORT_16650;
2324 tmp.type = PORT_CIRRUS;
2326 tmp.line = pCh->port_index;
2327 tmp.port = pCh->pMyBord->i2eBase;
2328 tmp.irq = ip2config.irq[pCh->port_index/64];
2329 tmp.flags = pCh->flags;
2330 tmp.baud_base = pCh->BaudBase;
2331 tmp.close_delay = pCh->ClosingDelay;
2332 tmp.closing_wait = pCh->ClosingWaitTime;
2333 tmp.custom_divisor = pCh->BaudDivisor;
2334 return copy_to_user(retinfo,&tmp,sizeof(*retinfo));
2337 /******************************************************************************/
2338 /* Function: SetSerialInfo() */
2339 /* Parameters: Pointer to channel structure */
2340 /* Pointer to old termios structure */
2341 /* Returns: Nothing */
2344 /* This function provides support for setserial, which uses the TIOCSSERIAL */
2345 /* ioctl. Not all setserial parameters are relevant. If the user attempts to */
2346 /* change the IRQ, address or type of the port the ioctl fails. */
2347 /******************************************************************************/
2349 set_serial_info( i2ChanStrPtr pCh, struct serial_struct __user *new_info )
2351 struct serial_struct ns;
2352 int old_flags, old_baud_divisor;
2354 if (copy_from_user(&ns, new_info, sizeof (ns)))
2358 * We don't allow setserial to change IRQ, board address, type or baud
2359 * base. Also line nunber as such is meaningless but we use it for our
2360 * array index so it is fixed also.
2362 if ( (ns.irq != ip2config.irq[pCh->port_index])
2363 || ((int) ns.port != ((int) (pCh->pMyBord->i2eBase)))
2364 || (ns.baud_base != pCh->BaudBase)
2365 || (ns.line != pCh->port_index) ) {
2369 old_flags = pCh->flags;
2370 old_baud_divisor = pCh->BaudDivisor;
2372 if ( !capable(CAP_SYS_ADMIN) ) {
2373 if ( ( ns.close_delay != pCh->ClosingDelay ) ||
2374 ( (ns.flags & ~ASYNC_USR_MASK) !=
2375 (pCh->flags & ~ASYNC_USR_MASK) ) ) {
2379 pCh->flags = (pCh->flags & ~ASYNC_USR_MASK) |
2380 (ns.flags & ASYNC_USR_MASK);
2381 pCh->BaudDivisor = ns.custom_divisor;
2383 pCh->flags = (pCh->flags & ~ASYNC_FLAGS) |
2384 (ns.flags & ASYNC_FLAGS);
2385 pCh->BaudDivisor = ns.custom_divisor;
2386 pCh->ClosingDelay = ns.close_delay * HZ/100;
2387 pCh->ClosingWaitTime = ns.closing_wait * HZ/100;
2390 if ( ( (old_flags & ASYNC_SPD_MASK) != (pCh->flags & ASYNC_SPD_MASK) )
2391 || (old_baud_divisor != pCh->BaudDivisor) ) {
2392 // Invalidate speed and reset parameters
2393 set_params( pCh, NULL );
2399 /******************************************************************************/
2400 /* Function: ip2_set_termios() */
2401 /* Parameters: Pointer to tty structure */
2402 /* Pointer to old termios structure */
2403 /* Returns: Nothing */
2408 /******************************************************************************/
2410 ip2_set_termios( PTTY tty, struct termios *old_termios )
2412 i2ChanStrPtr pCh = (i2ChanStrPtr)tty->driver_data;
2414 #ifdef IP2DEBUG_IOCTL
2415 printk (KERN_DEBUG "IP2: set termios %p\n", old_termios );
2418 set_params( pCh, old_termios );
2421 /******************************************************************************/
2422 /* Function: ip2_set_line_discipline() */
2423 /* Parameters: Pointer to tty structure */
2424 /* Returns: Nothing */
2426 /* Description: Does nothing */
2429 /******************************************************************************/
2431 ip2_set_line_discipline ( PTTY tty )
2433 #ifdef IP2DEBUG_IOCTL
2434 printk (KERN_DEBUG "IP2: set line discipline\n" );
2437 ip2trace (((i2ChanStrPtr)tty->driver_data)->port_index, ITRC_IOCTL, 16, 0 );
2441 /******************************************************************************/
2442 /* Function: SetLine Characteristics() */
2443 /* Parameters: Pointer to channel structure */
2444 /* Returns: Nothing */
2447 /* This routine is called to update the channel structure with the new line */
2448 /* characteristics, and send the appropriate commands to the board when they */
2450 /******************************************************************************/
2452 set_params( i2ChanStrPtr pCh, struct termios *o_tios )
2454 tcflag_t cflag, iflag, lflag;
2455 char stop_char, start_char;
2456 struct termios dummy;
2458 lflag = pCh->pTTY->termios->c_lflag;
2459 cflag = pCh->pTTY->termios->c_cflag;
2460 iflag = pCh->pTTY->termios->c_iflag;
2462 if (o_tios == NULL) {
2463 dummy.c_lflag = ~lflag;
2464 dummy.c_cflag = ~cflag;
2465 dummy.c_iflag = ~iflag;
2470 switch ( cflag & CBAUD ) {
2472 i2QueueCommands( PTYPE_BYPASS, pCh, 100, 2, CMD_RTSDN, CMD_DTRDN);
2473 pCh->dataSetOut &= ~(I2_DTR | I2_RTS);
2474 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_PAUSE(25));
2475 pCh->pTTY->termios->c_cflag |= (CBAUD & o_tios->c_cflag);
2480 * This is the speed that is overloaded with all the other high
2481 * speeds, depending upon the flag settings.
2483 if ( ( pCh->flags & ASYNC_SPD_MASK ) == ASYNC_SPD_HI ) {
2484 pCh->speed = CBR_57600;
2485 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI ) {
2486 pCh->speed = CBR_115200;
2487 } else if ( (pCh->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST ) {
2488 pCh->speed = CBR_C1;
2490 pCh->speed = CBR_38400;
2493 case B50: pCh->speed = CBR_50; break;
2494 case B75: pCh->speed = CBR_75; break;
2495 case B110: pCh->speed = CBR_110; break;
2496 case B134: pCh->speed = CBR_134; break;
2497 case B150: pCh->speed = CBR_150; break;
2498 case B200: pCh->speed = CBR_200; break;
2499 case B300: pCh->speed = CBR_300; break;
2500 case B600: pCh->speed = CBR_600; break;
2501 case B1200: pCh->speed = CBR_1200; break;
2502 case B1800: pCh->speed = CBR_1800; break;
2503 case B2400: pCh->speed = CBR_2400; break;
2504 case B4800: pCh->speed = CBR_4800; break;
2505 case B9600: pCh->speed = CBR_9600; break;
2506 case B19200: pCh->speed = CBR_19200; break;
2507 case B57600: pCh->speed = CBR_57600; break;
2508 case B115200: pCh->speed = CBR_115200; break;
2509 case B153600: pCh->speed = CBR_153600; break;
2510 case B230400: pCh->speed = CBR_230400; break;
2511 case B307200: pCh->speed = CBR_307200; break;
2512 case B460800: pCh->speed = CBR_460800; break;
2513 case B921600: pCh->speed = CBR_921600; break;
2514 default: pCh->speed = CBR_9600; break;
2516 if ( pCh->speed == CBR_C1 ) {
2517 // Process the custom speed parameters.
2518 int bps = pCh->BaudBase / pCh->BaudDivisor;
2519 if ( bps == 921600 ) {
2520 pCh->speed = CBR_921600;
2523 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_BAUD_DEF1(bps) );
2526 i2QueueCommands( PTYPE_INLINE, pCh, 100, 1, CMD_SETBAUD(pCh->speed));
2528 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 2, CMD_DTRUP, CMD_RTSUP);
2529 pCh->dataSetOut |= (I2_DTR | I2_RTS);
2531 if ( (CSTOPB & cflag) ^ (CSTOPB & o_tios->c_cflag))
2533 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2534 CMD_SETSTOP( ( cflag & CSTOPB ) ? CST_2 : CST_1));
2536 if (((PARENB|PARODD) & cflag) ^ ((PARENB|PARODD) & o_tios->c_cflag))
2538 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1,
2540 (cflag & PARENB ? (cflag & PARODD ? CSP_OD : CSP_EV) : CSP_NP)
2544 /* byte size and parity */
2545 if ( (CSIZE & cflag)^(CSIZE & o_tios->c_cflag))
2548 switch ( cflag & CSIZE ) {
2549 case CS5: datasize = CSZ_5; break;
2550 case CS6: datasize = CSZ_6; break;
2551 case CS7: datasize = CSZ_7; break;
2552 case CS8: datasize = CSZ_8; break;
2553 default: datasize = CSZ_5; break; /* as per serial.c */
2555 i2QueueCommands ( PTYPE_INLINE, pCh, 100, 1, CMD_SETBITS(datasize) );
2557 /* Process CTS flow control flag setting */
2558 if ( (cflag & CRTSCTS) ) {
2559 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2560 2, CMD_CTSFL_ENAB, CMD_RTSFL_ENAB);
2562 i2QueueCommands(PTYPE_INLINE, pCh, 100,
2563 2, CMD_CTSFL_DSAB, CMD_RTSFL_DSAB);
2566 // Process XON/XOFF flow control flags settings
2568 stop_char = STOP_CHAR(pCh->pTTY);
2569 start_char = START_CHAR(pCh->pTTY);
2571 //////////// can't be \000
2572 if (stop_char == __DISABLED_CHAR )
2574 stop_char = ~__DISABLED_CHAR;
2576 if (start_char == __DISABLED_CHAR )
2578 start_char = ~__DISABLED_CHAR;
2580 /////////////////////////////////
2582 if ( o_tios->c_cc[VSTART] != start_char )
2584 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXON(start_char));
2585 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXON(start_char));
2587 if ( o_tios->c_cc[VSTOP] != stop_char )
2589 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1, CMD_DEF_IXOFF(stop_char));
2590 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DEF_OXOFF(stop_char));
2592 if (stop_char == __DISABLED_CHAR )
2594 stop_char = ~__DISABLED_CHAR; //TEST123
2597 if ((iflag & (IXOFF))^(o_tios->c_iflag & (IXOFF)))
2599 if ( iflag & IXOFF ) { // Enable XOFF output flow control
2600 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_XON));
2601 } else { // Disable XOFF output flow control
2603 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_OXON_OPT(COX_NONE));
2606 if (start_char == __DISABLED_CHAR )
2610 if ((iflag & (IXON|IXANY)) ^ (o_tios->c_iflag & (IXON|IXANY)))
2612 if ( iflag & IXON ) {
2613 if ( iflag & IXANY ) { // Enable XON/XANY output flow control
2614 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XANY));
2615 } else { // Enable XON output flow control
2616 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_XON));
2618 } else { // Disable XON output flow control
2620 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_IXON_OPT(CIX_NONE));
2623 if ( (iflag & ISTRIP) ^ ( o_tios->c_iflag & (ISTRIP)) )
2625 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2626 CMD_ISTRIP_OPT((iflag & ISTRIP ? 1 : 0)));
2628 if ( (iflag & INPCK) ^ ( o_tios->c_iflag & (INPCK)) )
2630 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1,
2631 CMD_PARCHK((iflag & INPCK) ? CPK_ENAB : CPK_DSAB));
2634 if ( (iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR))
2635 ^ ( o_tios->c_iflag & (IGNBRK|PARMRK|BRKINT|IGNPAR)) )
2640 if ( iflag & IGNBRK ) { /* Ignore breaks altogether */
2641 /* Ignore breaks altogether */
2642 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_NREP);
2644 if ( iflag & BRKINT ) {
2645 if ( iflag & PARMRK ) {
2646 brkrpt = 0x0a; // exception an inline triple
2648 brkrpt = 0x1a; // exception and NULL
2650 brkrpt |= 0x04; // flush input
2652 if ( iflag & PARMRK ) {
2653 brkrpt = 0x0b; //POSIX triple \0377 \0 \0
2655 brkrpt = 0x01; // Null only
2658 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_BRK_REP(brkrpt));
2661 if (iflag & IGNPAR) {
2663 /* would be 2 for not cirrus bug */
2664 /* would be 0x20 cept for cirrus bug */
2666 if ( iflag & PARMRK ) {
2668 * Replace error characters with 3-byte sequence (\0377,\0,char)
2671 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_ISTRIP_OPT((char)0));
2676 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_SET_ERROR(parrpt));
2678 if (cflag & CLOCAL) {
2679 // Status reporting fails for DCD if this is off
2680 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_NREP);
2681 pCh->flags &= ~ASYNC_CHECK_CD;
2683 i2QueueCommands(PTYPE_INLINE, pCh, 100, 1, CMD_DCD_REP);
2684 pCh->flags |= ASYNC_CHECK_CD;
2688 do_flags_thing: // This is a test, we don't do the flags thing
2690 if ( (cflag & CRTSCTS) ) {
2691 cflag |= 014000000000;
2693 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 1,
2694 CMD_UNIX_FLAGS(iflag,cflag,lflag));
2698 i2DrainOutput( pCh, 100 );
2701 /******************************************************************************/
2702 /* IPL Device Section */
2703 /******************************************************************************/
2705 /******************************************************************************/
2706 /* Function: ip2_ipl_read() */
2707 /* Parameters: Pointer to device inode */
2708 /* Pointer to file structure */
2709 /* Pointer to data */
2710 /* Number of bytes to read */
2711 /* Returns: Success or failure */
2713 /* Description: Ugly */
2716 /******************************************************************************/
2720 ip2_ipl_read(struct file *pFile, char __user *pData, size_t count, loff_t *off )
2722 unsigned int minor = iminor(pFile->f_dentry->d_inode);
2726 printk (KERN_DEBUG "IP2IPL: read %p, %d bytes\n", pData, count );
2730 case 0: // IPL device
2733 case 1: // Status dump
2736 case 2: // Ping device
2739 case 3: // Trace device
2740 rc = DumpTraceBuffer ( pData, count );
2742 case 4: // Trace device
2743 rc = DumpFifoBuffer ( pData, count );
2753 DumpFifoBuffer ( char __user *pData, int count )
2757 rc = copy_to_user(pData, DBGBuf, count);
2759 printk(KERN_DEBUG "Last index %d\n", I );
2762 #endif /* DEBUG_FIFO */
2767 DumpTraceBuffer ( char __user *pData, int count )
2769 #ifdef IP2DEBUG_TRACE
2773 int *pIndex = (int __user *)pData;
2775 if ( count < (sizeof(int) * 6) ) {
2778 rc = put_user(tracewrap, pIndex );
2779 rc = put_user(TRACEMAX, ++pIndex );
2780 rc = put_user(tracestrip, ++pIndex );
2781 rc = put_user(tracestuff, ++pIndex );
2782 pData += sizeof(int) * 6;
2783 count -= sizeof(int) * 6;
2785 dumpcount = tracestuff - tracestrip;
2786 if ( dumpcount < 0 ) {
2787 dumpcount += TRACEMAX;
2789 if ( dumpcount > count ) {
2792 chunk = TRACEMAX - tracestrip;
2793 if ( dumpcount > chunk ) {
2794 rc = copy_to_user(pData, &tracebuf[tracestrip],
2795 chunk * sizeof(tracebuf[0]) );
2796 pData += chunk * sizeof(tracebuf[0]);
2798 chunk = dumpcount - chunk;
2802 rc = copy_to_user(pData, &tracebuf[tracestrip],
2803 chunk * sizeof(tracebuf[0]) );
2804 tracestrip += chunk;
2807 rc = put_user(tracestrip, ++pIndex );
2808 rc = put_user(tracestuff, ++pIndex );
2816 /******************************************************************************/
2817 /* Function: ip2_ipl_write() */
2819 /* Pointer to file structure */
2820 /* Pointer to data */
2821 /* Number of bytes to write */
2822 /* Returns: Success or failure */
2827 /******************************************************************************/
2829 ip2_ipl_write(struct file *pFile, const char __user *pData, size_t count, loff_t *off)
2832 printk (KERN_DEBUG "IP2IPL: write %p, %d bytes\n", pData, count );
2837 /******************************************************************************/
2838 /* Function: ip2_ipl_ioctl() */
2839 /* Parameters: Pointer to device inode */
2840 /* Pointer to file structure */
2843 /* Returns: Success or failure */
2848 /******************************************************************************/
2850 ip2_ipl_ioctl ( struct inode *pInode, struct file *pFile, UINT cmd, ULONG arg )
2852 unsigned int iplminor = iminor(pInode);
2854 void __user *argp = (void __user *)arg;
2855 ULONG __user *pIndex = argp;
2856 i2eBordStrPtr pB = i2BoardPtrTable[iplminor / 4];
2860 printk (KERN_DEBUG "IP2IPL: ioctl cmd %d, arg %ld\n", cmd, arg );
2863 switch ( iplminor ) {
2864 case 0: // IPL device
2867 case 1: // Status dump
2872 case 64: /* Driver - ip2stat */
2873 rc = put_user(ip2_tty_driver->refcount, pIndex++ );
2874 rc = put_user(irq_counter, pIndex++ );
2875 rc = put_user(bh_counter, pIndex++ );
2878 case 65: /* Board - ip2stat */
2880 rc = copy_to_user(argp, pB, sizeof(i2eBordStr));
2881 rc = put_user(INB(pB->i2eStatus),
2882 (ULONG __user *)(arg + (ULONG)(&pB->i2eStatus) - (ULONG)pB ) );
2889 if (cmd < IP2_MAX_PORTS) {
2890 pCh = DevTable[cmd];
2893 rc = copy_to_user(argp, pCh, sizeof(i2ChanStr));
2903 case 2: // Ping device
2906 case 3: // Trace device
2908 rc = put_user(iiSendPendingMail, pIndex++ );
2909 rc = put_user(i2InitChannels, pIndex++ );
2910 rc = put_user(i2QueueNeeds, pIndex++ );
2911 rc = put_user(i2QueueCommands, pIndex++ );
2912 rc = put_user(i2GetStatus, pIndex++ );
2913 rc = put_user(i2Input, pIndex++ );
2914 rc = put_user(i2InputFlush, pIndex++ );
2915 rc = put_user(i2Output, pIndex++ );
2916 rc = put_user(i2FlushOutput, pIndex++ );
2917 rc = put_user(i2DrainWakeup, pIndex++ );
2918 rc = put_user(i2DrainOutput, pIndex++ );
2919 rc = put_user(i2OutputFree, pIndex++ );
2920 rc = put_user(i2StripFifo, pIndex++ );
2921 rc = put_user(i2StuffFifoBypass, pIndex++ );
2922 rc = put_user(i2StuffFifoFlow, pIndex++ );
2923 rc = put_user(i2StuffFifoInline, pIndex++ );
2924 rc = put_user(i2ServiceBoard, pIndex++ );
2925 rc = put_user(serviceOutgoingFifo, pIndex++ );
2926 // rc = put_user(ip2_init, pIndex++ );
2927 rc = put_user(ip2_init_board, pIndex++ );
2928 rc = put_user(find_eisa_board, pIndex++ );
2929 rc = put_user(set_irq, pIndex++ );
2930 rc = put_user(ip2_interrupt, pIndex++ );
2931 rc = put_user(ip2_poll, pIndex++ );
2932 rc = put_user(service_all_boards, pIndex++ );
2933 rc = put_user(do_input, pIndex++ );
2934 rc = put_user(do_status, pIndex++ );
2935 #ifndef IP2DEBUG_OPEN
2936 rc = put_user(0, pIndex++ );
2938 rc = put_user(open_sanity_check, pIndex++ );
2940 rc = put_user(ip2_open, pIndex++ );
2941 rc = put_user(ip2_close, pIndex++ );
2942 rc = put_user(ip2_hangup, pIndex++ );
2943 rc = put_user(ip2_write, pIndex++ );
2944 rc = put_user(ip2_putchar, pIndex++ );
2945 rc = put_user(ip2_flush_chars, pIndex++ );
2946 rc = put_user(ip2_write_room, pIndex++ );
2947 rc = put_user(ip2_chars_in_buf, pIndex++ );
2948 rc = put_user(ip2_flush_buffer, pIndex++ );
2950 //rc = put_user(ip2_wait_until_sent, pIndex++ );
2951 rc = put_user(0, pIndex++ );
2953 rc = put_user(ip2_throttle, pIndex++ );
2954 rc = put_user(ip2_unthrottle, pIndex++ );
2955 rc = put_user(ip2_ioctl, pIndex++ );
2956 rc = put_user(0, pIndex++ );
2957 rc = put_user(get_serial_info, pIndex++ );
2958 rc = put_user(set_serial_info, pIndex++ );
2959 rc = put_user(ip2_set_termios, pIndex++ );
2960 rc = put_user(ip2_set_line_discipline, pIndex++ );
2961 rc = put_user(set_params, pIndex++ );
2975 /******************************************************************************/
2976 /* Function: ip2_ipl_open() */
2977 /* Parameters: Pointer to device inode */
2978 /* Pointer to file structure */
2979 /* Returns: Success or failure */
2984 /******************************************************************************/
2986 ip2_ipl_open( struct inode *pInode, struct file *pFile )
2988 unsigned int iplminor = iminor(pInode);
2993 printk (KERN_DEBUG "IP2IPL: open\n" );
2997 // These are the IPL devices
3004 // These are the status devices
3011 // These are the debug devices
3016 pB = i2BoardPtrTable[iplminor / 4];
3017 pCh = (i2ChanStrPtr) pB->i2eChannelPtr;
3020 // This is the trace device
3026 /******************************************************************************/
3027 /* Function: ip2_read_procmem */
3030 /* Returns: Length of output */
3033 /* Supplies some driver operating parameters */
3034 /* Not real useful unless your debugging the fifo */
3036 /******************************************************************************/
3038 #define LIMIT (PAGE_SIZE - 120)
3041 ip2_read_procmem(char *buf, char **start, off_t offset, int len)
3050 #define FMTLINE "%3d: 0x%08x 0x%08x 0%011o 0%011o\n"
3051 #define FMTLIN2 " 0x%04x 0x%04x tx flow 0x%x\n"
3052 #define FMTLIN3 " 0x%04x 0x%04x rc flow\n"
3054 len += sprintf(buf+len,"\n");
3056 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3057 pB = i2BoardPtrTable[i];
3059 len += sprintf(buf+len,"board %d:\n",i);
3060 len += sprintf(buf+len,"\tFifo rem: %d mty: %x outM %x\n",
3061 pB->i2eFifoRemains,pB->i2eWaitingForEmptyFifo,pB->i2eOutMailWaiting);
3065 len += sprintf(buf+len,"#: tty flags, port flags, cflags, iflags\n");
3066 for (i=0; i < IP2_MAX_PORTS; i++) {
3072 if (tty && tty->count) {
3073 len += sprintf(buf+len,FMTLINE,i,(int)tty->flags,pCh->flags,
3074 tty->termios->c_cflag,tty->termios->c_iflag);
3076 len += sprintf(buf+len,FMTLIN2,
3077 pCh->outfl.asof,pCh->outfl.room,pCh->channelNeeds);
3078 len += sprintf(buf+len,FMTLIN3,pCh->infl.asof,pCh->infl.room);
3086 * This is the handler for /proc/tty/driver/ip2
3088 * This stretch of code has been largely plagerized from at least three
3089 * different sources including ip2mkdev.c and a couple of other drivers.
3090 * The bugs are all mine. :-) =mhw=
3092 int ip2_read_proc(char *page, char **start, off_t off,
3093 int count, int *eof, void *data)
3103 len += sprintf(page, "ip2info: 1.0 driver: %s\n", pcVersion );
3104 len += sprintf(page+len, "Driver: SMajor=%d CMajor=%d IMajor=%d MaxBoards=%d MaxBoxes=%d MaxPorts=%d\n",
3105 IP2_TTY_MAJOR, IP2_CALLOUT_MAJOR, IP2_IPL_MAJOR,
3106 IP2_MAX_BOARDS, ABS_MAX_BOXES, ABS_BIGGEST_BOX);
3108 for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
3109 /* This need to be reset for a board by board count... */
3111 pB = i2BoardPtrTable[i];
3113 switch( pB->i2ePom.e.porID & ~POR_ID_RESERVED )
3116 len += sprintf( page+len, "Board %d: EX ports=", i );
3117 for( box = 0; box < ABS_MAX_BOXES; ++box )
3121 if( pB->i2eChannelMap[box] != 0 ) ++boxes;
3122 for( j = 0; j < ABS_BIGGEST_BOX; ++j )
3124 if( pB->i2eChannelMap[box] & 1<< j ) {
3128 len += sprintf( page+len, "%d,", ports );
3132 --len; /* Backup over that last comma */
3134 len += sprintf( page+len, " boxes=%d width=%d", boxes, pB->i2eDataWidth16 ? 16 : 8 );
3138 len += sprintf(page+len, "Board %d: ISA-4 ports=4 boxes=1", i );
3143 len += sprintf(page+len, "Board %d: ISA-8-std ports=8 boxes=1", i );
3148 len += sprintf(page+len, "Board %d: ISA-8-RJ11 ports=8 boxes=1", i );
3153 len += sprintf(page+len, "Board %d: unknown", i );
3154 /* Don't try and probe for minor numbers */
3159 /* Don't try and probe for minor numbers */
3160 len += sprintf(page+len, "Board %d: vacant", i );
3165 len += sprintf(page+len, " minors=" );
3167 for ( box = 0; box < ABS_MAX_BOXES; ++box )
3169 for ( j = 0; j < ABS_BIGGEST_BOX; ++j )
3171 if ( pB->i2eChannelMap[box] & (1 << j) )
3173 len += sprintf (page+len,"%d,",
3174 j + ABS_BIGGEST_BOX *
3175 (box+i*ABS_MAX_BOXES));
3180 page[ len - 1 ] = '\n'; /* Overwrite that last comma */
3182 len += sprintf (page+len,"\n" );
3185 if (len+begin > off+count)
3187 if (len+begin < off) {
3193 if (i >= IP2_MAX_BOARDS)
3195 if (off >= len+begin)
3198 *start = page + (off-begin);
3199 return ((count < begin+len-off) ? count : begin+len-off);
3202 /******************************************************************************/
3203 /* Function: ip2trace() */
3204 /* Parameters: Value to add to trace buffer */
3205 /* Returns: Nothing */
3210 /******************************************************************************/
3211 #ifdef IP2DEBUG_TRACE
3213 ip2trace (unsigned short pn, unsigned char cat, unsigned char label, unsigned long codes, ...)
3216 unsigned long *pCode = &codes;
3217 union ip2breadcrumb bc;
3221 tracebuf[tracestuff++] = jiffies;
3222 if ( tracestuff == TRACEMAX ) {
3225 if ( tracestuff == tracestrip ) {
3226 if ( ++tracestrip == TRACEMAX ) {
3232 bc.hdr.port = 0xff & pn;
3234 bc.hdr.codes = (unsigned char)( codes & 0xff );
3235 bc.hdr.label = label;
3236 tracebuf[tracestuff++] = bc.value;
3239 if ( tracestuff == TRACEMAX ) {
3242 if ( tracestuff == tracestrip ) {
3243 if ( ++tracestrip == TRACEMAX ) {
3252 tracebuf[tracestuff++] = *++pCode;
3258 MODULE_LICENSE("GPL");