projects / deliverable / linux.git / blob
? search:


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