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