drivers/char/ip2/ip2main.c

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