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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [stallion.c] - Blame information for rev 65

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*****************************************************************************/
2
 
3
/*
4
 *      stallion.c  -- stallion multiport serial driver.
5
 *
6
 *      Copyright (C) 1996-1999  Stallion Technologies
7
 *      Copyright (C) 1994-1996  Greg Ungerer.
8
 *
9
 *      This code is loosely based on the Linux serial driver, written by
10
 *      Linus Torvalds, Theodore T'so and others.
11
 *
12
 *      This program is free software; you can redistribute it and/or modify
13
 *      it under the terms of the GNU General Public License as published by
14
 *      the Free Software Foundation; either version 2 of the License, or
15
 *      (at your option) any later version.
16
 *
17
 *      This program is distributed in the hope that it will be useful,
18
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
19
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
 *      GNU General Public License for more details.
21
 *
22
 *      You should have received a copy of the GNU General Public License
23
 *      along with this program; if not, write to the Free Software
24
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
 */
26
 
27
/*****************************************************************************/
28
 
29
#include <linux/module.h>
30
#include <linux/slab.h>
31
#include <linux/interrupt.h>
32
#include <linux/tty.h>
33
#include <linux/tty_flip.h>
34
#include <linux/serial.h>
35
#include <linux/cd1400.h>
36
#include <linux/sc26198.h>
37
#include <linux/comstats.h>
38
#include <linux/stallion.h>
39
#include <linux/ioport.h>
40
#include <linux/init.h>
41
#include <linux/smp_lock.h>
42
#include <linux/device.h>
43
#include <linux/delay.h>
44
#include <linux/ctype.h>
45
 
46
#include <asm/io.h>
47
#include <asm/uaccess.h>
48
 
49
#include <linux/pci.h>
50
 
51
/*****************************************************************************/
52
 
53
/*
54
 *      Define different board types. Use the standard Stallion "assigned"
55
 *      board numbers. Boards supported in this driver are abbreviated as
56
 *      EIO = EasyIO and ECH = EasyConnection 8/32.
57
 */
58
#define BRD_EASYIO      20
59
#define BRD_ECH         21
60
#define BRD_ECHMC       22
61
#define BRD_ECHPCI      26
62
#define BRD_ECH64PCI    27
63
#define BRD_EASYIOPCI   28
64
 
65
struct stlconf {
66
        unsigned int    brdtype;
67
        int             ioaddr1;
68
        int             ioaddr2;
69
        unsigned long   memaddr;
70
        int             irq;
71
        int             irqtype;
72
};
73
 
74
static unsigned int stl_nrbrds;
75
 
76
/*****************************************************************************/
77
 
78
/*
79
 *      Define some important driver characteristics. Device major numbers
80
 *      allocated as per Linux Device Registry.
81
 */
82
#ifndef STL_SIOMEMMAJOR
83
#define STL_SIOMEMMAJOR         28
84
#endif
85
#ifndef STL_SERIALMAJOR
86
#define STL_SERIALMAJOR         24
87
#endif
88
#ifndef STL_CALLOUTMAJOR
89
#define STL_CALLOUTMAJOR        25
90
#endif
91
 
92
/*
93
 *      Set the TX buffer size. Bigger is better, but we don't want
94
 *      to chew too much memory with buffers!
95
 */
96
#define STL_TXBUFLOW            512
97
#define STL_TXBUFSIZE           4096
98
 
99
/*****************************************************************************/
100
 
101
/*
102
 *      Define our local driver identity first. Set up stuff to deal with
103
 *      all the local structures required by a serial tty driver.
104
 */
105
static char     *stl_drvtitle = "Stallion Multiport Serial Driver";
106
static char     *stl_drvname = "stallion";
107
static char     *stl_drvversion = "5.6.0";
108
 
109
static struct tty_driver        *stl_serial;
110
 
111
/*
112
 *      Define a local default termios struct. All ports will be created
113
 *      with this termios initially. Basically all it defines is a raw port
114
 *      at 9600, 8 data bits, 1 stop bit.
115
 */
116
static struct ktermios          stl_deftermios = {
117
        .c_cflag        = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
118
        .c_cc           = INIT_C_CC,
119
        .c_ispeed       = 9600,
120
        .c_ospeed       = 9600,
121
};
122
 
123
/*
124
 *      Define global place to put buffer overflow characters.
125
 */
126
static char             stl_unwanted[SC26198_RXFIFOSIZE];
127
 
128
/*****************************************************************************/
129
 
130
static DEFINE_MUTEX(stl_brdslock);
131
static struct stlbrd            *stl_brds[STL_MAXBRDS];
132
 
133
/*
134
 *      Per board state flags. Used with the state field of the board struct.
135
 *      Not really much here!
136
 */
137
#define BRD_FOUND       0x1
138
#define STL_PROBED      0x2
139
 
140
 
141
/*
142
 *      Define the port structure istate flags. These set of flags are
143
 *      modified at interrupt time - so setting and reseting them needs
144
 *      to be atomic. Use the bit clear/setting routines for this.
145
 */
146
#define ASYI_TXBUSY     1
147
#define ASYI_TXLOW      2
148
#define ASYI_DCDCHANGE  3
149
#define ASYI_TXFLOWED   4
150
 
151
/*
152
 *      Define an array of board names as printable strings. Handy for
153
 *      referencing boards when printing trace and stuff.
154
 */
155
static char     *stl_brdnames[] = {
156
        NULL,
157
        NULL,
158
        NULL,
159
        NULL,
160
        NULL,
161
        NULL,
162
        NULL,
163
        NULL,
164
        NULL,
165
        NULL,
166
        NULL,
167
        NULL,
168
        NULL,
169
        NULL,
170
        NULL,
171
        NULL,
172
        NULL,
173
        NULL,
174
        NULL,
175
        NULL,
176
        "EasyIO",
177
        "EC8/32-AT",
178
        "EC8/32-MC",
179
        NULL,
180
        NULL,
181
        NULL,
182
        "EC8/32-PCI",
183
        "EC8/64-PCI",
184
        "EasyIO-PCI",
185
};
186
 
187
/*****************************************************************************/
188
 
189
/*
190
 *      Define some string labels for arguments passed from the module
191
 *      load line. These allow for easy board definitions, and easy
192
 *      modification of the io, memory and irq resoucres.
193
 */
194
static unsigned int stl_nargs;
195
static char     *board0[4];
196
static char     *board1[4];
197
static char     *board2[4];
198
static char     *board3[4];
199
 
200
static char     **stl_brdsp[] = {
201
        (char **) &board0,
202
        (char **) &board1,
203
        (char **) &board2,
204
        (char **) &board3
205
};
206
 
207
/*
208
 *      Define a set of common board names, and types. This is used to
209
 *      parse any module arguments.
210
 */
211
 
212
static struct {
213
        char    *name;
214
        int     type;
215
} stl_brdstr[] = {
216
        { "easyio", BRD_EASYIO },
217
        { "eio", BRD_EASYIO },
218
        { "20", BRD_EASYIO },
219
        { "ec8/32", BRD_ECH },
220
        { "ec8/32-at", BRD_ECH },
221
        { "ec8/32-isa", BRD_ECH },
222
        { "ech", BRD_ECH },
223
        { "echat", BRD_ECH },
224
        { "21", BRD_ECH },
225
        { "ec8/32-mc", BRD_ECHMC },
226
        { "ec8/32-mca", BRD_ECHMC },
227
        { "echmc", BRD_ECHMC },
228
        { "echmca", BRD_ECHMC },
229
        { "22", BRD_ECHMC },
230
        { "ec8/32-pc", BRD_ECHPCI },
231
        { "ec8/32-pci", BRD_ECHPCI },
232
        { "26", BRD_ECHPCI },
233
        { "ec8/64-pc", BRD_ECH64PCI },
234
        { "ec8/64-pci", BRD_ECH64PCI },
235
        { "ech-pci", BRD_ECH64PCI },
236
        { "echpci", BRD_ECH64PCI },
237
        { "echpc", BRD_ECH64PCI },
238
        { "27", BRD_ECH64PCI },
239
        { "easyio-pc", BRD_EASYIOPCI },
240
        { "easyio-pci", BRD_EASYIOPCI },
241
        { "eio-pci", BRD_EASYIOPCI },
242
        { "eiopci", BRD_EASYIOPCI },
243
        { "28", BRD_EASYIOPCI },
244
};
245
 
246
/*
247
 *      Define the module agruments.
248
 */
249
 
250
module_param_array(board0, charp, &stl_nargs, 0);
251
MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,ioaddr2][,irq]]");
252
module_param_array(board1, charp, &stl_nargs, 0);
253
MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,ioaddr2][,irq]]");
254
module_param_array(board2, charp, &stl_nargs, 0);
255
MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,ioaddr2][,irq]]");
256
module_param_array(board3, charp, &stl_nargs, 0);
257
MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,ioaddr2][,irq]]");
258
 
259
/*****************************************************************************/
260
 
261
/*
262
 *      Hardware ID bits for the EasyIO and ECH boards. These defines apply
263
 *      to the directly accessible io ports of these boards (not the uarts -
264
 *      they are in cd1400.h and sc26198.h).
265
 */
266
#define EIO_8PORTRS     0x04
267
#define EIO_4PORTRS     0x05
268
#define EIO_8PORTDI     0x00
269
#define EIO_8PORTM      0x06
270
#define EIO_MK3         0x03
271
#define EIO_IDBITMASK   0x07
272
 
273
#define EIO_BRDMASK     0xf0
274
#define ID_BRD4         0x10
275
#define ID_BRD8         0x20
276
#define ID_BRD16        0x30
277
 
278
#define EIO_INTRPEND    0x08
279
#define EIO_INTEDGE     0x00
280
#define EIO_INTLEVEL    0x08
281
#define EIO_0WS         0x10
282
 
283
#define ECH_ID          0xa0
284
#define ECH_IDBITMASK   0xe0
285
#define ECH_BRDENABLE   0x08
286
#define ECH_BRDDISABLE  0x00
287
#define ECH_INTENABLE   0x01
288
#define ECH_INTDISABLE  0x00
289
#define ECH_INTLEVEL    0x02
290
#define ECH_INTEDGE     0x00
291
#define ECH_INTRPEND    0x01
292
#define ECH_BRDRESET    0x01
293
 
294
#define ECHMC_INTENABLE 0x01
295
#define ECHMC_BRDRESET  0x02
296
 
297
#define ECH_PNLSTATUS   2
298
#define ECH_PNL16PORT   0x20
299
#define ECH_PNLIDMASK   0x07
300
#define ECH_PNLXPID     0x40
301
#define ECH_PNLINTRPEND 0x80
302
 
303
#define ECH_ADDR2MASK   0x1e0
304
 
305
/*
306
 *      Define the vector mapping bits for the programmable interrupt board
307
 *      hardware. These bits encode the interrupt for the board to use - it
308
 *      is software selectable (except the EIO-8M).
309
 */
310
static unsigned char    stl_vecmap[] = {
311
        0xff, 0xff, 0xff, 0x04, 0x06, 0x05, 0xff, 0x07,
312
        0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0x03
313
};
314
 
315
/*
316
 *      Lock ordering is that you may not take stallion_lock holding
317
 *      brd_lock.
318
 */
319
 
320
static spinlock_t brd_lock;             /* Guard the board mapping */
321
static spinlock_t stallion_lock;        /* Guard the tty driver */
322
 
323
/*
324
 *      Set up enable and disable macros for the ECH boards. They require
325
 *      the secondary io address space to be activated and deactivated.
326
 *      This way all ECH boards can share their secondary io region.
327
 *      If this is an ECH-PCI board then also need to set the page pointer
328
 *      to point to the correct page.
329
 */
330
#define BRDENABLE(brdnr,pagenr)                                         \
331
        if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
332
                outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDENABLE),    \
333
                        stl_brds[(brdnr)]->ioctrl);                     \
334
        else if (stl_brds[(brdnr)]->brdtype == BRD_ECHPCI)              \
335
                outb((pagenr), stl_brds[(brdnr)]->ioctrl);
336
 
337
#define BRDDISABLE(brdnr)                                               \
338
        if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
339
                outb((stl_brds[(brdnr)]->ioctrlval | ECH_BRDDISABLE),   \
340
                        stl_brds[(brdnr)]->ioctrl);
341
 
342
#define STL_CD1400MAXBAUD       230400
343
#define STL_SC26198MAXBAUD      460800
344
 
345
#define STL_BAUDBASE            115200
346
#define STL_CLOSEDELAY          (5 * HZ / 10)
347
 
348
/*****************************************************************************/
349
 
350
/*
351
 *      Define the Stallion PCI vendor and device IDs.
352
 */
353
#ifndef PCI_VENDOR_ID_STALLION
354
#define PCI_VENDOR_ID_STALLION          0x124d
355
#endif
356
#ifndef PCI_DEVICE_ID_ECHPCI832
357
#define PCI_DEVICE_ID_ECHPCI832         0x0000
358
#endif
359
#ifndef PCI_DEVICE_ID_ECHPCI864
360
#define PCI_DEVICE_ID_ECHPCI864         0x0002
361
#endif
362
#ifndef PCI_DEVICE_ID_EIOPCI
363
#define PCI_DEVICE_ID_EIOPCI            0x0003
364
#endif
365
 
366
/*
367
 *      Define structure to hold all Stallion PCI boards.
368
 */
369
 
370
static struct pci_device_id stl_pcibrds[] = {
371
        { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI864),
372
                .driver_data = BRD_ECH64PCI },
373
        { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_EIOPCI),
374
                .driver_data = BRD_EASYIOPCI },
375
        { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI832),
376
                .driver_data = BRD_ECHPCI },
377
        { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410),
378
                .driver_data = BRD_ECHPCI },
379
        { }
380
};
381
MODULE_DEVICE_TABLE(pci, stl_pcibrds);
382
 
383
/*****************************************************************************/
384
 
385
/*
386
 *      Define macros to extract a brd/port number from a minor number.
387
 */
388
#define MINOR2BRD(min)          (((min) & 0xc0) >> 6)
389
#define MINOR2PORT(min)         ((min) & 0x3f)
390
 
391
/*
392
 *      Define a baud rate table that converts termios baud rate selector
393
 *      into the actual baud rate value. All baud rate calculations are
394
 *      based on the actual baud rate required.
395
 */
396
static unsigned int     stl_baudrates[] = {
397
        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
398
        9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600
399
};
400
 
401
/*****************************************************************************/
402
 
403
/*
404
 *      Declare all those functions in this driver!
405
 */
406
 
407
static int      stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
408
static int      stl_brdinit(struct stlbrd *brdp);
409
static int      stl_getportstats(struct stlport *portp, comstats_t __user *cp);
410
static int      stl_clrportstats(struct stlport *portp, comstats_t __user *cp);
411
static int      stl_waitcarrier(struct stlport *portp, struct file *filp);
412
 
413
/*
414
 *      CD1400 uart specific handling functions.
415
 */
416
static void     stl_cd1400setreg(struct stlport *portp, int regnr, int value);
417
static int      stl_cd1400getreg(struct stlport *portp, int regnr);
418
static int      stl_cd1400updatereg(struct stlport *portp, int regnr, int value);
419
static int      stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
420
static void     stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
421
static void     stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp);
422
static int      stl_cd1400getsignals(struct stlport *portp);
423
static void     stl_cd1400setsignals(struct stlport *portp, int dtr, int rts);
424
static void     stl_cd1400ccrwait(struct stlport *portp);
425
static void     stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx);
426
static void     stl_cd1400startrxtx(struct stlport *portp, int rx, int tx);
427
static void     stl_cd1400disableintrs(struct stlport *portp);
428
static void     stl_cd1400sendbreak(struct stlport *portp, int len);
429
static void     stl_cd1400flowctrl(struct stlport *portp, int state);
430
static void     stl_cd1400sendflow(struct stlport *portp, int state);
431
static void     stl_cd1400flush(struct stlport *portp);
432
static int      stl_cd1400datastate(struct stlport *portp);
433
static void     stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase);
434
static void     stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase);
435
static void     stl_cd1400txisr(struct stlpanel *panelp, int ioaddr);
436
static void     stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr);
437
static void     stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr);
438
 
439
static inline int       stl_cd1400breakisr(struct stlport *portp, int ioaddr);
440
 
441
/*
442
 *      SC26198 uart specific handling functions.
443
 */
444
static void     stl_sc26198setreg(struct stlport *portp, int regnr, int value);
445
static int      stl_sc26198getreg(struct stlport *portp, int regnr);
446
static int      stl_sc26198updatereg(struct stlport *portp, int regnr, int value);
447
static int      stl_sc26198getglobreg(struct stlport *portp, int regnr);
448
static int      stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
449
static void     stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
450
static void     stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp);
451
static int      stl_sc26198getsignals(struct stlport *portp);
452
static void     stl_sc26198setsignals(struct stlport *portp, int dtr, int rts);
453
static void     stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx);
454
static void     stl_sc26198startrxtx(struct stlport *portp, int rx, int tx);
455
static void     stl_sc26198disableintrs(struct stlport *portp);
456
static void     stl_sc26198sendbreak(struct stlport *portp, int len);
457
static void     stl_sc26198flowctrl(struct stlport *portp, int state);
458
static void     stl_sc26198sendflow(struct stlport *portp, int state);
459
static void     stl_sc26198flush(struct stlport *portp);
460
static int      stl_sc26198datastate(struct stlport *portp);
461
static void     stl_sc26198wait(struct stlport *portp);
462
static void     stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty);
463
static void     stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase);
464
static void     stl_sc26198txisr(struct stlport *port);
465
static void     stl_sc26198rxisr(struct stlport *port, unsigned int iack);
466
static void     stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch);
467
static void     stl_sc26198rxbadchars(struct stlport *portp);
468
static void     stl_sc26198otherisr(struct stlport *port, unsigned int iack);
469
 
470
/*****************************************************************************/
471
 
472
/*
473
 *      Generic UART support structure.
474
 */
