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