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