drivers/char/isicom.c

   1 /*
   2  *      This program is free software; you can redistribute it and/or
   3  *      modify it under the terms of the GNU General Public License
   4  *      as published by the Free Software Foundation; either version
   5  *      2 of the License, or (at your option) any later version.
   6  *
   7  *      Original driver code supplied by Multi-Tech
   8  *
   9  *      Changes
  10  *      1/9/98  alan@redhat.com         Merge to 2.0.x kernel tree
  11  *                                      Obtain and use official major/minors
  12  *                                      Loader switched to a misc device
  13  *                                      (fixed range check bug as a side effect)
  14  *                                      Printk clean up
  15  *      9/12/98 alan@redhat.com         Rough port to 2.1.x
  16  *
  17  *      10/6/99 sameer                  Merged the ISA and PCI drivers to
  18  *                                      a new unified driver.
  19  *
  20  *      3/9/99  sameer                  Added support for ISI4616 cards.
  21  *
  22  *      16/9/99 sameer                  We do not force RTS low anymore.
  23  *                                      This is to prevent the firmware
  24  *                                      from getting confused.
  25  *
  26  *      26/10/99 sameer                 Cosmetic changes:The driver now
  27  *                                      dumps the Port Count information
  28  *                                      along with I/O address and IRQ.
  29  *
  30  *      13/12/99 sameer                 Fixed the problem with IRQ sharing.
  31  *
  32  *      10/5/00  sameer                 Fixed isicom_shutdown_board()
  33  *                                      to not lower DTR on all the ports
  34  *                                      when the last port on the card is
  35  *                                      closed.
  36  *
  37  *      10/5/00  sameer                 Signal mask setup command added
  38  *                                      to  isicom_setup_port and
  39  *                                      isicom_shutdown_port.
  40  *
  41  *      24/5/00  sameer                 The driver is now SMP aware.
  42  *
  43  *
  44  *      27/11/00 Vinayak P Risbud       Fixed the Driver Crash Problem
  45  *
  46  *
  47  *      03/01/01  anil .s               Added support for resetting the
  48  *                                      internal modems on ISI cards.
  49  *
  50  *      08/02/01  anil .s               Upgraded the driver for kernel
  51  *                                      2.4.x
  52  *
  53  *      11/04/01  Kevin                 Fixed firmware load problem with
  54  *                                      ISIHP-4X card
  55  *
  56  *      30/04/01  anil .s               Fixed the remote login through
  57  *                                      ISI port problem. Now the link
  58  *                                      does not go down before password
  59  *                                      prompt.
  60  *
  61  *      03/05/01  anil .s               Fixed the problem with IRQ sharing
  62  *                                      among ISI-PCI cards.
  63  *
  64  *      03/05/01  anil .s               Added support to display the version
  65  *                                      info during insmod as well as module
  66  *                                      listing by lsmod.
  67  *
  68  *      10/05/01  anil .s               Done the modifications to the source
  69  *                                      file and Install script so that the
  70  *                                      same installation can be used for
  71  *                                      2.2.x and 2.4.x kernel.
  72  *
  73  *      06/06/01  anil .s               Now we drop both dtr and rts during
  74  *                                      shutdown_port as well as raise them
  75  *                                      during isicom_config_port.
  76  *
  77  *      09/06/01 acme@conectiva.com.br  use capable, not suser, do
  78  *                                      restore_flags on failure in
  79  *                                      isicom_send_break, verify put_user
  80  *                                      result
  81  *
  82  *      11/02/03  ranjeeth              Added support for 230 Kbps and 460 Kbps
  83  *                                      Baud index extended to 21
  84  *
  85  *      20/03/03  ranjeeth              Made to work for Linux Advanced server.
  86  *                                      Taken care of license warning.
  87  *
  88  *      10/12/03  Ravindra              Made to work for Fedora Core 1 of
  89  *                                      Red Hat Distribution
  90  *
  91  *      06/01/05  Alan Cox              Merged the ISI and base kernel strands
  92  *                                      into a single 2.6 driver
  93  *
  94  *      ***********************************************************
  95  *
  96  *      To use this driver you also need the support package. You
  97  *      can find this in RPM format on
  98  *              ftp://ftp.linux.org.uk/pub/linux/alan
  99  *
 100  *      You can find the original tools for this direct from Multitech
 101  *              ftp://ftp.multitech.com/ISI-Cards/
 102  *
 103  *      Having installed the cards the module options (/etc/modprobe.conf)
 104  *
 105  *      options isicom   io=card1,card2,card3,card4 irq=card1,card2,card3,card4
 106  *
 107  *      Omit those entries for boards you don't have installed.
 108  *
 109  *      TODO
 110  *              Merge testing
 111  *              64-bit verification
 112  */
 113
 114 #include <linux/module.h>
 115 #include <linux/firmware.h>
 116 #include <linux/kernel.h>
 117 #include <linux/tty.h>
 118 #include <linux/tty_flip.h>
 119 #include <linux/termios.h>
 120 #include <linux/fs.h>
 121 #include <linux/sched.h>
 122 #include <linux/serial.h>
 123 #include <linux/mm.h>
 124 #include <linux/interrupt.h>
 125 #include <linux/timer.h>
 126 #include <linux/delay.h>
 127 #include <linux/ioport.h>
 128
 129 #include <asm/uaccess.h>
 130 #include <asm/io.h>
 131 #include <asm/system.h>
 132
 133 #include <linux/pci.h>
 134
 135 #include <linux/isicom.h>
 136
 137 #define InterruptTheCard(base) outw(0, (base) + 0xc)
 138 #define ClearInterrupt(base) inw((base) + 0x0a)
 139
 140 #ifdef DEBUG
 141 #define pr_dbg(str...) printk(KERN_DEBUG "ISICOM: " str)
 142 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
 143 #else
 144 #define pr_dbg(str...) do { } while (0)
 145 #define isicom_paranoia_check(a, b, c) 0
 146 #endif
 147
 148 static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
 149 static void __devexit isicom_remove(struct pci_dev *);
 150
 151 static struct pci_device_id isicom_pci_tbl[] = {
 152         { PCI_DEVICE(VENDOR_ID, 0x2028) },
 153         { PCI_DEVICE(VENDOR_ID, 0x2051) },
 154         { PCI_DEVICE(VENDOR_ID, 0x2052) },
 155         { PCI_DEVICE(VENDOR_ID, 0x2053) },
 156         { PCI_DEVICE(VENDOR_ID, 0x2054) },
 157         { PCI_DEVICE(VENDOR_ID, 0x2055) },
 158         { PCI_DEVICE(VENDOR_ID, 0x2056) },
 159         { PCI_DEVICE(VENDOR_ID, 0x2057) },
 160         { PCI_DEVICE(VENDOR_ID, 0x2058) },
 161         { 0 }
 162 };
 163 MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
 164
 165 static struct pci_driver isicom_driver = {
 166         .name           = "isicom",
 167         .id_table       = isicom_pci_tbl,
 168         .probe          = isicom_probe,
 169         .remove         = __devexit_p(isicom_remove)
 170 };
 171
 172 static int prev_card = 3;       /*      start servicing isi_card[0]     */
 173 static struct tty_driver *isicom_normal;
 174
 175 static DECLARE_COMPLETION(isi_timerdone);
 176 static char re_schedule = 1;
 177
 178 static void isicom_tx(unsigned long _data);
 179 static void isicom_start(struct tty_struct *tty);
 180
 181 static DEFINE_TIMER(tx, isicom_tx, 0, 0);
 182
 183 /*   baud index mappings from linux defns to isi */
 184
 185 static signed char linuxb_to_isib[] = {
 186         -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19
 187 };
 188
 189 struct  isi_board {
 190         unsigned long           base;
 191         unsigned char           irq;
 192         unsigned char           port_count;
 193         unsigned short          status;
 194         unsigned short          port_status; /* each bit for each port */
 195         unsigned short          shift_count;
 196         struct isi_port         * ports;
 197         signed char             count;
 198         spinlock_t              card_lock; /* Card wide lock 11/5/00 -sameer */
 199         unsigned long           flags;
 200         unsigned int            index;
 201 };
 202
 203 struct  isi_port {
 204         unsigned short          magic;
 205         unsigned int            flags;
 206         int                     count;
 207         int                     blocked_open;
 208         int                     close_delay;
 209         u16                     channel;
 210         u16                     status;
 211         u16                     closing_wait;
 212         struct isi_board        * card;
 213         struct tty_struct       * tty;
 214         wait_queue_head_t       close_wait;
 215         wait_queue_head_t       open_wait;
 216         struct work_struct      hangup_tq;
 217         struct work_struct      bh_tqueue;
 218         unsigned char           * xmit_buf;
 219         int                     xmit_head;
 220         int                     xmit_tail;
 221         int                     xmit_cnt;
 222 };
 223
 224 static struct isi_board isi_card[BOARD_COUNT];
 225 static struct isi_port  isi_ports[PORT_COUNT];
 226
 227 /*
 228  *      Locking functions for card level locking. We need to own both
 229  *      the kernel lock for the card and have the card in a position that
 230  *      it wants to talk.
 231  */
 232
 233 static int lock_card(struct isi_board *card)
 234 {
 235         char            retries;
 236         unsigned long base = card->base;
 237
 238         for (retries = 0; retries < 100; retries++) {
 239                 spin_lock_irqsave(&card->card_lock, card->flags);
 240                 if (inw(base + 0xe) & 0x1) {
 241                         return 1;
 242                 } else {
 243                         spin_unlock_irqrestore(&card->card_lock, card->flags);
 244                         udelay(1000);   /* 1ms */
 245                 }
 246         }
 247         printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n",
 248                 card->base);
 249
 250         return 0;       /* Failed to acquire the card! */
 251 }
 252
 253 static int lock_card_at_interrupt(struct isi_board *card)
 254 {
 255         unsigned char           retries;
 256         unsigned long base = card->base;
 257
 258         for (retries = 0; retries < 200; retries++) {
 259                 spin_lock_irqsave(&card->card_lock, card->flags);
 260
 261                 if (inw(base + 0xe) & 0x1)
 262                         return 1;
 263                 else
 264                         spin_unlock_irqrestore(&card->card_lock, card->flags);
 265         }
 266         /* Failing in interrupt is an acceptable event */
 267         return 0;       /* Failed to acquire the card! */
 268 }
 269
 270 static void unlock_card(struct isi_board *card)
 271 {
 272         spin_unlock_irqrestore(&card->card_lock, card->flags);
 273 }
 274
 275 /*
 276  *  ISI Card specific ops ...
 277  */
 278
 279 static void raise_dtr(struct isi_port *port)
 280 {
 281         struct isi_board *card = port->card;
 282         unsigned long base = card->base;
 283         u16 channel = port->channel;
 284
 285         if (!lock_card(card))
 286                 return;
 287
 288         outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 289         outw(0x0504, base);
 290         InterruptTheCard(base);
 291         port->status |= ISI_DTR;
 292         unlock_card(card);
 293 }
 294
 295 static inline void drop_dtr(struct isi_port *port)
 296 {
 297         struct isi_board *card = port->card;
 298         unsigned long base = card->base;
 299         u16 channel = port->channel;
 300
 301         if (!lock_card(card))
 302                 return;
 303
 304         outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 305         outw(0x0404, base);
 306         InterruptTheCard(base);
 307         port->status &= ~ISI_DTR;
 308         unlock_card(card);
 309 }
 310
 311 static inline void raise_rts(struct isi_port *port)
 312 {
 313         struct isi_board *card = port->card;
 314         unsigned long base = card->base;
 315         u16 channel = port->channel;
 316
 317         if (!lock_card(card))
 318                 return;
 319
 320         outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 321         outw(0x0a04, base);
 322         InterruptTheCard(base);
 323         port->status |= ISI_RTS;
 324         unlock_card(card);
 325 }
 326 static inline void drop_rts(struct isi_port *port)
 327 {
 328         struct isi_board *card = port->card;
 329         unsigned long base = card->base;
 330         u16 channel = port->channel;
 331
 332         if (!lock_card(card))
 333                 return;
 334
 335         outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 336         outw(0x0804, base);
 337         InterruptTheCard(base);
 338         port->status &= ~ISI_RTS;
 339         unlock_card(card);
 340 }
 341
 342 static inline void raise_dtr_rts(struct isi_port *port)
 343 {
 344         struct isi_board *card = port->card;
 345         unsigned long base = card->base;
 346         u16 channel = port->channel;
 347
 348         if (!lock_card(card))
 349                 return;
 350
 351         outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 352         outw(0x0f04, base);
 353         InterruptTheCard(base);
 354         port->status |= (ISI_DTR | ISI_RTS);
 355         unlock_card(card);
 356 }
 357
 358 static void drop_dtr_rts(struct isi_port *port)
 359 {
 360         struct isi_board *card = port->card;
 361         unsigned long base = card->base;
 362         u16 channel = port->channel;
 363
 364         if (!lock_card(card))
 365                 return;
 366
 367         outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 368         outw(0x0c04, base);
 369         InterruptTheCard(base);
 370         port->status &= ~(ISI_RTS | ISI_DTR);
 371         unlock_card(card);
 372 }
 373
 374 static inline void kill_queue(struct isi_port *port, short queue)
 375 {
 376         struct isi_board *card = port->card;
 377         unsigned long base = card->base;
 378         u16 channel = port->channel;
 379
 380         if (!lock_card(card))
 381                 return;
 382
 383         outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 384         outw((queue << 8) | 0x06, base);
 385         InterruptTheCard(base);
 386         unlock_card(card);
 387 }
 388
 389 /*
 390  *      ISICOM Driver specific routines ...
 391  *
 392  */
 393
 394 static inline int __isicom_paranoia_check(struct isi_port const *port,
 395         char *name, const char *routine)
 396 {
 397         if (!port) {
 398                 printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
 399                         "dev %s in %s.\n", name, routine);
 400                 return 1;
 401         }
 402         if (port->magic != ISICOM_MAGIC) {
 403                 printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
 404                         "dev %s in %s.\n", name, routine);
 405                 return 1;
 406         }
 407
 408         return 0;
 409 }
 410
 411 /*
 412  *      Transmitter.
 413  *
 414  *      We shovel data into the card buffers on a regular basis. The card
 415  *      will do the rest of the work for us.
 416  */
 417
 418 static void isicom_tx(unsigned long _data)
 419 {
 420         short count = (BOARD_COUNT-1), card, base;
 421         short txcount, wrd, residue, word_count, cnt;
 422         struct isi_port *port;
 423         struct tty_struct *tty;
 424
 425         /*      find next active board  */
 426         card = (prev_card + 1) & 0x0003;
 427         while(count-- > 0) {
 428                 if (isi_card[card].status & BOARD_ACTIVE)
 429                         break;
 430                 card = (card + 1) & 0x0003;
 431         }
 432         if (!(isi_card[card].status & BOARD_ACTIVE))
 433                 goto sched_again;
 434
 435         prev_card = card;
 436
 437         count = isi_card[card].port_count;
 438         port = isi_card[card].ports;
 439         base = isi_card[card].base;
 440         for (;count > 0;count--, port++) {
 441                 if (!lock_card_at_interrupt(&isi_card[card]))
 442                         continue;
 443                 /* port not active or tx disabled to force flow control */
 444                 if (!(port->flags & ASYNC_INITIALIZED) ||
 445                                 !(port->status & ISI_TXOK))
 446                         unlock_card(&isi_card[card]);
 447                         continue;
 448
 449                 tty = port->tty;
 450
 451
 452                 if (tty == NULL) {
 453                         unlock_card(&isi_card[card]);
 454                         continue;
 455                 }
 456
 457                 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
 458                 if (txcount <= 0 || tty->stopped || tty->hw_stopped) {
 459                         unlock_card(&isi_card[card]);
 460                         continue;
 461                 }
 462                 if (!(inw(base + 0x02) & (1 << port->channel))) {
 463                         unlock_card(&isi_card[card]);
 464                         continue;
 465                 }
 466                 pr_dbg("txing %d bytes, port%d.\n", txcount,
 467                         port->channel + 1);
 468                 outw((port->channel << isi_card[card].shift_count) | txcount,
 469                         base);
 470                 residue = NO;
 471                 wrd = 0;
 472                 while (1) {
 473                         cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE
 474                                         - port->xmit_tail));
 475                         if (residue == YES) {
 476                                 residue = NO;
 477                                 if (cnt > 0) {
 478                                         wrd |= (port->xmit_buf[port->xmit_tail]
 479                                                                         << 8);
 480                                         port->xmit_tail = (port->xmit_tail + 1)
 481                                                 & (SERIAL_XMIT_SIZE - 1);
 482                                         port->xmit_cnt--;
 483                                         txcount--;
 484                                         cnt--;
 485                                         outw(wrd, base);
 486                                 } else {
 487                                         outw(wrd, base);
 488                                         break;
 489                                 }
 490                         }
 491                         if (cnt <= 0) break;
 492                         word_count = cnt >> 1;
 493                         outsw(base, port->xmit_buf+port->xmit_tail,word_count);
 494                         port->xmit_tail = (port->xmit_tail
 495                                 + (word_count << 1)) & (SERIAL_XMIT_SIZE - 1);
 496                         txcount -= (word_count << 1);
 497                         port->xmit_cnt -= (word_count << 1);
 498                         if (cnt & 0x0001) {
 499                                 residue = YES;
 500                                 wrd = port->xmit_buf[port->xmit_tail];
 501                                 port->xmit_tail = (port->xmit_tail + 1)
 502                                         & (SERIAL_XMIT_SIZE - 1);
 503                                 port->xmit_cnt--;
 504                                 txcount--;
 505                         }
 506                 }
 507
 508                 InterruptTheCard(base);
 509                 if (port->xmit_cnt <= 0)
 510                         port->status &= ~ISI_TXOK;
 511                 if (port->xmit_cnt <= WAKEUP_CHARS)
 512                         schedule_work(&port->bh_tqueue);
 513                 unlock_card(&isi_card[card]);
 514         }
 515
 516         /*      schedule another tx for hopefully in about 10ms */
 517 sched_again:
 518         if (!re_schedule) {
 519                 complete(&isi_timerdone);
 520                 return;
 521         }
 522
 523         mod_timer(&tx, jiffies + msecs_to_jiffies(10));
 524 }
 525
 526 /*      Interrupt handlers      */
 527
 528
 529 static void isicom_bottomhalf(struct work_struct *work)
 530 {
 531         struct isi_port *port = container_of(work, struct isi_port, bh_tqueue);
 532         struct tty_struct *tty = port->tty;
 533
 534         if (!tty)
 535                 return;
 536
 537         tty_wakeup(tty);
 538         wake_up_interruptible(&tty->write_wait);
 539 }
 540
 541 /*
 542  *      Main interrupt handler routine
 543  */
 544
 545 static irqreturn_t isicom_interrupt(int irq, void *dev_id)
 546 {
 547         struct isi_board *card = dev_id;
 548         struct isi_port *port;
 549         struct tty_struct *tty;
 550         unsigned long base;
 551         u16 header, word_count, count, channel;
 552         short byte_count;
 553         unsigned char *rp;
 554
 555         if (!card || !(card->status & FIRMWARE_LOADED))
 556                 return IRQ_NONE;
 557
 558         base = card->base;
 559         spin_lock(&card->card_lock);
 560
 561         /*
 562          * disable any interrupts from the PCI card and lower the
 563          * interrupt line
 564          */
 565         outw(0x8000, base+0x04);
 566         ClearInterrupt(base);
 567
 568         inw(base);              /* get the dummy word out */
 569         header = inw(base);
 570         channel = (header & 0x7800) >> card->shift_count;
 571         byte_count = header & 0xff;
 572
 573         if (channel + 1 > card->port_count) {
 574                 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
 575                         "%d(channel) > port_count.\n", base, channel+1);
 576                 outw(0x0000, base+0x04); /* enable interrupts */
 577                 spin_unlock(&card->card_lock);
 578                 return IRQ_HANDLED;
 579         }
 580         port = card->ports + channel;
 581         if (!(port->flags & ASYNC_INITIALIZED)) {
 582                 outw(0x0000, base+0x04); /* enable interrupts */
 583                 return IRQ_HANDLED;
 584         }
 585
 586         tty = port->tty;
 587         if (tty == NULL) {
 588                 word_count = byte_count >> 1;
 589                 while(byte_count > 1) {
 590                         inw(base);
 591                         byte_count -= 2;
 592                 }
 593                 if (byte_count & 0x01)
 594                         inw(base);
 595                 outw(0x0000, base+0x04); /* enable interrupts */
 596                 spin_unlock(&card->card_lock);
 597                 return IRQ_HANDLED;
 598         }
 599
 600         if (header & 0x8000) {          /* Status Packet */
 601                 header = inw(base);
 602                 switch(header & 0xff) {
 603                 case 0: /* Change in EIA signals */
 604                         if (port->flags & ASYNC_CHECK_CD) {
 605                                 if (port->status & ISI_DCD) {
 606                                         if (!(header & ISI_DCD)) {
 607                                         /* Carrier has been lost  */
 608                                                 pr_dbg("interrupt: DCD->low.\n"
 609                                                         );
 610                                                 port->status &= ~ISI_DCD;
 611                                                 schedule_work(&port->hangup_tq);
 612                                         }
 613                                 } else if (header & ISI_DCD) {
 614                                 /* Carrier has been detected */
 615                                         pr_dbg("interrupt: DCD->high.\n");
 616                                         port->status |= ISI_DCD;
 617                                         wake_up_interruptible(&port->open_wait);
 618                                 }
 619                         } else {
 620                                 if (header & ISI_DCD)
 621                                         port->status |= ISI_DCD;
 622                                 else
 623                                         port->status &= ~ISI_DCD;
 624                         }
 625
 626                         if (port->flags & ASYNC_CTS_FLOW) {
 627                                 if (port->tty->hw_stopped) {
 628                                         if (header & ISI_CTS) {
 629                                                 port->tty->hw_stopped = 0;
 630                                                 /* start tx ing */
 631                                                 port->status |= (ISI_TXOK
 632                                                         | ISI_CTS);
 633                                                 schedule_work(&port->bh_tqueue);
 634                                         }
 635                                 } else if (!(header & ISI_CTS)) {
 636                                         port->tty->hw_stopped = 1;
 637                                         /* stop tx ing */
 638                                         port->status &= ~(ISI_TXOK | ISI_CTS);
 639                                 }
 640                         } else {
 641                                 if (header & ISI_CTS)
 642                                         port->status |= ISI_CTS;
 643                                 else
 644                                         port->status &= ~ISI_CTS;
 645                         }
 646
 647                         if (header & ISI_DSR)
 648                                 port->status |= ISI_DSR;
 649                         else
 650                                 port->status &= ~ISI_DSR;
 651
 652                         if (header & ISI_RI)
 653                                 port->status |= ISI_RI;
 654                         else
 655                                 port->status &= ~ISI_RI;
 656
 657                         break;
 658
 659                 case 1: /* Received Break !!! */
 660                         tty_insert_flip_char(tty, 0, TTY_BREAK);
 661                         if (port->flags & ASYNC_SAK)
 662                                 do_SAK(tty);
 663                         tty_flip_buffer_push(tty);
 664                         break;
 665
 666                 case 2: /* Statistics            */
 667                         pr_dbg("isicom_interrupt: stats!!!.\n");
 668                         break;
 669
 670                 default:
 671                         pr_dbg("Intr: Unknown code in status packet.\n");
 672                         break;
 673                 }
 674         } else {                                /* Data   Packet */
 675
 676                 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
 677                 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
 678                 word_count = count >> 1;
 679                 insw(base, rp, word_count);
 680                 byte_count -= (word_count << 1);
 681                 if (count & 0x0001) {
 682                         tty_insert_flip_char(tty,  inw(base) & 0xff,
 683                                 TTY_NORMAL);
 684                         byte_count -= 2;
 685                 }
 686                 if (byte_count > 0) {
 687                         pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
 688                                 "bytes...\n", base, channel + 1);
 689                         while(byte_count > 0) { /* drain out unread xtra data */
 690                                 inw(base);
 691                                 byte_count -= 2;
 692                         }
 693                 }
 694                 tty_flip_buffer_push(tty);
 695         }
 696         outw(0x0000, base+0x04); /* enable interrupts */
 697
 698         return IRQ_HANDLED;
 699 }
 700
 701 static void isicom_config_port(struct isi_port *port)
 702 {
 703         struct isi_board *card = port->card;
 704         struct tty_struct *tty;
 705         unsigned long baud;
 706         unsigned long base = card->base;
 707         u16 channel_setup, channel = port->channel,
 708                 shift_count = card->shift_count;
 709         unsigned char flow_ctrl;
 710
 711         if (!(tty = port->tty) || !tty->termios)
 712                 return;
 713         baud = C_BAUD(tty);
 714         if (baud & CBAUDEX) {
 715                 baud &= ~CBAUDEX;
 716
 717                 /*  if CBAUDEX bit is on and the baud is set to either 50 or 75
 718                  *  then the card is programmed for 57.6Kbps or 115Kbps
 719                  *  respectively.
 720                  */
 721
 722                 if (baud < 1 || baud > 2)
 723                         port->tty->termios->c_cflag &= ~CBAUDEX;
 724                 else
 725                         baud += 15;
 726         }
 727         if (baud == 15) {
 728
 729                 /*  the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
 730                  *  by the set_serial_info ioctl ... this is done by
 731                  *  the 'setserial' utility.
 732                  */
 733
 734                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
 735                         baud++; /*  57.6 Kbps */
 736                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
 737                         baud +=2; /*  115  Kbps */
 738         }
 739         if (linuxb_to_isib[baud] == -1) {
 740                 /* hang up */
 741                 drop_dtr(port);
 742                 return;
 743         }
 744         else
 745                 raise_dtr(port);
 746
 747         if (lock_card(card)) {
 748                 outw(0x8000 | (channel << shift_count) |0x03, base);
 749                 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
 750                 channel_setup = 0;
 751                 switch(C_CSIZE(tty)) {
 752                 case CS5:
 753                         channel_setup |= ISICOM_CS5;
 754                         break;
 755                 case CS6:
 756                         channel_setup |= ISICOM_CS6;
 757                         break;
 758                 case CS7:
 759                         channel_setup |= ISICOM_CS7;
 760                         break;
 761                 case CS8:
 762                         channel_setup |= ISICOM_CS8;
 763                         break;
 764                 }
 765
 766                 if (C_CSTOPB(tty))
 767                         channel_setup |= ISICOM_2SB;
 768                 if (C_PARENB(tty)) {
 769                         channel_setup |= ISICOM_EVPAR;
 770                         if (C_PARODD(tty))
 771                                 channel_setup |= ISICOM_ODPAR;
 772                 }
 773                 outw(channel_setup, base);
 774                 InterruptTheCard(base);
 775                 unlock_card(card);
 776         }
 777         if (C_CLOCAL(tty))
 778                 port->flags &= ~ASYNC_CHECK_CD;
 779         else
 780                 port->flags |= ASYNC_CHECK_CD;
 781
 782         /* flow control settings ...*/
 783         flow_ctrl = 0;
 784         port->flags &= ~ASYNC_CTS_FLOW;
 785         if (C_CRTSCTS(tty)) {
 786                 port->flags |= ASYNC_CTS_FLOW;
 787                 flow_ctrl |= ISICOM_CTSRTS;
 788         }
 789         if (I_IXON(tty))
 790                 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
 791         if (I_IXOFF(tty))
 792                 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
 793
 794         if (lock_card(card)) {
 795                 outw(0x8000 | (channel << shift_count) |0x04, base);
 796                 outw(flow_ctrl << 8 | 0x05, base);
 797                 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
 798                 InterruptTheCard(base);
 799                 unlock_card(card);
 800         }
 801
 802         /*      rx enabled -> enable port for rx on the card    */
 803         if (C_CREAD(tty)) {
 804                 card->port_status |= (1 << channel);
 805                 outw(card->port_status, base + 0x02);
 806         }
 807 }
 808
 809 /* open et all */
 810
 811 static inline void isicom_setup_board(struct isi_board *bp)
 812 {
 813         int channel;
 814         struct isi_port *port;
 815         unsigned long flags;
 816
 817         spin_lock_irqsave(&bp->card_lock, flags);
 818         if (bp->status & BOARD_ACTIVE) {
 819                 spin_unlock_irqrestore(&bp->card_lock, flags);
 820                 return;
 821         }
 822         port = bp->ports;
 823         bp->status |= BOARD_ACTIVE;
 824         spin_unlock_irqrestore(&bp->card_lock, flags);
 825         for (channel = 0; channel < bp->port_count; channel++, port++)
 826                 drop_dtr_rts(port);
 827         return;
 828 }
 829
 830 static int isicom_setup_port(struct isi_port *port)
 831 {
 832         struct isi_board *card = port->card;
 833         unsigned long flags;
 834
 835         if (port->flags & ASYNC_INITIALIZED) {
 836                 return 0;
 837         }
 838         if (!port->xmit_buf) {
 839                 unsigned long page;
 840
 841                 if (!(page = get_zeroed_page(GFP_KERNEL)))
 842                         return -ENOMEM;
 843
 844                 if (port->xmit_buf) {
 845                         free_page(page);
 846                         return -ERESTARTSYS;
 847                 }
 848                 port->xmit_buf = (unsigned char *) page;
 849         }
 850
 851         spin_lock_irqsave(&card->card_lock, flags);
 852         if (port->tty)
 853                 clear_bit(TTY_IO_ERROR, &port->tty->flags);
 854         if (port->count == 1)
 855                 card->count++;
 856
 857         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
 858
 859         /*      discard any residual data       */
 860         kill_queue(port, ISICOM_KILLTX | ISICOM_KILLRX);
 861
 862         isicom_config_port(port);
 863         port->flags |= ASYNC_INITIALIZED;
 864         spin_unlock_irqrestore(&card->card_lock, flags);
 865
 866         return 0;
 867 }
 868
 869 static int block_til_ready(struct tty_struct *tty, struct file *filp,
 870         struct isi_port *port)
 871 {
 872         struct isi_board *card = port->card;
 873         int do_clocal = 0, retval;
 874         unsigned long flags;
 875         DECLARE_WAITQUEUE(wait, current);
 876
 877         /* block if port is in the process of being closed */
 878
 879         if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
 880                 pr_dbg("block_til_ready: close in progress.\n");
 881                 interruptible_sleep_on(&port->close_wait);
 882                 if (port->flags & ASYNC_HUP_NOTIFY)
 883                         return -EAGAIN;
 884                 else
 885                         return -ERESTARTSYS;
 886         }
 887
 888         /* if non-blocking mode is set ... */
 889
 890         if ((filp->f_flags & O_NONBLOCK) ||
 891                         (tty->flags & (1 << TTY_IO_ERROR))) {
 892                 pr_dbg("block_til_ready: non-block mode.\n");
 893                 port->flags |= ASYNC_NORMAL_ACTIVE;
 894                 return 0;
 895         }
 896
 897         if (C_CLOCAL(tty))
 898                 do_clocal = 1;
 899
 900         /* block waiting for DCD to be asserted, and while
 901                                                 callout dev is busy */
 902         retval = 0;
 903         add_wait_queue(&port->open_wait, &wait);
 904
 905         spin_lock_irqsave(&card->card_lock, flags);
 906         if (!tty_hung_up_p(filp))
 907                 port->count--;
 908         port->blocked_open++;
 909         spin_unlock_irqrestore(&card->card_lock, flags);
 910
 911         while (1) {
 912                 raise_dtr_rts(port);
 913
 914                 set_current_state(TASK_INTERRUPTIBLE);
 915                 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
 916                         if (port->flags & ASYNC_HUP_NOTIFY)
 917                                 retval = -EAGAIN;
 918                         else
 919                                 retval = -ERESTARTSYS;
 920                         break;
 921                 }
 922                 if (!(port->flags & ASYNC_CLOSING) &&
 923                                 (do_clocal || (port->status & ISI_DCD))) {
 924                         break;
 925                 }
 926                 if (signal_pending(current)) {
 927                         retval = -ERESTARTSYS;
 928                         break;
 929                 }
 930                 schedule();
 931         }
 932         set_current_state(TASK_RUNNING);
 933         remove_wait_queue(&port->open_wait, &wait);
 934         spin_lock_irqsave(&card->card_lock, flags);
 935         if (!tty_hung_up_p(filp))
 936                 port->count++;
 937         port->blocked_open--;
 938         spin_unlock_irqrestore(&card->card_lock, flags);
 939         if (retval)
 940                 return retval;
 941         port->flags |= ASYNC_NORMAL_ACTIVE;
 942         return 0;
 943 }
 944
 945 static int isicom_open(struct tty_struct *tty, struct file *filp)
 946 {
 947         struct isi_port *port;
 948         struct isi_board *card;
 949         unsigned int board;
 950         int error, line;
 951
 952         line = tty->index;
 953         if (line < 0 || line > PORT_COUNT-1)
 954                 return -ENODEV;
 955         board = BOARD(line);
 956         card = &isi_card[board];
 957
 958         if (!(card->status & FIRMWARE_LOADED))
 959                 return -ENODEV;
 960
 961         /*  open on a port greater than the port count for the card !!! */
 962         if (line > ((board * 16) + card->port_count - 1))
 963                 return -ENODEV;
 964
 965         port = &isi_ports[line];
 966         if (isicom_paranoia_check(port, tty->name, "isicom_open"))
 967                 return -ENODEV;
 968
 969         isicom_setup_board(card);
 970
 971         port->count++;
 972         tty->driver_data = port;
 973         port->tty = tty;
 974         if ((error = isicom_setup_port(port))!=0)
 975                 return error;
 976         if ((error = block_til_ready(tty, filp, port))!=0)
 977                 return error;
 978
 979         return 0;
 980 }
 981
 982 /* close et all */
 983
 984 static inline void isicom_shutdown_board(struct isi_board *bp)
 985 {
 986         unsigned long flags;
 987
 988         spin_lock_irqsave(&bp->card_lock, flags);
 989         if (bp->status & BOARD_ACTIVE) {
 990                 bp->status &= ~BOARD_ACTIVE;
 991         }
 992         spin_unlock_irqrestore(&bp->card_lock, flags);
 993 }
 994
 995 static void isicom_shutdown_port(struct isi_port *port)
 996 {
 997         struct isi_board *card = port->card;
 998         struct tty_struct *tty;
 999         unsigned long flags;
1000
1001         tty = port->tty;
1002
1003         spin_lock_irqsave(&card->card_lock, flags);
1004         if (!(port->flags & ASYNC_INITIALIZED)) {
1005                 spin_unlock_irqrestore(&card->card_lock, flags);
1006                 return;
1007         }
1008         if (port->xmit_buf) {
1009                 free_page((unsigned long) port->xmit_buf);
1010                 port->xmit_buf = NULL;
1011         }
1012         port->flags &= ~ASYNC_INITIALIZED;
1013         /* 3rd October 2000 : Vinayak P Risbud */
1014         port->tty = NULL;
1015         spin_unlock_irqrestore(&card->card_lock, flags);
1016
1017         /*Fix done by Anil .S on 30-04-2001
1018         remote login through isi port has dtr toggle problem
1019         due to which the carrier drops before the password prompt
1020         appears on the remote end. Now we drop the dtr only if the
1021         HUPCL(Hangup on close) flag is set for the tty*/
1022
1023         if (C_HUPCL(tty))
1024                 /* drop dtr on this port */
1025                 drop_dtr(port);
1026
1027         /* any other port uninits  */
1028         if (tty)
1029                 set_bit(TTY_IO_ERROR, &tty->flags);
1030
1031         if (--card->count < 0) {
1032                 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
1033                         card->base, card->count);
1034                 card->count = 0;
1035         }
1036
1037         /* last port was closed, shutdown that boad too */
1038         if (C_HUPCL(tty)) {
1039                 if (!card->count)
1040                         isicom_shutdown_board(card);
1041         }
1042 }
1043
1044 static void isicom_close(struct tty_struct *tty, struct file *filp)
1045 {
1046         struct isi_port *port = tty->driver_data;
1047         struct isi_board *card;
1048         unsigned long flags;
1049
1050         if (!port)
1051                 return;
1052         card = port->card;
1053         if (isicom_paranoia_check(port, tty->name, "isicom_close"))
1054                 return;
1055
1056         pr_dbg("Close start!!!.\n");
1057
1058         spin_lock_irqsave(&card->card_lock, flags);
1059         if (tty_hung_up_p(filp)) {
1060                 spin_unlock_irqrestore(&card->card_lock, flags);
1061                 return;
1062         }
1063
1064         if (tty->count == 1 && port->count != 1) {
1065                 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1066                         "count tty->count = 1 port count = %d.\n",
1067                         card->base, port->count);
1068                 port->count = 1;
1069         }
1070         if (--port->count < 0) {
1071                 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1072                         "count for channel%d = %d", card->base, port->channel,
1073                         port->count);
1074                 port->count = 0;
1075         }
1076
1077         if (port->count) {
1078                 spin_unlock_irqrestore(&card->card_lock, flags);
1079                 return;
1080         }
1081         port->flags |= ASYNC_CLOSING;
1082         tty->closing = 1;
1083         spin_unlock_irqrestore(&card->card_lock, flags);
1084
1085         if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1086                 tty_wait_until_sent(tty, port->closing_wait);
1087         /* indicate to the card that no more data can be received
1088            on this port */
1089         spin_lock_irqsave(&card->card_lock, flags);
1090         if (port->flags & ASYNC_INITIALIZED) {
1091                 card->port_status &= ~(1 << port->channel);
1092                 outw(card->port_status, card->base + 0x02);
1093         }
1094         isicom_shutdown_port(port);
1095         spin_unlock_irqrestore(&card->card_lock, flags);
1096
1097         if (tty->driver->flush_buffer)
1098                 tty->driver->flush_buffer(tty);
1099         tty_ldisc_flush(tty);
1100
1101         spin_lock_irqsave(&card->card_lock, flags);
1102         tty->closing = 0;
1103
1104         if (port->blocked_open) {
1105                 spin_unlock_irqrestore(&card->card_lock, flags);
1106                 if (port->close_delay) {
1107                         pr_dbg("scheduling until time out.\n");
1108                         msleep_interruptible(
1109                                 jiffies_to_msecs(port->close_delay));
1110                 }
1111                 spin_lock_irqsave(&card->card_lock, flags);
1112                 wake_up_interruptible(&port->open_wait);
1113         }
1114         port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1115         wake_up_interruptible(&port->close_wait);
1116         spin_unlock_irqrestore(&card->card_lock, flags);
1117 }
1118
1119 /* write et all */
1120 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1121         int count)
1122 {
1123         struct isi_port *port = tty->driver_data;
1124         struct isi_board *card = port->card;
1125         unsigned long flags;
1126         int cnt, total = 0;
1127
1128         if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1129                 return 0;
1130
1131         if (!port->xmit_buf)
1132                 return 0;
1133
1134         spin_lock_irqsave(&card->card_lock, flags);
1135
1136         while(1) {
1137                 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
1138                                 - 1, SERIAL_XMIT_SIZE - port->xmit_head));
1139                 if (cnt <= 0)
1140                         break;
1141
1142                 memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
1143                 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
1144                         - 1);
1145                 port->xmit_cnt += cnt;
1146                 buf += cnt;
1147                 count -= cnt;
1148                 total += cnt;
1149         }
1150         if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1151                 port->status |= ISI_TXOK;
1152         spin_unlock_irqrestore(&card->card_lock, flags);
1153         return total;
1154 }
1155
1156 /* put_char et all */
1157 static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
1158 {
1159         struct isi_port *port = tty->driver_data;
1160         struct isi_board *card = port->card;
1161         unsigned long flags;
1162
1163         if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1164                 return;
1165
1166         if (!port->xmit_buf)
1167                 return;
1168
1169         spin_lock_irqsave(&card->card_lock, flags);
1170         if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1171                 spin_unlock_irqrestore(&card->card_lock, flags);
1172                 return;
1173         }
1174
1175         port->xmit_buf[port->xmit_head++] = ch;
1176         port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1177         port->xmit_cnt++;
1178         spin_unlock_irqrestore(&card->card_lock, flags);
1179 }
1180
1181 /* flush_chars et all */
1182 static void isicom_flush_chars(struct tty_struct *tty)
1183 {
1184         struct isi_port *port = tty->driver_data;
1185
1186         if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1187                 return;
1188
1189         if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1190                         !port->xmit_buf)
1191                 return;
1192
1193         /* this tells the transmitter to consider this port for
1194            data output to the card ... that's the best we can do. */
1195         port->status |= ISI_TXOK;
1196 }
1197
1198 /* write_room et all */
1199 static int isicom_write_room(struct tty_struct *tty)
1200 {
1201         struct isi_port *port = tty->driver_data;
1202         int free;
1203
1204         if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1205                 return 0;
1206
1207         free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1208         if (free < 0)
1209                 free = 0;
1210         return free;
1211 }
1212
1213 /* chars_in_buffer et all */
1214 static int isicom_chars_in_buffer(struct tty_struct *tty)
1215 {
1216         struct isi_port *port = tty->driver_data;
1217         if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1218                 return 0;
1219         return port->xmit_cnt;
1220 }
1221
1222 /* ioctl et all */
1223 static inline void isicom_send_break(struct isi_port *port,
1224         unsigned long length)
1225 {
1226         struct isi_board *card = port->card;
1227         unsigned long base = card->base;
1228
1229         if (!lock_card(card))
1230                 return;
1231
1232         outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1233         outw((length & 0xff) << 8 | 0x00, base);
1234         outw((length & 0xff00), base);
1235         InterruptTheCard(base);
1236
1237         unlock_card(card);
1238 }
1239
1240 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1241 {
1242         struct isi_port *port = tty->driver_data;
1243         /* just send the port status */
1244         u16 status = port->status;
1245
1246         if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1247                 return -ENODEV;
1248
1249         return  ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1250                 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1251                 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1252                 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1253                 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1254                 ((status & ISI_RI ) ? TIOCM_RI  : 0);
1255 }
1256
1257 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1258         unsigned int set, unsigned int clear)
1259 {
1260         struct isi_port *port = tty->driver_data;
1261
1262         if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1263                 return -ENODEV;
1264
1265         if (set & TIOCM_RTS)
1266                 raise_rts(port);
1267         if (set & TIOCM_DTR)
1268                 raise_dtr(port);
1269
1270         if (clear & TIOCM_RTS)
1271                 drop_rts(port);
1272         if (clear & TIOCM_DTR)
1273                 drop_dtr(port);
1274
1275         return 0;
1276 }
1277
1278 static int isicom_set_serial_info(struct isi_port *port,
1279         struct serial_struct __user *info)
1280 {
1281         struct serial_struct newinfo;
1282         int reconfig_port;
1283
1284         if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1285                 return -EFAULT;
1286
1287         reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
1288                 (newinfo.flags & ASYNC_SPD_MASK));
1289
1290         if (!capable(CAP_SYS_ADMIN)) {
1291                 if ((newinfo.close_delay != port->close_delay) ||
1292                                 (newinfo.closing_wait != port->closing_wait) ||
1293                                 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1294                                 (port->flags & ~ASYNC_USR_MASK)))
1295                         return -EPERM;
1296                 port->flags = ((port->flags & ~ ASYNC_USR_MASK) |
1297                                 (newinfo.flags & ASYNC_USR_MASK));
1298         }
1299         else {
1300                 port->close_delay = newinfo.close_delay;
1301                 port->closing_wait = newinfo.closing_wait;
1302                 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1303                                 (newinfo.flags & ASYNC_FLAGS));
1304         }
1305         if (reconfig_port) {
1306                 isicom_config_port(port);
1307         }
1308         return 0;
1309 }
1310
1311 static int isicom_get_serial_info(struct isi_port *port,
1312         struct serial_struct __user *info)
1313 {
1314         struct serial_struct out_info;
1315
1316         memset(&out_info, 0, sizeof(out_info));
1317 /*      out_info.type = ? */
1318         out_info.line = port - isi_ports;
1319         out_info.port = port->card->base;
1320         out_info.irq = port->card->irq;
1321         out_info.flags = port->flags;
1322 /*      out_info.baud_base = ? */
1323         out_info.close_delay = port->close_delay;
1324         out_info.closing_wait = port->closing_wait;
1325         if (copy_to_user(info, &out_info, sizeof(out_info)))
1326                 return -EFAULT;
1327         return 0;
1328 }
1329
1330 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1331         unsigned int cmd, unsigned long arg)
1332 {
1333         struct isi_port *port = tty->driver_data;
1334         void __user *argp = (void __user *)arg;
1335         int retval;
1336
1337         if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1338                 return -ENODEV;
1339
1340         switch(cmd) {
1341         case TCSBRK:
1342                 retval = tty_check_change(tty);
1343                 if (retval)
1344                         return retval;
1345                 tty_wait_until_sent(tty, 0);
1346                 if (!arg)
1347                         isicom_send_break(port, HZ/4);
1348                 return 0;
1349
1350         case TCSBRKP:
1351                 retval = tty_check_change(tty);
1352                 if (retval)
1353                         return retval;
1354                 tty_wait_until_sent(tty, 0);
1355                 isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
1356                 return 0;
1357
1358         case TIOCGSOFTCAR:
1359                 return put_user(C_CLOCAL(tty) ? 1 : 0,
1360                                 (unsigned long __user *)argp);
1361
1362         case TIOCSSOFTCAR:
1363                 if (get_user(arg, (unsigned long __user *) argp))
1364                         return -EFAULT;
1365                 tty->termios->c_cflag =
1366                         ((tty->termios->c_cflag & ~CLOCAL) |
1367                         (arg ? CLOCAL : 0));
1368                 return 0;
1369
1370         case TIOCGSERIAL:
1371                 return isicom_get_serial_info(port, argp);
1372
1373         case TIOCSSERIAL:
1374                 return isicom_set_serial_info(port, argp);
1375
1376         default:
1377                 return -ENOIOCTLCMD;
1378         }
1379         return 0;
1380 }
1381
1382 /* set_termios et all */
1383 static void isicom_set_termios(struct tty_struct *tty,
1384         struct ktermios *old_termios)
1385 {
1386         struct isi_port *port = tty->driver_data;
1387
1388         if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1389                 return;
1390
1391         if (tty->termios->c_cflag == old_termios->c_cflag &&
1392                         tty->termios->c_iflag == old_termios->c_iflag)
1393                 return;
1394
1395         isicom_config_port(port);
1396
1397         if ((old_termios->c_cflag & CRTSCTS) &&
1398                         !(tty->termios->c_cflag & CRTSCTS)) {
1399                 tty->hw_stopped = 0;
1400                 isicom_start(tty);
1401         }
1402 }
1403
1404 /* throttle et all */
1405 static void isicom_throttle(struct tty_struct *tty)
1406 {
1407         struct isi_port *port = tty->driver_data;
1408         struct isi_board *card = port->card;
1409
1410         if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1411                 return;
1412
1413         /* tell the card that this port cannot handle any more data for now */
1414         card->port_status &= ~(1 << port->channel);
1415         outw(card->port_status, card->base + 0x02);
1416 }
1417
1418 /* unthrottle et all */
1419 static void isicom_unthrottle(struct tty_struct *tty)
1420 {
1421         struct isi_port *port = tty->driver_data;
1422         struct isi_board *card = port->card;
1423
1424         if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1425                 return;
1426
1427         /* tell the card that this port is ready to accept more data */
1428         card->port_status |= (1 << port->channel);
1429         outw(card->port_status, card->base + 0x02);
1430 }
1431
1432 /* stop et all */
1433 static void isicom_stop(struct tty_struct *tty)
1434 {
1435         struct isi_port *port = tty->driver_data;
1436
1437         if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1438                 return;
1439
1440         /* this tells the transmitter not to consider this port for
1441            data output to the card. */
1442         port->status &= ~ISI_TXOK;
1443 }
1444
1445 /* start et all */
1446 static void isicom_start(struct tty_struct *tty)
1447 {
1448         struct isi_port *port = tty->driver_data;
1449
1450         if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1451                 return;
1452
1453         /* this tells the transmitter to consider this port for
1454            data output to the card. */
1455         port->status |= ISI_TXOK;
1456 }
1457
1458 /* hangup et all */
1459 static void do_isicom_hangup(struct work_struct *work)
1460 {
1461         struct isi_port *port = container_of(work, struct isi_port, hangup_tq);
1462         struct tty_struct *tty;
1463
1464         tty = port->tty;
1465         if (tty)
1466                 tty_hangup(tty);
1467 }
1468
1469 static void isicom_hangup(struct tty_struct *tty)
1470 {
1471         struct isi_port *port = tty->driver_data;
1472
1473         if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1474                 return;
1475
1476         isicom_shutdown_port(port);
1477         port->count = 0;
1478         port->flags &= ~ASYNC_NORMAL_ACTIVE;
1479         port->tty = NULL;
1480         wake_up_interruptible(&port->open_wait);
1481 }
1482
1483 /* flush_buffer et all */
1484 static void isicom_flush_buffer(struct tty_struct *tty)
1485 {
1486         struct isi_port *port = tty->driver_data;
1487         struct isi_board *card = port->card;
1488         unsigned long flags;
1489
1490         if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
1491                 return;
1492
1493         spin_lock_irqsave(&card->card_lock, flags);
1494         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1495         spin_unlock_irqrestore(&card->card_lock, flags);
1496
1497         wake_up_interruptible(&tty->write_wait);
1498         tty_wakeup(tty);
1499 }
1500
1501 /*
1502  * Driver init and deinit functions
1503  */
1504
1505 static const struct tty_operations isicom_ops = {
1506         .open                   = isicom_open,
1507         .close                  = isicom_close,
1508         .write                  = isicom_write,
1509         .put_char               = isicom_put_char,
1510         .flush_chars            = isicom_flush_chars,
1511         .write_room             = isicom_write_room,
1512         .chars_in_buffer        = isicom_chars_in_buffer,
1513         .ioctl                  = isicom_ioctl,
1514         .set_termios            = isicom_set_termios,
1515         .throttle               = isicom_throttle,
1516         .unthrottle             = isicom_unthrottle,
1517         .stop                   = isicom_stop,
1518         .start                  = isicom_start,
1519         .hangup                 = isicom_hangup,
1520         .flush_buffer           = isicom_flush_buffer,
1521         .tiocmget               = isicom_tiocmget,
1522         .tiocmset               = isicom_tiocmset,
1523 };
1524
1525 static int __devinit reset_card(struct pci_dev *pdev,
1526         const unsigned int card, unsigned int *signature)
1527 {
1528         struct isi_board *board = pci_get_drvdata(pdev);
1529         unsigned long base = board->base;
1530         unsigned int portcount = 0;
1531         int retval = 0;
1532
1533         dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1534                 base);
1535
1536         inw(base + 0x8);
1537
1538         mdelay(10);
1539
1540         outw(0, base + 0x8); /* Reset */
1541
1542         msleep(3000);
1543
1544         *signature = inw(base + 0x4) & 0xff;
1545
1546         portcount = inw(base + 0x2);
1547         if (!(inw(base + 0xe) & 0x1) || ((portcount != 0) &&
1548                         (portcount != 4) && (portcount != 8))) {
1549                 dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
1550                         inw(base + 0x2), inw(base + 0xe));
1551                 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure "
1552                         "(Possible bad I/O Port Address 0x%lx).\n",
1553                         card + 1, base);
1554                 retval = -EIO;
1555                 goto end;
1556         }
1557
1558         switch (*signature) {
1559         case 0xa5:
1560         case 0xbb:
1561         case 0xdd:
1562                 board->port_count = (portcount == 4) ? 4 : 8;
1563                 board->shift_count = 12;
1564                 break;
1565         case 0xcc:
1566                 board->port_count = 16;
1567                 board->shift_count = 11;
1568                 break;
1569         default:
1570                 dev_warn(&pdev->dev, "ISILoad:Card%d reset failure (Possible "
1571                         "bad I/O Port Address 0x%lx).\n", card + 1, base);
1572                 dev_dbg(&pdev->dev, "Sig=0x%lx\n", signature);
1573                 retval = -EIO;
1574         }
1575         dev_info(&pdev->dev, "-Done\n");
1576
1577 end:
1578         return retval;
1579 }
1580
1581 static inline int WaitTillCardIsFree(u16 base)
1582 {
1583         unsigned long count = 0;
1584
1585         while (!(inw(base + 0xe) & 0x1) && count++ < 100)
1586                 msleep(5);
1587
1588         return !(inw(base + 0xe) & 0x1);
1589 }
1590
1591 static int __devinit load_firmware(struct pci_dev *pdev,
1592         const unsigned int index, const unsigned int signature)
1593 {
1594         struct isi_board *board = pci_get_drvdata(pdev);
1595         const struct firmware *fw;
1596         unsigned long base = board->base;
1597         unsigned int a;
1598         u16 word_count, status;
1599         int retval = -EIO;
1600         char *name;
1601         u8 *data;
1602
1603         struct stframe {
1604                 u16     addr;
1605                 u16     count;
1606                 u8      data[0];
1607         } *frame;
1608
1609         switch (signature) {
1610         case 0xa5:
1611                 name = "isi608.bin";
1612                 break;
1613         case 0xbb:
1614                 name = "isi608em.bin";
1615                 break;
1616         case 0xcc:
1617                 name = "isi616em.bin";
1618                 break;
1619         case 0xdd:
1620                 name = "isi4608.bin";
1621                 break;
1622         case 0xee:
1623                 name = "isi4616.bin";
1624                 break;
1625         default:
1626                 dev_err(&pdev->dev, "Unknown signature.\n");
1627                 goto end;
1628         }
1629
1630         retval = request_firmware(&fw, name, &pdev->dev);
1631         if (retval)
1632                 goto end;
1633
1634         retval = -EIO;
1635
1636         for (frame = (struct stframe *)fw->data;
1637                         frame < (struct stframe *)(fw->data + fw->size);
1638                         frame = (struct stframe *)((u8 *)(frame + 1) +
1639                                 frame->count)) {
1640                 if (WaitTillCardIsFree(base))
1641                         goto errrelfw;
1642
1643                 outw(0xf0, base);       /* start upload sequence */
1644                 outw(0x00, base);
1645                 outw(frame->addr, base); /* lsb of address */
1646
1647                 word_count = frame->count / 2 + frame->count % 2;
1648                 outw(word_count, base);
1649                 InterruptTheCard(base);
1650
1651                 udelay(100); /* 0x2f */
1652
1653                 if (WaitTillCardIsFree(base))
1654                         goto errrelfw;
1655
1656                 if ((status = inw(base + 0x4)) != 0) {
1657                         dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1658                                 "Address:0x%x\nCount:0x%x\nStatus:0x%x\n",
1659                                 index + 1, frame->addr, frame->count, status);
1660                         goto errrelfw;
1661                 }
1662                 outsw(base, frame->data, word_count);
1663
1664                 InterruptTheCard(base);
1665
1666                 udelay(50); /* 0x0f */
1667
1668                 if (WaitTillCardIsFree(base))
1669                         goto errrelfw;
1670
1671                 if ((status = inw(base + 0x4)) != 0) {
1672                         dev_err(&pdev->dev, "Card%d got out of sync.Card "
1673                                 "Status:0x%x\n", index + 1, status);
1674                         goto errrelfw;
1675                 }
1676         }
1677
1678 /* XXX: should we test it by reading it back and comparing with original like
1679  * in load firmware package? */
1680         for (frame = (struct stframe *)fw->data;
1681                         frame < (struct stframe *)(fw->data + fw->size);
1682                         frame = (struct stframe *)((u8 *)(frame + 1) +
1683                                 frame->count)) {
1684                 if (WaitTillCardIsFree(base))
1685                         goto errrelfw;
1686
1687                 outw(0xf1, base); /* start download sequence */
1688                 outw(0x00, base);
1689                 outw(frame->addr, base); /* lsb of address */
1690
1691                 word_count = (frame->count >> 1) + frame->count % 2;
1692                 outw(word_count + 1, base);
1693                 InterruptTheCard(base);
1694
1695                 udelay(50); /* 0xf */
1696
1697                 if (WaitTillCardIsFree(base))
1698                         goto errrelfw;
1699
1700                 if ((status = inw(base + 0x4)) != 0) {
1701                         dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1702                                 "Address:0x%x\nCount:0x%x\nStatus: 0x%x\n",
1703                                 index + 1, frame->addr, frame->count, status);
1704                         goto errrelfw;
1705                 }
1706
1707                 data = kmalloc(word_count * 2, GFP_KERNEL);
1708                 if (data == NULL) {
1709                         dev_err(&pdev->dev, "Card%d, firmware upload "
1710                                 "failed, not enough memory\n", index + 1);
1711                         goto errrelfw;
1712                 }
1713                 inw(base);
1714                 insw(base, data, word_count);
1715                 InterruptTheCard(base);
1716
1717                 for (a = 0; a < frame->count; a++)
1718                         if (data[a] != frame->data[a]) {
1719                                 kfree(data);
1720                                 dev_err(&pdev->dev, "Card%d, firmware upload "
1721                                         "failed\n", index + 1);
1722                                 goto errrelfw;
1723                         }
1724                 kfree(data);
1725
1726                 udelay(50); /* 0xf */
1727
1728                 if (WaitTillCardIsFree(base))
1729                         goto errrelfw;
1730
1731                 if ((status = inw(base + 0x4)) != 0) {
1732                         dev_err(&pdev->dev, "Card%d verify got out of sync. "
1733                                 "Card Status:0x%x\n", index + 1, status);
1734                         goto errrelfw;
1735                 }
1736         }
1737
1738         /* xfer ctrl */
1739         if (WaitTillCardIsFree(base))
1740                 goto errrelfw;
1741
1742         outw(0xf2, base);
1743         outw(0x800, base);
1744         outw(0x0, base);
1745         outw(0x0, base);
1746         InterruptTheCard(base);
1747         outw(0x0, base + 0x4); /* for ISI4608 cards */
1748
1749         board->status |= FIRMWARE_LOADED;
1750         retval = 0;
1751
1752 errrelfw:
1753         release_firmware(fw);
1754 end:
1755         return retval;
1756 }
1757
1758 /*
1759  *      Insmod can set static symbols so keep these static
1760  */
1761 static int card;
1762
1763 static int __devinit isicom_probe(struct pci_dev *pdev,
1764         const struct pci_device_id *ent)
1765 {
1766         unsigned int ioaddr, signature, index;
1767         int retval = -EPERM;
1768         u8 pciirq;
1769         struct isi_board *board = NULL;
1770
1771         if (card >= BOARD_COUNT)
1772                 goto err;
1773
1774         ioaddr = pci_resource_start(pdev, 3);
1775         /* i.e at offset 0x1c in the PCI configuration register space. */
1776         pciirq = pdev->irq;
1777         dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1778
1779         /* allot the first empty slot in the array */
1780         for (index = 0; index < BOARD_COUNT; index++)
1781                 if (isi_card[index].base == 0) {
1782                         board = &isi_card[index];
1783                         break;
1784                 }
1785
1786         board->index = index;
1787         board->base = ioaddr;
1788         board->irq = pciirq;
1789         card++;
1790
1791         pci_set_drvdata(pdev, board);
1792
1793         retval = pci_request_region(pdev, 3, ISICOM_NAME);
1794         if (retval) {
1795                 dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1796                         "will be disabled.\n", board->base, board->base + 15,
1797                         index + 1);
1798                 retval = -EBUSY;
1799                 goto err;
1800         }
1801
1802         retval = request_irq(board->irq, isicom_interrupt,
1803                         IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
1804         if (retval < 0) {
1805                 dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1806                         "Card%d will be disabled.\n", board->irq, index + 1);
1807                 goto errunrr;
1808         }
1809
1810         retval = reset_card(pdev, index, &signature);
1811         if (retval < 0)
1812                 goto errunri;
1813
1814         retval = load_firmware(pdev, index, signature);
1815         if (retval < 0)
1816                 goto errunri;
1817
1818         for (index = 0; index < board->port_count; index++)
1819                 tty_register_device(isicom_normal, board->index * 16 + index,
1820                                 &pdev->dev);
1821
1822         return 0;
1823
1824 errunri:
1825         free_irq(board->irq, board);
1826 errunrr:
1827         pci_release_region(pdev, 3);
1828 err:
1829         board->base = 0;
1830         return retval;
1831 }
1832
1833 static void __devexit isicom_remove(struct pci_dev *pdev)
1834 {
1835         struct isi_board *board = pci_get_drvdata(pdev);
1836         unsigned int i;
1837
1838         for (i = 0; i < board->port_count; i++)
1839                 tty_unregister_device(isicom_normal, board->index * 16 + i);
1840
1841         free_irq(board->irq, board);
1842         pci_release_region(pdev, 3);
1843 }
1844
1845 static int __init isicom_init(void)
1846 {
1847         int retval, idx, channel;
1848         struct isi_port *port;
1849
1850         card = 0;
1851
1852         for(idx = 0; idx < BOARD_COUNT; idx++) {
1853                 port = &isi_ports[idx * 16];
1854                 isi_card[idx].ports = port;
1855                 spin_lock_init(&isi_card[idx].card_lock);
1856                 for (channel = 0; channel < 16; channel++, port++) {
1857                         port->magic = ISICOM_MAGIC;
1858                         port->card = &isi_card[idx];
1859                         port->channel = channel;
1860                         port->close_delay = 50 * HZ/100;
1861                         port->closing_wait = 3000 * HZ/100;
1862                         INIT_WORK(&port->hangup_tq, do_isicom_hangup);
1863                         INIT_WORK(&port->bh_tqueue, isicom_bottomhalf);
1864                         port->status = 0;
1865                         init_waitqueue_head(&port->open_wait);
1866                         init_waitqueue_head(&port->close_wait);
1867                         /*  . . .  */
1868                 }
1869                 isi_card[idx].base = 0;
1870                 isi_card[idx].irq = 0;
1871         }
1872
1873         /* tty driver structure initialization */
1874         isicom_normal = alloc_tty_driver(PORT_COUNT);
1875         if (!isicom_normal) {
1876                 retval = -ENOMEM;
1877                 goto error;
1878         }
1879
1880         isicom_normal->owner                    = THIS_MODULE;
1881         isicom_normal->name                     = "ttyM";
1882         isicom_normal->major                    = ISICOM_NMAJOR;
1883         isicom_normal->minor_start              = 0;
1884         isicom_normal->type                     = TTY_DRIVER_TYPE_SERIAL;
1885         isicom_normal->subtype                  = SERIAL_TYPE_NORMAL;
1886         isicom_normal->init_termios             = tty_std_termios;
1887         isicom_normal->init_termios.c_cflag     = B9600 | CS8 | CREAD | HUPCL |
1888                 CLOCAL;
1889         isicom_normal->flags                    = TTY_DRIVER_REAL_RAW |
1890                 TTY_DRIVER_DYNAMIC_DEV;
1891         tty_set_operations(isicom_normal, &isicom_ops);
1892
1893         retval = tty_register_driver(isicom_normal);
1894         if (retval) {
1895                 pr_dbg("Couldn't register the dialin driver\n");
1896                 goto err_puttty;
1897         }
1898
1899         retval = pci_register_driver(&isicom_driver);
1900         if (retval < 0) {
1901                 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1902                 goto err_unrtty;
1903         }
1904
1905         mod_timer(&tx, jiffies + 1);
1906
1907         return 0;
1908 err_unrtty:
1909         tty_unregister_driver(isicom_normal);
1910 err_puttty:
1911         put_tty_driver(isicom_normal);
1912 error:
1913         return retval;
1914 }
1915
1916 static void __exit isicom_exit(void)
1917 {
1918         re_schedule = 0;
1919
1920         wait_for_completion_timeout(&isi_timerdone, HZ);
1921
1922         pci_unregister_driver(&isicom_driver);
1923         tty_unregister_driver(isicom_normal);
1924         put_tty_driver(isicom_normal);
1925 }
1926
1927 module_init(isicom_init);
1928 module_exit(isicom_exit);
1929
1930 MODULE_AUTHOR("MultiTech");
1931 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1932 MODULE_LICENSE("GPL");