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