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