475
typedef struct uart {
476
        int     (*panelinit)(struct stlbrd *brdp, struct stlpanel *panelp);
477
        void    (*portinit)(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
478
        void    (*setport)(struct stlport *portp, struct ktermios *tiosp);
479
        int     (*getsignals)(struct stlport *portp);
480
        void    (*setsignals)(struct stlport *portp, int dtr, int rts);
481
        void    (*enablerxtx)(struct stlport *portp, int rx, int tx);
482
        void    (*startrxtx)(struct stlport *portp, int rx, int tx);
483
        void    (*disableintrs)(struct stlport *portp);
484
        void    (*sendbreak)(struct stlport *portp, int len);
485
        void    (*flowctrl)(struct stlport *portp, int state);
486
        void    (*sendflow)(struct stlport *portp, int state);
487
        void    (*flush)(struct stlport *portp);
488
        int     (*datastate)(struct stlport *portp);
489
        void    (*intr)(struct stlpanel *panelp, unsigned int iobase);
490
} uart_t;
491
 
492
/*
493
 *      Define some macros to make calling these functions nice and clean.
494
 */
495
#define stl_panelinit           (* ((uart_t *) panelp->uartp)->panelinit)
496
#define stl_portinit            (* ((uart_t *) portp->uartp)->portinit)
497
#define stl_setport             (* ((uart_t *) portp->uartp)->setport)
498
#define stl_getsignals          (* ((uart_t *) portp->uartp)->getsignals)
499
#define stl_setsignals          (* ((uart_t *) portp->uartp)->setsignals)
500
#define stl_enablerxtx          (* ((uart_t *) portp->uartp)->enablerxtx)
501
#define stl_startrxtx           (* ((uart_t *) portp->uartp)->startrxtx)
502
#define stl_disableintrs        (* ((uart_t *) portp->uartp)->disableintrs)
503
#define stl_sendbreak           (* ((uart_t *) portp->uartp)->sendbreak)
504
#define stl_flowctrl            (* ((uart_t *) portp->uartp)->flowctrl)
505
#define stl_sendflow            (* ((uart_t *) portp->uartp)->sendflow)
506
#define stl_flush               (* ((uart_t *) portp->uartp)->flush)
507
#define stl_datastate           (* ((uart_t *) portp->uartp)->datastate)
508
 
509
/*****************************************************************************/
510
 
511
/*
512
 *      CD1400 UART specific data initialization.
513
 */
514
static uart_t stl_cd1400uart = {
515
        stl_cd1400panelinit,
516
        stl_cd1400portinit,
517
        stl_cd1400setport,
518
        stl_cd1400getsignals,
519
        stl_cd1400setsignals,
520
        stl_cd1400enablerxtx,
521
        stl_cd1400startrxtx,
522
        stl_cd1400disableintrs,
523
        stl_cd1400sendbreak,
524
        stl_cd1400flowctrl,
525
        stl_cd1400sendflow,
526
        stl_cd1400flush,
527
        stl_cd1400datastate,
528
        stl_cd1400eiointr
529
};
530
 
531
/*
532
 *      Define the offsets within the register bank of a cd1400 based panel.
533
 *      These io address offsets are common to the EasyIO board as well.
534
 */
535
#define EREG_ADDR       0
536
#define EREG_DATA       4
537
#define EREG_RXACK      5
538
#define EREG_TXACK      6
539
#define EREG_MDACK      7
540
 
541
#define EREG_BANKSIZE   8
542
 
543
#define CD1400_CLK      25000000
544
#define CD1400_CLK8M    20000000
545
 
546
/*
547
 *      Define the cd1400 baud rate clocks. These are used when calculating
548
 *      what clock and divisor to use for the required baud rate. Also
549
 *      define the maximum baud rate allowed, and the default base baud.
550
 */
551
static int      stl_cd1400clkdivs[] = {
552
        CD1400_CLK0, CD1400_CLK1, CD1400_CLK2, CD1400_CLK3, CD1400_CLK4
553
};
554
 
555
/*****************************************************************************/
556
 
557
/*
558
 *      SC26198 UART specific data initization.
559
 */
560
static uart_t stl_sc26198uart = {
561
        stl_sc26198panelinit,
562
        stl_sc26198portinit,
563
        stl_sc26198setport,
564
        stl_sc26198getsignals,
565
        stl_sc26198setsignals,
566
        stl_sc26198enablerxtx,
567
        stl_sc26198startrxtx,
568
        stl_sc26198disableintrs,
569
        stl_sc26198sendbreak,
570
        stl_sc26198flowctrl,
571
        stl_sc26198sendflow,
572
        stl_sc26198flush,
573
        stl_sc26198datastate,
574
        stl_sc26198intr
575
};
576
 
577
/*
578
 *      Define the offsets within the register bank of a sc26198 based panel.
579
 */
580
#define XP_DATA         0
581
#define XP_ADDR         1
582
#define XP_MODID        2
583
#define XP_STATUS       2
584
#define XP_IACK         3
585
 
586
#define XP_BANKSIZE     4
587
 
588
/*
589
 *      Define the sc26198 baud rate table. Offsets within the table
590
 *      represent the actual baud rate selector of sc26198 registers.
591
 */
592
static unsigned int     sc26198_baudtable[] = {
593
        50, 75, 150, 200, 300, 450, 600, 900, 1200, 1800, 2400, 3600,
594
        4800, 7200, 9600, 14400, 19200, 28800, 38400, 57600, 115200,
595
        230400, 460800, 921600
596
};
597
 
598
#define SC26198_NRBAUDS         ARRAY_SIZE(sc26198_baudtable)
599
 
600
/*****************************************************************************/
601
 
602
/*
603
 *      Define the driver info for a user level control device. Used mainly
604
 *      to get at port stats - only not using the port device itself.
605
 */
606
static const struct file_operations     stl_fsiomem = {
607
        .owner          = THIS_MODULE,
608
        .ioctl          = stl_memioctl,
609
};
610
 
611
static struct class *stallion_class;
612
 
613
/*
614
 *      Check for any arguments passed in on the module load command line.
615
 */
616
 
617
/*****************************************************************************/
618
 
619
/*
620
 *      Parse the supplied argument string, into the board conf struct.
621
 */
622
 
623
static int __init stl_parsebrd(struct stlconf *confp, char **argp)
624
{
625
        char    *sp;
626
        unsigned int i;
627
 
628
        pr_debug("stl_parsebrd(confp=%p,argp=%p)\n", confp, argp);
629
 
630
        if ((argp[0] == NULL) || (*argp[0] == 0))
631
                return 0;
632
 
633
        for (sp = argp[0], i = 0; (*sp != 0) && (i < 25); sp++, i++)
634
                *sp = tolower(*sp);
635
 
636
        for (i = 0; i < ARRAY_SIZE(stl_brdstr); i++)
637
                if (strcmp(stl_brdstr[i].name, argp[0]) == 0)
638
                        break;
639
 
640
        if (i == ARRAY_SIZE(stl_brdstr)) {
641
                printk("STALLION: unknown board name, %s?\n", argp[0]);
642
                return 0;
643
        }
644
 
645
        confp->brdtype = stl_brdstr[i].type;
646
 
647
        i = 1;
648
        if ((argp[i] != NULL) && (*argp[i] != 0))
649
                confp->ioaddr1 = simple_strtoul(argp[i], NULL, 0);
650
        i++;
651
        if (confp->brdtype == BRD_ECH) {
652
                if ((argp[i] != NULL) && (*argp[i] != 0))
653
                        confp->ioaddr2 = simple_strtoul(argp[i], NULL, 0);
654
                i++;
655
        }
656
        if ((argp[i] != NULL) && (*argp[i] != 0))
657
                confp->irq = simple_strtoul(argp[i], NULL, 0);
658
        return 1;
659
}
660
 
661
/*****************************************************************************/
662
 
663
/*
664
 *      Allocate a new board structure. Fill out the basic info in it.
665
 */
666
 
667
static struct stlbrd *stl_allocbrd(void)
668
{
669
        struct stlbrd   *brdp;
670
 
671
        brdp = kzalloc(sizeof(struct stlbrd), GFP_KERNEL);
672
        if (!brdp) {
673
                printk("STALLION: failed to allocate memory (size=%Zd)\n",
674
                        sizeof(struct stlbrd));
675
                return NULL;
676
        }
677
 
678
        brdp->magic = STL_BOARDMAGIC;
679
        return brdp;
680
}
681
 
682
/*****************************************************************************/
683
 
684
static int stl_open(struct tty_struct *tty, struct file *filp)
685
{
686
        struct stlport  *portp;
687
        struct stlbrd   *brdp;
688
        unsigned int    minordev, brdnr, panelnr;
689
        int             portnr, rc;
690
 
691
        pr_debug("stl_open(tty=%p,filp=%p): device=%s\n", tty, filp, tty->name);
692
 
693
        minordev = tty->index;
694
        brdnr = MINOR2BRD(minordev);
695
        if (brdnr >= stl_nrbrds)
696
                return -ENODEV;
697
        brdp = stl_brds[brdnr];
698
        if (brdp == NULL)
699
                return -ENODEV;
700
        minordev = MINOR2PORT(minordev);
701
        for (portnr = -1, panelnr = 0; panelnr < STL_MAXPANELS; panelnr++) {
702
                if (brdp->panels[panelnr] == NULL)
703
                        break;
704
                if (minordev < brdp->panels[panelnr]->nrports) {
705
                        portnr = minordev;
706
                        break;
707
                }
708
                minordev -= brdp->panels[panelnr]->nrports;
709
        }
710
        if (portnr < 0)
711
                return -ENODEV;
712
 
713
        portp = brdp->panels[panelnr]->ports[portnr];
714
        if (portp == NULL)
715
                return -ENODEV;
716
 
717
/*
718
 *      On the first open of the device setup the port hardware, and
719
 *      initialize the per port data structure.
720
 */
721
        portp->tty = tty;
722
        tty->driver_data = portp;
723
        portp->refcount++;
724
 
725
        if ((portp->flags & ASYNC_INITIALIZED) == 0) {
726
                if (!portp->tx.buf) {
727
                        portp->tx.buf = kmalloc(STL_TXBUFSIZE, GFP_KERNEL);
728
                        if (!portp->tx.buf)
729
                                return -ENOMEM;
730
                        portp->tx.head = portp->tx.buf;
731
                        portp->tx.tail = portp->tx.buf;
732
                }
733
                stl_setport(portp, tty->termios);
734
                portp->sigs = stl_getsignals(portp);
735
                stl_setsignals(portp, 1, 1);
736
                stl_enablerxtx(portp, 1, 1);
737
                stl_startrxtx(portp, 1, 0);
738
                clear_bit(TTY_IO_ERROR, &tty->flags);
739
                portp->flags |= ASYNC_INITIALIZED;
740
        }
741
 
742
/*
743
 *      Check if this port is in the middle of closing. If so then wait
744
 *      until it is closed then return error status, based on flag settings.
745
 *      The sleep here does not need interrupt protection since the wakeup
746
 *      for it is done with the same context.
747
 */
748
        if (portp->flags & ASYNC_CLOSING) {
749
                interruptible_sleep_on(&portp->close_wait);
750
                if (portp->flags & ASYNC_HUP_NOTIFY)
751
                        return -EAGAIN;
752
                return -ERESTARTSYS;
753
        }
754
 
755
/*
756
 *      Based on type of open being done check if it can overlap with any
757
 *      previous opens still in effect. If we are a normal serial device
758
 *      then also we might have to wait for carrier.
759
 */
760
        if (!(filp->f_flags & O_NONBLOCK))
761
                if ((rc = stl_waitcarrier(portp, filp)) != 0)
762
                        return rc;
763
 
764
        portp->flags |= ASYNC_NORMAL_ACTIVE;
765
 
766
        return 0;
767
}
768
 
769
/*****************************************************************************/
770
 
771
/*
772
 *      Possibly need to wait for carrier (DCD signal) to come high. Say
773
 *      maybe because if we are clocal then we don't need to wait...
774
 */
775
 
776
static int stl_waitcarrier(struct stlport *portp, struct file *filp)
777
{
778
        unsigned long   flags;
779
        int             rc, doclocal;
780
 
781
        pr_debug("stl_waitcarrier(portp=%p,filp=%p)\n", portp, filp);
782
 
783
        rc = 0;
784
        doclocal = 0;
785
 
786
        spin_lock_irqsave(&stallion_lock, flags);
787
 
788
        if (portp->tty->termios->c_cflag & CLOCAL)
789
                doclocal++;
790
 
791
        portp->openwaitcnt++;
792
        if (! tty_hung_up_p(filp))
793
                portp->refcount--;
794
 
795
        for (;;) {
796
                /* Takes brd_lock internally */
797
                stl_setsignals(portp, 1, 1);
798
                if (tty_hung_up_p(filp) ||
799
                    ((portp->flags & ASYNC_INITIALIZED) == 0)) {
800
                        if (portp->flags & ASYNC_HUP_NOTIFY)
801
                                rc = -EBUSY;
802
                        else
803
                                rc = -ERESTARTSYS;
804
                        break;
805
                }
806
                if (((portp->flags & ASYNC_CLOSING) == 0) &&
807
                    (doclocal || (portp->sigs & TIOCM_CD)))
808
                        break;
809
                if (signal_pending(current)) {
810
                        rc = -ERESTARTSYS;
811
                        break;
812
                }
813
                /* FIXME */
814
                interruptible_sleep_on(&portp->open_wait);
815
        }
816
 
817
        if (! tty_hung_up_p(filp))
818
                portp->refcount++;
819
        portp->openwaitcnt--;
820
        spin_unlock_irqrestore(&stallion_lock, flags);
821
 
822
        return rc;
823
}
824
 
825
/*****************************************************************************/
826
 
827
static void stl_flushbuffer(struct tty_struct *tty)
828
{
829
        struct stlport  *portp;
830
 
831
        pr_debug("stl_flushbuffer(tty=%p)\n", tty);
832
 
833
        if (tty == NULL)
834
                return;
835
        portp = tty->driver_data;
836
        if (portp == NULL)
837
                return;
838
 
839
        stl_flush(portp);
840
        tty_wakeup(tty);
841
}
842
 
843
/*****************************************************************************/
844
 
845
static void stl_waituntilsent(struct tty_struct *tty, int timeout)
846
{
847
        struct stlport  *portp;
848
        unsigned long   tend;
849
 
850
        pr_debug("stl_waituntilsent(tty=%p,timeout=%d)\n", tty, timeout);
851
 
852
        if (tty == NULL)
853
                return;
854
        portp = tty->driver_data;
855
        if (portp == NULL)
856
                return;
857
 
858
        if (timeout == 0)
859
                timeout = HZ;
860
        tend = jiffies + timeout;
861
 
862
        while (stl_datastate(portp)) {
863
                if (signal_pending(current))
864
                        break;
865
                msleep_interruptible(20);
866
                if (time_after_eq(jiffies, tend))
867
                        break;
868
        }
869
}
870
 
871
/*****************************************************************************/
872
 
873
static void stl_close(struct tty_struct *tty, struct file *filp)
874
{
875
        struct stlport  *portp;
876
        unsigned long   flags;
877
 
878
        pr_debug("stl_close(tty=%p,filp=%p)\n", tty, filp);
879
 
880
        portp = tty->driver_data;
881
        if (portp == NULL)
882
                return;
883
 
884
        spin_lock_irqsave(&stallion_lock, flags);
885
        if (tty_hung_up_p(filp)) {
886
                spin_unlock_irqrestore(&stallion_lock, flags);
887
                return;
888
        }
889
        if ((tty->count == 1) && (portp->refcount != 1))
890
                portp->refcount = 1;
891
        if (portp->refcount-- > 1) {
892
                spin_unlock_irqrestore(&stallion_lock, flags);
893
                return;
894
        }
895
 
896
        portp->refcount = 0;
897
        portp->flags |= ASYNC_CLOSING;
898
 
899
/*
900
 *      May want to wait for any data to drain before closing. The BUSY
901
 *      flag keeps track of whether we are still sending or not - it is
902
 *      very accurate for the cd1400, not quite so for the sc26198.
903
 *      (The sc26198 has no "end-of-data" interrupt only empty FIFO)
904
 */
905
        tty->closing = 1;
906
 
907
        spin_unlock_irqrestore(&stallion_lock, flags);
908
 
909
        if (portp->closing_wait != ASYNC_CLOSING_WAIT_NONE)
910
                tty_wait_until_sent(tty, portp->closing_wait);
911
        stl_waituntilsent(tty, (HZ / 2));
912
 
913
 
914
        spin_lock_irqsave(&stallion_lock, flags);
915
        portp->flags &= ~ASYNC_INITIALIZED;
916
        spin_unlock_irqrestore(&stallion_lock, flags);
917
 
918
        stl_disableintrs(portp);
919
        if (tty->termios->c_cflag & HUPCL)
920
                stl_setsignals(portp, 0, 0);
921
        stl_enablerxtx(portp, 0, 0);
922
        stl_flushbuffer(tty);
923
        portp->istate = 0;
924
        if (portp->tx.buf != NULL) {
925
                kfree(portp->tx.buf);
926
                portp->tx.buf = NULL;
927
                portp->tx.head = NULL;
928
                portp->tx.tail = NULL;
929
        }
930
        set_bit(TTY_IO_ERROR, &tty->flags);
931
        tty_ldisc_flush(tty);
932
 
933
        tty->closing = 0;
934
        portp->tty = NULL;
935
 
936
        if (portp->openwaitcnt) {
937
                if (portp->close_delay)
938
                        msleep_interruptible(jiffies_to_msecs(portp->close_delay));
939
                wake_up_interruptible(&portp->open_wait);
940
        }
941
 
942
        portp->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
943
        wake_up_interruptible(&portp->close_wait);
944
}
945
 
946
/*****************************************************************************/
947
 
948
/*
949
 *      Write routine. Take data and stuff it in to the TX ring queue.
950
 *      If transmit interrupts are not running then start them.
951
 */
952
 
953
static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count)
954
{
955
        struct stlport  *portp;
956
        unsigned int    len, stlen;
957
        unsigned char   *chbuf;
958
        char            *head, *tail;
959
 
960
        pr_debug("stl_write(tty=%p,buf=%p,count=%d)\n", tty, buf, count);
961
 
962
        portp = tty->driver_data;
963
        if (portp == NULL)
964
                return 0;
965
        if (portp->tx.buf == NULL)
966
                return 0;
967
 
968
/*
969
 *      If copying direct from user space we must cater for page faults,
970
 *      causing us to "sleep" here for a while. To handle this copy in all
971
 *      the data we need now, into a local buffer. Then when we got it all
972
 *      copy it into the TX buffer.
973
 */
974
        chbuf = (unsigned char *) buf;
975
 
976
        head = portp->tx.head;
977
        tail = portp->tx.tail;
978
        if (head >= tail) {
979
                len = STL_TXBUFSIZE - (head - tail) - 1;
980
                stlen = STL_TXBUFSIZE - (head - portp->tx.buf);
981
        } else {
982
                len = tail - head - 1;
983
                stlen = len;
984
        }
985
 
986
        len = min(len, (unsigned int)count);
987
        count = 0;
988
        while (len > 0) {
989
                stlen = min(len, stlen);
990
                memcpy(head, chbuf, stlen);
991
                len -= stlen;
992
                chbuf += stlen;
993
                count += stlen;
994
                head += stlen;
995
                if (head >= (portp->tx.buf + STL_TXBUFSIZE)) {
996
                        head = portp->tx.buf;
997
                        stlen = tail - head;
998
                }
999
        }
1000
        portp->tx.head = head;
1001
 
1002
        clear_bit(ASYI_TXLOW, &portp->istate);
1003
        stl_startrxtx(portp, -1, 1);
1004
 
1005
        return count;
1006
}
1007
 
1008
/*****************************************************************************/
1009
 
1010
static void stl_putchar(struct tty_struct *tty, unsigned char ch)
1011
{
1012
        struct stlport  *portp;
1013
        unsigned int    len;
1014
        char            *head, *tail;
1015
 
1016
        pr_debug("stl_putchar(tty=%p,ch=%x)\n", tty, ch);
1017
 
1018
        if (tty == NULL)
1019
                return;
1020
        portp = tty->driver_data;
1021
        if (portp == NULL)
1022
                return;
1023
        if (portp->tx.buf == NULL)
1024
                return;
1025
 
1026
        head = portp->tx.head;
1027
        tail = portp->tx.tail;
1028
 
1029
        len = (head >= tail) ? (STL_TXBUFSIZE - (head - tail)) : (tail - head);
1030
        len--;
1031
 
1032
        if (len > 0) {
1033
                *head++ = ch;
1034
                if (head >= (portp->tx.buf + STL_TXBUFSIZE))
1035
                        head = portp->tx.buf;
1036
        }
1037
        portp->tx.head = head;
1038
}
1039
 
1040
/*****************************************************************************/
1041
 
1042
/*
1043
 *      If there are any characters in the buffer then make sure that TX
1044
 *      interrupts are on and get'em out. Normally used after the putchar
1045
 *      routine has been called.
1046
 */
1047
 
1048
static void stl_flushchars(struct tty_struct *tty)
1049
{
1050
        struct stlport  *portp;
1051
 
1052
        pr_debug("stl_flushchars(tty=%p)\n", tty);
1053
 
1054
        if (tty == NULL)
1055
                return;
1056
        portp = tty->driver_data;
1057
        if (portp == NULL)
1058
                return;
1059
        if (portp->tx.buf == NULL)
1060
                return;
1061
 
1062
        stl_startrxtx(portp, -1, 1);
1063
}
1064
 
1065
/*****************************************************************************/
1066
 
1067
static int stl_writeroom(struct tty_struct *tty)
1068
{
1069
        struct stlport  *portp;
1070
        char            *head, *tail;
1071
 
1072
        pr_debug("stl_writeroom(tty=%p)\n", tty);
1073
 
1074
        if (tty == NULL)
1075
                return 0;
1076
        portp = tty->driver_data;
1077
        if (portp == NULL)
1078
                return 0;
1079
        if (portp->tx.buf == NULL)
1080
                return 0;
1081
 
1082
        head = portp->tx.head;
1083
        tail = portp->tx.tail;
1084
        return (head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1);
1085
}
1086
 
1087
/*****************************************************************************/
1088
 
1089
/*
1090
 *      Return number of chars in the TX buffer. Normally we would just
1091
 *      calculate the number of chars in the buffer and return that, but if
1092
 *      the buffer is empty and TX interrupts are still on then we return
1093
 *      that the buffer still has 1 char in it. This way whoever called us
1094
 *      will not think that ALL chars have drained - since the UART still
1095
 *      must have some chars in it (we are busy after all).
1096
 */
1097
 
1098
static int stl_charsinbuffer(struct tty_struct *tty)
1099
{
1100
        struct stlport  *portp;
1101
        unsigned int    size;
1102
        char            *head, *tail;
1103
 
1104
        pr_debug("stl_charsinbuffer(tty=%p)\n", tty);
1105
 
1106
        if (tty == NULL)
1107
                return 0;
1108
        portp = tty->driver_data;
1109
        if (portp == NULL)
1110
                return 0;
1111
        if (portp->tx.buf == NULL)
1112
                return 0;
1113
 
1114
        head = portp->tx.head;
1115
        tail = portp->tx.tail;
1116
        size = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
1117
        if ((size == 0) && test_bit(ASYI_TXBUSY, &portp->istate))
1118
                size = 1;
1119
        return size;
1120
}
1121
 
1122
/*****************************************************************************/
1123
 
1124
/*
1125
 *      Generate the serial struct info.
1126
 */
1127
 
1128
static int stl_getserial(struct stlport *portp, struct serial_struct __user *sp)
1129
{
1130
        struct serial_struct    sio;
1131
        struct stlbrd           *brdp;
1132
 
1133
        pr_debug("stl_getserial(portp=%p,sp=%p)\n", portp, sp);
1134
 
1135
        memset(&sio, 0, sizeof(struct serial_struct));
1136
        sio.line = portp->portnr;
1137
        sio.port = portp->ioaddr;
1138
        sio.flags = portp->flags;
1139
        sio.baud_base = portp->baud_base;
1140
        sio.close_delay = portp->close_delay;
1141
        sio.closing_wait = portp->closing_wait;
1142
        sio.custom_divisor = portp->custom_divisor;
1143
        sio.hub6 = 0;
1144
        if (portp->uartp == &stl_cd1400uart) {
1145
                sio.type = PORT_CIRRUS;
1146
                sio.xmit_fifo_size = CD1400_TXFIFOSIZE;
1147
        } else {
1148
                sio.type = PORT_UNKNOWN;
1149
                sio.xmit_fifo_size = SC26198_TXFIFOSIZE;
1150
        }
1151
 
1152
        brdp = stl_brds[portp->brdnr];
1153
        if (brdp != NULL)
1154
                sio.irq = brdp->irq;
1155
 
1156
        return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ? -EFAULT : 0;
1157
}
1158
 
1159
/*****************************************************************************/
1160
 
1161
/*
1162
 *      Set port according to the serial struct info.
1163
 *      At this point we do not do any auto-configure stuff, so we will
1164
 *      just quietly ignore any requests to change irq, etc.
1165
 */
1166
 
1167
static int stl_setserial(struct stlport *portp, struct serial_struct __user *sp)
1168
{
1169
        struct serial_struct    sio;
1170
 
1171
        pr_debug("stl_setserial(portp=%p,sp=%p)\n", portp, sp);
1172
 
1173
        if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
1174
                return -EFAULT;
1175
        if (!capable(CAP_SYS_ADMIN)) {
1176
                if ((sio.baud_base != portp->baud_base) ||
1177
                    (sio.close_delay != portp->close_delay) ||
1178
                    ((sio.flags & ~ASYNC_USR_MASK) !=
1179
                    (portp->flags & ~ASYNC_USR_MASK)))
1180
                        return -EPERM;
1181
        }
1182
 
1183
        portp->flags = (portp->flags & ~ASYNC_USR_MASK) |
1184
                (sio.flags & ASYNC_USR_MASK);
1185
        portp->baud_base = sio.baud_base;
1186
        portp->close_delay = sio.close_delay;
1187
        portp->closing_wait = sio.closing_wait;
1188
        portp->custom_divisor = sio.custom_divisor;
1189
        stl_setport(portp, portp->tty->termios);
1190
        return 0;
1191
}
1192
 
1193
/*****************************************************************************/
1194
 
1195
static int stl_tiocmget(struct tty_struct *tty, struct file *file)
1196
{
1197
        struct stlport  *portp;
1198
 
1199
        if (tty == NULL)
1200
                return -ENODEV;
1201
        portp = tty->driver_data;
1202
        if (portp == NULL)
1203
                return -ENODEV;
1204
        if (tty->flags & (1 << TTY_IO_ERROR))
1205
                return -EIO;
1206
 
1207
        return stl_getsignals(portp);
1208
}
1209
 
1210
static int stl_tiocmset(struct tty_struct *tty, struct file *file,
1211
                        unsigned int set, unsigned int clear)
1212
{
1213
        struct stlport  *portp;
1214
        int rts = -1, dtr = -1;
1215
 
1216
        if (tty == NULL)
1217
                return -ENODEV;
1218
        portp = tty->driver_data;
1219
        if (portp == NULL)
1220
                return -ENODEV;
1221
        if (tty->flags & (1 << TTY_IO_ERROR))
1222
                return -EIO;
1223
 
1224
        if (set & TIOCM_RTS)
1225
                rts = 1;
1226
        if (set & TIOCM_DTR)
1227
                dtr = 1;
1228
        if (clear & TIOCM_RTS)
1229
                rts = 0;
1230
        if (clear & TIOCM_DTR)
1231
                dtr = 0;
1232
 
1233
        stl_setsignals(portp, dtr, rts);
1234
        return 0;
1235
}
1236
 
1237
static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1238
{
1239
        struct stlport  *portp;
1240
        unsigned int    ival;
1241
        int             rc;
1242
        void __user *argp = (void __user *)arg;
1243
 
1244
        pr_debug("stl_ioctl(tty=%p,file=%p,cmd=%x,arg=%lx)\n", tty, file, cmd,
1245
                        arg);
1246
 
1247
        if (tty == NULL)
1248
                return -ENODEV;
1249
        portp = tty->driver_data;
1250
        if (portp == NULL)
1251
                return -ENODEV;
1252
 
1253
        if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1254
            (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS))
1255
                if (tty->flags & (1 << TTY_IO_ERROR))
1256
                        return -EIO;
1257
 
1258
        rc = 0;
1259
 
1260
        switch (cmd) {
1261
        case TIOCGSOFTCAR:
1262
                rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
1263
                        (unsigned __user *) argp);
1264
                break;
1265
        case TIOCSSOFTCAR:
1266
                if (get_user(ival, (unsigned int __user *) arg))
