projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
riscom8: remove bogus checks
[deliverable/linux.git] / drivers / char / isicom.c
1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License
4 * as published by the Free Software Foundation; either version
5 * 2 of the License, or (at your option) any later version.
6 *
7 * Original driver code supplied by Multi-Tech
8 *
9 * Changes
10 * 1/9/98 alan@redhat.com Merge to 2.0.x kernel tree
11 * Obtain and use official major/minors
12 * Loader switched to a misc device
13 * (fixed range check bug as a side effect)
14 * Printk clean up
15 * 9/12/98 alan@redhat.com Rough port to 2.1.x
16 *
17 * 10/6/99 sameer Merged the ISA and PCI drivers to
18 * a new unified driver.
19 *
20 * 3/9/99 sameer Added support for ISI4616 cards.
21 *
22 * 16/9/99 sameer We do not force RTS low anymore.
23 * This is to prevent the firmware
24 * from getting confused.
25 *
26 * 26/10/99 sameer Cosmetic changes:The driver now
27 * dumps the Port Count information
28 * along with I/O address and IRQ.
29 *
30 * 13/12/99 sameer Fixed the problem with IRQ sharing.
31 *
32 * 10/5/00 sameer Fixed isicom_shutdown_board()
33 * to not lower DTR on all the ports
34 * when the last port on the card is
35 * closed.
36 *
37 * 10/5/00 sameer Signal mask setup command added
38 * to isicom_setup_port and
39 * isicom_shutdown_port.
40 *
41 * 24/5/00 sameer The driver is now SMP aware.
42 *
43 *
44 * 27/11/00 Vinayak P Risbud Fixed the Driver Crash Problem
45 *
46 *
47 * 03/01/01 anil .s Added support for resetting the
48 * internal modems on ISI cards.
49 *
50 * 08/02/01 anil .s Upgraded the driver for kernel
51 * 2.4.x
52 *
53 * 11/04/01 Kevin Fixed firmware load problem with
54 * ISIHP-4X card
55 *
56 * 30/04/01 anil .s Fixed the remote login through
57 * ISI port problem. Now the link
58 * does not go down before password
59 * prompt.
60 *
61 * 03/05/01 anil .s Fixed the problem with IRQ sharing
62 * among ISI-PCI cards.
63 *
64 * 03/05/01 anil .s Added support to display the version
65 * info during insmod as well as module
66 * listing by lsmod.
67 *
68 * 10/05/01 anil .s Done the modifications to the source
69 * file and Install script so that the
70 * same installation can be used for
71 * 2.2.x and 2.4.x kernel.
72 *
73 * 06/06/01 anil .s Now we drop both dtr and rts during
74 * shutdown_port as well as raise them
75 * during isicom_config_port.
76 *
77 * 09/06/01 acme@conectiva.com.br use capable, not suser, do
78 * restore_flags on failure in
79 * isicom_send_break, verify put_user
80 * result
81 *
82 * 11/02/03 ranjeeth Added support for 230 Kbps and 460 Kbps
83 * Baud index extended to 21
84 *
85 * 20/03/03 ranjeeth Made to work for Linux Advanced server.
86 * Taken care of license warning.
87 *
88 * 10/12/03 Ravindra Made to work for Fedora Core 1 of
89 * Red Hat Distribution
90 *
91 * 06/01/05 Alan Cox Merged the ISI and base kernel strands
92 * into a single 2.6 driver
93 *
94 * ***********************************************************
95 *
96 * To use this driver you also need the support package. You
97 * can find this in RPM format on
98 * ftp://ftp.linux.org.uk/pub/linux/alan
99 *
100 * You can find the original tools for this direct from Multitech
101 * ftp://ftp.multitech.com/ISI-Cards/
102 *
103 * Having installed the cards the module options (/etc/modprobe.conf)
104 *
105 * options isicom io=card1,card2,card3,card4 irq=card1,card2,card3,card4
106 *
107 * Omit those entries for boards you don't have installed.
108 *
109 * TODO
110 * Merge testing
111 * 64-bit verification
112 */
113
114 #include <linux/module.h>
115 #include <linux/firmware.h>
116 #include <linux/kernel.h>
117 #include <linux/tty.h>
118 #include <linux/tty_flip.h>
119 #include <linux/termios.h>
120 #include <linux/fs.h>
121 #include <linux/sched.h>
122 #include <linux/serial.h>
123 #include <linux/mm.h>
124 #include <linux/interrupt.h>
125 #include <linux/timer.h>
126 #include <linux/delay.h>
127 #include <linux/ioport.h>
128
129 #include <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 unsigned long page = get_zeroed_page(GFP_KERNEL);
817 if (page == 0)
818 return -ENOMEM;
819 if (port->xmit_buf)
820 free_page(page);
821 else
822 port->xmit_buf = (unsigned char *) page;
823 }
824
825 spin_lock_irqsave(&card->card_lock, flags);
826 if (port->tty)
827 clear_bit(TTY_IO_ERROR, &port->tty->flags);
828 if (port->count == 1)
829 card->count++;
830
831 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
832
833 /* discard any residual data */
834 if (WaitTillCardIsFree(card->base) == 0) {
835 outw(0x8000 | (port->channel << card->shift_count) | 0x02,
836 card->base);
837 outw(((ISICOM_KILLTX | ISICOM_KILLRX) << 8) | 0x06, card->base);
838 InterruptTheCard(card->base);
839 }
840
841 isicom_config_port(port);
842 port->flags |= ASYNC_INITIALIZED;
843 spin_unlock_irqrestore(&card->card_lock, flags);
844
845 return 0;
846 }
847
848 static int block_til_ready(struct tty_struct *tty, struct file *filp,
849 struct isi_port *port)
850 {
851 struct isi_board *card = port->card;
852 int do_clocal = 0, retval;
853 unsigned long flags;
854 DECLARE_WAITQUEUE(wait, current);
855
856 /* block if port is in the process of being closed */
857
858 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
859 pr_dbg("block_til_ready: close in progress.\n");
860 interruptible_sleep_on(&port->close_wait);
861 if (port->flags & ASYNC_HUP_NOTIFY)
862 return -EAGAIN;
863 else
864 return -ERESTARTSYS;
865 }
866
867 /* if non-blocking mode is set ... */
868
869 if ((filp->f_flags & O_NONBLOCK) ||
870 (tty->flags & (1 << TTY_IO_ERROR))) {
871 pr_dbg("block_til_ready: non-block mode.\n");
872 port->flags |= ASYNC_NORMAL_ACTIVE;
873 return 0;
874 }
875
876 if (C_CLOCAL(tty))
877 do_clocal = 1;
878
879 /* block waiting for DCD to be asserted, and while
880 callout dev is busy */
881 retval = 0;
882 add_wait_queue(&port->open_wait, &wait);
883
884 spin_lock_irqsave(&card->card_lock, flags);
885 if (!tty_hung_up_p(filp))
886 port->count--;
887 port->blocked_open++;
888 spin_unlock_irqrestore(&card->card_lock, flags);
889
890 while (1) {
891 raise_dtr_rts(port);
892
893 set_current_state(TASK_INTERRUPTIBLE);
894 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
895 if (port->flags & ASYNC_HUP_NOTIFY)
896 retval = -EAGAIN;
897 else
898 retval = -ERESTARTSYS;
899 break;
900 }
901 if (!(port->flags & ASYNC_CLOSING) &&
902 (do_clocal || (port->status & ISI_DCD))) {
903 break;
904 }
905 if (signal_pending(current)) {
906 retval = -ERESTARTSYS;
907 break;
908 }
909 schedule();
910 }
911 set_current_state(TASK_RUNNING);
912 remove_wait_queue(&port->open_wait, &wait);
913 spin_lock_irqsave(&card->card_lock, flags);
914 if (!tty_hung_up_p(filp))
915 port->count++;
916 port->blocked_open--;
917 spin_unlock_irqrestore(&card->card_lock, flags);
918 if (retval)
919 return retval;
920 port->flags |= ASYNC_NORMAL_ACTIVE;
921 return 0;
922 }
923
924 static int isicom_open(struct tty_struct *tty, struct file *filp)
925 {
926 struct isi_port *port;
927 struct isi_board *card;
928 unsigned int board;
929 int error, line;
930
931 line = tty->index;
932 if (line < 0 || line > PORT_COUNT-1)
933 return -ENODEV;
934 board = BOARD(line);
935 card = &isi_card[board];
936
937 if (!(card->status & FIRMWARE_LOADED))
938 return -ENODEV;
939
940 /* open on a port greater than the port count for the card !!! */
941 if (line > ((board * 16) + card->port_count - 1))
942 return -ENODEV;
943
944 port = &isi_ports[line];
945 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
946 return -ENODEV;
947
948 isicom_setup_board(card);
949
950 port->count++;
951 tty->driver_data = port;
952 port->tty = tty;
953 error = isicom_setup_port(port);
954 if (error == 0)
955 error = block_til_ready(tty, filp, port);
956 return error;
957 }
958
959 /* close et all */
960
961 static inline void isicom_shutdown_board(struct isi_board *bp)
962 {
963 if (bp->status & BOARD_ACTIVE)
964 bp->status &= ~BOARD_ACTIVE;
965 }
966
967 /* card->lock HAS to be held */
968 static void isicom_shutdown_port(struct isi_port *port)
969 {
970 struct isi_board *card = port->card;
971 struct tty_struct *tty;
972
973 tty = port->tty;
974
975 if (!(port->flags & ASYNC_INITIALIZED))
976 return;
977
978 if (port->xmit_buf) {
979 free_page((unsigned long) port->xmit_buf);
980 port->xmit_buf = NULL;
981 }
982 port->flags &= ~ASYNC_INITIALIZED;
983 /* 3rd October 2000 : Vinayak P Risbud */
984 port->tty = NULL;
985
986 /*Fix done by Anil .S on 30-04-2001
987 remote login through isi port has dtr toggle problem
988 due to which the carrier drops before the password prompt
989 appears on the remote end. Now we drop the dtr only if the
990 HUPCL(Hangup on close) flag is set for the tty*/
991
992 if (C_HUPCL(tty))
993 /* drop dtr on this port */
994 drop_dtr(port);
995
996 /* any other port uninits */
997 if (tty)
998 set_bit(TTY_IO_ERROR, &tty->flags);
999
1000 if (--card->count < 0) {
1001 pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
1002 card->base, card->count);
1003 card->count = 0;
1004 }
1005
1006 /* last port was closed, shutdown that boad too */
1007 if (C_HUPCL(tty)) {
1008 if (!card->count)
1009 isicom_shutdown_board(card);
1010 }
1011 }
1012
1013 static void isicom_flush_buffer(struct tty_struct *tty)
1014 {
1015 struct isi_port *port = tty->driver_data;
1016 struct isi_board *card = port->card;
1017 unsigned long flags;
1018
1019 if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
1020 return;
1021
1022 spin_lock_irqsave(&card->card_lock, flags);
1023 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1024 spin_unlock_irqrestore(&card->card_lock, flags);
1025
1026 tty_wakeup(tty);
1027 }
1028
1029 static void isicom_close(struct tty_struct *tty, struct file *filp)
1030 {
1031 struct isi_port *port = tty->driver_data;
1032 struct isi_board *card;
1033 unsigned long flags;
1034
1035 if (!port)
1036 return;
1037 card = port->card;
1038 if (isicom_paranoia_check(port, tty->name, "isicom_close"))
1039 return;
1040
1041 pr_dbg("Close start!!!.\n");
1042
1043 spin_lock_irqsave(&card->card_lock, flags);
1044 if (tty_hung_up_p(filp)) {
1045 spin_unlock_irqrestore(&card->card_lock, flags);
1046 return;
1047 }
1048
1049 if (tty->count == 1 && port->count != 1) {
1050 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1051 "count tty->count = 1 port count = %d.\n",
1052 card->base, port->count);
1053 port->count = 1;
1054 }
1055 if (--port->count < 0) {
1056 printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
1057 "count for channel%d = %d", card->base, port->channel,
1058 port->count);
1059 port->count = 0;
1060 }
1061
1062 if (port->count) {
1063 spin_unlock_irqrestore(&card->card_lock, flags);
1064 return;
1065 }
1066 port->flags |= ASYNC_CLOSING;
1067 tty->closing = 1;
1068 spin_unlock_irqrestore(&card->card_lock, flags);
1069
1070 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1071 tty_wait_until_sent(tty, port->closing_wait);
1072 /* indicate to the card that no more data can be received
1073 on this port */
1074 spin_lock_irqsave(&card->card_lock, flags);
1075 if (port->flags & ASYNC_INITIALIZED) {
1076 card->port_status &= ~(1 << port->channel);
1077 outw(card->port_status, card->base + 0x02);
1078 }
1079 isicom_shutdown_port(port);
1080 spin_unlock_irqrestore(&card->card_lock, flags);
1081
1082 isicom_flush_buffer(tty);
1083 tty_ldisc_flush(tty);
1084
1085 spin_lock_irqsave(&card->card_lock, flags);
1086 tty->closing = 0;
1087
1088 if (port->blocked_open) {
1089 spin_unlock_irqrestore(&card->card_lock, flags);
1090 if (port->close_delay) {
1091 pr_dbg("scheduling until time out.\n");
1092 msleep_interruptible(
1093 jiffies_to_msecs(port->close_delay));
1094 }
1095 spin_lock_irqsave(&card->card_lock, flags);
1096 wake_up_interruptible(&port->open_wait);
1097 }
1098 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1099 wake_up_interruptible(&port->close_wait);
1100 spin_unlock_irqrestore(&card->card_lock, flags);
1101 }
1102
1103 /* write et all */
1104 static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
1105 int count)
1106 {
1107 struct isi_port *port = tty->driver_data;
1108 struct isi_board *card = port->card;
1109 unsigned long flags;
1110 int cnt, total = 0;
1111
1112 if (isicom_paranoia_check(port, tty->name, "isicom_write"))
1113 return 0;
1114
1115 if (!port->xmit_buf)
1116 return 0;
1117
1118 spin_lock_irqsave(&card->card_lock, flags);
1119
1120 while (1) {
1121 cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
1122 - 1, SERIAL_XMIT_SIZE - port->xmit_head));
1123 if (cnt <= 0)
1124 break;
1125
1126 memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
1127 port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
1128 - 1);
1129 port->xmit_cnt += cnt;
1130 buf += cnt;
1131 count -= cnt;
1132 total += cnt;
1133 }
1134 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1135 port->status |= ISI_TXOK;
1136 spin_unlock_irqrestore(&card->card_lock, flags);
1137 return total;
1138 }
1139
1140 /* put_char et all */
1141 static int isicom_put_char(struct tty_struct *tty, unsigned char ch)
1142 {
1143 struct isi_port *port = tty->driver_data;
1144 struct isi_board *card = port->card;
1145 unsigned long flags;
1146
1147 if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
1148 return 0;
1149
1150 if (!port->xmit_buf)
1151 return 0;
1152
1153 spin_lock_irqsave(&card->card_lock, flags);
1154 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1155 spin_unlock_irqrestore(&card->card_lock, flags);
1156 return 0;
1157 }
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 return 1;
1164 }
1165
1166 /* flush_chars et all */
1167 static void isicom_flush_chars(struct tty_struct *tty)
1168 {
1169 struct isi_port *port = tty->driver_data;
1170
1171 if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
1172 return;
1173
1174 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1175 !port->xmit_buf)
1176 return;
1177
1178 /* this tells the transmitter to consider this port for
1179 data output to the card ... that's the best we can do. */
1180 port->status |= ISI_TXOK;
1181 }
1182
1183 /* write_room et all */
1184 static int isicom_write_room(struct tty_struct *tty)
1185 {
1186 struct isi_port *port = tty->driver_data;
1187 int free;
1188
1189 if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1190 return 0;
1191
1192 free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1193 if (free < 0)
1194 free = 0;
1195 return free;
1196 }
1197
1198 /* chars_in_buffer et all */
1199 static int isicom_chars_in_buffer(struct tty_struct *tty)
1200 {
1201 struct isi_port *port = tty->driver_data;
1202 if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1203 return 0;
1204 return port->xmit_cnt;
1205 }
1206
1207 /* ioctl et all */
1208 static inline void isicom_send_break(struct isi_port *port,
1209 unsigned long length)
1210 {
1211 struct isi_board *card = port->card;
1212 unsigned long base = card->base;
1213
1214 if (!lock_card(card))
1215 return;
1216
1217 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1218 outw((length & 0xff) << 8 | 0x00, base);
1219 outw((length & 0xff00), base);
1220 InterruptTheCard(base);
1221
1222 unlock_card(card);
1223 }
1224
1225 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1226 {
1227 struct isi_port *port = tty->driver_data;
1228 /* just send the port status */
1229 u16 status = port->status;
1230
1231 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1232 return -ENODEV;
1233
1234 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1235 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1236 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1237 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1238 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1239 ((status & ISI_RI ) ? TIOCM_RI : 0);
1240 }
1241
1242 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1243 unsigned int set, unsigned int clear)
1244 {
1245 struct isi_port *port = tty->driver_data;
1246 unsigned long flags;
1247
1248 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1249 return -ENODEV;
1250
1251 spin_lock_irqsave(&port->card->card_lock, flags);
1252 if (set & TIOCM_RTS)
1253 raise_rts(port);
1254 if (set & TIOCM_DTR)
1255 raise_dtr(port);
1256
1257 if (clear & TIOCM_RTS)
1258 drop_rts(port);
1259 if (clear & TIOCM_DTR)
1260 drop_dtr(port);
1261 spin_unlock_irqrestore(&port->card->card_lock, flags);
1262
1263 return 0;
1264 }
1265
1266 static int isicom_set_serial_info(struct isi_port *port,
1267 struct serial_struct __user *info)
1268 {
1269 struct serial_struct newinfo;
1270 int reconfig_port;
1271
1272 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1273 return -EFAULT;
1274
1275 lock_kernel();
1276
1277 reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
1278 (newinfo.flags & ASYNC_SPD_MASK));
1279
1280 if (!capable(CAP_SYS_ADMIN)) {
1281 if ((newinfo.close_delay != port->close_delay) ||
1282 (newinfo.closing_wait != port->closing_wait) ||
1283 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1284 (port->flags & ~ASYNC_USR_MASK))) {
1285 unlock_kernel();
1286 return -EPERM;
1287 }
1288 port->flags = ((port->flags & ~ASYNC_USR_MASK) |
1289 (newinfo.flags & ASYNC_USR_MASK));
1290 } else {
1291 port->close_delay = newinfo.close_delay;
1292 port->closing_wait = newinfo.closing_wait;
1293 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1294 (newinfo.flags & ASYNC_FLAGS));
1295 }
1296 if (reconfig_port) {
1297 unsigned long flags;
1298 spin_lock_irqsave(&port->card->card_lock, flags);
1299 isicom_config_port(port);
1300 spin_unlock_irqrestore(&port->card->card_lock, flags);
1301 }
1302 unlock_kernel();
1303 return 0;
1304 }
1305
1306 static int isicom_get_serial_info(struct isi_port *port,
1307 struct serial_struct __user *info)
1308 {
1309 struct serial_struct out_info;
1310
1311 lock_kernel();
1312 memset(&out_info, 0, sizeof(out_info));
1313 /* out_info.type = ? */
1314 out_info.line = port - isi_ports;
1315 out_info.port = port->card->base;
1316 out_info.irq = port->card->irq;
1317 out_info.flags = port->flags;
1318 /* out_info.baud_base = ? */
1319 out_info.close_delay = port->close_delay;
1320 out_info.closing_wait = port->closing_wait;
1321 unlock_kernel();
1322 if (copy_to_user(info, &out_info, sizeof(out_info)))
1323 return -EFAULT;
1324 return 0;
1325 }
1326
1327 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1328 unsigned int cmd, unsigned long arg)
1329 {
1330 struct isi_port *port = tty->driver_data;
1331 void __user *argp = (void __user *)arg;
1332 int retval;
1333
1334 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1335 return -ENODEV;
1336
1337 switch (cmd) {
1338 case TCSBRK:
1339 retval = tty_check_change(tty);
1340 if (retval)
1341 return retval;
1342 tty_wait_until_sent(tty, 0);
1343 if (!arg)
1344 isicom_send_break(port, HZ/4);
1345 return 0;
1346
1347 case TCSBRKP:
1348 retval = tty_check_change(tty);
1349 if (retval)
1350 return retval;
1351 tty_wait_until_sent(tty, 0);
1352 isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
1353 return 0;
1354 case TIOCGSERIAL:
1355 return isicom_get_serial_info(port, argp);
1356
1357 case TIOCSSERIAL:
1358 return isicom_set_serial_info(port, argp);
1359
1360 default:
1361 return -ENOIOCTLCMD;
1362 }
1363 return 0;
1364 }
1365
1366 /* set_termios et all */
1367 static void isicom_set_termios(struct tty_struct *tty,
1368 struct ktermios *old_termios)
1369 {
1370 struct isi_port *port = tty->driver_data;
1371 unsigned long flags;
1372
1373 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1374 return;
1375
1376 if (tty->termios->c_cflag == old_termios->c_cflag &&
1377 tty->termios->c_iflag == old_termios->c_iflag)
1378 return;
1379
1380 spin_lock_irqsave(&port->card->card_lock, flags);
1381 isicom_config_port(port);
1382 spin_unlock_irqrestore(&port->card->card_lock, flags);
1383
1384 if ((old_termios->c_cflag & CRTSCTS) &&
1385 !(tty->termios->c_cflag & CRTSCTS)) {
1386 tty->hw_stopped = 0;
1387 isicom_start(tty);
1388 }
1389 }
1390
1391 /* throttle et all */
1392 static void isicom_throttle(struct tty_struct *tty)
1393 {
1394 struct isi_port *port = tty->driver_data;
1395 struct isi_board *card = port->card;
1396
1397 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1398 return;
1399
1400 /* tell the card that this port cannot handle any more data for now */
1401 card->port_status &= ~(1 << port->channel);
1402 outw(card->port_status, card->base + 0x02);
1403 }
1404
1405 /* unthrottle et all */
1406 static void isicom_unthrottle(struct tty_struct *tty)
1407 {
1408 struct isi_port *port = tty->driver_data;
1409 struct isi_board *card = port->card;
1410
1411 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1412 return;
1413
1414 /* tell the card that this port is ready to accept more data */
1415 card->port_status |= (1 << port->channel);
1416 outw(card->port_status, card->base + 0x02);
1417 }
1418
1419 /* stop et all */
1420 static void isicom_stop(struct tty_struct *tty)
1421 {
1422 struct isi_port *port = tty->driver_data;
1423
1424 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1425 return;
1426
1427 /* this tells the transmitter not to consider this port for
1428 data output to the card. */
1429 port->status &= ~ISI_TXOK;
1430 }
1431
1432 /* start et all */
1433 static void isicom_start(struct tty_struct *tty)
1434 {
1435 struct isi_port *port = tty->driver_data;
1436
1437 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1438 return;
1439
1440 /* this tells the transmitter to consider this port for
1441 data output to the card. */
1442 port->status |= ISI_TXOK;
1443 }
1444
1445 static void isicom_hangup(struct tty_struct *tty)
1446 {
1447 struct isi_port *port = tty->driver_data;
1448 unsigned long flags;
1449
1450 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1451 return;
1452
1453 spin_lock_irqsave(&port->card->card_lock, flags);
1454 isicom_shutdown_port(port);
1455 spin_unlock_irqrestore(&port->card->card_lock, flags);
1456
1457 port->count = 0;
1458 port->flags &= ~ASYNC_NORMAL_ACTIVE;
1459 port->tty = NULL;
1460 wake_up_interruptible(&port->open_wait);
1461 }
1462
1463
1464 /*
1465 * Driver init and deinit functions
1466 */
1467
1468 static const struct tty_operations isicom_ops = {
1469 .open = isicom_open,
1470 .close = isicom_close,
1471 .write = isicom_write,
1472 .put_char = isicom_put_char,
1473 .flush_chars = isicom_flush_chars,
1474 .write_room = isicom_write_room,
1475 .chars_in_buffer = isicom_chars_in_buffer,
1476 .ioctl = isicom_ioctl,
1477 .set_termios = isicom_set_termios,
1478 .throttle = isicom_throttle,
1479 .unthrottle = isicom_unthrottle,
1480 .stop = isicom_stop,
1481 .start = isicom_start,
1482 .hangup = isicom_hangup,
1483 .flush_buffer = isicom_flush_buffer,
1484 .tiocmget = isicom_tiocmget,
1485 .tiocmset = isicom_tiocmset,
1486 };
1487
1488 static int __devinit reset_card(struct pci_dev *pdev,
1489 const unsigned int card, unsigned int *signature)
1490 {
1491 struct isi_board *board = pci_get_drvdata(pdev);
1492 unsigned long base = board->base;
1493 unsigned int sig, portcount = 0;
1494 int retval = 0;
1495
1496 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1497 base);
1498
1499 inw(base + 0x8);
1500
1501 msleep(10);
1502
1503 outw(0, base + 0x8); /* Reset */
1504
1505 msleep(1000);
1506
1507 sig = inw(base + 0x4) & 0xff;
1508
1509 if (sig != 0xa5 && sig != 0xbb && sig != 0xcc && sig != 0xdd &&
1510 sig != 0xee) {
1511 dev_warn(&pdev->dev, "ISILoad:Card%u reset failure (Possible "
1512 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1513 dev_dbg(&pdev->dev, "Sig=0x%x\n", sig);
1514 retval = -EIO;
1515 goto end;
1516 }
1517
1518 msleep(10);
1519
1520 portcount = inw(base + 0x2);
1521 if (!(inw(base + 0xe) & 0x1) || (portcount != 0 && portcount != 4 &&
1522 portcount != 8 && portcount != 16)) {
1523 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure.\n",
1524 card + 1);
1525 retval = -EIO;
1526 goto end;
1527 }
1528
1529 switch (sig) {
1530 case 0xa5:
1531 case 0xbb:
1532 case 0xdd:
1533 board->port_count = (portcount == 4) ? 4 : 8;
1534 board->shift_count = 12;
1535 break;
1536 case 0xcc:
1537 case 0xee:
1538 board->port_count = 16;
1539 board->shift_count = 11;
1540 break;
1541 }
1542 dev_info(&pdev->dev, "-Done\n");
1543 *signature = sig;
1544
1545 end:
1546 return retval;
1547 }
1548
1549 static int __devinit load_firmware(struct pci_dev *pdev,
1550 const unsigned int index, const unsigned int signature)
1551 {
1552 struct isi_board *board = pci_get_drvdata(pdev);
1553 const struct firmware *fw;
1554 unsigned long base = board->base;
1555 unsigned int a;
1556 u16 word_count, status;
1557 int retval = -EIO;
1558 char *name;
1559 u8 *data;
1560
1561 struct stframe {
1562 u16 addr;
1563 u16 count;
1564 u8 data[0];
1565 } *frame;
1566
1567 switch (signature) {
1568 case 0xa5:
1569 name = "isi608.bin";
1570 break;
1571 case 0xbb:
1572 name = "isi608em.bin";
1573 break;
1574 case 0xcc:
1575 name = "isi616em.bin";
1576 break;
1577 case 0xdd:
1578 name = "isi4608.bin";
1579 break;
1580 case 0xee:
1581 name = "isi4616.bin";
1582 break;
1583 default:
1584 dev_err(&pdev->dev, "Unknown signature.\n");
1585 goto end;
1586 }
1587
1588 retval = request_firmware(&fw, name, &pdev->dev);
1589 if (retval)
1590 goto end;
1591
1592 retval = -EIO;
1593
1594 for (frame = (struct stframe *)fw->data;
1595 frame < (struct stframe *)(fw->data + fw->size);
1596 frame = (struct stframe *)((u8 *)(frame + 1) +
1597 frame->count)) {
1598 if (WaitTillCardIsFree(base))
1599 goto errrelfw;
1600
1601 outw(0xf0, base); /* start upload sequence */
1602 outw(0x00, base);
1603 outw(frame->addr, base); /* lsb of address */
1604
1605 word_count = frame->count / 2 + frame->count % 2;
1606 outw(word_count, base);
1607 InterruptTheCard(base);
1608
1609 udelay(100); /* 0x2f */
1610
1611 if (WaitTillCardIsFree(base))
1612 goto errrelfw;
1613
1614 status = inw(base + 0x4);
1615 if (status != 0) {
1616 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1617 KERN_WARNING "Address:0x%x\n"
1618 KERN_WARNING "Count:0x%x\n"
1619 KERN_WARNING "Status:0x%x\n",
1620 index + 1, frame->addr, frame->count, status);
1621 goto errrelfw;
1622 }
1623 outsw(base, frame->data, word_count);
1624
1625 InterruptTheCard(base);
1626
1627 udelay(50); /* 0x0f */
1628
1629 if (WaitTillCardIsFree(base))
1630 goto errrelfw;
1631
1632 status = inw(base + 0x4);
1633 if (status != 0) {
1634 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1635 "Status:0x%x\n", index + 1, status);
1636 goto errrelfw;
1637 }
1638 }
1639
1640 /* XXX: should we test it by reading it back and comparing with original like
1641 * in load firmware package? */
1642 for (frame = (struct stframe *)fw->data;
1643 frame < (struct stframe *)(fw->data + fw->size);
1644 frame = (struct stframe *)((u8 *)(frame + 1) +
1645 frame->count)) {
1646 if (WaitTillCardIsFree(base))
1647 goto errrelfw;
1648
1649 outw(0xf1, base); /* start download sequence */
1650 outw(0x00, base);
1651 outw(frame->addr, base); /* lsb of address */
1652
1653 word_count = (frame->count >> 1) + frame->count % 2;
1654 outw(word_count + 1, base);
1655 InterruptTheCard(base);
1656
1657 udelay(50); /* 0xf */
1658
1659 if (WaitTillCardIsFree(base))
1660 goto errrelfw;
1661
1662 status = inw(base + 0x4);
1663 if (status != 0) {
1664 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1665 KERN_WARNING "Address:0x%x\n"
1666 KERN_WARNING "Count:0x%x\n"
1667 KERN_WARNING "Status: 0x%x\n",
1668 index + 1, frame->addr, frame->count, status);
1669 goto errrelfw;
1670 }
1671
1672 data = kmalloc(word_count * 2, GFP_KERNEL);
1673 if (data == NULL) {
1674 dev_err(&pdev->dev, "Card%d, firmware upload "
1675 "failed, not enough memory\n", index + 1);
1676 goto errrelfw;
1677 }
1678 inw(base);
1679 insw(base, data, word_count);
1680 InterruptTheCard(base);
1681
1682 for (a = 0; a < frame->count; a++)
1683 if (data[a] != frame->data[a]) {
1684 kfree(data);
1685 dev_err(&pdev->dev, "Card%d, firmware upload "
1686 "failed\n", index + 1);
1687 goto errrelfw;
1688 }
1689 kfree(data);
1690
1691 udelay(50); /* 0xf */
1692
1693 if (WaitTillCardIsFree(base))
1694 goto errrelfw;
1695
1696 status = inw(base + 0x4);
1697 if (status != 0) {
1698 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1699 "Card Status:0x%x\n", index + 1, status);
1700 goto errrelfw;
1701 }
1702 }
1703
1704 /* xfer ctrl */
1705 if (WaitTillCardIsFree(base))
1706 goto errrelfw;
1707
1708 outw(0xf2, base);
1709 outw(0x800, base);
1710 outw(0x0, base);
1711 outw(0x0, base);
1712 InterruptTheCard(base);
1713 outw(0x0, base + 0x4); /* for ISI4608 cards */
1714
1715 board->status |= FIRMWARE_LOADED;
1716 retval = 0;
1717
1718 errrelfw:
1719 release_firmware(fw);
1720 end:
1721 return retval;
1722 }
1723
1724 /*
1725 * Insmod can set static symbols so keep these static
1726 */
1727 static unsigned int card_count;
1728
1729 static int __devinit isicom_probe(struct pci_dev *pdev,
1730 const struct pci_device_id *ent)
1731 {
1732 unsigned int signature, index;
1733 int retval = -EPERM;
1734 struct isi_board *board = NULL;
1735
1736 if (card_count >= BOARD_COUNT)
1737 goto err;
1738
1739 retval = pci_enable_device(pdev);
1740 if (retval) {
1741 dev_err(&pdev->dev, "failed to enable\n");
1742 goto err;
1743 }
1744
1745 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1746
1747 /* allot the first empty slot in the array */
1748 for (index = 0; index < BOARD_COUNT; index++)
1749 if (isi_card[index].base == 0) {
1750 board = &isi_card[index];
1751 break;
1752 }
1753
1754 board->index = index;
1755 board->base = pci_resource_start(pdev, 3);
1756 board->irq = pdev->irq;
1757 card_count++;
1758
1759 pci_set_drvdata(pdev, board);
1760
1761 retval = pci_request_region(pdev, 3, ISICOM_NAME);
1762 if (retval) {
1763 dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1764 "will be disabled.\n", board->base, board->base + 15,
1765 index + 1);
1766 retval = -EBUSY;
1767 goto errdec;
1768 }
1769
1770 retval = request_irq(board->irq, isicom_interrupt,
1771 IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
1772 if (retval < 0) {
1773 dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1774 "Card%d will be disabled.\n", board->irq, index + 1);
1775 goto errunrr;
1776 }
1777
1778 retval = reset_card(pdev, index, &signature);
1779 if (retval < 0)
1780 goto errunri;
1781
1782 retval = load_firmware(pdev, index, signature);
1783 if (retval < 0)
1784 goto errunri;
1785
1786 for (index = 0; index < board->port_count; index++)
1787 tty_register_device(isicom_normal, board->index * 16 + index,
1788 &pdev->dev);
1789
1790 return 0;
1791
1792 errunri:
1793 free_irq(board->irq, board);
1794 errunrr:
1795 pci_release_region(pdev, 3);
1796 errdec:
1797 board->base = 0;
1798 card_count--;
1799 pci_disable_device(pdev);
1800 err:
1801 return retval;
1802 }
1803
1804 static void __devexit isicom_remove(struct pci_dev *pdev)
1805 {
1806 struct isi_board *board = pci_get_drvdata(pdev);
1807 unsigned int i;
1808
1809 for (i = 0; i < board->port_count; i++)
1810 tty_unregister_device(isicom_normal, board->index * 16 + i);
1811
1812 free_irq(board->irq, board);
1813 pci_release_region(pdev, 3);
1814 board->base = 0;
1815 card_count--;
1816 pci_disable_device(pdev);
1817 }
1818
1819 static int __init isicom_init(void)
1820 {
1821 int retval, idx, channel;
1822 struct isi_port *port;
1823
1824 for (idx = 0; idx < BOARD_COUNT; idx++) {
1825 port = &isi_ports[idx * 16];
1826 isi_card[idx].ports = port;
1827 spin_lock_init(&isi_card[idx].card_lock);
1828 for (channel = 0; channel < 16; channel++, port++) {
1829 port->magic = ISICOM_MAGIC;
1830 port->card = &isi_card[idx];
1831 port->channel = channel;
1832 port->close_delay = 50 * HZ/100;
1833 port->closing_wait = 3000 * HZ/100;
1834 port->status = 0;
1835 init_waitqueue_head(&port->open_wait);
1836 init_waitqueue_head(&port->close_wait);
1837 /* . . . */
1838 }
1839 isi_card[idx].base = 0;
1840 isi_card[idx].irq = 0;
1841 }
1842
1843 /* tty driver structure initialization */
1844 isicom_normal = alloc_tty_driver(PORT_COUNT);
1845 if (!isicom_normal) {
1846 retval = -ENOMEM;
1847 goto error;
1848 }
1849
1850 isicom_normal->owner = THIS_MODULE;
1851 isicom_normal->name = "ttyM";
1852 isicom_normal->major = ISICOM_NMAJOR;
1853 isicom_normal->minor_start = 0;
1854 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1855 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1856 isicom_normal->init_termios = tty_std_termios;
1857 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1858 CLOCAL;
1859 isicom_normal->flags = TTY_DRIVER_REAL_RAW |
1860 TTY_DRIVER_DYNAMIC_DEV;
1861 tty_set_operations(isicom_normal, &isicom_ops);
1862
1863 retval = tty_register_driver(isicom_normal);
1864 if (retval) {
1865 pr_dbg("Couldn't register the dialin driver\n");
1866 goto err_puttty;
1867 }
1868
1869 retval = pci_register_driver(&isicom_driver);
1870 if (retval < 0) {
1871 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1872 goto err_unrtty;
1873 }
1874
1875 mod_timer(&tx, jiffies + 1);
1876
1877 return 0;
1878 err_unrtty:
1879 tty_unregister_driver(isicom_normal);
1880 err_puttty:
1881 put_tty_driver(isicom_normal);
1882 error:
1883 return retval;
1884 }
1885
1886 static void __exit isicom_exit(void)
1887 {
1888 del_timer_sync(&tx);
1889
1890 pci_unregister_driver(&isicom_driver);
1891 tty_unregister_driver(isicom_normal);
1892 put_tty_driver(isicom_normal);
1893 }
1894
1895 module_init(isicom_init);
1896 module_exit(isicom_exit);
1897
1898 MODULE_AUTHOR("MultiTech");
1899 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1900 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.070538 seconds and 6 git commands to generate.