OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [sx.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
 
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:
35
 * 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
 
201
#define SX_VERSION      1.33
202
 
203
#include <linux/module.h>
204
#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>
217
#include <linux/eisa.h>
218
#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
 
241
/* I don't think that this driver can handle more than 256 ports on
242
   one machine. You'll have to increase the number of boards in sx.h
243
   if you want more than 4 boards.  */
244
 
245
#ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
246
#define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
247
#endif
248
 
249
/* Configurable options:
250
   (Don't be too sure that it'll work if you toggle them) */
251
 
252
/* Am I paranoid or not ? ;-) */
253
#undef SX_PARANOIA_CHECK
254
 
255
/* 20 -> 2000 per second. The card should rate-limit interrupts at 100
256
   Hz, but it is user configurable. I don't recommend going above 1000
257
   Hz. The interrupt ratelimit might trigger if the interrupt is
258
   shared with a very active other device. */
259
#define IRQ_RATE_LIMIT 20
260
 
261
/* Sharing interrupts is possible now. If the other device wants more
262
   than 2000 interrupts per second, we'd gracefully decline further
263
   interrupts. That's not what we want. On the other hand, if the
264
   other device interrupts 2000 times a second, don't use the SX
265
   interrupt. Use polling. */
266
#undef IRQ_RATE_LIMIT
267
 
268
#if 0
269
/* Not implemented */
270
/*
271
 * The following defines are mostly for testing purposes. But if you need
272
 * some nice reporting in your syslog, you can define them also.
273
 */
274
#define SX_REPORT_FIFO
275
#define SX_REPORT_OVERRUN
276
#endif
277
 
278
/* Function prototypes */
279
static void sx_disable_tx_interrupts(void *ptr);
280
static void sx_enable_tx_interrupts(void *ptr);
281
static void sx_disable_rx_interrupts(void *ptr);
282
static void sx_enable_rx_interrupts(void *ptr);
283
static int sx_get_CD(void *ptr);
284
static void sx_shutdown_port(void *ptr);
285
static int sx_set_real_termios(void *ptr);
286
static void sx_close(void *ptr);
287
static int sx_chars_in_buffer(void *ptr);
288
static int sx_init_board(struct sx_board *board);
289
static int sx_init_portstructs(int nboards, int nports);
290
static int sx_fw_ioctl(struct inode *inode, struct file *filp,
291
                unsigned int cmd, unsigned long arg);
292
static int sx_init_drivers(void);
293
 
294
static struct tty_driver *sx_driver;
295
 
296
static DEFINE_MUTEX(sx_boards_lock);
297
static struct sx_board boards[SX_NBOARDS];
298
static struct sx_port *sx_ports;
299
static int sx_initialized;
300
static int sx_nports;
301
static int sx_debug;
302
 
303
/* You can have the driver poll your card.
304
    - Set sx_poll to 1 to poll every timer tick (10ms on Intel).
305
      This is used when the card cannot use an interrupt for some reason.
306
 
307
    - set sx_slowpoll to 100 to do an extra poll once a second (on Intel). If
308
      the driver misses an interrupt (report this if it DOES happen to you!)
309
      everything will continue to work....
310
 */
311
static int sx_poll = 1;
312
static int sx_slowpoll;
313
 
314
/* The card limits the number of interrupts per second.
315
   At 115k2 "100" should be sufficient.
316
   If you're using higher baudrates, you can increase this...
317
 */
318
 
319
static int sx_maxints = 100;
320
 
321
#ifdef CONFIG_ISA
322
 
323
/* These are the only open spaces in my computer. Yours may have more
324
   or less.... -- REW
325
   duh: Card at 0xa0000 is possible on HP Netserver?? -- pvdl
326
*/
327
static int sx_probe_addrs[] = {
328
        0xc0000, 0xd0000, 0xe0000,
329
        0xc8000, 0xd8000, 0xe8000
330
};
331
static int si_probe_addrs[] = {
332
        0xc0000, 0xd0000, 0xe0000,
333
        0xc8000, 0xd8000, 0xe8000, 0xa0000
334
};
335
static int si1_probe_addrs[] = {
336
        0xd0000
337
};
338
 
339
#define NR_SX_ADDRS ARRAY_SIZE(sx_probe_addrs)
340
#define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
341
#define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
342
 
343
module_param_array(sx_probe_addrs, int, NULL, 0);
344
module_param_array(si_probe_addrs, int, NULL, 0);
345
#endif
346
 
347
/* Set the mask to all-ones. This alas, only supports 32 interrupts.
348
   Some architectures may need more. */
349
static int sx_irqmask = -1;
350
 
351
module_param(sx_poll, int, 0);
352
module_param(sx_slowpoll, int, 0);
353
module_param(sx_maxints, int, 0);
354
module_param(sx_debug, int, 0);
355
module_param(sx_irqmask, int, 0);
356
 
357
MODULE_LICENSE("GPL");
358
 
359
static struct real_driver sx_real_driver = {
360
        sx_disable_tx_interrupts,
361
        sx_enable_tx_interrupts,
362
        sx_disable_rx_interrupts,
363
        sx_enable_rx_interrupts,
364
        sx_get_CD,
365
        sx_shutdown_port,
366
        sx_set_real_termios,
367
        sx_chars_in_buffer,
368
        sx_close,
369
};
370
 
371
/*
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
 
381
#ifdef DEBUG
382
#define sx_dprintk(f, str...)   if (sx_debug & f) printk (str)
383
#else
384
#define sx_dprintk(f, str...)   /* nothing */
385
#endif
386
 
387
#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__)
389
 
390
#define func_enter2()   sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
391
                                __FUNCTION__, port->line)
392
 
393
/*
394
 *  Firmware loader driver specific routines
395
 *
396
 */
397
 
398
static const struct file_operations sx_fw_fops = {
399
        .owner = THIS_MODULE,
400
        .ioctl = sx_fw_ioctl,
401
};
402
 
403
static struct miscdevice sx_fw_device = {
404
        SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
405
};
406
 
407
#ifdef SX_PARANOIA_CHECK
408
 
409
/* This doesn't work. Who's paranoid around here? Not me! */
410
 
411
static inline int sx_paranoia_check(struct sx_port const *port,
412
                                    char *name, const char *routine)
413
{
414
        static const char *badmagic = KERN_ERR "sx: Warning: bad sx port magic "
415
                        "number for device %s in %s\n";
416
        static const char *badinfo = KERN_ERR "sx: Warning: null sx port for "
417
                        "device %s in %s\n";
418
 
419
        if (!port) {
420
                printk(badinfo, name, routine);
421
                return 1;
422
        }
423
        if (port->magic != SX_MAGIC) {
424
                printk(badmagic, name, routine);
425
                return 1;
426
        }
427
 
428
        return 0;
429
}
430
#else
431
#define sx_paranoia_check(a,b,c) 0
432
#endif
433
 
434
/* The timeouts. First try 30 times as fast as possible. Then give
435
   the card some time to breathe between accesses. (Otherwise the
436
   processor on the card might not be able to access its OWN bus... */
437
 
438
#define TIMEOUT_1 30
439
#define TIMEOUT_2 1000000
440
 
441
#ifdef DEBUG
442
static void my_hd_io(void __iomem *p, int len)
443
{
444
        int i, j, ch;
445
        unsigned char __iomem *addr = p;
446
 
447
        for (i = 0; i < len; i += 16) {
448
                printk("%p ", addr + i);
449
                for (j = 0; j < 16; j++) {
450
                        printk("%02x %s", readb(addr + j + i),
451
                                        (j == 7) ? " " : "");
452
                }
453
                for (j = 0; j < 16; j++) {
454
                        ch = readb(addr + j + i);
455
                        printk("%c", (ch < 0x20) ? '.' :
456
                                        ((ch > 0x7f) ? '.' : ch));
457
                }
458
                printk("\n");
459
        }
460
}
461
static void my_hd(void *p, int len)
462
{
463
        int i, j, ch;
464
        unsigned char *addr = p;
465
 
466
        for (i = 0; i < len; i += 16) {
467
                printk("%p ", addr + i);
468
                for (j = 0; j < 16; j++) {
469
                        printk("%02x %s", addr[j + i], (j == 7) ? " " : "");
470
                }
471
                for (j = 0; j < 16; j++) {
472
                        ch = addr[j + i];
473
                        printk("%c", (ch < 0x20) ? '.' :
474
                                        ((ch > 0x7f) ? '.' : ch));
475
                }
476
                printk("\n");
477
        }
478
}
479
#endif
480
 
481
/* This needs redoing for Alpha -- REW -- Done. */
482
 
483
static inline void write_sx_byte(struct sx_board *board, int offset, u8 byte)
484
{
485
        writeb(byte, board->base + offset);
486
}
487
 
