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