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