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