488
static inline u8 read_sx_byte(struct sx_board *board, int offset)
489
{
490
        return readb(board->base + offset);
491
}
492
 
493
static inline void write_sx_word(struct sx_board *board, int offset, u16 word)
494
{
495
        writew(word, board->base + offset);
496
}
497
 
498
static inline u16 read_sx_word(struct sx_board *board, int offset)
499
{
500
        return readw(board->base + offset);
501
}
502
 
503
static int sx_busy_wait_eq(struct sx_board *board,
504
                int offset, int mask, int correctval)
505
{
506
        int i;
507
 
508
        func_enter();
509
 
510
        for (i = 0; i < TIMEOUT_1; i++)
511
                if ((read_sx_byte(board, offset) & mask) == correctval) {
512
                        func_exit();
513
                        return 1;
514
                }
515
 
516
        for (i = 0; i < TIMEOUT_2; i++) {
517
                if ((read_sx_byte(board, offset) & mask) == correctval) {
518
                        func_exit();
519
                        return 1;
520
                }
521
                udelay(1);
522
        }
523
 
524
        func_exit();
525
        return 0;
526
}
527
 
528
static int sx_busy_wait_neq(struct sx_board *board,
529
                int offset, int mask, int badval)
530
{
531
        int i;
532
 
533
        func_enter();
534
 
535
        for (i = 0; i < TIMEOUT_1; i++)
536
                if ((read_sx_byte(board, offset) & mask) != badval) {
537
                        func_exit();
538
                        return 1;
539
                }
540
 
541
        for (i = 0; i < TIMEOUT_2; i++) {
542
                if ((read_sx_byte(board, offset) & mask) != badval) {
543
                        func_exit();
544
                        return 1;
545
                }
546
                udelay(1);
547
        }
548
 
549
        func_exit();
550
        return 0;
551
}
552
 
553
/* 5.6.4 of 6210028 r2.3 */
554
static int sx_reset(struct sx_board *board)
555
{
556
        func_enter();
557
 
558
        if (IS_SX_BOARD(board)) {
559
 
560
                write_sx_byte(board, SX_CONFIG, 0);
561
                write_sx_byte(board, SX_RESET, 1); /* Value doesn't matter */
562
 
563
                if (!sx_busy_wait_eq(board, SX_RESET_STATUS, 1, 0)) {
564
                        printk(KERN_INFO "sx: Card doesn't respond to "
565
                                        "reset...\n");
566
                        return 0;
567
                }
568
        } else if (IS_EISA_BOARD(board)) {
569
                outb(board->irq << 4, board->eisa_base + 0xc02);
570
        } else if (IS_SI1_BOARD(board)) {
571
                write_sx_byte(board, SI1_ISA_RESET, 0);  /*value doesn't matter*/
572
        } else {
573
                /* Gory details of the SI/ISA board */
574
                write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
575
                write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
576
                write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
577
                write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
578
                write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
579
                write_sx_byte(board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
580
        }
581
 
582
        func_exit();
583
        return 1;
584
}
585
 
586
/* This doesn't work on machines where "NULL" isn't 0 */
587
/* If you have one of those, someone will need to write
588
   the equivalent of this, which will amount to about 3 lines. I don't
589
   want to complicate this right now. -- REW
590
   (See, I do write comments every now and then :-) */
591
#define OFFSETOF(strct, elem)   ((long)&(((struct strct *)NULL)->elem))
592
 
593
#define CHAN_OFFSET(port,elem)  (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
594
#define MODU_OFFSET(board,addr,elem)    (addr + OFFSETOF (_SXMODULE, elem))
595
#define  BRD_OFFSET(board,elem) (OFFSETOF (_SXCARD, elem))
596
 
597
#define sx_write_channel_byte(port, elem, val) \
598
        write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
599
 
600
#define sx_read_channel_byte(port, elem) \
601
        read_sx_byte (port->board, CHAN_OFFSET (port, elem))
602
 
603
#define sx_write_channel_word(port, elem, val) \
604
        write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
605
 
606
#define sx_read_channel_word(port, elem) \
607
        read_sx_word (port->board, CHAN_OFFSET (port, elem))
608
 
609
#define sx_write_module_byte(board, addr, elem, val) \
610
        write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
611
 
612
#define sx_read_module_byte(board, addr, elem) \
613
        read_sx_byte (board, MODU_OFFSET (board, addr, elem))
614
 
615
#define sx_write_module_word(board, addr, elem, val) \
616
        write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
617
 
618
#define sx_read_module_word(board, addr, elem) \
619
        read_sx_word (board, MODU_OFFSET (board, addr, elem))
620
 
621
#define sx_write_board_byte(board, elem, val) \
622
        write_sx_byte (board, BRD_OFFSET (board, elem), val)
623
 
624
#define sx_read_board_byte(board, elem) \
625
        read_sx_byte (board, BRD_OFFSET (board, elem))
626
 
627
#define sx_write_board_word(board, elem, val) \
628
        write_sx_word (board, BRD_OFFSET (board, elem), val)
629
 
630
#define sx_read_board_word(board, elem) \
631
        read_sx_word (board, BRD_OFFSET (board, elem))
632
 
633
static int sx_start_board(struct sx_board *board)
634
{
635
        if (IS_SX_BOARD(board)) {
636
                write_sx_byte(board, SX_CONFIG, SX_CONF_BUSEN);
637
        } else if (IS_EISA_BOARD(board)) {
638
                write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
639
                outb((board->irq << 4) | 4, board->eisa_base + 0xc02);
640
        } else if (IS_SI1_BOARD(board)) {
641
                write_sx_byte(board, SI1_ISA_RESET_CLEAR, 0);
642
                write_sx_byte(board, SI1_ISA_INTCL, 0);
643
        } else {
644
                /* Don't bug me about the clear_set.
645
                   I haven't the foggiest idea what it's about -- REW */
646
                write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
647
                write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
648
        }
649
        return 1;
650
}
651
 
652
#define SX_IRQ_REG_VAL(board) \
653
        ((board->flags & SX_ISA_BOARD) ? (board->irq << 4) : 0)
654
 
655
/* Note. The SX register is write-only. Therefore, we have to enable the
656
   bus too. This is a no-op, if you don't mess with this driver... */
657
static int sx_start_interrupts(struct sx_board *board)
658
{
659
 
660
        /* Don't call this with board->irq == 0 */
661
 
662
        if (IS_SX_BOARD(board)) {
663
                write_sx_byte(board, SX_CONFIG, SX_IRQ_REG_VAL(board) |
664
                                SX_CONF_BUSEN | SX_CONF_HOSTIRQ);
665
        } else if (IS_EISA_BOARD(board)) {
666
                inb(board->eisa_base + 0xc03);
667
        } else if (IS_SI1_BOARD(board)) {
668
                write_sx_byte(board, SI1_ISA_INTCL, 0);
669
                write_sx_byte(board, SI1_ISA_INTCL_CLEAR, 0);
670
        } else {
671
                switch (board->irq) {
672
                case 11:
673
                        write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);
674
                        break;
675
                case 12:
676
                        write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);
677
                        break;
678
                case 15:
679
                        write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);
680
                        break;
681
                default:
682
                        printk(KERN_INFO "sx: SI/XIO card doesn't support "
683
                                        "interrupt %d.\n", board->irq);
684
                        return 0;
685
                }
686
                write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
687
        }
688
 
689
        return 1;
690
}
691
 
692
static int sx_send_command(struct sx_port *port,
693
                int command, int mask, int newstat)
694
{
695
        func_enter2();
696
        write_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat), command);
697
        func_exit();
698
        return sx_busy_wait_eq(port->board, CHAN_OFFSET(port, hi_hstat), mask,
699
                        newstat);
700
}
701
 
702
static char *mod_type_s(int module_type)
703
{
704
        switch (module_type) {
705
        case TA4:
706
                return "TA4";
707
        case TA8:
708
                return "TA8";
709
        case TA4_ASIC:
710
                return "TA4_ASIC";
711
        case TA8_ASIC:
712
                return "TA8_ASIC";
713
        case MTA_CD1400:
714
                return "MTA_CD1400";
715
        case SXDC:
716
                return "SXDC";
717
        default:
718
                return "Unknown/invalid";
719
        }
720
}
721
 
722
static char *pan_type_s(int pan_type)
723
{
724
        switch (pan_type) {
725
        case MOD_RS232DB25:
726
                return "MOD_RS232DB25";
727
        case MOD_RS232RJ45:
728
                return "MOD_RS232RJ45";
729
        case MOD_RS422DB25:
730
                return "MOD_RS422DB25";
731
        case MOD_PARALLEL:
732
                return "MOD_PARALLEL";
733
        case MOD_2_RS232DB25:
734
                return "MOD_2_RS232DB25";
735
        case MOD_2_RS232RJ45:
736
                return "MOD_2_RS232RJ45";
737
        case MOD_2_RS422DB25:
738
                return "MOD_2_RS422DB25";
739
        case MOD_RS232DB25MALE:
740
                return "MOD_RS232DB25MALE";
741
        case MOD_2_PARALLEL:
742
                return "MOD_2_PARALLEL";
743
        case MOD_BLANK:
744
                return "empty";
745
        default:
746
                return "invalid";
747
        }
748
}
749
 
