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.
112 * 64-bit verification
115 #include <linux/module.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/miscdevice.h>
125 #include <linux/interrupt.h>
126 #include <linux/timer.h>
127 #include <linux/delay.h>
128 #include <linux/ioport.h>
130 #include <asm/uaccess.h>
132 #include <asm/system.h>
134 #include <linux/pci.h>
136 #include <linux/isicom.h>
138 #define InterruptTheCard(base) outw(0, (base) + 0xc)
139 #define ClearInterrupt(base) inw((base) + 0x0a)
142 #define pr_dbg(str...) printk(KERN_DEBUG "ISICOM: " str)
143 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
145 #define pr_dbg(str...) do { } while (0)
146 #define isicom_paranoia_check(a, b, c) 0
149 static struct pci_device_id isicom_pci_tbl[] = {
150 { VENDOR_ID, 0x2028, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
151 { VENDOR_ID, 0x2051, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
152 { VENDOR_ID, 0x2052, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
153 { VENDOR_ID, 0x2053, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
154 { VENDOR_ID, 0x2054, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
155 { VENDOR_ID, 0x2055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
156 { VENDOR_ID, 0x2056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
157 { VENDOR_ID, 0x2057, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
158 { VENDOR_ID, 0x2058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
161 MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
163 static int prev_card = 3; /* start servicing isi_card[0] */
164 static struct tty_driver *isicom_normal;
166 static struct timer_list tx;
167 static char re_schedule = 1;
169 static int ISILoad_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
171 static void isicom_tx(unsigned long _data);
172 static void isicom_start(struct tty_struct *tty);
174 static unsigned char *tmp_buf;
176 /* baud index mappings from linux defns to isi */
178 static signed char linuxb_to_isib[] = {
179 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19
185 unsigned char port_count;
186 unsigned short status;
187 unsigned short port_status; /* each bit represents a single port */
188 unsigned short shift_count;
189 struct isi_port * ports;
192 spinlock_t card_lock; /* Card wide lock 11/5/00 -sameer */
197 unsigned short magic;
205 struct isi_board * card;
206 struct tty_struct * tty;
207 wait_queue_head_t close_wait;
208 wait_queue_head_t open_wait;
209 struct work_struct hangup_tq;
210 struct work_struct bh_tqueue;
211 unsigned char * xmit_buf;
217 static struct isi_board isi_card[BOARD_COUNT];
218 static struct isi_port isi_ports[PORT_COUNT];
221 * Locking functions for card level locking. We need to own both
222 * the kernel lock for the card and have the card in a position that
226 static int lock_card(struct isi_board *card)
229 unsigned long base = card->base;
231 for (retries = 0; retries < 100; retries++) {
232 spin_lock_irqsave(&card->card_lock, card->flags);
233 if (inw(base + 0xe) & 0x1) {
236 spin_unlock_irqrestore(&card->card_lock, card->flags);
237 udelay(1000); /* 1ms */
240 printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n", card->base);
241 return 0; /* Failed to aquire the card! */
244 static int lock_card_at_interrupt(struct isi_board *card)
246 unsigned char retries;
247 unsigned long base = card->base;
249 for (retries = 0; retries < 200; retries++) {
250 spin_lock_irqsave(&card->card_lock, card->flags);
252 if (inw(base + 0xe) & 0x1)
255 spin_unlock_irqrestore(&card->card_lock, card->flags);
257 /* Failing in interrupt is an acceptable event */
258 return 0; /* Failed to aquire the card! */
261 static void unlock_card(struct isi_board *card)
263 spin_unlock_irqrestore(&card->card_lock, card->flags);
267 * ISI Card specific ops ...
270 static void raise_dtr(struct isi_port *port)
272 struct isi_board *card = port->card;
273 unsigned long base = card->base;
274 u16 channel = port->channel;
276 if (!lock_card(card))
279 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
281 InterruptTheCard(base);
282 port->status |= ISI_DTR;
286 static inline void drop_dtr(struct isi_port *port)
288 struct isi_board *card = port->card;
289 unsigned long base = card->base;
290 u16 channel = port->channel;
292 if (!lock_card(card))
295 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
297 InterruptTheCard(base);
298 port->status &= ~ISI_DTR;
302 static inline void raise_rts(struct isi_port *port)
304 struct isi_board *card = port->card;
305 unsigned long base = card->base;
306 u16 channel = port->channel;
308 if (!lock_card(card))
311 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
313 InterruptTheCard(base);
314 port->status |= ISI_RTS;
317 static inline void drop_rts(struct isi_port *port)
319 struct isi_board *card = port->card;
320 unsigned long base = card->base;
321 u16 channel = port->channel;
323 if (!lock_card(card))
326 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
328 InterruptTheCard(base);
329 port->status &= ~ISI_RTS;
333 static inline void raise_dtr_rts(struct isi_port *port)
335 struct isi_board *card = port->card;
336 unsigned long base = card->base;
337 u16 channel = port->channel;
339 if (!lock_card(card))
342 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
344 InterruptTheCard(base);
345 port->status |= (ISI_DTR | ISI_RTS);
349 static void drop_dtr_rts(struct isi_port *port)
351 struct isi_board *card = port->card;
352 unsigned long base = card->base;
353 u16 channel = port->channel;
355 if (!lock_card(card))
358 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
360 InterruptTheCard(base);
361 port->status &= ~(ISI_RTS | ISI_DTR);
365 static inline void kill_queue(struct isi_port *port, short queue)
367 struct isi_board *card = port->card;
368 unsigned long base = card->base;
369 u16 channel = port->channel;
371 if (!lock_card(card))
374 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
375 outw((queue << 8) | 0x06, base);
376 InterruptTheCard(base);
382 * Firmware loader driver specific routines. This needs to mostly die
383 * and be replaced with request_firmware.
386 static struct file_operations ISILoad_fops = {
387 .owner = THIS_MODULE,
388 .ioctl = ISILoad_ioctl,
391 static struct miscdevice isiloader_device = {
392 ISILOAD_MISC_MINOR, "isictl", &ISILoad_fops
396 static inline int WaitTillCardIsFree(unsigned long base)
398 unsigned long count=0;
399 while( (!(inw(base+0xe) & 0x1)) && (count++ < 6000000));
400 if (inw(base+0xe)&0x1)
406 static int ISILoad_ioctl(struct inode *inode, struct file *filp,
407 unsigned int cmd, unsigned long arg)
409 unsigned int card, i, j, signature, status, portcount = 0;
410 unsigned long t, base;
413 void __user *argp = (void __user *)arg;
414 /* exec_record exec_rec; */
416 if (get_user(card, (int __user *)argp))
419 if (card < 0 || card >= BOARD_COUNT)
422 base=isi_card[card].base;
425 return -ENXIO; /* disabled or not used */
428 case MIOCTL_RESET_CARD:
429 if (!capable(CAP_SYS_ADMIN))
431 printk(KERN_DEBUG "ISILoad:Resetting Card%d at 0x%lx ",card+1,base);
435 for (t=jiffies+HZ/100;time_before(jiffies, t););
437 outw(0,base+0x8); /* Reset */
440 for (t=jiffies+HZ;time_before(jiffies, t););
443 signature=(inw(base+0x4)) & 0xff;
444 if (isi_card[card].isa) {
446 if (!(inw(base+0xe) & 0x1) || (inw(base+0x2))) {
448 printk("\nbase+0x2=0x%x , base+0xe=0x%x",inw(base+0x2),inw(base+0xe));
450 printk("\nISILoad:ISA Card%d reset failure (Possible bad I/O Port Address 0x%lx).\n",card+1,base);
455 portcount = inw(base+0x2);
456 if (!(inw(base+0xe) & 0x1) || ((portcount!=0) && (portcount!=4) && (portcount!=8))) {
458 printk("\nbase+0x2=0x%x , base+0xe=0x%x",inw(base+0x2),inw(base+0xe));
460 printk("\nISILoad:PCI Card%d reset failure (Possible bad I/O Port Address 0x%lx).\n",card+1,base);
468 if (isi_card[card].isa)
469 isi_card[card].port_count = 8;
472 isi_card[card].port_count = 4;
474 isi_card[card].port_count = 8;
476 isi_card[card].shift_count = 12;
479 case 0xcc: isi_card[card].port_count = 16;
480 isi_card[card].shift_count = 11;
483 default: printk("ISILoad:Card%d reset failure (Possible bad I/O Port Address 0x%lx).\n",card+1,base);
485 printk("Sig=0x%x\n",signature);
490 return put_user(signature,(unsigned __user *)argp);
492 case MIOCTL_LOAD_FIRMWARE:
493 if (!capable(CAP_SYS_ADMIN))
496 if (copy_from_user(&frame, argp, sizeof(bin_frame)))
499 if (WaitTillCardIsFree(base))
502 outw(0xf0,base); /* start upload sequence */
504 outw((frame.addr), base); /* lsb of adderess */
506 word_count=(frame.count >> 1) + frame.count % 2;
507 outw(word_count, base);
508 InterruptTheCard(base);
510 for (i=0;i<=0x2f;i++); /* a wee bit of delay */
512 if (WaitTillCardIsFree(base))
515 if ((status=inw(base+0x4))!=0) {
516 printk(KERN_WARNING "ISILoad:Card%d rejected load header:\nAddress:0x%x \nCount:0x%x \nStatus:0x%x \n",
517 card+1, frame.addr, frame.count, status);
520 outsw(base, (void *) frame.bin_data, word_count);
522 InterruptTheCard(base);
524 for (i=0;i<=0x0f;i++); /* another wee bit of delay */
526 if (WaitTillCardIsFree(base))
529 if ((status=inw(base+0x4))!=0) {
530 printk(KERN_ERR "ISILoad:Card%d got out of sync.Card Status:0x%x\n",card+1, status);
535 case MIOCTL_READ_FIRMWARE:
536 if (!capable(CAP_SYS_ADMIN))
539 if (copy_from_user(&frame, argp, sizeof(bin_header)))
542 if (WaitTillCardIsFree(base))
545 outw(0xf1,base); /* start download sequence */
547 outw((frame.addr), base); /* lsb of adderess */
549 word_count=(frame.count >> 1) + frame.count % 2;
550 outw(word_count+1, base);
551 InterruptTheCard(base);
553 for (i=0;i<=0xf;i++); /* a wee bit of delay */
555 if (WaitTillCardIsFree(base))
558 if ((status=inw(base+0x4))!=0) {
559 printk(KERN_WARNING "ISILoad:Card%d rejected verify header:\nAddress:0x%x \nCount:0x%x \nStatus:0x%x \n",
560 card+1, frame.addr, frame.count, status);
565 insw(base, frame.bin_data, word_count);
566 InterruptTheCard(base);
568 for (i=0;i<=0x0f;i++); /* another wee bit of delay */
570 if (WaitTillCardIsFree(base))
573 if ((status=inw(base+0x4))!=0) {
574 printk(KERN_ERR "ISILoad:Card%d verify got out of sync.Card Status:0x%x\n",card+1, status);
578 if (copy_to_user(argp, &frame, sizeof(bin_frame)))
582 case MIOCTL_XFER_CTRL:
583 if (!capable(CAP_SYS_ADMIN))
585 if (WaitTillCardIsFree(base))
592 InterruptTheCard(base);
593 outw(0x0, base+0x4); /* for ISI4608 cards */
595 isi_card[card].status |= FIRMWARE_LOADED;
600 printk(KERN_DEBUG "ISILoad: Received Ioctl cmd 0x%x.\n", cmd);
608 * ISICOM Driver specific routines ...
612 static inline int __isicom_paranoia_check(struct isi_port const *port,
613 char *name, const char *routine)
616 printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
617 "dev %s in %s.\n", name, routine);
620 if (port->magic != ISICOM_MAGIC) {
621 printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
622 "dev %s in %s.\n", name, routine);
632 * We shovel data into the card buffers on a regular basis. The card
633 * will do the rest of the work for us.
636 static void isicom_tx(unsigned long _data)
638 short count = (BOARD_COUNT-1), card, base;
639 short txcount, wrd, residue, word_count, cnt;
640 struct isi_port *port;
641 struct tty_struct *tty;
643 /* find next active board */
644 card = (prev_card + 1) & 0x0003;
646 if (isi_card[card].status & BOARD_ACTIVE)
648 card = (card + 1) & 0x0003;
650 if (!(isi_card[card].status & BOARD_ACTIVE))
655 count = isi_card[card].port_count;
656 port = isi_card[card].ports;
657 base = isi_card[card].base;
658 for (;count > 0;count--, port++) {
659 if (!lock_card_at_interrupt(&isi_card[card]))
661 /* port not active or tx disabled to force flow control */
662 if (!(port->flags & ASYNC_INITIALIZED) ||
663 !(port->status & ISI_TXOK))
664 unlock_card(&isi_card[card]);
671 unlock_card(&isi_card[card]);
675 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
676 if (txcount <= 0 || tty->stopped || tty->hw_stopped) {
677 unlock_card(&isi_card[card]);
680 if (!(inw(base + 0x02) & (1 << port->channel))) {
681 unlock_card(&isi_card[card]);
684 pr_dbg("txing %d bytes, port%d.\n", txcount,
686 outw((port->channel << isi_card[card].shift_count) | txcount,
691 cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE - port->xmit_tail));
692 if (residue == YES) {
695 wrd |= (port->xmit_buf[port->xmit_tail] << 8);
696 port->xmit_tail = (port->xmit_tail + 1) & (SERIAL_XMIT_SIZE - 1);
708 word_count = cnt >> 1;
709 outsw(base, port->xmit_buf+port->xmit_tail, word_count);
710 port->xmit_tail = (port->xmit_tail + (word_count << 1)) &
711 (SERIAL_XMIT_SIZE - 1);
712 txcount -= (word_count << 1);
713 port->xmit_cnt -= (word_count << 1);
716 wrd = port->xmit_buf[port->xmit_tail];
717 port->xmit_tail = (port->xmit_tail + 1) & (SERIAL_XMIT_SIZE - 1);
723 InterruptTheCard(base);
724 if (port->xmit_cnt <= 0)
725 port->status &= ~ISI_TXOK;
726 if (port->xmit_cnt <= WAKEUP_CHARS)
727 schedule_work(&port->bh_tqueue);
728 unlock_card(&isi_card[card]);
731 /* schedule another tx for hopefully in about 10ms */
739 tx.expires = jiffies + HZ/100;
741 tx.function = isicom_tx;
747 /* Interrupt handlers */
750 static void isicom_bottomhalf(void *data)
752 struct isi_port *port = (struct isi_port *) data;
753 struct tty_struct *tty = port->tty;
759 wake_up_interruptible(&tty->write_wait);
763 * Main interrupt handler routine
766 static irqreturn_t isicom_interrupt(int irq, void *dev_id, struct pt_regs *regs)
768 struct isi_board *card = dev_id;
769 struct isi_port *port;
770 struct tty_struct *tty;
772 u16 header, word_count, count, channel;
776 if (!card || !(card->status & FIRMWARE_LOADED))
780 spin_lock(&card->card_lock);
782 if (card->isa == NO) {
784 * disable any interrupts from the PCI card and lower the
787 outw(0x8000, base+0x04);
788 ClearInterrupt(base);
791 inw(base); /* get the dummy word out */
793 channel = (header & 0x7800) >> card->shift_count;
794 byte_count = header & 0xff;
796 if (channel + 1 > card->port_count) {
797 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): %d(channel) > port_count.\n",
800 ClearInterrupt(base);
802 outw(0x0000, base+0x04); /* enable interrupts */
803 spin_unlock(&card->card_lock);
806 port = card->ports + channel;
807 if (!(port->flags & ASYNC_INITIALIZED)) {
809 ClearInterrupt(base);
811 outw(0x0000, base+0x04); /* enable interrupts */
817 word_count = byte_count >> 1;
818 while(byte_count > 1) {
822 if (byte_count & 0x01)
824 if (card->isa == YES)
825 ClearInterrupt(base);
827 outw(0x0000, base+0x04); /* enable interrupts */
828 spin_unlock(&card->card_lock);
832 if (header & 0x8000) { /* Status Packet */
834 switch(header & 0xff) {
835 case 0: /* Change in EIA signals */
837 if (port->flags & ASYNC_CHECK_CD) {
838 if (port->status & ISI_DCD) {
839 if (!(header & ISI_DCD)) {
840 /* Carrier has been lost */
841 pr_dbg("interrupt: DCD->low.\n");
842 port->status &= ~ISI_DCD;
843 schedule_work(&port->hangup_tq);
847 if (header & ISI_DCD) {
848 /* Carrier has been detected */
849 pr_dbg("interrupt: DCD->high.\n");
850 port->status |= ISI_DCD;
851 wake_up_interruptible(&port->open_wait);
856 if (header & ISI_DCD)
857 port->status |= ISI_DCD;
859 port->status &= ~ISI_DCD;
862 if (port->flags & ASYNC_CTS_FLOW) {
863 if (port->tty->hw_stopped) {
864 if (header & ISI_CTS) {
865 port->tty->hw_stopped = 0;
867 port->status |= (ISI_TXOK | ISI_CTS);
868 schedule_work(&port->bh_tqueue);
872 if (!(header & ISI_CTS)) {
873 port->tty->hw_stopped = 1;
875 port->status &= ~(ISI_TXOK | ISI_CTS);
880 if (header & ISI_CTS)
881 port->status |= ISI_CTS;
883 port->status &= ~ISI_CTS;
886 if (header & ISI_DSR)
887 port->status |= ISI_DSR;
889 port->status &= ~ISI_DSR;
892 port->status |= ISI_RI;
894 port->status &= ~ISI_RI;
898 case 1: /* Received Break !!! */
899 tty_insert_flip_char(tty, 0, TTY_BREAK);
900 if (port->flags & ASYNC_SAK)
902 tty_flip_buffer_push(tty);
905 case 2: /* Statistics */
906 pr_dbg("isicom_interrupt: stats!!!.\n");
910 pr_dbg("Intr: Unknown code in status packet.\n");
914 else { /* Data Packet */
916 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
917 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
918 word_count = count >> 1;
919 insw(base, rp, word_count);
920 byte_count -= (word_count << 1);
921 if (count & 0x0001) {
922 tty_insert_flip_char(tty, inw(base) & 0xff, TTY_NORMAL);
925 if (byte_count > 0) {
926 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
927 "bytes...\n", base, channel + 1);
928 while(byte_count > 0) { /* drain out unread xtra data */
933 tty_flip_buffer_push(tty);
935 if (card->isa == YES)
936 ClearInterrupt(base);
938 outw(0x0000, base+0x04); /* enable interrupts */
942 static void isicom_config_port(struct isi_port *port)
944 struct isi_board *card = port->card;
945 struct tty_struct *tty;
947 unsigned long base = card->base;
948 u16 channel_setup, channel = port->channel,
949 shift_count = card->shift_count;
950 unsigned char flow_ctrl;
952 if (!(tty = port->tty) || !tty->termios)
955 if (baud & CBAUDEX) {
958 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
959 * then the card is programmed for 57.6Kbps or 115Kbps
963 if (baud < 1 || baud > 2)
964 port->tty->termios->c_cflag &= ~CBAUDEX;
970 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
971 * by the set_serial_info ioctl ... this is done by
972 * the 'setserial' utility.
975 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
976 baud++; /* 57.6 Kbps */
977 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
978 baud +=2; /* 115 Kbps */
980 if (linuxb_to_isib[baud] == -1) {
988 if (lock_card(card)) {
989 outw(0x8000 | (channel << shift_count) |0x03, base);
990 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
992 switch(C_CSIZE(tty)) {
994 channel_setup |= ISICOM_CS5;
997 channel_setup |= ISICOM_CS6;
1000 channel_setup |= ISICOM_CS7;
1003 channel_setup |= ISICOM_CS8;
1008 channel_setup |= ISICOM_2SB;
1009 if (C_PARENB(tty)) {
1010 channel_setup |= ISICOM_EVPAR;
1012 channel_setup |= ISICOM_ODPAR;
1014 outw(channel_setup, base);
1015 InterruptTheCard(base);
1019 port->flags &= ~ASYNC_CHECK_CD;
1021 port->flags |= ASYNC_CHECK_CD;
1023 /* flow control settings ...*/
1025 port->flags &= ~ASYNC_CTS_FLOW;
1026 if (C_CRTSCTS(tty)) {
1027 port->flags |= ASYNC_CTS_FLOW;
1028 flow_ctrl |= ISICOM_CTSRTS;
1031 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
1033 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
1035 if (lock_card(card)) {
1036 outw(0x8000 | (channel << shift_count) |0x04, base);
1037 outw(flow_ctrl << 8 | 0x05, base);
1038 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
1039 InterruptTheCard(base);
1043 /* rx enabled -> enable port for rx on the card */
1045 card->port_status |= (1 << channel);
1046 outw(card->port_status, base + 0x02);
1052 static inline void isicom_setup_board(struct isi_board *bp)
1055 struct isi_port *port;
1056 unsigned long flags;
1058 spin_lock_irqsave(&bp->card_lock, flags);
1059 if (bp->status & BOARD_ACTIVE) {
1060 spin_unlock_irqrestore(&bp->card_lock, flags);
1064 bp->status |= BOARD_ACTIVE;
1065 spin_unlock_irqrestore(&bp->card_lock, flags);
1066 for (channel = 0; channel < bp->port_count; channel++, port++)
1071 static int isicom_setup_port(struct isi_port *port)
1073 struct isi_board *card = port->card;
1074 unsigned long flags;
1076 if (port->flags & ASYNC_INITIALIZED) {
1079 if (!port->xmit_buf) {
1082 if (!(page = get_zeroed_page(GFP_KERNEL)))
1085 if (port->xmit_buf) {
1087 return -ERESTARTSYS;
1089 port->xmit_buf = (unsigned char *) page;
1092 spin_lock_irqsave(&card->card_lock, flags);
1094 clear_bit(TTY_IO_ERROR, &port->tty->flags);
1095 if (port->count == 1)
1098 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1100 /* discard any residual data */
1101 kill_queue(port, ISICOM_KILLTX | ISICOM_KILLRX);
1103 isicom_config_port(port);
1104 port->flags |= ASYNC_INITIALIZED;
1105 spin_unlock_irqrestore(&card->card_lock, flags);
1110 static int block_til_ready(struct tty_struct *tty, struct file *filp, struct isi_port *port)
1112 struct isi_board *card = port->card;
1113 int do_clocal = 0, retval;
1114 unsigned long flags;
1115 DECLARE_WAITQUEUE(wait, current);
1117 /* block if port is in the process of being closed */
1119 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
1120 pr_dbg("block_til_ready: close in progress.\n");
1121 interruptible_sleep_on(&port->close_wait);
1122 if (port->flags & ASYNC_HUP_NOTIFY)
1125 return -ERESTARTSYS;
1128 /* if non-blocking mode is set ... */
1130 if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
1131 pr_dbg("block_til_ready: non-block mode.\n");
1132 port->flags |= ASYNC_NORMAL_ACTIVE;
1139 /* block waiting for DCD to be asserted, and while
1140 callout dev is busy */
1142 add_wait_queue(&port->open_wait, &wait);
1144 spin_lock_irqsave(&card->card_lock, flags);
1145 if (!tty_hung_up_p(filp))
1147 port->blocked_open++;
1148 spin_unlock_irqrestore(&card->card_lock, flags);
1151 raise_dtr_rts(port);
1153 set_current_state(TASK_INTERRUPTIBLE);
1154 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
1155 if (port->flags & ASYNC_HUP_NOTIFY)
1158 retval = -ERESTARTSYS;
1161 if (!(port->flags & ASYNC_CLOSING) &&
1162 (do_clocal || (port->status & ISI_DCD))) {
1165 if (signal_pending(current)) {
1166 retval = -ERESTARTSYS;
1171 set_current_state(TASK_RUNNING);
1172 remove_wait_queue(&port->open_wait, &wait);
1173 spin_lock_irqsave(&card->card_lock, flags);
1174 if (!tty_hung_up_p(filp))
1176 port->blocked_open--;
1177 spin_unlock_irqrestore(&card->card_lock, flags);
1180 port->flags |= ASYNC_NORMAL_ACTIVE;
1184 static int isicom_open(struct tty_struct *tty, struct file *filp)
1186 struct isi_port *port;
1187 struct isi_board *card;
1188 unsigned int line, board;
1192 if (line < 0 || line > PORT_COUNT-1)
1194 board = BOARD(line);
1195 card = &isi_card[board];
1197 if (!(card->status & FIRMWARE_LOADED))
1200 /* open on a port greater than the port count for the card !!! */
1201 if (line > ((board * 16) + card->port_count - 1))
1204 port = &isi_ports[line];
1205 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
1208 isicom_setup_board(card);
1211 tty->driver_data = port;
1213 if ((error = isicom_setup_port(port))!=0)
1215 if ((error = block_til_ready(tty, filp, port))!=0)
1223 static inline void isicom_shutdown_board(struct isi_board *bp)
1225 unsigned long flags;
1227 spin_lock_irqsave(&bp->card_lock, flags);
1228 if (bp->status & BOARD_ACTIVE) {
1229 bp->status &= ~BOARD_ACTIVE;
1231 spin_unlock_irqrestore(&bp->card_lock, flags);
1234 static void isicom_shutdown_port(struct isi_port *port)
1236 struct isi_board *card = port->card;
1237 struct tty_struct *tty;
1238 unsigned long flags;
1242 spin_lock_irqsave(&card->card_lock, flags);
1243 if (!(port->flags & ASYNC_INITIALIZED)) {
1244 spin_unlock_irqrestore(&card->card_lock, flags);
1247 if (port->xmit_buf) {
1248 free_page((unsigned long) port->xmit_buf);
1249 port->xmit_buf = NULL;
1251 port->flags &= ~ASYNC_INITIALIZED;
1252 /* 3rd October 2000 : Vinayak P Risbud */
1254 spin_unlock_irqrestore(&card->card_lock, flags);
1256 /*Fix done by Anil .S on 30-04-2001
1257 remote login through isi port has dtr toggle problem
1258 due to which the carrier drops before the password prompt
1259 appears on the remote end. Now we drop the dtr only if the
1260 HUPCL(Hangup on close) flag is set for the tty*/
1263 /* drop dtr on this port */
1266 /* any other port uninits */
1268 set_bit(TTY_IO_ERROR, &tty->flags);
1270 if (--card->count < 0) {
1271 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
1272 card->base, card->count);
1276 /* last port was closed , shutdown that boad too */
1279 isicom_shutdown_board(card);
1283 static void isicom_close(struct tty_struct *tty, struct file *filp)
1285 struct isi_port *port = tty->driver_data;
1286 struct isi_board *card = port->card;
1287 unsigned long flags;
1291 if (isicom_paranoia_check(port, tty->name, "isicom_close"))
1294 pr_dbg("Close start!!!.\n");
1296 spin_lock_irqsave(&card->card_lock, flags);
1297 if (tty_hung_up_p(filp)) {
1298 spin_unlock_irqrestore(&card->card_lock, flags);
1302 if (tty->count == 1 && port->count != 1) {
1303 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port count"
1304 "tty->count = 1 port count = %d.\n",
1305 card->base, port->count);
1308 if (--port->count < 0) {
1309 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port count for"
1310 "channel%d = %d", card->base, port->channel,
1316 spin_unlock_irqrestore(&card->card_lock, flags);
1319 port->flags |= ASYNC_CLOSING;
1321 spin_unlock_irqrestore(&card->card_lock, flags);
1323 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1324 tty_wait_until_sent(tty, port->closing_wait);
1325 /* indicate to the card that no more data can be received
1327 spin_lock_irqsave(&card->card_lock, flags);
1328 if (port->flags & ASYNC_INITIALIZED) {
1329 card->port_status &= ~(1 << port->channel);
1330 outw(card->port_status, card->base + 0x02);
1332 isicom_shutdown_port(port);
1333 spin_unlock_irqrestore(&card->card_lock, flags);
1335 if (tty->driver->flush_buffer)
1336 tty->driver->flush_buffer(tty);
1337 tty_ldisc_flush(tty);
1339 spin_lock_irqsave(&card->card_lock, flags);
1342 if (port->blocked_open) {
1343 spin_unlock_irqrestore(&card->card_lock, flags);
1344 if (port->close_delay) {
1345 pr_dbg("scheduling until time out.\n");
1346 msleep_interruptible(jiffies_to_msecs(port->close_delay));
1348 spin_lock_irqsave(&card->card_lock, flags);
1349 wake_up_interruptible(&port->open_wait);
1351 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1352 wake_up_interruptible(&port->close_wait);
1353 spin_unlock_irqrestore(&card->card_lock, flags);
1357 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1360 struct isi_port *port = tty->driver_data;
1361 struct isi_board *card = port->card;
1362 unsigned long flags;
1365 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1368 if (!tty || !port->xmit_buf || !tmp_buf)
1371 spin_lock_irqsave(&card->card_lock, flags);
1374 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1375 SERIAL_XMIT_SIZE - port->xmit_head));
1379 memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
1380 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE - 1);
1381 port->xmit_cnt += cnt;
1386 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1387 port->status |= ISI_TXOK;
1388 spin_unlock_irqrestore(&card->card_lock, flags);
1392 /* put_char et all */
1393 static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
1395 struct isi_port *port = tty->driver_data;
1396 struct isi_board *card = port->card;
1397 unsigned long flags;
1399 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1402 if (!tty || !port->xmit_buf)
1405 spin_lock_irqsave(&card->card_lock, flags);
1406 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1407 spin_unlock_irqrestore(&card->card_lock, flags);
1411 port->xmit_buf[port->xmit_head++] = ch;
1412 port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1414 spin_unlock_irqrestore(&card->card_lock, flags);
1417 /* flush_chars et all */
1418 static void isicom_flush_chars(struct tty_struct *tty)
1420 struct isi_port *port = tty->driver_data;
1422 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1425 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped || !port->xmit_buf)
1428 /* this tells the transmitter to consider this port for
1429 data output to the card ... that's the best we can do. */
1430 port->status |= ISI_TXOK;
1433 /* write_room et all */
1434 static int isicom_write_room(struct tty_struct *tty)
1436 struct isi_port *port = tty->driver_data;
1439 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1442 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1448 /* chars_in_buffer et all */
1449 static int isicom_chars_in_buffer(struct tty_struct *tty)
1451 struct isi_port *port = tty->driver_data;
1452 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1454 return port->xmit_cnt;
1458 static inline void isicom_send_break(struct isi_port *port, unsigned long length)
1460 struct isi_board *card = port->card;
1461 unsigned long base = card->base;
1463 if (!lock_card(card))
1466 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1467 outw((length & 0xff) << 8 | 0x00, base);
1468 outw((length & 0xff00), base);
1469 InterruptTheCard(base);
1474 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1476 struct isi_port *port = tty->driver_data;
1477 /* just send the port status */
1478 u16 status = port->status;
1480 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1483 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1484 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1485 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1486 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1487 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1488 ((status & ISI_RI ) ? TIOCM_RI : 0);
1491 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1492 unsigned int set, unsigned int clear)
1494 struct isi_port *port = tty->driver_data;
1496 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1499 if (set & TIOCM_RTS)
1501 if (set & TIOCM_DTR)
1504 if (clear & TIOCM_RTS)
1506 if (clear & TIOCM_DTR)
1512 static int isicom_set_serial_info(struct isi_port *port,
1513 struct serial_struct __user *info)
1515 struct serial_struct newinfo;
1518 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1521 reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
1522 (newinfo.flags & ASYNC_SPD_MASK));
1524 if (!capable(CAP_SYS_ADMIN)) {
1525 if ((newinfo.close_delay != port->close_delay) ||
1526 (newinfo.closing_wait != port->closing_wait) ||
1527 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1528 (port->flags & ~ASYNC_USR_MASK)))
1530 port->flags = ((port->flags & ~ ASYNC_USR_MASK) |
1531 (newinfo.flags & ASYNC_USR_MASK));
1534 port->close_delay = newinfo.close_delay;
1535 port->closing_wait = newinfo.closing_wait;
1536 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1537 (newinfo.flags & ASYNC_FLAGS));
1539 if (reconfig_port) {
1540 isicom_config_port(port);
1545 static int isicom_get_serial_info(struct isi_port *port,
1546 struct serial_struct __user *info)
1548 struct serial_struct out_info;
1550 memset(&out_info, 0, sizeof(out_info));
1551 /* out_info.type = ? */
1552 out_info.line = port - isi_ports;
1553 out_info.port = port->card->base;
1554 out_info.irq = port->card->irq;
1555 out_info.flags = port->flags;
1556 /* out_info.baud_base = ? */
1557 out_info.close_delay = port->close_delay;
1558 out_info.closing_wait = port->closing_wait;
1559 if (copy_to_user(info, &out_info, sizeof(out_info)))
1564 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1565 unsigned int cmd, unsigned long arg)
1567 struct isi_port *port = tty->driver_data;
1568 void __user *argp = (void __user *)arg;
1571 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1576 retval = tty_check_change(tty);
1579 tty_wait_until_sent(tty, 0);
1581 isicom_send_break(port, HZ/4);
1585 retval = tty_check_change(tty);
1588 tty_wait_until_sent(tty, 0);
1589 isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
1593 return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
1596 if (get_user(arg, (unsigned long __user *) argp))
1598 tty->termios->c_cflag =
1599 ((tty->termios->c_cflag & ~CLOCAL) |
1600 (arg ? CLOCAL : 0));
1604 return isicom_get_serial_info(port, argp);
1607 return isicom_set_serial_info(port, argp);
1610 return -ENOIOCTLCMD;
1615 /* set_termios et all */
1616 static void isicom_set_termios(struct tty_struct *tty,
1617 struct termios *old_termios)
1619 struct isi_port *port = tty->driver_data;
1621 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1624 if (tty->termios->c_cflag == old_termios->c_cflag &&
1625 tty->termios->c_iflag == old_termios->c_iflag)
1628 isicom_config_port(port);
1630 if ((old_termios->c_cflag & CRTSCTS) &&
1631 !(tty->termios->c_cflag & CRTSCTS)) {
1632 tty->hw_stopped = 0;
1637 /* throttle et all */
1638 static void isicom_throttle(struct tty_struct *tty)
1640 struct isi_port *port = tty->driver_data;
1641 struct isi_board *card = port->card;
1643 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1646 /* tell the card that this port cannot handle any more data for now */
1647 card->port_status &= ~(1 << port->channel);
1648 outw(card->port_status, card->base + 0x02);
1651 /* unthrottle et all */
1652 static void isicom_unthrottle(struct tty_struct *tty)
1654 struct isi_port *port = tty->driver_data;
1655 struct isi_board *card = port->card;
1657 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1660 /* tell the card that this port is ready to accept more data */
1661 card->port_status |= (1 << port->channel);
1662 outw(card->port_status, card->base + 0x02);
1666 static void isicom_stop(struct tty_struct *tty)
1668 struct isi_port *port = tty->driver_data;
1670 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1673 /* this tells the transmitter not to consider this port for
1674 data output to the card. */
1675 port->status &= ~ISI_TXOK;
1679 static void isicom_start(struct tty_struct *tty)
1681 struct isi_port *port = tty->driver_data;
1683 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1686 /* this tells the transmitter to consider this port for
1687 data output to the card. */
1688 port->status |= ISI_TXOK;
1692 static void do_isicom_hangup(void *data)
1694 struct isi_port *port = data;
1695 struct tty_struct *tty;
1702 static void isicom_hangup(struct tty_struct *tty)
1704 struct isi_port *port = tty->driver_data;
1706 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1709 isicom_shutdown_port(port);
1711 port->flags &= ~ASYNC_NORMAL_ACTIVE;
1713 wake_up_interruptible(&port->open_wait);
1716 /* flush_buffer et all */
1717 static void isicom_flush_buffer(struct tty_struct *tty)
1719 struct isi_port *port = tty->driver_data;
1720 struct isi_board *card = port->card;
1721 unsigned long flags;
1723 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
1726 spin_lock_irqsave(&card->card_lock, flags);
1727 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1728 spin_unlock_irqrestore(&card->card_lock, flags);
1730 wake_up_interruptible(&tty->write_wait);
1735 static int __devinit register_ioregion(void)
1738 for (count=0; count < BOARD_COUNT; count++ ) {
1739 if (isi_card[count].base)
1740 if (!request_region(isi_card[count].base,16,ISICOM_NAME)) {
1741 printk(KERN_DEBUG "ISICOM: I/O Region 0x%lx-0x%lx is busy. Card%d will be disabled.\n",
1742 isi_card[count].base,isi_card[count].base+15,count+1);
1743 isi_card[count].base=0;
1750 static void unregister_ioregion(void)
1753 for (count=0; count < BOARD_COUNT; count++ )
1754 if (isi_card[count].base) {
1755 release_region(isi_card[count].base,16);
1757 printk(KERN_DEBUG "ISICOM: I/O Region 0x%lx-0x%lx released for Card%d.\n",isi_card[count].base,isi_card[count].base+15,count+1);
1762 static struct tty_operations isicom_ops = {
1763 .open = isicom_open,
1764 .close = isicom_close,
1765 .write = isicom_write,
1766 .put_char = isicom_put_char,
1767 .flush_chars = isicom_flush_chars,
1768 .write_room = isicom_write_room,
1769 .chars_in_buffer = isicom_chars_in_buffer,
1770 .ioctl = isicom_ioctl,
1771 .set_termios = isicom_set_termios,
1772 .throttle = isicom_throttle,
1773 .unthrottle = isicom_unthrottle,
1774 .stop = isicom_stop,
1775 .start = isicom_start,
1776 .hangup = isicom_hangup,
1777 .flush_buffer = isicom_flush_buffer,
1778 .tiocmget = isicom_tiocmget,
1779 .tiocmset = isicom_tiocmset,
1782 static int __devinit isicom_register_tty_driver(void)
1784 int error = -ENOMEM;
1786 /* tty driver structure initialization */
1787 isicom_normal = alloc_tty_driver(PORT_COUNT);
1791 isicom_normal->owner = THIS_MODULE;
1792 isicom_normal->name = "ttyM";
1793 isicom_normal->devfs_name = "isicom/";
1794 isicom_normal->major = ISICOM_NMAJOR;
1795 isicom_normal->minor_start = 0;
1796 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1797 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1798 isicom_normal->init_termios = tty_std_termios;
1799 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1801 isicom_normal->flags = TTY_DRIVER_REAL_RAW;
1802 tty_set_operations(isicom_normal, &isicom_ops);
1804 if ((error = tty_register_driver(isicom_normal))) {
1805 pr_dbg("Couldn't register the dialin driver, error=%d\n",
1807 put_tty_driver(isicom_normal);
1813 static void isicom_unregister_tty_driver(void)
1817 if ((error = tty_unregister_driver(isicom_normal)))
1818 pr_dbg("couldn't unregister normal driver, error=%d.\n", error);
1820 put_tty_driver(isicom_normal);
1823 static int __devinit register_isr(void)
1826 unsigned long irqflags;
1828 for (count=0; count < BOARD_COUNT; count++ ) {
1829 if (isi_card[count].base) {
1830 irqflags = (isi_card[count].isa == YES) ?
1832 (SA_INTERRUPT | SA_SHIRQ);
1834 if (request_irq(isi_card[count].irq,
1837 ISICOM_NAME, &isi_card[count])) {
1839 printk(KERN_WARNING "ISICOM: Could not"
1840 " install handler at Irq %d."
1841 " Card%d will be disabled.\n",
1842 isi_card[count].irq, count+1);
1844 release_region(isi_card[count].base,16);
1845 isi_card[count].base=0;
1854 static void __exit unregister_isr(void)
1858 for (count=0; count < BOARD_COUNT; count++ ) {
1859 if (isi_card[count].base)
1860 free_irq(isi_card[count].irq, &isi_card[count]);
1864 static int __devinit isicom_init(void)
1866 int card, channel, base;
1867 struct isi_port *port;
1871 page = get_zeroed_page(GFP_KERNEL);
1874 printk(KERN_DEBUG "ISICOM: Couldn't allocate page for tmp_buf.\n");
1876 printk(KERN_ERR "ISICOM: Not enough memory...\n");
1880 tmp_buf = (unsigned char *) page;
1883 if (!register_ioregion())
1885 printk(KERN_ERR "ISICOM: All required I/O space found busy.\n");
1886 free_page((unsigned long)tmp_buf);
1889 if (isicom_register_tty_driver())
1891 unregister_ioregion();
1892 free_page((unsigned long)tmp_buf);
1895 if (!register_isr())
1897 isicom_unregister_tty_driver();
1898 /* ioports already uregistered in register_isr */
1899 free_page((unsigned long)tmp_buf);
1903 memset(isi_ports, 0, sizeof(isi_ports));
1904 for (card = 0; card < BOARD_COUNT; card++) {
1905 port = &isi_ports[card * 16];
1906 isi_card[card].ports = port;
1907 spin_lock_init(&isi_card[card].card_lock);
1908 base = isi_card[card].base;
1909 for (channel = 0; channel < 16; channel++, port++) {
1910 port->magic = ISICOM_MAGIC;
1911 port->card = &isi_card[card];
1912 port->channel = channel;
1913 port->close_delay = 50 * HZ/100;
1914 port->closing_wait = 3000 * HZ/100;
1915 INIT_WORK(&port->hangup_tq, do_isicom_hangup, port);
1916 INIT_WORK(&port->bh_tqueue, isicom_bottomhalf, port);
1918 init_waitqueue_head(&port->open_wait);
1919 init_waitqueue_head(&port->close_wait);
1928 * Insmod can set static symbols so keep these static
1934 static int __devinit isicom_setup(void)
1936 struct pci_dev *dev = NULL;
1937 int retval, card, idx, count;
1938 unsigned char pciirq;
1939 unsigned int ioaddr;
1942 for (idx=0; idx < BOARD_COUNT; idx++) {
1944 isi_card[idx].base=io[idx];
1945 isi_card[idx].irq=irq[idx];
1946 isi_card[idx].isa=YES;
1950 isi_card[idx].base = 0;
1951 isi_card[idx].irq = 0;
1955 for (idx=0 ;idx < card; idx++) {
1956 if (!((isi_card[idx].irq==2)||(isi_card[idx].irq==3)||
1957 (isi_card[idx].irq==4)||(isi_card[idx].irq==5)||
1958 (isi_card[idx].irq==7)||(isi_card[idx].irq==10)||
1959 (isi_card[idx].irq==11)||(isi_card[idx].irq==12)||
1960 (isi_card[idx].irq==15))) {
1962 if (isi_card[idx].base) {
1963 printk(KERN_ERR "ISICOM: Irq %d unsupported. Disabling Card%d...\n",
1964 isi_card[idx].irq, idx+1);
1965 isi_card[idx].base=0;
1971 if (card < BOARD_COUNT) {
1972 for (idx=0; idx < DEVID_COUNT; idx++) {
1975 if (!(dev = pci_find_device(VENDOR_ID, isicom_pci_tbl[idx].device, dev)))
1977 if (card >= BOARD_COUNT)
1980 if (pci_enable_device(dev))
1983 /* found a PCI ISI card! */
1984 ioaddr = pci_resource_start (dev, 3);
1985 /* i.e at offset 0x1c in the
1986 * PCI configuration register
1990 printk(KERN_INFO "ISI PCI Card(Device ID 0x%x)\n", isicom_pci_tbl[idx].device);
1992 * allot the first empty slot in the array
1994 for (count=0; count < BOARD_COUNT; count++) {
1995 if (isi_card[count].base == 0) {
1996 isi_card[count].base = ioaddr;
1997 isi_card[count].irq = pciirq;
1998 isi_card[count].isa = NO;
2004 if (card >= BOARD_COUNT) break;
2008 if (!(isi_card[0].base || isi_card[1].base || isi_card[2].base || isi_card[3].base)) {
2009 printk(KERN_ERR "ISICOM: No valid card configuration. Driver cannot be initialized...\n");
2013 retval = misc_register(&isiloader_device);
2015 printk(KERN_ERR "ISICOM: Unable to register firmware loader driver.\n");
2019 if (!isicom_init()) {
2020 if (misc_deregister(&isiloader_device))
2021 printk(KERN_ERR "ISICOM: Unable to unregister Firmware Loader driver\n");
2026 tx.expires = jiffies + 1;
2028 tx.function = isicom_tx;
2035 static void __exit isicom_exit(void)
2037 unsigned int index = 0;
2041 while (re_schedule != 2 && index++ < 100)
2045 isicom_unregister_tty_driver();
2046 unregister_ioregion();
2048 free_page((unsigned long)tmp_buf);
2049 if (misc_deregister(&isiloader_device))
2050 printk(KERN_ERR "ISICOM: Unable to unregister Firmware Loader driver\n");
2053 module_init(isicom_setup);
2054 module_exit(isicom_exit);
2056 MODULE_AUTHOR("MultiTech");
2057 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
2058 MODULE_LICENSE("GPL");
2059 module_param_array(io, int, NULL, 0);
2060 MODULE_PARM_DESC(io, "I/O ports for the cards");
2061 module_param_array(irq, int, NULL, 0);
2062 MODULE_PARM_DESC(irq, "Interrupts for the cards");