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