Merge ../linux-2.6
[linux-2.6] / drivers / char / sx.c
1 /* sx.c -- driver for the Specialix SX series cards. 
2  *
3  *  This driver will also support the older SI, and XIO cards.
4  *
5  *
6  *   (C) 1998 - 2004  R.E.Wolff@BitWizard.nl
7  *
8  *  Simon Allen (simonallen@cix.compulink.co.uk) wrote a previous
9  *  version of this driver. Some fragments may have been copied. (none
10  *  yet :-)
11  *
12  * Specialix pays for the development and support of this driver.
13  * Please DO contact support@specialix.co.uk if you require
14  * support. But please read the documentation (sx.txt) first.
15  *
16  *
17  *
18  *      This program is free software; you can redistribute it and/or
19  *      modify it under the terms of the GNU General Public License as
20  *      published by the Free Software Foundation; either version 2 of
21  *      the License, or (at your option) any later version.
22  *
23  *      This program is distributed in the hope that it will be
24  *      useful, but WITHOUT ANY WARRANTY; without even the implied
25  *      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
26  *      PURPOSE.  See the GNU General Public License for more details.
27  *
28  *      You should have received a copy of the GNU General Public
29  *      License along with this program; if not, write to the Free
30  *      Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
31  *      USA.
32  *
33  * Revision history:
34  * Revision 1.33  2000/03/09 10:00:00  pvdl,wolff
35  * - Fixed module and port counting
36  * - Fixed signal handling
37  * - Fixed an Ooops
38  * 
39  * Revision 1.32  2000/03/07 09:00:00  wolff,pvdl
40  * - Fixed some sx_dprintk typos
41  * - added detection for an invalid board/module configuration
42  *
43  * Revision 1.31  2000/03/06 12:00:00  wolff,pvdl
44  * - Added support for EISA
45  *
46  * Revision 1.30  2000/01/21 17:43:06  wolff
47  * - Added support for SX+
48  *
49  * Revision 1.26  1999/08/05 15:22:14  wolff
50  * - Port to 2.3.x
51  * - Reformatted to Linus' liking.
52  *
53  * Revision 1.25  1999/07/30 14:24:08  wolff
54  * Had accidentally left "gs_debug" set to "-1" instead of "off" (=0).
55  *
56  * Revision 1.24  1999/07/28 09:41:52  wolff
57  * - I noticed the remark about use-count straying in sx.txt. I checked
58  *   sx_open, and found a few places where that could happen. I hope it's
59  *   fixed now.
60  *
61  * Revision 1.23  1999/07/28 08:56:06  wolff
62  * - Fixed crash when sx_firmware run twice.
63  * - Added sx_slowpoll as a module parameter (I guess nobody really wanted
64  *   to change it from the default... )
65  * - Fixed a stupid editing problem I introduced in 1.22.
66  * - Fixed dropping characters on a termios change.
67  *
68  * Revision 1.22  1999/07/26 21:01:43  wolff
69  * Russell Brown noticed that I had overlooked 4 out of six modem control
70  * signals in sx_getsignals. Ooops.
71  *
72  * Revision 1.21  1999/07/23 09:11:33  wolff
73  * I forgot to free dynamically allocated memory when the driver is unloaded.
74  *
75  * Revision 1.20  1999/07/20 06:25:26  wolff
76  * The "closing wait" wasn't honoured. Thanks to James Griffiths for
77  * reporting this.
78  *
79  * Revision 1.19  1999/07/11 08:59:59  wolff
80  * Fixed an oops in close, when an open was pending. Changed the memtest
81  * a bit. Should also test the board in word-mode, however my card fails the
82  * memtest then. I still have to figure out what is wrong...
83  *
84  * Revision 1.18  1999/06/10 09:38:42  wolff
85  * Changed the format of the firmware revision from %04x to %x.%02x .
86  *
87  * Revision 1.17  1999/06/04 09:44:35  wolff
88  * fixed problem: reference to pci stuff when config_pci was off...
89  * Thanks to Jorge Novo for noticing this.
90  *
91  * Revision 1.16  1999/06/02 08:30:15  wolff
92  * added/removed the workaround for the DCD bug in the Firmware.
93  * A bit more debugging code to locate that...
94  *
95  * Revision 1.15  1999/06/01 11:35:30  wolff
96  * when DCD is left low (floating?), on TA's the firmware first tells us
97  * that DCD is high, but after a short while suddenly comes to the
98  * conclusion that it is low. All this would be fine, if it weren't that
99  * Unix requires us to send a "hangup" signal in that case. This usually
100  * all happens BEFORE the program has had a chance to ioctl the device
101  * into clocal mode..
102  *
103  * Revision 1.14  1999/05/25 11:18:59  wolff
104  * Added PCI-fix.
105  * Added checks for return code of sx_sendcommand.
106  * Don't issue "reconfig" if port isn't open yet. (bit us on TA modules...)
107  *
108  * Revision 1.13  1999/04/29 15:18:01  wolff
109  * Fixed an "oops" that showed on SuSE 6.0 systems.
110  * Activate DTR again after stty 0.
111  *
112  * Revision 1.12  1999/04/29 07:49:52  wolff
113  * Improved "stty 0" handling a bit. (used to change baud to 9600 assuming
114  *     the connection would be dropped anyway. That is not always the case,
115  *     and confuses people).
116  * Told the card to always monitor the modem signals.
117  * Added support for dynamic  gs_debug adjustments.
118  * Now tells the rest of the system the number of ports.
119  *
120  * Revision 1.11  1999/04/24 11:11:30  wolff
121  * Fixed two stupid typos in the memory test.
122  *
123  * Revision 1.10  1999/04/24 10:53:39  wolff
124  * Added some of Christian's suggestions.
125  * Fixed an HW_COOK_IN bug (ISIG was not in I_OTHER. We used to trust the
126  * card to send the signal to the process.....)
127  *
128  * Revision 1.9  1999/04/23 07:26:38  wolff
129  * Included Christian Lademann's 2.0 compile-warning fixes and interrupt
130  *    assignment redesign.
131  * Cleanup of some other stuff.
132  *
133  * Revision 1.8  1999/04/16 13:05:30  wolff
134  * fixed a DCD change unnoticed bug.
135  *
136  * Revision 1.7  1999/04/14 22:19:51  wolff
137  * Fixed typo that showed up in 2.0.x builds (get_user instead of Get_user!)
138  *
139  * Revision 1.6  1999/04/13 18:40:20  wolff
140  * changed misc-minor to 161, as assigned by HPA.
141  *
142  * Revision 1.5  1999/04/13 15:12:25  wolff
143  * Fixed use-count leak when "hangup" occurred.
144  * Added workaround for a stupid-PCIBIOS bug.
145  *
146  *
147  * Revision 1.4  1999/04/01 22:47:40  wolff
148  * Fixed < 1M linux-2.0 problem.
149  * (vremap isn't compatible with ioremap in that case)
150  *
151  * Revision 1.3  1999/03/31 13:45:45  wolff
152  * Firmware loading is now done through a separate IOCTL.
153  *
154  * Revision 1.2  1999/03/28 12:22:29  wolff
155  * rcs cleanup
156  *
157  * Revision 1.1  1999/03/28 12:10:34  wolff
158  * Readying for release on 2.0.x (sorry David, 1.01 becomes 1.1 for RCS). 
159  *
160  * Revision 0.12  1999/03/28 09:20:10  wolff
161  * Fixed problem in 0.11, continueing cleanup.
162  *
163  * Revision 0.11  1999/03/28 08:46:44  wolff
164  * cleanup. Not good.
165  *
166  * Revision 0.10  1999/03/28 08:09:43  wolff
167  * Fixed loosing characters on close.
168  *
169  * Revision 0.9  1999/03/21 22:52:01  wolff
170  * Ported back to 2.2.... (minor things)
171  *
172  * Revision 0.8  1999/03/21 22:40:33  wolff
173  * Port to 2.0
174  *
175  * Revision 0.7  1999/03/21 19:06:34  wolff
176  * Fixed hangup processing.
177  *
178  * Revision 0.6  1999/02/05 08:45:14  wolff
179  * fixed real_raw problems. Inclusion into kernel imminent.
180  *
181  * Revision 0.5  1998/12/21 23:51:06  wolff
182  * Snatched a nasty bug: sx_transmit_chars was getting re-entered, and it
183  * shouldn't have. THATs why I want to have transmit interrupts even when
184  * the buffer is empty.
185  *
186  * Revision 0.4  1998/12/17 09:34:46  wolff
187  * PPP works. ioctl works. Basically works!
188  *
189  * Revision 0.3  1998/12/15 13:05:18  wolff
190  * It works! Wow! Gotta start implementing IOCTL and stuff....
191  *
192  * Revision 0.2  1998/12/01 08:33:53  wolff
193  * moved over to 2.1.130
194  *
195  * Revision 0.1  1998/11/03 21:23:51  wolff
196  * Initial revision. Detects SX card.
197  *
198  * */
199
200 #define SX_VERSION      1.33
201
202 #include <linux/module.h>
203 #include <linux/kdev_t.h>
204 #include <linux/kernel.h>
205 #include <linux/sched.h>
206 #include <linux/ioport.h>
207 #include <linux/interrupt.h>
208 #include <linux/errno.h>
209 #include <linux/tty.h>
210 #include <linux/tty_flip.h>
211 #include <linux/mm.h>
212 #include <linux/serial.h>
213 #include <linux/fcntl.h>
214 #include <linux/major.h>
215 #include <linux/delay.h>
216 #include <linux/eisa.h>
217 #include <linux/pci.h>
218 #include <linux/slab.h>
219 #include <linux/init.h>
220 #include <linux/miscdevice.h>
221 #include <linux/bitops.h>
222
223 #include <asm/io.h>
224 #include <asm/uaccess.h>
225
226 /* The 3.0.0 version of sxboards/sxwindow.h  uses BYTE and WORD.... */
227 #define BYTE u8
228 #define WORD u16
229
230 /* .... but the 3.0.4 version uses _u8 and _u16. */
231 #define _u8 u8
232 #define _u16 u16
233
234 #include "sxboards.h"
235 #include "sxwindow.h"
236
237 #include <linux/generic_serial.h>
238 #include "sx.h"
239
240 /* I don't think that this driver can handle more than 256 ports on
241    one machine. You'll have to increase the number of boards in sx.h
242    if you want more than 4 boards.  */
243
244 #ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
245 #define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
246 #endif
247
248 /* Configurable options: 
249    (Don't be too sure that it'll work if you toggle them) */
250
251 /* Am I paranoid or not ? ;-) */
252 #undef SX_PARANOIA_CHECK
253
254 /* 20 -> 2000 per second. The card should rate-limit interrupts at 100
255    Hz, but it is user configurable. I don't recommend going above 1000
256    Hz. The interrupt ratelimit might trigger if the interrupt is
257    shared with a very active other device. */
258 #define IRQ_RATE_LIMIT 20
259
260 /* Sharing interrupts is possible now. If the other device wants more
261    than 2000 interrupts per second, we'd gracefully decline further
262    interrupts. That's not what we want. On the other hand, if the
263    other device interrupts 2000 times a second, don't use the SX
264    interrupt. Use polling. */
265 #undef IRQ_RATE_LIMIT
266
267 #if 0
268 /* Not implemented */
269 /* 
270  * The following defines are mostly for testing purposes. But if you need
271  * some nice reporting in your syslog, you can define them also.
272  */
273 #define SX_REPORT_FIFO
274 #define SX_REPORT_OVERRUN
275 #endif
276
277 /* Function prototypes */
278 static void sx_disable_tx_interrupts(void *ptr);
279 static void sx_enable_tx_interrupts(void *ptr);
280 static void sx_disable_rx_interrupts(void *ptr);
281 static void sx_enable_rx_interrupts(void *ptr);
282 static int sx_get_CD(void *ptr);
283 static void sx_shutdown_port(void *ptr);
284 static int sx_set_real_termios(void *ptr);
285 static void sx_close(void *ptr);
286 static int sx_chars_in_buffer(void *ptr);
287 static int sx_init_board(struct sx_board *board);
288 static int sx_init_portstructs(int nboards, int nports);
289 static int sx_fw_ioctl(struct inode *inode, struct file *filp,
290                 unsigned int cmd, unsigned long arg);
291 static int sx_init_drivers(void);
292
293 static struct tty_driver *sx_driver;
294
295 static DEFINE_MUTEX(sx_boards_lock);
296 static struct sx_board boards[SX_NBOARDS];
297 static struct sx_port *sx_ports;
298 static int sx_initialized;
299 static int sx_nports;
300 static int sx_debug;
301
302 /* You can have the driver poll your card. 
303     - Set sx_poll to 1 to poll every timer tick (10ms on Intel). 
304       This is used when the card cannot use an interrupt for some reason.
305
306     - set sx_slowpoll to 100 to do an extra poll once a second (on Intel). If 
307       the driver misses an interrupt (report this if it DOES happen to you!)
308       everything will continue to work.... 
309  */
310 static int sx_poll = 1;
311 static int sx_slowpoll;
312
313 /* The card limits the number of interrupts per second. 
314    At 115k2 "100" should be sufficient. 
315    If you're using higher baudrates, you can increase this...
316  */
317
318 static int sx_maxints = 100;
319
320 #ifdef CONFIG_ISA
321
322 /* These are the only open spaces in my computer. Yours may have more
323    or less.... -- REW 
324    duh: Card at 0xa0000 is possible on HP Netserver?? -- pvdl
325 */
326 static int sx_probe_addrs[] = {
327         0xc0000, 0xd0000, 0xe0000,
328         0xc8000, 0xd8000, 0xe8000
329 };
330 static int si_probe_addrs[] = {
331         0xc0000, 0xd0000, 0xe0000,
332         0xc8000, 0xd8000, 0xe8000, 0xa0000
333 };
334 static int si1_probe_addrs[] = {
335         0xd0000
336 };
337
338 #define NR_SX_ADDRS ARRAY_SIZE(sx_probe_addrs)
339 #define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
340 #define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
341
342 module_param_array(sx_probe_addrs, int, NULL, 0);
343 module_param_array(si_probe_addrs, int, NULL, 0);
344 #endif
345
346 /* Set the mask to all-ones. This alas, only supports 32 interrupts. 
347    Some architectures may need more. */
348 static int sx_irqmask = -1;
349
350 module_param(sx_poll, int, 0);
351 module_param(sx_slowpoll, int, 0);
352 module_param(sx_maxints, int, 0);
353 module_param(sx_debug, int, 0);
354 module_param(sx_irqmask, int, 0);
355
356 MODULE_LICENSE("GPL");
357
358 static struct real_driver sx_real_driver = {
359         sx_disable_tx_interrupts,
360         sx_enable_tx_interrupts,
361         sx_disable_rx_interrupts,
362         sx_enable_rx_interrupts,
363         sx_get_CD,
364         sx_shutdown_port,
365         sx_set_real_termios,
366         sx_chars_in_buffer,
367         sx_close,
368 };
369
370 /* 
371    This driver can spew a whole lot of debugging output at you. If you
372    need maximum performance, you should disable the DEBUG define. To
373    aid in debugging in the field, I'm leaving the compile-time debug
374    features enabled, and disable them "runtime". That allows me to
375    instruct people with problems to enable debugging without requiring
376    them to recompile... 
377 */
378 #define DEBUG
379
380 #ifdef DEBUG
381 #define sx_dprintk(f, str...)   if (sx_debug & f) printk (str)
382 #else
383 #define sx_dprintk(f, str...)   /* nothing */
384 #endif
385
386 #define func_enter()    sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__func__)
387 #define func_exit()     sx_dprintk(SX_DEBUG_FLOW, "sx: exit  %s\n",__func__)
388
389 #define func_enter2()   sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
390                                 __func__, port->line)
391
392 /* 
393  *  Firmware loader driver specific routines
394  *
395  */
396
397 static const struct file_operations sx_fw_fops = {
398         .owner = THIS_MODULE,
399         .ioctl = sx_fw_ioctl,
400 };
401
402 static struct miscdevice sx_fw_device = {
403         SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
404 };
405
406 #ifdef SX_PARANOIA_CHECK
407
408 /* This doesn't work. Who's paranoid around here? Not me! */
409
410 static inline int sx_paranoia_check(struct sx_port const *port,
411                                     char *name, const char *routine)
412 {
413         static const char *badmagic = KERN_ERR "sx: Warning: bad sx port magic "
414                         "number for device %s in %s\n";
415         static const char *badinfo = KERN_ERR "sx: Warning: null sx port for "
416                         "device %s in %s\n";
417
418         if (!port) {
419                 printk(badinfo, name, routine);
420                 return 1;
421         }
422         if (port->magic != SX_MAGIC) {
423                 printk(badmagic, name, routine);
424                 return 1;
425         }
426
427         return 0;
428 }
429 #else
430 #define sx_paranoia_check(a,b,c) 0
431 #endif
432
433 /* The timeouts. First try 30 times as fast as possible. Then give
434    the card some time to breathe between accesses. (Otherwise the
435    processor on the card might not be able to access its OWN bus... */
436
437 #define TIMEOUT_1 30
438 #define TIMEOUT_2 1000000
439
440 #ifdef DEBUG
441 static void my_hd_io(void __iomem *p, int len)
442 {
443         int i, j, ch;
444         unsigned char __iomem *addr = p;
445
446         for (i = 0; i < len; i += 16) {
447                 printk("%p ", addr + i);
448                 for (j = 0; j < 16; j++) {
449                         printk("%02x %s", readb(addr + j + i),
450                                         (j == 7) ? " " : "");
451                 }
452                 for (j = 0; j < 16; j++) {
453                         ch = readb(addr + j + i);
454                         printk("%c", (ch < 0x20) ? '.' :
455                                         ((ch > 0x7f) ? '.' : ch));
456                 }
457                 printk("\n");
458         }
459 }
460 static void my_hd(void *p, int len)
461 {
462         int i, j, ch;
463         unsigned char *addr = p;
464
465         for (i = 0; i < len; i += 16) {
466                 printk("%p ", addr + i);
467                 for (j = 0; j < 16; j++) {
468                         printk("%02x %s", addr[j + i], (j == 7) ? " " : "");
469                 }
470                 for (j = 0; j < 16; j++) {
471                         ch = addr[j + i];
472                         printk("%c", (ch < 0x20) ? '.' :
473                                         ((ch > 0x7f) ? '.' : ch));
474                 }
475                 printk("\n");
476         }
477 }
478 #endif
479
480 /* This needs redoing for Alpha -- REW -- Done. */
481
482 static inline void write_sx_byte(struct sx_board *board, int offset, u8 byte)
483 {
484         writeb(byte, board->base + offset);
485 }
486
487 static inline u8 read_sx_byte(struct sx_board *board, int offset)
488 {
489         return readb(board->base + offset);
490 }
491
492 static inline void write_sx_word(struct sx_board *board, int offset, u16 word)
493 {
494         writew(word, board->base + offset);
495 }
496
497 static inline u16 read_sx_word(struct sx_board *board, int offset)
498 {
499         return readw(board->base + offset);
500 }
501
502 static int sx_busy_wait_eq(struct sx_board *board,
503                 int offset, int mask, int correctval)
504 {
505         int i;
506
507         func_enter();
508
509         for (i = 0; i < TIMEOUT_1; i++)
510                 if ((read_sx_byte(board, offset) & mask) == correctval) {
511                         func_exit();
512                         return 1;
513                 }
514
515         for (i = 0; i < TIMEOUT_2; i++) {
516                 if ((read_sx_byte(board, offset) & mask) == correctval) {
517                         func_exit();
518                         return 1;
519                 }
520                 udelay(1);
521         }
522
523         func_exit();
524         return 0;
525 }
526
527 static int sx_busy_wait_neq(struct sx_board *board,
528                 int offset, int mask, int badval)
529 {
530         int i;
531
532         func_enter();
533
534         for (i = 0; i < TIMEOUT_1; i++)
535                 if ((read_sx_byte(board, offset) & mask) != badval) {
536                         func_exit();
537                         return 1;
538                 }
539
540         for (i = 0; i < TIMEOUT_2; i++) {
541                 if ((read_sx_byte(board, offset) & mask) != badval) {
542                         func_exit();
543                         return 1;
544                 }
545                 udelay(1);
546         }
547
548         func_exit();
549         return 0;
550 }
551
552 /* 5.6.4 of 6210028 r2.3 */
553 static int sx_reset(struct sx_board *board)
554 {
555         func_enter();
556
557         if (IS_SX_BOARD(board)) {
558
559                 write_sx_byte(board, SX_CONFIG, 0);
560                 write_sx_byte(board, SX_RESET, 1); /* Value doesn't matter */
561
562                 if (!sx_busy_wait_eq(board, SX_RESET_STATUS, 1, 0)) {
563                         printk(KERN_INFO "sx: Card doesn't respond to "
564                                         "reset...\n");
565                         return 0;
566                 }
567         } else if (IS_EISA_BOARD(board)) {
568                 outb(board->irq << 4, board->eisa_base + 0xc02);
569         } else if (IS_SI1_BOARD(board)) {
570                 write_sx_byte(board, SI1_ISA_RESET, 0); /*value doesn't matter*/
571         } else {
572                 /* Gory details of the SI/ISA board */
573                 write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
574                 write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
575                 write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
576                 write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
577                 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
578                 write_sx_byte(board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
579         }
580
581         func_exit();
582         return 1;
583 }
584
585 /* This doesn't work on machines where "NULL" isn't 0 */
586 /* If you have one of those, someone will need to write 
587    the equivalent of this, which will amount to about 3 lines. I don't
588    want to complicate this right now. -- REW
589    (See, I do write comments every now and then :-) */
590 #define OFFSETOF(strct, elem)   ((long)&(((struct strct *)NULL)->elem))
591
592 #define CHAN_OFFSET(port,elem)  (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
593 #define MODU_OFFSET(board,addr,elem)    (addr + OFFSETOF (_SXMODULE, elem))
594 #define  BRD_OFFSET(board,elem) (OFFSETOF (_SXCARD, elem))
595
596 #define sx_write_channel_byte(port, elem, val) \
597         write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
598
599 #define sx_read_channel_byte(port, elem) \
600         read_sx_byte (port->board, CHAN_OFFSET (port, elem))
601
602 #define sx_write_channel_word(port, elem, val) \
603         write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
604
605 #define sx_read_channel_word(port, elem) \
606         read_sx_word (port->board, CHAN_OFFSET (port, elem))
607
608 #define sx_write_module_byte(board, addr, elem, val) \
609         write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
610
611 #define sx_read_module_byte(board, addr, elem) \
612         read_sx_byte (board, MODU_OFFSET (board, addr, elem))
613
614 #define sx_write_module_word(board, addr, elem, val) \
615         write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
616
617 #define sx_read_module_word(board, addr, elem) \
618         read_sx_word (board, MODU_OFFSET (board, addr, elem))
619
620 #define sx_write_board_byte(board, elem, val) \
621         write_sx_byte (board, BRD_OFFSET (board, elem), val)
622
623 #define sx_read_board_byte(board, elem) \
624         read_sx_byte (board, BRD_OFFSET (board, elem))
625
626 #define sx_write_board_word(board, elem, val) \
627         write_sx_word (board, BRD_OFFSET (board, elem), val)
628
629 #define sx_read_board_word(board, elem) \
630         read_sx_word (board, BRD_OFFSET (board, elem))
631
632 static int sx_start_board(struct sx_board *board)
633 {
634         if (IS_SX_BOARD(board)) {
635                 write_sx_byte(board, SX_CONFIG, SX_CONF_BUSEN);
636         } else if (IS_EISA_BOARD(board)) {
637                 write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
638                 outb((board->irq << 4) | 4, board->eisa_base + 0xc02);
639         } else if (IS_SI1_BOARD(board)) {
640                 write_sx_byte(board, SI1_ISA_RESET_CLEAR, 0);
641                 write_sx_byte(board, SI1_ISA_INTCL, 0);
642         } else {
643                 /* Don't bug me about the clear_set. 
644                    I haven't the foggiest idea what it's about -- REW */
645                 write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
646                 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
647         }
648         return 1;
649 }
650
651 #define SX_IRQ_REG_VAL(board) \
652         ((board->flags & SX_ISA_BOARD) ? (board->irq << 4) : 0)
653
654 /* Note. The SX register is write-only. Therefore, we have to enable the
655    bus too. This is a no-op, if you don't mess with this driver... */
656 static int sx_start_interrupts(struct sx_board *board)
657 {
658
659         /* Don't call this with board->irq == 0 */
660
661         if (IS_SX_BOARD(board)) {
662                 write_sx_byte(board, SX_CONFIG, SX_IRQ_REG_VAL(board) |
663                                 SX_CONF_BUSEN | SX_CONF_HOSTIRQ);
664         } else if (IS_EISA_BOARD(board)) {
665                 inb(board->eisa_base + 0xc03);
666         } else if (IS_SI1_BOARD(board)) {
667                 write_sx_byte(board, SI1_ISA_INTCL, 0);
668                 write_sx_byte(board, SI1_ISA_INTCL_CLEAR, 0);
669         } else {
670                 switch (board->irq) {
671                 case 11:
672                         write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);
673                         break;
674                 case 12:
675                         write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);
676                         break;
677                 case 15:
678                         write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);
679                         break;
680                 default:
681                         printk(KERN_INFO "sx: SI/XIO card doesn't support "
682                                         "interrupt %d.\n", board->irq);
683                         return 0;
684                 }
685                 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
686         }
687
688         return 1;
689 }
690
691 static int sx_send_command(struct sx_port *port,
692                 int command, int mask, int newstat)
693 {
694         func_enter2();
695         write_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat), command);
696         func_exit();
697         return sx_busy_wait_eq(port->board, CHAN_OFFSET(port, hi_hstat), mask,
698                         newstat);
699 }
700
701 static char *mod_type_s(int module_type)
702 {
703         switch (module_type) {
704         case TA4:
705                 return "TA4";
706         case TA8:
707                 return "TA8";
708         case TA4_ASIC:
709                 return "TA4_ASIC";
710         case TA8_ASIC:
711                 return "TA8_ASIC";
712         case MTA_CD1400:
713                 return "MTA_CD1400";
714         case SXDC:
715                 return "SXDC";
716         default:
717                 return "Unknown/invalid";
718         }
719 }
720
721 static char *pan_type_s(int pan_type)
722 {
723         switch (pan_type) {
724         case MOD_RS232DB25:
725                 return "MOD_RS232DB25";
726         case MOD_RS232RJ45:
727                 return "MOD_RS232RJ45";
728         case MOD_RS422DB25:
729                 return "MOD_RS422DB25";
730         case MOD_PARALLEL:
731                 return "MOD_PARALLEL";
732         case MOD_2_RS232DB25:
733                 return "MOD_2_RS232DB25";
734         case MOD_2_RS232RJ45:
735                 return "MOD_2_RS232RJ45";
736         case MOD_2_RS422DB25:
737                 return "MOD_2_RS422DB25";
738         case MOD_RS232DB25MALE:
739                 return "MOD_RS232DB25MALE";
740         case MOD_2_PARALLEL:
741                 return "MOD_2_PARALLEL";
742         case MOD_BLANK:
743                 return "empty";
744         default:
745                 return "invalid";
746         }
747 }
748
749 static int mod_compat_type(int module_type)
750 {
751         return module_type >> 4;
752 }
753
754 static void sx_reconfigure_port(struct sx_port *port)
755 {
756         if (sx_read_channel_byte(port, hi_hstat) == HS_IDLE_OPEN) {
757                 if (sx_send_command(port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
758                         printk(KERN_WARNING "sx: Sent reconfigure command, but "
759                                         "card didn't react.\n");
760                 }
761         } else {
762                 sx_dprintk(SX_DEBUG_TERMIOS, "sx: Not sending reconfigure: "
763                                 "port isn't open (%02x).\n",
764                                 sx_read_channel_byte(port, hi_hstat));
765         }
766 }
767
768 static void sx_setsignals(struct sx_port *port, int dtr, int rts)
769 {
770         int t;
771         func_enter2();
772
773         t = sx_read_channel_byte(port, hi_op);
774         if (dtr >= 0)
775                 t = dtr ? (t | OP_DTR) : (t & ~OP_DTR);
776         if (rts >= 0)
777                 t = rts ? (t | OP_RTS) : (t & ~OP_RTS);
778         sx_write_channel_byte(port, hi_op, t);
779         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
780
781         func_exit();
782 }
783
784 static int sx_getsignals(struct sx_port *port)
785 {
786         int i_stat, o_stat;
787
788         o_stat = sx_read_channel_byte(port, hi_op);
789         i_stat = sx_read_channel_byte(port, hi_ip);
790
791         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d  (%d/%d) "
792                         "%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));
797
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));
804 }
805
806 static void sx_set_baud(struct sx_port *port)
807 {
808         int t;
809
810         if (port->board->ta_type == MOD_SXDC) {
811                 switch (port->gs.baud) {
812                         /* Save some typing work... */
813 #define e(x) case x: t = BAUD_ ## x; break
814                         e(50);
815                         e(75);
816                         e(110);
817                         e(150);
818                         e(200);
819                         e(300);
820                         e(600);
821                         e(1200);
822                         e(1800);
823                         e(2000);
824                         e(2400);
825                         e(4800);
826                         e(7200);
827                         e(9600);
828                         e(14400);
829                         e(19200);
830                         e(28800);
831                         e(38400);
832                         e(56000);
833                         e(57600);
834                         e(64000);
835                         e(76800);
836                         e(115200);
837                         e(128000);
838                         e(150000);
839                         e(230400);
840                         e(256000);
841                         e(460800);
842                         e(921600);
843                 case 134:
844                         t = BAUD_134_5;
845                         break;
846                 case 0:
847                         t = -1;
848                         break;
849                 default:
850                         /* Can I return "invalid"? */
851                         t = BAUD_9600;
852                         printk(KERN_INFO "sx: unsupported baud rate: %d.\n",
853                                         port->gs.baud);
854                         break;
855                 }
856 #undef e
857                 if (t > 0) {
858 /* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
859                         sx_setsignals(port, 1, -1);
860                         /* XXX This is not TA & MTA compatible */
861                         sx_write_channel_byte(port, hi_csr, 0xff);
862
863                         sx_write_channel_byte(port, hi_txbaud, t);
864                         sx_write_channel_byte(port, hi_rxbaud, t);
865                 } else {
866                         sx_setsignals(port, 0, -1);
867                 }
868         } else {
869                 switch (port->gs.baud) {
870 #define e(x) case x: t = CSR_ ## x; break
871                         e(75);
872                         e(150);
873                         e(300);
874                         e(600);
875                         e(1200);
876                         e(2400);
877                         e(4800);
878                         e(1800);
879                         e(9600);
880                         e(19200);
881                         e(57600);
882                         e(38400);
883 /* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
884                 case 110:
885                         if (port->board->ta_type == MOD_TA) {
886                                 t = CSR_110;
887                                 break;
888                         } else {
889                                 t = CSR_9600;
890                                 printk(KERN_INFO "sx: Unsupported baud rate: "
891                                                 "%d.\n", port->gs.baud);
892                                 break;
893                         }
894                 case 115200:
895                         if (port->board->ta_type == MOD_TA) {
896                                 t = CSR_9600;
897                                 printk(KERN_INFO "sx: Unsupported baud rate: "
898                                                 "%d.\n", port->gs.baud);
899                                 break;
900                         } else {
901                                 t = CSR_110;
902                                 break;
903                         }
904                 case 0:
905                         t = -1;
906                         break;
907                 default:
908                         t = CSR_9600;
909                         printk(KERN_INFO "sx: Unsupported baud rate: %d.\n",
910                                         port->gs.baud);
911                         break;
912                 }
913 #undef e
914                 if (t >= 0) {
915                         sx_setsignals(port, 1, -1);
916                         sx_write_channel_byte(port, hi_csr, t * 0x11);
917                 } else {
918                         sx_setsignals(port, 0, -1);
919                 }
920         }
921 }
922
923 /* Simon Allen's version of this routine was 225 lines long. 85 is a lot
924    better. -- REW */
925
926 static int sx_set_real_termios(void *ptr)
927 {
928         struct sx_port *port = ptr;
929
930         func_enter2();
931
932         if (!port->gs.port.tty)
933                 return 0;
934
935         /* What is this doing here? -- REW
936            Ha! figured it out. It is to allow you to get DTR active again
937            if you've dropped it with stty 0. Moved to set_baud, where it
938            belongs (next to the drop dtr if baud == 0) -- REW */
939         /* sx_setsignals (port, 1, -1); */
940
941         sx_set_baud(port);
942
943 #define CFLAG port->gs.port.tty->termios->c_cflag
944         sx_write_channel_byte(port, hi_mr1,
945                         (C_PARENB(port->gs.port.tty) ? MR1_WITH : MR1_NONE) |
946                         (C_PARODD(port->gs.port.tty) ? MR1_ODD : MR1_EVEN) |
947                         (C_CRTSCTS(port->gs.port.tty) ? MR1_RTS_RXFLOW : 0) |
948                         (((CFLAG & CSIZE) == CS8) ? MR1_8_BITS : 0) |
949                         (((CFLAG & CSIZE) == CS7) ? MR1_7_BITS : 0) |
950                         (((CFLAG & CSIZE) == CS6) ? MR1_6_BITS : 0) |
951                         (((CFLAG & CSIZE) == CS5) ? MR1_5_BITS : 0));
952
953         sx_write_channel_byte(port, hi_mr2,
954                         (C_CRTSCTS(port->gs.port.tty) ? MR2_CTS_TXFLOW : 0) |
955                         (C_CSTOPB(port->gs.port.tty) ? MR2_2_STOP :
956                         MR2_1_STOP));
957
958         switch (CFLAG & CSIZE) {
959         case CS8:
960                 sx_write_channel_byte(port, hi_mask, 0xff);
961                 break;
962         case CS7:
963                 sx_write_channel_byte(port, hi_mask, 0x7f);
964                 break;
965         case CS6:
966                 sx_write_channel_byte(port, hi_mask, 0x3f);
967                 break;
968         case CS5:
969                 sx_write_channel_byte(port, hi_mask, 0x1f);
970                 break;
971         default:
972                 printk(KERN_INFO "sx: Invalid wordsize: %u\n",
973                         (unsigned int)CFLAG & CSIZE);
974                 break;
975         }
976
977         sx_write_channel_byte(port, hi_prtcl,
978                         (I_IXON(port->gs.port.tty) ? SP_TXEN : 0) |
979                         (I_IXOFF(port->gs.port.tty) ? SP_RXEN : 0) |
980                         (I_IXANY(port->gs.port.tty) ? SP_TANY : 0) | SP_DCEN);
981
982         sx_write_channel_byte(port, hi_break,
983                         (I_IGNBRK(port->gs.port.tty) ? BR_IGN : 0 |
984                         I_BRKINT(port->gs.port.tty) ? BR_INT : 0));
985
986         sx_write_channel_byte(port, hi_txon, START_CHAR(port->gs.port.tty));
987         sx_write_channel_byte(port, hi_rxon, START_CHAR(port->gs.port.tty));
988         sx_write_channel_byte(port, hi_txoff, STOP_CHAR(port->gs.port.tty));
989         sx_write_channel_byte(port, hi_rxoff, STOP_CHAR(port->gs.port.tty));
990
991         sx_reconfigure_port(port);
992
993         /* Tell line discipline whether we will do input cooking */
994         if (I_OTHER(port->gs.port.tty)) {
995                 clear_bit(TTY_HW_COOK_IN, &port->gs.port.tty->flags);
996         } else {
997                 set_bit(TTY_HW_COOK_IN, &port->gs.port.tty->flags);
998         }
999         sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
1000                         (unsigned int)port->gs.port.tty->termios->c_iflag,
1001                         I_OTHER(port->gs.port.tty));
1002
1003 /* Tell line discipline whether we will do output cooking.
1004  * If OPOST is set and no other output flags are set then we can do output
1005  * processing.  Even if only *one* other flag in the O_OTHER group is set
1006  * we do cooking in software.
1007  */
1008         if (O_OPOST(port->gs.port.tty) && !O_OTHER(port->gs.port.tty)) {
1009                 set_bit(TTY_HW_COOK_OUT, &port->gs.port.tty->flags);
1010         } else {
1011                 clear_bit(TTY_HW_COOK_OUT, &port->gs.port.tty->flags);
1012         }
1013         sx_dprintk(SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
1014                         (unsigned int)port->gs.port.tty->termios->c_oflag,
1015                         O_OTHER(port->gs.port.tty));
1016         /* port->c_dcd = sx_get_CD (port); */
1017         func_exit();
1018         return 0;
1019 }
1020
1021 /* ********************************************************************** *
1022  *                   the interrupt related routines                       *
1023  * ********************************************************************** */
1024
1025 /* Note:
1026    Other drivers use the macro "MIN" to calculate how much to copy.
1027    This has the disadvantage that it will evaluate parts twice. That's
1028    expensive when it's IO (and the compiler cannot optimize those away!).
1029    Moreover, I'm not sure that you're race-free. 
1030
1031    I assign a value, and then only allow the value to decrease. This
1032    is always safe. This makes the code a few lines longer, and you
1033    know I'm dead against that, but I think it is required in this
1034    case.  */
1035
1036 static void sx_transmit_chars(struct sx_port *port)
1037 {
1038         int c;
1039         int tx_ip;
1040         int txroom;
1041
1042         func_enter2();
1043         sx_dprintk(SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
1044                         port, port->gs.xmit_cnt);
1045
1046         if (test_and_set_bit(SX_PORT_TRANSMIT_LOCK, &port->locks)) {
1047                 return;
1048         }
1049
1050         while (1) {
1051                 c = port->gs.xmit_cnt;
1052
1053                 sx_dprintk(SX_DEBUG_TRANSMIT, "Copying %d ", c);
1054                 tx_ip = sx_read_channel_byte(port, hi_txipos);
1055
1056                 /* Took me 5 minutes to deduce this formula. 
1057                    Luckily it is literally in the manual in section 6.5.4.3.5 */
1058                 txroom = (sx_read_channel_byte(port, hi_txopos) - tx_ip - 1) &
1059                                 0xff;
1060
1061                 /* Don't copy more bytes than there is room for in the buffer */
1062                 if (c > txroom)
1063                         c = txroom;
1064                 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom);
1065
1066                 /* Don't copy past the end of the hardware transmit buffer */
1067                 if (c > 0x100 - tx_ip)
1068                         c = 0x100 - tx_ip;
1069
1070                 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100 - tx_ip);
1071
1072                 /* Don't copy pas the end of the source buffer */
1073                 if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
1074                         c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
1075
1076                 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%ld) \n",
1077                                 c, SERIAL_XMIT_SIZE - port->gs.xmit_tail);
1078
1079                 /* If for one reason or another, we can't copy more data, we're
1080                    done! */
1081                 if (c == 0)
1082                         break;
1083
1084                 memcpy_toio(port->board->base + CHAN_OFFSET(port, hi_txbuf) +
1085                         tx_ip, port->gs.xmit_buf + port->gs.xmit_tail, c);
1086
1087                 /* Update the pointer in the card */
1088                 sx_write_channel_byte(port, hi_txipos, (tx_ip + c) & 0xff);
1089
1090                 /* Update the kernel buffer end */
1091                 port->gs.xmit_tail = (port->gs.xmit_tail + c) &
1092                                 (SERIAL_XMIT_SIZE - 1);
1093
1094                 /* This one last. (this is essential)
1095                    It would allow others to start putting more data into the
1096                    buffer! */
1097                 port->gs.xmit_cnt -= c;
1098         }
1099
1100         if (port->gs.xmit_cnt == 0) {
1101                 sx_disable_tx_interrupts(port);
1102         }
1103
1104         if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.port.tty) {
1105                 tty_wakeup(port->gs.port.tty);
1106                 sx_dprintk(SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
1107                                 port->gs.wakeup_chars);
1108         }
1109
1110         clear_bit(SX_PORT_TRANSMIT_LOCK, &port->locks);
1111         func_exit();
1112 }
1113
1114 /* Note the symmetry between receiving chars and transmitting them!
1115    Note: The kernel should have implemented both a receive buffer and
1116    a transmit buffer. */
1117
1118 /* Inlined: Called only once. Remove the inline when you add another call */
1119 static inline void sx_receive_chars(struct sx_port *port)
1120 {
1121         int c;
1122         int rx_op;
1123         struct tty_struct *tty;
1124         int copied = 0;
1125         unsigned char *rp;
1126
1127         func_enter2();
1128         tty = port->gs.port.tty;
1129         while (1) {
1130                 rx_op = sx_read_channel_byte(port, hi_rxopos);
1131                 c = (sx_read_channel_byte(port, hi_rxipos) - rx_op) & 0xff;
1132
1133                 sx_dprintk(SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
1134
1135                 /* Don't copy past the end of the hardware receive buffer */
1136                 if (rx_op + c > 0x100)
1137                         c = 0x100 - rx_op;
1138
1139                 sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
1140
1141                 /* Don't copy more bytes than there is room for in the buffer */
1142
1143                 c = tty_prepare_flip_string(tty, &rp, c);
1144
1145                 sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
1146
1147                 /* If for one reason or another, we can't copy more data, we're done! */
1148                 if (c == 0)
1149                         break;
1150
1151                 sx_dprintk(SX_DEBUG_RECEIVE, "Copying over %d chars. First is "
1152                                 "%d at %lx\n", c, read_sx_byte(port->board,
1153                                         CHAN_OFFSET(port, hi_rxbuf) + rx_op),
1154                                 CHAN_OFFSET(port, hi_rxbuf));
1155                 memcpy_fromio(rp, port->board->base +
1156                                 CHAN_OFFSET(port, hi_rxbuf) + rx_op, c);
1157
1158                 /* This one last. ( Not essential.)
1159                    It allows the card to start putting more data into the
1160                    buffer!
1161                    Update the pointer in the card */
1162                 sx_write_channel_byte(port, hi_rxopos, (rx_op + c) & 0xff);
1163
1164                 copied += c;
1165         }
1166         if (copied) {
1167                 struct timeval tv;
1168
1169                 do_gettimeofday(&tv);
1170                 sx_dprintk(SX_DEBUG_RECEIVE, "pushing flipq port %d (%3d "
1171                                 "chars): %d.%06d  (%d/%d)\n", port->line,
1172                                 copied, (int)(tv.tv_sec % 60), (int)tv.tv_usec,
1173                                 tty->raw, tty->real_raw);
1174
1175                 /* Tell the rest of the system the news. Great news. New
1176                    characters! */
1177                 tty_flip_buffer_push(tty);
1178                 /*    tty_schedule_flip (tty); */
1179         }
1180
1181         func_exit();
1182 }
1183
1184 /* Inlined: it is called only once. Remove the inline if you add another 
1185    call */
1186 static inline void sx_check_modem_signals(struct sx_port *port)
1187 {
1188         int hi_state;
1189         int c_dcd;
1190
1191         hi_state = sx_read_channel_byte(port, hi_state);
1192         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
1193                         port->c_dcd, sx_get_CD(port));
1194
1195         if (hi_state & ST_BREAK) {
1196                 hi_state &= ~ST_BREAK;
1197                 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a break.\n");
1198                 sx_write_channel_byte(port, hi_state, hi_state);
1199                 gs_got_break(&port->gs);
1200         }
1201         if (hi_state & ST_DCD) {
1202                 hi_state &= ~ST_DCD;
1203                 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
1204                 sx_write_channel_byte(port, hi_state, hi_state);
1205                 c_dcd = sx_get_CD(port);
1206                 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
1207                 if (c_dcd != port->c_dcd) {
1208                         port->c_dcd = c_dcd;
1209                         if (sx_get_CD(port)) {
1210                                 /* DCD went UP */
1211                                 if ((sx_read_channel_byte(port, hi_hstat) !=
1212                                                 HS_IDLE_CLOSED) &&
1213                                                 !(port->gs.port.tty->termios->
1214                                                         c_cflag & CLOCAL)) {
1215                                         /* Are we blocking in open? */
1216                                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1217                                                 "active, unblocking open\n");
1218                                         wake_up_interruptible(&port->gs.port.
1219                                                         open_wait);
1220                                 } else {
1221                                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1222                                                 "raised. Ignoring.\n");
1223                                 }
1224                         } else {
1225                                 /* DCD went down! */
1226                                 if (!(port->gs.port.tty->termios->c_cflag & CLOCAL)){
1227                                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1228                                                 "dropped. hanging up....\n");
1229                                         tty_hangup(port->gs.port.tty);
1230                                 } else {
1231                                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1232                                                 "dropped. ignoring.\n");
1233                                 }
1234                         }
1235                 } else {
1236                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us "
1237                                 "DCD changed, but it didn't.\n");
1238                 }
1239         }
1240 }
1241
1242 /* This is what an interrupt routine should look like. 
1243  * Small, elegant, clear.
1244  */
1245
1246 static irqreturn_t sx_interrupt(int irq, void *ptr)
1247 {
1248         struct sx_board *board = ptr;
1249         struct sx_port *port;
1250         int i;
1251
1252         func_enter();
1253         sx_dprintk(SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq,
1254                         board->irq);
1255
1256         /* AAargh! The order in which to do these things is essential and
1257            not trivial. 
1258
1259            - Rate limit goes before "recursive". Otherwise a series of
1260            recursive calls will hang the machine in the interrupt routine.
1261
1262            - hardware twiddling goes before "recursive". Otherwise when we
1263            poll the card, and a recursive interrupt happens, we won't
1264            ack the card, so it might keep on interrupting us. (especially
1265            level sensitive interrupt systems like PCI).
1266
1267            - Rate limit goes before hardware twiddling. Otherwise we won't
1268            catch a card that has gone bonkers.
1269
1270            - The "initialized" test goes after the hardware twiddling. Otherwise
1271            the card will stick us in the interrupt routine again.
1272
1273            - The initialized test goes before recursive. 
1274          */
1275
1276 #ifdef IRQ_RATE_LIMIT
1277         /* Aaargh! I'm ashamed. This costs more lines-of-code than the
1278            actual interrupt routine!. (Well, used to when I wrote that
1279            comment) */
1280         {
1281                 static int lastjif;
1282                 static int nintr = 0;
1283
1284                 if (lastjif == jiffies) {
1285                         if (++nintr > IRQ_RATE_LIMIT) {
1286                                 free_irq(board->irq, board);
1287                                 printk(KERN_ERR "sx: Too many interrupts. "
1288                                                 "Turning off interrupt %d.\n",
1289                                                 board->irq);
1290                         }
1291                 } else {
1292                         lastjif = jiffies;
1293                         nintr = 0;
1294                 }
1295         }
1296 #endif
1297
1298         if (board->irq == irq) {
1299                 /* Tell the card we've noticed the interrupt. */
1300
1301                 sx_write_board_word(board, cc_int_pending, 0);
1302                 if (IS_SX_BOARD(board)) {
1303                         write_sx_byte(board, SX_RESET_IRQ, 1);
1304                 } else if (IS_EISA_BOARD(board)) {
1305                         inb(board->eisa_base + 0xc03);
1306                         write_sx_word(board, 8, 0);
1307                 } else {
1308                         write_sx_byte(board, SI2_ISA_INTCLEAR,
1309                                         SI2_ISA_INTCLEAR_CLEAR);
1310                         write_sx_byte(board, SI2_ISA_INTCLEAR,
1311                                         SI2_ISA_INTCLEAR_SET);
1312                 }
1313         }
1314
1315         if (!sx_initialized)
1316                 return IRQ_HANDLED;
1317         if (!(board->flags & SX_BOARD_INITIALIZED))
1318                 return IRQ_HANDLED;
1319
1320         if (test_and_set_bit(SX_BOARD_INTR_LOCK, &board->locks)) {
1321                 printk(KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
1322                 return IRQ_HANDLED;
1323         }
1324
1325         for (i = 0; i < board->nports; i++) {
1326                 port = &board->ports[i];
1327                 if (port->gs.port.flags & GS_ACTIVE) {
1328                         if (sx_read_channel_byte(port, hi_state)) {
1329                                 sx_dprintk(SX_DEBUG_INTERRUPTS, "Port %d: "
1330                                                 "modem signal change?... \n",i);
1331                                 sx_check_modem_signals(port);
1332                         }
1333                         if (port->gs.xmit_cnt) {
1334                                 sx_transmit_chars(port);
1335                         }
1336                         if (!(port->gs.port.flags & SX_RX_THROTTLE)) {
1337                                 sx_receive_chars(port);
1338                         }
1339                 }
1340         }
1341
1342         clear_bit(SX_BOARD_INTR_LOCK, &board->locks);
1343
1344         sx_dprintk(SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq,
1345                         board->irq);
1346         func_exit();
1347         return IRQ_HANDLED;
1348 }
1349
1350 static void sx_pollfunc(unsigned long data)
1351 {
1352         struct sx_board *board = (struct sx_board *)data;
1353
1354         func_enter();
1355
1356         sx_interrupt(0, board);
1357
1358         mod_timer(&board->timer, jiffies + sx_poll);
1359         func_exit();
1360 }
1361
1362 /* ********************************************************************** *
1363  *                Here are the routines that actually                     *
1364  *              interface with the generic_serial driver                  *
1365  * ********************************************************************** */
1366
1367 /* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
1368 /* Hmm. Ok I figured it out. You don't.  */
1369
1370 static void sx_disable_tx_interrupts(void *ptr)
1371 {
1372         struct sx_port *port = ptr;
1373         func_enter2();
1374
1375         port->gs.port.flags &= ~GS_TX_INTEN;
1376
1377         func_exit();
1378 }
1379
1380 static void sx_enable_tx_interrupts(void *ptr)
1381 {
1382         struct sx_port *port = ptr;
1383         int data_in_buffer;
1384         func_enter2();
1385
1386         /* First transmit the characters that we're supposed to */
1387         sx_transmit_chars(port);
1388
1389         /* The sx card will never interrupt us if we don't fill the buffer
1390            past 25%. So we keep considering interrupts off if that's the case. */
1391         data_in_buffer = (sx_read_channel_byte(port, hi_txipos) -
1392                           sx_read_channel_byte(port, hi_txopos)) & 0xff;
1393
1394         /* XXX Must be "HIGH_WATER" for SI card according to doc. */
1395         if (data_in_buffer < LOW_WATER)
1396                 port->gs.port.flags &= ~GS_TX_INTEN;
1397
1398         func_exit();
1399 }
1400
1401 static void sx_disable_rx_interrupts(void *ptr)
1402 {
1403         /*  struct sx_port *port = ptr; */
1404         func_enter();
1405
1406         func_exit();
1407 }
1408
1409 static void sx_enable_rx_interrupts(void *ptr)
1410 {
1411         /*  struct sx_port *port = ptr; */
1412         func_enter();
1413
1414         func_exit();
1415 }
1416
1417 /* Jeez. Isn't this simple? */
1418 static int sx_get_CD(void *ptr)
1419 {
1420         struct sx_port *port = ptr;
1421         func_enter2();
1422
1423         func_exit();
1424         return ((sx_read_channel_byte(port, hi_ip) & IP_DCD) != 0);
1425 }
1426
1427 /* Jeez. Isn't this simple? */
1428 static int sx_chars_in_buffer(void *ptr)
1429 {
1430         struct sx_port *port = ptr;
1431         func_enter2();
1432
1433         func_exit();
1434         return ((sx_read_channel_byte(port, hi_txipos) -
1435                  sx_read_channel_byte(port, hi_txopos)) & 0xff);
1436 }
1437
1438 static void sx_shutdown_port(void *ptr)
1439 {
1440         struct sx_port *port = ptr;
1441
1442         func_enter();
1443
1444         port->gs.port.flags &= ~GS_ACTIVE;
1445         if (port->gs.port.tty && (port->gs.port.tty->termios->c_cflag & HUPCL)) {
1446                 sx_setsignals(port, 0, 0);
1447                 sx_reconfigure_port(port);
1448         }
1449
1450         func_exit();
1451 }
1452
1453 /* ********************************************************************** *
1454  *                Here are the routines that actually                     *
1455  *               interface with the rest of the system                    *
1456  * ********************************************************************** */
1457
1458 static int sx_open(struct tty_struct *tty, struct file *filp)
1459 {
1460         struct sx_port *port;
1461         int retval, line;
1462         unsigned long flags;
1463
1464         func_enter();
1465
1466         if (!sx_initialized) {
1467                 return -EIO;
1468         }
1469
1470         line = tty->index;
1471         sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
1472                         "np=%d)\n", task_pid_nr(current), line, tty,
1473                         current->signal->tty, sx_nports);
1474
1475         if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1476                 return -ENODEV;
1477
1478         port = &sx_ports[line];
1479         port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
1480                             1 -> 0 transition. */
1481
1482         sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
1483
1484         spin_lock_irqsave(&port->gs.driver_lock, flags);
1485
1486         tty->driver_data = port;
1487         port->gs.port.tty = tty;
1488         port->gs.port.count++;
1489         spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1490
1491         sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
1492
1493         /*
1494          * Start up serial port
1495          */
1496         retval = gs_init_port(&port->gs);
1497         sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
1498         if (retval) {
1499                 port->gs.port.count--;
1500                 return retval;
1501         }
1502
1503         port->gs.port.flags |= GS_ACTIVE;
1504         if (port->gs.port.count <= 1)
1505                 sx_setsignals(port, 1, 1);
1506
1507 #if 0
1508         if (sx_debug & SX_DEBUG_OPEN)
1509                 my_hd(port, sizeof(*port));
1510 #else
1511         if (sx_debug & SX_DEBUG_OPEN)
1512                 my_hd_io(port->board->base + port->ch_base, sizeof(*port));
1513 #endif
1514
1515         if (port->gs.port.count <= 1) {
1516                 if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1517                         printk(KERN_ERR "sx: Card didn't respond to LOPEN "
1518                                         "command.\n");
1519                         spin_lock_irqsave(&port->gs.driver_lock, flags);
1520                         port->gs.port.count--;
1521                         spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1522                         return -EIO;
1523                 }
1524         }
1525
1526         retval = gs_block_til_ready(port, filp);
1527         sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
1528                         retval, port->gs.port.count);
1529
1530         if (retval) {
1531 /*
1532  * Don't lower gs.port.count here because sx_close() will be called later
1533  */
1534
1535                 return retval;
1536         }
1537         /* tty->low_latency = 1; */
1538
1539         port->c_dcd = sx_get_CD(port);
1540         sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
1541
1542         func_exit();
1543         return 0;
1544
1545 }
1546
1547 static void sx_close(void *ptr)
1548 {
1549         struct sx_port *port = ptr;
1550         /* Give the port 5 seconds to close down. */
1551         int to = 5 * HZ;
1552
1553         func_enter();
1554
1555         sx_setsignals(port, 0, 0);
1556         sx_reconfigure_port(port);
1557         sx_send_command(port, HS_CLOSE, 0, 0);
1558
1559         while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
1560                 if (msleep_interruptible(10))
1561                         break;
1562         if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
1563                 if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
1564                                 != 1) {
1565                         printk(KERN_ERR "sx: sent the force_close command, but "
1566                                         "card didn't react\n");
1567                 } else
1568                         sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
1569                                         "command.\n");
1570         }
1571
1572         sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
1573                         5 * HZ - to - 1, port->gs.port.count);
1574
1575         if (port->gs.port.count) {
1576                 sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n",
1577                                 port->gs.port.count);
1578                 /*printk("%s SETTING port count to zero: %p count: %d\n",
1579                                 __func__, port, port->gs.port.count);
1580                 port->gs.port.count = 0;*/
1581         }
1582
1583         func_exit();
1584 }
1585
1586 /* This is relatively thorough. But then again it is only 20 lines. */
1587 #define MARCHUP         for (i = min; i < max; i++)
1588 #define MARCHDOWN       for (i = max - 1; i >= min; i--)
1589 #define W0              write_sx_byte(board, i, 0x55)
1590 #define W1              write_sx_byte(board, i, 0xaa)
1591 #define R0              if (read_sx_byte(board, i) != 0x55) return 1
1592 #define R1              if (read_sx_byte(board, i) != 0xaa) return 1
1593
1594 /* This memtest takes a human-noticable time. You normally only do it
1595    once a boot, so I guess that it is worth it. */
1596 static int do_memtest(struct sx_board *board, int min, int max)
1597 {
1598         int i;
1599
1600         /* This is a marchb. Theoretically, marchb catches much more than
1601            simpler tests. In practise, the longer test just catches more
1602            intermittent errors. -- REW
1603            (For the theory behind memory testing see: 
1604            Testing Semiconductor Memories by A.J. van de Goor.) */
1605         MARCHUP {
1606                 W0;
1607         }
1608         MARCHUP {
1609                 R0;
1610                 W1;
1611                 R1;
1612                 W0;
1613                 R0;
1614                 W1;
1615         }
1616         MARCHUP {
1617                 R1;
1618                 W0;
1619                 W1;
1620         }
1621         MARCHDOWN {
1622                 R1;
1623                 W0;
1624                 W1;
1625                 W0;
1626         }
1627         MARCHDOWN {
1628                 R0;
1629                 W1;
1630                 W0;
1631         }
1632
1633         return 0;
1634 }
1635
1636 #undef MARCHUP
1637 #undef MARCHDOWN
1638 #undef W0
1639 #undef W1
1640 #undef R0
1641 #undef R1
1642
1643 #define MARCHUP         for (i = min; i < max; i += 2)
1644 #define MARCHDOWN       for (i = max - 1; i >= min; i -= 2)
1645 #define W0              write_sx_word(board, i, 0x55aa)
1646 #define W1              write_sx_word(board, i, 0xaa55)
1647 #define R0              if (read_sx_word(board, i) != 0x55aa) return 1
1648 #define R1              if (read_sx_word(board, i) != 0xaa55) return 1
1649
1650 #if 0
1651 /* This memtest takes a human-noticable time. You normally only do it
1652    once a boot, so I guess that it is worth it. */
1653 static int do_memtest_w(struct sx_board *board, int min, int max)
1654 {
1655         int i;
1656
1657         MARCHUP {
1658                 W0;
1659         }
1660         MARCHUP {
1661                 R0;
1662                 W1;
1663                 R1;
1664                 W0;
1665                 R0;
1666                 W1;
1667         }
1668         MARCHUP {
1669                 R1;
1670                 W0;
1671                 W1;
1672         }
1673         MARCHDOWN {
1674                 R1;
1675                 W0;
1676                 W1;
1677                 W0;
1678         }
1679         MARCHDOWN {
1680                 R0;
1681                 W1;
1682                 W0;
1683         }
1684
1685         return 0;
1686 }
1687 #endif
1688
1689 static int sx_fw_ioctl(struct inode *inode, struct file *filp,
1690                 unsigned int cmd, unsigned long arg)
1691 {
1692         int rc = 0;
1693         int __user *descr = (int __user *)arg;
1694         int i;
1695         static struct sx_board *board = NULL;
1696         int nbytes, offset;
1697         unsigned long data;
1698         char *tmp;
1699
1700         func_enter();
1701
1702 #if 0
1703         /* Removed superuser check: Sysops can use the permissions on the device
1704            file to restrict access. Recommendation: Root only. (root.root 600) */
1705         if (!capable(CAP_SYS_ADMIN)) {
1706                 return -EPERM;
1707         }
1708 #endif
1709
1710         sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
1711
1712         if (!board)
1713                 board = &boards[0];
1714         if (board->flags & SX_BOARD_PRESENT) {
1715                 sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1716                                 board->flags);
1717         } else {
1718                 sx_dprintk(SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
1719                                 board->flags);
1720                 for (i = 0; i < SX_NBOARDS; i++)
1721                         sx_dprintk(SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
1722                 sx_dprintk(SX_DEBUG_FIRMWARE, "\n");
1723                 return -EIO;
1724         }
1725
1726         switch (cmd) {
1727         case SXIO_SET_BOARD:
1728                 sx_dprintk(SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
1729                 if (arg >= SX_NBOARDS)
1730                         return -EIO;
1731                 sx_dprintk(SX_DEBUG_FIRMWARE, "not out of range\n");
1732                 if (!(boards[arg].flags & SX_BOARD_PRESENT))
1733                         return -EIO;
1734                 sx_dprintk(SX_DEBUG_FIRMWARE, ".. and present!\n");
1735                 board = &boards[arg];
1736                 break;
1737         case SXIO_GET_TYPE:
1738                 rc = -ENOENT;   /* If we manage to miss one, return error. */
1739                 if (IS_SX_BOARD(board))
1740                         rc = SX_TYPE_SX;
1741                 if (IS_CF_BOARD(board))
1742                         rc = SX_TYPE_CF;
1743                 if (IS_SI_BOARD(board))
1744                         rc = SX_TYPE_SI;
1745                 if (IS_SI1_BOARD(board))
1746                         rc = SX_TYPE_SI;
1747                 if (IS_EISA_BOARD(board))
1748                         rc = SX_TYPE_SI;
1749                 sx_dprintk(SX_DEBUG_FIRMWARE, "returning type= %d\n", rc);
1750                 break;
1751         case SXIO_DO_RAMTEST:
1752                 if (sx_initialized)     /* Already initialized: better not ramtest the board.  */
1753                         return -EPERM;
1754                 if (IS_SX_BOARD(board)) {
1755                         rc = do_memtest(board, 0, 0x7000);
1756                         if (!rc)
1757                                 rc = do_memtest(board, 0, 0x7000);
1758                         /*if (!rc) rc = do_memtest_w (board, 0, 0x7000); */
1759                 } else {
1760                         rc = do_memtest(board, 0, 0x7ff8);
1761                         /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
1762                 }
1763                 sx_dprintk(SX_DEBUG_FIRMWARE, "returning memtest result= %d\n",
1764                            rc);
1765                 break;
1766         case SXIO_DOWNLOAD:
1767                 if (sx_initialized)     /* Already initialized */
1768                         return -EEXIST;
1769                 if (!sx_reset(board))
1770                         return -EIO;
1771                 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
1772
1773                 tmp = kmalloc(SX_CHUNK_SIZE, GFP_USER);
1774                 if (!tmp)
1775                         return -ENOMEM;
1776                 get_user(nbytes, descr++);
1777                 get_user(offset, descr++);
1778                 get_user(data, descr++);
1779                 while (nbytes && data) {
1780                         for (i = 0; i < nbytes; i += SX_CHUNK_SIZE) {
1781                                 if (copy_from_user(tmp, (char __user *)data + i,
1782                                                 (i + SX_CHUNK_SIZE > nbytes) ?
1783                                                 nbytes - i : SX_CHUNK_SIZE)) {
1784                                         kfree(tmp);
1785                                         return -EFAULT;
1786                                 }
1787                                 memcpy_toio(board->base2 + offset + i, tmp,
1788                                                 (i + SX_CHUNK_SIZE > nbytes) ?
1789                                                 nbytes - i : SX_CHUNK_SIZE);
1790                         }
1791
1792                         get_user(nbytes, descr++);
1793                         get_user(offset, descr++);
1794                         get_user(data, descr++);
1795                 }
1796                 kfree(tmp);
1797                 sx_nports += sx_init_board(board);
1798                 rc = sx_nports;
1799                 break;
1800         case SXIO_INIT:
1801                 if (sx_initialized)     /* Already initialized */
1802                         return -EEXIST;
1803                 /* This is not allowed until all boards are initialized... */
1804                 for (i = 0; i < SX_NBOARDS; i++) {
1805                         if ((boards[i].flags & SX_BOARD_PRESENT) &&
1806                                 !(boards[i].flags & SX_BOARD_INITIALIZED))
1807                                 return -EIO;
1808                 }
1809                 for (i = 0; i < SX_NBOARDS; i++)
1810                         if (!(boards[i].flags & SX_BOARD_PRESENT))
1811                                 break;
1812
1813                 sx_dprintk(SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
1814                                 "%d channels, first board: %d ports\n",
1815                                 i, sx_nports, boards[0].nports);
1816                 rc = sx_init_portstructs(i, sx_nports);
1817                 sx_init_drivers();
1818                 if (rc >= 0)
1819                         sx_initialized++;
1820                 break;
1821         case SXIO_SETDEBUG:
1822                 sx_debug = arg;
1823                 break;
1824         case SXIO_GETDEBUG:
1825                 rc = sx_debug;
1826                 break;
1827         case SXIO_GETGSDEBUG:
1828         case SXIO_SETGSDEBUG:
1829                 rc = -EINVAL;
1830                 break;
1831         case SXIO_GETNPORTS:
1832                 rc = sx_nports;
1833                 break;
1834         default:
1835                 printk(KERN_WARNING "Unknown ioctl on firmware device (%x).\n",
1836                                 cmd);
1837                 break;
1838         }
1839         func_exit();
1840         return rc;
1841 }
1842
1843 static int sx_break(struct tty_struct *tty, int flag)
1844 {
1845         struct sx_port *port = tty->driver_data;
1846         int rv;
1847
1848         func_enter();
1849         lock_kernel();
1850
1851         if (flag)
1852                 rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
1853         else
1854                 rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
1855         if (rv != 1)
1856                 printk(KERN_ERR "sx: couldn't send break (%x).\n",
1857                         read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
1858         unlock_kernel();
1859         func_exit();
1860         return 0;
1861 }
1862
1863 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1864 {
1865         struct sx_port *port = tty->driver_data;
1866         return sx_getsignals(port);
1867 }
1868
1869 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1870                 unsigned int set, unsigned int clear)
1871 {
1872         struct sx_port *port = tty->driver_data;
1873         int rts = -1, dtr = -1;
1874
1875         if (set & TIOCM_RTS)
1876                 rts = 1;
1877         if (set & TIOCM_DTR)
1878                 dtr = 1;
1879         if (clear & TIOCM_RTS)
1880                 rts = 0;
1881         if (clear & TIOCM_DTR)
1882                 dtr = 0;
1883
1884         sx_setsignals(port, dtr, rts);
1885         sx_reconfigure_port(port);
1886         return 0;
1887 }
1888
1889 static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1890                 unsigned int cmd, unsigned long arg)
1891 {
1892         int rc;
1893         struct sx_port *port = tty->driver_data;
1894         void __user *argp = (void __user *)arg;
1895
1896         /* func_enter2(); */
1897
1898         rc = 0;
1899         lock_kernel();
1900         switch (cmd) {
1901         case TIOCGSERIAL:
1902                 rc = gs_getserial(&port->gs, argp);
1903                 break;
1904         case TIOCSSERIAL:
1905                 rc = gs_setserial(&port->gs, argp);
1906                 break;
1907         default:
1908                 rc = -ENOIOCTLCMD;
1909                 break;
1910         }
1911         unlock_kernel();
1912
1913         /* func_exit(); */
1914         return rc;
1915 }
1916
1917 /* The throttle/unthrottle scheme for the Specialix card is different
1918  * from other drivers and deserves some explanation. 
1919  * The Specialix hardware takes care of XON/XOFF
1920  * and CTS/RTS flow control itself.  This means that all we have to
1921  * do when signalled by the upper tty layer to throttle/unthrottle is
1922  * to make a note of it here.  When we come to read characters from the
1923  * rx buffers on the card (sx_receive_chars()) we look to see if the
1924  * upper layer can accept more (as noted here in sx_rx_throt[]). 
1925  * If it can't we simply don't remove chars from the cards buffer. 
1926  * When the tty layer can accept chars, we again note that here and when
1927  * sx_receive_chars() is called it will remove them from the cards buffer.
1928  * The card will notice that a ports buffer has drained below some low
1929  * water mark and will unflow control the line itself, using whatever
1930  * flow control scheme is in use for that port. -- Simon Allen
1931  */
1932
1933 static void sx_throttle(struct tty_struct *tty)
1934 {
1935         struct sx_port *port = (struct sx_port *)tty->driver_data;
1936
1937         func_enter2();
1938         /* If the port is using any type of input flow
1939          * control then throttle the port.
1940          */
1941         if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
1942                 port->gs.port.flags |= SX_RX_THROTTLE;
1943         }
1944         func_exit();
1945 }
1946
1947 static void sx_unthrottle(struct tty_struct *tty)
1948 {
1949         struct sx_port *port = (struct sx_port *)tty->driver_data;
1950
1951         func_enter2();
1952         /* Always unthrottle even if flow control is not enabled on
1953          * this port in case we disabled flow control while the port
1954          * was throttled
1955          */
1956         port->gs.port.flags &= ~SX_RX_THROTTLE;
1957         func_exit();
1958         return;
1959 }
1960
1961 /* ********************************************************************** *
1962  *                    Here are the initialization routines.               *
1963  * ********************************************************************** */
1964
1965 static int sx_init_board(struct sx_board *board)
1966 {
1967         int addr;
1968         int chans;
1969         int type;
1970
1971         func_enter();
1972
1973         /* This is preceded by downloading the download code. */
1974
1975         board->flags |= SX_BOARD_INITIALIZED;
1976
1977         if (read_sx_byte(board, 0))
1978                 /* CF boards may need this. */
1979                 write_sx_byte(board, 0, 0);
1980
1981         /* This resets the processor again, to make sure it didn't do any
1982            foolish things while we were downloading the image */
1983         if (!sx_reset(board))
1984                 return 0;
1985
1986         sx_start_board(board);
1987         udelay(10);
1988         if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
1989                 printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
1990                 return 0;
1991         }
1992
1993         /* Ok. So now the processor on the card is running. It gathered
1994            some info for us... */
1995         sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
1996         if (sx_debug & SX_DEBUG_INIT)
1997                 my_hd_io(board->base, 0x10);
1998         sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
1999         if (sx_debug & SX_DEBUG_INIT)
2000                 my_hd_io(board->base + 0x80, 0x30);
2001
2002         sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
2003                         "V%x.%02x,\n",
2004                         read_sx_byte(board, 0), read_sx_byte(board, 1),
2005                         read_sx_byte(board, 5), read_sx_byte(board, 4));
2006
2007         if (read_sx_byte(board, 0) == 0xff) {
2008                 printk(KERN_INFO "sx: No modules found. Sorry.\n");
2009                 board->nports = 0;
2010                 return 0;
2011         }
2012
2013         chans = 0;
2014
2015         if (IS_SX_BOARD(board)) {
2016                 sx_write_board_word(board, cc_int_count, sx_maxints);
2017         } else {
2018                 if (sx_maxints)
2019                         sx_write_board_word(board, cc_int_count,
2020                                         SI_PROCESSOR_CLOCK / 8 / sx_maxints);
2021         }
2022
2023         /* grab the first module type... */
2024         /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
2025         board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
2026                                 mc_chip));
2027
2028         /* XXX byteorder */
2029         for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
2030                 type = sx_read_module_byte(board, addr, mc_chip);
2031                 sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
2032                                 addr, read_sx_byte(board, addr + 2));
2033
2034                 chans += sx_read_module_byte(board, addr, mc_type);
2035
2036                 sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
2037                                 "panels\n",
2038                                 mod_type_s(type),
2039                                 pan_type_s(sx_read_module_byte(board, addr,
2040                                                 mc_mods) & 0xf),
2041                                 pan_type_s(sx_read_module_byte(board, addr,
2042                                                 mc_mods) >> 4));
2043
2044                 sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
2045                         "version: %x\n",
2046                         sx_read_module_byte(board, addr, mc_rev1),
2047                         sx_read_module_byte(board, addr, mc_rev2),
2048                         sx_read_module_byte(board, addr, mc_mtaasic_rev));
2049
2050                 /* The following combinations are illegal: It should theoretically
2051                    work, but timing problems make the bus HANG. */
2052
2053                 if (mod_compat_type(type) != board->ta_type) {
2054                         printk(KERN_ERR "sx: This is an invalid "
2055                                 "configuration.\nDon't mix TA/MTA/SXDC on the "
2056                                 "same hostadapter.\n");
2057                         chans = 0;
2058                         break;
2059                 }
2060                 if ((IS_EISA_BOARD(board) ||
2061                                 IS_SI_BOARD(board)) &&
2062                                 (mod_compat_type(type) == 4)) {
2063                         printk(KERN_ERR "sx: This is an invalid "
2064                                 "configuration.\nDon't use SXDCs on an SI/XIO "
2065                                 "adapter.\n");
2066                         chans = 0;
2067                         break;
2068                 }
2069 #if 0                           /* Problem fixed: firmware 3.05 */
2070                 if (IS_SX_BOARD(board) && (type == TA8)) {
2071                         /* There are some issues with the firmware and the DCD/RTS
2072                            lines. It might work if you tie them together or something.
2073                            It might also work if you get a newer sx_firmware.   Therefore
2074                            this is just a warning. */
2075                         printk(KERN_WARNING
2076                                "sx: The SX host doesn't work too well "
2077                                "with the TA8 adapters.\nSpecialix is working on it.\n");
2078                 }
2079 #endif
2080         }
2081
2082         if (chans) {
2083                 if (board->irq > 0) {
2084                         /* fixed irq, probably PCI */
2085                         if (sx_irqmask & (1 << board->irq)) {   /* may we use this irq? */
2086                                 if (request_irq(board->irq, sx_interrupt,
2087                                                 IRQF_SHARED | IRQF_DISABLED,
2088                                                 "sx", board)) {
2089                                         printk(KERN_ERR "sx: Cannot allocate "
2090                                                 "irq %d.\n", board->irq);
2091                                         board->irq = 0;
2092                                 }
2093                         } else
2094                                 board->irq = 0;
2095                 } else if (board->irq < 0 && sx_irqmask) {
2096                         /* auto-allocate irq */
2097                         int irqnr;
2098                         int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
2099                                         SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
2100                         for (irqnr = 15; irqnr > 0; irqnr--)
2101                                 if (irqmask & (1 << irqnr))
2102                                         if (!request_irq(irqnr, sx_interrupt,
2103                                                 IRQF_SHARED | IRQF_DISABLED,
2104                                                 "sx", board))
2105                                                 break;
2106                         if (!irqnr)
2107                                 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2108                         board->irq = irqnr;
2109                 } else
2110                         board->irq = 0;
2111
2112                 if (board->irq) {
2113                         /* Found a valid interrupt, start up interrupts! */
2114                         sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
2115                                         board->irq);
2116                         sx_start_interrupts(board);
2117                         board->poll = sx_slowpoll;
2118                         board->flags |= SX_IRQ_ALLOCATED;
2119                 } else {
2120                         /* no irq: setup board for polled operation */
2121                         board->poll = sx_poll;
2122                         sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
2123                                         board->poll);
2124                 }
2125
2126                 /* The timer should be initialized anyway: That way we can
2127                    safely del_timer it when the module is unloaded. */
2128                 setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
2129
2130                 if (board->poll)
2131                         mod_timer(&board->timer, jiffies + board->poll);
2132         } else {
2133                 board->irq = 0;
2134         }
2135
2136         board->nports = chans;
2137         sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
2138
2139         func_exit();
2140         return chans;
2141 }
2142
2143 static void __devinit printheader(void)
2144 {
2145         static int header_printed;
2146
2147         if (!header_printed) {
2148                 printk(KERN_INFO "Specialix SX driver "
2149                         "(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
2150                 printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
2151                 header_printed = 1;
2152         }
2153 }
2154
2155 static int __devinit probe_sx(struct sx_board *board)
2156 {
2157         struct vpd_prom vpdp;
2158         char *p;
2159         int i;
2160
2161         func_enter();
2162
2163         if (!IS_CF_BOARD(board)) {
2164                 sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2165                                 board->base + SX_VPD_ROM);
2166
2167                 if (sx_debug & SX_DEBUG_PROBE)
2168                         my_hd_io(board->base + SX_VPD_ROM, 0x40);
2169
2170                 p = (char *)&vpdp;
2171                 for (i = 0; i < sizeof(struct vpd_prom); i++)
2172                         *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
2173
2174                 if (sx_debug & SX_DEBUG_PROBE)
2175                         my_hd(&vpdp, 0x20);
2176
2177                 sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
2178
2179                 if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2180                         sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
2181                                         "'%s'\n", vpdp.identifier);
2182                         return 0;
2183                 }
2184         }
2185
2186         printheader();
2187
2188         if (!IS_CF_BOARD(board)) {
2189                 printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
2190                         board->hw_base);
2191                 printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
2192                                 "uniq ID:%08x, ",
2193                                 vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2194                 printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
2195
2196                 if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
2197                                 SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
2198                                 SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2199                         /* This might be a bit harsh. This was the primary
2200                            reason the SX/ISA card didn't work at first... */
2201                         printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
2202                                         "card. Sorry: giving up.\n");
2203                         return (0);
2204                 }
2205
2206                 if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
2207                                 SX_ISA_UNIQUEID1) {
2208                         if (((unsigned long)board->hw_base) & 0x8000) {
2209                                 printk(KERN_WARNING "sx: Warning: There may be "
2210                                         "hardware problems with the card at "
2211                                         "%lx.\n", board->hw_base);
2212                                 printk(KERN_WARNING "sx: Read sx.txt for more "
2213                                                 "info.\n");
2214                         }
2215                 }
2216         }
2217
2218         board->nports = -1;
2219
2220         /* This resets the processor, and keeps it off the bus. */
2221         if (!sx_reset(board))
2222                 return 0;
2223         sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2224
2225         func_exit();
2226         return 1;
2227 }
2228
2229 #if defined(CONFIG_ISA) || defined(CONFIG_EISA)
2230
2231 /* Specialix probes for this card at 32k increments from 640k to 16M.
2232    I consider machines with less than 16M unlikely nowadays, so I'm
2233    not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2234    card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves 
2235    0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2236
2237 static int __devinit probe_si(struct sx_board *board)
2238 {
2239         int i;
2240
2241         func_enter();
2242         sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
2243                 "%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
2244
2245         if (sx_debug & SX_DEBUG_PROBE)
2246                 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2247
2248         if (!IS_EISA_BOARD(board)) {
2249                 if (IS_SI1_BOARD(board)) {
2250                         for (i = 0; i < 8; i++) {
2251                                 write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
2252                         }
2253                 }
2254                 for (i = 0; i < 8; i++) {
2255                         if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
2256                                         != i) {
2257                                 func_exit();
2258                                 return 0;
2259                         }
2260                 }
2261         }
2262
2263         /* Now we're pretty much convinced that there is an SI board here, 
2264            but to prevent trouble, we'd better double check that we don't
2265            have an SI1 board when we're probing for an SI2 board.... */
2266
2267         write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2268         if (IS_SI1_BOARD(board)) {
2269                 /* This should be an SI1 board, which has this
2270                    location writable... */
2271                 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2272                         func_exit();
2273                         return 0;
2274                 }
2275         } else {
2276                 /* This should be an SI2 board, which has the bottom
2277                    3 bits non-writable... */
2278                 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2279                         func_exit();
2280                         return 0;
2281                 }
2282         }
2283
2284         /* Now we're pretty much convinced that there is an SI board here, 
2285            but to prevent trouble, we'd better double check that we don't
2286            have an SI1 board when we're probing for an SI2 board.... */
2287
2288         write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2289         if (IS_SI1_BOARD(board)) {
2290                 /* This should be an SI1 board, which has this
2291                    location writable... */
2292                 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2293                         func_exit();
2294                         return 0;
2295                 }
2296         } else {
2297                 /* This should be an SI2 board, which has the bottom
2298                    3 bits non-writable... */
2299                 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2300                         func_exit();
2301                         return 0;
2302                 }
2303         }
2304
2305         printheader();
2306
2307         printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
2308         /* Compared to the SX boards, it is a complete guess as to what
2309            this card is up to... */
2310
2311         board->nports = -1;
2312
2313         /* This resets the processor, and keeps it off the bus. */
2314         if (!sx_reset(board))
2315                 return 0;
2316         sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2317
2318         func_exit();
2319         return 1;
2320 }
2321 #endif
2322
2323 static const struct tty_operations sx_ops = {
2324         .break_ctl = sx_break,
2325         .open = sx_open,
2326         .close = gs_close,
2327         .write = gs_write,
2328         .put_char = gs_put_char,
2329         .flush_chars = gs_flush_chars,
2330         .write_room = gs_write_room,
2331         .chars_in_buffer = gs_chars_in_buffer,
2332         .flush_buffer = gs_flush_buffer,
2333         .ioctl = sx_ioctl,
2334         .throttle = sx_throttle,
2335         .unthrottle = sx_unthrottle,
2336         .set_termios = gs_set_termios,
2337         .stop = gs_stop,
2338         .start = gs_start,
2339         .hangup = gs_hangup,
2340         .tiocmget = sx_tiocmget,
2341         .tiocmset = sx_tiocmset,
2342 };
2343
2344 static int sx_init_drivers(void)
2345 {
2346         int error;
2347
2348         func_enter();
2349
2350         sx_driver = alloc_tty_driver(sx_nports);
2351         if (!sx_driver)
2352                 return 1;
2353         sx_driver->owner = THIS_MODULE;
2354         sx_driver->driver_name = "specialix_sx";
2355         sx_driver->name = "ttyX";
2356         sx_driver->major = SX_NORMAL_MAJOR;
2357         sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2358         sx_driver->subtype = SERIAL_TYPE_NORMAL;
2359         sx_driver->init_termios = tty_std_termios;
2360         sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2361         sx_driver->init_termios.c_ispeed = 9600;
2362         sx_driver->init_termios.c_ospeed = 9600;
2363         sx_driver->flags = TTY_DRIVER_REAL_RAW;
2364         tty_set_operations(sx_driver, &sx_ops);
2365
2366         if ((error = tty_register_driver(sx_driver))) {
2367                 put_tty_driver(sx_driver);
2368                 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
2369                         error);
2370                 return 1;
2371         }
2372         func_exit();
2373         return 0;
2374 }
2375
2376 static int sx_init_portstructs(int nboards, int nports)
2377 {
2378         struct sx_board *board;
2379         struct sx_port *port;
2380         int i, j;
2381         int addr, chans;
2382         int portno;
2383
2384         func_enter();
2385
2386         /* Many drivers statically allocate the maximum number of ports
2387            There is no reason not to allocate them dynamically.
2388            Is there? -- REW */
2389         sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
2390         if (!sx_ports)
2391                 return -ENOMEM;
2392
2393         port = sx_ports;
2394         for (i = 0; i < nboards; i++) {
2395                 board = &boards[i];
2396                 board->ports = port;
2397                 for (j = 0; j < boards[i].nports; j++) {
2398                         sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
2399                         tty_port_init(&port->gs.port);
2400                         port->gs.magic = SX_MAGIC;
2401                         port->gs.close_delay = HZ / 2;
2402                         port->gs.closing_wait = 30 * HZ;
2403                         port->board = board;
2404                         port->gs.rd = &sx_real_driver;
2405 #ifdef NEW_WRITE_LOCKING
2406                         port->gs.port_write_mutex = MUTEX;
2407 #endif
2408                         spin_lock_init(&port->gs.driver_lock);
2409                         /*
2410                          * Initializing wait queue
2411                          */
2412                         port++;
2413                 }
2414         }
2415
2416         port = sx_ports;
2417         portno = 0;
2418         for (i = 0; i < nboards; i++) {
2419                 board = &boards[i];
2420                 board->port_base = portno;
2421                 /* Possibly the configuration was rejected. */
2422                 sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
2423                                 board->nports);
2424                 if (board->nports <= 0)
2425                         continue;
2426                 /* XXX byteorder ?? */
2427                 for (addr = 0x80; addr != 0;
2428                                 addr = read_sx_word(board, addr) & 0x7fff) {
2429                         chans = sx_read_module_byte(board, addr, mc_type);
2430                         sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
2431                                         "channels\n", addr, chans);
2432                         sx_dprintk(SX_DEBUG_PROBE, "Port at");
2433                         for (j = 0; j < chans; j++) {
2434                                 /* The "sx-way" is the way it SHOULD be done.
2435                                    That way in the future, the firmware may for
2436                                    example pack the structures a bit more
2437                                    efficient. Neil tells me it isn't going to
2438                                    happen anytime soon though. */
2439                                 if (IS_SX_BOARD(board))
2440                                         port->ch_base = sx_read_module_word(
2441                                                         board, addr + j * 2,
2442                                                         mc_chan_pointer);
2443                                 else
2444                                         port->ch_base = addr + 0x100 + 0x300 *j;
2445
2446                                 sx_dprintk(SX_DEBUG_PROBE, " %x",
2447                                                 port->ch_base);
2448                                 port->line = portno++;
2449                                 port++;
2450                         }
2451                         sx_dprintk(SX_DEBUG_PROBE, "\n");
2452                 }
2453                 /* This has to be done earlier. */
2454                 /* board->flags |= SX_BOARD_INITIALIZED; */
2455         }
2456
2457         func_exit();
2458         return 0;
2459 }
2460
2461 static unsigned int sx_find_free_board(void)
2462 {
2463         unsigned int i;
2464
2465         for (i = 0; i < SX_NBOARDS; i++)
2466                 if (!(boards[i].flags & SX_BOARD_PRESENT))
2467                         break;
2468
2469         return i;
2470 }
2471
2472 static void __exit sx_release_drivers(void)
2473 {
2474         func_enter();
2475         tty_unregister_driver(sx_driver);
2476         put_tty_driver(sx_driver);
2477         func_exit();
2478 }
2479
2480 static void __devexit sx_remove_card(struct sx_board *board,
2481                 struct pci_dev *pdev)
2482 {
2483         if (board->flags & SX_BOARD_INITIALIZED) {
2484                 /* The board should stop messing with us. (actually I mean the
2485                    interrupt) */
2486                 sx_reset(board);
2487                 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2488                         free_irq(board->irq, board);
2489
2490                 /* It is safe/allowed to del_timer a non-active timer */
2491                 del_timer(&board->timer);
2492                 if (pdev) {
2493 #ifdef CONFIG_PCI
2494                         pci_iounmap(pdev, board->base);
2495                         pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
2496 #endif
2497                 } else {
2498                         iounmap(board->base);
2499                         release_region(board->hw_base, board->hw_len);
2500                 }
2501
2502                 board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
2503         }
2504 }
2505
2506 #ifdef CONFIG_EISA
2507
2508 static int __devinit sx_eisa_probe(struct device *dev)
2509 {
2510         struct eisa_device *edev = to_eisa_device(dev);
2511         struct sx_board *board;
2512         unsigned long eisa_slot = edev->base_addr;
2513         unsigned int i;
2514         int retval = -EIO;
2515
2516         mutex_lock(&sx_boards_lock);
2517         i = sx_find_free_board();
2518         if (i == SX_NBOARDS) {
2519                 mutex_unlock(&sx_boards_lock);
2520                 goto err;
2521         }
2522         board = &boards[i];
2523         board->flags |= SX_BOARD_PRESENT;
2524         mutex_unlock(&sx_boards_lock);
2525
2526         dev_info(dev, "XIO : Signature found in EISA slot %lu, "
2527                  "Product %d Rev %d (REPORT THIS TO LKLM)\n",
2528                  eisa_slot >> 12,
2529                  inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
2530                  inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
2531
2532         board->eisa_base = eisa_slot;
2533         board->flags &= ~SX_BOARD_TYPE;
2534         board->flags |= SI_EISA_BOARD;
2535
2536         board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
2537                           inb(eisa_slot + 0xc00)) << 16;
2538         board->hw_len = SI2_EISA_WINDOW_LEN;
2539         if (!request_region(board->hw_base, board->hw_len, "sx")) {
2540                 dev_err(dev, "can't request region\n");
2541                 goto err_flag;
2542         }
2543         board->base2 =
2544         board->base = ioremap_nocache(board->hw_base, SI2_EISA_WINDOW_LEN);
2545         if (!board->base) {
2546                 dev_err(dev, "can't remap memory\n");
2547                 goto err_reg;
2548         }
2549
2550         sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2551         sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2552         board->irq = inb(eisa_slot + 0xc02) >> 4;
2553         sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2554
2555         if (!probe_si(board))
2556                 goto err_unmap;
2557
2558         dev_set_drvdata(dev, board);
2559
2560         return 0;
2561 err_unmap:
2562         iounmap(board->base);
2563 err_reg:
2564         release_region(board->hw_base, board->hw_len);
2565 err_flag:
2566         board->flags &= ~SX_BOARD_PRESENT;
2567 err:
2568         return retval;
2569 }
2570
2571 static int __devexit sx_eisa_remove(struct device *dev)
2572 {
2573         struct sx_board *board = dev_get_drvdata(dev);
2574
2575         sx_remove_card(board, NULL);
2576
2577         return 0;
2578 }
2579
2580 static struct eisa_device_id sx_eisa_tbl[] = {
2581         { "SLX" },
2582         { "" }
2583 };
2584
2585 MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2586
2587 static struct eisa_driver sx_eisadriver = {
2588         .id_table = sx_eisa_tbl,
2589         .driver = {
2590                 .name = "sx",
2591                 .probe = sx_eisa_probe,
2592                 .remove = __devexit_p(sx_eisa_remove),
2593         }
2594 };
2595
2596 #endif
2597
2598 #ifdef CONFIG_PCI
2599  /******************************************************** 
2600  * Setting bit 17 in the CNTRL register of the PLX 9050  * 
2601  * chip forces a retry on writes while a read is pending.*
2602  * This is to prevent the card locking up on Intel Xeon  *
2603  * multiprocessor systems with the NX chipset.    -- NV  *
2604  ********************************************************/
2605
2606 /* Newer cards are produced with this bit set from the configuration
2607    EEprom.  As the bit is read/write for the CPU, we can fix it here,
2608    if we detect that it isn't set correctly. -- REW */
2609
2610 static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
2611 {
2612         unsigned int hwbase;
2613         void __iomem *rebase;
2614         unsigned int t;
2615
2616 #define CNTRL_REG_OFFSET        0x50
2617 #define CNTRL_REG_GOODVALUE     0x18260000
2618
2619         pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2620         hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2621         rebase = ioremap_nocache(hwbase, 0x80);
2622         t = readl(rebase + CNTRL_REG_OFFSET);
2623         if (t != CNTRL_REG_GOODVALUE) {
2624                 printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
2625                         "%08x\n", t, CNTRL_REG_GOODVALUE);
2626                 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
2627         }
2628         iounmap(rebase);
2629 }
2630 #endif
2631
2632 static int __devinit sx_pci_probe(struct pci_dev *pdev,
2633                                   const struct pci_device_id *ent)
2634 {
2635 #ifdef CONFIG_PCI
2636         struct sx_board *board;
2637         unsigned int i, reg;
2638         int retval = -EIO;
2639
2640         mutex_lock(&sx_boards_lock);
2641         i = sx_find_free_board();
2642         if (i == SX_NBOARDS) {
2643                 mutex_unlock(&sx_boards_lock);
2644                 goto err;
2645         }
2646         board = &boards[i];
2647         board->flags |= SX_BOARD_PRESENT;
2648         mutex_unlock(&sx_boards_lock);
2649
2650         retval = pci_enable_device(pdev);
2651         if (retval)
2652                 goto err_flag;
2653
2654         board->flags &= ~SX_BOARD_TYPE;
2655         board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
2656                 SX_CFPCI_BOARD;
2657
2658         /* CF boards use base address 3.... */
2659         reg = IS_CF_BOARD(board) ? 3 : 2;
2660         retval = pci_request_region(pdev, reg, "sx");
2661         if (retval) {
2662                 dev_err(&pdev->dev, "can't request region\n");
2663                 goto err_flag;
2664         }
2665         board->hw_base = pci_resource_start(pdev, reg);
2666         board->base2 =
2667         board->base = pci_iomap(pdev, reg, WINDOW_LEN(board));
2668         if (!board->base) {
2669                 dev_err(&pdev->dev, "ioremap failed\n");
2670                 goto err_reg;
2671         }
2672
2673         /* Most of the stuff on the CF board is offset by 0x18000 ....  */
2674         if (IS_CF_BOARD(board))
2675                 board->base += 0x18000;
2676
2677         board->irq = pdev->irq;
2678
2679         dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
2680                  board->irq, board->flags);
2681
2682         if (!probe_sx(board)) {
2683                 retval = -EIO;
2684                 goto err_unmap;
2685         }
2686
2687         fix_sx_pci(pdev, board);
2688
2689         pci_set_drvdata(pdev, board);
2690
2691         return 0;
2692 err_unmap:
2693         pci_iounmap(pdev, board->base);
2694 err_reg:
2695         pci_release_region(pdev, reg);
2696 err_flag:
2697         board->flags &= ~SX_BOARD_PRESENT;
2698 err:
2699         return retval;
2700 #else
2701         return -ENODEV;
2702 #endif
2703 }
2704
2705 static void __devexit sx_pci_remove(struct pci_dev *pdev)
2706 {
2707         struct sx_board *board = pci_get_drvdata(pdev);
2708
2709         sx_remove_card(board, pdev);
2710 }
2711
2712 /* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
2713    its because the standard requires it. So check for SUBVENDOR_ID. */
2714 static struct pci_device_id sx_pci_tbl[] = {
2715         { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2716                 .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
2717         { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2718                 .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
2719         { 0 }
2720 };
2721
2722 MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2723
2724 static struct pci_driver sx_pcidriver = {
2725         .name = "sx",
2726         .id_table = sx_pci_tbl,
2727         .probe = sx_pci_probe,
2728         .remove = __devexit_p(sx_pci_remove)
2729 };
2730
2731 static int __init sx_init(void)
2732 {
2733 #ifdef CONFIG_EISA
2734         int retval1;
2735 #endif
2736 #ifdef CONFIG_ISA
2737         struct sx_board *board;
2738         unsigned int i;
2739 #endif
2740         unsigned int found = 0;
2741         int retval;
2742
2743         func_enter();
2744         sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
2745                         sx_debug);
2746         if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
2747                 printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
2748                                 "value. Assuming -1.\n(%p)\n", &sx_debug);
2749                 sx_debug = -1;
2750         }
2751
2752         if (misc_register(&sx_fw_device) < 0) {
2753                 printk(KERN_ERR "SX: Unable to register firmware loader "
2754                                 "driver.\n");
2755                 return -EIO;
2756         }
2757 #ifdef CONFIG_ISA
2758         for (i = 0; i < NR_SX_ADDRS; i++) {
2759                 board = &boards[found];
2760                 board->hw_base = sx_probe_addrs[i];
2761                 board->hw_len = SX_WINDOW_LEN;
2762                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2763                         continue;
2764                 board->base2 =
2765                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2766                 if (!board->base)
2767                         goto err_sx_reg;
2768                 board->flags &= ~SX_BOARD_TYPE;
2769                 board->flags |= SX_ISA_BOARD;
2770                 board->irq = sx_irqmask ? -1 : 0;
2771
2772                 if (probe_sx(board)) {
2773                         board->flags |= SX_BOARD_PRESENT;
2774                         found++;
2775                 } else {
2776                         iounmap(board->base);
2777 err_sx_reg:
2778                         release_region(board->hw_base, board->hw_len);
2779                 }
2780         }
2781
2782         for (i = 0; i < NR_SI_ADDRS; i++) {
2783                 board = &boards[found];
2784                 board->hw_base = si_probe_addrs[i];
2785                 board->hw_len = SI2_ISA_WINDOW_LEN;
2786                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2787                         continue;
2788                 board->base2 =
2789                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2790                 if (!board->base)
2791                         goto err_si_reg;
2792                 board->flags &= ~SX_BOARD_TYPE;
2793                 board->flags |= SI_ISA_BOARD;
2794                 board->irq = sx_irqmask ? -1 : 0;
2795
2796                 if (probe_si(board)) {
2797                         board->flags |= SX_BOARD_PRESENT;
2798                         found++;
2799                 } else {
2800                         iounmap(board->base);
2801 err_si_reg:
2802                         release_region(board->hw_base, board->hw_len);
2803                 }
2804         }
2805         for (i = 0; i < NR_SI1_ADDRS; i++) {
2806                 board = &boards[found];
2807                 board->hw_base = si1_probe_addrs[i];
2808                 board->hw_len = SI1_ISA_WINDOW_LEN;
2809                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2810                         continue;
2811                 board->base2 =
2812                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2813                 if (!board->base)
2814                         goto err_si1_reg;
2815                 board->flags &= ~SX_BOARD_TYPE;
2816                 board->flags |= SI1_ISA_BOARD;
2817                 board->irq = sx_irqmask ? -1 : 0;
2818
2819                 if (probe_si(board)) {
2820                         board->flags |= SX_BOARD_PRESENT;
2821                         found++;
2822                 } else {
2823                         iounmap(board->base);
2824 err_si1_reg:
2825                         release_region(board->hw_base, board->hw_len);
2826                 }
2827         }
2828 #endif
2829 #ifdef CONFIG_EISA
2830         retval1 = eisa_driver_register(&sx_eisadriver);
2831 #endif
2832         retval = pci_register_driver(&sx_pcidriver);
2833
2834         if (found) {
2835                 printk(KERN_INFO "sx: total of %d boards detected.\n", found);
2836                 retval = 0;
2837         } else if (retval) {
2838 #ifdef CONFIG_EISA
2839                 retval = retval1;
2840                 if (retval1)
2841 #endif
2842                         misc_deregister(&sx_fw_device);
2843         }
2844
2845         func_exit();
2846         return retval;
2847 }
2848
2849 static void __exit sx_exit(void)
2850 {
2851         int i;
2852
2853         func_enter();
2854 #ifdef CONFIG_EISA
2855         eisa_driver_unregister(&sx_eisadriver);
2856 #endif
2857         pci_unregister_driver(&sx_pcidriver);
2858
2859         for (i = 0; i < SX_NBOARDS; i++)
2860                 sx_remove_card(&boards[i], NULL);
2861
2862         if (misc_deregister(&sx_fw_device) < 0) {
2863                 printk(KERN_INFO "sx: couldn't deregister firmware loader "
2864                                 "device\n");
2865         }
2866         sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
2867                         sx_initialized);
2868         if (sx_initialized)
2869                 sx_release_drivers();
2870
2871         kfree(sx_ports);
2872         func_exit();
2873 }
2874
2875 module_init(sx_init);
2876 module_exit(sx_exit);