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