blob: a786326cea2f38163c343ff77997d2c2322c5e5b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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:
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 * 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
Jiri Slaby11c83872006-12-08 02:38:56 -0800200#define SX_VERSION 1.33
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203#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>
Jiri Slaby18f813e2006-12-08 02:39:01 -0800216#include <linux/eisa.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217#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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267#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
Jiri Slaby15b611f2006-12-08 02:39:04 -0800275#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
277/* Function prototypes */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800278static void sx_disable_tx_interrupts(void *ptr);
279static void sx_enable_tx_interrupts(void *ptr);
280static void sx_disable_rx_interrupts(void *ptr);
281static void sx_enable_rx_interrupts(void *ptr);
Alan Cox31f35932009-01-02 13:45:05 +0000282static int sx_carrier_raised(struct tty_port *port);
Jiri Slaby15b611f2006-12-08 02:39:04 -0800283static void sx_shutdown_port(void *ptr);
284static int sx_set_real_termios(void *ptr);
285static void sx_close(void *ptr);
286static int sx_chars_in_buffer(void *ptr);
287static int sx_init_board(struct sx_board *board);
288static int sx_init_portstructs(int nboards, int nports);
Alan Cox11af7472008-07-25 01:48:15 -0700289static long sx_fw_ioctl(struct file *filp, unsigned int cmd,
290 unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291static int sx_init_drivers(void);
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293static struct tty_driver *sx_driver;
294
Jiri Slaby42f63842006-12-08 02:39:03 -0800295static DEFINE_MUTEX(sx_boards_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296static struct sx_board boards[SX_NBOARDS];
297static struct sx_port *sx_ports;
298static int sx_initialized;
299static int sx_nports;
300static int sx_debug;
301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302/* 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 */
310static int sx_poll = 1;
311static 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
318static int sx_maxints = 100;
319
Jiri Slaby927a6f92006-12-08 02:39:02 -0800320#ifdef CONFIG_ISA
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322/* 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*/
Jiri Slaby15b611f2006-12-08 02:39:04 -0800326static int sx_probe_addrs[] = {
327 0xc0000, 0xd0000, 0xe0000,
328 0xc8000, 0xd8000, 0xe8000
329};
330static int si_probe_addrs[] = {
331 0xc0000, 0xd0000, 0xe0000,
332 0xc8000, 0xd8000, 0xe8000, 0xa0000
333};
334static int si1_probe_addrs[] = {
335 0xd0000
336};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Tobias Klauserfe971072006-01-09 20:54:02 -0800338#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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Jiri Slaby927a6f92006-12-08 02:39:02 -0800342module_param_array(sx_probe_addrs, int, NULL, 0);
343module_param_array(si_probe_addrs, int, NULL, 0);
344#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346/* Set the mask to all-ones. This alas, only supports 32 interrupts.
347 Some architectures may need more. */
348static int sx_irqmask = -1;
349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350module_param(sx_poll, int, 0);
351module_param(sx_slowpoll, int, 0);
352module_param(sx_maxints, int, 0);
353module_param(sx_debug, int, 0);
354module_param(sx_irqmask, int, 0);
355
356MODULE_LICENSE("GPL");
357
358static 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,
Jiri Slaby15b611f2006-12-08 02:39:04 -0800363 sx_shutdown_port,
364 sx_set_real_termios,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 sx_chars_in_buffer,
366 sx_close,
367};
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379#ifdef DEBUG
Jiri Slaby15b611f2006-12-08 02:39:04 -0800380#define sx_dprintk(f, str...) if (sx_debug & f) printk (str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381#else
Jiri Slaby15b611f2006-12-08 02:39:04 -0800382#define sx_dprintk(f, str...) /* nothing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383#endif
384
Harvey Harrisonbf9d8922008-04-30 00:55:10 -0700385#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__)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Jiri Slaby15b611f2006-12-08 02:39:04 -0800388#define func_enter2() sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
Harvey Harrisonbf9d8922008-04-30 00:55:10 -0700389 __func__, port->line)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
391/*
392 * Firmware loader driver specific routines
393 *
394 */
395
Arjan van de Ven62322d22006-07-03 00:24:21 -0700396static const struct file_operations sx_fw_fops = {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800397 .owner = THIS_MODULE,
Alan Cox11af7472008-07-25 01:48:15 -0700398 .unlocked_ioctl = sx_fw_ioctl,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200399 .llseek = noop_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400};
401
402static struct miscdevice sx_fw_device = {
403 SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
404};
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406#ifdef SX_PARANOIA_CHECK
407
408/* This doesn't work. Who's paranoid around here? Not me! */
409
Jiri Slaby15b611f2006-12-08 02:39:04 -0800410static inline int sx_paranoia_check(struct sx_port const *port,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 char *name, const char *routine)
412{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800413 static const char *badmagic = KERN_ERR "sx: Warning: bad sx port magic "
414 "number for device %s in %s\n";
415 static const char *badinfo = KERN_ERR "sx: Warning: null sx port for "
416 "device %s in %s\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 if (!port) {
419 printk(badinfo, name, routine);
420 return 1;
421 }
422 if (port->magic != SX_MAGIC) {
423 printk(badmagic, name, routine);
424 return 1;
425 }
426
427 return 0;
428}
429#else
430#define sx_paranoia_check(a,b,c) 0
431#endif
432
433/* The timeouts. First try 30 times as fast as possible. Then give
434 the card some time to breathe between accesses. (Otherwise the
435 processor on the card might not be able to access its OWN bus... */
436
437#define TIMEOUT_1 30
438#define TIMEOUT_2 1000000
439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440#ifdef DEBUG
441static void my_hd_io(void __iomem *p, int len)
442{
443 int i, j, ch;
444 unsigned char __iomem *addr = p;
445
Jiri Slaby15b611f2006-12-08 02:39:04 -0800446 for (i = 0; i < len; i += 16) {
447 printk("%p ", addr + i);
448 for (j = 0; j < 16; j++) {
449 printk("%02x %s", readb(addr + j + i),
450 (j == 7) ? " " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800452 for (j = 0; j < 16; j++) {
453 ch = readb(addr + j + i);
454 printk("%c", (ch < 0x20) ? '.' :
455 ((ch > 0x7f) ? '.' : ch));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800457 printk("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 }
459}
460static void my_hd(void *p, int len)
461{
462 int i, j, ch;
463 unsigned char *addr = p;
464
Jiri Slaby15b611f2006-12-08 02:39:04 -0800465 for (i = 0; i < len; i += 16) {
466 printk("%p ", addr + i);
467 for (j = 0; j < 16; j++) {
468 printk("%02x %s", addr[j + i], (j == 7) ? " " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800470 for (j = 0; j < 16; j++) {
471 ch = addr[j + i];
472 printk("%c", (ch < 0x20) ? '.' :
473 ((ch > 0x7f) ? '.' : ch));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800475 printk("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 }
477}
478#endif
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480/* This needs redoing for Alpha -- REW -- Done. */
481
Jiri Slaby15b611f2006-12-08 02:39:04 -0800482static inline void write_sx_byte(struct sx_board *board, int offset, u8 byte)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800484 writeb(byte, board->base + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
Jiri Slaby15b611f2006-12-08 02:39:04 -0800487static inline u8 read_sx_byte(struct sx_board *board, int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800489 return readb(board->base + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490}
491
Jiri Slaby15b611f2006-12-08 02:39:04 -0800492static inline void write_sx_word(struct sx_board *board, int offset, u16 word)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800494 writew(word, board->base + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495}
496
Jiri Slaby15b611f2006-12-08 02:39:04 -0800497static inline u16 read_sx_word(struct sx_board *board, int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800499 return readw(board->base + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
501
Jiri Slaby15b611f2006-12-08 02:39:04 -0800502static int sx_busy_wait_eq(struct sx_board *board,
503 int offset, int mask, int correctval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504{
505 int i;
506
Jiri Slaby15b611f2006-12-08 02:39:04 -0800507 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Jiri Slaby15b611f2006-12-08 02:39:04 -0800509 for (i = 0; i < TIMEOUT_1; i++)
510 if ((read_sx_byte(board, offset) & mask) == correctval) {
511 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 return 1;
513 }
514
Jiri Slaby15b611f2006-12-08 02:39:04 -0800515 for (i = 0; i < TIMEOUT_2; i++) {
516 if ((read_sx_byte(board, offset) & mask) == correctval) {
517 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 return 1;
519 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800520 udelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
522
Jiri Slaby15b611f2006-12-08 02:39:04 -0800523 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return 0;
525}
526
Jiri Slaby15b611f2006-12-08 02:39:04 -0800527static int sx_busy_wait_neq(struct sx_board *board,
528 int offset, int mask, int badval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
530 int i;
531
Jiri Slaby15b611f2006-12-08 02:39:04 -0800532 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
Jiri Slaby15b611f2006-12-08 02:39:04 -0800534 for (i = 0; i < TIMEOUT_1; i++)
535 if ((read_sx_byte(board, offset) & mask) != badval) {
536 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 return 1;
538 }
539
Jiri Slaby15b611f2006-12-08 02:39:04 -0800540 for (i = 0; i < TIMEOUT_2; i++) {
541 if ((read_sx_byte(board, offset) & mask) != badval) {
542 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 return 1;
544 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800545 udelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 }
547
Jiri Slaby15b611f2006-12-08 02:39:04 -0800548 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 return 0;
550}
551
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552/* 5.6.4 of 6210028 r2.3 */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800553static int sx_reset(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800555 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
Jiri Slaby15b611f2006-12-08 02:39:04 -0800557 if (IS_SX_BOARD(board)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Jiri Slaby15b611f2006-12-08 02:39:04 -0800559 write_sx_byte(board, SX_CONFIG, 0);
560 write_sx_byte(board, SX_RESET, 1); /* Value doesn't matter */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Jiri Slaby15b611f2006-12-08 02:39:04 -0800562 if (!sx_busy_wait_eq(board, SX_RESET_STATUS, 1, 0)) {
563 printk(KERN_INFO "sx: Card doesn't respond to "
564 "reset...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 return 0;
566 }
567 } else if (IS_EISA_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800568 outb(board->irq << 4, board->eisa_base + 0xc02);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 } else if (IS_SI1_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800570 write_sx_byte(board, SI1_ISA_RESET, 0); /*value doesn't matter*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 } else {
572 /* Gory details of the SI/ISA board */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800573 write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
574 write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
575 write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
576 write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
577 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
578 write_sx_byte(board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 }
580
Jiri Slaby15b611f2006-12-08 02:39:04 -0800581 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return 1;
583}
584
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585/* This doesn't work on machines where "NULL" isn't 0 */
586/* If you have one of those, someone will need to write
587 the equivalent of this, which will amount to about 3 lines. I don't
588 want to complicate this right now. -- REW
589 (See, I do write comments every now and then :-) */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800590#define OFFSETOF(strct, elem) ((long)&(((struct strct *)NULL)->elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
Jiri Slaby15b611f2006-12-08 02:39:04 -0800592#define CHAN_OFFSET(port,elem) (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
593#define MODU_OFFSET(board,addr,elem) (addr + OFFSETOF (_SXMODULE, elem))
594#define BRD_OFFSET(board,elem) (OFFSETOF (_SXCARD, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596#define sx_write_channel_byte(port, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800597 write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599#define sx_read_channel_byte(port, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800600 read_sx_byte (port->board, CHAN_OFFSET (port, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602#define sx_write_channel_word(port, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800603 write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605#define sx_read_channel_word(port, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800606 read_sx_word (port->board, CHAN_OFFSET (port, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
608#define sx_write_module_byte(board, addr, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800609 write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611#define sx_read_module_byte(board, addr, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800612 read_sx_byte (board, MODU_OFFSET (board, addr, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
614#define sx_write_module_word(board, addr, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800615 write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617#define sx_read_module_word(board, addr, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800618 read_sx_word (board, MODU_OFFSET (board, addr, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
620#define sx_write_board_byte(board, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800621 write_sx_byte (board, BRD_OFFSET (board, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
623#define sx_read_board_byte(board, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800624 read_sx_byte (board, BRD_OFFSET (board, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
626#define sx_write_board_word(board, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800627 write_sx_word (board, BRD_OFFSET (board, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629#define sx_read_board_word(board, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800630 read_sx_word (board, BRD_OFFSET (board, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
Jiri Slaby15b611f2006-12-08 02:39:04 -0800632static int sx_start_board(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800634 if (IS_SX_BOARD(board)) {
635 write_sx_byte(board, SX_CONFIG, SX_CONF_BUSEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 } else if (IS_EISA_BOARD(board)) {
637 write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
Jiri Slaby15b611f2006-12-08 02:39:04 -0800638 outb((board->irq << 4) | 4, board->eisa_base + 0xc02);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 } else if (IS_SI1_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800640 write_sx_byte(board, SI1_ISA_RESET_CLEAR, 0);
641 write_sx_byte(board, SI1_ISA_INTCL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 } else {
643 /* Don't bug me about the clear_set.
644 I haven't the foggiest idea what it's about -- REW */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800645 write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
646 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 }
648 return 1;
649}
650
651#define SX_IRQ_REG_VAL(board) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800652 ((board->flags & SX_ISA_BOARD) ? (board->irq << 4) : 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654/* Note. The SX register is write-only. Therefore, we have to enable the
655 bus too. This is a no-op, if you don't mess with this driver... */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800656static int sx_start_interrupts(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657{
658
659 /* Don't call this with board->irq == 0 */
660
661 if (IS_SX_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800662 write_sx_byte(board, SX_CONFIG, SX_IRQ_REG_VAL(board) |
663 SX_CONF_BUSEN | SX_CONF_HOSTIRQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 } else if (IS_EISA_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800665 inb(board->eisa_base + 0xc03);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 } else if (IS_SI1_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800667 write_sx_byte(board, SI1_ISA_INTCL, 0);
668 write_sx_byte(board, SI1_ISA_INTCL_CLEAR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 } else {
670 switch (board->irq) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800671 case 11:
672 write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);
673 break;
674 case 12:
675 write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);
676 break;
677 case 15:
678 write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);
679 break;
680 default:
681 printk(KERN_INFO "sx: SI/XIO card doesn't support "
682 "interrupt %d.\n", board->irq);
683 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800685 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 }
687
688 return 1;
689}
690
Jiri Slaby15b611f2006-12-08 02:39:04 -0800691static int sx_send_command(struct sx_port *port,
692 int command, int mask, int newstat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800694 func_enter2();
695 write_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat), command);
696 func_exit();
697 return sx_busy_wait_eq(port->board, CHAN_OFFSET(port, hi_hstat), mask,
698 newstat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699}
700
Jiri Slaby15b611f2006-12-08 02:39:04 -0800701static char *mod_type_s(int module_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702{
703 switch (module_type) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800704 case TA4:
705 return "TA4";
706 case TA8:
707 return "TA8";
708 case TA4_ASIC:
709 return "TA4_ASIC";
710 case TA8_ASIC:
711 return "TA8_ASIC";
712 case MTA_CD1400:
713 return "MTA_CD1400";
714 case SXDC:
715 return "SXDC";
716 default:
717 return "Unknown/invalid";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 }
719}
720
Jiri Slaby15b611f2006-12-08 02:39:04 -0800721static char *pan_type_s(int pan_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722{
723 switch (pan_type) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800724 case MOD_RS232DB25:
725 return "MOD_RS232DB25";
726 case MOD_RS232RJ45:
727 return "MOD_RS232RJ45";
728 case MOD_RS422DB25:
729 return "MOD_RS422DB25";
730 case MOD_PARALLEL:
731 return "MOD_PARALLEL";
732 case MOD_2_RS232DB25:
733 return "MOD_2_RS232DB25";
734 case MOD_2_RS232RJ45:
735 return "MOD_2_RS232RJ45";
736 case MOD_2_RS422DB25:
737 return "MOD_2_RS422DB25";
738 case MOD_RS232DB25MALE:
739 return "MOD_RS232DB25MALE";
740 case MOD_2_PARALLEL:
741 return "MOD_2_PARALLEL";
742 case MOD_BLANK:
743 return "empty";
744 default:
745 return "invalid";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 }
747}
748
Jiri Slaby15b611f2006-12-08 02:39:04 -0800749static int mod_compat_type(int module_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
751 return module_type >> 4;
752}
753
754static void sx_reconfigure_port(struct sx_port *port)
755{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800756 if (sx_read_channel_byte(port, hi_hstat) == HS_IDLE_OPEN) {
757 if (sx_send_command(port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
758 printk(KERN_WARNING "sx: Sent reconfigure command, but "
759 "card didn't react.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 }
761 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800762 sx_dprintk(SX_DEBUG_TERMIOS, "sx: Not sending reconfigure: "
763 "port isn't open (%02x).\n",
764 sx_read_channel_byte(port, hi_hstat));
765 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}
767
Jiri Slaby15b611f2006-12-08 02:39:04 -0800768static void sx_setsignals(struct sx_port *port, int dtr, int rts)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
770 int t;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800771 func_enter2();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Jiri Slaby15b611f2006-12-08 02:39:04 -0800773 t = sx_read_channel_byte(port, hi_op);
774 if (dtr >= 0)
775 t = dtr ? (t | OP_DTR) : (t & ~OP_DTR);
776 if (rts >= 0)
777 t = rts ? (t | OP_RTS) : (t & ~OP_RTS);
778 sx_write_channel_byte(port, hi_op, t);
779 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Jiri Slaby15b611f2006-12-08 02:39:04 -0800781 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782}
783
Jiri Slaby15b611f2006-12-08 02:39:04 -0800784static int sx_getsignals(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800786 int i_stat, o_stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
Jiri Slaby15b611f2006-12-08 02:39:04 -0800788 o_stat = sx_read_channel_byte(port, hi_op);
789 i_stat = sx_read_channel_byte(port, hi_ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Jiri Slaby15b611f2006-12-08 02:39:04 -0800791 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d (%d/%d) "
792 "%02x/%02x\n",
793 (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
Alan Cox31f35932009-01-02 13:45:05 +0000794 port->c_dcd, tty_port_carrier_raised(&port->gs.port),
Jiri Slaby15b611f2006-12-08 02:39:04 -0800795 sx_read_channel_byte(port, hi_ip),
796 sx_read_channel_byte(port, hi_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
Jiri Slaby15b611f2006-12-08 02:39:04 -0800798 return (((o_stat & OP_DTR) ? TIOCM_DTR : 0) |
799 ((o_stat & OP_RTS) ? TIOCM_RTS : 0) |
800 ((i_stat & IP_CTS) ? TIOCM_CTS : 0) |
801 ((i_stat & IP_DCD) ? TIOCM_CAR : 0) |
802 ((i_stat & IP_DSR) ? TIOCM_DSR : 0) |
803 ((i_stat & IP_RI) ? TIOCM_RNG : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
805
Jiri Slaby15b611f2006-12-08 02:39:04 -0800806static void sx_set_baud(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807{
808 int t;
809
810 if (port->board->ta_type == MOD_SXDC) {
811 switch (port->gs.baud) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800812 /* Save some typing work... */
813#define e(x) case x: t = BAUD_ ## x; break
814 e(50);
815 e(75);
816 e(110);
817 e(150);
818 e(200);
819 e(300);
820 e(600);
821 e(1200);
822 e(1800);
823 e(2000);
824 e(2400);
825 e(4800);
826 e(7200);
827 e(9600);
828 e(14400);
829 e(19200);
830 e(28800);
831 e(38400);
832 e(56000);
833 e(57600);
834 e(64000);
835 e(76800);
836 e(115200);
837 e(128000);
838 e(150000);
839 e(230400);
840 e(256000);
841 e(460800);
842 e(921600);
843 case 134:
844 t = BAUD_134_5;
845 break;
846 case 0:
847 t = -1;
848 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 default:
850 /* Can I return "invalid"? */
851 t = BAUD_9600;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800852 printk(KERN_INFO "sx: unsupported baud rate: %d.\n",
853 port->gs.baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 break;
855 }
856#undef e
857 if (t > 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800858/* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
859 sx_setsignals(port, 1, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 /* XXX This is not TA & MTA compatible */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800861 sx_write_channel_byte(port, hi_csr, 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Jiri Slaby15b611f2006-12-08 02:39:04 -0800863 sx_write_channel_byte(port, hi_txbaud, t);
864 sx_write_channel_byte(port, hi_rxbaud, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800866 sx_setsignals(port, 0, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 }
868 } else {
869 switch (port->gs.baud) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800870#define e(x) case x: t = CSR_ ## x; break
871 e(75);
872 e(150);
873 e(300);
874 e(600);
875 e(1200);
876 e(2400);
877 e(4800);
878 e(1800);
879 e(9600);
880 e(19200);
881 e(57600);
882 e(38400);
883/* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
884 case 110:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 if (port->board->ta_type == MOD_TA) {
886 t = CSR_110;
887 break;
888 } else {
889 t = CSR_9600;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800890 printk(KERN_INFO "sx: Unsupported baud rate: "
891 "%d.\n", port->gs.baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 break;
893 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800894 case 115200:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 if (port->board->ta_type == MOD_TA) {
896 t = CSR_9600;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800897 printk(KERN_INFO "sx: Unsupported baud rate: "
898 "%d.\n", port->gs.baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 break;
900 } else {
901 t = CSR_110;
902 break;
903 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800904 case 0:
905 t = -1;
906 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 default:
908 t = CSR_9600;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800909 printk(KERN_INFO "sx: Unsupported baud rate: %d.\n",
910 port->gs.baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 break;
912 }
913#undef e
914 if (t >= 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800915 sx_setsignals(port, 1, -1);
916 sx_write_channel_byte(port, hi_csr, t * 0x11);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800918 sx_setsignals(port, 0, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 }
920 }
921}
922
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923/* Simon Allen's version of this routine was 225 lines long. 85 is a lot
924 better. -- REW */
925
Jiri Slaby15b611f2006-12-08 02:39:04 -0800926static int sx_set_real_termios(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927{
928 struct sx_port *port = ptr;
929
930 func_enter2();
931
Alan Coxb5391e22008-07-16 21:55:20 +0100932 if (!port->gs.port.tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 return 0;
934
935 /* What is this doing here? -- REW
936 Ha! figured it out. It is to allow you to get DTR active again
937 if you've dropped it with stty 0. Moved to set_baud, where it
938 belongs (next to the drop dtr if baud == 0) -- REW */
939 /* sx_setsignals (port, 1, -1); */
940
Jiri Slaby15b611f2006-12-08 02:39:04 -0800941 sx_set_baud(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
Alan Coxb5391e22008-07-16 21:55:20 +0100943#define CFLAG port->gs.port.tty->termios->c_cflag
Jiri Slaby15b611f2006-12-08 02:39:04 -0800944 sx_write_channel_byte(port, hi_mr1,
Alan Coxb5391e22008-07-16 21:55:20 +0100945 (C_PARENB(port->gs.port.tty) ? MR1_WITH : MR1_NONE) |
946 (C_PARODD(port->gs.port.tty) ? MR1_ODD : MR1_EVEN) |
947 (C_CRTSCTS(port->gs.port.tty) ? MR1_RTS_RXFLOW : 0) |
Jiri Slaby15b611f2006-12-08 02:39:04 -0800948 (((CFLAG & CSIZE) == CS8) ? MR1_8_BITS : 0) |
949 (((CFLAG & CSIZE) == CS7) ? MR1_7_BITS : 0) |
950 (((CFLAG & CSIZE) == CS6) ? MR1_6_BITS : 0) |
951 (((CFLAG & CSIZE) == CS5) ? MR1_5_BITS : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
Jiri Slaby15b611f2006-12-08 02:39:04 -0800953 sx_write_channel_byte(port, hi_mr2,
Alan Coxb5391e22008-07-16 21:55:20 +0100954 (C_CRTSCTS(port->gs.port.tty) ? MR2_CTS_TXFLOW : 0) |
955 (C_CSTOPB(port->gs.port.tty) ? MR2_2_STOP :
Jiri Slaby15b611f2006-12-08 02:39:04 -0800956 MR2_1_STOP));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
958 switch (CFLAG & CSIZE) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800959 case CS8:
960 sx_write_channel_byte(port, hi_mask, 0xff);
961 break;
962 case CS7:
963 sx_write_channel_byte(port, hi_mask, 0x7f);
964 break;
965 case CS6:
966 sx_write_channel_byte(port, hi_mask, 0x3f);
967 break;
968 case CS5:
969 sx_write_channel_byte(port, hi_mask, 0x1f);
970 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 default:
Andrew Morton32fb3ca2008-05-06 20:42:35 -0700972 printk(KERN_INFO "sx: Invalid wordsize: %u\n",
973 (unsigned int)CFLAG & CSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 break;
975 }
976
Jiri Slaby15b611f2006-12-08 02:39:04 -0800977 sx_write_channel_byte(port, hi_prtcl,
Alan Coxb5391e22008-07-16 21:55:20 +0100978 (I_IXON(port->gs.port.tty) ? SP_TXEN : 0) |
979 (I_IXOFF(port->gs.port.tty) ? SP_RXEN : 0) |
980 (I_IXANY(port->gs.port.tty) ? SP_TANY : 0) | SP_DCEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
Jiri Slaby15b611f2006-12-08 02:39:04 -0800982 sx_write_channel_byte(port, hi_break,
Alan Coxb5391e22008-07-16 21:55:20 +0100983 (I_IGNBRK(port->gs.port.tty) ? BR_IGN : 0 |
984 I_BRKINT(port->gs.port.tty) ? BR_INT : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
Alan Coxb5391e22008-07-16 21:55:20 +0100986 sx_write_channel_byte(port, hi_txon, START_CHAR(port->gs.port.tty));
987 sx_write_channel_byte(port, hi_rxon, START_CHAR(port->gs.port.tty));
988 sx_write_channel_byte(port, hi_txoff, STOP_CHAR(port->gs.port.tty));
989 sx_write_channel_byte(port, hi_rxoff, STOP_CHAR(port->gs.port.tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991 sx_reconfigure_port(port);
992
993 /* Tell line discipline whether we will do input cooking */
Alan Coxb5391e22008-07-16 21:55:20 +0100994 if (I_OTHER(port->gs.port.tty)) {
995 clear_bit(TTY_HW_COOK_IN, &port->gs.port.tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 } else {
Alan Coxb5391e22008-07-16 21:55:20 +0100997 set_bit(TTY_HW_COOK_IN, &port->gs.port.tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800999 sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
Alan Coxb5391e22008-07-16 21:55:20 +01001000 (unsigned int)port->gs.port.tty->termios->c_iflag,
1001 I_OTHER(port->gs.port.tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002
1003/* Tell line discipline whether we will do output cooking.
1004 * If OPOST is set and no other output flags are set then we can do output
1005 * processing. Even if only *one* other flag in the O_OTHER group is set
1006 * we do cooking in software.
1007 */
Alan Coxb5391e22008-07-16 21:55:20 +01001008 if (O_OPOST(port->gs.port.tty) && !O_OTHER(port->gs.port.tty)) {
1009 set_bit(TTY_HW_COOK_OUT, &port->gs.port.tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 } else {
Alan Coxb5391e22008-07-16 21:55:20 +01001011 clear_bit(TTY_HW_COOK_OUT, &port->gs.port.tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001013 sx_dprintk(SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
Alan Coxb5391e22008-07-16 21:55:20 +01001014 (unsigned int)port->gs.port.tty->termios->c_oflag,
1015 O_OTHER(port->gs.port.tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 /* port->c_dcd = sx_get_CD (port); */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001017 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 return 0;
1019}
1020
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021/* ********************************************************************** *
1022 * the interrupt related routines *
1023 * ********************************************************************** */
1024
1025/* Note:
1026 Other drivers use the macro "MIN" to calculate how much to copy.
1027 This has the disadvantage that it will evaluate parts twice. That's
1028 expensive when it's IO (and the compiler cannot optimize those away!).
1029 Moreover, I'm not sure that you're race-free.
1030
1031 I assign a value, and then only allow the value to decrease. This
1032 is always safe. This makes the code a few lines longer, and you
1033 know I'm dead against that, but I think it is required in this
1034 case. */
1035
Jiri Slaby15b611f2006-12-08 02:39:04 -08001036static void sx_transmit_chars(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037{
1038 int c;
1039 int tx_ip;
1040 int txroom;
1041
Jiri Slaby15b611f2006-12-08 02:39:04 -08001042 func_enter2();
1043 sx_dprintk(SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
1044 port, port->gs.xmit_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045
Jiri Slaby15b611f2006-12-08 02:39:04 -08001046 if (test_and_set_bit(SX_PORT_TRANSMIT_LOCK, &port->locks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 return;
1048 }
1049
1050 while (1) {
1051 c = port->gs.xmit_cnt;
1052
Jiri Slaby15b611f2006-12-08 02:39:04 -08001053 sx_dprintk(SX_DEBUG_TRANSMIT, "Copying %d ", c);
1054 tx_ip = sx_read_channel_byte(port, hi_txipos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055
1056 /* Took me 5 minutes to deduce this formula.
1057 Luckily it is literally in the manual in section 6.5.4.3.5 */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001058 txroom = (sx_read_channel_byte(port, hi_txopos) - tx_ip - 1) &
1059 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060
1061 /* Don't copy more bytes than there is room for in the buffer */
1062 if (c > txroom)
1063 c = txroom;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001064 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
1066 /* Don't copy past the end of the hardware transmit buffer */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001067 if (c > 0x100 - tx_ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 c = 0x100 - tx_ip;
1069
Jiri Slaby15b611f2006-12-08 02:39:04 -08001070 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100 - tx_ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
1072 /* Don't copy pas the end of the source buffer */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001073 if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
1075
Jiri Slaby15b611f2006-12-08 02:39:04 -08001076 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%ld) \n",
1077 c, SERIAL_XMIT_SIZE - port->gs.xmit_tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078
Jiri Slaby15b611f2006-12-08 02:39:04 -08001079 /* If for one reason or another, we can't copy more data, we're
1080 done! */
1081 if (c == 0)
1082 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Jiri Slaby15b611f2006-12-08 02:39:04 -08001084 memcpy_toio(port->board->base + CHAN_OFFSET(port, hi_txbuf) +
1085 tx_ip, port->gs.xmit_buf + port->gs.xmit_tail, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
1087 /* Update the pointer in the card */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001088 sx_write_channel_byte(port, hi_txipos, (tx_ip + c) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
1090 /* Update the kernel buffer end */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001091 port->gs.xmit_tail = (port->gs.xmit_tail + c) &
1092 (SERIAL_XMIT_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093
1094 /* This one last. (this is essential)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001095 It would allow others to start putting more data into the
1096 buffer! */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 port->gs.xmit_cnt -= c;
1098 }
1099
1100 if (port->gs.xmit_cnt == 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001101 sx_disable_tx_interrupts(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 }
1103
Alan Coxb5391e22008-07-16 21:55:20 +01001104 if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.port.tty) {
1105 tty_wakeup(port->gs.port.tty);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001106 sx_dprintk(SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
1107 port->gs.wakeup_chars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 }
1109
Jiri Slaby15b611f2006-12-08 02:39:04 -08001110 clear_bit(SX_PORT_TRANSMIT_LOCK, &port->locks);
1111 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112}
1113
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114/* Note the symmetry between receiving chars and transmitting them!
1115 Note: The kernel should have implemented both a receive buffer and
1116 a transmit buffer. */
1117
1118/* Inlined: Called only once. Remove the inline when you add another call */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001119static inline void sx_receive_chars(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120{
1121 int c;
1122 int rx_op;
1123 struct tty_struct *tty;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001124 int copied = 0;
Alan Cox33f0f882006-01-09 20:54:13 -08001125 unsigned char *rp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Jiri Slaby15b611f2006-12-08 02:39:04 -08001127 func_enter2();
Alan Coxb5391e22008-07-16 21:55:20 +01001128 tty = port->gs.port.tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 while (1) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001130 rx_op = sx_read_channel_byte(port, hi_rxopos);
1131 c = (sx_read_channel_byte(port, hi_rxipos) - rx_op) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132
Jiri Slaby15b611f2006-12-08 02:39:04 -08001133 sx_dprintk(SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
Marc Zyngierd904ffd2006-02-27 12:08:00 +01001135 /* Don't copy past the end of the hardware receive buffer */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001136 if (rx_op + c > 0x100)
1137 c = 0x100 - rx_op;
Marc Zyngierd904ffd2006-02-27 12:08:00 +01001138
Jiri Slaby15b611f2006-12-08 02:39:04 -08001139 sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
Marc Zyngierd904ffd2006-02-27 12:08:00 +01001140
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 /* Don't copy more bytes than there is room for in the buffer */
Alan Cox33f0f882006-01-09 20:54:13 -08001142
1143 c = tty_prepare_flip_string(tty, &rp, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Jiri Slaby15b611f2006-12-08 02:39:04 -08001145 sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 /* If for one reason or another, we can't copy more data, we're done! */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001148 if (c == 0)
1149 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
Jiri Slaby15b611f2006-12-08 02:39:04 -08001151 sx_dprintk(SX_DEBUG_RECEIVE, "Copying over %d chars. First is "
1152 "%d at %lx\n", c, read_sx_byte(port->board,
1153 CHAN_OFFSET(port, hi_rxbuf) + rx_op),
1154 CHAN_OFFSET(port, hi_rxbuf));
1155 memcpy_fromio(rp, port->board->base +
1156 CHAN_OFFSET(port, hi_rxbuf) + rx_op, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158 /* This one last. ( Not essential.)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001159 It allows the card to start putting more data into the
1160 buffer!
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 Update the pointer in the card */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001162 sx_write_channel_byte(port, hi_rxopos, (rx_op + c) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
1164 copied += c;
1165 }
1166 if (copied) {
1167 struct timeval tv;
1168
Jiri Slaby15b611f2006-12-08 02:39:04 -08001169 do_gettimeofday(&tv);
1170 sx_dprintk(SX_DEBUG_RECEIVE, "pushing flipq port %d (%3d "
1171 "chars): %d.%06d (%d/%d)\n", port->line,
1172 copied, (int)(tv.tv_sec % 60), (int)tv.tv_usec,
1173 tty->raw, tty->real_raw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174
Jiri Slaby15b611f2006-12-08 02:39:04 -08001175 /* Tell the rest of the system the news. Great news. New
1176 characters! */
1177 tty_flip_buffer_push(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 /* tty_schedule_flip (tty); */
1179 }
1180
Jiri Slaby15b611f2006-12-08 02:39:04 -08001181 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182}
1183
1184/* Inlined: it is called only once. Remove the inline if you add another
1185 call */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001186static inline void sx_check_modem_signals(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187{
1188 int hi_state;
1189 int c_dcd;
1190
Jiri Slaby15b611f2006-12-08 02:39:04 -08001191 hi_state = sx_read_channel_byte(port, hi_state);
1192 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
Alan Cox31f35932009-01-02 13:45:05 +00001193 port->c_dcd, tty_port_carrier_raised(&port->gs.port));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
1195 if (hi_state & ST_BREAK) {
1196 hi_state &= ~ST_BREAK;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001197 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a break.\n");
1198 sx_write_channel_byte(port, hi_state, hi_state);
1199 gs_got_break(&port->gs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 }
1201 if (hi_state & ST_DCD) {
1202 hi_state &= ~ST_DCD;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001203 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
1204 sx_write_channel_byte(port, hi_state, hi_state);
Alan Cox31f35932009-01-02 13:45:05 +00001205 c_dcd = tty_port_carrier_raised(&port->gs.port);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001206 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 if (c_dcd != port->c_dcd) {
1208 port->c_dcd = c_dcd;
Alan Cox31f35932009-01-02 13:45:05 +00001209 if (tty_port_carrier_raised(&port->gs.port)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 /* DCD went UP */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001211 if ((sx_read_channel_byte(port, hi_hstat) !=
1212 HS_IDLE_CLOSED) &&
Alan Coxb5391e22008-07-16 21:55:20 +01001213 !(port->gs.port.tty->termios->
Jiri Slaby15b611f2006-12-08 02:39:04 -08001214 c_cflag & CLOCAL)) {
1215 /* Are we blocking in open? */
1216 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1217 "active, unblocking open\n");
Alan Coxb5391e22008-07-16 21:55:20 +01001218 wake_up_interruptible(&port->gs.port.
Jiri Slaby15b611f2006-12-08 02:39:04 -08001219 open_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001221 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1222 "raised. Ignoring.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 }
1224 } else {
1225 /* DCD went down! */
Alan Coxb5391e22008-07-16 21:55:20 +01001226 if (!(port->gs.port.tty->termios->c_cflag & CLOCAL)){
Jiri Slaby15b611f2006-12-08 02:39:04 -08001227 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1228 "dropped. hanging up....\n");
Alan Coxb5391e22008-07-16 21:55:20 +01001229 tty_hangup(port->gs.port.tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001231 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1232 "dropped. ignoring.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 }
1234 }
1235 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001236 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us "
1237 "DCD changed, but it didn't.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 }
1239 }
1240}
1241
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242/* This is what an interrupt routine should look like.
1243 * Small, elegant, clear.
1244 */
1245
Jiri Slaby15b611f2006-12-08 02:39:04 -08001246static irqreturn_t sx_interrupt(int irq, void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247{
1248 struct sx_board *board = ptr;
1249 struct sx_port *port;
1250 int i;
1251
Jiri Slaby15b611f2006-12-08 02:39:04 -08001252 func_enter();
1253 sx_dprintk(SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq,
1254 board->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
1256 /* AAargh! The order in which to do these things is essential and
1257 not trivial.
1258
1259 - Rate limit goes before "recursive". Otherwise a series of
Jiri Slaby15b611f2006-12-08 02:39:04 -08001260 recursive calls will hang the machine in the interrupt routine.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
1262 - hardware twiddling goes before "recursive". Otherwise when we
Jiri Slaby15b611f2006-12-08 02:39:04 -08001263 poll the card, and a recursive interrupt happens, we won't
1264 ack the card, so it might keep on interrupting us. (especially
1265 level sensitive interrupt systems like PCI).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
1267 - Rate limit goes before hardware twiddling. Otherwise we won't
Jiri Slaby15b611f2006-12-08 02:39:04 -08001268 catch a card that has gone bonkers.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269
1270 - The "initialized" test goes after the hardware twiddling. Otherwise
Jiri Slaby15b611f2006-12-08 02:39:04 -08001271 the card will stick us in the interrupt routine again.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
1273 - The initialized test goes before recursive.
Jiri Slaby15b611f2006-12-08 02:39:04 -08001274 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
1276#ifdef IRQ_RATE_LIMIT
1277 /* Aaargh! I'm ashamed. This costs more lines-of-code than the
Jiri Slaby15b611f2006-12-08 02:39:04 -08001278 actual interrupt routine!. (Well, used to when I wrote that
1279 comment) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 {
1281 static int lastjif;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001282 static int nintr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
1284 if (lastjif == jiffies) {
1285 if (++nintr > IRQ_RATE_LIMIT) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001286 free_irq(board->irq, board);
1287 printk(KERN_ERR "sx: Too many interrupts. "
1288 "Turning off interrupt %d.\n",
1289 board->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 }
1291 } else {
1292 lastjif = jiffies;
1293 nintr = 0;
1294 }
1295 }
1296#endif
1297
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 if (board->irq == irq) {
1299 /* Tell the card we've noticed the interrupt. */
1300
Jiri Slaby15b611f2006-12-08 02:39:04 -08001301 sx_write_board_word(board, cc_int_pending, 0);
1302 if (IS_SX_BOARD(board)) {
1303 write_sx_byte(board, SX_RESET_IRQ, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 } else if (IS_EISA_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001305 inb(board->eisa_base + 0xc03);
1306 write_sx_word(board, 8, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001308 write_sx_byte(board, SI2_ISA_INTCLEAR,
1309 SI2_ISA_INTCLEAR_CLEAR);
1310 write_sx_byte(board, SI2_ISA_INTCLEAR,
1311 SI2_ISA_INTCLEAR_SET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 }
1313 }
1314
1315 if (!sx_initialized)
1316 return IRQ_HANDLED;
1317 if (!(board->flags & SX_BOARD_INITIALIZED))
1318 return IRQ_HANDLED;
1319
Jiri Slaby15b611f2006-12-08 02:39:04 -08001320 if (test_and_set_bit(SX_BOARD_INTR_LOCK, &board->locks)) {
1321 printk(KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 return IRQ_HANDLED;
1323 }
1324
Jiri Slaby15b611f2006-12-08 02:39:04 -08001325 for (i = 0; i < board->nports; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 port = &board->ports[i];
Alan Coxb5391e22008-07-16 21:55:20 +01001327 if (port->gs.port.flags & GS_ACTIVE) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001328 if (sx_read_channel_byte(port, hi_state)) {
1329 sx_dprintk(SX_DEBUG_INTERRUPTS, "Port %d: "
1330 "modem signal change?... \n",i);
1331 sx_check_modem_signals(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 }
1333 if (port->gs.xmit_cnt) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001334 sx_transmit_chars(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 }
Alan Coxb5391e22008-07-16 21:55:20 +01001336 if (!(port->gs.port.flags & SX_RX_THROTTLE)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001337 sx_receive_chars(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 }
1339 }
1340 }
1341
Jiri Slaby15b611f2006-12-08 02:39:04 -08001342 clear_bit(SX_BOARD_INTR_LOCK, &board->locks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
Jiri Slaby15b611f2006-12-08 02:39:04 -08001344 sx_dprintk(SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq,
1345 board->irq);
1346 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 return IRQ_HANDLED;
1348}
1349
Jiri Slaby15b611f2006-12-08 02:39:04 -08001350static void sx_pollfunc(unsigned long data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001352 struct sx_board *board = (struct sx_board *)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
Jiri Slaby15b611f2006-12-08 02:39:04 -08001354 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
Jiri Slaby15b611f2006-12-08 02:39:04 -08001356 sx_interrupt(0, board);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357
Jiri Slabyc9594642006-12-08 02:39:05 -08001358 mod_timer(&board->timer, jiffies + sx_poll);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001359 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360}
1361
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362/* ********************************************************************** *
1363 * Here are the routines that actually *
1364 * interface with the generic_serial driver *
1365 * ********************************************************************** */
1366
1367/* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
1368/* Hmm. Ok I figured it out. You don't. */
1369
Jiri Slaby15b611f2006-12-08 02:39:04 -08001370static void sx_disable_tx_interrupts(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001372 struct sx_port *port = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 func_enter2();
1374
Alan Coxb5391e22008-07-16 21:55:20 +01001375 port->gs.port.flags &= ~GS_TX_INTEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
1377 func_exit();
1378}
1379
Jiri Slaby15b611f2006-12-08 02:39:04 -08001380static void sx_enable_tx_interrupts(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001382 struct sx_port *port = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 int data_in_buffer;
1384 func_enter2();
1385
1386 /* First transmit the characters that we're supposed to */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001387 sx_transmit_chars(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388
1389 /* The sx card will never interrupt us if we don't fill the buffer
1390 past 25%. So we keep considering interrupts off if that's the case. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001391 data_in_buffer = (sx_read_channel_byte(port, hi_txipos) -
1392 sx_read_channel_byte(port, hi_txopos)) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
1394 /* XXX Must be "HIGH_WATER" for SI card according to doc. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001395 if (data_in_buffer < LOW_WATER)
Alan Coxb5391e22008-07-16 21:55:20 +01001396 port->gs.port.flags &= ~GS_TX_INTEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
1398 func_exit();
1399}
1400
Jiri Slaby15b611f2006-12-08 02:39:04 -08001401static void sx_disable_rx_interrupts(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402{
1403 /* struct sx_port *port = ptr; */
1404 func_enter();
1405
1406 func_exit();
1407}
1408
Jiri Slaby15b611f2006-12-08 02:39:04 -08001409static void sx_enable_rx_interrupts(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410{
1411 /* struct sx_port *port = ptr; */
1412 func_enter();
1413
1414 func_exit();
1415}
1416
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417/* Jeez. Isn't this simple? */
Alan Cox31f35932009-01-02 13:45:05 +00001418static int sx_carrier_raised(struct tty_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419{
Alan Cox31f35932009-01-02 13:45:05 +00001420 struct sx_port *sp = container_of(port, struct sx_port, gs.port);
1421 return ((sx_read_channel_byte(sp, hi_ip) & IP_DCD) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422}
1423
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424/* Jeez. Isn't this simple? */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001425static int sx_chars_in_buffer(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426{
1427 struct sx_port *port = ptr;
1428 func_enter2();
1429
1430 func_exit();
Jiri Slaby15b611f2006-12-08 02:39:04 -08001431 return ((sx_read_channel_byte(port, hi_txipos) -
1432 sx_read_channel_byte(port, hi_txopos)) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433}
1434
Jiri Slaby15b611f2006-12-08 02:39:04 -08001435static void sx_shutdown_port(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001437 struct sx_port *port = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
1439 func_enter();
1440
Alan Coxb5391e22008-07-16 21:55:20 +01001441 port->gs.port.flags &= ~GS_ACTIVE;
1442 if (port->gs.port.tty && (port->gs.port.tty->termios->c_cflag & HUPCL)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001443 sx_setsignals(port, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 sx_reconfigure_port(port);
1445 }
1446
1447 func_exit();
1448}
1449
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450/* ********************************************************************** *
1451 * Here are the routines that actually *
1452 * interface with the rest of the system *
1453 * ********************************************************************** */
1454
Jiri Slaby15b611f2006-12-08 02:39:04 -08001455static int sx_open(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456{
1457 struct sx_port *port;
1458 int retval, line;
1459 unsigned long flags;
1460
1461 func_enter();
1462
1463 if (!sx_initialized) {
1464 return -EIO;
1465 }
1466
1467 line = tty->index;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001468 sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07001469 "np=%d)\n", task_pid_nr(current), line, tty,
Jiri Slaby15b611f2006-12-08 02:39:04 -08001470 current->signal->tty, sx_nports);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
1472 if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1473 return -ENODEV;
1474
Jiri Slaby15b611f2006-12-08 02:39:04 -08001475 port = &sx_ports[line];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
Jiri Slaby15b611f2006-12-08 02:39:04 -08001477 1 -> 0 transition. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478
Jiri Slaby15b611f2006-12-08 02:39:04 -08001479 sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
1481 spin_lock_irqsave(&port->gs.driver_lock, flags);
1482
1483 tty->driver_data = port;
Alan Coxb5391e22008-07-16 21:55:20 +01001484 port->gs.port.tty = tty;
1485 port->gs.port.count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1487
Jiri Slaby15b611f2006-12-08 02:39:04 -08001488 sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
1490 /*
1491 * Start up serial port
1492 */
1493 retval = gs_init_port(&port->gs);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001494 sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 if (retval) {
Alan Coxb5391e22008-07-16 21:55:20 +01001496 port->gs.port.count--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 return retval;
1498 }
1499
Alan Coxb5391e22008-07-16 21:55:20 +01001500 port->gs.port.flags |= GS_ACTIVE;
1501 if (port->gs.port.count <= 1)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001502 sx_setsignals(port, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503
1504#if 0
1505 if (sx_debug & SX_DEBUG_OPEN)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001506 my_hd(port, sizeof(*port));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507#else
1508 if (sx_debug & SX_DEBUG_OPEN)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001509 my_hd_io(port->board->base + port->ch_base, sizeof(*port));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510#endif
1511
Alan Coxb5391e22008-07-16 21:55:20 +01001512 if (port->gs.port.count <= 1) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001513 if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1514 printk(KERN_ERR "sx: Card didn't respond to LOPEN "
1515 "command.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 spin_lock_irqsave(&port->gs.driver_lock, flags);
Alan Coxb5391e22008-07-16 21:55:20 +01001517 port->gs.port.count--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1519 return -EIO;
1520 }
1521 }
1522
1523 retval = gs_block_til_ready(port, filp);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001524 sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
Alan Coxb5391e22008-07-16 21:55:20 +01001525 retval, port->gs.port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526
1527 if (retval) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001528/*
Alan Coxb5391e22008-07-16 21:55:20 +01001529 * Don't lower gs.port.count here because sx_close() will be called later
Jiri Slaby15b611f2006-12-08 02:39:04 -08001530 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
1532 return retval;
1533 }
1534 /* tty->low_latency = 1; */
1535
Alan Cox31f35932009-01-02 13:45:05 +00001536 port->c_dcd = sx_carrier_raised(&port->gs.port);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001537 sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538
1539 func_exit();
1540 return 0;
1541
1542}
1543
Jiri Slaby15b611f2006-12-08 02:39:04 -08001544static void sx_close(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001546 struct sx_port *port = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 /* Give the port 5 seconds to close down. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001548 int to = 5 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549
Jiri Slaby15b611f2006-12-08 02:39:04 -08001550 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
Jiri Slaby15b611f2006-12-08 02:39:04 -08001552 sx_setsignals(port, 0, 0);
1553 sx_reconfigure_port(port);
1554 sx_send_command(port, HS_CLOSE, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555
Jiri Slaby15b611f2006-12-08 02:39:04 -08001556 while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 if (msleep_interruptible(10))
1558 break;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001559 if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
1560 if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
1561 != 1) {
1562 printk(KERN_ERR "sx: sent the force_close command, but "
1563 "card didn't react\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 } else
Jiri Slaby15b611f2006-12-08 02:39:04 -08001565 sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
1566 "command.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 }
1568
Jiri Slaby15b611f2006-12-08 02:39:04 -08001569 sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
Alan Coxb5391e22008-07-16 21:55:20 +01001570 5 * HZ - to - 1, port->gs.port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571
Alan Coxb5391e22008-07-16 21:55:20 +01001572 if (port->gs.port.count) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001573 sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n",
Alan Coxb5391e22008-07-16 21:55:20 +01001574 port->gs.port.count);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001575 /*printk("%s SETTING port count to zero: %p count: %d\n",
Alan Coxb5391e22008-07-16 21:55:20 +01001576 __func__, port, port->gs.port.count);
1577 port->gs.port.count = 0;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 }
1579
Jiri Slaby15b611f2006-12-08 02:39:04 -08001580 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581}
1582
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583/* This is relatively thorough. But then again it is only 20 lines. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001584#define MARCHUP for (i = min; i < max; i++)
1585#define MARCHDOWN for (i = max - 1; i >= min; i--)
1586#define W0 write_sx_byte(board, i, 0x55)
1587#define W1 write_sx_byte(board, i, 0xaa)
1588#define R0 if (read_sx_byte(board, i) != 0x55) return 1
1589#define R1 if (read_sx_byte(board, i) != 0xaa) return 1
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
1591/* This memtest takes a human-noticable time. You normally only do it
1592 once a boot, so I guess that it is worth it. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001593static int do_memtest(struct sx_board *board, int min, int max)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594{
1595 int i;
1596
1597 /* This is a marchb. Theoretically, marchb catches much more than
1598 simpler tests. In practise, the longer test just catches more
1599 intermittent errors. -- REW
1600 (For the theory behind memory testing see:
1601 Testing Semiconductor Memories by A.J. van de Goor.) */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001602 MARCHUP {
1603 W0;
1604 }
1605 MARCHUP {
1606 R0;
1607 W1;
1608 R1;
1609 W0;
1610 R0;
1611 W1;
1612 }
1613 MARCHUP {
1614 R1;
1615 W0;
1616 W1;
1617 }
1618 MARCHDOWN {
1619 R1;
1620 W0;
1621 W1;
1622 W0;
1623 }
1624 MARCHDOWN {
1625 R0;
1626 W1;
1627 W0;
1628 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
1630 return 0;
1631}
1632
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633#undef MARCHUP
1634#undef MARCHDOWN
1635#undef W0
1636#undef W1
1637#undef R0
1638#undef R1
1639
Jiri Slaby15b611f2006-12-08 02:39:04 -08001640#define MARCHUP for (i = min; i < max; i += 2)
1641#define MARCHDOWN for (i = max - 1; i >= min; i -= 2)
1642#define W0 write_sx_word(board, i, 0x55aa)
1643#define W1 write_sx_word(board, i, 0xaa55)
1644#define R0 if (read_sx_word(board, i) != 0x55aa) return 1
1645#define R1 if (read_sx_word(board, i) != 0xaa55) return 1
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647#if 0
1648/* This memtest takes a human-noticable time. You normally only do it
1649 once a boot, so I guess that it is worth it. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001650static int do_memtest_w(struct sx_board *board, int min, int max)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651{
1652 int i;
1653
Jiri Slaby15b611f2006-12-08 02:39:04 -08001654 MARCHUP {
1655 W0;
1656 }
1657 MARCHUP {
1658 R0;
1659 W1;
1660 R1;
1661 W0;
1662 R0;
1663 W1;
1664 }
1665 MARCHUP {
1666 R1;
1667 W0;
1668 W1;
1669 }
1670 MARCHDOWN {
1671 R1;
1672 W0;
1673 W1;
1674 W0;
1675 }
1676 MARCHDOWN {
1677 R0;
1678 W1;
1679 W0;
1680 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681
1682 return 0;
1683}
1684#endif
1685
Alan Cox11af7472008-07-25 01:48:15 -07001686static long sx_fw_ioctl(struct file *filp, unsigned int cmd,
1687 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688{
Alan Cox11af7472008-07-25 01:48:15 -07001689 long rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 int __user *descr = (int __user *)arg;
1691 int i;
1692 static struct sx_board *board = NULL;
1693 int nbytes, offset;
1694 unsigned long data;
1695 char *tmp;
1696
1697 func_enter();
1698
Alan Cox11af7472008-07-25 01:48:15 -07001699 if (!capable(CAP_SYS_RAWIO))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 return -EPERM;
Alan Cox11af7472008-07-25 01:48:15 -07001701
Arnd Bergmannec79d602010-06-01 22:53:01 +02001702 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
Jiri Slaby15b611f2006-12-08 02:39:04 -08001704 sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705
Jiri Slaby15b611f2006-12-08 02:39:04 -08001706 if (!board)
1707 board = &boards[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 if (board->flags & SX_BOARD_PRESENT) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001709 sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1710 board->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001712 sx_dprintk(SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
1713 board->flags);
1714 for (i = 0; i < SX_NBOARDS; i++)
1715 sx_dprintk(SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
1716 sx_dprintk(SX_DEBUG_FIRMWARE, "\n");
Dan Carpenter736d5452009-02-04 15:12:20 -08001717 rc = -EIO;
1718 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 }
1720
1721 switch (cmd) {
1722 case SXIO_SET_BOARD:
Jiri Slaby15b611f2006-12-08 02:39:04 -08001723 sx_dprintk(SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
Alan Cox11af7472008-07-25 01:48:15 -07001724 rc = -EIO;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001725 if (arg >= SX_NBOARDS)
Alan Cox11af7472008-07-25 01:48:15 -07001726 break;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001727 sx_dprintk(SX_DEBUG_FIRMWARE, "not out of range\n");
1728 if (!(boards[arg].flags & SX_BOARD_PRESENT))
Alan Cox11af7472008-07-25 01:48:15 -07001729 break;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001730 sx_dprintk(SX_DEBUG_FIRMWARE, ".. and present!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 board = &boards[arg];
Alan Cox11af7472008-07-25 01:48:15 -07001732 rc = 0;
1733 /* FIXME: And this does ... nothing?? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 break;
1735 case SXIO_GET_TYPE:
Jiri Slaby15b611f2006-12-08 02:39:04 -08001736 rc = -ENOENT; /* If we manage to miss one, return error. */
1737 if (IS_SX_BOARD(board))
1738 rc = SX_TYPE_SX;
1739 if (IS_CF_BOARD(board))
1740 rc = SX_TYPE_CF;
1741 if (IS_SI_BOARD(board))
1742 rc = SX_TYPE_SI;
1743 if (IS_SI1_BOARD(board))
1744 rc = SX_TYPE_SI;
1745 if (IS_EISA_BOARD(board))
1746 rc = SX_TYPE_SI;
Alan Cox11af7472008-07-25 01:48:15 -07001747 sx_dprintk(SX_DEBUG_FIRMWARE, "returning type= %ld\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 break;
1749 case SXIO_DO_RAMTEST:
Ilpo Järvinen9b6d2512009-02-20 15:38:45 -08001750 if (sx_initialized) { /* Already initialized: better not ramtest the board. */
Dan Carpenter736d5452009-02-04 15:12:20 -08001751 rc = -EPERM;
1752 break;
Ilpo Järvinen9b6d2512009-02-20 15:38:45 -08001753 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001754 if (IS_SX_BOARD(board)) {
1755 rc = do_memtest(board, 0, 0x7000);
1756 if (!rc)
1757 rc = do_memtest(board, 0, 0x7000);
1758 /*if (!rc) rc = do_memtest_w (board, 0, 0x7000); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001760 rc = do_memtest(board, 0, 0x7ff8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
1762 }
Alan Cox11af7472008-07-25 01:48:15 -07001763 sx_dprintk(SX_DEBUG_FIRMWARE,
1764 "returning memtest result= %ld\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 break;
1766 case SXIO_DOWNLOAD:
Alan Cox11af7472008-07-25 01:48:15 -07001767 if (sx_initialized) {/* Already initialized */
1768 rc = -EEXIST;
1769 break;
1770 }
1771 if (!sx_reset(board)) {
1772 rc = -EIO;
1773 break;
1774 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001775 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
Jiri Slaby15b611f2006-12-08 02:39:04 -08001777 tmp = kmalloc(SX_CHUNK_SIZE, GFP_USER);
Alan Cox11af7472008-07-25 01:48:15 -07001778 if (!tmp) {
1779 rc = -ENOMEM;
1780 break;
1781 }
1782 /* FIXME: check returns */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001783 get_user(nbytes, descr++);
1784 get_user(offset, descr++);
1785 get_user(data, descr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 while (nbytes && data) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001787 for (i = 0; i < nbytes; i += SX_CHUNK_SIZE) {
1788 if (copy_from_user(tmp, (char __user *)data + i,
1789 (i + SX_CHUNK_SIZE > nbytes) ?
1790 nbytes - i : SX_CHUNK_SIZE)) {
1791 kfree(tmp);
Alan Cox11af7472008-07-25 01:48:15 -07001792 rc = -EFAULT;
Dan Carpenterb28fe282009-02-20 15:38:46 -08001793 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001795 memcpy_toio(board->base2 + offset + i, tmp,
1796 (i + SX_CHUNK_SIZE > nbytes) ?
1797 nbytes - i : SX_CHUNK_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 }
1799
Jiri Slaby15b611f2006-12-08 02:39:04 -08001800 get_user(nbytes, descr++);
1801 get_user(offset, descr++);
1802 get_user(data, descr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001804 kfree(tmp);
1805 sx_nports += sx_init_board(board);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 rc = sx_nports;
1807 break;
1808 case SXIO_INIT:
Alan Cox11af7472008-07-25 01:48:15 -07001809 if (sx_initialized) { /* Already initialized */
1810 rc = -EEXIST;
1811 break;
1812 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 /* This is not allowed until all boards are initialized... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001814 for (i = 0; i < SX_NBOARDS; i++) {
1815 if ((boards[i].flags & SX_BOARD_PRESENT) &&
Alan Cox11af7472008-07-25 01:48:15 -07001816 !(boards[i].flags & SX_BOARD_INITIALIZED)) {
1817 rc = -EIO;
1818 break;
1819 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001821 for (i = 0; i < SX_NBOARDS; i++)
1822 if (!(boards[i].flags & SX_BOARD_PRESENT))
1823 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824
Jiri Slaby15b611f2006-12-08 02:39:04 -08001825 sx_dprintk(SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
1826 "%d channels, first board: %d ports\n",
1827 i, sx_nports, boards[0].nports);
1828 rc = sx_init_portstructs(i, sx_nports);
1829 sx_init_drivers();
1830 if (rc >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 sx_initialized++;
1832 break;
1833 case SXIO_SETDEBUG:
1834 sx_debug = arg;
1835 break;
1836 case SXIO_GETDEBUG:
1837 rc = sx_debug;
1838 break;
1839 case SXIO_GETGSDEBUG:
1840 case SXIO_SETGSDEBUG:
1841 rc = -EINVAL;
1842 break;
1843 case SXIO_GETNPORTS:
1844 rc = sx_nports;
1845 break;
1846 default:
Alan Cox11af7472008-07-25 01:48:15 -07001847 rc = -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 break;
1849 }
Dan Carpenter736d5452009-02-04 15:12:20 -08001850out:
Arnd Bergmannec79d602010-06-01 22:53:01 +02001851 tty_unlock();
Jiri Slaby15b611f2006-12-08 02:39:04 -08001852 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 return rc;
1854}
1855
Alan Cox9e989662008-07-22 11:18:03 +01001856static int sx_break(struct tty_struct *tty, int flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857{
1858 struct sx_port *port = tty->driver_data;
1859 int rv;
1860
Jiri Slaby15b611f2006-12-08 02:39:04 -08001861 func_enter();
Arnd Bergmannec79d602010-06-01 22:53:01 +02001862 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863
Jiri Slaby15b611f2006-12-08 02:39:04 -08001864 if (flag)
1865 rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
1866 else
1867 rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
1868 if (rv != 1)
1869 printk(KERN_ERR "sx: couldn't send break (%x).\n",
1870 read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
Arnd Bergmannec79d602010-06-01 22:53:01 +02001871 tty_unlock();
Jiri Slaby15b611f2006-12-08 02:39:04 -08001872 func_exit();
Alan Cox9e989662008-07-22 11:18:03 +01001873 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874}
1875
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1877{
1878 struct sx_port *port = tty->driver_data;
1879 return sx_getsignals(port);
1880}
1881
1882static int sx_tiocmset(struct tty_struct *tty, struct file *file,
Jiri Slaby15b611f2006-12-08 02:39:04 -08001883 unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884{
1885 struct sx_port *port = tty->driver_data;
1886 int rts = -1, dtr = -1;
1887
1888 if (set & TIOCM_RTS)
1889 rts = 1;
1890 if (set & TIOCM_DTR)
1891 dtr = 1;
1892 if (clear & TIOCM_RTS)
1893 rts = 0;
1894 if (clear & TIOCM_DTR)
1895 dtr = 0;
1896
1897 sx_setsignals(port, dtr, rts);
1898 sx_reconfigure_port(port);
1899 return 0;
1900}
1901
Jiri Slaby15b611f2006-12-08 02:39:04 -08001902static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1903 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904{
1905 int rc;
1906 struct sx_port *port = tty->driver_data;
1907 void __user *argp = (void __user *)arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
1909 /* func_enter2(); */
1910
1911 rc = 0;
Arnd Bergmannec79d602010-06-01 22:53:01 +02001912 tty_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 case TIOCGSERIAL:
1915 rc = gs_getserial(&port->gs, argp);
1916 break;
1917 case TIOCSSERIAL:
1918 rc = gs_setserial(&port->gs, argp);
1919 break;
1920 default:
1921 rc = -ENOIOCTLCMD;
1922 break;
1923 }
Arnd Bergmannec79d602010-06-01 22:53:01 +02001924 tty_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
1926 /* func_exit(); */
1927 return rc;
1928}
1929
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930/* The throttle/unthrottle scheme for the Specialix card is different
1931 * from other drivers and deserves some explanation.
1932 * The Specialix hardware takes care of XON/XOFF
1933 * and CTS/RTS flow control itself. This means that all we have to
1934 * do when signalled by the upper tty layer to throttle/unthrottle is
1935 * to make a note of it here. When we come to read characters from the
1936 * rx buffers on the card (sx_receive_chars()) we look to see if the
1937 * upper layer can accept more (as noted here in sx_rx_throt[]).
1938 * If it can't we simply don't remove chars from the cards buffer.
1939 * When the tty layer can accept chars, we again note that here and when
1940 * sx_receive_chars() is called it will remove them from the cards buffer.
1941 * The card will notice that a ports buffer has drained below some low
1942 * water mark and will unflow control the line itself, using whatever
1943 * flow control scheme is in use for that port. -- Simon Allen
1944 */
1945
Jiri Slaby15b611f2006-12-08 02:39:04 -08001946static void sx_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947{
Alan Coxc9f19e92009-01-02 13:47:26 +00001948 struct sx_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949
1950 func_enter2();
1951 /* If the port is using any type of input flow
1952 * control then throttle the port.
1953 */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001954 if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
Alan Coxb5391e22008-07-16 21:55:20 +01001955 port->gs.port.flags |= SX_RX_THROTTLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 }
1957 func_exit();
1958}
1959
Jiri Slaby15b611f2006-12-08 02:39:04 -08001960static void sx_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961{
Alan Coxc9f19e92009-01-02 13:47:26 +00001962 struct sx_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963
1964 func_enter2();
1965 /* Always unthrottle even if flow control is not enabled on
1966 * this port in case we disabled flow control while the port
1967 * was throttled
1968 */
Alan Coxb5391e22008-07-16 21:55:20 +01001969 port->gs.port.flags &= ~SX_RX_THROTTLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 func_exit();
1971 return;
1972}
1973
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974/* ********************************************************************** *
1975 * Here are the initialization routines. *
1976 * ********************************************************************** */
1977
Jiri Slaby15b611f2006-12-08 02:39:04 -08001978static int sx_init_board(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979{
1980 int addr;
1981 int chans;
1982 int type;
1983
1984 func_enter();
1985
1986 /* This is preceded by downloading the download code. */
1987
1988 board->flags |= SX_BOARD_INITIALIZED;
1989
Jiri Slaby15b611f2006-12-08 02:39:04 -08001990 if (read_sx_byte(board, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 /* CF boards may need this. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001992 write_sx_byte(board, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993
1994 /* This resets the processor again, to make sure it didn't do any
1995 foolish things while we were downloading the image */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001996 if (!sx_reset(board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 return 0;
1998
Jiri Slaby15b611f2006-12-08 02:39:04 -08001999 sx_start_board(board);
2000 udelay(10);
2001 if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
2002 printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 return 0;
2004 }
2005
2006 /* Ok. So now the processor on the card is running. It gathered
2007 some info for us... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002008 sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
2009 if (sx_debug & SX_DEBUG_INIT)
2010 my_hd_io(board->base, 0x10);
2011 sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
2012 if (sx_debug & SX_DEBUG_INIT)
2013 my_hd_io(board->base + 0x80, 0x30);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014
Jiri Slaby15b611f2006-12-08 02:39:04 -08002015 sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
2016 "V%x.%02x,\n",
2017 read_sx_byte(board, 0), read_sx_byte(board, 1),
2018 read_sx_byte(board, 5), read_sx_byte(board, 4));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019
Jiri Slaby15b611f2006-12-08 02:39:04 -08002020 if (read_sx_byte(board, 0) == 0xff) {
2021 printk(KERN_INFO "sx: No modules found. Sorry.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 board->nports = 0;
2023 return 0;
2024 }
2025
2026 chans = 0;
2027
2028 if (IS_SX_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002029 sx_write_board_word(board, cc_int_count, sx_maxints);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 } else {
2031 if (sx_maxints)
Jiri Slaby15b611f2006-12-08 02:39:04 -08002032 sx_write_board_word(board, cc_int_count,
2033 SI_PROCESSOR_CLOCK / 8 / sx_maxints);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 }
2035
2036 /* grab the first module type... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002037 /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
2038 board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
2039 mc_chip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040
2041 /* XXX byteorder */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002042 for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
2043 type = sx_read_module_byte(board, addr, mc_chip);
2044 sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
2045 addr, read_sx_byte(board, addr + 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046
Jiri Slaby15b611f2006-12-08 02:39:04 -08002047 chans += sx_read_module_byte(board, addr, mc_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048
Jiri Slaby15b611f2006-12-08 02:39:04 -08002049 sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
2050 "panels\n",
2051 mod_type_s(type),
2052 pan_type_s(sx_read_module_byte(board, addr,
2053 mc_mods) & 0xf),
2054 pan_type_s(sx_read_module_byte(board, addr,
2055 mc_mods) >> 4));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056
Jiri Slaby15b611f2006-12-08 02:39:04 -08002057 sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
2058 "version: %x\n",
2059 sx_read_module_byte(board, addr, mc_rev1),
2060 sx_read_module_byte(board, addr, mc_rev2),
2061 sx_read_module_byte(board, addr, mc_mtaasic_rev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062
2063 /* The following combinations are illegal: It should theoretically
2064 work, but timing problems make the bus HANG. */
2065
Jiri Slaby15b611f2006-12-08 02:39:04 -08002066 if (mod_compat_type(type) != board->ta_type) {
2067 printk(KERN_ERR "sx: This is an invalid "
2068 "configuration.\nDon't mix TA/MTA/SXDC on the "
2069 "same hostadapter.\n");
2070 chans = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 break;
2072 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002073 if ((IS_EISA_BOARD(board) ||
2074 IS_SI_BOARD(board)) &&
2075 (mod_compat_type(type) == 4)) {
2076 printk(KERN_ERR "sx: This is an invalid "
2077 "configuration.\nDon't use SXDCs on an SI/XIO "
2078 "adapter.\n");
2079 chans = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 break;
2081 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002082#if 0 /* Problem fixed: firmware 3.05 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 if (IS_SX_BOARD(board) && (type == TA8)) {
2084 /* There are some issues with the firmware and the DCD/RTS
2085 lines. It might work if you tie them together or something.
Jiri Slaby15b611f2006-12-08 02:39:04 -08002086 It might also work if you get a newer sx_firmware. Therefore
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 this is just a warning. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002088 printk(KERN_WARNING
2089 "sx: The SX host doesn't work too well "
2090 "with the TA8 adapters.\nSpecialix is working on it.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 }
2092#endif
2093 }
2094
2095 if (chans) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002096 if (board->irq > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 /* fixed irq, probably PCI */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002098 if (sx_irqmask & (1 << board->irq)) { /* may we use this irq? */
2099 if (request_irq(board->irq, sx_interrupt,
2100 IRQF_SHARED | IRQF_DISABLED,
2101 "sx", board)) {
2102 printk(KERN_ERR "sx: Cannot allocate "
2103 "irq %d.\n", board->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 board->irq = 0;
2105 }
2106 } else
2107 board->irq = 0;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002108 } else if (board->irq < 0 && sx_irqmask) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 /* auto-allocate irq */
2110 int irqnr;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002111 int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
2112 SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
2113 for (irqnr = 15; irqnr > 0; irqnr--)
2114 if (irqmask & (1 << irqnr))
2115 if (!request_irq(irqnr, sx_interrupt,
2116 IRQF_SHARED | IRQF_DISABLED,
2117 "sx", board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 break;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002119 if (!irqnr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2121 board->irq = irqnr;
2122 } else
2123 board->irq = 0;
2124
2125 if (board->irq) {
2126 /* Found a valid interrupt, start up interrupts! */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002127 sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
2128 board->irq);
2129 sx_start_interrupts(board);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 board->poll = sx_slowpoll;
2131 board->flags |= SX_IRQ_ALLOCATED;
2132 } else {
2133 /* no irq: setup board for polled operation */
2134 board->poll = sx_poll;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002135 sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
2136 board->poll);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 }
2138
Jiri Slaby15b611f2006-12-08 02:39:04 -08002139 /* The timer should be initialized anyway: That way we can
2140 safely del_timer it when the module is unloaded. */
Jiri Slabyc9594642006-12-08 02:39:05 -08002141 setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142
Jiri Slabyc9594642006-12-08 02:39:05 -08002143 if (board->poll)
2144 mod_timer(&board->timer, jiffies + board->poll);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 } else {
2146 board->irq = 0;
2147 }
2148
2149 board->nports = chans;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002150 sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151
2152 func_exit();
2153 return chans;
2154}
2155
Jiri Slabycda52652006-12-08 02:39:00 -08002156static void __devinit printheader(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157{
2158 static int header_printed;
2159
2160 if (!header_printed) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002161 printk(KERN_INFO "Specialix SX driver "
2162 "(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
2163 printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 header_printed = 1;
2165 }
2166}
2167
Jiri Slaby15b611f2006-12-08 02:39:04 -08002168static int __devinit probe_sx(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169{
2170 struct vpd_prom vpdp;
2171 char *p;
2172 int i;
2173
2174 func_enter();
2175
Jiri Slaby15b611f2006-12-08 02:39:04 -08002176 if (!IS_CF_BOARD(board)) {
2177 sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2178 board->base + SX_VPD_ROM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179
2180 if (sx_debug & SX_DEBUG_PROBE)
2181 my_hd_io(board->base + SX_VPD_ROM, 0x40);
2182
Jiri Slaby15b611f2006-12-08 02:39:04 -08002183 p = (char *)&vpdp;
2184 for (i = 0; i < sizeof(struct vpd_prom); i++)
2185 *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186
2187 if (sx_debug & SX_DEBUG_PROBE)
Jiri Slaby15b611f2006-12-08 02:39:04 -08002188 my_hd(&vpdp, 0x20);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189
Jiri Slaby15b611f2006-12-08 02:39:04 -08002190 sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
Jiri Slaby15b611f2006-12-08 02:39:04 -08002192 if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2193 sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
2194 "'%s'\n", vpdp.identifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 return 0;
2196 }
2197 }
2198
Jiri Slaby15b611f2006-12-08 02:39:04 -08002199 printheader();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200
Jiri Slaby15b611f2006-12-08 02:39:04 -08002201 if (!IS_CF_BOARD(board)) {
2202 printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
2203 board->hw_base);
2204 printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
2205 "uniq ID:%08x, ",
2206 vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2207 printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208
Jiri Slaby15b611f2006-12-08 02:39:04 -08002209 if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
2210 SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
2211 SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2212 /* This might be a bit harsh. This was the primary
2213 reason the SX/ISA card didn't work at first... */
2214 printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
2215 "card. Sorry: giving up.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 return (0);
2217 }
2218
Jiri Slaby15b611f2006-12-08 02:39:04 -08002219 if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
2220 SX_ISA_UNIQUEID1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 if (((unsigned long)board->hw_base) & 0x8000) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002222 printk(KERN_WARNING "sx: Warning: There may be "
2223 "hardware problems with the card at "
2224 "%lx.\n", board->hw_base);
2225 printk(KERN_WARNING "sx: Read sx.txt for more "
2226 "info.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 }
2228 }
2229 }
2230
2231 board->nports = -1;
2232
2233 /* This resets the processor, and keeps it off the bus. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002234 if (!sx_reset(board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 return 0;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002236 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 func_exit();
2239 return 1;
2240}
2241
Jiri Slaby927a6f92006-12-08 02:39:02 -08002242#if defined(CONFIG_ISA) || defined(CONFIG_EISA)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243
2244/* Specialix probes for this card at 32k increments from 640k to 16M.
2245 I consider machines with less than 16M unlikely nowadays, so I'm
2246 not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2247 card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves
2248 0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2249
Jiri Slaby15b611f2006-12-08 02:39:04 -08002250static int __devinit probe_si(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251{
2252 int i;
2253
2254 func_enter();
Jiri Slaby15b611f2006-12-08 02:39:04 -08002255 sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
2256 "%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257
2258 if (sx_debug & SX_DEBUG_PROBE)
2259 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2260
2261 if (!IS_EISA_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002262 if (IS_SI1_BOARD(board)) {
2263 for (i = 0; i < 8; i++) {
2264 write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
2265 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002267 for (i = 0; i < 8; i++) {
2268 if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
2269 != i) {
2270 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 return 0;
2272 }
2273 }
2274 }
2275
2276 /* Now we're pretty much convinced that there is an SI board here,
2277 but to prevent trouble, we'd better double check that we don't
2278 have an SI1 board when we're probing for an SI2 board.... */
2279
Jiri Slaby15b611f2006-12-08 02:39:04 -08002280 write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2281 if (IS_SI1_BOARD(board)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 /* This should be an SI1 board, which has this
2283 location writable... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002284 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2285 func_exit();
2286 return 0;
Marc Zyngier04a3d312006-02-26 12:02:56 +01002287 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 } else {
2289 /* This should be an SI2 board, which has the bottom
2290 3 bits non-writable... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002291 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2292 func_exit();
2293 return 0;
Marc Zyngier04a3d312006-02-26 12:02:56 +01002294 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 }
2296
2297 /* Now we're pretty much convinced that there is an SI board here,
2298 but to prevent trouble, we'd better double check that we don't
2299 have an SI1 board when we're probing for an SI2 board.... */
2300
Jiri Slaby15b611f2006-12-08 02:39:04 -08002301 write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2302 if (IS_SI1_BOARD(board)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 /* This should be an SI1 board, which has this
2304 location writable... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002305 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 func_exit();
Jiri Slaby15b611f2006-12-08 02:39:04 -08002307 return 0;
Marc Zyngier04a3d312006-02-26 12:02:56 +01002308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 } else {
2310 /* This should be an SI2 board, which has the bottom
2311 3 bits non-writable... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002312 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2313 func_exit();
2314 return 0;
Marc Zyngier04a3d312006-02-26 12:02:56 +01002315 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 }
2317
Jiri Slaby15b611f2006-12-08 02:39:04 -08002318 printheader();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
Jiri Slaby15b611f2006-12-08 02:39:04 -08002320 printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 /* Compared to the SX boards, it is a complete guess as to what
Jiri Slaby15b611f2006-12-08 02:39:04 -08002322 this card is up to... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323
2324 board->nports = -1;
2325
2326 /* This resets the processor, and keeps it off the bus. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002327 if (!sx_reset(board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 return 0;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002329 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 func_exit();
2332 return 1;
2333}
Jiri Slaby927a6f92006-12-08 02:39:02 -08002334#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335
Jeff Dikeb68e31d2006-10-02 02:17:18 -07002336static const struct tty_operations sx_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 .break_ctl = sx_break,
Jiri Slaby15b611f2006-12-08 02:39:04 -08002338 .open = sx_open,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 .close = gs_close,
2340 .write = gs_write,
2341 .put_char = gs_put_char,
2342 .flush_chars = gs_flush_chars,
2343 .write_room = gs_write_room,
2344 .chars_in_buffer = gs_chars_in_buffer,
2345 .flush_buffer = gs_flush_buffer,
2346 .ioctl = sx_ioctl,
2347 .throttle = sx_throttle,
2348 .unthrottle = sx_unthrottle,
2349 .set_termios = gs_set_termios,
2350 .stop = gs_stop,
2351 .start = gs_start,
2352 .hangup = gs_hangup,
2353 .tiocmget = sx_tiocmget,
2354 .tiocmset = sx_tiocmset,
2355};
2356
Alan Cox31f35932009-01-02 13:45:05 +00002357static const struct tty_port_operations sx_port_ops = {
2358 .carrier_raised = sx_carrier_raised,
2359};
2360
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361static int sx_init_drivers(void)
2362{
2363 int error;
2364
2365 func_enter();
2366
2367 sx_driver = alloc_tty_driver(sx_nports);
2368 if (!sx_driver)
2369 return 1;
2370 sx_driver->owner = THIS_MODULE;
2371 sx_driver->driver_name = "specialix_sx";
2372 sx_driver->name = "ttyX";
2373 sx_driver->major = SX_NORMAL_MAJOR;
2374 sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2375 sx_driver->subtype = SERIAL_TYPE_NORMAL;
2376 sx_driver->init_termios = tty_std_termios;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002377 sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
Alan Cox606d0992006-12-08 02:38:45 -08002378 sx_driver->init_termios.c_ispeed = 9600;
2379 sx_driver->init_termios.c_ospeed = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 sx_driver->flags = TTY_DRIVER_REAL_RAW;
2381 tty_set_operations(sx_driver, &sx_ops);
2382
2383 if ((error = tty_register_driver(sx_driver))) {
2384 put_tty_driver(sx_driver);
2385 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
Jiri Slaby15b611f2006-12-08 02:39:04 -08002386 error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 return 1;
2388 }
2389 func_exit();
2390 return 0;
2391}
2392
Jiri Slaby15b611f2006-12-08 02:39:04 -08002393static int sx_init_portstructs(int nboards, int nports)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394{
2395 struct sx_board *board;
2396 struct sx_port *port;
2397 int i, j;
2398 int addr, chans;
2399 int portno;
2400
2401 func_enter();
2402
2403 /* Many drivers statically allocate the maximum number of ports
Jiri Slaby15b611f2006-12-08 02:39:04 -08002404 There is no reason not to allocate them dynamically.
2405 Is there? -- REW */
Jiri Slaby4a7cb692006-12-08 02:38:59 -08002406 sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 if (!sx_ports)
2408 return -ENOMEM;
2409
2410 port = sx_ports;
2411 for (i = 0; i < nboards; i++) {
2412 board = &boards[i];
2413 board->ports = port;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002414 for (j = 0; j < boards[i].nports; j++) {
2415 sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
Alan Cox44b7d1b2008-07-16 21:57:18 +01002416 tty_port_init(&port->gs.port);
Alan Cox31f35932009-01-02 13:45:05 +00002417 port->gs.port.ops = &sx_port_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 port->gs.magic = SX_MAGIC;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002419 port->gs.close_delay = HZ / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 port->gs.closing_wait = 30 * HZ;
2421 port->board = board;
2422 port->gs.rd = &sx_real_driver;
2423#ifdef NEW_WRITE_LOCKING
Ingo Molnar81861d72006-03-23 03:00:44 -08002424 port->gs.port_write_mutex = MUTEX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425#endif
Ingo Molnar34af9462006-06-27 02:53:55 -07002426 spin_lock_init(&port->gs.driver_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 /*
2428 * Initializing wait queue
2429 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430 port++;
2431 }
2432 }
2433
2434 port = sx_ports;
2435 portno = 0;
2436 for (i = 0; i < nboards; i++) {
2437 board = &boards[i];
2438 board->port_base = portno;
2439 /* Possibly the configuration was rejected. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002440 sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
2441 board->nports);
2442 if (board->nports <= 0)
2443 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 /* XXX byteorder ?? */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002445 for (addr = 0x80; addr != 0;
2446 addr = read_sx_word(board, addr) & 0x7fff) {
2447 chans = sx_read_module_byte(board, addr, mc_type);
2448 sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
2449 "channels\n", addr, chans);
2450 sx_dprintk(SX_DEBUG_PROBE, "Port at");
2451 for (j = 0; j < chans; j++) {
2452 /* The "sx-way" is the way it SHOULD be done.
2453 That way in the future, the firmware may for
2454 example pack the structures a bit more
2455 efficient. Neil tells me it isn't going to
2456 happen anytime soon though. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457 if (IS_SX_BOARD(board))
Jiri Slaby15b611f2006-12-08 02:39:04 -08002458 port->ch_base = sx_read_module_word(
2459 board, addr + j * 2,
2460 mc_chan_pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 else
Jiri Slaby15b611f2006-12-08 02:39:04 -08002462 port->ch_base = addr + 0x100 + 0x300 *j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463
Jiri Slaby15b611f2006-12-08 02:39:04 -08002464 sx_dprintk(SX_DEBUG_PROBE, " %x",
2465 port->ch_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 port->line = portno++;
2467 port++;
2468 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002469 sx_dprintk(SX_DEBUG_PROBE, "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 }
2471 /* This has to be done earlier. */
2472 /* board->flags |= SX_BOARD_INITIALIZED; */
2473 }
2474
2475 func_exit();
2476 return 0;
2477}
2478
Jiri Slaby18f813e2006-12-08 02:39:01 -08002479static unsigned int sx_find_free_board(void)
2480{
2481 unsigned int i;
2482
Jiri Slaby15b611f2006-12-08 02:39:04 -08002483 for (i = 0; i < SX_NBOARDS; i++)
Jiri Slaby18f813e2006-12-08 02:39:01 -08002484 if (!(boards[i].flags & SX_BOARD_PRESENT))
2485 break;
2486
2487 return i;
2488}
2489
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490static void __exit sx_release_drivers(void)
2491{
2492 func_enter();
2493 tty_unregister_driver(sx_driver);
2494 put_tty_driver(sx_driver);
2495 func_exit();
2496}
2497
Jiri Slaby39103492006-12-08 02:39:07 -08002498static void __devexit sx_remove_card(struct sx_board *board,
2499 struct pci_dev *pdev)
Jiri Slaby18f813e2006-12-08 02:39:01 -08002500{
2501 if (board->flags & SX_BOARD_INITIALIZED) {
2502 /* The board should stop messing with us. (actually I mean the
2503 interrupt) */
2504 sx_reset(board);
2505 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2506 free_irq(board->irq, board);
2507
2508 /* It is safe/allowed to del_timer a non-active timer */
2509 del_timer(&board->timer);
Jiri Slaby30f42182006-12-08 02:39:08 -08002510 if (pdev) {
Jiri Slaby3468a332006-12-13 00:34:20 -08002511#ifdef CONFIG_PCI
Jiri Slabyda1cfe12008-10-18 20:27:44 -07002512 iounmap(board->base2);
Jiri Slaby30f42182006-12-08 02:39:08 -08002513 pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
Jiri Slaby3468a332006-12-13 00:34:20 -08002514#endif
Jiri Slaby30f42182006-12-08 02:39:08 -08002515 } else {
Jiri Slaby39103492006-12-08 02:39:07 -08002516 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002517 release_region(board->hw_base, board->hw_len);
2518 }
Jiri Slaby18f813e2006-12-08 02:39:01 -08002519
Jiri Slaby15b611f2006-12-08 02:39:04 -08002520 board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002521 }
2522}
2523
2524#ifdef CONFIG_EISA
2525
2526static int __devinit sx_eisa_probe(struct device *dev)
2527{
2528 struct eisa_device *edev = to_eisa_device(dev);
2529 struct sx_board *board;
2530 unsigned long eisa_slot = edev->base_addr;
2531 unsigned int i;
2532 int retval = -EIO;
2533
Jiri Slaby42f63842006-12-08 02:39:03 -08002534 mutex_lock(&sx_boards_lock);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002535 i = sx_find_free_board();
Jiri Slaby42f63842006-12-08 02:39:03 -08002536 if (i == SX_NBOARDS) {
2537 mutex_unlock(&sx_boards_lock);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002538 goto err;
Jiri Slaby42f63842006-12-08 02:39:03 -08002539 }
2540 board = &boards[i];
2541 board->flags |= SX_BOARD_PRESENT;
2542 mutex_unlock(&sx_boards_lock);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002543
2544 dev_info(dev, "XIO : Signature found in EISA slot %lu, "
Jiri Slaby15b611f2006-12-08 02:39:04 -08002545 "Product %d Rev %d (REPORT THIS TO LKLM)\n",
2546 eisa_slot >> 12,
2547 inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
2548 inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
Jiri Slaby18f813e2006-12-08 02:39:01 -08002549
Jiri Slaby18f813e2006-12-08 02:39:01 -08002550 board->eisa_base = eisa_slot;
2551 board->flags &= ~SX_BOARD_TYPE;
2552 board->flags |= SI_EISA_BOARD;
2553
2554 board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
Jiri Slaby15b611f2006-12-08 02:39:04 -08002555 inb(eisa_slot + 0xc00)) << 16;
Jiri Slaby30f42182006-12-08 02:39:08 -08002556 board->hw_len = SI2_EISA_WINDOW_LEN;
2557 if (!request_region(board->hw_base, board->hw_len, "sx")) {
2558 dev_err(dev, "can't request region\n");
2559 goto err_flag;
2560 }
Jiri Slaby18f813e2006-12-08 02:39:01 -08002561 board->base2 =
Alan Cox24cb2332008-04-30 00:54:19 -07002562 board->base = ioremap_nocache(board->hw_base, SI2_EISA_WINDOW_LEN);
Jiri Slaby30f42182006-12-08 02:39:08 -08002563 if (!board->base) {
2564 dev_err(dev, "can't remap memory\n");
2565 goto err_reg;
2566 }
Jiri Slaby18f813e2006-12-08 02:39:01 -08002567
2568 sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2569 sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2570 board->irq = inb(eisa_slot + 0xc02) >> 4;
2571 sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2572
2573 if (!probe_si(board))
2574 goto err_unmap;
2575
2576 dev_set_drvdata(dev, board);
2577
2578 return 0;
2579err_unmap:
2580 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002581err_reg:
2582 release_region(board->hw_base, board->hw_len);
2583err_flag:
Jiri Slaby42f63842006-12-08 02:39:03 -08002584 board->flags &= ~SX_BOARD_PRESENT;
Jiri Slaby18f813e2006-12-08 02:39:01 -08002585err:
2586 return retval;
2587}
2588
2589static int __devexit sx_eisa_remove(struct device *dev)
2590{
2591 struct sx_board *board = dev_get_drvdata(dev);
2592
Jiri Slaby39103492006-12-08 02:39:07 -08002593 sx_remove_card(board, NULL);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002594
2595 return 0;
2596}
2597
2598static struct eisa_device_id sx_eisa_tbl[] = {
2599 { "SLX" },
2600 { "" }
2601};
Jiri Slaby15b611f2006-12-08 02:39:04 -08002602
Jiri Slaby18f813e2006-12-08 02:39:01 -08002603MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2604
2605static struct eisa_driver sx_eisadriver = {
2606 .id_table = sx_eisa_tbl,
2607 .driver = {
2608 .name = "sx",
2609 .probe = sx_eisa_probe,
2610 .remove = __devexit_p(sx_eisa_remove),
2611 }
2612};
2613
2614#endif
2615
Jiri Slaby3468a332006-12-13 00:34:20 -08002616#ifdef CONFIG_PCI
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 /********************************************************
2618 * Setting bit 17 in the CNTRL register of the PLX 9050 *
2619 * chip forces a retry on writes while a read is pending.*
2620 * This is to prevent the card locking up on Intel Xeon *
2621 * multiprocessor systems with the NX chipset. -- NV *
2622 ********************************************************/
2623
2624/* Newer cards are produced with this bit set from the configuration
2625 EEprom. As the bit is read/write for the CPU, we can fix it here,
2626 if we detect that it isn't set correctly. -- REW */
2627
Jiri Slabycda52652006-12-08 02:39:00 -08002628static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629{
2630 unsigned int hwbase;
2631 void __iomem *rebase;
2632 unsigned int t;
2633
Jiri Slaby15b611f2006-12-08 02:39:04 -08002634#define CNTRL_REG_OFFSET 0x50
2635#define CNTRL_REG_GOODVALUE 0x18260000
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636
2637 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2638 hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
Alan Cox24cb2332008-04-30 00:54:19 -07002639 rebase = ioremap_nocache(hwbase, 0x80);
Jiri Slaby15b611f2006-12-08 02:39:04 -08002640 t = readl(rebase + CNTRL_REG_OFFSET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641 if (t != CNTRL_REG_GOODVALUE) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002642 printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
2643 "%08x\n", t, CNTRL_REG_GOODVALUE);
2644 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 }
2646 iounmap(rebase);
2647}
Jiri Slaby3468a332006-12-13 00:34:20 -08002648#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649
Jiri Slaby5572e102006-12-08 02:38:58 -08002650static int __devinit sx_pci_probe(struct pci_dev *pdev,
Jiri Slaby15b611f2006-12-08 02:39:04 -08002651 const struct pci_device_id *ent)
Jiri Slaby5572e102006-12-08 02:38:58 -08002652{
Jiri Slaby3468a332006-12-13 00:34:20 -08002653#ifdef CONFIG_PCI
Jiri Slaby5572e102006-12-08 02:38:58 -08002654 struct sx_board *board;
Jiri Slaby39103492006-12-08 02:39:07 -08002655 unsigned int i, reg;
Jiri Slaby5572e102006-12-08 02:38:58 -08002656 int retval = -EIO;
2657
Jiri Slaby42f63842006-12-08 02:39:03 -08002658 mutex_lock(&sx_boards_lock);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002659 i = sx_find_free_board();
Jiri Slaby42f63842006-12-08 02:39:03 -08002660 if (i == SX_NBOARDS) {
2661 mutex_unlock(&sx_boards_lock);
Jiri Slaby5572e102006-12-08 02:38:58 -08002662 goto err;
Jiri Slaby42f63842006-12-08 02:39:03 -08002663 }
2664 board = &boards[i];
2665 board->flags |= SX_BOARD_PRESENT;
2666 mutex_unlock(&sx_boards_lock);
Jiri Slaby5572e102006-12-08 02:38:58 -08002667
2668 retval = pci_enable_device(pdev);
2669 if (retval)
Jiri Slaby42f63842006-12-08 02:39:03 -08002670 goto err_flag;
Jiri Slaby5572e102006-12-08 02:38:58 -08002671
2672 board->flags &= ~SX_BOARD_TYPE;
2673 board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
Jiri Slaby15b611f2006-12-08 02:39:04 -08002674 SX_CFPCI_BOARD;
Jiri Slaby5572e102006-12-08 02:38:58 -08002675
2676 /* CF boards use base address 3.... */
Jiri Slaby39103492006-12-08 02:39:07 -08002677 reg = IS_CF_BOARD(board) ? 3 : 2;
Jiri Slaby30f42182006-12-08 02:39:08 -08002678 retval = pci_request_region(pdev, reg, "sx");
2679 if (retval) {
2680 dev_err(&pdev->dev, "can't request region\n");
2681 goto err_flag;
2682 }
Jiri Slaby39103492006-12-08 02:39:07 -08002683 board->hw_base = pci_resource_start(pdev, reg);
Jiri Slaby5572e102006-12-08 02:38:58 -08002684 board->base2 =
Jiri Slabyda1cfe12008-10-18 20:27:44 -07002685 board->base = ioremap_nocache(board->hw_base, WINDOW_LEN(board));
Jiri Slaby5572e102006-12-08 02:38:58 -08002686 if (!board->base) {
2687 dev_err(&pdev->dev, "ioremap failed\n");
Jiri Slaby30f42182006-12-08 02:39:08 -08002688 goto err_reg;
Jiri Slaby5572e102006-12-08 02:38:58 -08002689 }
2690
2691 /* Most of the stuff on the CF board is offset by 0x18000 .... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002692 if (IS_CF_BOARD(board))
Jiri Slaby5572e102006-12-08 02:38:58 -08002693 board->base += 0x18000;
2694
2695 board->irq = pdev->irq;
2696
2697 dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
Jiri Slaby15b611f2006-12-08 02:39:04 -08002698 board->irq, board->flags);
Jiri Slaby5572e102006-12-08 02:38:58 -08002699
2700 if (!probe_sx(board)) {
2701 retval = -EIO;
2702 goto err_unmap;
2703 }
2704
2705 fix_sx_pci(pdev, board);
2706
2707 pci_set_drvdata(pdev, board);
2708
2709 return 0;
2710err_unmap:
Jiri Slabyda1cfe12008-10-18 20:27:44 -07002711 iounmap(board->base2);
Jiri Slaby30f42182006-12-08 02:39:08 -08002712err_reg:
2713 pci_release_region(pdev, reg);
Jiri Slaby42f63842006-12-08 02:39:03 -08002714err_flag:
2715 board->flags &= ~SX_BOARD_PRESENT;
Jiri Slaby5572e102006-12-08 02:38:58 -08002716err:
2717 return retval;
Jiri Slaby3468a332006-12-13 00:34:20 -08002718#else
2719 return -ENODEV;
2720#endif
Jiri Slaby5572e102006-12-08 02:38:58 -08002721}
2722
2723static void __devexit sx_pci_remove(struct pci_dev *pdev)
2724{
2725 struct sx_board *board = pci_get_drvdata(pdev);
2726
Jiri Slaby39103492006-12-08 02:39:07 -08002727 sx_remove_card(board, pdev);
Jiri Slaby5572e102006-12-08 02:38:58 -08002728}
2729
2730/* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
2731 its because the standard requires it. So check for SUBVENDOR_ID. */
2732static struct pci_device_id sx_pci_tbl[] = {
2733 { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
Jiri Slabyc14d4442007-07-10 17:22:25 -07002734 .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
Jiri Slaby5572e102006-12-08 02:38:58 -08002735 { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
Jiri Slabyc14d4442007-07-10 17:22:25 -07002736 .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
Jiri Slaby5572e102006-12-08 02:38:58 -08002737 { 0 }
2738};
Jiri Slaby15b611f2006-12-08 02:39:04 -08002739
Jiri Slaby5572e102006-12-08 02:38:58 -08002740MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2741
2742static struct pci_driver sx_pcidriver = {
2743 .name = "sx",
2744 .id_table = sx_pci_tbl,
2745 .probe = sx_pci_probe,
2746 .remove = __devexit_p(sx_pci_remove)
2747};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748
Jiri Slaby15b611f2006-12-08 02:39:04 -08002749static int __init sx_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750{
Jiri Slaby18f813e2006-12-08 02:39:01 -08002751#ifdef CONFIG_EISA
2752 int retval1;
2753#endif
Jiri Slaby927a6f92006-12-08 02:39:02 -08002754#ifdef CONFIG_ISA
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 struct sx_board *board;
Jiri Slaby927a6f92006-12-08 02:39:02 -08002756 unsigned int i;
2757#endif
2758 unsigned int found = 0;
2759 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761 func_enter();
Jiri Slaby15b611f2006-12-08 02:39:04 -08002762 sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
2763 sx_debug);
2764 if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
2765 printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
2766 "value. Assuming -1.\n(%p)\n", &sx_debug);
2767 sx_debug = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 }
2769
2770 if (misc_register(&sx_fw_device) < 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002771 printk(KERN_ERR "SX: Unable to register firmware loader "
2772 "driver.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773 return -EIO;
2774 }
Jiri Slaby927a6f92006-12-08 02:39:02 -08002775#ifdef CONFIG_ISA
Jiri Slaby15b611f2006-12-08 02:39:04 -08002776 for (i = 0; i < NR_SX_ADDRS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777 board = &boards[found];
2778 board->hw_base = sx_probe_addrs[i];
Jiri Slaby30f42182006-12-08 02:39:08 -08002779 board->hw_len = SX_WINDOW_LEN;
2780 if (!request_region(board->hw_base, board->hw_len, "sx"))
2781 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 board->base2 =
Alan Cox24cb2332008-04-30 00:54:19 -07002783 board->base = ioremap_nocache(board->hw_base, board->hw_len);
Jiri Slaby30f42182006-12-08 02:39:08 -08002784 if (!board->base)
2785 goto err_sx_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 board->flags &= ~SX_BOARD_TYPE;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002787 board->flags |= SX_ISA_BOARD;
2788 board->irq = sx_irqmask ? -1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789
Jiri Slaby15b611f2006-12-08 02:39:04 -08002790 if (probe_sx(board)) {
Jiri Slaby42f63842006-12-08 02:39:03 -08002791 board->flags |= SX_BOARD_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 found++;
2793 } else {
2794 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002795err_sx_reg:
2796 release_region(board->hw_base, board->hw_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 }
2798 }
2799
Jiri Slaby15b611f2006-12-08 02:39:04 -08002800 for (i = 0; i < NR_SI_ADDRS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 board = &boards[found];
2802 board->hw_base = si_probe_addrs[i];
Jiri Slaby30f42182006-12-08 02:39:08 -08002803 board->hw_len = SI2_ISA_WINDOW_LEN;
2804 if (!request_region(board->hw_base, board->hw_len, "sx"))
2805 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806 board->base2 =
Alan Cox24cb2332008-04-30 00:54:19 -07002807 board->base = ioremap_nocache(board->hw_base, board->hw_len);
Jiri Slaby30f42182006-12-08 02:39:08 -08002808 if (!board->base)
2809 goto err_si_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810 board->flags &= ~SX_BOARD_TYPE;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002811 board->flags |= SI_ISA_BOARD;
2812 board->irq = sx_irqmask ? -1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813
Jiri Slaby15b611f2006-12-08 02:39:04 -08002814 if (probe_si(board)) {
Jiri Slaby42f63842006-12-08 02:39:03 -08002815 board->flags |= SX_BOARD_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816 found++;
2817 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002818 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002819err_si_reg:
2820 release_region(board->hw_base, board->hw_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 }
2822 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002823 for (i = 0; i < NR_SI1_ADDRS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 board = &boards[found];
2825 board->hw_base = si1_probe_addrs[i];
Jiri Slaby30f42182006-12-08 02:39:08 -08002826 board->hw_len = SI1_ISA_WINDOW_LEN;
2827 if (!request_region(board->hw_base, board->hw_len, "sx"))
2828 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 board->base2 =
Alan Cox24cb2332008-04-30 00:54:19 -07002830 board->base = ioremap_nocache(board->hw_base, board->hw_len);
Jiri Slaby30f42182006-12-08 02:39:08 -08002831 if (!board->base)
2832 goto err_si1_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 board->flags &= ~SX_BOARD_TYPE;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002834 board->flags |= SI1_ISA_BOARD;
2835 board->irq = sx_irqmask ? -1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002836
Jiri Slaby15b611f2006-12-08 02:39:04 -08002837 if (probe_si(board)) {
Jiri Slaby42f63842006-12-08 02:39:03 -08002838 board->flags |= SX_BOARD_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839 found++;
2840 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002841 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002842err_si1_reg:
2843 release_region(board->hw_base, board->hw_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 }
2845 }
Jiri Slaby927a6f92006-12-08 02:39:02 -08002846#endif
Jiri Slaby18f813e2006-12-08 02:39:01 -08002847#ifdef CONFIG_EISA
2848 retval1 = eisa_driver_register(&sx_eisadriver);
2849#endif
Jiri Slaby5572e102006-12-08 02:38:58 -08002850 retval = pci_register_driver(&sx_pcidriver);
2851
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 if (found) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002853 printk(KERN_INFO "sx: total of %d boards detected.\n", found);
Jiri Slaby5572e102006-12-08 02:38:58 -08002854 retval = 0;
2855 } else if (retval) {
Jiri Slaby18f813e2006-12-08 02:39:01 -08002856#ifdef CONFIG_EISA
Jiri Slaby7eb99762006-12-08 02:39:06 -08002857 retval = retval1;
Jiri Slaby18f813e2006-12-08 02:39:01 -08002858 if (retval1)
2859#endif
Jiri Slaby15b611f2006-12-08 02:39:04 -08002860 misc_deregister(&sx_fw_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 }
2862
2863 func_exit();
Jiri Slaby5572e102006-12-08 02:38:58 -08002864 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865}
2866
Jiri Slaby15b611f2006-12-08 02:39:04 -08002867static void __exit sx_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868{
Jiri Slaby15b611f2006-12-08 02:39:04 -08002869 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870
2871 func_enter();
Jiri Slaby18f813e2006-12-08 02:39:01 -08002872#ifdef CONFIG_EISA
2873 eisa_driver_unregister(&sx_eisadriver);
2874#endif
Jiri Slaby5572e102006-12-08 02:38:58 -08002875 pci_unregister_driver(&sx_pcidriver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876
Jiri Slaby55e70712006-12-08 02:39:03 -08002877 for (i = 0; i < SX_NBOARDS; i++)
Jiri Slaby39103492006-12-08 02:39:07 -08002878 sx_remove_card(&boards[i], NULL);
Jiri Slaby55e70712006-12-08 02:39:03 -08002879
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880 if (misc_deregister(&sx_fw_device) < 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002881 printk(KERN_INFO "sx: couldn't deregister firmware loader "
2882 "device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002884 sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
2885 sx_initialized);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 if (sx_initialized)
Jiri Slaby15b611f2006-12-08 02:39:04 -08002887 sx_release_drivers();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888
Jiri Slaby15b611f2006-12-08 02:39:04 -08002889 kfree(sx_ports);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890 func_exit();
2891}
2892
2893module_init(sx_init);
2894module_exit(sx_exit);