750
static int mod_compat_type(int module_type)
751
{
752
        return module_type >> 4;
753
}
754
 
755
static void sx_reconfigure_port(struct sx_port *port)
756
{
757
        if (sx_read_channel_byte(port, hi_hstat) == HS_IDLE_OPEN) {
758
                if (sx_send_command(port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
759
                        printk(KERN_WARNING "sx: Sent reconfigure command, but "
760
                                        "card didn't react.\n");
761
                }
762
        } else {
763
                sx_dprintk(SX_DEBUG_TERMIOS, "sx: Not sending reconfigure: "
764
                                "port isn't open (%02x).\n",
765
                                sx_read_channel_byte(port, hi_hstat));
766
        }
767
}
768
 
769
static void sx_setsignals(struct sx_port *port, int dtr, int rts)
770
{
771
        int t;
772
        func_enter2();
773
 
774
        t = sx_read_channel_byte(port, hi_op);
775
        if (dtr >= 0)
776
                t = dtr ? (t | OP_DTR) : (t & ~OP_DTR);
777
        if (rts >= 0)
778
                t = rts ? (t | OP_RTS) : (t & ~OP_RTS);
779
        sx_write_channel_byte(port, hi_op, t);
780
        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
781
 
782
        func_exit();
783
}
784
 
785
static int sx_getsignals(struct sx_port *port)
786
{
787
        int i_stat, o_stat;
788
 
789
        o_stat = sx_read_channel_byte(port, hi_op);
790
        i_stat = sx_read_channel_byte(port, hi_ip);
791
 
792
        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d  (%d/%d) "
793
                        "%02x/%02x\n",
794
                        (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
795
                        port->c_dcd, sx_get_CD(port),
796
                        sx_read_channel_byte(port, hi_ip),
797
                        sx_read_channel_byte(port, hi_state));
798
 
799
        return (((o_stat & OP_DTR) ? TIOCM_DTR : 0) |
800
                ((o_stat & OP_RTS) ? TIOCM_RTS : 0) |
801
                ((i_stat & IP_CTS) ? TIOCM_CTS : 0) |
802
                ((i_stat & IP_DCD) ? TIOCM_CAR : 0) |
803
                ((i_stat & IP_DSR) ? TIOCM_DSR : 0) |
804
                ((i_stat & IP_RI) ? TIOCM_RNG : 0));
805
}
806
 
807
static void sx_set_baud(struct sx_port *port)
808
{
809
        int t;
810
 
811
        if (port->board->ta_type == MOD_SXDC) {
812
                switch (port->gs.baud) {
813
                        /* Save some typing work... */
814
#define e(x) case x: t = BAUD_ ## x; break
815
                        e(50);
816
                        e(75);
817
                        e(110);
818
                        e(150);
819
                        e(200);
820
                        e(300);
821
                        e(600);
822
                        e(1200);
823
                        e(1800);
824
                        e(2000);
825
                        e(2400);
826
                        e(4800);
827
                        e(7200);
828
                        e(9600);
829
                        e(14400);
830
                        e(19200);
831
                        e(28800);
832
                        e(38400);
833
                        e(56000);
834
                        e(57600);
835
                        e(64000);
836
                        e(76800);
837
                        e(115200);
838
                        e(128000);
839
                        e(150000);
840
                        e(230400);
841
                        e(256000);
842
                        e(460800);
843
                        e(921600);
844
                case 134:
845
                        t = BAUD_134_5;
846
                        break;
847
                case 0:
848
                        t = -1;
849
                        break;
850
                default:
851
                        /* Can I return "invalid"? */
852
                        t = BAUD_9600;
853
                        printk(KERN_INFO "sx: unsupported baud rate: %d.\n",
854
                                        port->gs.baud);
855
                        break;
856
                }
857
#undef e
858
                if (t > 0) {
859
/* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
860
                        sx_setsignals(port, 1, -1);
861
                        /* XXX This is not TA & MTA compatible */
862
                        sx_write_channel_byte(port, hi_csr, 0xff);
863
 
864
                        sx_write_channel_byte(port, hi_txbaud, t);
865
                        sx_write_channel_byte(port, hi_rxbaud, t);
866
                } else {
867
                        sx_setsignals(port, 0, -1);
868
                }
869
        } else {
870
                switch (port->gs.baud) {
871
#define e(x) case x: t = CSR_ ## x; break
872
                        e(75);
873
                        e(150);
874
                        e(300);
875
                        e(600);
876
                        e(1200);
877
                        e(2400);
878
                        e(4800);
879
                        e(1800);
880
                        e(9600);
881
                        e(19200);
882
                        e(57600);
883
                        e(38400);
884
/* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
885
                case 110:
886
                        if (port->board->ta_type == MOD_TA) {
887
                                t = CSR_110;
888
                                break;
889
                        } else {
890
                                t = CSR_9600;
891
                                printk(KERN_INFO "sx: Unsupported baud rate: "
892
                                                "%d.\n", port->gs.baud);
893
                                break;
894
                        }
895
                case 115200:
896
                        if (port->board->ta_type == MOD_TA) {
897
                                t = CSR_9600;
898
                                printk(KERN_INFO "sx: Unsupported baud rate: "
899
                                                "%d.\n", port->gs.baud);
900
                                break;
901
                        } else {
902
                                t = CSR_110;
903
                                break;
904
                        }
905
                case 0:
906
                        t = -1;
907
                        break;
908
                default:
909
                        t = CSR_9600;
910
                        printk(KERN_INFO "sx: Unsupported baud rate: %d.\n",
911
                                        port->gs.baud);
912
                        break;
913
                }
914
#undef e
915
                if (t >= 0) {
916
                        sx_setsignals(port, 1, -1);
917
                        sx_write_channel_byte(port, hi_csr, t * 0x11);
918
                } else {
919
                        sx_setsignals(port, 0, -1);
920
                }
921
        }
922
}
923
 
924
/* Simon Allen's version of this routine was 225 lines long. 85 is a lot
925
   better. -- REW */
926
 
927
static int sx_set_real_termios(void *ptr)
928
{
929
        struct sx_port *port = ptr;
930
 
931
        func_enter2();
932
 
933
        if (!port->gs.tty)
934
                return 0;
935
 
936
        /* What is this doing here? -- REW
937
           Ha! figured it out. It is to allow you to get DTR active again
938
           if you've dropped it with stty 0. Moved to set_baud, where it
939
           belongs (next to the drop dtr if baud == 0) -- REW */
940
        /* sx_setsignals (port, 1, -1); */
941
 
942
        sx_set_baud(port);
943
 
944
#define CFLAG port->gs.tty->termios->c_cflag
945
        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));
953
 
954
        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));
958
 
959
        switch (CFLAG & CSIZE) {
960
        case CS8:
961
                sx_write_channel_byte(port, hi_mask, 0xff);
962
                break;
963
        case CS7:
964
                sx_write_channel_byte(port, hi_mask, 0x7f);
965
                break;
966
        case CS6:
967
                sx_write_channel_byte(port, hi_mask, 0x3f);
968
                break;
969
        case CS5:
970
                sx_write_channel_byte(port, hi_mask, 0x1f);
971
                break;
972
        default:
973
                printk(KERN_INFO "sx: Invalid wordsize: %u\n", CFLAG & CSIZE);
974
                break;
975
        }
976
 
977
        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);
981
 
982
        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));
985
 
986
        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));
990
 
991
        sx_reconfigure_port(port);
992
 
993
        /* Tell line discipline whether we will do input cooking */
994
        if (I_OTHER(port->gs.tty)) {
995
                clear_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
996
        } else {
997
                set_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
998
        }
999
        sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
1000
                        port->gs.tty->termios->c_iflag, I_OTHER(port->gs.tty));
1001
 
1002
/* Tell line discipline whether we will do output cooking.
1003
 * If OPOST is set and no other output flags are set then we can do output
1004
 * processing.  Even if only *one* other flag in the O_OTHER group is set
1005
 * we do cooking in software.
1006
 */
1007
        if (O_OPOST(port->gs.tty) && !O_OTHER(port->gs.tty)) {
1008
                set_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
1009
        } else {
1010
                clear_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
1011
        }
1012
        sx_dprintk(SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
1013
                        port->gs.tty->termios->c_oflag, O_OTHER(port->gs.tty));
1014
        /* port->c_dcd = sx_get_CD (port); */
1015
        func_exit();
1016
        return 0;
1017
}
1018
 
