Merge with rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[linux-2.6] / drivers / char / isicom.c
1 /*
2  *      This program is free software; you can redistribute it and/or
3  *      modify it under the terms of the GNU General Public License
4  *      as published by the Free Software Foundation; either version
5  *      2 of the License, or (at your option) any later version.
6  *
7  *      Original driver code supplied by Multi-Tech
8  *
9  *      Changes
10  *      1/9/98  alan@redhat.com         Merge to 2.0.x kernel tree
11  *                                      Obtain and use official major/minors
12  *                                      Loader switched to a misc device
13  *                                      (fixed range check bug as a side effect)
14  *                                      Printk clean up
15  *      9/12/98 alan@redhat.com         Rough port to 2.1.x
16  *
17  *      10/6/99 sameer                  Merged the ISA and PCI drivers to
18  *                                      a new unified driver.
19  *
20  *      3/9/99  sameer                  Added support for ISI4616 cards.
21  *
22  *      16/9/99 sameer                  We do not force RTS low anymore.
23  *                                      This is to prevent the firmware 
24  *                                      from getting confused.
25  *
26  *      26/10/99 sameer                 Cosmetic changes:The driver now
27  *                                      dumps the Port Count information
28  *                                      along with I/O address and IRQ.
29  *
30  *      13/12/99 sameer                 Fixed the problem with IRQ sharing.
31  *
32  *      10/5/00  sameer                 Fixed isicom_shutdown_board()
33  *                                      to not lower DTR on all the ports
34  *                                      when the last port on the card is 
35  *                                      closed.
36  *
37  *      10/5/00  sameer                 Signal mask setup command added
38  *                                      to  isicom_setup_port and 
39  *                                      isicom_shutdown_port.
40  *
41  *      24/5/00  sameer                 The driver is now SMP aware.
42  *                                      
43  *      
44  *      27/11/00 Vinayak P Risbud       Fixed the Driver Crash Problem
45  *      
46  *      
47  *      03/01/01  anil .s               Added support for resetting the
48  *                                      internal modems on ISI cards.
49  *
50  *      08/02/01  anil .s               Upgraded the driver for kernel
51  *                                      2.4.x
52  *
53  *      11/04/01  Kevin                 Fixed firmware load problem with
54  *                                      ISIHP-4X card
55  *      
56  *      30/04/01  anil .s               Fixed the remote login through
57  *                                      ISI port problem. Now the link
58  *                                      does not go down before password
59  *                                      prompt.
60  *
61  *      03/05/01  anil .s               Fixed the problem with IRQ sharing
62  *                                      among ISI-PCI cards.
63  *
64  *      03/05/01  anil .s               Added support to display the version
65  *                                      info during insmod as well as module 
66  *                                      listing by lsmod.
67  *      
68  *      10/05/01  anil .s               Done the modifications to the source
69  *                                      file and Install script so that the
70  *                                      same installation can be used for
71  *                                      2.2.x and 2.4.x kernel.
72  *
73  *      06/06/01  anil .s               Now we drop both dtr and rts during
74  *                                      shutdown_port as well as raise them
75  *                                      during isicom_config_port.
76  *      
77  *      09/06/01 acme@conectiva.com.br  use capable, not suser, do
78  *                                      restore_flags on failure in
79  *                                      isicom_send_break, verify put_user
80  *                                      result
81  *
82  *      11/02/03  ranjeeth              Added support for 230 Kbps and 460 Kbps
83  *                                      Baud index extended to 21
84  *      
85  *      20/03/03  ranjeeth              Made to work for Linux Advanced server.
86  *                                      Taken care of license warning.  
87  *      
88  *      10/12/03  Ravindra              Made to work for Fedora Core 1 of 
89  *                                      Red Hat Distribution
90  *
91  *      06/01/05  Alan Cox              Merged the ISI and base kernel strands
92  *                                      into a single 2.6 driver
93  *
94  *      ***********************************************************
95  *
96  *      To use this driver you also need the support package. You 
97  *      can find this in RPM format on
98  *              ftp://ftp.linux.org.uk/pub/linux/alan
99  *      
100  *      You can find the original tools for this direct from Multitech
101  *              ftp://ftp.multitech.com/ISI-Cards/
102  *
103  *      Having installed the cards the module options (/etc/modprobe.conf)
104  *
105  *      options isicom   io=card1,card2,card3,card4 irq=card1,card2,card3,card4
106  *
107  *      Omit those entries for boards you don't have installed.
108  *
109  *      TODO
110  *              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 __devinit 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 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 __devinit 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 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 __devinit 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 __devinit 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);