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