1019
/* ********************************************************************** *
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
 
1034
static void sx_transmit_chars(struct sx_port *port)
1035
{
1036
        int c;
1037
        int tx_ip;
1038
        int txroom;
1039
 
1040
        func_enter2();
1041
        sx_dprintk(SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
1042
                        port, port->gs.xmit_cnt);
1043
 
1044
        if (test_and_set_bit(SX_PORT_TRANSMIT_LOCK, &port->locks)) {
1045
                return;
1046
        }
1047
 
1048
        while (1) {
1049
                c = port->gs.xmit_cnt;
1050
 
1051
                sx_dprintk(SX_DEBUG_TRANSMIT, "Copying %d ", c);
1052
                tx_ip = sx_read_channel_byte(port, hi_txipos);
1053
 
1054
                /* Took me 5 minutes to deduce this formula.
1055
                   Luckily it is literally in the manual in section 6.5.4.3.5 */
1056
                txroom = (sx_read_channel_byte(port, hi_txopos) - tx_ip - 1) &
1057
                                0xff;
1058
 
1059
                /* Don't copy more bytes than there is room for in the buffer */
1060
                if (c > txroom)
1061
                        c = txroom;
1062
                sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom);
1063
 
1064
                /* Don't copy past the end of the hardware transmit buffer */
1065
                if (c > 0x100 - tx_ip)
1066
                        c = 0x100 - tx_ip;
1067
 
1068
                sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100 - tx_ip);
1069
 
1070
                /* Don't copy pas the end of the source buffer */
1071
                if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
1072
                        c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
1073
 
1074
                sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%ld) \n",
1075
                                c, SERIAL_XMIT_SIZE - port->gs.xmit_tail);
1076
 
1077
                /* If for one reason or another, we can't copy more data, we're
1078
                   done! */
1079
                if (c == 0)
1080
                        break;
1081
 
1082
                memcpy_toio(port->board->base + CHAN_OFFSET(port, hi_txbuf) +
1083
                        tx_ip, port->gs.xmit_buf + port->gs.xmit_tail, c);
1084
 
1085
                /* Update the pointer in the card */
1086
                sx_write_channel_byte(port, hi_txipos, (tx_ip + c) & 0xff);
1087
 
1088
                /* Update the kernel buffer end */
1089
                port->gs.xmit_tail = (port->gs.xmit_tail + c) &
1090
                                (SERIAL_XMIT_SIZE - 1);
1091
 
1092
                /* This one last. (this is essential)
1093
                   It would allow others to start putting more data into the
1094
                   buffer! */
1095
                port->gs.xmit_cnt -= c;
1096
        }
1097
 
1098
        if (port->gs.xmit_cnt == 0) {
1099
                sx_disable_tx_interrupts(port);
1100
        }
1101
 
1102
        if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.tty) {
1103
                tty_wakeup(port->gs.tty);
1104
                sx_dprintk(SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
1105
                                port->gs.wakeup_chars);
1106
        }
1107
 
1108
        clear_bit(SX_PORT_TRANSMIT_LOCK, &port->locks);
1109
        func_exit();
1110
}
1111
 
1112
/* 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 */
1117
static inline void sx_receive_chars(struct sx_port *port)
1118
{
1119
        int c;
1120
        int rx_op;
1121
        struct tty_struct *tty;
1122
        int copied = 0;
1123
        unsigned char *rp;
1124
 
1125
        func_enter2();
1126
        tty = port->gs.tty;
1127
        while (1) {
1128
                rx_op = sx_read_channel_byte(port, hi_rxopos);
1129
                c = (sx_read_channel_byte(port, hi_rxipos) - rx_op) & 0xff;
1130
 
1131
                sx_dprintk(SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
1132
 
1133
                /* Don't copy past the end of the hardware receive buffer */
1134
                if (rx_op + c > 0x100)
1135
                        c = 0x100 - rx_op;
1136
 
1137
                sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
1138
 
1139
                /* Don't copy more bytes than there is room for in the buffer */
1140
 
1141
                c = tty_prepare_flip_string(tty, &rp, c);
1142
 
1143
                sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
1144
 
1145
                /* If for one reason or another, we can't copy more data, we're done! */
1146
                if (c == 0)
1147
                        break;
1148
 
1149
                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);
1155
 
1156
                /* This one last. ( Not essential.)
1157
                   It allows the card to start putting more data into the
1158
                   buffer!
1159
                   Update the pointer in the card */
1160
                sx_write_channel_byte(port, hi_rxopos, (rx_op + c) & 0xff);
1161
 
1162
                copied += c;
1163
        }
1164
        if (copied) {
1165
                struct timeval tv;
1166
 
1167
                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);
1172
 
1173
                /* Tell the rest of the system the news. Great news. New
1174
                   characters! */
1175
                tty_flip_buffer_push(tty);
1176
                /*    tty_schedule_flip (tty); */
1177
        }
1178
 
1179
        func_exit();
1180
}
1181
 
1182
/* Inlined: it is called only once. Remove the inline if you add another
1183
   call */
1184
static inline void sx_check_modem_signals(struct sx_port *port)
1185
{
1186
        int hi_state;
1187
        int c_dcd;
1188
 
1189
        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));
1192
 
1193
        if (hi_state & ST_BREAK) {
1194
                hi_state &= ~ST_BREAK;
1195
                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);
1198
        }
1199
        if (hi_state & ST_DCD) {
1200
                hi_state &= ~ST_DCD;
1201
                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);
1205
                if (c_dcd != port->c_dcd) {
1206
                        port->c_dcd = c_dcd;
1207
                        if (sx_get_CD(port)) {
1208
                                /* DCD went UP */
1209
                                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);
1218
                                } else {
1219
                                        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1220
                                                "raised. Ignoring.\n");
1221
                                }
1222
                        } else {
1223
                                /* DCD went down! */
1224
                                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);
1228
                                } else {
1229
                                        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1230
                                                "dropped. ignoring.\n");
1231
                                }
1232
                        }
1233
                } else {
1234
                        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us "
1235
                                "DCD changed, but it didn't.\n");
1236
                }
1237
        }
1238
}
1239
 
1240
/* This is what an interrupt routine should look like.
1241
 * Small, elegant, clear.
1242
 */
1243
 
1244
static irqreturn_t sx_interrupt(int irq, void *ptr)
1245
{
1246
        struct sx_board *board = ptr;
1247
        struct sx_port *port;
1248
        int i;
1249
 
1250
        func_enter();
1251
        sx_dprintk(SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq,
1252
                        board->irq);
1253
 
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
1258
           recursive calls will hang the machine in the interrupt routine.
1259
 
1260
           - hardware twiddling goes before "recursive". Otherwise when we
1261
           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).
1264
 
1265
           - Rate limit goes before hardware twiddling. Otherwise we won't
1266
           catch a card that has gone bonkers.
1267
 
1268
           - The "initialized" test goes after the hardware twiddling. Otherwise
1269
           the card will stick us in the interrupt routine again.
1270
 
1271
           - The initialized test goes before recursive.
1272
         */
1273
 
1274
#ifdef IRQ_RATE_LIMIT
1275
        /* Aaargh! I'm ashamed. This costs more lines-of-code than the
1276
           actual interrupt routine!. (Well, used to when I wrote that
1277
           comment) */
1278
        {
1279
                static int lastjif;
1280
                static int nintr = 0;
1281
 
1282
                if (lastjif == jiffies) {
1283
                        if (++nintr > IRQ_RATE_LIMIT) {
1284
                                free_irq(board->irq, board);
1285
                                printk(KERN_ERR "sx: Too many interrupts. "
1286
                                                "Turning off interrupt %d.\n",
1287
                                                board->irq);
1288
                        }
1289
                } else {
1290
                        lastjif = jiffies;
1291
                        nintr = 0;
1292
                }
1293
        }
1294
#endif
1295
 
1296
        if (board->irq == irq) {
1297
                /* Tell the card we've noticed the interrupt. */
1298
 
1299
                sx_write_board_word(board, cc_int_pending, 0);
1300
                if (IS_SX_BOARD(board)) {
1301
                        write_sx_byte(board, SX_RESET_IRQ, 1);
1302
                } else if (IS_EISA_BOARD(board)) {
1303
                        inb(board->eisa_base + 0xc03);
1304
                        write_sx_word(board, 8, 0);
1305
                } else {
1306
                        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);
1310
                }
1311
        }
1312
 
1313
        if (!sx_initialized)
1314
                return IRQ_HANDLED;
1315
        if (!(board->flags & SX_BOARD_INITIALIZED))
1316
                return IRQ_HANDLED;
1317
 
