1
/* sx.c -- driver for the Specialix SX series cards.
3
* This driver will also support the older SI, and XIO cards.
6
* (C) 1998 - 2004 R.E.Wolff@BitWizard.nl
8
* Simon Allen (simonallen@cix.compulink.co.uk) wrote a previous
9
* version of this driver. Some fragments may have been copied. (none
12
* Specialix pays for the development and support of this driver.
13
* Please DO contact support@specialix.co.uk if you require
14
* support. But please read the documentation (sx.txt) first.
18
* This program is free software; you can redistribute it and/or
19
* modify it under the terms of the GNU General Public License as
20
* published by the Free Software Foundation; either version 2 of
21
* the License, or (at your option) any later version.
23
* This program is distributed in the hope that it will be
24
* useful, but WITHOUT ANY WARRANTY; without even the implied
25
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
26
* PURPOSE. See the GNU General Public License for more details.
28
* You should have received a copy of the GNU General Public
29
* License along with this program; if not, write to the Free
30
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
34
* Revision 1.33 2000/03/09 10:00:00 pvdl,wolff
35
* - Fixed module and port counting
36
* - Fixed signal handling
39
* Revision 1.32 2000/03/07 09:00:00 wolff,pvdl
40
* - Fixed some sx_dprintk typos
41
* - added detection for an invalid board/module configuration
43
* Revision 1.31 2000/03/06 12:00:00 wolff,pvdl
44
* - Added support for EISA
46
* Revision 1.30 2000/01/21 17:43:06 wolff
47
* - Added support for SX+
49
* Revision 1.26 1999/08/05 15:22:14 wolff
51
* - Reformatted to Linus' liking.
53
* Revision 1.25 1999/07/30 14:24:08 wolff
54
* Had accidentally left "gs_debug" set to "-1" instead of "off" (=0).
56
* Revision 1.24 1999/07/28 09:41:52 wolff
57
* - I noticed the remark about use-count straying in sx.txt. I checked
58
* sx_open, and found a few places where that could happen. I hope it's
61
* Revision 1.23 1999/07/28 08:56:06 wolff
62
* - Fixed crash when sx_firmware run twice.
63
* - Added sx_slowpoll as a module parameter (I guess nobody really wanted
64
* to change it from the default... )
65
* - Fixed a stupid editing problem I introduced in 1.22.
66
* - Fixed dropping characters on a termios change.
68
* Revision 1.22 1999/07/26 21:01:43 wolff
69
* Russell Brown noticed that I had overlooked 4 out of six modem control
70
* signals in sx_getsignals. Ooops.
72
* Revision 1.21 1999/07/23 09:11:33 wolff
73
* I forgot to free dynamically allocated memory when the driver is unloaded.
75
* Revision 1.20 1999/07/20 06:25:26 wolff
76
* The "closing wait" wasn't honoured. Thanks to James Griffiths for
79
* Revision 1.19 1999/07/11 08:59:59 wolff
80
* Fixed an oops in close, when an open was pending. Changed the memtest
81
* a bit. Should also test the board in word-mode, however my card fails the
82
* memtest then. I still have to figure out what is wrong...
84
* Revision 1.18 1999/06/10 09:38:42 wolff
85
* Changed the format of the firmware revision from %04x to %x.%02x .
87
* Revision 1.17 1999/06/04 09:44:35 wolff
88
* fixed problem: reference to pci stuff when config_pci was off...
89
* Thanks to Jorge Novo for noticing this.
91
* Revision 1.16 1999/06/02 08:30:15 wolff
92
* added/removed the workaround for the DCD bug in the Firmware.
93
* A bit more debugging code to locate that...
95
* Revision 1.15 1999/06/01 11:35:30 wolff
96
* when DCD is left low (floating?), on TA's the firmware first tells us
97
* that DCD is high, but after a short while suddenly comes to the
98
* conclusion that it is low. All this would be fine, if it weren't that
99
* Unix requires us to send a "hangup" signal in that case. This usually
100
* all happens BEFORE the program has had a chance to ioctl the device
103
* Revision 1.14 1999/05/25 11:18:59 wolff
105
* Added checks for return code of sx_sendcommand.
106
* Don't issue "reconfig" if port isn't open yet. (bit us on TA modules...)
108
* Revision 1.13 1999/04/29 15:18:01 wolff
109
* Fixed an "oops" that showed on SuSE 6.0 systems.
110
* Activate DTR again after stty 0.
112
* Revision 1.12 1999/04/29 07:49:52 wolff
113
* Improved "stty 0" handling a bit. (used to change baud to 9600 assuming
114
* the connection would be dropped anyway. That is not always the case,
115
* and confuses people).
116
* Told the card to always monitor the modem signals.
117
* Added support for dynamic gs_debug adjustments.
118
* Now tells the rest of the system the number of ports.
120
* Revision 1.11 1999/04/24 11:11:30 wolff
121
* Fixed two stupid typos in the memory test.
123
* Revision 1.10 1999/04/24 10:53:39 wolff
124
* Added some of Christian's suggestions.
125
* Fixed an HW_COOK_IN bug (ISIG was not in I_OTHER. We used to trust the
126
* card to send the signal to the process.....)
128
* Revision 1.9 1999/04/23 07:26:38 wolff
129
* Included Christian Lademann's 2.0 compile-warning fixes and interrupt
130
* assignment redesign.
131
* Cleanup of some other stuff.
133
* Revision 1.8 1999/04/16 13:05:30 wolff
134
* fixed a DCD change unnoticed bug.
136
* Revision 1.7 1999/04/14 22:19:51 wolff
137
* Fixed typo that showed up in 2.0.x builds (get_user instead of Get_user!)
139
* Revision 1.6 1999/04/13 18:40:20 wolff
140
* changed misc-minor to 161, as assigned by HPA.
142
* Revision 1.5 1999/04/13 15:12:25 wolff
143
* Fixed use-count leak when "hangup" occurred.
144
* Added workaround for a stupid-PCIBIOS bug.
147
* Revision 1.4 1999/04/01 22:47:40 wolff
148
* Fixed < 1M linux-2.0 problem.
149
* (vremap isn't compatible with ioremap in that case)
151
* Revision 1.3 1999/03/31 13:45:45 wolff
152
* Firmware loading is now done through a separate IOCTL.
154
* Revision 1.2 1999/03/28 12:22:29 wolff
157
* Revision 1.1 1999/03/28 12:10:34 wolff
158
* Readying for release on 2.0.x (sorry David, 1.01 becomes 1.1 for RCS).
160
* Revision 0.12 1999/03/28 09:20:10 wolff
161
* Fixed problem in 0.11, continueing cleanup.
163
* Revision 0.11 1999/03/28 08:46:44 wolff
166
* Revision 0.10 1999/03/28 08:09:43 wolff
167
* Fixed loosing characters on close.
169
* Revision 0.9 1999/03/21 22:52:01 wolff
170
* Ported back to 2.2.... (minor things)
172
* Revision 0.8 1999/03/21 22:40:33 wolff
175
* Revision 0.7 1999/03/21 19:06:34 wolff
176
* Fixed hangup processing.
178
* Revision 0.6 1999/02/05 08:45:14 wolff
179
* fixed real_raw problems. Inclusion into kernel imminent.
181
* Revision 0.5 1998/12/21 23:51:06 wolff
182
* Snatched a nasty bug: sx_transmit_chars was getting re-entered, and it
183
* shouldn't have. THATs why I want to have transmit interrupts even when
184
* the buffer is empty.
186
* Revision 0.4 1998/12/17 09:34:46 wolff
187
* PPP works. ioctl works. Basically works!
189
* Revision 0.3 1998/12/15 13:05:18 wolff
190
* It works! Wow! Gotta start implementing IOCTL and stuff....
192
* Revision 0.2 1998/12/01 08:33:53 wolff
193
* moved over to 2.1.130
195
* Revision 0.1 1998/11/03 21:23:51 wolff
196
* Initial revision. Detects SX card.
200
#define SX_VERSION 1.33
202
#include <linux/module.h>
203
#include <linux/kdev_t.h>
204
#include <linux/kernel.h>
205
#include <linux/sched.h>
206
#include <linux/ioport.h>
207
#include <linux/interrupt.h>
208
#include <linux/errno.h>
209
#include <linux/tty.h>
210
#include <linux/tty_flip.h>
211
#include <linux/mm.h>
212
#include <linux/serial.h>
213
#include <linux/fcntl.h>
214
#include <linux/major.h>
215
#include <linux/delay.h>
216
#include <linux/eisa.h>
217
#include <linux/pci.h>
218
#include <linux/slab.h>
219
#include <linux/init.h>
220
#include <linux/miscdevice.h>
221
#include <linux/bitops.h>
224
#include <asm/uaccess.h>
226
/* The 3.0.0 version of sxboards/sxwindow.h uses BYTE and WORD.... */
230
/* .... but the 3.0.4 version uses _u8 and _u16. */
234
#include "sxboards.h"
235
#include "sxwindow.h"
237
#include <linux/generic_serial.h>
240
/* I don't think that this driver can handle more than 256 ports on
241
one machine. You'll have to increase the number of boards in sx.h
242
if you want more than 4 boards. */
244
#ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
245
#define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
248
/* Configurable options:
249
(Don't be too sure that it'll work if you toggle them) */
251
/* Am I paranoid or not ? ;-) */
252
#undef SX_PARANOIA_CHECK
254
/* 20 -> 2000 per second. The card should rate-limit interrupts at 100
255
Hz, but it is user configurable. I don't recommend going above 1000
256
Hz. The interrupt ratelimit might trigger if the interrupt is
257
shared with a very active other device. */
258
#define IRQ_RATE_LIMIT 20
260
/* Sharing interrupts is possible now. If the other device wants more
261
than 2000 interrupts per second, we'd gracefully decline further
262
interrupts. That's not what we want. On the other hand, if the
263
other device interrupts 2000 times a second, don't use the SX
264
interrupt. Use polling. */
265
#undef IRQ_RATE_LIMIT
268
/* Not implemented */
270
* The following defines are mostly for testing purposes. But if you need
271
* some nice reporting in your syslog, you can define them also.
273
#define SX_REPORT_FIFO
274
#define SX_REPORT_OVERRUN
277
/* Function prototypes */
278
static void sx_disable_tx_interrupts(void *ptr);
279
static void sx_enable_tx_interrupts(void *ptr);
280
static void sx_disable_rx_interrupts(void *ptr);
281
static void sx_enable_rx_interrupts(void *ptr);
282
static int sx_carrier_raised(struct tty_port *port);
283
static void sx_shutdown_port(void *ptr);
284
static int sx_set_real_termios(void *ptr);
285
static void sx_close(void *ptr);
286
static int sx_chars_in_buffer(void *ptr);
287
static int sx_init_board(struct sx_board *board);
288
static int sx_init_portstructs(int nboards, int nports);
289
static long sx_fw_ioctl(struct file *filp, unsigned int cmd,
291
static int sx_init_drivers(void);
293
static struct tty_driver *sx_driver;
295
static DEFINE_MUTEX(sx_boards_lock);
296
static struct sx_board boards[SX_NBOARDS];
297
static struct sx_port *sx_ports;
298
static int sx_initialized;
299
static int sx_nports;
302
/* You can have the driver poll your card.
303
- Set sx_poll to 1 to poll every timer tick (10ms on Intel).
304
This is used when the card cannot use an interrupt for some reason.
306
- set sx_slowpoll to 100 to do an extra poll once a second (on Intel). If
307
the driver misses an interrupt (report this if it DOES happen to you!)
308
everything will continue to work....
310
static int sx_poll = 1;
311
static int sx_slowpoll;
313
/* The card limits the number of interrupts per second.
314
At 115k2 "100" should be sufficient.
315
If you're using higher baudrates, you can increase this...
318
static int sx_maxints = 100;
322
/* These are the only open spaces in my computer. Yours may have more
324
duh: Card at 0xa0000 is possible on HP Netserver?? -- pvdl
326
static int sx_probe_addrs[] = {
327
0xc0000, 0xd0000, 0xe0000,
328
0xc8000, 0xd8000, 0xe8000
330
static int si_probe_addrs[] = {
331
0xc0000, 0xd0000, 0xe0000,
332
0xc8000, 0xd8000, 0xe8000, 0xa0000
334
static int si1_probe_addrs[] = {
338
#define NR_SX_ADDRS ARRAY_SIZE(sx_probe_addrs)
339
#define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
340
#define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
342
module_param_array(sx_probe_addrs, int, NULL, 0);
343
module_param_array(si_probe_addrs, int, NULL, 0);
346
/* Set the mask to all-ones. This alas, only supports 32 interrupts.
347
Some architectures may need more. */
348
static int sx_irqmask = -1;
350
module_param(sx_poll, int, 0);
351
module_param(sx_slowpoll, int, 0);
352
module_param(sx_maxints, int, 0);
353
module_param(sx_debug, int, 0);
354
module_param(sx_irqmask, int, 0);
356
MODULE_LICENSE("GPL");
358
static struct real_driver sx_real_driver = {
359
sx_disable_tx_interrupts,
360
sx_enable_tx_interrupts,
361
sx_disable_rx_interrupts,
362
sx_enable_rx_interrupts,
370
This driver can spew a whole lot of debugging output at you. If you
371
need maximum performance, you should disable the DEBUG define. To
372
aid in debugging in the field, I'm leaving the compile-time debug
373
features enabled, and disable them "runtime". That allows me to
374
instruct people with problems to enable debugging without requiring
380
#define sx_dprintk(f, str...) if (sx_debug & f) printk (str)
382
#define sx_dprintk(f, str...) /* nothing */
385
#define func_enter() sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__func__)
386
#define func_exit() sx_dprintk(SX_DEBUG_FLOW, "sx: exit %s\n",__func__)
388
#define func_enter2() sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
389
__func__, port->line)
392
* Firmware loader driver specific routines
396
static const struct file_operations sx_fw_fops = {
397
.owner = THIS_MODULE,
398
.unlocked_ioctl = sx_fw_ioctl,
399
.llseek = noop_llseek,
402
static struct miscdevice sx_fw_device = {
403
SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
406
#ifdef SX_PARANOIA_CHECK
408
/* This doesn't work. Who's paranoid around here? Not me! */
410
static inline int sx_paranoia_check(struct sx_port const *port,
411
char *name, const char *routine)
413
static const char *badmagic = KERN_ERR "sx: Warning: bad sx port magic "
414
"number for device %s in %s\n";
415
static const char *badinfo = KERN_ERR "sx: Warning: null sx port for "
419
printk(badinfo, name, routine);
422
if (port->magic != SX_MAGIC) {
423
printk(badmagic, name, routine);
430
#define sx_paranoia_check(a,b,c) 0
433
/* The timeouts. First try 30 times as fast as possible. Then give
434
the card some time to breathe between accesses. (Otherwise the
435
processor on the card might not be able to access its OWN bus... */
438
#define TIMEOUT_2 1000000
441
static void my_hd_io(void __iomem *p, int len)
444
unsigned char __iomem *addr = p;
446
for (i = 0; i < len; i += 16) {
447
printk("%p ", addr + i);
448
for (j = 0; j < 16; j++) {
449
printk("%02x %s", readb(addr + j + i),
450
(j == 7) ? " " : "");
452
for (j = 0; j < 16; j++) {
453
ch = readb(addr + j + i);
454
printk("%c", (ch < 0x20) ? '.' :
455
((ch > 0x7f) ? '.' : ch));
460
static void my_hd(void *p, int len)
463
unsigned char *addr = p;
465
for (i = 0; i < len; i += 16) {
466
printk("%p ", addr + i);
467
for (j = 0; j < 16; j++) {
468
printk("%02x %s", addr[j + i], (j == 7) ? " " : "");
470
for (j = 0; j < 16; j++) {
472
printk("%c", (ch < 0x20) ? '.' :
473
((ch > 0x7f) ? '.' : ch));
480
/* This needs redoing for Alpha -- REW -- Done. */
482
static inline void write_sx_byte(struct sx_board *board, int offset, u8 byte)
484
writeb(byte, board->base + offset);
487
static inline u8 read_sx_byte(struct sx_board *board, int offset)
489
return readb(board->base + offset);
492
static inline void write_sx_word(struct sx_board *board, int offset, u16 word)
494
writew(word, board->base + offset);
497
static inline u16 read_sx_word(struct sx_board *board, int offset)
499
return readw(board->base + offset);
502
static int sx_busy_wait_eq(struct sx_board *board,
503
int offset, int mask, int correctval)
509
for (i = 0; i < TIMEOUT_1; i++)
510
if ((read_sx_byte(board, offset) & mask) == correctval) {
515
for (i = 0; i < TIMEOUT_2; i++) {
516
if ((read_sx_byte(board, offset) & mask) == correctval) {
527
static int sx_busy_wait_neq(struct sx_board *board,
528
int offset, int mask, int badval)
534
for (i = 0; i < TIMEOUT_1; i++)
535
if ((read_sx_byte(board, offset) & mask) != badval) {
540
for (i = 0; i < TIMEOUT_2; i++) {
541
if ((read_sx_byte(board, offset) & mask) != badval) {
552
/* 5.6.4 of 6210028 r2.3 */
553
static int sx_reset(struct sx_board *board)
557
if (IS_SX_BOARD(board)) {
559
write_sx_byte(board, SX_CONFIG, 0);
560
write_sx_byte(board, SX_RESET, 1); /* Value doesn't matter */
562
if (!sx_busy_wait_eq(board, SX_RESET_STATUS, 1, 0)) {
563
printk(KERN_INFO "sx: Card doesn't respond to "
567
} else if (IS_EISA_BOARD(board)) {
568
outb(board->irq << 4, board->eisa_base + 0xc02);
569
} else if (IS_SI1_BOARD(board)) {
570
write_sx_byte(board, SI1_ISA_RESET, 0); /*value doesn't matter*/
572
/* Gory details of the SI/ISA board */
573
write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
574
write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
575
write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
576
write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
577
write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
578
write_sx_byte(board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
585
/* This doesn't work on machines where "NULL" isn't 0 */
586
/* If you have one of those, someone will need to write
587
the equivalent of this, which will amount to about 3 lines. I don't
588
want to complicate this right now. -- REW
589
(See, I do write comments every now and then :-) */
590
#define OFFSETOF(strct, elem) ((long)&(((struct strct *)NULL)->elem))
592
#define CHAN_OFFSET(port,elem) (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
593
#define MODU_OFFSET(board,addr,elem) (addr + OFFSETOF (_SXMODULE, elem))
594
#define BRD_OFFSET(board,elem) (OFFSETOF (_SXCARD, elem))
596
#define sx_write_channel_byte(port, elem, val) \
597
write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
599
#define sx_read_channel_byte(port, elem) \
600
read_sx_byte (port->board, CHAN_OFFSET (port, elem))
602
#define sx_write_channel_word(port, elem, val) \
603
write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
605
#define sx_read_channel_word(port, elem) \
606
read_sx_word (port->board, CHAN_OFFSET (port, elem))
608
#define sx_write_module_byte(board, addr, elem, val) \
609
write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
611
#define sx_read_module_byte(board, addr, elem) \
612
read_sx_byte (board, MODU_OFFSET (board, addr, elem))
614
#define sx_write_module_word(board, addr, elem, val) \
615
write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
617
#define sx_read_module_word(board, addr, elem) \
618
read_sx_word (board, MODU_OFFSET (board, addr, elem))
620
#define sx_write_board_byte(board, elem, val) \
621
write_sx_byte (board, BRD_OFFSET (board, elem), val)
623
#define sx_read_board_byte(board, elem) \
624
read_sx_byte (board, BRD_OFFSET (board, elem))
626
#define sx_write_board_word(board, elem, val) \
627
write_sx_word (board, BRD_OFFSET (board, elem), val)
629
#define sx_read_board_word(board, elem) \
630
read_sx_word (board, BRD_OFFSET (board, elem))
632
static int sx_start_board(struct sx_board *board)
634
if (IS_SX_BOARD(board)) {
635
write_sx_byte(board, SX_CONFIG, SX_CONF_BUSEN);
636
} else if (IS_EISA_BOARD(board)) {
637
write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
638
outb((board->irq << 4) | 4, board->eisa_base + 0xc02);
639
} else if (IS_SI1_BOARD(board)) {
640
write_sx_byte(board, SI1_ISA_RESET_CLEAR, 0);
641
write_sx_byte(board, SI1_ISA_INTCL, 0);
643
/* Don't bug me about the clear_set.
644
I haven't the foggiest idea what it's about -- REW */
645
write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
646
write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
651
#define SX_IRQ_REG_VAL(board) \
652
((board->flags & SX_ISA_BOARD) ? (board->irq << 4) : 0)
654
/* Note. The SX register is write-only. Therefore, we have to enable the
655
bus too. This is a no-op, if you don't mess with this driver... */
656
static int sx_start_interrupts(struct sx_board *board)
659
/* Don't call this with board->irq == 0 */
661
if (IS_SX_BOARD(board)) {
662
write_sx_byte(board, SX_CONFIG, SX_IRQ_REG_VAL(board) |
663
SX_CONF_BUSEN | SX_CONF_HOSTIRQ);
664
} else if (IS_EISA_BOARD(board)) {
665
inb(board->eisa_base + 0xc03);
666
} else if (IS_SI1_BOARD(board)) {
667
write_sx_byte(board, SI1_ISA_INTCL, 0);
668
write_sx_byte(board, SI1_ISA_INTCL_CLEAR, 0);
670
switch (board->irq) {
672
write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);
675
write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);
678
write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);
681
printk(KERN_INFO "sx: SI/XIO card doesn't support "
682
"interrupt %d.\n", board->irq);
685
write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
691
static int sx_send_command(struct sx_port *port,
692
int command, int mask, int newstat)
695
write_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat), command);
697
return sx_busy_wait_eq(port->board, CHAN_OFFSET(port, hi_hstat), mask,
701
static char *mod_type_s(int module_type)
703
switch (module_type) {
717
return "Unknown/invalid";
721
static char *pan_type_s(int pan_type)
725
return "MOD_RS232DB25";
727
return "MOD_RS232RJ45";
729
return "MOD_RS422DB25";
731
return "MOD_PARALLEL";
732
case MOD_2_RS232DB25:
733
return "MOD_2_RS232DB25";
734
case MOD_2_RS232RJ45:
735
return "MOD_2_RS232RJ45";
736
case MOD_2_RS422DB25:
737
return "MOD_2_RS422DB25";
738
case MOD_RS232DB25MALE:
739
return "MOD_RS232DB25MALE";
741
return "MOD_2_PARALLEL";
749
static int mod_compat_type(int module_type)
751
return module_type >> 4;
754
static void sx_reconfigure_port(struct sx_port *port)
756
if (sx_read_channel_byte(port, hi_hstat) == HS_IDLE_OPEN) {
757
if (sx_send_command(port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
758
printk(KERN_WARNING "sx: Sent reconfigure command, but "
759
"card didn't react.\n");
762
sx_dprintk(SX_DEBUG_TERMIOS, "sx: Not sending reconfigure: "
763
"port isn't open (%02x).\n",
764
sx_read_channel_byte(port, hi_hstat));
768
static void sx_setsignals(struct sx_port *port, int dtr, int rts)
773
t = sx_read_channel_byte(port, hi_op);
775
t = dtr ? (t | OP_DTR) : (t & ~OP_DTR);
777
t = rts ? (t | OP_RTS) : (t & ~OP_RTS);
778
sx_write_channel_byte(port, hi_op, t);
779
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
784
static int sx_getsignals(struct sx_port *port)
788
o_stat = sx_read_channel_byte(port, hi_op);
789
i_stat = sx_read_channel_byte(port, hi_ip);
791
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d (%d/%d) "
793
(o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
794
port->c_dcd, tty_port_carrier_raised(&port->gs.port),
795
sx_read_channel_byte(port, hi_ip),
796
sx_read_channel_byte(port, hi_state));
798
return (((o_stat & OP_DTR) ? TIOCM_DTR : 0) |
799
((o_stat & OP_RTS) ? TIOCM_RTS : 0) |
800
((i_stat & IP_CTS) ? TIOCM_CTS : 0) |
801
((i_stat & IP_DCD) ? TIOCM_CAR : 0) |
802
((i_stat & IP_DSR) ? TIOCM_DSR : 0) |
803
((i_stat & IP_RI) ? TIOCM_RNG : 0));
806
static void sx_set_baud(struct sx_port *port)
810
if (port->board->ta_type == MOD_SXDC) {
811
switch (port->gs.baud) {
812
/* Save some typing work... */
813
#define e(x) case x: t = BAUD_ ## x; break
850
/* Can I return "invalid"? */
852
printk(KERN_INFO "sx: unsupported baud rate: %d.\n",
858
/* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
859
sx_setsignals(port, 1, -1);
860
/* XXX This is not TA & MTA compatible */
861
sx_write_channel_byte(port, hi_csr, 0xff);
863
sx_write_channel_byte(port, hi_txbaud, t);
864
sx_write_channel_byte(port, hi_rxbaud, t);
866
sx_setsignals(port, 0, -1);
869
switch (port->gs.baud) {
870
#define e(x) case x: t = CSR_ ## x; break
883
/* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
885
if (port->board->ta_type == MOD_TA) {
890
printk(KERN_INFO "sx: Unsupported baud rate: "
891
"%d.\n", port->gs.baud);
895
if (port->board->ta_type == MOD_TA) {
897
printk(KERN_INFO "sx: Unsupported baud rate: "
898
"%d.\n", port->gs.baud);
909
printk(KERN_INFO "sx: Unsupported baud rate: %d.\n",
915
sx_setsignals(port, 1, -1);
916
sx_write_channel_byte(port, hi_csr, t * 0x11);
918
sx_setsignals(port, 0, -1);
923
/* Simon Allen's version of this routine was 225 lines long. 85 is a lot
926
static int sx_set_real_termios(void *ptr)
928
struct sx_port *port = ptr;
932
if (!port->gs.port.tty)
935
/* What is this doing here? -- REW
936
Ha! figured it out. It is to allow you to get DTR active again
937
if you've dropped it with stty 0. Moved to set_baud, where it
938
belongs (next to the drop dtr if baud == 0) -- REW */
939
/* sx_setsignals (port, 1, -1); */
943
#define CFLAG port->gs.port.tty->termios->c_cflag
944
sx_write_channel_byte(port, hi_mr1,
945
(C_PARENB(port->gs.port.tty) ? MR1_WITH : MR1_NONE) |
946
(C_PARODD(port->gs.port.tty) ? MR1_ODD : MR1_EVEN) |
947
(C_CRTSCTS(port->gs.port.tty) ? MR1_RTS_RXFLOW : 0) |
948
(((CFLAG & CSIZE) == CS8) ? MR1_8_BITS : 0) |
949
(((CFLAG & CSIZE) == CS7) ? MR1_7_BITS : 0) |
950
(((CFLAG & CSIZE) == CS6) ? MR1_6_BITS : 0) |
951
(((CFLAG & CSIZE) == CS5) ? MR1_5_BITS : 0));
953
sx_write_channel_byte(port, hi_mr2,
954
(C_CRTSCTS(port->gs.port.tty) ? MR2_CTS_TXFLOW : 0) |
955
(C_CSTOPB(port->gs.port.tty) ? MR2_2_STOP :
958
switch (CFLAG & CSIZE) {
960
sx_write_channel_byte(port, hi_mask, 0xff);
963
sx_write_channel_byte(port, hi_mask, 0x7f);
966
sx_write_channel_byte(port, hi_mask, 0x3f);
969
sx_write_channel_byte(port, hi_mask, 0x1f);
972
printk(KERN_INFO "sx: Invalid wordsize: %u\n",
973
(unsigned int)CFLAG & CSIZE);
977
sx_write_channel_byte(port, hi_prtcl,
978
(I_IXON(port->gs.port.tty) ? SP_TXEN : 0) |
979
(I_IXOFF(port->gs.port.tty) ? SP_RXEN : 0) |
980
(I_IXANY(port->gs.port.tty) ? SP_TANY : 0) | SP_DCEN);
982
sx_write_channel_byte(port, hi_break,
983
(I_IGNBRK(port->gs.port.tty) ? BR_IGN : 0 |
984
I_BRKINT(port->gs.port.tty) ? BR_INT : 0));
986
sx_write_channel_byte(port, hi_txon, START_CHAR(port->gs.port.tty));
987
sx_write_channel_byte(port, hi_rxon, START_CHAR(port->gs.port.tty));
988
sx_write_channel_byte(port, hi_txoff, STOP_CHAR(port->gs.port.tty));
989
sx_write_channel_byte(port, hi_rxoff, STOP_CHAR(port->gs.port.tty));
991
sx_reconfigure_port(port);
993
/* Tell line discipline whether we will do input cooking */
994
if (I_OTHER(port->gs.port.tty)) {
995
clear_bit(TTY_HW_COOK_IN, &port->gs.port.tty->flags);
997
set_bit(TTY_HW_COOK_IN, &port->gs.port.tty->flags);
999
sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
1000
(unsigned int)port->gs.port.tty->termios->c_iflag,
1001
I_OTHER(port->gs.port.tty));
1003
/* Tell line discipline whether we will do output cooking.
1004
* If OPOST is set and no other output flags are set then we can do output
1005
* processing. Even if only *one* other flag in the O_OTHER group is set
1006
* we do cooking in software.
1008
if (O_OPOST(port->gs.port.tty) && !O_OTHER(port->gs.port.tty)) {
1009
set_bit(TTY_HW_COOK_OUT, &port->gs.port.tty->flags);
1011
clear_bit(TTY_HW_COOK_OUT, &port->gs.port.tty->flags);
1013
sx_dprintk(SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
1014
(unsigned int)port->gs.port.tty->termios->c_oflag,
1015
O_OTHER(port->gs.port.tty));
1016
/* port->c_dcd = sx_get_CD (port); */
1021
/* ********************************************************************** *
1022
* the interrupt related routines *
1023
* ********************************************************************** */
1026
Other drivers use the macro "MIN" to calculate how much to copy.
1027
This has the disadvantage that it will evaluate parts twice. That's
1028
expensive when it's IO (and the compiler cannot optimize those away!).
1029
Moreover, I'm not sure that you're race-free.
1031
I assign a value, and then only allow the value to decrease. This
1032
is always safe. This makes the code a few lines longer, and you
1033
know I'm dead against that, but I think it is required in this
1036
static void sx_transmit_chars(struct sx_port *port)
1043
sx_dprintk(SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
1044
port, port->gs.xmit_cnt);
1046
if (test_and_set_bit(SX_PORT_TRANSMIT_LOCK, &port->locks)) {
1051
c = port->gs.xmit_cnt;
1053
sx_dprintk(SX_DEBUG_TRANSMIT, "Copying %d ", c);
1054
tx_ip = sx_read_channel_byte(port, hi_txipos);
1056
/* Took me 5 minutes to deduce this formula.
1057
Luckily it is literally in the manual in section 6.5.4.3.5 */
1058
txroom = (sx_read_channel_byte(port, hi_txopos) - tx_ip - 1) &
1061
/* Don't copy more bytes than there is room for in the buffer */
1064
sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom);
1066
/* Don't copy past the end of the hardware transmit buffer */
1067
if (c > 0x100 - tx_ip)
1070
sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100 - tx_ip);
1072
/* Don't copy pas the end of the source buffer */
1073
if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
1074
c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
1076
sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%ld) \n",
1077
c, SERIAL_XMIT_SIZE - port->gs.xmit_tail);
1079
/* If for one reason or another, we can't copy more data, we're
1084
memcpy_toio(port->board->base + CHAN_OFFSET(port, hi_txbuf) +
1085
tx_ip, port->gs.xmit_buf + port->gs.xmit_tail, c);
1087
/* Update the pointer in the card */
1088
sx_write_channel_byte(port, hi_txipos, (tx_ip + c) & 0xff);
1090
/* Update the kernel buffer end */
1091
port->gs.xmit_tail = (port->gs.xmit_tail + c) &
1092
(SERIAL_XMIT_SIZE - 1);
1094
/* This one last. (this is essential)
1095
It would allow others to start putting more data into the
1097
port->gs.xmit_cnt -= c;
1100
if (port->gs.xmit_cnt == 0) {
1101
sx_disable_tx_interrupts(port);
1104
if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.port.tty) {
1105
tty_wakeup(port->gs.port.tty);
1106
sx_dprintk(SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
1107
port->gs.wakeup_chars);
1110
clear_bit(SX_PORT_TRANSMIT_LOCK, &port->locks);
1114
/* Note the symmetry between receiving chars and transmitting them!
1115
Note: The kernel should have implemented both a receive buffer and
1116
a transmit buffer. */
1118
/* Inlined: Called only once. Remove the inline when you add another call */
1119
static inline void sx_receive_chars(struct sx_port *port)
1123
struct tty_struct *tty;
1128
tty = port->gs.port.tty;
1130
rx_op = sx_read_channel_byte(port, hi_rxopos);
1131
c = (sx_read_channel_byte(port, hi_rxipos) - rx_op) & 0xff;
1133
sx_dprintk(SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
1135
/* Don't copy past the end of the hardware receive buffer */
1136
if (rx_op + c > 0x100)
1139
sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
1141
/* Don't copy more bytes than there is room for in the buffer */
1143
c = tty_prepare_flip_string(tty, &rp, c);
1145
sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
1147
/* If for one reason or another, we can't copy more data, we're done! */
1151
sx_dprintk(SX_DEBUG_RECEIVE, "Copying over %d chars. First is "
1152
"%d at %lx\n", c, read_sx_byte(port->board,
1153
CHAN_OFFSET(port, hi_rxbuf) + rx_op),
1154
CHAN_OFFSET(port, hi_rxbuf));
1155
memcpy_fromio(rp, port->board->base +
1156
CHAN_OFFSET(port, hi_rxbuf) + rx_op, c);
1158
/* This one last. ( Not essential.)
1159
It allows the card to start putting more data into the
1161
Update the pointer in the card */
1162
sx_write_channel_byte(port, hi_rxopos, (rx_op + c) & 0xff);
1169
do_gettimeofday(&tv);
1170
sx_dprintk(SX_DEBUG_RECEIVE, "pushing flipq port %d (%3d "
1171
"chars): %d.%06d (%d/%d)\n", port->line,
1172
copied, (int)(tv.tv_sec % 60), (int)tv.tv_usec,
1173
tty->raw, tty->real_raw);
1175
/* Tell the rest of the system the news. Great news. New
1177
tty_flip_buffer_push(tty);
1178
/* tty_schedule_flip (tty); */
1184
/* Inlined: it is called only once. Remove the inline if you add another
1186
static inline void sx_check_modem_signals(struct sx_port *port)
1191
hi_state = sx_read_channel_byte(port, hi_state);
1192
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
1193
port->c_dcd, tty_port_carrier_raised(&port->gs.port));
1195
if (hi_state & ST_BREAK) {
1196
hi_state &= ~ST_BREAK;
1197
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a break.\n");
1198
sx_write_channel_byte(port, hi_state, hi_state);
1199
gs_got_break(&port->gs);
1201
if (hi_state & ST_DCD) {
1202
hi_state &= ~ST_DCD;
1203
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
1204
sx_write_channel_byte(port, hi_state, hi_state);
1205
c_dcd = tty_port_carrier_raised(&port->gs.port);
1206
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
1207
if (c_dcd != port->c_dcd) {
1208
port->c_dcd = c_dcd;
1209
if (tty_port_carrier_raised(&port->gs.port)) {
1211
if ((sx_read_channel_byte(port, hi_hstat) !=
1213
!(port->gs.port.tty->termios->
1214
c_cflag & CLOCAL)) {
1215
/* Are we blocking in open? */
1216
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1217
"active, unblocking open\n");
1218
wake_up_interruptible(&port->gs.port.
1221
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1222
"raised. Ignoring.\n");
1225
/* DCD went down! */
1226
if (!(port->gs.port.tty->termios->c_cflag & CLOCAL)){
1227
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1228
"dropped. hanging up....\n");
1229
tty_hangup(port->gs.port.tty);
1231
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1232
"dropped. ignoring.\n");
1236
sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us "
1237
"DCD changed, but it didn't.\n");
1242
/* This is what an interrupt routine should look like.
1243
* Small, elegant, clear.
1246
static irqreturn_t sx_interrupt(int irq, void *ptr)
1248
struct sx_board *board = ptr;
1249
struct sx_port *port;
1253
sx_dprintk(SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq,
1256
/* AAargh! The order in which to do these things is essential and
1259
- Rate limit goes before "recursive". Otherwise a series of
1260
recursive calls will hang the machine in the interrupt routine.
1262
- hardware twiddling goes before "recursive". Otherwise when we
1263
poll the card, and a recursive interrupt happens, we won't
1264
ack the card, so it might keep on interrupting us. (especially
1265
level sensitive interrupt systems like PCI).
1267
- Rate limit goes before hardware twiddling. Otherwise we won't
1268
catch a card that has gone bonkers.
1270
- The "initialized" test goes after the hardware twiddling. Otherwise
1271
the card will stick us in the interrupt routine again.
1273
- The initialized test goes before recursive.
1276
#ifdef IRQ_RATE_LIMIT
1277
/* Aaargh! I'm ashamed. This costs more lines-of-code than the
1278
actual interrupt routine!. (Well, used to when I wrote that
1282
static int nintr = 0;
1284
if (lastjif == jiffies) {
1285
if (++nintr > IRQ_RATE_LIMIT) {
1286
free_irq(board->irq, board);
1287
printk(KERN_ERR "sx: Too many interrupts. "
1288
"Turning off interrupt %d.\n",
1298
if (board->irq == irq) {
1299
/* Tell the card we've noticed the interrupt. */
1301
sx_write_board_word(board, cc_int_pending, 0);
1302
if (IS_SX_BOARD(board)) {
1303
write_sx_byte(board, SX_RESET_IRQ, 1);
1304
} else if (IS_EISA_BOARD(board)) {
1305
inb(board->eisa_base + 0xc03);
1306
write_sx_word(board, 8, 0);
1308
write_sx_byte(board, SI2_ISA_INTCLEAR,
1309
SI2_ISA_INTCLEAR_CLEAR);
1310
write_sx_byte(board, SI2_ISA_INTCLEAR,
1311
SI2_ISA_INTCLEAR_SET);
1315
if (!sx_initialized)
1317
if (!(board->flags & SX_BOARD_INITIALIZED))
1320
if (test_and_set_bit(SX_BOARD_INTR_LOCK, &board->locks)) {
1321
printk(KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
1325
for (i = 0; i < board->nports; i++) {
1326
port = &board->ports[i];
1327
if (port->gs.port.flags & GS_ACTIVE) {
1328
if (sx_read_channel_byte(port, hi_state)) {
1329
sx_dprintk(SX_DEBUG_INTERRUPTS, "Port %d: "
1330
"modem signal change?... \n",i);
1331
sx_check_modem_signals(port);
1333
if (port->gs.xmit_cnt) {
1334
sx_transmit_chars(port);
1336
if (!(port->gs.port.flags & SX_RX_THROTTLE)) {
1337
sx_receive_chars(port);
1342
clear_bit(SX_BOARD_INTR_LOCK, &board->locks);
1344
sx_dprintk(SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq,
1350
static void sx_pollfunc(unsigned long data)
1352
struct sx_board *board = (struct sx_board *)data;
1356
sx_interrupt(0, board);
1358
mod_timer(&board->timer, jiffies + sx_poll);
1362
/* ********************************************************************** *
1363
* Here are the routines that actually *
1364
* interface with the generic_serial driver *
1365
* ********************************************************************** */
1367
/* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
1368
/* Hmm. Ok I figured it out. You don't. */
1370
static void sx_disable_tx_interrupts(void *ptr)
1372
struct sx_port *port = ptr;
1375
port->gs.port.flags &= ~GS_TX_INTEN;
1380
static void sx_enable_tx_interrupts(void *ptr)
1382
struct sx_port *port = ptr;
1386
/* First transmit the characters that we're supposed to */
1387
sx_transmit_chars(port);
1389
/* The sx card will never interrupt us if we don't fill the buffer
1390
past 25%. So we keep considering interrupts off if that's the case. */
1391
data_in_buffer = (sx_read_channel_byte(port, hi_txipos) -
1392
sx_read_channel_byte(port, hi_txopos)) & 0xff;
1394
/* XXX Must be "HIGH_WATER" for SI card according to doc. */
1395
if (data_in_buffer < LOW_WATER)
1396
port->gs.port.flags &= ~GS_TX_INTEN;
1401
static void sx_disable_rx_interrupts(void *ptr)
1403
/* struct sx_port *port = ptr; */
1409
static void sx_enable_rx_interrupts(void *ptr)
1411
/* struct sx_port *port = ptr; */
1417
/* Jeez. Isn't this simple? */
1418
static int sx_carrier_raised(struct tty_port *port)
1420
struct sx_port *sp = container_of(port, struct sx_port, gs.port);
1421
return ((sx_read_channel_byte(sp, hi_ip) & IP_DCD) != 0);
1424
/* Jeez. Isn't this simple? */
1425
static int sx_chars_in_buffer(void *ptr)
1427
struct sx_port *port = ptr;
1431
return ((sx_read_channel_byte(port, hi_txipos) -
1432
sx_read_channel_byte(port, hi_txopos)) & 0xff);
1435
static void sx_shutdown_port(void *ptr)
1437
struct sx_port *port = ptr;
1441
port->gs.port.flags &= ~GS_ACTIVE;
1442
if (port->gs.port.tty && (port->gs.port.tty->termios->c_cflag & HUPCL)) {
1443
sx_setsignals(port, 0, 0);
1444
sx_reconfigure_port(port);
1450
/* ********************************************************************** *
1451
* Here are the routines that actually *
1452
* interface with the rest of the system *
1453
* ********************************************************************** */
1455
static int sx_open(struct tty_struct *tty, struct file *filp)
1457
struct sx_port *port;
1459
unsigned long flags;
1463
if (!sx_initialized) {
1468
sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
1469
"np=%d)\n", task_pid_nr(current), line, tty,
1470
current->signal->tty, sx_nports);
1472
if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1475
port = &sx_ports[line];
1476
port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
1477
1 -> 0 transition. */
1479
sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
1481
spin_lock_irqsave(&port->gs.driver_lock, flags);
1483
tty->driver_data = port;
1484
port->gs.port.tty = tty;
1485
port->gs.port.count++;
1486
spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1488
sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
1491
* Start up serial port
1493
retval = gs_init_port(&port->gs);
1494
sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
1496
port->gs.port.count--;
1500
port->gs.port.flags |= GS_ACTIVE;
1501
if (port->gs.port.count <= 1)
1502
sx_setsignals(port, 1, 1);
1505
if (sx_debug & SX_DEBUG_OPEN)
1506
my_hd(port, sizeof(*port));
1508
if (sx_debug & SX_DEBUG_OPEN)
1509
my_hd_io(port->board->base + port->ch_base, sizeof(*port));
1512
if (port->gs.port.count <= 1) {
1513
if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1514
printk(KERN_ERR "sx: Card didn't respond to LOPEN "
1516
spin_lock_irqsave(&port->gs.driver_lock, flags);
1517
port->gs.port.count--;
1518
spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1523
retval = gs_block_til_ready(port, filp);
1524
sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
1525
retval, port->gs.port.count);
1529
* Don't lower gs.port.count here because sx_close() will be called later
1534
/* tty->low_latency = 1; */
1536
port->c_dcd = sx_carrier_raised(&port->gs.port);
1537
sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
1544
static void sx_close(void *ptr)
1546
struct sx_port *port = ptr;
1547
/* Give the port 5 seconds to close down. */
1552
sx_setsignals(port, 0, 0);
1553
sx_reconfigure_port(port);
1554
sx_send_command(port, HS_CLOSE, 0, 0);
1556
while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
1557
if (msleep_interruptible(10))
1559
if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
1560
if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
1562
printk(KERN_ERR "sx: sent the force_close command, but "
1563
"card didn't react\n");
1565
sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
1569
sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
1570
5 * HZ - to - 1, port->gs.port.count);
1572
if (port->gs.port.count) {
1573
sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n",
1574
port->gs.port.count);
1575
/*printk("%s SETTING port count to zero: %p count: %d\n",
1576
__func__, port, port->gs.port.count);
1577
port->gs.port.count = 0;*/
1583
/* This is relatively thorough. But then again it is only 20 lines. */
1584
#define MARCHUP for (i = min; i < max; i++)
1585
#define MARCHDOWN for (i = max - 1; i >= min; i--)
1586
#define W0 write_sx_byte(board, i, 0x55)
1587
#define W1 write_sx_byte(board, i, 0xaa)
1588
#define R0 if (read_sx_byte(board, i) != 0x55) return 1
1589
#define R1 if (read_sx_byte(board, i) != 0xaa) return 1
1591
/* This memtest takes a human-noticable time. You normally only do it
1592
once a boot, so I guess that it is worth it. */
1593
static int do_memtest(struct sx_board *board, int min, int max)
1597
/* This is a marchb. Theoretically, marchb catches much more than
1598
simpler tests. In practise, the longer test just catches more
1599
intermittent errors. -- REW
1600
(For the theory behind memory testing see:
1601
Testing Semiconductor Memories by A.J. van de Goor.) */
1640
#define MARCHUP for (i = min; i < max; i += 2)
1641
#define MARCHDOWN for (i = max - 1; i >= min; i -= 2)
1642
#define W0 write_sx_word(board, i, 0x55aa)
1643
#define W1 write_sx_word(board, i, 0xaa55)
1644
#define R0 if (read_sx_word(board, i) != 0x55aa) return 1
1645
#define R1 if (read_sx_word(board, i) != 0xaa55) return 1
1648
/* This memtest takes a human-noticable time. You normally only do it
1649
once a boot, so I guess that it is worth it. */
1650
static int do_memtest_w(struct sx_board *board, int min, int max)
1686
static long sx_fw_ioctl(struct file *filp, unsigned int cmd,
1690
int __user *descr = (int __user *)arg;
1692
static struct sx_board *board = NULL;
1699
if (!capable(CAP_SYS_RAWIO))
1704
sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
1708
if (board->flags & SX_BOARD_PRESENT) {
1709
sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1712
sx_dprintk(SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
1714
for (i = 0; i < SX_NBOARDS; i++)
1715
sx_dprintk(SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
1716
sx_dprintk(SX_DEBUG_FIRMWARE, "\n");
1722
case SXIO_SET_BOARD:
1723
sx_dprintk(SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
1725
if (arg >= SX_NBOARDS)
1727
sx_dprintk(SX_DEBUG_FIRMWARE, "not out of range\n");
1728
if (!(boards[arg].flags & SX_BOARD_PRESENT))
1730
sx_dprintk(SX_DEBUG_FIRMWARE, ".. and present!\n");
1731
board = &boards[arg];
1733
/* FIXME: And this does ... nothing?? */
1736
rc = -ENOENT; /* If we manage to miss one, return error. */
1737
if (IS_SX_BOARD(board))
1739
if (IS_CF_BOARD(board))
1741
if (IS_SI_BOARD(board))
1743
if (IS_SI1_BOARD(board))
1745
if (IS_EISA_BOARD(board))
1747
sx_dprintk(SX_DEBUG_FIRMWARE, "returning type= %ld\n", rc);
1749
case SXIO_DO_RAMTEST:
1750
if (sx_initialized) { /* Already initialized: better not ramtest the board. */
1754
if (IS_SX_BOARD(board)) {
1755
rc = do_memtest(board, 0, 0x7000);
1757
rc = do_memtest(board, 0, 0x7000);
1758
/*if (!rc) rc = do_memtest_w (board, 0, 0x7000); */
1760
rc = do_memtest(board, 0, 0x7ff8);
1761
/* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
1763
sx_dprintk(SX_DEBUG_FIRMWARE,
1764
"returning memtest result= %ld\n", rc);
1767
if (sx_initialized) {/* Already initialized */
1771
if (!sx_reset(board)) {
1775
sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
1777
tmp = kmalloc(SX_CHUNK_SIZE, GFP_USER);
1782
/* FIXME: check returns */
1783
get_user(nbytes, descr++);
1784
get_user(offset, descr++);
1785
get_user(data, descr++);
1786
while (nbytes && data) {
1787
for (i = 0; i < nbytes; i += SX_CHUNK_SIZE) {
1788
if (copy_from_user(tmp, (char __user *)data + i,
1789
(i + SX_CHUNK_SIZE > nbytes) ?
1790
nbytes - i : SX_CHUNK_SIZE)) {
1795
memcpy_toio(board->base2 + offset + i, tmp,
1796
(i + SX_CHUNK_SIZE > nbytes) ?
1797
nbytes - i : SX_CHUNK_SIZE);
1800
get_user(nbytes, descr++);
1801
get_user(offset, descr++);
1802
get_user(data, descr++);
1805
sx_nports += sx_init_board(board);
1809
if (sx_initialized) { /* Already initialized */
1813
/* This is not allowed until all boards are initialized... */
1814
for (i = 0; i < SX_NBOARDS; i++) {
1815
if ((boards[i].flags & SX_BOARD_PRESENT) &&
1816
!(boards[i].flags & SX_BOARD_INITIALIZED)) {
1821
for (i = 0; i < SX_NBOARDS; i++)
1822
if (!(boards[i].flags & SX_BOARD_PRESENT))
1825
sx_dprintk(SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
1826
"%d channels, first board: %d ports\n",
1827
i, sx_nports, boards[0].nports);
1828
rc = sx_init_portstructs(i, sx_nports);
1839
case SXIO_GETGSDEBUG:
1840
case SXIO_SETGSDEBUG:
1843
case SXIO_GETNPORTS:
1856
static int sx_break(struct tty_struct *tty, int flag)
1858
struct sx_port *port = tty->driver_data;
1865
rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
1867
rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
1869
printk(KERN_ERR "sx: couldn't send break (%x).\n",
1870
read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
1876
static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1878
struct sx_port *port = tty->driver_data;
1879
return sx_getsignals(port);
1882
static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1883
unsigned int set, unsigned int clear)
1885
struct sx_port *port = tty->driver_data;
1886
int rts = -1, dtr = -1;
1888
if (set & TIOCM_RTS)
1890
if (set & TIOCM_DTR)
1892
if (clear & TIOCM_RTS)
1894
if (clear & TIOCM_DTR)
1897
sx_setsignals(port, dtr, rts);
1898
sx_reconfigure_port(port);
1902
static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1903
unsigned int cmd, unsigned long arg)
1906
struct sx_port *port = tty->driver_data;
1907
void __user *argp = (void __user *)arg;
1909
/* func_enter2(); */
1915
rc = gs_getserial(&port->gs, argp);
1918
rc = gs_setserial(&port->gs, argp);
1930
/* The throttle/unthrottle scheme for the Specialix card is different
1931
* from other drivers and deserves some explanation.
1932
* The Specialix hardware takes care of XON/XOFF
1933
* and CTS/RTS flow control itself. This means that all we have to
1934
* do when signalled by the upper tty layer to throttle/unthrottle is
1935
* to make a note of it here. When we come to read characters from the
1936
* rx buffers on the card (sx_receive_chars()) we look to see if the
1937
* upper layer can accept more (as noted here in sx_rx_throt[]).
1938
* If it can't we simply don't remove chars from the cards buffer.
1939
* When the tty layer can accept chars, we again note that here and when
1940
* sx_receive_chars() is called it will remove them from the cards buffer.
1941
* The card will notice that a ports buffer has drained below some low
1942
* water mark and will unflow control the line itself, using whatever
1943
* flow control scheme is in use for that port. -- Simon Allen
1946
static void sx_throttle(struct tty_struct *tty)
1948
struct sx_port *port = tty->driver_data;
1951
/* If the port is using any type of input flow
1952
* control then throttle the port.
1954
if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
1955
port->gs.port.flags |= SX_RX_THROTTLE;
1960
static void sx_unthrottle(struct tty_struct *tty)
1962
struct sx_port *port = tty->driver_data;
1965
/* Always unthrottle even if flow control is not enabled on
1966
* this port in case we disabled flow control while the port
1969
port->gs.port.flags &= ~SX_RX_THROTTLE;
1974
/* ********************************************************************** *
1975
* Here are the initialization routines. *
1976
* ********************************************************************** */
1978
static int sx_init_board(struct sx_board *board)
1986
/* This is preceded by downloading the download code. */
1988
board->flags |= SX_BOARD_INITIALIZED;
1990
if (read_sx_byte(board, 0))
1991
/* CF boards may need this. */
1992
write_sx_byte(board, 0, 0);
1994
/* This resets the processor again, to make sure it didn't do any
1995
foolish things while we were downloading the image */
1996
if (!sx_reset(board))
1999
sx_start_board(board);
2001
if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
2002
printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
2006
/* Ok. So now the processor on the card is running. It gathered
2007
some info for us... */
2008
sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
2009
if (sx_debug & SX_DEBUG_INIT)
2010
my_hd_io(board->base, 0x10);
2011
sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
2012
if (sx_debug & SX_DEBUG_INIT)
2013
my_hd_io(board->base + 0x80, 0x30);
2015
sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
2017
read_sx_byte(board, 0), read_sx_byte(board, 1),
2018
read_sx_byte(board, 5), read_sx_byte(board, 4));
2020
if (read_sx_byte(board, 0) == 0xff) {
2021
printk(KERN_INFO "sx: No modules found. Sorry.\n");
2028
if (IS_SX_BOARD(board)) {
2029
sx_write_board_word(board, cc_int_count, sx_maxints);
2032
sx_write_board_word(board, cc_int_count,
2033
SI_PROCESSOR_CLOCK / 8 / sx_maxints);
2036
/* grab the first module type... */
2037
/* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
2038
board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
2042
for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
2043
type = sx_read_module_byte(board, addr, mc_chip);
2044
sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
2045
addr, read_sx_byte(board, addr + 2));
2047
chans += sx_read_module_byte(board, addr, mc_type);
2049
sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
2052
pan_type_s(sx_read_module_byte(board, addr,
2054
pan_type_s(sx_read_module_byte(board, addr,
2057
sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
2059
sx_read_module_byte(board, addr, mc_rev1),
2060
sx_read_module_byte(board, addr, mc_rev2),
2061
sx_read_module_byte(board, addr, mc_mtaasic_rev));
2063
/* The following combinations are illegal: It should theoretically
2064
work, but timing problems make the bus HANG. */
2066
if (mod_compat_type(type) != board->ta_type) {
2067
printk(KERN_ERR "sx: This is an invalid "
2068
"configuration.\nDon't mix TA/MTA/SXDC on the "
2069
"same hostadapter.\n");
2073
if ((IS_EISA_BOARD(board) ||
2074
IS_SI_BOARD(board)) &&
2075
(mod_compat_type(type) == 4)) {
2076
printk(KERN_ERR "sx: This is an invalid "
2077
"configuration.\nDon't use SXDCs on an SI/XIO "
2082
#if 0 /* Problem fixed: firmware 3.05 */
2083
if (IS_SX_BOARD(board) && (type == TA8)) {
2084
/* There are some issues with the firmware and the DCD/RTS
2085
lines. It might work if you tie them together or something.
2086
It might also work if you get a newer sx_firmware. Therefore
2087
this is just a warning. */
2089
"sx: The SX host doesn't work too well "
2090
"with the TA8 adapters.\nSpecialix is working on it.\n");
2096
if (board->irq > 0) {
2097
/* fixed irq, probably PCI */
2098
if (sx_irqmask & (1 << board->irq)) { /* may we use this irq? */
2099
if (request_irq(board->irq, sx_interrupt,
2100
IRQF_SHARED | IRQF_DISABLED,
2102
printk(KERN_ERR "sx: Cannot allocate "
2103
"irq %d.\n", board->irq);
2108
} else if (board->irq < 0 && sx_irqmask) {
2109
/* auto-allocate irq */
2111
int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
2112
SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
2113
for (irqnr = 15; irqnr > 0; irqnr--)
2114
if (irqmask & (1 << irqnr))
2115
if (!request_irq(irqnr, sx_interrupt,
2116
IRQF_SHARED | IRQF_DISABLED,
2120
printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2126
/* Found a valid interrupt, start up interrupts! */
2127
sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
2129
sx_start_interrupts(board);
2130
board->poll = sx_slowpoll;
2131
board->flags |= SX_IRQ_ALLOCATED;
2133
/* no irq: setup board for polled operation */
2134
board->poll = sx_poll;
2135
sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
2139
/* The timer should be initialized anyway: That way we can
2140
safely del_timer it when the module is unloaded. */
2141
setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
2144
mod_timer(&board->timer, jiffies + board->poll);
2149
board->nports = chans;
2150
sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
2156
static void __devinit printheader(void)
2158
static int header_printed;
2160
if (!header_printed) {
2161
printk(KERN_INFO "Specialix SX driver "
2162
"(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
2163
printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
2168
static int __devinit probe_sx(struct sx_board *board)
2170
struct vpd_prom vpdp;
2176
if (!IS_CF_BOARD(board)) {
2177
sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2178
board->base + SX_VPD_ROM);
2180
if (sx_debug & SX_DEBUG_PROBE)
2181
my_hd_io(board->base + SX_VPD_ROM, 0x40);
2184
for (i = 0; i < sizeof(struct vpd_prom); i++)
2185
*p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
2187
if (sx_debug & SX_DEBUG_PROBE)
2190
sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
2192
if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2193
sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
2194
"'%s'\n", vpdp.identifier);
2201
if (!IS_CF_BOARD(board)) {
2202
printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
2204
printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
2206
vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2207
printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
2209
if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
2210
SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
2211
SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2212
/* This might be a bit harsh. This was the primary
2213
reason the SX/ISA card didn't work at first... */
2214
printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
2215
"card. Sorry: giving up.\n");
2219
if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
2221
if (((unsigned long)board->hw_base) & 0x8000) {
2222
printk(KERN_WARNING "sx: Warning: There may be "
2223
"hardware problems with the card at "
2224
"%lx.\n", board->hw_base);
2225
printk(KERN_WARNING "sx: Read sx.txt for more "
2233
/* This resets the processor, and keeps it off the bus. */
2234
if (!sx_reset(board))
2236
sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2242
#if defined(CONFIG_ISA) || defined(CONFIG_EISA)
2244
/* Specialix probes for this card at 32k increments from 640k to 16M.
2245
I consider machines with less than 16M unlikely nowadays, so I'm
2246
not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2247
card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves
2248
0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2250
static int __devinit probe_si(struct sx_board *board)
2255
sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
2256
"%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
2258
if (sx_debug & SX_DEBUG_PROBE)
2259
my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2261
if (!IS_EISA_BOARD(board)) {
2262
if (IS_SI1_BOARD(board)) {
2263
for (i = 0; i < 8; i++) {
2264
write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
2267
for (i = 0; i < 8; i++) {
2268
if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
2276
/* Now we're pretty much convinced that there is an SI board here,
2277
but to prevent trouble, we'd better double check that we don't
2278
have an SI1 board when we're probing for an SI2 board.... */
2280
write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2281
if (IS_SI1_BOARD(board)) {
2282
/* This should be an SI1 board, which has this
2283
location writable... */
2284
if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2289
/* This should be an SI2 board, which has the bottom
2290
3 bits non-writable... */
2291
if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2297
/* Now we're pretty much convinced that there is an SI board here,
2298
but to prevent trouble, we'd better double check that we don't
2299
have an SI1 board when we're probing for an SI2 board.... */
2301
write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2302
if (IS_SI1_BOARD(board)) {
2303
/* This should be an SI1 board, which has this
2304
location writable... */
2305
if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2310
/* This should be an SI2 board, which has the bottom
2311
3 bits non-writable... */
2312
if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2320
printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
2321
/* Compared to the SX boards, it is a complete guess as to what
2322
this card is up to... */
2326
/* This resets the processor, and keeps it off the bus. */
2327
if (!sx_reset(board))
2329
sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2336
static const struct tty_operations sx_ops = {
2337
.break_ctl = sx_break,
2341
.put_char = gs_put_char,
2342
.flush_chars = gs_flush_chars,
2343
.write_room = gs_write_room,
2344
.chars_in_buffer = gs_chars_in_buffer,
2345
.flush_buffer = gs_flush_buffer,
2347
.throttle = sx_throttle,
2348
.unthrottle = sx_unthrottle,
2349
.set_termios = gs_set_termios,
2352
.hangup = gs_hangup,
2353
.tiocmget = sx_tiocmget,
2354
.tiocmset = sx_tiocmset,
2357
static const struct tty_port_operations sx_port_ops = {
2358
.carrier_raised = sx_carrier_raised,
2361
static int sx_init_drivers(void)
2367
sx_driver = alloc_tty_driver(sx_nports);
2370
sx_driver->owner = THIS_MODULE;
2371
sx_driver->driver_name = "specialix_sx";
2372
sx_driver->name = "ttyX";
2373
sx_driver->major = SX_NORMAL_MAJOR;
2374
sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2375
sx_driver->subtype = SERIAL_TYPE_NORMAL;
2376
sx_driver->init_termios = tty_std_termios;
2377
sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2378
sx_driver->init_termios.c_ispeed = 9600;
2379
sx_driver->init_termios.c_ospeed = 9600;
2380
sx_driver->flags = TTY_DRIVER_REAL_RAW;
2381
tty_set_operations(sx_driver, &sx_ops);
2383
if ((error = tty_register_driver(sx_driver))) {
2384
put_tty_driver(sx_driver);
2385
printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
2393
static int sx_init_portstructs(int nboards, int nports)
2395
struct sx_board *board;
2396
struct sx_port *port;
2403
/* Many drivers statically allocate the maximum number of ports
2404
There is no reason not to allocate them dynamically.
2406
sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
2411
for (i = 0; i < nboards; i++) {
2413
board->ports = port;
2414
for (j = 0; j < boards[i].nports; j++) {
2415
sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
2416
tty_port_init(&port->gs.port);
2417
port->gs.port.ops = &sx_port_ops;
2418
port->gs.magic = SX_MAGIC;
2419
port->gs.close_delay = HZ / 2;
2420
port->gs.closing_wait = 30 * HZ;
2421
port->board = board;
2422
port->gs.rd = &sx_real_driver;
2423
#ifdef NEW_WRITE_LOCKING
2424
port->gs.port_write_mutex = MUTEX;
2426
spin_lock_init(&port->gs.driver_lock);
2428
* Initializing wait queue
2436
for (i = 0; i < nboards; i++) {
2438
board->port_base = portno;
2439
/* Possibly the configuration was rejected. */
2440
sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
2442
if (board->nports <= 0)
2444
/* XXX byteorder ?? */
2445
for (addr = 0x80; addr != 0;
2446
addr = read_sx_word(board, addr) & 0x7fff) {
2447
chans = sx_read_module_byte(board, addr, mc_type);
2448
sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
2449
"channels\n", addr, chans);
2450
sx_dprintk(SX_DEBUG_PROBE, "Port at");
2451
for (j = 0; j < chans; j++) {
2452
/* The "sx-way" is the way it SHOULD be done.
2453
That way in the future, the firmware may for
2454
example pack the structures a bit more
2455
efficient. Neil tells me it isn't going to
2456
happen anytime soon though. */
2457
if (IS_SX_BOARD(board))
2458
port->ch_base = sx_read_module_word(
2459
board, addr + j * 2,
2462
port->ch_base = addr + 0x100 + 0x300 *j;
2464
sx_dprintk(SX_DEBUG_PROBE, " %x",
2466
port->line = portno++;
2469
sx_dprintk(SX_DEBUG_PROBE, "\n");
2471
/* This has to be done earlier. */
2472
/* board->flags |= SX_BOARD_INITIALIZED; */
2479
static unsigned int sx_find_free_board(void)
2483
for (i = 0; i < SX_NBOARDS; i++)
2484
if (!(boards[i].flags & SX_BOARD_PRESENT))
2490
static void __exit sx_release_drivers(void)
2493
tty_unregister_driver(sx_driver);
2494
put_tty_driver(sx_driver);
2498
static void __devexit sx_remove_card(struct sx_board *board,
2499
struct pci_dev *pdev)
2501
if (board->flags & SX_BOARD_INITIALIZED) {
2502
/* The board should stop messing with us. (actually I mean the
2505
if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2506
free_irq(board->irq, board);
2508
/* It is safe/allowed to del_timer a non-active timer */
2509
del_timer(&board->timer);
2512
iounmap(board->base2);
2513
pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
2516
iounmap(board->base);
2517
release_region(board->hw_base, board->hw_len);
2520
board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
2526
static int __devinit sx_eisa_probe(struct device *dev)
2528
struct eisa_device *edev = to_eisa_device(dev);
2529
struct sx_board *board;
2530
unsigned long eisa_slot = edev->base_addr;
2534
mutex_lock(&sx_boards_lock);
2535
i = sx_find_free_board();
2536
if (i == SX_NBOARDS) {
2537
mutex_unlock(&sx_boards_lock);
2541
board->flags |= SX_BOARD_PRESENT;
2542
mutex_unlock(&sx_boards_lock);
2544
dev_info(dev, "XIO : Signature found in EISA slot %lu, "
2545
"Product %d Rev %d (REPORT THIS TO LKLM)\n",
2547
inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
2548
inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
2550
board->eisa_base = eisa_slot;
2551
board->flags &= ~SX_BOARD_TYPE;
2552
board->flags |= SI_EISA_BOARD;
2554
board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
2555
inb(eisa_slot + 0xc00)) << 16;
2556
board->hw_len = SI2_EISA_WINDOW_LEN;
2557
if (!request_region(board->hw_base, board->hw_len, "sx")) {
2558
dev_err(dev, "can't request region\n");
2562
board->base = ioremap_nocache(board->hw_base, SI2_EISA_WINDOW_LEN);
2564
dev_err(dev, "can't remap memory\n");
2568
sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2569
sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2570
board->irq = inb(eisa_slot + 0xc02) >> 4;
2571
sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2573
if (!probe_si(board))
2576
dev_set_drvdata(dev, board);
2580
iounmap(board->base);
2582
release_region(board->hw_base, board->hw_len);
2584
board->flags &= ~SX_BOARD_PRESENT;
2589
static int __devexit sx_eisa_remove(struct device *dev)
2591
struct sx_board *board = dev_get_drvdata(dev);
2593
sx_remove_card(board, NULL);
2598
static struct eisa_device_id sx_eisa_tbl[] = {
2603
MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2605
static struct eisa_driver sx_eisadriver = {
2606
.id_table = sx_eisa_tbl,
2609
.probe = sx_eisa_probe,
2610
.remove = __devexit_p(sx_eisa_remove),
2617
/********************************************************
2618
* Setting bit 17 in the CNTRL register of the PLX 9050 *
2619
* chip forces a retry on writes while a read is pending.*
2620
* This is to prevent the card locking up on Intel Xeon *
2621
* multiprocessor systems with the NX chipset. -- NV *
2622
********************************************************/
2624
/* Newer cards are produced with this bit set from the configuration
2625
EEprom. As the bit is read/write for the CPU, we can fix it here,
2626
if we detect that it isn't set correctly. -- REW */
2628
static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
2630
unsigned int hwbase;
2631
void __iomem *rebase;
2634
#define CNTRL_REG_OFFSET 0x50
2635
#define CNTRL_REG_GOODVALUE 0x18260000
2637
pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2638
hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2639
rebase = ioremap_nocache(hwbase, 0x80);
2640
t = readl(rebase + CNTRL_REG_OFFSET);
2641
if (t != CNTRL_REG_GOODVALUE) {
2642
printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
2643
"%08x\n", t, CNTRL_REG_GOODVALUE);
2644
writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
2650
static int __devinit sx_pci_probe(struct pci_dev *pdev,
2651
const struct pci_device_id *ent)
2654
struct sx_board *board;
2655
unsigned int i, reg;
2658
mutex_lock(&sx_boards_lock);
2659
i = sx_find_free_board();
2660
if (i == SX_NBOARDS) {
2661
mutex_unlock(&sx_boards_lock);
2665
board->flags |= SX_BOARD_PRESENT;
2666
mutex_unlock(&sx_boards_lock);
2668
retval = pci_enable_device(pdev);
2672
board->flags &= ~SX_BOARD_TYPE;
2673
board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
2676
/* CF boards use base address 3.... */
2677
reg = IS_CF_BOARD(board) ? 3 : 2;
2678
retval = pci_request_region(pdev, reg, "sx");
2680
dev_err(&pdev->dev, "can't request region\n");
2683
board->hw_base = pci_resource_start(pdev, reg);
2685
board->base = ioremap_nocache(board->hw_base, WINDOW_LEN(board));
2687
dev_err(&pdev->dev, "ioremap failed\n");
2691
/* Most of the stuff on the CF board is offset by 0x18000 .... */
2692
if (IS_CF_BOARD(board))
2693
board->base += 0x18000;
2695
board->irq = pdev->irq;
2697
dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
2698
board->irq, board->flags);
2700
if (!probe_sx(board)) {
2705
fix_sx_pci(pdev, board);
2707
pci_set_drvdata(pdev, board);
2711
iounmap(board->base2);
2713
pci_release_region(pdev, reg);
2715
board->flags &= ~SX_BOARD_PRESENT;
2723
static void __devexit sx_pci_remove(struct pci_dev *pdev)
2725
struct sx_board *board = pci_get_drvdata(pdev);
2727
sx_remove_card(board, pdev);
2730
/* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
2731
its because the standard requires it. So check for SUBVENDOR_ID. */
2732
static struct pci_device_id sx_pci_tbl[] = {
2733
{ PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2734
.subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
2735
{ PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2736
.subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
2740
MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2742
static struct pci_driver sx_pcidriver = {
2744
.id_table = sx_pci_tbl,
2745
.probe = sx_pci_probe,
2746
.remove = __devexit_p(sx_pci_remove)
2749
static int __init sx_init(void)
2755
struct sx_board *board;
2758
unsigned int found = 0;
2762
sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
2764
if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
2765
printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
2766
"value. Assuming -1.\n(%p)\n", &sx_debug);
2770
if (misc_register(&sx_fw_device) < 0) {
2771
printk(KERN_ERR "SX: Unable to register firmware loader "
2776
for (i = 0; i < NR_SX_ADDRS; i++) {
2777
board = &boards[found];
2778
board->hw_base = sx_probe_addrs[i];
2779
board->hw_len = SX_WINDOW_LEN;
2780
if (!request_region(board->hw_base, board->hw_len, "sx"))
2783
board->base = ioremap_nocache(board->hw_base, board->hw_len);
2786
board->flags &= ~SX_BOARD_TYPE;
2787
board->flags |= SX_ISA_BOARD;
2788
board->irq = sx_irqmask ? -1 : 0;
2790
if (probe_sx(board)) {
2791
board->flags |= SX_BOARD_PRESENT;
2794
iounmap(board->base);
2796
release_region(board->hw_base, board->hw_len);
2800
for (i = 0; i < NR_SI_ADDRS; i++) {
2801
board = &boards[found];
2802
board->hw_base = si_probe_addrs[i];
2803
board->hw_len = SI2_ISA_WINDOW_LEN;
2804
if (!request_region(board->hw_base, board->hw_len, "sx"))
2807
board->base = ioremap_nocache(board->hw_base, board->hw_len);
2810
board->flags &= ~SX_BOARD_TYPE;
2811
board->flags |= SI_ISA_BOARD;
2812
board->irq = sx_irqmask ? -1 : 0;
2814
if (probe_si(board)) {
2815
board->flags |= SX_BOARD_PRESENT;
2818
iounmap(board->base);
2820
release_region(board->hw_base, board->hw_len);
2823
for (i = 0; i < NR_SI1_ADDRS; i++) {
2824
board = &boards[found];
2825
board->hw_base = si1_probe_addrs[i];
2826
board->hw_len = SI1_ISA_WINDOW_LEN;
2827
if (!request_region(board->hw_base, board->hw_len, "sx"))
2830
board->base = ioremap_nocache(board->hw_base, board->hw_len);
2833
board->flags &= ~SX_BOARD_TYPE;
2834
board->flags |= SI1_ISA_BOARD;
2835
board->irq = sx_irqmask ? -1 : 0;
2837
if (probe_si(board)) {
2838
board->flags |= SX_BOARD_PRESENT;
2841
iounmap(board->base);
2843
release_region(board->hw_base, board->hw_len);
2848
retval1 = eisa_driver_register(&sx_eisadriver);
2850
retval = pci_register_driver(&sx_pcidriver);
2853
printk(KERN_INFO "sx: total of %d boards detected.\n", found);
2855
} else if (retval) {
2860
misc_deregister(&sx_fw_device);
2867
static void __exit sx_exit(void)
2873
eisa_driver_unregister(&sx_eisadriver);
2875
pci_unregister_driver(&sx_pcidriver);
2877
for (i = 0; i < SX_NBOARDS; i++)
2878
sx_remove_card(&boards[i], NULL);
2880
if (misc_deregister(&sx_fw_device) < 0) {
2881
printk(KERN_INFO "sx: couldn't deregister firmware loader "
2884
sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
2887
sx_release_drivers();
2893
module_init(sx_init);
2894
module_exit(sx_exit);
added
removed
drivers/char/sx.c