1267
                        return -EFAULT;
1268
                tty->termios->c_cflag =
1269
                                (tty->termios->c_cflag & ~CLOCAL) |
1270
                                (ival ? CLOCAL : 0);
1271
                break;
1272
        case TIOCGSERIAL:
1273
                rc = stl_getserial(portp, argp);
1274
                break;
1275
        case TIOCSSERIAL:
1276
                rc = stl_setserial(portp, argp);
1277
                break;
1278
        case COM_GETPORTSTATS:
1279
                rc = stl_getportstats(portp, argp);
1280
                break;
1281
        case COM_CLRPORTSTATS:
1282
                rc = stl_clrportstats(portp, argp);
1283
                break;
1284
        case TIOCSERCONFIG:
1285
        case TIOCSERGWILD:
1286
        case TIOCSERSWILD:
1287
        case TIOCSERGETLSR:
1288
        case TIOCSERGSTRUCT:
1289
        case TIOCSERGETMULTI:
1290
        case TIOCSERSETMULTI:
1291
        default:
1292
                rc = -ENOIOCTLCMD;
1293
                break;
1294
        }
1295
 
1296
        return rc;
1297
}
1298
 
1299
/*****************************************************************************/
1300
 
1301
/*
1302
 *      Start the transmitter again. Just turn TX interrupts back on.
1303
 */
1304
 
1305
static void stl_start(struct tty_struct *tty)
1306
{
1307
        struct stlport  *portp;
1308
 
1309
        pr_debug("stl_start(tty=%p)\n", tty);
1310
 
1311
        if (tty == NULL)
1312
                return;
1313
        portp = tty->driver_data;
1314
        if (portp == NULL)
1315
                return;
1316
        stl_startrxtx(portp, -1, 1);
1317
}
1318
 
1319
/*****************************************************************************/
1320
 
1321
static void stl_settermios(struct tty_struct *tty, struct ktermios *old)
1322
{
1323
        struct stlport  *portp;
1324
        struct ktermios *tiosp;
1325
 
1326
        pr_debug("stl_settermios(tty=%p,old=%p)\n", tty, old);
1327
 
1328
        if (tty == NULL)
1329
                return;
1330
        portp = tty->driver_data;
1331
        if (portp == NULL)
1332
                return;
1333
 
1334
        tiosp = tty->termios;
1335
        if ((tiosp->c_cflag == old->c_cflag) &&
1336
            (tiosp->c_iflag == old->c_iflag))
1337
                return;
1338
 
1339
        stl_setport(portp, tiosp);
1340
        stl_setsignals(portp, ((tiosp->c_cflag & (CBAUD & ~CBAUDEX)) ? 1 : 0),
1341
                -1);
1342
        if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0)) {
1343
                tty->hw_stopped = 0;
1344
                stl_start(tty);
1345
        }
1346
        if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL))
1347
                wake_up_interruptible(&portp->open_wait);
1348
}
1349
 
1350
/*****************************************************************************/
1351
 
1352
/*
1353
 *      Attempt to flow control who ever is sending us data. Based on termios
1354
 *      settings use software or/and hardware flow control.
1355
 */
1356
 
1357
static void stl_throttle(struct tty_struct *tty)
1358
{
1359
        struct stlport  *portp;
1360
 
1361
        pr_debug("stl_throttle(tty=%p)\n", tty);
1362
 
1363
        if (tty == NULL)
1364
                return;
1365
        portp = tty->driver_data;
1366
        if (portp == NULL)
1367
                return;
1368
        stl_flowctrl(portp, 0);
1369
}
1370
 
1371
/*****************************************************************************/
1372
 
1373
/*
1374
 *      Unflow control the device sending us data...
1375
 */
1376
 
1377
static void stl_unthrottle(struct tty_struct *tty)
1378
{
1379
        struct stlport  *portp;
1380
 
1381
        pr_debug("stl_unthrottle(tty=%p)\n", tty);
1382
 
1383
        if (tty == NULL)
1384
                return;
1385
        portp = tty->driver_data;
1386
        if (portp == NULL)
1387
                return;
1388
        stl_flowctrl(portp, 1);
1389
}
1390
 
1391
/*****************************************************************************/
1392
 
1393
/*
1394
 *      Stop the transmitter. Basically to do this we will just turn TX
1395
 *      interrupts off.
1396
 */
1397
 
1398
static void stl_stop(struct tty_struct *tty)
1399
{
1400
        struct stlport  *portp;
1401
 
1402
        pr_debug("stl_stop(tty=%p)\n", tty);
1403
 
1404
        if (tty == NULL)
1405
                return;
1406
        portp = tty->driver_data;
1407
        if (portp == NULL)
1408
                return;
1409
        stl_startrxtx(portp, -1, 0);
1410
}
1411
 
1412
/*****************************************************************************/
1413
 
1414
/*
1415
 *      Hangup this port. This is pretty much like closing the port, only
1416
 *      a little more brutal. No waiting for data to drain. Shutdown the
1417
 *      port and maybe drop signals.
1418
 */
1419
 
1420
static void stl_hangup(struct tty_struct *tty)
1421
{
1422
        struct stlport  *portp;
1423
 
1424
        pr_debug("stl_hangup(tty=%p)\n", tty);
1425
 
1426
        if (tty == NULL)
1427
                return;
1428
        portp = tty->driver_data;
1429
        if (portp == NULL)
1430
                return;
1431
 
1432
        portp->flags &= ~ASYNC_INITIALIZED;
1433
        stl_disableintrs(portp);
1434
        if (tty->termios->c_cflag & HUPCL)
1435
                stl_setsignals(portp, 0, 0);
1436
        stl_enablerxtx(portp, 0, 0);
1437
        stl_flushbuffer(tty);
1438
        portp->istate = 0;
1439
        set_bit(TTY_IO_ERROR, &tty->flags);
1440
        if (portp->tx.buf != NULL) {
1441
                kfree(portp->tx.buf);
1442
                portp->tx.buf = NULL;
1443
                portp->tx.head = NULL;
1444
                portp->tx.tail = NULL;
1445
        }
1446
        portp->tty = NULL;
1447
        portp->flags &= ~ASYNC_NORMAL_ACTIVE;
1448
        portp->refcount = 0;
1449
        wake_up_interruptible(&portp->open_wait);
1450
}
1451
 
1452
/*****************************************************************************/
1453
 
1454
static void stl_breakctl(struct tty_struct *tty, int state)
1455
{
1456
        struct stlport  *portp;
1457
 
1458
        pr_debug("stl_breakctl(tty=%p,state=%d)\n", tty, state);
1459
 
1460
        if (tty == NULL)
1461
                return;
1462
        portp = tty->driver_data;
1463
        if (portp == NULL)
1464
                return;
1465
 
1466
        stl_sendbreak(portp, ((state == -1) ? 1 : 2));
1467
}
1468
 
1469
/*****************************************************************************/
1470
 
1471
static void stl_sendxchar(struct tty_struct *tty, char ch)
1472
{
1473
        struct stlport  *portp;
1474
 
1475
        pr_debug("stl_sendxchar(tty=%p,ch=%x)\n", tty, ch);
1476
 
1477
        if (tty == NULL)
1478
                return;
1479
        portp = tty->driver_data;
1480
        if (portp == NULL)
1481
                return;
1482
 
1483
        if (ch == STOP_CHAR(tty))
1484
                stl_sendflow(portp, 0);
1485
        else if (ch == START_CHAR(tty))
1486
                stl_sendflow(portp, 1);
1487
        else
1488
                stl_putchar(tty, ch);
1489
}
1490
 
1491
/*****************************************************************************/
1492
 
1493
#define MAXLINE         80
1494
 
1495
/*
1496
 *      Format info for a specified port. The line is deliberately limited
1497
 *      to 80 characters. (If it is too long it will be truncated, if too
1498
 *      short then padded with spaces).
1499
 */
1500
 
1501
static int stl_portinfo(struct stlport *portp, int portnr, char *pos)
1502
{
1503
        char    *sp;
1504
        int     sigs, cnt;
1505
 
1506
        sp = pos;
1507
        sp += sprintf(sp, "%d: uart:%s tx:%d rx:%d",
1508
                portnr, (portp->hwid == 1) ? "SC26198" : "CD1400",
1509
                (int) portp->stats.txtotal, (int) portp->stats.rxtotal);
1510
 
1511
        if (portp->stats.rxframing)
1512
                sp += sprintf(sp, " fe:%d", (int) portp->stats.rxframing);
1513
        if (portp->stats.rxparity)
1514
                sp += sprintf(sp, " pe:%d", (int) portp->stats.rxparity);
1515
        if (portp->stats.rxbreaks)
1516
                sp += sprintf(sp, " brk:%d", (int) portp->stats.rxbreaks);
1517
        if (portp->stats.rxoverrun)
1518
                sp += sprintf(sp, " oe:%d", (int) portp->stats.rxoverrun);
1519
 
1520
        sigs = stl_getsignals(portp);
1521
        cnt = sprintf(sp, "%s%s%s%s%s ",
1522
                (sigs & TIOCM_RTS) ? "|RTS" : "",
1523
                (sigs & TIOCM_CTS) ? "|CTS" : "",
1524
                (sigs & TIOCM_DTR) ? "|DTR" : "",
1525
                (sigs & TIOCM_CD) ? "|DCD" : "",
1526
                (sigs & TIOCM_DSR) ? "|DSR" : "");
1527
        *sp = ' ';
1528
        sp += cnt;
1529
 
1530
        for (cnt = sp - pos; cnt < (MAXLINE - 1); cnt++)
1531
                *sp++ = ' ';
1532
        if (cnt >= MAXLINE)
1533
                pos[(MAXLINE - 2)] = '+';
1534
        pos[(MAXLINE - 1)] = '\n';
1535
 
1536
        return MAXLINE;
1537
}
1538
 
1539
/*****************************************************************************/
1540
 
1541
/*
1542
 *      Port info, read from the /proc file system.
1543
 */
1544
 
1545
static int stl_readproc(char *page, char **start, off_t off, int count, int *eof, void *data)
1546
{
1547
        struct stlbrd   *brdp;
1548
        struct stlpanel *panelp;
1549
        struct stlport  *portp;
1550
        unsigned int    brdnr, panelnr, portnr;
1551
        int             totalport, curoff, maxoff;
1552
        char            *pos;
1553
 
1554
        pr_debug("stl_readproc(page=%p,start=%p,off=%lx,count=%d,eof=%p,"
1555
                "data=%p\n", page, start, off, count, eof, data);
1556
 
1557
        pos = page;
1558
        totalport = 0;
1559
        curoff = 0;
1560
 
1561
        if (off == 0) {
1562
                pos += sprintf(pos, "%s: version %s", stl_drvtitle,
1563
                        stl_drvversion);
1564
                while (pos < (page + MAXLINE - 1))
1565
                        *pos++ = ' ';
1566
                *pos++ = '\n';
1567
        }
1568
        curoff =  MAXLINE;
1569
 
1570
/*
1571
 *      We scan through for each board, panel and port. The offset is
1572
 *      calculated on the fly, and irrelevant ports are skipped.
1573
 */
1574
        for (brdnr = 0; brdnr < stl_nrbrds; brdnr++) {
1575
                brdp = stl_brds[brdnr];
1576
                if (brdp == NULL)
1577
                        continue;
1578
                if (brdp->state == 0)
1579
                        continue;
1580
 
1581
                maxoff = curoff + (brdp->nrports * MAXLINE);
1582
                if (off >= maxoff) {
1583
                        curoff = maxoff;
1584
                        continue;
1585
                }
1586
 
1587
                totalport = brdnr * STL_MAXPORTS;
1588
                for (panelnr = 0; panelnr < brdp->nrpanels; panelnr++) {
1589
                        panelp = brdp->panels[panelnr];
1590
                        if (panelp == NULL)
1591
                                continue;
1592
 
1593
                        maxoff = curoff + (panelp->nrports * MAXLINE);
1594
                        if (off >= maxoff) {
1595
                                curoff = maxoff;
1596
                                totalport += panelp->nrports;
1597
                                continue;
1598
                        }
1599
 
1600
                        for (portnr = 0; portnr < panelp->nrports; portnr++,
1601
                            totalport++) {
1602
                                portp = panelp->ports[portnr];
1603
                                if (portp == NULL)
1604
                                        continue;
1605
                                if (off >= (curoff += MAXLINE))
1606
                                        continue;
1607
                                if ((pos - page + MAXLINE) > count)
1608
                                        goto stl_readdone;
1609
                                pos += stl_portinfo(portp, totalport, pos);
1610
                        }
1611
                }
1612
        }
1613
 
1614
        *eof = 1;
1615
 
1616
stl_readdone:
1617
        *start = page;
1618
        return pos - page;
1619
}
1620
 
1621
/*****************************************************************************/
1622
 
1623
/*
1624
 *      All board interrupts are vectored through here first. This code then
1625
 *      calls off to the approrpriate board interrupt handlers.
1626
 */
1627
 
1628
static irqreturn_t stl_intr(int irq, void *dev_id)
1629
{
1630
        struct stlbrd *brdp = dev_id;
1631
 
1632
        pr_debug("stl_intr(brdp=%p,irq=%d)\n", brdp, irq);
1633
 
1634
        return IRQ_RETVAL((* brdp->isr)(brdp));
1635
}
1636
 
1637
/*****************************************************************************/
1638
 
1639
/*
1640
 *      Interrupt service routine for EasyIO board types.
1641
 */
1642
 
1643
static int stl_eiointr(struct stlbrd *brdp)
1644
{
1645
        struct stlpanel *panelp;
1646
        unsigned int    iobase;
1647
        int             handled = 0;
1648
 
1649
        spin_lock(&brd_lock);
1650
        panelp = brdp->panels[0];
1651
        iobase = panelp->iobase;
1652
        while (inb(brdp->iostatus) & EIO_INTRPEND) {
1653
                handled = 1;
1654
                (* panelp->isr)(panelp, iobase);
1655
        }
1656
        spin_unlock(&brd_lock);
1657
        return handled;
1658
}
1659
 
1660
/*****************************************************************************/
1661
 
1662
/*
1663
 *      Interrupt service routine for ECH-AT board types.
1664
 */
1665
 
1666
static int stl_echatintr(struct stlbrd *brdp)
1667
{
1668
        struct stlpanel *panelp;
1669
        unsigned int    ioaddr, bnknr;
1670
        int             handled = 0;
1671
 
1672
        outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
1673
 
1674
        while (inb(brdp->iostatus) & ECH_INTRPEND) {
1675
                handled = 1;
1676
                for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1677
                        ioaddr = brdp->bnkstataddr[bnknr];
1678
                        if (inb(ioaddr) & ECH_PNLINTRPEND) {
1679
                                panelp = brdp->bnk2panel[bnknr];
1680
                                (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1681
                        }
1682
                }
1683
        }
1684
 
1685
        outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl);
1686
 
1687
        return handled;
1688
}
1689
 
1690
/*****************************************************************************/
1691
 
1692
/*
1693
 *      Interrupt service routine for ECH-MCA board types.
1694
 */
1695
 
1696
static int stl_echmcaintr(struct stlbrd *brdp)
1697
{
1698
        struct stlpanel *panelp;
1699
        unsigned int    ioaddr, bnknr;
1700
        int             handled = 0;
1701
 
1702
        while (inb(brdp->iostatus) & ECH_INTRPEND) {
1703
                handled = 1;
1704
                for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1705
                        ioaddr = brdp->bnkstataddr[bnknr];
1706
                        if (inb(ioaddr) & ECH_PNLINTRPEND) {
1707
                                panelp = brdp->bnk2panel[bnknr];
1708
                                (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1709
                        }
1710
                }
1711
        }
1712
        return handled;
1713
}
1714
 
1715
/*****************************************************************************/
1716
 
1717
/*
1718
 *      Interrupt service routine for ECH-PCI board types.
1719
 */
1720
 
1721
static int stl_echpciintr(struct stlbrd *brdp)
1722
{
1723
        struct stlpanel *panelp;
1724
        unsigned int    ioaddr, bnknr, recheck;
1725
        int             handled = 0;
1726
 
1727
        while (1) {
1728
                recheck = 0;
1729
                for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1730
                        outb(brdp->bnkpageaddr[bnknr], brdp->ioctrl);
1731
                        ioaddr = brdp->bnkstataddr[bnknr];
1732
                        if (inb(ioaddr) & ECH_PNLINTRPEND) {
1733
                                panelp = brdp->bnk2panel[bnknr];
1734
                                (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1735
                                recheck++;
1736
                                handled = 1;
1737
                        }
1738
                }
1739
                if (! recheck)
1740
                        break;
1741
        }
1742
        return handled;
1743
}
1744
 
1745
/*****************************************************************************/
1746
 
1747
/*
1748
 *      Interrupt service routine for ECH-8/64-PCI board types.
1749
 */
1750
 
1751
static int stl_echpci64intr(struct stlbrd *brdp)
1752
{
1753
        struct stlpanel *panelp;
1754
        unsigned int    ioaddr, bnknr;
1755
        int             handled = 0;
1756
 
1757
        while (inb(brdp->ioctrl) & 0x1) {
1758
                handled = 1;
1759
                for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
1760
                        ioaddr = brdp->bnkstataddr[bnknr];
1761
                        if (inb(ioaddr) & ECH_PNLINTRPEND) {
1762
                                panelp = brdp->bnk2panel[bnknr];
1763
                                (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1764
                        }
1765
                }
1766
        }
1767
 
1768
        return handled;
1769
}
1770
 
1771
/*****************************************************************************/
1772
 
1773
/*
1774
 *      Service an off-level request for some channel.
1775
 */
1776
static void stl_offintr(struct work_struct *work)
1777
{
1778
        struct stlport          *portp = container_of(work, struct stlport, tqueue);
1779
        struct tty_struct       *tty;
1780
        unsigned int            oldsigs;
1781
 
1782
        pr_debug("stl_offintr(portp=%p)\n", portp);
1783
 
1784
        if (portp == NULL)
1785
                return;
1786
 
1787
        tty = portp->tty;
1788
        if (tty == NULL)
1789
                return;
1790
 
1791
        if (test_bit(ASYI_TXLOW, &portp->istate))
1792
                tty_wakeup(tty);
1793
 
1794
        if (test_bit(ASYI_DCDCHANGE, &portp->istate)) {
1795
                clear_bit(ASYI_DCDCHANGE, &portp->istate);
1796
                oldsigs = portp->sigs;
1797
                portp->sigs = stl_getsignals(portp);
1798
                if ((portp->sigs & TIOCM_CD) && ((oldsigs & TIOCM_CD) == 0))
1799
                        wake_up_interruptible(&portp->open_wait);
1800
                if ((oldsigs & TIOCM_CD) && ((portp->sigs & TIOCM_CD) == 0))
1801
                        if (portp->flags & ASYNC_CHECK_CD)
1802
                                tty_hangup(tty);        /* FIXME: module removal race here - AKPM */
1803
        }
1804
}
1805
 
1806
/*****************************************************************************/
1807
 
1808
/*
1809
 *      Initialize all the ports on a panel.
1810
 */
1811
 
1812
static int __devinit stl_initports(struct stlbrd *brdp, struct stlpanel *panelp)
1813
{
1814
        struct stlport *portp;
1815
        unsigned int i;
1816
        int chipmask;
1817
 
1818
        pr_debug("stl_initports(brdp=%p,panelp=%p)\n", brdp, panelp);
1819
 
1820
        chipmask = stl_panelinit(brdp, panelp);
1821
 
1822
/*
1823
 *      All UART's are initialized (if found!). Now go through and setup
1824
 *      each ports data structures.
1825
 */
1826
        for (i = 0; i < panelp->nrports; i++) {
1827
                portp = kzalloc(sizeof(struct stlport), GFP_KERNEL);
1828
                if (!portp) {
1829
                        printk("STALLION: failed to allocate memory "
1830
                                "(size=%Zd)\n", sizeof(struct stlport));
1831
                        break;
1832
                }
1833
 
1834
                portp->magic = STL_PORTMAGIC;
1835
                portp->portnr = i;
1836
                portp->brdnr = panelp->brdnr;
1837
                portp->panelnr = panelp->panelnr;
1838
                portp->uartp = panelp->uartp;
1839
                portp->clk = brdp->clk;
1840
                portp->baud_base = STL_BAUDBASE;
1841
                portp->close_delay = STL_CLOSEDELAY;
1842
                portp->closing_wait = 30 * HZ;
1843
                INIT_WORK(&portp->tqueue, stl_offintr);
1844
                init_waitqueue_head(&portp->open_wait);
1845
                init_waitqueue_head(&portp->close_wait);
1846
                portp->stats.brd = portp->brdnr;
1847
                portp->stats.panel = portp->panelnr;
1848
                portp->stats.port = portp->portnr;
1849
                panelp->ports[i] = portp;
1850
                stl_portinit(brdp, panelp, portp);
1851
        }
1852
 
1853
        return 0;
1854
}
1855
 
1856
static void stl_cleanup_panels(struct stlbrd *brdp)
1857
{
1858
        struct stlpanel *panelp;
1859
        struct stlport *portp;
1860
        unsigned int j, k;
1861
 
1862
        for (j = 0; j < STL_MAXPANELS; j++) {
1863
                panelp = brdp->panels[j];
1864
                if (panelp == NULL)
1865
                        continue;
1866
                for (k = 0; k < STL_PORTSPERPANEL; k++) {
1867
                        portp = panelp->ports[k];
1868
                        if (portp == NULL)
1869
                                continue;
1870
                        if (portp->tty != NULL)
1871
                                stl_hangup(portp->tty);
1872
                        kfree(portp->tx.buf);
1873
                        kfree(portp);
1874
                }
1875
                kfree(panelp);
1876
        }
1877
}
1878
 
1879
/*****************************************************************************/
1880
 
1881
/*
1882
 *      Try to find and initialize an EasyIO board.
1883
 */
1884
 
1885
static int __devinit stl_initeio(struct stlbrd *brdp)
1886
{
1887
        struct stlpanel *panelp;
1888
        unsigned int    status;
1889
        char            *name;
1890
        int             retval;
1891
 
1892
        pr_debug("stl_initeio(brdp=%p)\n", brdp);
1893
 
1894
        brdp->ioctrl = brdp->ioaddr1 + 1;
1895
        brdp->iostatus = brdp->ioaddr1 + 2;
1896
 
1897
        status = inb(brdp->iostatus);
1898
        if ((status & EIO_IDBITMASK) == EIO_MK3)
1899
                brdp->ioctrl++;
1900
 
1901
/*
1902
 *      Handle board specific stuff now. The real difference is PCI
1903
 *      or not PCI.
1904
 */
1905
        if (brdp->brdtype == BRD_EASYIOPCI) {
1906
                brdp->iosize1 = 0x80;
1907
                brdp->iosize2 = 0x80;
1908
                name = "serial(EIO-PCI)";
1909
                outb(0x41, (brdp->ioaddr2 + 0x4c));
1910
        } else {
1911
                brdp->iosize1 = 8;
1912
                name = "serial(EIO)";
1913
                if ((brdp->irq < 0) || (brdp->irq > 15) ||
1914
                    (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
1915
                        printk("STALLION: invalid irq=%d for brd=%d\n",
1916
                                brdp->irq, brdp->brdnr);
1917
                        retval = -EINVAL;
1918
                        goto err;
1919
                }
1920
                outb((stl_vecmap[brdp->irq] | EIO_0WS |
1921
                        ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)),
1922
                        brdp->ioctrl);
1923
        }
1924
 
1925
        retval = -EBUSY;
1926
        if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
1927
                printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
1928
                        "%x conflicts with another device\n", brdp->brdnr,
1929
                        brdp->ioaddr1);
