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