1318
        if (test_and_set_bit(SX_BOARD_INTR_LOCK, &board->locks)) {
1319
                printk(KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
1320
                return IRQ_HANDLED;
1321
        }
1322
 
1323
        for (i = 0; i < board->nports; i++) {
1324
                port = &board->ports[i];
1325
                if (port->gs.flags & GS_ACTIVE) {
1326
                        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);
1330
                        }
1331
                        if (port->gs.xmit_cnt) {
1332
                                sx_transmit_chars(port);
1333
                        }
1334
                        if (!(port->gs.flags & SX_RX_THROTTLE)) {
1335
                                sx_receive_chars(port);
1336
                        }
1337
                }
1338
        }
1339
 
1340
        clear_bit(SX_BOARD_INTR_LOCK, &board->locks);
1341
 
1342
        sx_dprintk(SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq,
1343
                        board->irq);
1344
        func_exit();
1345
        return IRQ_HANDLED;
1346
}
1347
 
1348
static void sx_pollfunc(unsigned long data)
1349
{
1350
        struct sx_board *board = (struct sx_board *)data;
1351
 
1352
        func_enter();
1353
 
1354
        sx_interrupt(0, board);
1355
 
1356
        mod_timer(&board->timer, jiffies + sx_poll);
1357
        func_exit();
1358
}
1359
 
1360
/* ********************************************************************** *
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
 
1368
static void sx_disable_tx_interrupts(void *ptr)
1369
{
1370
        struct sx_port *port = ptr;
1371
        func_enter2();
1372
 
1373
        port->gs.flags &= ~GS_TX_INTEN;
1374
 
1375
        func_exit();
1376
}
1377
 
1378
static void sx_enable_tx_interrupts(void *ptr)
1379
{
1380
        struct sx_port *port = ptr;
1381
        int data_in_buffer;
1382
        func_enter2();
1383
 
1384
        /* First transmit the characters that we're supposed to */
1385
        sx_transmit_chars(port);
1386
 
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. */
1389
        data_in_buffer = (sx_read_channel_byte(port, hi_txipos) -
1390
                          sx_read_channel_byte(port, hi_txopos)) & 0xff;
1391
 
1392
        /* XXX Must be "HIGH_WATER" for SI card according to doc. */
1393
        if (data_in_buffer < LOW_WATER)
1394
                port->gs.flags &= ~GS_TX_INTEN;
1395
 
1396
        func_exit();
1397
}
1398
 
1399
static void sx_disable_rx_interrupts(void *ptr)
1400
{
1401
        /*  struct sx_port *port = ptr; */
1402
        func_enter();
1403
 
1404
        func_exit();
1405
}
1406
 
1407
static void sx_enable_rx_interrupts(void *ptr)
1408
{
1409
        /*  struct sx_port *port = ptr; */
1410
        func_enter();
1411
 
1412
        func_exit();
1413
}
1414
 
1415
/* Jeez. Isn't this simple? */
1416
static int sx_get_CD(void *ptr)
1417
{
1418
        struct sx_port *port = ptr;
1419
        func_enter2();
1420
 
1421
        func_exit();
1422
        return ((sx_read_channel_byte(port, hi_ip) & IP_DCD) != 0);
1423
}
1424
 
1425
/* Jeez. Isn't this simple? */
1426
static int sx_chars_in_buffer(void *ptr)
1427
{
1428
        struct sx_port *port = ptr;
1429
        func_enter2();
1430
 
1431
        func_exit();
1432
        return ((sx_read_channel_byte(port, hi_txipos) -
1433
                 sx_read_channel_byte(port, hi_txopos)) & 0xff);
1434
}
1435
 
1436
static void sx_shutdown_port(void *ptr)
1437
{
1438
        struct sx_port *port = ptr;
1439
 
1440
        func_enter();
1441
 
1442
        port->gs.flags &= ~GS_ACTIVE;
1443
        if (port->gs.tty && (port->gs.tty->termios->c_cflag & HUPCL)) {
1444
                sx_setsignals(port, 0, 0);
1445
                sx_reconfigure_port(port);
1446
        }
1447
 
1448
        func_exit();
1449
}
1450
 
1451
/* ********************************************************************** *
1452
 *                Here are the routines that actually                     *
1453
 *               interface with the rest of the system                    *
1454
 * ********************************************************************** */
1455
 
1456
static int sx_open(struct tty_struct *tty, struct file *filp)
1457
{
1458
        struct sx_port *port;
1459
        int retval, line;
1460
        unsigned long flags;
1461
 
1462
        func_enter();
1463
 
1464
        if (!sx_initialized) {
1465
                return -EIO;
1466
        }
1467
 
1468
        line = tty->index;
1469
        sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
1470
                        "np=%d)\n", task_pid_nr(current), line, tty,
1471
                        current->signal->tty, sx_nports);
1472
 
1473
        if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1474
                return -ENODEV;
1475
 
1476
        port = &sx_ports[line];
1477
        port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
1478
                            1 -> 0 transition. */
1479
 
1480
        sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
1481
 
1482
        spin_lock_irqsave(&port->gs.driver_lock, flags);
1483
 
1484
        tty->driver_data = port;
1485
        port->gs.tty = tty;
1486
        port->gs.count++;
1487
        spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1488
 
1489
        sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
1490
 
1491
        /*
1492
         * Start up serial port
1493
         */
1494
        retval = gs_init_port(&port->gs);
1495
        sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
1496
        if (retval) {
1497
                port->gs.count--;
1498
                return retval;
1499
        }
1500
 
1501
        port->gs.flags |= GS_ACTIVE;
1502
        if (port->gs.count <= 1)
1503
                sx_setsignals(port, 1, 1);
1504
 
1505
#if 0
1506
        if (sx_debug & SX_DEBUG_OPEN)
1507
                my_hd(port, sizeof(*port));
1508
#else
1509
        if (sx_debug & SX_DEBUG_OPEN)
1510
                my_hd_io(port->board->base + port->ch_base, sizeof(*port));
1511
#endif
1512
 
1513
        if (port->gs.count <= 1) {
1514
                if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1515
                        printk(KERN_ERR "sx: Card didn't respond to LOPEN "
1516
                                        "command.\n");
1517
                        spin_lock_irqsave(&port->gs.driver_lock, flags);
1518
                        port->gs.count--;
1519
                        spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1520
                        return -EIO;
1521
                }
1522
        }
1523
 
1524
        retval = gs_block_til_ready(port, filp);
1525
        sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
1526
                        retval, port->gs.count);
1527
 
1528
        if (retval) {
1529
/*
1530
 * Don't lower gs.count here because sx_close() will be called later
1531
 */
1532
 
1533
                return retval;
1534
        }
1535
        /* tty->low_latency = 1; */
1536
 
1537
        port->c_dcd = sx_get_CD(port);
1538
        sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
1539
 
1540
        func_exit();
1541
        return 0;
1542
 
1543
}
1544
 
1545
static void sx_close(void *ptr)
1546
{
1547
        struct sx_port *port = ptr;
1548
        /* Give the port 5 seconds to close down. */
1549
        int to = 5 * HZ;
1550
 
1551
        func_enter();
1552
 
1553
        sx_setsignals(port, 0, 0);
1554
        sx_reconfigure_port(port);
1555
        sx_send_command(port, HS_CLOSE, 0, 0);
1556
 
1557
        while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
1558
                if (msleep_interruptible(10))
1559
                        break;
1560
        if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
1561
                if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
1562
                                != 1) {
1563
                        printk(KERN_ERR "sx: sent the force_close command, but "
1564
                                        "card didn't react\n");
1565
                } else
1566
                        sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
1567
                                        "command.\n");
1568
        }
1569
 
1570
        sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
1571
                        5 * HZ - to - 1, port->gs.count);
1572
 
1573
        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;*/
1579
        }
1580
 
1581
        func_exit();
1582
}
1583
 
1584
/* This is relatively thorough. But then again it is only 20 lines. */
1585
#define MARCHUP         for (i = min; i < max; i++)
1586
#define MARCHDOWN       for (i = max - 1; i >= min; i--)
1587
#define W0              write_sx_byte(board, i, 0x55)
1588
#define W1              write_sx_byte(board, i, 0xaa)
1589
#define R0              if (read_sx_byte(board, i) != 0x55) return 1
1590
#define R1              if (read_sx_byte(board, i) != 0xaa) return 1
1591
 
1592
/* This memtest takes a human-noticable time. You normally only do it
1593
   once a boot, so I guess that it is worth it. */
1594
static int do_memtest(struct sx_board *board, int min, int max)
1595
{
1596
        int i;
1597
 
1598
        /* This is a marchb. Theoretically, marchb catches much more than
1599
           simpler tests. In practise, the longer test just catches more
1600
           intermittent errors. -- REW
1601
           (For the theory behind memory testing see:
1602
           Testing Semiconductor Memories by A.J. van de Goor.) */
1603
        MARCHUP {
1604
                W0;
1605
        }
1606
        MARCHUP {
1607
                R0;
1608
                W1;
1609
                R1;
1610
                W0;
1611
                R0;
1612
                W1;
1613
        }
1614
        MARCHUP {
1615
                R1;
1616
                W0;
1617
                W1;
1618
        }
1619
        MARCHDOWN {
1620
                R1;
1621
                W0;
1622
                W1;
1623
                W0;
1624
        }
1625
        MARCHDOWN {
1626
                R0;
1627
                W1;
1628
                W0;
1629
        }
1630
 
1631
        return 0;
1632
}
1633
 
