ia64/linux-2.6.18-xen.hg

view drivers/char/isicom.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 3e8752eb6d9c
children
line source
1 /*
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.
6 *
7 * Original driver code supplied by Multi-Tech
8 *
9 * Changes
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)
14 * Printk clean up
15 * 9/12/98 alan@redhat.com Rough port to 2.1.x
16 *
17 * 10/6/99 sameer Merged the ISA and PCI drivers to
18 * a new unified driver.
19 *
20 * 3/9/99 sameer Added support for ISI4616 cards.
21 *
22 * 16/9/99 sameer We do not force RTS low anymore.
23 * This is to prevent the firmware
24 * from getting confused.
25 *
26 * 26/10/99 sameer Cosmetic changes:The driver now
27 * dumps the Port Count information
28 * along with I/O address and IRQ.
29 *
30 * 13/12/99 sameer Fixed the problem with IRQ sharing.
31 *
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
35 * closed.
36 *
37 * 10/5/00 sameer Signal mask setup command added
38 * to isicom_setup_port and
39 * isicom_shutdown_port.
40 *
41 * 24/5/00 sameer The driver is now SMP aware.
42 *
43 *
44 * 27/11/00 Vinayak P Risbud Fixed the Driver Crash Problem
45 *
46 *
47 * 03/01/01 anil .s Added support for resetting the
48 * internal modems on ISI cards.
49 *
50 * 08/02/01 anil .s Upgraded the driver for kernel
51 * 2.4.x
52 *
53 * 11/04/01 Kevin Fixed firmware load problem with
54 * ISIHP-4X card
55 *
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
59 * prompt.
60 *
61 * 03/05/01 anil .s Fixed the problem with IRQ sharing
62 * among ISI-PCI cards.
63 *
64 * 03/05/01 anil .s Added support to display the version
65 * info during insmod as well as module
66 * listing by lsmod.
67 *
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.
72 *
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.
76 *
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
80 * result
81 *
82 * 11/02/03 ranjeeth Added support for 230 Kbps and 460 Kbps
83 * Baud index extended to 21
84 *
85 * 20/03/03 ranjeeth Made to work for Linux Advanced server.
86 * Taken care of license warning.
87 *
88 * 10/12/03 Ravindra Made to work for Fedora Core 1 of
89 * Red Hat Distribution
90 *
91 * 06/01/05 Alan Cox Merged the ISI and base kernel strands
92 * into a single 2.6 driver
93 *
94 * ***********************************************************
95 *
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
99 *
100 * You can find the original tools for this direct from Multitech
101 * ftp://ftp.multitech.com/ISI-Cards/
102 *
103 * Having installed the cards the module options (/etc/modprobe.conf)
104 *
105 * options isicom io=card1,card2,card3,card4 irq=card1,card2,card3,card4
106 *
107 * Omit those entries for boards you don't have installed.
108 *
109 * TODO
110 * Merge testing
111 * 64-bit verification
112 */
114 #include <linux/module.h>
115 #include <linux/firmware.h>
116 #include <linux/kernel.h>
117 #include <linux/tty.h>
118 #include <linux/tty_flip.h>
119 #include <linux/termios.h>
120 #include <linux/fs.h>
121 #include <linux/sched.h>
122 #include <linux/serial.h>
123 #include <linux/mm.h>
124 #include <linux/interrupt.h>
125 #include <linux/timer.h>
126 #include <linux/delay.h>
127 #include <linux/ioport.h>
129 #include <asm/uaccess.h>
130 #include <asm/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 #ifdef DEBUG
141 #define pr_dbg(str...) printk(KERN_DEBUG "ISICOM: " str)
142 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
143 #else
144 #define pr_dbg(str...) do { } while (0)
145 #define isicom_paranoia_check(a, b, c) 0
146 #endif
148 static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
149 static void __devexit isicom_remove(struct pci_dev *);
151 static struct pci_device_id isicom_pci_tbl[] = {
152 { PCI_DEVICE(VENDOR_ID, 0x2028) },
153 { PCI_DEVICE(VENDOR_ID, 0x2051) },
154 { PCI_DEVICE(VENDOR_ID, 0x2052) },
155 { PCI_DEVICE(VENDOR_ID, 0x2053) },
156 { PCI_DEVICE(VENDOR_ID, 0x2054) },
157 { PCI_DEVICE(VENDOR_ID, 0x2055) },
158 { PCI_DEVICE(VENDOR_ID, 0x2056) },
159 { PCI_DEVICE(VENDOR_ID, 0x2057) },
160 { PCI_DEVICE(VENDOR_ID, 0x2058) },
161 { 0 }
162 };
163 MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
165 static struct pci_driver isicom_driver = {
166 .name = "isicom",
167 .id_table = isicom_pci_tbl,
168 .probe = isicom_probe,
169 .remove = __devexit_p(isicom_remove)
170 };
172 static int prev_card = 3; /* start servicing isi_card[0] */
173 static struct tty_driver *isicom_normal;
175 static struct timer_list tx;
176 static char re_schedule = 1;
178 static void isicom_tx(unsigned long _data);
179 static void isicom_start(struct tty_struct *tty);
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
185 };
187 struct isi_board {
188 unsigned long base;
189 unsigned char irq;
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;
195 signed char count;
196 unsigned char isa;
197 spinlock_t card_lock; /* Card wide lock 11/5/00 -sameer */
198 unsigned long flags;
199 };
201 struct isi_port {
202 unsigned short magic;
203 unsigned int flags;
204 int count;
205 int blocked_open;
206 int close_delay;
207 u16 channel;
208 u16 status;
209 u16 closing_wait;
210 struct isi_board * card;
211 struct tty_struct * tty;
212 wait_queue_head_t close_wait;
213 wait_queue_head_t open_wait;
214 struct work_struct hangup_tq;
215 struct work_struct bh_tqueue;
216 unsigned char * xmit_buf;
217 int xmit_head;
218 int xmit_tail;
219 int xmit_cnt;
220 };
222 static struct isi_board isi_card[BOARD_COUNT];
223 static struct isi_port isi_ports[PORT_COUNT];
225 /*
226 * Locking functions for card level locking. We need to own both
227 * the kernel lock for the card and have the card in a position that
228 * it wants to talk.
229 */
231 static int lock_card(struct isi_board *card)
232 {
233 char retries;
234 unsigned long base = card->base;
236 for (retries = 0; retries < 100; retries++) {
237 spin_lock_irqsave(&card->card_lock, card->flags);
238 if (inw(base + 0xe) & 0x1) {
239 return 1;
240 } else {
241 spin_unlock_irqrestore(&card->card_lock, card->flags);
242 udelay(1000); /* 1ms */
243 }
244 }
245 printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n",
246 card->base);
248 return 0; /* Failed to acquire the card! */
249 }
251 static int lock_card_at_interrupt(struct isi_board *card)
252 {
253 unsigned char retries;
254 unsigned long base = card->base;
256 for (retries = 0; retries < 200; retries++) {
257 spin_lock_irqsave(&card->card_lock, card->flags);
259 if (inw(base + 0xe) & 0x1)
260 return 1;
261 else
262 spin_unlock_irqrestore(&card->card_lock, card->flags);
263 }
264 /* Failing in interrupt is an acceptable event */
265 return 0; /* Failed to acquire the card! */
266 }
268 static void unlock_card(struct isi_board *card)
269 {
270 spin_unlock_irqrestore(&card->card_lock, card->flags);
271 }
273 /*
274 * ISI Card specific ops ...
275 */
277 static void raise_dtr(struct isi_port *port)
278 {
279 struct isi_board *card = port->card;
280 unsigned long base = card->base;
281 u16 channel = port->channel;
283 if (!lock_card(card))
284 return;
286 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
287 outw(0x0504, base);
288 InterruptTheCard(base);
289 port->status |= ISI_DTR;
290 unlock_card(card);
291 }
293 static inline void drop_dtr(struct isi_port *port)
294 {
295 struct isi_board *card = port->card;
296 unsigned long base = card->base;
297 u16 channel = port->channel;
299 if (!lock_card(card))
300 return;
302 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
303 outw(0x0404, base);
304 InterruptTheCard(base);
305 port->status &= ~ISI_DTR;
306 unlock_card(card);
307 }
309 static inline void raise_rts(struct isi_port *port)
310 {
311 struct isi_board *card = port->card;
312 unsigned long base = card->base;
313 u16 channel = port->channel;
315 if (!lock_card(card))
316 return;
318 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
319 outw(0x0a04, base);
320 InterruptTheCard(base);
321 port->status |= ISI_RTS;
322 unlock_card(card);
323 }
324 static inline void drop_rts(struct isi_port *port)
325 {
326 struct isi_board *card = port->card;
327 unsigned long base = card->base;
328 u16 channel = port->channel;
330 if (!lock_card(card))
331 return;
333 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
334 outw(0x0804, base);
335 InterruptTheCard(base);
336 port->status &= ~ISI_RTS;
337 unlock_card(card);
338 }
340 static inline void raise_dtr_rts(struct isi_port *port)
341 {
342 struct isi_board *card = port->card;
343 unsigned long base = card->base;
344 u16 channel = port->channel;
346 if (!lock_card(card))
347 return;
349 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
350 outw(0x0f04, base);
351 InterruptTheCard(base);
352 port->status |= (ISI_DTR | ISI_RTS);
353 unlock_card(card);
354 }
356 static void drop_dtr_rts(struct isi_port *port)
357 {
358 struct isi_board *card = port->card;
359 unsigned long base = card->base;
360 u16 channel = port->channel;
362 if (!lock_card(card))
363 return;
365 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
366 outw(0x0c04, base);
367 InterruptTheCard(base);
368 port->status &= ~(ISI_RTS | ISI_DTR);
369 unlock_card(card);
370 }
372 static inline void kill_queue(struct isi_port *port, short queue)
373 {
374 struct isi_board *card = port->card;
375 unsigned long base = card->base;
376 u16 channel = port->channel;
378 if (!lock_card(card))
379 return;
381 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
382 outw((queue << 8) | 0x06, base);
383 InterruptTheCard(base);
384 unlock_card(card);
385 }
387 /*
388 * ISICOM Driver specific routines ...
389 *
390 */
392 static inline int __isicom_paranoia_check(struct isi_port const *port,
393 char *name, const char *routine)
394 {
395 if (!port) {
396 printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
397 "dev %s in %s.\n", name, routine);
398 return 1;
399 }
400 if (port->magic != ISICOM_MAGIC) {
401 printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
402 "dev %s in %s.\n", name, routine);
403 return 1;
404 }
406 return 0;
407 }
409 /*
410 * Transmitter.
411 *
412 * We shovel data into the card buffers on a regular basis. The card
413 * will do the rest of the work for us.
414 */
416 static void isicom_tx(unsigned long _data)
417 {
418 short count = (BOARD_COUNT-1), card, base;
419 short txcount, wrd, residue, word_count, cnt;
420 struct isi_port *port;
421 struct tty_struct *tty;
423 /* find next active board */
424 card = (prev_card + 1) & 0x0003;
425 while(count-- > 0) {
426 if (isi_card[card].status & BOARD_ACTIVE)
427 break;
428 card = (card + 1) & 0x0003;
429 }
430 if (!(isi_card[card].status & BOARD_ACTIVE))
431 goto sched_again;
433 prev_card = card;
435 count = isi_card[card].port_count;
436 port = isi_card[card].ports;
437 base = isi_card[card].base;
438 for (;count > 0;count--, port++) {
439 if (!lock_card_at_interrupt(&isi_card[card]))
440 continue;
441 /* port not active or tx disabled to force flow control */
442 if (!(port->flags & ASYNC_INITIALIZED) ||
443 !(port->status & ISI_TXOK))
444 unlock_card(&isi_card[card]);
445 continue;
447 tty = port->tty;
450 if (tty == NULL) {
451 unlock_card(&isi_card[card]);
452 continue;
453 }
455 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
456 if (txcount <= 0 || tty->stopped || tty->hw_stopped) {
457 unlock_card(&isi_card[card]);
458 continue;
459 }
460 if (!(inw(base + 0x02) & (1 << port->channel))) {
461 unlock_card(&isi_card[card]);
462 continue;
463 }
464 pr_dbg("txing %d bytes, port%d.\n", txcount,
465 port->channel + 1);
466 outw((port->channel << isi_card[card].shift_count) | txcount,
467 base);
468 residue = NO;
469 wrd = 0;
470 while (1) {
471 cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE
472 - port->xmit_tail));
473 if (residue == YES) {
474 residue = NO;
475 if (cnt > 0) {
476 wrd |= (port->xmit_buf[port->xmit_tail]
477 << 8);
478 port->xmit_tail = (port->xmit_tail + 1)
479 & (SERIAL_XMIT_SIZE - 1);
480 port->xmit_cnt--;
481 txcount--;
482 cnt--;
483 outw(wrd, base);
484 } else {
485 outw(wrd, base);
486 break;
487 }
488 }
489 if (cnt <= 0) break;
490 word_count = cnt >> 1;
491 outsw(base, port->xmit_buf+port->xmit_tail,word_count);
492 port->xmit_tail = (port->xmit_tail
493 + (word_count << 1)) & (SERIAL_XMIT_SIZE - 1);
494 txcount -= (word_count << 1);
495 port->xmit_cnt -= (word_count << 1);
496 if (cnt & 0x0001) {
497 residue = YES;
498 wrd = port->xmit_buf[port->xmit_tail];
499 port->xmit_tail = (port->xmit_tail + 1)
500 & (SERIAL_XMIT_SIZE - 1);
501 port->xmit_cnt--;
502 txcount--;
503 }
504 }
506 InterruptTheCard(base);
507 if (port->xmit_cnt <= 0)
508 port->status &= ~ISI_TXOK;
509 if (port->xmit_cnt <= WAKEUP_CHARS)
510 schedule_work(&port->bh_tqueue);
511 unlock_card(&isi_card[card]);
512 }
514 /* schedule another tx for hopefully in about 10ms */
515 sched_again:
516 if (!re_schedule) {
517 re_schedule = 2;
518 return;
519 }
521 init_timer(&tx);
522 tx.expires = jiffies + HZ/100;
523 tx.data = 0;
524 tx.function = isicom_tx;
525 add_timer(&tx);
527 return;
528 }
530 /* Interrupt handlers */
533 static void isicom_bottomhalf(void *data)
534 {
535 struct isi_port *port = (struct isi_port *) data;
536 struct tty_struct *tty = port->tty;
538 if (!tty)
539 return;
541 tty_wakeup(tty);
542 wake_up_interruptible(&tty->write_wait);
543 }
545 /*
546 * Main interrupt handler routine
547 */
549 static irqreturn_t isicom_interrupt(int irq, void *dev_id, struct pt_regs *regs)
550 {
551 struct isi_board *card = dev_id;
552 struct isi_port *port;
553 struct tty_struct *tty;
554 unsigned long base;
555 u16 header, word_count, count, channel;
556 short byte_count;
557 unsigned char *rp;
559 if (!card || !(card->status & FIRMWARE_LOADED))
560 return IRQ_NONE;
562 base = card->base;
563 spin_lock(&card->card_lock);
565 if (card->isa == NO) {
566 /*
567 * disable any interrupts from the PCI card and lower the
568 * interrupt line
569 */
570 outw(0x8000, base+0x04);
571 ClearInterrupt(base);
572 }
574 inw(base); /* get the dummy word out */
575 header = inw(base);
576 channel = (header & 0x7800) >> card->shift_count;
577 byte_count = header & 0xff;
579 if (channel + 1 > card->port_count) {
580 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
581 "%d(channel) > port_count.\n", base, channel+1);
582 if (card->isa)
583 ClearInterrupt(base);
584 else
585 outw(0x0000, base+0x04); /* enable interrupts */
586 spin_unlock(&card->card_lock);
587 return IRQ_HANDLED;
588 }
589 port = card->ports + channel;
590 if (!(port->flags & ASYNC_INITIALIZED)) {
591 if (card->isa)
592 ClearInterrupt(base);
593 else
594 outw(0x0000, base+0x04); /* enable interrupts */
595 return IRQ_HANDLED;
596 }
598 tty = port->tty;
599 if (tty == NULL) {
600 word_count = byte_count >> 1;
601 while(byte_count > 1) {
602 inw(base);
603 byte_count -= 2;
604 }
605 if (byte_count & 0x01)
606 inw(base);
607 if (card->isa == YES)
608 ClearInterrupt(base);
609 else
610 outw(0x0000, base+0x04); /* enable interrupts */
611 spin_unlock(&card->card_lock);
612 return IRQ_HANDLED;
613 }
615 if (header & 0x8000) { /* Status Packet */
616 header = inw(base);
617 switch(header & 0xff) {
618 case 0: /* Change in EIA signals */
619 if (port->flags & ASYNC_CHECK_CD) {
620 if (port->status & ISI_DCD) {
621 if (!(header & ISI_DCD)) {
622 /* Carrier has been lost */
623 pr_dbg("interrupt: DCD->low.\n"
624 );
625 port->status &= ~ISI_DCD;
626 schedule_work(&port->hangup_tq);
627 }
628 } else if (header & ISI_DCD) {
629 /* Carrier has been detected */
630 pr_dbg("interrupt: DCD->high.\n");
631 port->status |= ISI_DCD;
632 wake_up_interruptible(&port->open_wait);
633 }
634 } else {
635 if (header & ISI_DCD)
636 port->status |= ISI_DCD;
637 else
638 port->status &= ~ISI_DCD;
639 }
641 if (port->flags & ASYNC_CTS_FLOW) {
642 if (port->tty->hw_stopped) {
643 if (header & ISI_CTS) {
644 port->tty->hw_stopped = 0;
645 /* start tx ing */
646 port->status |= (ISI_TXOK
647 | ISI_CTS);
648 schedule_work(&port->bh_tqueue);
649 }
650 } else if (!(header & ISI_CTS)) {
651 port->tty->hw_stopped = 1;
652 /* stop tx ing */
653 port->status &= ~(ISI_TXOK | ISI_CTS);
654 }
655 } else {
656 if (header & ISI_CTS)
657 port->status |= ISI_CTS;
658 else
659 port->status &= ~ISI_CTS;
660 }
662 if (header & ISI_DSR)
663 port->status |= ISI_DSR;
664 else
665 port->status &= ~ISI_DSR;
667 if (header & ISI_RI)
668 port->status |= ISI_RI;
669 else
670 port->status &= ~ISI_RI;
672 break;
674 case 1: /* Received Break !!! */
675 tty_insert_flip_char(tty, 0, TTY_BREAK);
676 if (port->flags & ASYNC_SAK)
677 do_SAK(tty);
678 tty_flip_buffer_push(tty);
679 break;
681 case 2: /* Statistics */
682 pr_dbg("isicom_interrupt: stats!!!.\n");
683 break;
685 default:
686 pr_dbg("Intr: Unknown code in status packet.\n");
687 break;
688 }
689 } else { /* Data Packet */
691 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
692 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
693 word_count = count >> 1;
694 insw(base, rp, word_count);
695 byte_count -= (word_count << 1);
696 if (count & 0x0001) {
697 tty_insert_flip_char(tty, inw(base) & 0xff,
698 TTY_NORMAL);
699 byte_count -= 2;
700 }
701 if (byte_count > 0) {
702 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
703 "bytes...\n", base, channel + 1);
704 while(byte_count > 0) { /* drain out unread xtra data */
705 inw(base);
706 byte_count -= 2;
707 }
708 }
709 tty_flip_buffer_push(tty);
710 }
711 if (card->isa == YES)
712 ClearInterrupt(base);
713 else
714 outw(0x0000, base+0x04); /* enable interrupts */
716 return IRQ_HANDLED;
717 }
719 static void isicom_config_port(struct isi_port *port)
720 {
721 struct isi_board *card = port->card;
722 struct tty_struct *tty;
723 unsigned long baud;
724 unsigned long base = card->base;
725 u16 channel_setup, channel = port->channel,
726 shift_count = card->shift_count;
727 unsigned char flow_ctrl;
729 if (!(tty = port->tty) || !tty->termios)
730 return;
731 baud = C_BAUD(tty);
732 if (baud & CBAUDEX) {
733 baud &= ~CBAUDEX;
735 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
736 * then the card is programmed for 57.6Kbps or 115Kbps
737 * respectively.
738 */
740 if (baud < 1 || baud > 2)
741 port->tty->termios->c_cflag &= ~CBAUDEX;
742 else
743 baud += 15;
744 }
745 if (baud == 15) {
747 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
748 * by the set_serial_info ioctl ... this is done by
749 * the 'setserial' utility.
750 */
752 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
753 baud++; /* 57.6 Kbps */
754 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
755 baud +=2; /* 115 Kbps */
756 }
757 if (linuxb_to_isib[baud] == -1) {
758 /* hang up */
759 drop_dtr(port);
760 return;
761 }
762 else
763 raise_dtr(port);
765 if (lock_card(card)) {
766 outw(0x8000 | (channel << shift_count) |0x03, base);
767 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
768 channel_setup = 0;
769 switch(C_CSIZE(tty)) {
770 case CS5:
771 channel_setup |= ISICOM_CS5;
772 break;
773 case CS6:
774 channel_setup |= ISICOM_CS6;
775 break;
776 case CS7:
777 channel_setup |= ISICOM_CS7;
778 break;
779 case CS8:
780 channel_setup |= ISICOM_CS8;
781 break;
782 }
784 if (C_CSTOPB(tty))
785 channel_setup |= ISICOM_2SB;
786 if (C_PARENB(tty)) {
787 channel_setup |= ISICOM_EVPAR;
788 if (C_PARODD(tty))
789 channel_setup |= ISICOM_ODPAR;
790 }
791 outw(channel_setup, base);
792 InterruptTheCard(base);
793 unlock_card(card);
794 }
795 if (C_CLOCAL(tty))
796 port->flags &= ~ASYNC_CHECK_CD;
797 else
798 port->flags |= ASYNC_CHECK_CD;
800 /* flow control settings ...*/
801 flow_ctrl = 0;
802 port->flags &= ~ASYNC_CTS_FLOW;
803 if (C_CRTSCTS(tty)) {
804 port->flags |= ASYNC_CTS_FLOW;
805 flow_ctrl |= ISICOM_CTSRTS;
806 }
807 if (I_IXON(tty))
808 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
809 if (I_IXOFF(tty))
810 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
812 if (lock_card(card)) {
813 outw(0x8000 | (channel << shift_count) |0x04, base);
814 outw(flow_ctrl << 8 | 0x05, base);
815 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
816 InterruptTheCard(base);
817 unlock_card(card);
818 }
820 /* rx enabled -> enable port for rx on the card */
821 if (C_CREAD(tty)) {
822 card->port_status |= (1 << channel);
823 outw(card->port_status, base + 0x02);
824 }
825 }
827 /* open et all */
829 static inline void isicom_setup_board(struct isi_board *bp)
830 {
831 int channel;
832 struct isi_port *port;
833 unsigned long flags;
835 spin_lock_irqsave(&bp->card_lock, flags);
836 if (bp->status & BOARD_ACTIVE) {
837 spin_unlock_irqrestore(&bp->card_lock, flags);
838 return;
839 }
840 port = bp->ports;
841 bp->status |= BOARD_ACTIVE;
842 spin_unlock_irqrestore(&bp->card_lock, flags);
843 for (channel = 0; channel < bp->port_count; channel++, port++)
844 drop_dtr_rts(port);
845 return;
846 }
848 static int isicom_setup_port(struct isi_port *port)
849 {
850 struct isi_board *card = port->card;
851 unsigned long flags;
853 if (port->flags & ASYNC_INITIALIZED) {
854 return 0;
855 }
856 if (!port->xmit_buf) {
857 unsigned long page;
859 if (!(page = get_zeroed_page(GFP_KERNEL)))
860 return -ENOMEM;
862 if (port->xmit_buf) {
863 free_page(page);
864 return -ERESTARTSYS;
865 }
866 port->xmit_buf = (unsigned char *) page;
867 }
869 spin_lock_irqsave(&card->card_lock, flags);
870 if (port->tty)
871 clear_bit(TTY_IO_ERROR, &port->tty->flags);
872 if (port->count == 1)
873 card->count++;
875 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
877 /* discard any residual data */
878 kill_queue(port, ISICOM_KILLTX | ISICOM_KILLRX);
880 isicom_config_port(port);
881 port->flags |= ASYNC_INITIALIZED;
882 spin_unlock_irqrestore(&card->card_lock, flags);
884 return 0;
885 }
887 static int block_til_ready(struct tty_struct *tty, struct file *filp,
888 struct isi_port *port)
889 {
890 struct isi_board *card = port->card;
891 int do_clocal = 0, retval;
892 unsigned long flags;
893 DECLARE_WAITQUEUE(wait, current);
895 /* block if port is in the process of being closed */
897 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
898 pr_dbg("block_til_ready: close in progress.\n");
899 interruptible_sleep_on(&port->close_wait);
900 if (port->flags & ASYNC_HUP_NOTIFY)
901 return -EAGAIN;
902 else
903 return -ERESTARTSYS;
904 }
906 /* if non-blocking mode is set ... */
908 if ((filp->f_flags & O_NONBLOCK) ||
909 (tty->flags & (1 << TTY_IO_ERROR))) {
910 pr_dbg("block_til_ready: non-block mode.\n");
911 port->flags |= ASYNC_NORMAL_ACTIVE;
912 return 0;
913 }
915 if (C_CLOCAL(tty))
916 do_clocal = 1;
918 /* block waiting for DCD to be asserted, and while
919 callout dev is busy */
920 retval = 0;
921 add_wait_queue(&port->open_wait, &wait);
923 spin_lock_irqsave(&card->card_lock, flags);
924 if (!tty_hung_up_p(filp))
925 port->count--;
926 port->blocked_open++;
927 spin_unlock_irqrestore(&card->card_lock, flags);
929 while (1) {
930 raise_dtr_rts(port);
932 set_current_state(TASK_INTERRUPTIBLE);
933 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
934 if (port->flags & ASYNC_HUP_NOTIFY)
935 retval = -EAGAIN;
936 else
937 retval = -ERESTARTSYS;
938 break;
939 }
940 if (!(port->flags & ASYNC_CLOSING) &&
941 (do_clocal || (port->status & ISI_DCD))) {
942 break;
943 }
944 if (signal_pending(current)) {
945 retval = -ERESTARTSYS;
946 break;
947 }
948 schedule();
949 }
950 set_current_state(TASK_RUNNING);
951 remove_wait_queue(&port->open_wait, &wait);
952 spin_lock_irqsave(&card->card_lock, flags);
953 if (!tty_hung_up_p(filp))
954 port->count++;
955 port->blocked_open--;
956 spin_unlock_irqrestore(&card->card_lock, flags);
957 if (retval)
958 return retval;
959 port->flags |= ASYNC_NORMAL_ACTIVE;
960 return 0;
961 }
963 static int isicom_open(struct tty_struct *tty, struct file *filp)
964 {
965 struct isi_port *port;
966 struct isi_board *card;
967 unsigned int line, board;
968 int error;
970 line = tty->index;
971 if (line < 0 || line > PORT_COUNT-1)
972 return -ENODEV;
973 board = BOARD(line);
974 card = &isi_card[board];
976 if (!(card->status & FIRMWARE_LOADED))
977 return -ENODEV;
979 /* open on a port greater than the port count for the card !!! */
980 if (line > ((board * 16) + card->port_count - 1))
981 return -ENODEV;
983 port = &isi_ports[line];
984 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
985 return -ENODEV;
987 isicom_setup_board(card);
989 port->count++;
990 tty->driver_data = port;
991 port->tty = tty;
992 if ((error = isicom_setup_port(port))!=0)
993 return error;
994 if ((error = block_til_ready(tty, filp, port))!=0)
995 return error;
997 return 0;
998 }
1000 /* close et all */
1002 static inline void isicom_shutdown_board(struct isi_board *bp)
1004 unsigned long flags;
1006 spin_lock_irqsave(&bp->card_lock, flags);
1007 if (bp->status & BOARD_ACTIVE) {
1008 bp->status &= ~BOARD_ACTIVE;
1010 spin_unlock_irqrestore(&bp->card_lock, flags);
1013 static void isicom_shutdown_port(struct isi_port *port)
1015 struct isi_board *card = port->card;
1016 struct tty_struct *tty;
1017 unsigned long flags;
1019 tty = port->tty;
1021 spin_lock_irqsave(&card->card_lock, flags);
1022 if (!(port->flags & ASYNC_INITIALIZED)) {
1023 spin_unlock_irqrestore(&card->card_lock, flags);
1024 return;
1026 if (port->xmit_buf) {
1027 free_page((unsigned long) port->xmit_buf);
1028 port->xmit_buf = NULL;
1030 port->flags &= ~ASYNC_INITIALIZED;
1031 /* 3rd October 2000 : Vinayak P Risbud */
1032 port->tty = NULL;
1033 spin_unlock_irqrestore(&card->card_lock, flags);
1035 /*Fix done by Anil .S on 30-04-2001
1036 remote login through isi port has dtr toggle problem
1037 due to which the carrier drops before the password prompt
1038 appears on the remote end. Now we drop the dtr only if the
1039 HUPCL(Hangup on close) flag is set for the tty*/
1041 if (C_HUPCL(tty))
1042 /* drop dtr on this port */
1043 drop_dtr(port);
1045 /* any other port uninits */
1046 if (tty)
1047 set_bit(TTY_IO_ERROR, &tty->flags);
1049 if (--card->count < 0) {
1050 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
1051 card->base, card->count);
1052 card->count = 0;
1055 /* last port was closed, shutdown that boad too */
1056 if (C_HUPCL(tty)) {
1057 if (!card->count)
1058 isicom_shutdown_board(card);
1062 static void isicom_close(struct tty_struct *tty, struct file *filp)
1064 struct isi_port *port = tty->driver_data;
1065 struct isi_board *card;
1066 unsigned long flags;
1068 if (!port)
1069 return;
1070 card = port->card;
1071 if (isicom_paranoia_check(port, tty->name, "isicom_close"))
1072 return;
1074 pr_dbg("Close start!!!.\n");
1076 spin_lock_irqsave(&card->card_lock, flags);
1077 if (tty_hung_up_p(filp)) {
1078 spin_unlock_irqrestore(&card->card_lock, flags);
1079 return;
1082 if (tty->count == 1 && port->count != 1) {
1083 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1084 "count tty->count = 1 port count = %d.\n",
1085 card->base, port->count);
1086 port->count = 1;
1088 if (--port->count < 0) {
1089 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1090 "count for channel%d = %d", card->base, port->channel,
1091 port->count);
1092 port->count = 0;
1095 if (port->count) {
1096 spin_unlock_irqrestore(&card->card_lock, flags);
1097 return;
1099 port->flags |= ASYNC_CLOSING;
1100 tty->closing = 1;
1101 spin_unlock_irqrestore(&card->card_lock, flags);
1103 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1104 tty_wait_until_sent(tty, port->closing_wait);
1105 /* indicate to the card that no more data can be received
1106 on this port */
1107 spin_lock_irqsave(&card->card_lock, flags);
1108 if (port->flags & ASYNC_INITIALIZED) {
1109 card->port_status &= ~(1 << port->channel);
1110 outw(card->port_status, card->base + 0x02);
1112 isicom_shutdown_port(port);
1113 spin_unlock_irqrestore(&card->card_lock, flags);
1115 if (tty->driver->flush_buffer)
1116 tty->driver->flush_buffer(tty);
1117 tty_ldisc_flush(tty);
1119 spin_lock_irqsave(&card->card_lock, flags);
1120 tty->closing = 0;
1122 if (port->blocked_open) {
1123 spin_unlock_irqrestore(&card->card_lock, flags);
1124 if (port->close_delay) {
1125 pr_dbg("scheduling until time out.\n");
1126 msleep_interruptible(
1127 jiffies_to_msecs(port->close_delay));
1129 spin_lock_irqsave(&card->card_lock, flags);
1130 wake_up_interruptible(&port->open_wait);
1132 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1133 wake_up_interruptible(&port->close_wait);
1134 spin_unlock_irqrestore(&card->card_lock, flags);
1137 /* write et all */
1138 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1139 int count)
1141 struct isi_port *port = tty->driver_data;
1142 struct isi_board *card = port->card;
1143 unsigned long flags;
1144 int cnt, total = 0;
1146 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1147 return 0;
1149 if (!port->xmit_buf)
1150 return 0;
1152 spin_lock_irqsave(&card->card_lock, flags);
1154 while(1) {
1155 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
1156 - 1, SERIAL_XMIT_SIZE - port->xmit_head));
1157 if (cnt <= 0)
1158 break;
1160 memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
1161 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
1162 - 1);
1163 port->xmit_cnt += cnt;
1164 buf += cnt;
1165 count -= cnt;
1166 total += cnt;
1168 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1169 port->status |= ISI_TXOK;
1170 spin_unlock_irqrestore(&card->card_lock, flags);
1171 return total;
1174 /* put_char et all */
1175 static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
1177 struct isi_port *port = tty->driver_data;
1178 struct isi_board *card = port->card;
1179 unsigned long flags;
1181 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1182 return;
1184 if (!port->xmit_buf)
1185 return;
1187 spin_lock_irqsave(&card->card_lock, flags);
1188 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1189 spin_unlock_irqrestore(&card->card_lock, flags);
1190 return;
1193 port->xmit_buf[port->xmit_head++] = ch;
1194 port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1195 port->xmit_cnt++;
1196 spin_unlock_irqrestore(&card->card_lock, flags);
1199 /* flush_chars et all */
1200 static void isicom_flush_chars(struct tty_struct *tty)
1202 struct isi_port *port = tty->driver_data;
1204 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1205 return;
1207 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1208 !port->xmit_buf)
1209 return;
1211 /* this tells the transmitter to consider this port for
1212 data output to the card ... that's the best we can do. */
1213 port->status |= ISI_TXOK;
1216 /* write_room et all */
1217 static int isicom_write_room(struct tty_struct *tty)
1219 struct isi_port *port = tty->driver_data;
1220 int free;
1222 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1223 return 0;
1225 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1226 if (free < 0)
1227 free = 0;
1228 return free;
1231 /* chars_in_buffer et all */
1232 static int isicom_chars_in_buffer(struct tty_struct *tty)
1234 struct isi_port *port = tty->driver_data;
1235 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1236 return 0;
1237 return port->xmit_cnt;
1240 /* ioctl et all */
1241 static inline void isicom_send_break(struct isi_port *port,
1242 unsigned long length)
1244 struct isi_board *card = port->card;
1245 unsigned long base = card->base;
1247 if (!lock_card(card))
1248 return;
1250 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1251 outw((length & 0xff) << 8 | 0x00, base);
1252 outw((length & 0xff00), base);
1253 InterruptTheCard(base);
1255 unlock_card(card);
1258 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1260 struct isi_port *port = tty->driver_data;
1261 /* just send the port status */
1262 u16 status = port->status;
1264 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1265 return -ENODEV;
1267 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1268 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1269 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1270 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1271 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1272 ((status & ISI_RI ) ? TIOCM_RI : 0);
1275 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1276 unsigned int set, unsigned int clear)
1278 struct isi_port *port = tty->driver_data;
1280 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1281 return -ENODEV;
1283 if (set & TIOCM_RTS)
1284 raise_rts(port);
1285 if (set & TIOCM_DTR)
1286 raise_dtr(port);
1288 if (clear & TIOCM_RTS)
1289 drop_rts(port);
1290 if (clear & TIOCM_DTR)
1291 drop_dtr(port);
1293 return 0;
1296 static int isicom_set_serial_info(struct isi_port *port,
1297 struct serial_struct __user *info)
1299 struct serial_struct newinfo;
1300 int reconfig_port;
1302 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1303 return -EFAULT;
1305 reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
1306 (newinfo.flags & ASYNC_SPD_MASK));
1308 if (!capable(CAP_SYS_ADMIN)) {
1309 if ((newinfo.close_delay != port->close_delay) ||
1310 (newinfo.closing_wait != port->closing_wait) ||
1311 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1312 (port->flags & ~ASYNC_USR_MASK)))
1313 return -EPERM;
1314 port->flags = ((port->flags & ~ ASYNC_USR_MASK) |
1315 (newinfo.flags & ASYNC_USR_MASK));
1317 else {
1318 port->close_delay = newinfo.close_delay;
1319 port->closing_wait = newinfo.closing_wait;
1320 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1321 (newinfo.flags & ASYNC_FLAGS));
1323 if (reconfig_port) {
1324 isicom_config_port(port);
1326 return 0;
1329 static int isicom_get_serial_info(struct isi_port *port,
1330 struct serial_struct __user *info)
1332 struct serial_struct out_info;
1334 memset(&out_info, 0, sizeof(out_info));
1335 /* out_info.type = ? */
1336 out_info.line = port - isi_ports;
1337 out_info.port = port->card->base;
1338 out_info.irq = port->card->irq;
1339 out_info.flags = port->flags;
1340 /* out_info.baud_base = ? */
1341 out_info.close_delay = port->close_delay;
1342 out_info.closing_wait = port->closing_wait;
1343 if (copy_to_user(info, &out_info, sizeof(out_info)))
1344 return -EFAULT;
1345 return 0;
1348 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1349 unsigned int cmd, unsigned long arg)
1351 struct isi_port *port = tty->driver_data;
1352 void __user *argp = (void __user *)arg;
1353 int retval;
1355 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1356 return -ENODEV;
1358 switch(cmd) {
1359 case TCSBRK:
1360 retval = tty_check_change(tty);
1361 if (retval)
1362 return retval;
1363 tty_wait_until_sent(tty, 0);
1364 if (!arg)
1365 isicom_send_break(port, HZ/4);
1366 return 0;
1368 case TCSBRKP:
1369 retval = tty_check_change(tty);
1370 if (retval)
1371 return retval;
1372 tty_wait_until_sent(tty, 0);
1373 isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
1374 return 0;
1376 case TIOCGSOFTCAR:
1377 return put_user(C_CLOCAL(tty) ? 1 : 0,
1378 (unsigned long __user *)argp);
1380 case TIOCSSOFTCAR:
1381 if (get_user(arg, (unsigned long __user *) argp))
1382 return -EFAULT;
1383 tty->termios->c_cflag =
1384 ((tty->termios->c_cflag & ~CLOCAL) |
1385 (arg ? CLOCAL : 0));
1386 return 0;
1388 case TIOCGSERIAL:
1389 return isicom_get_serial_info(port, argp);
1391 case TIOCSSERIAL:
1392 return isicom_set_serial_info(port, argp);
1394 default:
1395 return -ENOIOCTLCMD;
1397 return 0;
1400 /* set_termios et all */
1401 static void isicom_set_termios(struct tty_struct *tty,
1402 struct termios *old_termios)
1404 struct isi_port *port = tty->driver_data;
1406 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1407 return;
1409 if (tty->termios->c_cflag == old_termios->c_cflag &&
1410 tty->termios->c_iflag == old_termios->c_iflag)
1411 return;
1413 isicom_config_port(port);
1415 if ((old_termios->c_cflag & CRTSCTS) &&
1416 !(tty->termios->c_cflag & CRTSCTS)) {
1417 tty->hw_stopped = 0;
1418 isicom_start(tty);
1422 /* throttle et all */
1423 static void isicom_throttle(struct tty_struct *tty)
1425 struct isi_port *port = tty->driver_data;
1426 struct isi_board *card = port->card;
1428 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1429 return;
1431 /* tell the card that this port cannot handle any more data for now */
1432 card->port_status &= ~(1 << port->channel);
1433 outw(card->port_status, card->base + 0x02);
1436 /* unthrottle et all */
1437 static void isicom_unthrottle(struct tty_struct *tty)
1439 struct isi_port *port = tty->driver_data;
1440 struct isi_board *card = port->card;
1442 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1443 return;
1445 /* tell the card that this port is ready to accept more data */
1446 card->port_status |= (1 << port->channel);
1447 outw(card->port_status, card->base + 0x02);
1450 /* stop et all */
1451 static void isicom_stop(struct tty_struct *tty)
1453 struct isi_port *port = tty->driver_data;
1455 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1456 return;
1458 /* this tells the transmitter not to consider this port for
1459 data output to the card. */
1460 port->status &= ~ISI_TXOK;
1463 /* start et all */
1464 static void isicom_start(struct tty_struct *tty)
1466 struct isi_port *port = tty->driver_data;
1468 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1469 return;
1471 /* this tells the transmitter to consider this port for
1472 data output to the card. */
1473 port->status |= ISI_TXOK;
1476 /* hangup et all */
1477 static void do_isicom_hangup(void *data)
1479 struct isi_port *port = data;
1480 struct tty_struct *tty;
1482 tty = port->tty;
1483 if (tty)
1484 tty_hangup(tty);
1487 static void isicom_hangup(struct tty_struct *tty)
1489 struct isi_port *port = tty->driver_data;
1491 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1492 return;
1494 isicom_shutdown_port(port);
1495 port->count = 0;
1496 port->flags &= ~ASYNC_NORMAL_ACTIVE;
1497 port->tty = NULL;
1498 wake_up_interruptible(&port->open_wait);
1501 /* flush_buffer et all */
1502 static void isicom_flush_buffer(struct tty_struct *tty)
1504 struct isi_port *port = tty->driver_data;
1505 struct isi_board *card = port->card;
1506 unsigned long flags;
1508 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
1509 return;
1511 spin_lock_irqsave(&card->card_lock, flags);
1512 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1513 spin_unlock_irqrestore(&card->card_lock, flags);
1515 wake_up_interruptible(&tty->write_wait);
1516 tty_wakeup(tty);
1519 /*
1520 * Driver init and deinit functions
1521 */
1523 static int __devinit isicom_register_ioregion(struct pci_dev *pdev,
1524 const unsigned int index)
1526 struct isi_board *board = pci_get_drvdata(pdev);
1528 if (!board->base)
1529 return -EINVAL;
1531 if (!request_region(board->base, 16, ISICOM_NAME)) {
1532 dev_dbg(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1533 "will be disabled.\n", board->base, board->base + 15,
1534 index + 1);
1535 return -EBUSY;
1538 return 0;
1541 static void isicom_unregister_ioregion(struct pci_dev *pdev)
1543 struct isi_board *board = pci_get_drvdata(pdev);
1545 if (!board->base)
1546 return;
1548 release_region(board->base, 16);
1549 dev_dbg(&pdev->dev, "I/O Region 0x%lx-0x%lx released.\n",
1550 board->base, board->base + 15);
1551 board->base = 0;
1554 static struct tty_operations isicom_ops = {
1555 .open = isicom_open,
1556 .close = isicom_close,
1557 .write = isicom_write,
1558 .put_char = isicom_put_char,
1559 .flush_chars = isicom_flush_chars,
1560 .write_room = isicom_write_room,
1561 .chars_in_buffer = isicom_chars_in_buffer,
1562 .ioctl = isicom_ioctl,
1563 .set_termios = isicom_set_termios,
1564 .throttle = isicom_throttle,
1565 .unthrottle = isicom_unthrottle,
1566 .stop = isicom_stop,
1567 .start = isicom_start,
1568 .hangup = isicom_hangup,
1569 .flush_buffer = isicom_flush_buffer,
1570 .tiocmget = isicom_tiocmget,
1571 .tiocmset = isicom_tiocmset,
1572 };
1574 static int __devinit isicom_register_tty_driver(void)
1576 int error = -ENOMEM;
1578 /* tty driver structure initialization */
1579 isicom_normal = alloc_tty_driver(PORT_COUNT);
1580 if (!isicom_normal)
1581 goto end;
1583 isicom_normal->owner = THIS_MODULE;
1584 isicom_normal->name = "ttyM";
1585 isicom_normal->major = ISICOM_NMAJOR;
1586 isicom_normal->minor_start = 0;
1587 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1588 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1589 isicom_normal->init_termios = tty_std_termios;
1590 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1591 CLOCAL;
1592 isicom_normal->flags = TTY_DRIVER_REAL_RAW;
1593 tty_set_operations(isicom_normal, &isicom_ops);
1595 if ((error = tty_register_driver(isicom_normal))) {
1596 pr_dbg("Couldn't register the dialin driver, error=%d\n",
1597 error);
1598 put_tty_driver(isicom_normal);
1600 end:
1601 return error;
1604 static void isicom_unregister_tty_driver(void)
1606 int error;
1608 if ((error = tty_unregister_driver(isicom_normal)))
1609 pr_dbg("couldn't unregister normal driver, error=%d.\n", error);
1611 put_tty_driver(isicom_normal);
1614 static int __devinit isicom_register_isr(struct pci_dev *pdev,
1615 const unsigned int index)
1617 struct isi_board *board = pci_get_drvdata(pdev);
1618 unsigned long irqflags = IRQF_DISABLED;
1619 int retval = -EINVAL;
1621 if (!board->base)
1622 goto end;
1624 if (board->isa == NO)
1625 irqflags |= IRQF_SHARED;
1627 retval = request_irq(board->irq, isicom_interrupt, irqflags,
1628 ISICOM_NAME, board);
1629 if (retval < 0)
1630 dev_warn(&pdev->dev, "Could not install handler at Irq %d. "
1631 "Card%d will be disabled.\n", board->irq, index + 1);
1632 else
1633 retval = 0;
1634 end:
1635 return retval;
1638 static int __devinit reset_card(struct pci_dev *pdev,
1639 const unsigned int card, unsigned int *signature)
1641 struct isi_board *board = pci_get_drvdata(pdev);
1642 unsigned long base = board->base;
1643 unsigned int portcount = 0;
1644 int retval = 0;
1646 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1647 base);
1649 inw(base + 0x8);
1651 mdelay(10);
1653 outw(0, base + 0x8); /* Reset */
1655 msleep(3000);
1657 *signature = inw(base + 0x4) & 0xff;
1659 if (board->isa == YES) {
1660 if (!(inw(base + 0xe) & 0x1) || (inw(base + 0x2))) {
1661 dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
1662 inw(base + 0x2), inw(base + 0xe));
1663 dev_err(&pdev->dev, "ISILoad:ISA Card%d reset failure "
1664 "(Possible bad I/O Port Address 0x%lx).\n",
1665 card + 1, base);
1666 retval = -EIO;
1667 goto end;
1669 } else {
1670 portcount = inw(base + 0x2);
1671 if (!(inw(base + 0xe) & 0x1) || ((portcount != 0) &&
1672 (portcount != 4) && (portcount != 8))) {
1673 dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
1674 inw(base + 0x2), inw(base + 0xe));
1675 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure "
1676 "(Possible bad I/O Port Address 0x%lx).\n",
1677 card + 1, base);
1678 retval = -EIO;
1679 goto end;
1683 switch (*signature) {
1684 case 0xa5:
1685 case 0xbb:
1686 case 0xdd:
1687 board->port_count = (board->isa == NO && portcount == 4) ? 4 :
1688 8;
1689 board->shift_count = 12;
1690 break;
1691 case 0xcc:
1692 board->port_count = 16;
1693 board->shift_count = 11;
1694 break;
1695 default:
1696 dev_warn(&pdev->dev, "ISILoad:Card%d reset failure (Possible "
1697 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1698 dev_dbg(&pdev->dev, "Sig=0x%lx\n", signature);
1699 retval = -EIO;
1701 dev_info(&pdev->dev, "-Done\n");
1703 end:
1704 return retval;
1707 static inline int WaitTillCardIsFree(u16 base)
1709 unsigned long count = 0;
1711 while (!(inw(base + 0xe) & 0x1) && count++ < 100)
1712 msleep(5);
1714 return !(inw(base + 0xe) & 0x1);
1717 static int __devinit load_firmware(struct pci_dev *pdev,
1718 const unsigned int index, const unsigned int signature)
1720 struct isi_board *board = pci_get_drvdata(pdev);
1721 const struct firmware *fw;
1722 unsigned long base = board->base;
1723 unsigned int a;
1724 u16 word_count, status;
1725 int retval = -EIO;
1726 char *name;
1727 u8 *data;
1729 struct stframe {
1730 u16 addr;
1731 u16 count;
1732 u8 data[0];
1733 } *frame;
1735 switch (signature) {
1736 case 0xa5:
1737 name = "isi608.bin";
1738 break;
1739 case 0xbb:
1740 name = "isi608em.bin";
1741 break;
1742 case 0xcc:
1743 name = "isi616em.bin";
1744 break;
1745 case 0xdd:
1746 name = "isi4608.bin";
1747 break;
1748 case 0xee:
1749 name = "isi4616.bin";
1750 break;
1751 default:
1752 dev_err(&pdev->dev, "Unknown signature.\n");
1753 goto end;
1756 retval = request_firmware(&fw, name, &pdev->dev);
1757 if (retval)
1758 goto end;
1760 for (frame = (struct stframe *)fw->data;
1761 frame < (struct stframe *)(fw->data + fw->size);
1762 frame++) {
1763 if (WaitTillCardIsFree(base))
1764 goto errrelfw;
1766 outw(0xf0, base); /* start upload sequence */
1767 outw(0x00, base);
1768 outw(frame->addr, base); /* lsb of address */
1770 word_count = frame->count / 2 + frame->count % 2;
1771 outw(word_count, base);
1772 InterruptTheCard(base);
1774 udelay(100); /* 0x2f */
1776 if (WaitTillCardIsFree(base))
1777 goto errrelfw;
1779 if ((status = inw(base + 0x4)) != 0) {
1780 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1781 "Address:0x%x\nCount:0x%x\nStatus:0x%x\n",
1782 index + 1, frame->addr, frame->count, status);
1783 goto errrelfw;
1785 outsw(base, frame->data, word_count);
1787 InterruptTheCard(base);
1789 udelay(50); /* 0x0f */
1791 if (WaitTillCardIsFree(base))
1792 goto errrelfw;
1794 if ((status = inw(base + 0x4)) != 0) {
1795 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1796 "Status:0x%x\n", index + 1, status);
1797 goto errrelfw;
1801 retval = -EIO;
1803 if (WaitTillCardIsFree(base))
1804 goto errrelfw;
1806 outw(0xf2, base);
1807 outw(0x800, base);
1808 outw(0x0, base);
1809 outw(0x0, base);
1810 InterruptTheCard(base);
1811 outw(0x0, base + 0x4); /* for ISI4608 cards */
1813 /* XXX: should we test it by reading it back and comparing with original like
1814 * in load firmware package? */
1815 for (frame = (struct stframe*)fw->data;
1816 frame < (struct stframe*)(fw->data + fw->size);
1817 frame++) {
1818 if (WaitTillCardIsFree(base))
1819 goto errrelfw;
1821 outw(0xf1, base); /* start download sequence */
1822 outw(0x00, base);
1823 outw(frame->addr, base); /* lsb of address */
1825 word_count = (frame->count >> 1) + frame->count % 2;
1826 outw(word_count + 1, base);
1827 InterruptTheCard(base);
1829 udelay(50); /* 0xf */
1831 if (WaitTillCardIsFree(base))
1832 goto errrelfw;
1834 if ((status = inw(base + 0x4)) != 0) {
1835 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1836 "Address:0x%x\nCount:0x%x\nStatus: 0x%x\n",
1837 index + 1, frame->addr, frame->count, status);
1838 goto errrelfw;
1841 data = kmalloc(word_count * 2, GFP_KERNEL);
1842 inw(base);
1843 insw(base, data, word_count);
1844 InterruptTheCard(base);
1846 for (a = 0; a < frame->count; a++)
1847 if (data[a] != frame->data[a]) {
1848 kfree(data);
1849 dev_err(&pdev->dev, "Card%d, firmware upload "
1850 "failed\n", index + 1);
1851 goto errrelfw;
1853 kfree(data);
1855 udelay(50); /* 0xf */
1857 if (WaitTillCardIsFree(base))
1858 goto errrelfw;
1860 if ((status = inw(base + 0x4)) != 0) {
1861 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1862 "Card Status:0x%x\n", index + 1, status);
1863 goto errrelfw;
1867 board->status |= FIRMWARE_LOADED;
1868 retval = 0;
1870 errrelfw:
1871 release_firmware(fw);
1872 end:
1873 return retval;
1876 /*
1877 * Insmod can set static symbols so keep these static
1878 */
1879 static int io[4];
1880 static int irq[4];
1881 static int card;
1883 static int __devinit isicom_probe(struct pci_dev *pdev,
1884 const struct pci_device_id *ent)
1886 unsigned int ioaddr, signature, index;
1887 int retval = -EPERM;
1888 u8 pciirq;
1889 struct isi_board *board = NULL;
1891 if (card >= BOARD_COUNT)
1892 goto err;
1894 ioaddr = pci_resource_start(pdev, 3);
1895 /* i.e at offset 0x1c in the PCI configuration register space. */
1896 pciirq = pdev->irq;
1897 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1899 /* allot the first empty slot in the array */
1900 for (index = 0; index < BOARD_COUNT; index++)
1901 if (isi_card[index].base == 0) {
1902 board = &isi_card[index];
1903 break;
1906 board->base = ioaddr;
1907 board->irq = pciirq;
1908 board->isa = NO;
1909 card++;
1911 pci_set_drvdata(pdev, board);
1913 retval = isicom_register_ioregion(pdev, index);
1914 if (retval < 0)
1915 goto err;
1917 retval = isicom_register_isr(pdev, index);
1918 if (retval < 0)
1919 goto errunrr;
1921 retval = reset_card(pdev, index, &signature);
1922 if (retval < 0)
1923 goto errunri;
1925 retval = load_firmware(pdev, index, signature);
1926 if (retval < 0)
1927 goto errunri;
1929 return 0;
1931 errunri:
1932 free_irq(board->irq, board);
1933 errunrr:
1934 isicom_unregister_ioregion(pdev);
1935 err:
1936 board->base = 0;
1937 return retval;
1940 static void __devexit isicom_remove(struct pci_dev *pdev)
1942 struct isi_board *board = pci_get_drvdata(pdev);
1944 free_irq(board->irq, board);
1945 isicom_unregister_ioregion(pdev);
1948 static int __devinit isicom_setup(void)
1950 int retval, idx, channel;
1951 struct isi_port *port;
1953 card = 0;
1954 memset(isi_ports, 0, sizeof(isi_ports));
1956 for(idx = 0; idx < BOARD_COUNT; idx++) {
1957 port = &isi_ports[idx * 16];
1958 isi_card[idx].ports = port;
1959 spin_lock_init(&isi_card[idx].card_lock);
1960 for (channel = 0; channel < 16; channel++, port++) {
1961 port->magic = ISICOM_MAGIC;
1962 port->card = &isi_card[idx];
1963 port->channel = channel;
1964 port->close_delay = 50 * HZ/100;
1965 port->closing_wait = 3000 * HZ/100;
1966 INIT_WORK(&port->hangup_tq, do_isicom_hangup, port);
1967 INIT_WORK(&port->bh_tqueue, isicom_bottomhalf, port);
1968 port->status = 0;
1969 init_waitqueue_head(&port->open_wait);
1970 init_waitqueue_head(&port->close_wait);
1971 /* . . . */
1973 isi_card[idx].base = 0;
1974 isi_card[idx].irq = 0;
1976 if (!io[idx])
1977 continue;
1979 if (irq[idx] == 2 || irq[idx] == 3 || irq[idx] == 4 ||
1980 irq[idx] == 5 || irq[idx] == 7 ||
1981 irq[idx] == 10 || irq[idx] == 11 ||
1982 irq[idx] == 12 || irq[idx] == 15) {
1983 printk(KERN_ERR "ISICOM: ISA not supported yet.\n");
1984 retval = -EINVAL;
1985 goto error;
1986 } else
1987 printk(KERN_ERR "ISICOM: Irq %d unsupported. "
1988 "Disabling Card%d...\n", irq[idx], idx + 1);
1991 retval = isicom_register_tty_driver();
1992 if (retval < 0)
1993 goto error;
1995 retval = pci_register_driver(&isicom_driver);
1996 if (retval < 0) {
1997 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1998 goto errtty;
2001 init_timer(&tx);
2002 tx.expires = jiffies + 1;
2003 tx.data = 0;
2004 tx.function = isicom_tx;
2005 re_schedule = 1;
2006 add_timer(&tx);
2008 return 0;
2009 errtty:
2010 isicom_unregister_tty_driver();
2011 error:
2012 return retval;
2015 static void __exit isicom_exit(void)
2017 unsigned int index = 0;
2019 re_schedule = 0;
2021 while (re_schedule != 2 && index++ < 100)
2022 msleep(10);
2024 pci_unregister_driver(&isicom_driver);
2025 isicom_unregister_tty_driver();
2028 module_init(isicom_setup);
2029 module_exit(isicom_exit);
2031 MODULE_AUTHOR("MultiTech");
2032 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
2033 MODULE_LICENSE("GPL");
2034 module_param_array(io, int, NULL, 0);
2035 MODULE_PARM_DESC(io, "I/O ports for the cards");
2036 module_param_array(irq, int, NULL, 0);
2037 MODULE_PARM_DESC(irq, "Interrupts for the cards");