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