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