2 Copyright (C) 1996 Digi International.
4 For technical support please email digiLinux@dgii.com or
5 call Digi tech support at (612) 912-3456
7 ** This driver is no longer supported by Digi **
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.
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.
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.
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.
27 /* See README.epca for change history --DAT*/
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/types.h>
32 #include <linux/init.h>
33 #include <linux/serial.h>
34 #include <linux/delay.h>
35 #include <linux/ctype.h>
36 #include <linux/tty.h>
37 #include <linux/tty_flip.h>
38 #include <linux/slab.h>
39 #include <linux/ioport.h>
40 #include <linux/interrupt.h>
41 #include <linux/uaccess.h>
43 #include <linux/spinlock.h>
44 #include <linux/pci.h>
51 #include "epcaconfig.h"
53 #define VERSION "1.3.0.1-LK2.6"
55 /* This major needs to be submitted to Linux to join the majors list */
56 #define DIGIINFOMAJOR 35 /* For Digi specific ioctl */
60 #define epcaassert(x, msg) if (!(x)) epca_error(__LINE__, msg)
64 static int nbdevs, num_cards, liloconfig;
65 static int digi_poller_inhibited = 1 ;
67 static int setup_error_code;
68 static int invalid_lilo_config;
71 * The ISA boards do window flipping into the same spaces so its only sane with
72 * a single lock. It's still pretty efficient. This lock guards the hardware
73 * and the tty_port lock guards the kernel side stuff like use counts. Take
74 * this lock inside the port lock if you must take both.
76 static DEFINE_SPINLOCK(epca_lock);
78 /* MAXBOARDS is typically 12, but ISA and EISA cards are restricted
80 static struct board_info boards[MAXBOARDS];
82 static struct tty_driver *pc_driver;
83 static struct tty_driver *pc_info;
85 /* ------------------ Begin Digi specific structures -------------------- */
88 * digi_channels represents an array of structures that keep track of each
89 * channel of the Digi product. Information such as transmit and receive
90 * pointers, termio data, and signal definitions (DTR, CTS, etc ...) are stored
91 * here. This structure is NOT used to overlay the cards physical channel
94 static struct channel digi_channels[MAX_ALLOC];
97 * card_ptr is an array used to hold the address of the first channel structure
98 * of each card. This array will hold the addresses of various channels located
101 static struct channel *card_ptr[MAXCARDS];
103 static struct timer_list epca_timer;
106 * Begin generic memory functions. These functions will be alias (point at)
107 * more specific functions dependent on the board being configured.
109 static void memwinon(struct board_info *b, unsigned int win);
110 static void memwinoff(struct board_info *b, unsigned int win);
111 static void globalwinon(struct channel *ch);
112 static void rxwinon(struct channel *ch);
113 static void txwinon(struct channel *ch);
114 static void memoff(struct channel *ch);
115 static void assertgwinon(struct channel *ch);
116 static void assertmemoff(struct channel *ch);
118 /* ---- Begin more 'specific' memory functions for cx_like products --- */
120 static void pcxem_memwinon(struct board_info *b, unsigned int win);
121 static void pcxem_memwinoff(struct board_info *b, unsigned int win);
122 static void pcxem_globalwinon(struct channel *ch);
123 static void pcxem_rxwinon(struct channel *ch);
124 static void pcxem_txwinon(struct channel *ch);
125 static void pcxem_memoff(struct channel *ch);
127 /* ------ Begin more 'specific' memory functions for the pcxe ------- */
129 static void pcxe_memwinon(struct board_info *b, unsigned int win);
130 static void pcxe_memwinoff(struct board_info *b, unsigned int win);
131 static void pcxe_globalwinon(struct channel *ch);
132 static void pcxe_rxwinon(struct channel *ch);
133 static void pcxe_txwinon(struct channel *ch);
134 static void pcxe_memoff(struct channel *ch);
136 /* ---- Begin more 'specific' memory functions for the pc64xe and pcxi ---- */
137 /* Note : pc64xe and pcxi share the same windowing routines */
139 static void pcxi_memwinon(struct board_info *b, unsigned int win);
140 static void pcxi_memwinoff(struct board_info *b, unsigned int win);
141 static void pcxi_globalwinon(struct channel *ch);
142 static void pcxi_rxwinon(struct channel *ch);
143 static void pcxi_txwinon(struct channel *ch);
144 static void pcxi_memoff(struct channel *ch);
146 /* - Begin 'specific' do nothing memory functions needed for some cards - */
148 static void dummy_memwinon(struct board_info *b, unsigned int win);
149 static void dummy_memwinoff(struct board_info *b, unsigned int win);
150 static void dummy_globalwinon(struct channel *ch);
151 static void dummy_rxwinon(struct channel *ch);
152 static void dummy_txwinon(struct channel *ch);
153 static void dummy_memoff(struct channel *ch);
154 static void dummy_assertgwinon(struct channel *ch);
155 static void dummy_assertmemoff(struct channel *ch);
157 static struct channel *verifyChannel(struct tty_struct *);
158 static void pc_sched_event(struct channel *, int);
159 static void epca_error(int, char *);
160 static void pc_close(struct tty_struct *, struct file *);
161 static void shutdown(struct channel *, struct tty_struct *tty);
162 static void pc_hangup(struct tty_struct *);
163 static int pc_write_room(struct tty_struct *);
164 static int pc_chars_in_buffer(struct tty_struct *);
165 static void pc_flush_buffer(struct tty_struct *);
166 static void pc_flush_chars(struct tty_struct *);
167 static int block_til_ready(struct tty_struct *, struct file *,
169 static int pc_open(struct tty_struct *, struct file *);
170 static void post_fep_init(unsigned int crd);
171 static void epcapoll(unsigned long);
172 static void doevent(int);
173 static void fepcmd(struct channel *, int, int, int, int, int);
174 static unsigned termios2digi_h(struct channel *ch, unsigned);
175 static unsigned termios2digi_i(struct channel *ch, unsigned);
176 static unsigned termios2digi_c(struct channel *ch, unsigned);
177 static void epcaparam(struct tty_struct *, struct channel *);
178 static void receive_data(struct channel *, struct tty_struct *tty);
179 static int pc_ioctl(struct tty_struct *, struct file *,
180 unsigned int, unsigned long);
181 static int info_ioctl(struct tty_struct *, struct file *,
182 unsigned int, unsigned long);
183 static void pc_set_termios(struct tty_struct *, struct ktermios *);
184 static void do_softint(struct work_struct *work);
185 static void pc_stop(struct tty_struct *);
186 static void pc_start(struct tty_struct *);
187 static void pc_throttle(struct tty_struct *tty);
188 static void pc_unthrottle(struct tty_struct *tty);
189 static int pc_send_break(struct tty_struct *tty, int msec);
190 static void setup_empty_event(struct tty_struct *tty, struct channel *ch);
192 static int pc_write(struct tty_struct *, const unsigned char *, int);
193 static int pc_init(void);
194 static int init_PCI(void);
197 * Table of functions for each board to handle memory. Mantaining parallelism
198 * is a *very* good idea here. The idea is for the runtime code to blindly call
199 * these functions, not knowing/caring about the underlying hardware. This
200 * stuff should contain no conditionals; if more functionality is needed a
201 * different entry should be established. These calls are the interface calls
202 * and are the only functions that should be accessed. Anyone caught making
203 * direct calls deserves what they get.
205 static void memwinon(struct board_info *b, unsigned int win)
210 static void memwinoff(struct board_info *b, unsigned int win)
212 b->memwinoff(b, win);
215 static void globalwinon(struct channel *ch)
217 ch->board->globalwinon(ch);
220 static void rxwinon(struct channel *ch)
222 ch->board->rxwinon(ch);
225 static void txwinon(struct channel *ch)
227 ch->board->txwinon(ch);
230 static void memoff(struct channel *ch)
232 ch->board->memoff(ch);
234 static void assertgwinon(struct channel *ch)
236 ch->board->assertgwinon(ch);
239 static void assertmemoff(struct channel *ch)
241 ch->board->assertmemoff(ch);
244 /* PCXEM windowing is the same as that used in the PCXR and CX series cards. */
245 static void pcxem_memwinon(struct board_info *b, unsigned int win)
247 outb_p(FEPWIN | win, b->port + 1);
250 static void pcxem_memwinoff(struct board_info *b, unsigned int win)
252 outb_p(0, b->port + 1);
255 static void pcxem_globalwinon(struct channel *ch)
257 outb_p(FEPWIN, (int)ch->board->port + 1);
260 static void pcxem_rxwinon(struct channel *ch)
262 outb_p(ch->rxwin, (int)ch->board->port + 1);
265 static void pcxem_txwinon(struct channel *ch)
267 outb_p(ch->txwin, (int)ch->board->port + 1);
270 static void pcxem_memoff(struct channel *ch)
272 outb_p(0, (int)ch->board->port + 1);
275 /* ----------------- Begin pcxe memory window stuff ------------------ */
276 static void pcxe_memwinon(struct board_info *b, unsigned int win)
278 outb_p(FEPWIN | win, b->port + 1);
281 static void pcxe_memwinoff(struct board_info *b, unsigned int win)
283 outb_p(inb(b->port) & ~FEPMEM, b->port + 1);
284 outb_p(0, b->port + 1);
287 static void pcxe_globalwinon(struct channel *ch)
289 outb_p(FEPWIN, (int)ch->board->port + 1);
292 static void pcxe_rxwinon(struct channel *ch)
294 outb_p(ch->rxwin, (int)ch->board->port + 1);
297 static void pcxe_txwinon(struct channel *ch)
299 outb_p(ch->txwin, (int)ch->board->port + 1);
302 static void pcxe_memoff(struct channel *ch)
304 outb_p(0, (int)ch->board->port);
305 outb_p(0, (int)ch->board->port + 1);
308 /* ------------- Begin pc64xe and pcxi memory window stuff -------------- */
309 static void pcxi_memwinon(struct board_info *b, unsigned int win)
311 outb_p(inb(b->port) | FEPMEM, b->port);
314 static void pcxi_memwinoff(struct board_info *b, unsigned int win)
316 outb_p(inb(b->port) & ~FEPMEM, b->port);
319 static void pcxi_globalwinon(struct channel *ch)
321 outb_p(FEPMEM, ch->board->port);
324 static void pcxi_rxwinon(struct channel *ch)
326 outb_p(FEPMEM, ch->board->port);
329 static void pcxi_txwinon(struct channel *ch)
331 outb_p(FEPMEM, ch->board->port);
334 static void pcxi_memoff(struct channel *ch)
336 outb_p(0, ch->board->port);
339 static void pcxi_assertgwinon(struct channel *ch)
341 epcaassert(inb(ch->board->port) & FEPMEM, "Global memory off");
344 static void pcxi_assertmemoff(struct channel *ch)
346 epcaassert(!(inb(ch->board->port) & FEPMEM), "Memory on");
350 * Not all of the cards need specific memory windowing routines. Some cards
351 * (Such as PCI) needs no windowing routines at all. We provide these do
352 * nothing routines so that the same code base can be used. The driver will
353 * ALWAYS call a windowing routine if it thinks it needs to; regardless of the
354 * card. However, dependent on the card the routine may or may not do anything.
356 static void dummy_memwinon(struct board_info *b, unsigned int win)
360 static void dummy_memwinoff(struct board_info *b, unsigned int win)
364 static void dummy_globalwinon(struct channel *ch)
368 static void dummy_rxwinon(struct channel *ch)
372 static void dummy_txwinon(struct channel *ch)
376 static void dummy_memoff(struct channel *ch)
380 static void dummy_assertgwinon(struct channel *ch)
384 static void dummy_assertmemoff(struct channel *ch)
388 static struct channel *verifyChannel(struct tty_struct *tty)
391 * This routine basically provides a sanity check. It insures that the
392 * channel returned is within the proper range of addresses as well as
393 * properly initialized. If some bogus info gets passed in
394 * through tty->driver_data this should catch it.
397 struct channel *ch = tty->driver_data;
398 if (ch >= &digi_channels[0] && ch < &digi_channels[nbdevs]) {
399 if (ch->magic == EPCA_MAGIC)
406 static void pc_sched_event(struct channel *ch, int event)
409 * We call this to schedule interrupt processing on some event. The
410 * kernel sees our request and calls the related routine in OUR driver.
412 ch->event |= 1 << event;
413 schedule_work(&ch->tqueue);
416 static void epca_error(int line, char *msg)
418 printk(KERN_ERR "epca_error (Digi): line = %d %s\n", line, msg);
421 static void pc_close(struct tty_struct *tty, struct file *filp)
424 struct tty_port *port;
427 * verifyChannel returns the channel from the tty struct if it is
428 * valid. This serves as a sanity check.
430 ch = verifyChannel(tty);
435 if (tty_port_close_start(port, tty, filp) == 0)
438 pc_flush_buffer(tty);
441 tty_port_close_end(port, tty);
442 ch->event = 0; /* FIXME: review ch->event locking */
443 tty_port_tty_set(port, NULL);
446 static void shutdown(struct channel *ch, struct tty_struct *tty)
449 struct board_chan __iomem *bc;
450 struct tty_port *port = &ch->port;
452 if (!(port->flags & ASYNC_INITIALIZED))
455 spin_lock_irqsave(&epca_lock, flags);
461 * In order for an event to be generated on the receipt of data the
462 * idata flag must be set. Since we are shutting down, this is not
463 * necessary clear this flag.
466 writeb(0, &bc->idata);
468 /* If we're a modem control device and HUPCL is on, drop RTS & DTR. */
469 if (tty->termios->c_cflag & HUPCL) {
470 ch->omodem &= ~(ch->m_rts | ch->m_dtr);
471 fepcmd(ch, SETMODEM, 0, ch->m_dtr | ch->m_rts, 10, 1);
476 * The channel has officialy been closed. The next time it is opened it
477 * will have to reinitialized. Set a flag to indicate this.
479 /* Prevent future Digi programmed interrupts from coming active */
480 port->flags &= ~ASYNC_INITIALIZED;
481 spin_unlock_irqrestore(&epca_lock, flags);
484 static void pc_hangup(struct tty_struct *tty)
489 * verifyChannel returns the channel from the tty struct if it is
490 * valid. This serves as a sanity check.
492 ch = verifyChannel(tty);
496 pc_flush_buffer(tty);
497 tty_ldisc_flush(tty);
500 ch->event = 0; /* FIXME: review locking of ch->event */
501 tty_port_hangup(&ch->port);
505 static int pc_write(struct tty_struct *tty,
506 const unsigned char *buf, int bytesAvailable)
508 unsigned int head, tail;
515 struct board_chan __iomem *bc;
518 * pc_write is primarily called directly by the kernel routine
519 * tty_write (Though it can also be called by put_char) found in
520 * tty_io.c. pc_write is passed a line discipline buffer where the data
521 * to be written out is stored. The line discipline implementation
522 * itself is done at the kernel level and is not brought into the
527 * verifyChannel returns the channel from the tty struct if it is
528 * valid. This serves as a sanity check.
530 ch = verifyChannel(tty);
534 /* Make a pointer to the channel data structure found on the board. */
536 size = ch->txbufsize;
539 spin_lock_irqsave(&epca_lock, flags);
542 head = readw(&bc->tin) & (size - 1);
543 tail = readw(&bc->tout);
545 if (tail != readw(&bc->tout))
546 tail = readw(&bc->tout);
550 /* head has not wrapped */
552 * remain (much like dataLen above) represents the total amount
553 * of space available on the card for data. Here dataLen
554 * represents the space existing between the head pointer and
555 * the end of buffer. This is important because a memcpy cannot
556 * be told to automatically wrap around when it hits the buffer
559 dataLen = size - head;
560 remain = size - (head - tail) - 1;
562 /* head has wrapped around */
563 remain = tail - head - 1;
567 * Check the space on the card. If we have more data than space; reduce
568 * the amount of data to fit the space.
570 bytesAvailable = min(remain, bytesAvailable);
572 while (bytesAvailable > 0) {
573 /* there is data to copy onto card */
576 * If head is not wrapped, the below will make sure the first
577 * data copy fills to the end of card buffer.
579 dataLen = min(bytesAvailable, dataLen);
580 memcpy_toio(ch->txptr + head, buf, dataLen);
583 amountCopied += dataLen;
584 bytesAvailable -= dataLen;
591 ch->statusflags |= TXBUSY;
593 writew(head, &bc->tin);
595 if ((ch->statusflags & LOWWAIT) == 0) {
596 ch->statusflags |= LOWWAIT;
597 writeb(1, &bc->ilow);
600 spin_unlock_irqrestore(&epca_lock, flags);
604 static int pc_write_room(struct tty_struct *tty)
609 unsigned int head, tail;
610 struct board_chan __iomem *bc;
612 * verifyChannel returns the channel from the tty struct if it is
613 * valid. This serves as a sanity check.
615 ch = verifyChannel(tty);
617 spin_lock_irqsave(&epca_lock, flags);
621 head = readw(&bc->tin) & (ch->txbufsize - 1);
622 tail = readw(&bc->tout);
624 if (tail != readw(&bc->tout))
625 tail = readw(&bc->tout);
626 /* Wrap tail if necessary */
627 tail &= (ch->txbufsize - 1);
628 remain = tail - head - 1;
630 remain += ch->txbufsize;
632 if (remain && (ch->statusflags & LOWWAIT) == 0) {
633 ch->statusflags |= LOWWAIT;
634 writeb(1, &bc->ilow);
637 spin_unlock_irqrestore(&epca_lock, flags);
639 /* Return how much room is left on card */
643 static int pc_chars_in_buffer(struct tty_struct *tty)
646 unsigned int ctail, head, tail;
650 struct board_chan __iomem *bc;
652 * verifyChannel returns the channel from the tty struct if it is
653 * valid. This serves as a sanity check.
655 ch = verifyChannel(tty);
659 spin_lock_irqsave(&epca_lock, flags);
663 tail = readw(&bc->tout);
664 head = readw(&bc->tin);
665 ctail = readw(&ch->mailbox->cout);
667 if (tail == head && readw(&ch->mailbox->cin) == ctail &&
668 readb(&bc->tbusy) == 0)
670 else { /* Begin if some space on the card has been used */
671 head = readw(&bc->tin) & (ch->txbufsize - 1);
672 tail &= (ch->txbufsize - 1);
674 * The logic here is basically opposite of the above
675 * pc_write_room here we are finding the amount of bytes in the
676 * buffer filled. Not the amount of bytes empty.
678 remain = tail - head - 1;
680 remain += ch->txbufsize;
681 chars = (int)(ch->txbufsize - remain);
683 * Make it possible to wakeup anything waiting for output in
686 * If not already set. Setup an event to indicate when the
687 * transmit buffer empties.
689 if (!(ch->statusflags & EMPTYWAIT))
690 setup_empty_event(tty, ch);
691 } /* End if some space on the card has been used */
693 spin_unlock_irqrestore(&epca_lock, flags);
694 /* Return number of characters residing on card. */
698 static void pc_flush_buffer(struct tty_struct *tty)
703 struct board_chan __iomem *bc;
705 * verifyChannel returns the channel from the tty struct if it is
706 * valid. This serves as a sanity check.
708 ch = verifyChannel(tty);
712 spin_lock_irqsave(&epca_lock, flags);
715 tail = readw(&bc->tout);
716 /* Have FEP move tout pointer; effectively flushing transmit buffer */
717 fepcmd(ch, STOUT, (unsigned) tail, 0, 0, 0);
719 spin_unlock_irqrestore(&epca_lock, flags);
723 static void pc_flush_chars(struct tty_struct *tty)
727 * verifyChannel returns the channel from the tty struct if it is
728 * valid. This serves as a sanity check.
730 ch = verifyChannel(tty);
733 spin_lock_irqsave(&epca_lock, flags);
735 * If not already set and the transmitter is busy setup an
736 * event to indicate when the transmit empties.
738 if ((ch->statusflags & TXBUSY) &&
739 !(ch->statusflags & EMPTYWAIT))
740 setup_empty_event(tty, ch);
741 spin_unlock_irqrestore(&epca_lock, flags);
745 static int epca_carrier_raised(struct tty_port *port)
747 struct channel *ch = container_of(port, struct channel, port);
748 if (ch->imodem & ch->dcd)
753 static void epca_raise_dtr_rts(struct tty_port *port0
757 static int pc_open(struct tty_struct *tty, struct file *filp)
760 struct tty_port *port;
762 int line, retval, boardnum;
763 struct board_chan __iomem *bc;
767 if (line < 0 || line >= nbdevs)
770 ch = &digi_channels[line];
772 boardnum = ch->boardnum;
774 /* Check status of board configured in system. */
777 * I check to see if the epca_setup routine detected an user error. It
778 * might be better to put this in pc_init, but for the moment it goes
781 if (invalid_lilo_config) {
782 if (setup_error_code & INVALID_BOARD_TYPE)
783 printk(KERN_ERR "epca: pc_open: Invalid board type specified in kernel options.\n");
784 if (setup_error_code & INVALID_NUM_PORTS)
785 printk(KERN_ERR "epca: pc_open: Invalid number of ports specified in kernel options.\n");
786 if (setup_error_code & INVALID_MEM_BASE)
787 printk(KERN_ERR "epca: pc_open: Invalid board memory address specified in kernel options.\n");
788 if (setup_error_code & INVALID_PORT_BASE)
789 printk(KERN_ERR "epca; pc_open: Invalid board port address specified in kernel options.\n");
790 if (setup_error_code & INVALID_BOARD_STATUS)
791 printk(KERN_ERR "epca: pc_open: Invalid board status specified in kernel options.\n");
792 if (setup_error_code & INVALID_ALTPIN)
793 printk(KERN_ERR "epca: pc_open: Invalid board altpin specified in kernel options;\n");
794 tty->driver_data = NULL; /* Mark this device as 'down' */
797 if (boardnum >= num_cards || boards[boardnum].status == DISABLED) {
798 tty->driver_data = NULL; /* Mark this device as 'down' */
804 tty->driver_data = NULL;
808 spin_lock_irqsave(&port->lock, flags);
810 * Every time a channel is opened, increment a counter. This is
811 * necessary because we do not wish to flush and shutdown the channel
812 * until the last app holding the channel open, closes it.
816 * Set a kernel structures pointer to our local channel structure. This
817 * way we can get to it when passed only a tty struct.
819 tty->driver_data = ch;
822 * If this is the first time the channel has been opened, initialize
823 * the tty->termios struct otherwise let pc_close handle it.
825 spin_lock(&epca_lock);
829 /* Save boards current modem status */
830 ch->imodem = readb(&bc->mstat);
833 * Set receive head and tail ptrs to each other. This indicates no data
836 head = readw(&bc->rin);
837 writew(head, &bc->rout);
839 /* Set the channels associated tty structure */
842 * The below routine generally sets up parity, baud, flow control
843 * issues, etc.... It effect both control flags and input flags.
847 spin_unlock(&epca_lock);
848 port->flags |= ASYNC_INITIALIZED;
849 spin_unlock_irqrestore(&port->lock, flags);
851 retval = tty_port_block_til_ready(port, tty, filp);
855 * Set this again in case a hangup set it to zero while this open() was
856 * waiting for the line...
858 spin_lock_irqsave(&port->lock, flags);
860 spin_lock(&epca_lock);
862 /* Enable Digi Data events */
863 writeb(1, &bc->idata);
865 spin_unlock(&epca_lock);
866 spin_unlock_irqrestore(&port->lock, flags);
870 static int __init epca_module_init(void)
874 module_init(epca_module_init);
876 static struct pci_driver epca_driver;
878 static void __exit epca_module_exit(void)
881 struct board_info *bd;
884 del_timer_sync(&epca_timer);
886 if (tty_unregister_driver(pc_driver) ||
887 tty_unregister_driver(pc_info)) {
888 printk(KERN_WARNING "epca: cleanup_module failed to un-register tty driver\n");
891 put_tty_driver(pc_driver);
892 put_tty_driver(pc_info);
894 for (crd = 0; crd < num_cards; crd++) {
896 if (!bd) { /* sanity check */
897 printk(KERN_ERR "<Error> - Digi : cleanup_module failed\n");
901 for (count = 0; count < bd->numports; count++, ch++) {
902 struct tty_struct *tty = tty_port_tty_get(&ch->port);
909 pci_unregister_driver(&epca_driver);
911 module_exit(epca_module_exit);
913 static const struct tty_operations pc_ops = {
917 .write_room = pc_write_room,
918 .flush_buffer = pc_flush_buffer,
919 .chars_in_buffer = pc_chars_in_buffer,
920 .flush_chars = pc_flush_chars,
922 .set_termios = pc_set_termios,
925 .throttle = pc_throttle,
926 .unthrottle = pc_unthrottle,
928 .break_ctl = pc_send_break
931 static const struct tty_port_operations epca_port_ops = {
932 .carrier_raised = epca_carrier_raised,
933 .raise_dtr_rts = epca_raise_dtr_rts,
936 static int info_open(struct tty_struct *tty, struct file *filp)
941 static struct tty_operations info_ops = {
946 static int __init pc_init(void)
949 struct board_info *bd;
950 unsigned char board_id = 0;
953 int pci_boards_found, pci_count;
957 pc_driver = alloc_tty_driver(MAX_ALLOC);
961 pc_info = alloc_tty_driver(MAX_ALLOC);
966 * If epca_setup has not been ran by LILO set num_cards to defaults;
967 * copy board structure defined by digiConfig into drivers board
968 * structure. Note : If LILO has ran epca_setup then epca_setup will
969 * handle defining num_cards as well as copying the data into the board
973 /* driver has been configured via. epcaconfig */
975 num_cards = NUMCARDS;
976 memcpy(&boards, &static_boards,
977 sizeof(struct board_info) * NUMCARDS);
981 * Note : If lilo was used to configure the driver and the ignore
982 * epcaconfig option was choosen (digiepca=2) then nbdevs and num_cards
983 * will equal 0 at this point. This is okay; PCI cards will still be
984 * picked up if detected.
988 * Set up interrupt, we will worry about memory allocation in
991 printk(KERN_INFO "DIGI epca driver version %s loaded.\n", VERSION);
994 * NOTE : This code assumes that the number of ports found in the
995 * boards array is correct. This could be wrong if the card in question
996 * is PCI (And therefore has no ports entry in the boards structure.)
997 * The rest of the information will be valid for PCI because the
998 * beginning of pc_init scans for PCI and determines i/o and base
999 * memory addresses. I am not sure if it is possible to read the number
1000 * of ports supported by the card prior to it being booted (Since that
1001 * is the state it is in when pc_init is run). Because it is not
1002 * possible to query the number of supported ports until after the card
1003 * has booted; we are required to calculate the card_ptrs as the card
1004 * is initialized (Inside post_fep_init). The negative thing about this
1005 * approach is that digiDload's call to GET_INFO will have a bad port
1006 * value. (Since this is called prior to post_fep_init.)
1008 pci_boards_found = 0;
1009 if (num_cards < MAXBOARDS)
1010 pci_boards_found += init_PCI();
1011 num_cards += pci_boards_found;
1013 pc_driver->owner = THIS_MODULE;
1014 pc_driver->name = "ttyD";
1015 pc_driver->major = DIGI_MAJOR;
1016 pc_driver->minor_start = 0;
1017 pc_driver->type = TTY_DRIVER_TYPE_SERIAL;
1018 pc_driver->subtype = SERIAL_TYPE_NORMAL;
1019 pc_driver->init_termios = tty_std_termios;
1020 pc_driver->init_termios.c_iflag = 0;
1021 pc_driver->init_termios.c_oflag = 0;
1022 pc_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
1023 pc_driver->init_termios.c_lflag = 0;
1024 pc_driver->init_termios.c_ispeed = 9600;
1025 pc_driver->init_termios.c_ospeed = 9600;
1026 pc_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_HARDWARE_BREAK;
1027 tty_set_operations(pc_driver, &pc_ops);
1029 pc_info->owner = THIS_MODULE;
1030 pc_info->name = "digi_ctl";
1031 pc_info->major = DIGIINFOMAJOR;
1032 pc_info->minor_start = 0;
1033 pc_info->type = TTY_DRIVER_TYPE_SERIAL;
1034 pc_info->subtype = SERIAL_TYPE_INFO;
1035 pc_info->init_termios = tty_std_termios;
1036 pc_info->init_termios.c_iflag = 0;
1037 pc_info->init_termios.c_oflag = 0;
1038 pc_info->init_termios.c_lflag = 0;
1039 pc_info->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
1040 pc_info->init_termios.c_ispeed = 9600;
1041 pc_info->init_termios.c_ospeed = 9600;
1042 pc_info->flags = TTY_DRIVER_REAL_RAW;
1043 tty_set_operations(pc_info, &info_ops);
1046 for (crd = 0; crd < num_cards; crd++) {
1048 * This is where the appropriate memory handlers for the
1049 * hardware is set. Everything at runtime blindly jumps through
1053 /* defined in epcaconfig.h */
1059 bd->memwinon = pcxem_memwinon;
1060 bd->memwinoff = pcxem_memwinoff;
1061 bd->globalwinon = pcxem_globalwinon;
1062 bd->txwinon = pcxem_txwinon;
1063 bd->rxwinon = pcxem_rxwinon;
1064 bd->memoff = pcxem_memoff;
1065 bd->assertgwinon = dummy_assertgwinon;
1066 bd->assertmemoff = dummy_assertmemoff;
1072 bd->memwinon = dummy_memwinon;
1073 bd->memwinoff = dummy_memwinoff;
1074 bd->globalwinon = dummy_globalwinon;
1075 bd->txwinon = dummy_txwinon;
1076 bd->rxwinon = dummy_rxwinon;
1077 bd->memoff = dummy_memoff;
1078 bd->assertgwinon = dummy_assertgwinon;
1079 bd->assertmemoff = dummy_assertmemoff;
1084 bd->memwinon = pcxe_memwinon;
1085 bd->memwinoff = pcxe_memwinoff;
1086 bd->globalwinon = pcxe_globalwinon;
1087 bd->txwinon = pcxe_txwinon;
1088 bd->rxwinon = pcxe_rxwinon;
1089 bd->memoff = pcxe_memoff;
1090 bd->assertgwinon = dummy_assertgwinon;
1091 bd->assertmemoff = dummy_assertmemoff;
1096 bd->memwinon = pcxi_memwinon;
1097 bd->memwinoff = pcxi_memwinoff;
1098 bd->globalwinon = pcxi_globalwinon;
1099 bd->txwinon = pcxi_txwinon;
1100 bd->rxwinon = pcxi_rxwinon;
1101 bd->memoff = pcxi_memoff;
1102 bd->assertgwinon = pcxi_assertgwinon;
1103 bd->assertmemoff = pcxi_assertmemoff;
1111 * Some cards need a memory segment to be defined for use in
1112 * transmit and receive windowing operations. These boards are
1113 * listed in the below switch. In the case of the XI the amount
1114 * of memory on the board is variable so the memory_seg is also
1115 * variable. This code determines what they segment should be.
1121 bd->memory_seg = 0xf000;
1125 board_id = inb((int)bd->port);
1126 if ((board_id & 0x1) == 0x1) {
1127 /* it's an XI card */
1128 /* Is it a 64K board */
1129 if ((board_id & 0x30) == 0)
1130 bd->memory_seg = 0xf000;
1132 /* Is it a 128K board */
1133 if ((board_id & 0x30) == 0x10)
1134 bd->memory_seg = 0xe000;
1136 /* Is is a 256K board */
1137 if ((board_id & 0x30) == 0x20)
1138 bd->memory_seg = 0xc000;
1140 /* Is it a 512K board */
1141 if ((board_id & 0x30) == 0x30)
1142 bd->memory_seg = 0x8000;
1144 printk(KERN_ERR "epca: Board at 0x%x doesn't appear to be an XI\n", (int)bd->port);
1149 err = tty_register_driver(pc_driver);
1151 printk(KERN_ERR "Couldn't register Digi PC/ driver");
1155 err = tty_register_driver(pc_info);
1157 printk(KERN_ERR "Couldn't register Digi PC/ info ");
1161 /* Start up the poller to check for events on all enabled boards */
1162 init_timer(&epca_timer);
1163 epca_timer.function = epcapoll;
1164 mod_timer(&epca_timer, jiffies + HZ/25);
1168 tty_unregister_driver(pc_driver);
1170 put_tty_driver(pc_info);
1172 put_tty_driver(pc_driver);
1177 static void post_fep_init(unsigned int crd)
1180 void __iomem *memaddr;
1181 struct global_data __iomem *gd;
1182 struct board_info *bd;
1183 struct board_chan __iomem *bc;
1185 int shrinkmem = 0, lowwater;
1188 * This call is made by the user via. the ioctl call DIGI_INIT. It is
1189 * responsible for setting up all the card specific stuff.
1194 * If this is a PCI board, get the port info. Remember PCI cards do not
1195 * have entries into the epcaconfig.h file, so we can't get the number
1196 * of ports from it. Unfortunetly, this means that anyone doing a
1197 * DIGI_GETINFO before the board has booted will get an invalid number
1198 * of ports returned (It should return 0). Calls to DIGI_GETINFO after
1199 * DIGI_INIT has been called will return the proper values.
1201 if (bd->type >= PCIXEM) { /* Begin get PCI number of ports */
1203 * Below we use XEMPORTS as a memory offset regardless of which
1204 * PCI card it is. This is because all of the supported PCI
1205 * cards have the same memory offset for the channel data. This
1206 * will have to be changed if we ever develop a PCI/XE card.
1207 * NOTE : The FEP manual states that the port offset is 0xC22
1208 * as opposed to 0xC02. This is only true for PC/XE, and PC/XI
1209 * cards; not for the XEM, or CX series. On the PCI cards the
1210 * number of ports is determined by reading a ID PROM located
1211 * in the box attached to the card. The card can then determine
1212 * the index the id to determine the number of ports available.
1213 * (FYI - The id should be located at 0x1ac (And may use up to
1214 * 4 bytes if the box in question is a XEM or CX)).
1216 /* PCI cards are already remapped at this point ISA are not */
1217 bd->numports = readw(bd->re_map_membase + XEMPORTS);
1218 epcaassert(bd->numports <= 64, "PCI returned a invalid number of ports");
1219 nbdevs += (bd->numports);
1221 /* Fix up the mappings for ISA/EISA etc */
1222 /* FIXME: 64K - can we be smarter ? */
1223 bd->re_map_membase = ioremap_nocache(bd->membase, 0x10000);
1227 card_ptr[crd] = card_ptr[crd-1] + boards[crd-1].numports;
1229 card_ptr[crd] = &digi_channels[crd]; /* <- For card 0 only */
1232 epcaassert(ch <= &digi_channels[nbdevs - 1], "ch out of range");
1234 memaddr = bd->re_map_membase;
1237 * The below assignment will set bc to point at the BEGINING of the
1238 * cards channel structures. For 1 card there will be between 8 and 64
1239 * of these structures.
1241 bc = memaddr + CHANSTRUCT;
1244 * The below assignment will set gd to point at the BEGINING of global
1245 * memory address 0xc00. The first data in that global memory actually
1246 * starts at address 0xc1a. The command in pointer begins at 0xd10.
1248 gd = memaddr + GLOBAL;
1251 * XEPORTS (address 0xc22) points at the number of channels the card
1252 * supports. (For 64XE, XI, XEM, and XR use 0xc02)
1254 if ((bd->type == PCXEVE || bd->type == PCXE) &&
1255 (readw(memaddr + XEPORTS) < 3))
1257 if (bd->type < PCIXEM)
1258 if (!request_region((int)bd->port, 4, board_desc[bd->type]))
1263 * Remember ch is the main drivers channels structure, while bc is the
1264 * cards channel structure.
1266 for (i = 0; i < bd->numports; i++, ch++, bc++) {
1267 unsigned long flags;
1270 tty_port_init(&ch->port);
1271 ch->port.ops - &epca_port_ops;
1274 INIT_WORK(&ch->tqueue, do_softint);
1275 ch->board = &boards[crd];
1277 spin_lock_irqsave(&epca_lock, flags);
1280 * Since some of the boards use different bitmaps for
1281 * their control signals we cannot hard code these
1282 * values and retain portability. We virtualize this
1311 if (boards[crd].altpin) {
1312 ch->dsr = ch->m_dcd;
1313 ch->dcd = ch->m_dsr;
1314 ch->digiext.digi_flags |= DIGI_ALTPIN;
1316 ch->dcd = ch->m_dcd;
1317 ch->dsr = ch->m_dsr;
1322 ch->magic = EPCA_MAGIC;
1323 tty_port_tty_set(&ch->port, NULL);
1326 fepcmd(ch, SETBUFFER, 32, 0, 0, 0);
1330 tseg = readw(&bc->tseg);
1331 rseg = readw(&bc->rseg);
1337 /* Cover all the 2MEG cards */
1338 ch->txptr = memaddr + ((tseg << 4) & 0x1fffff);
1339 ch->rxptr = memaddr + ((rseg << 4) & 0x1fffff);
1340 ch->txwin = FEPWIN | (tseg >> 11);
1341 ch->rxwin = FEPWIN | (rseg >> 11);
1346 /* Cover all the 32K windowed cards */
1347 /* Mask equal to window size - 1 */
1348 ch->txptr = memaddr + ((tseg << 4) & 0x7fff);
1349 ch->rxptr = memaddr + ((rseg << 4) & 0x7fff);
1350 ch->txwin = FEPWIN | (tseg >> 11);
1351 ch->rxwin = FEPWIN | (rseg >> 11);
1356 ch->txptr = memaddr + (((tseg - bd->memory_seg) << 4)
1358 ch->txwin = FEPWIN | ((tseg - bd->memory_seg) >> 9);
1359 ch->rxptr = memaddr + (((rseg - bd->memory_seg) << 4)
1361 ch->rxwin = FEPWIN | ((rseg - bd->memory_seg) >> 9);
1366 ch->txptr = memaddr + ((tseg - bd->memory_seg) << 4);
1367 ch->rxptr = memaddr + ((rseg - bd->memory_seg) << 4);
1368 ch->txwin = ch->rxwin = 0;
1373 ch->txbufsize = readw(&bc->tmax) + 1;
1376 ch->rxbufsize = readw(&bc->rmax) + 1;
1378 lowwater = ch->txbufsize >= 2000 ? 1024 : (ch->txbufsize / 2);
1380 /* Set transmitter low water mark */
1381 fepcmd(ch, STXLWATER, lowwater, 0, 10, 0);
1383 /* Set receiver low water mark */
1384 fepcmd(ch, SRXLWATER, (ch->rxbufsize / 4), 0, 10, 0);
1386 /* Set receiver high water mark */
1387 fepcmd(ch, SRXHWATER, (3 * ch->rxbufsize / 4), 0, 10, 0);
1389 writew(100, &bc->edelay);
1390 writeb(1, &bc->idata);
1392 ch->startc = readb(&bc->startc);
1393 ch->stopc = readb(&bc->stopc);
1394 ch->startca = readb(&bc->startca);
1395 ch->stopca = readb(&bc->stopca);
1405 ch->port.close_delay = 50;
1407 spin_unlock_irqrestore(&epca_lock, flags);
1411 "Digi PC/Xx Driver V%s: %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n",
1412 VERSION, board_desc[bd->type], (long)bd->port,
1413 (long)bd->membase, bd->numports);
1417 static void epcapoll(unsigned long ignored)
1419 unsigned long flags;
1421 unsigned int head, tail;
1423 struct board_info *bd;
1426 * This routine is called upon every timer interrupt. Even though the
1427 * Digi series cards are capable of generating interrupts this method
1428 * of non-looping polling is more efficient. This routine checks for
1429 * card generated events (Such as receive data, are transmit buffer
1430 * empty) and acts on those events.
1432 for (crd = 0; crd < num_cards; crd++) {
1436 if ((bd->status == DISABLED) || digi_poller_inhibited)
1440 * assertmemoff is not needed here; indeed it is an empty
1441 * subroutine. It is being kept because future boards may need
1442 * this as well as some legacy boards.
1444 spin_lock_irqsave(&epca_lock, flags);
1451 * In this case head and tail actually refer to the event queue
1452 * not the transmit or receive queue.
1454 head = readw(&ch->mailbox->ein);
1455 tail = readw(&ch->mailbox->eout);
1457 /* If head isn't equal to tail we have an event */
1462 spin_unlock_irqrestore(&epca_lock, flags);
1463 } /* End for each card */
1464 mod_timer(&epca_timer, jiffies + (HZ / 25));
1467 static void doevent(int crd)
1469 void __iomem *eventbuf;
1470 struct channel *ch, *chan0;
1471 static struct tty_struct *tty;
1472 struct board_info *bd;
1473 struct board_chan __iomem *bc;
1474 unsigned int tail, head;
1479 * This subroutine is called by epcapoll when an event is detected
1480 * in the event queue. This routine responds to those events.
1484 chan0 = card_ptr[crd];
1485 epcaassert(chan0 <= &digi_channels[nbdevs - 1], "ch out of range");
1486 assertgwinon(chan0);
1487 while ((tail = readw(&chan0->mailbox->eout)) !=
1488 (head = readw(&chan0->mailbox->ein))) {
1489 /* Begin while something in event queue */
1490 assertgwinon(chan0);
1491 eventbuf = bd->re_map_membase + tail + ISTART;
1492 /* Get the channel the event occurred on */
1493 channel = readb(eventbuf);
1494 /* Get the actual event code that occurred */
1495 event = readb(eventbuf + 1);
1497 * The two assignments below get the current modem status
1498 * (mstat) and the previous modem status (lstat). These are
1499 * useful becuase an event could signal a change in modem
1502 mstat = readb(eventbuf + 2);
1503 lstat = readb(eventbuf + 3);
1505 ch = chan0 + channel;
1506 if ((unsigned)channel >= bd->numports || !ch) {
1507 if (channel >= bd->numports)
1517 tty = tty_port_tty_get(&ch->port);
1518 if (event & DATA_IND) { /* Begin DATA_IND */
1519 receive_data(ch, tty);
1521 } /* End DATA_IND */
1522 /* else *//* Fix for DCD transition missed bug */
1523 if (event & MODEMCHG_IND) {
1524 /* A modem signal change has been indicated */
1526 if (test_bit(ASYNC_CHECK_CD, &ch->port.flags)) {
1527 /* We are now receiving dcd */
1528 if (mstat & ch->dcd)
1529 wake_up_interruptible(&ch->port.open_wait);
1530 else /* No dcd; hangup */
1531 pc_sched_event(ch, EPCA_EVENT_HANGUP);
1535 if (event & BREAK_IND) {
1536 /* A break has been indicated */
1537 tty_insert_flip_char(tty, 0, TTY_BREAK);
1538 tty_schedule_flip(tty);
1539 } else if (event & LOWTX_IND) {
1540 if (ch->statusflags & LOWWAIT) {
1541 ch->statusflags &= ~LOWWAIT;
1544 } else if (event & EMPTYTX_IND) {
1545 /* This event is generated by
1546 setup_empty_event */
1547 ch->statusflags &= ~TXBUSY;
1548 if (ch->statusflags & EMPTYWAIT) {
1549 ch->statusflags &= ~EMPTYWAIT;
1558 writew(1, &bc->idata);
1559 writew((tail + 4) & (IMAX - ISTART - 4), &chan0->mailbox->eout);
1561 } /* End while something in event queue */
1564 static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
1565 int byte2, int ncmds, int bytecmd)
1567 unchar __iomem *memaddr;
1568 unsigned int head, cmdTail, cmdStart, cmdMax;
1572 /* This is the routine in which commands may be passed to the card. */
1574 if (ch->board->status == DISABLED)
1577 /* Remember head (As well as max) is just an offset not a base addr */
1578 head = readw(&ch->mailbox->cin);
1579 /* cmdStart is a base address */
1580 cmdStart = readw(&ch->mailbox->cstart);
1582 * We do the addition below because we do not want a max pointer
1583 * relative to cmdStart. We want a max pointer that points at the
1584 * physical end of the command queue.
1586 cmdMax = (cmdStart + 4 + readw(&ch->mailbox->cmax));
1587 memaddr = ch->board->re_map_membase;
1589 if (head >= (cmdMax - cmdStart) || (head & 03)) {
1590 printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n",
1591 __LINE__, cmd, head);
1592 printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n",
1593 __LINE__, cmdMax, cmdStart);
1597 writeb(cmd, memaddr + head + cmdStart + 0);
1598 writeb(ch->channelnum, memaddr + head + cmdStart + 1);
1599 /* Below word_or_byte is bits to set */
1600 writeb(word_or_byte, memaddr + head + cmdStart + 2);
1601 /* Below byte2 is bits to reset */
1602 writeb(byte2, memaddr + head + cmdStart + 3);
1604 writeb(cmd, memaddr + head + cmdStart + 0);
1605 writeb(ch->channelnum, memaddr + head + cmdStart + 1);
1606 writeb(word_or_byte, memaddr + head + cmdStart + 2);
1608 head = (head + 4) & (cmdMax - cmdStart - 4);
1609 writew(head, &ch->mailbox->cin);
1615 printk(KERN_ERR "<Error> - Fep not responding in fepcmd()\n");
1618 head = readw(&ch->mailbox->cin);
1619 cmdTail = readw(&ch->mailbox->cout);
1620 n = (head - cmdTail) & (cmdMax - cmdStart - 4);
1622 * Basically this will break when the FEP acknowledges the
1623 * command by incrementing cmdTail (Making it equal to head).
1625 if (n <= ncmds * (sizeof(short) * 4))
1631 * Digi products use fields in their channels structures that are very similar
1632 * to the c_cflag and c_iflag fields typically found in UNIX termios
1633 * structures. The below three routines allow mappings between these hardware
1634 * "flags" and their respective Linux flags.
1636 static unsigned termios2digi_h(struct channel *ch, unsigned cflag)
1640 if (cflag & CRTSCTS) {
1641 ch->digiext.digi_flags |= (RTSPACE | CTSPACE);
1642 res |= ((ch->m_cts) | (ch->m_rts));
1645 if (ch->digiext.digi_flags & RTSPACE)
1648 if (ch->digiext.digi_flags & DTRPACE)
1651 if (ch->digiext.digi_flags & CTSPACE)
1654 if (ch->digiext.digi_flags & DSRPACE)
1657 if (ch->digiext.digi_flags & DCDPACE)
1660 if (res & (ch->m_rts))
1661 ch->digiext.digi_flags |= RTSPACE;
1663 if (res & (ch->m_cts))
1664 ch->digiext.digi_flags |= CTSPACE;
1669 static unsigned termios2digi_i(struct channel *ch, unsigned iflag)
1671 unsigned res = iflag & (IGNBRK | BRKINT | IGNPAR | PARMRK |
1672 INPCK | ISTRIP | IXON | IXANY | IXOFF);
1673 if (ch->digiext.digi_flags & DIGI_AIXON)
1678 static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
1681 if (cflag & CBAUDEX) {
1682 ch->digiext.digi_flags |= DIGI_FAST;
1684 * HUPCL bit is used by FEP to indicate fast baud table is to
1689 ch->digiext.digi_flags &= ~DIGI_FAST;
1691 * CBAUD has bit position 0x1000 set these days to indicate Linux
1692 * baud rate remap. Digi hardware can't handle the bit assignment.
1693 * (We use a different bit assignment for high speed.). Clear this
1696 res |= cflag & ((CBAUD ^ CBAUDEX) | PARODD | PARENB | CSTOPB | CSIZE);
1698 * This gets a little confusing. The Digi cards have their own
1699 * representation of c_cflags controlling baud rate. For the most part
1700 * this is identical to the Linux implementation. However; Digi
1701 * supports one rate (76800) that Linux doesn't. This means that the
1702 * c_cflag entry that would normally mean 76800 for Digi actually means
1703 * 115200 under Linux. Without the below mapping, a stty 115200 would
1704 * only drive the board at 76800. Since the rate 230400 is also found
1705 * after 76800, the same problem afflicts us when we choose a rate of
1706 * 230400. Without the below modificiation stty 230400 would actually
1709 * There are two additional differences. The Linux value for CLOCAL
1710 * (0x800; 0004000) has no meaning to the Digi hardware. Also in later
1711 * releases of Linux; the CBAUD define has CBAUDEX (0x1000; 0010000)
1712 * ored into it (CBAUD = 0x100f as opposed to 0xf). CBAUDEX should be
1713 * checked for a screened out prior to termios2digi_c returning. Since
1714 * CLOCAL isn't used by the board this can be ignored as long as the
1715 * returned value is used only by Digi hardware.
1717 if (cflag & CBAUDEX) {
1719 * The below code is trying to guarantee that only baud rates
1720 * 115200 and 230400 are remapped. We use exclusive or because
1721 * the various baud rates share common bit positions and
1722 * therefore can't be tested for easily.
1724 if ((!((cflag & 0x7) ^ (B115200 & ~CBAUDEX))) ||
1725 (!((cflag & 0x7) ^ (B230400 & ~CBAUDEX))))
1731 /* Caller must hold the locks */
1732 static void epcaparam(struct tty_struct *tty, struct channel *ch)
1734 unsigned int cmdHead;
1735 struct ktermios *ts;
1736 struct board_chan __iomem *bc;
1737 unsigned mval, hflow, cflag, iflag;
1740 epcaassert(bc != NULL, "bc out of range");
1744 if ((ts->c_cflag & CBAUD) == 0) { /* Begin CBAUD detected */
1745 cmdHead = readw(&bc->rin);
1746 writew(cmdHead, &bc->rout);
1747 cmdHead = readw(&bc->tin);
1748 /* Changing baud in mid-stream transmission can be wonderful */
1750 * Flush current transmit buffer by setting cmdTail pointer
1751 * (tout) to cmdHead pointer (tin). Hopefully the transmit
1754 fepcmd(ch, STOUT, (unsigned) cmdHead, 0, 0, 0);
1756 } else { /* Begin CBAUD not detected */
1758 * c_cflags have changed but that change had nothing to do with
1759 * BAUD. Propagate the change to the card.
1761 cflag = termios2digi_c(ch, ts->c_cflag);
1762 if (cflag != ch->fepcflag) {
1763 ch->fepcflag = cflag;
1764 /* Set baud rate, char size, stop bits, parity */
1765 fepcmd(ch, SETCTRLFLAGS, (unsigned) cflag, 0, 0, 0);
1768 * If the user has not forced CLOCAL and if the device is not a
1769 * CALLOUT device (Which is always CLOCAL) we set flags such
1770 * that the driver will wait on carrier detect.
1772 if (ts->c_cflag & CLOCAL)
1773 clear_bit(ASYNC_CHECK_CD, &ch->port.flags);
1775 set_bit(ASYNC_CHECK_CD, &ch->port.flags);
1776 mval = ch->m_dtr | ch->m_rts;
1777 } /* End CBAUD not detected */
1778 iflag = termios2digi_i(ch, ts->c_iflag);
1779 /* Check input mode flags */
1780 if (iflag != ch->fepiflag) {
1781 ch->fepiflag = iflag;
1783 * Command sets channels iflag structure on the board. Such
1784 * things as input soft flow control, handling of parity
1785 * errors, and break handling are all set here.
1787 * break handling, parity handling, input stripping,
1788 * flow control chars
1790 fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0);
1793 * Set the board mint value for this channel. This will cause hardware
1794 * events to be generated each time the DCD signal (Described in mint)
1797 writeb(ch->dcd, &bc->mint);
1798 if ((ts->c_cflag & CLOCAL) || (ch->digiext.digi_flags & DIGI_FORCEDCD))
1799 if (ch->digiext.digi_flags & DIGI_FORCEDCD)
1800 writeb(0, &bc->mint);
1801 ch->imodem = readb(&bc->mstat);
1802 hflow = termios2digi_h(ch, ts->c_cflag);
1803 if (hflow != ch->hflow) {
1806 * Hard flow control has been selected but the board is not
1807 * using it. Activate hard flow control now.
1809 fepcmd(ch, SETHFLOW, hflow, 0xff, 0, 1);
1811 mval ^= ch->modemfake & (mval ^ ch->modem);
1813 if (ch->omodem ^ mval) {
1816 * The below command sets the DTR and RTS mstat structure. If
1817 * hard flow control is NOT active these changes will drive the
1818 * output of the actual DTR and RTS lines. If hard flow control
1819 * is active, the changes will be saved in the mstat structure
1820 * and only asserted when hard flow control is turned off.
1823 /* First reset DTR & RTS; then set them */
1824 fepcmd(ch, SETMODEM, 0, ((ch->m_dtr)|(ch->m_rts)), 0, 1);
1825 fepcmd(ch, SETMODEM, mval, 0, 0, 1);
1827 if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc) {
1828 ch->fepstartc = ch->startc;
1829 ch->fepstopc = ch->stopc;
1831 * The XON / XOFF characters have changed; propagate these
1832 * changes to the card.
1834 fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
1836 if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca) {
1837 ch->fepstartca = ch->startca;
1838 ch->fepstopca = ch->stopca;
1840 * Similar to the above, this time the auxilarly XON / XOFF
1841 * characters have changed; propagate these changes to the card.
1843 fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
1847 /* Caller holds lock */
1848 static void receive_data(struct channel *ch, struct tty_struct *tty)
1851 struct ktermios *ts = NULL;
1852 struct board_chan __iomem *bc;
1853 int dataToRead, wrapgap, bytesAvailable;
1854 unsigned int tail, head;
1855 unsigned int wrapmask;
1858 * This routine is called by doint when a receive data event has taken
1862 if (ch->statusflags & RXSTOPPED)
1868 wrapmask = ch->rxbufsize - 1;
1871 * Get the head and tail pointers to the receiver queue. Wrap the head
1872 * pointer if it has reached the end of the buffer.
1874 head = readw(&bc->rin);
1876 tail = readw(&bc->rout) & wrapmask;
1878 bytesAvailable = (head - tail) & wrapmask;
1879 if (bytesAvailable == 0)
1882 /* If CREAD bit is off or device not open, set TX tail to head */
1883 if (!tty || !ts || !(ts->c_cflag & CREAD)) {
1884 writew(head, &bc->rout);
1888 if (tty_buffer_request_room(tty, bytesAvailable + 1) == 0)
1891 if (readb(&bc->orun)) {
1892 writeb(0, &bc->orun);
1893 printk(KERN_WARNING "epca; overrun! DigiBoard device %s\n",
1895 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1898 while (bytesAvailable > 0) {
1899 /* Begin while there is data on the card */
1900 wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
1902 * Even if head has wrapped around only report the amount of
1903 * data to be equal to the size - tail. Remember memcpy can't
1904 * automaticly wrap around the receive buffer.
1906 dataToRead = (wrapgap < bytesAvailable) ? wrapgap
1908 /* Make sure we don't overflow the buffer */
1909 dataToRead = tty_prepare_flip_string(tty, &rptr, dataToRead);
1910 if (dataToRead == 0)
1913 * Move data read from our card into the line disciplines
1914 * buffer for translation if necessary.
1916 memcpy_fromio(rptr, ch->rxptr + tail, dataToRead);
1917 tail = (tail + dataToRead) & wrapmask;
1918 bytesAvailable -= dataToRead;
1919 } /* End while there is data on the card */
1921 writew(tail, &bc->rout);
1922 /* Must be called with global data */
1923 tty_schedule_flip(tty);
1926 static int info_ioctl(struct tty_struct *tty, struct file *file,
1927 unsigned int cmd, unsigned long arg)
1932 struct digi_info di;
1935 if (get_user(brd, (unsigned int __user *)arg))
1937 if (brd < 0 || brd >= num_cards || num_cards == 0)
1940 memset(&di, 0, sizeof(di));
1943 di.status = boards[brd].status;
1944 di.type = boards[brd].type ;
1945 di.numports = boards[brd].numports ;
1946 /* Legacy fixups - just move along nothing to see */
1947 di.port = (unsigned char *)boards[brd].port ;
1948 di.membase = (unsigned char *)boards[brd].membase ;
1950 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
1958 int brd = arg & 0xff000000 >> 16;
1959 unsigned char state = arg & 0xff;
1961 if (brd < 0 || brd >= num_cards) {
1962 printk(KERN_ERR "epca: DIGI POLLER : brd not valid!\n");
1965 digi_poller_inhibited = state;
1972 * This call is made by the apps to complete the
1973 * initialization of the board(s). This routine is
1974 * responsible for setting the card to its initial
1975 * state and setting the drivers control fields to the
1976 * sutianle settings for the card in question.
1979 for (crd = 0; crd < num_cards; crd++)
1989 static int pc_tiocmget(struct tty_struct *tty, struct file *file)
1991 struct channel *ch = tty->driver_data;
1992 struct board_chan __iomem *bc;
1993 unsigned int mstat, mflag = 0;
1994 unsigned long flags;
2001 spin_lock_irqsave(&epca_lock, flags);
2003 mstat = readb(&bc->mstat);
2005 spin_unlock_irqrestore(&epca_lock, flags);
2007 if (mstat & ch->m_dtr)
2009 if (mstat & ch->m_rts)
2011 if (mstat & ch->m_cts)
2013 if (mstat & ch->dsr)
2015 if (mstat & ch->m_ri)
2017 if (mstat & ch->dcd)
2022 static int pc_tiocmset(struct tty_struct *tty, struct file *file,
2023 unsigned int set, unsigned int clear)
2025 struct channel *ch = tty->driver_data;
2026 unsigned long flags;
2031 spin_lock_irqsave(&epca_lock, flags);
2033 * I think this modemfake stuff is broken. It doesn't correctly reflect
2034 * the behaviour desired by the TIOCM* ioctls. Therefore this is
2037 if (set & TIOCM_RTS) {
2038 ch->modemfake |= ch->m_rts;
2039 ch->modem |= ch->m_rts;
2041 if (set & TIOCM_DTR) {
2042 ch->modemfake |= ch->m_dtr;
2043 ch->modem |= ch->m_dtr;
2045 if (clear & TIOCM_RTS) {
2046 ch->modemfake |= ch->m_rts;
2047 ch->modem &= ~ch->m_rts;
2049 if (clear & TIOCM_DTR) {
2050 ch->modemfake |= ch->m_dtr;
2051 ch->modem &= ~ch->m_dtr;
2055 * The below routine generally sets up parity, baud, flow control
2056 * issues, etc.... It effect both control flags and input flags.
2060 spin_unlock_irqrestore(&epca_lock, flags);
2064 static int pc_ioctl(struct tty_struct *tty, struct file *file,
2065 unsigned int cmd, unsigned long arg)
2068 unsigned long flags;
2069 unsigned int mflag, mstat;
2070 unsigned char startc, stopc;
2071 struct board_chan __iomem *bc;
2072 struct channel *ch = tty->driver_data;
2073 void __user *argp = (void __user *)arg;
2081 mflag = pc_tiocmget(tty, file);
2082 if (put_user(mflag, (unsigned long __user *)argp))
2086 if (get_user(mstat, (unsigned __user *)argp))
2088 return pc_tiocmset(tty, file, mstat, ~mstat);
2090 spin_lock_irqsave(&epca_lock, flags);
2091 ch->omodem |= ch->m_dtr;
2093 fepcmd(ch, SETMODEM, ch->m_dtr, 0, 10, 1);
2095 spin_unlock_irqrestore(&epca_lock, flags);
2099 spin_lock_irqsave(&epca_lock, flags);
2100 ch->omodem &= ~ch->m_dtr;
2102 fepcmd(ch, SETMODEM, 0, ch->m_dtr, 10, 1);
2104 spin_unlock_irqrestore(&epca_lock, flags);
2107 if (copy_to_user(argp, &ch->digiext, sizeof(digi_t)))
2113 if (cmd == DIGI_SETAW) {
2114 /* Setup an event to indicate when the transmit
2116 spin_lock_irqsave(&epca_lock, flags);
2117 setup_empty_event(tty, ch);
2118 spin_unlock_irqrestore(&epca_lock, flags);
2119 tty_wait_until_sent(tty, 0);
2121 /* ldisc lock already held in ioctl */
2122 if (tty->ldisc.ops->flush_buffer)
2123 tty->ldisc.ops->flush_buffer(tty);
2128 if (copy_from_user(&ch->digiext, argp, sizeof(digi_t)))
2131 if (ch->digiext.digi_flags & DIGI_ALTPIN) {
2132 ch->dcd = ch->m_dsr;
2133 ch->dsr = ch->m_dcd;
2135 ch->dcd = ch->m_dcd;
2136 ch->dsr = ch->m_dsr;
2139 spin_lock_irqsave(&epca_lock, flags);
2143 * The below routine generally sets up parity, baud, flow
2144 * control issues, etc.... It effect both control flags and
2149 spin_unlock_irqrestore(&epca_lock, flags);
2154 spin_lock_irqsave(&epca_lock, flags);
2156 if (cmd == DIGI_GETFLOW) {
2157 dflow.startc = readb(&bc->startc);
2158 dflow.stopc = readb(&bc->stopc);
2160 dflow.startc = readb(&bc->startca);
2161 dflow.stopc = readb(&bc->stopca);
2164 spin_unlock_irqrestore(&epca_lock, flags);
2166 if (copy_to_user(argp, &dflow, sizeof(dflow)))
2172 if (cmd == DIGI_SETFLOW) {
2173 startc = ch->startc;
2176 startc = ch->startca;
2180 if (copy_from_user(&dflow, argp, sizeof(dflow)))
2183 if (dflow.startc != startc || dflow.stopc != stopc) {
2184 /* Begin if setflow toggled */
2185 spin_lock_irqsave(&epca_lock, flags);
2188 if (cmd == DIGI_SETFLOW) {
2189 ch->fepstartc = ch->startc = dflow.startc;
2190 ch->fepstopc = ch->stopc = dflow.stopc;
2191 fepcmd(ch, SONOFFC, ch->fepstartc,
2192 ch->fepstopc, 0, 1);
2194 ch->fepstartca = ch->startca = dflow.startc;
2195 ch->fepstopca = ch->stopca = dflow.stopc;
2196 fepcmd(ch, SAUXONOFFC, ch->fepstartca,
2197 ch->fepstopca, 0, 1);
2200 if (ch->statusflags & TXSTOPPED)
2204 spin_unlock_irqrestore(&epca_lock, flags);
2205 } /* End if setflow toggled */
2208 return -ENOIOCTLCMD;
2213 static void pc_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2216 unsigned long flags;
2218 * verifyChannel returns the channel from the tty struct if it is
2219 * valid. This serves as a sanity check.
2221 ch = verifyChannel(tty);
2223 if (ch != NULL) { /* Begin if channel valid */
2224 spin_lock_irqsave(&epca_lock, flags);
2228 spin_unlock_irqrestore(&epca_lock, flags);
2230 if ((old_termios->c_cflag & CRTSCTS) &&
2231 ((tty->termios->c_cflag & CRTSCTS) == 0))
2232 tty->hw_stopped = 0;
2234 if (!(old_termios->c_cflag & CLOCAL) &&
2235 (tty->termios->c_cflag & CLOCAL))
2236 wake_up_interruptible(&ch->port.open_wait);
2238 } /* End if channel valid */
2241 static void do_softint(struct work_struct *work)
2243 struct channel *ch = container_of(work, struct channel, tqueue);
2244 /* Called in response to a modem change event */
2245 if (ch && ch->magic == EPCA_MAGIC) {
2246 struct tty_struct *tty = tty_port_tty_get(&ch->port);;
2248 if (tty && tty->driver_data) {
2249 if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) {
2251 wake_up_interruptible(&ch->port.open_wait);
2252 clear_bit(ASYNC_NORMAL_ACTIVE, &ch->port.flags);
2260 * pc_stop and pc_start provide software flow control to the routine and the
2263 static void pc_stop(struct tty_struct *tty)
2266 unsigned long flags;
2268 * verifyChannel returns the channel from the tty struct if it is
2269 * valid. This serves as a sanity check.
2271 ch = verifyChannel(tty);
2273 spin_lock_irqsave(&epca_lock, flags);
2274 if ((ch->statusflags & TXSTOPPED) == 0) {
2275 /* Begin if transmit stop requested */
2277 /* STOP transmitting now !! */
2278 fepcmd(ch, PAUSETX, 0, 0, 0, 0);
2279 ch->statusflags |= TXSTOPPED;
2281 } /* End if transmit stop requested */
2282 spin_unlock_irqrestore(&epca_lock, flags);
2286 static void pc_start(struct tty_struct *tty)
2290 * verifyChannel returns the channel from the tty struct if it is
2291 * valid. This serves as a sanity check.
2293 ch = verifyChannel(tty);
2295 unsigned long flags;
2296 spin_lock_irqsave(&epca_lock, flags);
2297 /* Just in case output was resumed because of a change
2299 if (ch->statusflags & TXSTOPPED) {
2300 /* Begin transmit resume requested */
2301 struct board_chan __iomem *bc;
2304 if (ch->statusflags & LOWWAIT)
2305 writeb(1, &bc->ilow);
2306 /* Okay, you can start transmitting again... */
2307 fepcmd(ch, RESUMETX, 0, 0, 0, 0);
2308 ch->statusflags &= ~TXSTOPPED;
2310 } /* End transmit resume requested */
2311 spin_unlock_irqrestore(&epca_lock, flags);
2316 * The below routines pc_throttle and pc_unthrottle are used to slow (And
2317 * resume) the receipt of data into the kernels receive buffers. The exact
2318 * occurrence of this depends on the size of the kernels receive buffer and
2319 * what the 'watermarks' are set to for that buffer. See the n_ttys.c file for
2322 static void pc_throttle(struct tty_struct *tty)
2325 unsigned long flags;
2327 * verifyChannel returns the channel from the tty struct if it is
2328 * valid. This serves as a sanity check.
2330 ch = verifyChannel(tty);
2332 spin_lock_irqsave(&epca_lock, flags);
2333 if ((ch->statusflags & RXSTOPPED) == 0) {
2335 fepcmd(ch, PAUSERX, 0, 0, 0, 0);
2336 ch->statusflags |= RXSTOPPED;
2339 spin_unlock_irqrestore(&epca_lock, flags);
2343 static void pc_unthrottle(struct tty_struct *tty)
2346 unsigned long flags;
2348 * verifyChannel returns the channel from the tty struct if it is
2349 * valid. This serves as a sanity check.
2351 ch = verifyChannel(tty);
2353 /* Just in case output was resumed because of a change
2355 spin_lock_irqsave(&epca_lock, flags);
2356 if (ch->statusflags & RXSTOPPED) {
2358 fepcmd(ch, RESUMERX, 0, 0, 0, 0);
2359 ch->statusflags &= ~RXSTOPPED;
2362 spin_unlock_irqrestore(&epca_lock, flags);
2366 static int pc_send_break(struct tty_struct *tty, int msec)
2368 struct channel *ch = tty->driver_data;
2369 unsigned long flags;
2373 else if (msec > 0xFFFE)
2378 spin_lock_irqsave(&epca_lock, flags);
2381 * Maybe I should send an infinite break here, schedule() for msec
2382 * amount of time, and then stop the break. This way, the user can't
2383 * screw up the FEP by causing digi_send_break() to be called (i.e. via
2384 * an ioctl()) more than once in msec amount of time.
2385 * Try this for now...
2387 fepcmd(ch, SENDBREAK, msec, 0, 10, 0);
2389 spin_unlock_irqrestore(&epca_lock, flags);
2393 /* Caller MUST hold the lock */
2394 static void setup_empty_event(struct tty_struct *tty, struct channel *ch)
2396 struct board_chan __iomem *bc = ch->brdchan;
2399 ch->statusflags |= EMPTYWAIT;
2401 * When set the iempty flag request a event to be generated when the
2402 * transmit buffer is empty (If there is no BREAK in progress).
2404 writeb(1, &bc->iempty);
2409 static void __init epca_setup(char *str, int *ints)
2411 struct board_info board;
2412 int index, loop, last;
2417 * If this routine looks a little strange it is because it is only
2418 * called if a LILO append command is given to boot the kernel with
2419 * parameters. In this way, we can provide the user a method of
2420 * changing his board configuration without rebuilding the kernel.
2425 memset(&board, 0, sizeof(board));
2427 /* Assume the data is int first, later we can change it */
2428 /* I think that array position 0 of ints holds the number of args */
2429 for (last = 0, index = 1; index <= ints[0]; index++)
2430 switch (index) { /* Begin parse switch */
2432 board.status = ints[index];
2434 * We check for 2 (As opposed to 1; because 2 is a flag
2435 * instructing the driver to ignore epcaconfig.) For
2436 * this reason we check for 2.
2438 if (board.status == 2) {
2439 /* Begin ignore epcaconfig as well as lilo cmd line */
2443 } /* End ignore epcaconfig as well as lilo cmd line */
2445 if (board.status > 2) {
2446 printk(KERN_ERR "epca_setup: Invalid board status 0x%x\n",
2448 invalid_lilo_config = 1;
2449 setup_error_code |= INVALID_BOARD_STATUS;
2455 board.type = ints[index];
2456 if (board.type >= PCIXEM) {
2457 printk(KERN_ERR "epca_setup: Invalid board type 0x%x\n", board.type);
2458 invalid_lilo_config = 1;
2459 setup_error_code |= INVALID_BOARD_TYPE;
2465 board.altpin = ints[index];
2466 if (board.altpin > 1) {
2467 printk(KERN_ERR "epca_setup: Invalid board altpin 0x%x\n", board.altpin);
2468 invalid_lilo_config = 1;
2469 setup_error_code |= INVALID_ALTPIN;
2476 board.numports = ints[index];
2477 if (board.numports < 2 || board.numports > 256) {
2478 printk(KERN_ERR "epca_setup: Invalid board numports 0x%x\n", board.numports);
2479 invalid_lilo_config = 1;
2480 setup_error_code |= INVALID_NUM_PORTS;
2483 nbdevs += board.numports;
2488 board.port = ints[index];
2489 if (ints[index] <= 0) {
2490 printk(KERN_ERR "epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
2491 invalid_lilo_config = 1;
2492 setup_error_code |= INVALID_PORT_BASE;
2499 board.membase = ints[index];
2500 if (ints[index] <= 0) {
2501 printk(KERN_ERR "epca_setup: Invalid memory base 0x%x\n",
2502 (unsigned int)board.membase);
2503 invalid_lilo_config = 1;
2504 setup_error_code |= INVALID_MEM_BASE;
2511 printk(KERN_ERR "<Error> - epca_setup: Too many integer parms\n");
2514 } /* End parse switch */
2516 while (str && *str) { /* Begin while there is a string arg */
2517 /* find the next comma or terminator */
2519 /* While string is not null, and a comma hasn't been found */
2520 while (*temp && (*temp != ','))
2526 /* Set index to the number of args + 1 */
2532 if (strncmp("Disable", str, len) == 0)
2534 else if (strncmp("Enable", str, len) == 0)
2537 printk(KERN_ERR "epca_setup: Invalid status %s\n", str);
2538 invalid_lilo_config = 1;
2539 setup_error_code |= INVALID_BOARD_STATUS;
2546 for (loop = 0; loop < EPCA_NUM_TYPES; loop++)
2547 if (strcmp(board_desc[loop], str) == 0)
2550 * If the index incremented above refers to a
2551 * legitamate board type set it here.
2553 if (index < EPCA_NUM_TYPES)
2556 printk(KERN_ERR "epca_setup: Invalid board type: %s\n", str);
2557 invalid_lilo_config = 1;
2558 setup_error_code |= INVALID_BOARD_TYPE;
2566 if (strncmp("Disable", str, len) == 0)
2568 else if (strncmp("Enable", str, len) == 0)
2571 printk(KERN_ERR "epca_setup: Invalid altpin %s\n", str);
2572 invalid_lilo_config = 1;
2573 setup_error_code |= INVALID_ALTPIN;
2581 while (isdigit(*t2))
2585 printk(KERN_ERR "epca_setup: Invalid port count %s\n", str);
2586 invalid_lilo_config = 1;
2587 setup_error_code |= INVALID_NUM_PORTS;
2592 * There is not a man page for simple_strtoul but the
2593 * code can be found in vsprintf.c. The first argument
2594 * is the string to translate (To an unsigned long
2595 * obviously), the second argument can be the address
2596 * of any character variable or a NULL. If a variable
2597 * is given, the end pointer of the string will be
2598 * stored in that variable; if a NULL is given the end
2599 * pointer will not be returned. The last argument is
2600 * the base to use. If a 0 is indicated, the routine
2601 * will attempt to determine the proper base by looking
2602 * at the values prefix (A '0' for octal, a 'x' for
2603 * hex, etc ... If a value is given it will use that
2604 * value as the base.
2606 board.numports = simple_strtoul(str, NULL, 0);
2607 nbdevs += board.numports;
2613 while (isxdigit(*t2))
2617 printk(KERN_ERR "epca_setup: Invalid i/o address %s\n", str);
2618 invalid_lilo_config = 1;
2619 setup_error_code |= INVALID_PORT_BASE;
2623 board.port = simple_strtoul(str, NULL, 16);
2629 while (isxdigit(*t2))
2633 printk(KERN_ERR "epca_setup: Invalid memory base %s\n", str);
2634 invalid_lilo_config = 1;
2635 setup_error_code |= INVALID_MEM_BASE;
2638 board.membase = simple_strtoul(str, NULL, 16);
2642 printk(KERN_ERR "epca: Too many string parms\n");
2646 } /* End while there is a string arg */
2649 printk(KERN_ERR "epca: Insufficient parms specified\n");
2653 /* I should REALLY validate the stuff here */
2654 /* Copies our local copy of board into boards */
2655 memcpy((void *)&boards[num_cards], (void *)&board, sizeof(board));
2656 /* Does this get called once per lilo arg are what ? */
2657 printk(KERN_INFO "PC/Xx: Added board %i, %s %i ports at 0x%4.4X base 0x%6.6X\n",
2658 num_cards, board_desc[board.type],
2659 board.numports, (int)board.port, (unsigned int) board.membase);
2663 static int __init epca_real_setup(char *str)
2667 epca_setup(get_options(str, 11, ints), ints);
2671 __setup("digiepca", epca_real_setup);
2674 enum epic_board_types {
2681 /* indexed directly by epic_board_types enum */
2683 unsigned char board_type;
2684 unsigned bar_idx; /* PCI base address region */
2685 } epca_info_tbl[] = {
2692 static int __devinit epca_init_one(struct pci_dev *pdev,
2693 const struct pci_device_id *ent)
2695 static int board_num = -1;
2696 int board_idx, info_idx = ent->driver_data;
2699 if (pci_enable_device(pdev))
2703 board_idx = board_num + num_cards;
2704 if (board_idx >= MAXBOARDS)
2707 addr = pci_resource_start(pdev, epca_info_tbl[info_idx].bar_idx);
2709 printk(KERN_ERR PFX "PCI region #%d not available (size 0)\n",
2710 epca_info_tbl[info_idx].bar_idx);
2714 boards[board_idx].status = ENABLED;
2715 boards[board_idx].type = epca_info_tbl[info_idx].board_type;
2716 boards[board_idx].numports = 0x0;
2717 boards[board_idx].port = addr + PCI_IO_OFFSET;
2718 boards[board_idx].membase = addr;
2720 if (!request_mem_region(addr + PCI_IO_OFFSET, 0x200000, "epca")) {
2721 printk(KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
2722 0x200000, addr + PCI_IO_OFFSET);
2726 boards[board_idx].re_map_port = ioremap_nocache(addr + PCI_IO_OFFSET,
2728 if (!boards[board_idx].re_map_port) {
2729 printk(KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
2730 0x200000, addr + PCI_IO_OFFSET);
2731 goto err_out_free_pciio;
2734 if (!request_mem_region(addr, 0x200000, "epca")) {
2735 printk(KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
2737 goto err_out_free_iounmap;
2740 boards[board_idx].re_map_membase = ioremap_nocache(addr, 0x200000);
2741 if (!boards[board_idx].re_map_membase) {
2742 printk(KERN_ERR PFX "cannot map 0x%x @ 0x%lx\n",
2743 0x200000, addr + PCI_IO_OFFSET);
2744 goto err_out_free_memregion;
2748 * I don't know what the below does, but the hardware guys say its
2749 * required on everything except PLX (In this case XRJ).
2751 if (info_idx != brd_xrj) {
2752 pci_write_config_byte(pdev, 0x40, 0);
2753 pci_write_config_byte(pdev, 0x46, 0);
2758 err_out_free_memregion:
2759 release_mem_region(addr, 0x200000);
2760 err_out_free_iounmap:
2761 iounmap(boards[board_idx].re_map_port);
2763 release_mem_region(addr + PCI_IO_OFFSET, 0x200000);
2769 static struct pci_device_id epca_pci_tbl[] = {
2770 { PCI_VENDOR_DIGI, PCI_DEVICE_XR, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xr },
2771 { PCI_VENDOR_DIGI, PCI_DEVICE_XEM, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xem },
2772 { PCI_VENDOR_DIGI, PCI_DEVICE_CX, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_cx },
2773 { PCI_VENDOR_DIGI, PCI_DEVICE_XRJ, PCI_ANY_ID, PCI_ANY_ID, 0, 0, brd_xrj },
2777 MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
2779 static int __init init_PCI(void)
2781 memset(&epca_driver, 0, sizeof(epca_driver));
2782 epca_driver.name = "epca";
2783 epca_driver.id_table = epca_pci_tbl;
2784 epca_driver.probe = epca_init_one;
2786 return pci_register_driver(&epca_driver);
2789 MODULE_LICENSE("GPL");