?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: relax BAD_MADT_ENTRY check to allow LSAPIC variable length string UIDs
[linux-2.6/mini2440.git] / drivers / char / sx.c
blobe1cd2bc4b1e4222e5806dab4389169ffa774900b
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 ARRAY_SIZE(sx_probe_addrs)
349 #define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
350 #define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
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 const 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: %u\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 unsigned char *rp;
1089
1090 func_enter2 ();
1091 tty = port->gs.tty;
1092 while (1) {
1093 rx_op = sx_read_channel_byte (port, hi_rxopos);
1094 c = (sx_read_channel_byte (port, hi_rxipos) - rx_op) & 0xff;
1095
1096 sx_dprintk (SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
1097
1098 /* Don't copy past the end of the hardware receive buffer */
1099 if (rx_op + c > 0x100) c = 0x100 - rx_op;
1100
1101 sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c);
1102
1103 /* Don't copy more bytes than there is room for in the buffer */
1104
1105 c = tty_prepare_flip_string(tty, &rp, c);
1106
1107 sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c);
1108
1109 /* If for one reason or another, we can't copy more data, we're done! */
1110 if (c == 0) break;
1111
1112 sx_dprintk (SX_DEBUG_RECEIVE , "Copying over %d chars. First is %d at %lx\n", c,
1113 read_sx_byte (port->board, CHAN_OFFSET(port,hi_rxbuf) + rx_op),
1114 CHAN_OFFSET(port, hi_rxbuf));
1115 memcpy_fromio (rp,
1116 port->board->base + CHAN_OFFSET(port,hi_rxbuf) + rx_op, c);
1117
1118 /* This one last. ( Not essential.)
1119 It allows the card to start putting more data into the buffer!
1120 Update the pointer in the card */
1121 sx_write_channel_byte (port, hi_rxopos, (rx_op + c) & 0xff);
1122
1123 copied += c;
1124 }
1125 if (copied) {
1126 struct timeval tv;
1127
1128 do_gettimeofday (&tv);
1129 sx_dprintk (SX_DEBUG_RECEIVE,
1130 "pushing flipq port %d (%3d chars): %d.%06d (%d/%d)\n",
1131 port->line, copied,
1132 (int) (tv.tv_sec % 60), (int)tv.tv_usec, tty->raw, tty->real_raw);
1133
1134 /* Tell the rest of the system the news. Great news. New characters! */
1135 tty_flip_buffer_push (tty);
1136 /* tty_schedule_flip (tty); */
1137 }
1138
1139 func_exit ();
1140 }
1141
1142 /* Inlined: it is called only once. Remove the inline if you add another
1143 call */
1144 static inline void sx_check_modem_signals (struct sx_port *port)
1145 {
1146 int hi_state;
1147 int c_dcd;
1148
1149 hi_state = sx_read_channel_byte (port, hi_state);
1150 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
1151 port->c_dcd, sx_get_CD (port));
1152
1153 if (hi_state & ST_BREAK) {
1154 hi_state &= ~ST_BREAK;
1155 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "got a break.\n");
1156 sx_write_channel_byte (port, hi_state, hi_state);
1157 gs_got_break (&port->gs);
1158 }
1159 if (hi_state & ST_DCD) {
1160 hi_state &= ~ST_DCD;
1161 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
1162 sx_write_channel_byte (port, hi_state, hi_state);
1163 c_dcd = sx_get_CD (port);
1164 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
1165 if (c_dcd != port->c_dcd) {
1166 port->c_dcd = c_dcd;
1167 if (sx_get_CD (port)) {
1168 /* DCD went UP */
1169 if ((sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) &&
1170 !(port->gs.tty->termios->c_cflag & CLOCAL) ) {
1171 /* Are we blocking in open?*/
1172 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD active, unblocking open\n");
1173 wake_up_interruptible(&port->gs.open_wait);
1174 } else {
1175 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD raised. Ignoring.\n");
1176 }
1177 } else {
1178 /* DCD went down! */
1179 if (!(port->gs.tty->termios->c_cflag & CLOCAL) ) {
1180 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD dropped. hanging up....\n");
1181 tty_hangup (port->gs.tty);
1182 } else {
1183 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD dropped. ignoring.\n");
1184 }
1185 }
1186 } else {
1187 sx_dprintk (SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us DCD changed, but it didn't.\n");
1188 }
1189 }
1190 }
1191
1192
1193 /* This is what an interrupt routine should look like.
1194 * Small, elegant, clear.
1195 */
1196
1197 static irqreturn_t sx_interrupt (int irq, void *ptr, struct pt_regs *regs)
1198 {
1199 struct sx_board *board = ptr;
1200 struct sx_port *port;
1201 int i;
1202
1203 func_enter ();
1204 sx_dprintk (SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq, board->irq);
1205
1206 /* AAargh! The order in which to do these things is essential and
1207 not trivial.
1208
1209 - Rate limit goes before "recursive". Otherwise a series of
1210 recursive calls will hang the machine in the interrupt routine.
1211
1212 - hardware twiddling goes before "recursive". Otherwise when we
1213 poll the card, and a recursive interrupt happens, we won't
1214 ack the card, so it might keep on interrupting us. (especially
1215 level sensitive interrupt systems like PCI).
1216
1217 - Rate limit goes before hardware twiddling. Otherwise we won't
1218 catch a card that has gone bonkers.
1219
1220 - The "initialized" test goes after the hardware twiddling. Otherwise
1221 the card will stick us in the interrupt routine again.
1222
1223 - The initialized test goes before recursive.
1224 */
1225
1226
1227
1228 #ifdef IRQ_RATE_LIMIT
1229 /* Aaargh! I'm ashamed. This costs more lines-of-code than the
1230 actual interrupt routine!. (Well, used to when I wrote that comment) */
1231 {
1232 static int lastjif;
1233 static int nintr=0;
1234
1235 if (lastjif == jiffies) {
1236 if (++nintr > IRQ_RATE_LIMIT) {
1237 free_irq (board->irq, board);
1238 printk (KERN_ERR "sx: Too many interrupts. Turning off interrupt %d.\n",
1239 board->irq);
1240 }
1241 } else {
1242 lastjif = jiffies;
1243 nintr = 0;
1244 }
1245 }
1246 #endif
1247
1248
1249 if (board->irq == irq) {
1250 /* Tell the card we've noticed the interrupt. */
1251
1252 sx_write_board_word (board, cc_int_pending, 0);
1253 if (IS_SX_BOARD (board)) {
1254 write_sx_byte (board, SX_RESET_IRQ, 1);
1255 } else if (IS_EISA_BOARD(board)) {
1256 inb(board->eisa_base+0xc03);
1257 write_sx_word(board, 8, 0);
1258 } else {
1259 write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
1260 write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
1261 }
1262 }
1263
1264 if (!sx_initialized)
1265 return IRQ_HANDLED;
1266 if (!(board->flags & SX_BOARD_INITIALIZED))
1267 return IRQ_HANDLED;
1268
1269 if (test_and_set_bit (SX_BOARD_INTR_LOCK, &board->locks)) {
1270 printk (KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
1271 return IRQ_HANDLED;
1272 }
1273
1274 for (i=0;i<board->nports;i++) {
1275 port = &board->ports[i];
1276 if (port->gs.flags & GS_ACTIVE) {
1277 if (sx_read_channel_byte (port, hi_state)) {
1278 sx_dprintk (SX_DEBUG_INTERRUPTS,
1279 "Port %d: modem signal change?... \n", i);
1280 sx_check_modem_signals (port);
1281 }
1282 if (port->gs.xmit_cnt) {
1283 sx_transmit_chars (port);
1284 }
1285 if (!(port->gs.flags & SX_RX_THROTTLE)) {
1286 sx_receive_chars (port);
1287 }
1288 }
1289 }
1290
1291 clear_bit (SX_BOARD_INTR_LOCK, &board->locks);
1292
1293 sx_dprintk (SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq, board->irq);
1294 func_exit ();
1295 return IRQ_HANDLED;
1296 }
1297
1298
1299 static void sx_pollfunc (unsigned long data)
1300 {
1301 struct sx_board *board = (struct sx_board *) data;
1302
1303 func_enter ();
1304
1305 sx_interrupt (0, board, NULL);
1306
1307 init_timer(&board->timer);
1308
1309 board->timer.expires = jiffies + sx_poll;
1310 add_timer (&board->timer);
1311 func_exit ();
1312 }
1313
1314
1315
1316 /* ********************************************************************** *
1317 * Here are the routines that actually *
1318 * interface with the generic_serial driver *
1319 * ********************************************************************** */
1320
1321 /* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
1322 /* Hmm. Ok I figured it out. You don't. */
1323
1324 static void sx_disable_tx_interrupts (void * ptr)
1325 {
1326 struct sx_port *port = ptr;
1327 func_enter2();
1328
1329 port->gs.flags &= ~GS_TX_INTEN;
1330
1331 func_exit();
1332 }
1333
1334
1335 static void sx_enable_tx_interrupts (void * ptr)
1336 {
1337 struct sx_port *port = ptr;
1338 int data_in_buffer;
1339 func_enter2();
1340
1341 /* First transmit the characters that we're supposed to */
1342 sx_transmit_chars (port);
1343
1344 /* The sx card will never interrupt us if we don't fill the buffer
1345 past 25%. So we keep considering interrupts off if that's the case. */
1346 data_in_buffer = (sx_read_channel_byte (port, hi_txipos) -
1347 sx_read_channel_byte (port, hi_txopos)) & 0xff;
1348
1349 /* XXX Must be "HIGH_WATER" for SI card according to doc. */
1350 if (data_in_buffer < LOW_WATER)
1351 port->gs.flags &= ~GS_TX_INTEN;
1352
1353 func_exit();
1354 }
1355
1356
1357 static void sx_disable_rx_interrupts (void * ptr)
1358 {
1359 /* struct sx_port *port = ptr; */
1360 func_enter();
1361
1362 func_exit();
1363 }
1364
1365 static void sx_enable_rx_interrupts (void * ptr)
1366 {
1367 /* struct sx_port *port = ptr; */
1368 func_enter();
1369
1370 func_exit();
1371 }
1372
1373
1374 /* Jeez. Isn't this simple? */
1375 static int sx_get_CD (void * ptr)
1376 {
1377 struct sx_port *port = ptr;
1378 func_enter2();
1379
1380 func_exit();
1381 return ((sx_read_channel_byte (port, hi_ip) & IP_DCD) != 0);
1382 }
1383
1384
1385 /* Jeez. Isn't this simple? */
1386 static int sx_chars_in_buffer (void * ptr)
1387 {
1388 struct sx_port *port = ptr;
1389 func_enter2();
1390
1391 func_exit();
1392 return ((sx_read_channel_byte (port, hi_txipos) -
1393 sx_read_channel_byte (port, hi_txopos)) & 0xff);
1394 }
1395
1396
1397 static void sx_shutdown_port (void * ptr)
1398 {
1399 struct sx_port *port = ptr;
1400
1401 func_enter();
1402
1403 port->gs.flags &= ~ GS_ACTIVE;
1404 if (port->gs.tty && (port->gs.tty->termios->c_cflag & HUPCL)) {
1405 sx_setsignals (port, 0, 0);
1406 sx_reconfigure_port(port);
1407 }
1408
1409 func_exit();
1410 }
1411
1412
1413
1414
1415
1416 /* ********************************************************************** *
1417 * Here are the routines that actually *
1418 * interface with the rest of the system *
1419 * ********************************************************************** */
1420
1421 static int sx_open (struct tty_struct * tty, struct file * filp)
1422 {
1423 struct sx_port *port;
1424 int retval, line;
1425 unsigned long flags;
1426
1427 func_enter();
1428
1429 if (!sx_initialized) {
1430 return -EIO;
1431 }
1432
1433 line = tty->index;
1434 sx_dprintk (SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, np=%d)\n",
1435 current->pid, line, tty, current->signal->tty, sx_nports);
1436
1437 if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1438 return -ENODEV;
1439
1440 port = & sx_ports[line];
1441 port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
1442 1 -> 0 transition. */
1443
1444
1445 sx_dprintk (SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
1446
1447 spin_lock_irqsave(&port->gs.driver_lock, flags);
1448
1449 tty->driver_data = port;
1450 port->gs.tty = tty;
1451 port->gs.count++;
1452 spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1453
1454 sx_dprintk (SX_DEBUG_OPEN, "starting port\n");
1455
1456 /*
1457 * Start up serial port
1458 */
1459 retval = gs_init_port(&port->gs);
1460 sx_dprintk (SX_DEBUG_OPEN, "done gs_init\n");
1461 if (retval) {
1462 port->gs.count--;
1463 return retval;
1464 }
1465
1466 port->gs.flags |= GS_ACTIVE;
1467 if (port->gs.count <= 1)
1468 sx_setsignals (port, 1,1);
1469
1470 #if 0
1471 if (sx_debug & SX_DEBUG_OPEN)
1472 my_hd (port, sizeof (*port));
1473 #else
1474 if (sx_debug & SX_DEBUG_OPEN)
1475 my_hd_io (port->board->base + port->ch_base, sizeof (*port));
1476 #endif
1477
1478 if (port->gs.count <= 1) {
1479 if (sx_send_command (port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1480 printk (KERN_ERR "sx: Card didn't respond to LOPEN command.\n");
1481 spin_lock_irqsave(&port->gs.driver_lock, flags);
1482 port->gs.count--;
1483 spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1484 return -EIO;
1485 }
1486 }
1487
1488 retval = gs_block_til_ready(port, filp);
1489 sx_dprintk (SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
1490 retval, port->gs.count);
1491
1492 if (retval) {
1493 /*
1494 * Don't lower gs.count here because sx_close() will be called later
1495 */
1496
1497 return retval;
1498 }
1499 /* tty->low_latency = 1; */
1500
1501 port->c_dcd = sx_get_CD (port);
1502 sx_dprintk (SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
1503
1504 func_exit();
1505 return 0;
1506
1507 }
1508
1509
1510 static void sx_close (void *ptr)
1511 {
1512 struct sx_port *port = ptr;
1513 /* Give the port 5 seconds to close down. */
1514 int to = 5 * HZ;
1515
1516 func_enter ();
1517
1518 sx_setsignals (port, 0, 0);
1519 sx_reconfigure_port(port);
1520 sx_send_command (port, HS_CLOSE, 0, 0);
1521
1522 while (to-- && (sx_read_channel_byte (port, hi_hstat) != HS_IDLE_CLOSED))
1523 if (msleep_interruptible(10))
1524 break;
1525 if (sx_read_channel_byte (port, hi_hstat) != HS_IDLE_CLOSED) {
1526 if (sx_send_command (port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED) != 1) {
1527 printk (KERN_ERR
1528 "sx: sent the force_close command, but card didn't react\n");
1529 } else
1530 sx_dprintk (SX_DEBUG_CLOSE, "sent the force_close command.\n");
1531 }
1532
1533 sx_dprintk (SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
1534 5 * HZ - to - 1, port->gs.count);
1535
1536 if(port->gs.count) {
1537 sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n", port->gs.count);
1538 //printk ("%s SETTING port count to zero: %p count: %d\n", __FUNCTION__, port, port->gs.count);
1539 //port->gs.count = 0;
1540 }
1541
1542 func_exit ();
1543 }
1544
1545
1546
1547 /* This is relatively thorough. But then again it is only 20 lines. */
1548 #define MARCHUP for (i=min;i<max;i++)
1549 #define MARCHDOWN for (i=max-1;i>=min;i--)
1550 #define W0 write_sx_byte (board, i, 0x55)
1551 #define W1 write_sx_byte (board, i, 0xaa)
1552 #define R0 if (read_sx_byte (board, i) != 0x55) return 1
1553 #define R1 if (read_sx_byte (board, i) != 0xaa) return 1
1554
1555 /* This memtest takes a human-noticable time. You normally only do it
1556 once a boot, so I guess that it is worth it. */
1557 static int do_memtest (struct sx_board *board, int min, int max)
1558 {
1559 int i;
1560
1561 /* This is a marchb. Theoretically, marchb catches much more than
1562 simpler tests. In practise, the longer test just catches more
1563 intermittent errors. -- REW
1564 (For the theory behind memory testing see:
1565 Testing Semiconductor Memories by A.J. van de Goor.) */
1566 MARCHUP {W0;}
1567 MARCHUP {R0;W1;R1;W0;R0;W1;}
1568 MARCHUP {R1;W0;W1;}
1569 MARCHDOWN {R1;W0;W1;W0;}
1570 MARCHDOWN {R0;W1;W0;}
1571
1572 return 0;
1573 }
1574
1575
1576 #undef MARCHUP
1577 #undef MARCHDOWN
1578 #undef W0
1579 #undef W1
1580 #undef R0
1581 #undef R1
1582
1583 #define MARCHUP for (i=min;i<max;i+=2)
1584 #define MARCHDOWN for (i=max-1;i>=min;i-=2)
1585 #define W0 write_sx_word (board, i, 0x55aa)
1586 #define W1 write_sx_word (board, i, 0xaa55)
1587 #define R0 if (read_sx_word (board, i) != 0x55aa) return 1
1588 #define R1 if (read_sx_word (board, i) != 0xaa55) return 1
1589
1590 #if 0
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_w (struct sx_board *board, int min, int max)
1594 {
1595 int i;
1596
1597 MARCHUP {W0;}
1598 MARCHUP {R0;W1;R1;W0;R0;W1;}
1599 MARCHUP {R1;W0;W1;}
1600 MARCHDOWN {R1;W0;W1;W0;}
1601 MARCHDOWN {R0;W1;W0;}
1602
1603 return 0;
1604 }
1605 #endif
1606
1607
1608 static int sx_fw_ioctl (struct inode *inode, struct file *filp,
1609 unsigned int cmd, unsigned long arg)
1610 {
1611 int rc = 0;
1612 int __user *descr = (int __user *)arg;
1613 int i;
1614 static struct sx_board *board = NULL;
1615 int nbytes, offset;
1616 unsigned long data;
1617 char *tmp;
1618
1619 func_enter();
1620
1621 #if 0
1622 /* Removed superuser check: Sysops can use the permissions on the device
1623 file to restrict access. Recommendation: Root only. (root.root 600) */
1624 if (!capable(CAP_SYS_ADMIN)) {
1625 return -EPERM;
1626 }
1627 #endif
1628
1629 sx_dprintk (SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
1630
1631 if (!board) board = &boards[0];
1632 if (board->flags & SX_BOARD_PRESENT) {
1633 sx_dprintk (SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1634 board->flags);
1635 } else {
1636 sx_dprintk (SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
1637 board->flags);
1638 for (i=0;i< SX_NBOARDS;i++)
1639 sx_dprintk (SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
1640 sx_dprintk (SX_DEBUG_FIRMWARE, "\n");
1641 return -EIO;
1642 }
1643
1644 switch (cmd) {
1645 case SXIO_SET_BOARD:
1646 sx_dprintk (SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
1647 if (arg >= SX_NBOARDS) return -EIO;
1648 sx_dprintk (SX_DEBUG_FIRMWARE, "not out of range\n");
1649 if (!(boards[arg].flags & SX_BOARD_PRESENT)) return -EIO;
1650 sx_dprintk (SX_DEBUG_FIRMWARE, ".. and present!\n");
1651 board = &boards[arg];
1652 break;
1653 case SXIO_GET_TYPE:
1654 rc = -ENOENT; /* If we manage to miss one, return error. */
1655 if (IS_SX_BOARD (board)) rc = SX_TYPE_SX;
1656 if (IS_CF_BOARD (board)) rc = SX_TYPE_CF;
1657 if (IS_SI_BOARD (board)) rc = SX_TYPE_SI;
1658 if (IS_SI1_BOARD (board)) rc = SX_TYPE_SI;
1659 if (IS_EISA_BOARD (board)) rc = SX_TYPE_SI;
1660 sx_dprintk (SX_DEBUG_FIRMWARE, "returning type= %d\n", rc);
1661 break;
1662 case SXIO_DO_RAMTEST:
1663 if (sx_initialized) /* Already initialized: better not ramtest the board. */
1664 return -EPERM;
1665 if (IS_SX_BOARD (board)) {
1666 rc = do_memtest (board, 0, 0x7000);
1667 if (!rc) rc = do_memtest (board, 0, 0x7000);
1668 /*if (!rc) rc = do_memtest_w (board, 0, 0x7000);*/
1669 } else {
1670 rc = do_memtest (board, 0, 0x7ff8);
1671 /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
1672 }
1673 sx_dprintk (SX_DEBUG_FIRMWARE, "returning memtest result= %d\n", rc);
1674 break;
1675 case SXIO_DOWNLOAD:
1676 if (sx_initialized) /* Already initialized */
1677 return -EEXIST;
1678 if (!sx_reset (board))
1679 return -EIO;
1680 sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
1681
1682 tmp = kmalloc (SX_CHUNK_SIZE, GFP_USER);
1683 if (!tmp) return -ENOMEM;
1684 get_user (nbytes, descr++);
1685 get_user (offset, descr++);
1686 get_user (data, descr++);
1687 while (nbytes && data) {
1688 for (i=0;i<nbytes;i += SX_CHUNK_SIZE) {
1689 if (copy_from_user(tmp, (char __user *)data+i,
1690 (i + SX_CHUNK_SIZE >
1691 nbytes) ? nbytes - i :
1692 SX_CHUNK_SIZE)) {
1693 kfree (tmp);
1694 return -EFAULT;
1695 }
1696 memcpy_toio(board->base2 + offset + i, tmp,
1697 (i+SX_CHUNK_SIZE>nbytes)?nbytes-i:SX_CHUNK_SIZE);
1698 }
1699
1700 get_user (nbytes, descr++);
1701 get_user (offset, descr++);
1702 get_user (data, descr++);
1703 }
1704 kfree (tmp);
1705 sx_nports += sx_init_board (board);
1706 rc = sx_nports;
1707 break;
1708 case SXIO_INIT:
1709 if (sx_initialized) /* Already initialized */
1710 return -EEXIST;
1711 /* This is not allowed until all boards are initialized... */
1712 for (i=0;i<SX_NBOARDS;i++) {
1713 if ( (boards[i].flags & SX_BOARD_PRESENT) &&
1714 !(boards[i].flags & SX_BOARD_INITIALIZED))
1715 return -EIO;
1716 }
1717 for (i=0;i<SX_NBOARDS;i++)
1718 if (!(boards[i].flags & SX_BOARD_PRESENT)) break;
1719
1720 sx_dprintk (SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
1721 "%d channels, first board: %d ports\n",
1722 i, sx_nports, boards[0].nports);
1723 rc = sx_init_portstructs (i, sx_nports);
1724 sx_init_drivers ();
1725 if (rc >= 0)
1726 sx_initialized++;
1727 break;
1728 case SXIO_SETDEBUG:
1729 sx_debug = arg;
1730 break;
1731 case SXIO_GETDEBUG:
1732 rc = sx_debug;
1733 break;
1734 case SXIO_GETGSDEBUG:
1735 case SXIO_SETGSDEBUG:
1736 rc = -EINVAL;
1737 break;
1738 case SXIO_GETNPORTS:
1739 rc = sx_nports;
1740 break;
1741 default:
1742 printk (KERN_WARNING "Unknown ioctl on firmware device (%x).\n", cmd);
1743 break;
1744 }
1745 func_exit ();
1746 return rc;
1747 }
1748
1749
1750 static void sx_break (struct tty_struct * tty, int flag)
1751 {
1752 struct sx_port *port = tty->driver_data;
1753 int rv;
1754
1755 func_enter ();
1756
1757 if (flag)
1758 rv = sx_send_command (port, HS_START, -1, HS_IDLE_BREAK);
1759 else
1760 rv = sx_send_command (port, HS_STOP, -1, HS_IDLE_OPEN);
1761 if (rv != 1) printk (KERN_ERR "sx: couldn't send break (%x).\n",
1762 read_sx_byte (port->board, CHAN_OFFSET (port, hi_hstat)));
1763
1764 func_exit ();
1765 }
1766
1767
1768 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1769 {
1770 struct sx_port *port = tty->driver_data;
1771 return sx_getsignals(port);
1772 }
1773
1774 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1775 unsigned int set, unsigned int clear)
1776 {
1777 struct sx_port *port = tty->driver_data;
1778 int rts = -1, dtr = -1;
1779
1780 if (set & TIOCM_RTS)
1781 rts = 1;
1782 if (set & TIOCM_DTR)
1783 dtr = 1;
1784 if (clear & TIOCM_RTS)
1785 rts = 0;
1786 if (clear & TIOCM_DTR)
1787 dtr = 0;
1788
1789 sx_setsignals(port, dtr, rts);
1790 sx_reconfigure_port(port);
1791 return 0;
1792 }
1793
1794 static int sx_ioctl (struct tty_struct * tty, struct file * filp,
1795 unsigned int cmd, unsigned long arg)
1796 {
1797 int rc;
1798 struct sx_port *port = tty->driver_data;
1799 void __user *argp = (void __user *)arg;
1800 int ival;
1801
1802 /* func_enter2(); */
1803
1804 rc = 0;
1805 switch (cmd) {
1806 case TIOCGSOFTCAR:
1807 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
1808 (unsigned __user *) argp);
1809 break;
1810 case TIOCSSOFTCAR:
1811 if ((rc = get_user(ival, (unsigned __user *) argp)) == 0) {
1812 tty->termios->c_cflag =
1813 (tty->termios->c_cflag & ~CLOCAL) |
1814 (ival ? CLOCAL : 0);
1815 }
1816 break;
1817 case TIOCGSERIAL:
1818 rc = gs_getserial(&port->gs, argp);
1819 break;
1820 case TIOCSSERIAL:
1821 rc = gs_setserial(&port->gs, argp);
1822 break;
1823 default:
1824 rc = -ENOIOCTLCMD;
1825 break;
1826 }
1827
1828 /* func_exit(); */
1829 return rc;
1830 }
1831
1832
1833 /* The throttle/unthrottle scheme for the Specialix card is different
1834 * from other drivers and deserves some explanation.
1835 * The Specialix hardware takes care of XON/XOFF
1836 * and CTS/RTS flow control itself. This means that all we have to
1837 * do when signalled by the upper tty layer to throttle/unthrottle is
1838 * to make a note of it here. When we come to read characters from the
1839 * rx buffers on the card (sx_receive_chars()) we look to see if the
1840 * upper layer can accept more (as noted here in sx_rx_throt[]).
1841 * If it can't we simply don't remove chars from the cards buffer.
1842 * When the tty layer can accept chars, we again note that here and when
1843 * sx_receive_chars() is called it will remove them from the cards buffer.
1844 * The card will notice that a ports buffer has drained below some low
1845 * water mark and will unflow control the line itself, using whatever
1846 * flow control scheme is in use for that port. -- Simon Allen
1847 */
1848
1849 static void sx_throttle (struct tty_struct * tty)
1850 {
1851 struct sx_port *port = (struct sx_port *)tty->driver_data;
1852
1853 func_enter2();
1854 /* If the port is using any type of input flow
1855 * control then throttle the port.
1856 */
1857 if((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty)) ) {
1858 port->gs.flags |= SX_RX_THROTTLE;
1859 }
1860 func_exit();
1861 }
1862
1863
1864 static void sx_unthrottle (struct tty_struct * tty)
1865 {
1866 struct sx_port *port = (struct sx_port *)tty->driver_data;
1867
1868 func_enter2();
1869 /* Always unthrottle even if flow control is not enabled on
1870 * this port in case we disabled flow control while the port
1871 * was throttled
1872 */
1873 port->gs.flags &= ~SX_RX_THROTTLE;
1874 func_exit();
1875 return;
1876 }
1877
1878
1879 /* ********************************************************************** *
1880 * Here are the initialization routines. *
1881 * ********************************************************************** */
1882
1883
1884
1885
1886 static int sx_init_board (struct sx_board *board)
1887 {
1888 int addr;
1889 int chans;
1890 int type;
1891
1892 func_enter();
1893
1894 /* This is preceded by downloading the download code. */
1895
1896 board->flags |= SX_BOARD_INITIALIZED;
1897
1898 if (read_sx_byte (board, 0))
1899 /* CF boards may need this. */
1900 write_sx_byte(board,0, 0);
1901
1902 /* This resets the processor again, to make sure it didn't do any
1903 foolish things while we were downloading the image */
1904 if (!sx_reset (board))
1905 return 0;
1906
1907 sx_start_board (board);
1908 udelay (10);
1909 if (!sx_busy_wait_neq (board, 0, 0xff, 0)) {
1910 printk (KERN_ERR "sx: Ooops. Board won't initialize.\n");
1911 return 0;
1912 }
1913
1914 /* Ok. So now the processor on the card is running. It gathered
1915 some info for us... */
1916 sx_dprintk (SX_DEBUG_INIT, "The sxcard structure:\n");
1917 if (sx_debug & SX_DEBUG_INIT) my_hd_io (board->base, 0x10);
1918 sx_dprintk (SX_DEBUG_INIT, "the first sx_module structure:\n");
1919 if (sx_debug & SX_DEBUG_INIT) my_hd_io (board->base + 0x80, 0x30);
1920
1921 sx_dprintk (SX_DEBUG_INIT,
1922 "init_status: %x, %dk memory, firmware V%x.%02x,\n",
1923 read_sx_byte (board, 0), read_sx_byte(board, 1),
1924 read_sx_byte (board, 5), read_sx_byte(board, 4));
1925
1926 if (read_sx_byte (board, 0) == 0xff) {
1927 printk (KERN_INFO "sx: No modules found. Sorry.\n");
1928 board->nports = 0;
1929 return 0;
1930 }
1931
1932 chans = 0;
1933
1934 if (IS_SX_BOARD(board)) {
1935 sx_write_board_word (board, cc_int_count, sx_maxints);
1936 } else {
1937 if (sx_maxints)
1938 sx_write_board_word (board, cc_int_count, SI_PROCESSOR_CLOCK/8/sx_maxints);
1939 }
1940
1941 /* grab the first module type... */
1942 /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
1943 board->ta_type = mod_compat_type (sx_read_module_byte (board, 0x80, mc_chip));
1944
1945 /* XXX byteorder */
1946 for (addr = 0x80;addr != 0;addr = read_sx_word (board, addr) & 0x7fff) {
1947 type = sx_read_module_byte (board, addr, mc_chip);
1948 sx_dprintk (SX_DEBUG_INIT, "Module at %x: %d channels\n",
1949 addr, read_sx_byte (board, addr + 2));
1950
1951 chans += sx_read_module_byte (board, addr, mc_type);
1952
1953 sx_dprintk (SX_DEBUG_INIT, "module is an %s, which has %s/%s panels\n",
1954 mod_type_s (type),
1955 pan_type_s (sx_read_module_byte (board, addr, mc_mods) & 0xf),
1956 pan_type_s (sx_read_module_byte (board, addr, mc_mods) >> 4));
1957
1958 sx_dprintk (SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC version: %x\n",
1959 sx_read_module_byte (board, addr, mc_rev1),
1960 sx_read_module_byte (board, addr, mc_rev2),
1961 sx_read_module_byte (board, addr, mc_mtaasic_rev));
1962
1963 /* The following combinations are illegal: It should theoretically
1964 work, but timing problems make the bus HANG. */
1965
1966 if (mod_compat_type (type) != board->ta_type) {
1967 printk (KERN_ERR "sx: This is an invalid configuration.\n"
1968 "Don't mix TA/MTA/SXDC on the same hostadapter.\n");
1969 chans=0;
1970 break;
1971 }
1972 if ((IS_EISA_BOARD(board) ||
1973 IS_SI_BOARD(board)) && (mod_compat_type(type) == 4)) {
1974 printk (KERN_ERR "sx: This is an invalid configuration.\n"
1975 "Don't use SXDCs on an SI/XIO adapter.\n");
1976 chans=0;
1977 break;
1978 }
1979 #if 0 /* Problem fixed: firmware 3.05 */
1980 if (IS_SX_BOARD(board) && (type == TA8)) {
1981 /* There are some issues with the firmware and the DCD/RTS
1982 lines. It might work if you tie them together or something.
1983 It might also work if you get a newer sx_firmware. Therefore
1984 this is just a warning. */
1985 printk (KERN_WARNING "sx: The SX host doesn't work too well "
1986 "with the TA8 adapters.\nSpecialix is working on it.\n");
1987 }
1988 #endif
1989 }
1990
1991 if (chans) {
1992 /* board->flags |= SX_BOARD_PRESENT; */
1993 if(board->irq > 0) {
1994 /* fixed irq, probably PCI */
1995 if(sx_irqmask & (1 << board->irq)) { /* may we use this irq? */
1996 if(request_irq(board->irq, sx_interrupt, IRQF_SHARED | IRQF_DISABLED, "sx", board)) {
1997 printk(KERN_ERR "sx: Cannot allocate irq %d.\n", board->irq);
1998 board->irq = 0;
1999 }
2000 } else
2001 board->irq = 0;
2002 } else if(board->irq < 0 && sx_irqmask) {
2003 /* auto-allocate irq */
2004 int irqnr;
2005 int irqmask = sx_irqmask & (IS_SX_BOARD(board) ? SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
2006 for(irqnr = 15; irqnr > 0; irqnr--)
2007 if(irqmask & (1 << irqnr))
2008 if(! request_irq(irqnr, sx_interrupt, IRQF_SHARED | IRQF_DISABLED, "sx", board))
2009 break;
2010 if(! irqnr)
2011 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2012 board->irq = irqnr;
2013 } else
2014 board->irq = 0;
2015
2016 if (board->irq) {
2017 /* Found a valid interrupt, start up interrupts! */
2018 sx_dprintk (SX_DEBUG_INIT, "Using irq %d.\n", board->irq);
2019 sx_start_interrupts (board);
2020 board->poll = sx_slowpoll;
2021 board->flags |= SX_IRQ_ALLOCATED;
2022 } else {
2023 /* no irq: setup board for polled operation */
2024 board->poll = sx_poll;
2025 sx_dprintk (SX_DEBUG_INIT, "Using poll-interval %d.\n", board->poll);
2026 }
2027
2028 /* The timer should be initialized anyway: That way we can safely
2029 del_timer it when the module is unloaded. */
2030 init_timer (&board->timer);
2031
2032 if (board->poll) {
2033 board->timer.data = (unsigned long) board;
2034 board->timer.function = sx_pollfunc;
2035 board->timer.expires = jiffies + board->poll;
2036 add_timer (&board->timer);
2037 }
2038 } else {
2039 board->irq = 0;
2040 }
2041
2042 board->nports = chans;
2043 sx_dprintk (SX_DEBUG_INIT, "returning %d ports.", board->nports);
2044
2045 func_exit();
2046 return chans;
2047 }
2048
2049
2050 static void printheader(void)
2051 {
2052 static int header_printed;
2053
2054 if (!header_printed) {
2055 printk (KERN_INFO "Specialix SX driver "
2056 "(C) 1998/1999 R.E.Wolff@BitWizard.nl \n");
2057 printk (KERN_INFO "sx: version %s\n", RCS_ID);
2058 header_printed = 1;
2059 }
2060 }
2061
2062
2063 static int probe_sx (struct sx_board *board)
2064 {
2065 struct vpd_prom vpdp;
2066 char *p;
2067 int i;
2068
2069 func_enter();
2070
2071 if (!IS_CF_BOARD (board)) {
2072 sx_dprintk (SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2073 board->base + SX_VPD_ROM);
2074
2075 if (sx_debug & SX_DEBUG_PROBE)
2076 my_hd_io(board->base + SX_VPD_ROM, 0x40);
2077
2078 p = (char *) &vpdp;
2079 for (i=0;i< sizeof (struct vpd_prom);i++)
2080 *p++ = read_sx_byte (board, SX_VPD_ROM + i*2);
2081
2082 if (sx_debug & SX_DEBUG_PROBE)
2083 my_hd (&vpdp, 0x20);
2084
2085 sx_dprintk (SX_DEBUG_PROBE, "checking identifier...\n");
2086
2087 if (strncmp (vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2088 sx_dprintk (SX_DEBUG_PROBE, "Got non-SX identifier: '%s'\n",
2089 vpdp.identifier);
2090 return 0;
2091 }
2092 }
2093
2094 printheader ();
2095
2096 if (!IS_CF_BOARD (board)) {
2097 printk (KERN_DEBUG "sx: Found an SX board at %lx\n", board->hw_base);
2098 printk (KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, uniq ID:%08x, ",
2099 vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2100 printk ( "Manufactured: %d/%d\n",
2101 1970 + vpdp.myear, vpdp.mweek);
2102
2103
2104 if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) != SX_PCI_UNIQUEID1) &&
2105 (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2106 /* This might be a bit harsh. This was the primary reason the
2107 SX/ISA card didn't work at first... */
2108 printk (KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA card. Sorry: giving up.\n");
2109 return (0);
2110 }
2111
2112 if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) == SX_ISA_UNIQUEID1) {
2113 if (((unsigned long)board->hw_base) & 0x8000) {
2114 printk (KERN_WARNING "sx: Warning: There may be hardware problems with the card at %lx.\n", board->hw_base);
2115 printk (KERN_WARNING "sx: Read sx.txt for more info.\n");
2116 }
2117 }
2118 }
2119
2120 board->nports = -1;
2121
2122 /* This resets the processor, and keeps it off the bus. */
2123 if (!sx_reset (board))
2124 return 0;
2125 sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
2126
2127 board->flags |= SX_BOARD_PRESENT;
2128
2129 func_exit();
2130 return 1;
2131 }
2132
2133
2134
2135 /* Specialix probes for this card at 32k increments from 640k to 16M.
2136 I consider machines with less than 16M unlikely nowadays, so I'm
2137 not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2138 card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves
2139 0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2140
2141 static int probe_si (struct sx_board *board)
2142 {
2143 int i;
2144
2145 func_enter();
2146 sx_dprintk (SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at %p.\n", board->hw_base,
2147 board->base + SI2_ISA_ID_BASE);
2148
2149 if (sx_debug & SX_DEBUG_PROBE)
2150 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2151
2152 if (!IS_EISA_BOARD(board)) {
2153 if( IS_SI1_BOARD(board) )
2154 {
2155 for (i=0;i<8;i++) {
2156 write_sx_byte (board, SI2_ISA_ID_BASE+7-i,i);
2157
2158 }
2159 }
2160 for (i=0;i<8;i++) {
2161 if ((read_sx_byte (board, SI2_ISA_ID_BASE+7-i) & 7) != i) {
2162 func_exit ();
2163 return 0;
2164 }
2165 }
2166 }
2167
2168 /* Now we're pretty much convinced that there is an SI board here,
2169 but to prevent trouble, we'd better double check that we don't
2170 have an SI1 board when we're probing for an SI2 board.... */
2171
2172 write_sx_byte (board, SI2_ISA_ID_BASE,0x10);
2173 if ( IS_SI1_BOARD(board)) {
2174 /* This should be an SI1 board, which has this
2175 location writable... */
2176 if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
2177 func_exit ();
2178 return 0;
2179 }
2180 } else {
2181 /* This should be an SI2 board, which has the bottom
2182 3 bits non-writable... */
2183 if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
2184 func_exit ();
2185 return 0;
2186 }
2187 }
2188
2189 /* Now we're pretty much convinced that there is an SI board here,
2190 but to prevent trouble, we'd better double check that we don't
2191 have an SI1 board when we're probing for an SI2 board.... */
2192
2193 write_sx_byte (board, SI2_ISA_ID_BASE,0x10);
2194 if ( IS_SI1_BOARD(board)) {
2195 /* This should be an SI1 board, which has this
2196 location writable... */
2197 if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
2198 func_exit();
2199 return 0;
2200 }
2201 } else {
2202 /* This should be an SI2 board, which has the bottom
2203 3 bits non-writable... */
2204 if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
2205 func_exit ();
2206 return 0;
2207 }
2208 }
2209
2210 printheader ();
2211
2212 printk (KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
2213 /* Compared to the SX boards, it is a complete guess as to what
2214 this card is up to... */
2215
2216 board->nports = -1;
2217
2218 /* This resets the processor, and keeps it off the bus. */
2219 if (!sx_reset (board))
2220 return 0;
2221 sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
2222
2223 board->flags |= SX_BOARD_PRESENT;
2224
2225 func_exit();
2226 return 1;
2227 }
2228
2229 static struct tty_operations sx_ops = {
2230 .break_ctl = sx_break,
2231 .open = sx_open,
2232 .close = gs_close,
2233 .write = gs_write,
2234 .put_char = gs_put_char,
2235 .flush_chars = gs_flush_chars,
2236 .write_room = gs_write_room,
2237 .chars_in_buffer = gs_chars_in_buffer,
2238 .flush_buffer = gs_flush_buffer,
2239 .ioctl = sx_ioctl,
2240 .throttle = sx_throttle,
2241 .unthrottle = sx_unthrottle,
2242 .set_termios = gs_set_termios,
2243 .stop = gs_stop,
2244 .start = gs_start,
2245 .hangup = gs_hangup,
2246 .tiocmget = sx_tiocmget,
2247 .tiocmset = sx_tiocmset,
2248 };
2249
2250 static int sx_init_drivers(void)
2251 {
2252 int error;
2253
2254 func_enter();
2255
2256 sx_driver = alloc_tty_driver(sx_nports);
2257 if (!sx_driver)
2258 return 1;
2259 sx_driver->owner = THIS_MODULE;
2260 sx_driver->driver_name = "specialix_sx";
2261 sx_driver->name = "ttyX";
2262 sx_driver->major = SX_NORMAL_MAJOR;
2263 sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2264 sx_driver->subtype = SERIAL_TYPE_NORMAL;
2265 sx_driver->init_termios = tty_std_termios;
2266 sx_driver->init_termios.c_cflag =
2267 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2268 sx_driver->flags = TTY_DRIVER_REAL_RAW;
2269 tty_set_operations(sx_driver, &sx_ops);
2270
2271 if ((error = tty_register_driver(sx_driver))) {
2272 put_tty_driver(sx_driver);
2273 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
2274 error);
2275 return 1;
2276 }
2277 func_exit();
2278 return 0;
2279 }
2280
2281
2282 static void * ckmalloc (int size)
2283 {
2284 void *p;
2285
2286 p = kmalloc(size, GFP_KERNEL);
2287 if (p)
2288 memset(p, 0, size);
2289 return p;
2290 }
2291
2292
2293 static int sx_init_portstructs (int nboards, int nports)
2294 {
2295 struct sx_board *board;
2296 struct sx_port *port;
2297 int i, j;
2298 int addr, chans;
2299 int portno;
2300
2301 func_enter();
2302
2303 /* Many drivers statically allocate the maximum number of ports
2304 There is no reason not to allocate them dynamically. Is there? -- REW */
2305 sx_ports = ckmalloc(nports * sizeof (struct sx_port));
2306 if (!sx_ports)
2307 return -ENOMEM;
2308
2309 port = sx_ports;
2310 for (i = 0; i < nboards; i++) {
2311 board = &boards[i];
2312 board->ports = port;
2313 for (j=0; j < boards[i].nports;j++) {
2314 sx_dprintk (SX_DEBUG_INIT, "initing port %d\n", j);
2315 port->gs.magic = SX_MAGIC;
2316 port->gs.close_delay = HZ/2;
2317 port->gs.closing_wait = 30 * HZ;
2318 port->board = board;
2319 port->gs.rd = &sx_real_driver;
2320 #ifdef NEW_WRITE_LOCKING
2321 port->gs.port_write_mutex = MUTEX;
2322 #endif
2323 spin_lock_init(&port->gs.driver_lock);
2324 /*
2325 * Initializing wait queue
2326 */
2327 init_waitqueue_head(&port->gs.open_wait);
2328 init_waitqueue_head(&port->gs.close_wait);
2329
2330 port++;
2331 }
2332 }
2333
2334 port = sx_ports;
2335 portno = 0;
2336 for (i = 0; i < nboards; i++) {
2337 board = &boards[i];
2338 board->port_base = portno;
2339 /* Possibly the configuration was rejected. */
2340 sx_dprintk (SX_DEBUG_PROBE, "Board has %d channels\n", board->nports);
2341 if (board->nports <= 0) continue;
2342 /* XXX byteorder ?? */
2343 for (addr = 0x80;addr != 0;addr = read_sx_word (board, addr) & 0x7fff) {
2344 chans = sx_read_module_byte (board, addr, mc_type);
2345 sx_dprintk (SX_DEBUG_PROBE, "Module at %x: %d channels\n", addr, chans);
2346 sx_dprintk (SX_DEBUG_PROBE, "Port at");
2347 for (j=0;j<chans;j++) {
2348 /* The "sx-way" is the way it SHOULD be done. That way in the
2349 future, the firmware may for example pack the structures a bit
2350 more efficient. Neil tells me it isn't going to happen anytime
2351 soon though. */
2352 if (IS_SX_BOARD(board))
2353 port->ch_base = sx_read_module_word (board, addr+j*2, mc_chan_pointer);
2354 else
2355 port->ch_base = addr + 0x100 + 0x300*j;
2356
2357 sx_dprintk (SX_DEBUG_PROBE, " %x", port->ch_base);
2358 port->line = portno++;
2359 port++;
2360 }
2361 sx_dprintk (SX_DEBUG_PROBE, "\n");
2362 }
2363 /* This has to be done earlier. */
2364 /* board->flags |= SX_BOARD_INITIALIZED; */
2365 }
2366
2367 func_exit();
2368 return 0;
2369 }
2370
2371 static void __exit sx_release_drivers(void)
2372 {
2373 func_enter();
2374 tty_unregister_driver(sx_driver);
2375 put_tty_driver(sx_driver);
2376 func_exit();
2377 }
2378
2379 #ifdef CONFIG_PCI
2380 /********************************************************
2381 * Setting bit 17 in the CNTRL register of the PLX 9050 *
2382 * chip forces a retry on writes while a read is pending.*
2383 * This is to prevent the card locking up on Intel Xeon *
2384 * multiprocessor systems with the NX chipset. -- NV *
2385 ********************************************************/
2386
2387 /* Newer cards are produced with this bit set from the configuration
2388 EEprom. As the bit is read/write for the CPU, we can fix it here,
2389 if we detect that it isn't set correctly. -- REW */
2390
2391 static void fix_sx_pci (struct pci_dev *pdev, struct sx_board *board)
2392 {
2393 unsigned int hwbase;
2394 void __iomem *rebase;
2395 unsigned int t;
2396
2397 #define CNTRL_REG_OFFSET 0x50
2398 #define CNTRL_REG_GOODVALUE 0x18260000
2399
2400 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2401 hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2402 rebase = ioremap(hwbase, 0x80);
2403 t = readl (rebase + CNTRL_REG_OFFSET);
2404 if (t != CNTRL_REG_GOODVALUE) {
2405 printk (KERN_DEBUG "sx: performing cntrl reg fix: %08x -> %08x\n", t, CNTRL_REG_GOODVALUE);
2406 writel (CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
2407 }
2408 iounmap(rebase);
2409 }
2410 #endif
2411
2412
2413 static int __init sx_init(void)
2414 {
2415 int i;
2416 int found = 0;
2417 int eisa_slot;
2418 struct sx_board *board;
2419
2420 #ifdef CONFIG_PCI
2421 struct pci_dev *pdev = NULL;
2422 unsigned int tint;
2423 unsigned short tshort;
2424 #endif
2425
2426 func_enter();
2427 sx_dprintk (SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n", sx_debug);
2428 if (abs ((long) (&sx_debug) - sx_debug) < 0x10000) {
2429 printk (KERN_WARNING "sx: sx_debug is an address, instead of a value. "
2430 "Assuming -1.\n");
2431 printk ("(%p)\n", &sx_debug);
2432 sx_debug=-1;
2433 }
2434
2435 if (misc_register(&sx_fw_device) < 0) {
2436 printk(KERN_ERR "SX: Unable to register firmware loader driver.\n");
2437 return -EIO;
2438 }
2439
2440 #ifdef CONFIG_PCI
2441 while ((pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
2442 PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2443 pdev))) {
2444 if (pci_enable_device(pdev))
2445 continue;
2446
2447 /* Specialix has a whole bunch of cards with
2448 0x2000 as the device ID. They say its because
2449 the standard requires it. Stupid standard. */
2450 /* It seems that reading a word doesn't work reliably on 2.0.
2451 Also, reading a non-aligned dword doesn't work. So we read the
2452 whole dword at 0x2c and extract the word at 0x2e (SUBSYSTEM_ID)
2453 ourselves */
2454 /* I don't know why the define doesn't work, constant 0x2c does --REW */
2455 pci_read_config_dword (pdev, 0x2c, &tint);
2456 tshort = (tint >> 16) & 0xffff;
2457 sx_dprintk (SX_DEBUG_PROBE, "Got a specialix card: %x.\n", tint);
2458 /* sx_dprintk (SX_DEBUG_PROBE, "pdev = %d/%d (%x)\n", pdev, tint); */
2459 if ((tshort != 0x0200) && (tshort != 0x0300)) {
2460 sx_dprintk (SX_DEBUG_PROBE, "But it's not an SX card (%d)...\n",
2461 tshort);
2462 continue;
2463 }
2464 board = &boards[found];
2465
2466 board->flags &= ~SX_BOARD_TYPE;
2467 board->flags |= (tshort == 0x200)?SX_PCI_BOARD:
2468 SX_CFPCI_BOARD;
2469
2470 /* CF boards use base address 3.... */
2471 if (IS_CF_BOARD (board))
2472 board->hw_base = pci_resource_start (pdev, 3);
2473 else
2474 board->hw_base = pci_resource_start (pdev, 2);
2475 board->base2 =
2476 board->base = ioremap(board->hw_base, WINDOW_LEN (board));
2477 if (!board->base) {
2478 printk(KERN_ERR "ioremap failed\n");
2479 /* XXX handle error */
2480 }
2481
2482 /* Most of the stuff on the CF board is offset by
2483 0x18000 .... */
2484 if (IS_CF_BOARD (board)) board->base += 0x18000;
2485
2486 board->irq = pdev->irq;
2487
2488 sx_dprintk (SX_DEBUG_PROBE, "Got a specialix card: %x/%p(%d) %x.\n",
2489 tint, boards[found].base, board->irq, board->flags);
2490
2491 if (probe_sx (board)) {
2492 found++;
2493 fix_sx_pci (pdev, board);
2494 } else
2495 iounmap(board->base2);
2496 }
2497 #endif
2498
2499 for (i=0;i<NR_SX_ADDRS;i++) {
2500 board = &boards[found];
2501 board->hw_base = sx_probe_addrs[i];
2502 board->base2 =
2503 board->base = ioremap(board->hw_base, SX_WINDOW_LEN);
2504 board->flags &= ~SX_BOARD_TYPE;
2505 board->flags |= SX_ISA_BOARD;
2506 board->irq = sx_irqmask?-1:0;
2507
2508 if (probe_sx (board)) {
2509 found++;
2510 } else {
2511 iounmap(board->base);
2512 }
2513 }
2514
2515 for (i=0;i<NR_SI_ADDRS;i++) {
2516 board = &boards[found];
2517 board->hw_base = si_probe_addrs[i];
2518 board->base2 =
2519 board->base = ioremap(board->hw_base, SI2_ISA_WINDOW_LEN);
2520 board->flags &= ~SX_BOARD_TYPE;
2521 board->flags |= SI_ISA_BOARD;
2522 board->irq = sx_irqmask ?-1:0;
2523
2524 if (probe_si (board)) {
2525 found++;
2526 } else {
2527 iounmap (board->base);
2528 }
2529 }
2530 for (i=0;i<NR_SI1_ADDRS;i++) {
2531 board = &boards[found];
2532 board->hw_base = si1_probe_addrs[i];
2533 board->base2 =
2534 board->base = ioremap(board->hw_base, SI1_ISA_WINDOW_LEN);
2535 board->flags &= ~SX_BOARD_TYPE;
2536 board->flags |= SI1_ISA_BOARD;
2537 board->irq = sx_irqmask ?-1:0;
2538
2539 if (probe_si (board)) {
2540 found++;
2541 } else {
2542 iounmap (board->base);
2543 }
2544 }
2545
2546 sx_dprintk(SX_DEBUG_PROBE, "Probing for EISA cards\n");
2547 for(eisa_slot=0x1000; eisa_slot<0x10000; eisa_slot+=0x1000)
2548 {
2549 if((inb(eisa_slot+0xc80)==0x4d) &&
2550 (inb(eisa_slot+0xc81)==0x98))
2551 {
2552 sx_dprintk(SX_DEBUG_PROBE, "%s : Signature found in EISA slot %d, Product %d Rev %d\n",
2553 "XIO", (eisa_slot>>12), inb(eisa_slot+0xc82), inb(eisa_slot+0xc83));
2554
2555 board = &boards[found];
2556 board->eisa_base = eisa_slot;
2557 board->flags &= ~SX_BOARD_TYPE;
2558 board->flags |= SI_EISA_BOARD;
2559
2560 board->hw_base = (((inb(0xc01+eisa_slot) << 8) + inb(0xc00+eisa_slot)) << 16);
2561 board->base2 =
2562 board->base = ioremap(board->hw_base, SI2_EISA_WINDOW_LEN);
2563
2564 sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2565 sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2566 board->irq = inb(board->eisa_base+0xc02)>>4;
2567 sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2568
2569 probe_si(board);
2570
2571 found++;
2572 }
2573 }
2574 if (found) {
2575 printk (KERN_INFO "sx: total of %d boards detected.\n", found);
2576 } else {
2577 misc_deregister(&sx_fw_device);
2578 }
2579
2580 func_exit();
2581 return found?0:-EIO;
2582 }
2583
2584
2585 static void __exit sx_exit (void)
2586 {
2587 int i;
2588 struct sx_board *board;
2589
2590 func_enter();
2591 for (i = 0; i < SX_NBOARDS; i++) {
2592 board = &boards[i];
2593 if (board->flags & SX_BOARD_INITIALIZED) {
2594 sx_dprintk (SX_DEBUG_CLEANUP, "Cleaning up board at %p\n", board->base);
2595 /* The board should stop messing with us.
2596 (actually I mean the interrupt) */
2597 sx_reset (board);
2598 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2599 free_irq (board->irq, board);
2600
2601 /* It is safe/allowed to del_timer a non-active timer */
2602 del_timer (& board->timer);
2603 iounmap(board->base);
2604 }
2605 }
2606 if (misc_deregister(&sx_fw_device) < 0) {
2607 printk (KERN_INFO "sx: couldn't deregister firmware loader devic\n");
2608 }
2609 sx_dprintk (SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n", sx_initialized);
2610 if (sx_initialized)
2611 sx_release_drivers ();
2612
2613 kfree (sx_ports);
2614 func_exit();
2615 }
2616
2617 module_init(sx_init);
2618 module_exit(sx_exit);
2619
2620
Support for the Chinese Samsung S3C2440 based development boards