1930
                goto err;
1931
        }
1932
 
1933
        if (brdp->iosize2 > 0)
1934
                if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) {
1935
                        printk(KERN_WARNING "STALLION: Warning, board %d I/O "
1936
                                "address %x conflicts with another device\n",
1937
                                brdp->brdnr, brdp->ioaddr2);
1938
                        printk(KERN_WARNING "STALLION: Warning, also "
1939
                                "releasing board %d I/O address %x \n",
1940
                                brdp->brdnr, brdp->ioaddr1);
1941
                        goto err_rel1;
1942
                }
1943
 
1944
/*
1945
 *      Everything looks OK, so let's go ahead and probe for the hardware.
1946
 */
1947
        brdp->clk = CD1400_CLK;
1948
        brdp->isr = stl_eiointr;
1949
 
1950
        retval = -ENODEV;
1951
        switch (status & EIO_IDBITMASK) {
1952
        case EIO_8PORTM:
1953
                brdp->clk = CD1400_CLK8M;
1954
                /* fall thru */
1955
        case EIO_8PORTRS:
1956
        case EIO_8PORTDI:
1957
                brdp->nrports = 8;
1958
                break;
1959
        case EIO_4PORTRS:
1960
                brdp->nrports = 4;
1961
                break;
1962
        case EIO_MK3:
1963
                switch (status & EIO_BRDMASK) {
1964
                case ID_BRD4:
1965
                        brdp->nrports = 4;
1966
                        break;
1967
                case ID_BRD8:
1968
                        brdp->nrports = 8;
1969
                        break;
1970
                case ID_BRD16:
1971
                        brdp->nrports = 16;
1972
                        break;
1973
                default:
1974
                        goto err_rel2;
1975
                }
1976
                break;
1977
        default:
1978
                goto err_rel2;
1979
        }
1980
 
1981
/*
1982
 *      We have verified that the board is actually present, so now we
1983
 *      can complete the setup.
1984
 */
1985
 
1986
        panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
1987
        if (!panelp) {
1988
                printk(KERN_WARNING "STALLION: failed to allocate memory "
1989
                        "(size=%Zd)\n", sizeof(struct stlpanel));
1990
                retval = -ENOMEM;
1991
                goto err_rel2;
1992
        }
1993
 
1994
        panelp->magic = STL_PANELMAGIC;
1995
        panelp->brdnr = brdp->brdnr;
1996
        panelp->panelnr = 0;
1997
        panelp->nrports = brdp->nrports;
1998
        panelp->iobase = brdp->ioaddr1;
1999
        panelp->hwid = status;
2000
        if ((status & EIO_IDBITMASK) == EIO_MK3) {
2001
                panelp->uartp = &stl_sc26198uart;
2002
                panelp->isr = stl_sc26198intr;
2003
        } else {
2004
                panelp->uartp = &stl_cd1400uart;
2005
                panelp->isr = stl_cd1400eiointr;
2006
        }
2007
 
2008
        brdp->panels[0] = panelp;
2009
        brdp->nrpanels = 1;
2010
        brdp->state |= BRD_FOUND;
2011
        brdp->hwid = status;
2012
        if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
2013
                printk("STALLION: failed to register interrupt "
2014
                    "routine for %s irq=%d\n", name, brdp->irq);
2015
                retval = -ENODEV;
2016
                goto err_fr;
2017
        }
2018
 
2019
        return 0;
2020
err_fr:
2021
        stl_cleanup_panels(brdp);
2022
err_rel2:
2023
        if (brdp->iosize2 > 0)
2024
                release_region(brdp->ioaddr2, brdp->iosize2);
2025
err_rel1:
2026
        release_region(brdp->ioaddr1, brdp->iosize1);
2027
err:
2028
        return retval;
2029
}
2030
 
2031
/*****************************************************************************/
2032
 
2033
/*
2034
 *      Try to find an ECH board and initialize it. This code is capable of
2035
 *      dealing with all types of ECH board.
2036
 */
2037
 
2038
static int __devinit stl_initech(struct stlbrd *brdp)
2039
{
2040
        struct stlpanel *panelp;
2041
        unsigned int    status, nxtid, ioaddr, conflict, panelnr, banknr, i;
2042
        int             retval;
2043
        char            *name;
2044
 
2045
        pr_debug("stl_initech(brdp=%p)\n", brdp);
2046
 
2047
        status = 0;
2048
        conflict = 0;
2049
 
2050
/*
2051
 *      Set up the initial board register contents for boards. This varies a
2052
 *      bit between the different board types. So we need to handle each
2053
 *      separately. Also do a check that the supplied IRQ is good.
2054
 */
2055
        switch (brdp->brdtype) {
2056
 
2057
        case BRD_ECH:
2058
                brdp->isr = stl_echatintr;
2059
                brdp->ioctrl = brdp->ioaddr1 + 1;
2060
                brdp->iostatus = brdp->ioaddr1 + 1;
2061
                status = inb(brdp->iostatus);
2062
                if ((status & ECH_IDBITMASK) != ECH_ID) {
2063
                        retval = -ENODEV;
2064
                        goto err;
2065
                }
2066
                if ((brdp->irq < 0) || (brdp->irq > 15) ||
2067
                    (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2068
                        printk("STALLION: invalid irq=%d for brd=%d\n",
2069
                                brdp->irq, brdp->brdnr);
2070
                        retval = -EINVAL;
2071
                        goto err;
2072
                }
2073
                status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1);
2074
                status |= (stl_vecmap[brdp->irq] << 1);
2075
                outb((status | ECH_BRDRESET), brdp->ioaddr1);
2076
                brdp->ioctrlval = ECH_INTENABLE |
2077
                        ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE);
2078
                for (i = 0; i < 10; i++)
2079
                        outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
2080
                brdp->iosize1 = 2;
2081
                brdp->iosize2 = 32;
2082
                name = "serial(EC8/32)";
2083
                outb(status, brdp->ioaddr1);
2084
                break;
2085
 
2086
        case BRD_ECHMC:
2087
                brdp->isr = stl_echmcaintr;
2088
                brdp->ioctrl = brdp->ioaddr1 + 0x20;
2089
                brdp->iostatus = brdp->ioctrl;
2090
                status = inb(brdp->iostatus);
2091
                if ((status & ECH_IDBITMASK) != ECH_ID) {
2092
                        retval = -ENODEV;
2093
                        goto err;
2094
                }
2095
                if ((brdp->irq < 0) || (brdp->irq > 15) ||
2096
                    (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2097
                        printk("STALLION: invalid irq=%d for brd=%d\n",
2098
                                brdp->irq, brdp->brdnr);
2099
                        retval = -EINVAL;
2100
                        goto err;
2101
                }
2102
                outb(ECHMC_BRDRESET, brdp->ioctrl);
2103
                outb(ECHMC_INTENABLE, brdp->ioctrl);
2104
                brdp->iosize1 = 64;
2105
                name = "serial(EC8/32-MC)";
2106
                break;
2107
 
2108
        case BRD_ECHPCI:
2109
                brdp->isr = stl_echpciintr;
2110
                brdp->ioctrl = brdp->ioaddr1 + 2;
2111
                brdp->iosize1 = 4;
2112
                brdp->iosize2 = 8;
2113
                name = "serial(EC8/32-PCI)";
2114
                break;
2115
 
2116
        case BRD_ECH64PCI:
2117
                brdp->isr = stl_echpci64intr;
2118
                brdp->ioctrl = brdp->ioaddr2 + 0x40;
2119
                outb(0x43, (brdp->ioaddr1 + 0x4c));
2120
                brdp->iosize1 = 0x80;
2121
                brdp->iosize2 = 0x80;
2122
                name = "serial(EC8/64-PCI)";
2123
                break;
2124
 
2125
        default:
2126
                printk("STALLION: unknown board type=%d\n", brdp->brdtype);
2127
                retval = -EINVAL;
2128
                goto err;
2129
        }
2130
 
2131
/*
2132
 *      Check boards for possible IO address conflicts and return fail status
2133
 *      if an IO conflict found.
2134
 */
2135
        retval = -EBUSY;
2136
        if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
2137
                printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
2138
                        "%x conflicts with another device\n", brdp->brdnr,
2139
                        brdp->ioaddr1);
2140
                goto err;
2141
        }
2142
 
2143
        if (brdp->iosize2 > 0)
2144
                if (!request_region(brdp->ioaddr2, brdp->iosize2, name)) {
2145
                        printk(KERN_WARNING "STALLION: Warning, board %d I/O "
2146
                                "address %x conflicts with another device\n",
2147
                                brdp->brdnr, brdp->ioaddr2);
2148
                        printk(KERN_WARNING "STALLION: Warning, also "
2149
                                "releasing board %d I/O address %x \n",
2150
                                brdp->brdnr, brdp->ioaddr1);
2151
                        goto err_rel1;
2152
                }
2153
 
2154
/*
2155
 *      Scan through the secondary io address space looking for panels.
2156
 *      As we find'em allocate and initialize panel structures for each.
2157
 */
2158
        brdp->clk = CD1400_CLK;
2159
        brdp->hwid = status;
2160
 
2161
        ioaddr = brdp->ioaddr2;
2162
        banknr = 0;
2163
        panelnr = 0;
2164
        nxtid = 0;
2165
 
2166
        for (i = 0; i < STL_MAXPANELS; i++) {
2167
                if (brdp->brdtype == BRD_ECHPCI) {
2168
                        outb(nxtid, brdp->ioctrl);
2169
                        ioaddr = brdp->ioaddr2;
2170
                }
2171
                status = inb(ioaddr + ECH_PNLSTATUS);
2172
                if ((status & ECH_PNLIDMASK) != nxtid)
2173
                        break;
2174
                panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
2175
                if (!panelp) {
2176
                        printk("STALLION: failed to allocate memory "
2177
                                "(size=%Zd)\n", sizeof(struct stlpanel));
2178
                        retval = -ENOMEM;
2179
                        goto err_fr;
2180
                }
2181
                panelp->magic = STL_PANELMAGIC;
2182
                panelp->brdnr = brdp->brdnr;
2183
                panelp->panelnr = panelnr;
2184
                panelp->iobase = ioaddr;
2185
                panelp->pagenr = nxtid;
2186
                panelp->hwid = status;
2187
                brdp->bnk2panel[banknr] = panelp;
2188
                brdp->bnkpageaddr[banknr] = nxtid;
2189
                brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS;
2190
 
2191
                if (status & ECH_PNLXPID) {
2192
                        panelp->uartp = &stl_sc26198uart;
2193
                        panelp->isr = stl_sc26198intr;
2194
                        if (status & ECH_PNL16PORT) {
2195
                                panelp->nrports = 16;
2196
                                brdp->bnk2panel[banknr] = panelp;
2197
                                brdp->bnkpageaddr[banknr] = nxtid;
2198
                                brdp->bnkstataddr[banknr++] = ioaddr + 4 +
2199
                                        ECH_PNLSTATUS;
2200
                        } else
2201
                                panelp->nrports = 8;
2202
                } else {
2203
                        panelp->uartp = &stl_cd1400uart;
2204
                        panelp->isr = stl_cd1400echintr;
2205
                        if (status & ECH_PNL16PORT) {
2206
                                panelp->nrports = 16;
2207
                                panelp->ackmask = 0x80;
2208
                                if (brdp->brdtype != BRD_ECHPCI)
2209
                                        ioaddr += EREG_BANKSIZE;
2210
                                brdp->bnk2panel[banknr] = panelp;
2211
                                brdp->bnkpageaddr[banknr] = ++nxtid;
2212
                                brdp->bnkstataddr[banknr++] = ioaddr +
2213
                                        ECH_PNLSTATUS;
2214
                        } else {
2215
                                panelp->nrports = 8;
2216
                                panelp->ackmask = 0xc0;
2217
                        }
2218
                }
2219
 
2220
                nxtid++;
2221
                ioaddr += EREG_BANKSIZE;
2222
                brdp->nrports += panelp->nrports;
2223
                brdp->panels[panelnr++] = panelp;
2224
                if ((brdp->brdtype != BRD_ECHPCI) &&
2225
                    (ioaddr >= (brdp->ioaddr2 + brdp->iosize2))) {
2226
                        retval = -EINVAL;
2227
                        goto err_fr;
2228
                }
2229
        }
2230
 
2231
        brdp->nrpanels = panelnr;
2232
        brdp->nrbnks = banknr;
2233
        if (brdp->brdtype == BRD_ECH)
2234
                outb((brdp->ioctrlval | ECH_BRDDISABLE), brdp->ioctrl);
2235
 
2236
        brdp->state |= BRD_FOUND;
2237
        if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
2238
                printk("STALLION: failed to register interrupt "
2239
                    "routine for %s irq=%d\n", name, brdp->irq);
2240
                retval = -ENODEV;
2241
                goto err_fr;
2242
        }
2243
 
2244
        return 0;
2245
err_fr:
2246
        stl_cleanup_panels(brdp);
2247
        if (brdp->iosize2 > 0)
2248
                release_region(brdp->ioaddr2, brdp->iosize2);
2249
err_rel1:
2250
        release_region(brdp->ioaddr1, brdp->iosize1);
2251
err:
2252
        return retval;
2253
}
2254
 
2255
/*****************************************************************************/
2256
 
2257
/*
2258
 *      Initialize and configure the specified board.
2259
 *      Scan through all the boards in the configuration and see what we
2260
 *      can find. Handle EIO and the ECH boards a little differently here
2261
 *      since the initial search and setup is very different.
2262
 */
2263
 
2264
static int __devinit stl_brdinit(struct stlbrd *brdp)
2265
{
2266
        int i, retval;
2267
 
2268
        pr_debug("stl_brdinit(brdp=%p)\n", brdp);
2269
 
2270
        switch (brdp->brdtype) {
2271
        case BRD_EASYIO:
2272
        case BRD_EASYIOPCI:
2273
                retval = stl_initeio(brdp);
2274
                if (retval)
2275
                        goto err;
2276
                break;
2277
        case BRD_ECH:
2278
        case BRD_ECHMC:
2279
        case BRD_ECHPCI:
2280
        case BRD_ECH64PCI:
2281
                retval = stl_initech(brdp);
2282
                if (retval)
2283
                        goto err;
2284
                break;
2285
        default:
2286
                printk("STALLION: board=%d is unknown board type=%d\n",
2287
                        brdp->brdnr, brdp->brdtype);
2288
                retval = -ENODEV;
2289
                goto err;
2290
        }
2291
 
2292
        if ((brdp->state & BRD_FOUND) == 0) {
2293
                printk("STALLION: %s board not found, board=%d io=%x irq=%d\n",
2294
                        stl_brdnames[brdp->brdtype], brdp->brdnr,
2295
                        brdp->ioaddr1, brdp->irq);
2296
                goto err_free;
2297
        }
2298
 
2299
        for (i = 0; i < STL_MAXPANELS; i++)
2300
                if (brdp->panels[i] != NULL)
2301
                        stl_initports(brdp, brdp->panels[i]);
2302
 
2303
        printk("STALLION: %s found, board=%d io=%x irq=%d "
2304
                "nrpanels=%d nrports=%d\n", stl_brdnames[brdp->brdtype],
2305
                brdp->brdnr, brdp->ioaddr1, brdp->irq, brdp->nrpanels,
2306
                brdp->nrports);
2307
 
2308
        return 0;
2309
err_free:
2310
        free_irq(brdp->irq, brdp);
2311
 
2312
        stl_cleanup_panels(brdp);
2313
 
2314
        release_region(brdp->ioaddr1, brdp->iosize1);
2315
        if (brdp->iosize2 > 0)
2316
                release_region(brdp->ioaddr2, brdp->iosize2);
2317
err:
2318
        return retval;
2319
}
2320
 
2321
/*****************************************************************************/
2322
 
2323
/*
2324
 *      Find the next available board number that is free.
2325
 */
2326
 
2327
static int __devinit stl_getbrdnr(void)
2328
{
2329
        unsigned int i;
2330
 
2331
        for (i = 0; i < STL_MAXBRDS; i++)
2332
                if (stl_brds[i] == NULL) {
2333
                        if (i >= stl_nrbrds)
2334
                                stl_nrbrds = i + 1;
2335
                        return i;
2336
                }
2337
 
2338
        return -1;
2339
}
2340
 
2341
/*****************************************************************************/
2342
/*
2343
 *      We have a Stallion board. Allocate a board structure and
2344
 *      initialize it. Read its IO and IRQ resources from PCI
2345
 *      configuration space.
2346
 */
2347
 
2348
static int __devinit stl_pciprobe(struct pci_dev *pdev,
2349
                const struct pci_device_id *ent)
2350
{
2351
        struct stlbrd *brdp;
2352
        unsigned int i, brdtype = ent->driver_data;
2353
        int brdnr, retval = -ENODEV;
2354
 
2355
        if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE)
2356
                goto err;
2357
 
2358
        retval = pci_enable_device(pdev);
2359
        if (retval)
2360
                goto err;
2361
        brdp = stl_allocbrd();
2362
        if (brdp == NULL) {
2363
                retval = -ENOMEM;
2364
                goto err;
2365
        }
2366
        mutex_lock(&stl_brdslock);
2367
        brdnr = stl_getbrdnr();
2368
        if (brdnr < 0) {
2369
                dev_err(&pdev->dev, "too many boards found, "
2370
                        "maximum supported %d\n", STL_MAXBRDS);
2371
                mutex_unlock(&stl_brdslock);
2372
                retval = -ENODEV;
2373
                goto err_fr;
2374
        }
2375
        brdp->brdnr = (unsigned int)brdnr;
2376
        stl_brds[brdp->brdnr] = brdp;
2377
        mutex_unlock(&stl_brdslock);
2378
 
2379
        brdp->brdtype = brdtype;
2380
        brdp->state |= STL_PROBED;
2381
 
2382
/*
2383
 *      We have all resources from the board, so let's setup the actual
2384
 *      board structure now.
2385
 */
2386
        switch (brdtype) {
2387
        case BRD_ECHPCI:
2388
                brdp->ioaddr2 = pci_resource_start(pdev, 0);
2389
                brdp->ioaddr1 = pci_resource_start(pdev, 1);
2390
                break;
2391
        case BRD_ECH64PCI:
2392
                brdp->ioaddr2 = pci_resource_start(pdev, 2);
2393
                brdp->ioaddr1 = pci_resource_start(pdev, 1);
2394
                break;
2395
        case BRD_EASYIOPCI:
2396
                brdp->ioaddr1 = pci_resource_start(pdev, 2);
2397
                brdp->ioaddr2 = pci_resource_start(pdev, 1);
2398
                break;
2399
        default:
2400
                dev_err(&pdev->dev, "unknown PCI board type=%u\n", brdtype);
2401
                break;
2402
        }
2403
 
2404
        brdp->irq = pdev->irq;
2405
        retval = stl_brdinit(brdp);
2406
        if (retval)
2407
                goto err_null;
2408
 
2409
        pci_set_drvdata(pdev, brdp);
2410
 
2411
        for (i = 0; i < brdp->nrports; i++)
2412
                tty_register_device(stl_serial,
2413
                                brdp->brdnr * STL_MAXPORTS + i, &pdev->dev);
2414
 
2415
        return 0;
2416
err_null:
2417
        stl_brds[brdp->brdnr] = NULL;
2418
err_fr:
2419
        kfree(brdp);
2420
err:
2421
        return retval;
2422
}
2423
 
2424
static void __devexit stl_pciremove(struct pci_dev *pdev)
2425
{
2426
        struct stlbrd *brdp = pci_get_drvdata(pdev);
2427
        unsigned int i;
2428
 
2429
        free_irq(brdp->irq, brdp);
2430
 
2431
        stl_cleanup_panels(brdp);
2432
 
2433
        release_region(brdp->ioaddr1, brdp->iosize1);
2434
        if (brdp->iosize2 > 0)
2435
                release_region(brdp->ioaddr2, brdp->iosize2);
2436
 
2437
        for (i = 0; i < brdp->nrports; i++)
2438
                tty_unregister_device(stl_serial,
2439
                                brdp->brdnr * STL_MAXPORTS + i);
2440
 
2441
        stl_brds[brdp->brdnr] = NULL;
2442
        kfree(brdp);
2443
}
2444
 
2445
static struct pci_driver stl_pcidriver = {
2446
        .name = "stallion",
2447
        .id_table = stl_pcibrds,
2448
        .probe = stl_pciprobe,
2449
        .remove = __devexit_p(stl_pciremove)
2450
};
2451
 
2452
/*****************************************************************************/
2453
 
2454
/*
2455
 *      Return the board stats structure to user app.
2456
 */
2457
 
2458
static int stl_getbrdstats(combrd_t __user *bp)
2459
{
2460
        combrd_t        stl_brdstats;
2461
        struct stlbrd   *brdp;
2462
        struct stlpanel *panelp;
2463
        unsigned int i;
2464
 
2465
        if (copy_from_user(&stl_brdstats, bp, sizeof(combrd_t)))
2466
                return -EFAULT;
2467
        if (stl_brdstats.brd >= STL_MAXBRDS)
2468
                return -ENODEV;
2469
        brdp = stl_brds[stl_brdstats.brd];
2470
        if (brdp == NULL)
2471
                return -ENODEV;
2472
 
2473
        memset(&stl_brdstats, 0, sizeof(combrd_t));
2474
        stl_brdstats.brd = brdp->brdnr;
2475
        stl_brdstats.type = brdp->brdtype;
2476
        stl_brdstats.hwid = brdp->hwid;
2477
        stl_brdstats.state = brdp->state;
2478
        stl_brdstats.ioaddr = brdp->ioaddr1;
2479
        stl_brdstats.ioaddr2 = brdp->ioaddr2;
2480
        stl_brdstats.irq = brdp->irq;
2481
        stl_brdstats.nrpanels = brdp->nrpanels;
2482
        stl_brdstats.nrports = brdp->nrports;
2483
        for (i = 0; i < brdp->nrpanels; i++) {
2484
                panelp = brdp->panels[i];
2485
                stl_brdstats.panels[i].panel = i;
2486
                stl_brdstats.panels[i].hwid = panelp->hwid;
2487
                stl_brdstats.panels[i].nrports = panelp->nrports;
2488
        }
2489
 
2490
        return copy_to_user(bp, &stl_brdstats, sizeof(combrd_t)) ? -EFAULT : 0;
2491
}
2492
 
2493
/*****************************************************************************/
2494
 
2495
/*
2496
 *      Resolve the referenced port number into a port struct pointer.
2497
 */
2498
 
2499
static struct stlport *stl_getport(int brdnr, int panelnr, int portnr)
2500
{
2501
        struct stlbrd   *brdp;
2502
        struct stlpanel *panelp;
2503
 
2504
        if (brdnr < 0 || brdnr >= STL_MAXBRDS)
2505
                return NULL;
2506
        brdp = stl_brds[brdnr];
2507
        if (brdp == NULL)
2508
                return NULL;
2509
        if (panelnr < 0 || (unsigned int)panelnr >= brdp->nrpanels)
2510
                return NULL;
2511
        panelp = brdp->panels[panelnr];
2512
        if (panelp == NULL)
2513
                return NULL;
2514
        if (portnr < 0 || (unsigned int)portnr >= panelp->nrports)
2515
                return NULL;
2516
        return panelp->ports[portnr];
2517
}
2518
 