1634
#undef MARCHUP
1635
#undef MARCHDOWN
1636
#undef W0
1637
#undef W1
1638
#undef R0
1639
#undef R1
1640
 
1641
#define MARCHUP         for (i = min; i < max; i += 2)
1642
#define MARCHDOWN       for (i = max - 1; i >= min; i -= 2)
1643
#define W0              write_sx_word(board, i, 0x55aa)
1644
#define W1              write_sx_word(board, i, 0xaa55)
1645
#define R0              if (read_sx_word(board, i) != 0x55aa) return 1
1646
#define R1              if (read_sx_word(board, i) != 0xaa55) return 1
1647
 
1648
#if 0
1649
/* This memtest takes a human-noticable time. You normally only do it
1650
   once a boot, so I guess that it is worth it. */
1651
static int do_memtest_w(struct sx_board *board, int min, int max)
1652
{
1653
        int i;
1654
 
1655
        MARCHUP {
1656
                W0;
1657
        }
1658
        MARCHUP {
1659
                R0;
1660
                W1;
1661
                R1;
1662
                W0;
1663
                R0;
1664
                W1;
1665
        }
1666
        MARCHUP {
1667
                R1;
1668
                W0;
1669
                W1;
1670
        }
1671
        MARCHDOWN {
1672
                R1;
1673
                W0;
1674
                W1;
1675
                W0;
1676
        }
1677
        MARCHDOWN {
1678
                R0;
1679
                W1;
1680
                W0;
1681
        }
1682
 
1683
        return 0;
1684
}
1685
#endif
1686
 
1687
static int sx_fw_ioctl(struct inode *inode, struct file *filp,
1688
                unsigned int cmd, unsigned long arg)
1689
{
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
 
1700
#if 0
1701
        /* 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
 
1708
        sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
1709
 
1710
        if (!board)
1711
                board = &boards[0];
1712
        if (board->flags & SX_BOARD_PRESENT) {
1713
                sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1714
                                board->flags);
1715
        } else {
1716
                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");
1721
                return -EIO;
1722
        }
1723
 
1724
        switch (cmd) {
1725
        case SXIO_SET_BOARD:
1726
                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");
1733
                board = &boards[arg];
1734
                break;
1735
        case SXIO_GET_TYPE:
1736
                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);
1748
                break;
1749
        case SXIO_DO_RAMTEST:
1750
                if (sx_initialized)     /* Already initialized: better not ramtest the board.  */
1751
                        return -EPERM;
1752
                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); */
1757
                } else {
1758
                        rc = do_memtest(board, 0, 0x7ff8);
1759
                        /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
1760
                }
1761
                sx_dprintk(SX_DEBUG_FIRMWARE, "returning memtest result= %d\n",
1762
                           rc);
1763
                break;
1764
        case SXIO_DOWNLOAD:
1765
                if (sx_initialized)     /* Already initialized */
1766
                        return -EEXIST;
1767
                if (!sx_reset(board))
1768
                        return -EIO;
1769
                sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
1770
 
1771
                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++);
1777
                while (nbytes && data) {
1778
                        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);
1783
                                        return -EFAULT;
1784
                                }
1785
                                memcpy_toio(board->base2 + offset + i, tmp,
1786
                                                (i + SX_CHUNK_SIZE > nbytes) ?
1787
                                                nbytes - i : SX_CHUNK_SIZE);
1788
                        }
1789
 
1790
                        get_user(nbytes, descr++);
1791
                        get_user(offset, descr++);
1792
                        get_user(data, descr++);
1793
                }
1794
                kfree(tmp);
1795
                sx_nports += sx_init_board(board);
1796
                rc = sx_nports;
1797
                break;
1798
        case SXIO_INIT:
1799
                if (sx_initialized)     /* Already initialized */
1800
                        return -EEXIST;
1801
                /* This is not allowed until all boards are initialized... */
1802
                for (i = 0; i < SX_NBOARDS; i++) {
1803
                        if ((boards[i].flags & SX_BOARD_PRESENT) &&
1804
                                !(boards[i].flags & SX_BOARD_INITIALIZED))
1805
                                return -EIO;
1806
                }
1807
                for (i = 0; i < SX_NBOARDS; i++)
1808
                        if (!(boards[i].flags & SX_BOARD_PRESENT))
1809
                                break;
1810
 
1811
                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)
1817
                        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:
1833
                printk(KERN_WARNING "Unknown ioctl on firmware device (%x).\n",
1834
                                cmd);
1835
                break;
1836
        }
1837
        func_exit();
1838
        return rc;
1839
}
1840
 
1841
static void sx_break(struct tty_struct *tty, int flag)
1842
{
1843
        struct sx_port *port = tty->driver_data;
1844
        int rv;
1845
 
1846
        func_enter();
1847
 
1848
        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)));
1855
 
1856
        func_exit();
1857
}
1858
 
1859
static 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
 
1865
static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1866
                unsigned int set, unsigned int clear)
1867
{
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
 
1885
static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1886
                unsigned int cmd, unsigned long arg)
1887
{
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),
1899
                                (unsigned __user *)argp);
1900
                break;
1901
        case TIOCSSOFTCAR:
1902
                if ((rc = get_user(ival, (unsigned __user *)argp)) == 0) {
1903
                        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
 
1923
/* 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
 
1939
static void sx_throttle(struct tty_struct *tty)
1940
{
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
         */
1947
        if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
1948
                port->gs.flags |= SX_RX_THROTTLE;
1949
        }
1950
        func_exit();
1951
}
1952
 
1953
static void sx_unthrottle(struct tty_struct *tty)
1954
{
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
 
1967
/* ********************************************************************** *
1968
 *                    Here are the initialization routines.               *
1969
 * ********************************************************************** */
1970
 
1971
static int sx_init_board(struct sx_board *board)
1972
{
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
 
1983
        if (read_sx_byte(board, 0))
1984
                /* CF boards may need this. */
1985
                write_sx_byte(board, 0, 0);
1986
 
1987
        /* This resets the processor again, to make sure it didn't do any
1988
           foolish things while we were downloading the image */
1989
        if (!sx_reset(board))
1990
                return 0;
1991
 
1992
        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");
1996
                return 0;
1997
        }
1998
 
1999
        /* Ok. So now the processor on the card is running. It gathered
2000
           some info for us... */
2001
        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);
2007
 
2008
        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));
2012
 
2013
        if (read_sx_byte(board, 0) == 0xff) {
2014
                printk(KERN_INFO "sx: No modules found. Sorry.\n");
2015
                board->nports = 0;
2016
                return 0;
2017
        }
2018
 
2019
        chans = 0;
2020
 
2021
        if (IS_SX_BOARD(board)) {
2022
                sx_write_board_word(board, cc_int_count, sx_maxints);
2023
        } else {
2024
                if (sx_maxints)
2025
                        sx_write_board_word(board, cc_int_count,
2026
                                        SI_PROCESSOR_CLOCK / 8 / sx_maxints);
2027
        }
2028
 
2029
        /* grab the first module type... */
2030
        /* 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));
2033
 
2034
        /* XXX byteorder */
2035
        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));
2039
 
2040
                chans += sx_read_module_byte(board, addr, mc_type);
2041
 
2042
                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));
2049
 
2050
                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));
2055
 
2056
                /* The following combinations are illegal: It should theoretically
2057
                   work, but timing problems make the bus HANG. */
2058
 
2059
                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;
2064
                        break;
2065
                }
2066
                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;
2073
                        break;
2074
                }
2075
#if 0                           /* Problem fixed: firmware 3.05 */
2076
                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.
2079
                           It might also work if you get a newer sx_firmware.   Therefore
2080
                           this is just a warning. */
2081
                        printk(KERN_WARNING
2082
                               "sx: The SX host doesn't work too well "
2083
                               "with the TA8 adapters.\nSpecialix is working on it.\n");
2084
                }
2085
#endif
2086
        }
2087
 
2088
        if (chans) {
2089
                if (board->irq > 0) {
2090
                        /* fixed irq, probably PCI */
2091
                        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);
2097
                                        board->irq = 0;
2098
                                }
2099
                        } else
2100
                                board->irq = 0;
2101
                } else if (board->irq < 0 && sx_irqmask) {
2102
                        /* auto-allocate irq */
2103
                        int irqnr;
2104
                        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))
2111
                                                break;
2112
                        if (!irqnr)
