2 /* sx.c -- driver for the Specialix SX series cards.
4 * This driver will also support the older SI, and XIO cards.
7 * (C) 1998 - 2004 R.E.Wolff@BitWizard.nl
9 * Simon Allen (simonallen@cix.compulink.co.uk) wrote a previous
10 * version of this driver. Some fragments may have been copied. (none
13 * Specialix pays for the development and support of this driver.
14 * Please DO contact support@specialix.co.uk if you require
15 * support. But please read the documentation (sx.txt) first.
19 * This program is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU General Public License as
21 * published by the Free Software Foundation; either version 2 of
22 * the License, or (at your option) any later version.
24 * This program is distributed in the hope that it will be
25 * useful, but WITHOUT ANY WARRANTY; without even the implied
26 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
27 * PURPOSE. See the GNU General Public License for more details.
29 * You should have received a copy of the GNU General Public
30 * License along with this program; if not, write to the Free
31 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
35 * Revision 1.33 2000/03/09 10:00:00 pvdl,wolff
36 * - Fixed module and port counting
37 * - Fixed signal handling
40 * Revision 1.32 2000/03/07 09:00:00 wolff,pvdl
41 * - Fixed some sx_dprintk typos
42 * - added detection for an invalid board/module configuration
44 * Revision 1.31 2000/03/06 12:00:00 wolff,pvdl
45 * - Added support for EISA
47 * Revision 1.30 2000/01/21 17:43:06 wolff
48 * - Added support for SX+
50 * Revision 1.26 1999/08/05 15:22:14 wolff
52 * - Reformatted to Linus' liking.
54 * Revision 1.25 1999/07/30 14:24:08 wolff
55 * Had accidentally left "gs_debug" set to "-1" instead of "off" (=0).
57 * Revision 1.24 1999/07/28 09:41:52 wolff
58 * - I noticed the remark about use-count straying in sx.txt. I checked
59 * sx_open, and found a few places where that could happen. I hope it's
62 * Revision 1.23 1999/07/28 08:56:06 wolff
63 * - Fixed crash when sx_firmware run twice.
64 * - Added sx_slowpoll as a module parameter (I guess nobody really wanted
65 * to change it from the default... )
66 * - Fixed a stupid editing problem I introduced in 1.22.
67 * - Fixed dropping characters on a termios change.
69 * Revision 1.22 1999/07/26 21:01:43 wolff
70 * Russell Brown noticed that I had overlooked 4 out of six modem control
71 * signals in sx_getsignals. Ooops.
73 * Revision 1.21 1999/07/23 09:11:33 wolff
74 * I forgot to free dynamically allocated memory when the driver is unloaded.
76 * Revision 1.20 1999/07/20 06:25:26 wolff
77 * The "closing wait" wasn't honoured. Thanks to James Griffiths for
80 * Revision 1.19 1999/07/11 08:59:59 wolff
81 * Fixed an oops in close, when an open was pending. Changed the memtest
82 * a bit. Should also test the board in word-mode, however my card fails the
83 * memtest then. I still have to figure out what is wrong...
85 * Revision 1.18 1999/06/10 09:38:42 wolff
86 * Changed the format of the firmware revision from %04x to %x.%02x .
88 * Revision 1.17 1999/06/04 09:44:35 wolff
89 * fixed problem: reference to pci stuff when config_pci was off...
90 * Thanks to Jorge Novo for noticing this.
92 * Revision 1.16 1999/06/02 08:30:15 wolff
93 * added/removed the workaround for the DCD bug in the Firmware.
94 * A bit more debugging code to locate that...
96 * Revision 1.15 1999/06/01 11:35:30 wolff
97 * when DCD is left low (floating?), on TA's the firmware first tells us
98 * that DCD is high, but after a short while suddenly comes to the
99 * conclusion that it is low. All this would be fine, if it weren't that
100 * Unix requires us to send a "hangup" signal in that case. This usually
101 * all happens BEFORE the program has had a chance to ioctl the device
104 * Revision 1.14 1999/05/25 11:18:59 wolff
106 * Added checks for return code of sx_sendcommand.
107 * Don't issue "reconfig" if port isn't open yet. (bit us on TA modules...)
109 * Revision 1.13 1999/04/29 15:18:01 wolff
110 * Fixed an "oops" that showed on SuSE 6.0 systems.
111 * Activate DTR again after stty 0.
113 * Revision 1.12 1999/04/29 07:49:52 wolff
114 * Improved "stty 0" handling a bit. (used to change baud to 9600 assuming
115 * the connection would be dropped anyway. That is not always the case,
116 * and confuses people).
117 * Told the card to always monitor the modem signals.
118 * Added support for dynamic gs_debug adjustments.
119 * Now tells the rest of the system the number of ports.
121 * Revision 1.11 1999/04/24 11:11:30 wolff
122 * Fixed two stupid typos in the memory test.
124 * Revision 1.10 1999/04/24 10:53:39 wolff
125 * Added some of Christian's suggestions.
126 * Fixed an HW_COOK_IN bug (ISIG was not in I_OTHER. We used to trust the
127 * card to send the signal to the process.....)
129 * Revision 1.9 1999/04/23 07:26:38 wolff
130 * Included Christian Lademann's 2.0 compile-warning fixes and interrupt
131 * assignment redesign.
132 * Cleanup of some other stuff.
134 * Revision 1.8 1999/04/16 13:05:30 wolff
135 * fixed a DCD change unnoticed bug.
137 * Revision 1.7 1999/04/14 22:19:51 wolff
138 * Fixed typo that showed up in 2.0.x builds (get_user instead of Get_user!)
140 * Revision 1.6 1999/04/13 18:40:20 wolff
141 * changed misc-minor to 161, as assigned by HPA.
143 * Revision 1.5 1999/04/13 15:12:25 wolff
144 * Fixed use-count leak when "hangup" occurred.
145 * Added workaround for a stupid-PCIBIOS bug.
148 * Revision 1.4 1999/04/01 22:47:40 wolff
149 * Fixed < 1M linux-2.0 problem.
150 * (vremap isn't compatible with ioremap in that case)
152 * Revision 1.3 1999/03/31 13:45:45 wolff
153 * Firmware loading is now done through a separate IOCTL.
155 * Revision 1.2 1999/03/28 12:22:29 wolff
158 * Revision 1.1 1999/03/28 12:10:34 wolff
159 * Readying for release on 2.0.x (sorry David, 1.01 becomes 1.1 for RCS).
161 * Revision 0.12 1999/03/28 09:20:10 wolff
162 * Fixed problem in 0.11, continueing cleanup.
164 * Revision 0.11 1999/03/28 08:46:44 wolff
167 * Revision 0.10 1999/03/28 08:09:43 wolff
168 * Fixed loosing characters on close.
170 * Revision 0.9 1999/03/21 22:52:01 wolff
171 * Ported back to 2.2.... (minor things)
173 * Revision 0.8 1999/03/21 22:40:33 wolff
176 * Revision 0.7 1999/03/21 19:06:34 wolff
177 * Fixed hangup processing.
179 * Revision 0.6 1999/02/05 08:45:14 wolff
180 * fixed real_raw problems. Inclusion into kernel imminent.
182 * Revision 0.5 1998/12/21 23:51:06 wolff
183 * Snatched a nasty bug: sx_transmit_chars was getting re-entered, and it
184 * shouldn't have. THATs why I want to have transmit interrupts even when
185 * the buffer is empty.
187 * Revision 0.4 1998/12/17 09:34:46 wolff
188 * PPP works. ioctl works. Basically works!
190 * Revision 0.3 1998/12/15 13:05:18 wolff
191 * It works! Wow! Gotta start implementing IOCTL and stuff....
193 * Revision 0.2 1998/12/01 08:33:53 wolff
194 * moved over to 2.1.130
196 * Revision 0.1 1998/11/03 21:23:51 wolff
197 * Initial revision. Detects SX card.
201 #define SX_VERSION 1.33
203 #include <linux/module.h>
204 #include <linux/kdev_t.h>
205 #include <linux/kernel.h>
206 #include <linux/sched.h>
207 #include <linux/ioport.h>
208 #include <linux/interrupt.h>
209 #include <linux/errno.h>
210 #include <linux/tty.h>
211 #include <linux/tty_flip.h>
212 #include <linux/mm.h>
213 #include <linux/serial.h>
214 #include <linux/fcntl.h>
215 #include <linux/major.h>
216 #include <linux/delay.h>
217 #include <linux/eisa.h>
218 #include <linux/pci.h>
219 #include <linux/slab.h>
220 #include <linux/init.h>
221 #include <linux/miscdevice.h>
222 #include <linux/bitops.h>
225 #include <asm/uaccess.h>
227 /* The 3.0.0 version of sxboards/sxwindow.h uses BYTE and WORD.... */
231 /* .... but the 3.0.4 version uses _u8 and _u16. */
235 #include "sxboards.h"
236 #include "sxwindow.h"
238 #include <linux/generic_serial.h>
242 /* I don't think that this driver can handle more than 256 ports on
243 one machine. You'll have to increase the number of boards in sx.h
244 if you want more than 4 boards. */
246 #ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
247 #define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
250 /* Configurable options:
251 (Don't be too sure that it'll work if you toggle them) */
253 /* Am I paranoid or not ? ;-) */
254 #undef SX_PARANOIA_CHECK
257 /* 20 -> 2000 per second. The card should rate-limit interrupts at 100
258 Hz, but it is user configurable. I don't recommend going above 1000
259 Hz. The interrupt ratelimit might trigger if the interrupt is
260 shared with a very active other device. */
261 #define IRQ_RATE_LIMIT 20
263 /* Sharing interrupts is possible now. If the other device wants more
264 than 2000 interrupts per second, we'd gracefully decline further
265 interrupts. That's not what we want. On the other hand, if the
266 other device interrupts 2000 times a second, don't use the SX
267 interrupt. Use polling. */
268 #undef IRQ_RATE_LIMIT
272 /* Not implemented */
274 * The following defines are mostly for testing purposes. But if you need
275 * some nice reporting in your syslog, you can define them also.
277 #define SX_REPORT_FIFO
278 #define SX_REPORT_OVERRUN
282 /* Function prototypes */
283 static void sx_disable_tx_interrupts (void * ptr);
284 static void sx_enable_tx_interrupts (void * ptr);
285 static void sx_disable_rx_interrupts (void * ptr);
286 static void sx_enable_rx_interrupts (void * ptr);
287 static int sx_get_CD (void * ptr);
288 static void sx_shutdown_port (void * ptr);
289 static int sx_set_real_termios (void *ptr);
290 static void sx_close (void *ptr);
291 static int sx_chars_in_buffer (void * ptr);
292 static int sx_init_board (struct sx_board *board);
293 static int sx_init_portstructs (int nboards, int nports);
294 static int sx_fw_ioctl (struct inode *inode, struct file *filp,
295 unsigned int cmd, unsigned long arg);
296 static int sx_init_drivers(void);
299 static struct tty_driver *sx_driver;
301 static DEFINE_MUTEX(sx_boards_lock);
302 static struct sx_board boards[SX_NBOARDS];
303 static struct sx_port *sx_ports;
304 static int sx_initialized;
305 static int sx_nports;
309 /* You can have the driver poll your card.
310 - Set sx_poll to 1 to poll every timer tick (10ms on Intel).
311 This is used when the card cannot use an interrupt for some reason.
313 - set sx_slowpoll to 100 to do an extra poll once a second (on Intel). If
314 the driver misses an interrupt (report this if it DOES happen to you!)
315 everything will continue to work....
317 static int sx_poll = 1;
318 static int sx_slowpoll;
320 /* The card limits the number of interrupts per second.
321 At 115k2 "100" should be sufficient.
322 If you're using higher baudrates, you can increase this...
325 static int sx_maxints = 100;
329 /* These are the only open spaces in my computer. Yours may have more
331 duh: Card at 0xa0000 is possible on HP Netserver?? -- pvdl
333 static int sx_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000,
334 0xc8000, 0xd8000, 0xe8000};
335 static int si_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000,
336 0xc8000, 0xd8000, 0xe8000, 0xa0000};
337 static int si1_probe_addrs[]= { 0xd0000};
339 #define NR_SX_ADDRS ARRAY_SIZE(sx_probe_addrs)
340 #define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
341 #define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
343 module_param_array(sx_probe_addrs, int, NULL, 0);
344 module_param_array(si_probe_addrs, int, NULL, 0);
347 /* Set the mask to all-ones. This alas, only supports 32 interrupts.
348 Some architectures may need more. */
349 static int sx_irqmask = -1;
351 module_param(sx_poll, int, 0);
352 module_param(sx_slowpoll, int, 0);
353 module_param(sx_maxints, int, 0);
354 module_param(sx_debug, int, 0);
355 module_param(sx_irqmask, int, 0);
357 MODULE_LICENSE("GPL");
359 static struct real_driver sx_real_driver = {
360 sx_disable_tx_interrupts,
361 sx_enable_tx_interrupts,
362 sx_disable_rx_interrupts,
363 sx_enable_rx_interrupts,
373 This driver can spew a whole lot of debugging output at you. If you
374 need maximum performance, you should disable the DEBUG define. To
375 aid in debugging in the field, I'm leaving the compile-time debug
376 features enabled, and disable them "runtime". That allows me to
377 instruct people with problems to enable debugging without requiring
384 #define sx_dprintk(f, str...) if (sx_debug & f) printk (str)
386 #define sx_dprintk(f, str...) /* nothing */
391 #define func_enter() sx_dprintk (SX_DEBUG_FLOW, "sx: enter %s\n",__FUNCTION__)
392 #define func_exit() sx_dprintk (SX_DEBUG_FLOW, "sx: exit %s\n", __FUNCTION__)
394 #define func_enter2() sx_dprintk (SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
395 __FUNCTION__, port->line)
401 * Firmware loader driver specific routines
405 static const struct file_operations sx_fw_fops = {
406 .owner = THIS_MODULE,
407 .ioctl = sx_fw_ioctl,
410 static struct miscdevice sx_fw_device = {
411 SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
418 #ifdef SX_PARANOIA_CHECK
420 /* This doesn't work. Who's paranoid around here? Not me! */
422 static inline int sx_paranoia_check(struct sx_port const * port,
423 char *name, const char *routine)
426 static const char *badmagic =
427 KERN_ERR "sx: Warning: bad sx port magic number for device %s in %s\n";
428 static const char *badinfo =
429 KERN_ERR "sx: Warning: null sx port for device %s in %s\n";
432 printk(badinfo, name, routine);
435 if (port->magic != SX_MAGIC) {
436 printk(badmagic, name, routine);
443 #define sx_paranoia_check(a,b,c) 0
446 /* The timeouts. First try 30 times as fast as possible. Then give
447 the card some time to breathe between accesses. (Otherwise the
448 processor on the card might not be able to access its OWN bus... */
451 #define TIMEOUT_2 1000000
455 static void my_hd_io(void __iomem *p, int len)
458 unsigned char __iomem *addr = p;
460 for (i=0;i<len;i+=16) {
461 printk ("%p ", addr+i);
463 printk ("%02x %s", readb(addr+j+i), (j==7)?" ":"");
466 ch = readb(addr+j+i);
467 printk ("%c", (ch < 0x20)?'.':((ch > 0x7f)?'.':ch));
472 static void my_hd(void *p, int len)
475 unsigned char *addr = p;
477 for (i=0;i<len;i+=16) {
478 printk ("%p ", addr+i);
480 printk ("%02x %s", addr[j+i], (j==7)?" ":"");
484 printk ("%c", (ch < 0x20)?'.':((ch > 0x7f)?'.':ch));
493 /* This needs redoing for Alpha -- REW -- Done. */
495 static inline void write_sx_byte (struct sx_board *board, int offset, u8 byte)
497 writeb (byte, board->base+offset);
500 static inline u8 read_sx_byte (struct sx_board *board, int offset)
502 return readb (board->base+offset);
506 static inline void write_sx_word (struct sx_board *board, int offset, u16 word)
508 writew (word, board->base+offset);
511 static inline u16 read_sx_word (struct sx_board *board, int offset)
513 return readw (board->base + offset);
517 static int sx_busy_wait_eq (struct sx_board *board,
518 int offset, int mask, int correctval)
524 for (i=0; i < TIMEOUT_1 ;i++)
525 if ((read_sx_byte (board, offset) & mask) == correctval) {
530 for (i=0; i < TIMEOUT_2 ;i++) {
531 if ((read_sx_byte (board, offset) & mask) == correctval) {
543 static int sx_busy_wait_neq (struct sx_board *board,
544 int offset, int mask, int badval)
550 for (i=0; i < TIMEOUT_1 ;i++)
551 if ((read_sx_byte (board, offset) & mask) != badval) {
556 for (i=0; i < TIMEOUT_2 ;i++) {
557 if ((read_sx_byte (board, offset) & mask) != badval) {
570 /* 5.6.4 of 6210028 r2.3 */
571 static int sx_reset (struct sx_board *board)
575 if (IS_SX_BOARD (board)) {
577 write_sx_byte (board, SX_CONFIG, 0);
578 write_sx_byte (board, SX_RESET, 1); /* Value doesn't matter */
580 if (!sx_busy_wait_eq (board, SX_RESET_STATUS, 1, 0)) {
581 printk (KERN_INFO "sx: Card doesn't respond to reset....\n");
584 } else if (IS_EISA_BOARD(board)) {
585 outb(board->irq<<4, board->eisa_base+0xc02);
586 } else if (IS_SI1_BOARD(board)) {
587 write_sx_byte (board, SI1_ISA_RESET, 0); // value does not matter
589 /* Gory details of the SI/ISA board */
590 write_sx_byte (board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
591 write_sx_byte (board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
592 write_sx_byte (board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
593 write_sx_byte (board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
594 write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
595 write_sx_byte (board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
603 /* This doesn't work on machines where "NULL" isn't 0 */
604 /* If you have one of those, someone will need to write
605 the equivalent of this, which will amount to about 3 lines. I don't
606 want to complicate this right now. -- REW
607 (See, I do write comments every now and then :-) */
608 #define OFFSETOF(strct, elem) ((long)&(((struct strct *)NULL)->elem))
611 #define CHAN_OFFSET(port,elem) (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
612 #define MODU_OFFSET(board,addr,elem) (addr + OFFSETOF (_SXMODULE, elem))
613 #define BRD_OFFSET(board,elem) (OFFSETOF (_SXCARD, elem))
616 #define sx_write_channel_byte(port, elem, val) \
617 write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
619 #define sx_read_channel_byte(port, elem) \
620 read_sx_byte (port->board, CHAN_OFFSET (port, elem))
622 #define sx_write_channel_word(port, elem, val) \
623 write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
625 #define sx_read_channel_word(port, elem) \
626 read_sx_word (port->board, CHAN_OFFSET (port, elem))
629 #define sx_write_module_byte(board, addr, elem, val) \
630 write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
632 #define sx_read_module_byte(board, addr, elem) \
633 read_sx_byte (board, MODU_OFFSET (board, addr, elem))
635 #define sx_write_module_word(board, addr, elem, val) \
636 write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
638 #define sx_read_module_word(board, addr, elem) \
639 read_sx_word (board, MODU_OFFSET (board, addr, elem))
642 #define sx_write_board_byte(board, elem, val) \
643 write_sx_byte (board, BRD_OFFSET (board, elem), val)
645 #define sx_read_board_byte(board, elem) \
646 read_sx_byte (board, BRD_OFFSET (board, elem))
648 #define sx_write_board_word(board, elem, val) \
649 write_sx_word (board, BRD_OFFSET (board, elem), val)
651 #define sx_read_board_word(board, elem) \
652 read_sx_word (board, BRD_OFFSET (board, elem))
655 static int sx_start_board (struct sx_board *board)
657 if (IS_SX_BOARD (board)) {
658 write_sx_byte (board, SX_CONFIG, SX_CONF_BUSEN);
659 } else if (IS_EISA_BOARD(board)) {
660 write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
661 outb((board->irq<<4)|4, board->eisa_base+0xc02);
662 } else if (IS_SI1_BOARD(board)) {
663 write_sx_byte (board, SI1_ISA_RESET_CLEAR, 0);
664 write_sx_byte (board, SI1_ISA_INTCL, 0);
666 /* Don't bug me about the clear_set.
667 I haven't the foggiest idea what it's about -- REW */
668 write_sx_byte (board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
669 write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
674 #define SX_IRQ_REG_VAL(board) \
675 ((board->flags & SX_ISA_BOARD)?(board->irq << 4):0)
677 /* Note. The SX register is write-only. Therefore, we have to enable the
678 bus too. This is a no-op, if you don't mess with this driver... */
679 static int sx_start_interrupts (struct sx_board *board)
682 /* Don't call this with board->irq == 0 */
684 if (IS_SX_BOARD(board)) {
685 write_sx_byte (board, SX_CONFIG, SX_IRQ_REG_VAL (board) |
688 } else if (IS_EISA_BOARD(board)) {
689 inb(board->eisa_base+0xc03);
690 } else if (IS_SI1_BOARD(board)) {
691 write_sx_byte (board, SI1_ISA_INTCL,0);
692 write_sx_byte (board, SI1_ISA_INTCL_CLEAR,0);
694 switch (board->irq) {
695 case 11:write_sx_byte (board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);break;
696 case 12:write_sx_byte (board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);break;
697 case 15:write_sx_byte (board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);break;
698 default:printk (KERN_INFO "sx: SI/XIO card doesn't support interrupt %d.\n",
702 write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
709 static int sx_send_command (struct sx_port *port,
710 int command, int mask, int newstat)
713 write_sx_byte (port->board, CHAN_OFFSET (port, hi_hstat), command);
715 return sx_busy_wait_eq (port->board, CHAN_OFFSET (port, hi_hstat), mask, newstat);
719 static char *mod_type_s (int module_type)
721 switch (module_type) {
722 case TA4: return "TA4";
723 case TA8: return "TA8";
724 case TA4_ASIC: return "TA4_ASIC";
725 case TA8_ASIC: return "TA8_ASIC";
726 case MTA_CD1400:return "MTA_CD1400";
727 case SXDC: return "SXDC";
728 default:return "Unknown/invalid";
733 static char *pan_type_s (int pan_type)
736 case MOD_RS232DB25: return "MOD_RS232DB25";
737 case MOD_RS232RJ45: return "MOD_RS232RJ45";
738 case MOD_RS422DB25: return "MOD_RS422DB25";
739 case MOD_PARALLEL: return "MOD_PARALLEL";
740 case MOD_2_RS232DB25: return "MOD_2_RS232DB25";
741 case MOD_2_RS232RJ45: return "MOD_2_RS232RJ45";
742 case MOD_2_RS422DB25: return "MOD_2_RS422DB25";
743 case MOD_RS232DB25MALE: return "MOD_RS232DB25MALE";
744 case MOD_2_PARALLEL: return "MOD_2_PARALLEL";
745 case MOD_BLANK: return "empty";
746 default:return "invalid";
751 static int mod_compat_type (int module_type)
753 return module_type >> 4;
756 static void sx_reconfigure_port(struct sx_port *port)
758 if (sx_read_channel_byte (port, hi_hstat) == HS_IDLE_OPEN) {
759 if (sx_send_command (port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
760 printk (KERN_WARNING "sx: Sent reconfigure command, but card didn't react.\n");
763 sx_dprintk (SX_DEBUG_TERMIOS,
764 "sx: Not sending reconfigure: port isn't open (%02x).\n",
765 sx_read_channel_byte (port, hi_hstat));
769 static void sx_setsignals (struct sx_port *port, int dtr, int rts)
774 t = sx_read_channel_byte (port, hi_op);
775 if (dtr >= 0) t = dtr? (t | OP_DTR): (t & ~OP_DTR);
776 if (rts >= 0) t = rts? (t | OP_RTS): (t & ~OP_RTS);
777 sx_write_channel_byte (port, hi_op, t);
778 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
785 static int sx_getsignals (struct sx_port *port)
789 o_stat = sx_read_channel_byte (port, hi_op);
790 i_stat = sx_read_channel_byte (port, hi_ip);
792 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d (%d/%d) %02x/%02x\n",
793 (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
794 port->c_dcd, sx_get_CD (port),
795 sx_read_channel_byte (port, hi_ip),
796 sx_read_channel_byte (port, hi_state));
798 return (((o_stat & OP_DTR)?TIOCM_DTR:0) |
799 ((o_stat & OP_RTS)?TIOCM_RTS:0) |
800 ((i_stat & IP_CTS)?TIOCM_CTS:0) |
801 ((i_stat & IP_DCD)?TIOCM_CAR:0) |
802 ((i_stat & IP_DSR)?TIOCM_DSR:0) |
803 ((i_stat & IP_RI)?TIOCM_RNG:0)
808 static void sx_set_baud (struct sx_port *port)
812 if (port->board->ta_type == MOD_SXDC) {
813 switch (port->gs.baud) {
814 /* Save some typing work... */
815 #define e(x) case x:t= BAUD_ ## x ; break
816 e(50);e(75);e(110);e(150);e(200);e(300);e(600);
817 e(1200);e(1800);e(2000);e(2400);e(4800);e(7200);
818 e(9600);e(14400);e(19200);e(28800);e(38400);
819 e(56000);e(57600);e(64000);e(76800);e(115200);
820 e(128000);e(150000);e(230400);e(256000);e(460800);
822 case 134 :t = BAUD_134_5; break;
826 /* Can I return "invalid"? */
828 printk (KERN_INFO "sx: unsupported baud rate: %d.\n", port->gs.baud);
833 /* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
834 sx_setsignals (port, 1, -1);
835 /* XXX This is not TA & MTA compatible */
836 sx_write_channel_byte (port, hi_csr, 0xff);
838 sx_write_channel_byte (port, hi_txbaud, t);
839 sx_write_channel_byte (port, hi_rxbaud, t);
841 sx_setsignals (port, 0, -1);
844 switch (port->gs.baud) {
845 #define e(x) case x:t= CSR_ ## x ; break
846 e(75);e(150);e(300);e(600);e(1200);e(2400);e(4800);
848 e(19200);e(57600);e(38400);
849 /* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
851 if (port->board->ta_type == MOD_TA) {
856 printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
860 if (port->board->ta_type == MOD_TA) {
862 printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
872 printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
877 sx_setsignals (port, 1, -1);
878 sx_write_channel_byte (port, hi_csr, t * 0x11);
880 sx_setsignals (port, 0, -1);
886 /* Simon Allen's version of this routine was 225 lines long. 85 is a lot
889 static int sx_set_real_termios (void *ptr)
891 struct sx_port *port = ptr;
898 /* What is this doing here? -- REW
899 Ha! figured it out. It is to allow you to get DTR active again
900 if you've dropped it with stty 0. Moved to set_baud, where it
901 belongs (next to the drop dtr if baud == 0) -- REW */
902 /* sx_setsignals (port, 1, -1); */
906 #define CFLAG port->gs.tty->termios->c_cflag
907 sx_write_channel_byte (port, hi_mr1,
908 (C_PARENB (port->gs.tty)? MR1_WITH:MR1_NONE) |
909 (C_PARODD (port->gs.tty)? MR1_ODD:MR1_EVEN) |
910 (C_CRTSCTS(port->gs.tty)? MR1_RTS_RXFLOW:0) |
911 (((CFLAG & CSIZE)==CS8) ? MR1_8_BITS:0) |
912 (((CFLAG & CSIZE)==CS7) ? MR1_7_BITS:0) |
913 (((CFLAG & CSIZE)==CS6) ? MR1_6_BITS:0) |
914 (((CFLAG & CSIZE)==CS5) ? MR1_5_BITS:0) );
916 sx_write_channel_byte (port, hi_mr2,
917 (C_CRTSCTS(port->gs.tty)?MR2_CTS_TXFLOW:0) |
918 (C_CSTOPB (port->gs.tty)?MR2_2_STOP:MR2_1_STOP));
920 switch (CFLAG & CSIZE) {
921 case CS8:sx_write_channel_byte (port, hi_mask, 0xff);break;
922 case CS7:sx_write_channel_byte (port, hi_mask, 0x7f);break;
923 case CS6:sx_write_channel_byte (port, hi_mask, 0x3f);break;
924 case CS5:sx_write_channel_byte (port, hi_mask, 0x1f);break;
926 printk (KERN_INFO "sx: Invalid wordsize: %u\n", CFLAG & CSIZE);
930 sx_write_channel_byte (port, hi_prtcl,
931 (I_IXON (port->gs.tty)?SP_TXEN:0) |
932 (I_IXOFF (port->gs.tty)?SP_RXEN:0) |
933 (I_IXANY (port->gs.tty)?SP_TANY:0) |
936 sx_write_channel_byte (port, hi_break,
937 (I_IGNBRK(port->gs.tty)?BR_IGN:0 |
938 I_BRKINT(port->gs.tty)?BR_INT:0));
940 sx_write_channel_byte (port, hi_txon, START_CHAR (port->gs.tty));
941 sx_write_channel_byte (port, hi_rxon, START_CHAR (port->gs.tty));
942 sx_write_channel_byte (port, hi_txoff, STOP_CHAR (port->gs.tty));
943 sx_write_channel_byte (port, hi_rxoff, STOP_CHAR (port->gs.tty));
945 sx_reconfigure_port(port);
947 /* Tell line discipline whether we will do input cooking */
948 if(I_OTHER(port->gs.tty)) {
949 clear_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
951 set_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
953 sx_dprintk (SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
954 port->gs.tty->termios->c_iflag,
955 I_OTHER(port->gs.tty));
958 /* Tell line discipline whether we will do output cooking.
959 * If OPOST is set and no other output flags are set then we can do output
960 * processing. Even if only *one* other flag in the O_OTHER group is set
961 * we do cooking in software.
963 if(O_OPOST(port->gs.tty) && !O_OTHER(port->gs.tty)) {
964 set_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
966 clear_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
968 sx_dprintk (SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
969 port->gs.tty->termios->c_oflag,
970 O_OTHER(port->gs.tty));
971 /* port->c_dcd = sx_get_CD (port); */
978 /* ********************************************************************** *
979 * the interrupt related routines *
980 * ********************************************************************** */
983 Other drivers use the macro "MIN" to calculate how much to copy.
984 This has the disadvantage that it will evaluate parts twice. That's
985 expensive when it's IO (and the compiler cannot optimize those away!).
986 Moreover, I'm not sure that you're race-free.
988 I assign a value, and then only allow the value to decrease. This
989 is always safe. This makes the code a few lines longer, and you
990 know I'm dead against that, but I think it is required in this
994 static void sx_transmit_chars (struct sx_port *port)
1001 sx_dprintk (SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
1002 port, port->gs.xmit_cnt);
1004 if (test_and_set_bit (SX_PORT_TRANSMIT_LOCK, &port->locks)) {
1009 c = port->gs.xmit_cnt;
1011 sx_dprintk (SX_DEBUG_TRANSMIT, "Copying %d ", c);
1012 tx_ip = sx_read_channel_byte (port, hi_txipos);
1014 /* Took me 5 minutes to deduce this formula.
1015 Luckily it is literally in the manual in section 6.5.4.3.5 */
1016 txroom = (sx_read_channel_byte (port, hi_txopos) - tx_ip - 1) & 0xff;
1018 /* Don't copy more bytes than there is room for in the buffer */
1021 sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom );
1023 /* Don't copy past the end of the hardware transmit buffer */
1024 if (c > 0x100 - tx_ip)
1027 sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100-tx_ip );
1029 /* Don't copy pas the end of the source buffer */
1030 if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
1031 c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
1033 sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%ld) \n",
1034 c, SERIAL_XMIT_SIZE- port->gs.xmit_tail);
1036 /* If for one reason or another, we can't copy more data, we're done! */
1040 memcpy_toio (port->board->base + CHAN_OFFSET(port,hi_txbuf) + tx_ip,
1041 port->gs.xmit_buf + port->gs.xmit_tail, c);
1043 /* Update the pointer in the card */
1044 sx_write_channel_byte (port, hi_txipos, (tx_ip+c) & 0xff);
1046 /* Update the kernel buffer end */
1047 port->gs.xmit_tail = (port->gs.xmit_tail + c) & (SERIAL_XMIT_SIZE-1);
1049 /* This one last. (this is essential)
1050 It would allow others to start putting more data into the buffer! */
1051 port->gs.xmit_cnt -= c;
1054 if (port->gs.xmit_cnt == 0) {
1055 sx_disable_tx_interrupts (port);
1058 if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.tty) {
1059 tty_wakeup(port->gs.tty);
1060 sx_dprintk (SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
1061 port->gs.wakeup_chars);
1064 clear_bit (SX_PORT_TRANSMIT_LOCK, &port->locks);
1069 /* Note the symmetry between receiving chars and transmitting them!
1070 Note: The kernel should have implemented both a receive buffer and
1071 a transmit buffer. */
1073 /* Inlined: Called only once. Remove the inline when you add another call */
1074 static inline void sx_receive_chars (struct sx_port *port)
1078 struct tty_struct *tty;
1085 rx_op = sx_read_channel_byte (port, hi_rxopos);
1086 c = (sx_read_channel_byte (port, hi_rxipos) - rx_op) & 0xff;
1088 sx_dprintk (SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
1090 /* Don't copy past the end of the hardware receive buffer */
1091 if (rx_op + c > 0x100) c = 0x100 - rx_op;
1093 sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c);
1095 /* Don't copy more bytes than there is room for in the buffer */
1097 c = tty_prepare_flip_string(tty, &rp, c);
1099 sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c);
1101 /* If for one reason or another, we can't copy more data, we're done! */
1104 sx_dprintk (SX_DEBUG_RECEIVE , "Copying over %d chars. First is %d at %lx\n", c,
1105 read_sx_byte (port->board, CHAN_OFFSET(port,hi_rxbuf) + rx_op),
1106 CHAN_OFFSET(port, hi_rxbuf));
1108 port->board->base + CHAN_OFFSET(port,hi_rxbuf) + rx_op, c);
1110 /* This one last. ( Not essential.)
1111 It allows the card to start putting more data into the buffer!
1112 Update the pointer in the card */
1113 sx_write_channel_byte (port, hi_rxopos, (rx_op + c) & 0xff);
1120 do_gettimeofday (&tv);
1121 sx_dprintk (SX_DEBUG_RECEIVE,
1122 "pushing flipq port %d (%3d chars): %d.%06d (%d/%d)\n",
1124 (int) (tv.tv_sec % 60), (int)tv.tv_usec, tty->raw, tty->real_raw);
1126 /* Tell the rest of the system the news. Great news. New characters! */
1127 tty_flip_buffer_push (tty);
1128 /* tty_schedule_flip (tty); */
1134 /* Inlined: it is called only once. Remove the inline if you add another
1136 static inline void sx_check_modem_signals (struct sx_port *port)
1141 hi_state = sx_read_channel_byte (port, hi_state);
1142 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
1143 port->c_dcd, sx_get_CD (port));
1145 if (hi_state & ST_BREAK) {
1146 hi_state &= ~ST_BREAK;
1147 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "got a break.\n");
1148 sx_write_channel_byte (port, hi_state, hi_state);
1149 gs_got_break (&port->gs);
1151 if (hi_state & ST_DCD) {
1152 hi_state &= ~ST_DCD;
1153 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
1154 sx_write_channel_byte (port, hi_state, hi_state);
1155 c_dcd = sx_get_CD (port);
1156 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
1157 if (c_dcd != port->c_dcd) {
1158 port->c_dcd = c_dcd;
1159 if (sx_get_CD (port)) {
1161 if ((sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) &&
1162 !(port->gs.tty->termios->c_cflag & CLOCAL) ) {
1163 /* Are we blocking in open?*/
1164 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD active, unblocking open\n");
1165 wake_up_interruptible(&port->gs.open_wait);
1167 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD raised. Ignoring.\n");
1170 /* DCD went down! */
1171 if (!(port->gs.tty->termios->c_cflag & CLOCAL) ) {
1172 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD dropped. hanging up....\n");
1173 tty_hangup (port->gs.tty);
1175 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD dropped. ignoring.\n");
1179 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us DCD changed, but it didn't.\n");
1185 /* This is what an interrupt routine should look like.
1186 * Small, elegant, clear.
1189 static irqreturn_t sx_interrupt (int irq, void *ptr)
1191 struct sx_board *board = ptr;
1192 struct sx_port *port;
1196 sx_dprintk (SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq, board->irq);
1198 /* AAargh! The order in which to do these things is essential and
1201 - Rate limit goes before "recursive". Otherwise a series of
1202 recursive calls will hang the machine in the interrupt routine.
1204 - hardware twiddling goes before "recursive". Otherwise when we
1205 poll the card, and a recursive interrupt happens, we won't
1206 ack the card, so it might keep on interrupting us. (especially
1207 level sensitive interrupt systems like PCI).
1209 - Rate limit goes before hardware twiddling. Otherwise we won't
1210 catch a card that has gone bonkers.
1212 - The "initialized" test goes after the hardware twiddling. Otherwise
1213 the card will stick us in the interrupt routine again.
1215 - The initialized test goes before recursive.
1220 #ifdef IRQ_RATE_LIMIT
1221 /* Aaargh! I'm ashamed. This costs more lines-of-code than the
1222 actual interrupt routine!. (Well, used to when I wrote that comment) */
1227 if (lastjif == jiffies) {
1228 if (++nintr > IRQ_RATE_LIMIT) {
1229 free_irq (board->irq, board);
1230 printk (KERN_ERR "sx: Too many interrupts. Turning off interrupt %d.\n",
1241 if (board->irq == irq) {
1242 /* Tell the card we've noticed the interrupt. */
1244 sx_write_board_word (board, cc_int_pending, 0);
1245 if (IS_SX_BOARD (board)) {
1246 write_sx_byte (board, SX_RESET_IRQ, 1);
1247 } else if (IS_EISA_BOARD(board)) {
1248 inb(board->eisa_base+0xc03);
1249 write_sx_word(board, 8, 0);
1251 write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
1252 write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
1256 if (!sx_initialized)
1258 if (!(board->flags & SX_BOARD_INITIALIZED))
1261 if (test_and_set_bit (SX_BOARD_INTR_LOCK, &board->locks)) {
1262 printk (KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
1266 for (i=0;i<board->nports;i++) {
1267 port = &board->ports[i];
1268 if (port->gs.flags & GS_ACTIVE) {
1269 if (sx_read_channel_byte (port, hi_state)) {
1270 sx_dprintk (SX_DEBUG_INTERRUPTS,
1271 "Port %d: modem signal change?... \n", i);
1272 sx_check_modem_signals (port);
1274 if (port->gs.xmit_cnt) {
1275 sx_transmit_chars (port);
1277 if (!(port->gs.flags & SX_RX_THROTTLE)) {
1278 sx_receive_chars (port);
1283 clear_bit (SX_BOARD_INTR_LOCK, &board->locks);
1285 sx_dprintk (SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq, board->irq);
1291 static void sx_pollfunc (unsigned long data)
1293 struct sx_board *board = (struct sx_board *) data;
1297 sx_interrupt (0, board);
1299 init_timer(&board->timer);
1301 board->timer.expires = jiffies + sx_poll;
1302 add_timer (&board->timer);
1308 /* ********************************************************************** *
1309 * Here are the routines that actually *
1310 * interface with the generic_serial driver *
1311 * ********************************************************************** */
1313 /* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
1314 /* Hmm. Ok I figured it out. You don't. */
1316 static void sx_disable_tx_interrupts (void * ptr)
1318 struct sx_port *port = ptr;
1321 port->gs.flags &= ~GS_TX_INTEN;
1327 static void sx_enable_tx_interrupts (void * ptr)
1329 struct sx_port *port = ptr;
1333 /* First transmit the characters that we're supposed to */
1334 sx_transmit_chars (port);
1336 /* The sx card will never interrupt us if we don't fill the buffer
1337 past 25%. So we keep considering interrupts off if that's the case. */
1338 data_in_buffer = (sx_read_channel_byte (port, hi_txipos) -
1339 sx_read_channel_byte (port, hi_txopos)) & 0xff;
1341 /* XXX Must be "HIGH_WATER" for SI card according to doc. */
1342 if (data_in_buffer < LOW_WATER)
1343 port->gs.flags &= ~GS_TX_INTEN;
1349 static void sx_disable_rx_interrupts (void * ptr)
1351 /* struct sx_port *port = ptr; */
1357 static void sx_enable_rx_interrupts (void * ptr)
1359 /* struct sx_port *port = ptr; */
1366 /* Jeez. Isn't this simple? */
1367 static int sx_get_CD (void * ptr)
1369 struct sx_port *port = ptr;
1373 return ((sx_read_channel_byte (port, hi_ip) & IP_DCD) != 0);
1377 /* Jeez. Isn't this simple? */
1378 static int sx_chars_in_buffer (void * ptr)
1380 struct sx_port *port = ptr;
1384 return ((sx_read_channel_byte (port, hi_txipos) -
1385 sx_read_channel_byte (port, hi_txopos)) & 0xff);
1389 static void sx_shutdown_port (void * ptr)
1391 struct sx_port *port = ptr;
1395 port->gs.flags &= ~ GS_ACTIVE;
1396 if (port->gs.tty && (port->gs.tty->termios->c_cflag & HUPCL)) {
1397 sx_setsignals (port, 0, 0);
1398 sx_reconfigure_port(port);
1408 /* ********************************************************************** *
1409 * Here are the routines that actually *
1410 * interface with the rest of the system *
1411 * ********************************************************************** */
1413 static int sx_open (struct tty_struct * tty, struct file * filp)
1415 struct sx_port *port;
1417 unsigned long flags;
1421 if (!sx_initialized) {
1426 sx_dprintk (SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, np=%d)\n",
1427 current->pid, line, tty, current->signal->tty, sx_nports);
1429 if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1432 port = & sx_ports[line];
1433 port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
1434 1 -> 0 transition. */
1437 sx_dprintk (SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
1439 spin_lock_irqsave(&port->gs.driver_lock, flags);
1441 tty->driver_data = port;
1444 spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1446 sx_dprintk (SX_DEBUG_OPEN, "starting port\n");
1449 * Start up serial port
1451 retval = gs_init_port(&port->gs);
1452 sx_dprintk (SX_DEBUG_OPEN, "done gs_init\n");
1458 port->gs.flags |= GS_ACTIVE;
1459 if (port->gs.count <= 1)
1460 sx_setsignals (port, 1,1);
1463 if (sx_debug & SX_DEBUG_OPEN)
1464 my_hd (port, sizeof (*port));
1466 if (sx_debug & SX_DEBUG_OPEN)
1467 my_hd_io (port->board->base + port->ch_base, sizeof (*port));
1470 if (port->gs.count <= 1) {
1471 if (sx_send_command (port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1472 printk (KERN_ERR "sx: Card didn't respond to LOPEN command.\n");
1473 spin_lock_irqsave(&port->gs.driver_lock, flags);
1475 spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1480 retval = gs_block_til_ready(port, filp);
1481 sx_dprintk (SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
1482 retval, port->gs.count);
1486 * Don't lower gs.count here because sx_close() will be called later
1491 /* tty->low_latency = 1; */
1493 port->c_dcd = sx_get_CD (port);
1494 sx_dprintk (SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
1502 static void sx_close (void *ptr)
1504 struct sx_port *port = ptr;
1505 /* Give the port 5 seconds to close down. */
1510 sx_setsignals (port, 0, 0);
1511 sx_reconfigure_port(port);
1512 sx_send_command (port, HS_CLOSE, 0, 0);
1514 while (to-- && (sx_read_channel_byte (port, hi_hstat) != HS_IDLE_CLOSED))
1515 if (msleep_interruptible(10))
1517 if (sx_read_channel_byte (port, hi_hstat) != HS_IDLE_CLOSED) {
1518 if (sx_send_command (port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED) != 1) {
1520 "sx: sent the force_close command, but card didn't react\n");
1522 sx_dprintk (SX_DEBUG_CLOSE, "sent the force_close command.\n");
1525 sx_dprintk (SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
1526 5 * HZ - to - 1, port->gs.count);
1528 if(port->gs.count) {
1529 sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n", port->gs.count);
1530 //printk ("%s SETTING port count to zero: %p count: %d\n", __FUNCTION__, port, port->gs.count);
1531 //port->gs.count = 0;
1539 /* This is relatively thorough. But then again it is only 20 lines. */
1540 #define MARCHUP for (i=min;i<max;i++)
1541 #define MARCHDOWN for (i=max-1;i>=min;i--)
1542 #define W0 write_sx_byte (board, i, 0x55)
1543 #define W1 write_sx_byte (board, i, 0xaa)
1544 #define R0 if (read_sx_byte (board, i) != 0x55) return 1
1545 #define R1 if (read_sx_byte (board, i) != 0xaa) return 1
1547 /* This memtest takes a human-noticable time. You normally only do it
1548 once a boot, so I guess that it is worth it. */
1549 static int do_memtest (struct sx_board *board, int min, int max)
1553 /* This is a marchb. Theoretically, marchb catches much more than
1554 simpler tests. In practise, the longer test just catches more
1555 intermittent errors. -- REW
1556 (For the theory behind memory testing see:
1557 Testing Semiconductor Memories by A.J. van de Goor.) */
1559 MARCHUP {R0;W1;R1;W0;R0;W1;}
1561 MARCHDOWN {R1;W0;W1;W0;}
1562 MARCHDOWN {R0;W1;W0;}
1575 #define MARCHUP for (i=min;i<max;i+=2)
1576 #define MARCHDOWN for (i=max-1;i>=min;i-=2)
1577 #define W0 write_sx_word (board, i, 0x55aa)
1578 #define W1 write_sx_word (board, i, 0xaa55)
1579 #define R0 if (read_sx_word (board, i) != 0x55aa) return 1
1580 #define R1 if (read_sx_word (board, i) != 0xaa55) return 1
1583 /* This memtest takes a human-noticable time. You normally only do it
1584 once a boot, so I guess that it is worth it. */
1585 static int do_memtest_w (struct sx_board *board, int min, int max)
1590 MARCHUP {R0;W1;R1;W0;R0;W1;}
1592 MARCHDOWN {R1;W0;W1;W0;}
1593 MARCHDOWN {R0;W1;W0;}
1600 static int sx_fw_ioctl (struct inode *inode, struct file *filp,
1601 unsigned int cmd, unsigned long arg)
1604 int __user *descr = (int __user *)arg;
1606 static struct sx_board *board = NULL;
1614 /* Removed superuser check: Sysops can use the permissions on the device
1615 file to restrict access. Recommendation: Root only. (root.root 600) */
1616 if (!capable(CAP_SYS_ADMIN)) {
1621 sx_dprintk (SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
1623 if (!board) board = &boards[0];
1624 if (board->flags & SX_BOARD_PRESENT) {
1625 sx_dprintk (SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1628 sx_dprintk (SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
1630 for (i=0;i< SX_NBOARDS;i++)
1631 sx_dprintk (SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
1632 sx_dprintk (SX_DEBUG_FIRMWARE, "\n");
1637 case SXIO_SET_BOARD:
1638 sx_dprintk (SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
1639 if (arg >= SX_NBOARDS) return -EIO;
1640 sx_dprintk (SX_DEBUG_FIRMWARE, "not out of range\n");
1641 if (!(boards[arg].flags & SX_BOARD_PRESENT)) return -EIO;
1642 sx_dprintk (SX_DEBUG_FIRMWARE, ".. and present!\n");
1643 board = &boards[arg];
1646 rc = -ENOENT; /* If we manage to miss one, return error. */
1647 if (IS_SX_BOARD (board)) rc = SX_TYPE_SX;
1648 if (IS_CF_BOARD (board)) rc = SX_TYPE_CF;
1649 if (IS_SI_BOARD (board)) rc = SX_TYPE_SI;
1650 if (IS_SI1_BOARD (board)) rc = SX_TYPE_SI;
1651 if (IS_EISA_BOARD (board)) rc = SX_TYPE_SI;
1652 sx_dprintk (SX_DEBUG_FIRMWARE, "returning type= %d\n", rc);
1654 case SXIO_DO_RAMTEST:
1655 if (sx_initialized) /* Already initialized: better not ramtest the board. */
1657 if (IS_SX_BOARD (board)) {
1658 rc = do_memtest (board, 0, 0x7000);
1659 if (!rc) rc = do_memtest (board, 0, 0x7000);
1660 /*if (!rc) rc = do_memtest_w (board, 0, 0x7000);*/
1662 rc = do_memtest (board, 0, 0x7ff8);
1663 /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
1665 sx_dprintk (SX_DEBUG_FIRMWARE, "returning memtest result= %d\n", rc);
1668 if (sx_initialized) /* Already initialized */
1670 if (!sx_reset (board))
1672 sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
1674 tmp = kmalloc (SX_CHUNK_SIZE, GFP_USER);
1675 if (!tmp) return -ENOMEM;
1676 get_user (nbytes, descr++);
1677 get_user (offset, descr++);
1678 get_user (data, descr++);
1679 while (nbytes && data) {
1680 for (i=0;i<nbytes;i += SX_CHUNK_SIZE) {
1681 if (copy_from_user(tmp, (char __user *)data+i,
1682 (i + SX_CHUNK_SIZE >
1683 nbytes) ? nbytes - i :
1688 memcpy_toio(board->base2 + offset + i, tmp,
1689 (i+SX_CHUNK_SIZE>nbytes)?nbytes-i:SX_CHUNK_SIZE);
1692 get_user (nbytes, descr++);
1693 get_user (offset, descr++);
1694 get_user (data, descr++);
1697 sx_nports += sx_init_board (board);
1701 if (sx_initialized) /* Already initialized */
1703 /* This is not allowed until all boards are initialized... */
1704 for (i=0;i<SX_NBOARDS;i++) {
1705 if ( (boards[i].flags & SX_BOARD_PRESENT) &&
1706 !(boards[i].flags & SX_BOARD_INITIALIZED))
1709 for (i=0;i<SX_NBOARDS;i++)
1710 if (!(boards[i].flags & SX_BOARD_PRESENT)) break;
1712 sx_dprintk (SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
1713 "%d channels, first board: %d ports\n",
1714 i, sx_nports, boards[0].nports);
1715 rc = sx_init_portstructs (i, sx_nports);
1726 case SXIO_GETGSDEBUG:
1727 case SXIO_SETGSDEBUG:
1730 case SXIO_GETNPORTS:
1734 printk (KERN_WARNING "Unknown ioctl on firmware device (%x).\n", cmd);
1742 static void sx_break (struct tty_struct * tty, int flag)
1744 struct sx_port *port = tty->driver_data;
1750 rv = sx_send_command (port, HS_START, -1, HS_IDLE_BREAK);
1752 rv = sx_send_command (port, HS_STOP, -1, HS_IDLE_OPEN);
1753 if (rv != 1) printk (KERN_ERR "sx: couldn't send break (%x).\n",
1754 read_sx_byte (port->board, CHAN_OFFSET (port, hi_hstat)));
1760 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1762 struct sx_port *port = tty->driver_data;
1763 return sx_getsignals(port);
1766 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1767 unsigned int set, unsigned int clear)
1769 struct sx_port *port = tty->driver_data;
1770 int rts = -1, dtr = -1;
1772 if (set & TIOCM_RTS)
1774 if (set & TIOCM_DTR)
1776 if (clear & TIOCM_RTS)
1778 if (clear & TIOCM_DTR)
1781 sx_setsignals(port, dtr, rts);
1782 sx_reconfigure_port(port);
1786 static int sx_ioctl (struct tty_struct * tty, struct file * filp,
1787 unsigned int cmd, unsigned long arg)
1790 struct sx_port *port = tty->driver_data;
1791 void __user *argp = (void __user *)arg;
1794 /* func_enter2(); */
1799 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
1800 (unsigned __user *) argp);
1803 if ((rc = get_user(ival, (unsigned __user *) argp)) == 0) {
1804 tty->termios->c_cflag =
1805 (tty->termios->c_cflag & ~CLOCAL) |
1806 (ival ? CLOCAL : 0);
1810 rc = gs_getserial(&port->gs, argp);
1813 rc = gs_setserial(&port->gs, argp);
1825 /* The throttle/unthrottle scheme for the Specialix card is different
1826 * from other drivers and deserves some explanation.
1827 * The Specialix hardware takes care of XON/XOFF
1828 * and CTS/RTS flow control itself. This means that all we have to
1829 * do when signalled by the upper tty layer to throttle/unthrottle is
1830 * to make a note of it here. When we come to read characters from the
1831 * rx buffers on the card (sx_receive_chars()) we look to see if the
1832 * upper layer can accept more (as noted here in sx_rx_throt[]).
1833 * If it can't we simply don't remove chars from the cards buffer.
1834 * When the tty layer can accept chars, we again note that here and when
1835 * sx_receive_chars() is called it will remove them from the cards buffer.
1836 * The card will notice that a ports buffer has drained below some low
1837 * water mark and will unflow control the line itself, using whatever
1838 * flow control scheme is in use for that port. -- Simon Allen
1841 static void sx_throttle (struct tty_struct * tty)
1843 struct sx_port *port = (struct sx_port *)tty->driver_data;
1846 /* If the port is using any type of input flow
1847 * control then throttle the port.
1849 if((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty)) ) {
1850 port->gs.flags |= SX_RX_THROTTLE;
1856 static void sx_unthrottle (struct tty_struct * tty)
1858 struct sx_port *port = (struct sx_port *)tty->driver_data;
1861 /* Always unthrottle even if flow control is not enabled on
1862 * this port in case we disabled flow control while the port
1865 port->gs.flags &= ~SX_RX_THROTTLE;
1871 /* ********************************************************************** *
1872 * Here are the initialization routines. *
1873 * ********************************************************************** */
1878 static int sx_init_board (struct sx_board *board)
1886 /* This is preceded by downloading the download code. */
1888 board->flags |= SX_BOARD_INITIALIZED;
1890 if (read_sx_byte (board, 0))
1891 /* CF boards may need this. */
1892 write_sx_byte(board,0, 0);
1894 /* This resets the processor again, to make sure it didn't do any
1895 foolish things while we were downloading the image */
1896 if (!sx_reset (board))
1899 sx_start_board (board);
1901 if (!sx_busy_wait_neq (board, 0, 0xff, 0)) {
1902 printk (KERN_ERR "sx: Ooops. Board won't initialize.\n");
1906 /* Ok. So now the processor on the card is running. It gathered
1907 some info for us... */
1908 sx_dprintk (SX_DEBUG_INIT, "The sxcard structure:\n");
1909 if (sx_debug & SX_DEBUG_INIT) my_hd_io (board->base, 0x10);
1910 sx_dprintk (SX_DEBUG_INIT, "the first sx_module structure:\n");
1911 if (sx_debug & SX_DEBUG_INIT) my_hd_io (board->base + 0x80, 0x30);
1913 sx_dprintk (SX_DEBUG_INIT,
1914 "init_status: %x, %dk memory, firmware V%x.%02x,\n",
1915 read_sx_byte (board, 0), read_sx_byte(board, 1),
1916 read_sx_byte (board, 5), read_sx_byte(board, 4));
1918 if (read_sx_byte (board, 0) == 0xff) {
1919 printk (KERN_INFO "sx: No modules found. Sorry.\n");
1926 if (IS_SX_BOARD(board)) {
1927 sx_write_board_word (board, cc_int_count, sx_maxints);
1930 sx_write_board_word (board, cc_int_count, SI_PROCESSOR_CLOCK/8/sx_maxints);
1933 /* grab the first module type... */
1934 /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
1935 board->ta_type = mod_compat_type (sx_read_module_byte (board, 0x80, mc_chip));
1938 for (addr = 0x80;addr != 0;addr = read_sx_word (board, addr) & 0x7fff) {
1939 type = sx_read_module_byte (board, addr, mc_chip);
1940 sx_dprintk (SX_DEBUG_INIT, "Module at %x: %d channels\n",
1941 addr, read_sx_byte (board, addr + 2));
1943 chans += sx_read_module_byte (board, addr, mc_type);
1945 sx_dprintk (SX_DEBUG_INIT, "module is an %s, which has %s/%s panels\n",
1947 pan_type_s (sx_read_module_byte (board, addr, mc_mods) & 0xf),
1948 pan_type_s (sx_read_module_byte (board, addr, mc_mods) >> 4));
1950 sx_dprintk (SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC version: %x\n",
1951 sx_read_module_byte (board, addr, mc_rev1),
1952 sx_read_module_byte (board, addr, mc_rev2),
1953 sx_read_module_byte (board, addr, mc_mtaasic_rev));
1955 /* The following combinations are illegal: It should theoretically
1956 work, but timing problems make the bus HANG. */
1958 if (mod_compat_type (type) != board->ta_type) {
1959 printk (KERN_ERR "sx: This is an invalid configuration.\n"
1960 "Don't mix TA/MTA/SXDC on the same hostadapter.\n");
1964 if ((IS_EISA_BOARD(board) ||
1965 IS_SI_BOARD(board)) && (mod_compat_type(type) == 4)) {
1966 printk (KERN_ERR "sx: This is an invalid configuration.\n"
1967 "Don't use SXDCs on an SI/XIO adapter.\n");
1971 #if 0 /* Problem fixed: firmware 3.05 */
1972 if (IS_SX_BOARD(board) && (type == TA8)) {
1973 /* There are some issues with the firmware and the DCD/RTS
1974 lines. It might work if you tie them together or something.
1975 It might also work if you get a newer sx_firmware. Therefore
1976 this is just a warning. */
1977 printk (KERN_WARNING "sx: The SX host doesn't work too well "
1978 "with the TA8 adapters.\nSpecialix is working on it.\n");
1984 if(board->irq > 0) {
1985 /* fixed irq, probably PCI */
1986 if(sx_irqmask & (1 << board->irq)) { /* may we use this irq? */
1987 if(request_irq(board->irq, sx_interrupt, IRQF_SHARED | IRQF_DISABLED, "sx", board)) {
1988 printk(KERN_ERR "sx: Cannot allocate irq %d.\n", board->irq);
1993 } else if(board->irq < 0 && sx_irqmask) {
1994 /* auto-allocate irq */
1996 int irqmask = sx_irqmask & (IS_SX_BOARD(board) ? SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
1997 for(irqnr = 15; irqnr > 0; irqnr--)
1998 if(irqmask & (1 << irqnr))
1999 if(! request_irq(irqnr, sx_interrupt, IRQF_SHARED | IRQF_DISABLED, "sx", board))
2002 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2008 /* Found a valid interrupt, start up interrupts! */
2009 sx_dprintk (SX_DEBUG_INIT, "Using irq %d.\n", board->irq);
2010 sx_start_interrupts (board);
2011 board->poll = sx_slowpoll;
2012 board->flags |= SX_IRQ_ALLOCATED;
2014 /* no irq: setup board for polled operation */
2015 board->poll = sx_poll;
2016 sx_dprintk (SX_DEBUG_INIT, "Using poll-interval %d.\n", board->poll);
2019 /* The timer should be initialized anyway: That way we can safely
2020 del_timer it when the module is unloaded. */
2021 init_timer (&board->timer);
2024 board->timer.data = (unsigned long) board;
2025 board->timer.function = sx_pollfunc;
2026 board->timer.expires = jiffies + board->poll;
2027 add_timer (&board->timer);
2033 board->nports = chans;
2034 sx_dprintk (SX_DEBUG_INIT, "returning %d ports.", board->nports);
2041 static void __devinit printheader(void)
2043 static int header_printed;
2045 if (!header_printed) {
2046 printk (KERN_INFO "Specialix SX driver "
2047 "(C) 1998/1999 R.E.Wolff@BitWizard.nl \n");
2048 printk (KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
2054 static int __devinit probe_sx (struct sx_board *board)
2056 struct vpd_prom vpdp;
2062 if (!IS_CF_BOARD (board)) {
2063 sx_dprintk (SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2064 board->base + SX_VPD_ROM);
2066 if (sx_debug & SX_DEBUG_PROBE)
2067 my_hd_io(board->base + SX_VPD_ROM, 0x40);
2070 for (i=0;i< sizeof (struct vpd_prom);i++)
2071 *p++ = read_sx_byte (board, SX_VPD_ROM + i*2);
2073 if (sx_debug & SX_DEBUG_PROBE)
2074 my_hd (&vpdp, 0x20);
2076 sx_dprintk (SX_DEBUG_PROBE, "checking identifier...\n");
2078 if (strncmp (vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2079 sx_dprintk (SX_DEBUG_PROBE, "Got non-SX identifier: '%s'\n",
2087 if (!IS_CF_BOARD (board)) {
2088 printk (KERN_DEBUG "sx: Found an SX board at %lx\n", board->hw_base);
2089 printk (KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, uniq ID:%08x, ",
2090 vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2091 printk ( "Manufactured: %d/%d\n",
2092 1970 + vpdp.myear, vpdp.mweek);
2095 if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) != SX_PCI_UNIQUEID1) &&
2096 (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2097 /* This might be a bit harsh. This was the primary reason the
2098 SX/ISA card didn't work at first... */
2099 printk (KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA card. Sorry: giving up.\n");
2103 if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) == SX_ISA_UNIQUEID1) {
2104 if (((unsigned long)board->hw_base) & 0x8000) {
2105 printk (KERN_WARNING "sx: Warning: There may be hardware problems with the card at %lx.\n", board->hw_base);
2106 printk (KERN_WARNING "sx: Read sx.txt for more info.\n");
2113 /* This resets the processor, and keeps it off the bus. */
2114 if (!sx_reset (board))
2116 sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
2122 #if defined(CONFIG_ISA) || defined(CONFIG_EISA)
2124 /* Specialix probes for this card at 32k increments from 640k to 16M.
2125 I consider machines with less than 16M unlikely nowadays, so I'm
2126 not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2127 card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves
2128 0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2130 static int __devinit probe_si (struct sx_board *board)
2135 sx_dprintk (SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at %p.\n", board->hw_base,
2136 board->base + SI2_ISA_ID_BASE);
2138 if (sx_debug & SX_DEBUG_PROBE)
2139 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2141 if (!IS_EISA_BOARD(board)) {
2142 if( IS_SI1_BOARD(board) )
2145 write_sx_byte (board, SI2_ISA_ID_BASE+7-i,i);
2150 if ((read_sx_byte (board, SI2_ISA_ID_BASE+7-i) & 7) != i) {
2157 /* Now we're pretty much convinced that there is an SI board here,
2158 but to prevent trouble, we'd better double check that we don't
2159 have an SI1 board when we're probing for an SI2 board.... */
2161 write_sx_byte (board, SI2_ISA_ID_BASE,0x10);
2162 if ( IS_SI1_BOARD(board)) {
2163 /* This should be an SI1 board, which has this
2164 location writable... */
2165 if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
2170 /* This should be an SI2 board, which has the bottom
2171 3 bits non-writable... */
2172 if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
2178 /* Now we're pretty much convinced that there is an SI board here,
2179 but to prevent trouble, we'd better double check that we don't
2180 have an SI1 board when we're probing for an SI2 board.... */
2182 write_sx_byte (board, SI2_ISA_ID_BASE,0x10);
2183 if ( IS_SI1_BOARD(board)) {
2184 /* This should be an SI1 board, which has this
2185 location writable... */
2186 if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
2191 /* This should be an SI2 board, which has the bottom
2192 3 bits non-writable... */
2193 if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
2201 printk (KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
2202 /* Compared to the SX boards, it is a complete guess as to what
2203 this card is up to... */
2207 /* This resets the processor, and keeps it off the bus. */
2208 if (!sx_reset (board))
2210 sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
2217 static const struct tty_operations sx_ops = {
2218 .break_ctl = sx_break,
2222 .put_char = gs_put_char,
2223 .flush_chars = gs_flush_chars,
2224 .write_room = gs_write_room,
2225 .chars_in_buffer = gs_chars_in_buffer,
2226 .flush_buffer = gs_flush_buffer,
2228 .throttle = sx_throttle,
2229 .unthrottle = sx_unthrottle,
2230 .set_termios = gs_set_termios,
2233 .hangup = gs_hangup,
2234 .tiocmget = sx_tiocmget,
2235 .tiocmset = sx_tiocmset,
2238 static int sx_init_drivers(void)
2244 sx_driver = alloc_tty_driver(sx_nports);
2247 sx_driver->owner = THIS_MODULE;
2248 sx_driver->driver_name = "specialix_sx";
2249 sx_driver->name = "ttyX";
2250 sx_driver->major = SX_NORMAL_MAJOR;
2251 sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2252 sx_driver->subtype = SERIAL_TYPE_NORMAL;
2253 sx_driver->init_termios = tty_std_termios;
2254 sx_driver->init_termios.c_cflag =
2255 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2256 sx_driver->init_termios.c_ispeed = 9600;
2257 sx_driver->init_termios.c_ospeed = 9600;
2258 sx_driver->flags = TTY_DRIVER_REAL_RAW;
2259 tty_set_operations(sx_driver, &sx_ops);
2261 if ((error = tty_register_driver(sx_driver))) {
2262 put_tty_driver(sx_driver);
2263 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
2271 static int sx_init_portstructs (int nboards, int nports)
2273 struct sx_board *board;
2274 struct sx_port *port;
2281 /* Many drivers statically allocate the maximum number of ports
2282 There is no reason not to allocate them dynamically. Is there? -- REW */
2283 sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
2288 for (i = 0; i < nboards; i++) {
2290 board->ports = port;
2291 for (j=0; j < boards[i].nports;j++) {
2292 sx_dprintk (SX_DEBUG_INIT, "initing port %d\n", j);
2293 port->gs.magic = SX_MAGIC;
2294 port->gs.close_delay = HZ/2;
2295 port->gs.closing_wait = 30 * HZ;
2296 port->board = board;
2297 port->gs.rd = &sx_real_driver;
2298 #ifdef NEW_WRITE_LOCKING
2299 port->gs.port_write_mutex = MUTEX;
2301 spin_lock_init(&port->gs.driver_lock);
2303 * Initializing wait queue
2305 init_waitqueue_head(&port->gs.open_wait);
2306 init_waitqueue_head(&port->gs.close_wait);
2314 for (i = 0; i < nboards; i++) {
2316 board->port_base = portno;
2317 /* Possibly the configuration was rejected. */
2318 sx_dprintk (SX_DEBUG_PROBE, "Board has %d channels\n", board->nports);
2319 if (board->nports <= 0) continue;
2320 /* XXX byteorder ?? */
2321 for (addr = 0x80;addr != 0;addr = read_sx_word (board, addr) & 0x7fff) {
2322 chans = sx_read_module_byte (board, addr, mc_type);
2323 sx_dprintk (SX_DEBUG_PROBE, "Module at %x: %d channels\n", addr, chans);
2324 sx_dprintk (SX_DEBUG_PROBE, "Port at");
2325 for (j=0;j<chans;j++) {
2326 /* The "sx-way" is the way it SHOULD be done. That way in the
2327 future, the firmware may for example pack the structures a bit
2328 more efficient. Neil tells me it isn't going to happen anytime
2330 if (IS_SX_BOARD(board))
2331 port->ch_base = sx_read_module_word (board, addr+j*2, mc_chan_pointer);
2333 port->ch_base = addr + 0x100 + 0x300*j;
2335 sx_dprintk (SX_DEBUG_PROBE, " %x", port->ch_base);
2336 port->line = portno++;
2339 sx_dprintk (SX_DEBUG_PROBE, "\n");
2341 /* This has to be done earlier. */
2342 /* board->flags |= SX_BOARD_INITIALIZED; */
2349 static unsigned int sx_find_free_board(void)
2353 for (i = 0; i < SX_NBOARDS; i++)
2354 if (!(boards[i].flags & SX_BOARD_PRESENT))
2360 static void __exit sx_release_drivers(void)
2363 tty_unregister_driver(sx_driver);
2364 put_tty_driver(sx_driver);
2368 static void __devexit sx_remove_card(struct sx_board *board)
2370 if (board->flags & SX_BOARD_INITIALIZED) {
2371 /* The board should stop messing with us. (actually I mean the
2374 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2375 free_irq(board->irq, board);
2377 /* It is safe/allowed to del_timer a non-active timer */
2378 del_timer(&board->timer);
2379 iounmap(board->base);
2381 board->flags &= ~(SX_BOARD_INITIALIZED|SX_BOARD_PRESENT);
2387 static int __devinit sx_eisa_probe(struct device *dev)
2389 struct eisa_device *edev = to_eisa_device(dev);
2390 struct sx_board *board;
2391 unsigned long eisa_slot = edev->base_addr;
2395 mutex_lock(&sx_boards_lock);
2396 i = sx_find_free_board();
2397 if (i == SX_NBOARDS) {
2398 mutex_unlock(&sx_boards_lock);
2402 board->flags |= SX_BOARD_PRESENT;
2403 mutex_unlock(&sx_boards_lock);
2405 dev_info(dev, "XIO : Signature found in EISA slot %lu, "
2406 "Product %d Rev %d (REPORT THIS TO LKLM)\n",
2408 inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
2409 inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
2411 board->eisa_base = eisa_slot;
2412 board->flags &= ~SX_BOARD_TYPE;
2413 board->flags |= SI_EISA_BOARD;
2415 board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
2416 inb(eisa_slot + 0xc00)) << 16;
2418 board->base = ioremap(board->hw_base, SI2_EISA_WINDOW_LEN);
2420 sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2421 sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2422 board->irq = inb(eisa_slot + 0xc02) >> 4;
2423 sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2425 if (!probe_si(board))
2428 dev_set_drvdata(dev, board);
2432 iounmap(board->base);
2433 board->flags &= ~SX_BOARD_PRESENT;
2438 static int __devexit sx_eisa_remove(struct device *dev)
2440 struct sx_board *board = dev_get_drvdata(dev);
2442 sx_remove_card(board);
2447 static struct eisa_device_id sx_eisa_tbl[] = {
2451 MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2453 static struct eisa_driver sx_eisadriver = {
2454 .id_table = sx_eisa_tbl,
2457 .probe = sx_eisa_probe,
2458 .remove = __devexit_p(sx_eisa_remove),
2464 /********************************************************
2465 * Setting bit 17 in the CNTRL register of the PLX 9050 *
2466 * chip forces a retry on writes while a read is pending.*
2467 * This is to prevent the card locking up on Intel Xeon *
2468 * multiprocessor systems with the NX chipset. -- NV *
2469 ********************************************************/
2471 /* Newer cards are produced with this bit set from the configuration
2472 EEprom. As the bit is read/write for the CPU, we can fix it here,
2473 if we detect that it isn't set correctly. -- REW */
2475 static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
2477 unsigned int hwbase;
2478 void __iomem *rebase;
2481 #define CNTRL_REG_OFFSET 0x50
2482 #define CNTRL_REG_GOODVALUE 0x18260000
2484 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2485 hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2486 rebase = ioremap(hwbase, 0x80);
2487 t = readl (rebase + CNTRL_REG_OFFSET);
2488 if (t != CNTRL_REG_GOODVALUE) {
2489 printk (KERN_DEBUG "sx: performing cntrl reg fix: %08x -> %08x\n", t, CNTRL_REG_GOODVALUE);
2490 writel (CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
2495 static int __devinit sx_pci_probe(struct pci_dev *pdev,
2496 const struct pci_device_id *ent)
2498 struct sx_board *board;
2502 mutex_lock(&sx_boards_lock);
2503 i = sx_find_free_board();
2504 if (i == SX_NBOARDS) {
2505 mutex_unlock(&sx_boards_lock);
2509 board->flags |= SX_BOARD_PRESENT;
2510 mutex_unlock(&sx_boards_lock);
2512 retval = pci_enable_device(pdev);
2516 board->flags &= ~SX_BOARD_TYPE;
2517 board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
2520 /* CF boards use base address 3.... */
2521 if (IS_CF_BOARD (board))
2522 board->hw_base = pci_resource_start(pdev, 3);
2524 board->hw_base = pci_resource_start(pdev, 2);
2526 board->base = ioremap(board->hw_base, WINDOW_LEN (board));
2528 dev_err(&pdev->dev, "ioremap failed\n");
2532 /* Most of the stuff on the CF board is offset by 0x18000 .... */
2533 if (IS_CF_BOARD (board))
2534 board->base += 0x18000;
2536 board->irq = pdev->irq;
2538 dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
2539 board->irq, board->flags);
2541 if (!probe_sx(board)) {
2546 fix_sx_pci(pdev, board);
2548 pci_set_drvdata(pdev, board);
2552 iounmap(board->base2);
2554 board->flags &= ~SX_BOARD_PRESENT;
2559 static void __devexit sx_pci_remove(struct pci_dev *pdev)
2561 struct sx_board *board = pci_get_drvdata(pdev);
2563 sx_remove_card(board);
2566 /* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
2567 its because the standard requires it. So check for SUBVENDOR_ID. */
2568 static struct pci_device_id sx_pci_tbl[] = {
2569 { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2570 .subvendor = 0x0200, .subdevice = PCI_ANY_ID },
2571 { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2572 .subvendor = 0x0300, .subdevice = PCI_ANY_ID },
2575 MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2577 static struct pci_driver sx_pcidriver = {
2579 .id_table = sx_pci_tbl,
2580 .probe = sx_pci_probe,
2581 .remove = __devexit_p(sx_pci_remove)
2584 static int __init sx_init(void)
2590 struct sx_board *board;
2593 unsigned int found = 0;
2597 sx_dprintk (SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n", sx_debug);
2598 if (abs ((long) (&sx_debug) - sx_debug) < 0x10000) {
2599 printk (KERN_WARNING "sx: sx_debug is an address, instead of a value. "
2601 printk ("(%p)\n", &sx_debug);
2605 if (misc_register(&sx_fw_device) < 0) {
2606 printk(KERN_ERR "SX: Unable to register firmware loader driver.\n");
2610 for (i=0;i<NR_SX_ADDRS;i++) {
2611 board = &boards[found];
2612 board->hw_base = sx_probe_addrs[i];
2614 board->base = ioremap(board->hw_base, SX_WINDOW_LEN);
2615 board->flags &= ~SX_BOARD_TYPE;
2616 board->flags |= SX_ISA_BOARD;
2617 board->irq = sx_irqmask?-1:0;
2619 if (probe_sx (board)) {
2620 board->flags |= SX_BOARD_PRESENT;
2623 iounmap(board->base);
2627 for (i=0;i<NR_SI_ADDRS;i++) {
2628 board = &boards[found];
2629 board->hw_base = si_probe_addrs[i];
2631 board->base = ioremap(board->hw_base, SI2_ISA_WINDOW_LEN);
2632 board->flags &= ~SX_BOARD_TYPE;
2633 board->flags |= SI_ISA_BOARD;
2634 board->irq = sx_irqmask ?-1:0;
2636 if (probe_si (board)) {
2637 board->flags |= SX_BOARD_PRESENT;
2640 iounmap (board->base);
2643 for (i=0;i<NR_SI1_ADDRS;i++) {
2644 board = &boards[found];
2645 board->hw_base = si1_probe_addrs[i];
2647 board->base = ioremap(board->hw_base, SI1_ISA_WINDOW_LEN);
2648 board->flags &= ~SX_BOARD_TYPE;
2649 board->flags |= SI1_ISA_BOARD;
2650 board->irq = sx_irqmask ?-1:0;
2652 if (probe_si (board)) {
2653 board->flags |= SX_BOARD_PRESENT;
2656 iounmap (board->base);
2661 retval1 = eisa_driver_register(&sx_eisadriver);
2663 retval = pci_register_driver(&sx_pcidriver);
2666 printk (KERN_INFO "sx: total of %d boards detected.\n", found);
2668 } else if (retval) {
2672 misc_deregister(&sx_fw_device);
2680 static void __exit sx_exit (void)
2683 struct sx_board *board;
2687 eisa_driver_unregister(&sx_eisadriver);
2689 pci_unregister_driver(&sx_pcidriver);
2690 for (i = 0; i < SX_NBOARDS; i++) {
2692 if (board->flags & SX_BOARD_INITIALIZED) {
2693 sx_dprintk (SX_DEBUG_CLEANUP, "Cleaning up board at %p\n", board->base);
2694 /* The board should stop messing with us.
2695 (actually I mean the interrupt) */
2697 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2698 free_irq (board->irq, board);
2700 /* It is safe/allowed to del_timer a non-active timer */
2701 del_timer (& board->timer);
2702 iounmap(board->base);
2705 if (misc_deregister(&sx_fw_device) < 0) {
2706 printk (KERN_INFO "sx: couldn't deregister firmware loader device\n");
2708 sx_dprintk (SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n", sx_initialized);
2710 sx_release_drivers ();
2716 module_init(sx_init);
2717 module_exit(sx_exit);