git.oblomov.eu Git - linux-2.6/blob - drivers/char/ip2/ip2main.c

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