?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm-only debug patch...
[mmotm.git] / drivers / char / isicom.c
blob280195b9030c94b94565f5920b7157965ca9370b
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@lxorguk.ukuu.org.uk
11 * Merge to 2.0.x kernel tree
12 * Obtain and use official major/minors
13 * Loader switched to a misc device
14 * (fixed range check bug as a side effect)
15 * Printk clean up
16 * 9/12/98 alan@lxorguk.ukuu.org.uk
17 * Rough port to 2.1.x
18 *
19 * 10/6/99 sameer Merged the ISA and PCI drivers to
20 * a new unified driver.
21 *
22 * 3/9/99 sameer Added support for ISI4616 cards.
23 *
24 * 16/9/99 sameer We do not force RTS low anymore.
25 * This is to prevent the firmware
26 * from getting confused.
27 *
28 * 26/10/99 sameer Cosmetic changes:The driver now
29 * dumps the Port Count information
30 * along with I/O address and IRQ.
31 *
32 * 13/12/99 sameer Fixed the problem with IRQ sharing.
33 *
34 * 10/5/00 sameer Fixed isicom_shutdown_board()
35 * to not lower DTR on all the ports
36 * when the last port on the card is
37 * closed.
38 *
39 * 10/5/00 sameer Signal mask setup command added
40 * to isicom_setup_port and
41 * isicom_shutdown_port.
42 *
43 * 24/5/00 sameer The driver is now SMP aware.
44 *
45 *
46 * 27/11/00 Vinayak P Risbud Fixed the Driver Crash Problem
47 *
48 *
49 * 03/01/01 anil .s Added support for resetting the
50 * internal modems on ISI cards.
51 *
52 * 08/02/01 anil .s Upgraded the driver for kernel
53 * 2.4.x
54 *
55 * 11/04/01 Kevin Fixed firmware load problem with
56 * ISIHP-4X card
57 *
58 * 30/04/01 anil .s Fixed the remote login through
59 * ISI port problem. Now the link
60 * does not go down before password
61 * prompt.
62 *
63 * 03/05/01 anil .s Fixed the problem with IRQ sharing
64 * among ISI-PCI cards.
65 *
66 * 03/05/01 anil .s Added support to display the version
67 * info during insmod as well as module
68 * listing by lsmod.
69 *
70 * 10/05/01 anil .s Done the modifications to the source
71 * file and Install script so that the
72 * same installation can be used for
73 * 2.2.x and 2.4.x kernel.
74 *
75 * 06/06/01 anil .s Now we drop both dtr and rts during
76 * shutdown_port as well as raise them
77 * during isicom_config_port.
78 *
79 * 09/06/01 acme@conectiva.com.br use capable, not suser, do
80 * restore_flags on failure in
81 * isicom_send_break, verify put_user
82 * result
83 *
84 * 11/02/03 ranjeeth Added support for 230 Kbps and 460 Kbps
85 * Baud index extended to 21
86 *
87 * 20/03/03 ranjeeth Made to work for Linux Advanced server.
88 * Taken care of license warning.
89 *
90 * 10/12/03 Ravindra Made to work for Fedora Core 1 of
91 * Red Hat Distribution
92 *
93 * 06/01/05 Alan Cox Merged the ISI and base kernel strands
94 * into a single 2.6 driver
95 *
96 * ***********************************************************
97 *
98 * To use this driver you also need the support package. You
99 * can find this in RPM format on
100 * ftp://ftp.linux.org.uk/pub/linux/alan
101 *
102 * You can find the original tools for this direct from Multitech
103 * ftp://ftp.multitech.com/ISI-Cards/
104 *
105 * Having installed the cards the module options (/etc/modprobe.conf)
106 *
107 * options isicom io=card1,card2,card3,card4 irq=card1,card2,card3,card4
108 *
109 * Omit those entries for boards you don't have installed.
110 *
111 * TODO
112 * Merge testing
113 * 64-bit verification
114 */
115
116 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
117
118 #include <linux/module.h>
119 #include <linux/firmware.h>
120 #include <linux/kernel.h>
121 #include <linux/tty.h>
122 #include <linux/tty_flip.h>
123 #include <linux/termios.h>
124 #include <linux/fs.h>
125 #include <linux/sched.h>
126 #include <linux/serial.h>
127 #include <linux/smp_lock.h>
128 #include <linux/mm.h>
129 #include <linux/interrupt.h>
130 #include <linux/timer.h>
131 #include <linux/delay.h>
132 #include <linux/ioport.h>
133
134 #include <linux/uaccess.h>
135 #include <linux/io.h>
136 #include <asm/system.h>
137
138 #include <linux/pci.h>
139
140 #include <linux/isicom.h>
141
142 #define InterruptTheCard(base) outw(0, (base) + 0xc)
143 #define ClearInterrupt(base) inw((base) + 0x0a)
144
145 #ifdef DEBUG
146 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
147 #else
148 #define isicom_paranoia_check(a, b, c) 0
149 #endif
150
151 static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
152 static void __devexit isicom_remove(struct pci_dev *);
153
154 static struct pci_device_id isicom_pci_tbl[] = {
155 { PCI_DEVICE(VENDOR_ID, 0x2028) },
156 { PCI_DEVICE(VENDOR_ID, 0x2051) },
157 { PCI_DEVICE(VENDOR_ID, 0x2052) },
158 { PCI_DEVICE(VENDOR_ID, 0x2053) },
159 { PCI_DEVICE(VENDOR_ID, 0x2054) },
160 { PCI_DEVICE(VENDOR_ID, 0x2055) },
161 { PCI_DEVICE(VENDOR_ID, 0x2056) },
162 { PCI_DEVICE(VENDOR_ID, 0x2057) },
163 { PCI_DEVICE(VENDOR_ID, 0x2058) },
164 { 0 }
165 };
166 MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
167
168 static struct pci_driver isicom_driver = {
169 .name = "isicom",
170 .id_table = isicom_pci_tbl,
171 .probe = isicom_probe,
172 .remove = __devexit_p(isicom_remove)
173 };
174
175 static int prev_card = 3; /* start servicing isi_card[0] */
176 static struct tty_driver *isicom_normal;
177
178 static void isicom_tx(unsigned long _data);
179 static void isicom_start(struct tty_struct *tty);
180
181 static DEFINE_TIMER(tx, isicom_tx, 0, 0);
182
183 /* baud index mappings from linux defns to isi */
184
185 static signed char linuxb_to_isib[] = {
186 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19, 20, 21
187 };
188
189 struct isi_board {
190 unsigned long base;
191 int irq;
192 unsigned char port_count;
193 unsigned short status;
194 unsigned short port_status; /* each bit for each port */
195 unsigned short shift_count;
196 struct isi_port *ports;
197 signed char count;
198 spinlock_t card_lock; /* Card wide lock 11/5/00 -sameer */
199 unsigned long flags;
200 unsigned int index;
201 };
202
203 struct isi_port {
204 unsigned short magic;
205 struct tty_port port;
206 u16 channel;
207 u16 status;
208 struct isi_board *card;
209 unsigned char *xmit_buf;
210 int xmit_head;
211 int xmit_tail;
212 int xmit_cnt;
213 };
214
215 static struct isi_board isi_card[BOARD_COUNT];
216 static struct isi_port isi_ports[PORT_COUNT];
217
218 /*
219 * Locking functions for card level locking. We need to own both
220 * the kernel lock for the card and have the card in a position that
221 * it wants to talk.
222 */
223
224 static inline int WaitTillCardIsFree(unsigned long base)
225 {
226 unsigned int count = 0;
227 unsigned int a = in_atomic(); /* do we run under spinlock? */
228
229 while (!(inw(base + 0xe) & 0x1) && count++ < 100)
230 if (a)
231 mdelay(1);
232 else
233 msleep(1);
234
235 return !(inw(base + 0xe) & 0x1);
236 }
237
238 static int lock_card(struct isi_board *card)
239 {
240 unsigned long base = card->base;
241 unsigned int retries, a;
242
243 for (retries = 0; retries < 10; retries++) {
244 spin_lock_irqsave(&card->card_lock, card->flags);
245 for (a = 0; a < 10; a++) {
246 if (inw(base + 0xe) & 0x1)
247 return 1;
248 udelay(10);
249 }
250 spin_unlock_irqrestore(&card->card_lock, card->flags);
251 msleep(10);
252 }
253 pr_warning("Failed to lock Card (0x%lx)\n", card->base);
254
255 return 0; /* Failed to acquire the card! */
256 }
257
258 static void unlock_card(struct isi_board *card)
259 {
260 spin_unlock_irqrestore(&card->card_lock, card->flags);
261 }
262
263 /*
264 * ISI Card specific ops ...
265 */
266
267 /* card->lock HAS to be held */
268 static 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 /* card->lock HAS to be held */
284 static 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 /* card->lock HAS to be held */
300 static 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 /* card->lock HAS to be held */
316 static 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 /* card->lock MUST NOT be held */
332
333 static 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 /* card->lock HAS to be held */
358 static 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 * ISICOM Driver specific routines ...
375 *
376 */
377
378 static inline int __isicom_paranoia_check(struct isi_port const *port,
379 char *name, const char *routine)
380 {
381 if (!port) {
382 pr_warning("Warning: bad isicom magic for dev %s in %s.\n",
383 name, routine);
384 return 1;
385 }
386 if (port->magic != ISICOM_MAGIC) {
387 pr_warning("Warning: NULL isicom port for dev %s in %s.\n",
388 name, routine);
389 return 1;
390 }
391
392 return 0;
393 }
394
395 /*
396 * Transmitter.
397 *
398 * We shovel data into the card buffers on a regular basis. The card
399 * will do the rest of the work for us.
400 */
401
402 static 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 /* find next active board */
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 /* port not active or tx disabled to force flow control */
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_debug("txing %d bytes, port%d.\n",
454 txcount, 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
503 put_unlock:
504 tty_kref_put(tty);
505 unlock:
506 spin_unlock_irqrestore(&isi_card[card].card_lock, flags);
507 /* schedule another tx for hopefully in about 10ms */
508 sched_again:
509 mod_timer(&tx, jiffies + msecs_to_jiffies(10));
510 }
511
512 /*
513 * Main interrupt handler routine
514 */
515
516 static 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 /* did the card interrupt us? */
532 if (!(inw(base + 0x0e) & 0x02))
533 return IRQ_NONE;
534
535 spin_lock(&card->card_lock);
536
537 /*
538 * disable any interrupts from the PCI card and lower the
539 * interrupt line
540 */
541 outw(0x8000, base+0x04);
542 ClearInterrupt(base);
543
544 inw(base); /* get the dummy word out */
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 pr_warning("%s(0x%lx): %d(channel) > port_count.\n",
551 __func__, base, channel+1);
552 outw(0x0000, base+0x04); /* enable interrupts */
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); /* enable interrupts */
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); /* enable interrupts */
573 spin_unlock(&card->card_lock);
574 return IRQ_HANDLED;
575 }
576
577 if (header & 0x8000) { /* Status Packet */
578 header = inw(base);
579 switch (header & 0xff) {
580 case 0: /* Change in EIA signals */
581 if (port->port.flags & ASYNC_CHECK_CD) {
582 if (port->status & ISI_DCD) {
583 if (!(header & ISI_DCD)) {
584 /* Carrier has been lost */
585 pr_debug("%s: DCD->low.\n",
586 __func__);
587 port->status &= ~ISI_DCD;
588 tty_hangup(tty);
589 }
590 } else if (header & ISI_DCD) {
591 /* Carrier has been detected */
592 pr_debug("%s: DCD->high.\n",
593 __func__);
594 port->status |= ISI_DCD;
595 wake_up_interruptible(&port->port.open_wait);
596 }
597 } else {
598 if (header & ISI_DCD)
599 port->status |= ISI_DCD;
600 else
601 port->status &= ~ISI_DCD;
602 }
603
604 if (port->port.flags & ASYNC_CTS_FLOW) {
605 if (tty->hw_stopped) {
606 if (header & ISI_CTS) {
607 port->port.tty->hw_stopped = 0;
608 /* start tx ing */
609 port->status |= (ISI_TXOK
610 | ISI_CTS);
611 tty_wakeup(tty);
612 }
613 } else if (!(header & ISI_CTS)) {
614 tty->hw_stopped = 1;
615 /* stop tx ing */
616 port->status &= ~(ISI_TXOK | ISI_CTS);
617 }
618 } else {
619 if (header & ISI_CTS)
620 port->status |= ISI_CTS;
621 else
622 port->status &= ~ISI_CTS;
623 }
624
625 if (header & ISI_DSR)
626 port->status |= ISI_DSR;
627 else
628 port->status &= ~ISI_DSR;
629
630 if (header & ISI_RI)
631 port->status |= ISI_RI;
632 else
633 port->status &= ~ISI_RI;
634
635 break;
636
637 case 1: /* Received Break !!! */
638 tty_insert_flip_char(tty, 0, TTY_BREAK);
639 if (port->port.flags & ASYNC_SAK)
640 do_SAK(tty);
641 tty_flip_buffer_push(tty);
642 break;
643
644 case 2: /* Statistics */
645 pr_debug("%s: stats!!!\n", __func__);
646 break;
647
648 default:
649 pr_debug("%s: Unknown code in status packet.\n",
650 __func__);
651 break;
652 }
653 } else { /* Data Packet */
654
655 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
656 pr_debug("%s: Can rx %d of %d bytes.\n",
657 __func__, count, byte_count);
658 word_count = count >> 1;
659 insw(base, rp, word_count);
660 byte_count -= (word_count << 1);
661 if (count & 0x0001) {
662 tty_insert_flip_char(tty, inw(base) & 0xff,
663 TTY_NORMAL);
664 byte_count -= 2;
665 }
666 if (byte_count > 0) {
667 pr_debug("%s(0x%lx:%d): Flip buffer overflow! dropping bytes...\n",
668 __func__, base, channel + 1);
669 /* drain out unread xtra data */
670 while (byte_count > 0) {
671 inw(base);
672 byte_count -= 2;
673 }
674 }
675 tty_flip_buffer_push(tty);
676 }
677 outw(0x0000, base+0x04); /* enable interrupts */
678 spin_unlock(&card->card_lock);
679 tty_kref_put(tty);
680
681 return IRQ_HANDLED;
682 }
683
684 static void isicom_config_port(struct tty_struct *tty)
685 {
686 struct isi_port *port = tty->driver_data;
687 struct isi_board *card = port->card;
688 unsigned long baud;
689 unsigned long base = card->base;
690 u16 channel_setup, channel = port->channel,
691 shift_count = card->shift_count;
692 unsigned char flow_ctrl;
693
694 /* FIXME: Switch to new tty baud API */
695 baud = C_BAUD(tty);
696 if (baud & CBAUDEX) {
697 baud &= ~CBAUDEX;
698
699 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
700 * then the card is programmed for 57.6Kbps or 115Kbps
701 * respectively.
702 */
703
704 /* 1,2,3,4 => 57.6, 115.2, 230, 460 kbps resp. */
705 if (baud < 1 || baud > 4)
706 tty->termios->c_cflag &= ~CBAUDEX;
707 else
708 baud += 15;
709 }
710 if (baud == 15) {
711
712 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
713 * by the set_serial_info ioctl ... this is done by
714 * the 'setserial' utility.
715 */
716
717 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
718 baud++; /* 57.6 Kbps */
719 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
720 baud += 2; /* 115 Kbps */
721 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
722 baud += 3; /* 230 kbps*/
723 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
724 baud += 4; /* 460 kbps*/
725 }
726 if (linuxb_to_isib[baud] == -1) {
727 /* hang up */
728 drop_dtr(port);
729 return;
730 } else
731 raise_dtr(port);
732
733 if (WaitTillCardIsFree(base) == 0) {
734 outw(0x8000 | (channel << shift_count) | 0x03, base);
735 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
736 channel_setup = 0;
737 switch (C_CSIZE(tty)) {
738 case CS5:
739 channel_setup |= ISICOM_CS5;
740 break;
741 case CS6:
742 channel_setup |= ISICOM_CS6;
743 break;
744 case CS7:
745 channel_setup |= ISICOM_CS7;
746 break;
747 case CS8:
748 channel_setup |= ISICOM_CS8;
749 break;
750 }
751
752 if (C_CSTOPB(tty))
753 channel_setup |= ISICOM_2SB;
754 if (C_PARENB(tty)) {
755 channel_setup |= ISICOM_EVPAR;
756 if (C_PARODD(tty))
757 channel_setup |= ISICOM_ODPAR;
758 }
759 outw(channel_setup, base);
760 InterruptTheCard(base);
761 }
762 if (C_CLOCAL(tty))
763 port->port.flags &= ~ASYNC_CHECK_CD;
764 else
765 port->port.flags |= ASYNC_CHECK_CD;
766
767 /* flow control settings ...*/
768 flow_ctrl = 0;
769 port->port.flags &= ~ASYNC_CTS_FLOW;
770 if (C_CRTSCTS(tty)) {
771 port->port.flags |= ASYNC_CTS_FLOW;
772 flow_ctrl |= ISICOM_CTSRTS;
773 }
774 if (I_IXON(tty))
775 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
776 if (I_IXOFF(tty))
777 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
778
779 if (WaitTillCardIsFree(base) == 0) {
780 outw(0x8000 | (channel << shift_count) | 0x04, base);
781 outw(flow_ctrl << 8 | 0x05, base);
782 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
783 InterruptTheCard(base);
784 }
785
786 /* rx enabled -> enable port for rx on the card */
787 if (C_CREAD(tty)) {
788 card->port_status |= (1 << channel);
789 outw(card->port_status, base + 0x02);
790 }
791 }
792
793 /* open et all */
794
795 static inline void isicom_setup_board(struct isi_board *bp)
796 {
797 int channel;
798 struct isi_port *port;
799 unsigned long flags;
800
801 spin_lock_irqsave(&bp->card_lock, flags);
802 if (bp->status & BOARD_ACTIVE) {
803 spin_unlock_irqrestore(&bp->card_lock, flags);
804 return;
805 }
806 port = bp->ports;
807 bp->status |= BOARD_ACTIVE;
808 for (channel = 0; channel < bp->port_count; channel++, port++)
809 drop_dtr_rts(port);
810 spin_unlock_irqrestore(&bp->card_lock, flags);
811 }
812
813 static int isicom_setup_port(struct tty_struct *tty)
814 {
815 struct isi_port *port = tty->driver_data;
816 struct isi_board *card = port->card;
817 unsigned long flags;
818
819 if (port->port.flags & ASYNC_INITIALIZED)
820 return 0;
821 if (tty_port_alloc_xmit_buf(&port->port) < 0)
822 return -ENOMEM;
823
824 spin_lock_irqsave(&card->card_lock, flags);
825 clear_bit(TTY_IO_ERROR, &tty->flags);
826 if (port->port.count == 1)
827 card->count++;
828
829 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
830
831 /* discard any residual data */
832 if (WaitTillCardIsFree(card->base) == 0) {
833 outw(0x8000 | (port->channel << card->shift_count) | 0x02,
834 card->base);
835 outw(((ISICOM_KILLTX | ISICOM_KILLRX) << 8) | 0x06, card->base);
836 InterruptTheCard(card->base);
837 }
838
839 isicom_config_port(tty);
840 port->port.flags |= ASYNC_INITIALIZED;
841 spin_unlock_irqrestore(&card->card_lock, flags);
842
843 return 0;
844 }
845
846 static int isicom_carrier_raised(struct tty_port *port)
847 {
848 struct isi_port *ip = container_of(port, struct isi_port, port);
849 return (ip->status & ISI_DCD)?1 : 0;
850 }
851
852 static struct tty_port *isicom_find_port(struct tty_struct *tty)
853 {
854 struct isi_port *port;
855 struct isi_board *card;
856 unsigned int board;
857 int line = tty->index;
858
859 if (line < 0 || line > PORT_COUNT-1)
860 return NULL;
861 board = BOARD(line);
862 card = &isi_card[board];
863
864 if (!(card->status & FIRMWARE_LOADED))
865 return NULL;
866
867 /* open on a port greater than the port count for the card !!! */
868 if (line > ((board * 16) + card->port_count - 1))
869 return NULL;
870
871 port = &isi_ports[line];
872 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
873 return NULL;
874
875 return &port->port;
876 }
877
878 static int isicom_open(struct tty_struct *tty, struct file *filp)
879 {
880 struct isi_port *port;
881 struct isi_board *card;
882 struct tty_port *tport;
883 int error = 0;
884
885 tport = isicom_find_port(tty);
886 if (tport == NULL)
887 return -ENODEV;
888 port = container_of(tport, struct isi_port, port);
889 card = &isi_card[BOARD(tty->index)];
890 isicom_setup_board(card);
891
892 /* FIXME: locking on port.count etc */
893 port->port.count++;
894 tty->driver_data = port;
895 tty_port_tty_set(&port->port, tty);
896 /* FIXME: Locking on Initialized flag */
897 if (!test_bit(ASYNCB_INITIALIZED, &tport->flags))
898 error = isicom_setup_port(tty);
899 if (error == 0)
900 error = tty_port_block_til_ready(&port->port, tty, filp);
901 return error;
902 }
903
904 /* close et all */
905
906 static inline void isicom_shutdown_board(struct isi_board *bp)
907 {
908 if (bp->status & BOARD_ACTIVE)
909 bp->status &= ~BOARD_ACTIVE;
910 }
911
912 /* card->lock HAS to be held */
913 static void isicom_shutdown_port(struct isi_port *port)
914 {
915 struct isi_board *card = port->card;
916 struct tty_struct *tty;
917
918 tty = tty_port_tty_get(&port->port);
919
920 if (!(port->port.flags & ASYNC_INITIALIZED)) {
921 tty_kref_put(tty);
922 return;
923 }
924
925 tty_port_free_xmit_buf(&port->port);
926 port->port.flags &= ~ASYNC_INITIALIZED;
927 /* 3rd October 2000 : Vinayak P Risbud */
928 tty_port_tty_set(&port->port, NULL);
929
930 /*Fix done by Anil .S on 30-04-2001
931 remote login through isi port has dtr toggle problem
932 due to which the carrier drops before the password prompt
933 appears on the remote end. Now we drop the dtr only if the
934 HUPCL(Hangup on close) flag is set for the tty*/
935
936 if (C_HUPCL(tty))
937 /* drop dtr on this port */
938 drop_dtr(port);
939
940 /* any other port uninits */
941 if (tty)
942 set_bit(TTY_IO_ERROR, &tty->flags);
943
944 if (--card->count < 0) {
945 pr_debug("%s: bad board(0x%lx) count %d.\n",
946 __func__, card->base, card->count);
947 card->count = 0;
948 }
949
950 /* last port was closed, shutdown that boad too */
951 if (C_HUPCL(tty)) {
952 if (!card->count)
953 isicom_shutdown_board(card);
954 }
955 tty_kref_put(tty);
956 }
957
958 static void isicom_flush_buffer(struct tty_struct *tty)
959 {
960 struct isi_port *port = tty->driver_data;
961 struct isi_board *card = port->card;
962 unsigned long flags;
963
964 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
965 return;
966
967 spin_lock_irqsave(&card->card_lock, flags);
968 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
969 spin_unlock_irqrestore(&card->card_lock, flags);
970
971 tty_wakeup(tty);
972 }
973
974 static void isicom_close_port(struct tty_port *port)
975 {
976 struct isi_port *ip = container_of(port, struct isi_port, port);
977 struct isi_board *card = ip->card;
978 unsigned long flags;
979
980 /* indicate to the card that no more data can be received
981 on this port */
982 spin_lock_irqsave(&card->card_lock, flags);
983 if (port->flags & ASYNC_INITIALIZED) {
984 card->port_status &= ~(1 << ip->channel);
985 outw(card->port_status, card->base + 0x02);
986 }
987 isicom_shutdown_port(ip);
988 spin_unlock_irqrestore(&card->card_lock, flags);
989 }
990
991 static void isicom_close(struct tty_struct *tty, struct file *filp)
992 {
993 struct isi_port *ip = tty->driver_data;
994 struct tty_port *port = &ip->port;
995 if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
996 return;
997
998 if (tty_port_close_start(port, tty, filp) == 0)
999 return;
1000 isicom_close_port(port);
1001 isicom_flush_buffer(tty);
1002 tty_port_close_end(port, tty);
1003 }
1004
1005 /* write et all */
1006 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1007 int count)
1008 {
1009 struct isi_port *port = tty->driver_data;
1010 struct isi_board *card = port->card;
1011 unsigned long flags;
1012 int cnt, total = 0;
1013
1014 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1015 return 0;
1016
1017 spin_lock_irqsave(&card->card_lock, flags);
1018
1019 while (1) {
1020 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
1021 - 1, SERIAL_XMIT_SIZE - port->xmit_head));
1022 if (cnt <= 0)
1023 break;
1024
1025 memcpy(port->port.xmit_buf + port->xmit_head, buf, cnt);
1026 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
1027 - 1);
1028 port->xmit_cnt += cnt;
1029 buf += cnt;
1030 count -= cnt;
1031 total += cnt;
1032 }
1033 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1034 port->status |= ISI_TXOK;
1035 spin_unlock_irqrestore(&card->card_lock, flags);
1036 return total;
1037 }
1038
1039 /* put_char et all */
1040 static int isicom_put_char(struct tty_struct *tty, unsigned char ch)
1041 {
1042 struct isi_port *port = tty->driver_data;
1043 struct isi_board *card = port->card;
1044 unsigned long flags;
1045
1046 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1047 return 0;
1048
1049 spin_lock_irqsave(&card->card_lock, flags);
1050 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1051 spin_unlock_irqrestore(&card->card_lock, flags);
1052 return 0;
1053 }
1054
1055 port->port.xmit_buf[port->xmit_head++] = ch;
1056 port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
1057 port->xmit_cnt++;
1058 spin_unlock_irqrestore(&card->card_lock, flags);
1059 return 1;
1060 }
1061
1062 /* flush_chars et all */
1063 static void isicom_flush_chars(struct tty_struct *tty)
1064 {
1065 struct isi_port *port = tty->driver_data;
1066
1067 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1068 return;
1069
1070 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1071 !port->port.xmit_buf)
1072 return;
1073
1074 /* this tells the transmitter to consider this port for
1075 data output to the card ... that's the best we can do. */
1076 port->status |= ISI_TXOK;
1077 }
1078
1079 /* write_room et all */
1080 static int isicom_write_room(struct tty_struct *tty)
1081 {
1082 struct isi_port *port = tty->driver_data;
1083 int free;
1084
1085 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1086 return 0;
1087
1088 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1089 if (free < 0)
1090 free = 0;
1091 return free;
1092 }
1093
1094 /* chars_in_buffer et all */
1095 static int isicom_chars_in_buffer(struct tty_struct *tty)
1096 {
1097 struct isi_port *port = tty->driver_data;
1098 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1099 return 0;
1100 return port->xmit_cnt;
1101 }
1102
1103 /* ioctl et all */
1104 static int isicom_send_break(struct tty_struct *tty, int length)
1105 {
1106 struct isi_port *port = tty->driver_data;
1107 struct isi_board *card = port->card;
1108 unsigned long base = card->base;
1109
1110 if (length == -1)
1111 return -EOPNOTSUPP;
1112
1113 if (!lock_card(card))
1114 return -EINVAL;
1115
1116 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1117 outw((length & 0xff) << 8 | 0x00, base);
1118 outw((length & 0xff00), base);
1119 InterruptTheCard(base);
1120
1121 unlock_card(card);
1122 return 0;
1123 }
1124
1125 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1126 {
1127 struct isi_port *port = tty->driver_data;
1128 /* just send the port status */
1129 u16 status = port->status;
1130
1131 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1132 return -ENODEV;
1133
1134 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1135 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1136 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1137 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1138 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1139 ((status & ISI_RI ) ? TIOCM_RI : 0);
1140 }
1141
1142 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1143 unsigned int set, unsigned int clear)
1144 {
1145 struct isi_port *port = tty->driver_data;
1146 unsigned long flags;
1147
1148 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1149 return -ENODEV;
1150
1151 spin_lock_irqsave(&port->card->card_lock, flags);
1152 if (set & TIOCM_RTS)
1153 raise_rts(port);
1154 if (set & TIOCM_DTR)
1155 raise_dtr(port);
1156
1157 if (clear & TIOCM_RTS)
1158 drop_rts(port);
1159 if (clear & TIOCM_DTR)
1160 drop_dtr(port);
1161 spin_unlock_irqrestore(&port->card->card_lock, flags);
1162
1163 return 0;
1164 }
1165
1166 static int isicom_set_serial_info(struct tty_struct *tty,
1167 struct serial_struct __user *info)
1168 {
1169 struct isi_port *port = tty->driver_data;
1170 struct serial_struct newinfo;
1171 int reconfig_port;
1172
1173 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1174 return -EFAULT;
1175
1176 lock_kernel();
1177
1178 reconfig_port = ((port->port.flags & ASYNC_SPD_MASK) !=
1179 (newinfo.flags & ASYNC_SPD_MASK));
1180
1181 if (!capable(CAP_SYS_ADMIN)) {
1182 if ((newinfo.close_delay != port->port.close_delay) ||
1183 (newinfo.closing_wait != port->port.closing_wait) ||
1184 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1185 (port->port.flags & ~ASYNC_USR_MASK))) {
1186 unlock_kernel();
1187 return -EPERM;
1188 }
1189 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1190 (newinfo.flags & ASYNC_USR_MASK));
1191 } else {
1192 port->port.close_delay = newinfo.close_delay;
1193 port->port.closing_wait = newinfo.closing_wait;
1194 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1195 (newinfo.flags & ASYNC_FLAGS));
1196 }
1197 if (reconfig_port) {
1198 unsigned long flags;
1199 spin_lock_irqsave(&port->card->card_lock, flags);
1200 isicom_config_port(tty);
1201 spin_unlock_irqrestore(&port->card->card_lock, flags);
1202 }
1203 unlock_kernel();
1204 return 0;
1205 }
1206
1207 static int isicom_get_serial_info(struct isi_port *port,
1208 struct serial_struct __user *info)
1209 {
1210 struct serial_struct out_info;
1211
1212 lock_kernel();
1213 memset(&out_info, 0, sizeof(out_info));
1214 /* out_info.type = ? */
1215 out_info.line = port - isi_ports;
1216 out_info.port = port->card->base;
1217 out_info.irq = port->card->irq;
1218 out_info.flags = port->port.flags;
1219 /* out_info.baud_base = ? */
1220 out_info.close_delay = port->port.close_delay;
1221 out_info.closing_wait = port->port.closing_wait;
1222 unlock_kernel();
1223 if (copy_to_user(info, &out_info, sizeof(out_info)))
1224 return -EFAULT;
1225 return 0;
1226 }
1227
1228 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1229 unsigned int cmd, unsigned long arg)
1230 {
1231 struct isi_port *port = tty->driver_data;
1232 void __user *argp = (void __user *)arg;
1233
1234 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1235 return -ENODEV;
1236
1237 switch (cmd) {
1238 case TIOCGSERIAL:
1239 return isicom_get_serial_info(port, argp);
1240
1241 case TIOCSSERIAL:
1242 return isicom_set_serial_info(tty, argp);
1243
1244 default:
1245 return -ENOIOCTLCMD;
1246 }
1247 return 0;
1248 }
1249
1250 /* set_termios et all */
1251 static void isicom_set_termios(struct tty_struct *tty,
1252 struct ktermios *old_termios)
1253 {
1254 struct isi_port *port = tty->driver_data;
1255 unsigned long flags;
1256
1257 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1258 return;
1259
1260 if (tty->termios->c_cflag == old_termios->c_cflag &&
1261 tty->termios->c_iflag == old_termios->c_iflag)
1262 return;
1263
1264 spin_lock_irqsave(&port->card->card_lock, flags);
1265 isicom_config_port(tty);
1266 spin_unlock_irqrestore(&port->card->card_lock, flags);
1267
1268 if ((old_termios->c_cflag & CRTSCTS) &&
1269 !(tty->termios->c_cflag & CRTSCTS)) {
1270 tty->hw_stopped = 0;
1271 isicom_start(tty);
1272 }
1273 }
1274
1275 /* throttle et all */
1276 static void isicom_throttle(struct tty_struct *tty)
1277 {
1278 struct isi_port *port = tty->driver_data;
1279 struct isi_board *card = port->card;
1280
1281 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1282 return;
1283
1284 /* tell the card that this port cannot handle any more data for now */
1285 card->port_status &= ~(1 << port->channel);
1286 outw(card->port_status, card->base + 0x02);
1287 }
1288
1289 /* unthrottle et all */
1290 static void isicom_unthrottle(struct tty_struct *tty)
1291 {
1292 struct isi_port *port = tty->driver_data;
1293 struct isi_board *card = port->card;
1294
1295 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1296 return;
1297
1298 /* tell the card that this port is ready to accept more data */
1299 card->port_status |= (1 << port->channel);
1300 outw(card->port_status, card->base + 0x02);
1301 }
1302
1303 /* stop et all */
1304 static void isicom_stop(struct tty_struct *tty)
1305 {
1306 struct isi_port *port = tty->driver_data;
1307
1308 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1309 return;
1310
1311 /* this tells the transmitter not to consider this port for
1312 data output to the card. */
1313 port->status &= ~ISI_TXOK;
1314 }
1315
1316 /* start et all */
1317 static void isicom_start(struct tty_struct *tty)
1318 {
1319 struct isi_port *port = tty->driver_data;
1320
1321 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1322 return;
1323
1324 /* this tells the transmitter to consider this port for
1325 data output to the card. */
1326 port->status |= ISI_TXOK;
1327 }
1328
1329 static void isicom_hangup(struct tty_struct *tty)
1330 {
1331 struct isi_port *port = tty->driver_data;
1332 unsigned long flags;
1333
1334 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1335 return;
1336
1337 spin_lock_irqsave(&port->card->card_lock, flags);
1338 isicom_shutdown_port(port);
1339 spin_unlock_irqrestore(&port->card->card_lock, flags);
1340
1341 tty_port_hangup(&port->port);
1342 }
1343
1344
1345 /*
1346 * Driver init and deinit functions
1347 */
1348
1349 static const struct tty_operations isicom_ops = {
1350 .open = isicom_open,
1351 .close = isicom_close,
1352 .write = isicom_write,
1353 .put_char = isicom_put_char,
1354 .flush_chars = isicom_flush_chars,
1355 .write_room = isicom_write_room,
1356 .chars_in_buffer = isicom_chars_in_buffer,
1357 .ioctl = isicom_ioctl,
1358 .set_termios = isicom_set_termios,
1359 .throttle = isicom_throttle,
1360 .unthrottle = isicom_unthrottle,
1361 .stop = isicom_stop,
1362 .start = isicom_start,
1363 .hangup = isicom_hangup,
1364 .flush_buffer = isicom_flush_buffer,
1365 .tiocmget = isicom_tiocmget,
1366 .tiocmset = isicom_tiocmset,
1367 .break_ctl = isicom_send_break,
1368 };
1369
1370 static const struct tty_port_operations isicom_port_ops = {
1371 .carrier_raised = isicom_carrier_raised,
1372 .dtr_rts = isicom_dtr_rts,
1373 };
1374
1375 static int __devinit reset_card(struct pci_dev *pdev,
1376 const unsigned int card, unsigned int *signature)
1377 {
1378 struct isi_board *board = pci_get_drvdata(pdev);
1379 unsigned long base = board->base;
1380 unsigned int sig, portcount = 0;
1381 int retval = 0;
1382
1383 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1384 base);
1385
1386 inw(base + 0x8);
1387
1388 msleep(10);
1389
1390 outw(0, base + 0x8); /* Reset */
1391
1392 msleep(1000);
1393
1394 sig = inw(base + 0x4) & 0xff;
1395
1396 if (sig != 0xa5 && sig != 0xbb && sig != 0xcc && sig != 0xdd &&
1397 sig != 0xee) {
1398 dev_warn(&pdev->dev, "ISILoad:Card%u reset failure (Possible "
1399 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1400 dev_dbg(&pdev->dev, "Sig=0x%x\n", sig);
1401 retval = -EIO;
1402 goto end;
1403 }
1404
1405 msleep(10);
1406
1407 portcount = inw(base + 0x2);
1408 if (!(inw(base + 0xe) & 0x1) || (portcount != 0 && portcount != 4 &&
1409 portcount != 8 && portcount != 16)) {
1410 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure.\n",
1411 card + 1);
1412 retval = -EIO;
1413 goto end;
1414 }
1415
1416 switch (sig) {
1417 case 0xa5:
1418 case 0xbb:
1419 case 0xdd:
1420 board->port_count = (portcount == 4) ? 4 : 8;
1421 board->shift_count = 12;
1422 break;
1423 case 0xcc:
1424 case 0xee:
1425 board->port_count = 16;
1426 board->shift_count = 11;
1427 break;
1428 }
1429 dev_info(&pdev->dev, "-Done\n");
1430 *signature = sig;
1431
1432 end:
1433 return retval;
1434 }
1435
1436 static int __devinit load_firmware(struct pci_dev *pdev,
1437 const unsigned int index, const unsigned int signature)
1438 {
1439 struct isi_board *board = pci_get_drvdata(pdev);
1440 const struct firmware *fw;
1441 unsigned long base = board->base;
1442 unsigned int a;
1443 u16 word_count, status;
1444 int retval = -EIO;
1445 char *name;
1446 u8 *data;
1447
1448 struct stframe {
1449 u16 addr;
1450 u16 count;
1451 u8 data[0];
1452 } *frame;
1453
1454 switch (signature) {
1455 case 0xa5:
1456 name = "isi608.bin";
1457 break;
1458 case 0xbb:
1459 name = "isi608em.bin";
1460 break;
1461 case 0xcc:
1462 name = "isi616em.bin";
1463 break;
1464 case 0xdd:
1465 name = "isi4608.bin";
1466 break;
1467 case 0xee:
1468 name = "isi4616.bin";
1469 break;
1470 default:
1471 dev_err(&pdev->dev, "Unknown signature.\n");
1472 goto end;
1473 }
1474
1475 retval = request_firmware(&fw, name, &pdev->dev);
1476 if (retval)
1477 goto end;
1478
1479 retval = -EIO;
1480
1481 for (frame = (struct stframe *)fw->data;
1482 frame < (struct stframe *)(fw->data + fw->size);
1483 frame = (struct stframe *)((u8 *)(frame + 1) +
1484 frame->count)) {
1485 if (WaitTillCardIsFree(base))
1486 goto errrelfw;
1487
1488 outw(0xf0, base); /* start upload sequence */
1489 outw(0x00, base);
1490 outw(frame->addr, base); /* lsb of address */
1491
1492 word_count = frame->count / 2 + frame->count % 2;
1493 outw(word_count, base);
1494 InterruptTheCard(base);
1495
1496 udelay(100); /* 0x2f */
1497
1498 if (WaitTillCardIsFree(base))
1499 goto errrelfw;
1500
1501 status = inw(base + 0x4);
1502 if (status != 0) {
1503 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1504 "Address:0x%x\n"
1505 "Count:0x%x\n"
1506 "Status:0x%x\n",
1507 index + 1, frame->addr, frame->count, status);
1508 goto errrelfw;
1509 }
1510 outsw(base, frame->data, word_count);
1511
1512 InterruptTheCard(base);
1513
1514 udelay(50); /* 0x0f */
1515
1516 if (WaitTillCardIsFree(base))
1517 goto errrelfw;
1518
1519 status = inw(base + 0x4);
1520 if (status != 0) {
1521 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1522 "Status:0x%x\n", index + 1, status);
1523 goto errrelfw;
1524 }
1525 }
1526
1527 /* XXX: should we test it by reading it back and comparing with original like
1528 * in load firmware package? */
1529 for (frame = (struct stframe *)fw->data;
1530 frame < (struct stframe *)(fw->data + fw->size);
1531 frame = (struct stframe *)((u8 *)(frame + 1) +
1532 frame->count)) {
1533 if (WaitTillCardIsFree(base))
1534 goto errrelfw;
1535
1536 outw(0xf1, base); /* start download sequence */
1537 outw(0x00, base);
1538 outw(frame->addr, base); /* lsb of address */
1539
1540 word_count = (frame->count >> 1) + frame->count % 2;
1541 outw(word_count + 1, base);
1542 InterruptTheCard(base);
1543
1544 udelay(50); /* 0xf */
1545
1546 if (WaitTillCardIsFree(base))
1547 goto errrelfw;
1548
1549 status = inw(base + 0x4);
1550 if (status != 0) {
1551 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1552 "Address:0x%x\n"
1553 "Count:0x%x\n"
1554 "Status: 0x%x\n",
1555 index + 1, frame->addr, frame->count, status);
1556 goto errrelfw;
1557 }
1558
1559 data = kmalloc(word_count * 2, GFP_KERNEL);
1560 if (data == NULL) {
1561 dev_err(&pdev->dev, "Card%d, firmware upload "
1562 "failed, not enough memory\n", index + 1);
1563 goto errrelfw;
1564 }
1565 inw(base);
1566 insw(base, data, word_count);
1567 InterruptTheCard(base);
1568
1569 for (a = 0; a < frame->count; a++)
1570 if (data[a] != frame->data[a]) {
1571 kfree(data);
1572 dev_err(&pdev->dev, "Card%d, firmware upload "
1573 "failed\n", index + 1);
1574 goto errrelfw;
1575 }
1576 kfree(data);
1577
1578 udelay(50); /* 0xf */
1579
1580 if (WaitTillCardIsFree(base))
1581 goto errrelfw;
1582
1583 status = inw(base + 0x4);
1584 if (status != 0) {
1585 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1586 "Card Status:0x%x\n", index + 1, status);
1587 goto errrelfw;
1588 }
1589 }
1590
1591 /* xfer ctrl */
1592 if (WaitTillCardIsFree(base))
1593 goto errrelfw;
1594
1595 outw(0xf2, base);
1596 outw(0x800, base);
1597 outw(0x0, base);
1598 outw(0x0, base);
1599 InterruptTheCard(base);
1600 outw(0x0, base + 0x4); /* for ISI4608 cards */
1601
1602 board->status |= FIRMWARE_LOADED;
1603 retval = 0;
1604
1605 errrelfw:
1606 release_firmware(fw);
1607 end:
1608 return retval;
1609 }
1610
1611 /*
1612 * Insmod can set static symbols so keep these static
1613 */
1614 static unsigned int card_count;
1615
1616 static int __devinit isicom_probe(struct pci_dev *pdev,
1617 const struct pci_device_id *ent)
1618 {
1619 unsigned int uninitialized_var(signature), index;
1620 int retval = -EPERM;
1621 struct isi_board *board = NULL;
1622
1623 if (card_count >= BOARD_COUNT)
1624 goto err;
1625
1626 retval = pci_enable_device(pdev);
1627 if (retval) {
1628 dev_err(&pdev->dev, "failed to enable\n");
1629 goto err;
1630 }
1631
1632 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1633
1634 /* allot the first empty slot in the array */
1635 for (index = 0; index < BOARD_COUNT; index++)
1636 if (isi_card[index].base == 0) {
1637 board = &isi_card[index];
1638 break;
1639 }
1640
1641 board->index = index;
1642 board->base = pci_resource_start(pdev, 3);
1643 board->irq = pdev->irq;
1644 card_count++;
1645
1646 pci_set_drvdata(pdev, board);
1647
1648 retval = pci_request_region(pdev, 3, ISICOM_NAME);
1649 if (retval) {
1650 dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1651 "will be disabled.\n", board->base, board->base + 15,
1652 index + 1);
1653 retval = -EBUSY;
1654 goto errdec;
1655 }
1656
1657 retval = request_irq(board->irq, isicom_interrupt,
1658 IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
1659 if (retval < 0) {
1660 dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1661 "Card%d will be disabled.\n", board->irq, index + 1);
1662 goto errunrr;
1663 }
1664
1665 retval = reset_card(pdev, index, &signature);
1666 if (retval < 0)
1667 goto errunri;
1668
1669 retval = load_firmware(pdev, index, signature);
1670 if (retval < 0)
1671 goto errunri;
1672
1673 for (index = 0; index < board->port_count; index++)
1674 tty_register_device(isicom_normal, board->index * 16 + index,
1675 &pdev->dev);
1676
1677 return 0;
1678
1679 errunri:
1680 free_irq(board->irq, board);
1681 errunrr:
1682 pci_release_region(pdev, 3);
1683 errdec:
1684 board->base = 0;
1685 card_count--;
1686 pci_disable_device(pdev);
1687 err:
1688 return retval;
1689 }
1690
1691 static void __devexit isicom_remove(struct pci_dev *pdev)
1692 {
1693 struct isi_board *board = pci_get_drvdata(pdev);
1694 unsigned int i;
1695
1696 for (i = 0; i < board->port_count; i++)
1697 tty_unregister_device(isicom_normal, board->index * 16 + i);
1698
1699 free_irq(board->irq, board);
1700 pci_release_region(pdev, 3);
1701 board->base = 0;
1702 card_count--;
1703 pci_disable_device(pdev);
1704 }
1705
1706 static int __init isicom_init(void)
1707 {
1708 int retval, idx, channel;
1709 struct isi_port *port;
1710
1711 for (idx = 0; idx < BOARD_COUNT; idx++) {
1712 port = &isi_ports[idx * 16];
1713 isi_card[idx].ports = port;
1714 spin_lock_init(&isi_card[idx].card_lock);
1715 for (channel = 0; channel < 16; channel++, port++) {
1716 tty_port_init(&port->port);
1717 port->port.ops = &isicom_port_ops;
1718 port->magic = ISICOM_MAGIC;
1719 port->card = &isi_card[idx];
1720 port->channel = channel;
1721 port->port.close_delay = 50 * HZ/100;
1722 port->port.closing_wait = 3000 * HZ/100;
1723 port->status = 0;
1724 /* . . . */
1725 }
1726 isi_card[idx].base = 0;
1727 isi_card[idx].irq = 0;
1728 }
1729
1730 /* tty driver structure initialization */
1731 isicom_normal = alloc_tty_driver(PORT_COUNT);
1732 if (!isicom_normal) {
1733 retval = -ENOMEM;
1734 goto error;
1735 }
1736
1737 isicom_normal->owner = THIS_MODULE;
1738 isicom_normal->name = "ttyM";
1739 isicom_normal->major = ISICOM_NMAJOR;
1740 isicom_normal->minor_start = 0;
1741 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1742 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1743 isicom_normal->init_termios = tty_std_termios;
1744 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1745 CLOCAL;
1746 isicom_normal->flags = TTY_DRIVER_REAL_RAW |
1747 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK;
1748 tty_set_operations(isicom_normal, &isicom_ops);
1749
1750 retval = tty_register_driver(isicom_normal);
1751 if (retval) {
1752 pr_debug("Couldn't register the dialin driver\n");
1753 goto err_puttty;
1754 }
1755
1756 retval = pci_register_driver(&isicom_driver);
1757 if (retval < 0) {
1758 pr_err("Unable to register pci driver.\n");
1759 goto err_unrtty;
1760 }
1761
1762 mod_timer(&tx, jiffies + 1);
1763
1764 return 0;
1765 err_unrtty:
1766 tty_unregister_driver(isicom_normal);
1767 err_puttty:
1768 put_tty_driver(isicom_normal);
1769 error:
1770 return retval;
1771 }
1772
1773 static void __exit isicom_exit(void)
1774 {
1775 del_timer_sync(&tx);
1776
1777 pci_unregister_driver(&isicom_driver);
1778 tty_unregister_driver(isicom_normal);
1779 put_tty_driver(isicom_normal);
1780 }
1781
1782 module_init(isicom_init);
1783 module_exit(isicom_exit);
1784
1785 MODULE_AUTHOR("MultiTech");
1786 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1787 MODULE_LICENSE("GPL");
mm of the moment repository