2519
/*****************************************************************************/
2520
 
2521
/*
2522
 *      Return the port stats structure to user app. A NULL port struct
2523
 *      pointer passed in means that we need to find out from the app
2524
 *      what port to get stats for (used through board control device).
2525
 */
2526
 
2527
static int stl_getportstats(struct stlport *portp, comstats_t __user *cp)
2528
{
2529
        comstats_t      stl_comstats;
2530
        unsigned char   *head, *tail;
2531
        unsigned long   flags;
2532
 
2533
        if (!portp) {
2534
                if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
2535
                        return -EFAULT;
2536
                portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2537
                        stl_comstats.port);
2538
                if (portp == NULL)
2539
                        return -ENODEV;
2540
        }
2541
 
2542
        portp->stats.state = portp->istate;
2543
        portp->stats.flags = portp->flags;
2544
        portp->stats.hwid = portp->hwid;
2545
 
2546
        portp->stats.ttystate = 0;
2547
        portp->stats.cflags = 0;
2548
        portp->stats.iflags = 0;
2549
        portp->stats.oflags = 0;
2550
        portp->stats.lflags = 0;
2551
        portp->stats.rxbuffered = 0;
2552
 
2553
        spin_lock_irqsave(&stallion_lock, flags);
2554
        if (portp->tty != NULL)
2555
                if (portp->tty->driver_data == portp) {
2556
                        portp->stats.ttystate = portp->tty->flags;
2557
                        /* No longer available as a statistic */
2558
                        portp->stats.rxbuffered = 1; /*portp->tty->flip.count; */
2559
                        if (portp->tty->termios != NULL) {
2560
                                portp->stats.cflags = portp->tty->termios->c_cflag;
2561
                                portp->stats.iflags = portp->tty->termios->c_iflag;
2562
                                portp->stats.oflags = portp->tty->termios->c_oflag;
2563
                                portp->stats.lflags = portp->tty->termios->c_lflag;
2564
                        }
2565
                }
2566
        spin_unlock_irqrestore(&stallion_lock, flags);
2567
 
2568
        head = portp->tx.head;
2569
        tail = portp->tx.tail;
2570
        portp->stats.txbuffered = (head >= tail) ? (head - tail) :
2571
                (STL_TXBUFSIZE - (tail - head));
2572
 
2573
        portp->stats.signals = (unsigned long) stl_getsignals(portp);
2574
 
2575
        return copy_to_user(cp, &portp->stats,
2576
                            sizeof(comstats_t)) ? -EFAULT : 0;
2577
}
2578
 
2579
/*****************************************************************************/
2580
 
2581
/*
2582
 *      Clear the port stats structure. We also return it zeroed out...
2583
 */
2584
 
2585
static int stl_clrportstats(struct stlport *portp, comstats_t __user *cp)
2586
{
2587
        comstats_t      stl_comstats;
2588
 
2589
        if (!portp) {
2590
                if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
2591
                        return -EFAULT;
2592
                portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2593
                        stl_comstats.port);
2594
                if (portp == NULL)
2595
                        return -ENODEV;
2596
        }
2597
 
2598
        memset(&portp->stats, 0, sizeof(comstats_t));
2599
        portp->stats.brd = portp->brdnr;
2600
        portp->stats.panel = portp->panelnr;
2601
        portp->stats.port = portp->portnr;
2602
        return copy_to_user(cp, &portp->stats,
2603
                            sizeof(comstats_t)) ? -EFAULT : 0;
2604
}
2605
 
2606
/*****************************************************************************/
2607
 
2608
/*
2609
 *      Return the entire driver ports structure to a user app.
2610
 */
2611
 
2612
static int stl_getportstruct(struct stlport __user *arg)
2613
{
2614
        struct stlport  stl_dummyport;
2615
        struct stlport  *portp;
2616
 
2617
        if (copy_from_user(&stl_dummyport, arg, sizeof(struct stlport)))
2618
                return -EFAULT;
2619
        portp = stl_getport(stl_dummyport.brdnr, stl_dummyport.panelnr,
2620
                 stl_dummyport.portnr);
2621
        if (!portp)
2622
                return -ENODEV;
2623
        return copy_to_user(arg, portp, sizeof(struct stlport)) ? -EFAULT : 0;
2624
}
2625
 
2626
/*****************************************************************************/
2627
 
2628
/*
2629
 *      Return the entire driver board structure to a user app.
2630
 */
2631
 
2632
static int stl_getbrdstruct(struct stlbrd __user *arg)
2633
{
2634
        struct stlbrd   stl_dummybrd;
2635
        struct stlbrd   *brdp;
2636
 
2637
        if (copy_from_user(&stl_dummybrd, arg, sizeof(struct stlbrd)))
2638
                return -EFAULT;
2639
        if (stl_dummybrd.brdnr >= STL_MAXBRDS)
2640
                return -ENODEV;
2641
        brdp = stl_brds[stl_dummybrd.brdnr];
2642
        if (!brdp)
2643
                return -ENODEV;
2644
        return copy_to_user(arg, brdp, sizeof(struct stlbrd)) ? -EFAULT : 0;
2645
}
2646
 
2647
/*****************************************************************************/
2648
 
2649
/*
2650
 *      The "staliomem" device is also required to do some special operations
2651
 *      on the board and/or ports. In this driver it is mostly used for stats
2652
 *      collection.
2653
 */
2654
 
2655
static int stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
2656
{
2657
        int     brdnr, rc;
2658
        void __user *argp = (void __user *)arg;
2659
 
2660
        pr_debug("stl_memioctl(ip=%p,fp=%p,cmd=%x,arg=%lx)\n", ip, fp, cmd,arg);
2661
 
2662
        brdnr = iminor(ip);
2663
        if (brdnr >= STL_MAXBRDS)
2664
                return -ENODEV;
2665
        rc = 0;
2666
 
2667
        switch (cmd) {
2668
        case COM_GETPORTSTATS:
2669
                rc = stl_getportstats(NULL, argp);
2670
                break;
2671
        case COM_CLRPORTSTATS:
2672
                rc = stl_clrportstats(NULL, argp);
2673
                break;
2674
        case COM_GETBRDSTATS:
2675
                rc = stl_getbrdstats(argp);
2676
                break;
2677
        case COM_READPORT:
2678
                rc = stl_getportstruct(argp);
2679
                break;
2680
        case COM_READBOARD:
2681
                rc = stl_getbrdstruct(argp);
2682
                break;
2683
        default:
2684
                rc = -ENOIOCTLCMD;
2685
                break;
2686
        }
2687
 
2688
        return rc;
2689
}
2690
 
2691
static const struct tty_operations stl_ops = {
2692
        .open = stl_open,
2693
        .close = stl_close,
2694
        .write = stl_write,
2695
        .put_char = stl_putchar,
2696
        .flush_chars = stl_flushchars,
2697
        .write_room = stl_writeroom,
2698
        .chars_in_buffer = stl_charsinbuffer,
2699
        .ioctl = stl_ioctl,
2700
        .set_termios = stl_settermios,
2701
        .throttle = stl_throttle,
2702
        .unthrottle = stl_unthrottle,
2703
        .stop = stl_stop,
2704
        .start = stl_start,
2705
        .hangup = stl_hangup,
2706
        .flush_buffer = stl_flushbuffer,
2707
        .break_ctl = stl_breakctl,
2708
        .wait_until_sent = stl_waituntilsent,
2709
        .send_xchar = stl_sendxchar,
2710
        .read_proc = stl_readproc,
2711
        .tiocmget = stl_tiocmget,
2712
        .tiocmset = stl_tiocmset,
2713
};
2714
 
2715
/*****************************************************************************/
2716
/*                       CD1400 HARDWARE FUNCTIONS                           */
2717
/*****************************************************************************/
2718
 
2719
/*
2720
 *      These functions get/set/update the registers of the cd1400 UARTs.
2721
 *      Access to the cd1400 registers is via an address/data io port pair.
2722
 *      (Maybe should make this inline...)
2723
 */
2724
 
2725
static int stl_cd1400getreg(struct stlport *portp, int regnr)
2726
{
2727
        outb((regnr + portp->uartaddr), portp->ioaddr);
2728
        return inb(portp->ioaddr + EREG_DATA);
2729
}
2730
 
2731
static void stl_cd1400setreg(struct stlport *portp, int regnr, int value)
2732
{
2733
        outb(regnr + portp->uartaddr, portp->ioaddr);
2734
        outb(value, portp->ioaddr + EREG_DATA);
2735
}
2736
 
2737
static int stl_cd1400updatereg(struct stlport *portp, int regnr, int value)
2738
{
2739
        outb(regnr + portp->uartaddr, portp->ioaddr);
2740
        if (inb(portp->ioaddr + EREG_DATA) != value) {
2741
                outb(value, portp->ioaddr + EREG_DATA);
2742
                return 1;
2743
        }
2744
        return 0;
2745
}
2746
 
2747
/*****************************************************************************/
2748
 
2749
/*
2750
 *      Inbitialize the UARTs in a panel. We don't care what sort of board
2751
 *      these ports are on - since the port io registers are almost
2752
 *      identical when dealing with ports.
2753
 */
2754
 
2755
static int stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
2756
{
2757
        unsigned int    gfrcr;
2758
        int             chipmask, i, j;
2759
        int             nrchips, uartaddr, ioaddr;
2760
        unsigned long   flags;
2761
 
2762
        pr_debug("stl_panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
2763
 
2764
        spin_lock_irqsave(&brd_lock, flags);
2765
        BRDENABLE(panelp->brdnr, panelp->pagenr);
2766
 
2767
/*
2768
 *      Check that each chip is present and started up OK.
2769
 */
2770
        chipmask = 0;
2771
        nrchips = panelp->nrports / CD1400_PORTS;
2772
        for (i = 0; i < nrchips; i++) {
2773
                if (brdp->brdtype == BRD_ECHPCI) {
2774
                        outb((panelp->pagenr + (i >> 1)), brdp->ioctrl);
2775
                        ioaddr = panelp->iobase;
2776
                } else
2777
                        ioaddr = panelp->iobase + (EREG_BANKSIZE * (i >> 1));
2778
                uartaddr = (i & 0x01) ? 0x080 : 0;
2779
                outb((GFRCR + uartaddr), ioaddr);
2780
                outb(0, (ioaddr + EREG_DATA));
2781
                outb((CCR + uartaddr), ioaddr);
2782
                outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
2783
                outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
2784
                outb((GFRCR + uartaddr), ioaddr);
2785
                for (j = 0; j < CCR_MAXWAIT; j++)
2786
                        if ((gfrcr = inb(ioaddr + EREG_DATA)) != 0)
2787
                                break;
2788
 
2789
                if ((j >= CCR_MAXWAIT) || (gfrcr < 0x40) || (gfrcr > 0x60)) {
2790
                        printk("STALLION: cd1400 not responding, "
2791
                                "brd=%d panel=%d chip=%d\n",
2792
                                panelp->brdnr, panelp->panelnr, i);
2793
                        continue;
2794
                }
2795
                chipmask |= (0x1 << i);
2796
                outb((PPR + uartaddr), ioaddr);
2797
                outb(PPR_SCALAR, (ioaddr + EREG_DATA));
2798
        }
2799
 
2800
        BRDDISABLE(panelp->brdnr);
2801
        spin_unlock_irqrestore(&brd_lock, flags);
2802
        return chipmask;
2803
}
2804
 
2805
/*****************************************************************************/
2806
 
2807
/*
2808
 *      Initialize hardware specific port registers.
2809
 */
2810
 
2811
static void stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
2812
{
2813
        unsigned long flags;
2814
        pr_debug("stl_cd1400portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
2815
                        panelp, portp);
2816
 
2817
        if ((brdp == NULL) || (panelp == NULL) ||
2818
            (portp == NULL))
2819
                return;
2820
 
2821
        spin_lock_irqsave(&brd_lock, flags);
2822
        portp->ioaddr = panelp->iobase + (((brdp->brdtype == BRD_ECHPCI) ||
2823
                (portp->portnr < 8)) ? 0 : EREG_BANKSIZE);
2824
        portp->uartaddr = (portp->portnr & 0x04) << 5;
2825
        portp->pagenr = panelp->pagenr + (portp->portnr >> 3);
2826
 
2827
        BRDENABLE(portp->brdnr, portp->pagenr);
2828
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2829
        stl_cd1400setreg(portp, LIVR, (portp->portnr << 3));
2830
        portp->hwid = stl_cd1400getreg(portp, GFRCR);
2831
        BRDDISABLE(portp->brdnr);
2832
        spin_unlock_irqrestore(&brd_lock, flags);
2833
}
2834
 
2835
/*****************************************************************************/
2836
 
2837
/*
2838
 *      Wait for the command register to be ready. We will poll this,
2839
 *      since it won't usually take too long to be ready.
2840
 */
2841
 
2842
static void stl_cd1400ccrwait(struct stlport *portp)
2843
{
2844
        int     i;
2845
 
2846
        for (i = 0; i < CCR_MAXWAIT; i++)
2847
                if (stl_cd1400getreg(portp, CCR) == 0)
2848
                        return;
2849
 
2850
        printk("STALLION: cd1400 not responding, port=%d panel=%d brd=%d\n",
2851
                portp->portnr, portp->panelnr, portp->brdnr);
2852
}
2853
 
2854
/*****************************************************************************/
2855
 
2856
/*
2857
 *      Set up the cd1400 registers for a port based on the termios port
2858
 *      settings.
2859
 */
2860
 
2861
static void stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp)
2862
{
2863
        struct stlbrd   *brdp;
2864
        unsigned long   flags;
2865
        unsigned int    clkdiv, baudrate;
2866
        unsigned char   cor1, cor2, cor3;
2867
        unsigned char   cor4, cor5, ccr;
2868
        unsigned char   srer, sreron, sreroff;
2869
        unsigned char   mcor1, mcor2, rtpr;
2870
        unsigned char   clk, div;
2871
 
2872
        cor1 = 0;
2873
        cor2 = 0;
2874
        cor3 = 0;
2875
        cor4 = 0;
2876
        cor5 = 0;
2877
        ccr = 0;
2878
        rtpr = 0;
2879
        clk = 0;
2880
        div = 0;
2881
        mcor1 = 0;
2882
        mcor2 = 0;
2883
        sreron = 0;
2884
        sreroff = 0;
2885
 
2886
        brdp = stl_brds[portp->brdnr];
2887
        if (brdp == NULL)
2888
                return;
2889
 
2890
/*
2891
 *      Set up the RX char ignore mask with those RX error types we
2892
 *      can ignore. We can get the cd1400 to help us out a little here,
2893
 *      it will ignore parity errors and breaks for us.
2894
 */
2895
        portp->rxignoremsk = 0;
2896
        if (tiosp->c_iflag & IGNPAR) {
2897
                portp->rxignoremsk |= (ST_PARITY | ST_FRAMING | ST_OVERRUN);
2898
                cor1 |= COR1_PARIGNORE;
2899
        }
2900
        if (tiosp->c_iflag & IGNBRK) {
2901
                portp->rxignoremsk |= ST_BREAK;
2902
                cor4 |= COR4_IGNBRK;
2903
        }
2904
 
2905
        portp->rxmarkmsk = ST_OVERRUN;
2906
        if (tiosp->c_iflag & (INPCK | PARMRK))
2907
                portp->rxmarkmsk |= (ST_PARITY | ST_FRAMING);
2908
        if (tiosp->c_iflag & BRKINT)
2909
                portp->rxmarkmsk |= ST_BREAK;
2910
 
2911
/*
2912
 *      Go through the char size, parity and stop bits and set all the
2913
 *      option register appropriately.
2914
 */
2915
        switch (tiosp->c_cflag & CSIZE) {
2916
        case CS5:
2917
                cor1 |= COR1_CHL5;
2918
                break;
2919
        case CS6:
2920
                cor1 |= COR1_CHL6;
2921
                break;
2922
        case CS7:
2923
                cor1 |= COR1_CHL7;
2924
                break;
2925
        default:
2926
                cor1 |= COR1_CHL8;
2927
                break;
2928
        }
2929
 
2930
        if (tiosp->c_cflag & CSTOPB)
2931
                cor1 |= COR1_STOP2;
2932
        else
2933
                cor1 |= COR1_STOP1;
2934
 
2935
        if (tiosp->c_cflag & PARENB) {
2936
                if (tiosp->c_cflag & PARODD)
2937
                        cor1 |= (COR1_PARENB | COR1_PARODD);
2938
                else
2939
                        cor1 |= (COR1_PARENB | COR1_PAREVEN);
2940
        } else {
2941
                cor1 |= COR1_PARNONE;
2942
        }
2943
 
2944
/*
2945
 *      Set the RX FIFO threshold at 6 chars. This gives a bit of breathing
2946
 *      space for hardware flow control and the like. This should be set to
2947
 *      VMIN. Also here we will set the RX data timeout to 10ms - this should
2948
 *      really be based on VTIME.
2949
 */
2950
        cor3 |= FIFO_RXTHRESHOLD;
2951
        rtpr = 2;
2952
 
2953
/*
2954
 *      Calculate the baud rate timers. For now we will just assume that
2955
 *      the input and output baud are the same. Could have used a baud
2956
 *      table here, but this way we can generate virtually any baud rate
2957
 *      we like!
2958
 */
2959
        baudrate = tiosp->c_cflag & CBAUD;
2960
        if (baudrate & CBAUDEX) {
2961
                baudrate &= ~CBAUDEX;
2962
                if ((baudrate < 1) || (baudrate > 4))
2963
                        tiosp->c_cflag &= ~CBAUDEX;
2964
                else
2965
                        baudrate += 15;
2966
        }
2967
        baudrate = stl_baudrates[baudrate];
2968
        if ((tiosp->c_cflag & CBAUD) == B38400) {
2969
                if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2970
                        baudrate = 57600;
2971
                else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2972
                        baudrate = 115200;
2973
                else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2974
                        baudrate = 230400;
2975
                else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2976
                        baudrate = 460800;
2977
                else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
2978
                        baudrate = (portp->baud_base / portp->custom_divisor);
2979
        }
2980
        if (baudrate > STL_CD1400MAXBAUD)
2981
                baudrate = STL_CD1400MAXBAUD;
2982
 
2983
        if (baudrate > 0) {
2984
                for (clk = 0; clk < CD1400_NUMCLKS; clk++) {
2985
                        clkdiv = (portp->clk / stl_cd1400clkdivs[clk]) / baudrate;
2986
                        if (clkdiv < 0x100)
2987
                                break;
2988
                }
2989
                div = (unsigned char) clkdiv;
2990
        }
2991
 
2992
/*
2993
 *      Check what form of modem signaling is required and set it up.
2994
 */
2995
        if ((tiosp->c_cflag & CLOCAL) == 0) {
2996
                mcor1 |= MCOR1_DCD;
2997
                mcor2 |= MCOR2_DCD;
2998
                sreron |= SRER_MODEM;
2999
                portp->flags |= ASYNC_CHECK_CD;
3000
        } else
3001
                portp->flags &= ~ASYNC_CHECK_CD;
3002
 
3003
/*
3004
 *      Setup cd1400 enhanced modes if we can. In particular we want to
3005
 *      handle as much of the flow control as possible automatically. As
3006
 *      well as saving a few CPU cycles it will also greatly improve flow
3007
 *      control reliability.
3008
 */
3009
        if (tiosp->c_iflag & IXON) {
3010
                cor2 |= COR2_TXIBE;
3011
                cor3 |= COR3_SCD12;
3012
                if (tiosp->c_iflag & IXANY)
3013
                        cor2 |= COR2_IXM;
3014
        }
3015
 
3016
        if (tiosp->c_cflag & CRTSCTS) {
3017
                cor2 |= COR2_CTSAE;
3018
                mcor1 |= FIFO_RTSTHRESHOLD;
3019
        }
3020
 
3021
/*
3022
 *      All cd1400 register values calculated so go through and set
3023
 *      them all up.
3024
 */
3025
 
3026
        pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
3027
                portp->portnr, portp->panelnr, portp->brdnr);
3028
        pr_debug("    cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n",
3029
                cor1, cor2, cor3, cor4, cor5);
3030
        pr_debug("    mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
3031
                mcor1, mcor2, rtpr, sreron, sreroff);
3032
        pr_debug("    tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
3033
        pr_debug("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
3034
                tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
3035
                tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
3036
 
3037
        spin_lock_irqsave(&brd_lock, flags);
3038
        BRDENABLE(portp->brdnr, portp->pagenr);
3039
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3040
        srer = stl_cd1400getreg(portp, SRER);
3041
        stl_cd1400setreg(portp, SRER, 0);
3042
        if (stl_cd1400updatereg(portp, COR1, cor1))
3043
                ccr = 1;
3044
        if (stl_cd1400updatereg(portp, COR2, cor2))
3045
                ccr = 1;
3046
        if (stl_cd1400updatereg(portp, COR3, cor3))
3047
                ccr = 1;
3048
        if (ccr) {
3049
                stl_cd1400ccrwait(portp);
3050
                stl_cd1400setreg(portp, CCR, CCR_CORCHANGE);
3051
        }
3052
        stl_cd1400setreg(portp, COR4, cor4);
3053
        stl_cd1400setreg(portp, COR5, cor5);
3054
        stl_cd1400setreg(portp, MCOR1, mcor1);
3055
        stl_cd1400setreg(portp, MCOR2, mcor2);
3056
        if (baudrate > 0) {
3057
                stl_cd1400setreg(portp, TCOR, clk);
3058
                stl_cd1400setreg(portp, TBPR, div);
3059
                stl_cd1400setreg(portp, RCOR, clk);
3060
                stl_cd1400setreg(portp, RBPR, div);
3061
        }
3062
        stl_cd1400setreg(portp, SCHR1, tiosp->c_cc[VSTART]);
3063
        stl_cd1400setreg(portp, SCHR2, tiosp->c_cc[VSTOP]);
3064
        stl_cd1400setreg(portp, SCHR3, tiosp->c_cc[VSTART]);
3065
        stl_cd1400setreg(portp, SCHR4, tiosp->c_cc[VSTOP]);
3066
        stl_cd1400setreg(portp, RTPR, rtpr);
3067
        mcor1 = stl_cd1400getreg(portp, MSVR1);
3068
        if (mcor1 & MSVR1_DCD)
3069
                portp->sigs |= TIOCM_CD;
3070
        else
3071
                portp->sigs &= ~TIOCM_CD;
3072
        stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron));
3073
        BRDDISABLE(portp->brdnr);
3074
        spin_unlock_irqrestore(&brd_lock, flags);
3075
}
3076
 
3077
/*****************************************************************************/
3078
 
3079
/*
3080
 *      Set the state of the DTR and RTS signals.
3081
 */
3082
 
