Merge branch 'x86-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6] / drivers / char / epca.c
1 /*
2         Copyright (C) 1996  Digi International.
3
4         For technical support please email digiLinux@dgii.com or
5         call Digi tech support at (612) 912-3456
6
7         ** This driver is no longer supported by Digi **
8
9         Much of this design and code came from epca.c which was
10         copyright (C) 1994, 1995 Troy De Jongh, and subsquently
11         modified by David Nugent, Christoph Lameter, Mike McLagan.
12
13         This program is free software; you can redistribute it and/or modify
14         it under the terms of the GNU General Public License as published by
15         the Free Software Foundation; either version 2 of the License, or
16         (at your option) any later version.
17
18         This program is distributed in the hope that it will be useful,
19         but WITHOUT ANY WARRANTY; without even the implied warranty of
20         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21         GNU General Public License for more details.
22
23         You should have received a copy of the GNU General Public License
24         along with this program; if not, write to the Free Software
25         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 */
27 /* See README.epca for change history --DAT*/
28
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/types.h>
32 #include <linux/init.h>
33 #include <linux/serial.h>
34 #include <linux/delay.h>
35 #include <linux/ctype.h>
36 #include <linux/tty.h>
37 #include <linux/tty_flip.h>
38 #include <linux/slab.h>
39 #include <linux/ioport.h>
40 #include <linux/interrupt.h>
41 #include <linux/uaccess.h>
42 #include <linux/io.h>
43 #include <linux/spinlock.h>
44 #include <linux/pci.h>
45 #include "digiPCI.h"
46
47
48 #include "digi1.h"
49 #include "digiFep1.h"
50 #include "epca.h"
51 #include "epcaconfig.h"
52
53 #define VERSION            "1.3.0.1-LK2.6"
54
55 /* This major needs to be submitted to Linux to join the majors list */
56 #define DIGIINFOMAJOR       35  /* For Digi specific ioctl */
57
58
59 #define MAXCARDS 7
60 #define epcaassert(x, msg)  if (!(x)) epca_error(__LINE__, msg)
61
62 #define PFX "epca: "
63
64 static int nbdevs, num_cards, liloconfig;
65 static int digi_poller_inhibited = 1 ;
66
67 static int setup_error_code;
68 static int invalid_lilo_config;
69
70 /*
71  * The ISA boards do window flipping into the same spaces so its only sane with
72  * a single lock. It's still pretty efficient.
73  */
74 static DEFINE_SPINLOCK(epca_lock);
75
76 /* MAXBOARDS is typically 12, but ISA and EISA cards are restricted
77    to 7 below. */
78 static struct board_info boards[MAXBOARDS];
79
80 static struct tty_driver *pc_driver;
81 static struct tty_driver *pc_info;
82
83 /* ------------------ Begin Digi specific structures -------------------- */
84
85 /*
86  * digi_channels represents an array of structures that keep track of each
87  * channel of the Digi product. Information such as transmit and receive
88  * pointers, termio data, and signal definitions (DTR, CTS, etc ...) are stored
89  * here. This structure is NOT used to overlay the cards physical channel
90  * structure.
91  */
92 static struct channel digi_channels[MAX_ALLOC];
93
94 /*
95  * card_ptr is an array used to hold the address of the first channel structure
96  * of each card. This array will hold the addresses of various channels located
97  * in digi_channels.
98  */
99 static struct channel *card_ptr[MAXCARDS];
100
101 static struct timer_list epca_timer;
102
103 /*
104  * Begin generic memory functions. These functions will be alias (point at)
105  * more specific functions dependent on the board being configured.
106  */
107 static void memwinon(struct board_info *b, unsigned int win);
108 static void memwinoff(struct board_info *b, unsigned int win);
109 static void globalwinon(struct channel *ch);
110 static void rxwinon(struct channel *ch);
111 static void txwinon(struct channel *ch);
112 static void memoff(struct channel *ch);
113 static void assertgwinon(struct channel *ch);
114 static void assertmemoff(struct channel *ch);
115
116 /* ---- Begin more 'specific' memory functions for cx_like products --- */
117
118 static void pcxem_memwinon(struct board_info *b, unsigned int win);
119 static void pcxem_memwinoff(struct board_info *b, unsigned int win);
120 static void pcxem_globalwinon(struct channel *ch);
121 static void pcxem_rxwinon(struct channel *ch);
122 static void pcxem_txwinon(struct channel *ch);
123 static void pcxem_memoff(struct channel *ch);
124
125 /* ------ Begin more 'specific' memory functions for the pcxe ------- */
126
127 static void pcxe_memwinon(struct board_info *b, unsigned int win);
128 static void pcxe_memwinoff(struct board_info *b, unsigned int win);
129 static void pcxe_globalwinon(struct channel *ch);
130 static void pcxe_rxwinon(struct channel *ch);
131 static void pcxe_txwinon(struct channel *ch);
132 static void pcxe_memoff(struct channel *ch);
133
134 /* ---- Begin more 'specific' memory functions for the pc64xe and pcxi ---- */
135 /* Note : pc64xe and pcxi share the same windowing routines */
136
137 static void pcxi_memwinon(struct board_info *b, unsigned int win);
138 static void pcxi_memwinoff(struct board_info *b, unsigned int win);
139 static void pcxi_globalwinon(struct channel *ch);
140 static void pcxi_rxwinon(struct channel *ch);
141 static void pcxi_txwinon(struct channel *ch);
142 static void pcxi_memoff(struct channel *ch);
143
144 /* - Begin 'specific' do nothing memory functions needed for some cards - */
145
146 static void dummy_memwinon(struct board_info *b, unsigned int win);
147 static void dummy_memwinoff(struct board_info *b, unsigned int win);
148 static void dummy_globalwinon(struct channel *ch);
149 static void dummy_rxwinon(struct channel *ch);
150 static void dummy_txwinon(struct channel *ch);
151 static void dummy_memoff(struct channel *ch);
152 static void dummy_assertgwinon(struct channel *ch);
153 static void dummy_assertmemoff(struct channel *ch);
154
155 static struct channel *verifyChannel(struct tty_struct *);
156 static void pc_sched_event(struct channel *, int);
157 static void epca_error(int, char *);
158 static void pc_close(struct tty_struct *, struct file *);
159 static void shutdown(struct channel *);
160 static void pc_hangup(struct tty_struct *);
161 static int pc_write_room(struct tty_struct *);
162 static int pc_chars_in_buffer(struct tty_struct *);
163 static void pc_flush_buffer(struct tty_struct *);
164 static void pc_flush_chars(struct tty_struct *);
165 static int block_til_ready(struct tty_struct *, struct file *,
166                         struct channel *);
167 static int pc_open(struct tty_struct *, struct file *);
168 static void post_fep_init(unsigned int crd);
169 static void epcapoll(unsigned long);
170 static void doevent(int);
171 static void fepcmd(struct channel *, int, int, int, int, int);
172 static unsigned termios2digi_h(struct channel *ch, unsigned);
173 static unsigned termios2digi_i(struct channel *ch, unsigned);
174 static unsigned termios2digi_c(struct channel *ch, unsigned);
175 static void epcaparam(struct tty_struct *, struct channel *);
176 static void receive_data(struct channel *);
177 static int pc_ioctl(struct tty_struct *, struct file *,
178                         unsigned int, unsigned long);
179 static int info_ioctl(struct tty_struct *, struct file *,
180                         unsigned int, unsigned long);
181 static void pc_set_termios(struct tty_struct *, struct ktermios *);
182 static void do_softint(struct work_struct *work);
183 static void pc_stop(struct tty_struct *);
184 static void pc_start(struct tty_struct *);
185 static void pc_throttle(struct tty_struct *tty);
186 static void pc_unthrottle(struct tty_struct *tty);
187 static void digi_send_break(struct channel *ch, int msec);
188 static void setup_empty_event(struct tty_struct *tty, struct channel *ch);
189 static void epca_setup(char *, int *);
190
191 static int pc_write(struct tty_struct *, const unsigned char *, int);
192 static int pc_init(void);
193 static int init_PCI(void);
194
195 /*
196  * Table of functions for each board to handle memory. Mantaining parallelism
197  * is a *very* good idea here. The idea is for the runtime code to blindly call
198  * these functions, not knowing/caring about the underlying hardware. This
199  * stuff should contain no conditionals; if more functionality is needed a
200  * different entry should be established. These calls are the interface calls
201  * and are the only functions that should be accessed. Anyone caught making
202  * direct calls deserves what they get.
203  */
204 static void memwinon(struct board_info *b, unsigned int win)
205 {
206         b->memwinon(b, win);
207 }
208
209 static void memwinoff(struct board_info *b, unsigned int win)
210 {
211         b->memwinoff(b, win);
212 }
213
214 static void globalwinon(struct channel *ch)
215 {
216         ch->board->globalwinon(ch);
217 }
218
219 static void rxwinon(struct channel *ch)
220 {
221         ch->board->rxwinon(ch);
222 }
223
224 static void txwinon(struct channel *ch)
225 {
226         ch->board->txwinon(ch);
227 }
228
229 static void memoff(struct channel *ch)
230 {
231         ch->board->memoff(ch);
232 }
233 static void assertgwinon(struct channel *ch)
234 {
235         ch->board->assertgwinon(ch);
236 }
237
238 static void assertmemoff(struct channel *ch)
239 {
240         ch->board->assertmemoff(ch);
241 }
242
243 /* PCXEM windowing is the same as that used in the PCXR and CX series cards. */
244 static void pcxem_memwinon(struct board_info *b, unsigned int win)
245 {
246         outb_p(FEPWIN | win, b->port + 1);
247 }
248
249 static void pcxem_memwinoff(struct board_info *b, unsigned int win)
250 {
251         outb_p(0, b->port + 1);
252 }
253
254 static void pcxem_globalwinon(struct channel *ch)
255 {
256         outb_p(FEPWIN, (int)ch->board->port + 1);
257 }
258
259 static void pcxem_rxwinon(struct channel *ch)
260 {
261         outb_p(ch->rxwin, (int)ch->board->port + 1);
262 }
263
264 static void pcxem_txwinon(struct channel *ch)
265 {
266         outb_p(ch->txwin, (int)ch->board->port + 1);
267 }
268
269 static void pcxem_memoff(struct channel *ch)
270 {
271         outb_p(0, (int)ch->board->port + 1);
272 }
273
274 /* ----------------- Begin pcxe memory window stuff ------------------ */
275 static void pcxe_memwinon(struct board_info *b, unsigned int win)
276 {
277         outb_p(FEPWIN | win, b->port + 1);
278 }
279
280 static void pcxe_memwinoff(struct board_info *b, unsigned int win)
281 {
282         outb_p(inb(b->port) & ~FEPMEM, b->port + 1);
283         outb_p(0, b->port + 1);
284 }
285
286 static void pcxe_globalwinon(struct channel *ch)
287 {
288         outb_p(FEPWIN, (int)ch->board->port + 1);
289 }
290
291 static void pcxe_rxwinon(struct channel *ch)
292 {
293         outb_p(ch->rxwin, (int)ch->board->port + 1);
294 }
295
296 static void pcxe_txwinon(struct channel *ch)
297 {
298         outb_p(ch->txwin, (int)ch->board->port + 1);
299 }
300
301 static void pcxe_memoff(struct channel *ch)
302 {
303         outb_p(0, (int)ch->board->port);
304         outb_p(0, (int)ch->board->port + 1);
305 }
306
307 /* ------------- Begin pc64xe and pcxi memory window stuff -------------- */
308 static void pcxi_memwinon(struct board_info *b, unsigned int win)
309 {
310         outb_p(inb(b->port) | FEPMEM, b->port);
311 }
312
313 static void pcxi_memwinoff(struct board_info *b, unsigned int win)
314 {
315         outb_p(inb(b->port) & ~FEPMEM, b->port);
316 }
317
318 static void pcxi_globalwinon(struct channel *ch)
319 {
320         outb_p(FEPMEM, ch->board->port);
321 }
322
323 static void pcxi_rxwinon(struct channel *ch)
324 {
325         outb_p(FEPMEM, ch->board->port);
326 }
327
328 static void pcxi_txwinon(struct channel *ch)
329 {
330         outb_p(FEPMEM, ch->board->port);
331 }
332
333 static void pcxi_memoff(struct channel *ch)
334 {
335         outb_p(0, ch->board->port);
336 }
337
338 static void pcxi_assertgwinon(struct channel *ch)
339 {
340         epcaassert(inb(ch->board->port) & FEPMEM, "Global memory off");
341 }
342
343 static void pcxi_assertmemoff(struct channel *ch)
344 {
345         epcaassert(!(inb(ch->board->port) & FEPMEM), "Memory on");
346 }
347
348 /*
349  * Not all of the cards need specific memory windowing routines. Some cards
350  * (Such as PCI) needs no windowing routines at all. We provide these do
351  * nothing routines so that the same code base can be used. The driver will
352  * ALWAYS call a windowing routine if it thinks it needs to; regardless of the
353  * card. However, dependent on the card the routine may or may not do anything.
354  */
355 static void dummy_memwinon(struct board_info *b, unsigned int win)
356 {
357 }
358
359 static void dummy_memwinoff(struct board_info *b, unsigned int win)
360 {
361 }
362
363 static void dummy_globalwinon(struct channel *ch)
364 {
365 }
366
367 static void dummy_rxwinon(struct channel *ch)
368 {
369 }
370
371 static void dummy_txwinon(struct channel *ch)
372 {
373 }
374
375 static void dummy_memoff(struct channel *ch)
376 {
377 }
378
379 static void dummy_assertgwinon(struct channel *ch)
380 {
381 }
382
383 static void dummy_assertmemoff(struct channel *ch)
384 {
385 }
386
387 static struct channel *verifyChannel(struct tty_struct *tty)
388 {
389         /*
390          * This routine basically provides a sanity check. It insures that the
391          * channel returned is within the proper range of addresses as well as
392          * properly initialized. If some bogus info gets passed in
393          * through tty->driver_data this should catch it.
394          */
395         if (tty) {
396                 struct channel *ch = (struct channel *)tty->driver_data;
397                 if (ch >= &digi_channels[0] && ch < &digi_channels[nbdevs]) {
398                         if (ch->magic == EPCA_MAGIC)
399                                 return ch;
400                 }
401         }
402         return NULL;
403 }
404
405 static void pc_sched_event(struct channel *ch, int event)
406 {
407         /*
408          * We call this to schedule interrupt processing on some event. The
409          * kernel sees our request and calls the related routine in OUR driver.
410          */
411         ch->event |= 1 << event;
412         schedule_work(&ch->tqueue);
413 }
414
415 static void epca_error(int line, char *msg)
416 {
417         printk(KERN_ERR "epca_error (Digi): line = %d %s\n", line, msg);
418 }
419
420 static void pc_close(struct tty_struct *tty, struct file *filp)
421 {
422         struct channel *ch;
423         unsigned long flags;
424         /*
425          * verifyChannel returns the channel from the tty struct if it is
426          * valid. This serves as a sanity check.
427          */
428         ch = verifyChannel(tty);
429         if (ch != NULL) {
430                 spin_lock_irqsave(&epca_lock, flags);
431                 if (tty_hung_up_p(filp)) {
432                         spin_unlock_irqrestore(&epca_lock, flags);
433                         return;
434                 }
435                 if (ch->count-- > 1)  {
436                         /* Begin channel is open more than once */
437                         /*
438                          * Return without doing anything. Someone might still
439                          * be using the channel.
440                          */
441                         spin_unlock_irqrestore(&epca_lock, flags);
442                         return;
443                 }
444                 /* Port open only once go ahead with shutdown & reset */
445                 BUG_ON(ch->count < 0);
446
447                 /*
448                  * Let the rest of the driver know the channel is being closed.
449                  * This becomes important if an open is attempted before close
450                  * is finished.
451                  */
452                 ch->asyncflags |= ASYNC_CLOSING;
453                 tty->closing = 1;
454
455                 spin_unlock_irqrestore(&epca_lock, flags);
456
457                 if (ch->asyncflags & ASYNC_INITIALIZED)  {
458                         /* Setup an event to indicate when the
459                            transmit buffer empties */
460                         setup_empty_event(tty, ch);
461                         /* 30 seconds timeout */
462                         tty_wait_until_sent(tty, 3000);
463                 }
464                 pc_flush_buffer(tty);
465
466                 tty_ldisc_flush(tty);
467                 shutdown(ch);
468
469                 spin_lock_irqsave(&epca_lock, flags);
470                 tty->closing = 0;
471                 ch->event = 0;
472                 ch->tty = NULL;
473                 spin_unlock_irqrestore(&epca_lock, flags);
474
475                 if (ch->blocked_open) {
476                         if (ch->close_delay)
477                                 msleep_interruptible(jiffies_to_msecs(ch->close_delay));
478                         wake_up_interruptible(&ch->open_wait);
479                 }
480                 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED |
481                                         ASYNC_CLOSING);
482                 wake_up_interruptible(&ch->close_wait);
483         }
484 }
485
486 static void shutdown(struct channel *ch)
487 {
488         unsigned long flags;
489         struct tty_struct *tty;
490         struct board_chan __iomem *bc;
491
492         if (!(ch->asyncflags & ASYNC_INITIALIZED))
493                 return;
494
495         spin_lock_irqsave(&epca_lock, flags);
496
497         globalwinon(ch);
498         bc = ch->brdchan;
499
500         /*
501          * In order for an event to be generated on the receipt of data the
502          * idata flag must be set. Since we are shutting down, this is not
503          * necessary clear this flag.
504          */
505         if (bc)
506                 writeb(0, &bc->idata);
507         tty = ch->tty;
508
509         /* If we're a modem control device and HUPCL is on, drop RTS & DTR. */
510         if (tty->termios->c_cflag & HUPCL)  {
511                 ch->omodem &= ~(ch->m_rts | ch->m_dtr);
512                 fepcmd(ch, SETMODEM, 0, ch->m_dtr | ch->m_rts, 10, 1);
513         }
514         memoff(ch);
515
516         /*
517          * The channel has officialy been closed. The next time it is opened it
518          * will have to reinitialized. Set a flag to indicate this.
519          */
520         /* Prevent future Digi programmed interrupts from coming active */
521         ch->asyncflags &= ~ASYNC_INITIALIZED;
522         spin_unlock_irqrestore(&epca_lock, flags);
523 }
524
525 static void pc_hangup(struct tty_struct *tty)
526 {
527         struct channel *ch;
528         /*
529          * verifyChannel returns the channel from the tty struct if it is
530          * valid. This serves as a sanity check.
531          */
532         ch = verifyChannel(tty);
533         if (ch != NULL) {
534                 unsigned long flags;
535
536                 pc_flush_buffer(tty);
537                 tty_ldisc_flush(tty);
538                 shutdown(ch);
539
540                 spin_lock_irqsave(&epca_lock, flags);
541                 ch->tty   = NULL;
542                 ch->event = 0;
543                 ch->count = 0;
544                 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED);
545                 spin_unlock_irqrestore(&epca_lock, flags);
546                 wake_up_interruptible(&ch->open_wait);
547         }
548 }
549
550 static int pc_write(struct tty_struct *tty,
551                         const unsigned char *buf, int bytesAvailable)
552 {
553         unsigned int head, tail;
554         int dataLen;
555         int size;
556         int amountCopied;
557         struct channel *ch;
558         unsigned long flags;
559         int remain;
560         struct board_chan __iomem *bc;
561
562         /*
563          * pc_write is primarily called directly by the kernel routine
564          * tty_write (Though it can also be called by put_char) found in
565          * tty_io.c. pc_write is passed a line discipline buffer where the data
566          * to be written out is stored. The line discipline implementation
567          * itself is done at the kernel level and is not brought into the
568          * driver.
569          */
570
571         /*
572          * verifyChannel returns the channel from the tty struct if it is
573          * valid. This serves as a sanity check.
574          */
575         ch = verifyChannel(tty);
576         if (ch == NULL)
577                 return 0;
578
579         /* Make a pointer to the channel data structure found on the board. */
580         bc   = ch->brdchan;
581         size = ch->txbufsize;
582         amountCopied = 0;
583
584         spin_lock_irqsave(&epca_lock, flags);
585         globalwinon(ch);
586
587         head = readw(&bc->tin) & (size - 1);
588         tail = readw(&bc->tout);
589
590         if (tail != readw(&bc->tout))
591                 tail = readw(&bc->tout);
592         tail &= (size - 1);
593
594         if (head >= tail) {
595                 /* head has not wrapped */
596                 /*
597                  * remain (much like dataLen above) represents the total amount
598                  * of space available on the card for data. Here dataLen
599                  * represents the space existing between the head pointer and
600                  * the end of buffer. This is important because a memcpy cannot
601                  * be told to automatically wrap around when it hits the buffer
602                  * end.
603                  */
604                 dataLen = size - head;
605                 remain = size - (head - tail) - 1;
606         } else {
607                 /* head has wrapped around */
608                 remain = tail - head - 1;
609                 dataLen = remain;
610         }
611         /*
612          * Check the space on the card. If we have more data than space; reduce
613          * the amount of data to fit the space.
614          */
615         bytesAvailable = min(remain, bytesAvailable);
616         txwinon(ch);
617         while (bytesAvailable > 0) {
618                 /* there is data to copy onto card */
619
620                 /*
621                  * If head is not wrapped, the below will make sure the first
622                  * data copy fills to the end of card buffer.
623                  */
624                 dataLen = min(bytesAvailable, dataLen);
625                 memcpy_toio(ch->txptr + head, buf, dataLen);
626                 buf += dataLen;
627                 head += dataLen;
628                 amountCopied += dataLen;
629                 bytesAvailable -= dataLen;
630
631                 if (head >= size) {
632                         head = 0;
633                         dataLen = tail;
634                 }
635         }
636         ch->statusflags |= TXBUSY;
637         globalwinon(ch);
638         writew(head, &bc->tin);
639
640         if ((ch->statusflags & LOWWAIT) == 0)  {
641                 ch->statusflags |= LOWWAIT;
642                 writeb(1, &bc->ilow);
643         }
644         memoff(ch);
645         spin_unlock_irqrestore(&epca_lock, flags);
646         return amountCopied;
647 }
648
649 static int pc_write_room(struct tty_struct *tty)
650 {
651         int remain = 0;
652         struct channel *ch;
653         unsigned long flags;
654         unsigned int head, tail;
655         struct board_chan __iomem *bc;
656         /*
657          * verifyChannel returns the channel from the tty struct if it is
658          * valid. This serves as a sanity check.
659          */
660         ch = verifyChannel(tty);
661         if (ch != NULL) {
662                 spin_lock_irqsave(&epca_lock, flags);
663                 globalwinon(ch);
664
665                 bc   = ch->brdchan;
666                 head = readw(&bc->tin) & (ch->txbufsize - 1);
667                 tail = readw(&bc->tout);
668
669                 if (tail != readw(&bc->tout))
670                         tail = readw(&bc->tout);
671                 /* Wrap tail if necessary */
672                 tail &= (ch->txbufsize - 1);
673                 remain = tail - head - 1;
674                 if (remain < 0)
675                         remain += ch->txbufsize;
676
677                 if (remain && (ch->statusflags & LOWWAIT) == 0) {
678                         ch->statusflags |= LOWWAIT;
679                         writeb(1, &bc->ilow);
680                 }
681                 memoff(ch);
682                 spin_unlock_irqrestore(&epca_lock, flags);
683         }
684         /* Return how much room is left on card */
685         return remain;
686 }
687
688 static int pc_chars_in_buffer(struct tty_struct *tty)
689 {
690         int chars;
691         unsigned int ctail, head, tail;
692         int remain;
693         unsigned long flags;
694         struct channel *ch;
695         struct board_chan __iomem *bc;
696         /*
697          * verifyChannel returns the channel from the tty struct if it is
698          * valid. This serves as a sanity check.
699          */
700         ch = verifyChannel(tty);
701         if (ch == NULL)
702                 return 0;
703
704         spin_lock_irqsave(&epca_lock, flags);
705         globalwinon(ch);
706
707         bc = ch->brdchan;
708         tail = readw(&bc->tout);
709         head = readw(&bc->tin);
710         ctail = readw(&ch->mailbox->cout);
711
712         if (tail == head && readw(&ch->mailbox->cin) == ctail &&
713                                                 readb(&bc->tbusy) == 0)
714                 chars = 0;
715         else  { /* Begin if some space on the card has been used */
716                 head = readw(&bc->tin) & (ch->txbufsize - 1);
717                 tail &= (ch->txbufsize - 1);
718                 /*
719                  * The logic here is basically opposite of the above
720                  * pc_write_room here we are finding the amount of bytes in the
721                  * buffer filled. Not the amount of bytes empty.
722                  */
723                 remain = tail - head - 1;
724                 if (remain < 0)
725                         remain += ch->txbufsize;
726                 chars = (int)(ch->txbufsize - remain);
727                 /*
728                  * Make it possible to wakeup anything waiting for output in
729                  * tty_ioctl.c, etc.
730                  *
731                  * If not already set. Setup an event to indicate when the
732                  * transmit buffer empties.
733                  */
734                 if (!(ch->statusflags & EMPTYWAIT))
735                         setup_empty_event(tty, ch);
736         } /* End if some space on the card has been used */
737         memoff(ch);
738         spin_unlock_irqrestore(&epca_lock, flags);
739         /* Return number of characters residing on card. */
740         return chars;
741 }
742
743 static void pc_flush_buffer(struct tty_struct *tty)
744 {
745         unsigned int tail;
746         unsigned long flags;
747         struct channel *ch;
748         struct board_chan __iomem *bc;
749         /*
750          * verifyChannel returns the channel from the tty struct if it is
751          * valid. This serves as a sanity check.
752          */
753         ch = verifyChannel(tty);
754         if (ch == NULL)
755                 return;
756
757         spin_lock_irqsave(&epca_lock, flags);
758         globalwinon(ch);
759         bc   = ch->brdchan;
760         tail = readw(&bc->tout);
761         /* Have FEP move tout pointer; effectively flushing transmit buffer */
762         fepcmd(ch, STOUT, (unsigned) tail, 0, 0, 0);
763         memoff(ch);
764         spin_unlock_irqrestore(&epca_lock, flags);
765         tty_wakeup(tty);
766 }
767
768 static void pc_flush_chars(struct tty_struct *tty)
769 {
770         struct channel *ch;
771         /*
772          * verifyChannel returns the channel from the tty struct if it is
773          * valid. This serves as a sanity check.
774          */
775         ch = verifyChannel(tty);
776         if (ch != NULL) {
777                 unsigned long flags;
778                 spin_lock_irqsave(&epca_lock, flags);
779                 /*
780                  * If not already set and the transmitter is busy setup an
781                  * event to indicate when the transmit empties.
782                  */
783                 if ((ch->statusflags & TXBUSY) &&
784                                 !(ch->statusflags & EMPTYWAIT))
785                         setup_empty_event(tty, ch);
786                 spin_unlock_irqrestore(&epca_lock, flags);
787         }
788 }
789
790 static int block_til_ready(struct tty_struct *tty,
791                                 struct file *filp, struct channel *ch)
792 {
793         DECLARE_WAITQUEUE(wait, current);
794         int retval, do_clocal = 0;
795         unsigned long flags;
796
797         if (tty_hung_up_p(filp)) {
798                 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
799                         retval = -EAGAIN;
800                 else
801                         retval = -ERESTARTSYS;
802                 return retval;
803         }
804
805         /*
806          * If the device is in the middle of being closed, then block until
807          * it's done, and then try again.
808          */
809         if (ch->asyncflags & ASYNC_CLOSING) {
810                 interruptible_sleep_on(&ch->close_wait);
811
812                 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
813                         return -EAGAIN;
814                 else
815                         return -ERESTARTSYS;
816         }
817
818         if (filp->f_flags & O_NONBLOCK)  {
819                 /*
820                  * If non-blocking mode is set, then make the check up front
821                  * and then exit.
822                  */
823                 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
824                 return 0;
825         }
826         if (tty->termios->c_cflag & CLOCAL)
827                 do_clocal = 1;
828         /* Block waiting for the carrier detect and the line to become free */
829
830         retval = 0;
831         add_wait_queue(&ch->open_wait, &wait);
832
833         spin_lock_irqsave(&epca_lock, flags);
834         /* We dec count so that pc_close will know when to free things */
835         if (!tty_hung_up_p(filp))
836                 ch->count--;
837         ch->blocked_open++;
838         while (1) {
839                 set_current_state(TASK_INTERRUPTIBLE);
840                 if (tty_hung_up_p(filp) ||
841                                 !(ch->asyncflags & ASYNC_INITIALIZED)) {
842                         if (ch->asyncflags & ASYNC_HUP_NOTIFY)
843                                 retval = -EAGAIN;
844                         else
845                                 retval = -ERESTARTSYS;
846                         break;
847                 }
848                 if (!(ch->asyncflags & ASYNC_CLOSING) &&
849                           (do_clocal || (ch->imodem & ch->dcd)))
850                         break;
851                 if (signal_pending(current)) {
852                         retval = -ERESTARTSYS;
853                         break;
854                 }
855                 spin_unlock_irqrestore(&epca_lock, flags);
856                 /*
857                  * Allow someone else to be scheduled. We will occasionally go
858                  * through this loop until one of the above conditions change.
859                  * The below schedule call will allow other processes to enter
860                  * and prevent this loop from hogging the cpu.
861                  */
862                 schedule();
863                 spin_lock_irqsave(&epca_lock, flags);
864         }
865
866         __set_current_state(TASK_RUNNING);
867         remove_wait_queue(&ch->open_wait, &wait);
868         if (!tty_hung_up_p(filp))
869                 ch->count++;
870         ch->blocked_open--;
871
872         spin_unlock_irqrestore(&epca_lock, flags);
873
874         if (retval)
875                 return retval;
876
877         ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
878         return 0;
879 }
880
881 static int pc_open(struct tty_struct *tty, struct file *filp)
882 {
883         struct channel *ch;
884         unsigned long flags;
885         int line, retval, boardnum;
886         struct board_chan __iomem *bc;
887         unsigned int head;
888
889         line = tty->index;
890         if (line < 0 || line >= nbdevs)
891                 return -ENODEV;
892
893         ch = &digi_channels[line];
894         boardnum = ch->boardnum;
895
896         /* Check status of board configured in system.  */
897
898         /*
899          * I check to see if the epca_setup routine detected an user error. It
900          * might be better to put this in pc_init, but for the moment it goes
901          * here.
902          */
903         if (invalid_lilo_config) {
904                 if (setup_error_code & INVALID_BOARD_TYPE)
905                         printk(KERN_ERR "epca: pc_open: Invalid board type specified in kernel options.\n");
906                 if (setup_error_code & INVALID_NUM_PORTS)
907                         printk(KERN_ERR "epca: pc_open: Invalid number of ports specified in kernel options.\n");
908                 if (setup_error_code & INVALID_MEM_BASE)
909                         printk(KERN_ERR "epca: pc_open: Invalid board memory address specified in kernel options.\n");
910                 if (setup_error_code & INVALID_PORT_BASE)
911                         printk(KERN_ERR "epca; pc_open: Invalid board port address specified in kernel options.\n");
912                 if (setup_error_code & INVALID_BOARD_STATUS)
913                         printk(KERN_ERR "epca: pc_open: Invalid board status specified in kernel options.\n");
914                 if (setup_error_code & INVALID_ALTPIN)
915                         printk(KERN_ERR "epca: pc_open: Invalid board altpin specified in kernel options;\n");
916                 tty->driver_data = NULL;   /* Mark this device as 'down' */
917                 return -ENODEV;
918         }
919         if (boardnum >= num_cards || boards[boardnum].status == DISABLED)  {
920                 tty->driver_data = NULL;   /* Mark this device as 'down' */
921                 return(-ENODEV);
922         }
923
924         bc = ch->brdchan;
925         if (bc == NULL) {
926                 tty->driver_data = NULL;
927                 return -ENODEV;
928         }
929
930         spin_lock_irqsave(&epca_lock, flags);
931         /*
932          * Every time a channel is opened, increment a counter. This is
933          * necessary because we do not wish to flush and shutdown the channel
934          * until the last app holding the channel open, closes it.
935          */
936         ch->count++;
937         /*
938          * Set a kernel structures pointer to our local channel structure. This
939          * way we can get to it when passed only a tty struct.
940          */
941         tty->driver_data = ch;
942         /*
943          * If this is the first time the channel has been opened, initialize
944          * the tty->termios struct otherwise let pc_close handle it.
945          */
946         globalwinon(ch);
947         ch->statusflags = 0;
948
949         /* Save boards current modem status */
950         ch->imodem = readb(&bc->mstat);
951
952         /*
953          * Set receive head and tail ptrs to each other. This indicates no data
954          * available to read.
955          */
956         head = readw(&bc->rin);
957         writew(head, &bc->rout);
958
959         /* Set the channels associated tty structure */
960         ch->tty = tty;
961
962         /*
963          * The below routine generally sets up parity, baud, flow control
964          * issues, etc.... It effect both control flags and input flags.
965          */
966         epcaparam(tty, ch);
967         ch->asyncflags |= ASYNC_INITIALIZED;
968         memoff(ch);
969         spin_unlock_irqrestore(&epca_lock, flags);
970
971         retval = block_til_ready(tty, filp, ch);
972         if (retval)
973                 return retval;
974         /*
975          * Set this again in case a hangup set it to zero while this open() was
976          * waiting for the line...
977          */
978         spin_lock_irqsave(&epca_lock, flags);
979         ch->tty = tty;
980         globalwinon(ch);
981         /* Enable Digi Data events */
982         writeb(1, &bc->idata);
983         memoff(ch);
984         spin_unlock_irqrestore(&epca_lock, flags);
985         return 0;
986 }
987
988 static int __init epca_module_init(void)
989 {
990         return pc_init();
991 }
992 module_init(epca_module_init);
993
994 static struct pci_driver epca_driver;
995
996 static void __exit epca_module_exit(void)
997 {
998         int               count, crd;
999         struct board_info *bd;
1000         struct channel    *ch;
1001
1002         del_timer_sync(&epca_timer);
1003
1004         if (tty_unregister_driver(pc_driver) ||
1005                                 tty_unregister_driver(pc_info)) {
1006                 printk(KERN_WARNING "epca: cleanup_module failed to un-register tty driver\n");
1007                 return;
1008         }
1009         put_tty_driver(pc_driver);
1010         put_tty_driver(pc_info);
1011
1012         for (crd = 0; crd < num_cards; crd++) {
1013                 bd = &boards[crd];
1014                 if (!bd) { /* sanity check */
1015                         printk(KERN_ERR "<Error> - Digi : cleanup_module failed\n");
1016                         return;
1017                 }
1018                 ch = card_ptr[crd];
1019                 for (count = 0; count < bd->numports; count++, ch++) {
1020                         if (ch && ch->tty)
1021                                 tty_hangup(ch->tty);
1022                 }
1023         }
1024         pci_unregister_driver(&epca_driver);
1025 }
1026 module_exit(epca_module_exit);
1027
1028 static const struct tty_operations pc_ops = {
1029         .open = pc_open,
1030         .close = pc_close,
1031         .write = pc_write,
1032         .write_room = pc_write_room,
1033         .flush_buffer = pc_flush_buffer,
1034         .chars_in_buffer = pc_chars_in_buffer,
1035         .flush_chars = pc_flush_chars,
1036         .ioctl = pc_ioctl,
1037         .set_termios = pc_set_termios,
1038         .stop = pc_stop,
1039         .start = pc_start,
1040         .throttle = pc_throttle,
1041         .unthrottle = pc_unthrottle,
1042         .hangup = pc_hangup,
1043 };
1044
1045 static int info_open(struct tty_struct *tty, struct file *filp)
1046 {
1047         return 0;
1048 }
1049
1050 static struct tty_operations info_ops = {
1051         .open = info_open,
1052         .ioctl = info_ioctl,
1053 };
1054
1055 static int __init pc_init(void)
1056 {
1057         int crd;
1058         struct board_info *bd;
1059         unsigned char board_id = 0;
1060         int err = -ENOMEM;
1061
1062         int pci_boards_found, pci_count;
1063
1064         pci_count = 0;
1065
1066         pc_driver = alloc_tty_driver(MAX_ALLOC);
1067         if (!pc_driver)
1068                 goto out1;
1069
1070         pc_info = alloc_tty_driver(MAX_ALLOC);
1071         if (!pc_info)
1072                 goto out2;
1073
1074         /*
1075          * If epca_setup has not been ran by LILO set num_cards to defaults;
1076          * copy board structure defined by digiConfig into drivers board
1077          * structure. Note : If LILO has ran epca_setup then epca_setup will
1078          * handle defining num_cards as well as copying the data into the board
1079          * structure.
1080          */
1081         if (!liloconfig) {
1082                 /* driver has been configured via. epcaconfig */
1083                 nbdevs = NBDEVS;
1084                 num_cards = NUMCARDS;
1085                 memcpy(&boards, &static_boards,
1086                        sizeof(struct board_info) * NUMCARDS);
1087         }
1088
1089         /*
1090          * Note : If lilo was used to configure the driver and the ignore
1091          * epcaconfig option was choosen (digiepca=2) then nbdevs and num_cards
1092          * will equal 0 at this point. This is okay; PCI cards will still be
1093          * picked up if detected.
1094          */
1095
1096         /*
1097          * Set up interrupt, we will worry about memory allocation in
1098          * post_fep_init.
1099          */
1100         printk(KERN_INFO "DIGI epca driver version %s loaded.\n", VERSION);
1101
1102         /*
1103          * NOTE : This code assumes that the number of ports found in the
1104          * boards array is correct. This could be wrong if the card in question
1105          * is PCI (And therefore has no ports entry in the boards structure.)
1106          * The rest of the information will be valid for PCI because the
1107          * beginning of pc_init scans for PCI and determines i/o and base
1108          * memory addresses. I am not sure if it is possible to read the number
1109          * of ports supported by the card prior to it being booted (Since that
1110          * is the state it is in when pc_init is run). Because it is not
1111          * possible to query the number of supported ports until after the card
1112          * has booted; we are required to calculate the card_ptrs as the card
1113          * is initialized (Inside post_fep_init). The negative thing about this
1114          * approach is that digiDload's call to GET_INFO will have a bad port
1115          * value. (Since this is called prior to post_fep_init.)
1116          */
1117         pci_boards_found = 0;
1118         if (num_cards < MAXBOARDS)
1119                 pci_boards_found += init_PCI();
1120         num_cards += pci_boards_found;
1121
1122         pc_driver->owner = THIS_MODULE;
1123         pc_driver->name = "ttyD";
1124         pc_driver->major = DIGI_MAJOR;
1125         pc_driver->minor_start = 0;
1126         pc_driver->type = TTY_DRIVER_TYPE_SERIAL;
1127         pc_driver->subtype = SERIAL_TYPE_NORMAL;
1128         pc_driver->init_termios = tty_std_termios;
1129         pc_driver->init_termios.c_iflag = 0;
1130         pc_driver->init_termios.c_oflag = 0;
1131         pc_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
1132         pc_driver->init_termios.c_lflag = 0;
1133         pc_driver->init_termios.c_ispeed = 9600;
1134         pc_driver->init_termios.c_ospeed = 9600;
1135         pc_driver->flags = TTY_DRIVER_REAL_RAW;
1136         tty_set_operations(pc_driver, &pc_ops);
1137
1138         pc_info->owner = THIS_MODULE;
1139         pc_info->name = "digi_ctl";
1140         pc_info->major = DIGIINFOMAJOR;
1141         pc_info->minor_start = 0;
1142         pc_info->type = TTY_DRIVER_TYPE_SERIAL;
1143         pc_info->subtype = SERIAL_TYPE_INFO;
1144         pc_info->init_termios = tty_std_termios;
1145         pc_info->init_termios.c_iflag = 0;
1146         pc_info->init_termios.c_oflag = 0;
1147         pc_info->init_termios.c_lflag = 0;
1148         pc_info->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
1149         pc_info->init_termios.c_ispeed = 9600;
1150         pc_info->init_termios.c_ospeed = 9600;
1151         pc_info->flags = TTY_DRIVER_REAL_RAW;
1152         tty_set_operations(pc_info, &info_ops);
1153
1154
1155         for (crd = 0; crd < num_cards; crd++) {
1156                 /*
1157                  * This is where the appropriate memory handlers for the
1158                  * hardware is set. Everything at runtime blindly jumps through
1159                  * these vectors.
1160                  */
1161
1162                 /* defined in epcaconfig.h */
1163                 bd = &boards[crd];
1164
1165                 switch (bd->type) {
1166                 case PCXEM:
1167                 case EISAXEM:
1168                         bd->memwinon     = pcxem_memwinon;
1169                         bd->memwinoff    = pcxem_memwinoff;
1170                         bd->globalwinon  = pcxem_globalwinon;
1171                         bd->txwinon      = pcxem_txwinon;
1172                         bd->rxwinon      = pcxem_rxwinon;
1173                         bd->memoff       = pcxem_memoff;
1174                         bd->assertgwinon = dummy_assertgwinon;
1175                         bd->assertmemoff = dummy_assertmemoff;
1176                         break;
1177
1178                 case PCIXEM:
1179                 case PCIXRJ:
1180                 case PCIXR:
1181                         bd->memwinon     = dummy_memwinon;
1182                         bd->memwinoff    = dummy_memwinoff;
1183                         bd->globalwinon  = dummy_globalwinon;
1184                         bd->txwinon      = dummy_txwinon;
1185                         bd->rxwinon      = dummy_rxwinon;
1186                         bd->memoff       = dummy_memoff;
1187                         bd->assertgwinon = dummy_assertgwinon;
1188                         bd->assertmemoff = dummy_assertmemoff;
1189                         break;
1190
1191                 case PCXE:
1192                 case PCXEVE:
1193                         bd->memwinon     = pcxe_memwinon;
1194                         bd->memwinoff    = pcxe_memwinoff;
1195                         bd->globalwinon  = pcxe_globalwinon;
1196                         bd->txwinon      = pcxe_txwinon;
1197                         bd->rxwinon      = pcxe_rxwinon;
1198                         bd->memoff       = pcxe_memoff;
1199                         bd->assertgwinon = dummy_assertgwinon;
1200                         bd->assertmemoff = dummy_assertmemoff;
1201                         break;
1202
1203                 case PCXI:
1204                 case PC64XE:
1205                         bd->memwinon     = pcxi_memwinon;
1206                         bd->memwinoff    = pcxi_memwinoff;
1207                         bd->globalwinon  = pcxi_globalwinon;
1208                         bd->txwinon      = pcxi_txwinon;
1209                         bd->rxwinon      = pcxi_rxwinon;
1210                         bd->memoff       = pcxi_memoff;
1211                         bd->assertgwinon = pcxi_assertgwinon;
1212                         bd->assertmemoff = pcxi_assertmemoff;
1213                         break;
1214
1215                 default:
1216                         break;
1217                 }
1218
1219                 /*
1220                  * Some cards need a memory segment to be defined for use in
1221                  * transmit and receive windowing operations. These boards are
1222                  * listed in the below switch. In the case of the XI the amount
1223                  * of memory on the board is variable so the memory_seg is also
1224                  * variable. This code determines what they segment should be.
1225                  */
1226                 switch (bd->type) {
1227                 case PCXE:
1228                 case PCXEVE:
1229                 case PC64XE:
1230                         bd->memory_seg = 0xf000;
1231                         break;
1232
1233                 case PCXI:
1234                         board_id = inb((int)bd->port);
1235                         if ((board_id & 0x1) == 0x1) {
1236                                 /* it's an XI card */
1237                                 /* Is it a 64K board */
1238                                 if ((board_id & 0x30) == 0)
1239                                         bd->memory_seg = 0xf000;
1240
1241                                 /* Is it a 128K board */
1242                                 if ((board_id & 0x30) == 0x10)
1243                                         bd->memory_seg = 0xe000;
1244
1245                                 /* Is is a 256K board */
1246                                 if ((board_id & 0x30) == 0x20)
1247                                         bd->memory_seg = 0xc000;
1248
1249                                 /* Is it a 512K board */
1250                                 if ((board_id & 0x30) == 0x30)
1251                                         bd->memory_seg = 0x8000;
1252                         } else
1253                                 printk(KERN_ERR "epca: Board at 0x%x doesn't appear to be an XI\n", (int)bd->port);
1254                         break;
1255                 }
1256         }
1257
1258         err = tty_register_driver(pc_driver);
1259         if (err) {
1260                 printk(KERN_ERR "Couldn't register Digi PC/ driver");
1261                 goto out3;
1262         }
1263
1264         err = tty_register_driver(pc_info);
1265         if (err) {
1266                 printk(KERN_ERR "Couldn't register Digi PC/ info ");
1267                 goto out4;
1268         }
1269
1270         /* Start up the poller to check for events on all enabled boards */
1271         init_timer(&epca_timer);
1272         epca_timer.function = epcapoll;
1273         mod_timer(&epca_timer, jiffies + HZ/25);
1274         return 0;
1275
1276 out4:
1277         tty_unregister_driver(pc_driver);
1278 out3:
1279         put_tty_driver(pc_info);
1280 out2:
1281         put_tty_driver(pc_driver);
1282 out1:
1283         return err;
1284 }
1285
1286 static void post_fep_init(unsigned int crd)
1287 {
1288         int i;
1289         void __iomem *memaddr;
1290         struct global_data __iomem *gd;
1291         struct board_info *bd;
1292         struct board_chan __iomem *bc;
1293         struct channel *ch;
1294         int shrinkmem = 0, lowwater;
1295
1296         /*
1297          * This call is made by the user via. the ioctl call DIGI_INIT. It is
1298          * responsible for setting up all the card specific stuff.
1299          */
1300         bd = &boards[crd];
1301
1302         /*
1303          * If this is a PCI board, get the port info. Remember PCI cards do not
1304          * have entries into the epcaconfig.h file, so we can't get the number
1305          * of ports from it. Unfortunetly, this means that anyone doing a
1306          * DIGI_GETINFO before the board has booted will get an invalid number
1307          * of ports returned (It should return 0). Calls to DIGI_GETINFO after
1308          * DIGI_INIT has been called will return the proper values.
1309          */
1310         if (bd->type >= PCIXEM) { /* Begin get PCI number of ports */
1311                 /*
1312                  * Below we use XEMPORTS as a memory offset regardless of which
1313                  * PCI card it is. This is because all of the supported PCI
1314                  * cards have the same memory offset for the channel data. This
1315                  * will have to be changed if we ever develop a PCI/XE card.
1316                  * NOTE : The FEP manual states that the port offset is 0xC22
1317                  * as opposed to 0xC02. This is only true for PC/XE, and PC/XI
1318                  * cards; not for the XEM, or CX series. On the PCI cards the
1319                  * number of ports is determined by reading a ID PROM located
1320                  * in the box attached to the card. The card can then determine
1321                  * the index the id to determine the number of ports available.
1322                  * (FYI - The id should be located at 0x1ac (And may use up to
1323                  * 4 bytes if the box in question is a XEM or CX)).
1324                  */
1325                 /* PCI cards are already remapped at this point ISA are not */
1326                 bd->numports = readw(bd->re_map_membase + XEMPORTS);
1327                 epcaassert(bd->numports <= 64, "PCI returned a invalid number of ports");
1328                 nbdevs += (bd->numports);
1329         } else {
1330                 /* Fix up the mappings for ISA/EISA etc */
1331                 /* FIXME: 64K - can we be smarter ? */
1332                 bd->re_map_membase = ioremap_nocache(bd->membase, 0x10000);
1333         }
1334
1335         if (crd != 0)
1336                 card_ptr[crd] = card_ptr[crd-1] + boards[crd-1].numports;
1337         else
1338                 card_ptr[crd] = &digi_channels[crd]; /* <- For card 0 only */
1339
1340         ch = card_ptr[crd];
1341         epcaassert(ch <= &digi_channels[nbdevs - 1], "ch out of range");
1342
1343         memaddr = bd->re_map_membase;
1344
1345         /*
1346          * The below assignment will set bc to point at the BEGINING of the
1347          * cards channel structures. For 1 card there will be between 8 and 64
1348          * of these structures.
1349          */
1350         bc = memaddr + CHANSTRUCT;
1351
1352         /*
1353          * The below assignment will set gd to point at the BEGINING of global
1354          * memory address 0xc00. The first data in that global memory actually
1355          * starts at address 0xc1a. The command in pointer begins at 0xd10.
1356          */
1357         gd = memaddr + GLOBAL;
1358
1359         /*
1360          * XEPORTS (address 0xc22) points at the number of channels the card
1361          * supports. (For 64XE, XI, XEM, and XR use 0xc02)
1362          */
1363         if ((bd->type == PCXEVE || bd->type == PCXE) &&
1364                                         (readw(memaddr + XEPORTS) < 3))
1365                 shrinkmem = 1;
1366         if (bd->type < PCIXEM)
1367                 if (!request_region((int)bd->port, 4, board_desc[bd->type]))
1368                         return;
1369         memwinon(bd, 0);
1370
1371         /*
1372          * Remember ch is the main drivers channels structure, while bc is the
1373          * cards channel structure.
1374          */
1375         for (i = 0; i < bd->numports; i++, ch++, bc++) {
1376                 unsigned long flags;
1377                 u16 tseg, rseg;
1378
1379                 ch->brdchan = bc;
1380                 ch->mailbox = gd;
1381                 INIT_WORK(&ch->tqueue, do_softint);
1382                 ch->board = &boards[crd];
1383
1384                 spin_lock_irqsave(&epca_lock, flags);
1385                 switch (bd->type) {
1386                 /*
1387                  * Since some of the boards use different bitmaps for
1388                  * their control signals we cannot hard code these
1389                  * values and retain portability. We virtualize this
1390                  * data here.
1391                  */
1392                 case EISAXEM:
1393                 case PCXEM:
1394                 case PCIXEM:
1395                 case PCIXRJ:
1396                 case PCIXR:
1397                         ch->m_rts = 0x02;
1398                         ch->m_dcd = 0x80;
1399                         ch->m_dsr = 0x20;
1400                         ch->m_cts = 0x10;
1401                         ch->m_ri  = 0x40;
1402                         ch->m_dtr = 0x01;
1403                         break;
1404
1405                 case PCXE:
1406                 case PCXEVE:
1407                 case PCXI:
1408                 case PC64XE:
1409                         ch->m_rts = 0x02;
1410                         ch->m_dcd = 0x08;
1411                         ch->m_dsr = 0x10;
1412                         ch->m_cts = 0x20;
1413                         ch->m_ri  = 0x40;
1414                         ch->m_dtr = 0x80;
1415                         break;
1416                 }
1417
1418                 if (boards[crd].altpin) {
1419                         ch->dsr = ch->m_dcd;
1420                         ch->dcd = ch->m_dsr;
1421                         ch->digiext.digi_flags |= DIGI_ALTPIN;
1422                 } else {
1423                         ch->dcd = ch->m_dcd;
1424                         ch->dsr = ch->m_dsr;
1425                 }
1426
1427                 ch->boardnum   = crd;
1428                 ch->channelnum = i;
1429                 ch->magic      = EPCA_MAGIC;
1430                 ch->tty        = NULL;
1431
1432                 if (shrinkmem) {
1433                         fepcmd(ch, SETBUFFER, 32, 0, 0, 0);
1434                         shrinkmem = 0;
1435                 }
1436
1437                 tseg = readw(&bc->tseg);
1438                 rseg = readw(&bc->rseg);
1439
1440                 switch (bd->type) {
1441                 case PCIXEM:
1442                 case PCIXRJ:
1443                 case PCIXR:
1444                         /* Cover all the 2MEG cards */
1445                         ch->txptr = memaddr + ((tseg << 4) & 0x1fffff);
1446                         ch->rxptr = memaddr + ((rseg << 4) & 0x1fffff);
1447                         ch->txwin = FEPWIN | (tseg >> 11);
1448                         ch->rxwin = FEPWIN | (rseg >> 11);
1449                         break;
1450
1451                 case PCXEM:
1452                 case EISAXEM:
1453                         /* Cover all the 32K windowed cards */
1454                         /* Mask equal to window size - 1 */
1455                         ch->txptr = memaddr + ((tseg << 4) & 0x7fff);
1456                         ch->rxptr = memaddr + ((rseg << 4) & 0x7fff);
1457                         ch->txwin = FEPWIN | (tseg >> 11);
1458                         ch->rxwin = FEPWIN | (rseg >> 11);
1459                         break;
1460
1461                 case PCXEVE:
1462                 case PCXE:
1463                         ch->txptr = memaddr + (((tseg - bd->memory_seg) << 4)
1464                                                                 & 0x1fff);
1465                         ch->txwin = FEPWIN | ((tseg - bd->memory_seg) >> 9);
1466                         ch->rxptr = memaddr + (((rseg - bd->memory_seg) << 4)
1467                                                                 & 0x1fff);
1468                         ch->rxwin = FEPWIN | ((rseg - bd->memory_seg) >> 9);
1469                         break;
1470
1471                 case PCXI:
1472                 case PC64XE:
1473                         ch->txptr = memaddr + ((tseg - bd->memory_seg) << 4);
1474                         ch->rxptr = memaddr + ((rseg - bd->memory_seg) << 4);
1475                         ch->txwin = ch->rxwin = 0;
1476                         break;
1477                 }
1478
1479                 ch->txbufhead = 0;
1480                 ch->txbufsize = readw(&bc->tmax) + 1;
1481
1482                 ch->rxbufhead = 0;
1483                 ch->rxbufsize = readw(&bc->rmax) + 1;
1484
1485                 lowwater = ch->txbufsize >= 2000 ? 1024 : (ch->txbufsize / 2);
1486
1487                 /* Set transmitter low water mark */
1488                 fepcmd(ch, STXLWATER, lowwater, 0, 10, 0);
1489
1490                 /* Set receiver low water mark */
1491                 fepcmd(ch, SRXLWATER, (ch->rxbufsize / 4), 0, 10, 0);
1492
1493                 /* Set receiver high water mark */
1494                 fepcmd(ch, SRXHWATER, (3 * ch->rxbufsize / 4), 0, 10, 0);
1495
1496                 writew(100, &bc->edelay);
1497                 writeb(1, &bc->idata);
1498
1499                 ch->startc  = readb(&bc->startc);
1500                 ch->stopc   = readb(&bc->stopc);
1501                 ch->startca = readb(&bc->startca);
1502                 ch->stopca  = readb(&bc->stopca);
1503
1504                 ch->fepcflag = 0;
1505                 ch->fepiflag = 0;
1506                 ch->fepoflag = 0;
1507                 ch->fepstartc = 0;
1508                 ch->fepstopc = 0;
1509                 ch->fepstartca = 0;
1510                 ch->fepstopca = 0;
1511
1512                 ch->close_delay = 50;
1513                 ch->count = 0;
1514                 ch->blocked_open = 0;
1515                 init_waitqueue_head(&ch->open_wait);
1516                 init_waitqueue_head(&ch->close_wait);
1517
1518                 spin_unlock_irqrestore(&epca_lock, flags);
1519         }
1520
1521         printk(KERN_INFO
1522         "Digi PC/Xx Driver V%s:  %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n",
1523                                 VERSION, board_desc[bd->type], (long)bd->port,
1524                                         (long)bd->membase, bd->numports);
1525         memwinoff(bd, 0);
1526 }
1527
1528 static void epcapoll(unsigned long ignored)
1529 {
1530         unsigned long flags;
1531         int crd;
1532         unsigned int head, tail;
1533         struct channel *ch;
1534         struct board_info *bd;
1535
1536         /*
1537          * This routine is called upon every timer interrupt. Even though the
1538          * Digi series cards are capable of generating interrupts this method
1539          * of non-looping polling is more efficient. This routine checks for
1540          * card generated events (Such as receive data, are transmit buffer
1541          * empty) and acts on those events.
1542          */
1543         for (crd = 0; crd < num_cards; crd++) {
1544                 bd = &boards[crd];
1545                 ch = card_ptr[crd];
1546
1547                 if ((bd->status == DISABLED) || digi_poller_inhibited)
1548                         continue;
1549
1550                 /*
1551                  * assertmemoff is not needed here; indeed it is an empty
1552                  * subroutine. It is being kept because future boards may need
1553                  * this as well as some legacy boards.
1554                  */
1555                 spin_lock_irqsave(&epca_lock, flags);
1556
1557                 assertmemoff(ch);
1558
1559                 globalwinon(ch);
1560
1561                 /*
1562                  * In this case head and tail actually refer to the event queue
1563                  * not the transmit or receive queue.
1564                  */
1565                 head = readw(&ch->mailbox->ein);
1566                 tail = readw(&ch->mailbox->eout);
1567
1568                 /* If head isn't equal to tail we have an event */
1569                 if (head != tail)
1570                         doevent(crd);
1571                 memoff(ch);
1572
1573                 spin_unlock_irqrestore(&epca_lock, flags);
1574         } /* End for each card */
1575         mod_timer(&epca_timer, jiffies + (HZ / 25));
1576 }
1577
1578 static void doevent(int crd)
1579 {
1580         void __iomem *eventbuf;
1581         struct channel *ch, *chan0;
1582         static struct tty_struct *tty;
1583         struct board_info *bd;
1584         struct board_chan __iomem *bc;
1585         unsigned int tail, head;
1586         int event, channel;
1587         int mstat, lstat;
1588
1589         /*
1590          * This subroutine is called by epcapoll when an event is detected
1591          * in the event queue. This routine responds to those events.
1592          */
1593         bd = &boards[crd];
1594
1595         chan0 = card_ptr[crd];
1596         epcaassert(chan0 <= &digi_channels[nbdevs - 1], "ch out of range");
1597         assertgwinon(chan0);
1598         while ((tail = readw(&chan0->mailbox->eout)) !=
1599                         (head = readw(&chan0->mailbox->ein))) {
1600                 /* Begin while something in event queue */
1601                 assertgwinon(chan0);
1602                 eventbuf = bd->re_map_membase + tail + ISTART;
1603                 /* Get the channel the event occurred on */
1604                 channel = readb(eventbuf);
1605                 /* Get the actual event code that occurred */
1606                 event = readb(eventbuf + 1);
1607                 /*
1608                  * The two assignments below get the current modem status
1609                  * (mstat) and the previous modem status (lstat). These are
1610                  * useful becuase an event could signal a change in modem
1611                  * signals itself.
1612                  */
1613                 mstat = readb(eventbuf + 2);
1614                 lstat = readb(eventbuf + 3);
1615
1616                 ch = chan0 + channel;
1617                 if ((unsigned)channel >= bd->numports || !ch)  {
1618                         if (channel >= bd->numports)
1619                                 ch = chan0;
1620                         bc = ch->brdchan;
1621                         goto next;
1622                 }
1623
1624                 bc = ch->brdchan;
1625                 if (bc == NULL)
1626                         goto next;
1627
1628                 if (event & DATA_IND)  { /* Begin DATA_IND */
1629                         receive_data(ch);
1630                         assertgwinon(ch);
1631                 } /* End DATA_IND */
1632                 /* else *//* Fix for DCD transition missed bug */
1633                 if (event & MODEMCHG_IND) {
1634                         /* A modem signal change has been indicated */
1635                         ch->imodem = mstat;
1636                         if (ch->asyncflags & ASYNC_CHECK_CD) {
1637                                 /* We are now receiving dcd */
1638                                 if (mstat & ch->dcd)
1639                                         wake_up_interruptible(&ch->open_wait);
1640                                 else    /* No dcd; hangup */
1641                                         pc_sched_event(ch, EPCA_EVENT_HANGUP);
1642                         }
1643                 }
1644                 tty = ch->tty;
1645                 if (tty) {
1646                         if (event & BREAK_IND) {
1647                                 /* A break has been indicated */
1648                                 tty_insert_flip_char(tty, 0, TTY_BREAK);
1649                                 tty_schedule_flip(tty);
1650                         } else if (event & LOWTX_IND)  {
1651                                 if (ch->statusflags & LOWWAIT) {
1652                                         ch->statusflags &= ~LOWWAIT;
1653                                         tty_wakeup(tty);
1654                                 }
1655                         } else if (event & EMPTYTX_IND) {
1656                                 /* This event is generated by
1657                                    setup_empty_event */
1658                                 ch->statusflags &= ~TXBUSY;
1659                                 if (ch->statusflags & EMPTYWAIT) {
1660                                         ch->statusflags &= ~EMPTYWAIT;
1661                                         tty_wakeup(tty);
1662                                 }
1663                         }
1664                 }
1665 next:
1666                 globalwinon(ch);
1667                 BUG_ON(!bc);
1668                 writew(1, &bc->idata);
1669                 writew((tail + 4) & (IMAX - ISTART - 4), &chan0->mailbox->eout);
1670                 globalwinon(chan0);
1671         } /* End while something in event queue */
1672 }
1673
1674 static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
1675                                         int byte2, int ncmds, int bytecmd)
1676 {
1677         unchar __iomem *memaddr;
1678         unsigned int head, cmdTail, cmdStart, cmdMax;
1679         long count;
1680         int n;
1681
1682         /* This is the routine in which commands may be passed to the card. */
1683
1684         if (ch->board->status == DISABLED)
1685                 return;
1686         assertgwinon(ch);
1687         /* Remember head (As well as max) is just an offset not a base addr */
1688         head = readw(&ch->mailbox->cin);
1689         /* cmdStart is a base address */
1690         cmdStart = readw(&ch->mailbox->cstart);
1691         /*
1692          * We do the addition below because we do not want a max pointer
1693          * relative to cmdStart. We want a max pointer that points at the
1694          * physical end of the command queue.
1695          */
1696         cmdMax = (cmdStart + 4 + readw(&ch->mailbox->cmax));
1697         memaddr = ch->board->re_map_membase;
1698
1699         if (head >= (cmdMax - cmdStart) || (head & 03))  {
1700                 printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n",
1701                                                 __LINE__,  cmd, head);
1702                 printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n",
1703                                                 __LINE__,  cmdMax, cmdStart);
1704                 return;
1705         }
1706         if (bytecmd)  {
1707                 writeb(cmd, memaddr + head + cmdStart + 0);
1708                 writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
1709                 /* Below word_or_byte is bits to set */
1710                 writeb(word_or_byte,  memaddr + head + cmdStart + 2);
1711                 /* Below byte2 is bits to reset */
1712                 writeb(byte2, memaddr + head + cmdStart + 3);
1713         }  else {
1714                 writeb(cmd, memaddr + head + cmdStart + 0);
1715                 writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
1716                 writeb(word_or_byte,  memaddr + head + cmdStart + 2);
1717         }
1718         head = (head + 4) & (cmdMax - cmdStart - 4);
1719         writew(head, &ch->mailbox->cin);
1720         count = FEPTIMEOUT;
1721
1722         for (;;) {
1723                 count--;
1724                 if (count == 0)  {
1725                         printk(KERN_ERR "<Error> - Fep not responding in fepcmd()\n");
1726                         return;
1727                 }
1728                 head = readw(&ch->mailbox->cin);
1729                 cmdTail = readw(&ch->mailbox->cout);
1730                 n = (head - cmdTail) & (cmdMax - cmdStart - 4);
1731                 /*
1732                  * Basically this will break when the FEP acknowledges the
1733                  * command by incrementing cmdTail (Making it equal to head).
1734                  */
1735                 if (n <= ncmds * (sizeof(short) * 4))
1736                         break;
1737         }
1738 }
1739
1740 /*
1741  * Digi products use fields in their channels structures that are very similar
1742  * to the c_cflag and c_iflag fields typically found in UNIX termios
1743  * structures. The below three routines allow mappings between these hardware
1744  * "flags" and their respective Linux flags.
1745  */
1746 static unsigned termios2digi_h(struct channel *ch, unsigned cflag)
1747 {
1748         unsigned res = 0;
1749
1750         if (cflag & CRTSCTS) {
1751                 ch->digiext.digi_flags |= (RTSPACE | CTSPACE);
1752                 res |= ((ch->m_cts) | (ch->m_rts));
1753         }
1754
1755         if (ch->digiext.digi_flags & RTSPACE)
1756                 res |= ch->m_rts;
1757
1758         if (ch->digiext.digi_flags & DTRPACE)
1759                 res |= ch->m_dtr;
1760
1761         if (ch->digiext.digi_flags & CTSPACE)
1762                 res |= ch->m_cts;
1763
1764         if (ch->digiext.digi_flags & DSRPACE)
1765                 res |= ch->dsr;
1766
1767         if (ch->digiext.digi_flags & DCDPACE)
1768                 res |= ch->dcd;
1769
1770         if (res & (ch->m_rts))
1771                 ch->digiext.digi_flags |= RTSPACE;
1772
1773         if (res & (ch->m_cts))
1774                 ch->digiext.digi_flags |= CTSPACE;
1775
1776         return res;
1777 }
1778
1779 static unsigned termios2digi_i(struct channel *ch, unsigned iflag)
1780 {
1781         unsigned res = iflag & (IGNBRK | BRKINT | IGNPAR | PARMRK |
1782                                         INPCK | ISTRIP | IXON | IXANY | IXOFF);
1783         if (ch->digiext.digi_flags & DIGI_AIXON)
1784                 res |= IAIXON;
1785         return res;
1786 }
1787
1788 static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
1789 {
1790         unsigned res = 0;
1791         if (cflag & CBAUDEX) {
1792                 ch->digiext.digi_flags |= DIGI_FAST;
1793                 /*
1794                  * HUPCL bit is used by FEP to indicate fast baud table is to
1795                  * be used.
1796                  */
1797                 res |= FEP_HUPCL;
1798         } else
1799                 ch->digiext.digi_flags &= ~DIGI_FAST;
1800         /*
1801          * CBAUD has bit position 0x1000 set these days to indicate Linux
1802          * baud rate remap. Digi hardware can't handle the bit assignment.
1803          * (We use a different bit assignment for high speed.). Clear this
1804          * bit out.
1805          */
1806         res |= cflag & ((CBAUD ^ CBAUDEX) | PARODD | PARENB | CSTOPB | CSIZE);
1807         /*
1808          * This gets a little confusing. The Digi cards have their own
1809          * representation of c_cflags controlling baud rate. For the most part
1810          * this is identical to the Linux implementation. However; Digi
1811          * supports one rate (76800) that Linux doesn't. This means that the
1812          * c_cflag entry that would normally mean 76800 for Digi actually means
1813          * 115200 under Linux. Without the below mapping, a stty 115200 would
1814          * only drive the board at 76800. Since the rate 230400 is also found
1815          * after 76800, the same problem afflicts us when we choose a rate of
1816          * 230400. Without the below modificiation stty 230400 would actually
1817          * give us 115200.
1818          *
1819          * There are two additional differences. The Linux value for CLOCAL
1820          * (0x800; 0004000) has no meaning to the Digi hardware. Also in later
1821          * releases of Linux; the CBAUD define has CBAUDEX (0x1000; 0010000)
1822          * ored into it (CBAUD = 0x100f as opposed to 0xf). CBAUDEX should be
1823          * checked for a screened out prior to termios2digi_c returning. Since
1824          * CLOCAL isn't used by the board this can be ignored as long as the
1825          * returned value is used only by Digi hardware.
1826          */
1827         if (cflag & CBAUDEX) {
1828                 /*
1829                  * The below code is trying to guarantee that only baud rates
1830                  * 115200 and 230400 are remapped. We use exclusive or because
1831                  * the various baud rates share common bit positions and
1832                  * therefore can't be tested for easily.
1833                  */
1834                 if ((!((cflag & 0x7) ^ (B115200 & ~CBAUDEX))) ||
1835                     (!((cflag & 0x7) ^ (B230400 & ~CBAUDEX))))
1836                         res += 1;
1837         }
1838         return res;
1839 }
1840
1841 /* Caller must hold the locks */
1842 static void epcaparam(struct tty_struct *tty, struct channel *ch)
1843 {
1844         unsigned int cmdHead;
1845         struct ktermios *ts;
1846         struct board_chan __iomem *bc;
1847         unsigned mval, hflow, cflag, iflag;
1848
1849         bc = ch->brdchan;
1850         epcaassert(bc != NULL, "bc out of range");
1851
1852         assertgwinon(ch);
1853         ts = tty->termios;
1854         if ((ts->c_cflag & CBAUD) == 0)  { /* Begin CBAUD detected */
1855                 cmdHead = readw(&bc->rin);
1856                 writew(cmdHead, &bc->rout);
1857                 cmdHead = readw(&bc->tin);
1858                 /* Changing baud in mid-stream transmission can be wonderful */
1859                 /*
1860                  * Flush current transmit buffer by setting cmdTail pointer
1861                  * (tout) to cmdHead pointer (tin). Hopefully the transmit
1862                  * buffer is empty.
1863                  */
1864                 fepcmd(ch, STOUT, (unsigned) cmdHead, 0, 0, 0);
1865                 mval = 0;
1866         } else { /* Begin CBAUD not detected */
1867                 /*
1868                  * c_cflags have changed but that change had nothing to do with
1869                  * BAUD. Propagate the change to the card.
1870                  */
1871                 cflag = termios2digi_c(ch, ts->c_cflag);
1872                 if (cflag != ch->fepcflag)  {
1873                         ch->fepcflag = cflag;
1874                         /* Set baud rate, char size, stop bits, parity */
1875                         fepcmd(ch, SETCTRLFLAGS, (unsigned) cflag, 0, 0, 0);
1876                 }
1877                 /*
1878                  * If the user has not forced CLOCAL and if the device is not a
1879                  * CALLOUT device (Which is always CLOCAL) we set flags such
1880                  * that the driver will wait on carrier detect.
1881                  */
1882                 if (ts->c_cflag & CLOCAL)
1883                         ch->asyncflags &= ~ASYNC_CHECK_CD;
1884                 else
1885                         ch->asyncflags |= ASYNC_CHECK_CD;
1886                 mval = ch->m_dtr | ch->m_rts;
1887         } /* End CBAUD not detected */
1888         iflag = termios2digi_i(ch, ts->c_iflag);
1889         /* Check input mode flags */
1890         if (iflag != ch->fepiflag)  {
1891                 ch->fepiflag = iflag;
1892                 /*
1893                  * Command sets channels iflag structure on the board. Such
1894                  * things as input soft flow control, handling of parity
1895                  * errors, and break handling are all set here.
1896                  *
1897                  * break handling, parity handling, input stripping,
1898                  * flow control chars
1899                  */
1900                 fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0);
1901         }
1902         /*
1903          * Set the board mint value for this channel. This will cause hardware
1904          * events to be generated each time the DCD signal (Described in mint)
1905          * changes.
1906          */
1907         writeb(ch->dcd, &bc->mint);
1908         if ((ts->c_cflag & CLOCAL) || (ch->digiext.digi_flags & DIGI_FORCEDCD))
1909                 if (ch->digiext.digi_flags & DIGI_FORCEDCD)
1910                         writeb(0, &bc->mint);
1911         ch->imodem = readb(&bc->mstat);
1912         hflow = termios2digi_h(ch, ts->c_cflag);
1913         if (hflow != ch->hflow)  {
1914                 ch->hflow = hflow;
1915                 /*
1916                  * Hard flow control has been selected but the board is not
1917                  * using it. Activate hard flow control now.
1918                  */
1919                 fepcmd(ch, SETHFLOW, hflow, 0xff, 0, 1);
1920         }
1921         mval ^= ch->modemfake & (mval ^ ch->modem);
1922
1923         if (ch->omodem ^ mval)  {
1924                 ch->omodem = mval;
1925                 /*
1926                  * The below command sets the DTR and RTS mstat structure. If
1927                  * hard flow control is NOT active these changes will drive the
1928                  * output of the actual DTR and RTS lines. If hard flow control
1929                  * is active, the changes will be saved in the mstat structure
1930                  * and only asserted when hard flow control is turned off.
1931                  */
1932
1933                 /* First reset DTR & RTS; then set them */
1934                 fepcmd(ch, SETMODEM, 0, ((ch->m_dtr)|(ch->m_rts)), 0, 1);
1935                 fepcmd(ch, SETMODEM, mval, 0, 0, 1);
1936         }
1937         if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc)  {
1938                 ch->fepstartc = ch->startc;
1939                 ch->fepstopc = ch->stopc;
1940                 /*
1941                  * The XON / XOFF characters have changed; propagate these
1942                  * changes to the card.
1943                  */
1944                 fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
1945         }
1946         if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca)  {
1947                 ch->fepstartca = ch->startca;
1948                 ch->fepstopca = ch->stopca;
1949                 /*
1950                  * Similar to the above, this time the auxilarly XON / XOFF
1951                  * characters have changed; propagate these changes to the card.
1952                  */
1953                 fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
1954         }
1955 }
1956
1957 /* Caller holds lock */
1958 static void receive_data(struct channel *ch)
1959 {
1960         unchar *rptr;
1961         struct ktermios *ts = NULL;
1962         struct tty_struct *tty;
1963         struct board_chan __iomem *bc;
1964         int dataToRead, wrapgap, bytesAvailable;
1965         unsigned int tail, head;
1966         unsigned int wrapmask;
1967
1968         /*
1969          * This routine is called by doint when a receive data event has taken
1970          * place.
1971          */
1972         globalwinon(ch);
1973         if (ch->statusflags & RXSTOPPED)
1974                 return;
1975         tty = ch->tty;
1976         if (tty)
1977                 ts = tty->termios;
1978         bc = ch->brdchan;
1979         BUG_ON(!bc);
1980         wrapmask = ch->rxbufsize - 1;
1981
1982         /*
1983          * Get the head and tail pointers to the receiver queue. Wrap the head
1984          * pointer if it has reached the end of the buffer.
1985          */
1986         head = readw(&bc->rin);
1987         head &= wrapmask;
1988         tail = readw(&bc->rout) & wrapmask;
1989
1990         bytesAvailable = (head - tail) & wrapmask;
1991         if (bytesAvailable == 0)
1992                 return;
1993
1994         /* If CREAD bit is off or device not open, set TX tail to head */
1995         if (!tty || !ts || !(ts->c_cflag & CREAD)) {
1996                 writew(head, &bc->rout);
1997                 return;
1998         }
1999
2000         if (tty_buffer_request_room(tty, bytesAvailable + 1) == 0)
2001                 return;
2002
2003         if (readb(&bc->orun)) {
2004                 writeb(0, &bc->orun);
2005                 printk(KERN_WARNING "epca; overrun! DigiBoard device %s\n",
2006                                                                 tty->name);
2007                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
2008         }
2009         rxwinon(ch);
2010         while (bytesAvailable > 0) {
2011                 /* Begin while there is data on the card */
2012                 wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
2013                 /*
2014                  * Even if head has wrapped around only report the amount of
2015                  * data to be equal to the size - tail. Remember memcpy can't
2016                  * automaticly wrap around the receive buffer.
2017                  */
2018                 dataToRead = (wrapgap < bytesAvailable) ? wrapgap
2019                                                         : bytesAvailable;
2020                 /* Make sure we don't overflow the buffer */
2021                 dataToRead = tty_prepare_flip_string(tty, &rptr, dataToRead);
2022                 if (dataToRead == 0)
2023                         break;
2024                 /*
2025                  * Move data read from our card into the line disciplines
2026                  * buffer for translation if necessary.
2027                  */
2028                 memcpy_fromio(rptr, ch->rxptr + tail, dataToRead);
2029                 tail = (tail + dataToRead) & wrapmask;
2030                 bytesAvailable -= dataToRead;
2031         } /* End while there is data on the card */
2032         globalwinon(ch);
2033         writew(tail, &bc->rout);
2034         /* Must be called with global data */
2035         tty_schedule_flip(ch->tty);
2036 }
2037
2038 static int info_ioctl(struct tty_struct *tty, struct file *file,
2039                     unsigned int cmd, unsigned long arg)
2040 {
2041         switch (cmd) {
2042         case DIGI_GETINFO:
2043                 {
2044                         struct digi_info di;
2045                         int brd;
2046
2047                         if (get_user(brd, (unsigned int __user *)arg))
2048                                 return -EFAULT;
2049                         if (brd < 0 || brd >= num_cards || num_cards == 0)
2050                                 return -ENODEV;
2051
2052                         memset(&di, 0, sizeof(di));
2053
2054                         di.board = brd;
2055                         di.status = boards[brd].status;
2056                         di.type = boards[brd].type ;
2057                         di.numports = boards[brd].numports ;
2058                         /* Legacy fixups - just move along nothing to see */
2059                         di.port = (unsigned char *)boards[brd].port ;
2060                         di.membase = (unsigned char *)boards[brd].membase ;
2061
2062                         if (copy_to_user((void __user *)arg, &di, sizeof(di)))
2063                                 return -EFAULT;
2064                         break;
2065
2066                 }
2067
2068         case DIGI_POLLER:
2069                 {
2070                         int brd = arg & 0xff000000 >> 16;
2071                         unsigned char state = arg & 0xff;
2072
2073                         if (brd < 0 || brd >= num_cards) {
2074                                 printk(KERN_ERR "epca: DIGI POLLER : brd not valid!\n");
2075                                 return -ENODEV;
2076                         }
2077                         digi_poller_inhibited = state;
2078                         break;
2079                 }
2080
2081         case DIGI_INIT:
2082                 {
2083                         /*
2084                          * This call is made by the apps to complete the
2085                          * initialization of the board(s). This routine is
2086                          * responsible for setting the card to its initial
2087                          * state and setting the drivers control fields to the
2088                          * sutianle settings for the card in question.
2089                          */
2090                         int crd;
2091                         for (crd = 0; crd < num_cards; crd++)
2092                                 post_fep_init(crd);
2093                         break;
2094                 }
2095         default:
2096                 return -ENOTTY;
2097         }
2098         return 0;
2099 }
2100
2101 static int pc_tiocmget(struct tty_struct *tty, struct file *file)
2102 {
2103         struct channel *ch = (struct channel *) tty->driver_data;
2104         struct board_chan __iomem *bc;
2105         unsigned int mstat, mflag = 0;
2106         unsigned long flags;
2107
2108         if (ch)
2109                 bc = ch->brdchan;
2110         else
2111                 return -EINVAL;
2112
2113         spin_lock_irqsave(&epca_lock, flags);
2114         globalwinon(ch);
2115         mstat = readb(&bc->mstat);
2116         memoff(ch);
2117         spin_unlock_irqrestore(&epca_lock, flags);
2118
2119         if (mstat & ch->m_dtr)
2120                 mflag |= TIOCM_DTR;
2121         if (mstat & ch->m_rts)
2122                 mflag |= TIOCM_RTS;
2123         if (mstat & ch->m_cts)
2124                 mflag |= TIOCM_CTS;
2125         if (mstat & ch->dsr)
2126                 mflag |= TIOCM_DSR;
2127         if (mstat & ch->m_ri)
2128                 mflag |= TIOCM_RI;
2129         if (mstat & ch->dcd)
2130                 mflag |= TIOCM_CD;
2131         return mflag;
2132 }
2133
2134 static int pc_tiocmset(struct tty_struct *tty, struct file *file,
2135                        unsigned int set, unsigned int clear)
2136 {
2137         struct channel *ch = (struct channel *) tty->driver_data;
2138         unsigned long flags;
2139
2140         if (!ch)
2141                 return -EINVAL;
2142
2143         spin_lock_irqsave(&epca_lock, flags);
2144         /*
2145          * I think this modemfake stuff is broken. It doesn't correctly reflect
2146          * the behaviour desired by the TIOCM* ioctls. Therefore this is
2147          * probably broken.
2148          */
2149         if (set & TIOCM_RTS) {
2150                 ch->modemfake |= ch->m_rts;
2151                 ch->modem |= ch->m_rts;
2152         }
2153         if (set & TIOCM_DTR) {
2154                 ch->modemfake |= ch->m_dtr;
2155                 ch->modem |= ch->m_dtr;
2156         }
2157         if (clear & TIOCM_RTS) {
2158                 ch->modemfake |= ch->m_rts;
2159                 ch->modem &= ~ch->m_rts;
2160         }
2161         if (clear & TIOCM_DTR) {
2162                 ch->modemfake |= ch->m_dtr;
2163                 ch->modem &= ~ch->m_dtr;
2164         }
2165         globalwinon(ch);
2166         /*
2167          * The below routine generally sets up parity, baud, flow control
2168          * issues, etc.... It effect both control flags and input flags.
2169          */
2170         epcaparam(tty, ch);
2171         memoff(ch);
2172         spin_unlock_irqrestore(&epca_lock, flags);
2173         return 0;
2174 }
2175
2176 static int pc_ioctl(struct tty_struct *tty, struct file *file,
2177                                         unsigned int cmd, unsigned long arg)
2178 {
2179         digiflow_t dflow;
2180         int retval;
2181         unsigned long flags;
2182         unsigned int mflag, mstat;
2183         unsigned char startc, stopc;
2184         struct board_chan __iomem *bc;
2185         struct channel *ch = (struct channel *) tty->driver_data;
2186         void __user *argp = (void __user *)arg;
2187
2188         if (ch)
2189                 bc = ch->brdchan;
2190         else
2191                 return -EINVAL;
2192         /*
2193          * For POSIX compliance we need to add more ioctls. See tty_ioctl.c in
2194          * /usr/src/linux/drivers/char for a good example. In particular think
2195          * about adding TCSETAF, TCSETAW, TCSETA, TCSETSF, TCSETSW, TCSETS.
2196          */
2197         switch (cmd) {
2198         case TCSBRK:    /* SVID version: non-zero arg --> no break */
2199                 retval = tty_check_change(tty);
2200                 if (retval)
2201                         return retval;
2202                 /* Setup an event to indicate when the transmit
2203                    buffer empties */
2204                 spin_lock_irqsave(&epca_lock, flags);
2205                 setup_empty_event(tty, ch);
2206                 spin_unlock_irqrestore(&epca_lock, flags);
2207                 tty_wait_until_sent(tty, 0);
2208                 if (!arg)
2209                         digi_send_break(ch, HZ / 4);    /* 1/4 second */
2210                 return 0;
2211         case TCSBRKP:   /* support for POSIX tcsendbreak() */
2212                 retval = tty_check_change(tty);
2213                 if (retval)
2214                         return retval;
2215                 /* Setup an event to indicate when the transmit buffer
2216                    empties */
2217                 spin_lock_irqsave(&epca_lock, flags);
2218                 setup_empty_event(tty, ch);
2219                 spin_unlock_irqrestore(&epca_lock, flags);
2220                 tty_wait_until_sent(tty, 0);
2221                 digi_send_break(ch, arg ? arg*(HZ/10) : HZ/4);
2222                 return 0;
2223         case TIOCMODG:
2224                 mflag = pc_tiocmget(tty, file);
2225                 if (put_user(mflag, (unsigned long __user *)argp))
2226                         return -EFAULT;
2227                 break;
2228         case TIOCMODS:
2229                 if (get_user(mstat, (unsigned __user *)argp))
2230                         return -EFAULT;
2231                 return pc_tiocmset(tty, file, mstat, ~mstat);
2232         case TIOCSDTR:
2233                 spin_lock_irqsave(&epca_lock, flags);
2234                 ch->omodem |= ch->m_dtr;
2235                 globalwinon(ch);
2236                 fepcmd(ch, SETMODEM, ch->m_dtr, 0, 10, 1);
2237                 memoff(ch);
2238                 spin_unlock_irqrestore(&epca_lock, flags);
2239                 break;
2240
2241         case TIOCCDTR:
2242                 spin_lock_irqsave(&epca_lock, flags);
2243                 ch->omodem &= ~ch->m_dtr;
2244                 globalwinon(ch);
2245                 fepcmd(ch, SETMODEM, 0, ch->m_dtr, 10, 1);
2246                 memoff(ch);
2247                 spin_unlock_irqrestore(&epca_lock, flags);
2248                 break;
2249         case DIGI_GETA:
2250                 if (copy_to_user(argp, &ch->digiext, sizeof(digi_t)))
2251                         return -EFAULT;
2252                 break;
2253         case DIGI_SETAW:
2254         case DIGI_SETAF:
2255                 lock_kernel();
2256                 if (cmd == DIGI_SETAW) {
2257                         /* Setup an event to indicate when the transmit
2258                            buffer empties */
2259                         spin_lock_irqsave(&epca_lock, flags);
2260                         setup_empty_event(tty, ch);
2261                         spin_unlock_irqrestore(&epca_lock, flags);
2262                         tty_wait_until_sent(tty, 0);
2263                 } else {
2264                         /* ldisc lock already held in ioctl */
2265                         if (tty->ldisc.flush_buffer)
2266                                 tty->ldisc.flush_buffer(tty);
2267                 }
2268                 unlock_kernel();
2269                 /* Fall Thru */
2270         case DIGI_SETA:
2271                 if (copy_from_user(&ch->digiext, argp, sizeof(digi_t)))
2272                         return -EFAULT;
2273
2274                 if (ch->digiext.digi_flags & DIGI_ALTPIN)  {
2275                         ch->dcd = ch->m_dsr;
2276                         ch->dsr = ch->m_dcd;
2277                 } else {
2278                         ch->dcd = ch->m_dcd;
2279                         ch->dsr = ch->m_dsr;
2280                         }
2281
2282                 spin_lock_irqsave(&epca_lock, flags);
2283                 globalwinon(ch);
2284
2285                 /*
2286                  * The below routine generally sets up parity, baud, flow
2287                  * control issues, etc.... It effect both control flags and
2288                  * input flags.
2289                  */
2290                 epcaparam(tty, ch);
2291                 memoff(ch);
2292                 spin_unlock_irqrestore(&epca_lock, flags);
2293                 break;
2294
2295         case DIGI_GETFLOW:
2296         case DIGI_GETAFLOW:
2297                 spin_lock_irqsave(&epca_lock, flags);
2298                 globalwinon(ch);
2299                 if (cmd == DIGI_GETFLOW) {
2300                         dflow.startc = readb(&bc->startc);
2301                         dflow.stopc = readb(&bc->stopc);
2302                 } else {
2303                         dflow.startc = readb(&bc->startca);
2304                         dflow.stopc = readb(&bc->stopca);
2305                 }
2306                 memoff(ch);
2307                 spin_unlock_irqrestore(&epca_lock, flags);
2308
2309                 if (copy_to_user(argp, &dflow, sizeof(dflow)))
2310                         return -EFAULT;
2311                 break;
2312
2313         case DIGI_SETAFLOW:
2314         case DIGI_SETFLOW:
2315                 if (cmd == DIGI_SETFLOW) {
2316                         startc = ch->startc;
2317                         stopc = ch->stopc;
2318                 } else {
2319                         startc = ch->startca;
2320                         stopc = ch->stopca;
2321                 }
2322
2323                 if (copy_from_user(&dflow, argp, sizeof(dflow)))
2324                         return -EFAULT;
2325
2326                 if (dflow.startc != startc || dflow.stopc != stopc) {
2327                         /* Begin  if setflow toggled */
2328                         spin_lock_irqsave(&epca_lock, flags);
2329                         globalwinon(ch);
2330
2331                         if (cmd == DIGI_SETFLOW) {
2332                                 ch->fepstartc = ch->startc = dflow.startc;
2333                                 ch->fepstopc = ch->stopc = dflow.stopc;
2334                                 fepcmd(ch, SONOFFC, ch->fepstartc,
2335                                                 ch->fepstopc, 0, 1);
2336                         } else {
2337                                 ch->fepstartca = ch->startca = dflow.startc;
2338                                 ch->fepstopca  = ch->stopca = dflow.stopc;
2339                                 fepcmd(ch, SAUXONOFFC, ch->fepstartca,
2340                                                 ch->fepstopca, 0, 1);
2341                         }
2342
2343                         if (ch->statusflags & TXSTOPPED)
2344                                 pc_start(tty);
2345
2346                         memoff(ch);
2347                         spin_unlock_irqrestore(&epca_lock, flags);
2348                 } /* End if setflow toggled */
2349                 break;
2350         default:
2351                 return -ENOIOCTLCMD;
2352         }
2353         return 0;
2354 }
2355
2356 static void pc_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2357 {
2358         struct channel *ch;
2359         unsigned long flags;
2360         /*
2361          * verifyChannel returns the channel from the tty struct if it is
2362          * valid. This serves as a sanity check.
2363          */
2364         ch = verifyChannel(tty);
2365
2366         if (ch != NULL)  { /* Begin if channel valid */
2367                 spin_lock_irqsave(&epca_lock, flags);
2368                 globalwinon(ch);
2369                 epcaparam(tty, ch);
2370                 memoff(ch);
2371                 spin_unlock_irqrestore(&epca_lock, flags);
2372
2373                 if ((old_termios->c_cflag & CRTSCTS) &&
2374                          ((tty->termios->c_cflag & CRTSCTS) == 0))
2375                         tty->hw_stopped = 0;
2376
2377                 if (!(old_termios->c_cflag & CLOCAL) &&
2378                          (tty->termios->c_cflag & CLOCAL))
2379                         wake_up_interruptible(&ch->open_wait);
2380
2381         } /* End if channel valid */
2382 }
2383
2384 static void do_softint(struct work_struct *work)
2385 {
2386         struct channel *ch = container_of(work, struct channel, tqueue);
2387         /* Called in response to a modem change event */
2388         if (ch && ch->magic == EPCA_MAGIC) {
2389                 struct tty_struct *tty = ch->tty;
2390
2391                 if (tty && tty->driver_data) {
2392                         if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) {
2393                                 tty_hangup(tty);
2394                                 wake_up_interruptible(&ch->open_wait);
2395                                 ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
2396                         }
2397                 }
2398         }
2399 }
2400
2401 /*
2402  * pc_stop and pc_start provide software flow control to the routine and the
2403  * pc_ioctl routine.
2404  */
2405 static void pc_stop(struct tty_struct *tty)
2406 {
2407         struct channel *ch;
2408         unsigned long flags;
2409         /*
2410          * verifyChannel returns the channel from the tty struct if it is
2411          * valid. This serves as a sanity check.
2412          */
2413         ch = verifyChannel(tty);
2414         if (ch != NULL) {
2415                 spin_lock_irqsave(&epca_lock, flags);
2416                 if ((ch->statusflags & TXSTOPPED) == 0) {
2417                         /* Begin if transmit stop requested */
2418                         globalwinon(ch);
2419                         /* STOP transmitting now !! */
2420                         fepcmd(ch, PAUSETX, 0, 0, 0, 0);
2421                         ch->statusflags |= TXSTOPPED;
2422                         memoff(ch);
2423                 } /* End if transmit stop requested */
2424                 spin_unlock_irqrestore(&epca_lock, flags);
2425         }
2426 }
2427
2428 static void pc_start(struct tty_struct *tty)
2429 {
2430         struct channel *ch;
2431         /*
2432          * verifyChannel returns the channel from the tty struct if it is
2433          * valid. This serves as a sanity check.
2434          */
2435         ch = verifyChannel(tty);
2436         if (ch != NULL) {
2437                 unsigned long flags;
2438                 spin_lock_irqsave(&epca_lock, flags);
2439                 /* Just in case output was resumed because of a change
2440                    in Digi-flow */
2441                 if (ch->statusflags & TXSTOPPED)  {
2442                         /* Begin transmit resume requested */
2443                         struct board_chan __iomem *bc;
2444                         globalwinon(ch);
2445                         bc = ch->brdchan;
2446                         if (ch->statusflags & LOWWAIT)
2447                                 writeb(1, &bc->ilow);
2448                         /* Okay, you can start transmitting again... */
2449                         fepcmd(ch, RESUMETX, 0, 0, 0, 0);
2450                         ch->statusflags &= ~TXSTOPPED;
2451                         memoff(ch);
2452                 } /* End transmit resume requested */
2453                 spin_unlock_irqrestore(&epca_lock, flags);
2454         }
2455 }
2456
2457 /*
2458  * The below routines pc_throttle and pc_unthrottle are used to slow (And
2459  * resume) the receipt of data into the kernels receive buffers. The exact
2460  * occurrence of this depends on the size of the kernels receive buffer and
2461  * what the 'watermarks' are set to for that buffer. See the n_ttys.c file for
2462  * more details.
2463  */
2464 static void pc_throttle(struct tty_struct *tty)
2465 {
2466         struct channel *ch;
2467         unsigned long flags;
2468         /*
2469          * verifyChannel returns the channel from the tty struct if it is
2470          * valid. This serves as a sanity check.
2471          */
2472         ch = verifyChannel(tty);
2473         if (ch != NULL) {
2474                 spin_lock_irqsave(&epca_lock, flags);
2475                 if ((ch->statusflags & RXSTOPPED) == 0) {
2476                         globalwinon(ch);
2477                         fepcmd(ch, PAUSERX, 0, 0, 0, 0);
2478                         ch->statusflags |= RXSTOPPED;
2479                         memoff(ch);
2480                 }
2481                 spin_unlock_irqrestore(&epca_lock, flags);
2482         }
2483 }
2484
2485 static void pc_unthrottle(struct tty_struct *tty)
2486 {
2487         struct channel *ch;
2488         unsigned long flags;
2489         /*
2490          * verifyChannel returns the channel from the tty struct if it is
2491          * valid. This serves as a sanity check.
2492          */
2493         ch = verifyChannel(tty);
2494         if (ch != NULL) {
2495                 /* Just in case output was resumed because of a change
2496                    in Digi-flow */
2497                 spin_lock_irqsave(&epca_lock, flags);
2498                 if (ch->statusflags & RXSTOPPED) {
2499                         globalwinon(ch);
2500                         fepcmd(ch, RESUMERX, 0, 0, 0, 0);
2501                         ch->statusflags &= ~RXSTOPPED;
2502                         memoff(ch);
2503                 }
2504                 spin_unlock_irqrestore(&epca_lock, flags);
2505         }
2506 }
2507
2508 static void digi_send_break(struct channel *ch, int msec)
2509 {
2510         unsigned long flags;
2511
2512         spin_lock_irqsave(&epca_lock, flags);
2513         globalwinon(ch);
2514         /*
2515          * Maybe I should send an infinite break here, schedule() for msec
2516          * amount of time, and then stop the break. This way, the user can't
2517          * screw up the FEP by causing digi_send_break() to be called (i.e. via
2518          * an ioctl()) more than once in msec amount of time.
2519          * Try this for now...
2520          */
2521         fepcmd(ch, SENDBREAK, msec, 0, 10, 0);
2522         memoff(ch);
2523         spin_unlock_irqrestore(&epca_lock, flags);
2524 }
2525
2526 /* Caller MUST hold the lock */
2527 static void setup_empty_event(struct tty_struct *tty, struct channel *ch)
2528 {
2529         struct board_chan __iomem *bc = ch->brdchan;
2530
2531         globalwinon(ch);
2532         ch->statusflags |= EMPTYWAIT;
2533         /*
2534          * When set the iempty flag request a event to be generated when the
2535          * transmit buffer is empty (If there is no BREAK in progress).
2536          */
2537         writeb(1, &bc->iempty);
2538         memoff(ch);
2539 }
2540
2541 static void epca_setup(char *str, int *ints)
2542 {
2543         struct board_info board;
2544         int               index, loop, last;
2545         char              *temp, *t2;
2546         unsigned          len;
2547
2548         /*
2549          * If this routine looks a little strange it is because it is only
2550          * called if a LILO append command is given to boot the kernel with
2551          * parameters. In this way, we can provide the user a method of
2552          * changing his board configuration without rebuilding the kernel.
2553          */
2554         if (!liloconfig)
2555                 liloconfig = 1;
2556
2557         memset(&board, 0, sizeof(board));
2558
2559         /* Assume the data is int first, later we can change it */
2560         /* I think that array position 0 of ints holds the number of args */
2561         for (last = 0, index = 1; index <= ints[0]; index++)
2562                 switch (index) { /* Begin parse switch */
2563                 case 1:
2564                         board.status = ints[index];
2565                         /*
2566                          * We check for 2 (As opposed to 1; because 2 is a flag
2567                          * instructing the driver to ignore epcaconfig.) For
2568                          * this reason we check for 2.
2569                          */
2570                         if (board.status == 2) {
2571                         /* Begin ignore epcaconfig as well as lilo cmd line */
2572                                 nbdevs = 0;
2573                                 num_cards = 0;
2574                                 return;
2575                         } /* End ignore epcaconfig as well as lilo cmd line */
2576
2577                         if (board.status > 2) {
2578                                 printk(KERN_ERR "epca_setup: Invalid board status 0x%x\n",
2579                                                 board.status);
2580                                 invalid_lilo_config = 1;
2581                                 setup_error_code |= INVALID_BOARD_STATUS;
2582                                 return;
2583                         }
2584                         last = index;
2585                         break;
2586                 case 2:
2587                         board.type = ints[index];
2588                         if (board.type >= PCIXEM)  {
2589                                 printk(KERN_ERR "epca_setup: Invalid board type 0x%x\n", board.type);
2590                                 invalid_lilo_config = 1;
2591                                 setup_error_code |= INVALID_BOARD_TYPE;
2592                                 return;
2593                         }
2594                         last = index;
2595                         break;
2596                 case 3:
2597                         board.altpin = ints[index];
2598                         if (board.altpin > 1) {
2599                                 printk(KERN_ERR "epca_setup: Invalid board altpin 0x%x\n", board.altpin);
2600                                 invalid_lilo_config = 1;
2601                                 setup_error_code |= INVALID_ALTPIN;
2602                                 return;
2603                         }
2604                         last = index;
2605                         break;
2606
2607                 case 4:
2608                         board.numports = ints[index];
2609                         if (board.numports < 2 || board.numports > 256) {
2610                                 printk(KERN_ERR "epca_setup: Invalid board numports 0x%x\n", board.numports);
2611                                 invalid_lilo_config = 1;
2612                                 setup_error_code |= INVALID_NUM_PORTS;
2613                                 return;
2614                         }
2615                         nbdevs += board.numports;
2616                         last = index;
2617                         break;
2618
2619                 case 5:
2620                         board.port = ints[index];
2621                         if (ints[index] <= 0) {
2622                                 printk(KERN_ERR "epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
2623                                 invalid_lilo_config = 1;
2624                                 setup_error_code |= INVALID_PORT_BASE;
2625                                 return;
2626                         }
2627                         last = index;
2628                         break;
2629
2630                 case 6:
2631                         board.membase = ints[index];
2632                         if (ints[index] <= 0) {
2633                                 printk(KERN_ERR "epca_setup: Invalid memory base 0x%x\n",
2634                                         (unsigned int)board.membase);
2635                                 invalid_lilo_config = 1;
2636                                 setup_error_code |= INVALID_MEM_BASE;
2637                                 return;
2638                         }
2639                         last = index;
2640                         break;
2641
2642                 default:
2643                         printk(KERN_ERR "<Error> - epca_setup: Too many integer parms\n");
2644                         return;
2645
2646                 } /* End parse switch */
2647
2648         while (str && *str)  { /* Begin while there is a string arg */
2649                 /* find the next comma or terminator */
2650                 temp = str;
2651                 /* While string is not null, and a comma hasn't been found */
2652                 while (*temp && (*temp != ','))
2653                         temp++;
2654                 if (!*temp)
2655                         temp = NULL;
2656                 else
2657                         *temp++ = 0;
2658                 /* Set index to the number of args + 1 */
2659                 index = last + 1;
2660
2661                 switch (index) {
2662                 case 1:
2663                         len = strlen(str);
2664                         if (strncmp("Disable", str, len) == 0)
2665                                 board.status = 0;
2666                         else if (strncmp("Enable", str, len) == 0)
2667                                 board.status = 1;
2668                         else {
2669                                 printk(KERN_ERR "epca_setup: Invalid status %s\n", str);
2670                                 invalid_lilo_config = 1;
2671                                 setup_error_code |= INVALID_BOARD_STATUS;
2672                                 return;
2673                         }
2674                         last = index;
2675                         break;
2676
2677                 case 2:
2678                         for (loop = 0; loop < EPCA_NUM_TYPES; loop++)
2679                                 if (strcmp(board_desc[loop], str) == 0)
2680                                         break;
2681                         /*
2682                          * If the index incremented above refers to a
2683                          * legitamate board type set it here.
2684                          */
2685                         if (index < EPCA_NUM_TYPES)
2686                                 board.type = loop;
2687                         else {
2688                                 printk(KERN_ERR "epca_setup: Invalid board type: %s\n", str);
2689                                 invalid_lilo_config = 1;
2690                                 setup_error_code |= INVALID_BOARD_TYPE;
2691                                 return;
2692                         }
2693                         last = index;
2694                         break;
2695
2696                 case 3:
2697                         len = strlen(str);
2698                         if (strncmp("Disable", str, len) == 0)
2699                                 board.altpin = 0;
2700                         else if (strncmp("Enable", str, len) == 0)
2701                                 board.altpin = 1;
2702                         else {
2703                                 printk(KERN_ERR "epca_setup: Invalid altpin %s\n", str);
2704                                 invalid_lilo_config = 1;
2705                                 setup_error_code |= INVALID_ALTPIN;
2706                                 return;
2707                         }
2708                         last = index;
2709                         break;
2710
2711                 case 4:
2712                         t2 = str;
2713                         while (isdigit(*t2))
2714                                 t2++;
2715
2716                         if (*t2) {
2717                                 printk(KERN_ERR "epca_setup: Invalid port count %s\n", str);
2718                                 invalid_lilo_config = 1;
2719                                 setup_error_code |= INVALID_NUM_PORTS;
2720                                 return;
2721                         }
2722
2723                         /*
2724                          * There is not a man page for simple_strtoul but the
2725                          * code can be found in vsprintf.c. The first argument
2726                          * is the string to translate (To an unsigned long
2727                          * obviously), the second argument can be the address
2728                          * of any character variable or a NULL. If a variable
2729                          * is given, the end pointer of the string will be
2730                          * stored in that variable; if a NULL is given the end
2731                          * pointer will not be returned. The last argument is
2732                          * the base to use. If a 0 is indicated, the routine
2733                          * will attempt to determine the proper base by looking
2734                          * at the values prefix (A '0' for octal, a 'x' for
2735                          * hex, etc ... If a value is given it will use that
2736                          * value as the base.
2737                          */
2738                         board.numports = simple_strtoul(str, NULL, 0);
2739                         nbdevs += board.numports;
2740                         last = index;
2741                         break;
2742
2743                 case 5:
2744                         t2 = str;
2745                         while (isxdigit(*t2))
2746                                 t2++;
2747
2748                         if (*t2) {
2749                                 printk(KERN_ERR "epca_setup: Invalid i/o address %s\n", str);
2750                                 invalid_lilo_config = 1;
2751                                 setup_error_code |= INVALID_PORT_BASE;
2752                                 return;
2753                         }
2754
2755                         board.port = simple_strtoul(str, NULL, 16);
2756                         last = index;
2757                         break;
2758
2759                 case 6:
2760                         t2 = str;
2761                         while (isxdigit(*t2))
2762                                 t2++;
2763
2764                         if (*t2) {
2765                                 printk(KERN_ERR "epca_setup: Invalid memory base %s\n", str);
2766                                 invalid_lilo_config = 1;
2767                                 setup_error_code |= INVALID_MEM_BASE;
2768                                 return;
2769                         }
2770                         board.membase = simple_strtoul(str, NULL, 16);
2771                         last = index;
2772                         break;
2773                 default:
2774                         printk(KERN_ERR "epca: Too many string parms\n");
2775                         return;
2776                 }
2777                 str = temp;
2778         } /* End while there is a string arg */
2779
2780         if (last < 6) {
2781                 printk(KERN_ERR "epca: Insufficient parms specified\n");
2782                 return;
2783         }
2784
2785         /* I should REALLY validate the stuff here */
2786         /* Copies our local copy of board into boards */
2787         memcpy((void *)&boards[num_cards], (void *)&board, sizeof(board));
2788         /* Does this get called once per lilo arg are what ? */
2789         printk(KERN_INFO "PC/Xx: Added board %i, %s %i ports at 0x%4.4X base 0x%6.6X\n",
2790                 num_cards, board_desc[board.type],
2791                 board.numports, (int)board.port, (unsigned int) board.membase);
2792         num_cards++;
2793 }
2794
2795 enum epic_board_types {
2796         brd_xr = 0,
2797         brd_xem,
2798         brd_cx,
2799         brd_xrj,
2800 };
2801
2802 /* indexed directly by epic_board_types enum */
2803 static struct {
2804         unsigned char board_type;
2805         unsigned bar_idx;               /* PCI base address region */
2806 } epca_info_tbl[] = {
2807         { PCIXR, 0, },
2808         { PCIXEM, 0, },
2809         { PCICX, 0, },
2810         { PCIXRJ, 2, },
2811 };
2812
2813 static int __devinit epca_init_one(struct pci_dev *pdev,
2814                                  const struct pci_device_id *ent)
2815 {
2816         static int board_num = -1;
2817         int board_idx, info_idx = ent->driver_data;
2818         unsigned long addr;
2819
2820         if (pci_enable_device(pdev))
2821                 return -EIO;
2822
2823         board_num++;
2824         board_idx = board_num + num_cards;
2825         if (board_idx >= MAXBOARDS)
2826                 goto err_out;
2827
2828         addr = pci_resource_start(pdev, epca_info_tbl[info_idx].bar_idx);
2829         if (!addr) {
2830                 printk(KERN_ERR PFX "PCI region #%d not available (size 0)\n",
2831                         epca_info_tbl[info_idx].bar_idx);
2832                 goto err_out;
2833         }
2834
2835         boards[board_idx].status = ENABLED;
2836         boards[board_idx].type = epca_info_tbl[info_idx].board_type;
2837         boards[board_idx].numports = 0x0;
2838         boards[board_idx].port = addr + PCI_IO_OFFSET;
2839         boards[board_idx].membase = addr;
2840
2841         if (!request_mem_region(addr + PCI_IO_OFFSET, 0x200000, "epca")) {
2842                 printk(KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
2843                         0x200000, addr + PCI_IO_OFFSET);
2844                 goto err_out;
2845         }
2846
2847         boards[board_idx].re_map_port = ioremap_nocache(addr + PCI_IO_OFFSET,
2848                                                                 0x200000);
2849         if (!boards[board_idx].re_map_port) {
2850                 printk(KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
2851                         0x200000, addr + PCI_IO_OFFSET);
2852                 goto err_out_free_pciio;
2853         }
2854
2855         if (!request_mem_region(addr, 0x200000, "epca")) {
2856                 printk(KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
2857                         0x200000, addr);
2858                 goto err_out_free_iounmap;
2859         }
2860
2861         boards[board_idx].re_map_membase = ioremap_nocache(addr, 0x200000);
2862         if (!boards[board_idx].re_map_membase) {
2863                 printk(KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
2864                         0x200000, addr + PCI_IO_OFFSET);
2865                 goto err_out_free_memregion;
2866         }
2867
2868         /*
2869          * I don't know what the below does, but the hardware guys say its
2870          * required on everything except PLX (In this case XRJ).
2871          */
2872         if (info_idx != brd_xrj) {
2873                 pci_write_config_byte(pdev, 0x40, 0);
2874                 pci_write_config_byte(pdev, 0x46, 0);
2875         }
2876
2877         return 0;
2878
2879 err_out_free_memregion:
2880         release_mem_region(addr, 0x200000);
2881 err_out_free_iounmap:
2882         iounmap(boards[board_idx].re_map_port);
2883 err_out_free_pciio:
2884         release_mem_region(addr + PCI_IO_OFFSET, 0x200000);
2885 err_out:
2886         return -ENODEV;
2887 }
2888
2889
2890 static struct pci_device_id epca_pci_tbl[] = {
2891         { PCI_VENDOR_DIGI, PCI_DEVICE_XR, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xr },
2892         { PCI_VENDOR_DIGI, PCI_DEVICE_XEM, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xem },
2893         { PCI_VENDOR_DIGI, PCI_DEVICE_CX, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_cx },
2894         { PCI_VENDOR_DIGI, PCI_DEVICE_XRJ, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xrj },
2895         { 0, }
2896 };
2897
2898 MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
2899
2900 static int __init init_PCI(void)
2901 {
2902         memset(&epca_driver, 0, sizeof(epca_driver));
2903         epca_driver.name = "epca";
2904         epca_driver.id_table = epca_pci_tbl;
2905         epca_driver.probe = epca_init_one;
2906
2907         return pci_register_driver(&epca_driver);
2908 }
2909
2910 MODULE_LICENSE("GPL");