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@lxorguk.ukuu.org.uk
11 * Merge to 2.0.x kernel tree
12 * Obtain and use official major/minors
13 * Loader switched to a misc device
14 * (fixed range check bug as a side effect)
16 * 9/12/98 alan@lxorguk.ukuu.org.uk
19 * 10/6/99 sameer Merged the ISA and PCI drivers to
20 * a new unified driver.
22 * 3/9/99 sameer Added support for ISI4616 cards.
24 * 16/9/99 sameer We do not force RTS low anymore.
25 * This is to prevent the firmware
26 * from getting confused.
28 * 26/10/99 sameer Cosmetic changes:The driver now
29 * dumps the Port Count information
30 * along with I/O address and IRQ.
32 * 13/12/99 sameer Fixed the problem with IRQ sharing.
34 * 10/5/00 sameer Fixed isicom_shutdown_board()
35 * to not lower DTR on all the ports
36 * when the last port on the card is
39 * 10/5/00 sameer Signal mask setup command added
40 * to isicom_setup_port and
41 * isicom_shutdown_port.
43 * 24/5/00 sameer The driver is now SMP aware.
46 * 27/11/00 Vinayak P Risbud Fixed the Driver Crash Problem
49 * 03/01/01 anil .s Added support for resetting the
50 * internal modems on ISI cards.
52 * 08/02/01 anil .s Upgraded the driver for kernel
55 * 11/04/01 Kevin Fixed firmware load problem with
58 * 30/04/01 anil .s Fixed the remote login through
59 * ISI port problem. Now the link
60 * does not go down before password
63 * 03/05/01 anil .s Fixed the problem with IRQ sharing
64 * among ISI-PCI cards.
66 * 03/05/01 anil .s Added support to display the version
67 * info during insmod as well as module
70 * 10/05/01 anil .s Done the modifications to the source
71 * file and Install script so that the
72 * same installation can be used for
73 * 2.2.x and 2.4.x kernel.
75 * 06/06/01 anil .s Now we drop both dtr and rts during
76 * shutdown_port as well as raise them
77 * during isicom_config_port.
79 * 09/06/01 acme@conectiva.com.br use capable, not suser, do
80 * restore_flags on failure in
81 * isicom_send_break, verify put_user
84 * 11/02/03 ranjeeth Added support for 230 Kbps and 460 Kbps
85 * Baud index extended to 21
87 * 20/03/03 ranjeeth Made to work for Linux Advanced server.
88 * Taken care of license warning.
90 * 10/12/03 Ravindra Made to work for Fedora Core 1 of
91 * Red Hat Distribution
93 * 06/01/05 Alan Cox Merged the ISI and base kernel strands
94 * into a single 2.6 driver
96 * ***********************************************************
98 * To use this driver you also need the support package. You
99 * can find this in RPM format on
100 * ftp://ftp.linux.org.uk/pub/linux/alan
102 * You can find the original tools for this direct from Multitech
103 * ftp://ftp.multitech.com/ISI-Cards/
105 * Having installed the cards the module options (/etc/modprobe.conf)
107 * options isicom io=card1,card2,card3,card4 irq=card1,card2,card3,card4
109 * Omit those entries for boards you don't have installed.
113 * 64-bit verification
116 #include <linux/module.h>
117 #include <linux/firmware.h>
118 #include <linux/kernel.h>
119 #include <linux/tty.h>
120 #include <linux/tty_flip.h>
121 #include <linux/termios.h>
122 #include <linux/fs.h>
123 #include <linux/sched.h>
124 #include <linux/serial.h>
125 #include <linux/mm.h>
126 #include <linux/interrupt.h>
127 #include <linux/timer.h>
128 #include <linux/delay.h>
129 #include <linux/ioport.h>
131 #include <linux/uaccess.h>
132 #include <linux/io.h>
133 #include <asm/system.h>
135 #include <linux/pci.h>
137 #include <linux/isicom.h>
139 #define InterruptTheCard(base) outw(0, (base) + 0xc)
140 #define ClearInterrupt(base) inw((base) + 0x0a)
142 #define pr_dbg(str...) pr_debug("ISICOM: " str)
144 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
146 #define isicom_paranoia_check(a, b, c) 0
149 static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
150 static void __devexit isicom_remove(struct pci_dev *);
152 static struct pci_device_id isicom_pci_tbl[] = {
153 { PCI_DEVICE(VENDOR_ID, 0x2028) },
154 { PCI_DEVICE(VENDOR_ID, 0x2051) },
155 { PCI_DEVICE(VENDOR_ID, 0x2052) },
156 { PCI_DEVICE(VENDOR_ID, 0x2053) },
157 { PCI_DEVICE(VENDOR_ID, 0x2054) },
158 { PCI_DEVICE(VENDOR_ID, 0x2055) },
159 { PCI_DEVICE(VENDOR_ID, 0x2056) },
160 { PCI_DEVICE(VENDOR_ID, 0x2057) },
161 { PCI_DEVICE(VENDOR_ID, 0x2058) },
164 MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
166 static struct pci_driver isicom_driver = {
168 .id_table = isicom_pci_tbl,
169 .probe = isicom_probe,
170 .remove = __devexit_p(isicom_remove)
173 static int prev_card = 3; /* start servicing isi_card[0] */
174 static struct tty_driver *isicom_normal;
176 static void isicom_tx(unsigned long _data);
177 static void isicom_start(struct tty_struct *tty);
179 static DEFINE_TIMER(tx, isicom_tx, 0, 0);
181 /* baud index mappings from linux defns to isi */
183 static signed char linuxb_to_isib[] = {
184 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19, 20, 21
190 unsigned char port_count;
191 unsigned short status;
192 unsigned short port_status; /* each bit for each port */
193 unsigned short shift_count;
194 struct isi_port *ports;
196 spinlock_t card_lock; /* Card wide lock 11/5/00 -sameer */
202 unsigned short magic;
203 struct tty_port port;
206 struct isi_board *card;
207 unsigned char *xmit_buf;
213 static struct isi_board isi_card[BOARD_COUNT];
214 static struct isi_port isi_ports[PORT_COUNT];
217 * Locking functions for card level locking. We need to own both
218 * the kernel lock for the card and have the card in a position that
222 static inline int WaitTillCardIsFree(unsigned long base)
224 unsigned int count = 0;
225 unsigned int a = in_atomic(); /* do we run under spinlock? */
227 while (!(inw(base + 0xe) & 0x1) && count++ < 100)
233 return !(inw(base + 0xe) & 0x1);
236 static int lock_card(struct isi_board *card)
238 unsigned long base = card->base;
239 unsigned int retries, a;
241 for (retries = 0; retries < 10; retries++) {
242 spin_lock_irqsave(&card->card_lock, card->flags);
243 for (a = 0; a < 10; a++) {
244 if (inw(base + 0xe) & 0x1)
248 spin_unlock_irqrestore(&card->card_lock, card->flags);
251 printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n",
254 return 0; /* Failed to acquire the card! */
257 static void unlock_card(struct isi_board *card)
259 spin_unlock_irqrestore(&card->card_lock, card->flags);
263 * ISI Card specific ops ...
266 /* card->lock HAS to be held */
267 static void raise_dtr(struct isi_port *port)
269 struct isi_board *card = port->card;
270 unsigned long base = card->base;
271 u16 channel = port->channel;
273 if (WaitTillCardIsFree(base))
276 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
278 InterruptTheCard(base);
279 port->status |= ISI_DTR;
282 /* card->lock HAS to be held */
283 static inline void drop_dtr(struct isi_port *port)
285 struct isi_board *card = port->card;
286 unsigned long base = card->base;
287 u16 channel = port->channel;
289 if (WaitTillCardIsFree(base))
292 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
294 InterruptTheCard(base);
295 port->status &= ~ISI_DTR;
298 /* card->lock HAS to be held */
299 static inline void raise_rts(struct isi_port *port)
301 struct isi_board *card = port->card;
302 unsigned long base = card->base;
303 u16 channel = port->channel;
305 if (WaitTillCardIsFree(base))
308 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
310 InterruptTheCard(base);
311 port->status |= ISI_RTS;
314 /* card->lock HAS to be held */
315 static inline void drop_rts(struct isi_port *port)
317 struct isi_board *card = port->card;
318 unsigned long base = card->base;
319 u16 channel = port->channel;
321 if (WaitTillCardIsFree(base))
324 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
326 InterruptTheCard(base);
327 port->status &= ~ISI_RTS;
330 /* card->lock MUST NOT be held */
332 static void isicom_raise_dtr_rts(struct tty_port *port)
334 struct isi_port *ip = container_of(port, struct isi_port, port);
335 struct isi_board *card = ip->card;
336 unsigned long base = card->base;
337 u16 channel = ip->channel;
339 if (!lock_card(card))
342 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
344 InterruptTheCard(base);
345 ip->status |= (ISI_DTR | ISI_RTS);
349 /* card->lock HAS to be held */
350 static void drop_dtr_rts(struct isi_port *port)
352 struct isi_board *card = port->card;
353 unsigned long base = card->base;
354 u16 channel = port->channel;
356 if (WaitTillCardIsFree(base))
359 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
361 InterruptTheCard(base);
362 port->status &= ~(ISI_RTS | ISI_DTR);
366 * ISICOM Driver specific routines ...
370 static inline int __isicom_paranoia_check(struct isi_port const *port,
371 char *name, const char *routine)
374 printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
375 "dev %s in %s.\n", name, routine);
378 if (port->magic != ISICOM_MAGIC) {
379 printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
380 "dev %s in %s.\n", name, routine);
390 * We shovel data into the card buffers on a regular basis. The card
391 * will do the rest of the work for us.
394 static void isicom_tx(unsigned long _data)
396 unsigned long flags, base;
397 unsigned int retries;
398 short count = (BOARD_COUNT-1), card;
399 short txcount, wrd, residue, word_count, cnt;
400 struct isi_port *port;
401 struct tty_struct *tty;
403 /* find next active board */
404 card = (prev_card + 1) & 0x0003;
405 while (count-- > 0) {
406 if (isi_card[card].status & BOARD_ACTIVE)
408 card = (card + 1) & 0x0003;
410 if (!(isi_card[card].status & BOARD_ACTIVE))
415 count = isi_card[card].port_count;
416 port = isi_card[card].ports;
417 base = isi_card[card].base;
419 spin_lock_irqsave(&isi_card[card].card_lock, flags);
420 for (retries = 0; retries < 100; retries++) {
421 if (inw(base + 0xe) & 0x1)
428 tty = tty_port_tty_get(&port->port);
432 for (; count > 0; count--, port++) {
433 /* port not active or tx disabled to force flow control */
434 if (!(port->port.flags & ASYNC_INITIALIZED) ||
435 !(port->status & ISI_TXOK))
438 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
439 if (txcount <= 0 || tty->stopped || tty->hw_stopped)
442 if (!(inw(base + 0x02) & (1 << port->channel)))
445 pr_dbg("txing %d bytes, port%d.\n", txcount,
447 outw((port->channel << isi_card[card].shift_count) | txcount,
452 cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE
454 if (residue == YES) {
457 wrd |= (port->port.xmit_buf[port->xmit_tail]
459 port->xmit_tail = (port->xmit_tail + 1)
460 & (SERIAL_XMIT_SIZE - 1);
472 word_count = cnt >> 1;
473 outsw(base, port->port.xmit_buf+port->xmit_tail, word_count);
474 port->xmit_tail = (port->xmit_tail
475 + (word_count << 1)) & (SERIAL_XMIT_SIZE - 1);
476 txcount -= (word_count << 1);
477 port->xmit_cnt -= (word_count << 1);
480 wrd = port->port.xmit_buf[port->xmit_tail];
481 port->xmit_tail = (port->xmit_tail + 1)
482 & (SERIAL_XMIT_SIZE - 1);
488 InterruptTheCard(base);
489 if (port->xmit_cnt <= 0)
490 port->status &= ~ISI_TXOK;
491 if (port->xmit_cnt <= WAKEUP_CHARS)
498 spin_unlock_irqrestore(&isi_card[card].card_lock, flags);
499 /* schedule another tx for hopefully in about 10ms */
501 mod_timer(&tx, jiffies + msecs_to_jiffies(10));
505 * Main interrupt handler routine
508 static irqreturn_t isicom_interrupt(int irq, void *dev_id)
510 struct isi_board *card = dev_id;
511 struct isi_port *port;
512 struct tty_struct *tty;
514 u16 header, word_count, count, channel;
518 if (!card || !(card->status & FIRMWARE_LOADED))
523 /* did the card interrupt us? */
524 if (!(inw(base + 0x0e) & 0x02))
527 spin_lock(&card->card_lock);
530 * disable any interrupts from the PCI card and lower the
533 outw(0x8000, base+0x04);
534 ClearInterrupt(base);
536 inw(base); /* get the dummy word out */
538 channel = (header & 0x7800) >> card->shift_count;
539 byte_count = header & 0xff;
541 if (channel + 1 > card->port_count) {
542 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
543 "%d(channel) > port_count.\n", base, channel+1);
544 outw(0x0000, base+0x04); /* enable interrupts */
545 spin_unlock(&card->card_lock);
548 port = card->ports + channel;
549 if (!(port->port.flags & ASYNC_INITIALIZED)) {
550 outw(0x0000, base+0x04); /* enable interrupts */
551 spin_unlock(&card->card_lock);
555 tty = tty_port_tty_get(&port->port);
557 word_count = byte_count >> 1;
558 while (byte_count > 1) {
562 if (byte_count & 0x01)
564 outw(0x0000, base+0x04); /* enable interrupts */
565 spin_unlock(&card->card_lock);
569 if (header & 0x8000) { /* Status Packet */
571 switch (header & 0xff) {
572 case 0: /* Change in EIA signals */
573 if (port->port.flags & ASYNC_CHECK_CD) {
574 if (port->status & ISI_DCD) {
575 if (!(header & ISI_DCD)) {
576 /* Carrier has been lost */
577 pr_dbg("interrupt: DCD->low.\n"
579 port->status &= ~ISI_DCD;
582 } else if (header & ISI_DCD) {
583 /* Carrier has been detected */
584 pr_dbg("interrupt: DCD->high.\n");
585 port->status |= ISI_DCD;
586 wake_up_interruptible(&port->port.open_wait);
589 if (header & ISI_DCD)
590 port->status |= ISI_DCD;
592 port->status &= ~ISI_DCD;
595 if (port->port.flags & ASYNC_CTS_FLOW) {
596 if (tty->hw_stopped) {
597 if (header & ISI_CTS) {
598 port->port.tty->hw_stopped = 0;
600 port->status |= (ISI_TXOK
604 } else if (!(header & ISI_CTS)) {
607 port->status &= ~(ISI_TXOK | ISI_CTS);
610 if (header & ISI_CTS)
611 port->status |= ISI_CTS;
613 port->status &= ~ISI_CTS;
616 if (header & ISI_DSR)
617 port->status |= ISI_DSR;
619 port->status &= ~ISI_DSR;
622 port->status |= ISI_RI;
624 port->status &= ~ISI_RI;
628 case 1: /* Received Break !!! */
629 tty_insert_flip_char(tty, 0, TTY_BREAK);
630 if (port->port.flags & ASYNC_SAK)
632 tty_flip_buffer_push(tty);
635 case 2: /* Statistics */
636 pr_dbg("isicom_interrupt: stats!!!.\n");
640 pr_dbg("Intr: Unknown code in status packet.\n");
643 } else { /* Data Packet */
645 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
646 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
647 word_count = count >> 1;
648 insw(base, rp, word_count);
649 byte_count -= (word_count << 1);
650 if (count & 0x0001) {
651 tty_insert_flip_char(tty, inw(base) & 0xff,
655 if (byte_count > 0) {
656 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
657 "bytes...\n", base, channel + 1);
658 /* drain out unread xtra data */
659 while (byte_count > 0) {
664 tty_flip_buffer_push(tty);
666 outw(0x0000, base+0x04); /* enable interrupts */
667 spin_unlock(&card->card_lock);
673 static void isicom_config_port(struct tty_struct *tty)
675 struct isi_port *port = tty->driver_data;
676 struct isi_board *card = port->card;
678 unsigned long base = card->base;
679 u16 channel_setup, channel = port->channel,
680 shift_count = card->shift_count;
681 unsigned char flow_ctrl;
683 /* FIXME: Switch to new tty baud API */
685 if (baud & CBAUDEX) {
688 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
689 * then the card is programmed for 57.6Kbps or 115Kbps
693 /* 1,2,3,4 => 57.6, 115.2, 230, 460 kbps resp. */
694 if (baud < 1 || baud > 4)
695 tty->termios->c_cflag &= ~CBAUDEX;
701 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
702 * by the set_serial_info ioctl ... this is done by
703 * the 'setserial' utility.
706 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
707 baud++; /* 57.6 Kbps */
708 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
709 baud += 2; /* 115 Kbps */
710 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
711 baud += 3; /* 230 kbps*/
712 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
713 baud += 4; /* 460 kbps*/
715 if (linuxb_to_isib[baud] == -1) {
722 if (WaitTillCardIsFree(base) == 0) {
723 outw(0x8000 | (channel << shift_count) | 0x03, base);
724 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
726 switch (C_CSIZE(tty)) {
728 channel_setup |= ISICOM_CS5;
731 channel_setup |= ISICOM_CS6;
734 channel_setup |= ISICOM_CS7;
737 channel_setup |= ISICOM_CS8;
742 channel_setup |= ISICOM_2SB;
744 channel_setup |= ISICOM_EVPAR;
746 channel_setup |= ISICOM_ODPAR;
748 outw(channel_setup, base);
749 InterruptTheCard(base);
752 port->port.flags &= ~ASYNC_CHECK_CD;
754 port->port.flags |= ASYNC_CHECK_CD;
756 /* flow control settings ...*/
758 port->port.flags &= ~ASYNC_CTS_FLOW;
759 if (C_CRTSCTS(tty)) {
760 port->port.flags |= ASYNC_CTS_FLOW;
761 flow_ctrl |= ISICOM_CTSRTS;
764 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
766 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
768 if (WaitTillCardIsFree(base) == 0) {
769 outw(0x8000 | (channel << shift_count) | 0x04, base);
770 outw(flow_ctrl << 8 | 0x05, base);
771 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
772 InterruptTheCard(base);
775 /* rx enabled -> enable port for rx on the card */
777 card->port_status |= (1 << channel);
778 outw(card->port_status, base + 0x02);
784 static inline void isicom_setup_board(struct isi_board *bp)
787 struct isi_port *port;
790 spin_lock_irqsave(&bp->card_lock, flags);
791 if (bp->status & BOARD_ACTIVE) {
792 spin_unlock_irqrestore(&bp->card_lock, flags);
796 bp->status |= BOARD_ACTIVE;
797 for (channel = 0; channel < bp->port_count; channel++, port++)
799 spin_unlock_irqrestore(&bp->card_lock, flags);
802 static int isicom_setup_port(struct tty_struct *tty)
804 struct isi_port *port = tty->driver_data;
805 struct isi_board *card = port->card;
808 if (port->port.flags & ASYNC_INITIALIZED)
810 if (tty_port_alloc_xmit_buf(&port->port) < 0)
813 spin_lock_irqsave(&card->card_lock, flags);
814 clear_bit(TTY_IO_ERROR, &tty->flags);
815 if (port->port.count == 1)
818 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
820 /* discard any residual data */
821 if (WaitTillCardIsFree(card->base) == 0) {
822 outw(0x8000 | (port->channel << card->shift_count) | 0x02,
824 outw(((ISICOM_KILLTX | ISICOM_KILLRX) << 8) | 0x06, card->base);
825 InterruptTheCard(card->base);
828 isicom_config_port(tty);
829 port->port.flags |= ASYNC_INITIALIZED;
830 spin_unlock_irqrestore(&card->card_lock, flags);
835 static int isicom_carrier_raised(struct tty_port *port)
837 struct isi_port *ip = container_of(port, struct isi_port, port);
838 return (ip->status & ISI_DCD)?1 : 0;
841 static int block_til_ready(struct tty_struct *tty, struct file *filp,
844 struct isi_board *card = ip->card;
845 struct tty_port *port = &ip->port;
846 int do_clocal = 0, retval;
848 DECLARE_WAITQUEUE(wait, current);
851 /* block if port is in the process of being closed */
853 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
854 pr_dbg("block_til_ready: close in progress.\n");
855 interruptible_sleep_on(&port->close_wait);
856 if (port->flags & ASYNC_HUP_NOTIFY)
862 /* if non-blocking mode is set ... */
864 if ((filp->f_flags & O_NONBLOCK) ||
865 (tty->flags & (1 << TTY_IO_ERROR))) {
866 pr_dbg("block_til_ready: non-block mode.\n");
867 port->flags |= ASYNC_NORMAL_ACTIVE;
874 /* block waiting for DCD to be asserted, and while
875 callout dev is busy */
877 add_wait_queue(&port->open_wait, &wait);
879 spin_lock_irqsave(&card->card_lock, flags);
880 if (!tty_hung_up_p(filp))
882 port->blocked_open++;
883 spin_unlock_irqrestore(&card->card_lock, flags);
886 tty_port_raise_dtr_rts(port);
888 set_current_state(TASK_INTERRUPTIBLE);
889 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
890 if (port->flags & ASYNC_HUP_NOTIFY)
893 retval = -ERESTARTSYS;
896 cd = tty_port_carrier_raised(port);
897 if (!(port->flags & ASYNC_CLOSING) &&
900 if (signal_pending(current)) {
901 retval = -ERESTARTSYS;
906 set_current_state(TASK_RUNNING);
907 remove_wait_queue(&port->open_wait, &wait);
908 spin_lock_irqsave(&card->card_lock, flags);
909 if (!tty_hung_up_p(filp))
911 port->blocked_open--;
912 spin_unlock_irqrestore(&card->card_lock, flags);
915 port->flags |= ASYNC_NORMAL_ACTIVE;
919 static int isicom_open(struct tty_struct *tty, struct file *filp)
921 struct isi_port *port;
922 struct isi_board *card;
927 if (line < 0 || line > PORT_COUNT-1)
930 card = &isi_card[board];
932 if (!(card->status & FIRMWARE_LOADED))
935 /* open on a port greater than the port count for the card !!! */
936 if (line > ((board * 16) + card->port_count - 1))
939 port = &isi_ports[line];
940 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
943 isicom_setup_board(card);
946 tty->driver_data = port;
947 tty_port_tty_set(&port->port, tty);
948 error = isicom_setup_port(tty);
950 error = block_til_ready(tty, filp, port);
956 static inline void isicom_shutdown_board(struct isi_board *bp)
958 if (bp->status & BOARD_ACTIVE)
959 bp->status &= ~BOARD_ACTIVE;
962 /* card->lock HAS to be held */
963 static void isicom_shutdown_port(struct isi_port *port)
965 struct isi_board *card = port->card;
966 struct tty_struct *tty;
968 tty = tty_port_tty_get(&port->port);
970 if (!(port->port.flags & ASYNC_INITIALIZED)) {
975 tty_port_free_xmit_buf(&port->port);
976 port->port.flags &= ~ASYNC_INITIALIZED;
977 /* 3rd October 2000 : Vinayak P Risbud */
978 tty_port_tty_set(&port->port, NULL);
980 /*Fix done by Anil .S on 30-04-2001
981 remote login through isi port has dtr toggle problem
982 due to which the carrier drops before the password prompt
983 appears on the remote end. Now we drop the dtr only if the
984 HUPCL(Hangup on close) flag is set for the tty*/
987 /* drop dtr on this port */
990 /* any other port uninits */
992 set_bit(TTY_IO_ERROR, &tty->flags);
994 if (--card->count < 0) {
995 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
996 card->base, card->count);
1000 /* last port was closed, shutdown that boad too */
1003 isicom_shutdown_board(card);
1007 static void isicom_flush_buffer(struct tty_struct *tty)
1009 struct isi_port *port = tty->driver_data;
1010 struct isi_board *card = port->card;
1011 unsigned long flags;
1013 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
1016 spin_lock_irqsave(&card->card_lock, flags);
1017 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1018 spin_unlock_irqrestore(&card->card_lock, flags);
1023 static void isicom_close(struct tty_struct *tty, struct file *filp)
1025 struct isi_port *port = tty->driver_data;
1026 struct isi_board *card;
1027 unsigned long flags;
1032 if (isicom_paranoia_check(port, tty->name, "isicom_close"))
1035 pr_dbg("Close start!!!.\n");
1037 spin_lock_irqsave(&card->card_lock, flags);
1038 if (tty_hung_up_p(filp)) {
1039 spin_unlock_irqrestore(&card->card_lock, flags);
1043 if (tty->count == 1 && port->port.count != 1) {
1044 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1045 "count tty->count = 1 port count = %d.\n",
1046 card->base, port->port.count);
1047 port->port.count = 1;
1049 if (--port->port.count < 0) {
1050 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1051 "count for channel%d = %d", card->base, port->channel,
1053 port->port.count = 0;
1056 if (port->port.count) {
1057 spin_unlock_irqrestore(&card->card_lock, flags);
1060 port->port.flags |= ASYNC_CLOSING;
1062 spin_unlock_irqrestore(&card->card_lock, flags);
1064 if (port->port.closing_wait != ASYNC_CLOSING_WAIT_NONE)
1065 tty_wait_until_sent(tty, port->port.closing_wait);
1066 /* indicate to the card that no more data can be received
1068 spin_lock_irqsave(&card->card_lock, flags);
1069 if (port->port.flags & ASYNC_INITIALIZED) {
1070 card->port_status &= ~(1 << port->channel);
1071 outw(card->port_status, card->base + 0x02);
1073 isicom_shutdown_port(port);
1074 spin_unlock_irqrestore(&card->card_lock, flags);
1076 isicom_flush_buffer(tty);
1077 tty_ldisc_flush(tty);
1079 spin_lock_irqsave(&card->card_lock, flags);
1082 if (port->port.blocked_open) {
1083 spin_unlock_irqrestore(&card->card_lock, flags);
1084 if (port->port.close_delay) {
1085 pr_dbg("scheduling until time out.\n");
1086 msleep_interruptible(
1087 jiffies_to_msecs(port->port.close_delay));
1089 spin_lock_irqsave(&card->card_lock, flags);
1090 wake_up_interruptible(&port->port.open_wait);
1092 port->port.flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1093 wake_up_interruptible(&port->port.close_wait);
1094 spin_unlock_irqrestore(&card->card_lock, flags);
1098 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1101 struct isi_port *port = tty->driver_data;
1102 struct isi_board *card = port->card;
1103 unsigned long flags;
1106 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1109 spin_lock_irqsave(&card->card_lock, flags);
1112 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
1113 - 1, SERIAL_XMIT_SIZE - port->xmit_head));
1117 memcpy(port->port.xmit_buf + port->xmit_head, buf, cnt);
1118 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
1120 port->xmit_cnt += cnt;
1125 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1126 port->status |= ISI_TXOK;
1127 spin_unlock_irqrestore(&card->card_lock, flags);
1131 /* put_char et all */
1132 static int isicom_put_char(struct tty_struct *tty, unsigned char ch)
1134 struct isi_port *port = tty->driver_data;
1135 struct isi_board *card = port->card;
1136 unsigned long flags;
1138 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1141 spin_lock_irqsave(&card->card_lock, flags);
1142 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1143 spin_unlock_irqrestore(&card->card_lock, flags);
1147 port->port.xmit_buf[port->xmit_head++] = ch;
1148 port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1150 spin_unlock_irqrestore(&card->card_lock, flags);
1154 /* flush_chars et all */
1155 static void isicom_flush_chars(struct tty_struct *tty)
1157 struct isi_port *port = tty->driver_data;
1159 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1162 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1163 !port->port.xmit_buf)
1166 /* this tells the transmitter to consider this port for
1167 data output to the card ... that's the best we can do. */
1168 port->status |= ISI_TXOK;
1171 /* write_room et all */
1172 static int isicom_write_room(struct tty_struct *tty)
1174 struct isi_port *port = tty->driver_data;
1177 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1180 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1186 /* chars_in_buffer et all */
1187 static int isicom_chars_in_buffer(struct tty_struct *tty)
1189 struct isi_port *port = tty->driver_data;
1190 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1192 return port->xmit_cnt;
1196 static int isicom_send_break(struct tty_struct *tty, int length)
1198 struct isi_port *port = tty->driver_data;
1199 struct isi_board *card = port->card;
1200 unsigned long base = card->base;
1205 if (!lock_card(card))
1208 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1209 outw((length & 0xff) << 8 | 0x00, base);
1210 outw((length & 0xff00), base);
1211 InterruptTheCard(base);
1217 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1219 struct isi_port *port = tty->driver_data;
1220 /* just send the port status */
1221 u16 status = port->status;
1223 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1226 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1227 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1228 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1229 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1230 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1231 ((status & ISI_RI ) ? TIOCM_RI : 0);
1234 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1235 unsigned int set, unsigned int clear)
1237 struct isi_port *port = tty->driver_data;
1238 unsigned long flags;
1240 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1243 spin_lock_irqsave(&port->card->card_lock, flags);
1244 if (set & TIOCM_RTS)
1246 if (set & TIOCM_DTR)
1249 if (clear & TIOCM_RTS)
1251 if (clear & TIOCM_DTR)
1253 spin_unlock_irqrestore(&port->card->card_lock, flags);
1258 static int isicom_set_serial_info(struct tty_struct *tty,
1259 struct serial_struct __user *info)
1261 struct isi_port *port = tty->driver_data;
1262 struct serial_struct newinfo;
1265 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1270 reconfig_port = ((port->port.flags & ASYNC_SPD_MASK) !=
1271 (newinfo.flags & ASYNC_SPD_MASK));
1273 if (!capable(CAP_SYS_ADMIN)) {
1274 if ((newinfo.close_delay != port->port.close_delay) ||
1275 (newinfo.closing_wait != port->port.closing_wait) ||
1276 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1277 (port->port.flags & ~ASYNC_USR_MASK))) {
1281 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1282 (newinfo.flags & ASYNC_USR_MASK));
1284 port->port.close_delay = newinfo.close_delay;
1285 port->port.closing_wait = newinfo.closing_wait;
1286 port->port.flags = ((port->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(tty);
1293 spin_unlock_irqrestore(&port->card->card_lock, flags);
1299 static int isicom_get_serial_info(struct isi_port *port,
1300 struct serial_struct __user *info)
1302 struct serial_struct out_info;
1305 memset(&out_info, 0, sizeof(out_info));
1306 /* out_info.type = ? */
1307 out_info.line = port - isi_ports;
1308 out_info.port = port->card->base;
1309 out_info.irq = port->card->irq;
1310 out_info.flags = port->port.flags;
1311 /* out_info.baud_base = ? */
1312 out_info.close_delay = port->port.close_delay;
1313 out_info.closing_wait = port->port.closing_wait;
1315 if (copy_to_user(info, &out_info, sizeof(out_info)))
1320 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1321 unsigned int cmd, unsigned long arg)
1323 struct isi_port *port = tty->driver_data;
1324 void __user *argp = (void __user *)arg;
1326 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1331 return isicom_get_serial_info(port, argp);
1334 return isicom_set_serial_info(tty, argp);
1337 return -ENOIOCTLCMD;
1342 /* set_termios et all */
1343 static void isicom_set_termios(struct tty_struct *tty,
1344 struct ktermios *old_termios)
1346 struct isi_port *port = tty->driver_data;
1347 unsigned long flags;
1349 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1352 if (tty->termios->c_cflag == old_termios->c_cflag &&
1353 tty->termios->c_iflag == old_termios->c_iflag)
1356 spin_lock_irqsave(&port->card->card_lock, flags);
1357 isicom_config_port(tty);
1358 spin_unlock_irqrestore(&port->card->card_lock, flags);
1360 if ((old_termios->c_cflag & CRTSCTS) &&
1361 !(tty->termios->c_cflag & CRTSCTS)) {
1362 tty->hw_stopped = 0;
1367 /* throttle et all */
1368 static void isicom_throttle(struct tty_struct *tty)
1370 struct isi_port *port = tty->driver_data;
1371 struct isi_board *card = port->card;
1373 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1376 /* tell the card that this port cannot handle any more data for now */
1377 card->port_status &= ~(1 << port->channel);
1378 outw(card->port_status, card->base + 0x02);
1381 /* unthrottle et all */
1382 static void isicom_unthrottle(struct tty_struct *tty)
1384 struct isi_port *port = tty->driver_data;
1385 struct isi_board *card = port->card;
1387 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1390 /* tell the card that this port is ready to accept more data */
1391 card->port_status |= (1 << port->channel);
1392 outw(card->port_status, card->base + 0x02);
1396 static void isicom_stop(struct tty_struct *tty)
1398 struct isi_port *port = tty->driver_data;
1400 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1403 /* this tells the transmitter not to consider this port for
1404 data output to the card. */
1405 port->status &= ~ISI_TXOK;
1409 static void isicom_start(struct tty_struct *tty)
1411 struct isi_port *port = tty->driver_data;
1413 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1416 /* this tells the transmitter to consider this port for
1417 data output to the card. */
1418 port->status |= ISI_TXOK;
1421 static void isicom_hangup(struct tty_struct *tty)
1423 struct isi_port *port = tty->driver_data;
1424 unsigned long flags;
1426 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1429 spin_lock_irqsave(&port->card->card_lock, flags);
1430 isicom_shutdown_port(port);
1431 spin_unlock_irqrestore(&port->card->card_lock, flags);
1433 port->port.count = 0;
1434 port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1435 tty_port_tty_set(&port->port, NULL);
1436 wake_up_interruptible(&port->port.open_wait);
1441 * Driver init and deinit functions
1444 static const struct tty_operations isicom_ops = {
1445 .open = isicom_open,
1446 .close = isicom_close,
1447 .write = isicom_write,
1448 .put_char = isicom_put_char,
1449 .flush_chars = isicom_flush_chars,
1450 .write_room = isicom_write_room,
1451 .chars_in_buffer = isicom_chars_in_buffer,
1452 .ioctl = isicom_ioctl,
1453 .set_termios = isicom_set_termios,
1454 .throttle = isicom_throttle,
1455 .unthrottle = isicom_unthrottle,
1456 .stop = isicom_stop,
1457 .start = isicom_start,
1458 .hangup = isicom_hangup,
1459 .flush_buffer = isicom_flush_buffer,
1460 .tiocmget = isicom_tiocmget,
1461 .tiocmset = isicom_tiocmset,
1462 .break_ctl = isicom_send_break,
1465 static const struct tty_port_operations isicom_port_ops = {
1466 .carrier_raised = isicom_carrier_raised,
1467 .raise_dtr_rts = isicom_raise_dtr_rts,
1470 static int __devinit reset_card(struct pci_dev *pdev,
1471 const unsigned int card, unsigned int *signature)
1473 struct isi_board *board = pci_get_drvdata(pdev);
1474 unsigned long base = board->base;
1475 unsigned int sig, portcount = 0;
1478 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1485 outw(0, base + 0x8); /* Reset */
1489 sig = inw(base + 0x4) & 0xff;
1491 if (sig != 0xa5 && sig != 0xbb && sig != 0xcc && sig != 0xdd &&
1493 dev_warn(&pdev->dev, "ISILoad:Card%u reset failure (Possible "
1494 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1495 dev_dbg(&pdev->dev, "Sig=0x%x\n", sig);
1502 portcount = inw(base + 0x2);
1503 if (!(inw(base + 0xe) & 0x1) || (portcount != 0 && portcount != 4 &&
1504 portcount != 8 && portcount != 16)) {
1505 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure.\n",
1515 board->port_count = (portcount == 4) ? 4 : 8;
1516 board->shift_count = 12;
1520 board->port_count = 16;
1521 board->shift_count = 11;
1524 dev_info(&pdev->dev, "-Done\n");
1531 static int __devinit load_firmware(struct pci_dev *pdev,
1532 const unsigned int index, const unsigned int signature)
1534 struct isi_board *board = pci_get_drvdata(pdev);
1535 const struct firmware *fw;
1536 unsigned long base = board->base;
1538 u16 word_count, status;
1549 switch (signature) {
1551 name = "isi608.bin";
1554 name = "isi608em.bin";
1557 name = "isi616em.bin";
1560 name = "isi4608.bin";
1563 name = "isi4616.bin";
1566 dev_err(&pdev->dev, "Unknown signature.\n");
1570 retval = request_firmware(&fw, name, &pdev->dev);
1576 for (frame = (struct stframe *)fw->data;
1577 frame < (struct stframe *)(fw->data + fw->size);
1578 frame = (struct stframe *)((u8 *)(frame + 1) +
1580 if (WaitTillCardIsFree(base))
1583 outw(0xf0, base); /* start upload sequence */
1585 outw(frame->addr, base); /* lsb of address */
1587 word_count = frame->count / 2 + frame->count % 2;
1588 outw(word_count, base);
1589 InterruptTheCard(base);
1591 udelay(100); /* 0x2f */
1593 if (WaitTillCardIsFree(base))
1596 status = inw(base + 0x4);
1598 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1599 KERN_WARNING "Address:0x%x\n"
1600 KERN_WARNING "Count:0x%x\n"
1601 KERN_WARNING "Status:0x%x\n",
1602 index + 1, frame->addr, frame->count, status);
1605 outsw(base, frame->data, word_count);
1607 InterruptTheCard(base);
1609 udelay(50); /* 0x0f */
1611 if (WaitTillCardIsFree(base))
1614 status = inw(base + 0x4);
1616 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1617 "Status:0x%x\n", index + 1, status);
1622 /* XXX: should we test it by reading it back and comparing with original like
1623 * in load firmware package? */
1624 for (frame = (struct stframe *)fw->data;
1625 frame < (struct stframe *)(fw->data + fw->size);
1626 frame = (struct stframe *)((u8 *)(frame + 1) +
1628 if (WaitTillCardIsFree(base))
1631 outw(0xf1, base); /* start download sequence */
1633 outw(frame->addr, base); /* lsb of address */
1635 word_count = (frame->count >> 1) + frame->count % 2;
1636 outw(word_count + 1, base);
1637 InterruptTheCard(base);
1639 udelay(50); /* 0xf */
1641 if (WaitTillCardIsFree(base))
1644 status = inw(base + 0x4);
1646 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1647 KERN_WARNING "Address:0x%x\n"
1648 KERN_WARNING "Count:0x%x\n"
1649 KERN_WARNING "Status: 0x%x\n",
1650 index + 1, frame->addr, frame->count, status);
1654 data = kmalloc(word_count * 2, GFP_KERNEL);
1656 dev_err(&pdev->dev, "Card%d, firmware upload "
1657 "failed, not enough memory\n", index + 1);
1661 insw(base, data, word_count);
1662 InterruptTheCard(base);
1664 for (a = 0; a < frame->count; a++)
1665 if (data[a] != frame->data[a]) {
1667 dev_err(&pdev->dev, "Card%d, firmware upload "
1668 "failed\n", index + 1);
1673 udelay(50); /* 0xf */
1675 if (WaitTillCardIsFree(base))
1678 status = inw(base + 0x4);
1680 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1681 "Card Status:0x%x\n", index + 1, status);
1687 if (WaitTillCardIsFree(base))
1694 InterruptTheCard(base);
1695 outw(0x0, base + 0x4); /* for ISI4608 cards */
1697 board->status |= FIRMWARE_LOADED;
1701 release_firmware(fw);
1707 * Insmod can set static symbols so keep these static
1709 static unsigned int card_count;
1711 static int __devinit isicom_probe(struct pci_dev *pdev,
1712 const struct pci_device_id *ent)
1714 unsigned int signature, index;
1715 int retval = -EPERM;
1716 struct isi_board *board = NULL;
1718 if (card_count >= BOARD_COUNT)
1721 retval = pci_enable_device(pdev);
1723 dev_err(&pdev->dev, "failed to enable\n");
1727 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1729 /* allot the first empty slot in the array */
1730 for (index = 0; index < BOARD_COUNT; index++)
1731 if (isi_card[index].base == 0) {
1732 board = &isi_card[index];
1736 board->index = index;
1737 board->base = pci_resource_start(pdev, 3);
1738 board->irq = pdev->irq;
1741 pci_set_drvdata(pdev, board);
1743 retval = pci_request_region(pdev, 3, ISICOM_NAME);
1745 dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1746 "will be disabled.\n", board->base, board->base + 15,
1752 retval = request_irq(board->irq, isicom_interrupt,
1753 IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
1755 dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1756 "Card%d will be disabled.\n", board->irq, index + 1);
1760 retval = reset_card(pdev, index, &signature);
1764 retval = load_firmware(pdev, index, signature);
1768 for (index = 0; index < board->port_count; index++)
1769 tty_register_device(isicom_normal, board->index * 16 + index,
1775 free_irq(board->irq, board);
1777 pci_release_region(pdev, 3);
1781 pci_disable_device(pdev);
1786 static void __devexit isicom_remove(struct pci_dev *pdev)
1788 struct isi_board *board = pci_get_drvdata(pdev);
1791 for (i = 0; i < board->port_count; i++)
1792 tty_unregister_device(isicom_normal, board->index * 16 + i);
1794 free_irq(board->irq, board);
1795 pci_release_region(pdev, 3);
1798 pci_disable_device(pdev);
1801 static int __init isicom_init(void)
1803 int retval, idx, channel;
1804 struct isi_port *port;
1806 for (idx = 0; idx < BOARD_COUNT; idx++) {
1807 port = &isi_ports[idx * 16];
1808 isi_card[idx].ports = port;
1809 spin_lock_init(&isi_card[idx].card_lock);
1810 for (channel = 0; channel < 16; channel++, port++) {
1811 tty_port_init(&port->port);
1812 port->port.ops = &isicom_port_ops;
1813 port->magic = ISICOM_MAGIC;
1814 port->card = &isi_card[idx];
1815 port->channel = channel;
1816 port->port.close_delay = 50 * HZ/100;
1817 port->port.closing_wait = 3000 * HZ/100;
1821 isi_card[idx].base = 0;
1822 isi_card[idx].irq = 0;
1825 /* tty driver structure initialization */
1826 isicom_normal = alloc_tty_driver(PORT_COUNT);
1827 if (!isicom_normal) {
1832 isicom_normal->owner = THIS_MODULE;
1833 isicom_normal->name = "ttyM";
1834 isicom_normal->major = ISICOM_NMAJOR;
1835 isicom_normal->minor_start = 0;
1836 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1837 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1838 isicom_normal->init_termios = tty_std_termios;
1839 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1841 isicom_normal->flags = TTY_DRIVER_REAL_RAW |
1842 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK;
1843 tty_set_operations(isicom_normal, &isicom_ops);
1845 retval = tty_register_driver(isicom_normal);
1847 pr_dbg("Couldn't register the dialin driver\n");
1851 retval = pci_register_driver(&isicom_driver);
1853 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1857 mod_timer(&tx, jiffies + 1);
1861 tty_unregister_driver(isicom_normal);
1863 put_tty_driver(isicom_normal);
1868 static void __exit isicom_exit(void)
1870 del_timer_sync(&tx);
1872 pci_unregister_driver(&isicom_driver);
1873 tty_unregister_driver(isicom_normal);
1874 put_tty_driver(isicom_normal);
1877 module_init(isicom_init);
1878 module_exit(isicom_exit);
1880 MODULE_AUTHOR("MultiTech");
1881 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1882 MODULE_LICENSE("GPL");