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