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