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