intel-gtt: switch i81x to the common initialization helpers
[linux-2.6.git] / 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_carrier_raised(struct tty_port *port);
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 long sx_fw_ioctl(struct file *filp, unsigned int cmd,
290                                                 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_shutdown_port,
364         sx_set_real_termios,
365         sx_chars_in_buffer,
366         sx_close,
367 };
368
369 /* 
370    This driver can spew a whole lot of debugging output at you. If you
371    need maximum performance, you should disable the DEBUG define. To
372    aid in debugging in the field, I'm leaving the compile-time debug
373    features enabled, and disable them "runtime". That allows me to
374    instruct people with problems to enable debugging without requiring
375    them to recompile... 
376 */
377 #define DEBUG
378
379 #ifdef DEBUG
380 #define sx_dprintk(f, str...)   if (sx_debug & f) printk (str)
381 #else
382 #define sx_dprintk(f, str...)   /* nothing */
383 #endif
384
385 #define func_enter()    sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__func__)
386 #define func_exit()     sx_dprintk(SX_DEBUG_FLOW, "sx: exit  %s\n",__func__)
387
388 #define func_enter2()   sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
389                                 __func__, port->line)
390
391 /* 
392  *  Firmware loader driver specific routines
393  *
394  */
395
396 static const struct file_operations sx_fw_fops = {
397         .owner = THIS_MODULE,
398         .unlocked_ioctl = sx_fw_ioctl,
399         .llseek = noop_llseek,
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, tty_port_carrier_raised(&port->gs.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, tty_port_carrier_raised(&port->gs.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 = tty_port_carrier_raised(&port->gs.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 (tty_port_carrier_raised(&port->gs.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_carrier_raised(struct tty_port *port)
1419 {
1420         struct sx_port *sp = container_of(port, struct sx_port, gs.port);
1421         return ((sx_read_channel_byte(sp, hi_ip) & IP_DCD) != 0);
1422 }
1423
1424 /* Jeez. Isn't this simple? */
1425 static int sx_chars_in_buffer(void *ptr)
1426 {
1427         struct sx_port *port = ptr;
1428         func_enter2();
1429
1430         func_exit();
1431         return ((sx_read_channel_byte(port, hi_txipos) -
1432                  sx_read_channel_byte(port, hi_txopos)) & 0xff);
1433 }
1434
1435 static void sx_shutdown_port(void *ptr)
1436 {
1437         struct sx_port *port = ptr;
1438
1439         func_enter();
1440
1441         port->gs.port.flags &= ~GS_ACTIVE;
1442         if (port->gs.port.tty && (port->gs.port.tty->termios->c_cflag & HUPCL)) {
1443                 sx_setsignals(port, 0, 0);
1444                 sx_reconfigure_port(port);
1445         }
1446
1447         func_exit();
1448 }
1449
1450 /* ********************************************************************** *
1451  *                Here are the routines that actually                     *
1452  *               interface with the rest of the system                    *
1453  * ********************************************************************** */
1454
1455 static int sx_open(struct tty_struct *tty, struct file *filp)
1456 {
1457         struct sx_port *port;
1458         int retval, line;
1459         unsigned long flags;
1460
1461         func_enter();
1462
1463         if (!sx_initialized) {
1464                 return -EIO;
1465         }
1466
1467         line = tty->index;
1468         sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
1469                         "np=%d)\n", task_pid_nr(current), line, tty,
1470                         current->signal->tty, sx_nports);
1471
1472         if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1473                 return -ENODEV;
1474
1475         port = &sx_ports[line];
1476         port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
1477                             1 -> 0 transition. */
1478
1479         sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
1480
1481         spin_lock_irqsave(&port->gs.driver_lock, flags);
1482
1483         tty->driver_data = port;
1484         port->gs.port.tty = tty;
1485         port->gs.port.count++;
1486         spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1487
1488         sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
1489
1490         /*
1491          * Start up serial port
1492          */
1493         retval = gs_init_port(&port->gs);
1494         sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
1495         if (retval) {
1496                 port->gs.port.count--;
1497                 return retval;
1498         }
1499
1500         port->gs.port.flags |= GS_ACTIVE;
1501         if (port->gs.port.count <= 1)
1502                 sx_setsignals(port, 1, 1);
1503
1504 #if 0
1505         if (sx_debug & SX_DEBUG_OPEN)
1506                 my_hd(port, sizeof(*port));
1507 #else
1508         if (sx_debug & SX_DEBUG_OPEN)
1509                 my_hd_io(port->board->base + port->ch_base, sizeof(*port));
1510 #endif
1511
1512         if (port->gs.port.count <= 1) {
1513                 if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1514                         printk(KERN_ERR "sx: Card didn't respond to LOPEN "
1515                                         "command.\n");
1516                         spin_lock_irqsave(&port->gs.driver_lock, flags);
1517                         port->gs.port.count--;
1518                         spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1519                         return -EIO;
1520                 }
1521         }
1522
1523         retval = gs_block_til_ready(port, filp);
1524         sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
1525                         retval, port->gs.port.count);
1526
1527         if (retval) {
1528 /*
1529  * Don't lower gs.port.count here because sx_close() will be called later
1530  */
1531
1532                 return retval;
1533         }
1534         /* tty->low_latency = 1; */
1535
1536         port->c_dcd = sx_carrier_raised(&port->gs.port);
1537         sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
1538
1539         func_exit();
1540         return 0;
1541
1542 }
1543
1544 static void sx_close(void *ptr)
1545 {
1546         struct sx_port *port = ptr;
1547         /* Give the port 5 seconds to close down. */
1548         int to = 5 * HZ;
1549
1550         func_enter();
1551
1552         sx_setsignals(port, 0, 0);
1553         sx_reconfigure_port(port);
1554         sx_send_command(port, HS_CLOSE, 0, 0);
1555
1556         while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
1557                 if (msleep_interruptible(10))
1558                         break;
1559         if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
1560                 if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
1561                                 != 1) {
1562                         printk(KERN_ERR "sx: sent the force_close command, but "
1563                                         "card didn't react\n");
1564                 } else
1565                         sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
1566                                         "command.\n");
1567         }
1568
1569         sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
1570                         5 * HZ - to - 1, port->gs.port.count);
1571
1572         if (port->gs.port.count) {
1573                 sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n",
1574                                 port->gs.port.count);
1575                 /*printk("%s SETTING port count to zero: %p count: %d\n",
1576                                 __func__, port, port->gs.port.count);
1577                 port->gs.port.count = 0;*/
1578         }
1579
1580         func_exit();
1581 }
1582
1583 /* This is relatively thorough. But then again it is only 20 lines. */
1584 #define MARCHUP         for (i = min; i < max; i++)
1585 #define MARCHDOWN       for (i = max - 1; i >= min; i--)
1586 #define W0              write_sx_byte(board, i, 0x55)
1587 #define W1              write_sx_byte(board, i, 0xaa)
1588 #define R0              if (read_sx_byte(board, i) != 0x55) return 1
1589 #define R1              if (read_sx_byte(board, i) != 0xaa) return 1
1590
1591 /* This memtest takes a human-noticable time. You normally only do it
1592    once a boot, so I guess that it is worth it. */
1593 static int do_memtest(struct sx_board *board, int min, int max)
1594 {
1595         int i;
1596
1597         /* This is a marchb. Theoretically, marchb catches much more than
1598            simpler tests. In practise, the longer test just catches more
1599            intermittent errors. -- REW
1600            (For the theory behind memory testing see: 
1601            Testing Semiconductor Memories by A.J. van de Goor.) */
1602         MARCHUP {
1603                 W0;
1604         }
1605         MARCHUP {
1606                 R0;
1607                 W1;
1608                 R1;
1609                 W0;
1610                 R0;
1611                 W1;
1612         }
1613         MARCHUP {
1614                 R1;
1615                 W0;
1616                 W1;
1617         }
1618         MARCHDOWN {
1619                 R1;
1620                 W0;
1621                 W1;
1622                 W0;
1623         }
1624         MARCHDOWN {
1625                 R0;
1626                 W1;
1627                 W0;
1628         }
1629
1630         return 0;
1631 }
1632
1633 #undef MARCHUP
1634 #undef MARCHDOWN
1635 #undef W0
1636 #undef W1
1637 #undef R0
1638 #undef R1
1639
1640 #define MARCHUP         for (i = min; i < max; i += 2)
1641 #define MARCHDOWN       for (i = max - 1; i >= min; i -= 2)
1642 #define W0              write_sx_word(board, i, 0x55aa)
1643 #define W1              write_sx_word(board, i, 0xaa55)
1644 #define R0              if (read_sx_word(board, i) != 0x55aa) return 1
1645 #define R1              if (read_sx_word(board, i) != 0xaa55) return 1
1646
1647 #if 0
1648 /* This memtest takes a human-noticable time. You normally only do it
1649    once a boot, so I guess that it is worth it. */
1650 static int do_memtest_w(struct sx_board *board, int min, int max)
1651 {
1652         int i;
1653
1654         MARCHUP {
1655                 W0;
1656         }
1657         MARCHUP {
1658                 R0;
1659                 W1;
1660                 R1;
1661                 W0;
1662                 R0;
1663                 W1;
1664         }
1665         MARCHUP {
1666                 R1;
1667                 W0;
1668                 W1;
1669         }
1670         MARCHDOWN {
1671                 R1;
1672                 W0;
1673                 W1;
1674                 W0;
1675         }
1676         MARCHDOWN {
1677                 R0;
1678                 W1;
1679                 W0;
1680         }
1681
1682         return 0;
1683 }
1684 #endif
1685
1686 static long sx_fw_ioctl(struct file *filp, unsigned int cmd,
1687                                                         unsigned long arg)
1688 {
1689         long rc = 0;
1690         int __user *descr = (int __user *)arg;
1691         int i;
1692         static struct sx_board *board = NULL;
1693         int nbytes, offset;
1694         unsigned long data;
1695         char *tmp;
1696
1697         func_enter();
1698
1699         if (!capable(CAP_SYS_RAWIO))
1700                 return -EPERM;
1701
1702         tty_lock();
1703
1704         sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
1705
1706         if (!board)
1707                 board = &boards[0];
1708         if (board->flags & SX_BOARD_PRESENT) {
1709                 sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1710                                 board->flags);
1711         } else {
1712                 sx_dprintk(SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
1713                                 board->flags);
1714                 for (i = 0; i < SX_NBOARDS; i++)
1715                         sx_dprintk(SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
1716                 sx_dprintk(SX_DEBUG_FIRMWARE, "\n");
1717                 rc = -EIO;
1718                 goto out;
1719         }
1720
1721         switch (cmd) {
1722         case SXIO_SET_BOARD:
1723                 sx_dprintk(SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
1724                 rc = -EIO;
1725                 if (arg >= SX_NBOARDS)
1726                         break;
1727                 sx_dprintk(SX_DEBUG_FIRMWARE, "not out of range\n");
1728                 if (!(boards[arg].flags & SX_BOARD_PRESENT))
1729                         break;
1730                 sx_dprintk(SX_DEBUG_FIRMWARE, ".. and present!\n");
1731                 board = &boards[arg];
1732                 rc = 0;
1733                 /* FIXME: And this does ... nothing?? */
1734                 break;
1735         case SXIO_GET_TYPE:
1736                 rc = -ENOENT;   /* If we manage to miss one, return error. */
1737                 if (IS_SX_BOARD(board))
1738                         rc = SX_TYPE_SX;
1739                 if (IS_CF_BOARD(board))
1740                         rc = SX_TYPE_CF;
1741                 if (IS_SI_BOARD(board))
1742                         rc = SX_TYPE_SI;
1743                 if (IS_SI1_BOARD(board))
1744                         rc = SX_TYPE_SI;
1745                 if (IS_EISA_BOARD(board))
1746                         rc = SX_TYPE_SI;
1747                 sx_dprintk(SX_DEBUG_FIRMWARE, "returning type= %ld\n", rc);
1748                 break;
1749         case SXIO_DO_RAMTEST:
1750                 if (sx_initialized) {   /* Already initialized: better not ramtest the board.  */
1751                         rc = -EPERM;
1752                         break;
1753                 }
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,
1764                                 "returning memtest result= %ld\n", rc);
1765                 break;
1766         case SXIO_DOWNLOAD:
1767                 if (sx_initialized) {/* Already initialized */
1768                         rc = -EEXIST;
1769                         break;
1770                 }
1771                 if (!sx_reset(board)) {
1772                         rc = -EIO;
1773                         break;
1774                 }
1775                 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
1776
1777                 tmp = kmalloc(SX_CHUNK_SIZE, GFP_USER);
1778                 if (!tmp) {
1779                         rc = -ENOMEM;
1780                         break;
1781                 }
1782                 /* FIXME: check returns */
1783                 get_user(nbytes, descr++);
1784                 get_user(offset, descr++);
1785                 get_user(data, descr++);
1786                 while (nbytes && data) {
1787                         for (i = 0; i < nbytes; i += SX_CHUNK_SIZE) {
1788                                 if (copy_from_user(tmp, (char __user *)data + i,
1789                                                 (i + SX_CHUNK_SIZE > nbytes) ?
1790                                                 nbytes - i : SX_CHUNK_SIZE)) {
1791                                         kfree(tmp);
1792                                         rc = -EFAULT;
1793                                         goto out;
1794                                 }
1795                                 memcpy_toio(board->base2 + offset + i, tmp,
1796                                                 (i + SX_CHUNK_SIZE > nbytes) ?
1797                                                 nbytes - i : SX_CHUNK_SIZE);
1798                         }
1799
1800                         get_user(nbytes, descr++);
1801                         get_user(offset, descr++);
1802                         get_user(data, descr++);
1803                 }
1804                 kfree(tmp);
1805                 sx_nports += sx_init_board(board);
1806                 rc = sx_nports;
1807                 break;
1808         case SXIO_INIT:
1809                 if (sx_initialized) {   /* Already initialized */
1810                         rc = -EEXIST;
1811                         break;
1812                 }
1813                 /* This is not allowed until all boards are initialized... */
1814                 for (i = 0; i < SX_NBOARDS; i++) {
1815                         if ((boards[i].flags & SX_BOARD_PRESENT) &&
1816                                 !(boards[i].flags & SX_BOARD_INITIALIZED)) {
1817                                 rc = -EIO;
1818                                 break;
1819                         }
1820                 }
1821                 for (i = 0; i < SX_NBOARDS; i++)
1822                         if (!(boards[i].flags & SX_BOARD_PRESENT))
1823                                 break;
1824
1825                 sx_dprintk(SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
1826                                 "%d channels, first board: %d ports\n",
1827                                 i, sx_nports, boards[0].nports);
1828                 rc = sx_init_portstructs(i, sx_nports);
1829                 sx_init_drivers();
1830                 if (rc >= 0)
1831                         sx_initialized++;
1832                 break;
1833         case SXIO_SETDEBUG:
1834                 sx_debug = arg;
1835                 break;
1836         case SXIO_GETDEBUG:
1837                 rc = sx_debug;
1838                 break;
1839         case SXIO_GETGSDEBUG:
1840         case SXIO_SETGSDEBUG:
1841                 rc = -EINVAL;
1842                 break;
1843         case SXIO_GETNPORTS:
1844                 rc = sx_nports;
1845                 break;
1846         default:
1847                 rc = -ENOTTY;
1848                 break;
1849         }
1850 out:
1851         tty_unlock();
1852         func_exit();
1853         return rc;
1854 }
1855
1856 static int sx_break(struct tty_struct *tty, int flag)
1857 {
1858         struct sx_port *port = tty->driver_data;
1859         int rv;
1860
1861         func_enter();
1862         tty_lock();
1863
1864         if (flag)
1865                 rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
1866         else
1867                 rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
1868         if (rv != 1)
1869                 printk(KERN_ERR "sx: couldn't send break (%x).\n",
1870                         read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
1871         tty_unlock();
1872         func_exit();
1873         return 0;
1874 }
1875
1876 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1877 {
1878         struct sx_port *port = tty->driver_data;
1879         return sx_getsignals(port);
1880 }
1881
1882 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1883                 unsigned int set, unsigned int clear)
1884 {
1885         struct sx_port *port = tty->driver_data;
1886         int rts = -1, dtr = -1;
1887
1888         if (set & TIOCM_RTS)
1889                 rts = 1;
1890         if (set & TIOCM_DTR)
1891                 dtr = 1;
1892         if (clear & TIOCM_RTS)
1893                 rts = 0;
1894         if (clear & TIOCM_DTR)
1895                 dtr = 0;
1896
1897         sx_setsignals(port, dtr, rts);
1898         sx_reconfigure_port(port);
1899         return 0;
1900 }
1901
1902 static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1903                 unsigned int cmd, unsigned long arg)
1904 {
1905         int rc;
1906         struct sx_port *port = tty->driver_data;
1907         void __user *argp = (void __user *)arg;
1908
1909         /* func_enter2(); */
1910
1911         rc = 0;
1912         tty_lock();
1913         switch (cmd) {
1914         case TIOCGSERIAL:
1915                 rc = gs_getserial(&port->gs, argp);
1916                 break;
1917         case TIOCSSERIAL:
1918                 rc = gs_setserial(&port->gs, argp);
1919                 break;
1920         default:
1921                 rc = -ENOIOCTLCMD;
1922                 break;
1923         }
1924         tty_unlock();
1925
1926         /* func_exit(); */
1927         return rc;
1928 }
1929
1930 /* The throttle/unthrottle scheme for the Specialix card is different
1931  * from other drivers and deserves some explanation. 
1932  * The Specialix hardware takes care of XON/XOFF
1933  * and CTS/RTS flow control itself.  This means that all we have to
1934  * do when signalled by the upper tty layer to throttle/unthrottle is
1935  * to make a note of it here.  When we come to read characters from the
1936  * rx buffers on the card (sx_receive_chars()) we look to see if the
1937  * upper layer can accept more (as noted here in sx_rx_throt[]). 
1938  * If it can't we simply don't remove chars from the cards buffer. 
1939  * When the tty layer can accept chars, we again note that here and when
1940  * sx_receive_chars() is called it will remove them from the cards buffer.
1941  * The card will notice that a ports buffer has drained below some low
1942  * water mark and will unflow control the line itself, using whatever
1943  * flow control scheme is in use for that port. -- Simon Allen
1944  */
1945
1946 static void sx_throttle(struct tty_struct *tty)
1947 {
1948         struct sx_port *port = tty->driver_data;
1949
1950         func_enter2();
1951         /* If the port is using any type of input flow
1952          * control then throttle the port.
1953          */
1954         if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
1955                 port->gs.port.flags |= SX_RX_THROTTLE;
1956         }
1957         func_exit();
1958 }
1959
1960 static void sx_unthrottle(struct tty_struct *tty)
1961 {
1962         struct sx_port *port = tty->driver_data;
1963
1964         func_enter2();
1965         /* Always unthrottle even if flow control is not enabled on
1966          * this port in case we disabled flow control while the port
1967          * was throttled
1968          */
1969         port->gs.port.flags &= ~SX_RX_THROTTLE;
1970         func_exit();
1971         return;
1972 }
1973
1974 /* ********************************************************************** *
1975  *                    Here are the initialization routines.               *
1976  * ********************************************************************** */
1977
1978 static int sx_init_board(struct sx_board *board)
1979 {
1980         int addr;
1981         int chans;
1982         int type;
1983
1984         func_enter();
1985
1986         /* This is preceded by downloading the download code. */
1987
1988         board->flags |= SX_BOARD_INITIALIZED;
1989
1990         if (read_sx_byte(board, 0))
1991                 /* CF boards may need this. */
1992                 write_sx_byte(board, 0, 0);
1993
1994         /* This resets the processor again, to make sure it didn't do any
1995            foolish things while we were downloading the image */
1996         if (!sx_reset(board))
1997                 return 0;
1998
1999         sx_start_board(board);
2000         udelay(10);
2001         if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
2002                 printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
2003                 return 0;
2004         }
2005
2006         /* Ok. So now the processor on the card is running. It gathered
2007            some info for us... */
2008         sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
2009         if (sx_debug & SX_DEBUG_INIT)
2010                 my_hd_io(board->base, 0x10);
2011         sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
2012         if (sx_debug & SX_DEBUG_INIT)
2013                 my_hd_io(board->base + 0x80, 0x30);
2014
2015         sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
2016                         "V%x.%02x,\n",
2017                         read_sx_byte(board, 0), read_sx_byte(board, 1),
2018                         read_sx_byte(board, 5), read_sx_byte(board, 4));
2019
2020         if (read_sx_byte(board, 0) == 0xff) {
2021                 printk(KERN_INFO "sx: No modules found. Sorry.\n");
2022                 board->nports = 0;
2023                 return 0;
2024         }
2025
2026         chans = 0;
2027
2028         if (IS_SX_BOARD(board)) {
2029                 sx_write_board_word(board, cc_int_count, sx_maxints);
2030         } else {
2031                 if (sx_maxints)
2032                         sx_write_board_word(board, cc_int_count,
2033                                         SI_PROCESSOR_CLOCK / 8 / sx_maxints);
2034         }
2035
2036         /* grab the first module type... */
2037         /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
2038         board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
2039                                 mc_chip));
2040
2041         /* XXX byteorder */
2042         for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
2043                 type = sx_read_module_byte(board, addr, mc_chip);
2044                 sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
2045                                 addr, read_sx_byte(board, addr + 2));
2046
2047                 chans += sx_read_module_byte(board, addr, mc_type);
2048
2049                 sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
2050                                 "panels\n",
2051                                 mod_type_s(type),
2052                                 pan_type_s(sx_read_module_byte(board, addr,
2053                                                 mc_mods) & 0xf),
2054                                 pan_type_s(sx_read_module_byte(board, addr,
2055                                                 mc_mods) >> 4));
2056
2057                 sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
2058                         "version: %x\n",
2059                         sx_read_module_byte(board, addr, mc_rev1),
2060                         sx_read_module_byte(board, addr, mc_rev2),
2061                         sx_read_module_byte(board, addr, mc_mtaasic_rev));
2062
2063                 /* The following combinations are illegal: It should theoretically
2064                    work, but timing problems make the bus HANG. */
2065
2066                 if (mod_compat_type(type) != board->ta_type) {
2067                         printk(KERN_ERR "sx: This is an invalid "
2068                                 "configuration.\nDon't mix TA/MTA/SXDC on the "
2069                                 "same hostadapter.\n");
2070                         chans = 0;
2071                         break;
2072                 }
2073                 if ((IS_EISA_BOARD(board) ||
2074                                 IS_SI_BOARD(board)) &&
2075                                 (mod_compat_type(type) == 4)) {
2076                         printk(KERN_ERR "sx: This is an invalid "
2077                                 "configuration.\nDon't use SXDCs on an SI/XIO "
2078                                 "adapter.\n");
2079                         chans = 0;
2080                         break;
2081                 }
2082 #if 0                           /* Problem fixed: firmware 3.05 */
2083                 if (IS_SX_BOARD(board) && (type == TA8)) {
2084                         /* There are some issues with the firmware and the DCD/RTS
2085                            lines. It might work if you tie them together or something.
2086                            It might also work if you get a newer sx_firmware.   Therefore
2087                            this is just a warning. */
2088                         printk(KERN_WARNING
2089                                "sx: The SX host doesn't work too well "
2090                                "with the TA8 adapters.\nSpecialix is working on it.\n");
2091                 }
2092 #endif
2093         }
2094
2095         if (chans) {
2096                 if (board->irq > 0) {
2097                         /* fixed irq, probably PCI */
2098                         if (sx_irqmask & (1 << board->irq)) {   /* may we use this irq? */
2099                                 if (request_irq(board->irq, sx_interrupt,
2100                                                 IRQF_SHARED | IRQF_DISABLED,
2101                                                 "sx", board)) {
2102                                         printk(KERN_ERR "sx: Cannot allocate "
2103                                                 "irq %d.\n", board->irq);
2104                                         board->irq = 0;
2105                                 }
2106                         } else
2107                                 board->irq = 0;
2108                 } else if (board->irq < 0 && sx_irqmask) {
2109                         /* auto-allocate irq */
2110                         int irqnr;
2111                         int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
2112                                         SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
2113                         for (irqnr = 15; irqnr > 0; irqnr--)
2114                                 if (irqmask & (1 << irqnr))
2115                                         if (!request_irq(irqnr, sx_interrupt,
2116                                                 IRQF_SHARED | IRQF_DISABLED,
2117                                                 "sx", board))
2118                                                 break;
2119                         if (!irqnr)
2120                                 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2121                         board->irq = irqnr;
2122                 } else
2123                         board->irq = 0;
2124
2125                 if (board->irq) {
2126                         /* Found a valid interrupt, start up interrupts! */
2127                         sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
2128                                         board->irq);
2129                         sx_start_interrupts(board);
2130                         board->poll = sx_slowpoll;
2131                         board->flags |= SX_IRQ_ALLOCATED;
2132                 } else {
2133                         /* no irq: setup board for polled operation */
2134                         board->poll = sx_poll;
2135                         sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
2136                                         board->poll);
2137                 }
2138
2139                 /* The timer should be initialized anyway: That way we can
2140                    safely del_timer it when the module is unloaded. */
2141                 setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
2142
2143                 if (board->poll)
2144                         mod_timer(&board->timer, jiffies + board->poll);
2145         } else {
2146                 board->irq = 0;
2147         }
2148
2149         board->nports = chans;
2150         sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
2151
2152         func_exit();
2153         return chans;
2154 }
2155
2156 static void __devinit printheader(void)
2157 {
2158         static int header_printed;
2159
2160         if (!header_printed) {
2161                 printk(KERN_INFO "Specialix SX driver "
2162                         "(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
2163                 printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
2164                 header_printed = 1;
2165         }
2166 }
2167
2168 static int __devinit probe_sx(struct sx_board *board)
2169 {
2170         struct vpd_prom vpdp;
2171         char *p;
2172         int i;
2173
2174         func_enter();
2175
2176         if (!IS_CF_BOARD(board)) {
2177                 sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2178                                 board->base + SX_VPD_ROM);
2179
2180                 if (sx_debug & SX_DEBUG_PROBE)
2181                         my_hd_io(board->base + SX_VPD_ROM, 0x40);
2182
2183                 p = (char *)&vpdp;
2184                 for (i = 0; i < sizeof(struct vpd_prom); i++)
2185                         *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
2186
2187                 if (sx_debug & SX_DEBUG_PROBE)
2188                         my_hd(&vpdp, 0x20);
2189
2190                 sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
2191
2192                 if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2193                         sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
2194                                         "'%s'\n", vpdp.identifier);
2195                         return 0;
2196                 }
2197         }
2198
2199         printheader();
2200
2201         if (!IS_CF_BOARD(board)) {
2202                 printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
2203                         board->hw_base);
2204                 printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
2205                                 "uniq ID:%08x, ",
2206                                 vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2207                 printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
2208
2209                 if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
2210                                 SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
2211                                 SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2212                         /* This might be a bit harsh. This was the primary
2213                            reason the SX/ISA card didn't work at first... */
2214                         printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
2215                                         "card. Sorry: giving up.\n");
2216                         return (0);
2217                 }
2218
2219                 if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
2220                                 SX_ISA_UNIQUEID1) {
2221                         if (((unsigned long)board->hw_base) & 0x8000) {
2222                                 printk(KERN_WARNING "sx: Warning: There may be "
2223                                         "hardware problems with the card at "
2224                                         "%lx.\n", board->hw_base);
2225                                 printk(KERN_WARNING "sx: Read sx.txt for more "
2226                                                 "info.\n");
2227                         }
2228                 }
2229         }
2230
2231         board->nports = -1;
2232
2233         /* This resets the processor, and keeps it off the bus. */
2234         if (!sx_reset(board))
2235                 return 0;
2236         sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2237
2238         func_exit();
2239         return 1;
2240 }
2241
2242 #if defined(CONFIG_ISA) || defined(CONFIG_EISA)
2243
2244 /* Specialix probes for this card at 32k increments from 640k to 16M.
2245    I consider machines with less than 16M unlikely nowadays, so I'm
2246    not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2247    card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves 
2248    0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2249
2250 static int __devinit probe_si(struct sx_board *board)
2251 {
2252         int i;
2253
2254         func_enter();
2255         sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
2256                 "%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
2257
2258         if (sx_debug & SX_DEBUG_PROBE)
2259                 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2260
2261         if (!IS_EISA_BOARD(board)) {
2262                 if (IS_SI1_BOARD(board)) {
2263                         for (i = 0; i < 8; i++) {
2264                                 write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
2265                         }
2266                 }
2267                 for (i = 0; i < 8; i++) {
2268                         if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
2269                                         != i) {
2270                                 func_exit();
2271                                 return 0;
2272                         }
2273                 }
2274         }
2275
2276         /* Now we're pretty much convinced that there is an SI board here, 
2277            but to prevent trouble, we'd better double check that we don't
2278            have an SI1 board when we're probing for an SI2 board.... */
2279
2280         write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2281         if (IS_SI1_BOARD(board)) {
2282                 /* This should be an SI1 board, which has this
2283                    location writable... */
2284                 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2285                         func_exit();
2286                         return 0;
2287                 }
2288         } else {
2289                 /* This should be an SI2 board, which has the bottom
2290                    3 bits non-writable... */
2291                 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2292                         func_exit();
2293                         return 0;
2294                 }
2295         }
2296
2297         /* Now we're pretty much convinced that there is an SI board here, 
2298            but to prevent trouble, we'd better double check that we don't
2299            have an SI1 board when we're probing for an SI2 board.... */
2300
2301         write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2302         if (IS_SI1_BOARD(board)) {
2303                 /* This should be an SI1 board, which has this
2304                    location writable... */
2305                 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2306                         func_exit();
2307                         return 0;
2308                 }
2309         } else {
2310                 /* This should be an SI2 board, which has the bottom
2311                    3 bits non-writable... */
2312                 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2313                         func_exit();
2314                         return 0;
2315                 }
2316         }
2317
2318         printheader();
2319
2320         printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
2321         /* Compared to the SX boards, it is a complete guess as to what
2322            this card is up to... */
2323
2324         board->nports = -1;
2325
2326         /* This resets the processor, and keeps it off the bus. */
2327         if (!sx_reset(board))
2328                 return 0;
2329         sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2330
2331         func_exit();
2332         return 1;
2333 }
2334 #endif
2335
2336 static const struct tty_operations sx_ops = {
2337         .break_ctl = sx_break,
2338         .open = sx_open,
2339         .close = gs_close,
2340         .write = gs_write,
2341         .put_char = gs_put_char,
2342         .flush_chars = gs_flush_chars,
2343         .write_room = gs_write_room,
2344         .chars_in_buffer = gs_chars_in_buffer,
2345         .flush_buffer = gs_flush_buffer,
2346         .ioctl = sx_ioctl,
2347         .throttle = sx_throttle,
2348         .unthrottle = sx_unthrottle,
2349         .set_termios = gs_set_termios,
2350         .stop = gs_stop,
2351         .start = gs_start,
2352         .hangup = gs_hangup,
2353         .tiocmget = sx_tiocmget,
2354         .tiocmset = sx_tiocmset,
2355 };
2356
2357 static const struct tty_port_operations sx_port_ops = {
2358         .carrier_raised = sx_carrier_raised,
2359 };
2360
2361 static int sx_init_drivers(void)
2362 {
2363         int error;
2364
2365         func_enter();
2366
2367         sx_driver = alloc_tty_driver(sx_nports);
2368         if (!sx_driver)
2369                 return 1;
2370         sx_driver->owner = THIS_MODULE;
2371         sx_driver->driver_name = "specialix_sx";
2372         sx_driver->name = "ttyX";
2373         sx_driver->major = SX_NORMAL_MAJOR;
2374         sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2375         sx_driver->subtype = SERIAL_TYPE_NORMAL;
2376         sx_driver->init_termios = tty_std_termios;
2377         sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2378         sx_driver->init_termios.c_ispeed = 9600;
2379         sx_driver->init_termios.c_ospeed = 9600;
2380         sx_driver->flags = TTY_DRIVER_REAL_RAW;
2381         tty_set_operations(sx_driver, &sx_ops);
2382
2383         if ((error = tty_register_driver(sx_driver))) {
2384                 put_tty_driver(sx_driver);
2385                 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
2386                         error);
2387                 return 1;
2388         }
2389         func_exit();
2390         return 0;
2391 }
2392
2393 static int sx_init_portstructs(int nboards, int nports)
2394 {
2395         struct sx_board *board;
2396         struct sx_port *port;
2397         int i, j;
2398         int addr, chans;
2399         int portno;
2400
2401         func_enter();
2402
2403         /* Many drivers statically allocate the maximum number of ports
2404            There is no reason not to allocate them dynamically.
2405            Is there? -- REW */
2406         sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
2407         if (!sx_ports)
2408                 return -ENOMEM;
2409
2410         port = sx_ports;
2411         for (i = 0; i < nboards; i++) {
2412                 board = &boards[i];
2413                 board->ports = port;
2414                 for (j = 0; j < boards[i].nports; j++) {
2415                         sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
2416                         tty_port_init(&port->gs.port);
2417                         port->gs.port.ops = &sx_port_ops;
2418                         port->gs.magic = SX_MAGIC;
2419                         port->gs.close_delay = HZ / 2;
2420                         port->gs.closing_wait = 30 * HZ;
2421                         port->board = board;
2422                         port->gs.rd = &sx_real_driver;
2423 #ifdef NEW_WRITE_LOCKING
2424                         port->gs.port_write_mutex = MUTEX;
2425 #endif
2426                         spin_lock_init(&port->gs.driver_lock);
2427                         /*
2428                          * Initializing wait queue
2429                          */
2430                         port++;
2431                 }
2432         }
2433
2434         port = sx_ports;
2435         portno = 0;
2436         for (i = 0; i < nboards; i++) {
2437                 board = &boards[i];
2438                 board->port_base = portno;
2439                 /* Possibly the configuration was rejected. */
2440                 sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
2441                                 board->nports);
2442                 if (board->nports <= 0)
2443                         continue;
2444                 /* XXX byteorder ?? */
2445                 for (addr = 0x80; addr != 0;
2446                                 addr = read_sx_word(board, addr) & 0x7fff) {
2447                         chans = sx_read_module_byte(board, addr, mc_type);
2448                         sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
2449                                         "channels\n", addr, chans);
2450                         sx_dprintk(SX_DEBUG_PROBE, "Port at");
2451                         for (j = 0; j < chans; j++) {
2452                                 /* The "sx-way" is the way it SHOULD be done.
2453                                    That way in the future, the firmware may for
2454                                    example pack the structures a bit more
2455                                    efficient. Neil tells me it isn't going to
2456                                    happen anytime soon though. */
2457                                 if (IS_SX_BOARD(board))
2458                                         port->ch_base = sx_read_module_word(
2459                                                         board, addr + j * 2,
2460                                                         mc_chan_pointer);
2461                                 else
2462                                         port->ch_base = addr + 0x100 + 0x300 *j;
2463
2464                                 sx_dprintk(SX_DEBUG_PROBE, " %x",
2465                                                 port->ch_base);
2466                                 port->line = portno++;
2467                                 port++;
2468                         }
2469                         sx_dprintk(SX_DEBUG_PROBE, "\n");
2470                 }
2471                 /* This has to be done earlier. */
2472                 /* board->flags |= SX_BOARD_INITIALIZED; */
2473         }
2474
2475         func_exit();
2476         return 0;
2477 }
2478
2479 static unsigned int sx_find_free_board(void)
2480 {
2481         unsigned int i;
2482
2483         for (i = 0; i < SX_NBOARDS; i++)
2484                 if (!(boards[i].flags & SX_BOARD_PRESENT))
2485                         break;
2486
2487         return i;
2488 }
2489
2490 static void __exit sx_release_drivers(void)
2491 {
2492         func_enter();
2493         tty_unregister_driver(sx_driver);
2494         put_tty_driver(sx_driver);
2495         func_exit();
2496 }
2497
2498 static void __devexit sx_remove_card(struct sx_board *board,
2499                 struct pci_dev *pdev)
2500 {
2501         if (board->flags & SX_BOARD_INITIALIZED) {
2502                 /* The board should stop messing with us. (actually I mean the
2503                    interrupt) */
2504                 sx_reset(board);
2505                 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2506                         free_irq(board->irq, board);
2507
2508                 /* It is safe/allowed to del_timer a non-active timer */
2509                 del_timer(&board->timer);
2510                 if (pdev) {
2511 #ifdef CONFIG_PCI
2512                         iounmap(board->base2);
2513                         pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
2514 #endif
2515                 } else {
2516                         iounmap(board->base);
2517                         release_region(board->hw_base, board->hw_len);
2518                 }
2519
2520                 board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
2521         }
2522 }
2523
2524 #ifdef CONFIG_EISA
2525
2526 static int __devinit sx_eisa_probe(struct device *dev)
2527 {
2528         struct eisa_device *edev = to_eisa_device(dev);
2529         struct sx_board *board;
2530         unsigned long eisa_slot = edev->base_addr;
2531         unsigned int i;
2532         int retval = -EIO;
2533
2534         mutex_lock(&sx_boards_lock);
2535         i = sx_find_free_board();
2536         if (i == SX_NBOARDS) {
2537                 mutex_unlock(&sx_boards_lock);
2538                 goto err;
2539         }
2540         board = &boards[i];
2541         board->flags |= SX_BOARD_PRESENT;
2542         mutex_unlock(&sx_boards_lock);
2543
2544         dev_info(dev, "XIO : Signature found in EISA slot %lu, "
2545                  "Product %d Rev %d (REPORT THIS TO LKLM)\n",
2546                  eisa_slot >> 12,
2547                  inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
2548                  inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
2549
2550         board->eisa_base = eisa_slot;
2551         board->flags &= ~SX_BOARD_TYPE;
2552         board->flags |= SI_EISA_BOARD;
2553
2554         board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
2555                           inb(eisa_slot + 0xc00)) << 16;
2556         board->hw_len = SI2_EISA_WINDOW_LEN;
2557         if (!request_region(board->hw_base, board->hw_len, "sx")) {
2558                 dev_err(dev, "can't request region\n");
2559                 goto err_flag;
2560         }
2561         board->base2 =
2562         board->base = ioremap_nocache(board->hw_base, SI2_EISA_WINDOW_LEN);
2563         if (!board->base) {
2564                 dev_err(dev, "can't remap memory\n");
2565                 goto err_reg;
2566         }
2567
2568         sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2569         sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2570         board->irq = inb(eisa_slot + 0xc02) >> 4;
2571         sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2572
2573         if (!probe_si(board))
2574                 goto err_unmap;
2575
2576         dev_set_drvdata(dev, board);
2577
2578         return 0;
2579 err_unmap:
2580         iounmap(board->base);
2581 err_reg:
2582         release_region(board->hw_base, board->hw_len);
2583 err_flag:
2584         board->flags &= ~SX_BOARD_PRESENT;
2585 err:
2586         return retval;
2587 }
2588
2589 static int __devexit sx_eisa_remove(struct device *dev)
2590 {
2591         struct sx_board *board = dev_get_drvdata(dev);
2592
2593         sx_remove_card(board, NULL);
2594
2595         return 0;
2596 }
2597
2598 static struct eisa_device_id sx_eisa_tbl[] = {
2599         { "SLX" },
2600         { "" }
2601 };
2602
2603 MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2604
2605 static struct eisa_driver sx_eisadriver = {
2606         .id_table = sx_eisa_tbl,
2607         .driver = {
2608                 .name = "sx",
2609                 .probe = sx_eisa_probe,
2610                 .remove = __devexit_p(sx_eisa_remove),
2611         }
2612 };
2613
2614 #endif
2615
2616 #ifdef CONFIG_PCI
2617  /******************************************************** 
2618  * Setting bit 17 in the CNTRL register of the PLX 9050  * 
2619  * chip forces a retry on writes while a read is pending.*
2620  * This is to prevent the card locking up on Intel Xeon  *
2621  * multiprocessor systems with the NX chipset.    -- NV  *
2622  ********************************************************/
2623
2624 /* Newer cards are produced with this bit set from the configuration
2625    EEprom.  As the bit is read/write for the CPU, we can fix it here,
2626    if we detect that it isn't set correctly. -- REW */
2627
2628 static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
2629 {
2630         unsigned int hwbase;
2631         void __iomem *rebase;
2632         unsigned int t;
2633
2634 #define CNTRL_REG_OFFSET        0x50
2635 #define CNTRL_REG_GOODVALUE     0x18260000
2636
2637         pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2638         hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2639         rebase = ioremap_nocache(hwbase, 0x80);
2640         t = readl(rebase + CNTRL_REG_OFFSET);
2641         if (t != CNTRL_REG_GOODVALUE) {
2642                 printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
2643                         "%08x\n", t, CNTRL_REG_GOODVALUE);
2644                 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
2645         }
2646         iounmap(rebase);
2647 }
2648 #endif
2649
2650 static int __devinit sx_pci_probe(struct pci_dev *pdev,
2651                                   const struct pci_device_id *ent)
2652 {
2653 #ifdef CONFIG_PCI
2654         struct sx_board *board;
2655         unsigned int i, reg;
2656         int retval = -EIO;
2657
2658         mutex_lock(&sx_boards_lock);
2659         i = sx_find_free_board();
2660         if (i == SX_NBOARDS) {
2661                 mutex_unlock(&sx_boards_lock);
2662                 goto err;
2663         }
2664         board = &boards[i];
2665         board->flags |= SX_BOARD_PRESENT;
2666         mutex_unlock(&sx_boards_lock);
2667
2668         retval = pci_enable_device(pdev);
2669         if (retval)
2670                 goto err_flag;
2671
2672         board->flags &= ~SX_BOARD_TYPE;
2673         board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
2674                 SX_CFPCI_BOARD;
2675
2676         /* CF boards use base address 3.... */
2677         reg = IS_CF_BOARD(board) ? 3 : 2;
2678         retval = pci_request_region(pdev, reg, "sx");
2679         if (retval) {
2680                 dev_err(&pdev->dev, "can't request region\n");
2681                 goto err_flag;
2682         }
2683         board->hw_base = pci_resource_start(pdev, reg);
2684         board->base2 =
2685         board->base = ioremap_nocache(board->hw_base, WINDOW_LEN(board));
2686         if (!board->base) {
2687                 dev_err(&pdev->dev, "ioremap failed\n");
2688                 goto err_reg;
2689         }
2690
2691         /* Most of the stuff on the CF board is offset by 0x18000 ....  */
2692         if (IS_CF_BOARD(board))
2693                 board->base += 0x18000;
2694
2695         board->irq = pdev->irq;
2696
2697         dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
2698                  board->irq, board->flags);
2699
2700         if (!probe_sx(board)) {
2701                 retval = -EIO;
2702                 goto err_unmap;
2703         }
2704
2705         fix_sx_pci(pdev, board);
2706
2707         pci_set_drvdata(pdev, board);
2708
2709         return 0;
2710 err_unmap:
2711         iounmap(board->base2);
2712 err_reg:
2713         pci_release_region(pdev, reg);
2714 err_flag:
2715         board->flags &= ~SX_BOARD_PRESENT;
2716 err:
2717         return retval;
2718 #else
2719         return -ENODEV;
2720 #endif
2721 }
2722
2723 static void __devexit sx_pci_remove(struct pci_dev *pdev)
2724 {
2725         struct sx_board *board = pci_get_drvdata(pdev);
2726
2727         sx_remove_card(board, pdev);
2728 }
2729
2730 /* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
2731    its because the standard requires it. So check for SUBVENDOR_ID. */
2732 static struct pci_device_id sx_pci_tbl[] = {
2733         { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2734                 .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
2735         { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2736                 .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
2737         { 0 }
2738 };
2739
2740 MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2741
2742 static struct pci_driver sx_pcidriver = {
2743         .name = "sx",
2744         .id_table = sx_pci_tbl,
2745         .probe = sx_pci_probe,
2746         .remove = __devexit_p(sx_pci_remove)
2747 };
2748
2749 static int __init sx_init(void)
2750 {
2751 #ifdef CONFIG_EISA
2752         int retval1;
2753 #endif
2754 #ifdef CONFIG_ISA
2755         struct sx_board *board;
2756         unsigned int i;
2757 #endif
2758         unsigned int found = 0;
2759         int retval;
2760
2761         func_enter();
2762         sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
2763                         sx_debug);
2764         if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
2765                 printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
2766                                 "value. Assuming -1.\n(%p)\n", &sx_debug);
2767                 sx_debug = -1;
2768         }
2769
2770         if (misc_register(&sx_fw_device) < 0) {
2771                 printk(KERN_ERR "SX: Unable to register firmware loader "
2772                                 "driver.\n");
2773                 return -EIO;
2774         }
2775 #ifdef CONFIG_ISA
2776         for (i = 0; i < NR_SX_ADDRS; i++) {
2777                 board = &boards[found];
2778                 board->hw_base = sx_probe_addrs[i];
2779                 board->hw_len = SX_WINDOW_LEN;
2780                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2781                         continue;
2782                 board->base2 =
2783                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2784                 if (!board->base)
2785                         goto err_sx_reg;
2786                 board->flags &= ~SX_BOARD_TYPE;
2787                 board->flags |= SX_ISA_BOARD;
2788                 board->irq = sx_irqmask ? -1 : 0;
2789
2790                 if (probe_sx(board)) {
2791                         board->flags |= SX_BOARD_PRESENT;
2792                         found++;
2793                 } else {
2794                         iounmap(board->base);
2795 err_sx_reg:
2796                         release_region(board->hw_base, board->hw_len);
2797                 }
2798         }
2799
2800         for (i = 0; i < NR_SI_ADDRS; i++) {
2801                 board = &boards[found];
2802                 board->hw_base = si_probe_addrs[i];
2803                 board->hw_len = SI2_ISA_WINDOW_LEN;
2804                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2805                         continue;
2806                 board->base2 =
2807                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2808                 if (!board->base)
2809                         goto err_si_reg;
2810                 board->flags &= ~SX_BOARD_TYPE;
2811                 board->flags |= SI_ISA_BOARD;
2812                 board->irq = sx_irqmask ? -1 : 0;
2813
2814                 if (probe_si(board)) {
2815                         board->flags |= SX_BOARD_PRESENT;
2816                         found++;
2817                 } else {
2818                         iounmap(board->base);
2819 err_si_reg:
2820                         release_region(board->hw_base, board->hw_len);
2821                 }
2822         }
2823         for (i = 0; i < NR_SI1_ADDRS; i++) {
2824                 board = &boards[found];
2825                 board->hw_base = si1_probe_addrs[i];
2826                 board->hw_len = SI1_ISA_WINDOW_LEN;
2827                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2828                         continue;
2829                 board->base2 =
2830                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2831                 if (!board->base)
2832                         goto err_si1_reg;
2833                 board->flags &= ~SX_BOARD_TYPE;
2834                 board->flags |= SI1_ISA_BOARD;
2835                 board->irq = sx_irqmask ? -1 : 0;
2836
2837                 if (probe_si(board)) {
2838                         board->flags |= SX_BOARD_PRESENT;
2839                         found++;
2840                 } else {
2841                         iounmap(board->base);
2842 err_si1_reg:
2843                         release_region(board->hw_base, board->hw_len);
2844                 }
2845         }
2846 #endif
2847 #ifdef CONFIG_EISA
2848         retval1 = eisa_driver_register(&sx_eisadriver);
2849 #endif
2850         retval = pci_register_driver(&sx_pcidriver);
2851
2852         if (found) {
2853                 printk(KERN_INFO "sx: total of %d boards detected.\n", found);
2854                 retval = 0;
2855         } else if (retval) {
2856 #ifdef CONFIG_EISA
2857                 retval = retval1;
2858                 if (retval1)
2859 #endif
2860                         misc_deregister(&sx_fw_device);
2861         }
2862
2863         func_exit();
2864         return retval;
2865 }
2866
2867 static void __exit sx_exit(void)
2868 {
2869         int i;
2870
2871         func_enter();
2872 #ifdef CONFIG_EISA
2873         eisa_driver_unregister(&sx_eisadriver);
2874 #endif
2875         pci_unregister_driver(&sx_pcidriver);
2876
2877         for (i = 0; i < SX_NBOARDS; i++)
2878                 sx_remove_card(&boards[i], NULL);
2879
2880         if (misc_deregister(&sx_fw_device) < 0) {
2881                 printk(KERN_INFO "sx: couldn't deregister firmware loader "
2882                                 "device\n");
2883         }
2884         sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
2885                         sx_initialized);
2886         if (sx_initialized)
2887                 sx_release_drivers();
2888
2889         kfree(sx_ports);
2890         func_exit();
2891 }
2892
2893 module_init(sx_init);
2894 module_exit(sx_exit);