2113
                                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! */
2120
                        sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
2121
                                        board->irq);
2122
                        sx_start_interrupts(board);
2123
                        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;
2128
                        sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
2129
                                        board->poll);
2130
                }
2131
 
2132
                /* The timer should be initialized anyway: That way we can
2133
                   safely del_timer it when the module is unloaded. */
2134
                setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
2135
 
2136
                if (board->poll)
2137
                        mod_timer(&board->timer, jiffies + board->poll);
2138
        } else {
2139
                board->irq = 0;
2140
        }
2141
 
2142
        board->nports = chans;
2143
        sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
2144
 
2145
        func_exit();
2146
        return chans;
2147
}
2148
 
2149
static void __devinit printheader(void)
2150
{
2151
        static int header_printed;
2152
 
2153
        if (!header_printed) {
2154
                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");
2157
                header_printed = 1;
2158
        }
2159
}
2160
 
2161
static int __devinit probe_sx(struct sx_board *board)
2162
{
2163
        struct vpd_prom vpdp;
2164
        char *p;
2165
        int i;
2166
 
2167
        func_enter();
2168
 
2169
        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);
2172
 
2173
                if (sx_debug & SX_DEBUG_PROBE)
2174
                        my_hd_io(board->base + SX_VPD_ROM, 0x40);
2175
 
2176
                p = (char *)&vpdp;
2177
                for (i = 0; i < sizeof(struct vpd_prom); i++)
2178
                        *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
2179
 
2180
                if (sx_debug & SX_DEBUG_PROBE)
2181
                        my_hd(&vpdp, 0x20);
2182
 
2183
                sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
2184
 
2185
                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);
2188
                        return 0;
2189
                }
2190
        }
2191
 
2192
        printheader();
2193
 
2194
        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);
2201
 
2202
                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");
2209
                        return (0);
2210
                }
2211
 
2212
                if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
2213
                                SX_ISA_UNIQUEID1) {
2214
                        if (((unsigned long)board->hw_base) & 0x8000) {
2215
                                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");
2220
                        }
2221
                }
2222
        }
2223
 
2224
        board->nports = -1;
2225
 
2226
        /* This resets the processor, and keeps it off the bus. */
2227
        if (!sx_reset(board))
2228
                return 0;
2229
        sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2230
 
2231
        func_exit();
2232
        return 1;
2233
}
2234
 
2235
#if defined(CONFIG_ISA) || defined(CONFIG_EISA)
2236
 
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
 
2243
static int __devinit probe_si(struct sx_board *board)
2244
{
2245
        int i;
2246
 
2247
        func_enter();
2248
        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);
2250
 
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)) {
2255
                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
                        }
2259
                }
2260
                for (i = 0; i < 8; i++) {
2261
                        if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
2262
                                        != i) {
2263
                                func_exit();
2264
                                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
 
2273
        write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2274
        if (IS_SI1_BOARD(board)) {
2275
                /* This should be an SI1 board, which has this
2276
                   location writable... */
2277
                if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2278
                        func_exit();
2279
                        return 0;
2280
                }
2281
        } else {
2282
                /* This should be an SI2 board, which has the bottom
2283
                   3 bits non-writable... */
2284
                if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2285
                        func_exit();
2286
                        return 0;
2287
                }
2288
        }
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
 
2294
        write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2295
        if (IS_SI1_BOARD(board)) {
2296
                /* This should be an SI1 board, which has this
2297
                   location writable... */
2298
                if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2299
                        func_exit();
2300
                        return 0;
2301
                }
2302
        } else {
2303
                /* This should be an SI2 board, which has the bottom
2304
                   3 bits non-writable... */
2305
                if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2306
                        func_exit();
2307
                        return 0;
2308
                }
2309
        }
2310
 
2311
        printheader();
2312
 
2313
        printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
2314
        /* Compared to the SX boards, it is a complete guess as to what
2315
           this card is up to... */
2316
 
2317
        board->nports = -1;
2318
 
2319
        /* This resets the processor, and keeps it off the bus. */
2320
        if (!sx_reset(board))
2321
                return 0;
2322
        sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2323
 
2324
        func_exit();
2325
        return 1;
2326
}
2327
#endif
2328
 
2329
static const struct tty_operations sx_ops = {
2330
        .break_ctl = sx_break,
2331
        .open = sx_open,
2332
        .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
 
2350
static 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;
2366
        sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2367
        sx_driver->init_termios.c_ispeed = 9600;
2368
        sx_driver->init_termios.c_ospeed = 9600;
2369
        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",
2375
                        error);
2376
                return 1;
2377
        }
2378
        func_exit();
2379
        return 0;
2380
}
2381
 
2382
static int sx_init_portstructs(int nboards, int nports)
2383
{
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
2393
           There is no reason not to allocate them dynamically.
2394
           Is there? -- REW */
2395
        sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
2396
        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;
2403
                for (j = 0; j < boards[i].nports; j++) {
2404
                        sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
2405
                        port->gs.magic = SX_MAGIC;
2406
                        port->gs.close_delay = HZ / 2;
2407
                        port->gs.closing_wait = 30 * HZ;
2408
                        port->board = board;
2409
                        port->gs.rd = &sx_real_driver;
2410
#ifdef NEW_WRITE_LOCKING
2411
                        port->gs.port_write_mutex = MUTEX;
2412
#endif
2413
                        spin_lock_init(&port->gs.driver_lock);
2414
                        /*
2415
                         * Initializing wait queue
2416
                         */
2417
                        init_waitqueue_head(&port->gs.open_wait);
2418
                        init_waitqueue_head(&port->gs.close_wait);
2419
 
2420
                        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. */
2430
                sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
2431
                                board->nports);
2432
                if (board->nports <= 0)
2433
                        continue;
2434
                /* XXX byteorder ?? */
2435
                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. */
2447
                                if (IS_SX_BOARD(board))
2448
                                        port->ch_base = sx_read_module_word(
2449
                                                        board, addr + j * 2,
2450
                                                        mc_chan_pointer);
2451
                                else
2452
                                        port->ch_base = addr + 0x100 + 0x300 *j;
2453
 
2454
                                sx_dprintk(SX_DEBUG_PROBE, " %x",
2455
                                                port->ch_base);
2456
                                port->line = portno++;
2457
                                port++;
2458
                        }
2459
                        sx_dprintk(SX_DEBUG_PROBE, "\n");
2460
                }
2461
                /* This has to be done earlier. */
2462
                /* board->flags |= SX_BOARD_INITIALIZED; */
2463
        }
2464
 
2465
        func_exit();
2466
        return 0;
2467
}
2468
 
2469
static unsigned int sx_find_free_board(void)
2470
{
2471
        unsigned int i;
2472
 
2473
        for (i = 0; i < SX_NBOARDS; i++)
2474
                if (!(boards[i].flags & SX_BOARD_PRESENT))
2475
                        break;
2476
 
2477
        return i;
2478
}
2479
 
2480
static 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
 
2488
static void __devexit sx_remove_card(struct sx_board *board,
2489
                struct pci_dev *pdev)
2490
{
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);
2500
                if (pdev) {
2501
#ifdef CONFIG_PCI
2502
                        pci_iounmap(pdev, board->base);
2503
                        pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
2504
#endif
2505
                } else {
2506
                        iounmap(board->base);
2507
                        release_region(board->hw_base, board->hw_len);
2508
                }
2509
 
2510
                board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
2511
        }
2512
}
2513
 
2514
#ifdef CONFIG_EISA
2515
 
2516
static 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
 
2524
        mutex_lock(&sx_boards_lock);
2525
        i = sx_find_free_board();
2526
        if (i == SX_NBOARDS) {
2527
                mutex_unlock(&sx_boards_lock);
2528
                goto err;
2529
        }
2530
        board = &boards[i];
2531
        board->flags |= SX_BOARD_PRESENT;
2532
        mutex_unlock(&sx_boards_lock);
2533
 
2534
        dev_info(dev, "XIO : Signature found in EISA slot %lu, "
2535
                 "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));
2539
 
2540
        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) +
2545
                          inb(eisa_slot + 0xc00)) << 16;
2546
        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
        }
2551
        board->base2 =
2552
        board->base = ioremap(board->hw_base, SI2_EISA_WINDOW_LEN);
2553
        if (!board->base) {
2554
                dev_err(dev, "can't remap memory\n");
2555
                goto err_reg;
2556
        }
2557
 
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;
2569
err_unmap:
2570
        iounmap(board->base);
2571
err_reg:
2572
        release_region(board->hw_base, board->hw_len);
2573
err_flag:
2574
        board->flags &= ~SX_BOARD_PRESENT;
2575
err:
2576
        return retval;
2577
}
2578
 
