projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] char/isicom: Firmware loading
[deliverable/linux.git] / drivers / char / isicom.c
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 */
113
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>
128
129 #include <asm/uaccess.h>
130 #include <asm/io.h>
131 #include <asm/system.h>
132
133 #include <linux/pci.h>
134
135 #include <linux/isicom.h>
136
137 #define InterruptTheCard(base) outw(0, (base) + 0xc)
138 #define ClearInterrupt(base) inw((base) + 0x0a)
139
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
147
148 static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
149 static void __devexit isicom_remove(struct pci_dev *);
150
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);
164
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 };
171
172 static int prev_card = 3; /* start servicing isi_card[0] */
173 static struct tty_driver *isicom_normal;
174
175 static struct timer_list tx;
176 static char re_schedule = 1;
177
178 static void isicom_tx(unsigned long _data);
179 static void isicom_start(struct tty_struct *tty);
180
181 /* baud index mappings from linux defns to isi */
182
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 };
186
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 represents a single 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 };
200
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 };
221
222 static struct isi_board isi_card[BOARD_COUNT];
223 static struct isi_port isi_ports[PORT_COUNT];
224
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 */
230
231 static int lock_card(struct isi_board *card)
232 {
233 char retries;
234 unsigned long base = card->base;
235
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", card->base);
246 return 0; /* Failed to aquire the card! */
247 }
248
249 static int lock_card_at_interrupt(struct isi_board *card)
250 {
251 unsigned char retries;
252 unsigned long base = card->base;
253
254 for (retries = 0; retries < 200; retries++) {
255 spin_lock_irqsave(&card->card_lock, card->flags);
256
257 if (inw(base + 0xe) & 0x1)
258 return 1;
259 else
260 spin_unlock_irqrestore(&card->card_lock, card->flags);
261 }
262 /* Failing in interrupt is an acceptable event */
263 return 0; /* Failed to aquire the card! */
264 }
265
266 static void unlock_card(struct isi_board *card)
267 {
268 spin_unlock_irqrestore(&card->card_lock, card->flags);
269 }
270
271 /*
272 * ISI Card specific ops ...
273 */
274
275 static void raise_dtr(struct isi_port *port)
276 {
277 struct isi_board *card = port->card;
278 unsigned long base = card->base;
279 u16 channel = port->channel;
280
281 if (!lock_card(card))
282 return;
283
284 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
285 outw(0x0504, base);
286 InterruptTheCard(base);
287 port->status |= ISI_DTR;
288 unlock_card(card);
289 }
290
291 static inline void drop_dtr(struct isi_port *port)
292 {
293 struct isi_board *card = port->card;
294 unsigned long base = card->base;
295 u16 channel = port->channel;
296
297 if (!lock_card(card))
298 return;
299
300 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
301 outw(0x0404, base);
302 InterruptTheCard(base);
303 port->status &= ~ISI_DTR;
304 unlock_card(card);
305 }
306
307 static inline void raise_rts(struct isi_port *port)
308 {
309 struct isi_board *card = port->card;
310 unsigned long base = card->base;
311 u16 channel = port->channel;
312
313 if (!lock_card(card))
314 return;
315
316 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
317 outw(0x0a04, base);
318 InterruptTheCard(base);
319 port->status |= ISI_RTS;
320 unlock_card(card);
321 }
322 static inline void drop_rts(struct isi_port *port)
323 {
324 struct isi_board *card = port->card;
325 unsigned long base = card->base;
326 u16 channel = port->channel;
327
328 if (!lock_card(card))
329 return;
330
331 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
332 outw(0x0804, base);
333 InterruptTheCard(base);
334 port->status &= ~ISI_RTS;
335 unlock_card(card);
336 }
337
338 static inline void raise_dtr_rts(struct isi_port *port)
339 {
340 struct isi_board *card = port->card;
341 unsigned long base = card->base;
342 u16 channel = port->channel;
343
344 if (!lock_card(card))
345 return;
346
347 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
348 outw(0x0f04, base);
349 InterruptTheCard(base);
350 port->status |= (ISI_DTR | ISI_RTS);
351 unlock_card(card);
352 }
353
354 static void drop_dtr_rts(struct isi_port *port)
355 {
356 struct isi_board *card = port->card;
357 unsigned long base = card->base;
358 u16 channel = port->channel;
359
360 if (!lock_card(card))
361 return;
362
363 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
364 outw(0x0c04, base);
365 InterruptTheCard(base);
366 port->status &= ~(ISI_RTS | ISI_DTR);
367 unlock_card(card);
368 }
369
370 static inline void kill_queue(struct isi_port *port, short queue)
371 {
372 struct isi_board *card = port->card;
373 unsigned long base = card->base;
374 u16 channel = port->channel;
375
376 if (!lock_card(card))
377 return;
378
379 outw(0x8000 | (channel << card->shift_count) | 0x02, base);
380 outw((queue << 8) | 0x06, base);
381 InterruptTheCard(base);
382 unlock_card(card);
383 }
384
385 /*
386 * ISICOM Driver specific routines ...
387 *
388 */
389
390 static inline int __isicom_paranoia_check(struct isi_port const *port,
391 char *name, const char *routine)
392 {
393 if (!port) {
394 printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
395 "dev %s in %s.\n", name, routine);
396 return 1;
397 }
398 if (port->magic != ISICOM_MAGIC) {
399 printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
400 "dev %s in %s.\n", name, routine);
401 return 1;
402 }
403
404 return 0;
405 }
406
407 /*
408 * Transmitter.
409 *
410 * We shovel data into the card buffers on a regular basis. The card
411 * will do the rest of the work for us.
412 */
413
414 static void isicom_tx(unsigned long _data)
415 {
416 short count = (BOARD_COUNT-1), card, base;
417 short txcount, wrd, residue, word_count, cnt;
418 struct isi_port *port;
419 struct tty_struct *tty;
420
421 /* find next active board */
422 card = (prev_card + 1) & 0x0003;
423 while(count-- > 0) {
424 if (isi_card[card].status & BOARD_ACTIVE)
425 break;
426 card = (card + 1) & 0x0003;
427 }
428 if (!(isi_card[card].status & BOARD_ACTIVE))
429 goto sched_again;
430
431 prev_card = card;
432
433 count = isi_card[card].port_count;
434 port = isi_card[card].ports;
435 base = isi_card[card].base;
436 for (;count > 0;count--, port++) {
437 if (!lock_card_at_interrupt(&isi_card[card]))
438 continue;
439 /* port not active or tx disabled to force flow control */
440 if (!(port->flags & ASYNC_INITIALIZED) ||
441 !(port->status & ISI_TXOK))
442 unlock_card(&isi_card[card]);
443 continue;
444
445 tty = port->tty;
446
447
448 if (tty == NULL) {
449 unlock_card(&isi_card[card]);
450 continue;
451 }
452
453 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
454 if (txcount <= 0 || tty->stopped || tty->hw_stopped) {
455 unlock_card(&isi_card[card]);
456 continue;
457 }
458 if (!(inw(base + 0x02) & (1 << port->channel))) {
459 unlock_card(&isi_card[card]);
460 continue;
461 }
462 pr_dbg("txing %d bytes, port%d.\n", txcount,
463 port->channel + 1);
464 outw((port->channel << isi_card[card].shift_count) | txcount,
465 base);
466 residue = NO;
467 wrd = 0;
468 while (1) {
469 cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE - port->xmit_tail));
470 if (residue == YES) {
471 residue = NO;
472 if (cnt > 0) {
473 wrd |= (port->xmit_buf[port->xmit_tail] << 8);
474 port->xmit_tail = (port->xmit_tail + 1) & (SERIAL_XMIT_SIZE - 1);
475 port->xmit_cnt--;
476 txcount--;
477 cnt--;
478 outw(wrd, base);
479 }
480 else {
481 outw(wrd, base);
482 break;
483 }
484 }
485 if (cnt <= 0) break;
486 word_count = cnt >> 1;
487 outsw(base, port->xmit_buf+port->xmit_tail, word_count);
488 port->xmit_tail = (port->xmit_tail + (word_count << 1)) &
489 (SERIAL_XMIT_SIZE - 1);
490 txcount -= (word_count << 1);
491 port->xmit_cnt -= (word_count << 1);
492 if (cnt & 0x0001) {
493 residue = YES;
494 wrd = port->xmit_buf[port->xmit_tail];
495 port->xmit_tail = (port->xmit_tail + 1) & (SERIAL_XMIT_SIZE - 1);
496 port->xmit_cnt--;
497 txcount--;
498 }
499 }
500
501 InterruptTheCard(base);
502 if (port->xmit_cnt <= 0)
503 port->status &= ~ISI_TXOK;
504 if (port->xmit_cnt <= WAKEUP_CHARS)
505 schedule_work(&port->bh_tqueue);
506 unlock_card(&isi_card[card]);
507 }
508
509 /* schedule another tx for hopefully in about 10ms */
510 sched_again:
511 if (!re_schedule) {
512 re_schedule = 2;
513 return;
514 }
515
516 init_timer(&tx);
517 tx.expires = jiffies + HZ/100;
518 tx.data = 0;
519 tx.function = isicom_tx;
520 add_timer(&tx);
521
522 return;
523 }
524
525 /* Interrupt handlers */
526
527
528 static void isicom_bottomhalf(void *data)
529 {
530 struct isi_port *port = (struct isi_port *) data;
531 struct tty_struct *tty = port->tty;
532
533 if (!tty)
534 return;
535
536 tty_wakeup(tty);
537 wake_up_interruptible(&tty->write_wait);
538 }
539
540 /*
541 * Main interrupt handler routine
542 */
543
544 static irqreturn_t isicom_interrupt(int irq, void *dev_id, struct pt_regs *regs)
545 {
546 struct isi_board *card = dev_id;
547 struct isi_port *port;
548 struct tty_struct *tty;
549 unsigned long base;
550 u16 header, word_count, count, channel;
551 short byte_count;
552 unsigned char *rp;
553
554 if (!card || !(card->status & FIRMWARE_LOADED))
555 return IRQ_NONE;
556
557 base = card->base;
558 spin_lock(&card->card_lock);
559
560 if (card->isa == NO) {
561 /*
562 * disable any interrupts from the PCI card and lower the
563 * interrupt line
564 */
565 outw(0x8000, base+0x04);
566 ClearInterrupt(base);
567 }
568
569 inw(base); /* get the dummy word out */
570 header = inw(base);
571 channel = (header & 0x7800) >> card->shift_count;
572 byte_count = header & 0xff;
573
574 if (channel + 1 > card->port_count) {
575 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): %d(channel) > port_count.\n",
576 base, channel+1);
577 if (card->isa)
578 ClearInterrupt(base);
579 else
580 outw(0x0000, base+0x04); /* enable interrupts */
581 spin_unlock(&card->card_lock);
582 return IRQ_HANDLED;
583 }
584 port = card->ports + channel;
585 if (!(port->flags & ASYNC_INITIALIZED)) {
586 if (card->isa)
587 ClearInterrupt(base);
588 else
589 outw(0x0000, base+0x04); /* enable interrupts */
590 return IRQ_HANDLED;
591 }
592
593 tty = port->tty;
594 if (tty == NULL) {
595 word_count = byte_count >> 1;
596 while(byte_count > 1) {
597 inw(base);
598 byte_count -= 2;
599 }
600 if (byte_count & 0x01)
601 inw(base);
602 if (card->isa == YES)
603 ClearInterrupt(base);
604 else
605 outw(0x0000, base+0x04); /* enable interrupts */
606 spin_unlock(&card->card_lock);
607 return IRQ_HANDLED;
608 }
609
610 if (header & 0x8000) { /* Status Packet */
611 header = inw(base);
612 switch(header & 0xff) {
613 case 0: /* Change in EIA signals */
614
615 if (port->flags & ASYNC_CHECK_CD) {
616 if (port->status & ISI_DCD) {
617 if (!(header & ISI_DCD)) {
618 /* Carrier has been lost */
619 pr_dbg("interrupt: DCD->low.\n");
620 port->status &= ~ISI_DCD;
621 schedule_work(&port->hangup_tq);
622 }
623 }
624 else {
625 if (header & ISI_DCD) {
626 /* Carrier has been detected */
627 pr_dbg("interrupt: DCD->high.\n");
628 port->status |= ISI_DCD;
629 wake_up_interruptible(&port->open_wait);
630 }
631 }
632 }
633 else {
634 if (header & ISI_DCD)
635 port->status |= ISI_DCD;
636 else
637 port->status &= ~ISI_DCD;
638 }
639
640 if (port->flags & ASYNC_CTS_FLOW) {
641 if (port->tty->hw_stopped) {
642 if (header & ISI_CTS) {
643 port->tty->hw_stopped = 0;
644 /* start tx ing */
645 port->status |= (ISI_TXOK | ISI_CTS);
646 schedule_work(&port->bh_tqueue);
647 }
648 }
649 else {
650 if (!(header & ISI_CTS)) {
651 port->tty->hw_stopped = 1;
652 /* stop tx ing */
653 port->status &= ~(ISI_TXOK | ISI_CTS);
654 }
655 }
656 }
657 else {
658 if (header & ISI_CTS)
659 port->status |= ISI_CTS;
660 else
661 port->status &= ~ISI_CTS;
662 }
663
664 if (header & ISI_DSR)
665 port->status |= ISI_DSR;
666 else
667 port->status &= ~ISI_DSR;
668
669 if (header & ISI_RI)
670 port->status |= ISI_RI;
671 else
672 port->status &= ~ISI_RI;
673
674 break;
675
676 case 1: /* Received Break !!! */
677 tty_insert_flip_char(tty, 0, TTY_BREAK);
678 if (port->flags & ASYNC_SAK)
679 do_SAK(tty);
680 tty_flip_buffer_push(tty);
681 break;
682
683 case 2: /* Statistics */
684 pr_dbg("isicom_interrupt: stats!!!.\n");
685 break;
686
687 default:
688 pr_dbg("Intr: Unknown code in status packet.\n");
689 break;
690 }
691 }
692 else { /* Data Packet */
693
694 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
695 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
696 word_count = count >> 1;
697 insw(base, rp, word_count);
698 byte_count -= (word_count << 1);
699 if (count & 0x0001) {
700 tty_insert_flip_char(tty, inw(base) & 0xff, TTY_NORMAL);
701 byte_count -= 2;
702 }
703 if (byte_count > 0) {
704 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
705 "bytes...\n", base, channel + 1);
706 while(byte_count > 0) { /* drain out unread xtra data */
707 inw(base);
708 byte_count -= 2;
709 }
710 }
711 tty_flip_buffer_push(tty);
712 }
713 if (card->isa == YES)
714 ClearInterrupt(base);
715 else
716 outw(0x0000, base+0x04); /* enable interrupts */
717 return IRQ_HANDLED;
718 }
719
720 static void isicom_config_port(struct isi_port *port)
721 {
722 struct isi_board *card = port->card;
723 struct tty_struct *tty;
724 unsigned long baud;
725 unsigned long base = card->base;
726 u16 channel_setup, channel = port->channel,
727 shift_count = card->shift_count;
728 unsigned char flow_ctrl;
729
730 if (!(tty = port->tty) || !tty->termios)
731 return;
732 baud = C_BAUD(tty);
733 if (baud & CBAUDEX) {
734 baud &= ~CBAUDEX;
735
736 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
737 * then the card is programmed for 57.6Kbps or 115Kbps
738 * respectively.
739 */
740
741 if (baud < 1 || baud > 2)
742 port->tty->termios->c_cflag &= ~CBAUDEX;
743 else
744 baud += 15;
745 }
746 if (baud == 15) {
747
748 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
749 * by the set_serial_info ioctl ... this is done by
750 * the 'setserial' utility.
751 */
752
753 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
754 baud++; /* 57.6 Kbps */
755 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
756 baud +=2; /* 115 Kbps */
757 }
758 if (linuxb_to_isib[baud] == -1) {
759 /* hang up */
760 drop_dtr(port);
761 return;
762 }
763 else
764 raise_dtr(port);
765
766 if (lock_card(card)) {
767 outw(0x8000 | (channel << shift_count) |0x03, base);
768 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
769 channel_setup = 0;
770 switch(C_CSIZE(tty)) {
771 case CS5:
772 channel_setup |= ISICOM_CS5;
773 break;
774 case CS6:
775 channel_setup |= ISICOM_CS6;
776 break;
777 case CS7:
778 channel_setup |= ISICOM_CS7;
779 break;
780 case CS8:
781 channel_setup |= ISICOM_CS8;
782 break;
783 }
784
785 if (C_CSTOPB(tty))
786 channel_setup |= ISICOM_2SB;
787 if (C_PARENB(tty)) {
788 channel_setup |= ISICOM_EVPAR;
789 if (C_PARODD(tty))
790 channel_setup |= ISICOM_ODPAR;
791 }
792 outw(channel_setup, base);
793 InterruptTheCard(base);
794 unlock_card(card);
795 }
796 if (C_CLOCAL(tty))
797 port->flags &= ~ASYNC_CHECK_CD;
798 else
799 port->flags |= ASYNC_CHECK_CD;
800
801 /* flow control settings ...*/
802 flow_ctrl = 0;
803 port->flags &= ~ASYNC_CTS_FLOW;
804 if (C_CRTSCTS(tty)) {
805 port->flags |= ASYNC_CTS_FLOW;
806 flow_ctrl |= ISICOM_CTSRTS;
807 }
808 if (I_IXON(tty))
809 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
810 if (I_IXOFF(tty))
811 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
812
813 if (lock_card(card)) {
814 outw(0x8000 | (channel << shift_count) |0x04, base);
815 outw(flow_ctrl << 8 | 0x05, base);
816 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
817 InterruptTheCard(base);
818 unlock_card(card);
819 }
820
821 /* rx enabled -> enable port for rx on the card */
822 if (C_CREAD(tty)) {
823 card->port_status |= (1 << channel);
824 outw(card->port_status, base + 0x02);
825 }
826 }
827
828 /* open et all */
829
830 static inline void isicom_setup_board(struct isi_board *bp)
831 {
832 int channel;
833 struct isi_port *port;
834 unsigned long flags;
835
836 spin_lock_irqsave(&bp->card_lock, flags);
837 if (bp->status & BOARD_ACTIVE) {
838 spin_unlock_irqrestore(&bp->card_lock, flags);
839 return;
840 }
841 port = bp->ports;
842 bp->status |= BOARD_ACTIVE;
843 spin_unlock_irqrestore(&bp->card_lock, flags);
844 for (channel = 0; channel < bp->port_count; channel++, port++)
845 drop_dtr_rts(port);
846 return;
847 }
848
849 static int isicom_setup_port(struct isi_port *port)
850 {
851 struct isi_board *card = port->card;
852 unsigned long flags;
853
854 if (port->flags & ASYNC_INITIALIZED) {
855 return 0;
856 }
857 if (!port->xmit_buf) {
858 unsigned long page;
859
860 if (!(page = get_zeroed_page(GFP_KERNEL)))
861 return -ENOMEM;
862
863 if (port->xmit_buf) {
864 free_page(page);
865 return -ERESTARTSYS;
866 }
867 port->xmit_buf = (unsigned char *) page;
868 }
869
870 spin_lock_irqsave(&card->card_lock, flags);
871 if (port->tty)
872 clear_bit(TTY_IO_ERROR, &port->tty->flags);
873 if (port->count == 1)
874 card->count++;
875
876 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
877
878 /* discard any residual data */
879 kill_queue(port, ISICOM_KILLTX | ISICOM_KILLRX);
880
881 isicom_config_port(port);
882 port->flags |= ASYNC_INITIALIZED;
883 spin_unlock_irqrestore(&card->card_lock, flags);
884
885 return 0;
886 }
887
888 static int block_til_ready(struct tty_struct *tty, struct file *filp, 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);
894
895 /* block if port is in the process of being closed */
896
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 }
905
906 /* if non-blocking mode is set ... */
907
908 if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
909 pr_dbg("block_til_ready: non-block mode.\n");
910 port->flags |= ASYNC_NORMAL_ACTIVE;
911 return 0;
912 }
913
914 if (C_CLOCAL(tty))
915 do_clocal = 1;
916
917 /* block waiting for DCD to be asserted, and while
918 callout dev is busy */
919 retval = 0;
920 add_wait_queue(&port->open_wait, &wait);
921
922 spin_lock_irqsave(&card->card_lock, flags);
923 if (!tty_hung_up_p(filp))
924 port->count--;
925 port->blocked_open++;
926 spin_unlock_irqrestore(&card->card_lock, flags);
927
928 while (1) {
929 raise_dtr_rts(port);
930
931 set_current_state(TASK_INTERRUPTIBLE);
932 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
933 if (port->flags & ASYNC_HUP_NOTIFY)
934 retval = -EAGAIN;
935 else
936 retval = -ERESTARTSYS;
937 break;
938 }
939 if (!(port->flags & ASYNC_CLOSING) &&
940 (do_clocal || (port->status & ISI_DCD))) {
941 break;
942 }
943 if (signal_pending(current)) {
944 retval = -ERESTARTSYS;
945 break;
946 }
947 schedule();
948 }
949 set_current_state(TASK_RUNNING);
950 remove_wait_queue(&port->open_wait, &wait);
951 spin_lock_irqsave(&card->card_lock, flags);
952 if (!tty_hung_up_p(filp))
953 port->count++;
954 port->blocked_open--;
955 spin_unlock_irqrestore(&card->card_lock, flags);
956 if (retval)
957 return retval;
958 port->flags |= ASYNC_NORMAL_ACTIVE;
959 return 0;
960 }
961
962 static int isicom_open(struct tty_struct *tty, struct file *filp)
963 {
964 struct isi_port *port;
965 struct isi_board *card;
966 unsigned int line, board;
967 int error;
968
969 line = tty->index;
970 if (line < 0 || line > PORT_COUNT-1)
971 return -ENODEV;
972 board = BOARD(line);
973 card = &isi_card[board];
974
975 if (!(card->status & FIRMWARE_LOADED))
976 return -ENODEV;
977
978 /* open on a port greater than the port count for the card !!! */
979 if (line > ((board * 16) + card->port_count - 1))
980 return -ENODEV;
981
982 port = &isi_ports[line];
983 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
984 return -ENODEV;
985
986 isicom_setup_board(card);
987
988 port->count++;
989 tty->driver_data = port;
990 port->tty = tty;
991 if ((error = isicom_setup_port(port))!=0)
992 return error;
993 if ((error = block_til_ready(tty, filp, port))!=0)
994 return error;
995
996 return 0;
997 }
998
999 /* close et all */
1000
1001 static inline void isicom_shutdown_board(struct isi_board *bp)
1002 {
1003 unsigned long flags;
1004
1005 spin_lock_irqsave(&bp->card_lock, flags);
1006 if (bp->status & BOARD_ACTIVE) {
1007 bp->status &= ~BOARD_ACTIVE;
1008 }
1009 spin_unlock_irqrestore(&bp->card_lock, flags);
1010 }
1011
1012 static void isicom_shutdown_port(struct isi_port *port)
1013 {
1014 struct isi_board *card = port->card;
1015 struct tty_struct *tty;
1016 unsigned long flags;
1017
1018 tty = port->tty;
1019
1020 spin_lock_irqsave(&card->card_lock, flags);
1021 if (!(port->flags & ASYNC_INITIALIZED)) {
1022 spin_unlock_irqrestore(&card->card_lock, flags);
1023 return;
1024 }
1025 if (port->xmit_buf) {
1026 free_page((unsigned long) port->xmit_buf);
1027 port->xmit_buf = NULL;
1028 }
1029 port->flags &= ~ASYNC_INITIALIZED;
1030 /* 3rd October 2000 : Vinayak P Risbud */
1031 port->tty = NULL;
1032 spin_unlock_irqrestore(&card->card_lock, flags);
1033
1034 /*Fix done by Anil .S on 30-04-2001
1035 remote login through isi port has dtr toggle problem
1036 due to which the carrier drops before the password prompt
1037 appears on the remote end. Now we drop the dtr only if the
1038 HUPCL(Hangup on close) flag is set for the tty*/
1039
1040 if (C_HUPCL(tty))
1041 /* drop dtr on this port */
1042 drop_dtr(port);
1043
1044 /* any other port uninits */
1045 if (tty)
1046 set_bit(TTY_IO_ERROR, &tty->flags);
1047
1048 if (--card->count < 0) {
1049 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
1050 card->base, card->count);
1051 card->count = 0;
1052 }
1053
1054 /* last port was closed , shutdown that boad too */
1055 if (C_HUPCL(tty)) {
1056 if (!card->count)
1057 isicom_shutdown_board(card);
1058 }
1059 }
1060
1061 static void isicom_close(struct tty_struct *tty, struct file *filp)
1062 {
1063 struct isi_port *port = tty->driver_data;
1064 struct isi_board *card = port->card;
1065 unsigned long flags;
1066
1067 if (!port)
1068 return;
1069 if (isicom_paranoia_check(port, tty->name, "isicom_close"))
1070 return;
1071
1072 pr_dbg("Close start!!!.\n");
1073
1074 spin_lock_irqsave(&card->card_lock, flags);
1075 if (tty_hung_up_p(filp)) {
1076 spin_unlock_irqrestore(&card->card_lock, flags);
1077 return;
1078 }
1079
1080 if (tty->count == 1 && port->count != 1) {
1081 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port count"
1082 "tty->count = 1 port count = %d.\n",
1083 card->base, port->count);
1084 port->count = 1;
1085 }
1086 if (--port->count < 0) {
1087 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port count for"
1088 "channel%d = %d", card->base, port->channel,
1089 port->count);
1090 port->count = 0;
1091 }
1092
1093 if (port->count) {
1094 spin_unlock_irqrestore(&card->card_lock, flags);
1095 return;
1096 }
1097 port->flags |= ASYNC_CLOSING;
1098 tty->closing = 1;
1099 spin_unlock_irqrestore(&card->card_lock, flags);
1100
1101 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1102 tty_wait_until_sent(tty, port->closing_wait);
1103 /* indicate to the card that no more data can be received
1104 on this port */
1105 spin_lock_irqsave(&card->card_lock, flags);
1106 if (port->flags & ASYNC_INITIALIZED) {
1107 card->port_status &= ~(1 << port->channel);
1108 outw(card->port_status, card->base + 0x02);
1109 }
1110 isicom_shutdown_port(port);
1111 spin_unlock_irqrestore(&card->card_lock, flags);
1112
1113 if (tty->driver->flush_buffer)
1114 tty->driver->flush_buffer(tty);
1115 tty_ldisc_flush(tty);
1116
1117 spin_lock_irqsave(&card->card_lock, flags);
1118 tty->closing = 0;
1119
1120 if (port->blocked_open) {
1121 spin_unlock_irqrestore(&card->card_lock, flags);
1122 if (port->close_delay) {
1123 pr_dbg("scheduling until time out.\n");
1124 msleep_interruptible(jiffies_to_msecs(port->close_delay));
1125 }
1126 spin_lock_irqsave(&card->card_lock, flags);
1127 wake_up_interruptible(&port->open_wait);
1128 }
1129 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1130 wake_up_interruptible(&port->close_wait);
1131 spin_unlock_irqrestore(&card->card_lock, flags);
1132 }
1133
1134 /* write et all */
1135 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1136 int count)
1137 {
1138 struct isi_port *port = tty->driver_data;
1139 struct isi_board *card = port->card;
1140 unsigned long flags;
1141 int cnt, total = 0;
1142
1143 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1144 return 0;
1145
1146 if (!tty || !port->xmit_buf)
1147 return 0;
1148
1149 spin_lock_irqsave(&card->card_lock, flags);
1150
1151 while(1) {
1152 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1153 SERIAL_XMIT_SIZE - port->xmit_head));
1154 if (cnt <= 0)
1155 break;
1156
1157 memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
1158 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE - 1);
1159 port->xmit_cnt += cnt;
1160 buf += cnt;
1161 count -= cnt;
1162 total += cnt;
1163 }
1164 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1165 port->status |= ISI_TXOK;
1166 spin_unlock_irqrestore(&card->card_lock, flags);
1167 return total;
1168 }
1169
1170 /* put_char et all */
1171 static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
1172 {
1173 struct isi_port *port = tty->driver_data;
1174 struct isi_board *card = port->card;
1175 unsigned long flags;
1176
1177 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1178 return;
1179
1180 if (!tty || !port->xmit_buf)
1181 return;
1182
1183 spin_lock_irqsave(&card->card_lock, flags);
1184 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1185 spin_unlock_irqrestore(&card->card_lock, flags);
1186 return;
1187 }
1188
1189 port->xmit_buf[port->xmit_head++] = ch;
1190 port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1191 port->xmit_cnt++;
1192 spin_unlock_irqrestore(&card->card_lock, flags);
1193 }
1194
1195 /* flush_chars et all */
1196 static void isicom_flush_chars(struct tty_struct *tty)
1197 {
1198 struct isi_port *port = tty->driver_data;
1199
1200 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1201 return;
1202
1203 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped || !port->xmit_buf)
1204 return;
1205
1206 /* this tells the transmitter to consider this port for
1207 data output to the card ... that's the best we can do. */
1208 port->status |= ISI_TXOK;
1209 }
1210
1211 /* write_room et all */
1212 static int isicom_write_room(struct tty_struct *tty)
1213 {
1214 struct isi_port *port = tty->driver_data;
1215 int free;
1216
1217 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1218 return 0;
1219
1220 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1221 if (free < 0)
1222 free = 0;
1223 return free;
1224 }
1225
1226 /* chars_in_buffer et all */
1227 static int isicom_chars_in_buffer(struct tty_struct *tty)
1228 {
1229 struct isi_port *port = tty->driver_data;
1230 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1231 return 0;
1232 return port->xmit_cnt;
1233 }
1234
1235 /* ioctl et all */
1236 static inline void isicom_send_break(struct isi_port *port, unsigned long length)
1237 {
1238 struct isi_board *card = port->card;
1239 unsigned long base = card->base;
1240
1241 if (!lock_card(card))
1242 return;
1243
1244 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1245 outw((length & 0xff) << 8 | 0x00, base);
1246 outw((length & 0xff00), base);
1247 InterruptTheCard(base);
1248
1249 unlock_card(card);
1250 }
1251
1252 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1253 {
1254 struct isi_port *port = tty->driver_data;
1255 /* just send the port status */
1256 u16 status = port->status;
1257
1258 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1259 return -ENODEV;
1260
1261 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1262 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1263 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1264 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1265 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1266 ((status & ISI_RI ) ? TIOCM_RI : 0);
1267 }
1268
1269 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1270 unsigned int set, unsigned int clear)
1271 {
1272 struct isi_port *port = tty->driver_data;
1273
1274 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1275 return -ENODEV;
1276
1277 if (set & TIOCM_RTS)
1278 raise_rts(port);
1279 if (set & TIOCM_DTR)
1280 raise_dtr(port);
1281
1282 if (clear & TIOCM_RTS)
1283 drop_rts(port);
1284 if (clear & TIOCM_DTR)
1285 drop_dtr(port);
1286
1287 return 0;
1288 }
1289
1290 static int isicom_set_serial_info(struct isi_port *port,
1291 struct serial_struct __user *info)
1292 {
1293 struct serial_struct newinfo;
1294 int reconfig_port;
1295
1296 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1297 return -EFAULT;
1298
1299 reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
1300 (newinfo.flags & ASYNC_SPD_MASK));
1301
1302 if (!capable(CAP_SYS_ADMIN)) {
1303 if ((newinfo.close_delay != port->close_delay) ||
1304 (newinfo.closing_wait != port->closing_wait) ||
1305 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1306 (port->flags & ~ASYNC_USR_MASK)))
1307 return -EPERM;
1308 port->flags = ((port->flags & ~ ASYNC_USR_MASK) |
1309 (newinfo.flags & ASYNC_USR_MASK));
1310 }
1311 else {
1312 port->close_delay = newinfo.close_delay;
1313 port->closing_wait = newinfo.closing_wait;
1314 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1315 (newinfo.flags & ASYNC_FLAGS));
1316 }
1317 if (reconfig_port) {
1318 isicom_config_port(port);
1319 }
1320 return 0;
1321 }
1322
1323 static int isicom_get_serial_info(struct isi_port *port,
1324 struct serial_struct __user *info)
1325 {
1326 struct serial_struct out_info;
1327
1328 memset(&out_info, 0, sizeof(out_info));
1329 /* out_info.type = ? */
1330 out_info.line = port - isi_ports;
1331 out_info.port = port->card->base;
1332 out_info.irq = port->card->irq;
1333 out_info.flags = port->flags;
1334 /* out_info.baud_base = ? */
1335 out_info.close_delay = port->close_delay;
1336 out_info.closing_wait = port->closing_wait;
1337 if (copy_to_user(info, &out_info, sizeof(out_info)))
1338 return -EFAULT;
1339 return 0;
1340 }
1341
1342 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1343 unsigned int cmd, unsigned long arg)
1344 {
1345 struct isi_port *port = tty->driver_data;
1346 void __user *argp = (void __user *)arg;
1347 int retval;
1348
1349 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1350 return -ENODEV;
1351
1352 switch(cmd) {
1353 case TCSBRK:
1354 retval = tty_check_change(tty);
1355 if (retval)
1356 return retval;
1357 tty_wait_until_sent(tty, 0);
1358 if (!arg)
1359 isicom_send_break(port, HZ/4);
1360 return 0;
1361
1362 case TCSBRKP:
1363 retval = tty_check_change(tty);
1364 if (retval)
1365 return retval;
1366 tty_wait_until_sent(tty, 0);
1367 isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
1368 return 0;
1369
1370 case TIOCGSOFTCAR:
1371 return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
1372
1373 case TIOCSSOFTCAR:
1374 if (get_user(arg, (unsigned long __user *) argp))
1375 return -EFAULT;
1376 tty->termios->c_cflag =
1377 ((tty->termios->c_cflag & ~CLOCAL) |
1378 (arg ? CLOCAL : 0));
1379 return 0;
1380
1381 case TIOCGSERIAL:
1382 return isicom_get_serial_info(port, argp);
1383
1384 case TIOCSSERIAL:
1385 return isicom_set_serial_info(port, argp);
1386
1387 default:
1388 return -ENOIOCTLCMD;
1389 }
1390 return 0;
1391 }
1392
1393 /* set_termios et all */
1394 static void isicom_set_termios(struct tty_struct *tty,
1395 struct termios *old_termios)
1396 {
1397 struct isi_port *port = tty->driver_data;
1398
1399 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1400 return;
1401
1402 if (tty->termios->c_cflag == old_termios->c_cflag &&
1403 tty->termios->c_iflag == old_termios->c_iflag)
1404 return;
1405
1406 isicom_config_port(port);
1407
1408 if ((old_termios->c_cflag & CRTSCTS) &&
1409 !(tty->termios->c_cflag & CRTSCTS)) {
1410 tty->hw_stopped = 0;
1411 isicom_start(tty);
1412 }
1413 }
1414
1415 /* throttle et all */
1416 static void isicom_throttle(struct tty_struct *tty)
1417 {
1418 struct isi_port *port = tty->driver_data;
1419 struct isi_board *card = port->card;
1420
1421 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1422 return;
1423
1424 /* tell the card that this port cannot handle any more data for now */
1425 card->port_status &= ~(1 << port->channel);
1426 outw(card->port_status, card->base + 0x02);
1427 }
1428
1429 /* unthrottle et all */
1430 static void isicom_unthrottle(struct tty_struct *tty)
1431 {
1432 struct isi_port *port = tty->driver_data;
1433 struct isi_board *card = port->card;
1434
1435 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1436 return;
1437
1438 /* tell the card that this port is ready to accept more data */
1439 card->port_status |= (1 << port->channel);
1440 outw(card->port_status, card->base + 0x02);
1441 }
1442
1443 /* stop et all */
1444 static void isicom_stop(struct tty_struct *tty)
1445 {
1446 struct isi_port *port = tty->driver_data;
1447
1448 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1449 return;
1450
1451 /* this tells the transmitter not to consider this port for
1452 data output to the card. */
1453 port->status &= ~ISI_TXOK;
1454 }
1455
1456 /* start et all */
1457 static void isicom_start(struct tty_struct *tty)
1458 {
1459 struct isi_port *port = tty->driver_data;
1460
1461 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1462 return;
1463
1464 /* this tells the transmitter to consider this port for
1465 data output to the card. */
1466 port->status |= ISI_TXOK;
1467 }
1468
1469 /* hangup et all */
1470 static void do_isicom_hangup(void *data)
1471 {
1472 struct isi_port *port = data;
1473 struct tty_struct *tty;
1474
1475 tty = port->tty;
1476 if (tty)
1477 tty_hangup(tty);
1478 }
1479
1480 static void isicom_hangup(struct tty_struct *tty)
1481 {
1482 struct isi_port *port = tty->driver_data;
1483
1484 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1485 return;
1486
1487 isicom_shutdown_port(port);
1488 port->count = 0;
1489 port->flags &= ~ASYNC_NORMAL_ACTIVE;
1490 port->tty = NULL;
1491 wake_up_interruptible(&port->open_wait);
1492 }
1493
1494 /* flush_buffer et all */
1495 static void isicom_flush_buffer(struct tty_struct *tty)
1496 {
1497 struct isi_port *port = tty->driver_data;
1498 struct isi_board *card = port->card;
1499 unsigned long flags;
1500
1501 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
1502 return;
1503
1504 spin_lock_irqsave(&card->card_lock, flags);
1505 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1506 spin_unlock_irqrestore(&card->card_lock, flags);
1507
1508 wake_up_interruptible(&tty->write_wait);
1509 tty_wakeup(tty);
1510 }
1511
1512 /*
1513 * Driver init and deinit functions
1514 */
1515
1516 static int __devinit isicom_register_ioregion(struct pci_dev *pdev,
1517 const unsigned int index)
1518 {
1519 struct isi_board *board = pci_get_drvdata(pdev);
1520
1521 if (!board->base)
1522 return -EINVAL;
1523
1524 if (!request_region(board->base, 16, ISICOM_NAME)) {
1525 dev_dbg(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1526 "will be disabled.\n", board->base, board->base + 15,
1527 index + 1);
1528 return -EBUSY;
1529 }
1530
1531 return 0;
1532 }
1533
1534 static void isicom_unregister_ioregion(struct pci_dev *pdev)
1535 {
1536 struct isi_board *board = pci_get_drvdata(pdev);
1537
1538 if (!board->base)
1539 return;
1540
1541 release_region(board->base, 16);
1542 dev_dbg(&pdev->dev, "I/O Region 0x%lx-0x%lx released.\n",
1543 board->base, board->base + 15);
1544 board->base = 0;
1545 }
1546
1547 static struct tty_operations isicom_ops = {
1548 .open = isicom_open,
1549 .close = isicom_close,
1550 .write = isicom_write,
1551 .put_char = isicom_put_char,
1552 .flush_chars = isicom_flush_chars,
1553 .write_room = isicom_write_room,
1554 .chars_in_buffer = isicom_chars_in_buffer,
1555 .ioctl = isicom_ioctl,
1556 .set_termios = isicom_set_termios,
1557 .throttle = isicom_throttle,
1558 .unthrottle = isicom_unthrottle,
1559 .stop = isicom_stop,
1560 .start = isicom_start,
1561 .hangup = isicom_hangup,
1562 .flush_buffer = isicom_flush_buffer,
1563 .tiocmget = isicom_tiocmget,
1564 .tiocmset = isicom_tiocmset,
1565 };
1566
1567 static int __devinit isicom_register_tty_driver(void)
1568 {
1569 int error = -ENOMEM;
1570
1571 /* tty driver structure initialization */
1572 isicom_normal = alloc_tty_driver(PORT_COUNT);
1573 if (!isicom_normal)
1574 goto end;
1575
1576 isicom_normal->owner = THIS_MODULE;
1577 isicom_normal->name = "ttyM";
1578 isicom_normal->devfs_name = "isicom/";
1579 isicom_normal->major = ISICOM_NMAJOR;
1580 isicom_normal->minor_start = 0;
1581 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1582 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1583 isicom_normal->init_termios = tty_std_termios;
1584 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1585 CLOCAL;
1586 isicom_normal->flags = TTY_DRIVER_REAL_RAW;
1587 tty_set_operations(isicom_normal, &isicom_ops);
1588
1589 if ((error = tty_register_driver(isicom_normal))) {
1590 pr_dbg("Couldn't register the dialin driver, error=%d\n",
1591 error);
1592 put_tty_driver(isicom_normal);
1593 }
1594 end:
1595 return error;
1596 }
1597
1598 static void isicom_unregister_tty_driver(void)
1599 {
1600 int error;
1601
1602 if ((error = tty_unregister_driver(isicom_normal)))
1603 pr_dbg("couldn't unregister normal driver, error=%d.\n", error);
1604
1605 put_tty_driver(isicom_normal);
1606 }
1607
1608 static int __devinit isicom_register_isr(struct pci_dev *pdev,
1609 const unsigned int index)
1610 {
1611 struct isi_board *board = pci_get_drvdata(pdev);
1612 unsigned long irqflags = SA_INTERRUPT;
1613 int retval = -EINVAL;
1614
1615 if (!board->base)
1616 goto end;
1617
1618 if (board->isa == NO)
1619 irqflags |= SA_SHIRQ;
1620
1621 retval = request_irq(board->irq, isicom_interrupt, irqflags,
1622 ISICOM_NAME, board);
1623 if (retval < 0)
1624 dev_warn(&pdev->dev, "Could not install handler at Irq %d. "
1625 "Card%d will be disabled.\n", board->irq, index + 1);
1626 else
1627 retval = 0;
1628 end:
1629 return retval;
1630 }
1631
1632 static int __devinit reset_card(struct pci_dev *pdev,
1633 const unsigned int card, unsigned int *signature)
1634 {
1635 struct isi_board *board = pci_get_drvdata(pdev);
1636 unsigned long base = board->base;
1637 unsigned int portcount = 0;
1638 int retval = 0;
1639
1640 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1641 base);
1642
1643 inw(base + 0x8);
1644
1645 mdelay(10);
1646
1647 outw(0, base + 0x8); /* Reset */
1648
1649 msleep(3000);
1650
1651 *signature = inw(base + 0x4) & 0xff;
1652
1653 if (board->isa == YES) {
1654 if (!(inw(base + 0xe) & 0x1) || (inw(base + 0x2))) {
1655 dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
1656 inw(base + 0x2), inw(base + 0xe));
1657 dev_err(&pdev->dev, "ISILoad:ISA Card%d reset failure "
1658 "(Possible bad I/O Port Address 0x%lx).\n",
1659 card + 1, base);
1660 retval = -EIO;
1661 goto end;
1662 }
1663 } else {
1664 portcount = inw(base + 0x2);
1665 if (!(inw(base + 0xe) & 0x1) || ((portcount != 0) &&
1666 (portcount != 4) && (portcount != 8))) {
1667 dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
1668 inw(base + 0x2), inw(base + 0xe));
1669 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure "
1670 "(Possible bad I/O Port Address 0x%lx).\n",
1671 card + 1, base);
1672 retval = -EIO;
1673 goto end;
1674 }
1675 }
1676
1677 switch (*signature) {
1678 case 0xa5:
1679 case 0xbb:
1680 case 0xdd:
1681 board->port_count = (board->isa == NO && portcount == 4) ? 4 :
1682 8;
1683 board->shift_count = 12;
1684 break;
1685 case 0xcc:
1686 board->port_count = 16;
1687 board->shift_count = 11;
1688 break;
1689 default:
1690 dev_warn(&pdev->dev, "ISILoad:Card%d reset failure (Possible "
1691 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1692 dev_dbg(&pdev->dev, "Sig=0x%lx\n", signature);
1693 retval = -EIO;
1694 }
1695 dev_info(&pdev->dev, "-Done\n");
1696
1697 end:
1698 return retval;
1699 }
1700
1701 static inline int WaitTillCardIsFree(u16 base)
1702 {
1703 unsigned long count = 0;
1704
1705 while (!(inw(base + 0xe) & 0x1) && count++ < 100)
1706 msleep(5);
1707
1708 return !(inw(base + 0xe) & 0x1);
1709 }
1710
1711 static int __devinit load_firmware(struct pci_dev *pdev,
1712 const unsigned int index, const unsigned int signature)
1713 {
1714 struct isi_board *board = pci_get_drvdata(pdev);
1715 const struct firmware *fw;
1716 unsigned long base = board->base;
1717 unsigned int a;
1718 u16 word_count, status;
1719 int retval = -EIO;
1720 char *name;
1721 u8 *data;
1722
1723 struct stframe {
1724 u16 addr;
1725 u16 count;
1726 u8 data[0];
1727 } *frame;
1728
1729 switch (signature) {
1730 case 0xa5:
1731 name = "isi608.bin";
1732 break;
1733 case 0xbb:
1734 name = "isi608em.bin";
1735 break;
1736 case 0xcc:
1737 name = "isi616em.bin";
1738 break;
1739 case 0xdd:
1740 name = "isi4608.bin";
1741 break;
1742 case 0xee:
1743 name = "isi4616.bin";
1744 break;
1745 default:
1746 dev_err(&pdev->dev, "Unknown signature.\n");
1747 goto end;
1748 }
1749
1750 retval = request_firmware(&fw, name, &pdev->dev);
1751 if (retval)
1752 goto end;
1753
1754 for (frame = (struct stframe *)fw->data;
1755 frame < (struct stframe *)(fw->data + fw->size);
1756 frame++) {
1757 if (WaitTillCardIsFree(base))
1758 goto errrelfw;
1759
1760 outw(0xf0, base); /* start upload sequence */
1761 outw(0x00, base);
1762 outw(frame->addr, base); /* lsb of address */
1763
1764 word_count = frame->count / 2 + frame->count % 2;
1765 outw(word_count, base);
1766 InterruptTheCard(base);
1767
1768 udelay(100); /* 0x2f */
1769
1770 if (WaitTillCardIsFree(base))
1771 goto errrelfw;
1772
1773 if ((status = inw(base + 0x4)) != 0) {
1774 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1775 "Address:0x%x\nCount:0x%x\nStatus:0x%x\n",
1776 index + 1, frame->addr, frame->count, status);
1777 goto errrelfw;
1778 }
1779 outsw(base, frame->data, word_count);
1780
1781 InterruptTheCard(base);
1782
1783 udelay(50); /* 0x0f */
1784
1785 if (WaitTillCardIsFree(base))
1786 goto errrelfw;
1787
1788 if ((status = inw(base + 0x4)) != 0) {
1789 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1790 "Status:0x%x\n", index + 1, status);
1791 goto errrelfw;
1792 }
1793 }
1794
1795 retval = -EIO;
1796
1797 if (WaitTillCardIsFree(base))
1798 goto errrelfw;
1799
1800 outw(0xf2, base);
1801 outw(0x800, base);
1802 outw(0x0, base);
1803 outw(0x0, base);
1804 InterruptTheCard(base);
1805 outw(0x0, base + 0x4); /* for ISI4608 cards */
1806
1807 /* XXX: should we test it by reading it back and comparing with original like
1808 * in load firmware package? */
1809 for (frame = (struct stframe*)fw->data;
1810 frame < (struct stframe*)(fw->data + fw->size);
1811 frame++) {
1812 if (WaitTillCardIsFree(base))
1813 goto errrelfw;
1814
1815 outw(0xf1, base); /* start download sequence */
1816 outw(0x00, base);
1817 outw(frame->addr, base); /* lsb of address */
1818
1819 word_count = (frame->count >> 1) + frame->count % 2;
1820 outw(word_count + 1, base);
1821 InterruptTheCard(base);
1822
1823 udelay(50); /* 0xf */
1824
1825 if (WaitTillCardIsFree(base))
1826 goto errrelfw;
1827
1828 if ((status = inw(base + 0x4)) != 0) {
1829 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1830 "Address:0x%x\nCount:0x%x\nStatus: 0x%x\n",
1831 index + 1, frame->addr, frame->count, status);
1832 goto errrelfw;
1833 }
1834
1835 data = kmalloc(word_count * 2, GFP_KERNEL);
1836 inw(base);
1837 insw(base, data, word_count);
1838 InterruptTheCard(base);
1839
1840 for (a = 0; a < frame->count; a++)
1841 if (data[a] != frame->data[a]) {
1842 kfree(data);
1843 dev_err(&pdev->dev, "Card%d, firmware upload "
1844 "failed\n", index + 1);
1845 goto errrelfw;
1846 }
1847 kfree(data);
1848
1849 udelay(50); /* 0xf */
1850
1851 if (WaitTillCardIsFree(base))
1852 goto errrelfw;
1853
1854 if ((status = inw(base + 0x4)) != 0) {
1855 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1856 "Card Status:0x%x\n", index + 1, status);
1857 goto errrelfw;
1858 }
1859 }
1860
1861 board->status |= FIRMWARE_LOADED;
1862 retval = 0;
1863
1864 errrelfw:
1865 release_firmware(fw);
1866 end:
1867 return retval;
1868 }
1869
1870 /*
1871 * Insmod can set static symbols so keep these static
1872 */
1873 static int io[4];
1874 static int irq[4];
1875 static int card;
1876
1877 static int __devinit isicom_probe(struct pci_dev *pdev,
1878 const struct pci_device_id *ent)
1879 {
1880 unsigned int ioaddr, signature, index;
1881 int retval = -EPERM;
1882 u8 pciirq;
1883 struct isi_board *board = NULL;
1884
1885 if (card >= BOARD_COUNT)
1886 goto err;
1887
1888 ioaddr = pci_resource_start(pdev, 3);
1889 /* i.e at offset 0x1c in the PCI configuration register space. */
1890 pciirq = pdev->irq;
1891 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1892
1893 /* allot the first empty slot in the array */
1894 for (index = 0; index < BOARD_COUNT; index++)
1895 if (isi_card[index].base == 0) {
1896 board = &isi_card[index];
1897 break;
1898 }
1899
1900 board->base = ioaddr;
1901 board->irq = pciirq;
1902 board->isa = NO;
1903 card++;
1904
1905 pci_set_drvdata(pdev, board);
1906
1907 retval = isicom_register_ioregion(pdev, index);
1908 if (retval < 0)
1909 goto err;
1910
1911 retval = isicom_register_isr(pdev, index);
1912 if (retval < 0)
1913 goto errunrr;
1914
1915 retval = reset_card(pdev, index, &signature);
1916 if (retval < 0)
1917 goto errunri;
1918
1919 retval = load_firmware(pdev, index, signature);
1920 if (retval < 0)
1921 goto errunri;
1922
1923 return 0;
1924
1925 errunri:
1926 free_irq(board->irq, board);
1927 errunrr:
1928 isicom_unregister_ioregion(pdev);
1929 err:
1930 board->base = 0;
1931 return retval;
1932 }
1933
1934 static void __devexit isicom_remove(struct pci_dev *pdev)
1935 {
1936 struct isi_board *board = pci_get_drvdata(pdev);
1937
1938 free_irq(board->irq, board);
1939 isicom_unregister_ioregion(pdev);
1940 }
1941
1942 static int __devinit isicom_setup(void)
1943 {
1944 int retval, idx, channel;
1945 struct isi_port *port;
1946
1947 card = 0;
1948 memset(isi_ports, 0, sizeof(isi_ports));
1949
1950 for(idx = 0; idx < BOARD_COUNT; idx++) {
1951 port = &isi_ports[idx * 16];
1952 isi_card[idx].ports = port;
1953 spin_lock_init(&isi_card[idx].card_lock);
1954 for (channel = 0; channel < 16; channel++, port++) {
1955 port->magic = ISICOM_MAGIC;
1956 port->card = &isi_card[idx];
1957 port->channel = channel;
1958 port->close_delay = 50 * HZ/100;
1959 port->closing_wait = 3000 * HZ/100;
1960 INIT_WORK(&port->hangup_tq, do_isicom_hangup, port);
1961 INIT_WORK(&port->bh_tqueue, isicom_bottomhalf, port);
1962 port->status = 0;
1963 init_waitqueue_head(&port->open_wait);
1964 init_waitqueue_head(&port->close_wait);
1965 /* . . . */
1966 }
1967 isi_card[idx].base = 0;
1968 isi_card[idx].irq = 0;
1969
1970 if (!io[idx])
1971 continue;
1972
1973 if (irq[idx] == 2 || irq[idx] == 3 || irq[idx] == 4 ||
1974 irq[idx] == 5 || irq[idx] == 7 ||
1975 irq[idx] == 10 || irq[idx] == 11 ||
1976 irq[idx] == 12 || irq[idx] == 15) {
1977 printk(KERN_ERR "ISICOM: ISA not supported yet.\n");
1978 retval = -EINVAL;
1979 goto error;
1980 } else
1981 printk(KERN_ERR "ISICOM: Irq %d unsupported. "
1982 "Disabling Card%d...\n", irq[idx], idx + 1);
1983 }
1984
1985 retval = isicom_register_tty_driver();
1986 if (retval < 0)
1987 goto error;
1988
1989 retval = pci_register_driver(&isicom_driver);
1990 if (retval < 0) {
1991 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1992 goto errtty;
1993 }
1994
1995 init_timer(&tx);
1996 tx.expires = jiffies + 1;
1997 tx.data = 0;
1998 tx.function = isicom_tx;
1999 re_schedule = 1;
2000 add_timer(&tx);
2001
2002 return 0;
2003 errtty:
2004 isicom_unregister_tty_driver();
2005 error:
2006 return retval;
2007 }
2008
2009 static void __exit isicom_exit(void)
2010 {
2011 unsigned int index = 0;
2012
2013 re_schedule = 0;
2014
2015 while (re_schedule != 2 && index++ < 100)
2016 msleep(10);
2017
2018 pci_unregister_driver(&isicom_driver);
2019 isicom_unregister_tty_driver();
2020 }
2021
2022 module_init(isicom_setup);
2023 module_exit(isicom_exit);
2024
2025 MODULE_AUTHOR("MultiTech");
2026 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
2027 MODULE_LICENSE("GPL");
2028 module_param_array(io, int, NULL, 0);
2029 MODULE_PARM_DESC(io, "I/O ports for the cards");
2030 module_param_array(irq, int, NULL, 0);
2031 MODULE_PARM_DESC(irq, "Interrupts for the cards");
Linux kernel - Deliverables
This page took 0.078241 seconds and 6 git commands to generate.