blob: 85a23283dff55144b594ae86b6a87100814fdf66 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001
2/* sx.c -- driver for the Specialix SX series cards.
3 *
4 * This driver will also support the older SI, and XIO cards.
5 *
6 *
7 * (C) 1998 - 2004 R.E.Wolff@BitWizard.nl
8 *
9 * Simon Allen (simonallen@cix.compulink.co.uk) wrote a previous
10 * version of this driver. Some fragments may have been copied. (none
11 * yet :-)
12 *
13 * Specialix pays for the development and support of this driver.
14 * Please DO contact support@specialix.co.uk if you require
15 * support. But please read the documentation (sx.txt) first.
16 *
17 *
18 *
19 * This program is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU General Public License as
21 * published by the Free Software Foundation; either version 2 of
22 * the License, or (at your option) any later version.
23 *
24 * This program is distributed in the hope that it will be
25 * useful, but WITHOUT ANY WARRANTY; without even the implied
26 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
27 * PURPOSE. See the GNU General Public License for more details.
28 *
29 * You should have received a copy of the GNU General Public
30 * License along with this program; if not, write to the Free
31 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
32 * USA.
33 *
34 * Revision history:
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 * Revision 1.33 2000/03/09 10:00:00 pvdl,wolff
36 * - Fixed module and port counting
37 * - Fixed signal handling
38 * - Fixed an Ooops
39 *
40 * Revision 1.32 2000/03/07 09:00:00 wolff,pvdl
41 * - Fixed some sx_dprintk typos
42 * - added detection for an invalid board/module configuration
43 *
44 * Revision 1.31 2000/03/06 12:00:00 wolff,pvdl
45 * - Added support for EISA
46 *
47 * Revision 1.30 2000/01/21 17:43:06 wolff
48 * - Added support for SX+
49 *
50 * Revision 1.26 1999/08/05 15:22:14 wolff
51 * - Port to 2.3.x
52 * - Reformatted to Linus' liking.
53 *
54 * Revision 1.25 1999/07/30 14:24:08 wolff
55 * Had accidentally left "gs_debug" set to "-1" instead of "off" (=0).
56 *
57 * Revision 1.24 1999/07/28 09:41:52 wolff
58 * - I noticed the remark about use-count straying in sx.txt. I checked
59 * sx_open, and found a few places where that could happen. I hope it's
60 * fixed now.
61 *
62 * Revision 1.23 1999/07/28 08:56:06 wolff
63 * - Fixed crash when sx_firmware run twice.
64 * - Added sx_slowpoll as a module parameter (I guess nobody really wanted
65 * to change it from the default... )
66 * - Fixed a stupid editing problem I introduced in 1.22.
67 * - Fixed dropping characters on a termios change.
68 *
69 * Revision 1.22 1999/07/26 21:01:43 wolff
70 * Russell Brown noticed that I had overlooked 4 out of six modem control
71 * signals in sx_getsignals. Ooops.
72 *
73 * Revision 1.21 1999/07/23 09:11:33 wolff
74 * I forgot to free dynamically allocated memory when the driver is unloaded.
75 *
76 * Revision 1.20 1999/07/20 06:25:26 wolff
77 * The "closing wait" wasn't honoured. Thanks to James Griffiths for
78 * reporting this.
79 *
80 * Revision 1.19 1999/07/11 08:59:59 wolff
81 * Fixed an oops in close, when an open was pending. Changed the memtest
82 * a bit. Should also test the board in word-mode, however my card fails the
83 * memtest then. I still have to figure out what is wrong...
84 *
85 * Revision 1.18 1999/06/10 09:38:42 wolff
86 * Changed the format of the firmware revision from %04x to %x.%02x .
87 *
88 * Revision 1.17 1999/06/04 09:44:35 wolff
89 * fixed problem: reference to pci stuff when config_pci was off...
90 * Thanks to Jorge Novo for noticing this.
91 *
92 * Revision 1.16 1999/06/02 08:30:15 wolff
93 * added/removed the workaround for the DCD bug in the Firmware.
94 * A bit more debugging code to locate that...
95 *
96 * Revision 1.15 1999/06/01 11:35:30 wolff
97 * when DCD is left low (floating?), on TA's the firmware first tells us
98 * that DCD is high, but after a short while suddenly comes to the
99 * conclusion that it is low. All this would be fine, if it weren't that
100 * Unix requires us to send a "hangup" signal in that case. This usually
101 * all happens BEFORE the program has had a chance to ioctl the device
102 * into clocal mode..
103 *
104 * Revision 1.14 1999/05/25 11:18:59 wolff
105 * Added PCI-fix.
106 * Added checks for return code of sx_sendcommand.
107 * Don't issue "reconfig" if port isn't open yet. (bit us on TA modules...)
108 *
109 * Revision 1.13 1999/04/29 15:18:01 wolff
110 * Fixed an "oops" that showed on SuSE 6.0 systems.
111 * Activate DTR again after stty 0.
112 *
113 * Revision 1.12 1999/04/29 07:49:52 wolff
114 * Improved "stty 0" handling a bit. (used to change baud to 9600 assuming
115 * the connection would be dropped anyway. That is not always the case,
116 * and confuses people).
117 * Told the card to always monitor the modem signals.
118 * Added support for dynamic gs_debug adjustments.
119 * Now tells the rest of the system the number of ports.
120 *
121 * Revision 1.11 1999/04/24 11:11:30 wolff
122 * Fixed two stupid typos in the memory test.
123 *
124 * Revision 1.10 1999/04/24 10:53:39 wolff
125 * Added some of Christian's suggestions.
126 * Fixed an HW_COOK_IN bug (ISIG was not in I_OTHER. We used to trust the
127 * card to send the signal to the process.....)
128 *
129 * Revision 1.9 1999/04/23 07:26:38 wolff
130 * Included Christian Lademann's 2.0 compile-warning fixes and interrupt
131 * assignment redesign.
132 * Cleanup of some other stuff.
133 *
134 * Revision 1.8 1999/04/16 13:05:30 wolff
135 * fixed a DCD change unnoticed bug.
136 *
137 * Revision 1.7 1999/04/14 22:19:51 wolff
138 * Fixed typo that showed up in 2.0.x builds (get_user instead of Get_user!)
139 *
140 * Revision 1.6 1999/04/13 18:40:20 wolff
141 * changed misc-minor to 161, as assigned by HPA.
142 *
143 * Revision 1.5 1999/04/13 15:12:25 wolff
144 * Fixed use-count leak when "hangup" occurred.
145 * Added workaround for a stupid-PCIBIOS bug.
146 *
147 *
148 * Revision 1.4 1999/04/01 22:47:40 wolff
149 * Fixed < 1M linux-2.0 problem.
150 * (vremap isn't compatible with ioremap in that case)
151 *
152 * Revision 1.3 1999/03/31 13:45:45 wolff
153 * Firmware loading is now done through a separate IOCTL.
154 *
155 * Revision 1.2 1999/03/28 12:22:29 wolff
156 * rcs cleanup
157 *
158 * Revision 1.1 1999/03/28 12:10:34 wolff
159 * Readying for release on 2.0.x (sorry David, 1.01 becomes 1.1 for RCS).
160 *
161 * Revision 0.12 1999/03/28 09:20:10 wolff
162 * Fixed problem in 0.11, continueing cleanup.
163 *
164 * Revision 0.11 1999/03/28 08:46:44 wolff
165 * cleanup. Not good.
166 *
167 * Revision 0.10 1999/03/28 08:09:43 wolff
168 * Fixed loosing characters on close.
169 *
170 * Revision 0.9 1999/03/21 22:52:01 wolff
171 * Ported back to 2.2.... (minor things)
172 *
173 * Revision 0.8 1999/03/21 22:40:33 wolff
174 * Port to 2.0
175 *
176 * Revision 0.7 1999/03/21 19:06:34 wolff
177 * Fixed hangup processing.
178 *
179 * Revision 0.6 1999/02/05 08:45:14 wolff
180 * fixed real_raw problems. Inclusion into kernel imminent.
181 *
182 * Revision 0.5 1998/12/21 23:51:06 wolff
183 * Snatched a nasty bug: sx_transmit_chars was getting re-entered, and it
184 * shouldn't have. THATs why I want to have transmit interrupts even when
185 * the buffer is empty.
186 *
187 * Revision 0.4 1998/12/17 09:34:46 wolff
188 * PPP works. ioctl works. Basically works!
189 *
190 * Revision 0.3 1998/12/15 13:05:18 wolff
191 * It works! Wow! Gotta start implementing IOCTL and stuff....
192 *
193 * Revision 0.2 1998/12/01 08:33:53 wolff
194 * moved over to 2.1.130
195 *
196 * Revision 0.1 1998/11/03 21:23:51 wolff
197 * Initial revision. Detects SX card.
198 *
199 * */
200
Jiri Slaby11c83872006-12-08 02:38:56 -0800201#define SX_VERSION 1.33
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204#include <linux/kdev_t.h>
205#include <linux/kernel.h>
206#include <linux/sched.h>
207#include <linux/ioport.h>
208#include <linux/interrupt.h>
209#include <linux/errno.h>
210#include <linux/tty.h>
211#include <linux/tty_flip.h>
212#include <linux/mm.h>
213#include <linux/serial.h>
214#include <linux/fcntl.h>
215#include <linux/major.h>
216#include <linux/delay.h>
Jiri Slaby18f813e2006-12-08 02:39:01 -0800217#include <linux/eisa.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218#include <linux/pci.h>
219#include <linux/slab.h>
220#include <linux/init.h>
221#include <linux/miscdevice.h>
222#include <linux/bitops.h>
223
224#include <asm/io.h>
225#include <asm/uaccess.h>
226
227/* The 3.0.0 version of sxboards/sxwindow.h uses BYTE and WORD.... */
228#define BYTE u8
229#define WORD u16
230
231/* .... but the 3.0.4 version uses _u8 and _u16. */
232#define _u8 u8
233#define _u16 u16
234
235#include "sxboards.h"
236#include "sxwindow.h"
237
238#include <linux/generic_serial.h>
239#include "sx.h"
240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241/* I don't think that this driver can handle more than 256 ports on
242 one machine. You'll have to increase the number of boards in sx.h
243 if you want more than 4 boards. */
244
245#ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
246#define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
247#endif
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249/* Configurable options:
250 (Don't be too sure that it'll work if you toggle them) */
251
252/* Am I paranoid or not ? ;-) */
253#undef SX_PARANOIA_CHECK
254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255/* 20 -> 2000 per second. The card should rate-limit interrupts at 100
256 Hz, but it is user configurable. I don't recommend going above 1000
257 Hz. The interrupt ratelimit might trigger if the interrupt is
258 shared with a very active other device. */
259#define IRQ_RATE_LIMIT 20
260
261/* Sharing interrupts is possible now. If the other device wants more
262 than 2000 interrupts per second, we'd gracefully decline further
263 interrupts. That's not what we want. On the other hand, if the
264 other device interrupts 2000 times a second, don't use the SX
265 interrupt. Use polling. */
266#undef IRQ_RATE_LIMIT
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268#if 0
269/* Not implemented */
270/*
271 * The following defines are mostly for testing purposes. But if you need
272 * some nice reporting in your syslog, you can define them also.
273 */
274#define SX_REPORT_FIFO
275#define SX_REPORT_OVERRUN
Jiri Slaby15b611f2006-12-08 02:39:04 -0800276#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278/* Function prototypes */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800279static void sx_disable_tx_interrupts(void *ptr);
280static void sx_enable_tx_interrupts(void *ptr);
281static void sx_disable_rx_interrupts(void *ptr);
282static void sx_enable_rx_interrupts(void *ptr);
283static int sx_get_CD(void *ptr);
284static void sx_shutdown_port(void *ptr);
285static int sx_set_real_termios(void *ptr);
286static void sx_close(void *ptr);
287static int sx_chars_in_buffer(void *ptr);
288static int sx_init_board(struct sx_board *board);
289static int sx_init_portstructs(int nboards, int nports);
290static int sx_fw_ioctl(struct inode *inode, struct file *filp,
291 unsigned int cmd, unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292static int sx_init_drivers(void);
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294static struct tty_driver *sx_driver;
295
Jiri Slaby42f63842006-12-08 02:39:03 -0800296static DEFINE_MUTEX(sx_boards_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297static struct sx_board boards[SX_NBOARDS];
298static struct sx_port *sx_ports;
299static int sx_initialized;
300static int sx_nports;
301static int sx_debug;
302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303/* You can have the driver poll your card.
304 - Set sx_poll to 1 to poll every timer tick (10ms on Intel).
305 This is used when the card cannot use an interrupt for some reason.
306
307 - set sx_slowpoll to 100 to do an extra poll once a second (on Intel). If
308 the driver misses an interrupt (report this if it DOES happen to you!)
309 everything will continue to work....
310 */
311static int sx_poll = 1;
312static int sx_slowpoll;
313
314/* The card limits the number of interrupts per second.
315 At 115k2 "100" should be sufficient.
316 If you're using higher baudrates, you can increase this...
317 */
318
319static int sx_maxints = 100;
320
Jiri Slaby927a6f92006-12-08 02:39:02 -0800321#ifdef CONFIG_ISA
322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323/* These are the only open spaces in my computer. Yours may have more
324 or less.... -- REW
325 duh: Card at 0xa0000 is possible on HP Netserver?? -- pvdl
326*/
Jiri Slaby15b611f2006-12-08 02:39:04 -0800327static int sx_probe_addrs[] = {
328 0xc0000, 0xd0000, 0xe0000,
329 0xc8000, 0xd8000, 0xe8000
330};
331static int si_probe_addrs[] = {
332 0xc0000, 0xd0000, 0xe0000,
333 0xc8000, 0xd8000, 0xe8000, 0xa0000
334};
335static int si1_probe_addrs[] = {
336 0xd0000
337};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Tobias Klauserfe971072006-01-09 20:54:02 -0800339#define NR_SX_ADDRS ARRAY_SIZE(sx_probe_addrs)
340#define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
341#define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
Jiri Slaby927a6f92006-12-08 02:39:02 -0800343module_param_array(sx_probe_addrs, int, NULL, 0);
344module_param_array(si_probe_addrs, int, NULL, 0);
345#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347/* Set the mask to all-ones. This alas, only supports 32 interrupts.
348 Some architectures may need more. */
349static int sx_irqmask = -1;
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351module_param(sx_poll, int, 0);
352module_param(sx_slowpoll, int, 0);
353module_param(sx_maxints, int, 0);
354module_param(sx_debug, int, 0);
355module_param(sx_irqmask, int, 0);
356
357MODULE_LICENSE("GPL");
358
359static struct real_driver sx_real_driver = {
360 sx_disable_tx_interrupts,
361 sx_enable_tx_interrupts,
362 sx_disable_rx_interrupts,
363 sx_enable_rx_interrupts,
364 sx_get_CD,
Jiri Slaby15b611f2006-12-08 02:39:04 -0800365 sx_shutdown_port,
366 sx_set_real_termios,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 sx_chars_in_buffer,
368 sx_close,
369};
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371/*
372 This driver can spew a whole lot of debugging output at you. If you
373 need maximum performance, you should disable the DEBUG define. To
374 aid in debugging in the field, I'm leaving the compile-time debug
375 features enabled, and disable them "runtime". That allows me to
376 instruct people with problems to enable debugging without requiring
377 them to recompile...
378*/
379#define DEBUG
380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381#ifdef DEBUG
Jiri Slaby15b611f2006-12-08 02:39:04 -0800382#define sx_dprintk(f, str...) if (sx_debug & f) printk (str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383#else
Jiri Slaby15b611f2006-12-08 02:39:04 -0800384#define sx_dprintk(f, str...) /* nothing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385#endif
386
Jiri Slaby15b611f2006-12-08 02:39:04 -0800387#define func_enter() sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__FUNCTION__)
388#define func_exit() sx_dprintk(SX_DEBUG_FLOW, "sx: exit %s\n",__FUNCTION__)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Jiri Slaby15b611f2006-12-08 02:39:04 -0800390#define func_enter2() sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
391 __FUNCTION__, port->line)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393/*
394 * Firmware loader driver specific routines
395 *
396 */
397
Arjan van de Ven62322d22006-07-03 00:24:21 -0700398static const struct file_operations sx_fw_fops = {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800399 .owner = THIS_MODULE,
400 .ioctl = sx_fw_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401};
402
403static struct miscdevice sx_fw_device = {
404 SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
405};
406
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407#ifdef SX_PARANOIA_CHECK
408
409/* This doesn't work. Who's paranoid around here? Not me! */
410
Jiri Slaby15b611f2006-12-08 02:39:04 -0800411static inline int sx_paranoia_check(struct sx_port const *port,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 char *name, const char *routine)
413{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800414 static const char *badmagic = KERN_ERR "sx: Warning: bad sx port magic "
415 "number for device %s in %s\n";
416 static const char *badinfo = KERN_ERR "sx: Warning: null sx port for "
417 "device %s in %s\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 if (!port) {
420 printk(badinfo, name, routine);
421 return 1;
422 }
423 if (port->magic != SX_MAGIC) {
424 printk(badmagic, name, routine);
425 return 1;
426 }
427
428 return 0;
429}
430#else
431#define sx_paranoia_check(a,b,c) 0
432#endif
433
434/* The timeouts. First try 30 times as fast as possible. Then give
435 the card some time to breathe between accesses. (Otherwise the
436 processor on the card might not be able to access its OWN bus... */
437
438#define TIMEOUT_1 30
439#define TIMEOUT_2 1000000
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441#ifdef DEBUG
442static void my_hd_io(void __iomem *p, int len)
443{
444 int i, j, ch;
445 unsigned char __iomem *addr = p;
446
Jiri Slaby15b611f2006-12-08 02:39:04 -0800447 for (i = 0; i < len; i += 16) {
448 printk("%p ", addr + i);
449 for (j = 0; j < 16; j++) {
450 printk("%02x %s", readb(addr + j + i),
451 (j == 7) ? " " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800453 for (j = 0; j < 16; j++) {
454 ch = readb(addr + j + i);
455 printk("%c", (ch < 0x20) ? '.' :
456 ((ch > 0x7f) ? '.' : ch));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800458 printk("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 }
460}
461static void my_hd(void *p, int len)
462{
463 int i, j, ch;
464 unsigned char *addr = p;
465
Jiri Slaby15b611f2006-12-08 02:39:04 -0800466 for (i = 0; i < len; i += 16) {
467 printk("%p ", addr + i);
468 for (j = 0; j < 16; j++) {
469 printk("%02x %s", addr[j + i], (j == 7) ? " " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800471 for (j = 0; j < 16; j++) {
472 ch = addr[j + i];
473 printk("%c", (ch < 0x20) ? '.' :
474 ((ch > 0x7f) ? '.' : ch));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800476 printk("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 }
478}
479#endif
480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481/* This needs redoing for Alpha -- REW -- Done. */
482
Jiri Slaby15b611f2006-12-08 02:39:04 -0800483static inline void write_sx_byte(struct sx_board *board, int offset, u8 byte)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800485 writeb(byte, board->base + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486}
487
Jiri Slaby15b611f2006-12-08 02:39:04 -0800488static inline u8 read_sx_byte(struct sx_board *board, int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800490 return readb(board->base + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491}
492
Jiri Slaby15b611f2006-12-08 02:39:04 -0800493static inline void write_sx_word(struct sx_board *board, int offset, u16 word)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800495 writew(word, board->base + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496}
497
Jiri Slaby15b611f2006-12-08 02:39:04 -0800498static inline u16 read_sx_word(struct sx_board *board, int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800500 return readw(board->base + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
Jiri Slaby15b611f2006-12-08 02:39:04 -0800503static int sx_busy_wait_eq(struct sx_board *board,
504 int offset, int mask, int correctval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
506 int i;
507
Jiri Slaby15b611f2006-12-08 02:39:04 -0800508 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
Jiri Slaby15b611f2006-12-08 02:39:04 -0800510 for (i = 0; i < TIMEOUT_1; i++)
511 if ((read_sx_byte(board, offset) & mask) == correctval) {
512 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 return 1;
514 }
515
Jiri Slaby15b611f2006-12-08 02:39:04 -0800516 for (i = 0; i < TIMEOUT_2; i++) {
517 if ((read_sx_byte(board, offset) & mask) == correctval) {
518 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 return 1;
520 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800521 udelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 }
523
Jiri Slaby15b611f2006-12-08 02:39:04 -0800524 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 return 0;
526}
527
Jiri Slaby15b611f2006-12-08 02:39:04 -0800528static int sx_busy_wait_neq(struct sx_board *board,
529 int offset, int mask, int badval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530{
531 int i;
532
Jiri Slaby15b611f2006-12-08 02:39:04 -0800533 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Jiri Slaby15b611f2006-12-08 02:39:04 -0800535 for (i = 0; i < TIMEOUT_1; i++)
536 if ((read_sx_byte(board, offset) & mask) != badval) {
537 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 return 1;
539 }
540
Jiri Slaby15b611f2006-12-08 02:39:04 -0800541 for (i = 0; i < TIMEOUT_2; i++) {
542 if ((read_sx_byte(board, offset) & mask) != badval) {
543 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 return 1;
545 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800546 udelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 }
548
Jiri Slaby15b611f2006-12-08 02:39:04 -0800549 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 return 0;
551}
552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553/* 5.6.4 of 6210028 r2.3 */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800554static int sx_reset(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800556 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Jiri Slaby15b611f2006-12-08 02:39:04 -0800558 if (IS_SX_BOARD(board)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Jiri Slaby15b611f2006-12-08 02:39:04 -0800560 write_sx_byte(board, SX_CONFIG, 0);
561 write_sx_byte(board, SX_RESET, 1); /* Value doesn't matter */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Jiri Slaby15b611f2006-12-08 02:39:04 -0800563 if (!sx_busy_wait_eq(board, SX_RESET_STATUS, 1, 0)) {
564 printk(KERN_INFO "sx: Card doesn't respond to "
565 "reset...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 return 0;
567 }
568 } else if (IS_EISA_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800569 outb(board->irq << 4, board->eisa_base + 0xc02);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 } else if (IS_SI1_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800571 write_sx_byte(board, SI1_ISA_RESET, 0); /*value doesn't matter*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 } else {
573 /* Gory details of the SI/ISA board */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800574 write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
575 write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
576 write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
577 write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
578 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
579 write_sx_byte(board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 }
581
Jiri Slaby15b611f2006-12-08 02:39:04 -0800582 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 return 1;
584}
585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586/* This doesn't work on machines where "NULL" isn't 0 */
587/* If you have one of those, someone will need to write
588 the equivalent of this, which will amount to about 3 lines. I don't
589 want to complicate this right now. -- REW
590 (See, I do write comments every now and then :-) */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800591#define OFFSETOF(strct, elem) ((long)&(((struct strct *)NULL)->elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Jiri Slaby15b611f2006-12-08 02:39:04 -0800593#define CHAN_OFFSET(port,elem) (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
594#define MODU_OFFSET(board,addr,elem) (addr + OFFSETOF (_SXMODULE, elem))
595#define BRD_OFFSET(board,elem) (OFFSETOF (_SXCARD, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
597#define sx_write_channel_byte(port, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800598 write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
600#define sx_read_channel_byte(port, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800601 read_sx_byte (port->board, CHAN_OFFSET (port, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603#define sx_write_channel_word(port, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800604 write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
606#define sx_read_channel_word(port, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800607 read_sx_word (port->board, CHAN_OFFSET (port, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
609#define sx_write_module_byte(board, addr, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800610 write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
612#define sx_read_module_byte(board, addr, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800613 read_sx_byte (board, MODU_OFFSET (board, addr, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615#define sx_write_module_word(board, addr, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800616 write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
618#define sx_read_module_word(board, addr, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800619 read_sx_word (board, MODU_OFFSET (board, addr, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621#define sx_write_board_byte(board, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800622 write_sx_byte (board, BRD_OFFSET (board, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
624#define sx_read_board_byte(board, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800625 read_sx_byte (board, BRD_OFFSET (board, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626
627#define sx_write_board_word(board, elem, val) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800628 write_sx_word (board, BRD_OFFSET (board, elem), val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630#define sx_read_board_word(board, elem) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800631 read_sx_word (board, BRD_OFFSET (board, elem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
Jiri Slaby15b611f2006-12-08 02:39:04 -0800633static int sx_start_board(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800635 if (IS_SX_BOARD(board)) {
636 write_sx_byte(board, SX_CONFIG, SX_CONF_BUSEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 } else if (IS_EISA_BOARD(board)) {
638 write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
Jiri Slaby15b611f2006-12-08 02:39:04 -0800639 outb((board->irq << 4) | 4, board->eisa_base + 0xc02);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 } else if (IS_SI1_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800641 write_sx_byte(board, SI1_ISA_RESET_CLEAR, 0);
642 write_sx_byte(board, SI1_ISA_INTCL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 } else {
644 /* Don't bug me about the clear_set.
645 I haven't the foggiest idea what it's about -- REW */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800646 write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
647 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 }
649 return 1;
650}
651
652#define SX_IRQ_REG_VAL(board) \
Jiri Slaby15b611f2006-12-08 02:39:04 -0800653 ((board->flags & SX_ISA_BOARD) ? (board->irq << 4) : 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
655/* Note. The SX register is write-only. Therefore, we have to enable the
656 bus too. This is a no-op, if you don't mess with this driver... */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800657static int sx_start_interrupts(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658{
659
660 /* Don't call this with board->irq == 0 */
661
662 if (IS_SX_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800663 write_sx_byte(board, SX_CONFIG, SX_IRQ_REG_VAL(board) |
664 SX_CONF_BUSEN | SX_CONF_HOSTIRQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 } else if (IS_EISA_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800666 inb(board->eisa_base + 0xc03);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 } else if (IS_SI1_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800668 write_sx_byte(board, SI1_ISA_INTCL, 0);
669 write_sx_byte(board, SI1_ISA_INTCL_CLEAR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 } else {
671 switch (board->irq) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800672 case 11:
673 write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);
674 break;
675 case 12:
676 write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);
677 break;
678 case 15:
679 write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);
680 break;
681 default:
682 printk(KERN_INFO "sx: SI/XIO card doesn't support "
683 "interrupt %d.\n", board->irq);
684 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800686 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 }
688
689 return 1;
690}
691
Jiri Slaby15b611f2006-12-08 02:39:04 -0800692static int sx_send_command(struct sx_port *port,
693 int command, int mask, int newstat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800695 func_enter2();
696 write_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat), command);
697 func_exit();
698 return sx_busy_wait_eq(port->board, CHAN_OFFSET(port, hi_hstat), mask,
699 newstat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700}
701
Jiri Slaby15b611f2006-12-08 02:39:04 -0800702static char *mod_type_s(int module_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703{
704 switch (module_type) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800705 case TA4:
706 return "TA4";
707 case TA8:
708 return "TA8";
709 case TA4_ASIC:
710 return "TA4_ASIC";
711 case TA8_ASIC:
712 return "TA8_ASIC";
713 case MTA_CD1400:
714 return "MTA_CD1400";
715 case SXDC:
716 return "SXDC";
717 default:
718 return "Unknown/invalid";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 }
720}
721
Jiri Slaby15b611f2006-12-08 02:39:04 -0800722static char *pan_type_s(int pan_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723{
724 switch (pan_type) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800725 case MOD_RS232DB25:
726 return "MOD_RS232DB25";
727 case MOD_RS232RJ45:
728 return "MOD_RS232RJ45";
729 case MOD_RS422DB25:
730 return "MOD_RS422DB25";
731 case MOD_PARALLEL:
732 return "MOD_PARALLEL";
733 case MOD_2_RS232DB25:
734 return "MOD_2_RS232DB25";
735 case MOD_2_RS232RJ45:
736 return "MOD_2_RS232RJ45";
737 case MOD_2_RS422DB25:
738 return "MOD_2_RS422DB25";
739 case MOD_RS232DB25MALE:
740 return "MOD_RS232DB25MALE";
741 case MOD_2_PARALLEL:
742 return "MOD_2_PARALLEL";
743 case MOD_BLANK:
744 return "empty";
745 default:
746 return "invalid";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 }
748}
749
Jiri Slaby15b611f2006-12-08 02:39:04 -0800750static int mod_compat_type(int module_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
752 return module_type >> 4;
753}
754
755static void sx_reconfigure_port(struct sx_port *port)
756{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800757 if (sx_read_channel_byte(port, hi_hstat) == HS_IDLE_OPEN) {
758 if (sx_send_command(port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
759 printk(KERN_WARNING "sx: Sent reconfigure command, but "
760 "card didn't react.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
762 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800763 sx_dprintk(SX_DEBUG_TERMIOS, "sx: Not sending reconfigure: "
764 "port isn't open (%02x).\n",
765 sx_read_channel_byte(port, hi_hstat));
766 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767}
768
Jiri Slaby15b611f2006-12-08 02:39:04 -0800769static void sx_setsignals(struct sx_port *port, int dtr, int rts)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770{
771 int t;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800772 func_enter2();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Jiri Slaby15b611f2006-12-08 02:39:04 -0800774 t = sx_read_channel_byte(port, hi_op);
775 if (dtr >= 0)
776 t = dtr ? (t | OP_DTR) : (t & ~OP_DTR);
777 if (rts >= 0)
778 t = rts ? (t | OP_RTS) : (t & ~OP_RTS);
779 sx_write_channel_byte(port, hi_op, t);
780 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781
Jiri Slaby15b611f2006-12-08 02:39:04 -0800782 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783}
784
Jiri Slaby15b611f2006-12-08 02:39:04 -0800785static int sx_getsignals(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
Jiri Slaby15b611f2006-12-08 02:39:04 -0800787 int i_stat, o_stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Jiri Slaby15b611f2006-12-08 02:39:04 -0800789 o_stat = sx_read_channel_byte(port, hi_op);
790 i_stat = sx_read_channel_byte(port, hi_ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Jiri Slaby15b611f2006-12-08 02:39:04 -0800792 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d (%d/%d) "
793 "%02x/%02x\n",
794 (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
795 port->c_dcd, sx_get_CD(port),
796 sx_read_channel_byte(port, hi_ip),
797 sx_read_channel_byte(port, hi_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Jiri Slaby15b611f2006-12-08 02:39:04 -0800799 return (((o_stat & OP_DTR) ? TIOCM_DTR : 0) |
800 ((o_stat & OP_RTS) ? TIOCM_RTS : 0) |
801 ((i_stat & IP_CTS) ? TIOCM_CTS : 0) |
802 ((i_stat & IP_DCD) ? TIOCM_CAR : 0) |
803 ((i_stat & IP_DSR) ? TIOCM_DSR : 0) |
804 ((i_stat & IP_RI) ? TIOCM_RNG : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805}
806
Jiri Slaby15b611f2006-12-08 02:39:04 -0800807static void sx_set_baud(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808{
809 int t;
810
811 if (port->board->ta_type == MOD_SXDC) {
812 switch (port->gs.baud) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800813 /* Save some typing work... */
814#define e(x) case x: t = BAUD_ ## x; break
815 e(50);
816 e(75);
817 e(110);
818 e(150);
819 e(200);
820 e(300);
821 e(600);
822 e(1200);
823 e(1800);
824 e(2000);
825 e(2400);
826 e(4800);
827 e(7200);
828 e(9600);
829 e(14400);
830 e(19200);
831 e(28800);
832 e(38400);
833 e(56000);
834 e(57600);
835 e(64000);
836 e(76800);
837 e(115200);
838 e(128000);
839 e(150000);
840 e(230400);
841 e(256000);
842 e(460800);
843 e(921600);
844 case 134:
845 t = BAUD_134_5;
846 break;
847 case 0:
848 t = -1;
849 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 default:
851 /* Can I return "invalid"? */
852 t = BAUD_9600;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800853 printk(KERN_INFO "sx: unsupported baud rate: %d.\n",
854 port->gs.baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 break;
856 }
857#undef e
858 if (t > 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800859/* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
860 sx_setsignals(port, 1, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 /* XXX This is not TA & MTA compatible */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800862 sx_write_channel_byte(port, hi_csr, 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
Jiri Slaby15b611f2006-12-08 02:39:04 -0800864 sx_write_channel_byte(port, hi_txbaud, t);
865 sx_write_channel_byte(port, hi_rxbaud, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800867 sx_setsignals(port, 0, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 }
869 } else {
870 switch (port->gs.baud) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800871#define e(x) case x: t = CSR_ ## x; break
872 e(75);
873 e(150);
874 e(300);
875 e(600);
876 e(1200);
877 e(2400);
878 e(4800);
879 e(1800);
880 e(9600);
881 e(19200);
882 e(57600);
883 e(38400);
884/* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
885 case 110:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 if (port->board->ta_type == MOD_TA) {
887 t = CSR_110;
888 break;
889 } else {
890 t = CSR_9600;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800891 printk(KERN_INFO "sx: Unsupported baud rate: "
892 "%d.\n", port->gs.baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 break;
894 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800895 case 115200:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 if (port->board->ta_type == MOD_TA) {
897 t = CSR_9600;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800898 printk(KERN_INFO "sx: Unsupported baud rate: "
899 "%d.\n", port->gs.baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 break;
901 } else {
902 t = CSR_110;
903 break;
904 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800905 case 0:
906 t = -1;
907 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 default:
909 t = CSR_9600;
Jiri Slaby15b611f2006-12-08 02:39:04 -0800910 printk(KERN_INFO "sx: Unsupported baud rate: %d.\n",
911 port->gs.baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 break;
913 }
914#undef e
915 if (t >= 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800916 sx_setsignals(port, 1, -1);
917 sx_write_channel_byte(port, hi_csr, t * 0x11);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800919 sx_setsignals(port, 0, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 }
921 }
922}
923
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924/* Simon Allen's version of this routine was 225 lines long. 85 is a lot
925 better. -- REW */
926
Jiri Slaby15b611f2006-12-08 02:39:04 -0800927static int sx_set_real_termios(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928{
929 struct sx_port *port = ptr;
930
931 func_enter2();
932
933 if (!port->gs.tty)
934 return 0;
935
936 /* What is this doing here? -- REW
937 Ha! figured it out. It is to allow you to get DTR active again
938 if you've dropped it with stty 0. Moved to set_baud, where it
939 belongs (next to the drop dtr if baud == 0) -- REW */
940 /* sx_setsignals (port, 1, -1); */
941
Jiri Slaby15b611f2006-12-08 02:39:04 -0800942 sx_set_baud(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
944#define CFLAG port->gs.tty->termios->c_cflag
Jiri Slaby15b611f2006-12-08 02:39:04 -0800945 sx_write_channel_byte(port, hi_mr1,
946 (C_PARENB(port->gs.tty) ? MR1_WITH : MR1_NONE) |
947 (C_PARODD(port->gs.tty) ? MR1_ODD : MR1_EVEN) |
948 (C_CRTSCTS(port->gs.tty) ? MR1_RTS_RXFLOW : 0) |
949 (((CFLAG & CSIZE) == CS8) ? MR1_8_BITS : 0) |
950 (((CFLAG & CSIZE) == CS7) ? MR1_7_BITS : 0) |
951 (((CFLAG & CSIZE) == CS6) ? MR1_6_BITS : 0) |
952 (((CFLAG & CSIZE) == CS5) ? MR1_5_BITS : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
Jiri Slaby15b611f2006-12-08 02:39:04 -0800954 sx_write_channel_byte(port, hi_mr2,
955 (C_CRTSCTS(port->gs.tty) ? MR2_CTS_TXFLOW : 0) |
956 (C_CSTOPB(port->gs.tty) ? MR2_2_STOP :
957 MR2_1_STOP));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
959 switch (CFLAG & CSIZE) {
Jiri Slaby15b611f2006-12-08 02:39:04 -0800960 case CS8:
961 sx_write_channel_byte(port, hi_mask, 0xff);
962 break;
963 case CS7:
964 sx_write_channel_byte(port, hi_mask, 0x7f);
965 break;
966 case CS6:
967 sx_write_channel_byte(port, hi_mask, 0x3f);
968 break;
969 case CS5:
970 sx_write_channel_byte(port, hi_mask, 0x1f);
971 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 default:
Jiri Slaby15b611f2006-12-08 02:39:04 -0800973 printk(KERN_INFO "sx: Invalid wordsize: %u\n", 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,
978 (I_IXON(port->gs.tty) ? SP_TXEN : 0) |
979 (I_IXOFF(port->gs.tty) ? SP_RXEN : 0) |
980 (I_IXANY(port->gs.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,
983 (I_IGNBRK(port->gs.tty) ? BR_IGN : 0 |
984 I_BRKINT(port->gs.tty) ? BR_INT : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
Jiri Slaby15b611f2006-12-08 02:39:04 -0800986 sx_write_channel_byte(port, hi_txon, START_CHAR(port->gs.tty));
987 sx_write_channel_byte(port, hi_rxon, START_CHAR(port->gs.tty));
988 sx_write_channel_byte(port, hi_txoff, STOP_CHAR(port->gs.tty));
989 sx_write_channel_byte(port, hi_rxoff, STOP_CHAR(port->gs.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 */
Jiri Slaby15b611f2006-12-08 02:39:04 -0800994 if (I_OTHER(port->gs.tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 clear_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
996 } else {
997 set_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
998 }
Jiri Slaby15b611f2006-12-08 02:39:04 -0800999 sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
1000 port->gs.tty->termios->c_iflag, I_OTHER(port->gs.tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
1002/* Tell line discipline whether we will do output cooking.
1003 * If OPOST is set and no other output flags are set then we can do output
1004 * processing. Even if only *one* other flag in the O_OTHER group is set
1005 * we do cooking in software.
1006 */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001007 if (O_OPOST(port->gs.tty) && !O_OTHER(port->gs.tty)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 set_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
1009 } else {
1010 clear_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
1011 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001012 sx_dprintk(SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
1013 port->gs.tty->termios->c_oflag, O_OTHER(port->gs.tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 /* port->c_dcd = sx_get_CD (port); */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001015 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 return 0;
1017}
1018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019/* ********************************************************************** *
1020 * the interrupt related routines *
1021 * ********************************************************************** */
1022
1023/* Note:
1024 Other drivers use the macro "MIN" to calculate how much to copy.
1025 This has the disadvantage that it will evaluate parts twice. That's
1026 expensive when it's IO (and the compiler cannot optimize those away!).
1027 Moreover, I'm not sure that you're race-free.
1028
1029 I assign a value, and then only allow the value to decrease. This
1030 is always safe. This makes the code a few lines longer, and you
1031 know I'm dead against that, but I think it is required in this
1032 case. */
1033
Jiri Slaby15b611f2006-12-08 02:39:04 -08001034static void sx_transmit_chars(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035{
1036 int c;
1037 int tx_ip;
1038 int txroom;
1039
Jiri Slaby15b611f2006-12-08 02:39:04 -08001040 func_enter2();
1041 sx_dprintk(SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
1042 port, port->gs.xmit_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Jiri Slaby15b611f2006-12-08 02:39:04 -08001044 if (test_and_set_bit(SX_PORT_TRANSMIT_LOCK, &port->locks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 return;
1046 }
1047
1048 while (1) {
1049 c = port->gs.xmit_cnt;
1050
Jiri Slaby15b611f2006-12-08 02:39:04 -08001051 sx_dprintk(SX_DEBUG_TRANSMIT, "Copying %d ", c);
1052 tx_ip = sx_read_channel_byte(port, hi_txipos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
1054 /* Took me 5 minutes to deduce this formula.
1055 Luckily it is literally in the manual in section 6.5.4.3.5 */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001056 txroom = (sx_read_channel_byte(port, hi_txopos) - tx_ip - 1) &
1057 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
1059 /* Don't copy more bytes than there is room for in the buffer */
1060 if (c > txroom)
1061 c = txroom;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001062 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
1064 /* Don't copy past the end of the hardware transmit buffer */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001065 if (c > 0x100 - tx_ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 c = 0x100 - tx_ip;
1067
Jiri Slaby15b611f2006-12-08 02:39:04 -08001068 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100 - tx_ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
1070 /* Don't copy pas the end of the source buffer */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001071 if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
1073
Jiri Slaby15b611f2006-12-08 02:39:04 -08001074 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%ld) \n",
1075 c, SERIAL_XMIT_SIZE - port->gs.xmit_tail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
Jiri Slaby15b611f2006-12-08 02:39:04 -08001077 /* If for one reason or another, we can't copy more data, we're
1078 done! */
1079 if (c == 0)
1080 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
Jiri Slaby15b611f2006-12-08 02:39:04 -08001082 memcpy_toio(port->board->base + CHAN_OFFSET(port, hi_txbuf) +
1083 tx_ip, port->gs.xmit_buf + port->gs.xmit_tail, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
1085 /* Update the pointer in the card */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001086 sx_write_channel_byte(port, hi_txipos, (tx_ip + c) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
1088 /* Update the kernel buffer end */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001089 port->gs.xmit_tail = (port->gs.xmit_tail + c) &
1090 (SERIAL_XMIT_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
1092 /* This one last. (this is essential)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001093 It would allow others to start putting more data into the
1094 buffer! */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 port->gs.xmit_cnt -= c;
1096 }
1097
1098 if (port->gs.xmit_cnt == 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001099 sx_disable_tx_interrupts(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 }
1101
1102 if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.tty) {
1103 tty_wakeup(port->gs.tty);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001104 sx_dprintk(SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
1105 port->gs.wakeup_chars);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 }
1107
Jiri Slaby15b611f2006-12-08 02:39:04 -08001108 clear_bit(SX_PORT_TRANSMIT_LOCK, &port->locks);
1109 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110}
1111
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112/* Note the symmetry between receiving chars and transmitting them!
1113 Note: The kernel should have implemented both a receive buffer and
1114 a transmit buffer. */
1115
1116/* Inlined: Called only once. Remove the inline when you add another call */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001117static inline void sx_receive_chars(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118{
1119 int c;
1120 int rx_op;
1121 struct tty_struct *tty;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001122 int copied = 0;
Alan Cox33f0f882006-01-09 20:54:13 -08001123 unsigned char *rp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Jiri Slaby15b611f2006-12-08 02:39:04 -08001125 func_enter2();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 tty = port->gs.tty;
1127 while (1) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001128 rx_op = sx_read_channel_byte(port, hi_rxopos);
1129 c = (sx_read_channel_byte(port, hi_rxipos) - rx_op) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Jiri Slaby15b611f2006-12-08 02:39:04 -08001131 sx_dprintk(SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132
Marc Zyngierd904ffd2006-02-27 12:08:00 +01001133 /* Don't copy past the end of the hardware receive buffer */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001134 if (rx_op + c > 0x100)
1135 c = 0x100 - rx_op;
Marc Zyngierd904ffd2006-02-27 12:08:00 +01001136
Jiri Slaby15b611f2006-12-08 02:39:04 -08001137 sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
Marc Zyngierd904ffd2006-02-27 12:08:00 +01001138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 /* Don't copy more bytes than there is room for in the buffer */
Alan Cox33f0f882006-01-09 20:54:13 -08001140
1141 c = tty_prepare_flip_string(tty, &rp, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
Jiri Slaby15b611f2006-12-08 02:39:04 -08001143 sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 /* If for one reason or another, we can't copy more data, we're done! */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001146 if (c == 0)
1147 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Jiri Slaby15b611f2006-12-08 02:39:04 -08001149 sx_dprintk(SX_DEBUG_RECEIVE, "Copying over %d chars. First is "
1150 "%d at %lx\n", c, read_sx_byte(port->board,
1151 CHAN_OFFSET(port, hi_rxbuf) + rx_op),
1152 CHAN_OFFSET(port, hi_rxbuf));
1153 memcpy_fromio(rp, port->board->base +
1154 CHAN_OFFSET(port, hi_rxbuf) + rx_op, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
1156 /* This one last. ( Not essential.)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001157 It allows the card to start putting more data into the
1158 buffer!
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 Update the pointer in the card */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001160 sx_write_channel_byte(port, hi_rxopos, (rx_op + c) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
1162 copied += c;
1163 }
1164 if (copied) {
1165 struct timeval tv;
1166
Jiri Slaby15b611f2006-12-08 02:39:04 -08001167 do_gettimeofday(&tv);
1168 sx_dprintk(SX_DEBUG_RECEIVE, "pushing flipq port %d (%3d "
1169 "chars): %d.%06d (%d/%d)\n", port->line,
1170 copied, (int)(tv.tv_sec % 60), (int)tv.tv_usec,
1171 tty->raw, tty->real_raw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
Jiri Slaby15b611f2006-12-08 02:39:04 -08001173 /* Tell the rest of the system the news. Great news. New
1174 characters! */
1175 tty_flip_buffer_push(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 /* tty_schedule_flip (tty); */
1177 }
1178
Jiri Slaby15b611f2006-12-08 02:39:04 -08001179 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180}
1181
1182/* Inlined: it is called only once. Remove the inline if you add another
1183 call */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001184static inline void sx_check_modem_signals(struct sx_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185{
1186 int hi_state;
1187 int c_dcd;
1188
Jiri Slaby15b611f2006-12-08 02:39:04 -08001189 hi_state = sx_read_channel_byte(port, hi_state);
1190 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
1191 port->c_dcd, sx_get_CD(port));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193 if (hi_state & ST_BREAK) {
1194 hi_state &= ~ST_BREAK;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001195 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a break.\n");
1196 sx_write_channel_byte(port, hi_state, hi_state);
1197 gs_got_break(&port->gs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 }
1199 if (hi_state & ST_DCD) {
1200 hi_state &= ~ST_DCD;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001201 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
1202 sx_write_channel_byte(port, hi_state, hi_state);
1203 c_dcd = sx_get_CD(port);
1204 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 if (c_dcd != port->c_dcd) {
1206 port->c_dcd = c_dcd;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001207 if (sx_get_CD(port)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 /* DCD went UP */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001209 if ((sx_read_channel_byte(port, hi_hstat) !=
1210 HS_IDLE_CLOSED) &&
1211 !(port->gs.tty->termios->
1212 c_cflag & CLOCAL)) {
1213 /* Are we blocking in open? */
1214 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1215 "active, unblocking open\n");
1216 wake_up_interruptible(&port->gs.
1217 open_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001219 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1220 "raised. Ignoring.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 }
1222 } else {
1223 /* DCD went down! */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001224 if (!(port->gs.tty->termios->c_cflag & CLOCAL)){
1225 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1226 "dropped. hanging up....\n");
1227 tty_hangup(port->gs.tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001229 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1230 "dropped. ignoring.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 }
1232 }
1233 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001234 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us "
1235 "DCD changed, but it didn't.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 }
1237 }
1238}
1239
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240/* This is what an interrupt routine should look like.
1241 * Small, elegant, clear.
1242 */
1243
Jiri Slaby15b611f2006-12-08 02:39:04 -08001244static irqreturn_t sx_interrupt(int irq, void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245{
1246 struct sx_board *board = ptr;
1247 struct sx_port *port;
1248 int i;
1249
Jiri Slaby15b611f2006-12-08 02:39:04 -08001250 func_enter();
1251 sx_dprintk(SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq,
1252 board->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
1254 /* AAargh! The order in which to do these things is essential and
1255 not trivial.
1256
1257 - Rate limit goes before "recursive". Otherwise a series of
Jiri Slaby15b611f2006-12-08 02:39:04 -08001258 recursive calls will hang the machine in the interrupt routine.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
1260 - hardware twiddling goes before "recursive". Otherwise when we
Jiri Slaby15b611f2006-12-08 02:39:04 -08001261 poll the card, and a recursive interrupt happens, we won't
1262 ack the card, so it might keep on interrupting us. (especially
1263 level sensitive interrupt systems like PCI).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
1265 - Rate limit goes before hardware twiddling. Otherwise we won't
Jiri Slaby15b611f2006-12-08 02:39:04 -08001266 catch a card that has gone bonkers.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
1268 - The "initialized" test goes after the hardware twiddling. Otherwise
Jiri Slaby15b611f2006-12-08 02:39:04 -08001269 the card will stick us in the interrupt routine again.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
1271 - The initialized test goes before recursive.
Jiri Slaby15b611f2006-12-08 02:39:04 -08001272 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
1274#ifdef IRQ_RATE_LIMIT
1275 /* Aaargh! I'm ashamed. This costs more lines-of-code than the
Jiri Slaby15b611f2006-12-08 02:39:04 -08001276 actual interrupt routine!. (Well, used to when I wrote that
1277 comment) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 {
1279 static int lastjif;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001280 static int nintr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
1282 if (lastjif == jiffies) {
1283 if (++nintr > IRQ_RATE_LIMIT) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001284 free_irq(board->irq, board);
1285 printk(KERN_ERR "sx: Too many interrupts. "
1286 "Turning off interrupt %d.\n",
1287 board->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 }
1289 } else {
1290 lastjif = jiffies;
1291 nintr = 0;
1292 }
1293 }
1294#endif
1295
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 if (board->irq == irq) {
1297 /* Tell the card we've noticed the interrupt. */
1298
Jiri Slaby15b611f2006-12-08 02:39:04 -08001299 sx_write_board_word(board, cc_int_pending, 0);
1300 if (IS_SX_BOARD(board)) {
1301 write_sx_byte(board, SX_RESET_IRQ, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 } else if (IS_EISA_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001303 inb(board->eisa_base + 0xc03);
1304 write_sx_word(board, 8, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001306 write_sx_byte(board, SI2_ISA_INTCLEAR,
1307 SI2_ISA_INTCLEAR_CLEAR);
1308 write_sx_byte(board, SI2_ISA_INTCLEAR,
1309 SI2_ISA_INTCLEAR_SET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 }
1311 }
1312
1313 if (!sx_initialized)
1314 return IRQ_HANDLED;
1315 if (!(board->flags & SX_BOARD_INITIALIZED))
1316 return IRQ_HANDLED;
1317
Jiri Slaby15b611f2006-12-08 02:39:04 -08001318 if (test_and_set_bit(SX_BOARD_INTR_LOCK, &board->locks)) {
1319 printk(KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 return IRQ_HANDLED;
1321 }
1322
Jiri Slaby15b611f2006-12-08 02:39:04 -08001323 for (i = 0; i < board->nports; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 port = &board->ports[i];
1325 if (port->gs.flags & GS_ACTIVE) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001326 if (sx_read_channel_byte(port, hi_state)) {
1327 sx_dprintk(SX_DEBUG_INTERRUPTS, "Port %d: "
1328 "modem signal change?... \n",i);
1329 sx_check_modem_signals(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 }
1331 if (port->gs.xmit_cnt) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001332 sx_transmit_chars(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 }
1334 if (!(port->gs.flags & SX_RX_THROTTLE)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001335 sx_receive_chars(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 }
1337 }
1338 }
1339
Jiri Slaby15b611f2006-12-08 02:39:04 -08001340 clear_bit(SX_BOARD_INTR_LOCK, &board->locks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
Jiri Slaby15b611f2006-12-08 02:39:04 -08001342 sx_dprintk(SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq,
1343 board->irq);
1344 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 return IRQ_HANDLED;
1346}
1347
Jiri Slaby15b611f2006-12-08 02:39:04 -08001348static void sx_pollfunc(unsigned long data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001350 struct sx_board *board = (struct sx_board *)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
Jiri Slaby15b611f2006-12-08 02:39:04 -08001352 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
Jiri Slaby15b611f2006-12-08 02:39:04 -08001354 sx_interrupt(0, board);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
Jiri Slabyc9594642006-12-08 02:39:05 -08001356 mod_timer(&board->timer, jiffies + sx_poll);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001357 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358}
1359
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360/* ********************************************************************** *
1361 * Here are the routines that actually *
1362 * interface with the generic_serial driver *
1363 * ********************************************************************** */
1364
1365/* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
1366/* Hmm. Ok I figured it out. You don't. */
1367
Jiri Slaby15b611f2006-12-08 02:39:04 -08001368static void sx_disable_tx_interrupts(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001370 struct sx_port *port = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 func_enter2();
1372
1373 port->gs.flags &= ~GS_TX_INTEN;
1374
1375 func_exit();
1376}
1377
Jiri Slaby15b611f2006-12-08 02:39:04 -08001378static void sx_enable_tx_interrupts(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001380 struct sx_port *port = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 int data_in_buffer;
1382 func_enter2();
1383
1384 /* First transmit the characters that we're supposed to */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001385 sx_transmit_chars(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
1387 /* The sx card will never interrupt us if we don't fill the buffer
1388 past 25%. So we keep considering interrupts off if that's the case. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001389 data_in_buffer = (sx_read_channel_byte(port, hi_txipos) -
1390 sx_read_channel_byte(port, hi_txopos)) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
1392 /* XXX Must be "HIGH_WATER" for SI card according to doc. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001393 if (data_in_buffer < LOW_WATER)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 port->gs.flags &= ~GS_TX_INTEN;
1395
1396 func_exit();
1397}
1398
Jiri Slaby15b611f2006-12-08 02:39:04 -08001399static void sx_disable_rx_interrupts(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400{
1401 /* struct sx_port *port = ptr; */
1402 func_enter();
1403
1404 func_exit();
1405}
1406
Jiri Slaby15b611f2006-12-08 02:39:04 -08001407static void sx_enable_rx_interrupts(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408{
1409 /* struct sx_port *port = ptr; */
1410 func_enter();
1411
1412 func_exit();
1413}
1414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415/* Jeez. Isn't this simple? */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001416static int sx_get_CD(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417{
1418 struct sx_port *port = ptr;
1419 func_enter2();
1420
1421 func_exit();
Jiri Slaby15b611f2006-12-08 02:39:04 -08001422 return ((sx_read_channel_byte(port, hi_ip) & IP_DCD) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423}
1424
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425/* Jeez. Isn't this simple? */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001426static int sx_chars_in_buffer(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427{
1428 struct sx_port *port = ptr;
1429 func_enter2();
1430
1431 func_exit();
Jiri Slaby15b611f2006-12-08 02:39:04 -08001432 return ((sx_read_channel_byte(port, hi_txipos) -
1433 sx_read_channel_byte(port, hi_txopos)) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434}
1435
Jiri Slaby15b611f2006-12-08 02:39:04 -08001436static void sx_shutdown_port(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001438 struct sx_port *port = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439
1440 func_enter();
1441
Jiri Slaby15b611f2006-12-08 02:39:04 -08001442 port->gs.flags &= ~GS_ACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 if (port->gs.tty && (port->gs.tty->termios->c_cflag & HUPCL)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001444 sx_setsignals(port, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 sx_reconfigure_port(port);
1446 }
1447
1448 func_exit();
1449}
1450
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451/* ********************************************************************** *
1452 * Here are the routines that actually *
1453 * interface with the rest of the system *
1454 * ********************************************************************** */
1455
Jiri Slaby15b611f2006-12-08 02:39:04 -08001456static int sx_open(struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457{
1458 struct sx_port *port;
1459 int retval, line;
1460 unsigned long flags;
1461
1462 func_enter();
1463
1464 if (!sx_initialized) {
1465 return -EIO;
1466 }
1467
1468 line = tty->index;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001469 sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
1470 "np=%d)\n", current->pid, line, tty,
1471 current->signal->tty, sx_nports);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
1473 if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1474 return -ENODEV;
1475
Jiri Slaby15b611f2006-12-08 02:39:04 -08001476 port = &sx_ports[line];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
Jiri Slaby15b611f2006-12-08 02:39:04 -08001478 1 -> 0 transition. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
Jiri Slaby15b611f2006-12-08 02:39:04 -08001480 sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
1482 spin_lock_irqsave(&port->gs.driver_lock, flags);
1483
1484 tty->driver_data = port;
1485 port->gs.tty = tty;
1486 port->gs.count++;
1487 spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1488
Jiri Slaby15b611f2006-12-08 02:39:04 -08001489 sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490
1491 /*
1492 * Start up serial port
1493 */
1494 retval = gs_init_port(&port->gs);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001495 sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 if (retval) {
1497 port->gs.count--;
1498 return retval;
1499 }
1500
1501 port->gs.flags |= GS_ACTIVE;
1502 if (port->gs.count <= 1)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001503 sx_setsignals(port, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
1505#if 0
1506 if (sx_debug & SX_DEBUG_OPEN)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001507 my_hd(port, sizeof(*port));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508#else
1509 if (sx_debug & SX_DEBUG_OPEN)
Jiri Slaby15b611f2006-12-08 02:39:04 -08001510 my_hd_io(port->board->base + port->ch_base, sizeof(*port));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511#endif
1512
1513 if (port->gs.count <= 1) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001514 if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1515 printk(KERN_ERR "sx: Card didn't respond to LOPEN "
1516 "command.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 spin_lock_irqsave(&port->gs.driver_lock, flags);
1518 port->gs.count--;
1519 spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1520 return -EIO;
1521 }
1522 }
1523
1524 retval = gs_block_til_ready(port, filp);
Jiri Slaby15b611f2006-12-08 02:39:04 -08001525 sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
1526 retval, port->gs.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527
1528 if (retval) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001529/*
1530 * Don't lower gs.count here because sx_close() will be called later
1531 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
1533 return retval;
1534 }
1535 /* tty->low_latency = 1; */
1536
Jiri Slaby15b611f2006-12-08 02:39:04 -08001537 port->c_dcd = sx_get_CD(port);
1538 sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539
1540 func_exit();
1541 return 0;
1542
1543}
1544
Jiri Slaby15b611f2006-12-08 02:39:04 -08001545static void sx_close(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546{
Jiri Slaby15b611f2006-12-08 02:39:04 -08001547 struct sx_port *port = ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 /* Give the port 5 seconds to close down. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001549 int to = 5 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550
Jiri Slaby15b611f2006-12-08 02:39:04 -08001551 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
Jiri Slaby15b611f2006-12-08 02:39:04 -08001553 sx_setsignals(port, 0, 0);
1554 sx_reconfigure_port(port);
1555 sx_send_command(port, HS_CLOSE, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556
Jiri Slaby15b611f2006-12-08 02:39:04 -08001557 while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 if (msleep_interruptible(10))
1559 break;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001560 if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
1561 if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
1562 != 1) {
1563 printk(KERN_ERR "sx: sent the force_close command, but "
1564 "card didn't react\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 } else
Jiri Slaby15b611f2006-12-08 02:39:04 -08001566 sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
1567 "command.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 }
1569
Jiri Slaby15b611f2006-12-08 02:39:04 -08001570 sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
1571 5 * HZ - to - 1, port->gs.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572
Jiri Slaby15b611f2006-12-08 02:39:04 -08001573 if (port->gs.count) {
1574 sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n",
1575 port->gs.count);
1576 /*printk("%s SETTING port count to zero: %p count: %d\n",
1577 __FUNCTION__, port, port->gs.count);
1578 port->gs.count = 0;*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 }
1580
Jiri Slaby15b611f2006-12-08 02:39:04 -08001581 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582}
1583
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584/* This is relatively thorough. But then again it is only 20 lines. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001585#define MARCHUP for (i = min; i < max; i++)
1586#define MARCHDOWN for (i = max - 1; i >= min; i--)
1587#define W0 write_sx_byte(board, i, 0x55)
1588#define W1 write_sx_byte(board, i, 0xaa)
1589#define R0 if (read_sx_byte(board, i) != 0x55) return 1
1590#define R1 if (read_sx_byte(board, i) != 0xaa) return 1
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
1592/* This memtest takes a human-noticable time. You normally only do it
1593 once a boot, so I guess that it is worth it. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001594static int do_memtest(struct sx_board *board, int min, int max)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595{
1596 int i;
1597
1598 /* This is a marchb. Theoretically, marchb catches much more than
1599 simpler tests. In practise, the longer test just catches more
1600 intermittent errors. -- REW
1601 (For the theory behind memory testing see:
1602 Testing Semiconductor Memories by A.J. van de Goor.) */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001603 MARCHUP {
1604 W0;
1605 }
1606 MARCHUP {
1607 R0;
1608 W1;
1609 R1;
1610 W0;
1611 R0;
1612 W1;
1613 }
1614 MARCHUP {
1615 R1;
1616 W0;
1617 W1;
1618 }
1619 MARCHDOWN {
1620 R1;
1621 W0;
1622 W1;
1623 W0;
1624 }
1625 MARCHDOWN {
1626 R0;
1627 W1;
1628 W0;
1629 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630
1631 return 0;
1632}
1633
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634#undef MARCHUP
1635#undef MARCHDOWN
1636#undef W0
1637#undef W1
1638#undef R0
1639#undef R1
1640
Jiri Slaby15b611f2006-12-08 02:39:04 -08001641#define MARCHUP for (i = min; i < max; i += 2)
1642#define MARCHDOWN for (i = max - 1; i >= min; i -= 2)
1643#define W0 write_sx_word(board, i, 0x55aa)
1644#define W1 write_sx_word(board, i, 0xaa55)
1645#define R0 if (read_sx_word(board, i) != 0x55aa) return 1
1646#define R1 if (read_sx_word(board, i) != 0xaa55) return 1
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
1648#if 0
1649/* This memtest takes a human-noticable time. You normally only do it
1650 once a boot, so I guess that it is worth it. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001651static int do_memtest_w(struct sx_board *board, int min, int max)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652{
1653 int i;
1654
Jiri Slaby15b611f2006-12-08 02:39:04 -08001655 MARCHUP {
1656 W0;
1657 }
1658 MARCHUP {
1659 R0;
1660 W1;
1661 R1;
1662 W0;
1663 R0;
1664 W1;
1665 }
1666 MARCHUP {
1667 R1;
1668 W0;
1669 W1;
1670 }
1671 MARCHDOWN {
1672 R1;
1673 W0;
1674 W1;
1675 W0;
1676 }
1677 MARCHDOWN {
1678 R0;
1679 W1;
1680 W0;
1681 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682
1683 return 0;
1684}
1685#endif
1686
Jiri Slaby15b611f2006-12-08 02:39:04 -08001687static int sx_fw_ioctl(struct inode *inode, struct file *filp,
1688 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689{
1690 int rc = 0;
1691 int __user *descr = (int __user *)arg;
1692 int i;
1693 static struct sx_board *board = NULL;
1694 int nbytes, offset;
1695 unsigned long data;
1696 char *tmp;
1697
1698 func_enter();
1699
Jiri Slaby15b611f2006-12-08 02:39:04 -08001700#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 /* Removed superuser check: Sysops can use the permissions on the device
1702 file to restrict access. Recommendation: Root only. (root.root 600) */
1703 if (!capable(CAP_SYS_ADMIN)) {
1704 return -EPERM;
1705 }
1706#endif
1707
Jiri Slaby15b611f2006-12-08 02:39:04 -08001708 sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709
Jiri Slaby15b611f2006-12-08 02:39:04 -08001710 if (!board)
1711 board = &boards[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 if (board->flags & SX_BOARD_PRESENT) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001713 sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1714 board->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001716 sx_dprintk(SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
1717 board->flags);
1718 for (i = 0; i < SX_NBOARDS; i++)
1719 sx_dprintk(SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
1720 sx_dprintk(SX_DEBUG_FIRMWARE, "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 return -EIO;
1722 }
1723
1724 switch (cmd) {
1725 case SXIO_SET_BOARD:
Jiri Slaby15b611f2006-12-08 02:39:04 -08001726 sx_dprintk(SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
1727 if (arg >= SX_NBOARDS)
1728 return -EIO;
1729 sx_dprintk(SX_DEBUG_FIRMWARE, "not out of range\n");
1730 if (!(boards[arg].flags & SX_BOARD_PRESENT))
1731 return -EIO;
1732 sx_dprintk(SX_DEBUG_FIRMWARE, ".. and present!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 board = &boards[arg];
1734 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;
1747 sx_dprintk(SX_DEBUG_FIRMWARE, "returning type= %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 break;
1749 case SXIO_DO_RAMTEST:
Jiri Slaby15b611f2006-12-08 02:39:04 -08001750 if (sx_initialized) /* Already initialized: better not ramtest the board. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 return -EPERM;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001752 if (IS_SX_BOARD(board)) {
1753 rc = do_memtest(board, 0, 0x7000);
1754 if (!rc)
1755 rc = do_memtest(board, 0, 0x7000);
1756 /*if (!rc) rc = do_memtest_w (board, 0, 0x7000); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001758 rc = do_memtest(board, 0, 0x7ff8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
1760 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001761 sx_dprintk(SX_DEBUG_FIRMWARE, "returning memtest result= %d\n",
1762 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 break;
1764 case SXIO_DOWNLOAD:
Jiri Slaby15b611f2006-12-08 02:39:04 -08001765 if (sx_initialized) /* Already initialized */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 return -EEXIST;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001767 if (!sx_reset(board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 return -EIO;
Jiri Slaby15b611f2006-12-08 02:39:04 -08001769 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770
Jiri Slaby15b611f2006-12-08 02:39:04 -08001771 tmp = kmalloc(SX_CHUNK_SIZE, GFP_USER);
1772 if (!tmp)
1773 return -ENOMEM;
1774 get_user(nbytes, descr++);
1775 get_user(offset, descr++);
1776 get_user(data, descr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 while (nbytes && data) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08001778 for (i = 0; i < nbytes; i += SX_CHUNK_SIZE) {
1779 if (copy_from_user(tmp, (char __user *)data + i,
1780 (i + SX_CHUNK_SIZE > nbytes) ?
1781 nbytes - i : SX_CHUNK_SIZE)) {
1782 kfree(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 return -EFAULT;
1784 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001785 memcpy_toio(board->base2 + offset + i, tmp,
1786 (i + SX_CHUNK_SIZE > nbytes) ?
1787 nbytes - i : SX_CHUNK_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 }
1789
Jiri Slaby15b611f2006-12-08 02:39:04 -08001790 get_user(nbytes, descr++);
1791 get_user(offset, descr++);
1792 get_user(data, descr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001794 kfree(tmp);
1795 sx_nports += sx_init_board(board);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 rc = sx_nports;
1797 break;
1798 case SXIO_INIT:
Jiri Slaby15b611f2006-12-08 02:39:04 -08001799 if (sx_initialized) /* Already initialized */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 return -EEXIST;
1801 /* This is not allowed until all boards are initialized... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001802 for (i = 0; i < SX_NBOARDS; i++) {
1803 if ((boards[i].flags & SX_BOARD_PRESENT) &&
1804 !(boards[i].flags & SX_BOARD_INITIALIZED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 return -EIO;
1806 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001807 for (i = 0; i < SX_NBOARDS; i++)
1808 if (!(boards[i].flags & SX_BOARD_PRESENT))
1809 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
Jiri Slaby15b611f2006-12-08 02:39:04 -08001811 sx_dprintk(SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
1812 "%d channels, first board: %d ports\n",
1813 i, sx_nports, boards[0].nports);
1814 rc = sx_init_portstructs(i, sx_nports);
1815 sx_init_drivers();
1816 if (rc >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 sx_initialized++;
1818 break;
1819 case SXIO_SETDEBUG:
1820 sx_debug = arg;
1821 break;
1822 case SXIO_GETDEBUG:
1823 rc = sx_debug;
1824 break;
1825 case SXIO_GETGSDEBUG:
1826 case SXIO_SETGSDEBUG:
1827 rc = -EINVAL;
1828 break;
1829 case SXIO_GETNPORTS:
1830 rc = sx_nports;
1831 break;
1832 default:
Jiri Slaby15b611f2006-12-08 02:39:04 -08001833 printk(KERN_WARNING "Unknown ioctl on firmware device (%x).\n",
1834 cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 break;
1836 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08001837 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 return rc;
1839}
1840
Jiri Slaby15b611f2006-12-08 02:39:04 -08001841static void sx_break(struct tty_struct *tty, int flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842{
1843 struct sx_port *port = tty->driver_data;
1844 int rv;
1845
Jiri Slaby15b611f2006-12-08 02:39:04 -08001846 func_enter();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
Jiri Slaby15b611f2006-12-08 02:39:04 -08001848 if (flag)
1849 rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
1850 else
1851 rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
1852 if (rv != 1)
1853 printk(KERN_ERR "sx: couldn't send break (%x).\n",
1854 read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855
Jiri Slaby15b611f2006-12-08 02:39:04 -08001856 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857}
1858
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1860{
1861 struct sx_port *port = tty->driver_data;
1862 return sx_getsignals(port);
1863}
1864
1865static int sx_tiocmset(struct tty_struct *tty, struct file *file,
Jiri Slaby15b611f2006-12-08 02:39:04 -08001866 unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867{
1868 struct sx_port *port = tty->driver_data;
1869 int rts = -1, dtr = -1;
1870
1871 if (set & TIOCM_RTS)
1872 rts = 1;
1873 if (set & TIOCM_DTR)
1874 dtr = 1;
1875 if (clear & TIOCM_RTS)
1876 rts = 0;
1877 if (clear & TIOCM_DTR)
1878 dtr = 0;
1879
1880 sx_setsignals(port, dtr, rts);
1881 sx_reconfigure_port(port);
1882 return 0;
1883}
1884
Jiri Slaby15b611f2006-12-08 02:39:04 -08001885static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1886 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887{
1888 int rc;
1889 struct sx_port *port = tty->driver_data;
1890 void __user *argp = (void __user *)arg;
1891 int ival;
1892
1893 /* func_enter2(); */
1894
1895 rc = 0;
1896 switch (cmd) {
1897 case TIOCGSOFTCAR:
1898 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
Jiri Slaby15b611f2006-12-08 02:39:04 -08001899 (unsigned __user *)argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 break;
1901 case TIOCSSOFTCAR:
Jiri Slaby15b611f2006-12-08 02:39:04 -08001902 if ((rc = get_user(ival, (unsigned __user *)argp)) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 tty->termios->c_cflag =
1904 (tty->termios->c_cflag & ~CLOCAL) |
1905 (ival ? CLOCAL : 0);
1906 }
1907 break;
1908 case TIOCGSERIAL:
1909 rc = gs_getserial(&port->gs, argp);
1910 break;
1911 case TIOCSSERIAL:
1912 rc = gs_setserial(&port->gs, argp);
1913 break;
1914 default:
1915 rc = -ENOIOCTLCMD;
1916 break;
1917 }
1918
1919 /* func_exit(); */
1920 return rc;
1921}
1922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923/* The throttle/unthrottle scheme for the Specialix card is different
1924 * from other drivers and deserves some explanation.
1925 * The Specialix hardware takes care of XON/XOFF
1926 * and CTS/RTS flow control itself. This means that all we have to
1927 * do when signalled by the upper tty layer to throttle/unthrottle is
1928 * to make a note of it here. When we come to read characters from the
1929 * rx buffers on the card (sx_receive_chars()) we look to see if the
1930 * upper layer can accept more (as noted here in sx_rx_throt[]).
1931 * If it can't we simply don't remove chars from the cards buffer.
1932 * When the tty layer can accept chars, we again note that here and when
1933 * sx_receive_chars() is called it will remove them from the cards buffer.
1934 * The card will notice that a ports buffer has drained below some low
1935 * water mark and will unflow control the line itself, using whatever
1936 * flow control scheme is in use for that port. -- Simon Allen
1937 */
1938
Jiri Slaby15b611f2006-12-08 02:39:04 -08001939static void sx_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940{
1941 struct sx_port *port = (struct sx_port *)tty->driver_data;
1942
1943 func_enter2();
1944 /* If the port is using any type of input flow
1945 * control then throttle the port.
1946 */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001947 if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 port->gs.flags |= SX_RX_THROTTLE;
1949 }
1950 func_exit();
1951}
1952
Jiri Slaby15b611f2006-12-08 02:39:04 -08001953static void sx_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954{
1955 struct sx_port *port = (struct sx_port *)tty->driver_data;
1956
1957 func_enter2();
1958 /* Always unthrottle even if flow control is not enabled on
1959 * this port in case we disabled flow control while the port
1960 * was throttled
1961 */
1962 port->gs.flags &= ~SX_RX_THROTTLE;
1963 func_exit();
1964 return;
1965}
1966
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967/* ********************************************************************** *
1968 * Here are the initialization routines. *
1969 * ********************************************************************** */
1970
Jiri Slaby15b611f2006-12-08 02:39:04 -08001971static int sx_init_board(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972{
1973 int addr;
1974 int chans;
1975 int type;
1976
1977 func_enter();
1978
1979 /* This is preceded by downloading the download code. */
1980
1981 board->flags |= SX_BOARD_INITIALIZED;
1982
Jiri Slaby15b611f2006-12-08 02:39:04 -08001983 if (read_sx_byte(board, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 /* CF boards may need this. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001985 write_sx_byte(board, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986
1987 /* This resets the processor again, to make sure it didn't do any
1988 foolish things while we were downloading the image */
Jiri Slaby15b611f2006-12-08 02:39:04 -08001989 if (!sx_reset(board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 return 0;
1991
Jiri Slaby15b611f2006-12-08 02:39:04 -08001992 sx_start_board(board);
1993 udelay(10);
1994 if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
1995 printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 return 0;
1997 }
1998
1999 /* Ok. So now the processor on the card is running. It gathered
2000 some info for us... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002001 sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
2002 if (sx_debug & SX_DEBUG_INIT)
2003 my_hd_io(board->base, 0x10);
2004 sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
2005 if (sx_debug & SX_DEBUG_INIT)
2006 my_hd_io(board->base + 0x80, 0x30);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007
Jiri Slaby15b611f2006-12-08 02:39:04 -08002008 sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
2009 "V%x.%02x,\n",
2010 read_sx_byte(board, 0), read_sx_byte(board, 1),
2011 read_sx_byte(board, 5), read_sx_byte(board, 4));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012
Jiri Slaby15b611f2006-12-08 02:39:04 -08002013 if (read_sx_byte(board, 0) == 0xff) {
2014 printk(KERN_INFO "sx: No modules found. Sorry.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 board->nports = 0;
2016 return 0;
2017 }
2018
2019 chans = 0;
2020
2021 if (IS_SX_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002022 sx_write_board_word(board, cc_int_count, sx_maxints);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 } else {
2024 if (sx_maxints)
Jiri Slaby15b611f2006-12-08 02:39:04 -08002025 sx_write_board_word(board, cc_int_count,
2026 SI_PROCESSOR_CLOCK / 8 / sx_maxints);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 }
2028
2029 /* grab the first module type... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002030 /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
2031 board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
2032 mc_chip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033
2034 /* XXX byteorder */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002035 for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
2036 type = sx_read_module_byte(board, addr, mc_chip);
2037 sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
2038 addr, read_sx_byte(board, addr + 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039
Jiri Slaby15b611f2006-12-08 02:39:04 -08002040 chans += sx_read_module_byte(board, addr, mc_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041
Jiri Slaby15b611f2006-12-08 02:39:04 -08002042 sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
2043 "panels\n",
2044 mod_type_s(type),
2045 pan_type_s(sx_read_module_byte(board, addr,
2046 mc_mods) & 0xf),
2047 pan_type_s(sx_read_module_byte(board, addr,
2048 mc_mods) >> 4));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049
Jiri Slaby15b611f2006-12-08 02:39:04 -08002050 sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
2051 "version: %x\n",
2052 sx_read_module_byte(board, addr, mc_rev1),
2053 sx_read_module_byte(board, addr, mc_rev2),
2054 sx_read_module_byte(board, addr, mc_mtaasic_rev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055
2056 /* The following combinations are illegal: It should theoretically
2057 work, but timing problems make the bus HANG. */
2058
Jiri Slaby15b611f2006-12-08 02:39:04 -08002059 if (mod_compat_type(type) != board->ta_type) {
2060 printk(KERN_ERR "sx: This is an invalid "
2061 "configuration.\nDon't mix TA/MTA/SXDC on the "
2062 "same hostadapter.\n");
2063 chans = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 break;
2065 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002066 if ((IS_EISA_BOARD(board) ||
2067 IS_SI_BOARD(board)) &&
2068 (mod_compat_type(type) == 4)) {
2069 printk(KERN_ERR "sx: This is an invalid "
2070 "configuration.\nDon't use SXDCs on an SI/XIO "
2071 "adapter.\n");
2072 chans = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 break;
2074 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002075#if 0 /* Problem fixed: firmware 3.05 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 if (IS_SX_BOARD(board) && (type == TA8)) {
2077 /* There are some issues with the firmware and the DCD/RTS
2078 lines. It might work if you tie them together or something.
Jiri Slaby15b611f2006-12-08 02:39:04 -08002079 It might also work if you get a newer sx_firmware. Therefore
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 this is just a warning. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002081 printk(KERN_WARNING
2082 "sx: The SX host doesn't work too well "
2083 "with the TA8 adapters.\nSpecialix is working on it.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 }
2085#endif
2086 }
2087
2088 if (chans) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002089 if (board->irq > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 /* fixed irq, probably PCI */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002091 if (sx_irqmask & (1 << board->irq)) { /* may we use this irq? */
2092 if (request_irq(board->irq, sx_interrupt,
2093 IRQF_SHARED | IRQF_DISABLED,
2094 "sx", board)) {
2095 printk(KERN_ERR "sx: Cannot allocate "
2096 "irq %d.\n", board->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 board->irq = 0;
2098 }
2099 } else
2100 board->irq = 0;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002101 } else if (board->irq < 0 && sx_irqmask) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 /* auto-allocate irq */
2103 int irqnr;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002104 int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
2105 SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
2106 for (irqnr = 15; irqnr > 0; irqnr--)
2107 if (irqmask & (1 << irqnr))
2108 if (!request_irq(irqnr, sx_interrupt,
2109 IRQF_SHARED | IRQF_DISABLED,
2110 "sx", board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 break;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002112 if (!irqnr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2114 board->irq = irqnr;
2115 } else
2116 board->irq = 0;
2117
2118 if (board->irq) {
2119 /* Found a valid interrupt, start up interrupts! */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002120 sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
2121 board->irq);
2122 sx_start_interrupts(board);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 board->poll = sx_slowpoll;
2124 board->flags |= SX_IRQ_ALLOCATED;
2125 } else {
2126 /* no irq: setup board for polled operation */
2127 board->poll = sx_poll;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002128 sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
2129 board->poll);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 }
2131
Jiri Slaby15b611f2006-12-08 02:39:04 -08002132 /* The timer should be initialized anyway: That way we can
2133 safely del_timer it when the module is unloaded. */
Jiri Slabyc9594642006-12-08 02:39:05 -08002134 setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135
Jiri Slabyc9594642006-12-08 02:39:05 -08002136 if (board->poll)
2137 mod_timer(&board->timer, jiffies + board->poll);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 } else {
2139 board->irq = 0;
2140 }
2141
2142 board->nports = chans;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002143 sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
2145 func_exit();
2146 return chans;
2147}
2148
Jiri Slabycda52652006-12-08 02:39:00 -08002149static void __devinit printheader(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150{
2151 static int header_printed;
2152
2153 if (!header_printed) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002154 printk(KERN_INFO "Specialix SX driver "
2155 "(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
2156 printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 header_printed = 1;
2158 }
2159}
2160
Jiri Slaby15b611f2006-12-08 02:39:04 -08002161static int __devinit probe_sx(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162{
2163 struct vpd_prom vpdp;
2164 char *p;
2165 int i;
2166
2167 func_enter();
2168
Jiri Slaby15b611f2006-12-08 02:39:04 -08002169 if (!IS_CF_BOARD(board)) {
2170 sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2171 board->base + SX_VPD_ROM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172
2173 if (sx_debug & SX_DEBUG_PROBE)
2174 my_hd_io(board->base + SX_VPD_ROM, 0x40);
2175
Jiri Slaby15b611f2006-12-08 02:39:04 -08002176 p = (char *)&vpdp;
2177 for (i = 0; i < sizeof(struct vpd_prom); i++)
2178 *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179
2180 if (sx_debug & SX_DEBUG_PROBE)
Jiri Slaby15b611f2006-12-08 02:39:04 -08002181 my_hd(&vpdp, 0x20);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182
Jiri Slaby15b611f2006-12-08 02:39:04 -08002183 sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184
Jiri Slaby15b611f2006-12-08 02:39:04 -08002185 if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2186 sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
2187 "'%s'\n", vpdp.identifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 return 0;
2189 }
2190 }
2191
Jiri Slaby15b611f2006-12-08 02:39:04 -08002192 printheader();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193
Jiri Slaby15b611f2006-12-08 02:39:04 -08002194 if (!IS_CF_BOARD(board)) {
2195 printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
2196 board->hw_base);
2197 printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
2198 "uniq ID:%08x, ",
2199 vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2200 printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201
Jiri Slaby15b611f2006-12-08 02:39:04 -08002202 if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
2203 SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
2204 SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2205 /* This might be a bit harsh. This was the primary
2206 reason the SX/ISA card didn't work at first... */
2207 printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
2208 "card. Sorry: giving up.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 return (0);
2210 }
2211
Jiri Slaby15b611f2006-12-08 02:39:04 -08002212 if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
2213 SX_ISA_UNIQUEID1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 if (((unsigned long)board->hw_base) & 0x8000) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002215 printk(KERN_WARNING "sx: Warning: There may be "
2216 "hardware problems with the card at "
2217 "%lx.\n", board->hw_base);
2218 printk(KERN_WARNING "sx: Read sx.txt for more "
2219 "info.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 }
2221 }
2222 }
2223
2224 board->nports = -1;
2225
2226 /* This resets the processor, and keeps it off the bus. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002227 if (!sx_reset(board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 return 0;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002229 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 func_exit();
2232 return 1;
2233}
2234
Jiri Slaby927a6f92006-12-08 02:39:02 -08002235#if defined(CONFIG_ISA) || defined(CONFIG_EISA)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236
2237/* Specialix probes for this card at 32k increments from 640k to 16M.
2238 I consider machines with less than 16M unlikely nowadays, so I'm
2239 not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2240 card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves
2241 0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2242
Jiri Slaby15b611f2006-12-08 02:39:04 -08002243static int __devinit probe_si(struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244{
2245 int i;
2246
2247 func_enter();
Jiri Slaby15b611f2006-12-08 02:39:04 -08002248 sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
2249 "%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250
2251 if (sx_debug & SX_DEBUG_PROBE)
2252 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2253
2254 if (!IS_EISA_BOARD(board)) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002255 if (IS_SI1_BOARD(board)) {
2256 for (i = 0; i < 8; i++) {
2257 write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
2258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002260 for (i = 0; i < 8; i++) {
2261 if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
2262 != i) {
2263 func_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 return 0;
2265 }
2266 }
2267 }
2268
2269 /* Now we're pretty much convinced that there is an SI board here,
2270 but to prevent trouble, we'd better double check that we don't
2271 have an SI1 board when we're probing for an SI2 board.... */
2272
Jiri Slaby15b611f2006-12-08 02:39:04 -08002273 write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2274 if (IS_SI1_BOARD(board)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 /* This should be an SI1 board, which has this
2276 location writable... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002277 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2278 func_exit();
2279 return 0;
Marc Zyngier04a3d312006-02-26 12:02:56 +01002280 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 } else {
2282 /* This should be an SI2 board, which has the bottom
2283 3 bits non-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 }
2289
2290 /* Now we're pretty much convinced that there is an SI board here,
2291 but to prevent trouble, we'd better double check that we don't
2292 have an SI1 board when we're probing for an SI2 board.... */
2293
Jiri Slaby15b611f2006-12-08 02:39:04 -08002294 write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2295 if (IS_SI1_BOARD(board)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 /* This should be an SI1 board, which has this
2297 location writable... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002298 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 func_exit();
Jiri Slaby15b611f2006-12-08 02:39:04 -08002300 return 0;
Marc Zyngier04a3d312006-02-26 12:02:56 +01002301 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 } else {
2303 /* This should be an SI2 board, which has the bottom
2304 3 bits non-writable... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002305 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2306 func_exit();
2307 return 0;
Marc Zyngier04a3d312006-02-26 12:02:56 +01002308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 }
2310
Jiri Slaby15b611f2006-12-08 02:39:04 -08002311 printheader();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312
Jiri Slaby15b611f2006-12-08 02:39:04 -08002313 printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 /* Compared to the SX boards, it is a complete guess as to what
Jiri Slaby15b611f2006-12-08 02:39:04 -08002315 this card is up to... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316
2317 board->nports = -1;
2318
2319 /* This resets the processor, and keeps it off the bus. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002320 if (!sx_reset(board))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 return 0;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002322 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 func_exit();
2325 return 1;
2326}
Jiri Slaby927a6f92006-12-08 02:39:02 -08002327#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328
Jeff Dikeb68e31d2006-10-02 02:17:18 -07002329static const struct tty_operations sx_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 .break_ctl = sx_break,
Jiri Slaby15b611f2006-12-08 02:39:04 -08002331 .open = sx_open,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 .close = gs_close,
2333 .write = gs_write,
2334 .put_char = gs_put_char,
2335 .flush_chars = gs_flush_chars,
2336 .write_room = gs_write_room,
2337 .chars_in_buffer = gs_chars_in_buffer,
2338 .flush_buffer = gs_flush_buffer,
2339 .ioctl = sx_ioctl,
2340 .throttle = sx_throttle,
2341 .unthrottle = sx_unthrottle,
2342 .set_termios = gs_set_termios,
2343 .stop = gs_stop,
2344 .start = gs_start,
2345 .hangup = gs_hangup,
2346 .tiocmget = sx_tiocmget,
2347 .tiocmset = sx_tiocmset,
2348};
2349
2350static int sx_init_drivers(void)
2351{
2352 int error;
2353
2354 func_enter();
2355
2356 sx_driver = alloc_tty_driver(sx_nports);
2357 if (!sx_driver)
2358 return 1;
2359 sx_driver->owner = THIS_MODULE;
2360 sx_driver->driver_name = "specialix_sx";
2361 sx_driver->name = "ttyX";
2362 sx_driver->major = SX_NORMAL_MAJOR;
2363 sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2364 sx_driver->subtype = SERIAL_TYPE_NORMAL;
2365 sx_driver->init_termios = tty_std_termios;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002366 sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
Alan Cox606d0992006-12-08 02:38:45 -08002367 sx_driver->init_termios.c_ispeed = 9600;
2368 sx_driver->init_termios.c_ospeed = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 sx_driver->flags = TTY_DRIVER_REAL_RAW;
2370 tty_set_operations(sx_driver, &sx_ops);
2371
2372 if ((error = tty_register_driver(sx_driver))) {
2373 put_tty_driver(sx_driver);
2374 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
Jiri Slaby15b611f2006-12-08 02:39:04 -08002375 error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 return 1;
2377 }
2378 func_exit();
2379 return 0;
2380}
2381
Jiri Slaby15b611f2006-12-08 02:39:04 -08002382static int sx_init_portstructs(int nboards, int nports)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383{
2384 struct sx_board *board;
2385 struct sx_port *port;
2386 int i, j;
2387 int addr, chans;
2388 int portno;
2389
2390 func_enter();
2391
2392 /* Many drivers statically allocate the maximum number of ports
Jiri Slaby15b611f2006-12-08 02:39:04 -08002393 There is no reason not to allocate them dynamically.
2394 Is there? -- REW */
Jiri Slaby4a7cb692006-12-08 02:38:59 -08002395 sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 if (!sx_ports)
2397 return -ENOMEM;
2398
2399 port = sx_ports;
2400 for (i = 0; i < nboards; i++) {
2401 board = &boards[i];
2402 board->ports = port;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002403 for (j = 0; j < boards[i].nports; j++) {
2404 sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405 port->gs.magic = SX_MAGIC;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002406 port->gs.close_delay = HZ / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 port->gs.closing_wait = 30 * HZ;
2408 port->board = board;
2409 port->gs.rd = &sx_real_driver;
2410#ifdef NEW_WRITE_LOCKING
Ingo Molnar81861d72006-03-23 03:00:44 -08002411 port->gs.port_write_mutex = MUTEX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412#endif
Ingo Molnar34af9462006-06-27 02:53:55 -07002413 spin_lock_init(&port->gs.driver_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 /*
2415 * Initializing wait queue
2416 */
2417 init_waitqueue_head(&port->gs.open_wait);
Jiri Slaby15b611f2006-12-08 02:39:04 -08002418 init_waitqueue_head(&port->gs.close_wait);
2419
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 port++;
2421 }
2422 }
2423
2424 port = sx_ports;
2425 portno = 0;
2426 for (i = 0; i < nboards; i++) {
2427 board = &boards[i];
2428 board->port_base = portno;
2429 /* Possibly the configuration was rejected. */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002430 sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
2431 board->nports);
2432 if (board->nports <= 0)
2433 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 /* XXX byteorder ?? */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002435 for (addr = 0x80; addr != 0;
2436 addr = read_sx_word(board, addr) & 0x7fff) {
2437 chans = sx_read_module_byte(board, addr, mc_type);
2438 sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
2439 "channels\n", addr, chans);
2440 sx_dprintk(SX_DEBUG_PROBE, "Port at");
2441 for (j = 0; j < chans; j++) {
2442 /* The "sx-way" is the way it SHOULD be done.
2443 That way in the future, the firmware may for
2444 example pack the structures a bit more
2445 efficient. Neil tells me it isn't going to
2446 happen anytime soon though. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 if (IS_SX_BOARD(board))
Jiri Slaby15b611f2006-12-08 02:39:04 -08002448 port->ch_base = sx_read_module_word(
2449 board, addr + j * 2,
2450 mc_chan_pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451 else
Jiri Slaby15b611f2006-12-08 02:39:04 -08002452 port->ch_base = addr + 0x100 + 0x300 *j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453
Jiri Slaby15b611f2006-12-08 02:39:04 -08002454 sx_dprintk(SX_DEBUG_PROBE, " %x",
2455 port->ch_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 port->line = portno++;
2457 port++;
2458 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002459 sx_dprintk(SX_DEBUG_PROBE, "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 }
2461 /* This has to be done earlier. */
2462 /* board->flags |= SX_BOARD_INITIALIZED; */
2463 }
2464
2465 func_exit();
2466 return 0;
2467}
2468
Jiri Slaby18f813e2006-12-08 02:39:01 -08002469static unsigned int sx_find_free_board(void)
2470{
2471 unsigned int i;
2472
Jiri Slaby15b611f2006-12-08 02:39:04 -08002473 for (i = 0; i < SX_NBOARDS; i++)
Jiri Slaby18f813e2006-12-08 02:39:01 -08002474 if (!(boards[i].flags & SX_BOARD_PRESENT))
2475 break;
2476
2477 return i;
2478}
2479
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480static void __exit sx_release_drivers(void)
2481{
2482 func_enter();
2483 tty_unregister_driver(sx_driver);
2484 put_tty_driver(sx_driver);
2485 func_exit();
2486}
2487
Jiri Slaby39103492006-12-08 02:39:07 -08002488static void __devexit sx_remove_card(struct sx_board *board,
2489 struct pci_dev *pdev)
Jiri Slaby18f813e2006-12-08 02:39:01 -08002490{
2491 if (board->flags & SX_BOARD_INITIALIZED) {
2492 /* The board should stop messing with us. (actually I mean the
2493 interrupt) */
2494 sx_reset(board);
2495 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2496 free_irq(board->irq, board);
2497
2498 /* It is safe/allowed to del_timer a non-active timer */
2499 del_timer(&board->timer);
Jiri Slaby30f42182006-12-08 02:39:08 -08002500 if (pdev) {
Jiri Slaby3468a332006-12-13 00:34:20 -08002501#ifdef CONFIG_PCI
Jiri Slaby39103492006-12-08 02:39:07 -08002502 pci_iounmap(pdev, board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002503 pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
Jiri Slaby3468a332006-12-13 00:34:20 -08002504#endif
Jiri Slaby30f42182006-12-08 02:39:08 -08002505 } else {
Jiri Slaby39103492006-12-08 02:39:07 -08002506 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002507 release_region(board->hw_base, board->hw_len);
2508 }
Jiri Slaby18f813e2006-12-08 02:39:01 -08002509
Jiri Slaby15b611f2006-12-08 02:39:04 -08002510 board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002511 }
2512}
2513
2514#ifdef CONFIG_EISA
2515
2516static int __devinit sx_eisa_probe(struct device *dev)
2517{
2518 struct eisa_device *edev = to_eisa_device(dev);
2519 struct sx_board *board;
2520 unsigned long eisa_slot = edev->base_addr;
2521 unsigned int i;
2522 int retval = -EIO;
2523
Jiri Slaby42f63842006-12-08 02:39:03 -08002524 mutex_lock(&sx_boards_lock);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002525 i = sx_find_free_board();
Jiri Slaby42f63842006-12-08 02:39:03 -08002526 if (i == SX_NBOARDS) {
2527 mutex_unlock(&sx_boards_lock);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002528 goto err;
Jiri Slaby42f63842006-12-08 02:39:03 -08002529 }
2530 board = &boards[i];
2531 board->flags |= SX_BOARD_PRESENT;
2532 mutex_unlock(&sx_boards_lock);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002533
2534 dev_info(dev, "XIO : Signature found in EISA slot %lu, "
Jiri Slaby15b611f2006-12-08 02:39:04 -08002535 "Product %d Rev %d (REPORT THIS TO LKLM)\n",
2536 eisa_slot >> 12,
2537 inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
2538 inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
Jiri Slaby18f813e2006-12-08 02:39:01 -08002539
Jiri Slaby18f813e2006-12-08 02:39:01 -08002540 board->eisa_base = eisa_slot;
2541 board->flags &= ~SX_BOARD_TYPE;
2542 board->flags |= SI_EISA_BOARD;
2543
2544 board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
Jiri Slaby15b611f2006-12-08 02:39:04 -08002545 inb(eisa_slot + 0xc00)) << 16;
Jiri Slaby30f42182006-12-08 02:39:08 -08002546 board->hw_len = SI2_EISA_WINDOW_LEN;
2547 if (!request_region(board->hw_base, board->hw_len, "sx")) {
2548 dev_err(dev, "can't request region\n");
2549 goto err_flag;
2550 }
Jiri Slaby18f813e2006-12-08 02:39:01 -08002551 board->base2 =
2552 board->base = ioremap(board->hw_base, SI2_EISA_WINDOW_LEN);
Jiri Slaby30f42182006-12-08 02:39:08 -08002553 if (!board->base) {
2554 dev_err(dev, "can't remap memory\n");
2555 goto err_reg;
2556 }
Jiri Slaby18f813e2006-12-08 02:39:01 -08002557
2558 sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2559 sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2560 board->irq = inb(eisa_slot + 0xc02) >> 4;
2561 sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2562
2563 if (!probe_si(board))
2564 goto err_unmap;
2565
2566 dev_set_drvdata(dev, board);
2567
2568 return 0;
2569err_unmap:
2570 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002571err_reg:
2572 release_region(board->hw_base, board->hw_len);
2573err_flag:
Jiri Slaby42f63842006-12-08 02:39:03 -08002574 board->flags &= ~SX_BOARD_PRESENT;
Jiri Slaby18f813e2006-12-08 02:39:01 -08002575err:
2576 return retval;
2577}
2578
2579static int __devexit sx_eisa_remove(struct device *dev)
2580{
2581 struct sx_board *board = dev_get_drvdata(dev);
2582
Jiri Slaby39103492006-12-08 02:39:07 -08002583 sx_remove_card(board, NULL);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002584
2585 return 0;
2586}
2587
2588static struct eisa_device_id sx_eisa_tbl[] = {
2589 { "SLX" },
2590 { "" }
2591};
Jiri Slaby15b611f2006-12-08 02:39:04 -08002592
Jiri Slaby18f813e2006-12-08 02:39:01 -08002593MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2594
2595static struct eisa_driver sx_eisadriver = {
2596 .id_table = sx_eisa_tbl,
2597 .driver = {
2598 .name = "sx",
2599 .probe = sx_eisa_probe,
2600 .remove = __devexit_p(sx_eisa_remove),
2601 }
2602};
2603
2604#endif
2605
Jiri Slaby3468a332006-12-13 00:34:20 -08002606#ifdef CONFIG_PCI
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 /********************************************************
2608 * Setting bit 17 in the CNTRL register of the PLX 9050 *
2609 * chip forces a retry on writes while a read is pending.*
2610 * This is to prevent the card locking up on Intel Xeon *
2611 * multiprocessor systems with the NX chipset. -- NV *
2612 ********************************************************/
2613
2614/* Newer cards are produced with this bit set from the configuration
2615 EEprom. As the bit is read/write for the CPU, we can fix it here,
2616 if we detect that it isn't set correctly. -- REW */
2617
Jiri Slabycda52652006-12-08 02:39:00 -08002618static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619{
2620 unsigned int hwbase;
2621 void __iomem *rebase;
2622 unsigned int t;
2623
Jiri Slaby15b611f2006-12-08 02:39:04 -08002624#define CNTRL_REG_OFFSET 0x50
2625#define CNTRL_REG_GOODVALUE 0x18260000
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626
2627 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2628 hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2629 rebase = ioremap(hwbase, 0x80);
Jiri Slaby15b611f2006-12-08 02:39:04 -08002630 t = readl(rebase + CNTRL_REG_OFFSET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 if (t != CNTRL_REG_GOODVALUE) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002632 printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
2633 "%08x\n", t, CNTRL_REG_GOODVALUE);
2634 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 }
2636 iounmap(rebase);
2637}
Jiri Slaby3468a332006-12-13 00:34:20 -08002638#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639
Jiri Slaby5572e102006-12-08 02:38:58 -08002640static int __devinit sx_pci_probe(struct pci_dev *pdev,
Jiri Slaby15b611f2006-12-08 02:39:04 -08002641 const struct pci_device_id *ent)
Jiri Slaby5572e102006-12-08 02:38:58 -08002642{
Jiri Slaby3468a332006-12-13 00:34:20 -08002643#ifdef CONFIG_PCI
Jiri Slaby5572e102006-12-08 02:38:58 -08002644 struct sx_board *board;
Jiri Slaby39103492006-12-08 02:39:07 -08002645 unsigned int i, reg;
Jiri Slaby5572e102006-12-08 02:38:58 -08002646 int retval = -EIO;
2647
Jiri Slaby42f63842006-12-08 02:39:03 -08002648 mutex_lock(&sx_boards_lock);
Jiri Slaby18f813e2006-12-08 02:39:01 -08002649 i = sx_find_free_board();
Jiri Slaby42f63842006-12-08 02:39:03 -08002650 if (i == SX_NBOARDS) {
2651 mutex_unlock(&sx_boards_lock);
Jiri Slaby5572e102006-12-08 02:38:58 -08002652 goto err;
Jiri Slaby42f63842006-12-08 02:39:03 -08002653 }
2654 board = &boards[i];
2655 board->flags |= SX_BOARD_PRESENT;
2656 mutex_unlock(&sx_boards_lock);
Jiri Slaby5572e102006-12-08 02:38:58 -08002657
2658 retval = pci_enable_device(pdev);
2659 if (retval)
Jiri Slaby42f63842006-12-08 02:39:03 -08002660 goto err_flag;
Jiri Slaby5572e102006-12-08 02:38:58 -08002661
2662 board->flags &= ~SX_BOARD_TYPE;
2663 board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
Jiri Slaby15b611f2006-12-08 02:39:04 -08002664 SX_CFPCI_BOARD;
Jiri Slaby5572e102006-12-08 02:38:58 -08002665
2666 /* CF boards use base address 3.... */
Jiri Slaby39103492006-12-08 02:39:07 -08002667 reg = IS_CF_BOARD(board) ? 3 : 2;
Jiri Slaby30f42182006-12-08 02:39:08 -08002668 retval = pci_request_region(pdev, reg, "sx");
2669 if (retval) {
2670 dev_err(&pdev->dev, "can't request region\n");
2671 goto err_flag;
2672 }
Jiri Slaby39103492006-12-08 02:39:07 -08002673 board->hw_base = pci_resource_start(pdev, reg);
Jiri Slaby5572e102006-12-08 02:38:58 -08002674 board->base2 =
Jiri Slaby39103492006-12-08 02:39:07 -08002675 board->base = pci_iomap(pdev, reg, WINDOW_LEN(board));
Jiri Slaby5572e102006-12-08 02:38:58 -08002676 if (!board->base) {
2677 dev_err(&pdev->dev, "ioremap failed\n");
Jiri Slaby30f42182006-12-08 02:39:08 -08002678 goto err_reg;
Jiri Slaby5572e102006-12-08 02:38:58 -08002679 }
2680
2681 /* Most of the stuff on the CF board is offset by 0x18000 .... */
Jiri Slaby15b611f2006-12-08 02:39:04 -08002682 if (IS_CF_BOARD(board))
Jiri Slaby5572e102006-12-08 02:38:58 -08002683 board->base += 0x18000;
2684
2685 board->irq = pdev->irq;
2686
2687 dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
Jiri Slaby15b611f2006-12-08 02:39:04 -08002688 board->irq, board->flags);
Jiri Slaby5572e102006-12-08 02:38:58 -08002689
2690 if (!probe_sx(board)) {
2691 retval = -EIO;
2692 goto err_unmap;
2693 }
2694
2695 fix_sx_pci(pdev, board);
2696
2697 pci_set_drvdata(pdev, board);
2698
2699 return 0;
2700err_unmap:
Jiri Slaby39103492006-12-08 02:39:07 -08002701 pci_iounmap(pdev, board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002702err_reg:
2703 pci_release_region(pdev, reg);
Jiri Slaby42f63842006-12-08 02:39:03 -08002704err_flag:
2705 board->flags &= ~SX_BOARD_PRESENT;
Jiri Slaby5572e102006-12-08 02:38:58 -08002706err:
2707 return retval;
Jiri Slaby3468a332006-12-13 00:34:20 -08002708#else
2709 return -ENODEV;
2710#endif
Jiri Slaby5572e102006-12-08 02:38:58 -08002711}
2712
2713static void __devexit sx_pci_remove(struct pci_dev *pdev)
2714{
2715 struct sx_board *board = pci_get_drvdata(pdev);
2716
Jiri Slaby39103492006-12-08 02:39:07 -08002717 sx_remove_card(board, pdev);
Jiri Slaby5572e102006-12-08 02:38:58 -08002718}
2719
2720/* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
2721 its because the standard requires it. So check for SUBVENDOR_ID. */
2722static struct pci_device_id sx_pci_tbl[] = {
2723 { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
Jiri Slabyc14d4442007-07-10 17:22:25 -07002724 .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
Jiri Slaby5572e102006-12-08 02:38:58 -08002725 { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
Jiri Slabyc14d4442007-07-10 17:22:25 -07002726 .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
Jiri Slaby5572e102006-12-08 02:38:58 -08002727 { 0 }
2728};
Jiri Slaby15b611f2006-12-08 02:39:04 -08002729
Jiri Slaby5572e102006-12-08 02:38:58 -08002730MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2731
2732static struct pci_driver sx_pcidriver = {
2733 .name = "sx",
2734 .id_table = sx_pci_tbl,
2735 .probe = sx_pci_probe,
2736 .remove = __devexit_p(sx_pci_remove)
2737};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738
Jiri Slaby15b611f2006-12-08 02:39:04 -08002739static int __init sx_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740{
Jiri Slaby18f813e2006-12-08 02:39:01 -08002741#ifdef CONFIG_EISA
2742 int retval1;
2743#endif
Jiri Slaby927a6f92006-12-08 02:39:02 -08002744#ifdef CONFIG_ISA
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 struct sx_board *board;
Jiri Slaby927a6f92006-12-08 02:39:02 -08002746 unsigned int i;
2747#endif
2748 unsigned int found = 0;
2749 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751 func_enter();
Jiri Slaby15b611f2006-12-08 02:39:04 -08002752 sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
2753 sx_debug);
2754 if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
2755 printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
2756 "value. Assuming -1.\n(%p)\n", &sx_debug);
2757 sx_debug = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 }
2759
2760 if (misc_register(&sx_fw_device) < 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002761 printk(KERN_ERR "SX: Unable to register firmware loader "
2762 "driver.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 return -EIO;
2764 }
Jiri Slaby927a6f92006-12-08 02:39:02 -08002765#ifdef CONFIG_ISA
Jiri Slaby15b611f2006-12-08 02:39:04 -08002766 for (i = 0; i < NR_SX_ADDRS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 board = &boards[found];
2768 board->hw_base = sx_probe_addrs[i];
Jiri Slaby30f42182006-12-08 02:39:08 -08002769 board->hw_len = SX_WINDOW_LEN;
2770 if (!request_region(board->hw_base, board->hw_len, "sx"))
2771 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772 board->base2 =
Jiri Slaby30f42182006-12-08 02:39:08 -08002773 board->base = ioremap(board->hw_base, board->hw_len);
2774 if (!board->base)
2775 goto err_sx_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 board->flags &= ~SX_BOARD_TYPE;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002777 board->flags |= SX_ISA_BOARD;
2778 board->irq = sx_irqmask ? -1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779
Jiri Slaby15b611f2006-12-08 02:39:04 -08002780 if (probe_sx(board)) {
Jiri Slaby42f63842006-12-08 02:39:03 -08002781 board->flags |= SX_BOARD_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 found++;
2783 } else {
2784 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002785err_sx_reg:
2786 release_region(board->hw_base, board->hw_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787 }
2788 }
2789
Jiri Slaby15b611f2006-12-08 02:39:04 -08002790 for (i = 0; i < NR_SI_ADDRS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 board = &boards[found];
2792 board->hw_base = si_probe_addrs[i];
Jiri Slaby30f42182006-12-08 02:39:08 -08002793 board->hw_len = SI2_ISA_WINDOW_LEN;
2794 if (!request_region(board->hw_base, board->hw_len, "sx"))
2795 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796 board->base2 =
Jiri Slaby30f42182006-12-08 02:39:08 -08002797 board->base = ioremap(board->hw_base, board->hw_len);
2798 if (!board->base)
2799 goto err_si_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800 board->flags &= ~SX_BOARD_TYPE;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002801 board->flags |= SI_ISA_BOARD;
2802 board->irq = sx_irqmask ? -1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803
Jiri Slaby15b611f2006-12-08 02:39:04 -08002804 if (probe_si(board)) {
Jiri Slaby42f63842006-12-08 02:39:03 -08002805 board->flags |= SX_BOARD_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806 found++;
2807 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002808 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002809err_si_reg:
2810 release_region(board->hw_base, board->hw_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 }
2812 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002813 for (i = 0; i < NR_SI1_ADDRS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814 board = &boards[found];
2815 board->hw_base = si1_probe_addrs[i];
Jiri Slaby30f42182006-12-08 02:39:08 -08002816 board->hw_len = SI1_ISA_WINDOW_LEN;
2817 if (!request_region(board->hw_base, board->hw_len, "sx"))
2818 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819 board->base2 =
Jiri Slaby30f42182006-12-08 02:39:08 -08002820 board->base = ioremap(board->hw_base, board->hw_len);
2821 if (!board->base)
2822 goto err_si1_reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 board->flags &= ~SX_BOARD_TYPE;
Jiri Slaby15b611f2006-12-08 02:39:04 -08002824 board->flags |= SI1_ISA_BOARD;
2825 board->irq = sx_irqmask ? -1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826
Jiri Slaby15b611f2006-12-08 02:39:04 -08002827 if (probe_si(board)) {
Jiri Slaby42f63842006-12-08 02:39:03 -08002828 board->flags |= SX_BOARD_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 found++;
2830 } else {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002831 iounmap(board->base);
Jiri Slaby30f42182006-12-08 02:39:08 -08002832err_si1_reg:
2833 release_region(board->hw_base, board->hw_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 }
2835 }
Jiri Slaby927a6f92006-12-08 02:39:02 -08002836#endif
Jiri Slaby18f813e2006-12-08 02:39:01 -08002837#ifdef CONFIG_EISA
2838 retval1 = eisa_driver_register(&sx_eisadriver);
2839#endif
Jiri Slaby5572e102006-12-08 02:38:58 -08002840 retval = pci_register_driver(&sx_pcidriver);
2841
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 if (found) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002843 printk(KERN_INFO "sx: total of %d boards detected.\n", found);
Jiri Slaby5572e102006-12-08 02:38:58 -08002844 retval = 0;
2845 } else if (retval) {
Jiri Slaby18f813e2006-12-08 02:39:01 -08002846#ifdef CONFIG_EISA
Jiri Slaby7eb99762006-12-08 02:39:06 -08002847 retval = retval1;
Jiri Slaby18f813e2006-12-08 02:39:01 -08002848 if (retval1)
2849#endif
Jiri Slaby15b611f2006-12-08 02:39:04 -08002850 misc_deregister(&sx_fw_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 }
2852
2853 func_exit();
Jiri Slaby5572e102006-12-08 02:38:58 -08002854 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855}
2856
Jiri Slaby15b611f2006-12-08 02:39:04 -08002857static void __exit sx_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858{
Jiri Slaby15b611f2006-12-08 02:39:04 -08002859 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860
2861 func_enter();
Jiri Slaby18f813e2006-12-08 02:39:01 -08002862#ifdef CONFIG_EISA
2863 eisa_driver_unregister(&sx_eisadriver);
2864#endif
Jiri Slaby5572e102006-12-08 02:38:58 -08002865 pci_unregister_driver(&sx_pcidriver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866
Jiri Slaby55e70712006-12-08 02:39:03 -08002867 for (i = 0; i < SX_NBOARDS; i++)
Jiri Slaby39103492006-12-08 02:39:07 -08002868 sx_remove_card(&boards[i], NULL);
Jiri Slaby55e70712006-12-08 02:39:03 -08002869
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870 if (misc_deregister(&sx_fw_device) < 0) {
Jiri Slaby15b611f2006-12-08 02:39:04 -08002871 printk(KERN_INFO "sx: couldn't deregister firmware loader "
2872 "device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 }
Jiri Slaby15b611f2006-12-08 02:39:04 -08002874 sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
2875 sx_initialized);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876 if (sx_initialized)
Jiri Slaby15b611f2006-12-08 02:39:04 -08002877 sx_release_drivers();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878
Jiri Slaby15b611f2006-12-08 02:39:04 -08002879 kfree(sx_ports);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880 func_exit();
2881}
2882
2883module_init(sx_init);
2884module_exit(sx_exit);