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