2579
static int __devexit sx_eisa_remove(struct device *dev)
2580
{
2581
        struct sx_board *board = dev_get_drvdata(dev);
2582
 
2583
        sx_remove_card(board, NULL);
2584
 
2585
        return 0;
2586
}
2587
 
2588
static struct eisa_device_id sx_eisa_tbl[] = {
2589
        { "SLX" },
2590
        { "" }
2591
};
2592
 
2593
MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2594
 
2595
static 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
 
2606
#ifdef CONFIG_PCI
2607
 /********************************************************
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
 
2618
static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
2619
{
2620
        unsigned int hwbase;
2621
        void __iomem *rebase;
2622
        unsigned int t;
2623
 
2624
#define CNTRL_REG_OFFSET        0x50
2625
#define CNTRL_REG_GOODVALUE     0x18260000
2626
 
2627
        pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2628
        hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2629
        rebase = ioremap(hwbase, 0x80);
2630
        t = readl(rebase + CNTRL_REG_OFFSET);
2631
        if (t != CNTRL_REG_GOODVALUE) {
2632
                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);
2635
        }
2636
        iounmap(rebase);
2637
}
2638
#endif
2639
 
2640
static int __devinit sx_pci_probe(struct pci_dev *pdev,
2641
                                  const struct pci_device_id *ent)
2642
{
2643
#ifdef CONFIG_PCI
2644
        struct sx_board *board;
2645
        unsigned int i, reg;
2646
        int retval = -EIO;
2647
 
2648
        mutex_lock(&sx_boards_lock);
2649
        i = sx_find_free_board();
2650
        if (i == SX_NBOARDS) {
2651
                mutex_unlock(&sx_boards_lock);
2652
                goto err;
2653
        }
2654
        board = &boards[i];
2655
        board->flags |= SX_BOARD_PRESENT;
2656
        mutex_unlock(&sx_boards_lock);
2657
 
2658
        retval = pci_enable_device(pdev);
2659
        if (retval)
2660
                goto err_flag;
2661
 
2662
        board->flags &= ~SX_BOARD_TYPE;
2663
        board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
2664
                SX_CFPCI_BOARD;
2665
 
2666
        /* CF boards use base address 3.... */
2667
        reg = IS_CF_BOARD(board) ? 3 : 2;
2668
        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
        }
2673
        board->hw_base = pci_resource_start(pdev, reg);
2674
        board->base2 =
2675
        board->base = pci_iomap(pdev, reg, WINDOW_LEN(board));
2676
        if (!board->base) {
2677
                dev_err(&pdev->dev, "ioremap failed\n");
2678
                goto err_reg;
2679
        }
2680
 
2681
        /* Most of the stuff on the CF board is offset by 0x18000 ....  */
2682
        if (IS_CF_BOARD(board))
2683
                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,
2688
                 board->irq, board->flags);
2689
 
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;
2700
err_unmap:
2701
        pci_iounmap(pdev, board->base);
2702
err_reg:
2703
        pci_release_region(pdev, reg);
2704
err_flag:
2705
        board->flags &= ~SX_BOARD_PRESENT;
2706
err:
2707
        return retval;
2708
#else
2709
        return -ENODEV;
2710
#endif
2711
}
2712
 
2713
static void __devexit sx_pci_remove(struct pci_dev *pdev)
2714
{
2715
        struct sx_board *board = pci_get_drvdata(pdev);
2716
 
2717
        sx_remove_card(board, pdev);
2718
}
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. */
2722
static struct pci_device_id sx_pci_tbl[] = {
2723
        { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2724
                .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
2725
        { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2726
                .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
2727
        { 0 }
2728
};
2729
 
2730
MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2731
 
2732
static 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
};
2738
 
2739
static int __init sx_init(void)
2740
{
2741
#ifdef CONFIG_EISA
2742
        int retval1;
2743
#endif
2744
#ifdef CONFIG_ISA
2745
        struct sx_board *board;
2746
        unsigned int i;
2747
#endif
2748
        unsigned int found = 0;
2749
        int retval;
2750
 
2751
        func_enter();
2752
        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;
2758
        }
2759
 
2760
        if (misc_register(&sx_fw_device) < 0) {
2761
                printk(KERN_ERR "SX: Unable to register firmware loader "
2762
                                "driver.\n");
2763
                return -EIO;
2764
        }
2765
#ifdef CONFIG_ISA
2766
        for (i = 0; i < NR_SX_ADDRS; i++) {
2767
                board = &boards[found];
2768
                board->hw_base = sx_probe_addrs[i];
2769
                board->hw_len = SX_WINDOW_LEN;
2770
                if (!request_region(board->hw_base, board->hw_len, "sx"))
2771
                        continue;
2772
                board->base2 =
2773
                board->base = ioremap(board->hw_base, board->hw_len);
2774
                if (!board->base)
2775
                        goto err_sx_reg;
2776
                board->flags &= ~SX_BOARD_TYPE;
2777
                board->flags |= SX_ISA_BOARD;
2778
                board->irq = sx_irqmask ? -1 : 0;
2779
 
2780
                if (probe_sx(board)) {
2781
                        board->flags |= SX_BOARD_PRESENT;
2782
                        found++;
2783
                } else {
2784
                        iounmap(board->base);
2785
err_sx_reg:
2786
                        release_region(board->hw_base, board->hw_len);
2787
                }
2788
        }
2789
 
2790
        for (i = 0; i < NR_SI_ADDRS; i++) {
2791
                board = &boards[found];
2792
                board->hw_base = si_probe_addrs[i];
2793
                board->hw_len = SI2_ISA_WINDOW_LEN;
2794
                if (!request_region(board->hw_base, board->hw_len, "sx"))
2795
                        continue;
2796
                board->base2 =
2797
                board->base = ioremap(board->hw_base, board->hw_len);
2798
                if (!board->base)
2799
                        goto err_si_reg;
2800
                board->flags &= ~SX_BOARD_TYPE;
2801
                board->flags |= SI_ISA_BOARD;
2802
                board->irq = sx_irqmask ? -1 : 0;
2803
 
2804
                if (probe_si(board)) {
2805
                        board->flags |= SX_BOARD_PRESENT;
2806
                        found++;
2807
                } else {
2808
                        iounmap(board->base);
2809
err_si_reg:
2810
                        release_region(board->hw_base, board->hw_len);
2811
                }
2812
        }
2813
        for (i = 0; i < NR_SI1_ADDRS; i++) {
2814
                board = &boards[found];
2815
                board->hw_base = si1_probe_addrs[i];
2816
                board->hw_len = SI1_ISA_WINDOW_LEN;
2817
                if (!request_region(board->hw_base, board->hw_len, "sx"))
2818
                        continue;
2819
                board->base2 =
2820
                board->base = ioremap(board->hw_base, board->hw_len);
2821
                if (!board->base)
2822
                        goto err_si1_reg;
2823
                board->flags &= ~SX_BOARD_TYPE;
2824
                board->flags |= SI1_ISA_BOARD;
2825
                board->irq = sx_irqmask ? -1 : 0;
2826
 
2827
                if (probe_si(board)) {
2828
                        board->flags |= SX_BOARD_PRESENT;
2829
                        found++;
2830
                } else {
2831
                        iounmap(board->base);
2832
err_si1_reg:
2833
                        release_region(board->hw_base, board->hw_len);
2834
                }
2835
        }
2836
#endif
2837
#ifdef CONFIG_EISA
2838
        retval1 = eisa_driver_register(&sx_eisadriver);
2839
#endif
2840
        retval = pci_register_driver(&sx_pcidriver);
2841
 
2842
        if (found) {
2843
                printk(KERN_INFO "sx: total of %d boards detected.\n", found);
2844
                retval = 0;
2845
        } else if (retval) {
2846
#ifdef CONFIG_EISA
2847
                retval = retval1;
2848
                if (retval1)
2849
#endif
2850
                        misc_deregister(&sx_fw_device);
2851
        }
2852
 
2853
        func_exit();
2854
        return retval;
2855
}
2856
 
2857
static void __exit sx_exit(void)
2858
{
2859
        int i;
2860
 
2861
        func_enter();
2862
#ifdef CONFIG_EISA
2863
        eisa_driver_unregister(&sx_eisadriver);
2864
#endif
2865
        pci_unregister_driver(&sx_pcidriver);
2866
 
2867
        for (i = 0; i < SX_NBOARDS; i++)
2868
                sx_remove_card(&boards[i], NULL);
2869
 
2870
        if (misc_deregister(&sx_fw_device) < 0) {
2871
                printk(KERN_INFO "sx: couldn't deregister firmware loader "
2872
                                "device\n");
2873
        }
2874
        sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
2875
                        sx_initialized);
2876
        if (sx_initialized)
2877
                sx_release_drivers();
2878
 
2879
        kfree(sx_ports);
2880
        func_exit();
2881
}
2882
 
2883
module_init(sx_init);
2884
module_exit(sx_exit);

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.