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