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.
7 * Original driver code supplied by Multi-Tech
10 * 1/9/98 alan@redhat.com Merge to 2.0.x kernel tree
11 * Obtain and use official major/minors
12 * Loader switched to a misc device
13 * (fixed range check bug as a side effect)
15 * 9/12/98 alan@redhat.com Rough port to 2.1.x
17 * 10/6/99 sameer Merged the ISA and PCI drivers to
18 * a new unified driver.
20 * 3/9/99 sameer Added support for ISI4616 cards.
22 * 16/9/99 sameer We do not force RTS low anymore.
23 * This is to prevent the firmware
24 * from getting confused.
26 * 26/10/99 sameer Cosmetic changes:The driver now
27 * dumps the Port Count information
28 * along with I/O address and IRQ.
30 * 13/12/99 sameer Fixed the problem with IRQ sharing.
32 * 10/5/00 sameer Fixed isicom_shutdown_board()
33 * to not lower DTR on all the ports
34 * when the last port on the card is
37 * 10/5/00 sameer Signal mask setup command added
38 * to isicom_setup_port and
39 * isicom_shutdown_port.
41 * 24/5/00 sameer The driver is now SMP aware.
44 * 27/11/00 Vinayak P Risbud Fixed the Driver Crash Problem
47 * 03/01/01 anil .s Added support for resetting the
48 * internal modems on ISI cards.
50 * 08/02/01 anil .s Upgraded the driver for kernel
53 * 11/04/01 Kevin Fixed firmware load problem with
56 * 30/04/01 anil .s Fixed the remote login through
57 * ISI port problem. Now the link
58 * does not go down before password
61 * 03/05/01 anil .s Fixed the problem with IRQ sharing
62 * among ISI-PCI cards.
64 * 03/05/01 anil .s Added support to display the version
65 * info during insmod as well as module
68 * 10/05/01 anil .s Done the modifications to the source
69 * file and Install script so that the
70 * same installation can be used for
71 * 2.2.x and 2.4.x kernel.
73 * 06/06/01 anil .s Now we drop both dtr and rts during
74 * shutdown_port as well as raise them
75 * during isicom_config_port.
77 * 09/06/01 acme@conectiva.com.br use capable, not suser, do
78 * restore_flags on failure in
79 * isicom_send_break, verify put_user
82 * 11/02/03 ranjeeth Added support for 230 Kbps and 460 Kbps
83 * Baud index extended to 21
85 * 20/03/03 ranjeeth Made to work for Linux Advanced server.
86 * Taken care of license warning.
88 * 10/12/03 Ravindra Made to work for Fedora Core 1 of
89 * Red Hat Distribution
91 * 06/01/05 Alan Cox Merged the ISI and base kernel strands
92 * into a single 2.6 driver
94 * ***********************************************************
96 * To use this driver you also need the support package. You
97 * can find this in RPM format on
98 * ftp://ftp.linux.org.uk/pub/linux/alan
100 * You can find the original tools for this direct from Multitech
101 * ftp://ftp.multitech.com/ISI-Cards/
103 * Having installed the cards the module options (/etc/modprobe.conf)
105 * options isicom io=card1,card2,card3,card4 irq=card1,card2,card3,card4
107 * Omit those entries for boards you don't have installed.
111 * 64-bit verification
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>
129 #include <asm/uaccess.h>
131 #include <asm/system.h>
133 #include <linux/pci.h>
135 #include <linux/isicom.h>
137 #define InterruptTheCard(base) outw(0, (base) + 0xc)
138 #define ClearInterrupt(base) inw((base) + 0x0a)
141 #define pr_dbg(str...) printk(KERN_DEBUG "ISICOM: " str)
142 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
144 #define pr_dbg(str...) do { } while (0)
145 #define isicom_paranoia_check(a, b, c) 0
148 static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
149 static void __devexit isicom_remove(struct pci_dev *);
151 static struct pci_device_id isicom_pci_tbl[] = {
152 { PCI_DEVICE(VENDOR_ID, 0x2028) },
153 { PCI_DEVICE(VENDOR_ID, 0x2051) },
154 { PCI_DEVICE(VENDOR_ID, 0x2052) },
155 { PCI_DEVICE(VENDOR_ID, 0x2053) },
156 { PCI_DEVICE(VENDOR_ID, 0x2054) },
157 { PCI_DEVICE(VENDOR_ID, 0x2055) },
158 { PCI_DEVICE(VENDOR_ID, 0x2056) },
159 { PCI_DEVICE(VENDOR_ID, 0x2057) },
160 { PCI_DEVICE(VENDOR_ID, 0x2058) },
163 MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
165 static struct pci_driver isicom_driver = {
167 .id_table = isicom_pci_tbl,
168 .probe = isicom_probe,
169 .remove = __devexit_p(isicom_remove)
172 static int prev_card = 3; /* start servicing isi_card[0] */
173 static struct tty_driver *isicom_normal;
175 static DECLARE_COMPLETION(isi_timerdone);
176 static char re_schedule = 1;
178 static void isicom_tx(unsigned long _data);
179 static void isicom_start(struct tty_struct *tty);
181 static DEFINE_TIMER(tx, isicom_tx, 0, 0);
183 /* baud index mappings from linux defns to isi */
185 static signed char linuxb_to_isib[] = {
186 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19
192 unsigned char port_count;
193 unsigned short status;
194 unsigned short port_status; /* each bit for each port */
195 unsigned short shift_count;
196 struct isi_port * ports;
198 spinlock_t card_lock; /* Card wide lock 11/5/00 -sameer */
204 unsigned short magic;
212 struct isi_board * card;
213 struct tty_struct * tty;
214 wait_queue_head_t close_wait;
215 wait_queue_head_t open_wait;
216 unsigned char * xmit_buf;
222 static struct isi_board isi_card[BOARD_COUNT];
223 static struct isi_port isi_ports[PORT_COUNT];
226 * Locking functions for card level locking. We need to own both
227 * the kernel lock for the card and have the card in a position that
231 static inline int WaitTillCardIsFree(u16 base)
233 unsigned int count = 0;
234 unsigned int a = in_atomic(); /* do we run under spinlock? */
236 while (!(inw(base + 0xe) & 0x1) && count++ < 100)
242 return !(inw(base + 0xe) & 0x1);
245 static int lock_card(struct isi_board *card)
248 unsigned long base = card->base;
250 for (retries = 0; retries < 100; retries++) {
251 spin_lock_irqsave(&card->card_lock, card->flags);
252 if (inw(base + 0xe) & 0x1) {
255 spin_unlock_irqrestore(&card->card_lock, card->flags);
256 udelay(1000); /* 1ms */
259 printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n",
262 return 0; /* Failed to acquire the card! */
265 static int lock_card_at_interrupt(struct isi_board *card)
267 unsigned char retries;
268 unsigned long base = card->base;
270 for (retries = 0; retries < 200; retries++) {
271 spin_lock_irqsave(&card->card_lock, card->flags);
273 if (inw(base + 0xe) & 0x1)
276 spin_unlock_irqrestore(&card->card_lock, card->flags);
278 /* Failing in interrupt is an acceptable event */
279 return 0; /* Failed to acquire the card! */
282 static void unlock_card(struct isi_board *card)
284 spin_unlock_irqrestore(&card->card_lock, card->flags);
288 * ISI Card specific ops ...
291 /* card->lock HAS to be held */
292 static void raise_dtr(struct isi_port *port)
294 struct isi_board *card = port->card;
295 unsigned long base = card->base;
296 u16 channel = port->channel;
298 if (WaitTillCardIsFree(base))
301 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
303 InterruptTheCard(base);
304 port->status |= ISI_DTR;
307 /* card->lock HAS to be held */
308 static inline void drop_dtr(struct isi_port *port)
310 struct isi_board *card = port->card;
311 unsigned long base = card->base;
312 u16 channel = port->channel;
314 if (WaitTillCardIsFree(base))
317 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
319 InterruptTheCard(base);
320 port->status &= ~ISI_DTR;
323 /* card->lock HAS to be held */
324 static inline void raise_rts(struct isi_port *port)
326 struct isi_board *card = port->card;
327 unsigned long base = card->base;
328 u16 channel = port->channel;
330 if (WaitTillCardIsFree(base))
333 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
335 InterruptTheCard(base);
336 port->status |= ISI_RTS;
339 /* card->lock HAS to be held */
340 static inline void drop_rts(struct isi_port *port)
342 struct isi_board *card = port->card;
343 unsigned long base = card->base;
344 u16 channel = port->channel;
346 if (WaitTillCardIsFree(base))
349 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
351 InterruptTheCard(base);
352 port->status &= ~ISI_RTS;
355 /* card->lock MUST NOT be held */
356 static inline void raise_dtr_rts(struct isi_port *port)
358 struct isi_board *card = port->card;
359 unsigned long base = card->base;
360 u16 channel = port->channel;
362 if (!lock_card(card))
365 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
367 InterruptTheCard(base);
368 port->status |= (ISI_DTR | ISI_RTS);
372 /* card->lock HAS to be held */
373 static void drop_dtr_rts(struct isi_port *port)
375 struct isi_board *card = port->card;
376 unsigned long base = card->base;
377 u16 channel = port->channel;
379 if (WaitTillCardIsFree(base))
382 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
384 InterruptTheCard(base);
385 port->status &= ~(ISI_RTS | ISI_DTR);
389 * ISICOM Driver specific routines ...
393 static inline int __isicom_paranoia_check(struct isi_port const *port,
394 char *name, const char *routine)
397 printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
398 "dev %s in %s.\n", name, routine);
401 if (port->magic != ISICOM_MAGIC) {
402 printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
403 "dev %s in %s.\n", name, routine);
413 * We shovel data into the card buffers on a regular basis. The card
414 * will do the rest of the work for us.
417 static void isicom_tx(unsigned long _data)
419 short count = (BOARD_COUNT-1), card, base;
420 short txcount, wrd, residue, word_count, cnt;
421 struct isi_port *port;
422 struct tty_struct *tty;
424 /* find next active board */
425 card = (prev_card + 1) & 0x0003;
427 if (isi_card[card].status & BOARD_ACTIVE)
429 card = (card + 1) & 0x0003;
431 if (!(isi_card[card].status & BOARD_ACTIVE))
436 count = isi_card[card].port_count;
437 port = isi_card[card].ports;
438 base = isi_card[card].base;
439 for (;count > 0;count--, port++) {
440 if (!lock_card_at_interrupt(&isi_card[card]))
442 /* port not active or tx disabled to force flow control */
443 if (!(port->flags & ASYNC_INITIALIZED) ||
444 !(port->status & ISI_TXOK))
445 unlock_card(&isi_card[card]);
452 unlock_card(&isi_card[card]);
456 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
457 if (txcount <= 0 || tty->stopped || tty->hw_stopped) {
458 unlock_card(&isi_card[card]);
461 if (!(inw(base + 0x02) & (1 << port->channel))) {
462 unlock_card(&isi_card[card]);
465 pr_dbg("txing %d bytes, port%d.\n", txcount,
467 outw((port->channel << isi_card[card].shift_count) | txcount,
472 cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE
474 if (residue == YES) {
477 wrd |= (port->xmit_buf[port->xmit_tail]
479 port->xmit_tail = (port->xmit_tail + 1)
480 & (SERIAL_XMIT_SIZE - 1);
491 word_count = cnt >> 1;
492 outsw(base, port->xmit_buf+port->xmit_tail,word_count);
493 port->xmit_tail = (port->xmit_tail
494 + (word_count << 1)) & (SERIAL_XMIT_SIZE - 1);
495 txcount -= (word_count << 1);
496 port->xmit_cnt -= (word_count << 1);
499 wrd = port->xmit_buf[port->xmit_tail];
500 port->xmit_tail = (port->xmit_tail + 1)
501 & (SERIAL_XMIT_SIZE - 1);
507 InterruptTheCard(base);
508 if (port->xmit_cnt <= 0)
509 port->status &= ~ISI_TXOK;
510 if (port->xmit_cnt <= WAKEUP_CHARS)
512 unlock_card(&isi_card[card]);
515 /* schedule another tx for hopefully in about 10ms */
518 complete(&isi_timerdone);
522 mod_timer(&tx, jiffies + msecs_to_jiffies(10));
526 * Main interrupt handler routine
529 static irqreturn_t isicom_interrupt(int irq, void *dev_id)
531 struct isi_board *card = dev_id;
532 struct isi_port *port;
533 struct tty_struct *tty;
535 u16 header, word_count, count, channel;
539 if (!card || !(card->status & FIRMWARE_LOADED))
544 /* did the card interrupt us? */
545 if (!(inw(base + 0x0e) & 0x02))
548 spin_lock(&card->card_lock);
551 * disable any interrupts from the PCI card and lower the
554 outw(0x8000, base+0x04);
555 ClearInterrupt(base);
557 inw(base); /* get the dummy word out */
559 channel = (header & 0x7800) >> card->shift_count;
560 byte_count = header & 0xff;
562 if (channel + 1 > card->port_count) {
563 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
564 "%d(channel) > port_count.\n", base, channel+1);
565 outw(0x0000, base+0x04); /* enable interrupts */
566 spin_unlock(&card->card_lock);
569 port = card->ports + channel;
570 if (!(port->flags & ASYNC_INITIALIZED)) {
571 outw(0x0000, base+0x04); /* enable interrupts */
572 spin_unlock(&card->card_lock);
578 word_count = byte_count >> 1;
579 while(byte_count > 1) {
583 if (byte_count & 0x01)
585 outw(0x0000, base+0x04); /* enable interrupts */
586 spin_unlock(&card->card_lock);
590 if (header & 0x8000) { /* Status Packet */
592 switch(header & 0xff) {
593 case 0: /* Change in EIA signals */
594 if (port->flags & ASYNC_CHECK_CD) {
595 if (port->status & ISI_DCD) {
596 if (!(header & ISI_DCD)) {
597 /* Carrier has been lost */
598 pr_dbg("interrupt: DCD->low.\n"
600 port->status &= ~ISI_DCD;
603 } else if (header & ISI_DCD) {
604 /* Carrier has been detected */
605 pr_dbg("interrupt: DCD->high.\n");
606 port->status |= ISI_DCD;
607 wake_up_interruptible(&port->open_wait);
610 if (header & ISI_DCD)
611 port->status |= ISI_DCD;
613 port->status &= ~ISI_DCD;
616 if (port->flags & ASYNC_CTS_FLOW) {
617 if (port->tty->hw_stopped) {
618 if (header & ISI_CTS) {
619 port->tty->hw_stopped = 0;
621 port->status |= (ISI_TXOK
625 } else if (!(header & ISI_CTS)) {
626 port->tty->hw_stopped = 1;
628 port->status &= ~(ISI_TXOK | ISI_CTS);
631 if (header & ISI_CTS)
632 port->status |= ISI_CTS;
634 port->status &= ~ISI_CTS;
637 if (header & ISI_DSR)
638 port->status |= ISI_DSR;
640 port->status &= ~ISI_DSR;
643 port->status |= ISI_RI;
645 port->status &= ~ISI_RI;
649 case 1: /* Received Break !!! */
650 tty_insert_flip_char(tty, 0, TTY_BREAK);
651 if (port->flags & ASYNC_SAK)
653 tty_flip_buffer_push(tty);
656 case 2: /* Statistics */
657 pr_dbg("isicom_interrupt: stats!!!.\n");
661 pr_dbg("Intr: Unknown code in status packet.\n");
664 } else { /* Data Packet */
666 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
667 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
668 word_count = count >> 1;
669 insw(base, rp, word_count);
670 byte_count -= (word_count << 1);
671 if (count & 0x0001) {
672 tty_insert_flip_char(tty, inw(base) & 0xff,
676 if (byte_count > 0) {
677 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
678 "bytes...\n", base, channel + 1);
679 while(byte_count > 0) { /* drain out unread xtra data */
684 tty_flip_buffer_push(tty);
686 outw(0x0000, base+0x04); /* enable interrupts */
687 spin_unlock(&card->card_lock);
692 static void isicom_config_port(struct isi_port *port)
694 struct isi_board *card = port->card;
695 struct tty_struct *tty;
697 unsigned long base = card->base;
698 u16 channel_setup, channel = port->channel,
699 shift_count = card->shift_count;
700 unsigned char flow_ctrl;
702 if (!(tty = port->tty) || !tty->termios)
705 if (baud & CBAUDEX) {
708 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
709 * then the card is programmed for 57.6Kbps or 115Kbps
713 if (baud < 1 || baud > 2)
714 port->tty->termios->c_cflag &= ~CBAUDEX;
720 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
721 * by the set_serial_info ioctl ... this is done by
722 * the 'setserial' utility.
725 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
726 baud++; /* 57.6 Kbps */
727 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
728 baud +=2; /* 115 Kbps */
730 if (linuxb_to_isib[baud] == -1) {
738 if (WaitTillCardIsFree(base) == 0) {
739 outw(0x8000 | (channel << shift_count) |0x03, base);
740 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
742 switch(C_CSIZE(tty)) {
744 channel_setup |= ISICOM_CS5;
747 channel_setup |= ISICOM_CS6;
750 channel_setup |= ISICOM_CS7;
753 channel_setup |= ISICOM_CS8;
758 channel_setup |= ISICOM_2SB;
760 channel_setup |= ISICOM_EVPAR;
762 channel_setup |= ISICOM_ODPAR;
764 outw(channel_setup, base);
765 InterruptTheCard(base);
768 port->flags &= ~ASYNC_CHECK_CD;
770 port->flags |= ASYNC_CHECK_CD;
772 /* flow control settings ...*/
774 port->flags &= ~ASYNC_CTS_FLOW;
775 if (C_CRTSCTS(tty)) {
776 port->flags |= ASYNC_CTS_FLOW;
777 flow_ctrl |= ISICOM_CTSRTS;
780 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
782 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
784 if (WaitTillCardIsFree(base) == 0) {
785 outw(0x8000 | (channel << shift_count) |0x04, base);
786 outw(flow_ctrl << 8 | 0x05, base);
787 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
788 InterruptTheCard(base);
791 /* rx enabled -> enable port for rx on the card */
793 card->port_status |= (1 << channel);
794 outw(card->port_status, base + 0x02);
800 static inline void isicom_setup_board(struct isi_board *bp)
803 struct isi_port *port;
806 spin_lock_irqsave(&bp->card_lock, flags);
807 if (bp->status & BOARD_ACTIVE) {
808 spin_unlock_irqrestore(&bp->card_lock, flags);
812 bp->status |= BOARD_ACTIVE;
813 for (channel = 0; channel < bp->port_count; channel++, port++)
815 spin_unlock_irqrestore(&bp->card_lock, flags);
818 static int isicom_setup_port(struct isi_port *port)
820 struct isi_board *card = port->card;
823 if (port->flags & ASYNC_INITIALIZED) {
826 if (!port->xmit_buf) {
829 if (!(page = get_zeroed_page(GFP_KERNEL)))
832 if (port->xmit_buf) {
836 port->xmit_buf = (unsigned char *) page;
839 spin_lock_irqsave(&card->card_lock, flags);
841 clear_bit(TTY_IO_ERROR, &port->tty->flags);
842 if (port->count == 1)
845 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
847 /* discard any residual data */
848 if (WaitTillCardIsFree(card->base) == 0) {
849 outw(0x8000 | (port->channel << card->shift_count) | 0x02,
851 outw(((ISICOM_KILLTX | ISICOM_KILLRX) << 8) | 0x06, card->base);
852 InterruptTheCard(card->base);
855 isicom_config_port(port);
856 port->flags |= ASYNC_INITIALIZED;
857 spin_unlock_irqrestore(&card->card_lock, flags);
862 static int block_til_ready(struct tty_struct *tty, struct file *filp,
863 struct isi_port *port)
865 struct isi_board *card = port->card;
866 int do_clocal = 0, retval;
868 DECLARE_WAITQUEUE(wait, current);
870 /* block if port is in the process of being closed */
872 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
873 pr_dbg("block_til_ready: close in progress.\n");
874 interruptible_sleep_on(&port->close_wait);
875 if (port->flags & ASYNC_HUP_NOTIFY)
881 /* if non-blocking mode is set ... */
883 if ((filp->f_flags & O_NONBLOCK) ||
884 (tty->flags & (1 << TTY_IO_ERROR))) {
885 pr_dbg("block_til_ready: non-block mode.\n");
886 port->flags |= ASYNC_NORMAL_ACTIVE;
893 /* block waiting for DCD to be asserted, and while
894 callout dev is busy */
896 add_wait_queue(&port->open_wait, &wait);
898 spin_lock_irqsave(&card->card_lock, flags);
899 if (!tty_hung_up_p(filp))
901 port->blocked_open++;
902 spin_unlock_irqrestore(&card->card_lock, flags);
907 set_current_state(TASK_INTERRUPTIBLE);
908 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
909 if (port->flags & ASYNC_HUP_NOTIFY)
912 retval = -ERESTARTSYS;
915 if (!(port->flags & ASYNC_CLOSING) &&
916 (do_clocal || (port->status & ISI_DCD))) {
919 if (signal_pending(current)) {
920 retval = -ERESTARTSYS;
925 set_current_state(TASK_RUNNING);
926 remove_wait_queue(&port->open_wait, &wait);
927 spin_lock_irqsave(&card->card_lock, flags);
928 if (!tty_hung_up_p(filp))
930 port->blocked_open--;
931 spin_unlock_irqrestore(&card->card_lock, flags);
934 port->flags |= ASYNC_NORMAL_ACTIVE;
938 static int isicom_open(struct tty_struct *tty, struct file *filp)
940 struct isi_port *port;
941 struct isi_board *card;
946 if (line < 0 || line > PORT_COUNT-1)
949 card = &isi_card[board];
951 if (!(card->status & FIRMWARE_LOADED))
954 /* open on a port greater than the port count for the card !!! */
955 if (line > ((board * 16) + card->port_count - 1))
958 port = &isi_ports[line];
959 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
962 isicom_setup_board(card);
965 tty->driver_data = port;
967 if ((error = isicom_setup_port(port))!=0)
969 if ((error = block_til_ready(tty, filp, port))!=0)
977 static inline void isicom_shutdown_board(struct isi_board *bp)
979 if (bp->status & BOARD_ACTIVE) {
980 bp->status &= ~BOARD_ACTIVE;
984 /* card->lock HAS to be held */
985 static void isicom_shutdown_port(struct isi_port *port)
987 struct isi_board *card = port->card;
988 struct tty_struct *tty;
992 if (!(port->flags & ASYNC_INITIALIZED))
995 if (port->xmit_buf) {
996 free_page((unsigned long) port->xmit_buf);
997 port->xmit_buf = NULL;
999 port->flags &= ~ASYNC_INITIALIZED;
1000 /* 3rd October 2000 : Vinayak P Risbud */
1003 /*Fix done by Anil .S on 30-04-2001
1004 remote login through isi port has dtr toggle problem
1005 due to which the carrier drops before the password prompt
1006 appears on the remote end. Now we drop the dtr only if the
1007 HUPCL(Hangup on close) flag is set for the tty*/
1010 /* drop dtr on this port */
1013 /* any other port uninits */
1015 set_bit(TTY_IO_ERROR, &tty->flags);
1017 if (--card->count < 0) {
1018 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
1019 card->base, card->count);
1023 /* last port was closed, shutdown that boad too */
1026 isicom_shutdown_board(card);
1030 static void isicom_close(struct tty_struct *tty, struct file *filp)
1032 struct isi_port *port = tty->driver_data;
1033 struct isi_board *card;
1034 unsigned long flags;
1039 if (isicom_paranoia_check(port, tty->name, "isicom_close"))
1042 pr_dbg("Close start!!!.\n");
1044 spin_lock_irqsave(&card->card_lock, flags);
1045 if (tty_hung_up_p(filp)) {
1046 spin_unlock_irqrestore(&card->card_lock, flags);
1050 if (tty->count == 1 && port->count != 1) {
1051 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1052 "count tty->count = 1 port count = %d.\n",
1053 card->base, port->count);
1056 if (--port->count < 0) {
1057 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1058 "count for channel%d = %d", card->base, port->channel,
1064 spin_unlock_irqrestore(&card->card_lock, flags);
1067 port->flags |= ASYNC_CLOSING;
1069 spin_unlock_irqrestore(&card->card_lock, flags);
1071 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1072 tty_wait_until_sent(tty, port->closing_wait);
1073 /* indicate to the card that no more data can be received
1075 spin_lock_irqsave(&card->card_lock, flags);
1076 if (port->flags & ASYNC_INITIALIZED) {
1077 card->port_status &= ~(1 << port->channel);
1078 outw(card->port_status, card->base + 0x02);
1080 isicom_shutdown_port(port);
1081 spin_unlock_irqrestore(&card->card_lock, flags);
1083 if (tty->driver->flush_buffer)
1084 tty->driver->flush_buffer(tty);
1085 tty_ldisc_flush(tty);
1087 spin_lock_irqsave(&card->card_lock, flags);
1090 if (port->blocked_open) {
1091 spin_unlock_irqrestore(&card->card_lock, flags);
1092 if (port->close_delay) {
1093 pr_dbg("scheduling until time out.\n");
1094 msleep_interruptible(
1095 jiffies_to_msecs(port->close_delay));
1097 spin_lock_irqsave(&card->card_lock, flags);
1098 wake_up_interruptible(&port->open_wait);
1100 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1101 wake_up_interruptible(&port->close_wait);
1102 spin_unlock_irqrestore(&card->card_lock, flags);
1106 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1109 struct isi_port *port = tty->driver_data;
1110 struct isi_board *card = port->card;
1111 unsigned long flags;
1114 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1117 if (!port->xmit_buf)
1120 spin_lock_irqsave(&card->card_lock, flags);
1123 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
1124 - 1, SERIAL_XMIT_SIZE - port->xmit_head));
1128 memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
1129 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
1131 port->xmit_cnt += cnt;
1136 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1137 port->status |= ISI_TXOK;
1138 spin_unlock_irqrestore(&card->card_lock, flags);
1142 /* put_char et all */
1143 static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
1145 struct isi_port *port = tty->driver_data;
1146 struct isi_board *card = port->card;
1147 unsigned long flags;
1149 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1152 if (!port->xmit_buf)
1155 spin_lock_irqsave(&card->card_lock, flags);
1156 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1157 spin_unlock_irqrestore(&card->card_lock, flags);
1161 port->xmit_buf[port->xmit_head++] = ch;
1162 port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1164 spin_unlock_irqrestore(&card->card_lock, flags);
1167 /* flush_chars et all */
1168 static void isicom_flush_chars(struct tty_struct *tty)
1170 struct isi_port *port = tty->driver_data;
1172 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1175 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1179 /* this tells the transmitter to consider this port for
1180 data output to the card ... that's the best we can do. */
1181 port->status |= ISI_TXOK;
1184 /* write_room et all */
1185 static int isicom_write_room(struct tty_struct *tty)
1187 struct isi_port *port = tty->driver_data;
1190 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1193 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1199 /* chars_in_buffer et all */
1200 static int isicom_chars_in_buffer(struct tty_struct *tty)
1202 struct isi_port *port = tty->driver_data;
1203 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1205 return port->xmit_cnt;
1209 static inline void isicom_send_break(struct isi_port *port,
1210 unsigned long length)
1212 struct isi_board *card = port->card;
1213 unsigned long base = card->base;
1215 if (!lock_card(card))
1218 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1219 outw((length & 0xff) << 8 | 0x00, base);
1220 outw((length & 0xff00), base);
1221 InterruptTheCard(base);
1226 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1228 struct isi_port *port = tty->driver_data;
1229 /* just send the port status */
1230 u16 status = port->status;
1232 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1235 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1236 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1237 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1238 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1239 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1240 ((status & ISI_RI ) ? TIOCM_RI : 0);
1243 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1244 unsigned int set, unsigned int clear)
1246 struct isi_port *port = tty->driver_data;
1247 unsigned long flags;
1249 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1252 spin_lock_irqsave(&port->card->card_lock, flags);
1253 if (set & TIOCM_RTS)
1255 if (set & TIOCM_DTR)
1258 if (clear & TIOCM_RTS)
1260 if (clear & TIOCM_DTR)
1262 spin_unlock_irqrestore(&port->card->card_lock, flags);
1267 static int isicom_set_serial_info(struct isi_port *port,
1268 struct serial_struct __user *info)
1270 struct serial_struct newinfo;
1273 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1276 reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
1277 (newinfo.flags & ASYNC_SPD_MASK));
1279 if (!capable(CAP_SYS_ADMIN)) {
1280 if ((newinfo.close_delay != port->close_delay) ||
1281 (newinfo.closing_wait != port->closing_wait) ||
1282 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1283 (port->flags & ~ASYNC_USR_MASK)))
1285 port->flags = ((port->flags & ~ ASYNC_USR_MASK) |
1286 (newinfo.flags & ASYNC_USR_MASK));
1289 port->close_delay = newinfo.close_delay;
1290 port->closing_wait = newinfo.closing_wait;
1291 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1292 (newinfo.flags & ASYNC_FLAGS));
1294 if (reconfig_port) {
1295 unsigned long flags;
1296 spin_lock_irqsave(&port->card->card_lock, flags);
1297 isicom_config_port(port);
1298 spin_unlock_irqrestore(&port->card->card_lock, flags);
1303 static int isicom_get_serial_info(struct isi_port *port,
1304 struct serial_struct __user *info)
1306 struct serial_struct out_info;
1308 memset(&out_info, 0, sizeof(out_info));
1309 /* out_info.type = ? */
1310 out_info.line = port - isi_ports;
1311 out_info.port = port->card->base;
1312 out_info.irq = port->card->irq;
1313 out_info.flags = port->flags;
1314 /* out_info.baud_base = ? */
1315 out_info.close_delay = port->close_delay;
1316 out_info.closing_wait = port->closing_wait;
1317 if (copy_to_user(info, &out_info, sizeof(out_info)))
1322 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1323 unsigned int cmd, unsigned long arg)
1325 struct isi_port *port = tty->driver_data;
1326 void __user *argp = (void __user *)arg;
1329 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1334 retval = tty_check_change(tty);
1337 tty_wait_until_sent(tty, 0);
1339 isicom_send_break(port, HZ/4);
1343 retval = tty_check_change(tty);
1346 tty_wait_until_sent(tty, 0);
1347 isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
1351 return put_user(C_CLOCAL(tty) ? 1 : 0,
1352 (unsigned long __user *)argp);
1355 if (get_user(arg, (unsigned long __user *) argp))
1357 tty->termios->c_cflag =
1358 ((tty->termios->c_cflag & ~CLOCAL) |
1359 (arg ? CLOCAL : 0));
1363 return isicom_get_serial_info(port, argp);
1366 return isicom_set_serial_info(port, argp);
1369 return -ENOIOCTLCMD;
1374 /* set_termios et all */
1375 static void isicom_set_termios(struct tty_struct *tty,
1376 struct ktermios *old_termios)
1378 struct isi_port *port = tty->driver_data;
1379 unsigned long flags;
1381 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1384 if (tty->termios->c_cflag == old_termios->c_cflag &&
1385 tty->termios->c_iflag == old_termios->c_iflag)
1388 spin_lock_irqsave(&port->card->card_lock, flags);
1389 isicom_config_port(port);
1390 spin_unlock_irqrestore(&port->card->card_lock, flags);
1392 if ((old_termios->c_cflag & CRTSCTS) &&
1393 !(tty->termios->c_cflag & CRTSCTS)) {
1394 tty->hw_stopped = 0;
1399 /* throttle et all */
1400 static void isicom_throttle(struct tty_struct *tty)
1402 struct isi_port *port = tty->driver_data;
1403 struct isi_board *card = port->card;
1405 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1408 /* tell the card that this port cannot handle any more data for now */
1409 card->port_status &= ~(1 << port->channel);
1410 outw(card->port_status, card->base + 0x02);
1413 /* unthrottle et all */
1414 static void isicom_unthrottle(struct tty_struct *tty)
1416 struct isi_port *port = tty->driver_data;
1417 struct isi_board *card = port->card;
1419 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1422 /* tell the card that this port is ready to accept more data */
1423 card->port_status |= (1 << port->channel);
1424 outw(card->port_status, card->base + 0x02);
1428 static void isicom_stop(struct tty_struct *tty)
1430 struct isi_port *port = tty->driver_data;
1432 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1435 /* this tells the transmitter not to consider this port for
1436 data output to the card. */
1437 port->status &= ~ISI_TXOK;
1441 static void isicom_start(struct tty_struct *tty)
1443 struct isi_port *port = tty->driver_data;
1445 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1448 /* this tells the transmitter to consider this port for
1449 data output to the card. */
1450 port->status |= ISI_TXOK;
1453 static void isicom_hangup(struct tty_struct *tty)
1455 struct isi_port *port = tty->driver_data;
1456 unsigned long flags;
1458 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1461 spin_lock_irqsave(&port->card->card_lock, flags);
1462 isicom_shutdown_port(port);
1463 spin_unlock_irqrestore(&port->card->card_lock, flags);
1466 port->flags &= ~ASYNC_NORMAL_ACTIVE;
1468 wake_up_interruptible(&port->open_wait);
1471 /* flush_buffer et all */
1472 static void isicom_flush_buffer(struct tty_struct *tty)
1474 struct isi_port *port = tty->driver_data;
1475 struct isi_board *card = port->card;
1476 unsigned long flags;
1478 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
1481 spin_lock_irqsave(&card->card_lock, flags);
1482 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1483 spin_unlock_irqrestore(&card->card_lock, flags);
1485 wake_up_interruptible(&tty->write_wait);
1490 * Driver init and deinit functions
1493 static const struct tty_operations isicom_ops = {
1494 .open = isicom_open,
1495 .close = isicom_close,
1496 .write = isicom_write,
1497 .put_char = isicom_put_char,
1498 .flush_chars = isicom_flush_chars,
1499 .write_room = isicom_write_room,
1500 .chars_in_buffer = isicom_chars_in_buffer,
1501 .ioctl = isicom_ioctl,
1502 .set_termios = isicom_set_termios,
1503 .throttle = isicom_throttle,
1504 .unthrottle = isicom_unthrottle,
1505 .stop = isicom_stop,
1506 .start = isicom_start,
1507 .hangup = isicom_hangup,
1508 .flush_buffer = isicom_flush_buffer,
1509 .tiocmget = isicom_tiocmget,
1510 .tiocmset = isicom_tiocmset,
1513 static int __devinit reset_card(struct pci_dev *pdev,
1514 const unsigned int card, unsigned int *signature)
1516 struct isi_board *board = pci_get_drvdata(pdev);
1517 unsigned long base = board->base;
1518 unsigned int sig, portcount = 0;
1521 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1528 outw(0, base + 0x8); /* Reset */
1532 sig = inw(base + 0x4) & 0xff;
1534 if (sig != 0xa5 && sig != 0xbb && sig != 0xcc && sig != 0xdd &&
1536 dev_warn(&pdev->dev, "ISILoad:Card%u reset failure (Possible "
1537 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1538 dev_dbg(&pdev->dev, "Sig=0x%x\n", sig);
1545 portcount = inw(base + 0x2);
1546 if (!inw(base + 0xe) & 0x1 || (portcount != 0 && portcount != 4 &&
1547 portcount != 8 && portcount != 16)) {
1548 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure.",
1558 board->port_count = (portcount == 4) ? 4 : 8;
1559 board->shift_count = 12;
1563 board->port_count = 16;
1564 board->shift_count = 11;
1567 dev_info(&pdev->dev, "-Done\n");
1574 static int __devinit load_firmware(struct pci_dev *pdev,
1575 const unsigned int index, const unsigned int signature)
1577 struct isi_board *board = pci_get_drvdata(pdev);
1578 const struct firmware *fw;
1579 unsigned long base = board->base;
1581 u16 word_count, status;
1592 switch (signature) {
1594 name = "isi608.bin";
1597 name = "isi608em.bin";
1600 name = "isi616em.bin";
1603 name = "isi4608.bin";
1606 name = "isi4616.bin";
1609 dev_err(&pdev->dev, "Unknown signature.\n");
1613 retval = request_firmware(&fw, name, &pdev->dev);
1619 for (frame = (struct stframe *)fw->data;
1620 frame < (struct stframe *)(fw->data + fw->size);
1621 frame = (struct stframe *)((u8 *)(frame + 1) +
1623 if (WaitTillCardIsFree(base))
1626 outw(0xf0, base); /* start upload sequence */
1628 outw(frame->addr, base); /* lsb of address */
1630 word_count = frame->count / 2 + frame->count % 2;
1631 outw(word_count, base);
1632 InterruptTheCard(base);
1634 udelay(100); /* 0x2f */
1636 if (WaitTillCardIsFree(base))
1639 if ((status = inw(base + 0x4)) != 0) {
1640 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1641 "Address:0x%x\nCount:0x%x\nStatus:0x%x\n",
1642 index + 1, frame->addr, frame->count, status);
1645 outsw(base, frame->data, word_count);
1647 InterruptTheCard(base);
1649 udelay(50); /* 0x0f */
1651 if (WaitTillCardIsFree(base))
1654 if ((status = inw(base + 0x4)) != 0) {
1655 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1656 "Status:0x%x\n", index + 1, status);
1661 /* XXX: should we test it by reading it back and comparing with original like
1662 * in load firmware package? */
1663 for (frame = (struct stframe *)fw->data;
1664 frame < (struct stframe *)(fw->data + fw->size);
1665 frame = (struct stframe *)((u8 *)(frame + 1) +
1667 if (WaitTillCardIsFree(base))
1670 outw(0xf1, base); /* start download sequence */
1672 outw(frame->addr, base); /* lsb of address */
1674 word_count = (frame->count >> 1) + frame->count % 2;
1675 outw(word_count + 1, base);
1676 InterruptTheCard(base);
1678 udelay(50); /* 0xf */
1680 if (WaitTillCardIsFree(base))
1683 if ((status = inw(base + 0x4)) != 0) {
1684 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1685 "Address:0x%x\nCount:0x%x\nStatus: 0x%x\n",
1686 index + 1, frame->addr, frame->count, status);
1690 data = kmalloc(word_count * 2, GFP_KERNEL);
1692 dev_err(&pdev->dev, "Card%d, firmware upload "
1693 "failed, not enough memory\n", index + 1);
1697 insw(base, data, word_count);
1698 InterruptTheCard(base);
1700 for (a = 0; a < frame->count; a++)
1701 if (data[a] != frame->data[a]) {
1703 dev_err(&pdev->dev, "Card%d, firmware upload "
1704 "failed\n", index + 1);
1709 udelay(50); /* 0xf */
1711 if (WaitTillCardIsFree(base))
1714 if ((status = inw(base + 0x4)) != 0) {
1715 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1716 "Card Status:0x%x\n", index + 1, status);
1722 if (WaitTillCardIsFree(base))
1729 InterruptTheCard(base);
1730 outw(0x0, base + 0x4); /* for ISI4608 cards */
1732 board->status |= FIRMWARE_LOADED;
1736 release_firmware(fw);
1742 * Insmod can set static symbols so keep these static
1746 static int __devinit isicom_probe(struct pci_dev *pdev,
1747 const struct pci_device_id *ent)
1749 unsigned int ioaddr, signature, index;
1750 int retval = -EPERM;
1752 struct isi_board *board = NULL;
1754 if (card >= BOARD_COUNT)
1757 ioaddr = pci_resource_start(pdev, 3);
1758 /* i.e at offset 0x1c in the PCI configuration register space. */
1760 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1762 /* allot the first empty slot in the array */
1763 for (index = 0; index < BOARD_COUNT; index++)
1764 if (isi_card[index].base == 0) {
1765 board = &isi_card[index];
1769 board->index = index;
1770 board->base = ioaddr;
1771 board->irq = pciirq;
1774 pci_set_drvdata(pdev, board);
1776 retval = pci_request_region(pdev, 3, ISICOM_NAME);
1778 dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1779 "will be disabled.\n", board->base, board->base + 15,
1785 retval = request_irq(board->irq, isicom_interrupt,
1786 IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
1788 dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1789 "Card%d will be disabled.\n", board->irq, index + 1);
1793 retval = reset_card(pdev, index, &signature);
1797 retval = load_firmware(pdev, index, signature);
1801 for (index = 0; index < board->port_count; index++)
1802 tty_register_device(isicom_normal, board->index * 16 + index,
1808 free_irq(board->irq, board);
1810 pci_release_region(pdev, 3);
1816 static void __devexit isicom_remove(struct pci_dev *pdev)
1818 struct isi_board *board = pci_get_drvdata(pdev);
1821 for (i = 0; i < board->port_count; i++)
1822 tty_unregister_device(isicom_normal, board->index * 16 + i);
1824 free_irq(board->irq, board);
1825 pci_release_region(pdev, 3);
1828 static int __init isicom_init(void)
1830 int retval, idx, channel;
1831 struct isi_port *port;
1835 for(idx = 0; idx < BOARD_COUNT; idx++) {
1836 port = &isi_ports[idx * 16];
1837 isi_card[idx].ports = port;
1838 spin_lock_init(&isi_card[idx].card_lock);
1839 for (channel = 0; channel < 16; channel++, port++) {
1840 port->magic = ISICOM_MAGIC;
1841 port->card = &isi_card[idx];
1842 port->channel = channel;
1843 port->close_delay = 50 * HZ/100;
1844 port->closing_wait = 3000 * HZ/100;
1846 init_waitqueue_head(&port->open_wait);
1847 init_waitqueue_head(&port->close_wait);
1850 isi_card[idx].base = 0;
1851 isi_card[idx].irq = 0;
1854 /* tty driver structure initialization */
1855 isicom_normal = alloc_tty_driver(PORT_COUNT);
1856 if (!isicom_normal) {
1861 isicom_normal->owner = THIS_MODULE;
1862 isicom_normal->name = "ttyM";
1863 isicom_normal->major = ISICOM_NMAJOR;
1864 isicom_normal->minor_start = 0;
1865 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1866 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1867 isicom_normal->init_termios = tty_std_termios;
1868 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1870 isicom_normal->flags = TTY_DRIVER_REAL_RAW |
1871 TTY_DRIVER_DYNAMIC_DEV;
1872 tty_set_operations(isicom_normal, &isicom_ops);
1874 retval = tty_register_driver(isicom_normal);
1876 pr_dbg("Couldn't register the dialin driver\n");
1880 retval = pci_register_driver(&isicom_driver);
1882 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1886 mod_timer(&tx, jiffies + 1);
1890 tty_unregister_driver(isicom_normal);
1892 put_tty_driver(isicom_normal);
1897 static void __exit isicom_exit(void)
1901 wait_for_completion_timeout(&isi_timerdone, HZ);
1903 pci_unregister_driver(&isicom_driver);
1904 tty_unregister_driver(isicom_normal);
1905 put_tty_driver(isicom_normal);
1908 module_init(isicom_init);
1909 module_exit(isicom_exit);
1911 MODULE_AUTHOR("MultiTech");
1912 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1913 MODULE_LICENSE("GPL");