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))
543 spin_lock(&card->card_lock);
546 * disable any interrupts from the PCI card and lower the
549 outw(0x8000, base+0x04);
550 ClearInterrupt(base);
552 inw(base); /* get the dummy word out */
554 channel = (header & 0x7800) >> card->shift_count;
555 byte_count = header & 0xff;
557 if (channel + 1 > card->port_count) {
558 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
559 "%d(channel) > port_count.\n", base, channel+1);
560 outw(0x0000, base+0x04); /* enable interrupts */
561 spin_unlock(&card->card_lock);
564 port = card->ports + channel;
565 if (!(port->flags & ASYNC_INITIALIZED)) {
566 outw(0x0000, base+0x04); /* enable interrupts */
567 spin_unlock(&card->card_lock);
573 word_count = byte_count >> 1;
574 while(byte_count > 1) {
578 if (byte_count & 0x01)
580 outw(0x0000, base+0x04); /* enable interrupts */
581 spin_unlock(&card->card_lock);
585 if (header & 0x8000) { /* Status Packet */
587 switch(header & 0xff) {
588 case 0: /* Change in EIA signals */
589 if (port->flags & ASYNC_CHECK_CD) {
590 if (port->status & ISI_DCD) {
591 if (!(header & ISI_DCD)) {
592 /* Carrier has been lost */
593 pr_dbg("interrupt: DCD->low.\n"
595 port->status &= ~ISI_DCD;
598 } else if (header & ISI_DCD) {
599 /* Carrier has been detected */
600 pr_dbg("interrupt: DCD->high.\n");
601 port->status |= ISI_DCD;
602 wake_up_interruptible(&port->open_wait);
605 if (header & ISI_DCD)
606 port->status |= ISI_DCD;
608 port->status &= ~ISI_DCD;
611 if (port->flags & ASYNC_CTS_FLOW) {
612 if (port->tty->hw_stopped) {
613 if (header & ISI_CTS) {
614 port->tty->hw_stopped = 0;
616 port->status |= (ISI_TXOK
620 } else if (!(header & ISI_CTS)) {
621 port->tty->hw_stopped = 1;
623 port->status &= ~(ISI_TXOK | ISI_CTS);
626 if (header & ISI_CTS)
627 port->status |= ISI_CTS;
629 port->status &= ~ISI_CTS;
632 if (header & ISI_DSR)
633 port->status |= ISI_DSR;
635 port->status &= ~ISI_DSR;
638 port->status |= ISI_RI;
640 port->status &= ~ISI_RI;
644 case 1: /* Received Break !!! */
645 tty_insert_flip_char(tty, 0, TTY_BREAK);
646 if (port->flags & ASYNC_SAK)
648 tty_flip_buffer_push(tty);
651 case 2: /* Statistics */
652 pr_dbg("isicom_interrupt: stats!!!.\n");
656 pr_dbg("Intr: Unknown code in status packet.\n");
659 } else { /* Data Packet */
661 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
662 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
663 word_count = count >> 1;
664 insw(base, rp, word_count);
665 byte_count -= (word_count << 1);
666 if (count & 0x0001) {
667 tty_insert_flip_char(tty, inw(base) & 0xff,
671 if (byte_count > 0) {
672 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
673 "bytes...\n", base, channel + 1);
674 while(byte_count > 0) { /* drain out unread xtra data */
679 tty_flip_buffer_push(tty);
681 outw(0x0000, base+0x04); /* enable interrupts */
682 spin_unlock(&card->card_lock);
687 static void isicom_config_port(struct isi_port *port)
689 struct isi_board *card = port->card;
690 struct tty_struct *tty;
692 unsigned long base = card->base;
693 u16 channel_setup, channel = port->channel,
694 shift_count = card->shift_count;
695 unsigned char flow_ctrl;
697 if (!(tty = port->tty) || !tty->termios)
700 if (baud & CBAUDEX) {
703 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
704 * then the card is programmed for 57.6Kbps or 115Kbps
708 if (baud < 1 || baud > 2)
709 port->tty->termios->c_cflag &= ~CBAUDEX;
715 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
716 * by the set_serial_info ioctl ... this is done by
717 * the 'setserial' utility.
720 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
721 baud++; /* 57.6 Kbps */
722 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
723 baud +=2; /* 115 Kbps */
725 if (linuxb_to_isib[baud] == -1) {
733 if (WaitTillCardIsFree(base) == 0) {
734 outw(0x8000 | (channel << shift_count) |0x03, base);
735 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
737 switch(C_CSIZE(tty)) {
739 channel_setup |= ISICOM_CS5;
742 channel_setup |= ISICOM_CS6;
745 channel_setup |= ISICOM_CS7;
748 channel_setup |= ISICOM_CS8;
753 channel_setup |= ISICOM_2SB;
755 channel_setup |= ISICOM_EVPAR;
757 channel_setup |= ISICOM_ODPAR;
759 outw(channel_setup, base);
760 InterruptTheCard(base);
763 port->flags &= ~ASYNC_CHECK_CD;
765 port->flags |= ASYNC_CHECK_CD;
767 /* flow control settings ...*/
769 port->flags &= ~ASYNC_CTS_FLOW;
770 if (C_CRTSCTS(tty)) {
771 port->flags |= ASYNC_CTS_FLOW;
772 flow_ctrl |= ISICOM_CTSRTS;
775 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
777 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
779 if (WaitTillCardIsFree(base) == 0) {
780 outw(0x8000 | (channel << shift_count) |0x04, base);
781 outw(flow_ctrl << 8 | 0x05, base);
782 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
783 InterruptTheCard(base);
786 /* rx enabled -> enable port for rx on the card */
788 card->port_status |= (1 << channel);
789 outw(card->port_status, base + 0x02);
795 static inline void isicom_setup_board(struct isi_board *bp)
798 struct isi_port *port;
801 spin_lock_irqsave(&bp->card_lock, flags);
802 if (bp->status & BOARD_ACTIVE) {
803 spin_unlock_irqrestore(&bp->card_lock, flags);
807 bp->status |= BOARD_ACTIVE;
808 for (channel = 0; channel < bp->port_count; channel++, port++)
810 spin_unlock_irqrestore(&bp->card_lock, flags);
813 static int isicom_setup_port(struct isi_port *port)
815 struct isi_board *card = port->card;
818 if (port->flags & ASYNC_INITIALIZED) {
821 if (!port->xmit_buf) {
824 if (!(page = get_zeroed_page(GFP_KERNEL)))
827 if (port->xmit_buf) {
831 port->xmit_buf = (unsigned char *) page;
834 spin_lock_irqsave(&card->card_lock, flags);
836 clear_bit(TTY_IO_ERROR, &port->tty->flags);
837 if (port->count == 1)
840 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
842 /* discard any residual data */
843 if (WaitTillCardIsFree(card->base) == 0) {
844 outw(0x8000 | (port->channel << card->shift_count) | 0x02,
846 outw(((ISICOM_KILLTX | ISICOM_KILLRX) << 8) | 0x06, card->base);
847 InterruptTheCard(card->base);
850 isicom_config_port(port);
851 port->flags |= ASYNC_INITIALIZED;
852 spin_unlock_irqrestore(&card->card_lock, flags);
857 static int block_til_ready(struct tty_struct *tty, struct file *filp,
858 struct isi_port *port)
860 struct isi_board *card = port->card;
861 int do_clocal = 0, retval;
863 DECLARE_WAITQUEUE(wait, current);
865 /* block if port is in the process of being closed */
867 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
868 pr_dbg("block_til_ready: close in progress.\n");
869 interruptible_sleep_on(&port->close_wait);
870 if (port->flags & ASYNC_HUP_NOTIFY)
876 /* if non-blocking mode is set ... */
878 if ((filp->f_flags & O_NONBLOCK) ||
879 (tty->flags & (1 << TTY_IO_ERROR))) {
880 pr_dbg("block_til_ready: non-block mode.\n");
881 port->flags |= ASYNC_NORMAL_ACTIVE;
888 /* block waiting for DCD to be asserted, and while
889 callout dev is busy */
891 add_wait_queue(&port->open_wait, &wait);
893 spin_lock_irqsave(&card->card_lock, flags);
894 if (!tty_hung_up_p(filp))
896 port->blocked_open++;
897 spin_unlock_irqrestore(&card->card_lock, flags);
902 set_current_state(TASK_INTERRUPTIBLE);
903 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
904 if (port->flags & ASYNC_HUP_NOTIFY)
907 retval = -ERESTARTSYS;
910 if (!(port->flags & ASYNC_CLOSING) &&
911 (do_clocal || (port->status & ISI_DCD))) {
914 if (signal_pending(current)) {
915 retval = -ERESTARTSYS;
920 set_current_state(TASK_RUNNING);
921 remove_wait_queue(&port->open_wait, &wait);
922 spin_lock_irqsave(&card->card_lock, flags);
923 if (!tty_hung_up_p(filp))
925 port->blocked_open--;
926 spin_unlock_irqrestore(&card->card_lock, flags);
929 port->flags |= ASYNC_NORMAL_ACTIVE;
933 static int isicom_open(struct tty_struct *tty, struct file *filp)
935 struct isi_port *port;
936 struct isi_board *card;
941 if (line < 0 || line > PORT_COUNT-1)
944 card = &isi_card[board];
946 if (!(card->status & FIRMWARE_LOADED))
949 /* open on a port greater than the port count for the card !!! */
950 if (line > ((board * 16) + card->port_count - 1))
953 port = &isi_ports[line];
954 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
957 isicom_setup_board(card);
960 tty->driver_data = port;
962 if ((error = isicom_setup_port(port))!=0)
964 if ((error = block_til_ready(tty, filp, port))!=0)
972 static inline void isicom_shutdown_board(struct isi_board *bp)
974 if (bp->status & BOARD_ACTIVE) {
975 bp->status &= ~BOARD_ACTIVE;
979 /* card->lock HAS to be held */
980 static void isicom_shutdown_port(struct isi_port *port)
982 struct isi_board *card = port->card;
983 struct tty_struct *tty;
987 if (!(port->flags & ASYNC_INITIALIZED))
990 if (port->xmit_buf) {
991 free_page((unsigned long) port->xmit_buf);
992 port->xmit_buf = NULL;
994 port->flags &= ~ASYNC_INITIALIZED;
995 /* 3rd October 2000 : Vinayak P Risbud */
998 /*Fix done by Anil .S on 30-04-2001
999 remote login through isi port has dtr toggle problem
1000 due to which the carrier drops before the password prompt
1001 appears on the remote end. Now we drop the dtr only if the
1002 HUPCL(Hangup on close) flag is set for the tty*/
1005 /* drop dtr on this port */
1008 /* any other port uninits */
1010 set_bit(TTY_IO_ERROR, &tty->flags);
1012 if (--card->count < 0) {
1013 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
1014 card->base, card->count);
1018 /* last port was closed, shutdown that boad too */
1021 isicom_shutdown_board(card);
1025 static void isicom_close(struct tty_struct *tty, struct file *filp)
1027 struct isi_port *port = tty->driver_data;
1028 struct isi_board *card;
1029 unsigned long flags;
1034 if (isicom_paranoia_check(port, tty->name, "isicom_close"))
1037 pr_dbg("Close start!!!.\n");
1039 spin_lock_irqsave(&card->card_lock, flags);
1040 if (tty_hung_up_p(filp)) {
1041 spin_unlock_irqrestore(&card->card_lock, flags);
1045 if (tty->count == 1 && port->count != 1) {
1046 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1047 "count tty->count = 1 port count = %d.\n",
1048 card->base, port->count);
1051 if (--port->count < 0) {
1052 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1053 "count for channel%d = %d", card->base, port->channel,
1059 spin_unlock_irqrestore(&card->card_lock, flags);
1062 port->flags |= ASYNC_CLOSING;
1064 spin_unlock_irqrestore(&card->card_lock, flags);
1066 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1067 tty_wait_until_sent(tty, port->closing_wait);
1068 /* indicate to the card that no more data can be received
1070 spin_lock_irqsave(&card->card_lock, flags);
1071 if (port->flags & ASYNC_INITIALIZED) {
1072 card->port_status &= ~(1 << port->channel);
1073 outw(card->port_status, card->base + 0x02);
1075 isicom_shutdown_port(port);
1076 spin_unlock_irqrestore(&card->card_lock, flags);
1078 if (tty->driver->flush_buffer)
1079 tty->driver->flush_buffer(tty);
1080 tty_ldisc_flush(tty);
1082 spin_lock_irqsave(&card->card_lock, flags);
1085 if (port->blocked_open) {
1086 spin_unlock_irqrestore(&card->card_lock, flags);
1087 if (port->close_delay) {
1088 pr_dbg("scheduling until time out.\n");
1089 msleep_interruptible(
1090 jiffies_to_msecs(port->close_delay));
1092 spin_lock_irqsave(&card->card_lock, flags);
1093 wake_up_interruptible(&port->open_wait);
1095 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1096 wake_up_interruptible(&port->close_wait);
1097 spin_unlock_irqrestore(&card->card_lock, flags);
1101 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1104 struct isi_port *port = tty->driver_data;
1105 struct isi_board *card = port->card;
1106 unsigned long flags;
1109 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1112 if (!port->xmit_buf)
1115 spin_lock_irqsave(&card->card_lock, flags);
1118 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
1119 - 1, SERIAL_XMIT_SIZE - port->xmit_head));
1123 memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
1124 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
1126 port->xmit_cnt += cnt;
1131 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1132 port->status |= ISI_TXOK;
1133 spin_unlock_irqrestore(&card->card_lock, flags);
1137 /* put_char et all */
1138 static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
1140 struct isi_port *port = tty->driver_data;
1141 struct isi_board *card = port->card;
1142 unsigned long flags;
1144 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1147 if (!port->xmit_buf)
1150 spin_lock_irqsave(&card->card_lock, flags);
1151 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1152 spin_unlock_irqrestore(&card->card_lock, flags);
1156 port->xmit_buf[port->xmit_head++] = ch;
1157 port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1159 spin_unlock_irqrestore(&card->card_lock, flags);
1162 /* flush_chars et all */
1163 static void isicom_flush_chars(struct tty_struct *tty)
1165 struct isi_port *port = tty->driver_data;
1167 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1170 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1174 /* this tells the transmitter to consider this port for
1175 data output to the card ... that's the best we can do. */
1176 port->status |= ISI_TXOK;
1179 /* write_room et all */
1180 static int isicom_write_room(struct tty_struct *tty)
1182 struct isi_port *port = tty->driver_data;
1185 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1188 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1194 /* chars_in_buffer et all */
1195 static int isicom_chars_in_buffer(struct tty_struct *tty)
1197 struct isi_port *port = tty->driver_data;
1198 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1200 return port->xmit_cnt;
1204 static inline void isicom_send_break(struct isi_port *port,
1205 unsigned long length)
1207 struct isi_board *card = port->card;
1208 unsigned long base = card->base;
1210 if (!lock_card(card))
1213 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1214 outw((length & 0xff) << 8 | 0x00, base);
1215 outw((length & 0xff00), base);
1216 InterruptTheCard(base);
1221 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1223 struct isi_port *port = tty->driver_data;
1224 /* just send the port status */
1225 u16 status = port->status;
1227 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1230 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1231 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1232 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1233 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1234 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1235 ((status & ISI_RI ) ? TIOCM_RI : 0);
1238 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1239 unsigned int set, unsigned int clear)
1241 struct isi_port *port = tty->driver_data;
1242 unsigned long flags;
1244 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1247 spin_lock_irqsave(&port->card->card_lock, flags);
1248 if (set & TIOCM_RTS)
1250 if (set & TIOCM_DTR)
1253 if (clear & TIOCM_RTS)
1255 if (clear & TIOCM_DTR)
1257 spin_unlock_irqrestore(&port->card->card_lock, flags);
1262 static int isicom_set_serial_info(struct isi_port *port,
1263 struct serial_struct __user *info)
1265 struct serial_struct newinfo;
1268 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1271 reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
1272 (newinfo.flags & ASYNC_SPD_MASK));
1274 if (!capable(CAP_SYS_ADMIN)) {
1275 if ((newinfo.close_delay != port->close_delay) ||
1276 (newinfo.closing_wait != port->closing_wait) ||
1277 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1278 (port->flags & ~ASYNC_USR_MASK)))
1280 port->flags = ((port->flags & ~ ASYNC_USR_MASK) |
1281 (newinfo.flags & ASYNC_USR_MASK));
1284 port->close_delay = newinfo.close_delay;
1285 port->closing_wait = newinfo.closing_wait;
1286 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1287 (newinfo.flags & ASYNC_FLAGS));
1289 if (reconfig_port) {
1290 unsigned long flags;
1291 spin_lock_irqsave(&port->card->card_lock, flags);
1292 isicom_config_port(port);
1293 spin_unlock_irqrestore(&port->card->card_lock, flags);
1298 static int isicom_get_serial_info(struct isi_port *port,
1299 struct serial_struct __user *info)
1301 struct serial_struct out_info;
1303 memset(&out_info, 0, sizeof(out_info));
1304 /* out_info.type = ? */
1305 out_info.line = port - isi_ports;
1306 out_info.port = port->card->base;
1307 out_info.irq = port->card->irq;
1308 out_info.flags = port->flags;
1309 /* out_info.baud_base = ? */
1310 out_info.close_delay = port->close_delay;
1311 out_info.closing_wait = port->closing_wait;
1312 if (copy_to_user(info, &out_info, sizeof(out_info)))
1317 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1318 unsigned int cmd, unsigned long arg)
1320 struct isi_port *port = tty->driver_data;
1321 void __user *argp = (void __user *)arg;
1324 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1329 retval = tty_check_change(tty);
1332 tty_wait_until_sent(tty, 0);
1334 isicom_send_break(port, HZ/4);
1338 retval = tty_check_change(tty);
1341 tty_wait_until_sent(tty, 0);
1342 isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
1346 return put_user(C_CLOCAL(tty) ? 1 : 0,
1347 (unsigned long __user *)argp);
1350 if (get_user(arg, (unsigned long __user *) argp))
1352 tty->termios->c_cflag =
1353 ((tty->termios->c_cflag & ~CLOCAL) |
1354 (arg ? CLOCAL : 0));
1358 return isicom_get_serial_info(port, argp);
1361 return isicom_set_serial_info(port, argp);
1364 return -ENOIOCTLCMD;
1369 /* set_termios et all */
1370 static void isicom_set_termios(struct tty_struct *tty,
1371 struct ktermios *old_termios)
1373 struct isi_port *port = tty->driver_data;
1374 unsigned long flags;
1376 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1379 if (tty->termios->c_cflag == old_termios->c_cflag &&
1380 tty->termios->c_iflag == old_termios->c_iflag)
1383 spin_lock_irqsave(&port->card->card_lock, flags);
1384 isicom_config_port(port);
1385 spin_unlock_irqrestore(&port->card->card_lock, flags);
1387 if ((old_termios->c_cflag & CRTSCTS) &&
1388 !(tty->termios->c_cflag & CRTSCTS)) {
1389 tty->hw_stopped = 0;
1394 /* throttle et all */
1395 static void isicom_throttle(struct tty_struct *tty)
1397 struct isi_port *port = tty->driver_data;
1398 struct isi_board *card = port->card;
1400 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1403 /* tell the card that this port cannot handle any more data for now */
1404 card->port_status &= ~(1 << port->channel);
1405 outw(card->port_status, card->base + 0x02);
1408 /* unthrottle et all */
1409 static void isicom_unthrottle(struct tty_struct *tty)
1411 struct isi_port *port = tty->driver_data;
1412 struct isi_board *card = port->card;
1414 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1417 /* tell the card that this port is ready to accept more data */
1418 card->port_status |= (1 << port->channel);
1419 outw(card->port_status, card->base + 0x02);
1423 static void isicom_stop(struct tty_struct *tty)
1425 struct isi_port *port = tty->driver_data;
1427 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1430 /* this tells the transmitter not to consider this port for
1431 data output to the card. */
1432 port->status &= ~ISI_TXOK;
1436 static void isicom_start(struct tty_struct *tty)
1438 struct isi_port *port = tty->driver_data;
1440 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1443 /* this tells the transmitter to consider this port for
1444 data output to the card. */
1445 port->status |= ISI_TXOK;
1448 static void isicom_hangup(struct tty_struct *tty)
1450 struct isi_port *port = tty->driver_data;
1451 unsigned long flags;
1453 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1456 spin_lock_irqsave(&port->card->card_lock, flags);
1457 isicom_shutdown_port(port);
1458 spin_unlock_irqrestore(&port->card->card_lock, flags);
1461 port->flags &= ~ASYNC_NORMAL_ACTIVE;
1463 wake_up_interruptible(&port->open_wait);
1466 /* flush_buffer et all */
1467 static void isicom_flush_buffer(struct tty_struct *tty)
1469 struct isi_port *port = tty->driver_data;
1470 struct isi_board *card = port->card;
1471 unsigned long flags;
1473 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
1476 spin_lock_irqsave(&card->card_lock, flags);
1477 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1478 spin_unlock_irqrestore(&card->card_lock, flags);
1480 wake_up_interruptible(&tty->write_wait);
1485 * Driver init and deinit functions
1488 static const struct tty_operations isicom_ops = {
1489 .open = isicom_open,
1490 .close = isicom_close,
1491 .write = isicom_write,
1492 .put_char = isicom_put_char,
1493 .flush_chars = isicom_flush_chars,
1494 .write_room = isicom_write_room,
1495 .chars_in_buffer = isicom_chars_in_buffer,
1496 .ioctl = isicom_ioctl,
1497 .set_termios = isicom_set_termios,
1498 .throttle = isicom_throttle,
1499 .unthrottle = isicom_unthrottle,
1500 .stop = isicom_stop,
1501 .start = isicom_start,
1502 .hangup = isicom_hangup,
1503 .flush_buffer = isicom_flush_buffer,
1504 .tiocmget = isicom_tiocmget,
1505 .tiocmset = isicom_tiocmset,
1508 static int __devinit reset_card(struct pci_dev *pdev,
1509 const unsigned int card, unsigned int *signature)
1511 struct isi_board *board = pci_get_drvdata(pdev);
1512 unsigned long base = board->base;
1513 unsigned int portcount = 0;
1516 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1523 outw(0, base + 0x8); /* Reset */
1527 *signature = inw(base + 0x4) & 0xff;
1529 portcount = inw(base + 0x2);
1530 if (!(inw(base + 0xe) & 0x1) || ((portcount != 0) &&
1531 (portcount != 4) && (portcount != 8))) {
1532 dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
1533 inw(base + 0x2), inw(base + 0xe));
1534 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure "
1535 "(Possible bad I/O Port Address 0x%lx).\n",
1541 switch (*signature) {
1545 board->port_count = (portcount == 4) ? 4 : 8;
1546 board->shift_count = 12;
1549 board->port_count = 16;
1550 board->shift_count = 11;
1553 dev_warn(&pdev->dev, "ISILoad:Card%d reset failure (Possible "
1554 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1555 dev_dbg(&pdev->dev, "Sig=0x%lx\n", signature);
1558 dev_info(&pdev->dev, "-Done\n");
1564 static int __devinit load_firmware(struct pci_dev *pdev,
1565 const unsigned int index, const unsigned int signature)
1567 struct isi_board *board = pci_get_drvdata(pdev);
1568 const struct firmware *fw;
1569 unsigned long base = board->base;
1571 u16 word_count, status;
1582 switch (signature) {
1584 name = "isi608.bin";
1587 name = "isi608em.bin";
1590 name = "isi616em.bin";
1593 name = "isi4608.bin";
1596 name = "isi4616.bin";
1599 dev_err(&pdev->dev, "Unknown signature.\n");
1603 retval = request_firmware(&fw, name, &pdev->dev);
1609 for (frame = (struct stframe *)fw->data;
1610 frame < (struct stframe *)(fw->data + fw->size);
1611 frame = (struct stframe *)((u8 *)(frame + 1) +
1613 if (WaitTillCardIsFree(base))
1616 outw(0xf0, base); /* start upload sequence */
1618 outw(frame->addr, base); /* lsb of address */
1620 word_count = frame->count / 2 + frame->count % 2;
1621 outw(word_count, base);
1622 InterruptTheCard(base);
1624 udelay(100); /* 0x2f */
1626 if (WaitTillCardIsFree(base))
1629 if ((status = inw(base + 0x4)) != 0) {
1630 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1631 "Address:0x%x\nCount:0x%x\nStatus:0x%x\n",
1632 index + 1, frame->addr, frame->count, status);
1635 outsw(base, frame->data, word_count);
1637 InterruptTheCard(base);
1639 udelay(50); /* 0x0f */
1641 if (WaitTillCardIsFree(base))
1644 if ((status = inw(base + 0x4)) != 0) {
1645 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1646 "Status:0x%x\n", index + 1, status);
1651 /* XXX: should we test it by reading it back and comparing with original like
1652 * in load firmware package? */
1653 for (frame = (struct stframe *)fw->data;
1654 frame < (struct stframe *)(fw->data + fw->size);
1655 frame = (struct stframe *)((u8 *)(frame + 1) +
1657 if (WaitTillCardIsFree(base))
1660 outw(0xf1, base); /* start download sequence */
1662 outw(frame->addr, base); /* lsb of address */
1664 word_count = (frame->count >> 1) + frame->count % 2;
1665 outw(word_count + 1, base);
1666 InterruptTheCard(base);
1668 udelay(50); /* 0xf */
1670 if (WaitTillCardIsFree(base))
1673 if ((status = inw(base + 0x4)) != 0) {
1674 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1675 "Address:0x%x\nCount:0x%x\nStatus: 0x%x\n",
1676 index + 1, frame->addr, frame->count, status);
1680 data = kmalloc(word_count * 2, GFP_KERNEL);
1682 dev_err(&pdev->dev, "Card%d, firmware upload "
1683 "failed, not enough memory\n", index + 1);
1687 insw(base, data, word_count);
1688 InterruptTheCard(base);
1690 for (a = 0; a < frame->count; a++)
1691 if (data[a] != frame->data[a]) {
1693 dev_err(&pdev->dev, "Card%d, firmware upload "
1694 "failed\n", index + 1);
1699 udelay(50); /* 0xf */
1701 if (WaitTillCardIsFree(base))
1704 if ((status = inw(base + 0x4)) != 0) {
1705 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1706 "Card Status:0x%x\n", index + 1, status);
1712 if (WaitTillCardIsFree(base))
1719 InterruptTheCard(base);
1720 outw(0x0, base + 0x4); /* for ISI4608 cards */
1722 board->status |= FIRMWARE_LOADED;
1726 release_firmware(fw);
1732 * Insmod can set static symbols so keep these static
1736 static int __devinit isicom_probe(struct pci_dev *pdev,
1737 const struct pci_device_id *ent)
1739 unsigned int ioaddr, signature, index;
1740 int retval = -EPERM;
1742 struct isi_board *board = NULL;
1744 if (card >= BOARD_COUNT)
1747 ioaddr = pci_resource_start(pdev, 3);
1748 /* i.e at offset 0x1c in the PCI configuration register space. */
1750 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1752 /* allot the first empty slot in the array */
1753 for (index = 0; index < BOARD_COUNT; index++)
1754 if (isi_card[index].base == 0) {
1755 board = &isi_card[index];
1759 board->index = index;
1760 board->base = ioaddr;
1761 board->irq = pciirq;
1764 pci_set_drvdata(pdev, board);
1766 retval = pci_request_region(pdev, 3, ISICOM_NAME);
1768 dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1769 "will be disabled.\n", board->base, board->base + 15,
1775 retval = request_irq(board->irq, isicom_interrupt,
1776 IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
1778 dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1779 "Card%d will be disabled.\n", board->irq, index + 1);
1783 retval = reset_card(pdev, index, &signature);
1787 retval = load_firmware(pdev, index, signature);
1791 for (index = 0; index < board->port_count; index++)
1792 tty_register_device(isicom_normal, board->index * 16 + index,
1798 free_irq(board->irq, board);
1800 pci_release_region(pdev, 3);
1806 static void __devexit isicom_remove(struct pci_dev *pdev)
1808 struct isi_board *board = pci_get_drvdata(pdev);
1811 for (i = 0; i < board->port_count; i++)
1812 tty_unregister_device(isicom_normal, board->index * 16 + i);
1814 free_irq(board->irq, board);
1815 pci_release_region(pdev, 3);
1818 static int __init isicom_init(void)
1820 int retval, idx, channel;
1821 struct isi_port *port;
1825 for(idx = 0; idx < BOARD_COUNT; idx++) {
1826 port = &isi_ports[idx * 16];
1827 isi_card[idx].ports = port;
1828 spin_lock_init(&isi_card[idx].card_lock);
1829 for (channel = 0; channel < 16; channel++, port++) {
1830 port->magic = ISICOM_MAGIC;
1831 port->card = &isi_card[idx];
1832 port->channel = channel;
1833 port->close_delay = 50 * HZ/100;
1834 port->closing_wait = 3000 * HZ/100;
1836 init_waitqueue_head(&port->open_wait);
1837 init_waitqueue_head(&port->close_wait);
1840 isi_card[idx].base = 0;
1841 isi_card[idx].irq = 0;
1844 /* tty driver structure initialization */
1845 isicom_normal = alloc_tty_driver(PORT_COUNT);
1846 if (!isicom_normal) {
1851 isicom_normal->owner = THIS_MODULE;
1852 isicom_normal->name = "ttyM";
1853 isicom_normal->major = ISICOM_NMAJOR;
1854 isicom_normal->minor_start = 0;
1855 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1856 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1857 isicom_normal->init_termios = tty_std_termios;
1858 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1860 isicom_normal->flags = TTY_DRIVER_REAL_RAW |
1861 TTY_DRIVER_DYNAMIC_DEV;
1862 tty_set_operations(isicom_normal, &isicom_ops);
1864 retval = tty_register_driver(isicom_normal);
1866 pr_dbg("Couldn't register the dialin driver\n");
1870 retval = pci_register_driver(&isicom_driver);
1872 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1876 mod_timer(&tx, jiffies + 1);
1880 tty_unregister_driver(isicom_normal);
1882 put_tty_driver(isicom_normal);
1887 static void __exit isicom_exit(void)
1891 wait_for_completion_timeout(&isi_timerdone, HZ);
1893 pci_unregister_driver(&isicom_driver);
1894 tty_unregister_driver(isicom_normal);
1895 put_tty_driver(isicom_normal);
1898 module_init(isicom_init);
1899 module_exit(isicom_exit);
1901 MODULE_AUTHOR("MultiTech");
1902 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1903 MODULE_LICENSE("GPL");