?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
m68k/atari/debug.c: possible cleanups
[linux-2.6/openmoko-kernel.git] / drivers / char / isicom.c
blobd4281df10c22dbd54a28f790774c7636126cd709
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 for (; count > 0; count--, port++) {
425 /* port not active or tx disabled to force flow control */
426 if (!(port->port.flags & ASYNC_INITIALIZED) ||
427 !(port->status & ISI_TXOK))
428 continue;
429
430 tty = port->port.tty;
431
432 if (tty == NULL)
433 continue;
434
435 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
436 if (txcount <= 0 || tty->stopped || tty->hw_stopped)
437 continue;
438
439 if (!(inw(base + 0x02) & (1 << port->channel)))
440 continue;
441
442 pr_dbg("txing %d bytes, port%d.\n", txcount,
443 port->channel + 1);
444 outw((port->channel << isi_card[card].shift_count) | txcount,
445 base);
446 residue = NO;
447 wrd = 0;
448 while (1) {
449 cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE
450 - port->xmit_tail));
451 if (residue == YES) {
452 residue = NO;
453 if (cnt > 0) {
454 wrd |= (port->port.xmit_buf[port->xmit_tail]
455 << 8);
456 port->xmit_tail = (port->xmit_tail + 1)
457 & (SERIAL_XMIT_SIZE - 1);
458 port->xmit_cnt--;
459 txcount--;
460 cnt--;
461 outw(wrd, base);
462 } else {
463 outw(wrd, base);
464 break;
465 }
466 }
467 if (cnt <= 0)
468 break;
469 word_count = cnt >> 1;
470 outsw(base, port->port.xmit_buf+port->xmit_tail, word_count);
471 port->xmit_tail = (port->xmit_tail
472 + (word_count << 1)) & (SERIAL_XMIT_SIZE - 1);
473 txcount -= (word_count << 1);
474 port->xmit_cnt -= (word_count << 1);
475 if (cnt & 0x0001) {
476 residue = YES;
477 wrd = port->port.xmit_buf[port->xmit_tail];
478 port->xmit_tail = (port->xmit_tail + 1)
479 & (SERIAL_XMIT_SIZE - 1);
480 port->xmit_cnt--;
481 txcount--;
482 }
483 }
484
485 InterruptTheCard(base);
486 if (port->xmit_cnt <= 0)
487 port->status &= ~ISI_TXOK;
488 if (port->xmit_cnt <= WAKEUP_CHARS)
489 tty_wakeup(tty);
490 }
491
492 unlock:
493 spin_unlock_irqrestore(&isi_card[card].card_lock, flags);
494 /* schedule another tx for hopefully in about 10ms */
495 sched_again:
496 mod_timer(&tx, jiffies + msecs_to_jiffies(10));
497 }
498
499 /*
500 * Main interrupt handler routine
501 */
502
503 static irqreturn_t isicom_interrupt(int irq, void *dev_id)
504 {
505 struct isi_board *card = dev_id;
506 struct isi_port *port;
507 struct tty_struct *tty;
508 unsigned long base;
509 u16 header, word_count, count, channel;
510 short byte_count;
511 unsigned char *rp;
512
513 if (!card || !(card->status & FIRMWARE_LOADED))
514 return IRQ_NONE;
515
516 base = card->base;
517
518 /* did the card interrupt us? */
519 if (!(inw(base + 0x0e) & 0x02))
520 return IRQ_NONE;
521
522 spin_lock(&card->card_lock);
523
524 /*
525 * disable any interrupts from the PCI card and lower the
526 * interrupt line
527 */
528 outw(0x8000, base+0x04);
529 ClearInterrupt(base);
530
531 inw(base); /* get the dummy word out */
532 header = inw(base);
533 channel = (header & 0x7800) >> card->shift_count;
534 byte_count = header & 0xff;
535
536 if (channel + 1 > card->port_count) {
537 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
538 "%d(channel) > port_count.\n", base, channel+1);
539 outw(0x0000, base+0x04); /* enable interrupts */
540 spin_unlock(&card->card_lock);
541 return IRQ_HANDLED;
542 }
543 port = card->ports + channel;
544 if (!(port->port.flags & ASYNC_INITIALIZED)) {
545 outw(0x0000, base+0x04); /* enable interrupts */
546 spin_unlock(&card->card_lock);
547 return IRQ_HANDLED;
548 }
549
550 tty = port->port.tty;
551 if (tty == NULL) {
552 word_count = byte_count >> 1;
553 while (byte_count > 1) {
554 inw(base);
555 byte_count -= 2;
556 }
557 if (byte_count & 0x01)
558 inw(base);
559 outw(0x0000, base+0x04); /* enable interrupts */
560 spin_unlock(&card->card_lock);
561 return IRQ_HANDLED;
562 }
563
564 if (header & 0x8000) { /* Status Packet */
565 header = inw(base);
566 switch (header & 0xff) {
567 case 0: /* Change in EIA signals */
568 if (port->port.flags & ASYNC_CHECK_CD) {
569 if (port->status & ISI_DCD) {
570 if (!(header & ISI_DCD)) {
571 /* Carrier has been lost */
572 pr_dbg("interrupt: DCD->low.\n"
573 );
574 port->status &= ~ISI_DCD;
575 tty_hangup(tty);
576 }
577 } else if (header & ISI_DCD) {
578 /* Carrier has been detected */
579 pr_dbg("interrupt: DCD->high.\n");
580 port->status |= ISI_DCD;
581 wake_up_interruptible(&port->port.open_wait);
582 }
583 } else {
584 if (header & ISI_DCD)
585 port->status |= ISI_DCD;
586 else
587 port->status &= ~ISI_DCD;
588 }
589
590 if (port->port.flags & ASYNC_CTS_FLOW) {
591 if (port->port.tty->hw_stopped) {
592 if (header & ISI_CTS) {
593 port->port.tty->hw_stopped = 0;
594 /* start tx ing */
595 port->status |= (ISI_TXOK
596 | ISI_CTS);
597 tty_wakeup(tty);
598 }
599 } else if (!(header & ISI_CTS)) {
600 port->port.tty->hw_stopped = 1;
601 /* stop tx ing */
602 port->status &= ~(ISI_TXOK | ISI_CTS);
603 }
604 } else {
605 if (header & ISI_CTS)
606 port->status |= ISI_CTS;
607 else
608 port->status &= ~ISI_CTS;
609 }
610
611 if (header & ISI_DSR)
612 port->status |= ISI_DSR;
613 else
614 port->status &= ~ISI_DSR;
615
616 if (header & ISI_RI)
617 port->status |= ISI_RI;
618 else
619 port->status &= ~ISI_RI;
620
621 break;
622
623 case 1: /* Received Break !!! */
624 tty_insert_flip_char(tty, 0, TTY_BREAK);
625 if (port->port.flags & ASYNC_SAK)
626 do_SAK(tty);
627 tty_flip_buffer_push(tty);
628 break;
629
630 case 2: /* Statistics */
631 pr_dbg("isicom_interrupt: stats!!!.\n");
632 break;
633
634 default:
635 pr_dbg("Intr: Unknown code in status packet.\n");
636 break;
637 }
638 } else { /* Data Packet */
639
640 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
641 pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
642 word_count = count >> 1;
643 insw(base, rp, word_count);
644 byte_count -= (word_count << 1);
645 if (count & 0x0001) {
646 tty_insert_flip_char(tty, inw(base) & 0xff,
647 TTY_NORMAL);
648 byte_count -= 2;
649 }
650 if (byte_count > 0) {
651 pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
652 "bytes...\n", base, channel + 1);
653 /* drain out unread xtra data */
654 while (byte_count > 0) {
655 inw(base);
656 byte_count -= 2;
657 }
658 }
659 tty_flip_buffer_push(tty);
660 }
661 outw(0x0000, base+0x04); /* enable interrupts */
662 spin_unlock(&card->card_lock);
663
664 return IRQ_HANDLED;
665 }
666
667 static void isicom_config_port(struct isi_port *port)
668 {
669 struct isi_board *card = port->card;
670 struct tty_struct *tty;
671 unsigned long baud;
672 unsigned long base = card->base;
673 u16 channel_setup, channel = port->channel,
674 shift_count = card->shift_count;
675 unsigned char flow_ctrl;
676
677 tty = port->port.tty;
678
679 if (tty == NULL)
680 return;
681 /* FIXME: Switch to new tty baud API */
682 baud = C_BAUD(tty);
683 if (baud & CBAUDEX) {
684 baud &= ~CBAUDEX;
685
686 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
687 * then the card is programmed for 57.6Kbps or 115Kbps
688 * respectively.
689 */
690
691 /* 1,2,3,4 => 57.6, 115.2, 230, 460 kbps resp. */
692 if (baud < 1 || baud > 4)
693 port->port.tty->termios->c_cflag &= ~CBAUDEX;
694 else
695 baud += 15;
696 }
697 if (baud == 15) {
698
699 /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
700 * by the set_serial_info ioctl ... this is done by
701 * the 'setserial' utility.
702 */
703
704 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
705 baud++; /* 57.6 Kbps */
706 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
707 baud += 2; /* 115 Kbps */
708 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
709 baud += 3; /* 230 kbps*/
710 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
711 baud += 4; /* 460 kbps*/
712 }
713 if (linuxb_to_isib[baud] == -1) {
714 /* hang up */
715 drop_dtr(port);
716 return;
717 } else
718 raise_dtr(port);
719
720 if (WaitTillCardIsFree(base) == 0) {
721 outw(0x8000 | (channel << shift_count) | 0x03, base);
722 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
723 channel_setup = 0;
724 switch (C_CSIZE(tty)) {
725 case CS5:
726 channel_setup |= ISICOM_CS5;
727 break;
728 case CS6:
729 channel_setup |= ISICOM_CS6;
730 break;
731 case CS7:
732 channel_setup |= ISICOM_CS7;
733 break;
734 case CS8:
735 channel_setup |= ISICOM_CS8;
736 break;
737 }
738
739 if (C_CSTOPB(tty))
740 channel_setup |= ISICOM_2SB;
741 if (C_PARENB(tty)) {
742 channel_setup |= ISICOM_EVPAR;
743 if (C_PARODD(tty))
744 channel_setup |= ISICOM_ODPAR;
745 }
746 outw(channel_setup, base);
747 InterruptTheCard(base);
748 }
749 if (C_CLOCAL(tty))
750 port->port.flags &= ~ASYNC_CHECK_CD;
751 else
752 port->port.flags |= ASYNC_CHECK_CD;
753
754 /* flow control settings ...*/
755 flow_ctrl = 0;
756 port->port.flags &= ~ASYNC_CTS_FLOW;
757 if (C_CRTSCTS(tty)) {
758 port->port.flags |= ASYNC_CTS_FLOW;
759 flow_ctrl |= ISICOM_CTSRTS;
760 }
761 if (I_IXON(tty))
762 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
763 if (I_IXOFF(tty))
764 flow_ctrl |= ISICOM_INITIATE_XONXOFF;
765
766 if (WaitTillCardIsFree(base) == 0) {
767 outw(0x8000 | (channel << shift_count) | 0x04, base);
768 outw(flow_ctrl << 8 | 0x05, base);
769 outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
770 InterruptTheCard(base);
771 }
772
773 /* rx enabled -> enable port for rx on the card */
774 if (C_CREAD(tty)) {
775 card->port_status |= (1 << channel);
776 outw(card->port_status, base + 0x02);
777 }
778 }
779
780 /* open et all */
781
782 static inline void isicom_setup_board(struct isi_board *bp)
783 {
784 int channel;
785 struct isi_port *port;
786 unsigned long flags;
787
788 spin_lock_irqsave(&bp->card_lock, flags);
789 if (bp->status & BOARD_ACTIVE) {
790 spin_unlock_irqrestore(&bp->card_lock, flags);
791 return;
792 }
793 port = bp->ports;
794 bp->status |= BOARD_ACTIVE;
795 for (channel = 0; channel < bp->port_count; channel++, port++)
796 drop_dtr_rts(port);
797 spin_unlock_irqrestore(&bp->card_lock, flags);
798 }
799
800 static int isicom_setup_port(struct isi_port *port)
801 {
802 struct isi_board *card = port->card;
803 unsigned long flags;
804
805 if (port->port.flags & ASYNC_INITIALIZED)
806 return 0;
807 if (tty_port_alloc_xmit_buf(&port->port) < 0)
808 return -ENOMEM;
809
810 spin_lock_irqsave(&card->card_lock, flags);
811 if (port->port.tty)
812 clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
813 if (port->port.count == 1)
814 card->count++;
815
816 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
817
818 /* discard any residual data */
819 if (WaitTillCardIsFree(card->base) == 0) {
820 outw(0x8000 | (port->channel << card->shift_count) | 0x02,
821 card->base);
822 outw(((ISICOM_KILLTX | ISICOM_KILLRX) << 8) | 0x06, card->base);
823 InterruptTheCard(card->base);
824 }
825
826 isicom_config_port(port);
827 port->port.flags |= ASYNC_INITIALIZED;
828 spin_unlock_irqrestore(&card->card_lock, flags);
829
830 return 0;
831 }
832
833 static int block_til_ready(struct tty_struct *tty, struct file *filp,
834 struct isi_port *port)
835 {
836 struct isi_board *card = port->card;
837 int do_clocal = 0, retval;
838 unsigned long flags;
839 DECLARE_WAITQUEUE(wait, current);
840
841 /* block if port is in the process of being closed */
842
843 if (tty_hung_up_p(filp) || port->port.flags & ASYNC_CLOSING) {
844 pr_dbg("block_til_ready: close in progress.\n");
845 interruptible_sleep_on(&port->port.close_wait);
846 if (port->port.flags & ASYNC_HUP_NOTIFY)
847 return -EAGAIN;
848 else
849 return -ERESTARTSYS;
850 }
851
852 /* if non-blocking mode is set ... */
853
854 if ((filp->f_flags & O_NONBLOCK) ||
855 (tty->flags & (1 << TTY_IO_ERROR))) {
856 pr_dbg("block_til_ready: non-block mode.\n");
857 port->port.flags |= ASYNC_NORMAL_ACTIVE;
858 return 0;
859 }
860
861 if (C_CLOCAL(tty))
862 do_clocal = 1;
863
864 /* block waiting for DCD to be asserted, and while
865 callout dev is busy */
866 retval = 0;
867 add_wait_queue(&port->port.open_wait, &wait);
868
869 spin_lock_irqsave(&card->card_lock, flags);
870 if (!tty_hung_up_p(filp))
871 port->port.count--;
872 port->port.blocked_open++;
873 spin_unlock_irqrestore(&card->card_lock, flags);
874
875 while (1) {
876 raise_dtr_rts(port);
877
878 set_current_state(TASK_INTERRUPTIBLE);
879 if (tty_hung_up_p(filp) || !(port->port.flags & ASYNC_INITIALIZED)) {
880 if (port->port.flags & ASYNC_HUP_NOTIFY)
881 retval = -EAGAIN;
882 else
883 retval = -ERESTARTSYS;
884 break;
885 }
886 if (!(port->port.flags & ASYNC_CLOSING) &&
887 (do_clocal || (port->status & ISI_DCD))) {
888 break;
889 }
890 if (signal_pending(current)) {
891 retval = -ERESTARTSYS;
892 break;
893 }
894 schedule();
895 }
896 set_current_state(TASK_RUNNING);
897 remove_wait_queue(&port->port.open_wait, &wait);
898 spin_lock_irqsave(&card->card_lock, flags);
899 if (!tty_hung_up_p(filp))
900 port->port.count++;
901 port->port.blocked_open--;
902 spin_unlock_irqrestore(&card->card_lock, flags);
903 if (retval)
904 return retval;
905 port->port.flags |= ASYNC_NORMAL_ACTIVE;
906 return 0;
907 }
908
909 static int isicom_open(struct tty_struct *tty, struct file *filp)
910 {
911 struct isi_port *port;
912 struct isi_board *card;
913 unsigned int board;
914 int error, line;
915
916 line = tty->index;
917 if (line < 0 || line > PORT_COUNT-1)
918 return -ENODEV;
919 board = BOARD(line);
920 card = &isi_card[board];
921
922 if (!(card->status & FIRMWARE_LOADED))
923 return -ENODEV;
924
925 /* open on a port greater than the port count for the card !!! */
926 if (line > ((board * 16) + card->port_count - 1))
927 return -ENODEV;
928
929 port = &isi_ports[line];
930 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
931 return -ENODEV;
932
933 isicom_setup_board(card);
934
935 port->port.count++;
936 tty->driver_data = port;
937 port->port.tty = tty;
938 error = isicom_setup_port(port);
939 if (error == 0)
940 error = block_til_ready(tty, filp, port);
941 return error;
942 }
943
944 /* close et all */
945
946 static inline void isicom_shutdown_board(struct isi_board *bp)
947 {
948 if (bp->status & BOARD_ACTIVE)
949 bp->status &= ~BOARD_ACTIVE;
950 }
951
952 /* card->lock HAS to be held */
953 static void isicom_shutdown_port(struct isi_port *port)
954 {
955 struct isi_board *card = port->card;
956 struct tty_struct *tty;
957
958 tty = port->port.tty;
959
960 if (!(port->port.flags & ASYNC_INITIALIZED))
961 return;
962
963 tty_port_free_xmit_buf(&port->port);
964 port->port.flags &= ~ASYNC_INITIALIZED;
965 /* 3rd October 2000 : Vinayak P Risbud */
966 port->port.tty = 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 inline void isicom_send_break(struct isi_port *port,
1185 unsigned long length)
1186 {
1187 struct isi_board *card = port->card;
1188 unsigned long base = card->base;
1189
1190 if (!lock_card(card))
1191 return;
1192
1193 outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1194 outw((length & 0xff) << 8 | 0x00, base);
1195 outw((length & 0xff00), base);
1196 InterruptTheCard(base);
1197
1198 unlock_card(card);
1199 }
1200
1201 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
1202 {
1203 struct isi_port *port = tty->driver_data;
1204 /* just send the port status */
1205 u16 status = port->status;
1206
1207 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1208 return -ENODEV;
1209
1210 return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1211 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
1212 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
1213 ((status & ISI_DSR) ? TIOCM_DSR : 0) |
1214 ((status & ISI_CTS) ? TIOCM_CTS : 0) |
1215 ((status & ISI_RI ) ? TIOCM_RI : 0);
1216 }
1217
1218 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
1219 unsigned int set, unsigned int clear)
1220 {
1221 struct isi_port *port = tty->driver_data;
1222 unsigned long flags;
1223
1224 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1225 return -ENODEV;
1226
1227 spin_lock_irqsave(&port->card->card_lock, flags);
1228 if (set & TIOCM_RTS)
1229 raise_rts(port);
1230 if (set & TIOCM_DTR)
1231 raise_dtr(port);
1232
1233 if (clear & TIOCM_RTS)
1234 drop_rts(port);
1235 if (clear & TIOCM_DTR)
1236 drop_dtr(port);
1237 spin_unlock_irqrestore(&port->card->card_lock, flags);
1238
1239 return 0;
1240 }
1241
1242 static int isicom_set_serial_info(struct isi_port *port,
1243 struct serial_struct __user *info)
1244 {
1245 struct serial_struct newinfo;
1246 int reconfig_port;
1247
1248 if (copy_from_user(&newinfo, info, sizeof(newinfo)))
1249 return -EFAULT;
1250
1251 lock_kernel();
1252
1253 reconfig_port = ((port->port.flags & ASYNC_SPD_MASK) !=
1254 (newinfo.flags & ASYNC_SPD_MASK));
1255
1256 if (!capable(CAP_SYS_ADMIN)) {
1257 if ((newinfo.close_delay != port->port.close_delay) ||
1258 (newinfo.closing_wait != port->port.closing_wait) ||
1259 ((newinfo.flags & ~ASYNC_USR_MASK) !=
1260 (port->port.flags & ~ASYNC_USR_MASK))) {
1261 unlock_kernel();
1262 return -EPERM;
1263 }
1264 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1265 (newinfo.flags & ASYNC_USR_MASK));
1266 } else {
1267 port->port.close_delay = newinfo.close_delay;
1268 port->port.closing_wait = newinfo.closing_wait;
1269 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1270 (newinfo.flags & ASYNC_FLAGS));
1271 }
1272 if (reconfig_port) {
1273 unsigned long flags;
1274 spin_lock_irqsave(&port->card->card_lock, flags);
1275 isicom_config_port(port);
1276 spin_unlock_irqrestore(&port->card->card_lock, flags);
1277 }
1278 unlock_kernel();
1279 return 0;
1280 }
1281
1282 static int isicom_get_serial_info(struct isi_port *port,
1283 struct serial_struct __user *info)
1284 {
1285 struct serial_struct out_info;
1286
1287 lock_kernel();
1288 memset(&out_info, 0, sizeof(out_info));
1289 /* out_info.type = ? */
1290 out_info.line = port - isi_ports;
1291 out_info.port = port->card->base;
1292 out_info.irq = port->card->irq;
1293 out_info.flags = port->port.flags;
1294 /* out_info.baud_base = ? */
1295 out_info.close_delay = port->port.close_delay;
1296 out_info.closing_wait = port->port.closing_wait;
1297 unlock_kernel();
1298 if (copy_to_user(info, &out_info, sizeof(out_info)))
1299 return -EFAULT;
1300 return 0;
1301 }
1302
1303 static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
1304 unsigned int cmd, unsigned long arg)
1305 {
1306 struct isi_port *port = tty->driver_data;
1307 void __user *argp = (void __user *)arg;
1308 int retval;
1309
1310 if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1311 return -ENODEV;
1312
1313 switch (cmd) {
1314 case TCSBRK:
1315 retval = tty_check_change(tty);
1316 if (retval)
1317 return retval;
1318 tty_wait_until_sent(tty, 0);
1319 if (!arg)
1320 isicom_send_break(port, HZ/4);
1321 return 0;
1322
1323 case TCSBRKP:
1324 retval = tty_check_change(tty);
1325 if (retval)
1326 return retval;
1327 tty_wait_until_sent(tty, 0);
1328 isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
1329 return 0;
1330 case TIOCGSERIAL:
1331 return isicom_get_serial_info(port, argp);
1332
1333 case TIOCSSERIAL:
1334 return isicom_set_serial_info(port, argp);
1335
1336 default:
1337 return -ENOIOCTLCMD;
1338 }
1339 return 0;
1340 }
1341
1342 /* set_termios et all */
1343 static void isicom_set_termios(struct tty_struct *tty,
1344 struct ktermios *old_termios)
1345 {
1346 struct isi_port *port = tty->driver_data;
1347 unsigned long flags;
1348
1349 if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1350 return;
1351
1352 if (tty->termios->c_cflag == old_termios->c_cflag &&
1353 tty->termios->c_iflag == old_termios->c_iflag)
1354 return;
1355
1356 spin_lock_irqsave(&port->card->card_lock, flags);
1357 isicom_config_port(port);
1358 spin_unlock_irqrestore(&port->card->card_lock, flags);
1359
1360 if ((old_termios->c_cflag & CRTSCTS) &&
1361 !(tty->termios->c_cflag & CRTSCTS)) {
1362 tty->hw_stopped = 0;
1363 isicom_start(tty);
1364 }
1365 }
1366
1367 /* throttle et all */
1368 static void isicom_throttle(struct tty_struct *tty)
1369 {
1370 struct isi_port *port = tty->driver_data;
1371 struct isi_board *card = port->card;
1372
1373 if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1374 return;
1375
1376 /* tell the card that this port cannot handle any more data for now */
1377 card->port_status &= ~(1 << port->channel);
1378 outw(card->port_status, card->base + 0x02);
1379 }
1380
1381 /* unthrottle et all */
1382 static void isicom_unthrottle(struct tty_struct *tty)
1383 {
1384 struct isi_port *port = tty->driver_data;
1385 struct isi_board *card = port->card;
1386
1387 if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1388 return;
1389
1390 /* tell the card that this port is ready to accept more data */
1391 card->port_status |= (1 << port->channel);
1392 outw(card->port_status, card->base + 0x02);
1393 }
1394
1395 /* stop et all */
1396 static void isicom_stop(struct tty_struct *tty)
1397 {
1398 struct isi_port *port = tty->driver_data;
1399
1400 if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1401 return;
1402
1403 /* this tells the transmitter not to consider this port for
1404 data output to the card. */
1405 port->status &= ~ISI_TXOK;
1406 }
1407
1408 /* start et all */
1409 static void isicom_start(struct tty_struct *tty)
1410 {
1411 struct isi_port *port = tty->driver_data;
1412
1413 if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1414 return;
1415
1416 /* this tells the transmitter to consider this port for
1417 data output to the card. */
1418 port->status |= ISI_TXOK;
1419 }
1420
1421 static void isicom_hangup(struct tty_struct *tty)
1422 {
1423 struct isi_port *port = tty->driver_data;
1424 unsigned long flags;
1425
1426 if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1427 return;
1428
1429 spin_lock_irqsave(&port->card->card_lock, flags);
1430 isicom_shutdown_port(port);
1431 spin_unlock_irqrestore(&port->card->card_lock, flags);
1432
1433 port->port.count = 0;
1434 port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1435 port->port.tty = NULL;
1436 wake_up_interruptible(&port->port.open_wait);
1437 }
1438
1439
1440 /*
1441 * Driver init and deinit functions
1442 */
1443
1444 static const struct tty_operations isicom_ops = {
1445 .open = isicom_open,
1446 .close = isicom_close,
1447 .write = isicom_write,
1448 .put_char = isicom_put_char,
1449 .flush_chars = isicom_flush_chars,
1450 .write_room = isicom_write_room,
1451 .chars_in_buffer = isicom_chars_in_buffer,
1452 .ioctl = isicom_ioctl,
1453 .set_termios = isicom_set_termios,
1454 .throttle = isicom_throttle,
1455 .unthrottle = isicom_unthrottle,
1456 .stop = isicom_stop,
1457 .start = isicom_start,
1458 .hangup = isicom_hangup,
1459 .flush_buffer = isicom_flush_buffer,
1460 .tiocmget = isicom_tiocmget,
1461 .tiocmset = isicom_tiocmset,
1462 };
1463
1464 static int __devinit reset_card(struct pci_dev *pdev,
1465 const unsigned int card, unsigned int *signature)
1466 {
1467 struct isi_board *board = pci_get_drvdata(pdev);
1468 unsigned long base = board->base;
1469 unsigned int sig, portcount = 0;
1470 int retval = 0;
1471
1472 dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1473 base);
1474
1475 inw(base + 0x8);
1476
1477 msleep(10);
1478
1479 outw(0, base + 0x8); /* Reset */
1480
1481 msleep(1000);
1482
1483 sig = inw(base + 0x4) & 0xff;
1484
1485 if (sig != 0xa5 && sig != 0xbb && sig != 0xcc && sig != 0xdd &&
1486 sig != 0xee) {
1487 dev_warn(&pdev->dev, "ISILoad:Card%u reset failure (Possible "
1488 "bad I/O Port Address 0x%lx).\n", card + 1, base);
1489 dev_dbg(&pdev->dev, "Sig=0x%x\n", sig);
1490 retval = -EIO;
1491 goto end;
1492 }
1493
1494 msleep(10);
1495
1496 portcount = inw(base + 0x2);
1497 if (!(inw(base + 0xe) & 0x1) || (portcount != 0 && portcount != 4 &&
1498 portcount != 8 && portcount != 16)) {
1499 dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure.\n",
1500 card + 1);
1501 retval = -EIO;
1502 goto end;
1503 }
1504
1505 switch (sig) {
1506 case 0xa5:
1507 case 0xbb:
1508 case 0xdd:
1509 board->port_count = (portcount == 4) ? 4 : 8;
1510 board->shift_count = 12;
1511 break;
1512 case 0xcc:
1513 case 0xee:
1514 board->port_count = 16;
1515 board->shift_count = 11;
1516 break;
1517 }
1518 dev_info(&pdev->dev, "-Done\n");
1519 *signature = sig;
1520
1521 end:
1522 return retval;
1523 }
1524
1525 static int __devinit load_firmware(struct pci_dev *pdev,
1526 const unsigned int index, const unsigned int signature)
1527 {
1528 struct isi_board *board = pci_get_drvdata(pdev);
1529 const struct firmware *fw;
1530 unsigned long base = board->base;
1531 unsigned int a;
1532 u16 word_count, status;
1533 int retval = -EIO;
1534 char *name;
1535 u8 *data;
1536
1537 struct stframe {
1538 u16 addr;
1539 u16 count;
1540 u8 data[0];
1541 } *frame;
1542
1543 switch (signature) {
1544 case 0xa5:
1545 name = "isi608.bin";
1546 break;
1547 case 0xbb:
1548 name = "isi608em.bin";
1549 break;
1550 case 0xcc:
1551 name = "isi616em.bin";
1552 break;
1553 case 0xdd:
1554 name = "isi4608.bin";
1555 break;
1556 case 0xee:
1557 name = "isi4616.bin";
1558 break;
1559 default:
1560 dev_err(&pdev->dev, "Unknown signature.\n");
1561 goto end;
1562 }
1563
1564 retval = request_firmware(&fw, name, &pdev->dev);
1565 if (retval)
1566 goto end;
1567
1568 retval = -EIO;
1569
1570 for (frame = (struct stframe *)fw->data;
1571 frame < (struct stframe *)(fw->data + fw->size);
1572 frame = (struct stframe *)((u8 *)(frame + 1) +
1573 frame->count)) {
1574 if (WaitTillCardIsFree(base))
1575 goto errrelfw;
1576
1577 outw(0xf0, base); /* start upload sequence */
1578 outw(0x00, base);
1579 outw(frame->addr, base); /* lsb of address */
1580
1581 word_count = frame->count / 2 + frame->count % 2;
1582 outw(word_count, base);
1583 InterruptTheCard(base);
1584
1585 udelay(100); /* 0x2f */
1586
1587 if (WaitTillCardIsFree(base))
1588 goto errrelfw;
1589
1590 status = inw(base + 0x4);
1591 if (status != 0) {
1592 dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1593 KERN_WARNING "Address:0x%x\n"
1594 KERN_WARNING "Count:0x%x\n"
1595 KERN_WARNING "Status:0x%x\n",
1596 index + 1, frame->addr, frame->count, status);
1597 goto errrelfw;
1598 }
1599 outsw(base, frame->data, word_count);
1600
1601 InterruptTheCard(base);
1602
1603 udelay(50); /* 0x0f */
1604
1605 if (WaitTillCardIsFree(base))
1606 goto errrelfw;
1607
1608 status = inw(base + 0x4);
1609 if (status != 0) {
1610 dev_err(&pdev->dev, "Card%d got out of sync.Card "
1611 "Status:0x%x\n", index + 1, status);
1612 goto errrelfw;
1613 }
1614 }
1615
1616 /* XXX: should we test it by reading it back and comparing with original like
1617 * in load firmware package? */
1618 for (frame = (struct stframe *)fw->data;
1619 frame < (struct stframe *)(fw->data + fw->size);
1620 frame = (struct stframe *)((u8 *)(frame + 1) +
1621 frame->count)) {
1622 if (WaitTillCardIsFree(base))
1623 goto errrelfw;
1624
1625 outw(0xf1, base); /* start download sequence */
1626 outw(0x00, base);
1627 outw(frame->addr, base); /* lsb of address */
1628
1629 word_count = (frame->count >> 1) + frame->count % 2;
1630 outw(word_count + 1, base);
1631 InterruptTheCard(base);
1632
1633 udelay(50); /* 0xf */
1634
1635 if (WaitTillCardIsFree(base))
1636 goto errrelfw;
1637
1638 status = inw(base + 0x4);
1639 if (status != 0) {
1640 dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1641 KERN_WARNING "Address:0x%x\n"
1642 KERN_WARNING "Count:0x%x\n"
1643 KERN_WARNING "Status: 0x%x\n",
1644 index + 1, frame->addr, frame->count, status);
1645 goto errrelfw;
1646 }
1647
1648 data = kmalloc(word_count * 2, GFP_KERNEL);
1649 if (data == NULL) {
1650 dev_err(&pdev->dev, "Card%d, firmware upload "
1651 "failed, not enough memory\n", index + 1);
1652 goto errrelfw;
1653 }
1654 inw(base);
1655 insw(base, data, word_count);
1656 InterruptTheCard(base);
1657
1658 for (a = 0; a < frame->count; a++)
1659 if (data[a] != frame->data[a]) {
1660 kfree(data);
1661 dev_err(&pdev->dev, "Card%d, firmware upload "
1662 "failed\n", index + 1);
1663 goto errrelfw;
1664 }
1665 kfree(data);
1666
1667 udelay(50); /* 0xf */
1668
1669 if (WaitTillCardIsFree(base))
1670 goto errrelfw;
1671
1672 status = inw(base + 0x4);
1673 if (status != 0) {
1674 dev_err(&pdev->dev, "Card%d verify got out of sync. "
1675 "Card Status:0x%x\n", index + 1, status);
1676 goto errrelfw;
1677 }
1678 }
1679
1680 /* xfer ctrl */
1681 if (WaitTillCardIsFree(base))
1682 goto errrelfw;
1683
1684 outw(0xf2, base);
1685 outw(0x800, base);
1686 outw(0x0, base);
1687 outw(0x0, base);
1688 InterruptTheCard(base);
1689 outw(0x0, base + 0x4); /* for ISI4608 cards */
1690
1691 board->status |= FIRMWARE_LOADED;
1692 retval = 0;
1693
1694 errrelfw:
1695 release_firmware(fw);
1696 end:
1697 return retval;
1698 }
1699
1700 /*
1701 * Insmod can set static symbols so keep these static
1702 */
1703 static unsigned int card_count;
1704
1705 static int __devinit isicom_probe(struct pci_dev *pdev,
1706 const struct pci_device_id *ent)
1707 {
1708 unsigned int signature, index;
1709 int retval = -EPERM;
1710 struct isi_board *board = NULL;
1711
1712 if (card_count >= BOARD_COUNT)
1713 goto err;
1714
1715 retval = pci_enable_device(pdev);
1716 if (retval) {
1717 dev_err(&pdev->dev, "failed to enable\n");
1718 goto err;
1719 }
1720
1721 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1722
1723 /* allot the first empty slot in the array */
1724 for (index = 0; index < BOARD_COUNT; index++)
1725 if (isi_card[index].base == 0) {
1726 board = &isi_card[index];
1727 break;
1728 }
1729
1730 board->index = index;
1731 board->base = pci_resource_start(pdev, 3);
1732 board->irq = pdev->irq;
1733 card_count++;
1734
1735 pci_set_drvdata(pdev, board);
1736
1737 retval = pci_request_region(pdev, 3, ISICOM_NAME);
1738 if (retval) {
1739 dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1740 "will be disabled.\n", board->base, board->base + 15,
1741 index + 1);
1742 retval = -EBUSY;
1743 goto errdec;
1744 }
1745
1746 retval = request_irq(board->irq, isicom_interrupt,
1747 IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
1748 if (retval < 0) {
1749 dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1750 "Card%d will be disabled.\n", board->irq, index + 1);
1751 goto errunrr;
1752 }
1753
1754 retval = reset_card(pdev, index, &signature);
1755 if (retval < 0)
1756 goto errunri;
1757
1758 retval = load_firmware(pdev, index, signature);
1759 if (retval < 0)
1760 goto errunri;
1761
1762 for (index = 0; index < board->port_count; index++)
1763 tty_register_device(isicom_normal, board->index * 16 + index,
1764 &pdev->dev);
1765
1766 return 0;
1767
1768 errunri:
1769 free_irq(board->irq, board);
1770 errunrr:
1771 pci_release_region(pdev, 3);
1772 errdec:
1773 board->base = 0;
1774 card_count--;
1775 pci_disable_device(pdev);
1776 err:
1777 return retval;
1778 }
1779
1780 static void __devexit isicom_remove(struct pci_dev *pdev)
1781 {
1782 struct isi_board *board = pci_get_drvdata(pdev);
1783 unsigned int i;
1784
1785 for (i = 0; i < board->port_count; i++)
1786 tty_unregister_device(isicom_normal, board->index * 16 + i);
1787
1788 free_irq(board->irq, board);
1789 pci_release_region(pdev, 3);
1790 board->base = 0;
1791 card_count--;
1792 pci_disable_device(pdev);
1793 }
1794
1795 static int __init isicom_init(void)
1796 {
1797 int retval, idx, channel;
1798 struct isi_port *port;
1799
1800 for (idx = 0; idx < BOARD_COUNT; idx++) {
1801 port = &isi_ports[idx * 16];
1802 isi_card[idx].ports = port;
1803 spin_lock_init(&isi_card[idx].card_lock);
1804 for (channel = 0; channel < 16; channel++, port++) {
1805 tty_port_init(&port->port);
1806 port->magic = ISICOM_MAGIC;
1807 port->card = &isi_card[idx];
1808 port->channel = channel;
1809 port->port.close_delay = 50 * HZ/100;
1810 port->port.closing_wait = 3000 * HZ/100;
1811 port->status = 0;
1812 /* . . . */
1813 }
1814 isi_card[idx].base = 0;
1815 isi_card[idx].irq = 0;
1816 }
1817
1818 /* tty driver structure initialization */
1819 isicom_normal = alloc_tty_driver(PORT_COUNT);
1820 if (!isicom_normal) {
1821 retval = -ENOMEM;
1822 goto error;
1823 }
1824
1825 isicom_normal->owner = THIS_MODULE;
1826 isicom_normal->name = "ttyM";
1827 isicom_normal->major = ISICOM_NMAJOR;
1828 isicom_normal->minor_start = 0;
1829 isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
1830 isicom_normal->subtype = SERIAL_TYPE_NORMAL;
1831 isicom_normal->init_termios = tty_std_termios;
1832 isicom_normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL |
1833 CLOCAL;
1834 isicom_normal->flags = TTY_DRIVER_REAL_RAW |
1835 TTY_DRIVER_DYNAMIC_DEV;
1836 tty_set_operations(isicom_normal, &isicom_ops);
1837
1838 retval = tty_register_driver(isicom_normal);
1839 if (retval) {
1840 pr_dbg("Couldn't register the dialin driver\n");
1841 goto err_puttty;
1842 }
1843
1844 retval = pci_register_driver(&isicom_driver);
1845 if (retval < 0) {
1846 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
1847 goto err_unrtty;
1848 }
1849
1850 mod_timer(&tx, jiffies + 1);
1851
1852 return 0;
1853 err_unrtty:
1854 tty_unregister_driver(isicom_normal);
1855 err_puttty:
1856 put_tty_driver(isicom_normal);
1857 error:
1858 return retval;
1859 }
1860
1861 static void __exit isicom_exit(void)
1862 {
1863 del_timer_sync(&tx);
1864
1865 pci_unregister_driver(&isicom_driver);
1866 tty_unregister_driver(isicom_normal);
1867 put_tty_driver(isicom_normal);
1868 }
1869
1870 module_init(isicom_init);
1871 module_exit(isicom_exit);
1872
1873 MODULE_AUTHOR("MultiTech");
1874 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1875 MODULE_LICENSE("GPL");
Openmoko development kernel tree