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