1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116#include <linux/module.h>
117#include <linux/firmware.h>
118#include <linux/kernel.h>
119#include <linux/tty.h>
120#include <linux/tty_flip.h>
121#include <linux/termios.h>
122#include <linux/fs.h>
123#include <linux/sched.h>
124#include <linux/serial.h>
125#include <linux/smp_lock.h>
126#include <linux/mm.h>
127#include <linux/interrupt.h>
128#include <linux/timer.h>
129#include <linux/delay.h>
130#include <linux/ioport.h>
131
132#include <linux/uaccess.h>
133#include <linux/io.h>
134#include <asm/system.h>
135
136#include <linux/pci.h>
137
138#include <linux/isicom.h>
139
140#define InterruptTheCard(base) outw(0, (base) + 0xc)
141#define ClearInterrupt(base) inw((base) + 0x0a)
142
143#define pr_dbg(str...) pr_debug("ISICOM: " str)
144#ifdef DEBUG
145#define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
146#else
147#define isicom_paranoia_check(a, b, c) 0
148#endif
149
150static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
151static void __devexit isicom_remove(struct pci_dev *);
152
153static struct pci_device_id isicom_pci_tbl[] = {
154 { PCI_DEVICE(VENDOR_ID, 0x2028) },
155 { PCI_DEVICE(VENDOR_ID, 0x2051) },
156 { PCI_DEVICE(VENDOR_ID, 0x2052) },
157 { PCI_DEVICE(VENDOR_ID, 0x2053) },
158 { PCI_DEVICE(VENDOR_ID, 0x2054) },
159 { PCI_DEVICE(VENDOR_ID, 0x2055) },
160 { PCI_DEVICE(VENDOR_ID, 0x2056) },
161 { PCI_DEVICE(VENDOR_ID, 0x2057) },
162 { PCI_DEVICE(VENDOR_ID, 0x2058) },
163 { 0 }
164};
165MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
166
167static struct pci_driver isicom_driver = {
168 .name = "isicom",
169 .id_table = isicom_pci_tbl,
170 .probe = isicom_probe,
171 .remove = __devexit_p(isicom_remove)
172};
173
174static int prev_card = 3;
175static struct tty_driver *isicom_normal;
176
177static void isicom_tx(unsigned long _data);
178static void isicom_start(struct tty_struct *tty);
179
180static DEFINE_TIMER(tx, isicom_tx, 0, 0);
181
182
183
184static signed char linuxb_to_isib[] = {
185 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19, 20, 21
186};
187
188struct isi_board {
189 unsigned long base;
190 int irq;
191 unsigned char port_count;
192 unsigned short status;
193 unsigned short port_status;
194 unsigned short shift_count;
195 struct isi_port *ports;
196 signed char count;
197 spinlock_t card_lock;
198 unsigned long flags;
199 unsigned int index;
200};
201
202struct isi_port {
203 unsigned short magic;
204 struct tty_port port;
205 u16 channel;
206 u16 status;
207 struct isi_board *card;
208 unsigned char *xmit_buf;
209 int xmit_head;
210 int xmit_tail;
211 int xmit_cnt;
212};
213
214static struct isi_board isi_card[BOARD_COUNT];
215static struct isi_port isi_ports[PORT_COUNT];
216
217
218
219
220
221
222
223static inline int WaitTillCardIsFree(unsigned long base)
224{
225 unsigned int count = 0;
226 unsigned int a = in_atomic();
227
228 while (!(inw(base + 0xe) & 0x1) && count++ < 100)
229 if (a)
230 mdelay(1);
231 else
232 msleep(1);
233
234 return !(inw(base + 0xe) & 0x1);
235}
236
237static int lock_card(struct isi_board *card)
238{
239 unsigned long base = card->base;
240 unsigned int retries, a;
241
242 for (retries = 0; retries < 10; retries++) {
243 spin_lock_irqsave(&card->card_lock, card->flags);
244 for (a = 0; a < 10; a++) {
245 if (inw(base + 0xe) & 0x1)
246 return 1;
247 udelay(10);
248 }
249 spin_unlock_irqrestore(&card->card_lock, card->flags);
250 msleep(10);
251 }
252 printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n",
253 card->base);
254
255 return 0;
256}
257
258static void unlock_card(struct isi_board *card)
259{
260 spin_unlock_irqrestore(&card->card_lock, card->flags);
261}
262
263
264
265
266
267
268static void raise_dtr(struct isi_port *port)
269{
270 struct isi_board *card = port->card;
271 unsigned long base = card->base;
272 u16 channel = port->channel;
273
274 if (WaitTillCardIsFree(base))
275 return;
276
277 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
278 outw(0x0504, base);
279 InterruptTheCard(base);
280 port->status |= ISI_DTR;
281}
282
283
284static inline void drop_dtr(struct isi_port *port)
285{
286 struct isi_board *card = port->card;
287 unsigned long base = card->base;
288 u16 channel = port->channel;
289
290 if (WaitTillCardIsFree(base))
291 return;
292
293 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
294 outw(0x0404, base);
295 InterruptTheCard(base);
296 port->status &= ~ISI_DTR;
297}
298
299
300static inline void raise_rts(struct isi_port *port)
301{
302 struct isi_board *card = port->card;
303 unsigned long base = card->base;
304 u16 channel = port->channel;
305
306 if (WaitTillCardIsFree(base))
307 return;
308
309 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
310 outw(0x0a04, base);
311 InterruptTheCard(base);
312 port->status |= ISI_RTS;
313}
314
315
316static inline void drop_rts(struct isi_port *port)
317{
318 struct isi_board *card = port->card;
319 unsigned long base = card->base;
320 u16 channel = port->channel;
321
322 if (WaitTillCardIsFree(base))
323 return;
324
325 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
326 outw(0x0804, base);
327 InterruptTheCard(base);
328 port->status &= ~ISI_RTS;
329}
330
331
332
333static void isicom_dtr_rts(struct tty_port *port, int on)
334{
335 struct isi_port *ip = container_of(port, struct isi_port, port);
336 struct isi_board *card = ip->card;
337 unsigned long base = card->base;
338 u16 channel = ip->channel;
339
340 if (!lock_card(card))
341 return;
342
343 if (on) {
344 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
345 outw(0x0f04, base);
346 InterruptTheCard(base);
347 ip->status |= (ISI_DTR | ISI_RTS);
348 } else {
349 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
350 outw(0x0C04, base);
351 InterruptTheCard(base);
352 ip->status &= ~(ISI_DTR | ISI_RTS);
353 }
354 unlock_card(card);
355}
356
357
358static void drop_dtr_rts(struct isi_port *port)
359{
360 struct isi_board *card = port->card;
361 unsigned long base = card->base;
362 u16 channel = port->channel;
363
364 if (WaitTillCardIsFree(base))
365 return;
366
367 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
368 outw(0x0c04, base);
369 InterruptTheCard(base);
370 port->status &= ~(ISI_RTS | ISI_DTR);
371}
372
373
374
375
376
377
378static inline int __isicom_paranoia_check(struct isi_port const *port,
379 char *name, const char *routine)
380{
381 if (!port) {
382 printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
383 "dev %s in %s.\n", name, routine);
384 return 1;
385 }
386 if (port->magic != ISICOM_MAGIC) {
387 printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
388 "dev %s in %s.\n", name, routine);
389 return 1;
390 }
391
392 return 0;
393}
394
395
396
397
398
399
400
401
402static void isicom_tx(unsigned long _data)
403{
404 unsigned long flags, base;
405 unsigned int retries;
406 short count = (BOARD_COUNT-1), card;
407 short txcount, wrd, residue, word_count, cnt;
408 struct isi_port *port;
409 struct tty_struct *tty;
410
411
412 card = (prev_card + 1) & 0x0003;
413 while (count-- > 0) {
414 if (isi_card[card].status & BOARD_ACTIVE)
415 break;
416 card = (card + 1) & 0x0003;
417 }
418 if (!(isi_card[card].status & BOARD_ACTIVE))
419 goto sched_again;
420
421 prev_card = card;
422
423 count = isi_card[card].port_count;
424 port = isi_card[card].ports;
425 base = isi_card[card].base;
426
427 spin_lock_irqsave(&isi_card[card].card_lock, flags);
428 for (retries = 0; retries < 100; retries++) {
429 if (inw(base + 0xe) & 0x1)
430 break;
431 udelay(2);
432 }
433 if (retries >= 100)
434 goto unlock;
435
436 tty = tty_port_tty_get(&port->port);
437 if (tty == NULL)
438 goto put_unlock;
439
440 for (; count > 0; count--, port++) {
441
442 if (!(port->port.flags & ASYNC_INITIALIZED) ||
443 !(port->status & ISI_TXOK))
444 continue;
445
446 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
447 if (txcount <= 0 || tty->stopped || tty->hw_stopped)
448 continue;
449
450 if (!(inw(base + 0x02) & (1 << port->channel)))
451 continue;
452
453 pr_dbg("txing %d bytes, port%d.\n", txcount,
454 port->channel + 1);
455 outw((port->channel << isi_card[card].shift_count) | txcount,
456 base);
457 residue = NO;
458 wrd = 0;
459 while (1) {
460 cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE
461 - port->xmit_tail));
462 if (residue == YES) {
463 residue = NO;
464 if (cnt > 0) {
465 wrd |= (port->port.xmit_buf[port->xmit_tail]
466 << 8);
467 port->xmit_tail = (port->xmit_tail + 1)
468 & (SERIAL_XMIT_SIZE - 1);
469 port->xmit_cnt--;
470 txcount--;
471 cnt--;
472 outw(wrd, base);
473 } else {
474 outw(wrd, base);
475 break;
476 }
477 }
478 if (cnt <= 0)
479 break;
480 word_count = cnt >> 1;
481 outsw(base, port->port.xmit_buf+port->xmit_tail, word_count);
482 port->xmit_tail = (port->xmit_tail
483 + (word_count << 1)) & (SERIAL_XMIT_SIZE - 1);
484 txcount -= (word_count << 1);
485 port->xmit_cnt -= (word_count << 1);
486 if (cnt & 0x0001) {
487 residue = YES;
488 wrd = port->port.xmit_buf[port->xmit_tail];
489 port->xmit_tail = (port->xmit_tail + 1)
490 & (SERIAL_XMIT_SIZE - 1);
491 port->xmit_cnt--;
492 txcount--;
493 }
494 }
495
496 InterruptTheCard(base);
497 if (port->xmit_cnt <= 0)
498 port->status &= ~ISI_TXOK;
499 if (port->xmit_cnt <= WAKEUP_CHARS)
500 tty_wakeup(tty);
501 }
502
503put_unlock:
504 tty_kref_put(tty);
505unlock:
506 spin_unlock_irqrestore(&isi_card[card].card_lock, flags);
507
508sched_again:
509 mod_timer(&tx, jiffies + msecs_to_jiffies(10));
510}
511
512
513
514
515
516static irqreturn_t isicom_interrupt(int irq, void *dev_id)
517{
518 struct isi_board *card = dev_id;
519 struct isi_port *port;
520 struct tty_struct *tty;
521 unsigned long base;
522 u16 header, word_count, count, channel;
523 short byte_count;
524 unsigned char *rp;
525
526 if (!card || !(card->status & FIRMWARE_LOADED))
527 return IRQ_NONE;
528
529 base = card->base;
530
531
532 if (!(inw(base + 0x0e) & 0x02))
533 return IRQ_NONE;
534
535 spin_lock(&card->card_lock);
536
537
538
539
540
541 outw(0x8000, base+0x04);
542 ClearInterrupt(base);
543
544 inw(base);
545 header = inw(base);
546 channel = (header & 0x7800) >> card->shift_count;
547 byte_count = header & 0xff;
548
549 if (channel + 1 > card->port_count) {
550 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
551 "%d(channel) > port_count.\n", base, channel+1);
552 outw(0x0000, base+0x04);
553 spin_unlock(&card->card_lock);
554 return IRQ_HANDLED;
555 }
556 port = card->ports + channel;
557 if (!(port->port.flags & ASYNC_INITIALIZED)) {
558 outw(0x0000, base+0x04);
559 spin_unlock(&card->card_lock);
560 return IRQ_HANDLED;
561 }
562
563 tty = tty_port_tty_get(&port->port);
564 if (tty == NULL) {
565 word_count = byte_count >> 1;
566 while (byte_count > 1) {
567 inw(base);
568 byte_count -= 2;
569 }
570 if (byte_count & 0x01)
571 inw(base);
572 outw(0x0000, base+0x04);
573 spin_unlock(&card->card_lock);
574 return IRQ_HANDLED;
575 }
576
577 if (header & 0x8000) {
578 header = inw(base);
579 switch (header & 0xff) {
580 case 0:
581 if (port->port.flags & ASYNC_CHECK_CD) {
582 if (port->status & ISI_DCD) {
583 if (!(header & ISI_DCD)) {
584
585 pr_dbg("interrupt: DCD->low.\n"
586 );
587 port->status &= ~ISI_DCD;
588 tty_hangup(tty);
589 }
590 } else if (header & ISI_DCD) {
591
592 pr_dbg("interrupt: DCD->high.\n");
593 port->status |= ISI_DCD;
594 wake_up_interruptible(&port->port.open_wait);
595 }
596 } else {
597 if (header & ISI_DCD)
598 port->status |= ISI_DCD;
599 else
600 port->status &= ~ISI_DCD;
601 }
602
603 if (port->port.flags & ASYNC_CTS_FLOW) {
604 if (tty->hw_stopped) {
605 if (header & ISI_CTS) {
606 port->port.tty->hw_stopped = 0;
607
608 port->status |= (ISI_TXOK
609 | ISI_CTS);
610 tty_wakeup(tty);
611 }
612 } else if (!(header & ISI_CTS)) {
613 tty->hw_stopped = 1;
614
615 port->status &= ~(ISI_TXOK | ISI_CTS);
616 }
617 } else {
618 if (header & ISI_CTS)
619 port->status |= ISI_CTS;
620 else
621 port->status &= ~ISI_CTS;
622 }
623
624 if (header & ISI_DSR)
625 port->status |= ISI_DSR;
626 else
627 port->status &= ~ISI_DSR;
628
629 if (header & ISI_RI)
630 port->status |= ISI_RI;
631 else
632 port->status &= ~ISI_RI;
633
634 break;
635
636 case 1:
637 tty_insert_flip_char(tty, 0, TTY_BREAK);
638 if (port->port.flags & ASYNC_SAK)
639 do_SAK(tty);
640 tty_flip_buffer_push(tty);
641 break;
642
643 case 2:
644 pr_dbg("isicom_interrupt: stats!!!.\n");
645 break;
646
647 default:
648 pr_dbg("Intr: Unknown code in status packet.\n");
649 break;
650 }
651 } else {
652
653 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
654 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
655 word_count = count >> 1;
656 insw(base, rp, word_count);
657 byte_count -= (word_count << 1);
658 if (count & 0x0001) {
659 tty_insert_flip_char(tty, inw(base) & 0xff,
660 TTY_NORMAL);
661 byte_count -= 2;
662 }
663 if (byte_count > 0) {
664 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
665 "bytes...\n", base, channel + 1);
666
667 while (byte_count > 0) {
668 inw(base);
669 byte_count -= 2;
670 }
671 }
672 tty_flip_buffer_push(tty);
673 }
674 outw(0x0000, base+0x04);
675 spin_unlock(&card->card_lock);
676 tty_kref_put(tty);
677
678 return IRQ_HANDLED;
679}
680
681static void isicom_config_port(struct tty_struct *tty)
682{
683 struct isi_port *port = tty->driver_data;
684 struct isi_board *card = port->card;
685 unsigned long baud;
686 unsigned long base = card->base;
687 u16 channel_setup, channel = port->channel,
688 shift_count = card->shift_count;
689 unsigned char flow_ctrl;
690
691
692 baud = C_BAUD(tty);
693 if (baud & CBAUDEX) {
694 baud &= ~CBAUDEX;
695
696
697
698
699
700
701
702 if (baud < 1 || baud > 4)
703 tty->termios->c_cflag &= ~CBAUDEX;
704 else
705 baud += 15;
706 }
707 if (baud == 15) {
708
709
710
711
712
713
714 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
715 baud++;
716 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
717 baud += 2;
718 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
719 baud += 3;
720 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
721 baud += 4;
722 }
723 if (linuxb_to_isib[baud] == -1) {
724
725 drop_dtr(port);
726 return;
727 } else
728 raise_dtr(port);
729
730 if (WaitTillCardIsFree(base) == 0) {
731 outw(0x8000 | (channel << shift_count) | 0x03, base);
732 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
733 channel_setup = 0;
734 switch (C_CSIZE(tty)) {
735 case CS5:
736 channel_setup |= ISICOM_CS5;
737 break;
738 case CS6:
739 channel_setup |= ISICOM_CS6;
740 break;
741 case CS7:
742 channel_setup |= ISICOM_CS7;
743 break;
744 case CS8:
745 channel_setup |= ISICOM_CS8;
746 break;
747 }
748
749 if (C_CSTOPB(tty))
750 channel_setup |= ISICOM_2SB;
751 if (C_PARENB(tty)) {
752 channel_setup |= ISICOM_EVPAR;
753 if (C_PARODD(tty))
754 channel_setup |= ISICOM_ODPAR;
755 }
756 outw(channel_setup, base);
757 InterruptTheCard(base);
758 }
759 if (C_CLOCAL(tty))
760 port->port.flags &= ~ASYNC_CHECK_CD;
761 else
762 port->port.flags |= ASYNC_CHECK_CD;
763
764
765 flow_ctrl = 0;
766 port->port.flags &= ~ASYNC_CTS_FLOW;
767 if (C_CRTSCTS(tty)) {
768 port->port.flags |= ASYNC_CTS_FLOW;
769 flow_ctrl |= ISICOM_CTSRTS;
770 }
771 if (I_IXON(tty))
772 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
773 if (I_IXOFF(tty))
774 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
775
776 if (WaitTillCardIsFree(base) == 0) {
777 outw(0x8000 | (channel << shift_count) | 0x04, base);
778 outw(flow_ctrl << 8 | 0x05, base);
779 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
780 InterruptTheCard(base);
781 }
782
783
784 if (C_CREAD(tty)) {
785 card->port_status |= (1 << channel);
786 outw(card->port_status, base + 0x02);
787 }
788}
789
790
791
792static inline void isicom_setup_board(struct isi_board *bp)
793{
794 int channel;
795 struct isi_port *port;
796 unsigned long flags;
797
798 spin_lock_irqsave(&bp->card_lock, flags);
799 if (bp->status & BOARD_ACTIVE) {
800 spin_unlock_irqrestore(&bp->card_lock, flags);
801 return;
802 }
803 port = bp->ports;
804 bp->status |= BOARD_ACTIVE;
805 for (channel = 0; channel < bp->port_count; channel++, port++)
806 drop_dtr_rts(port);
807 spin_unlock_irqrestore(&bp->card_lock, flags);
808}
809
810static int isicom_setup_port(struct tty_struct *tty)
811{
812 struct isi_port *port = tty->driver_data;
813 struct isi_board *card = port->card;
814 unsigned long flags;
815
816 if (port->port.flags & ASYNC_INITIALIZED)
817 return 0;
818 if (tty_port_alloc_xmit_buf(&port->port) < 0)
819 return -ENOMEM;
820
821 spin_lock_irqsave(&card->card_lock, flags);
822 clear_bit(TTY_IO_ERROR, &tty->flags);
823 if (port->port.count == 1)
824 card->count++;
825
826 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
827
828
829 if (WaitTillCardIsFree(card->base) == 0) {
830 outw(0x8000 | (port->channel << card->shift_count) | 0x02,
831 card->base);
832 outw(((ISICOM_KILLTX | ISICOM_KILLRX) << 8) | 0x06, card->base);
833 InterruptTheCard(card->base);
834 }
835
836 isicom_config_port(tty);
837 port->port.flags |= ASYNC_INITIALIZED;
838 spin_unlock_irqrestore(&card->card_lock, flags);
839
840 return 0;
841}
842
843static int isicom_carrier_raised(struct tty_port *port)
844{
845 struct isi_port *ip = container_of(port, struct isi_port, port);
846 return (ip->status & ISI_DCD)?1 : 0;
847}
848
849static struct tty_port *isicom_find_port(struct tty_struct *tty)
850{
851 struct isi_port *port;
852 struct isi_board *card;
853 unsigned int board;
854 int line = tty->index;
855
856 if (line < 0 || line > PORT_COUNT-1)
857 return NULL;
858 board = BOARD(line);
859 card = &isi_card[board];
860
861 if (!(card->status & FIRMWARE_LOADED))
862 return NULL;
863
864
865 if (line > ((board * 16) + card->port_count - 1))
866 return NULL;
867
868 port = &isi_ports[line];
869 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
870 return NULL;
871
872 return &port->port;
873}
874
875static int isicom_open(struct tty_struct *tty, struct file *filp)
876{
877 struct isi_port *port;
878 struct isi_board *card;
879 struct tty_port *tport;
880 int error = 0;
881
882 tport = isicom_find_port(tty);
883 if (tport == NULL)
884 return -ENODEV;
885 port = container_of(tport, struct isi_port, port);
886 card = &isi_card[BOARD(tty->index)];
887 isicom_setup_board(card);
888
889
890 port->port.count++;
891 tty->driver_data = port;
892 tty_port_tty_set(&port->port, tty);
893
894 if (!test_bit(ASYNCB_INITIALIZED, &tport->flags))
895 error = isicom_setup_port(tty);
896 if (error == 0)
897 error = tty_port_block_til_ready(&port->port, tty, filp);
898 return error;
899}
900
901
902
903static inline void isicom_shutdown_board(struct isi_board *bp)
904{
905 if (bp->status & BOARD_ACTIVE)
906 bp->status &= ~BOARD_ACTIVE;
907}
908
909
910static void isicom_shutdown_port(struct isi_port *port)
911{
912 struct isi_board *card = port->card;
913 struct tty_struct *tty;
914
915 tty = tty_port_tty_get(&port->port);
916
917 if (!(port->port.flags & ASYNC_INITIALIZED)) {
918 tty_kref_put(tty);
919 return;
920 }
921
922 tty_port_free_xmit_buf(&port->port);
923 port->port.flags &= ~ASYNC_INITIALIZED;
924
925 tty_port_tty_set(&port->port, NULL);
926
927
928
929
930
931
932
933 if (C_HUPCL(tty))
934
935 drop_dtr(port);
936
937
938 if (tty)
939 set_bit(TTY_IO_ERROR, &tty->flags);
940
941 if (--card->count < 0) {
942 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
943 card->base, card->count);
944 card->count = 0;
945 }
946
947
948 if (C_HUPCL(tty)) {
949 if (!card->count)
950 isicom_shutdown_board(card);
951 }
952 tty_kref_put(tty);
953}
954
955static void isicom_flush_buffer(struct tty_struct *tty)
956{
957 struct isi_port *port = tty->driver_data;
958 struct isi_board *card = port->card;
959 unsigned long flags;
960
961 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
962 return;
963
964 spin_lock_irqsave(&card->card_lock, flags);
965 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
966 spin_unlock_irqrestore(&card->card_lock, flags);
967
968 tty_wakeup(tty);
969}
970
971static void isicom_close_port(struct tty_port *port)
972{
973 struct isi_port *ip = container_of(port, struct isi_port, port);
974 struct isi_board *card = ip->card;
975 unsigned long flags;
976
977
978
979 spin_lock_irqsave(&card->card_lock, flags);
980 if (port->flags & ASYNC_INITIALIZED) {
981 card->port_status &= ~(1 << ip->channel);
982 outw(card->port_status, card->base + 0x02);
983 }
984 isicom_shutdown_port(ip);
985 spin_unlock_irqrestore(&card->card_lock, flags);
986}
987
988static void isicom_close(struct tty_struct *tty, struct file *filp)
989{
990 struct isi_port *ip = tty->driver_data;
991 struct tty_port *port = &ip->port;
992 if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
993 return;
994
995 if (tty_port_close_start(port, tty, filp) == 0)
996 return;
997 isicom_close_port(port);
998 isicom_flush_buffer(tty);
999 tty_port_close_end(port, tty);
1000}
1001
1002
1003static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1004 int count)
1005{
1006 struct isi_port *port = tty->driver_data;
1007 struct isi_board *card = port->card;
1008 unsigned long flags;
1009 int cnt, total = 0;
1010
1011 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1012 return 0;
1013
1014 spin_lock_irqsave(&card->card_lock, flags);
1015
1016 while (1) {
1017 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
1018 - 1, SERIAL_XMIT_SIZE - port->xmit_head));
1019 if (cnt <= 0)
1020 break;
1021
1022 memcpy(port->port.xmit_buf + port->xmit_head, buf, cnt);
1023 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
1024 - 1);
1025 port->xmit_cnt += cnt;
1026 buf += cnt;
1027 count -= cnt;
1028 total += cnt;
1029 }
1030 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1031 port->status |= ISI_TXOK;
1032 spin_unlock_irqrestore(&card->card_lock, flags);
1033 return total;
1034}
1035
1036
1037static int isicom_put_char(struct tty_struct *tty, unsigned char ch)
1038{
1039 struct isi_port *port = tty->driver_data;
1040 struct isi_board *card = port->card;
1041 unsigned long flags;
1042
1043 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1044 return 0;
1045
1046 spin_lock_irqsave(&card->card_lock, flags);
1047 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1048 spin_unlock_irqrestore(&card->card_lock, flags);
1049 return 0;
1050 }
1051
1052 port->port.xmit_buf[port->xmit_head++] = ch;
1053 port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1054 port->xmit_cnt++;
1055 spin_unlock_irqrestore(&card->card_lock, flags);
1056 return 1;
1057}
1058
1059
1060static void isicom_flush_chars(struct tty_struct *tty)
1061{
1062 struct isi_port *port = tty->driver_data;
1063
1064 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1065 return;
1066
1067 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1068 !port->port.xmit_buf)
1069 return;
1070
1071
1072
1073 port->status |= ISI_TXOK;
1074}
1075
1076
1077static int isicom_write_room(struct tty_struct *tty)
1078{
1079 struct isi_port *port = tty->driver_data;
1080 int free;
1081
1082 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1083 return 0;
1084
1085 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1086 if (free < 0)
1087 free = 0;
1088 return free;
1089}
1090
1091
1092static int isicom_chars_in_buffer(struct tty_struct *tty)
1093{
1094 struct isi_port *port = tty->driver_data;
1095 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1096 return 0;
1097 return port->xmit_cnt;
1098}
1099
1100
1101static int isicom_send_break(struct tty_struct *tty, int length)
1102{
1103 struct isi_port *port = tty->driver_data;
1104 struct isi_board *card = port->card;
1105 unsigned long base = card->base;
1106
1107 if (length == -1)
1108 return -EOPNOTSUPP;
1109
1110 if (!lock_card(card))
1111 return -EINVAL;
1112
1113 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1114 outw((length & 0xff) << 8 | 0x00, base);
1115 outw((length & 0xff00), base);
1116 InterruptTheCard(base);
1117
1118 unlock_card(card);
1119 return 0;
1120}
1121
1122static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1123{
1124 struct isi_port *port = tty->driver_data;
1125
1126 u16 status = port->status;
1127
1128 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1129 return -ENODEV;
1130
1131 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1132 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1133 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1134 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1135 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1136 ((status & ISI_RI ) ? TIOCM_RI : 0);
1137}
1138
1139static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1140 unsigned int set, unsigned int clear)
1141{
1142 struct isi_port *port = tty->driver_data;
1143 unsigned long flags;
1144
1145 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1146 return -ENODEV;
1147
1148 spin_lock_irqsave(&port->card->card_lock, flags);
1149 if (set & TIOCM_RTS)
1150 raise_rts(port);
1151 if (set & TIOCM_DTR)
1152 raise_dtr(port);
1153
1154 if (clear & TIOCM_RTS)
1155 drop_rts(port);
1156 if (clear & TIOCM_DTR)
1157 drop_dtr(port);
1158 spin_unlock_irqrestore(&port->card->card_lock, flags);
1159
1160 return 0;
1161}
1162
1163static int isicom_set_serial_info(struct tty_struct *tty,
1164 struct serial_struct __user *info)
1165{
1166 struct isi_port *port = tty->driver_data;
1167 struct serial_struct newinfo;
1168 int reconfig_port;
1169
1170 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1171 return -EFAULT;
1172
1173 lock_kernel();
1174
1175 reconfig_port = ((port->port.flags & ASYNC_SPD_MASK) !=
1176 (newinfo.flags & ASYNC_SPD_MASK));
1177
1178 if (!capable(CAP_SYS_ADMIN)) {
1179 if ((newinfo.close_delay != port->port.close_delay) ||
1180 (newinfo.closing_wait != port->port.closing_wait) ||
1181 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1182 (port->port.flags & ~ASYNC_USR_MASK))) {
1183 unlock_kernel();
1184 return -EPERM;
1185 }
1186 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1187 (newinfo.flags & ASYNC_USR_MASK));
1188 } else {
1189 port->port.close_delay = newinfo.close_delay;
1190 port->port.closing_wait = newinfo.closing_wait;
1191 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1192 (newinfo.flags & ASYNC_FLAGS));
1193 }
1194 if (reconfig_port) {
1195 unsigned long flags;
1196 spin_lock_irqsave(&port->card->card_lock, flags);
1197 isicom_config_port(tty);
1198 spin_unlock_irqrestore(&port->card->card_lock, flags);
1199 }
1200 unlock_kernel();
1201 return 0;
1202}
1203
1204static int isicom_get_serial_info(struct isi_port *port,
1205 struct serial_struct __user *info)
1206{
1207 struct serial_struct out_info;
1208
1209 lock_kernel();
1210 memset(&out_info, 0, sizeof(out_info));
1211
1212 out_info.line = port - isi_ports;
1213 out_info.port = port->card->base;
1214 out_info.irq = port->card->irq;
1215 out_info.flags = port->port.flags;
1216
1217 out_info.close_delay = port->port.close_delay;
1218 out_info.closing_wait = port->port.closing_wait;
1219 unlock_kernel();
1220 if (copy_to_user(info, &out_info, sizeof(out_info)))
1221 return -EFAULT;
1222 return 0;
1223}
1224
1225static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1226 unsigned int cmd, unsigned long arg)
1227{
1228 struct isi_port *port = tty->driver_data;
1229 void __user *argp = (void __user *)arg;
1230
1231 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1232 return -ENODEV;
1233
1234 switch (cmd) {
1235 case TIOCGSERIAL:
1236 return isicom_get_serial_info(port, argp);
1237
1238 case TIOCSSERIAL:
1239 return isicom_set_serial_info(tty, argp);
1240
1241 default:
1242 return -ENOIOCTLCMD;
1243 }
1244 return 0;
1245}
1246
1247
1248static void isicom_set_termios(struct tty_struct *tty,
1249 struct ktermios *old_termios)
1250{
1251 struct isi_port *port = tty->driver_data;
1252 unsigned long flags;
1253
1254 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1255 return;
1256
1257 if (tty->termios->c_cflag == old_termios->c_cflag &&
1258 tty->termios->c_iflag == old_termios->c_iflag)
1259 return;
1260
1261 spin_lock_irqsave(&port->card->card_lock, flags);
1262 isicom_config_port(tty);
1263 spin_unlock_irqrestore(&port->card->card_lock, flags);
1264
1265 if ((old_termios->c_cflag & CRTSCTS) &&
1266 !(tty->termios->c_cflag & CRTSCTS)) {
1267 tty->hw_stopped = 0;
1268 isicom_start(tty);
1269 }
1270}
1271
1272
1273static void isicom_throttle(struct tty_struct *tty)
1274{
1275 struct isi_port *port = tty->driver_data;
1276 struct isi_board *card = port->card;
1277
1278 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1279 return;
1280
1281
1282 card->port_status &= ~(1 << port->channel);
1283 outw(card->port_status, card->base + 0x02);
1284}
1285
1286
1287static void isicom_unthrottle(struct tty_struct *tty)
1288{
1289 struct isi_port *port = tty->driver_data;
1290 struct isi_board *card = port->card;
1291
1292 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1293 return;
1294
1295
1296 card->port_status |= (1 << port->channel);
1297 outw(card->port_status, card->base + 0x02);
1298}
1299
1300
1301static void isicom_stop(struct tty_struct *tty)
1302{
1303 struct isi_port *port = tty->driver_data;
1304
1305 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1306 return;
1307
1308
1309
1310 port->status &= ~ISI_TXOK;
1311}
1312
1313
1314static void isicom_start(struct tty_struct *tty)
1315{
1316 struct isi_port *port = tty->driver_data;
1317
1318 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1319 return;
1320
1321
1322
1323 port->status |= ISI_TXOK;
1324}
1325
1326static void isicom_hangup(struct tty_struct *tty)
1327{
1328 struct isi_port *port = tty->driver_data;
1329 unsigned long flags;
1330
1331 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1332 return;
1333
1334 spin_lock_irqsave(&port->card->card_lock, flags);
1335 isicom_shutdown_port(port);
1336 spin_unlock_irqrestore(&port->card->card_lock, flags);
1337
1338 tty_port_hangup(&port->port);
1339}
1340
1341
1342
1343
1344
1345
1346static const struct tty_operations isicom_ops = {
1347 .open = isicom_open,
1348 .close = isicom_close,
1349 .write = isicom_write,
1350 .put_char = isicom_put_char,
1351 .flush_chars = isicom_flush_chars,
1352 .write_room = isicom_write_room,
1353 .chars_in_buffer = isicom_chars_in_buffer,
1354 .ioctl = isicom_ioctl,
1355 .set_termios = isicom_set_termios,
1356 .throttle = isicom_throttle,
1357 .unthrottle = isicom_unthrottle,
1358 .stop = isicom_stop,
1359 .start = isicom_start,
1360 .hangup = isicom_hangup,
1361 .flush_buffer = isicom_flush_buffer,
1362 .tiocmget = isicom_tiocmget,
1363 .tiocmset = isicom_tiocmset,
1364 .break_ctl = isicom_send_break,
1365};
1366
1367static const struct tty_port_operations isicom_port_ops = {
1368 .carrier_raised = isicom_carrier_raised,
1369 .dtr_rts = isicom_dtr_rts,
1370};
1371
1372static int __devinit reset_card(struct pci_dev *pdev,
1373 const unsigned int card, unsigned int *signature)
1374{
1375 struct isi_board *board = pci_get_drvdata(pdev);
1376 unsigned long base = board->base;
1377 unsigned int sig, portcount = 0;
1378 int retval = 0;
1379
1380 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1381 base);
1382
1383 inw(base + 0x8);
1384
1385 msleep(10);
1386
1387 outw(0, base + 0x8);
1388
1389 msleep(1000);
1390
1391 sig = inw(base + 0x4) & 0xff;
1392
1393 if (sig != 0xa5 && sig != 0xbb && sig != 0xcc && sig != 0xdd &&
1394 sig != 0xee) {
1395 dev_warn(&pdev->dev, "ISILoad:Card%u reset failure (Possible "
1396 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1397 dev_dbg(&pdev->dev, "Sig=0x%x\n", sig);
1398 retval = -EIO;
1399 goto end;
1400 }
1401
1402 msleep(10);
1403
1404 portcount = inw(base + 0x2);
1405 if (!(inw(base + 0xe) & 0x1) || (portcount != 0 && portcount != 4 &&
1406 portcount != 8 && portcount != 16)) {
1407 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure.\n",
1408 card + 1);
1409 retval = -EIO;
1410 goto end;
1411 }
1412
1413 switch (sig) {
1414 case 0xa5:
1415 case 0xbb:
1416 case 0xdd:
1417 board->port_count = (portcount == 4) ? 4 : 8;
1418 board->shift_count = 12;
1419 break;
1420 case 0xcc:
1421 case 0xee:
1422 board->port_count = 16;
1423 board->shift_count = 11;
1424 break;
1425 }
1426 dev_info(&pdev->dev, "-Done\n");
1427 *signature = sig;
1428
1429end:
1430 return retval;
1431}
1432
1433static int __devinit load_firmware(struct pci_dev *pdev,
1434 const unsigned int index, const unsigned int signature)
1435{
1436 struct isi_board *board = pci_get_drvdata(pdev);
1437 const struct firmware *fw;
1438 unsigned long base = board->base;
1439 unsigned int a;
1440 u16 word_count, status;
1441 int retval = -EIO;
1442 char *name;
1443 u8 *data;
1444
1445 struct stframe {
1446 u16 addr;
1447 u16 count;
1448 u8 data[0];
1449 } *frame;
1450
1451 switch (signature) {
1452 case 0xa5:
1453 name = "isi608.bin";
1454 break;
1455 case 0xbb:
1456 name = "isi608em.bin";
1457 break;
1458 case 0xcc:
1459 name = "isi616em.bin";
1460 break;
1461 case 0xdd:
1462 name = "isi4608.bin";
1463 break;
1464 case 0xee:
1465 name = "isi4616.bin";
1466 break;
1467 default:
1468 dev_err(&pdev->dev, "Unknown signature.\n");
1469 goto end;
1470 }
1471
1472 retval = request_firmware(&fw, name, &pdev->dev);
1473 if (retval)
1474 goto end;
1475
1476 retval = -EIO;
1477
1478 for (frame = (struct stframe *)fw->data;
1479 frame < (struct stframe *)(fw->data + fw->size);
1480 frame = (struct stframe *)((u8 *)(frame + 1) +
1481 frame->count)) {
1482 if (WaitTillCardIsFree(base))
1483 goto errrelfw;
1484
1485 outw(0xf0, base);
1486 outw(0x00, base);
1487 outw(frame->addr, base);
1488
1489 word_count = frame->count / 2 + frame->count % 2;
1490 outw(word_count, base);
1491 InterruptTheCard(base);
1492
1493 udelay(100);
1494
1495 if (WaitTillCardIsFree(base))
1496 goto errrelfw;
1497
1498 status = inw(base + 0x4);
1499 if (status != 0) {
1500 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1501 "Address:0x%x\n"
1502 "Count:0x%x\n"
1503 "Status:0x%x\n",
1504 index + 1, frame->addr, frame->count, status);
1505 goto errrelfw;
1506 }
1507 outsw(base, frame->data, word_count);
1508
1509 InterruptTheCard(base);
1510
1511 udelay(50);
1512
1513 if (WaitTillCardIsFree(base))
1514 goto errrelfw;
1515
1516 status = inw(base + 0x4);
1517 if (status != 0) {
1518 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1519 "Status:0x%x\n", index + 1, status);
1520 goto errrelfw;
1521 }
1522 }
1523
1524
1525
1526 for (frame = (struct stframe *)fw->data;
1527 frame < (struct stframe *)(fw->data + fw->size);
1528 frame = (struct stframe *)((u8 *)(frame + 1) +
1529 frame->count)) {
1530 if (WaitTillCardIsFree(base))
1531 goto errrelfw;
1532
1533 outw(0xf1, base);
1534 outw(0x00, base);
1535 outw(frame->addr, base);
1536
1537 word_count = (frame->count >> 1) + frame->count % 2;
1538 outw(word_count + 1, base);
1539 InterruptTheCard(base);
1540
1541 udelay(50);
1542
1543 if (WaitTillCardIsFree(base))
1544 goto errrelfw;
1545
1546 status = inw(base + 0x4);
1547 if (status != 0) {
1548 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1549 "Address:0x%x\n"
1550 "Count:0x%x\n"
1551 "Status: 0x%x\n",
1552 index + 1, frame->addr, frame->count, status);
1553 goto errrelfw;
1554 }
1555
1556 data = kmalloc(word_count * 2, GFP_KERNEL);
1557 if (data == NULL) {
1558 dev_err(&pdev->dev, "Card%d, firmware upload "
1559 "failed, not enough memory\n", index + 1);
1560 goto errrelfw;
1561 }
1562 inw(base);
1563 insw(base, data, word_count);
1564 InterruptTheCard(base);
1565
1566 for (a = 0; a < frame->count; a++)
1567 if (data[a] != frame->data[a]) {
1568 kfree(data);
1569 dev_err(&pdev->dev, "Card%d, firmware upload "
1570 "failed\n", index + 1);
1571 goto errrelfw;
1572 }
1573 kfree(data);
1574
1575 udelay(50);
1576
1577 if (WaitTillCardIsFree(base))
1578 goto errrelfw;
1579
1580 status = inw(base + 0x4);
1581 if (status != 0) {
1582 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1583 "Card Status:0x%x\n", index + 1, status);
1584 goto errrelfw;
1585 }
1586 }
1587
1588
1589 if (WaitTillCardIsFree(base))
1590 goto errrelfw;
1591
1592 outw(0xf2, base);
1593 outw(0x800, base);
1594 outw(0x0, base);
1595 outw(0x0, base);
1596 InterruptTheCard(base);
1597 outw(0x0, base + 0x4);
1598
1599 board->status |= FIRMWARE_LOADED;
1600 retval = 0;
1601
1602errrelfw:
1603 release_firmware(fw);
1604end:
1605 return retval;
1606}
1607
1608
1609
1610
1611static unsigned int card_count;
1612
1613static int __devinit isicom_probe(struct pci_dev *pdev,
1614 const struct pci_device_id *ent)
1615{
1616 unsigned int uninitialized_var(signature), index;
1617 int retval = -EPERM;
1618 struct isi_board *board = NULL;
1619
1620 if (card_count >= BOARD_COUNT)
1621 goto err;
1622
1623 retval = pci_enable_device(pdev);
1624 if (retval) {
1625 dev_err(&pdev->dev, "failed to enable\n");
1626 goto err;
1627 }
1628
1629 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1630
1631
1632 for (index = 0; index < BOARD_COUNT; index++)
1633 if (isi_card[index].base == 0) {
1634 board = &isi_card[index];
1635 break;
1636 }
1637
1638 board->index = index;
1639 board->base = pci_resource_start(pdev, 3);
1640 board->irq = pdev->irq;
1641 card_count++;
1642
1643 pci_set_drvdata(pdev, board);
1644
1645 retval = pci_request_region(pdev, 3, ISICOM_NAME);
1646 if (retval) {
1647 dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1648 "will be disabled.\n", board->base, board->base + 15,
1649 index + 1);
1650 retval = -EBUSY;
1651 goto errdec;
1652 }
1653
1654 retval = request_irq(board->irq, isicom_interrupt,
1655 IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
1656 if (retval < 0) {
1657 dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1658 "Card%d will be disabled.\n", board->irq, index + 1);
1659 goto errunrr;
1660 }
1661
1662 retval = reset_card(pdev, index, &signature);
1663 if (retval < 0)
1664 goto errunri;
1665
1666 retval = load_firmware(pdev, index, signature);
1667 if (retval < 0)
1668 goto errunri;
1669
1670 for (index = 0; index < board->port_count; index++)
1671 tty_register_device(isicom_normal, board->index * 16 + index,
1672 &pdev->dev);
1673
1674 return 0;
1675
1676errunri:
1677 free_irq(board->irq, board);
1678errunrr:
1679 pci_release_region(pdev, 3);
1680errdec:
1681 board->base = 0;
1682 card_count--;
1683 pci_disable_device(pdev);
1684err:
1685 return retval;
1686}
1687
1688static void __devexit isicom_remove(struct pci_dev *pdev)
1689{
1690 struct isi_board *board = pci_get_drvdata(pdev);
1691 unsigned int i;
1692
1693 for (i = 0; i < board->port_count; i++)
1694 tty_unregister_device(isicom_normal, board->index * 16 + i);
1695
1696 free_irq(board->irq, board);
1697 pci_release_region(pdev, 3);
1698 board->base = 0;
1699 card_count--;
1700 pci_disable_device(pdev);
1701}
1702
1703static int __init isicom_init(void)
1704{
1705 int retval, idx, channel;
1706 struct isi_port *port;
1707
1708 for (idx = 0; idx < BOARD_COUNT; idx++) {
1709 port = &isi_ports[idx * 16];
1710 isi_card[idx].ports = port;
1711 spin_lock_init(&isi_card[idx].card_lock);
1712 for (channel = 0; channel < 16; channel++, port++) {
1713 tty_port_init(&port->port);
1714 port->port.ops = &isicom_port_ops;
1715 port->magic = ISICOM_MAGIC;
1716 port->card = &isi_card[idx];
1717 port->channel = channel;
1718 port->port.close_delay = 50 * HZ/100;
1719 port->port.closing_wait = 3000 * HZ/100;
1720 port->status = 0;
1721
1722 }
1723 isi_card[idx].base = 0;
1724 isi_card[idx].irq = 0;
1725 }
1726
1727
1728 isicom_normal = alloc_tty_driver(PORT_COUNT);
1729 if (!isicom_normal) {
1730 retval = -ENOMEM;
1731 goto error;
1732 }
1733
1734 isicom_normal->owner = THIS_MODULE;
1735 isicom_normal->name = "ttyM";
1736 isicom_normal->major = ISICOM_NMAJOR;
1737 isicom_normal->minor_start = 0;
1738 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1739 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1740 isicom_normal->init_termios = tty_std_termios;
1741 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1742 CLOCAL;
1743 isicom_normal->flags = TTY_DRIVER_REAL_RAW |
1744 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK;
1745 tty_set_operations(isicom_normal, &isicom_ops);
1746
1747 retval = tty_register_driver(isicom_normal);
1748 if (retval) {
1749 pr_dbg("Couldn't register the dialin driver\n");
1750 goto err_puttty;
1751 }
1752
1753 retval = pci_register_driver(&isicom_driver);
1754 if (retval < 0) {
1755 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1756 goto err_unrtty;
1757 }
1758
1759 mod_timer(&tx, jiffies + 1);
1760
1761 return 0;
1762err_unrtty:
1763 tty_unregister_driver(isicom_normal);
1764err_puttty:
1765 put_tty_driver(isicom_normal);
1766error:
1767 return retval;
1768}
1769
1770static void __exit isicom_exit(void)
1771{
1772 del_timer_sync(&tx);
1773
1774 pci_unregister_driver(&isicom_driver);
1775 tty_unregister_driver(isicom_normal);
1776 put_tty_driver(isicom_normal);
1777}
1778
1779module_init(isicom_init);
1780module_exit(isicom_exit);
1781
1782MODULE_AUTHOR("MultiTech");
1783MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1784MODULE_LICENSE("GPL");
1785