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