3083
static void stl_cd1400setsignals(struct stlport *portp, int dtr, int rts)
3084
{
3085
        unsigned char   msvr1, msvr2;
3086
        unsigned long   flags;
3087
 
3088
        pr_debug("stl_cd1400setsignals(portp=%p,dtr=%d,rts=%d)\n",
3089
                        portp, dtr, rts);
3090
 
3091
        msvr1 = 0;
3092
        msvr2 = 0;
3093
        if (dtr > 0)
3094
                msvr1 = MSVR1_DTR;
3095
        if (rts > 0)
3096
                msvr2 = MSVR2_RTS;
3097
 
3098
        spin_lock_irqsave(&brd_lock, flags);
3099
        BRDENABLE(portp->brdnr, portp->pagenr);
3100
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3101
        if (rts >= 0)
3102
                stl_cd1400setreg(portp, MSVR2, msvr2);
3103
        if (dtr >= 0)
3104
                stl_cd1400setreg(portp, MSVR1, msvr1);
3105
        BRDDISABLE(portp->brdnr);
3106
        spin_unlock_irqrestore(&brd_lock, flags);
3107
}
3108
 
3109
/*****************************************************************************/
3110
 
3111
/*
3112
 *      Return the state of the signals.
3113
 */
3114
 
3115
static int stl_cd1400getsignals(struct stlport *portp)
3116
{
3117
        unsigned char   msvr1, msvr2;
3118
        unsigned long   flags;
3119
        int             sigs;
3120
 
3121
        pr_debug("stl_cd1400getsignals(portp=%p)\n", portp);
3122
 
3123
        spin_lock_irqsave(&brd_lock, flags);
3124
        BRDENABLE(portp->brdnr, portp->pagenr);
3125
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3126
        msvr1 = stl_cd1400getreg(portp, MSVR1);
3127
        msvr2 = stl_cd1400getreg(portp, MSVR2);
3128
        BRDDISABLE(portp->brdnr);
3129
        spin_unlock_irqrestore(&brd_lock, flags);
3130
 
3131
        sigs = 0;
3132
        sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0;
3133
        sigs |= (msvr1 & MSVR1_CTS) ? TIOCM_CTS : 0;
3134
        sigs |= (msvr1 & MSVR1_DTR) ? TIOCM_DTR : 0;
3135
        sigs |= (msvr2 & MSVR2_RTS) ? TIOCM_RTS : 0;
3136
#if 0
3137
        sigs |= (msvr1 & MSVR1_RI) ? TIOCM_RI : 0;
3138
        sigs |= (msvr1 & MSVR1_DSR) ? TIOCM_DSR : 0;
3139
#else
3140
        sigs |= TIOCM_DSR;
3141
#endif
3142
        return sigs;
3143
}
3144
 
3145
/*****************************************************************************/
3146
 
3147
/*
3148
 *      Enable/Disable the Transmitter and/or Receiver.
3149
 */
3150
 
