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