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