3151
static void stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx)
3152
{
3153
        unsigned char   ccr;
3154
        unsigned long   flags;
3155
 
3156
        pr_debug("stl_cd1400enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
3157
 
3158
        ccr = 0;
3159
 
3160
        if (tx == 0)
3161
                ccr |= CCR_TXDISABLE;
3162
        else if (tx > 0)
3163
                ccr |= CCR_TXENABLE;
3164
        if (rx == 0)
3165
                ccr |= CCR_RXDISABLE;
3166
        else if (rx > 0)
3167
                ccr |= CCR_RXENABLE;
3168
 
3169
        spin_lock_irqsave(&brd_lock, flags);
3170
        BRDENABLE(portp->brdnr, portp->pagenr);
3171
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3172
        stl_cd1400ccrwait(portp);
3173
        stl_cd1400setreg(portp, CCR, ccr);
3174
        stl_cd1400ccrwait(portp);
3175
        BRDDISABLE(portp->brdnr);
3176
        spin_unlock_irqrestore(&brd_lock, flags);
3177
}
3178
 
3179
/*****************************************************************************/
3180
 
3181
/*
3182
 *      Start/stop the Transmitter and/or Receiver.
3183
 */
3184
 
3185
static void stl_cd1400startrxtx(struct stlport *portp, int rx, int tx)
3186
{
3187
        unsigned char   sreron, sreroff;
3188
        unsigned long   flags;
3189
 
3190
        pr_debug("stl_cd1400startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
3191
 
3192
        sreron = 0;
3193
        sreroff = 0;
3194
        if (tx == 0)
3195
                sreroff |= (SRER_TXDATA | SRER_TXEMPTY);
3196
        else if (tx == 1)
3197
                sreron |= SRER_TXDATA;
3198
        else if (tx >= 2)
3199
                sreron |= SRER_TXEMPTY;
3200
        if (rx == 0)
3201
                sreroff |= SRER_RXDATA;
3202
        else if (rx > 0)
3203
                sreron |= SRER_RXDATA;
3204
 
3205
        spin_lock_irqsave(&brd_lock, flags);
3206
        BRDENABLE(portp->brdnr, portp->pagenr);
3207
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3208
        stl_cd1400setreg(portp, SRER,
3209
                ((stl_cd1400getreg(portp, SRER) & ~sreroff) | sreron));
3210
        BRDDISABLE(portp->brdnr);
3211
        if (tx > 0)
3212
                set_bit(ASYI_TXBUSY, &portp->istate);
3213
        spin_unlock_irqrestore(&brd_lock, flags);
3214
}
3215
 
3216
/*****************************************************************************/
3217
 
3218
/*
3219
 *      Disable all interrupts from this port.
3220
 */
3221
 
3222
static void stl_cd1400disableintrs(struct stlport *portp)
3223
{
3224
        unsigned long   flags;
3225
 
3226
        pr_debug("stl_cd1400disableintrs(portp=%p)\n", portp);
3227
 
3228
        spin_lock_irqsave(&brd_lock, flags);
3229
        BRDENABLE(portp->brdnr, portp->pagenr);
3230
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3231
        stl_cd1400setreg(portp, SRER, 0);
3232
        BRDDISABLE(portp->brdnr);
3233
        spin_unlock_irqrestore(&brd_lock, flags);
3234
}
3235
 
3236
/*****************************************************************************/
3237
 
3238
static void stl_cd1400sendbreak(struct stlport *portp, int len)
3239
{
3240
        unsigned long   flags;
3241
 
3242
        pr_debug("stl_cd1400sendbreak(portp=%p,len=%d)\n", portp, len);
3243
 
3244
        spin_lock_irqsave(&brd_lock, flags);
3245
        BRDENABLE(portp->brdnr, portp->pagenr);
3246
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3247
        stl_cd1400setreg(portp, SRER,
3248
                ((stl_cd1400getreg(portp, SRER) & ~SRER_TXDATA) |
3249
                SRER_TXEMPTY));
3250
        BRDDISABLE(portp->brdnr);
3251
        portp->brklen = len;
3252
        if (len == 1)
3253
                portp->stats.txbreaks++;
3254
        spin_unlock_irqrestore(&brd_lock, flags);
3255
}
3256
 
3257
/*****************************************************************************/
3258
 
3259
/*
3260
 *      Take flow control actions...
3261
 */
3262
 
3263
static void stl_cd1400flowctrl(struct stlport *portp, int state)
3264
{
3265
        struct tty_struct       *tty;
3266
        unsigned long           flags;
3267
 
3268
        pr_debug("stl_cd1400flowctrl(portp=%p,state=%x)\n", portp, state);
3269
 
3270
        if (portp == NULL)
3271
                return;
3272
        tty = portp->tty;
3273
        if (tty == NULL)
3274
                return;
3275
 
3276
        spin_lock_irqsave(&brd_lock, flags);
3277
        BRDENABLE(portp->brdnr, portp->pagenr);
3278
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3279
 
3280
        if (state) {
3281
                if (tty->termios->c_iflag & IXOFF) {
3282
                        stl_cd1400ccrwait(portp);
3283
                        stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3284
                        portp->stats.rxxon++;
3285
                        stl_cd1400ccrwait(portp);
3286
                }
3287
/*
3288
 *              Question: should we return RTS to what it was before? It may
3289
 *              have been set by an ioctl... Suppose not, since if you have
3290
 *              hardware flow control set then it is pretty silly to go and
3291
 *              set the RTS line by hand.
3292
 */
3293
                if (tty->termios->c_cflag & CRTSCTS) {
3294
                        stl_cd1400setreg(portp, MCOR1,
3295
                                (stl_cd1400getreg(portp, MCOR1) |
3296
                                FIFO_RTSTHRESHOLD));
3297
                        stl_cd1400setreg(portp, MSVR2, MSVR2_RTS);
3298
                        portp->stats.rxrtson++;
3299
                }
3300
        } else {
3301
                if (tty->termios->c_iflag & IXOFF) {
3302
                        stl_cd1400ccrwait(portp);
3303
                        stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3304
                        portp->stats.rxxoff++;
3305
                        stl_cd1400ccrwait(portp);
3306
                }
3307
                if (tty->termios->c_cflag & CRTSCTS) {
3308
                        stl_cd1400setreg(portp, MCOR1,
3309
                                (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3310
                        stl_cd1400setreg(portp, MSVR2, 0);
3311
                        portp->stats.rxrtsoff++;
3312
                }
3313
        }
3314
 
3315
        BRDDISABLE(portp->brdnr);
3316
        spin_unlock_irqrestore(&brd_lock, flags);
3317
}
3318
 
3319
/*****************************************************************************/
3320
 
3321
/*
3322
 *      Send a flow control character...
3323
 */
3324
 
3325
static void stl_cd1400sendflow(struct stlport *portp, int state)
3326
{
3327
        struct tty_struct       *tty;
3328
        unsigned long           flags;
3329
 
3330
        pr_debug("stl_cd1400sendflow(portp=%p,state=%x)\n", portp, state);
3331
 
3332
        if (portp == NULL)
3333
                return;
3334
        tty = portp->tty;
3335
        if (tty == NULL)
3336
                return;
3337
 
3338
        spin_lock_irqsave(&brd_lock, flags);
3339
        BRDENABLE(portp->brdnr, portp->pagenr);
3340
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3341
        if (state) {
3342
                stl_cd1400ccrwait(portp);
3343
                stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3344
                portp->stats.rxxon++;
3345
                stl_cd1400ccrwait(portp);
3346
        } else {
3347
                stl_cd1400ccrwait(portp);
3348
                stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3349
                portp->stats.rxxoff++;
3350
                stl_cd1400ccrwait(portp);
3351
        }
3352
        BRDDISABLE(portp->brdnr);
3353
        spin_unlock_irqrestore(&brd_lock, flags);
3354
}
3355
 
3356
/*****************************************************************************/
3357
 
3358
static void stl_cd1400flush(struct stlport *portp)
3359
{
3360
        unsigned long   flags;
3361
 
3362
        pr_debug("stl_cd1400flush(portp=%p)\n", portp);
3363
 
3364
        if (portp == NULL)
3365
                return;
3366
 
3367
        spin_lock_irqsave(&brd_lock, flags);
3368
        BRDENABLE(portp->brdnr, portp->pagenr);
3369
        stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3370
        stl_cd1400ccrwait(portp);
3371
        stl_cd1400setreg(portp, CCR, CCR_TXFLUSHFIFO);
3372
        stl_cd1400ccrwait(portp);
3373
        portp->tx.tail = portp->tx.head;
3374
        BRDDISABLE(portp->brdnr);
3375
        spin_unlock_irqrestore(&brd_lock, flags);
3376
}
3377
 
3378
/*****************************************************************************/
3379
 
3380
/*
3381
 *      Return the current state of data flow on this port. This is only
3382
 *      really interresting when determining if data has fully completed
3383
 *      transmission or not... This is easy for the cd1400, it accurately
3384
 *      maintains the busy port flag.
3385
 */
3386
 
3387
static int stl_cd1400datastate(struct stlport *portp)
3388
{
3389
        pr_debug("stl_cd1400datastate(portp=%p)\n", portp);
3390
 
3391
        if (portp == NULL)
3392
                return 0;
3393
 
3394
        return test_bit(ASYI_TXBUSY, &portp->istate) ? 1 : 0;
3395
}
3396
 
3397
/*****************************************************************************/
3398
 
3399
/*
3400
 *      Interrupt service routine for cd1400 EasyIO boards.
3401
 */
3402
 
3403
static void stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase)
3404
{
3405
        unsigned char   svrtype;
3406
 
3407
        pr_debug("stl_cd1400eiointr(panelp=%p,iobase=%x)\n", panelp, iobase);
3408
 
3409
        spin_lock(&brd_lock);
3410
        outb(SVRR, iobase);
3411
        svrtype = inb(iobase + EREG_DATA);
3412
        if (panelp->nrports > 4) {
3413
                outb((SVRR + 0x80), iobase);
3414
                svrtype |= inb(iobase + EREG_DATA);
3415
        }
3416
 
3417
        if (svrtype & SVRR_RX)
3418
                stl_cd1400rxisr(panelp, iobase);
3419
        else if (svrtype & SVRR_TX)
3420
                stl_cd1400txisr(panelp, iobase);
3421
        else if (svrtype & SVRR_MDM)
3422
                stl_cd1400mdmisr(panelp, iobase);
3423
 
3424
        spin_unlock(&brd_lock);
3425
}
3426
 
3427
/*****************************************************************************/
3428
 
3429
/*
3430
 *      Interrupt service routine for cd1400 panels.
3431
 */
3432
 
3433
static void stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase)
3434
{
3435
        unsigned char   svrtype;
3436
 
3437
        pr_debug("stl_cd1400echintr(panelp=%p,iobase=%x)\n", panelp, iobase);
3438
 
3439
        outb(SVRR, iobase);
3440
        svrtype = inb(iobase + EREG_DATA);
3441
        outb((SVRR + 0x80), iobase);
3442
        svrtype |= inb(iobase + EREG_DATA);
3443
        if (svrtype & SVRR_RX)
3444
                stl_cd1400rxisr(panelp, iobase);
3445
        else if (svrtype & SVRR_TX)
3446
                stl_cd1400txisr(panelp, iobase);
3447
        else if (svrtype & SVRR_MDM)
3448
                stl_cd1400mdmisr(panelp, iobase);
3449
}
3450
 
3451
 
3452
/*****************************************************************************/
3453
 
3454
/*
3455
 *      Unfortunately we need to handle breaks in the TX data stream, since
3456
 *      this is the only way to generate them on the cd1400.
3457
 */
3458
 
3459
static int stl_cd1400breakisr(struct stlport *portp, int ioaddr)
3460
{
3461
        if (portp->brklen == 1) {
3462
                outb((COR2 + portp->uartaddr), ioaddr);
3463
                outb((inb(ioaddr + EREG_DATA) | COR2_ETC),
3464
                        (ioaddr + EREG_DATA));
3465
                outb((TDR + portp->uartaddr), ioaddr);
3466
                outb(ETC_CMD, (ioaddr + EREG_DATA));
3467
                outb(ETC_STARTBREAK, (ioaddr + EREG_DATA));
3468
                outb((SRER + portp->uartaddr), ioaddr);
3469
                outb((inb(ioaddr + EREG_DATA) & ~(SRER_TXDATA | SRER_TXEMPTY)),
3470
                        (ioaddr + EREG_DATA));
3471
                return 1;
3472
        } else if (portp->brklen > 1) {
3473
                outb((TDR + portp->uartaddr), ioaddr);
3474
                outb(ETC_CMD, (ioaddr + EREG_DATA));
3475
                outb(ETC_STOPBREAK, (ioaddr + EREG_DATA));
3476
                portp->brklen = -1;
3477
                return 1;
3478
        } else {
3479
                outb((COR2 + portp->uartaddr), ioaddr);
3480
                outb((inb(ioaddr + EREG_DATA) & ~COR2_ETC),
3481
                        (ioaddr + EREG_DATA));
3482
                portp->brklen = 0;
3483
        }
3484
        return 0;
3485
}
3486
 
3487
/*****************************************************************************/
3488
 
3489
/*
3490
 *      Transmit interrupt handler. This has gotta be fast!  Handling TX
3491
 *      chars is pretty simple, stuff as many as possible from the TX buffer
3492
 *      into the cd1400 FIFO. Must also handle TX breaks here, since they
3493
 *      are embedded as commands in the data stream. Oh no, had to use a goto!
3494
 *      This could be optimized more, will do when I get time...
3495
 *      In practice it is possible that interrupts are enabled but that the
3496
 *      port has been hung up. Need to handle not having any TX buffer here,
3497
 *      this is done by using the side effect that head and tail will also
3498
 *      be NULL if the buffer has been freed.
3499
 */
3500
 
3501
static void stl_cd1400txisr(struct stlpanel *panelp, int ioaddr)
3502
{
3503
        struct stlport  *portp;
3504
        int             len, stlen;
3505
        char            *head, *tail;
3506
        unsigned char   ioack, srer;
3507
 
3508
        pr_debug("stl_cd1400txisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr);
3509
 
3510
        ioack = inb(ioaddr + EREG_TXACK);
3511
        if (((ioack & panelp->ackmask) != 0) ||
3512
            ((ioack & ACK_TYPMASK) != ACK_TYPTX)) {
3513
                printk("STALLION: bad TX interrupt ack value=%x\n", ioack);
3514
                return;
3515
        }
3516
        portp = panelp->ports[(ioack >> 3)];
3517
 
3518
/*
3519
 *      Unfortunately we need to handle breaks in the data stream, since
3520
 *      this is the only way to generate them on the cd1400. Do it now if
3521
 *      a break is to be sent.
3522
 */
3523
        if (portp->brklen != 0)
3524
                if (stl_cd1400breakisr(portp, ioaddr))
3525
                        goto stl_txalldone;
3526
 
3527
        head = portp->tx.head;
3528
        tail = portp->tx.tail;
3529
        len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
3530
        if ((len == 0) || ((len < STL_TXBUFLOW) &&
3531
            (test_bit(ASYI_TXLOW, &portp->istate) == 0))) {
3532
                set_bit(ASYI_TXLOW, &portp->istate);
3533
                schedule_work(&portp->tqueue);
3534
        }
3535
 
3536
        if (len == 0) {
3537
                outb((SRER + portp->uartaddr), ioaddr);
3538
                srer = inb(ioaddr + EREG_DATA);
3539
                if (srer & SRER_TXDATA) {
3540
                        srer = (srer & ~SRER_TXDATA) | SRER_TXEMPTY;
3541
                } else {
3542
                        srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
3543
                        clear_bit(ASYI_TXBUSY, &portp->istate);
3544
                }
3545
                outb(srer, (ioaddr + EREG_DATA));
3546
        } else {
3547
                len = min(len, CD1400_TXFIFOSIZE);
3548
                portp->stats.txtotal += len;
3549
                stlen = min(len, ((portp->tx.buf + STL_TXBUFSIZE) - tail));
3550
                outb((TDR + portp->uartaddr), ioaddr);
3551
                outsb((ioaddr + EREG_DATA), tail, stlen);
3552
                len -= stlen;
3553
                tail += stlen;
3554
                if (tail >= (portp->tx.buf + STL_TXBUFSIZE))
3555
                        tail = portp->tx.buf;
3556
                if (len > 0) {
3557
                        outsb((ioaddr + EREG_DATA), tail, len);
3558
                        tail += len;
3559
                }
3560
                portp->tx.tail = tail;
3561
        }
3562
 
3563
stl_txalldone:
3564
        outb((EOSRR + portp->uartaddr), ioaddr);
3565
        outb(0, (ioaddr + EREG_DATA));
3566
}
3567
 
3568
/*****************************************************************************/
3569
 
3570
/*
3571
 *      Receive character interrupt handler. Determine if we have good chars
3572
 *      or bad chars and then process appropriately. Good chars are easy
3573
 *      just shove the lot into the RX buffer and set all status byte to 0.
3574
 *      If a bad RX char then process as required. This routine needs to be
3575
 *      fast!  In practice it is possible that we get an interrupt on a port
3576
 *      that is closed. This can happen on hangups - since they completely
3577
 *      shutdown a port not in user context. Need to handle this case.
3578
 */
3579
 
3580
static void stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr)
3581
{
3582
        struct stlport          *portp;
3583
        struct tty_struct       *tty;
3584
        unsigned int            ioack, len, buflen;
3585
        unsigned char           status;
3586
        char                    ch;
3587
 
3588
        pr_debug("stl_cd1400rxisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr);
3589
 
3590
        ioack = inb(ioaddr + EREG_RXACK);
3591
        if ((ioack & panelp->ackmask) != 0) {
3592
                printk("STALLION: bad RX interrupt ack value=%x\n", ioack);
3593
                return;
3594
        }
3595
        portp = panelp->ports[(ioack >> 3)];
3596
        tty = portp->tty;
3597
 
3598
        if ((ioack & ACK_TYPMASK) == ACK_TYPRXGOOD) {
3599
                outb((RDCR + portp->uartaddr), ioaddr);
3600
                len = inb(ioaddr + EREG_DATA);
3601
                if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
3602
                        len = min(len, sizeof(stl_unwanted));
3603
                        outb((RDSR + portp->uartaddr), ioaddr);
3604
                        insb((ioaddr + EREG_DATA), &stl_unwanted[0], len);
3605
                        portp->stats.rxlost += len;
3606
                        portp->stats.rxtotal += len;
3607
                } else {
3608
                        len = min(len, buflen);
3609
                        if (len > 0) {
3610
                                unsigned char *ptr;
3611
                                outb((RDSR + portp->uartaddr), ioaddr);
3612
                                tty_prepare_flip_string(tty, &ptr, len);
3613
                                insb((ioaddr + EREG_DATA), ptr, len);
3614
                                tty_schedule_flip(tty);
3615
                                portp->stats.rxtotal += len;
3616
                        }
3617
                }
3618
        } else if ((ioack & ACK_TYPMASK) == ACK_TYPRXBAD) {
3619
                outb((RDSR + portp->uartaddr), ioaddr);
3620
                status = inb(ioaddr + EREG_DATA);
3621
                ch = inb(ioaddr + EREG_DATA);
3622
                if (status & ST_PARITY)
3623
                        portp->stats.rxparity++;
3624
                if (status & ST_FRAMING)
3625
                        portp->stats.rxframing++;
3626
                if (status & ST_OVERRUN)
3627
                        portp->stats.rxoverrun++;
3628
                if (status & ST_BREAK)
3629
                        portp->stats.rxbreaks++;
3630
                if (status & ST_SCHARMASK) {
3631
                        if ((status & ST_SCHARMASK) == ST_SCHAR1)
3632
                                portp->stats.txxon++;
3633
                        if ((status & ST_SCHARMASK) == ST_SCHAR2)
3634
                                portp->stats.txxoff++;
3635
                        goto stl_rxalldone;
3636
                }
3637
                if (tty != NULL && (portp->rxignoremsk & status) == 0) {
3638
                        if (portp->rxmarkmsk & status) {
3639
                                if (status & ST_BREAK) {
3640
                                        status = TTY_BREAK;
3641
                                        if (portp->flags & ASYNC_SAK) {
3642
                                                do_SAK(tty);
3643
                                                BRDENABLE(portp->brdnr, portp->pagenr);
3644
                                        }
3645
                                } else if (status & ST_PARITY)
3646
                                        status = TTY_PARITY;
3647
                                else if (status & ST_FRAMING)
3648
                                        status = TTY_FRAME;
3649
                                else if(status & ST_OVERRUN)
3650
                                        status = TTY_OVERRUN;
3651
                                else
3652
                                        status = 0;
3653
                        } else
3654
                                status = 0;
3655
                        tty_insert_flip_char(tty, ch, status);
3656
                        tty_schedule_flip(tty);
3657
                }
3658
        } else {
3659
                printk("STALLION: bad RX interrupt ack value=%x\n", ioack);
3660
                return;
3661
        }
3662
 
3663
stl_rxalldone:
3664
        outb((EOSRR + portp->uartaddr), ioaddr);
3665
        outb(0, (ioaddr + EREG_DATA));
3666
}
3667
 
3668
/*****************************************************************************/
3669
 
3670
/*
3671
 *      Modem interrupt handler. The is called when the modem signal line
3672
 *      (DCD) has changed state. Leave most of the work to the off-level
3673
 *      processing routine.
3674
 */
3675
 
3676
static void stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr)
3677
{
3678
        struct stlport  *portp;
3679
        unsigned int    ioack;
3680
        unsigned char   misr;
3681
 
3682
        pr_debug("stl_cd1400mdmisr(panelp=%p)\n", panelp);
3683
 
3684
        ioack = inb(ioaddr + EREG_MDACK);
3685
        if (((ioack & panelp->ackmask) != 0) ||
3686
            ((ioack & ACK_TYPMASK) != ACK_TYPMDM)) {
3687
                printk("STALLION: bad MODEM interrupt ack value=%x\n", ioack);
3688
                return;
3689
        }
3690
        portp = panelp->ports[(ioack >> 3)];
3691
 
3692
        outb((MISR + portp->uartaddr), ioaddr);
3693
        misr = inb(ioaddr + EREG_DATA);
3694
        if (misr & MISR_DCD) {
3695
                set_bit(ASYI_DCDCHANGE, &portp->istate);
3696
                schedule_work(&portp->tqueue);
3697
                portp->stats.modem++;
3698
        }
3699
 
3700
        outb((EOSRR + portp->uartaddr), ioaddr);
3701
        outb(0, (ioaddr + EREG_DATA));
3702
}
3703
 
3704
/*****************************************************************************/
3705
/*                      SC26198 HARDWARE FUNCTIONS                           */
3706
/*****************************************************************************/
3707
 
3708
/*
3709
 *      These functions get/set/update the registers of the sc26198 UARTs.
3710
 *      Access to the sc26198 registers is via an address/data io port pair.
3711
 *      (Maybe should make this inline...)
3712
 */
3713
 
3714
static int stl_sc26198getreg(struct stlport *portp, int regnr)
3715
{
3716
        outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3717
        return inb(portp->ioaddr + XP_DATA);
3718
}
3719
 
3720
static void stl_sc26198setreg(struct stlport *portp, int regnr, int value)
3721
{
3722
        outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3723
        outb(value, (portp->ioaddr + XP_DATA));
3724
}
3725
 
3726
static int stl_sc26198updatereg(struct stlport *portp, int regnr, int value)
3727
{
3728
        outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
3729
        if (inb(portp->ioaddr + XP_DATA) != value) {
3730
                outb(value, (portp->ioaddr + XP_DATA));
3731
                return 1;
3732
        }
3733
        return 0;
3734
}
3735
 
3736
/*****************************************************************************/
3737
 
3738
/*
3739
 *      Functions to get and set the sc26198 global registers.
3740
 */
3741
 
3742
static int stl_sc26198getglobreg(struct stlport *portp, int regnr)
3743
{
3744
        outb(regnr, (portp->ioaddr + XP_ADDR));
3745
        return inb(portp->ioaddr + XP_DATA);
3746
}
3747
 
3748
#if 0
3749
static void stl_sc26198setglobreg(struct stlport *portp, int regnr, int value)
3750
{
3751
        outb(regnr, (portp->ioaddr + XP_ADDR));
3752
        outb(value, (portp->ioaddr + XP_DATA));
3753
}
3754
#endif
3755
 
3756
/*****************************************************************************/
3757
 
3758
/*
3759
 *      Inbitialize the UARTs in a panel. We don't care what sort of board
3760
 *      these ports are on - since the port io registers are almost
3761
 *      identical when dealing with ports.
3762
 */
3763
 
3764
static int stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
3765
{
3766
        int     chipmask, i;
3767
        int     nrchips, ioaddr;
3768
 
3769
        pr_debug("stl_sc26198panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
3770
 
3771
        BRDENABLE(panelp->brdnr, panelp->pagenr);
3772
 
3773
/*
3774
 *      Check that each chip is present and started up OK.
3775
 */
3776
        chipmask = 0;
3777
        nrchips = (panelp->nrports + 4) / SC26198_PORTS;
3778
        if (brdp->brdtype == BRD_ECHPCI)
3779
                outb(panelp->pagenr, brdp->ioctrl);
3780
 
3781
        for (i = 0; i < nrchips; i++) {
3782
                ioaddr = panelp->iobase + (i * 4);
3783
                outb(SCCR, (ioaddr + XP_ADDR));
3784
                outb(CR_RESETALL, (ioaddr + XP_DATA));
3785
                outb(TSTR, (ioaddr + XP_ADDR));
3786
                if (inb(ioaddr + XP_DATA) != 0) {
3787
                        printk("STALLION: sc26198 not responding, "
3788
                                "brd=%d panel=%d chip=%d\n",
3789
                                panelp->brdnr, panelp->panelnr, i);
3790
                        continue;
3791
                }
3792
                chipmask |= (0x1 << i);
3793
                outb(GCCR, (ioaddr + XP_ADDR));
3794
                outb(GCCR_IVRTYPCHANACK, (ioaddr + XP_DATA));
3795
                outb(WDTRCR, (ioaddr + XP_ADDR));
3796
                outb(0xff, (ioaddr + XP_DATA));
3797
        }
3798
 
3799
        BRDDISABLE(panelp->brdnr);
3800
        return chipmask;
3801
}
3802
 
3803
/*****************************************************************************/
3804
 
3805
/*
3806
 *      Initialize hardware specific port registers.
3807
 */
3808
 
3809
static void stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
3810
{
3811
        pr_debug("stl_sc26198portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
3812
                        panelp, portp);
3813
 
3814
        if ((brdp == NULL) || (panelp == NULL) ||
3815
            (portp == NULL))
3816
                return;
3817
 
3818
        portp->ioaddr = panelp->iobase + ((portp->portnr < 8) ? 0 : 4);
3819
        portp->uartaddr = (portp->portnr & 0x07) << 4;
3820
        portp->pagenr = panelp->pagenr;
3821
        portp->hwid = 0x1;
3822
 
3823
        BRDENABLE(portp->brdnr, portp->pagenr);
3824
        stl_sc26198setreg(portp, IOPCR, IOPCR_SETSIGS);
3825
        BRDDISABLE(portp->brdnr);
3826
}
3827
 
3828
/*****************************************************************************/
3829
 
3830
/*
3831
 *      Set up the sc26198 registers for a port based on the termios port
3832
 *      settings.
3833
 */
3834
 
3835
static void stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp)
3836
{
3837
        struct stlbrd   *brdp;
3838
        unsigned long   flags;
3839
        unsigned int    baudrate;
3840
        unsigned char   mr0, mr1, mr2, clk;
3841
        unsigned char   imron, imroff, iopr, ipr;
3842
 
3843
        mr0 = 0;
3844
        mr1 = 0;
3845
        mr2 = 0;
3846
        clk = 0;
3847
        iopr = 0;
3848
        imron = 0;
3849
        imroff = 0;
3850
 
3851
        brdp = stl_brds[portp->brdnr];
3852
        if (brdp == NULL)
3853
                return;
3854
 
3855
/*
3856
 *      Set up the RX char ignore mask with those RX error types we
3857
 *      can ignore.
3858
 */
3859
        portp->rxignoremsk = 0;
3860
        if (tiosp->c_iflag & IGNPAR)
3861
                portp->rxignoremsk |= (SR_RXPARITY | SR_RXFRAMING |
3862
                        SR_RXOVERRUN);
3863
        if (tiosp->c_iflag & IGNBRK)
3864
                portp->rxignoremsk |= SR_RXBREAK;
3865
 
3866
        portp->rxmarkmsk = SR_RXOVERRUN;
3867
        if (tiosp->c_iflag & (INPCK | PARMRK))
3868
                portp->rxmarkmsk |= (SR_RXPARITY | SR_RXFRAMING);
3869
        if (tiosp->c_iflag & BRKINT)
3870
                portp->rxmarkmsk |= SR_RXBREAK;
3871
 
3872
/*
3873
 *      Go through the char size, parity and stop bits and set all the
3874
 *      option register appropriately.
3875
 */
3876
        switch (tiosp->c_cflag & CSIZE) {
3877
        case CS5:
3878
                mr1 |= MR1_CS5;
3879
                break;
3880
        case CS6:
3881
                mr1 |= MR1_CS6;
3882
                break;
3883
        case CS7:
3884
                mr1 |= MR1_CS7;
3885
                break;
3886
        default:
3887
                mr1 |= MR1_CS8;
3888
                break;
3889
        }
3890
 
3891
        if (tiosp->c_cflag & CSTOPB)
3892
                mr2 |= MR2_STOP2;
3893
        else
3894
                mr2 |= MR2_STOP1;
3895
 
3896
        if (tiosp->c_cflag & PARENB) {
3897
                if (tiosp->c_cflag & PARODD)
3898
                        mr1 |= (MR1_PARENB | MR1_PARODD);
3899
                else
3900
                        mr1 |= (MR1_PARENB | MR1_PAREVEN);
3901
        } else
3902
                mr1 |= MR1_PARNONE;
3903
 
3904
        mr1 |= MR1_ERRBLOCK;
3905
 
3906
/*
3907
 *      Set the RX FIFO threshold at 8 chars. This gives a bit of breathing
3908
 *      space for hardware flow control and the like. This should be set to
3909
 *      VMIN.
3910
 */
3911
        mr2 |= MR2_RXFIFOHALF;
3912
 
3913
/*
3914
 *      Calculate the baud rate timers. For now we will just assume that
3915
 *      the input and output baud are the same. The sc26198 has a fixed
3916
 *      baud rate table, so only discrete baud rates possible.
3917
 */
3918
        baudrate = tiosp->c_cflag & CBAUD;
3919
        if (baudrate & CBAUDEX) {
3920
                baudrate &= ~CBAUDEX;
3921
                if ((baudrate < 1) || (baudrate > 4))
3922
                        tiosp->c_cflag &= ~CBAUDEX;
3923
                else
3924
                        baudrate += 15;
3925
        }
3926
        baudrate = stl_baudrates[baudrate];
3927
        if ((tiosp->c_cflag & CBAUD) == B38400) {
3928
                if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
3929
                        baudrate = 57600;
3930
                else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
3931
                        baudrate = 115200;
3932
                else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
3933
                        baudrate = 230400;
3934
                else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
3935
                        baudrate = 460800;
3936
                else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
3937
                        baudrate = (portp->baud_base / portp->custom_divisor);
3938
        }
3939
        if (baudrate > STL_SC26198MAXBAUD)
3940
                baudrate = STL_SC26198MAXBAUD;
3941
 
3942
        if (baudrate > 0)
3943
                for (clk = 0; clk < SC26198_NRBAUDS; clk++)
3944
                        if (baudrate <= sc26198_baudtable[clk])
3945
                                break;
3946
 
3947
/*
3948
 *      Check what form of modem signaling is required and set it up.
3949
 */
3950
        if (tiosp->c_cflag & CLOCAL) {
3951
                portp->flags &= ~ASYNC_CHECK_CD;
3952
        } else {
3953
                iopr |= IOPR_DCDCOS;
3954
                imron |= IR_IOPORT;
3955
                portp->flags |= ASYNC_CHECK_CD;
3956
        }
3957
 
3958
/*
3959
 *      Setup sc26198 enhanced modes if we can. In particular we want to
3960
 *      handle as much of the flow control as possible automatically. As
3961
 *      well as saving a few CPU cycles it will also greatly improve flow
3962
 *      control reliability.
3963
 */
3964
        if (tiosp->c_iflag & IXON) {
3965
                mr0 |= MR0_SWFTX | MR0_SWFT;
3966
                imron |= IR_XONXOFF;
3967
        } else
3968
                imroff |= IR_XONXOFF;
3969
 
3970
        if (tiosp->c_iflag & IXOFF)
3971
                mr0 |= MR0_SWFRX;
3972
 
3973
        if (tiosp->c_cflag & CRTSCTS) {
3974
                mr2 |= MR2_AUTOCTS;
3975
                mr1 |= MR1_AUTORTS;
3976
        }
3977
 
3978
/*
3979
 *      All sc26198 register values calculated so go through and set
3980
 *      them all up.
3981
 */
3982
 
3983
        pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
3984
                portp->portnr, portp->panelnr, portp->brdnr);
3985
        pr_debug("    mr0=%x mr1=%x mr2=%x clk=%x\n", mr0, mr1, mr2, clk);
3986
        pr_debug("    iopr=%x imron=%x imroff=%x\n", iopr, imron, imroff);
3987
        pr_debug("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
3988
                tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
3989
                tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
3990
 
3991
        spin_lock_irqsave(&brd_lock, flags);
3992
        BRDENABLE(portp->brdnr, portp->pagenr);
3993
        stl_sc26198setreg(portp, IMR, 0);
3994
        stl_sc26198updatereg(portp, MR0, mr0);
3995
        stl_sc26198updatereg(portp, MR1, mr1);
3996
        stl_sc26198setreg(portp, SCCR, CR_RXERRBLOCK);
3997
        stl_sc26198updatereg(portp, MR2, mr2);
3998
        stl_sc26198updatereg(portp, IOPIOR,
3999
                ((stl_sc26198getreg(portp, IOPIOR) & ~IPR_CHANGEMASK) | iopr));
4000
 
4001
        if (baudrate > 0) {
4002
                stl_sc26198setreg(portp, TXCSR, clk);
4003
                stl_sc26198setreg(portp, RXCSR, clk);
4004
        }
4005
 
4006
        stl_sc26198setreg(portp, XONCR, tiosp->c_cc[VSTART]);
4007
        stl_sc26198setreg(portp, XOFFCR, tiosp->c_cc[VSTOP]);
4008
 
4009
        ipr = stl_sc26198getreg(portp, IPR);
4010
        if (ipr & IPR_DCD)
4011
                portp->sigs &= ~TIOCM_CD;
4012
        else
4013
                portp->sigs |= TIOCM_CD;
4014
 
4015
        portp->imr = (portp->imr & ~imroff) | imron;
4016
        stl_sc26198setreg(portp, IMR, portp->imr);
4017
        BRDDISABLE(portp->brdnr);
4018
        spin_unlock_irqrestore(&brd_lock, flags);
4019
}
4020
 
4021
/*****************************************************************************/
4022
 
4023
/*
4024
 *      Set the state of the DTR and RTS signals.
4025
 */
4026
 
4027
static void stl_sc26198setsignals(struct stlport *portp, int dtr, int rts)
4028
{
4029
        unsigned char   iopioron, iopioroff;
4030
        unsigned long   flags;
4031
 
4032
        pr_debug("stl_sc26198setsignals(portp=%p,dtr=%d,rts=%d)\n", portp,
4033
                        dtr, rts);
4034
 
4035
        iopioron = 0;
4036
        iopioroff = 0;
4037
        if (dtr == 0)
4038
                iopioroff |= IPR_DTR;
4039
        else if (dtr > 0)
4040
                iopioron |= IPR_DTR;
4041
        if (rts == 0)
4042
                iopioroff |= IPR_RTS;
4043
        else if (rts > 0)
4044
                iopioron |= IPR_RTS;
4045
 
4046
        spin_lock_irqsave(&brd_lock, flags);
4047
        BRDENABLE(portp->brdnr, portp->pagenr);
4048
        stl_sc26198setreg(portp, IOPIOR,
4049
                ((stl_sc26198getreg(portp, IOPIOR) & ~iopioroff) | iopioron));
4050
        BRDDISABLE(portp->brdnr);
4051
        spin_unlock_irqrestore(&brd_lock, flags);
4052
}
4053
 
4054
/*****************************************************************************/
4055
 
4056
/*
4057
 *      Return the state of the signals.
4058
 */
4059
 
4060
static int stl_sc26198getsignals(struct stlport *portp)
4061
{
4062
        unsigned char   ipr;
4063
        unsigned long   flags;
4064
        int             sigs;
4065
 
4066
        pr_debug("stl_sc26198getsignals(portp=%p)\n", portp);
4067
 
4068
        spin_lock_irqsave(&brd_lock, flags);
4069
        BRDENABLE(portp->brdnr, portp->pagenr);
4070
        ipr = stl_sc26198getreg(portp, IPR);
4071
        BRDDISABLE(portp->brdnr);
4072
        spin_unlock_irqrestore(&brd_lock, flags);
4073
 
4074
        sigs = 0;
4075
        sigs |= (ipr & IPR_DCD) ? 0 : TIOCM_CD;
4076
        sigs |= (ipr & IPR_CTS) ? 0 : TIOCM_CTS;
4077
        sigs |= (ipr & IPR_DTR) ? 0: TIOCM_DTR;
4078
        sigs |= (ipr & IPR_RTS) ? 0: TIOCM_RTS;
4079
        sigs |= TIOCM_DSR;
4080
        return sigs;
4081
}
4082
 
4083
/*****************************************************************************/
4084
 
4085
/*
4086
 *      Enable/Disable the Transmitter and/or Receiver.
4087
 */
4088
 
4089
static void stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx)
4090
{
4091
        unsigned char   ccr;
4092
        unsigned long   flags;
4093
 
4094
        pr_debug("stl_sc26198enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx,tx);
4095
 
4096
        ccr = portp->crenable;
4097
        if (tx == 0)
4098
                ccr &= ~CR_TXENABLE;
4099
        else if (tx > 0)
4100
                ccr |= CR_TXENABLE;
4101
        if (rx == 0)
4102
                ccr &= ~CR_RXENABLE;
4103
        else if (rx > 0)
4104
                ccr |= CR_RXENABLE;
4105
 
4106
        spin_lock_irqsave(&brd_lock, flags);
4107
        BRDENABLE(portp->brdnr, portp->pagenr);
4108
        stl_sc26198setreg(portp, SCCR, ccr);
4109
        BRDDISABLE(portp->brdnr);
4110
        portp->crenable = ccr;
4111
        spin_unlock_irqrestore(&brd_lock, flags);
4112
}
4113
 
4114
/*****************************************************************************/
4115
 
4116
/*
4117
 *      Start/stop the Transmitter and/or Receiver.
4118
 */
4119
 
4120
static void stl_sc26198startrxtx(struct stlport *portp, int rx, int tx)
4121
{
4122
        unsigned char   imr;
4123
        unsigned long   flags;
4124
 
4125
        pr_debug("stl_sc26198startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
4126
 
4127
        imr = portp->imr;
4128
        if (tx == 0)
4129
                imr &= ~IR_TXRDY;
4130
        else if (tx == 1)
4131
                imr |= IR_TXRDY;
4132
        if (rx == 0)
4133
                imr &= ~(IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG);
4134
        else if (rx > 0)
4135
                imr |= IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG;
4136
 
4137
        spin_lock_irqsave(&brd_lock, flags);
4138
        BRDENABLE(portp->brdnr, portp->pagenr);
4139
        stl_sc26198setreg(portp, IMR, imr);
4140
        BRDDISABLE(portp->brdnr);
4141
        portp->imr = imr;
4142
        if (tx > 0)
4143
                set_bit(ASYI_TXBUSY, &portp->istate);
4144
        spin_unlock_irqrestore(&brd_lock, flags);
4145
}
4146
 
4147
/*****************************************************************************/
4148
 
4149
/*
4150
 *      Disable all interrupts from this port.
4151
 */
4152
 
4153
static void stl_sc26198disableintrs(struct stlport *portp)
4154
{
4155
        unsigned long   flags;
4156
 
4157
        pr_debug("stl_sc26198disableintrs(portp=%p)\n", portp);
4158
 
4159
        spin_lock_irqsave(&brd_lock, flags);
4160
        BRDENABLE(portp->brdnr, portp->pagenr);
4161
        portp->imr = 0;
4162
        stl_sc26198setreg(portp, IMR, 0);
4163
        BRDDISABLE(portp->brdnr);
4164
        spin_unlock_irqrestore(&brd_lock, flags);
4165
}
4166
 
4167
/*****************************************************************************/
4168
 
4169
static void stl_sc26198sendbreak(struct stlport *portp, int len)
4170
{
4171
        unsigned long   flags;
4172
 
4173
        pr_debug("stl_sc26198sendbreak(portp=%p,len=%d)\n", portp, len);
4174
 
4175
        spin_lock_irqsave(&brd_lock, flags);
4176
        BRDENABLE(portp->brdnr, portp->pagenr);
4177
        if (len == 1) {
4178
                stl_sc26198setreg(portp, SCCR, CR_TXSTARTBREAK);
4179
                portp->stats.txbreaks++;
4180
        } else
4181
                stl_sc26198setreg(portp, SCCR, CR_TXSTOPBREAK);
4182
 
4183
        BRDDISABLE(portp->brdnr);
4184
        spin_unlock_irqrestore(&brd_lock, flags);
4185
}
4186
 
4187
/*****************************************************************************/
4188
 
4189
/*
4190
 *      Take flow control actions...
4191
 */
4192
 
4193
static void stl_sc26198flowctrl(struct stlport *portp, int state)
4194
{
4195
        struct tty_struct       *tty;
4196
        unsigned long           flags;
4197
        unsigned char           mr0;
4198
 
4199
        pr_debug("stl_sc26198flowctrl(portp=%p,state=%x)\n", portp, state);
4200
 
4201
        if (portp == NULL)
4202
                return;
4203
        tty = portp->tty;
4204
        if (tty == NULL)
4205
                return;
4206
 
4207
        spin_lock_irqsave(&brd_lock, flags);
4208
        BRDENABLE(portp->brdnr, portp->pagenr);
4209
 
4210
        if (state) {
4211
                if (tty->termios->c_iflag & IXOFF) {
4212
                        mr0 = stl_sc26198getreg(portp, MR0);
4213
                        stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4214
                        stl_sc26198setreg(portp, SCCR, CR_TXSENDXON);
4215
                        mr0 |= MR0_SWFRX;
4216
                        portp->stats.rxxon++;
4217
                        stl_sc26198wait(portp);
4218
                        stl_sc26198setreg(portp, MR0, mr0);
4219
                }
4220
/*
4221
 *              Question: should we return RTS to what it was before? It may
4222
 *              have been set by an ioctl... Suppose not, since if you have
4223
 *              hardware flow control set then it is pretty silly to go and
4224
 *              set the RTS line by hand.
4225
 */
4226
                if (tty->termios->c_cflag & CRTSCTS) {
4227
                        stl_sc26198setreg(portp, MR1,
4228
                                (stl_sc26198getreg(portp, MR1) | MR1_AUTORTS));
4229
                        stl_sc26198setreg(portp, IOPIOR,
4230
                                (stl_sc26198getreg(portp, IOPIOR) | IOPR_RTS));
4231
                        portp->stats.rxrtson++;
4232
                }
4233
        } else {
4234
                if (tty->termios->c_iflag & IXOFF) {
4235
                        mr0 = stl_sc26198getreg(portp, MR0);
4236
                        stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4237
                        stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF);
4238
                        mr0 &= ~MR0_SWFRX;
4239
                        portp->stats.rxxoff++;
4240
                        stl_sc26198wait(portp);
4241
                        stl_sc26198setreg(portp, MR0, mr0);
4242
                }
4243
                if (tty->termios->c_cflag & CRTSCTS) {
4244
                        stl_sc26198setreg(portp, MR1,
4245
                                (stl_sc26198getreg(portp, MR1) & ~MR1_AUTORTS));
4246
                        stl_sc26198setreg(portp, IOPIOR,
4247
                                (stl_sc26198getreg(portp, IOPIOR) & ~IOPR_RTS));
4248
                        portp->stats.rxrtsoff++;
4249
                }
4250
        }
4251
 
4252
        BRDDISABLE(portp->brdnr);
4253
        spin_unlock_irqrestore(&brd_lock, flags);
4254
}
4255
 
4256
/*****************************************************************************/
4257
 
4258
/*
4259
 *      Send a flow control character.
4260
 */
4261
 
4262
static void stl_sc26198sendflow(struct stlport *portp, int state)
4263
{
4264
        struct tty_struct       *tty;
4265
        unsigned long           flags;
4266
        unsigned char           mr0;
4267
 
4268
        pr_debug("stl_sc26198sendflow(portp=%p,state=%x)\n", portp, state);
4269
 
4270
        if (portp == NULL)
4271
                return;
4272
        tty = portp->tty;
4273
        if (tty == NULL)
4274
                return;
4275
 
4276
        spin_lock_irqsave(&brd_lock, flags);
4277
        BRDENABLE(portp->brdnr, portp->pagenr);
4278
        if (state) {
4279
                mr0 = stl_sc26198getreg(portp, MR0);
4280
                stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4281
                stl_sc26198setreg(portp, SCCR, CR_TXSENDXON);
4282
                mr0 |= MR0_SWFRX;
4283
                portp->stats.rxxon++;
4284
                stl_sc26198wait(portp);
4285
                stl_sc26198setreg(portp, MR0, mr0);
4286
        } else {
4287
                mr0 = stl_sc26198getreg(portp, MR0);
4288
                stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4289
                stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF);
4290
                mr0 &= ~MR0_SWFRX;
4291
                portp->stats.rxxoff++;
4292
                stl_sc26198wait(portp);
4293
                stl_sc26198setreg(portp, MR0, mr0);
4294
        }
4295
        BRDDISABLE(portp->brdnr);
4296
        spin_unlock_irqrestore(&brd_lock, flags);
4297
}
4298
 
