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 <linux/uaccess.h>
130 #include <linux/io.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)
140 #define pr_dbg(str...) pr_debug("ISICOM: " str)
142 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
144 #define isicom_paranoia_check(a, b, c) 0
147 static int isicom_probe(struct pci_dev
*, const struct pci_device_id
*);
148 static void __devexit
isicom_remove(struct pci_dev
*);
150 static struct pci_device_id isicom_pci_tbl
[] = {
151 { PCI_DEVICE(VENDOR_ID
, 0x2028) },
152 { PCI_DEVICE(VENDOR_ID
, 0x2051) },
153 { PCI_DEVICE(VENDOR_ID
, 0x2052) },
154 { PCI_DEVICE(VENDOR_ID
, 0x2053) },
155 { PCI_DEVICE(VENDOR_ID
, 0x2054) },
156 { PCI_DEVICE(VENDOR_ID
, 0x2055) },
157 { PCI_DEVICE(VENDOR_ID
, 0x2056) },
158 { PCI_DEVICE(VENDOR_ID
, 0x2057) },
159 { PCI_DEVICE(VENDOR_ID
, 0x2058) },
162 MODULE_DEVICE_TABLE(pci
, isicom_pci_tbl
);
164 static struct pci_driver isicom_driver
= {
166 .id_table
= isicom_pci_tbl
,
167 .probe
= isicom_probe
,
168 .remove
= __devexit_p(isicom_remove
)
171 static int prev_card
= 3; /* start servicing isi_card[0] */
172 static struct tty_driver
*isicom_normal
;
174 static void isicom_tx(unsigned long _data
);
175 static void isicom_start(struct tty_struct
*tty
);
177 static DEFINE_TIMER(tx
, isicom_tx
, 0, 0);
179 /* baud index mappings from linux defns to isi */
181 static signed char linuxb_to_isib
[] = {
182 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19, 20, 21
188 unsigned char port_count
;
189 unsigned short status
;
190 unsigned short port_status
; /* each bit for each port */
191 unsigned short shift_count
;
192 struct isi_port
*ports
;
194 spinlock_t card_lock
; /* Card wide lock 11/5/00 -sameer */
200 unsigned short magic
;
208 struct isi_board
*card
;
209 struct tty_struct
*tty
;
210 wait_queue_head_t close_wait
;
211 wait_queue_head_t open_wait
;
212 unsigned char *xmit_buf
;
218 static struct isi_board isi_card
[BOARD_COUNT
];
219 static struct isi_port isi_ports
[PORT_COUNT
];
222 * Locking functions for card level locking. We need to own both
223 * the kernel lock for the card and have the card in a position that
227 static inline int WaitTillCardIsFree(unsigned long base
)
229 unsigned int count
= 0;
230 unsigned int a
= in_atomic(); /* do we run under spinlock? */
232 while (!(inw(base
+ 0xe) & 0x1) && count
++ < 100)
238 return !(inw(base
+ 0xe) & 0x1);
241 static int lock_card(struct isi_board
*card
)
243 unsigned long base
= card
->base
;
244 unsigned int retries
, a
;
246 for (retries
= 0; retries
< 10; retries
++) {
247 spin_lock_irqsave(&card
->card_lock
, card
->flags
);
248 for (a
= 0; a
< 10; a
++) {
249 if (inw(base
+ 0xe) & 0x1)
253 spin_unlock_irqrestore(&card
->card_lock
, card
->flags
);
256 printk(KERN_WARNING
"ISICOM: Failed to lock Card (0x%lx)\n",
259 return 0; /* Failed to acquire the card! */
262 static void unlock_card(struct isi_board
*card
)
264 spin_unlock_irqrestore(&card
->card_lock
, card
->flags
);
268 * ISI Card specific ops ...
271 /* card->lock HAS to be held */
272 static void raise_dtr(struct isi_port
*port
)
274 struct isi_board
*card
= port
->card
;
275 unsigned long base
= card
->base
;
276 u16 channel
= port
->channel
;
278 if (WaitTillCardIsFree(base
))
281 outw(0x8000 | (channel
<< card
->shift_count
) | 0x02, base
);
283 InterruptTheCard(base
);
284 port
->status
|= ISI_DTR
;
287 /* card->lock HAS to be held */
288 static inline void drop_dtr(struct isi_port
*port
)
290 struct isi_board
*card
= port
->card
;
291 unsigned long base
= card
->base
;
292 u16 channel
= port
->channel
;
294 if (WaitTillCardIsFree(base
))
297 outw(0x8000 | (channel
<< card
->shift_count
) | 0x02, base
);
299 InterruptTheCard(base
);
300 port
->status
&= ~ISI_DTR
;
303 /* card->lock HAS to be held */
304 static inline void raise_rts(struct isi_port
*port
)
306 struct isi_board
*card
= port
->card
;
307 unsigned long base
= card
->base
;
308 u16 channel
= port
->channel
;
310 if (WaitTillCardIsFree(base
))
313 outw(0x8000 | (channel
<< card
->shift_count
) | 0x02, base
);
315 InterruptTheCard(base
);
316 port
->status
|= ISI_RTS
;
319 /* card->lock HAS to be held */
320 static inline void drop_rts(struct isi_port
*port
)
322 struct isi_board
*card
= port
->card
;
323 unsigned long base
= card
->base
;
324 u16 channel
= port
->channel
;
326 if (WaitTillCardIsFree(base
))
329 outw(0x8000 | (channel
<< card
->shift_count
) | 0x02, base
);
331 InterruptTheCard(base
);
332 port
->status
&= ~ISI_RTS
;
335 /* card->lock MUST NOT be held */
336 static inline void raise_dtr_rts(struct isi_port
*port
)
338 struct isi_board
*card
= port
->card
;
339 unsigned long base
= card
->base
;
340 u16 channel
= port
->channel
;
342 if (!lock_card(card
))
345 outw(0x8000 | (channel
<< card
->shift_count
) | 0x02, base
);
347 InterruptTheCard(base
);
348 port
->status
|= (ISI_DTR
| ISI_RTS
);
352 /* card->lock HAS to be held */
353 static void drop_dtr_rts(struct isi_port
*port
)
355 struct isi_board
*card
= port
->card
;
356 unsigned long base
= card
->base
;
357 u16 channel
= port
->channel
;
359 if (WaitTillCardIsFree(base
))
362 outw(0x8000 | (channel
<< card
->shift_count
) | 0x02, base
);
364 InterruptTheCard(base
);
365 port
->status
&= ~(ISI_RTS
| ISI_DTR
);
369 * ISICOM Driver specific routines ...
373 static inline int __isicom_paranoia_check(struct isi_port
const *port
,
374 char *name
, const char *routine
)
377 printk(KERN_WARNING
"ISICOM: Warning: bad isicom magic for "
378 "dev %s in %s.\n", name
, routine
);
381 if (port
->magic
!= ISICOM_MAGIC
) {
382 printk(KERN_WARNING
"ISICOM: Warning: NULL isicom port for "
383 "dev %s in %s.\n", name
, routine
);
393 * We shovel data into the card buffers on a regular basis. The card
394 * will do the rest of the work for us.
397 static void isicom_tx(unsigned long _data
)
399 unsigned long flags
, base
;
400 unsigned int retries
;
401 short count
= (BOARD_COUNT
-1), card
;
402 short txcount
, wrd
, residue
, word_count
, cnt
;
403 struct isi_port
*port
;
404 struct tty_struct
*tty
;
406 /* find next active board */
407 card
= (prev_card
+ 1) & 0x0003;
408 while (count
-- > 0) {
409 if (isi_card
[card
].status
& BOARD_ACTIVE
)
411 card
= (card
+ 1) & 0x0003;
413 if (!(isi_card
[card
].status
& BOARD_ACTIVE
))
418 count
= isi_card
[card
].port_count
;
419 port
= isi_card
[card
].ports
;
420 base
= isi_card
[card
].base
;
422 spin_lock_irqsave(&isi_card
[card
].card_lock
, flags
);
423 for (retries
= 0; retries
< 100; retries
++) {
424 if (inw(base
+ 0xe) & 0x1)
431 for (; count
> 0; count
--, port
++) {
432 /* port not active or tx disabled to force flow control */
433 if (!(port
->flags
& ASYNC_INITIALIZED
) ||
434 !(port
->status
& ISI_TXOK
))
442 txcount
= min_t(short, TX_SIZE
, port
->xmit_cnt
);
443 if (txcount
<= 0 || tty
->stopped
|| tty
->hw_stopped
)
446 if (!(inw(base
+ 0x02) & (1 << port
->channel
)))
449 pr_dbg("txing %d bytes, port%d.\n", txcount
,
451 outw((port
->channel
<< isi_card
[card
].shift_count
) | txcount
,
456 cnt
= min_t(int, txcount
, (SERIAL_XMIT_SIZE
458 if (residue
== YES
) {
461 wrd
|= (port
->xmit_buf
[port
->xmit_tail
]
463 port
->xmit_tail
= (port
->xmit_tail
+ 1)
464 & (SERIAL_XMIT_SIZE
- 1);
476 word_count
= cnt
>> 1;
477 outsw(base
, port
->xmit_buf
+port
->xmit_tail
, word_count
);
478 port
->xmit_tail
= (port
->xmit_tail
479 + (word_count
<< 1)) & (SERIAL_XMIT_SIZE
- 1);
480 txcount
-= (word_count
<< 1);
481 port
->xmit_cnt
-= (word_count
<< 1);
484 wrd
= port
->xmit_buf
[port
->xmit_tail
];
485 port
->xmit_tail
= (port
->xmit_tail
+ 1)
486 & (SERIAL_XMIT_SIZE
- 1);
492 InterruptTheCard(base
);
493 if (port
->xmit_cnt
<= 0)
494 port
->status
&= ~ISI_TXOK
;
495 if (port
->xmit_cnt
<= WAKEUP_CHARS
)
500 spin_unlock_irqrestore(&isi_card
[card
].card_lock
, flags
);
501 /* schedule another tx for hopefully in about 10ms */
503 mod_timer(&tx
, jiffies
+ msecs_to_jiffies(10));
507 * Main interrupt handler routine
510 static irqreturn_t
isicom_interrupt(int irq
, void *dev_id
)
512 struct isi_board
*card
= dev_id
;
513 struct isi_port
*port
;
514 struct tty_struct
*tty
;
516 u16 header
, word_count
, count
, channel
;
520 if (!card
|| !(card
->status
& FIRMWARE_LOADED
))
525 /* did the card interrupt us? */
526 if (!(inw(base
+ 0x0e) & 0x02))
529 spin_lock(&card
->card_lock
);
532 * disable any interrupts from the PCI card and lower the
535 outw(0x8000, base
+0x04);
536 ClearInterrupt(base
);
538 inw(base
); /* get the dummy word out */
540 channel
= (header
& 0x7800) >> card
->shift_count
;
541 byte_count
= header
& 0xff;
543 if (channel
+ 1 > card
->port_count
) {
544 printk(KERN_WARNING
"ISICOM: isicom_interrupt(0x%lx): "
545 "%d(channel) > port_count.\n", base
, channel
+1);
546 outw(0x0000, base
+0x04); /* enable interrupts */
547 spin_unlock(&card
->card_lock
);
550 port
= card
->ports
+ channel
;
551 if (!(port
->flags
& ASYNC_INITIALIZED
)) {
552 outw(0x0000, base
+0x04); /* enable interrupts */
553 spin_unlock(&card
->card_lock
);
559 word_count
= byte_count
>> 1;
560 while (byte_count
> 1) {
564 if (byte_count
& 0x01)
566 outw(0x0000, base
+0x04); /* enable interrupts */
567 spin_unlock(&card
->card_lock
);
571 if (header
& 0x8000) { /* Status Packet */
573 switch (header
& 0xff) {
574 case 0: /* Change in EIA signals */
575 if (port
->flags
& ASYNC_CHECK_CD
) {
576 if (port
->status
& ISI_DCD
) {
577 if (!(header
& ISI_DCD
)) {
578 /* Carrier has been lost */
579 pr_dbg("interrupt: DCD->low.\n"
581 port
->status
&= ~ISI_DCD
;
584 } else if (header
& ISI_DCD
) {
585 /* Carrier has been detected */
586 pr_dbg("interrupt: DCD->high.\n");
587 port
->status
|= ISI_DCD
;
588 wake_up_interruptible(&port
->open_wait
);
591 if (header
& ISI_DCD
)
592 port
->status
|= ISI_DCD
;
594 port
->status
&= ~ISI_DCD
;
597 if (port
->flags
& ASYNC_CTS_FLOW
) {
598 if (port
->tty
->hw_stopped
) {
599 if (header
& ISI_CTS
) {
600 port
->tty
->hw_stopped
= 0;
602 port
->status
|= (ISI_TXOK
606 } else if (!(header
& ISI_CTS
)) {
607 port
->tty
->hw_stopped
= 1;
609 port
->status
&= ~(ISI_TXOK
| ISI_CTS
);
612 if (header
& ISI_CTS
)
613 port
->status
|= ISI_CTS
;
615 port
->status
&= ~ISI_CTS
;
618 if (header
& ISI_DSR
)
619 port
->status
|= ISI_DSR
;
621 port
->status
&= ~ISI_DSR
;
624 port
->status
|= ISI_RI
;
626 port
->status
&= ~ISI_RI
;
630 case 1: /* Received Break !!! */
631 tty_insert_flip_char(tty
, 0, TTY_BREAK
);
632 if (port
->flags
& ASYNC_SAK
)
634 tty_flip_buffer_push(tty
);
637 case 2: /* Statistics */
638 pr_dbg("isicom_interrupt: stats!!!.\n");
642 pr_dbg("Intr: Unknown code in status packet.\n");
645 } else { /* Data Packet */
647 count
= tty_prepare_flip_string(tty
, &rp
, byte_count
& ~1);
648 pr_dbg("Intr: Can rx %d of %d bytes.\n", count
, byte_count
);
649 word_count
= count
>> 1;
650 insw(base
, rp
, word_count
);
651 byte_count
-= (word_count
<< 1);
652 if (count
& 0x0001) {
653 tty_insert_flip_char(tty
, inw(base
) & 0xff,
657 if (byte_count
> 0) {
658 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
659 "bytes...\n", base
, channel
+ 1);
660 /* drain out unread xtra data */
661 while (byte_count
> 0) {
666 tty_flip_buffer_push(tty
);
668 outw(0x0000, base
+0x04); /* enable interrupts */
669 spin_unlock(&card
->card_lock
);
674 static void isicom_config_port(struct isi_port
*port
)
676 struct isi_board
*card
= port
->card
;
677 struct tty_struct
*tty
;
679 unsigned long base
= card
->base
;
680 u16 channel_setup
, channel
= port
->channel
,
681 shift_count
= card
->shift_count
;
682 unsigned char flow_ctrl
;
688 /* FIXME: Switch to new tty baud API */
690 if (baud
& CBAUDEX
) {
693 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
694 * then the card is programmed for 57.6Kbps or 115Kbps
698 /* 1,2,3,4 => 57.6, 115.2, 230, 460 kbps resp. */
699 if (baud
< 1 || baud
> 4)
700 port
->tty
->termios
->c_cflag
&= ~CBAUDEX
;
706 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
707 * by the set_serial_info ioctl ... this is done by
708 * the 'setserial' utility.
711 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_HI
)
712 baud
++; /* 57.6 Kbps */
713 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_VHI
)
714 baud
+= 2; /* 115 Kbps */
715 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_SHI
)
716 baud
+= 3; /* 230 kbps*/
717 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_WARP
)
718 baud
+= 4; /* 460 kbps*/
720 if (linuxb_to_isib
[baud
] == -1) {
727 if (WaitTillCardIsFree(base
) == 0) {
728 outw(0x8000 | (channel
<< shift_count
) | 0x03, base
);
729 outw(linuxb_to_isib
[baud
] << 8 | 0x03, base
);
731 switch (C_CSIZE(tty
)) {
733 channel_setup
|= ISICOM_CS5
;
736 channel_setup
|= ISICOM_CS6
;
739 channel_setup
|= ISICOM_CS7
;
742 channel_setup
|= ISICOM_CS8
;
747 channel_setup
|= ISICOM_2SB
;
749 channel_setup
|= ISICOM_EVPAR
;
751 channel_setup
|= ISICOM_ODPAR
;
753 outw(channel_setup
, base
);
754 InterruptTheCard(base
);
757 port
->flags
&= ~ASYNC_CHECK_CD
;
759 port
->flags
|= ASYNC_CHECK_CD
;
761 /* flow control settings ...*/
763 port
->flags
&= ~ASYNC_CTS_FLOW
;
764 if (C_CRTSCTS(tty
)) {
765 port
->flags
|= ASYNC_CTS_FLOW
;
766 flow_ctrl
|= ISICOM_CTSRTS
;
769 flow_ctrl
|= ISICOM_RESPOND_XONXOFF
;
771 flow_ctrl
|= ISICOM_INITIATE_XONXOFF
;
773 if (WaitTillCardIsFree(base
) == 0) {
774 outw(0x8000 | (channel
<< shift_count
) | 0x04, base
);
775 outw(flow_ctrl
<< 8 | 0x05, base
);
776 outw((STOP_CHAR(tty
)) << 8 | (START_CHAR(tty
)), base
);
777 InterruptTheCard(base
);
780 /* rx enabled -> enable port for rx on the card */
782 card
->port_status
|= (1 << channel
);
783 outw(card
->port_status
, base
+ 0x02);
789 static inline void isicom_setup_board(struct isi_board
*bp
)
792 struct isi_port
*port
;
795 spin_lock_irqsave(&bp
->card_lock
, flags
);
796 if (bp
->status
& BOARD_ACTIVE
) {
797 spin_unlock_irqrestore(&bp
->card_lock
, flags
);
801 bp
->status
|= BOARD_ACTIVE
;
802 for (channel
= 0; channel
< bp
->port_count
; channel
++, port
++)
804 spin_unlock_irqrestore(&bp
->card_lock
, flags
);
807 static int isicom_setup_port(struct isi_port
*port
)
809 struct isi_board
*card
= port
->card
;
812 if (port
->flags
& ASYNC_INITIALIZED
)
814 if (!port
->xmit_buf
) {
816 void *xmit_buf
= (void *)get_zeroed_page(GFP_KERNEL
);
818 if (xmit_buf
== NULL
)
820 if (port
->xmit_buf
) {
821 free_page((unsigned long)xmit_buf
);
824 port
->xmit_buf
= xmit_buf
;
827 spin_lock_irqsave(&card
->card_lock
, flags
);
829 clear_bit(TTY_IO_ERROR
, &port
->tty
->flags
);
830 if (port
->count
== 1)
833 port
->xmit_cnt
= port
->xmit_head
= port
->xmit_tail
= 0;
835 /* discard any residual data */
836 if (WaitTillCardIsFree(card
->base
) == 0) {
837 outw(0x8000 | (port
->channel
<< card
->shift_count
) | 0x02,
839 outw(((ISICOM_KILLTX
| ISICOM_KILLRX
) << 8) | 0x06, card
->base
);
840 InterruptTheCard(card
->base
);
843 isicom_config_port(port
);
844 port
->flags
|= ASYNC_INITIALIZED
;
845 spin_unlock_irqrestore(&card
->card_lock
, flags
);
850 static int block_til_ready(struct tty_struct
*tty
, struct file
*filp
,
851 struct isi_port
*port
)
853 struct isi_board
*card
= port
->card
;
854 int do_clocal
= 0, retval
;
856 DECLARE_WAITQUEUE(wait
, current
);
858 /* block if port is in the process of being closed */
860 if (tty_hung_up_p(filp
) || port
->flags
& ASYNC_CLOSING
) {
861 pr_dbg("block_til_ready: close in progress.\n");
862 interruptible_sleep_on(&port
->close_wait
);
863 if (port
->flags
& ASYNC_HUP_NOTIFY
)
869 /* if non-blocking mode is set ... */
871 if ((filp
->f_flags
& O_NONBLOCK
) ||
872 (tty
->flags
& (1 << TTY_IO_ERROR
))) {
873 pr_dbg("block_til_ready: non-block mode.\n");
874 port
->flags
|= ASYNC_NORMAL_ACTIVE
;
881 /* block waiting for DCD to be asserted, and while
882 callout dev is busy */
884 add_wait_queue(&port
->open_wait
, &wait
);
886 spin_lock_irqsave(&card
->card_lock
, flags
);
887 if (!tty_hung_up_p(filp
))
889 port
->blocked_open
++;
890 spin_unlock_irqrestore(&card
->card_lock
, flags
);
895 set_current_state(TASK_INTERRUPTIBLE
);
896 if (tty_hung_up_p(filp
) || !(port
->flags
& ASYNC_INITIALIZED
)) {
897 if (port
->flags
& ASYNC_HUP_NOTIFY
)
900 retval
= -ERESTARTSYS
;
903 if (!(port
->flags
& ASYNC_CLOSING
) &&
904 (do_clocal
|| (port
->status
& ISI_DCD
))) {
907 if (signal_pending(current
)) {
908 retval
= -ERESTARTSYS
;
913 set_current_state(TASK_RUNNING
);
914 remove_wait_queue(&port
->open_wait
, &wait
);
915 spin_lock_irqsave(&card
->card_lock
, flags
);
916 if (!tty_hung_up_p(filp
))
918 port
->blocked_open
--;
919 spin_unlock_irqrestore(&card
->card_lock
, flags
);
922 port
->flags
|= ASYNC_NORMAL_ACTIVE
;
926 static int isicom_open(struct tty_struct
*tty
, struct file
*filp
)
928 struct isi_port
*port
;
929 struct isi_board
*card
;
934 if (line
< 0 || line
> PORT_COUNT
-1)
937 card
= &isi_card
[board
];
939 if (!(card
->status
& FIRMWARE_LOADED
))
942 /* open on a port greater than the port count for the card !!! */
943 if (line
> ((board
* 16) + card
->port_count
- 1))
946 port
= &isi_ports
[line
];
947 if (isicom_paranoia_check(port
, tty
->name
, "isicom_open"))
950 isicom_setup_board(card
);
953 tty
->driver_data
= port
;
955 error
= isicom_setup_port(port
);
957 error
= block_til_ready(tty
, filp
, port
);
963 static inline void isicom_shutdown_board(struct isi_board
*bp
)
965 if (bp
->status
& BOARD_ACTIVE
)
966 bp
->status
&= ~BOARD_ACTIVE
;
969 /* card->lock HAS to be held */
970 static void isicom_shutdown_port(struct isi_port
*port
)
972 struct isi_board
*card
= port
->card
;
973 struct tty_struct
*tty
;
977 if (!(port
->flags
& ASYNC_INITIALIZED
))
980 if (port
->xmit_buf
) {
981 free_page((unsigned long) port
->xmit_buf
);
982 port
->xmit_buf
= NULL
;
984 port
->flags
&= ~ASYNC_INITIALIZED
;
985 /* 3rd October 2000 : Vinayak P Risbud */
988 /*Fix done by Anil .S on 30-04-2001
989 remote login through isi port has dtr toggle problem
990 due to which the carrier drops before the password prompt
991 appears on the remote end. Now we drop the dtr only if the
992 HUPCL(Hangup on close) flag is set for the tty*/
995 /* drop dtr on this port */
998 /* any other port uninits */
1000 set_bit(TTY_IO_ERROR
, &tty
->flags
);
1002 if (--card
->count
< 0) {
1003 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
1004 card
->base
, card
->count
);
1008 /* last port was closed, shutdown that boad too */
1011 isicom_shutdown_board(card
);
1015 static void isicom_flush_buffer(struct tty_struct
*tty
)
1017 struct isi_port
*port
= tty
->driver_data
;
1018 struct isi_board
*card
= port
->card
;
1019 unsigned long flags
;
1021 if (isicom_paranoia_check(port
, tty
->name
, "isicom_flush_buffer"))
1024 spin_lock_irqsave(&card
->card_lock
, flags
);
1025 port
->xmit_cnt
= port
->xmit_head
= port
->xmit_tail
= 0;
1026 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1031 static void isicom_close(struct tty_struct
*tty
, struct file
*filp
)
1033 struct isi_port
*port
= tty
->driver_data
;
1034 struct isi_board
*card
;
1035 unsigned long flags
;
1040 if (isicom_paranoia_check(port
, tty
->name
, "isicom_close"))
1043 pr_dbg("Close start!!!.\n");
1045 spin_lock_irqsave(&card
->card_lock
, flags
);
1046 if (tty_hung_up_p(filp
)) {
1047 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1051 if (tty
->count
== 1 && port
->count
!= 1) {
1052 printk(KERN_WARNING
"ISICOM:(0x%lx) isicom_close: bad port "
1053 "count tty->count = 1 port count = %d.\n",
1054 card
->base
, port
->count
);
1057 if (--port
->count
< 0) {
1058 printk(KERN_WARNING
"ISICOM:(0x%lx) isicom_close: bad port "
1059 "count for channel%d = %d", card
->base
, port
->channel
,
1065 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1068 port
->flags
|= ASYNC_CLOSING
;
1070 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1072 if (port
->closing_wait
!= ASYNC_CLOSING_WAIT_NONE
)
1073 tty_wait_until_sent(tty
, port
->closing_wait
);
1074 /* indicate to the card that no more data can be received
1076 spin_lock_irqsave(&card
->card_lock
, flags
);
1077 if (port
->flags
& ASYNC_INITIALIZED
) {
1078 card
->port_status
&= ~(1 << port
->channel
);
1079 outw(card
->port_status
, card
->base
+ 0x02);
1081 isicom_shutdown_port(port
);
1082 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1084 isicom_flush_buffer(tty
);
1085 tty_ldisc_flush(tty
);
1087 spin_lock_irqsave(&card
->card_lock
, flags
);
1090 if (port
->blocked_open
) {
1091 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1092 if (port
->close_delay
) {
1093 pr_dbg("scheduling until time out.\n");
1094 msleep_interruptible(
1095 jiffies_to_msecs(port
->close_delay
));
1097 spin_lock_irqsave(&card
->card_lock
, flags
);
1098 wake_up_interruptible(&port
->open_wait
);
1100 port
->flags
&= ~(ASYNC_NORMAL_ACTIVE
| ASYNC_CLOSING
);
1101 wake_up_interruptible(&port
->close_wait
);
1102 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1106 static int isicom_write(struct tty_struct
*tty
, const unsigned char *buf
,
1109 struct isi_port
*port
= tty
->driver_data
;
1110 struct isi_board
*card
= port
->card
;
1111 unsigned long flags
;
1114 if (isicom_paranoia_check(port
, tty
->name
, "isicom_write"))
1117 if (!port
->xmit_buf
)
1120 spin_lock_irqsave(&card
->card_lock
, flags
);
1123 cnt
= min_t(int, count
, min(SERIAL_XMIT_SIZE
- port
->xmit_cnt
1124 - 1, SERIAL_XMIT_SIZE
- port
->xmit_head
));
1128 memcpy(port
->xmit_buf
+ port
->xmit_head
, buf
, cnt
);
1129 port
->xmit_head
= (port
->xmit_head
+ cnt
) & (SERIAL_XMIT_SIZE
1131 port
->xmit_cnt
+= cnt
;
1136 if (port
->xmit_cnt
&& !tty
->stopped
&& !tty
->hw_stopped
)
1137 port
->status
|= ISI_TXOK
;
1138 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1142 /* put_char et all */
1143 static int isicom_put_char(struct tty_struct
*tty
, unsigned char ch
)
1145 struct isi_port
*port
= tty
->driver_data
;
1146 struct isi_board
*card
= port
->card
;
1147 unsigned long flags
;
1149 if (isicom_paranoia_check(port
, tty
->name
, "isicom_put_char"))
1152 if (!port
->xmit_buf
)
1155 spin_lock_irqsave(&card
->card_lock
, flags
);
1156 if (port
->xmit_cnt
>= SERIAL_XMIT_SIZE
- 1) {
1157 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1161 port
->xmit_buf
[port
->xmit_head
++] = ch
;
1162 port
->xmit_head
&= (SERIAL_XMIT_SIZE
- 1);
1164 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1168 /* flush_chars et all */
1169 static void isicom_flush_chars(struct tty_struct
*tty
)
1171 struct isi_port
*port
= tty
->driver_data
;
1173 if (isicom_paranoia_check(port
, tty
->name
, "isicom_flush_chars"))
1176 if (port
->xmit_cnt
<= 0 || tty
->stopped
|| tty
->hw_stopped
||
1180 /* this tells the transmitter to consider this port for
1181 data output to the card ... that's the best we can do. */
1182 port
->status
|= ISI_TXOK
;
1185 /* write_room et all */
1186 static int isicom_write_room(struct tty_struct
*tty
)
1188 struct isi_port
*port
= tty
->driver_data
;
1191 if (isicom_paranoia_check(port
, tty
->name
, "isicom_write_room"))
1194 free
= SERIAL_XMIT_SIZE
- port
->xmit_cnt
- 1;
1200 /* chars_in_buffer et all */
1201 static int isicom_chars_in_buffer(struct tty_struct
*tty
)
1203 struct isi_port
*port
= tty
->driver_data
;
1204 if (isicom_paranoia_check(port
, tty
->name
, "isicom_chars_in_buffer"))
1206 return port
->xmit_cnt
;
1210 static inline void isicom_send_break(struct isi_port
*port
,
1211 unsigned long length
)
1213 struct isi_board
*card
= port
->card
;
1214 unsigned long base
= card
->base
;
1216 if (!lock_card(card
))
1219 outw(0x8000 | ((port
->channel
) << (card
->shift_count
)) | 0x3, base
);
1220 outw((length
& 0xff) << 8 | 0x00, base
);
1221 outw((length
& 0xff00), base
);
1222 InterruptTheCard(base
);
1227 static int isicom_tiocmget(struct tty_struct
*tty
, struct file
*file
)
1229 struct isi_port
*port
= tty
->driver_data
;
1230 /* just send the port status */
1231 u16 status
= port
->status
;
1233 if (isicom_paranoia_check(port
, tty
->name
, "isicom_ioctl"))
1236 return ((status
& ISI_RTS
) ? TIOCM_RTS
: 0) |
1237 ((status
& ISI_DTR
) ? TIOCM_DTR
: 0) |
1238 ((status
& ISI_DCD
) ? TIOCM_CAR
: 0) |
1239 ((status
& ISI_DSR
) ? TIOCM_DSR
: 0) |
1240 ((status
& ISI_CTS
) ? TIOCM_CTS
: 0) |
1241 ((status
& ISI_RI
) ? TIOCM_RI
: 0);
1244 static int isicom_tiocmset(struct tty_struct
*tty
, struct file
*file
,
1245 unsigned int set
, unsigned int clear
)
1247 struct isi_port
*port
= tty
->driver_data
;
1248 unsigned long flags
;
1250 if (isicom_paranoia_check(port
, tty
->name
, "isicom_ioctl"))
1253 spin_lock_irqsave(&port
->card
->card_lock
, flags
);
1254 if (set
& TIOCM_RTS
)
1256 if (set
& TIOCM_DTR
)
1259 if (clear
& TIOCM_RTS
)
1261 if (clear
& TIOCM_DTR
)
1263 spin_unlock_irqrestore(&port
->card
->card_lock
, flags
);
1268 static int isicom_set_serial_info(struct isi_port
*port
,
1269 struct serial_struct __user
*info
)
1271 struct serial_struct newinfo
;
1274 if (copy_from_user(&newinfo
, info
, sizeof(newinfo
)))
1279 reconfig_port
= ((port
->flags
& ASYNC_SPD_MASK
) !=
1280 (newinfo
.flags
& ASYNC_SPD_MASK
));
1282 if (!capable(CAP_SYS_ADMIN
)) {
1283 if ((newinfo
.close_delay
!= port
->close_delay
) ||
1284 (newinfo
.closing_wait
!= port
->closing_wait
) ||
1285 ((newinfo
.flags
& ~ASYNC_USR_MASK
) !=
1286 (port
->flags
& ~ASYNC_USR_MASK
))) {
1290 port
->flags
= ((port
->flags
& ~ASYNC_USR_MASK
) |
1291 (newinfo
.flags
& ASYNC_USR_MASK
));
1293 port
->close_delay
= newinfo
.close_delay
;
1294 port
->closing_wait
= newinfo
.closing_wait
;
1295 port
->flags
= ((port
->flags
& ~ASYNC_FLAGS
) |
1296 (newinfo
.flags
& ASYNC_FLAGS
));
1298 if (reconfig_port
) {
1299 unsigned long flags
;
1300 spin_lock_irqsave(&port
->card
->card_lock
, flags
);
1301 isicom_config_port(port
);
1302 spin_unlock_irqrestore(&port
->card
->card_lock
, flags
);
1308 static int isicom_get_serial_info(struct isi_port
*port
,
1309 struct serial_struct __user
*info
)
1311 struct serial_struct out_info
;
1314 memset(&out_info
, 0, sizeof(out_info
));
1315 /* out_info.type = ? */
1316 out_info
.line
= port
- isi_ports
;
1317 out_info
.port
= port
->card
->base
;
1318 out_info
.irq
= port
->card
->irq
;
1319 out_info
.flags
= port
->flags
;
1320 /* out_info.baud_base = ? */
1321 out_info
.close_delay
= port
->close_delay
;
1322 out_info
.closing_wait
= port
->closing_wait
;
1324 if (copy_to_user(info
, &out_info
, sizeof(out_info
)))
1329 static int isicom_ioctl(struct tty_struct
*tty
, struct file
*filp
,
1330 unsigned int cmd
, unsigned long arg
)
1332 struct isi_port
*port
= tty
->driver_data
;
1333 void __user
*argp
= (void __user
*)arg
;
1336 if (isicom_paranoia_check(port
, tty
->name
, "isicom_ioctl"))
1341 retval
= tty_check_change(tty
);
1344 tty_wait_until_sent(tty
, 0);
1346 isicom_send_break(port
, HZ
/4);
1350 retval
= tty_check_change(tty
);
1353 tty_wait_until_sent(tty
, 0);
1354 isicom_send_break(port
, arg
? arg
* (HZ
/10) : HZ
/4);
1357 return isicom_get_serial_info(port
, argp
);
1360 return isicom_set_serial_info(port
, argp
);
1363 return -ENOIOCTLCMD
;
1368 /* set_termios et all */
1369 static void isicom_set_termios(struct tty_struct
*tty
,
1370 struct ktermios
*old_termios
)
1372 struct isi_port
*port
= tty
->driver_data
;
1373 unsigned long flags
;
1375 if (isicom_paranoia_check(port
, tty
->name
, "isicom_set_termios"))
1378 if (tty
->termios
->c_cflag
== old_termios
->c_cflag
&&
1379 tty
->termios
->c_iflag
== old_termios
->c_iflag
)
1382 spin_lock_irqsave(&port
->card
->card_lock
, flags
);
1383 isicom_config_port(port
);
1384 spin_unlock_irqrestore(&port
->card
->card_lock
, flags
);
1386 if ((old_termios
->c_cflag
& CRTSCTS
) &&
1387 !(tty
->termios
->c_cflag
& CRTSCTS
)) {
1388 tty
->hw_stopped
= 0;
1393 /* throttle et all */
1394 static void isicom_throttle(struct tty_struct
*tty
)
1396 struct isi_port
*port
= tty
->driver_data
;
1397 struct isi_board
*card
= port
->card
;
1399 if (isicom_paranoia_check(port
, tty
->name
, "isicom_throttle"))
1402 /* tell the card that this port cannot handle any more data for now */
1403 card
->port_status
&= ~(1 << port
->channel
);
1404 outw(card
->port_status
, card
->base
+ 0x02);
1407 /* unthrottle et all */
1408 static void isicom_unthrottle(struct tty_struct
*tty
)
1410 struct isi_port
*port
= tty
->driver_data
;
1411 struct isi_board
*card
= port
->card
;
1413 if (isicom_paranoia_check(port
, tty
->name
, "isicom_unthrottle"))
1416 /* tell the card that this port is ready to accept more data */
1417 card
->port_status
|= (1 << port
->channel
);
1418 outw(card
->port_status
, card
->base
+ 0x02);
1422 static void isicom_stop(struct tty_struct
*tty
)
1424 struct isi_port
*port
= tty
->driver_data
;
1426 if (isicom_paranoia_check(port
, tty
->name
, "isicom_stop"))
1429 /* this tells the transmitter not to consider this port for
1430 data output to the card. */
1431 port
->status
&= ~ISI_TXOK
;
1435 static void isicom_start(struct tty_struct
*tty
)
1437 struct isi_port
*port
= tty
->driver_data
;
1439 if (isicom_paranoia_check(port
, tty
->name
, "isicom_start"))
1442 /* this tells the transmitter to consider this port for
1443 data output to the card. */
1444 port
->status
|= ISI_TXOK
;
1447 static void isicom_hangup(struct tty_struct
*tty
)
1449 struct isi_port
*port
= tty
->driver_data
;
1450 unsigned long flags
;
1452 if (isicom_paranoia_check(port
, tty
->name
, "isicom_hangup"))
1455 spin_lock_irqsave(&port
->card
->card_lock
, flags
);
1456 isicom_shutdown_port(port
);
1457 spin_unlock_irqrestore(&port
->card
->card_lock
, flags
);
1460 port
->flags
&= ~ASYNC_NORMAL_ACTIVE
;
1462 wake_up_interruptible(&port
->open_wait
);
1467 * Driver init and deinit functions
1470 static const struct tty_operations isicom_ops
= {
1471 .open
= isicom_open
,
1472 .close
= isicom_close
,
1473 .write
= isicom_write
,
1474 .put_char
= isicom_put_char
,
1475 .flush_chars
= isicom_flush_chars
,
1476 .write_room
= isicom_write_room
,
1477 .chars_in_buffer
= isicom_chars_in_buffer
,
1478 .ioctl
= isicom_ioctl
,
1479 .set_termios
= isicom_set_termios
,
1480 .throttle
= isicom_throttle
,
1481 .unthrottle
= isicom_unthrottle
,
1482 .stop
= isicom_stop
,
1483 .start
= isicom_start
,
1484 .hangup
= isicom_hangup
,
1485 .flush_buffer
= isicom_flush_buffer
,
1486 .tiocmget
= isicom_tiocmget
,
1487 .tiocmset
= isicom_tiocmset
,
1490 static int __devinit
reset_card(struct pci_dev
*pdev
,
1491 const unsigned int card
, unsigned int *signature
)
1493 struct isi_board
*board
= pci_get_drvdata(pdev
);
1494 unsigned long base
= board
->base
;
1495 unsigned int sig
, portcount
= 0;
1498 dev_dbg(&pdev
->dev
, "ISILoad:Resetting Card%d at 0x%lx\n", card
+ 1,
1505 outw(0, base
+ 0x8); /* Reset */
1509 sig
= inw(base
+ 0x4) & 0xff;
1511 if (sig
!= 0xa5 && sig
!= 0xbb && sig
!= 0xcc && sig
!= 0xdd &&
1513 dev_warn(&pdev
->dev
, "ISILoad:Card%u reset failure (Possible "
1514 "bad I/O Port Address 0x%lx).\n", card
+ 1, base
);
1515 dev_dbg(&pdev
->dev
, "Sig=0x%x\n", sig
);
1522 portcount
= inw(base
+ 0x2);
1523 if (!(inw(base
+ 0xe) & 0x1) || (portcount
!= 0 && portcount
!= 4 &&
1524 portcount
!= 8 && portcount
!= 16)) {
1525 dev_err(&pdev
->dev
, "ISILoad:PCI Card%d reset failure.\n",
1535 board
->port_count
= (portcount
== 4) ? 4 : 8;
1536 board
->shift_count
= 12;
1540 board
->port_count
= 16;
1541 board
->shift_count
= 11;
1544 dev_info(&pdev
->dev
, "-Done\n");
1551 static int __devinit
load_firmware(struct pci_dev
*pdev
,
1552 const unsigned int index
, const unsigned int signature
)
1554 struct isi_board
*board
= pci_get_drvdata(pdev
);
1555 const struct firmware
*fw
;
1556 unsigned long base
= board
->base
;
1558 u16 word_count
, status
;
1569 switch (signature
) {
1571 name
= "isi608.bin";
1574 name
= "isi608em.bin";
1577 name
= "isi616em.bin";
1580 name
= "isi4608.bin";
1583 name
= "isi4616.bin";
1586 dev_err(&pdev
->dev
, "Unknown signature.\n");
1590 retval
= request_firmware(&fw
, name
, &pdev
->dev
);
1596 for (frame
= (struct stframe
*)fw
->data
;
1597 frame
< (struct stframe
*)(fw
->data
+ fw
->size
);
1598 frame
= (struct stframe
*)((u8
*)(frame
+ 1) +
1600 if (WaitTillCardIsFree(base
))
1603 outw(0xf0, base
); /* start upload sequence */
1605 outw(frame
->addr
, base
); /* lsb of address */
1607 word_count
= frame
->count
/ 2 + frame
->count
% 2;
1608 outw(word_count
, base
);
1609 InterruptTheCard(base
);
1611 udelay(100); /* 0x2f */
1613 if (WaitTillCardIsFree(base
))
1616 status
= inw(base
+ 0x4);
1618 dev_warn(&pdev
->dev
, "Card%d rejected load header:\n"
1619 KERN_WARNING
"Address:0x%x\n"
1620 KERN_WARNING
"Count:0x%x\n"
1621 KERN_WARNING
"Status:0x%x\n",
1622 index
+ 1, frame
->addr
, frame
->count
, status
);
1625 outsw(base
, frame
->data
, word_count
);
1627 InterruptTheCard(base
);
1629 udelay(50); /* 0x0f */
1631 if (WaitTillCardIsFree(base
))
1634 status
= inw(base
+ 0x4);
1636 dev_err(&pdev
->dev
, "Card%d got out of sync.Card "
1637 "Status:0x%x\n", index
+ 1, status
);
1642 /* XXX: should we test it by reading it back and comparing with original like
1643 * in load firmware package? */
1644 for (frame
= (struct stframe
*)fw
->data
;
1645 frame
< (struct stframe
*)(fw
->data
+ fw
->size
);
1646 frame
= (struct stframe
*)((u8
*)(frame
+ 1) +
1648 if (WaitTillCardIsFree(base
))
1651 outw(0xf1, base
); /* start download sequence */
1653 outw(frame
->addr
, base
); /* lsb of address */
1655 word_count
= (frame
->count
>> 1) + frame
->count
% 2;
1656 outw(word_count
+ 1, base
);
1657 InterruptTheCard(base
);
1659 udelay(50); /* 0xf */
1661 if (WaitTillCardIsFree(base
))
1664 status
= inw(base
+ 0x4);
1666 dev_warn(&pdev
->dev
, "Card%d rejected verify header:\n"
1667 KERN_WARNING
"Address:0x%x\n"
1668 KERN_WARNING
"Count:0x%x\n"
1669 KERN_WARNING
"Status: 0x%x\n",
1670 index
+ 1, frame
->addr
, frame
->count
, status
);
1674 data
= kmalloc(word_count
* 2, GFP_KERNEL
);
1676 dev_err(&pdev
->dev
, "Card%d, firmware upload "
1677 "failed, not enough memory\n", index
+ 1);
1681 insw(base
, data
, word_count
);
1682 InterruptTheCard(base
);
1684 for (a
= 0; a
< frame
->count
; a
++)
1685 if (data
[a
] != frame
->data
[a
]) {
1687 dev_err(&pdev
->dev
, "Card%d, firmware upload "
1688 "failed\n", index
+ 1);
1693 udelay(50); /* 0xf */
1695 if (WaitTillCardIsFree(base
))
1698 status
= inw(base
+ 0x4);
1700 dev_err(&pdev
->dev
, "Card%d verify got out of sync. "
1701 "Card Status:0x%x\n", index
+ 1, status
);
1707 if (WaitTillCardIsFree(base
))
1714 InterruptTheCard(base
);
1715 outw(0x0, base
+ 0x4); /* for ISI4608 cards */
1717 board
->status
|= FIRMWARE_LOADED
;
1721 release_firmware(fw
);
1727 * Insmod can set static symbols so keep these static
1729 static unsigned int card_count
;
1731 static int __devinit
isicom_probe(struct pci_dev
*pdev
,
1732 const struct pci_device_id
*ent
)
1734 unsigned int signature
, index
;
1735 int retval
= -EPERM
;
1736 struct isi_board
*board
= NULL
;
1738 if (card_count
>= BOARD_COUNT
)
1741 dev_info(&pdev
->dev
, "ISI PCI Card(Device ID 0x%x)\n", ent
->device
);
1743 /* allot the first empty slot in the array */
1744 for (index
= 0; index
< BOARD_COUNT
; index
++)
1745 if (isi_card
[index
].base
== 0) {
1746 board
= &isi_card
[index
];
1750 board
->index
= index
;
1751 board
->base
= pci_resource_start(pdev
, 3);
1752 board
->irq
= pdev
->irq
;
1755 pci_set_drvdata(pdev
, board
);
1757 retval
= pci_request_region(pdev
, 3, ISICOM_NAME
);
1759 dev_err(&pdev
->dev
, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1760 "will be disabled.\n", board
->base
, board
->base
+ 15,
1766 retval
= request_irq(board
->irq
, isicom_interrupt
,
1767 IRQF_SHARED
| IRQF_DISABLED
, ISICOM_NAME
, board
);
1769 dev_err(&pdev
->dev
, "Could not install handler at Irq %d. "
1770 "Card%d will be disabled.\n", board
->irq
, index
+ 1);
1774 retval
= reset_card(pdev
, index
, &signature
);
1778 retval
= load_firmware(pdev
, index
, signature
);
1782 for (index
= 0; index
< board
->port_count
; index
++)
1783 tty_register_device(isicom_normal
, board
->index
* 16 + index
,
1789 free_irq(board
->irq
, board
);
1791 pci_release_region(pdev
, 3);
1799 static void __devexit
isicom_remove(struct pci_dev
*pdev
)
1801 struct isi_board
*board
= pci_get_drvdata(pdev
);
1804 for (i
= 0; i
< board
->port_count
; i
++)
1805 tty_unregister_device(isicom_normal
, board
->index
* 16 + i
);
1807 free_irq(board
->irq
, board
);
1808 pci_release_region(pdev
, 3);
1813 static int __init
isicom_init(void)
1815 int retval
, idx
, channel
;
1816 struct isi_port
*port
;
1818 for (idx
= 0; idx
< BOARD_COUNT
; idx
++) {
1819 port
= &isi_ports
[idx
* 16];
1820 isi_card
[idx
].ports
= port
;
1821 spin_lock_init(&isi_card
[idx
].card_lock
);
1822 for (channel
= 0; channel
< 16; channel
++, port
++) {
1823 port
->magic
= ISICOM_MAGIC
;
1824 port
->card
= &isi_card
[idx
];
1825 port
->channel
= channel
;
1826 port
->close_delay
= 50 * HZ
/100;
1827 port
->closing_wait
= 3000 * HZ
/100;
1829 init_waitqueue_head(&port
->open_wait
);
1830 init_waitqueue_head(&port
->close_wait
);
1833 isi_card
[idx
].base
= 0;
1834 isi_card
[idx
].irq
= 0;
1837 /* tty driver structure initialization */
1838 isicom_normal
= alloc_tty_driver(PORT_COUNT
);
1839 if (!isicom_normal
) {
1844 isicom_normal
->owner
= THIS_MODULE
;
1845 isicom_normal
->name
= "ttyM";
1846 isicom_normal
->major
= ISICOM_NMAJOR
;
1847 isicom_normal
->minor_start
= 0;
1848 isicom_normal
->type
= TTY_DRIVER_TYPE_SERIAL
;
1849 isicom_normal
->subtype
= SERIAL_TYPE_NORMAL
;
1850 isicom_normal
->init_termios
= tty_std_termios
;
1851 isicom_normal
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
1853 isicom_normal
->flags
= TTY_DRIVER_REAL_RAW
|
1854 TTY_DRIVER_DYNAMIC_DEV
;
1855 tty_set_operations(isicom_normal
, &isicom_ops
);
1857 retval
= tty_register_driver(isicom_normal
);
1859 pr_dbg("Couldn't register the dialin driver\n");
1863 retval
= pci_register_driver(&isicom_driver
);
1865 printk(KERN_ERR
"ISICOM: Unable to register pci driver.\n");
1869 mod_timer(&tx
, jiffies
+ 1);
1873 tty_unregister_driver(isicom_normal
);
1875 put_tty_driver(isicom_normal
);
1880 static void __exit
isicom_exit(void)
1882 del_timer_sync(&tx
);
1884 pci_unregister_driver(&isicom_driver
);
1885 tty_unregister_driver(isicom_normal
);
1886 put_tty_driver(isicom_normal
);
1889 module_init(isicom_init
);
1890 module_exit(isicom_exit
);
1892 MODULE_AUTHOR("MultiTech");
1893 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1894 MODULE_LICENSE("GPL");