4299
/*****************************************************************************/
4300
 
4301
static void stl_sc26198flush(struct stlport *portp)
4302
{
4303
        unsigned long   flags;
4304
 
4305
        pr_debug("stl_sc26198flush(portp=%p)\n", portp);
4306
 
4307
        if (portp == NULL)
4308
                return;
4309
 
4310
        spin_lock_irqsave(&brd_lock, flags);
4311
        BRDENABLE(portp->brdnr, portp->pagenr);
4312
        stl_sc26198setreg(portp, SCCR, CR_TXRESET);
4313
        stl_sc26198setreg(portp, SCCR, portp->crenable);
4314
        BRDDISABLE(portp->brdnr);
4315
        portp->tx.tail = portp->tx.head;
4316
        spin_unlock_irqrestore(&brd_lock, flags);
4317
}
4318
 
4319
/*****************************************************************************/
4320
 
4321
/*
4322
 *      Return the current state of data flow on this port. This is only
4323
 *      really interresting when determining if data has fully completed
4324
 *      transmission or not... The sc26198 interrupt scheme cannot
4325
 *      determine when all data has actually drained, so we need to
4326
 *      check the port statusy register to be sure.
4327
 */
4328
 
4329
static int stl_sc26198datastate(struct stlport *portp)
4330
{
4331
        unsigned long   flags;
4332
        unsigned char   sr;
4333
 
4334
        pr_debug("stl_sc26198datastate(portp=%p)\n", portp);
4335
 
4336
        if (portp == NULL)
4337
                return 0;
4338
        if (test_bit(ASYI_TXBUSY, &portp->istate))
4339
                return 1;
4340
 
4341
        spin_lock_irqsave(&brd_lock, flags);
4342
        BRDENABLE(portp->brdnr, portp->pagenr);
4343
        sr = stl_sc26198getreg(portp, SR);
4344
        BRDDISABLE(portp->brdnr);
4345
        spin_unlock_irqrestore(&brd_lock, flags);
4346
 
4347
        return (sr & SR_TXEMPTY) ? 0 : 1;
4348
}
4349
 
4350
/*****************************************************************************/
4351
 
4352
/*
4353
 *      Delay for a small amount of time, to give the sc26198 a chance
4354
 *      to process a command...
4355
 */
4356
 
4357
static void stl_sc26198wait(struct stlport *portp)
4358
{
4359
        int     i;
4360
 
4361
        pr_debug("stl_sc26198wait(portp=%p)\n", portp);
4362
 
4363
        if (portp == NULL)
4364
                return;
4365
 
4366
        for (i = 0; i < 20; i++)
4367
                stl_sc26198getglobreg(portp, TSTR);
4368
}
4369
 
4370
/*****************************************************************************/
4371
 
4372
/*
4373
 *      If we are TX flow controlled and in IXANY mode then we may
4374
 *      need to unflow control here. We gotta do this because of the
4375
 *      automatic flow control modes of the sc26198.
4376
 */
4377
 
4378
static void stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty)
4379
{
4380
        unsigned char   mr0;
4381
 
4382
        mr0 = stl_sc26198getreg(portp, MR0);
4383
        stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4384
        stl_sc26198setreg(portp, SCCR, CR_HOSTXON);
4385
        stl_sc26198wait(portp);
4386
        stl_sc26198setreg(portp, MR0, mr0);
4387
        clear_bit(ASYI_TXFLOWED, &portp->istate);
4388
}
4389
 
4390
/*****************************************************************************/
4391
 
4392
/*
4393
 *      Interrupt service routine for sc26198 panels.
4394
 */
4395
 
4396
static void stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase)
4397
{
4398
        struct stlport  *portp;
4399
        unsigned int    iack;
4400
 
4401
        spin_lock(&brd_lock);
4402
 
4403
/*
4404
 *      Work around bug in sc26198 chip... Cannot have A6 address
4405
 *      line of UART high, else iack will be returned as 0.
4406
 */
4407
        outb(0, (iobase + 1));
4408
 
4409
        iack = inb(iobase + XP_IACK);
4410
        portp = panelp->ports[(iack & IVR_CHANMASK) + ((iobase & 0x4) << 1)];
4411
 
4412
        if (iack & IVR_RXDATA)
4413
                stl_sc26198rxisr(portp, iack);
4414
        else if (iack & IVR_TXDATA)
4415
                stl_sc26198txisr(portp);
4416
        else
4417
                stl_sc26198otherisr(portp, iack);
4418
 
4419
        spin_unlock(&brd_lock);
4420
}
4421
 
4422
/*****************************************************************************/
4423
 
4424
/*
4425
 *      Transmit interrupt handler. This has gotta be fast!  Handling TX
4426
 *      chars is pretty simple, stuff as many as possible from the TX buffer
4427
 *      into the sc26198 FIFO.
4428
 *      In practice it is possible that interrupts are enabled but that the
4429
 *      port has been hung up. Need to handle not having any TX buffer here,
4430
 *      this is done by using the side effect that head and tail will also
4431
 *      be NULL if the buffer has been freed.
4432
 */
4433
 
4434
static void stl_sc26198txisr(struct stlport *portp)
4435
{
4436
        unsigned int    ioaddr;
4437
        unsigned char   mr0;
4438
        int             len, stlen;
4439
        char            *head, *tail;
4440
 
4441
        pr_debug("stl_sc26198txisr(portp=%p)\n", portp);
4442
 
4443
        ioaddr = portp->ioaddr;
4444
        head = portp->tx.head;
4445
        tail = portp->tx.tail;
4446
        len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
4447
        if ((len == 0) || ((len < STL_TXBUFLOW) &&
4448
            (test_bit(ASYI_TXLOW, &portp->istate) == 0))) {
4449
                set_bit(ASYI_TXLOW, &portp->istate);
4450
                schedule_work(&portp->tqueue);
4451
        }
4452
 
4453
        if (len == 0) {
4454
                outb((MR0 | portp->uartaddr), (ioaddr + XP_ADDR));
4455
                mr0 = inb(ioaddr + XP_DATA);
4456
                if ((mr0 & MR0_TXMASK) == MR0_TXEMPTY) {
4457
                        portp->imr &= ~IR_TXRDY;
4458
                        outb((IMR | portp->uartaddr), (ioaddr + XP_ADDR));
4459
                        outb(portp->imr, (ioaddr + XP_DATA));
4460
                        clear_bit(ASYI_TXBUSY, &portp->istate);
4461
                } else {
4462
                        mr0 |= ((mr0 & ~MR0_TXMASK) | MR0_TXEMPTY);
4463
                        outb(mr0, (ioaddr + XP_DATA));
4464
                }
4465
        } else {
4466
                len = min(len, SC26198_TXFIFOSIZE);
4467
                portp->stats.txtotal += len;
4468
                stlen = min(len, ((portp->tx.buf + STL_TXBUFSIZE) - tail));
4469
                outb(GTXFIFO, (ioaddr + XP_ADDR));
4470
                outsb((ioaddr + XP_DATA), tail, stlen);
4471
                len -= stlen;
4472
                tail += stlen;
4473
                if (tail >= (portp->tx.buf + STL_TXBUFSIZE))
4474
                        tail = portp->tx.buf;
4475
                if (len > 0) {
4476
                        outsb((ioaddr + XP_DATA), tail, len);
4477
                        tail += len;
4478
                }
4479
                portp->tx.tail = tail;
4480
        }
4481
}
4482
 
4483
/*****************************************************************************/
4484
 
4485
/*
4486
 *      Receive character interrupt handler. Determine if we have good chars
4487
 *      or bad chars and then process appropriately. Good chars are easy
4488
 *      just shove the lot into the RX buffer and set all status byte to 0.
4489
 *      If a bad RX char then process as required. This routine needs to be
4490
 *      fast!  In practice it is possible that we get an interrupt on a port
4491
 *      that is closed. This can happen on hangups - since they completely
4492
 *      shutdown a port not in user context. Need to handle this case.
4493
 */
4494
 
4495
static void stl_sc26198rxisr(struct stlport *portp, unsigned int iack)
4496
{
4497
        struct tty_struct       *tty;
4498
        unsigned int            len, buflen, ioaddr;
4499
 
4500
        pr_debug("stl_sc26198rxisr(portp=%p,iack=%x)\n", portp, iack);
4501
 
4502
        tty = portp->tty;
4503
        ioaddr = portp->ioaddr;
4504
        outb(GIBCR, (ioaddr + XP_ADDR));
4505
        len = inb(ioaddr + XP_DATA) + 1;
4506
 
4507
        if ((iack & IVR_TYPEMASK) == IVR_RXDATA) {
4508
                if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
4509
                        len = min(len, sizeof(stl_unwanted));
4510
                        outb(GRXFIFO, (ioaddr + XP_ADDR));
4511
                        insb((ioaddr + XP_DATA), &stl_unwanted[0], len);
4512
                        portp->stats.rxlost += len;
4513
                        portp->stats.rxtotal += len;
4514
                } else {
4515
                        len = min(len, buflen);
4516
                        if (len > 0) {
4517
                                unsigned char *ptr;
4518
                                outb(GRXFIFO, (ioaddr + XP_ADDR));
4519
                                tty_prepare_flip_string(tty, &ptr, len);
4520
                                insb((ioaddr + XP_DATA), ptr, len);
4521
                                tty_schedule_flip(tty);
4522
                                portp->stats.rxtotal += len;
4523
                        }
4524
                }
4525
        } else {
4526
                stl_sc26198rxbadchars(portp);
4527
        }
4528
 
4529
/*
4530
 *      If we are TX flow controlled and in IXANY mode then we may need
4531
 *      to unflow control here. We gotta do this because of the automatic
4532
 *      flow control modes of the sc26198.
4533
 */
4534
        if (test_bit(ASYI_TXFLOWED, &portp->istate)) {
4535
                if ((tty != NULL) &&
4536
                    (tty->termios != NULL) &&
4537
                    (tty->termios->c_iflag & IXANY)) {
4538
                        stl_sc26198txunflow(portp, tty);
4539
                }
4540
        }
4541
}
4542
 
4543
/*****************************************************************************/
4544
 
4545
/*
4546
 *      Process an RX bad character.
4547
 */
4548
 
4549
static void stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch)
4550
{
4551
        struct tty_struct       *tty;
4552
        unsigned int            ioaddr;
4553
 
4554
        tty = portp->tty;
4555
        ioaddr = portp->ioaddr;
4556
 
4557
        if (status & SR_RXPARITY)
4558
                portp->stats.rxparity++;
4559
        if (status & SR_RXFRAMING)
4560
                portp->stats.rxframing++;
4561
        if (status & SR_RXOVERRUN)
4562
                portp->stats.rxoverrun++;
4563
        if (status & SR_RXBREAK)
4564
                portp->stats.rxbreaks++;
4565
 
4566
        if ((tty != NULL) &&
4567
            ((portp->rxignoremsk & status) == 0)) {
4568
                if (portp->rxmarkmsk & status) {
4569
                        if (status & SR_RXBREAK) {
4570
                                status = TTY_BREAK;
4571
                                if (portp->flags & ASYNC_SAK) {
4572
                                        do_SAK(tty);
4573
                                        BRDENABLE(portp->brdnr, portp->pagenr);
4574
                                }
4575
                        } else if (status & SR_RXPARITY)
4576
                                status = TTY_PARITY;
4577
                        else if (status & SR_RXFRAMING)
4578
                                status = TTY_FRAME;
4579
                        else if(status & SR_RXOVERRUN)
4580
                                status = TTY_OVERRUN;
4581
                        else
4582
                                status = 0;
4583
                } else
4584
                        status = 0;
4585
 
4586
                tty_insert_flip_char(tty, ch, status);
4587
                tty_schedule_flip(tty);
4588
 
4589
                if (status == 0)
4590
                        portp->stats.rxtotal++;
4591
        }
4592
}
4593
 
4594
/*****************************************************************************/
4595
 
4596
/*
4597
 *      Process all characters in the RX FIFO of the UART. Check all char
4598
 *      status bytes as well, and process as required. We need to check
4599
 *      all bytes in the FIFO, in case some more enter the FIFO while we
4600
 *      are here. To get the exact character error type we need to switch
4601
 *      into CHAR error mode (that is why we need to make sure we empty
4602
 *      the FIFO).
4603
 */
4604
 
4605
static void stl_sc26198rxbadchars(struct stlport *portp)
4606
{
4607
        unsigned char   status, mr1;
4608
        char            ch;
4609
 
4610
/*
4611
 *      To get the precise error type for each character we must switch
4612
 *      back into CHAR error mode.
4613
 */
4614
        mr1 = stl_sc26198getreg(portp, MR1);
4615
        stl_sc26198setreg(portp, MR1, (mr1 & ~MR1_ERRBLOCK));
4616
 
4617
        while ((status = stl_sc26198getreg(portp, SR)) & SR_RXRDY) {
4618
                stl_sc26198setreg(portp, SCCR, CR_CLEARRXERR);
4619
                ch = stl_sc26198getreg(portp, RXFIFO);
4620
                stl_sc26198rxbadch(portp, status, ch);
4621
        }
4622
 
4623
/*
4624
 *      To get correct interrupt class we must switch back into BLOCK
4625
 *      error mode.
4626
 */
4627
        stl_sc26198setreg(portp, MR1, mr1);
4628
}
4629
 
4630
/*****************************************************************************/
4631
 
4632
/*
4633
 *      Other interrupt handler. This includes modem signals, flow
4634
 *      control actions, etc. Most stuff is left to off-level interrupt
4635
 *      processing time.
4636
 */
4637
 
4638
static void stl_sc26198otherisr(struct stlport *portp, unsigned int iack)
4639
{
4640
        unsigned char   cir, ipr, xisr;
4641
 
4642
        pr_debug("stl_sc26198otherisr(portp=%p,iack=%x)\n", portp, iack);
4643
 
4644
        cir = stl_sc26198getglobreg(portp, CIR);
4645
 
4646
        switch (cir & CIR_SUBTYPEMASK) {
4647
        case CIR_SUBCOS:
4648
                ipr = stl_sc26198getreg(portp, IPR);
4649
                if (ipr & IPR_DCDCHANGE) {
4650
                        set_bit(ASYI_DCDCHANGE, &portp->istate);
4651
                        schedule_work(&portp->tqueue);
4652
                        portp->stats.modem++;
4653
                }
4654
                break;
4655
        case CIR_SUBXONXOFF:
4656
                xisr = stl_sc26198getreg(portp, XISR);
4657
                if (xisr & XISR_RXXONGOT) {
4658
                        set_bit(ASYI_TXFLOWED, &portp->istate);
4659
                        portp->stats.txxoff++;
4660
                }
4661
                if (xisr & XISR_RXXOFFGOT) {
4662
                        clear_bit(ASYI_TXFLOWED, &portp->istate);
4663
                        portp->stats.txxon++;
4664
                }
4665
                break;
4666
        case CIR_SUBBREAK:
4667
                stl_sc26198setreg(portp, SCCR, CR_BREAKRESET);
4668
                stl_sc26198rxbadchars(portp);
4669
                break;
4670
        default:
4671
                break;
4672
        }
4673
}
4674
 
4675
static void stl_free_isabrds(void)
4676
{
4677
        struct stlbrd *brdp;
4678
        unsigned int i;
4679
 
4680
        for (i = 0; i < stl_nrbrds; i++) {
4681
                if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED))
4682
                        continue;
4683
 
4684
                free_irq(brdp->irq, brdp);
4685
 
4686
                stl_cleanup_panels(brdp);
4687
 
4688
                release_region(brdp->ioaddr1, brdp->iosize1);
4689
                if (brdp->iosize2 > 0)
4690
                        release_region(brdp->ioaddr2, brdp->iosize2);
4691
 
4692
                kfree(brdp);
4693
                stl_brds[i] = NULL;
4694
        }
4695
}
4696
 
4697
/*
4698
 *      Loadable module initialization stuff.
4699
 */
4700
static int __init stallion_module_init(void)
4701
{
4702
        struct stlbrd   *brdp;
4703
        struct stlconf  conf;
4704
        unsigned int i, j;
4705
        int retval;
4706
 
4707
        printk(KERN_INFO "%s: version %s\n", stl_drvtitle, stl_drvversion);
4708
 
4709
        spin_lock_init(&stallion_lock);
4710
        spin_lock_init(&brd_lock);
4711
 
4712
        stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
4713
        if (!stl_serial) {
4714
                retval = -ENOMEM;
4715
                goto err;
4716
        }
4717
 
4718
        stl_serial->owner = THIS_MODULE;
4719
        stl_serial->driver_name = stl_drvname;
4720
        stl_serial->name = "ttyE";
4721
        stl_serial->major = STL_SERIALMAJOR;
4722
        stl_serial->minor_start = 0;
4723
        stl_serial->type = TTY_DRIVER_TYPE_SERIAL;
4724
        stl_serial->subtype = SERIAL_TYPE_NORMAL;
4725
        stl_serial->init_termios = stl_deftermios;
4726
        stl_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4727
        tty_set_operations(stl_serial, &stl_ops);
4728
 
4729
        retval = tty_register_driver(stl_serial);
4730
        if (retval) {
4731
                printk("STALLION: failed to register serial driver\n");
4732
                goto err_frtty;
4733
        }
4734
 
4735
/*
4736
 *      Find any dynamically supported boards. That is via module load
4737
 *      line options.
4738
 */
4739
        for (i = stl_nrbrds; i < stl_nargs; i++) {
4740
                memset(&conf, 0, sizeof(conf));
4741
                if (stl_parsebrd(&conf, stl_brdsp[i]) == 0)
4742
                        continue;
4743
                if ((brdp = stl_allocbrd()) == NULL)
4744
                        continue;
4745
                brdp->brdnr = i;
4746
                brdp->brdtype = conf.brdtype;
4747
                brdp->ioaddr1 = conf.ioaddr1;
4748
                brdp->ioaddr2 = conf.ioaddr2;
4749
                brdp->irq = conf.irq;
4750
                brdp->irqtype = conf.irqtype;
4751
                stl_brds[brdp->brdnr] = brdp;
4752
                if (stl_brdinit(brdp)) {
4753
                        stl_brds[brdp->brdnr] = NULL;
4754
                        kfree(brdp);
4755
                } else {
4756
                        for (j = 0; j < brdp->nrports; j++)
4757
                                tty_register_device(stl_serial,
4758
                                        brdp->brdnr * STL_MAXPORTS + j, NULL);
4759
                        stl_nrbrds = i + 1;
4760
                }
4761
        }
4762
 
4763
        /* this has to be _after_ isa finding because of locking */
4764
        retval = pci_register_driver(&stl_pcidriver);
4765
        if (retval && stl_nrbrds == 0) {
4766
                printk(KERN_ERR "STALLION: can't register pci driver\n");
4767
                goto err_unrtty;
4768
        }
4769
 
4770
/*
4771
 *      Set up a character driver for per board stuff. This is mainly used
4772
 *      to do stats ioctls on the ports.
4773
 */
4774
        if (register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stl_fsiomem))
4775
                printk("STALLION: failed to register serial board device\n");
4776
 
4777
        stallion_class = class_create(THIS_MODULE, "staliomem");
4778
        if (IS_ERR(stallion_class))
4779
                printk("STALLION: failed to create class\n");
4780
        for (i = 0; i < 4; i++)
4781
                device_create(stallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
4782
                              "staliomem%d", i);
4783
 
4784
        return 0;
4785
err_unrtty:
4786
        tty_unregister_driver(stl_serial);
4787
err_frtty:
4788
        put_tty_driver(stl_serial);
4789
err:
4790
        return retval;
4791
}
4792
 
4793
static void __exit stallion_module_exit(void)
4794
{
4795
        struct stlbrd *brdp;
4796
        unsigned int i, j;
4797
 
4798
        pr_debug("cleanup_module()\n");
4799
 
4800
        printk(KERN_INFO "Unloading %s: version %s\n", stl_drvtitle,
4801
                stl_drvversion);
4802
 
4803
/*
4804
 *      Free up all allocated resources used by the ports. This includes
4805
 *      memory and interrupts. As part of this process we will also do
4806
 *      a hangup on every open port - to try to flush out any processes
4807
 *      hanging onto ports.
4808
 */
4809
        for (i = 0; i < stl_nrbrds; i++) {
4810
                if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED))
4811
                        continue;
4812
                for (j = 0; j < brdp->nrports; j++)
4813
                        tty_unregister_device(stl_serial,
4814
                                brdp->brdnr * STL_MAXPORTS + j);
4815
        }
4816
 
4817
        for (i = 0; i < 4; i++)
4818
                device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
4819
        unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
4820
        class_destroy(stallion_class);
4821
 
4822
        pci_unregister_driver(&stl_pcidriver);
4823
 
4824
        stl_free_isabrds();
4825
 
4826
        tty_unregister_driver(stl_serial);
4827
        put_tty_driver(stl_serial);
4828
}
4829
 
4830
module_init(stallion_module_init);
4831
module_exit(stallion_module_exit);
4832
 
4833
MODULE_AUTHOR("Greg Ungerer");
4834
MODULE_DESCRIPTION("Stallion Multiport Serial Driver");
4835
MODULE_LICENSE("GPL");

powered by: WebSVN 2.1.0

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