1 /*****************************************************************************/
4 * istallion.c -- stallion intelligent multiport serial driver.
6 * Copyright (C) 1996-1999 Stallion Technologies
7 * Copyright (C) 1994-1996 Greg Ungerer.
9 * This code is loosely based on the Linux serial driver, written by
10 * Linus Torvalds, Theodore T'so and others.
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.
19 /*****************************************************************************/
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/tty.h>
25 #include <linux/tty_flip.h>
26 #include <linux/serial.h>
27 #include <linux/cdk.h>
28 #include <linux/comstats.h>
29 #include <linux/istallion.h>
30 #include <linux/ioport.h>
31 #include <linux/delay.h>
32 #include <linux/init.h>
33 #include <linux/device.h>
34 #include <linux/wait.h>
35 #include <linux/eisa.h>
36 #include <linux/ctype.h>
39 #include <asm/uaccess.h>
41 #include <linux/pci.h>
43 /*****************************************************************************/
46 * Define different board types. Not all of the following board types
47 * are supported by this driver. But I will use the standard "assigned"
48 * board numbers. Currently supported boards are abbreviated as:
49 * ECP = EasyConnection 8/64, ONB = ONboard, BBY = Brumby and
53 #define BRD_STALLION 1
55 #define BRD_ONBOARD2 3
57 #define BRD_ONBOARDE 7
63 #define BRD_BRUMBY BRD_BRUMBY4
66 * Define a configuration structure to hold the board configuration.
67 * Need to set this up in the code (for now) with the boards that are
68 * to be configured into the system. This is what needs to be modified
69 * when adding/removing/modifying boards. Each line entry in the
70 * stli_brdconf[] array is a board. Each line contains io/irq/memory
71 * ranges for that board (as well as what type of board it is).
73 * { BRD_ECP, 0x2a0, 0, 0xcc000, 0, 0 },
74 * This line will configure an EasyConnection 8/64 at io address 2a0,
75 * and shared memory address of cc000. Multiple EasyConnection 8/64
76 * boards can share the same shared memory address space. No interrupt
77 * is required for this board type.
79 * { BRD_ECPE, 0x5000, 0, 0x80000000, 0, 0 },
80 * This line will configure an EasyConnection 8/64 EISA in slot 5 and
81 * shared memory address of 0x80000000 (2 GByte). Multiple
82 * EasyConnection 8/64 EISA boards can share the same shared memory
83 * address space. No interrupt is required for this board type.
85 * { BRD_ONBOARD, 0x240, 0, 0xd0000, 0, 0 },
86 * This line will configure an ONboard (ISA type) at io address 240,
87 * and shared memory address of d0000. Multiple ONboards can share
88 * the same shared memory address space. No interrupt required.
90 * { BRD_BRUMBY4, 0x360, 0, 0xc8000, 0, 0 },
91 * This line will configure a Brumby board (any number of ports!) at
92 * io address 360 and shared memory address of c8000. All Brumby boards
93 * configured into a system must have their own separate io and memory
94 * addresses. No interrupt is required.
96 * { BRD_STALLION, 0x330, 0, 0xd0000, 0, 0 },
97 * This line will configure an original Stallion board at io address 330
98 * and shared memory address d0000 (this would only be valid for a "V4.0"
99 * or Rev.O Stallion board). All Stallion boards configured into the
100 * system must have their own separate io and memory addresses. No
101 * interrupt is required.
108 unsigned long memaddr;
113 static unsigned int stli_nrbrds;
115 /* stli_lock must NOT be taken holding brd_lock */
116 static spinlock_t stli_lock; /* TTY logic lock */
117 static spinlock_t brd_lock; /* Board logic lock */
120 * There is some experimental EISA board detection code in this driver.
121 * By default it is disabled, but for those that want to try it out,
122 * then set the define below to be 1.
124 #define STLI_EISAPROBE 0
126 /*****************************************************************************/
129 * Define some important driver characteristics. Device major numbers
130 * allocated as per Linux Device Registry.
132 #ifndef STL_SIOMEMMAJOR
133 #define STL_SIOMEMMAJOR 28
135 #ifndef STL_SERIALMAJOR
136 #define STL_SERIALMAJOR 24
138 #ifndef STL_CALLOUTMAJOR
139 #define STL_CALLOUTMAJOR 25
142 /*****************************************************************************/
145 * Define our local driver identity first. Set up stuff to deal with
146 * all the local structures required by a serial tty driver.
148 static char *stli_drvtitle = "Stallion Intelligent Multiport Serial Driver";
149 static char *stli_drvname = "istallion";
150 static char *stli_drvversion = "5.6.0";
151 static char *stli_serialname = "ttyE";
153 static struct tty_driver *stli_serial;
156 #define STLI_TXBUFSIZE 4096
159 * Use a fast local buffer for cooked characters. Typically a whole
160 * bunch of cooked characters come in for a port, 1 at a time. So we
161 * save those up into a local buffer, then write out the whole lot
162 * with a large memcpy. Just use 1 buffer for all ports, since its
163 * use it is only need for short periods of time by each port.
165 static char *stli_txcookbuf;
166 static int stli_txcooksize;
167 static int stli_txcookrealsize;
168 static struct tty_struct *stli_txcooktty;
171 * Define a local default termios struct. All ports will be created
172 * with this termios initially. Basically all it defines is a raw port
173 * at 9600 baud, 8 data bits, no parity, 1 stop bit.
175 static struct ktermios stli_deftermios = {
176 .c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
183 * Define global stats structures. Not used often, and can be
184 * re-used for each stats call.
186 static comstats_t stli_comstats;
187 static combrd_t stli_brdstats;
188 static struct asystats stli_cdkstats;
190 /*****************************************************************************/
192 static struct stlibrd *stli_brds[STL_MAXBRDS];
194 static int stli_shared;
197 * Per board state flags. Used with the state field of the board struct.
198 * Not really much here... All we need to do is keep track of whether
199 * the board has been detected, and whether it is actually running a slave
202 #define BST_FOUND 0x1
203 #define BST_STARTED 0x2
206 * Define the set of port state flags. These are marked for internal
207 * state purposes only, usually to do with the state of communications
208 * with the slave. Most of them need to be updated atomically, so always
209 * use the bit setting operations (unless protected by cli/sti).
211 #define ST_INITIALIZING 1
217 #define ST_DOFLUSHRX 7
218 #define ST_DOFLUSHTX 8
221 #define ST_GETSIGS 11
224 * Define an array of board names as printable strings. Handy for
225 * referencing boards when printing trace and stuff.
227 static char *stli_brdnames[] = {
260 /*****************************************************************************/
263 * Define some string labels for arguments passed from the module
264 * load line. These allow for easy board definitions, and easy
265 * modification of the io, memory and irq resoucres.
268 static char *board0[8];
269 static char *board1[8];
270 static char *board2[8];
271 static char *board3[8];
273 static char **stli_brdsp[] = {
281 * Define a set of common board names, and types. This is used to
282 * parse any module arguments.
285 static struct stlibrdtype {
289 { "stallion", BRD_STALLION },
290 { "1", BRD_STALLION },
291 { "brumby", BRD_BRUMBY },
292 { "brumby4", BRD_BRUMBY },
293 { "brumby/4", BRD_BRUMBY },
294 { "brumby-4", BRD_BRUMBY },
295 { "brumby8", BRD_BRUMBY },
296 { "brumby/8", BRD_BRUMBY },
297 { "brumby-8", BRD_BRUMBY },
298 { "brumby16", BRD_BRUMBY },
299 { "brumby/16", BRD_BRUMBY },
300 { "brumby-16", BRD_BRUMBY },
302 { "onboard2", BRD_ONBOARD2 },
303 { "onboard-2", BRD_ONBOARD2 },
304 { "onboard/2", BRD_ONBOARD2 },
305 { "onboard-mc", BRD_ONBOARD2 },
306 { "onboard/mc", BRD_ONBOARD2 },
307 { "onboard-mca", BRD_ONBOARD2 },
308 { "onboard/mca", BRD_ONBOARD2 },
309 { "3", BRD_ONBOARD2 },
310 { "onboard", BRD_ONBOARD },
311 { "onboardat", BRD_ONBOARD },
312 { "4", BRD_ONBOARD },
313 { "onboarde", BRD_ONBOARDE },
314 { "onboard-e", BRD_ONBOARDE },
315 { "onboard/e", BRD_ONBOARDE },
316 { "onboard-ei", BRD_ONBOARDE },
317 { "onboard/ei", BRD_ONBOARDE },
318 { "7", BRD_ONBOARDE },
320 { "ecpat", BRD_ECP },
321 { "ec8/64", BRD_ECP },
322 { "ec8/64-at", BRD_ECP },
323 { "ec8/64-isa", BRD_ECP },
325 { "ecpe", BRD_ECPE },
326 { "ecpei", BRD_ECPE },
327 { "ec8/64-e", BRD_ECPE },
328 { "ec8/64-ei", BRD_ECPE },
330 { "ecpmc", BRD_ECPMC },
331 { "ec8/64-mc", BRD_ECPMC },
332 { "ec8/64-mca", BRD_ECPMC },
334 { "ecppci", BRD_ECPPCI },
335 { "ec/ra", BRD_ECPPCI },
336 { "ec/ra-pc", BRD_ECPPCI },
337 { "ec/ra-pci", BRD_ECPPCI },
338 { "29", BRD_ECPPCI },
342 * Define the module agruments.
344 MODULE_AUTHOR("Greg Ungerer");
345 MODULE_DESCRIPTION("Stallion Intelligent Multiport Serial Driver");
346 MODULE_LICENSE("GPL");
349 module_param_array(board0, charp, NULL, 0);
350 MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,memaddr]");
351 module_param_array(board1, charp, NULL, 0);
352 MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,memaddr]");
353 module_param_array(board2, charp, NULL, 0);
354 MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,memaddr]");
355 module_param_array(board3, charp, NULL, 0);
356 MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,memaddr]");
358 #if STLI_EISAPROBE != 0
360 * Set up a default memory address table for EISA board probing.
361 * The default addresses are all bellow 1Mbyte, which has to be the
362 * case anyway. They should be safe, since we only read values from
363 * them, and interrupts are disabled while we do it. If the higher
364 * memory support is compiled in then we also try probing around
365 * the 1Gb, 2Gb and 3Gb areas as well...
367 static unsigned long stli_eisamemprobeaddrs[] = {
368 0xc0000, 0xd0000, 0xe0000, 0xf0000,
369 0x80000000, 0x80010000, 0x80020000, 0x80030000,
370 0x40000000, 0x40010000, 0x40020000, 0x40030000,
371 0xc0000000, 0xc0010000, 0xc0020000, 0xc0030000,
372 0xff000000, 0xff010000, 0xff020000, 0xff030000,
375 static int stli_eisamempsize = ARRAY_SIZE(stli_eisamemprobeaddrs);
379 * Define the Stallion PCI vendor and device IDs.
381 #ifndef PCI_DEVICE_ID_ECRA
382 #define PCI_DEVICE_ID_ECRA 0x0004
385 static struct pci_device_id istallion_pci_tbl[] = {
386 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA), },
389 MODULE_DEVICE_TABLE(pci, istallion_pci_tbl);
391 static struct pci_driver stli_pcidriver;
393 /*****************************************************************************/
396 * Hardware configuration info for ECP boards. These defines apply
397 * to the directly accessible io ports of the ECP. There is a set of
398 * defines for each ECP board type, ISA, EISA, MCA and PCI.
402 #define ECP_MEMSIZE (128 * 1024)
403 #define ECP_PCIMEMSIZE (256 * 1024)
405 #define ECP_ATPAGESIZE (4 * 1024)
406 #define ECP_MCPAGESIZE (4 * 1024)
407 #define ECP_EIPAGESIZE (64 * 1024)
408 #define ECP_PCIPAGESIZE (64 * 1024)
410 #define STL_EISAID 0x8c4e
413 * Important defines for the ISA class of ECP board.
416 #define ECP_ATCONFR 1
417 #define ECP_ATMEMAR 2
418 #define ECP_ATMEMPR 3
419 #define ECP_ATSTOP 0x1
420 #define ECP_ATINTENAB 0x10
421 #define ECP_ATENABLE 0x20
422 #define ECP_ATDISABLE 0x00
423 #define ECP_ATADDRMASK 0x3f000
424 #define ECP_ATADDRSHFT 12
427 * Important defines for the EISA class of ECP board.
430 #define ECP_EIMEMARL 1
431 #define ECP_EICONFR 2
432 #define ECP_EIMEMARH 3
433 #define ECP_EIENABLE 0x1
434 #define ECP_EIDISABLE 0x0
435 #define ECP_EISTOP 0x4
436 #define ECP_EIEDGE 0x00
437 #define ECP_EILEVEL 0x80
438 #define ECP_EIADDRMASKL 0x00ff0000
439 #define ECP_EIADDRSHFTL 16
440 #define ECP_EIADDRMASKH 0xff000000
441 #define ECP_EIADDRSHFTH 24
442 #define ECP_EIBRDENAB 0xc84
444 #define ECP_EISAID 0x4
447 * Important defines for the Micro-channel class of ECP board.
448 * (It has a lot in common with the ISA boards.)
451 #define ECP_MCCONFR 1
452 #define ECP_MCSTOP 0x20
453 #define ECP_MCENABLE 0x80
454 #define ECP_MCDISABLE 0x00
457 * Important defines for the PCI class of ECP board.
458 * (It has a lot in common with the other ECP boards.)
460 #define ECP_PCIIREG 0
461 #define ECP_PCICONFR 1
462 #define ECP_PCISTOP 0x01
465 * Hardware configuration info for ONboard and Brumby boards. These
466 * defines apply to the directly accessible io ports of these boards.
468 #define ONB_IOSIZE 16
469 #define ONB_MEMSIZE (64 * 1024)
470 #define ONB_ATPAGESIZE (64 * 1024)
471 #define ONB_MCPAGESIZE (64 * 1024)
472 #define ONB_EIMEMSIZE (128 * 1024)
473 #define ONB_EIPAGESIZE (64 * 1024)
476 * Important defines for the ISA class of ONboard board.
479 #define ONB_ATMEMAR 1
480 #define ONB_ATCONFR 2
481 #define ONB_ATSTOP 0x4
482 #define ONB_ATENABLE 0x01
483 #define ONB_ATDISABLE 0x00
484 #define ONB_ATADDRMASK 0xff0000
485 #define ONB_ATADDRSHFT 16
487 #define ONB_MEMENABLO 0
488 #define ONB_MEMENABHI 0x02
491 * Important defines for the EISA class of ONboard board.
494 #define ONB_EIMEMARL 1
495 #define ONB_EICONFR 2
496 #define ONB_EIMEMARH 3
497 #define ONB_EIENABLE 0x1
498 #define ONB_EIDISABLE 0x0
499 #define ONB_EISTOP 0x4
500 #define ONB_EIEDGE 0x00
501 #define ONB_EILEVEL 0x80
502 #define ONB_EIADDRMASKL 0x00ff0000
503 #define ONB_EIADDRSHFTL 16
504 #define ONB_EIADDRMASKH 0xff000000
505 #define ONB_EIADDRSHFTH 24
506 #define ONB_EIBRDENAB 0xc84
508 #define ONB_EISAID 0x1
511 * Important defines for the Brumby boards. They are pretty simple,
512 * there is not much that is programmably configurable.
514 #define BBY_IOSIZE 16
515 #define BBY_MEMSIZE (64 * 1024)
516 #define BBY_PAGESIZE (16 * 1024)
519 #define BBY_ATCONFR 1
520 #define BBY_ATSTOP 0x4
523 * Important defines for the Stallion boards. They are pretty simple,
524 * there is not much that is programmably configurable.
526 #define STAL_IOSIZE 16
527 #define STAL_MEMSIZE (64 * 1024)
528 #define STAL_PAGESIZE (64 * 1024)
531 * Define the set of status register values for EasyConnection panels.
532 * The signature will return with the status value for each panel. From
533 * this we can determine what is attached to the board - before we have
534 * actually down loaded any code to it.
536 #define ECH_PNLSTATUS 2
537 #define ECH_PNL16PORT 0x20
538 #define ECH_PNLIDMASK 0x07
539 #define ECH_PNLXPID 0x40
540 #define ECH_PNLINTRPEND 0x80
543 * Define some macros to do things to the board. Even those these boards
544 * are somewhat related there is often significantly different ways of
545 * doing some operation on it (like enable, paging, reset, etc). So each
546 * board class has a set of functions which do the commonly required
547 * operations. The macros below basically just call these functions,
548 * generally checking for a NULL function - which means that the board
549 * needs nothing done to it to achieve this operation!
551 #define EBRDINIT(brdp) \
552 if (brdp->init != NULL) \
555 #define EBRDENABLE(brdp) \
556 if (brdp->enable != NULL) \
557 (* brdp->enable)(brdp);
559 #define EBRDDISABLE(brdp) \
560 if (brdp->disable != NULL) \
561 (* brdp->disable)(brdp);
563 #define EBRDINTR(brdp) \
564 if (brdp->intr != NULL) \
565 (* brdp->intr)(brdp);
567 #define EBRDRESET(brdp) \
568 if (brdp->reset != NULL) \
569 (* brdp->reset)(brdp);
571 #define EBRDGETMEMPTR(brdp,offset) \
572 (* brdp->getmemptr)(brdp, offset, __LINE__)
575 * Define the maximal baud rate, and the default baud base for ports.
577 #define STL_MAXBAUD 460800
578 #define STL_BAUDBASE 115200
579 #define STL_CLOSEDELAY (5 * HZ / 10)
581 /*****************************************************************************/
584 * Define macros to extract a brd or port number from a minor number.
586 #define MINOR2BRD(min) (((min) & 0xc0) >> 6)
587 #define MINOR2PORT(min) ((min) & 0x3f)
589 /*****************************************************************************/
592 * Prototype all functions in this driver!
595 static int stli_parsebrd(struct stlconf *confp, char **argp);
596 static int stli_init(void);
597 static int stli_open(struct tty_struct *tty, struct file *filp);
598 static void stli_close(struct tty_struct *tty, struct file *filp);
599 static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count);
600 static void stli_putchar(struct tty_struct *tty, unsigned char ch);
601 static void stli_flushchars(struct tty_struct *tty);
602 static int stli_writeroom(struct tty_struct *tty);
603 static int stli_charsinbuffer(struct tty_struct *tty);
604 static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
605 static void stli_settermios(struct tty_struct *tty, struct ktermios *old);
606 static void stli_throttle(struct tty_struct *tty);
607 static void stli_unthrottle(struct tty_struct *tty);
608 static void stli_stop(struct tty_struct *tty);
609 static void stli_start(struct tty_struct *tty);
610 static void stli_flushbuffer(struct tty_struct *tty);
611 static void stli_breakctl(struct tty_struct *tty, int state);
612 static void stli_waituntilsent(struct tty_struct *tty, int timeout);
613 static void stli_sendxchar(struct tty_struct *tty, char ch);
614 static void stli_hangup(struct tty_struct *tty);
615 static int stli_portinfo(struct stlibrd *brdp, struct stliport *portp, int portnr, char *pos);
617 static int stli_brdinit(struct stlibrd *brdp);
618 static int stli_startbrd(struct stlibrd *brdp);
619 static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp);
620 static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp);
621 static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
622 static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp);
623 static void stli_poll(unsigned long arg);
624 static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp);
625 static int stli_initopen(struct stlibrd *brdp, struct stliport *portp);
626 static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
627 static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
628 static int stli_waitcarrier(struct stlibrd *brdp, struct stliport *portp, struct file *filp);
629 static void stli_dohangup(struct work_struct *);
630 static int stli_setport(struct stliport *portp);
631 static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
632 static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
633 static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
634 static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp);
635 static void stli_mkasyport(struct stliport *portp, asyport_t *pp, struct ktermios *tiosp);
636 static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts);
637 static long stli_mktiocm(unsigned long sigvalue);
638 static void stli_read(struct stlibrd *brdp, struct stliport *portp);
639 static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp);
640 static int stli_setserial(struct stliport *portp, struct serial_struct __user *sp);
641 static int stli_getbrdstats(combrd_t __user *bp);
642 static int stli_getportstats(struct stliport *portp, comstats_t __user *cp);
643 static int stli_portcmdstats(struct stliport *portp);
644 static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp);
645 static int stli_getportstruct(struct stliport __user *arg);
646 static int stli_getbrdstruct(struct stlibrd __user *arg);
647 static struct stlibrd *stli_allocbrd(void);
649 static void stli_ecpinit(struct stlibrd *brdp);
650 static void stli_ecpenable(struct stlibrd *brdp);
651 static void stli_ecpdisable(struct stlibrd *brdp);
652 static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
653 static void stli_ecpreset(struct stlibrd *brdp);
654 static void stli_ecpintr(struct stlibrd *brdp);
655 static void stli_ecpeiinit(struct stlibrd *brdp);
656 static void stli_ecpeienable(struct stlibrd *brdp);
657 static void stli_ecpeidisable(struct stlibrd *brdp);
658 static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
659 static void stli_ecpeireset(struct stlibrd *brdp);
660 static void stli_ecpmcenable(struct stlibrd *brdp);
661 static void stli_ecpmcdisable(struct stlibrd *brdp);
662 static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
663 static void stli_ecpmcreset(struct stlibrd *brdp);
664 static void stli_ecppciinit(struct stlibrd *brdp);
665 static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
666 static void stli_ecppcireset(struct stlibrd *brdp);
668 static void stli_onbinit(struct stlibrd *brdp);
669 static void stli_onbenable(struct stlibrd *brdp);
670 static void stli_onbdisable(struct stlibrd *brdp);
671 static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
672 static void stli_onbreset(struct stlibrd *brdp);
673 static void stli_onbeinit(struct stlibrd *brdp);
674 static void stli_onbeenable(struct stlibrd *brdp);
675 static void stli_onbedisable(struct stlibrd *brdp);
676 static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
677 static void stli_onbereset(struct stlibrd *brdp);
678 static void stli_bbyinit(struct stlibrd *brdp);
679 static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
680 static void stli_bbyreset(struct stlibrd *brdp);
681 static void stli_stalinit(struct stlibrd *brdp);
682 static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
683 static void stli_stalreset(struct stlibrd *brdp);
685 static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr, unsigned int portnr);
687 static int stli_initecp(struct stlibrd *brdp);
688 static int stli_initonb(struct stlibrd *brdp);
689 #if STLI_EISAPROBE != 0
690 static int stli_eisamemprobe(struct stlibrd *brdp);
692 static int stli_initports(struct stlibrd *brdp);
694 /*****************************************************************************/
697 * Define the driver info for a user level shared memory device. This
698 * device will work sort of like the /dev/kmem device - except that it
699 * will give access to the shared memory on the Stallion intelligent
700 * board. This is also a very useful debugging tool.
702 static const struct file_operations stli_fsiomem = {
703 .owner = THIS_MODULE,
704 .read = stli_memread,
705 .write = stli_memwrite,
706 .ioctl = stli_memioctl,
709 /*****************************************************************************/
712 * Define a timer_list entry for our poll routine. The slave board
713 * is polled every so often to see if anything needs doing. This is
714 * much cheaper on host cpu than using interrupts. It turns out to
715 * not increase character latency by much either...
717 static DEFINE_TIMER(stli_timerlist, stli_poll, 0, 0);
719 static int stli_timeron;
722 * Define the calculation for the timeout routine.
724 #define STLI_TIMEOUT (jiffies + 1)
726 /*****************************************************************************/
728 static struct class *istallion_class;
730 static void stli_cleanup_ports(struct stlibrd *brdp)
732 struct stliport *portp;
735 for (j = 0; j < STL_MAXPORTS; j++) {
736 portp = brdp->ports[j];
738 if (portp->tty != NULL)
739 tty_hangup(portp->tty);
746 * Loadable module initialization stuff.
749 static int __init istallion_module_init(void)
755 /*****************************************************************************/
757 static void __exit istallion_module_exit(void)
759 struct stlibrd *brdp;
763 printk(KERN_INFO "Unloading %s: version %s\n", stli_drvtitle,
766 pci_unregister_driver(&stli_pcidriver);
768 * Free up all allocated resources used by the ports. This includes
769 * memory and interrupts.
773 del_timer_sync(&stli_timerlist);
776 i = tty_unregister_driver(stli_serial);
778 printk("STALLION: failed to un-register tty driver, "
782 put_tty_driver(stli_serial);
783 for (j = 0; j < 4; j++)
784 class_device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR, j));
785 class_destroy(istallion_class);
786 if ((i = unregister_chrdev(STL_SIOMEMMAJOR, "staliomem")))
787 printk("STALLION: failed to un-register serial memory device, "
790 kfree(stli_txcookbuf);
792 for (j = 0; (j < stli_nrbrds); j++) {
793 if ((brdp = stli_brds[j]) == NULL)
796 stli_cleanup_ports(brdp);
798 iounmap(brdp->membase);
799 if (brdp->iosize > 0)
800 release_region(brdp->iobase, brdp->iosize);
806 module_init(istallion_module_init);
807 module_exit(istallion_module_exit);
809 /*****************************************************************************/
812 * Parse the supplied argument string, into the board conf struct.
815 static int stli_parsebrd(struct stlconf *confp, char **argp)
820 if (argp[0] == NULL || *argp[0] == 0)
823 for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
826 for (i = 0; i < ARRAY_SIZE(stli_brdstr); i++) {
827 if (strcmp(stli_brdstr[i].name, argp[0]) == 0)
830 if (i == ARRAY_SIZE(stli_brdstr)) {
831 printk("STALLION: unknown board name, %s?\n", argp[0]);
835 confp->brdtype = stli_brdstr[i].type;
836 if (argp[1] != NULL && *argp[1] != 0)
837 confp->ioaddr1 = simple_strtoul(argp[1], NULL, 0);
838 if (argp[2] != NULL && *argp[2] != 0)
839 confp->memaddr = simple_strtoul(argp[2], NULL, 0);
843 /*****************************************************************************/
845 static int stli_open(struct tty_struct *tty, struct file *filp)
847 struct stlibrd *brdp;
848 struct stliport *portp;
849 unsigned int minordev, brdnr, portnr;
852 minordev = tty->index;
853 brdnr = MINOR2BRD(minordev);
854 if (brdnr >= stli_nrbrds)
856 brdp = stli_brds[brdnr];
859 if ((brdp->state & BST_STARTED) == 0)
861 portnr = MINOR2PORT(minordev);
862 if (portnr > brdp->nrports)
865 portp = brdp->ports[portnr];
868 if (portp->devnr < 1)
873 * Check if this port is in the middle of closing. If so then wait
874 * until it is closed then return error status based on flag settings.
875 * The sleep here does not need interrupt protection since the wakeup
876 * for it is done with the same context.
878 if (portp->flags & ASYNC_CLOSING) {
879 interruptible_sleep_on(&portp->close_wait);
880 if (portp->flags & ASYNC_HUP_NOTIFY)
886 * On the first open of the device setup the port hardware, and
887 * initialize the per port data structure. Since initializing the port
888 * requires several commands to the board we will need to wait for any
889 * other open that is already initializing the port.
892 tty->driver_data = portp;
895 wait_event_interruptible(portp->raw_wait,
896 !test_bit(ST_INITIALIZING, &portp->state));
897 if (signal_pending(current))
900 if ((portp->flags & ASYNC_INITIALIZED) == 0) {
901 set_bit(ST_INITIALIZING, &portp->state);
902 if ((rc = stli_initopen(brdp, portp)) >= 0) {
903 portp->flags |= ASYNC_INITIALIZED;
904 clear_bit(TTY_IO_ERROR, &tty->flags);
906 clear_bit(ST_INITIALIZING, &portp->state);
907 wake_up_interruptible(&portp->raw_wait);
913 * Check if this port is in the middle of closing. If so then wait
914 * until it is closed then return error status, based on flag settings.
915 * The sleep here does not need interrupt protection since the wakeup
916 * for it is done with the same context.
918 if (portp->flags & ASYNC_CLOSING) {
919 interruptible_sleep_on(&portp->close_wait);
920 if (portp->flags & ASYNC_HUP_NOTIFY)
926 * Based on type of open being done check if it can overlap with any
927 * previous opens still in effect. If we are a normal serial device
928 * then also we might have to wait for carrier.
930 if (!(filp->f_flags & O_NONBLOCK)) {
931 if ((rc = stli_waitcarrier(brdp, portp, filp)) != 0)
934 portp->flags |= ASYNC_NORMAL_ACTIVE;
938 /*****************************************************************************/
940 static void stli_close(struct tty_struct *tty, struct file *filp)
942 struct stlibrd *brdp;
943 struct stliport *portp;
946 portp = tty->driver_data;
950 spin_lock_irqsave(&stli_lock, flags);
951 if (tty_hung_up_p(filp)) {
952 spin_unlock_irqrestore(&stli_lock, flags);
955 if ((tty->count == 1) && (portp->refcount != 1))
957 if (portp->refcount-- > 1) {
958 spin_unlock_irqrestore(&stli_lock, flags);
962 portp->flags |= ASYNC_CLOSING;
965 * May want to wait for data to drain before closing. The BUSY flag
966 * keeps track of whether we are still transmitting or not. It is
967 * updated by messages from the slave - indicating when all chars
968 * really have drained.
970 if (tty == stli_txcooktty)
971 stli_flushchars(tty);
973 spin_unlock_irqrestore(&stli_lock, flags);
975 if (portp->closing_wait != ASYNC_CLOSING_WAIT_NONE)
976 tty_wait_until_sent(tty, portp->closing_wait);
978 portp->flags &= ~ASYNC_INITIALIZED;
979 brdp = stli_brds[portp->brdnr];
980 stli_rawclose(brdp, portp, 0, 0);
981 if (tty->termios->c_cflag & HUPCL) {
982 stli_mkasysigs(&portp->asig, 0, 0);
983 if (test_bit(ST_CMDING, &portp->state))
984 set_bit(ST_DOSIGS, &portp->state);
986 stli_sendcmd(brdp, portp, A_SETSIGNALS, &portp->asig,
987 sizeof(asysigs_t), 0);
989 clear_bit(ST_TXBUSY, &portp->state);
990 clear_bit(ST_RXSTOP, &portp->state);
991 set_bit(TTY_IO_ERROR, &tty->flags);
992 if (tty->ldisc.flush_buffer)
993 (tty->ldisc.flush_buffer)(tty);
994 set_bit(ST_DOFLUSHRX, &portp->state);
995 stli_flushbuffer(tty);
1000 if (portp->openwaitcnt) {
1001 if (portp->close_delay)
1002 msleep_interruptible(jiffies_to_msecs(portp->close_delay));
1003 wake_up_interruptible(&portp->open_wait);
1006 portp->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1007 wake_up_interruptible(&portp->close_wait);
1010 /*****************************************************************************/
1013 * Carry out first open operations on a port. This involves a number of
1014 * commands to be sent to the slave. We need to open the port, set the
1015 * notification events, set the initial port settings, get and set the
1016 * initial signal values. We sleep and wait in between each one. But
1017 * this still all happens pretty quickly.
1020 static int stli_initopen(struct stlibrd *brdp, struct stliport *portp)
1022 struct tty_struct *tty;
1027 if ((rc = stli_rawopen(brdp, portp, 0, 1)) < 0)
1030 memset(&nt, 0, sizeof(asynotify_t));
1031 nt.data = (DT_TXLOW | DT_TXEMPTY | DT_RXBUSY | DT_RXBREAK);
1033 if ((rc = stli_cmdwait(brdp, portp, A_SETNOTIFY, &nt,
1034 sizeof(asynotify_t), 0)) < 0)
1040 stli_mkasyport(portp, &aport, tty->termios);
1041 if ((rc = stli_cmdwait(brdp, portp, A_SETPORT, &aport,
1042 sizeof(asyport_t), 0)) < 0)
1045 set_bit(ST_GETSIGS, &portp->state);
1046 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS, &portp->asig,
1047 sizeof(asysigs_t), 1)) < 0)
1049 if (test_and_clear_bit(ST_GETSIGS, &portp->state))
1050 portp->sigs = stli_mktiocm(portp->asig.sigvalue);
1051 stli_mkasysigs(&portp->asig, 1, 1);
1052 if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1053 sizeof(asysigs_t), 0)) < 0)
1059 /*****************************************************************************/
1062 * Send an open message to the slave. This will sleep waiting for the
1063 * acknowledgement, so must have user context. We need to co-ordinate
1064 * with close events here, since we don't want open and close events
1068 static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
1070 cdkhdr_t __iomem *hdrp;
1071 cdkctrl_t __iomem *cp;
1072 unsigned char __iomem *bits;
1073 unsigned long flags;
1077 * Send a message to the slave to open this port.
1081 * Slave is already closing this port. This can happen if a hangup
1082 * occurs on this port. So we must wait until it is complete. The
1083 * order of opens and closes may not be preserved across shared
1084 * memory, so we must wait until it is complete.
1086 wait_event_interruptible(portp->raw_wait,
1087 !test_bit(ST_CLOSING, &portp->state));
1088 if (signal_pending(current)) {
1089 return -ERESTARTSYS;
1093 * Everything is ready now, so write the open message into shared
1094 * memory. Once the message is in set the service bits to say that
1095 * this port wants service.
1097 spin_lock_irqsave(&brd_lock, flags);
1099 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1100 writel(arg, &cp->openarg);
1101 writeb(1, &cp->open);
1102 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1103 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1105 writeb(readb(bits) | portp->portbit, bits);
1109 spin_unlock_irqrestore(&brd_lock, flags);
1114 * Slave is in action, so now we must wait for the open acknowledgment
1118 set_bit(ST_OPENING, &portp->state);
1119 spin_unlock_irqrestore(&brd_lock, flags);
1121 wait_event_interruptible(portp->raw_wait,
1122 !test_bit(ST_OPENING, &portp->state));
1123 if (signal_pending(current))
1126 if ((rc == 0) && (portp->rc != 0))
1131 /*****************************************************************************/
1134 * Send a close message to the slave. Normally this will sleep waiting
1135 * for the acknowledgement, but if wait parameter is 0 it will not. If
1136 * wait is true then must have user context (to sleep).
1139 static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
1141 cdkhdr_t __iomem *hdrp;
1142 cdkctrl_t __iomem *cp;
1143 unsigned char __iomem *bits;
1144 unsigned long flags;
1148 * Slave is already closing this port. This can happen if a hangup
1149 * occurs on this port.
1152 wait_event_interruptible(portp->raw_wait,
1153 !test_bit(ST_CLOSING, &portp->state));
1154 if (signal_pending(current)) {
1155 return -ERESTARTSYS;
1160 * Write the close command into shared memory.
1162 spin_lock_irqsave(&brd_lock, flags);
1164 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1165 writel(arg, &cp->closearg);
1166 writeb(1, &cp->close);
1167 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1168 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1170 writeb(readb(bits) |portp->portbit, bits);
1173 set_bit(ST_CLOSING, &portp->state);
1174 spin_unlock_irqrestore(&brd_lock, flags);
1180 * Slave is in action, so now we must wait for the open acknowledgment
1184 wait_event_interruptible(portp->raw_wait,
1185 !test_bit(ST_CLOSING, &portp->state));
1186 if (signal_pending(current))
1189 if ((rc == 0) && (portp->rc != 0))
1194 /*****************************************************************************/
1197 * Send a command to the slave and wait for the response. This must
1198 * have user context (it sleeps). This routine is generic in that it
1199 * can send any type of command. Its purpose is to wait for that command
1200 * to complete (as opposed to initiating the command then returning).
1203 static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
1205 wait_event_interruptible(portp->raw_wait,
1206 !test_bit(ST_CMDING, &portp->state));
1207 if (signal_pending(current))
1208 return -ERESTARTSYS;
1210 stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
1212 wait_event_interruptible(portp->raw_wait,
1213 !test_bit(ST_CMDING, &portp->state));
1214 if (signal_pending(current))
1215 return -ERESTARTSYS;
1222 /*****************************************************************************/
1225 * Send the termios settings for this port to the slave. This sleeps
1226 * waiting for the command to complete - so must have user context.
1229 static int stli_setport(struct stliport *portp)
1231 struct stlibrd *brdp;
1236 if (portp->tty == NULL)
1238 if (portp->brdnr >= stli_nrbrds)
1240 brdp = stli_brds[portp->brdnr];
1244 stli_mkasyport(portp, &aport, portp->tty->termios);
1245 return(stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0));
1248 /*****************************************************************************/
1251 * Possibly need to wait for carrier (DCD signal) to come high. Say
1252 * maybe because if we are clocal then we don't need to wait...
1255 static int stli_waitcarrier(struct stlibrd *brdp, struct stliport *portp, struct file *filp)
1257 unsigned long flags;
1263 if (portp->tty->termios->c_cflag & CLOCAL)
1266 spin_lock_irqsave(&stli_lock, flags);
1267 portp->openwaitcnt++;
1268 if (! tty_hung_up_p(filp))
1270 spin_unlock_irqrestore(&stli_lock, flags);
1273 stli_mkasysigs(&portp->asig, 1, 1);
1274 if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS,
1275 &portp->asig, sizeof(asysigs_t), 0)) < 0)
1277 if (tty_hung_up_p(filp) ||
1278 ((portp->flags & ASYNC_INITIALIZED) == 0)) {
1279 if (portp->flags & ASYNC_HUP_NOTIFY)
1285 if (((portp->flags & ASYNC_CLOSING) == 0) &&
1286 (doclocal || (portp->sigs & TIOCM_CD))) {
1289 if (signal_pending(current)) {
1293 interruptible_sleep_on(&portp->open_wait);
1296 spin_lock_irqsave(&stli_lock, flags);
1297 if (! tty_hung_up_p(filp))
1299 portp->openwaitcnt--;
1300 spin_unlock_irqrestore(&stli_lock, flags);
1305 /*****************************************************************************/
1308 * Write routine. Take the data and put it in the shared memory ring
1309 * queue. If port is not already sending chars then need to mark the
1310 * service bits for this port.
1313 static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count)
1315 cdkasy_t __iomem *ap;
1316 cdkhdr_t __iomem *hdrp;
1317 unsigned char __iomem *bits;
1318 unsigned char __iomem *shbuf;
1319 unsigned char *chbuf;
1320 struct stliport *portp;
1321 struct stlibrd *brdp;
1322 unsigned int len, stlen, head, tail, size;
1323 unsigned long flags;
1325 if (tty == stli_txcooktty)
1326 stli_flushchars(tty);
1327 portp = tty->driver_data;
1330 if (portp->brdnr >= stli_nrbrds)
1332 brdp = stli_brds[portp->brdnr];
1335 chbuf = (unsigned char *) buf;
1338 * All data is now local, shove as much as possible into shared memory.
1340 spin_lock_irqsave(&brd_lock, flags);
1342 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1343 head = (unsigned int) readw(&ap->txq.head);
1344 tail = (unsigned int) readw(&ap->txq.tail);
1345 if (tail != ((unsigned int) readw(&ap->txq.tail)))
1346 tail = (unsigned int) readw(&ap->txq.tail);
1347 size = portp->txsize;
1349 len = size - (head - tail) - 1;
1350 stlen = size - head;
1352 len = tail - head - 1;
1356 len = min(len, (unsigned int)count);
1358 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->txoffset);
1361 stlen = min(len, stlen);
1362 memcpy_toio(shbuf + head, chbuf, stlen);
1373 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1374 writew(head, &ap->txq.head);
1375 if (test_bit(ST_TXBUSY, &portp->state)) {
1376 if (readl(&ap->changed.data) & DT_TXEMPTY)
1377 writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
1379 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1380 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1382 writeb(readb(bits) | portp->portbit, bits);
1383 set_bit(ST_TXBUSY, &portp->state);
1385 spin_unlock_irqrestore(&brd_lock, flags);
1390 /*****************************************************************************/
1393 * Output a single character. We put it into a temporary local buffer
1394 * (for speed) then write out that buffer when the flushchars routine
1395 * is called. There is a safety catch here so that if some other port
1396 * writes chars before the current buffer has been, then we write them
1397 * first them do the new ports.
1400 static void stli_putchar(struct tty_struct *tty, unsigned char ch)
1402 if (tty != stli_txcooktty) {
1403 if (stli_txcooktty != NULL)
1404 stli_flushchars(stli_txcooktty);
1405 stli_txcooktty = tty;
1408 stli_txcookbuf[stli_txcooksize++] = ch;
1411 /*****************************************************************************/
1414 * Transfer characters from the local TX cooking buffer to the board.
1415 * We sort of ignore the tty that gets passed in here. We rely on the
1416 * info stored with the TX cook buffer to tell us which port to flush
1417 * the data on. In any case we clean out the TX cook buffer, for re-use
1421 static void stli_flushchars(struct tty_struct *tty)
1423 cdkhdr_t __iomem *hdrp;
1424 unsigned char __iomem *bits;
1425 cdkasy_t __iomem *ap;
1426 struct tty_struct *cooktty;
1427 struct stliport *portp;
1428 struct stlibrd *brdp;
1429 unsigned int len, stlen, head, tail, size, count, cooksize;
1431 unsigned char __iomem *shbuf;
1432 unsigned long flags;
1434 cooksize = stli_txcooksize;
1435 cooktty = stli_txcooktty;
1436 stli_txcooksize = 0;
1437 stli_txcookrealsize = 0;
1438 stli_txcooktty = NULL;
1442 if (cooktty == NULL)
1449 portp = tty->driver_data;
1452 if (portp->brdnr >= stli_nrbrds)
1454 brdp = stli_brds[portp->brdnr];
1458 spin_lock_irqsave(&brd_lock, flags);
1461 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1462 head = (unsigned int) readw(&ap->txq.head);
1463 tail = (unsigned int) readw(&ap->txq.tail);
1464 if (tail != ((unsigned int) readw(&ap->txq.tail)))
1465 tail = (unsigned int) readw(&ap->txq.tail);
1466 size = portp->txsize;
1468 len = size - (head - tail) - 1;
1469 stlen = size - head;
1471 len = tail - head - 1;
1475 len = min(len, cooksize);
1477 shbuf = EBRDGETMEMPTR(brdp, portp->txoffset);
1478 buf = stli_txcookbuf;
1481 stlen = min(len, stlen);
1482 memcpy_toio(shbuf + head, buf, stlen);
1493 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1494 writew(head, &ap->txq.head);
1496 if (test_bit(ST_TXBUSY, &portp->state)) {
1497 if (readl(&ap->changed.data) & DT_TXEMPTY)
1498 writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
1500 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1501 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1503 writeb(readb(bits) | portp->portbit, bits);
1504 set_bit(ST_TXBUSY, &portp->state);
1507 spin_unlock_irqrestore(&brd_lock, flags);
1510 /*****************************************************************************/
1512 static int stli_writeroom(struct tty_struct *tty)
1514 cdkasyrq_t __iomem *rp;
1515 struct stliport *portp;
1516 struct stlibrd *brdp;
1517 unsigned int head, tail, len;
1518 unsigned long flags;
1520 if (tty == stli_txcooktty) {
1521 if (stli_txcookrealsize != 0) {
1522 len = stli_txcookrealsize - stli_txcooksize;
1527 portp = tty->driver_data;
1530 if (portp->brdnr >= stli_nrbrds)
1532 brdp = stli_brds[portp->brdnr];
1536 spin_lock_irqsave(&brd_lock, flags);
1538 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1539 head = (unsigned int) readw(&rp->head);
1540 tail = (unsigned int) readw(&rp->tail);
1541 if (tail != ((unsigned int) readw(&rp->tail)))
1542 tail = (unsigned int) readw(&rp->tail);
1543 len = (head >= tail) ? (portp->txsize - (head - tail)) : (tail - head);
1546 spin_unlock_irqrestore(&brd_lock, flags);
1548 if (tty == stli_txcooktty) {
1549 stli_txcookrealsize = len;
1550 len -= stli_txcooksize;
1555 /*****************************************************************************/
1558 * Return the number of characters in the transmit buffer. Normally we
1559 * will return the number of chars in the shared memory ring queue.
1560 * We need to kludge around the case where the shared memory buffer is
1561 * empty but not all characters have drained yet, for this case just
1562 * return that there is 1 character in the buffer!
1565 static int stli_charsinbuffer(struct tty_struct *tty)
1567 cdkasyrq_t __iomem *rp;
1568 struct stliport *portp;
1569 struct stlibrd *brdp;
1570 unsigned int head, tail, len;
1571 unsigned long flags;
1573 if (tty == stli_txcooktty)
1574 stli_flushchars(tty);
1575 portp = tty->driver_data;
1578 if (portp->brdnr >= stli_nrbrds)
1580 brdp = stli_brds[portp->brdnr];
1584 spin_lock_irqsave(&brd_lock, flags);
1586 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1587 head = (unsigned int) readw(&rp->head);
1588 tail = (unsigned int) readw(&rp->tail);
1589 if (tail != ((unsigned int) readw(&rp->tail)))
1590 tail = (unsigned int) readw(&rp->tail);
1591 len = (head >= tail) ? (head - tail) : (portp->txsize - (tail - head));
1592 if ((len == 0) && test_bit(ST_TXBUSY, &portp->state))
1595 spin_unlock_irqrestore(&brd_lock, flags);
1600 /*****************************************************************************/
1603 * Generate the serial struct info.
1606 static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp)
1608 struct serial_struct sio;
1609 struct stlibrd *brdp;
1611 memset(&sio, 0, sizeof(struct serial_struct));
1612 sio.type = PORT_UNKNOWN;
1613 sio.line = portp->portnr;
1615 sio.flags = portp->flags;
1616 sio.baud_base = portp->baud_base;
1617 sio.close_delay = portp->close_delay;
1618 sio.closing_wait = portp->closing_wait;
1619 sio.custom_divisor = portp->custom_divisor;
1620 sio.xmit_fifo_size = 0;
1623 brdp = stli_brds[portp->brdnr];
1625 sio.port = brdp->iobase;
1627 return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ?
1631 /*****************************************************************************/
1634 * Set port according to the serial struct info.
1635 * At this point we do not do any auto-configure stuff, so we will
1636 * just quietly ignore any requests to change irq, etc.
1639 static int stli_setserial(struct stliport *portp, struct serial_struct __user *sp)
1641 struct serial_struct sio;
1644 if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
1646 if (!capable(CAP_SYS_ADMIN)) {
1647 if ((sio.baud_base != portp->baud_base) ||
1648 (sio.close_delay != portp->close_delay) ||
1649 ((sio.flags & ~ASYNC_USR_MASK) !=
1650 (portp->flags & ~ASYNC_USR_MASK)))
1654 portp->flags = (portp->flags & ~ASYNC_USR_MASK) |
1655 (sio.flags & ASYNC_USR_MASK);
1656 portp->baud_base = sio.baud_base;
1657 portp->close_delay = sio.close_delay;
1658 portp->closing_wait = sio.closing_wait;
1659 portp->custom_divisor = sio.custom_divisor;
1661 if ((rc = stli_setport(portp)) < 0)
1666 /*****************************************************************************/
1668 static int stli_tiocmget(struct tty_struct *tty, struct file *file)
1670 struct stliport *portp = tty->driver_data;
1671 struct stlibrd *brdp;
1676 if (portp->brdnr >= stli_nrbrds)
1678 brdp = stli_brds[portp->brdnr];
1681 if (tty->flags & (1 << TTY_IO_ERROR))
1684 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS,
1685 &portp->asig, sizeof(asysigs_t), 1)) < 0)
1688 return stli_mktiocm(portp->asig.sigvalue);
1691 static int stli_tiocmset(struct tty_struct *tty, struct file *file,
1692 unsigned int set, unsigned int clear)
1694 struct stliport *portp = tty->driver_data;
1695 struct stlibrd *brdp;
1696 int rts = -1, dtr = -1;
1700 if (portp->brdnr >= stli_nrbrds)
1702 brdp = stli_brds[portp->brdnr];
1705 if (tty->flags & (1 << TTY_IO_ERROR))
1708 if (set & TIOCM_RTS)
1710 if (set & TIOCM_DTR)
1712 if (clear & TIOCM_RTS)
1714 if (clear & TIOCM_DTR)
1717 stli_mkasysigs(&portp->asig, dtr, rts);
1719 return stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1720 sizeof(asysigs_t), 0);
1723 static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1725 struct stliport *portp;
1726 struct stlibrd *brdp;
1729 void __user *argp = (void __user *)arg;
1731 portp = tty->driver_data;
1734 if (portp->brdnr >= stli_nrbrds)
1736 brdp = stli_brds[portp->brdnr];
1740 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1741 (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) {
1742 if (tty->flags & (1 << TTY_IO_ERROR))
1750 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
1751 (unsigned __user *) arg);
1754 if ((rc = get_user(ival, (unsigned __user *) arg)) == 0)
1755 tty->termios->c_cflag =
1756 (tty->termios->c_cflag & ~CLOCAL) |
1757 (ival ? CLOCAL : 0);
1760 rc = stli_getserial(portp, argp);
1763 rc = stli_setserial(portp, argp);
1766 rc = put_user(portp->pflag, (unsigned __user *)argp);
1769 if ((rc = get_user(portp->pflag, (unsigned __user *)argp)) == 0)
1770 stli_setport(portp);
1772 case COM_GETPORTSTATS:
1773 rc = stli_getportstats(portp, argp);
1775 case COM_CLRPORTSTATS:
1776 rc = stli_clrportstats(portp, argp);
1782 case TIOCSERGSTRUCT:
1783 case TIOCSERGETMULTI:
1784 case TIOCSERSETMULTI:
1793 /*****************************************************************************/
1796 * This routine assumes that we have user context and can sleep.
1797 * Looks like it is true for the current ttys implementation..!!
1800 static void stli_settermios(struct tty_struct *tty, struct ktermios *old)
1802 struct stliport *portp;
1803 struct stlibrd *brdp;
1804 struct ktermios *tiosp;
1809 portp = tty->driver_data;
1812 if (portp->brdnr >= stli_nrbrds)
1814 brdp = stli_brds[portp->brdnr];
1818 tiosp = tty->termios;
1819 if ((tiosp->c_cflag == old->c_cflag) &&
1820 (tiosp->c_iflag == old->c_iflag))
1823 stli_mkasyport(portp, &aport, tiosp);
1824 stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0);
1825 stli_mkasysigs(&portp->asig, ((tiosp->c_cflag & CBAUD) ? 1 : 0), -1);
1826 stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1827 sizeof(asysigs_t), 0);
1828 if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0))
1829 tty->hw_stopped = 0;
1830 if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL))
1831 wake_up_interruptible(&portp->open_wait);
1834 /*****************************************************************************/
1837 * Attempt to flow control who ever is sending us data. We won't really
1838 * do any flow control action here. We can't directly, and even if we
1839 * wanted to we would have to send a command to the slave. The slave
1840 * knows how to flow control, and will do so when its buffers reach its
1841 * internal high water marks. So what we will do is set a local state
1842 * bit that will stop us sending any RX data up from the poll routine
1843 * (which is the place where RX data from the slave is handled).
1846 static void stli_throttle(struct tty_struct *tty)
1848 struct stliport *portp = tty->driver_data;
1851 set_bit(ST_RXSTOP, &portp->state);
1854 /*****************************************************************************/
1857 * Unflow control the device sending us data... That means that all
1858 * we have to do is clear the RXSTOP state bit. The next poll call
1859 * will then be able to pass the RX data back up.
1862 static void stli_unthrottle(struct tty_struct *tty)
1864 struct stliport *portp = tty->driver_data;
1867 clear_bit(ST_RXSTOP, &portp->state);
1870 /*****************************************************************************/
1873 * Stop the transmitter.
1876 static void stli_stop(struct tty_struct *tty)
1880 /*****************************************************************************/
1883 * Start the transmitter again.
1886 static void stli_start(struct tty_struct *tty)
1890 /*****************************************************************************/
1893 * Scheduler called hang up routine. This is called from the scheduler,
1894 * not direct from the driver "poll" routine. We can't call it there
1895 * since the real local hangup code will enable/disable the board and
1896 * other things that we can't do while handling the poll. Much easier
1897 * to deal with it some time later (don't really care when, hangups
1898 * aren't that time critical).
1901 static void stli_dohangup(struct work_struct *ugly_api)
1903 struct stliport *portp = container_of(ugly_api, struct stliport, tqhangup);
1904 if (portp->tty != NULL) {
1905 tty_hangup(portp->tty);
1909 /*****************************************************************************/
1912 * Hangup this port. This is pretty much like closing the port, only
1913 * a little more brutal. No waiting for data to drain. Shutdown the
1914 * port and maybe drop signals. This is rather tricky really. We want
1915 * to close the port as well.
1918 static void stli_hangup(struct tty_struct *tty)
1920 struct stliport *portp;
1921 struct stlibrd *brdp;
1922 unsigned long flags;
1924 portp = tty->driver_data;
1927 if (portp->brdnr >= stli_nrbrds)
1929 brdp = stli_brds[portp->brdnr];
1933 portp->flags &= ~ASYNC_INITIALIZED;
1935 if (!test_bit(ST_CLOSING, &portp->state))
1936 stli_rawclose(brdp, portp, 0, 0);
1938 spin_lock_irqsave(&stli_lock, flags);
1939 if (tty->termios->c_cflag & HUPCL) {
1940 stli_mkasysigs(&portp->asig, 0, 0);
1941 if (test_bit(ST_CMDING, &portp->state)) {
1942 set_bit(ST_DOSIGS, &portp->state);
1943 set_bit(ST_DOFLUSHTX, &portp->state);
1944 set_bit(ST_DOFLUSHRX, &portp->state);
1946 stli_sendcmd(brdp, portp, A_SETSIGNALSF,
1947 &portp->asig, sizeof(asysigs_t), 0);
1951 clear_bit(ST_TXBUSY, &portp->state);
1952 clear_bit(ST_RXSTOP, &portp->state);
1953 set_bit(TTY_IO_ERROR, &tty->flags);
1955 portp->flags &= ~ASYNC_NORMAL_ACTIVE;
1956 portp->refcount = 0;
1957 spin_unlock_irqrestore(&stli_lock, flags);
1959 wake_up_interruptible(&portp->open_wait);
1962 /*****************************************************************************/
1965 * Flush characters from the lower buffer. We may not have user context
1966 * so we cannot sleep waiting for it to complete. Also we need to check
1967 * if there is chars for this port in the TX cook buffer, and flush them
1971 static void stli_flushbuffer(struct tty_struct *tty)
1973 struct stliport *portp;
1974 struct stlibrd *brdp;
1975 unsigned long ftype, flags;
1977 portp = tty->driver_data;
1980 if (portp->brdnr >= stli_nrbrds)
1982 brdp = stli_brds[portp->brdnr];
1986 spin_lock_irqsave(&brd_lock, flags);
1987 if (tty == stli_txcooktty) {
1988 stli_txcooktty = NULL;
1989 stli_txcooksize = 0;
1990 stli_txcookrealsize = 0;
1992 if (test_bit(ST_CMDING, &portp->state)) {
1993 set_bit(ST_DOFLUSHTX, &portp->state);
1996 if (test_bit(ST_DOFLUSHRX, &portp->state)) {
1998 clear_bit(ST_DOFLUSHRX, &portp->state);
2000 __stli_sendcmd(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
2002 spin_unlock_irqrestore(&brd_lock, flags);
2006 /*****************************************************************************/
2008 static void stli_breakctl(struct tty_struct *tty, int state)
2010 struct stlibrd *brdp;
2011 struct stliport *portp;
2014 portp = tty->driver_data;
2017 if (portp->brdnr >= stli_nrbrds)
2019 brdp = stli_brds[portp->brdnr];
2023 arg = (state == -1) ? BREAKON : BREAKOFF;
2024 stli_cmdwait(brdp, portp, A_BREAK, &arg, sizeof(long), 0);
2027 /*****************************************************************************/
2029 static void stli_waituntilsent(struct tty_struct *tty, int timeout)
2031 struct stliport *portp;
2036 portp = tty->driver_data;
2042 tend = jiffies + timeout;
2044 while (test_bit(ST_TXBUSY, &portp->state)) {
2045 if (signal_pending(current))
2047 msleep_interruptible(20);
2048 if (time_after_eq(jiffies, tend))
2053 /*****************************************************************************/
2055 static void stli_sendxchar(struct tty_struct *tty, char ch)
2057 struct stlibrd *brdp;
2058 struct stliport *portp;
2061 portp = tty->driver_data;
2064 if (portp->brdnr >= stli_nrbrds)
2066 brdp = stli_brds[portp->brdnr];
2070 memset(&actrl, 0, sizeof(asyctrl_t));
2071 if (ch == STOP_CHAR(tty)) {
2072 actrl.rxctrl = CT_STOPFLOW;
2073 } else if (ch == START_CHAR(tty)) {
2074 actrl.rxctrl = CT_STARTFLOW;
2076 actrl.txctrl = CT_SENDCHR;
2079 stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0);
2082 /*****************************************************************************/
2087 * Format info for a specified port. The line is deliberately limited
2088 * to 80 characters. (If it is too long it will be truncated, if too
2089 * short then padded with spaces).
2092 static int stli_portinfo(struct stlibrd *brdp, struct stliport *portp, int portnr, char *pos)
2097 rc = stli_portcmdstats(portp);
2100 if (brdp->state & BST_STARTED) {
2101 switch (stli_comstats.hwid) {
2102 case 0: uart = "2681"; break;
2103 case 1: uart = "SC26198"; break;
2104 default:uart = "CD1400"; break;
2109 sp += sprintf(sp, "%d: uart:%s ", portnr, uart);
2111 if ((brdp->state & BST_STARTED) && (rc >= 0)) {
2112 sp += sprintf(sp, "tx:%d rx:%d", (int) stli_comstats.txtotal,
2113 (int) stli_comstats.rxtotal);
2115 if (stli_comstats.rxframing)
2116 sp += sprintf(sp, " fe:%d",
2117 (int) stli_comstats.rxframing);
2118 if (stli_comstats.rxparity)
2119 sp += sprintf(sp, " pe:%d",
2120 (int) stli_comstats.rxparity);
2121 if (stli_comstats.rxbreaks)
2122 sp += sprintf(sp, " brk:%d",
2123 (int) stli_comstats.rxbreaks);
2124 if (stli_comstats.rxoverrun)
2125 sp += sprintf(sp, " oe:%d",
2126 (int) stli_comstats.rxoverrun);
2128 cnt = sprintf(sp, "%s%s%s%s%s ",
2129 (stli_comstats.signals & TIOCM_RTS) ? "|RTS" : "",
2130 (stli_comstats.signals & TIOCM_CTS) ? "|CTS" : "",
2131 (stli_comstats.signals & TIOCM_DTR) ? "|DTR" : "",
2132 (stli_comstats.signals & TIOCM_CD) ? "|DCD" : "",
2133 (stli_comstats.signals & TIOCM_DSR) ? "|DSR" : "");
2138 for (cnt = (sp - pos); (cnt < (MAXLINE - 1)); cnt++)
2141 pos[(MAXLINE - 2)] = '+';
2142 pos[(MAXLINE - 1)] = '\n';
2147 /*****************************************************************************/
2150 * Port info, read from the /proc file system.
2153 static int stli_readproc(char *page, char **start, off_t off, int count, int *eof, void *data)
2155 struct stlibrd *brdp;
2156 struct stliport *portp;
2157 unsigned int brdnr, portnr, totalport;
2166 pos += sprintf(pos, "%s: version %s", stli_drvtitle,
2168 while (pos < (page + MAXLINE - 1))
2175 * We scan through for each board, panel and port. The offset is
2176 * calculated on the fly, and irrelevant ports are skipped.
2178 for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
2179 brdp = stli_brds[brdnr];
2182 if (brdp->state == 0)
2185 maxoff = curoff + (brdp->nrports * MAXLINE);
2186 if (off >= maxoff) {
2191 totalport = brdnr * STL_MAXPORTS;
2192 for (portnr = 0; (portnr < brdp->nrports); portnr++,
2194 portp = brdp->ports[portnr];
2197 if (off >= (curoff += MAXLINE))
2199 if ((pos - page + MAXLINE) > count)
2201 pos += stli_portinfo(brdp, portp, totalport, pos);
2212 /*****************************************************************************/
2215 * Generic send command routine. This will send a message to the slave,
2216 * of the specified type with the specified argument. Must be very
2217 * careful of data that will be copied out from shared memory -
2218 * containing command results. The command completion is all done from
2219 * a poll routine that does not have user context. Therefore you cannot
2220 * copy back directly into user space, or to the kernel stack of a
2221 * process. This routine does not sleep, so can be called from anywhere.
2223 * The caller must hold the brd_lock (see also stli_sendcmd the usual
2227 static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
2229 cdkhdr_t __iomem *hdrp;
2230 cdkctrl_t __iomem *cp;
2231 unsigned char __iomem *bits;
2232 unsigned long flags;
2234 spin_lock_irqsave(&brd_lock, flags);
2236 if (test_bit(ST_CMDING, &portp->state)) {
2237 printk(KERN_ERR "STALLION: command already busy, cmd=%x!\n",
2239 spin_unlock_irqrestore(&brd_lock, flags);
2244 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
2246 memcpy_toio((void __iomem *) &(cp->args[0]), arg, size);
2249 portp->argsize = size;
2252 writel(0, &cp->status);
2253 writel(cmd, &cp->cmd);
2254 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2255 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
2257 writeb(readb(bits) | portp->portbit, bits);
2258 set_bit(ST_CMDING, &portp->state);
2260 spin_unlock_irqrestore(&brd_lock, flags);
2263 static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
2265 unsigned long flags;
2267 spin_lock_irqsave(&brd_lock, flags);
2268 __stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
2269 spin_unlock_irqrestore(&brd_lock, flags);
2272 /*****************************************************************************/
2275 * Read data from shared memory. This assumes that the shared memory
2276 * is enabled and that interrupts are off. Basically we just empty out
2277 * the shared memory buffer into the tty buffer. Must be careful to
2278 * handle the case where we fill up the tty buffer, but still have
2279 * more chars to unload.
2282 static void stli_read(struct stlibrd *brdp, struct stliport *portp)
2284 cdkasyrq_t __iomem *rp;
2285 char __iomem *shbuf;
2286 struct tty_struct *tty;
2287 unsigned int head, tail, size;
2288 unsigned int len, stlen;
2290 if (test_bit(ST_RXSTOP, &portp->state))
2296 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2297 head = (unsigned int) readw(&rp->head);
2298 if (head != ((unsigned int) readw(&rp->head)))
2299 head = (unsigned int) readw(&rp->head);
2300 tail = (unsigned int) readw(&rp->tail);
2301 size = portp->rxsize;
2306 len = size - (tail - head);
2307 stlen = size - tail;
2310 len = tty_buffer_request_room(tty, len);
2312 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->rxoffset);
2315 unsigned char *cptr;
2317 stlen = min(len, stlen);
2318 tty_prepare_flip_string(tty, &cptr, stlen);
2319 memcpy_fromio(cptr, shbuf + tail, stlen);
2327 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2328 writew(tail, &rp->tail);
2331 set_bit(ST_RXING, &portp->state);
2333 tty_schedule_flip(tty);
2336 /*****************************************************************************/
2339 * Set up and carry out any delayed commands. There is only a small set
2340 * of slave commands that can be done "off-level". So it is not too
2341 * difficult to deal with them here.
2344 static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp)
2348 if (test_bit(ST_DOSIGS, &portp->state)) {
2349 if (test_bit(ST_DOFLUSHTX, &portp->state) &&
2350 test_bit(ST_DOFLUSHRX, &portp->state))
2351 cmd = A_SETSIGNALSF;
2352 else if (test_bit(ST_DOFLUSHTX, &portp->state))
2353 cmd = A_SETSIGNALSFTX;
2354 else if (test_bit(ST_DOFLUSHRX, &portp->state))
2355 cmd = A_SETSIGNALSFRX;
2358 clear_bit(ST_DOFLUSHTX, &portp->state);
2359 clear_bit(ST_DOFLUSHRX, &portp->state);
2360 clear_bit(ST_DOSIGS, &portp->state);
2361 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &portp->asig,
2363 writel(0, &cp->status);
2364 writel(cmd, &cp->cmd);
2365 set_bit(ST_CMDING, &portp->state);
2366 } else if (test_bit(ST_DOFLUSHTX, &portp->state) ||
2367 test_bit(ST_DOFLUSHRX, &portp->state)) {
2368 cmd = ((test_bit(ST_DOFLUSHTX, &portp->state)) ? FLUSHTX : 0);
2369 cmd |= ((test_bit(ST_DOFLUSHRX, &portp->state)) ? FLUSHRX : 0);
2370 clear_bit(ST_DOFLUSHTX, &portp->state);
2371 clear_bit(ST_DOFLUSHRX, &portp->state);
2372 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &cmd, sizeof(int));
2373 writel(0, &cp->status);
2374 writel(A_FLUSH, &cp->cmd);
2375 set_bit(ST_CMDING, &portp->state);
2379 /*****************************************************************************/
2382 * Host command service checking. This handles commands or messages
2383 * coming from the slave to the host. Must have board shared memory
2384 * enabled and interrupts off when called. Notice that by servicing the
2385 * read data last we don't need to change the shared memory pointer
2386 * during processing (which is a slow IO operation).
2387 * Return value indicates if this port is still awaiting actions from
2388 * the slave (like open, command, or even TX data being sent). If 0
2389 * then port is still busy, otherwise no longer busy.
2392 static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp)
2394 cdkasy_t __iomem *ap;
2395 cdkctrl_t __iomem *cp;
2396 struct tty_struct *tty;
2398 unsigned long oldsigs;
2401 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
2405 * Check if we are waiting for an open completion message.
2407 if (test_bit(ST_OPENING, &portp->state)) {
2408 rc = readl(&cp->openarg);
2409 if (readb(&cp->open) == 0 && rc != 0) {
2412 writel(0, &cp->openarg);
2414 clear_bit(ST_OPENING, &portp->state);
2415 wake_up_interruptible(&portp->raw_wait);
2420 * Check if we are waiting for a close completion message.
2422 if (test_bit(ST_CLOSING, &portp->state)) {
2423 rc = (int) readl(&cp->closearg);
2424 if (readb(&cp->close) == 0 && rc != 0) {
2427 writel(0, &cp->closearg);
2429 clear_bit(ST_CLOSING, &portp->state);
2430 wake_up_interruptible(&portp->raw_wait);
2435 * Check if we are waiting for a command completion message. We may
2436 * need to copy out the command results associated with this command.
2438 if (test_bit(ST_CMDING, &portp->state)) {
2439 rc = readl(&cp->status);
2440 if (readl(&cp->cmd) == 0 && rc != 0) {
2443 if (portp->argp != NULL) {
2444 memcpy_fromio(portp->argp, (void __iomem *) &(cp->args[0]),
2448 writel(0, &cp->status);
2450 clear_bit(ST_CMDING, &portp->state);
2451 stli_dodelaycmd(portp, cp);
2452 wake_up_interruptible(&portp->raw_wait);
2457 * Check for any notification messages ready. This includes lots of
2458 * different types of events - RX chars ready, RX break received,
2459 * TX data low or empty in the slave, modem signals changed state.
2468 if (nt.signal & SG_DCD) {
2469 oldsigs = portp->sigs;
2470 portp->sigs = stli_mktiocm(nt.sigvalue);
2471 clear_bit(ST_GETSIGS, &portp->state);
2472 if ((portp->sigs & TIOCM_CD) &&
2473 ((oldsigs & TIOCM_CD) == 0))
2474 wake_up_interruptible(&portp->open_wait);
2475 if ((oldsigs & TIOCM_CD) &&
2476 ((portp->sigs & TIOCM_CD) == 0)) {
2477 if (portp->flags & ASYNC_CHECK_CD) {
2479 schedule_work(&portp->tqhangup);
2484 if (nt.data & DT_TXEMPTY)
2485 clear_bit(ST_TXBUSY, &portp->state);
2486 if (nt.data & (DT_TXEMPTY | DT_TXLOW)) {
2490 wake_up_interruptible(&tty->write_wait);
2494 if ((nt.data & DT_RXBREAK) && (portp->rxmarkmsk & BRKINT)) {
2496 tty_insert_flip_char(tty, 0, TTY_BREAK);
2497 if (portp->flags & ASYNC_SAK) {
2501 tty_schedule_flip(tty);
2505 if (nt.data & DT_RXBUSY) {
2507 stli_read(brdp, portp);
2512 * It might seem odd that we are checking for more RX chars here.
2513 * But, we need to handle the case where the tty buffer was previously
2514 * filled, but we had more characters to pass up. The slave will not
2515 * send any more RX notify messages until the RX buffer has been emptied.
2516 * But it will leave the service bits on (since the buffer is not empty).
2517 * So from here we can try to process more RX chars.
2519 if ((!donerx) && test_bit(ST_RXING, &portp->state)) {
2520 clear_bit(ST_RXING, &portp->state);
2521 stli_read(brdp, portp);
2524 return((test_bit(ST_OPENING, &portp->state) ||
2525 test_bit(ST_CLOSING, &portp->state) ||
2526 test_bit(ST_CMDING, &portp->state) ||
2527 test_bit(ST_TXBUSY, &portp->state) ||
2528 test_bit(ST_RXING, &portp->state)) ? 0 : 1);
2531 /*****************************************************************************/
2534 * Service all ports on a particular board. Assumes that the boards
2535 * shared memory is enabled, and that the page pointer is pointed
2536 * at the cdk header structure.
2539 static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp)
2541 struct stliport *portp;
2542 unsigned char hostbits[(STL_MAXCHANS / 8) + 1];
2543 unsigned char slavebits[(STL_MAXCHANS / 8) + 1];
2544 unsigned char __iomem *slavep;
2545 int bitpos, bitat, bitsize;
2546 int channr, nrdevs, slavebitchange;
2548 bitsize = brdp->bitsize;
2549 nrdevs = brdp->nrdevs;
2552 * Check if slave wants any service. Basically we try to do as
2553 * little work as possible here. There are 2 levels of service
2554 * bits. So if there is nothing to do we bail early. We check
2555 * 8 service bits at a time in the inner loop, so we can bypass
2556 * the lot if none of them want service.
2558 memcpy_fromio(&hostbits[0], (((unsigned char __iomem *) hdrp) + brdp->hostoffset),
2561 memset(&slavebits[0], 0, bitsize);
2564 for (bitpos = 0; (bitpos < bitsize); bitpos++) {
2565 if (hostbits[bitpos] == 0)
2567 channr = bitpos * 8;
2568 for (bitat = 0x1; (channr < nrdevs); channr++, bitat <<= 1) {
2569 if (hostbits[bitpos] & bitat) {
2570 portp = brdp->ports[(channr - 1)];
2571 if (stli_hostcmd(brdp, portp)) {
2573 slavebits[bitpos] |= bitat;
2580 * If any of the ports are no longer busy then update them in the
2581 * slave request bits. We need to do this after, since a host port
2582 * service may initiate more slave requests.
2584 if (slavebitchange) {
2585 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2586 slavep = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset;
2587 for (bitpos = 0; (bitpos < bitsize); bitpos++) {
2588 if (readb(slavebits + bitpos))
2589 writeb(readb(slavep + bitpos) & ~slavebits[bitpos], slavebits + bitpos);
2594 /*****************************************************************************/
2597 * Driver poll routine. This routine polls the boards in use and passes
2598 * messages back up to host when necessary. This is actually very
2599 * CPU efficient, since we will always have the kernel poll clock, it
2600 * adds only a few cycles when idle (since board service can be
2601 * determined very easily), but when loaded generates no interrupts
2602 * (with their expensive associated context change).
2605 static void stli_poll(unsigned long arg)
2607 cdkhdr_t __iomem *hdrp;
2608 struct stlibrd *brdp;
2611 stli_timerlist.expires = STLI_TIMEOUT;
2612 add_timer(&stli_timerlist);
2615 * Check each board and do any servicing required.
2617 for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
2618 brdp = stli_brds[brdnr];
2621 if ((brdp->state & BST_STARTED) == 0)
2624 spin_lock(&brd_lock);
2626 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2627 if (readb(&hdrp->hostreq))
2628 stli_brdpoll(brdp, hdrp);
2630 spin_unlock(&brd_lock);
2634 /*****************************************************************************/
2637 * Translate the termios settings into the port setting structure of
2641 static void stli_mkasyport(struct stliport *portp, asyport_t *pp, struct ktermios *tiosp)
2643 memset(pp, 0, sizeof(asyport_t));
2646 * Start of by setting the baud, char size, parity and stop bit info.
2648 pp->baudout = tty_get_baud_rate(portp->tty);
2649 if ((tiosp->c_cflag & CBAUD) == B38400) {
2650 if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2651 pp->baudout = 57600;
2652 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2653 pp->baudout = 115200;
2654 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2655 pp->baudout = 230400;
2656 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2657 pp->baudout = 460800;
2658 else if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
2659 pp->baudout = (portp->baud_base / portp->custom_divisor);
2661 if (pp->baudout > STL_MAXBAUD)
2662 pp->baudout = STL_MAXBAUD;
2663 pp->baudin = pp->baudout;
2665 switch (tiosp->c_cflag & CSIZE) {
2680 if (tiosp->c_cflag & CSTOPB)
2681 pp->stopbs = PT_STOP2;
2683 pp->stopbs = PT_STOP1;
2685 if (tiosp->c_cflag & PARENB) {
2686 if (tiosp->c_cflag & PARODD)
2687 pp->parity = PT_ODDPARITY;
2689 pp->parity = PT_EVENPARITY;
2691 pp->parity = PT_NOPARITY;
2695 * Set up any flow control options enabled.
2697 if (tiosp->c_iflag & IXON) {
2699 if (tiosp->c_iflag & IXANY)
2700 pp->flow |= F_IXANY;
2702 if (tiosp->c_cflag & CRTSCTS)
2703 pp->flow |= (F_RTSFLOW | F_CTSFLOW);
2705 pp->startin = tiosp->c_cc[VSTART];
2706 pp->stopin = tiosp->c_cc[VSTOP];
2707 pp->startout = tiosp->c_cc[VSTART];
2708 pp->stopout = tiosp->c_cc[VSTOP];
2711 * Set up the RX char marking mask with those RX error types we must
2712 * catch. We can get the slave to help us out a little here, it will
2713 * ignore parity errors and breaks for us, and mark parity errors in
2716 if (tiosp->c_iflag & IGNPAR)
2717 pp->iflag |= FI_IGNRXERRS;
2718 if (tiosp->c_iflag & IGNBRK)
2719 pp->iflag |= FI_IGNBREAK;
2721 portp->rxmarkmsk = 0;
2722 if (tiosp->c_iflag & (INPCK | PARMRK))
2723 pp->iflag |= FI_1MARKRXERRS;
2724 if (tiosp->c_iflag & BRKINT)
2725 portp->rxmarkmsk |= BRKINT;
2728 * Set up clocal processing as required.
2730 if (tiosp->c_cflag & CLOCAL)
2731 portp->flags &= ~ASYNC_CHECK_CD;
2733 portp->flags |= ASYNC_CHECK_CD;
2736 * Transfer any persistent flags into the asyport structure.
2738 pp->pflag = (portp->pflag & 0xffff);
2739 pp->vmin = (portp->pflag & P_RXIMIN) ? 1 : 0;
2740 pp->vtime = (portp->pflag & P_RXITIME) ? 1 : 0;
2741 pp->cc[1] = (portp->pflag & P_RXTHOLD) ? 1 : 0;
2744 /*****************************************************************************/
2747 * Construct a slave signals structure for setting the DTR and RTS
2748 * signals as specified.
2751 static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts)
2753 memset(sp, 0, sizeof(asysigs_t));
2755 sp->signal |= SG_DTR;
2756 sp->sigvalue |= ((dtr > 0) ? SG_DTR : 0);
2759 sp->signal |= SG_RTS;
2760 sp->sigvalue |= ((rts > 0) ? SG_RTS : 0);
2764 /*****************************************************************************/
2767 * Convert the signals returned from the slave into a local TIOCM type
2768 * signals value. We keep them locally in TIOCM format.
2771 static long stli_mktiocm(unsigned long sigvalue)
2774 tiocm |= ((sigvalue & SG_DCD) ? TIOCM_CD : 0);
2775 tiocm |= ((sigvalue & SG_CTS) ? TIOCM_CTS : 0);
2776 tiocm |= ((sigvalue & SG_RI) ? TIOCM_RI : 0);
2777 tiocm |= ((sigvalue & SG_DSR) ? TIOCM_DSR : 0);
2778 tiocm |= ((sigvalue & SG_DTR) ? TIOCM_DTR : 0);
2779 tiocm |= ((sigvalue & SG_RTS) ? TIOCM_RTS : 0);
2783 /*****************************************************************************/
2786 * All panels and ports actually attached have been worked out. All
2787 * we need to do here is set up the appropriate per port data structures.
2790 static int stli_initports(struct stlibrd *brdp)
2792 struct stliport *portp;
2793 unsigned int i, panelnr, panelport;
2795 for (i = 0, panelnr = 0, panelport = 0; (i < brdp->nrports); i++) {
2796 portp = kzalloc(sizeof(struct stliport), GFP_KERNEL);
2798 printk("STALLION: failed to allocate port structure\n");
2802 portp->magic = STLI_PORTMAGIC;
2804 portp->brdnr = brdp->brdnr;
2805 portp->panelnr = panelnr;
2806 portp->baud_base = STL_BAUDBASE;
2807 portp->close_delay = STL_CLOSEDELAY;
2808 portp->closing_wait = 30 * HZ;
2809 INIT_WORK(&portp->tqhangup, stli_dohangup);
2810 init_waitqueue_head(&portp->open_wait);
2811 init_waitqueue_head(&portp->close_wait);
2812 init_waitqueue_head(&portp->raw_wait);
2814 if (panelport >= brdp->panels[panelnr]) {
2818 brdp->ports[i] = portp;
2824 /*****************************************************************************/
2827 * All the following routines are board specific hardware operations.
2830 static void stli_ecpinit(struct stlibrd *brdp)
2832 unsigned long memconf;
2834 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2836 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2839 memconf = (brdp->memaddr & ECP_ATADDRMASK) >> ECP_ATADDRSHFT;
2840 outb(memconf, (brdp->iobase + ECP_ATMEMAR));
2843 /*****************************************************************************/
2845 static void stli_ecpenable(struct stlibrd *brdp)
2847 outb(ECP_ATENABLE, (brdp->iobase + ECP_ATCONFR));
2850 /*****************************************************************************/
2852 static void stli_ecpdisable(struct stlibrd *brdp)
2854 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2857 /*****************************************************************************/
2859 static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2864 if (offset > brdp->memsize) {
2865 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
2866 "range at line=%d(%d), brd=%d\n",
2867 (int) offset, line, __LINE__, brdp->brdnr);
2871 ptr = brdp->membase + (offset % ECP_ATPAGESIZE);
2872 val = (unsigned char) (offset / ECP_ATPAGESIZE);
2874 outb(val, (brdp->iobase + ECP_ATMEMPR));
2878 /*****************************************************************************/
2880 static void stli_ecpreset(struct stlibrd *brdp)
2882 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2884 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2888 /*****************************************************************************/
2890 static void stli_ecpintr(struct stlibrd *brdp)
2892 outb(0x1, brdp->iobase);
2895 /*****************************************************************************/
2898 * The following set of functions act on ECP EISA boards.
2901 static void stli_ecpeiinit(struct stlibrd *brdp)
2903 unsigned long memconf;
2905 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
2906 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2908 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2911 memconf = (brdp->memaddr & ECP_EIADDRMASKL) >> ECP_EIADDRSHFTL;
2912 outb(memconf, (brdp->iobase + ECP_EIMEMARL));
2913 memconf = (brdp->memaddr & ECP_EIADDRMASKH) >> ECP_EIADDRSHFTH;
2914 outb(memconf, (brdp->iobase + ECP_EIMEMARH));
2917 /*****************************************************************************/
2919 static void stli_ecpeienable(struct stlibrd *brdp)
2921 outb(ECP_EIENABLE, (brdp->iobase + ECP_EICONFR));
2924 /*****************************************************************************/
2926 static void stli_ecpeidisable(struct stlibrd *brdp)
2928 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2931 /*****************************************************************************/
2933 static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2938 if (offset > brdp->memsize) {
2939 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
2940 "range at line=%d(%d), brd=%d\n",
2941 (int) offset, line, __LINE__, brdp->brdnr);
2945 ptr = brdp->membase + (offset % ECP_EIPAGESIZE);
2946 if (offset < ECP_EIPAGESIZE)
2949 val = ECP_EIENABLE | 0x40;
2951 outb(val, (brdp->iobase + ECP_EICONFR));
2955 /*****************************************************************************/
2957 static void stli_ecpeireset(struct stlibrd *brdp)
2959 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2961 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2965 /*****************************************************************************/
2968 * The following set of functions act on ECP MCA boards.
2971 static void stli_ecpmcenable(struct stlibrd *brdp)
2973 outb(ECP_MCENABLE, (brdp->iobase + ECP_MCCONFR));
2976 /*****************************************************************************/
2978 static void stli_ecpmcdisable(struct stlibrd *brdp)
2980 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2983 /*****************************************************************************/
2985 static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2990 if (offset > brdp->memsize) {
2991 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
2992 "range at line=%d(%d), brd=%d\n",
2993 (int) offset, line, __LINE__, brdp->brdnr);
2997 ptr = brdp->membase + (offset % ECP_MCPAGESIZE);
2998 val = ((unsigned char) (offset / ECP_MCPAGESIZE)) | ECP_MCENABLE;
3000 outb(val, (brdp->iobase + ECP_MCCONFR));
3004 /*****************************************************************************/
3006 static void stli_ecpmcreset(struct stlibrd *brdp)
3008 outb(ECP_MCSTOP, (brdp->iobase + ECP_MCCONFR));
3010 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
3014 /*****************************************************************************/
3017 * The following set of functions act on ECP PCI boards.
3020 static void stli_ecppciinit(struct stlibrd *brdp)
3022 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
3024 outb(0, (brdp->iobase + ECP_PCICONFR));
3028 /*****************************************************************************/
3030 static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
3035 if (offset > brdp->memsize) {
3036 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
3037 "range at line=%d(%d), board=%d\n",
3038 (int) offset, line, __LINE__, brdp->brdnr);
3042 ptr = brdp->membase + (offset % ECP_PCIPAGESIZE);
3043 val = (offset / ECP_PCIPAGESIZE) << 1;
3045 outb(val, (brdp->iobase + ECP_PCICONFR));
3049 /*****************************************************************************/
3051 static void stli_ecppcireset(struct stlibrd *brdp)
3053 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
3055 outb(0, (brdp->iobase + ECP_PCICONFR));
3059 /*****************************************************************************/
3062 * The following routines act on ONboards.
3065 static void stli_onbinit(struct stlibrd *brdp)
3067 unsigned long memconf;
3069 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
3071 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
3074 memconf = (brdp->memaddr & ONB_ATADDRMASK) >> ONB_ATADDRSHFT;
3075 outb(memconf, (brdp->iobase + ONB_ATMEMAR));
3076 outb(0x1, brdp->iobase);
3080 /*****************************************************************************/
3082 static void stli_onbenable(struct stlibrd *brdp)
3084 outb((brdp->enabval | ONB_ATENABLE), (brdp->iobase + ONB_ATCONFR));
3087 /*****************************************************************************/
3089 static void stli_onbdisable(struct stlibrd *brdp)
3091 outb((brdp->enabval | ONB_ATDISABLE), (brdp->iobase + ONB_ATCONFR));
3094 /*****************************************************************************/
3096 static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
3100 if (offset > brdp->memsize) {
3101 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
3102 "range at line=%d(%d), brd=%d\n",
3103 (int) offset, line, __LINE__, brdp->brdnr);
3106 ptr = brdp->membase + (offset % ONB_ATPAGESIZE);
3111 /*****************************************************************************/
3113 static void stli_onbreset(struct stlibrd *brdp)
3115 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
3117 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
3121 /*****************************************************************************/
3124 * The following routines act on ONboard EISA.
3127 static void stli_onbeinit(struct stlibrd *brdp)
3129 unsigned long memconf;
3131 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
3132 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3134 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3137 memconf = (brdp->memaddr & ONB_EIADDRMASKL) >> ONB_EIADDRSHFTL;
3138 outb(memconf, (brdp->iobase + ONB_EIMEMARL));
3139 memconf = (brdp->memaddr & ONB_EIADDRMASKH) >> ONB_EIADDRSHFTH;
3140 outb(memconf, (brdp->iobase + ONB_EIMEMARH));
3141 outb(0x1, brdp->iobase);
3145 /*****************************************************************************/
3147 static void stli_onbeenable(struct stlibrd *brdp)
3149 outb(ONB_EIENABLE, (brdp->iobase + ONB_EICONFR));
3152 /*****************************************************************************/
3154 static void stli_onbedisable(struct stlibrd *brdp)
3156 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3159 /*****************************************************************************/
3161 static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
3166 if (offset > brdp->memsize) {
3167 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
3168 "range at line=%d(%d), brd=%d\n",
3169 (int) offset, line, __LINE__, brdp->brdnr);
3173 ptr = brdp->membase + (offset % ONB_EIPAGESIZE);
3174 if (offset < ONB_EIPAGESIZE)
3177 val = ONB_EIENABLE | 0x40;
3179 outb(val, (brdp->iobase + ONB_EICONFR));
3183 /*****************************************************************************/
3185 static void stli_onbereset(struct stlibrd *brdp)
3187 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3189 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3193 /*****************************************************************************/
3196 * The following routines act on Brumby boards.
3199 static void stli_bbyinit(struct stlibrd *brdp)
3201 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
3203 outb(0, (brdp->iobase + BBY_ATCONFR));
3205 outb(0x1, brdp->iobase);
3209 /*****************************************************************************/
3211 static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
3216 BUG_ON(offset > brdp->memsize);
3218 ptr = brdp->membase + (offset % BBY_PAGESIZE);
3219 val = (unsigned char) (offset / BBY_PAGESIZE);
3220 outb(val, (brdp->iobase + BBY_ATCONFR));
3224 /*****************************************************************************/
3226 static void stli_bbyreset(struct stlibrd *brdp)
3228 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
3230 outb(0, (brdp->iobase + BBY_ATCONFR));
3234 /*****************************************************************************/
3237 * The following routines act on original old Stallion boards.
3240 static void stli_stalinit(struct stlibrd *brdp)
3242 outb(0x1, brdp->iobase);
3246 /*****************************************************************************/
3248 static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
3250 BUG_ON(offset > brdp->memsize);
3251 return brdp->membase + (offset % STAL_PAGESIZE);
3254 /*****************************************************************************/
3256 static void stli_stalreset(struct stlibrd *brdp)
3260 vecp = (u32 __iomem *) (brdp->membase + 0x30);
3261 writel(0xffff0000, vecp);
3262 outb(0, brdp->iobase);
3266 /*****************************************************************************/
3269 * Try to find an ECP board and initialize it. This handles only ECP
3273 static int stli_initecp(struct stlibrd *brdp)
3276 cdkecpsig_t __iomem *sigsp;
3277 unsigned int status, nxtid;
3279 int panelnr, nrports;
3281 if (!request_region(brdp->iobase, brdp->iosize, "istallion"))
3284 if ((brdp->iobase == 0) || (brdp->memaddr == 0))
3286 release_region(brdp->iobase, brdp->iosize);
3290 brdp->iosize = ECP_IOSIZE;
3293 * Based on the specific board type setup the common vars to access
3294 * and enable shared memory. Set all board specific information now
3297 switch (brdp->brdtype) {
3299 brdp->memsize = ECP_MEMSIZE;
3300 brdp->pagesize = ECP_ATPAGESIZE;
3301 brdp->init = stli_ecpinit;
3302 brdp->enable = stli_ecpenable;
3303 brdp->reenable = stli_ecpenable;
3304 brdp->disable = stli_ecpdisable;
3305 brdp->getmemptr = stli_ecpgetmemptr;
3306 brdp->intr = stli_ecpintr;
3307 brdp->reset = stli_ecpreset;
3308 name = "serial(EC8/64)";
3312 brdp->memsize = ECP_MEMSIZE;
3313 brdp->pagesize = ECP_EIPAGESIZE;
3314 brdp->init = stli_ecpeiinit;
3315 brdp->enable = stli_ecpeienable;
3316 brdp->reenable = stli_ecpeienable;
3317 brdp->disable = stli_ecpeidisable;
3318 brdp->getmemptr = stli_ecpeigetmemptr;
3319 brdp->intr = stli_ecpintr;
3320 brdp->reset = stli_ecpeireset;
3321 name = "serial(EC8/64-EI)";
3325 brdp->memsize = ECP_MEMSIZE;
3326 brdp->pagesize = ECP_MCPAGESIZE;
3328 brdp->enable = stli_ecpmcenable;
3329 brdp->reenable = stli_ecpmcenable;
3330 brdp->disable = stli_ecpmcdisable;
3331 brdp->getmemptr = stli_ecpmcgetmemptr;
3332 brdp->intr = stli_ecpintr;
3333 brdp->reset = stli_ecpmcreset;
3334 name = "serial(EC8/64-MCA)";
3338 brdp->memsize = ECP_PCIMEMSIZE;
3339 brdp->pagesize = ECP_PCIPAGESIZE;
3340 brdp->init = stli_ecppciinit;
3341 brdp->enable = NULL;
3342 brdp->reenable = NULL;
3343 brdp->disable = NULL;
3344 brdp->getmemptr = stli_ecppcigetmemptr;
3345 brdp->intr = stli_ecpintr;
3346 brdp->reset = stli_ecppcireset;
3347 name = "serial(EC/RA-PCI)";
3351 release_region(brdp->iobase, brdp->iosize);
3356 * The per-board operations structure is all set up, so now let's go
3357 * and get the board operational. Firstly initialize board configuration
3358 * registers. Set the memory mapping info so we can get at the boards
3363 brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
3364 if (brdp->membase == NULL)
3366 release_region(brdp->iobase, brdp->iosize);
3371 * Now that all specific code is set up, enable the shared memory and
3372 * look for the a signature area that will tell us exactly what board
3373 * this is, and what it is connected to it.
3376 sigsp = (cdkecpsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3377 memcpy_fromio(&sig, sigsp, sizeof(cdkecpsig_t));
3380 if (sig.magic != cpu_to_le32(ECP_MAGIC))
3382 release_region(brdp->iobase, brdp->iosize);
3383 iounmap(brdp->membase);
3384 brdp->membase = NULL;
3389 * Scan through the signature looking at the panels connected to the
3390 * board. Calculate the total number of ports as we go.
3392 for (panelnr = 0, nxtid = 0; (panelnr < STL_MAXPANELS); panelnr++) {
3393 status = sig.panelid[nxtid];
3394 if ((status & ECH_PNLIDMASK) != nxtid)
3397 brdp->panelids[panelnr] = status;
3398 nrports = (status & ECH_PNL16PORT) ? 16 : 8;
3399 if ((nrports == 16) && ((status & ECH_PNLXPID) == 0))
3401 brdp->panels[panelnr] = nrports;
3402 brdp->nrports += nrports;
3408 brdp->state |= BST_FOUND;
3412 /*****************************************************************************/
3415 * Try to find an ONboard, Brumby or Stallion board and initialize it.
3416 * This handles only these board types.
3419 static int stli_initonb(struct stlibrd *brdp)
3422 cdkonbsig_t __iomem *sigsp;
3427 * Do a basic sanity check on the IO and memory addresses.
3429 if (brdp->iobase == 0 || brdp->memaddr == 0)
3432 brdp->iosize = ONB_IOSIZE;
3434 if (!request_region(brdp->iobase, brdp->iosize, "istallion"))
3438 * Based on the specific board type setup the common vars to access
3439 * and enable shared memory. Set all board specific information now
3442 switch (brdp->brdtype) {
3445 brdp->memsize = ONB_MEMSIZE;
3446 brdp->pagesize = ONB_ATPAGESIZE;
3447 brdp->init = stli_onbinit;
3448 brdp->enable = stli_onbenable;
3449 brdp->reenable = stli_onbenable;
3450 brdp->disable = stli_onbdisable;
3451 brdp->getmemptr = stli_onbgetmemptr;
3452 brdp->intr = stli_ecpintr;
3453 brdp->reset = stli_onbreset;
3454 if (brdp->memaddr > 0x100000)
3455 brdp->enabval = ONB_MEMENABHI;
3457 brdp->enabval = ONB_MEMENABLO;
3458 name = "serial(ONBoard)";
3462 brdp->memsize = ONB_EIMEMSIZE;
3463 brdp->pagesize = ONB_EIPAGESIZE;
3464 brdp->init = stli_onbeinit;
3465 brdp->enable = stli_onbeenable;
3466 brdp->reenable = stli_onbeenable;
3467 brdp->disable = stli_onbedisable;
3468 brdp->getmemptr = stli_onbegetmemptr;
3469 brdp->intr = stli_ecpintr;
3470 brdp->reset = stli_onbereset;
3471 name = "serial(ONBoard/E)";
3475 brdp->memsize = BBY_MEMSIZE;
3476 brdp->pagesize = BBY_PAGESIZE;
3477 brdp->init = stli_bbyinit;
3478 brdp->enable = NULL;
3479 brdp->reenable = NULL;
3480 brdp->disable = NULL;
3481 brdp->getmemptr = stli_bbygetmemptr;
3482 brdp->intr = stli_ecpintr;
3483 brdp->reset = stli_bbyreset;
3484 name = "serial(Brumby)";
3488 brdp->memsize = STAL_MEMSIZE;
3489 brdp->pagesize = STAL_PAGESIZE;
3490 brdp->init = stli_stalinit;
3491 brdp->enable = NULL;
3492 brdp->reenable = NULL;
3493 brdp->disable = NULL;
3494 brdp->getmemptr = stli_stalgetmemptr;
3495 brdp->intr = stli_ecpintr;
3496 brdp->reset = stli_stalreset;
3497 name = "serial(Stallion)";
3501 release_region(brdp->iobase, brdp->iosize);
3506 * The per-board operations structure is all set up, so now let's go
3507 * and get the board operational. Firstly initialize board configuration
3508 * registers. Set the memory mapping info so we can get at the boards
3513 brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
3514 if (brdp->membase == NULL)
3516 release_region(brdp->iobase, brdp->iosize);
3521 * Now that all specific code is set up, enable the shared memory and
3522 * look for the a signature area that will tell us exactly what board
3523 * this is, and how many ports.
3526 sigsp = (cdkonbsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3527 memcpy_fromio(&sig, sigsp, sizeof(cdkonbsig_t));
3530 if (sig.magic0 != cpu_to_le16(ONB_MAGIC0) ||
3531 sig.magic1 != cpu_to_le16(ONB_MAGIC1) ||
3532 sig.magic2 != cpu_to_le16(ONB_MAGIC2) ||
3533 sig.magic3 != cpu_to_le16(ONB_MAGIC3))
3535 release_region(brdp->iobase, brdp->iosize);
3536 iounmap(brdp->membase);
3537 brdp->membase = NULL;
3542 * Scan through the signature alive mask and calculate how many ports
3543 * there are on this board.
3549 for (i = 0; (i < 16); i++) {
3550 if (((sig.amask0 << i) & 0x8000) == 0)
3555 brdp->panels[0] = brdp->nrports;
3558 brdp->state |= BST_FOUND;
3562 /*****************************************************************************/
3565 * Start up a running board. This routine is only called after the
3566 * code has been down loaded to the board and is operational. It will
3567 * read in the memory map, and get the show on the road...
3570 static int stli_startbrd(struct stlibrd *brdp)
3572 cdkhdr_t __iomem *hdrp;
3573 cdkmem_t __iomem *memp;
3574 cdkasy_t __iomem *ap;
3575 unsigned long flags;
3576 unsigned int portnr, nrdevs, i;
3577 struct stliport *portp;
3581 spin_lock_irqsave(&brd_lock, flags);
3583 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
3584 nrdevs = hdrp->nrdevs;
3587 printk("%s(%d): CDK version %d.%d.%d --> "
3588 "nrdevs=%d memp=%x hostp=%x slavep=%x\n",
3589 __FILE__, __LINE__, readb(&hdrp->ver_release), readb(&hdrp->ver_modification),
3590 readb(&hdrp->ver_fix), nrdevs, (int) readl(&hdrp->memp), readl(&hdrp->hostp),
3591 readl(&hdrp->slavep));
3594 if (nrdevs < (brdp->nrports + 1)) {
3595 printk(KERN_ERR "STALLION: slave failed to allocate memory for "
3596 "all devices, devices=%d\n", nrdevs);
3597 brdp->nrports = nrdevs - 1;
3599 brdp->nrdevs = nrdevs;
3600 brdp->hostoffset = hdrp->hostp - CDK_CDKADDR;
3601 brdp->slaveoffset = hdrp->slavep - CDK_CDKADDR;
3602 brdp->bitsize = (nrdevs + 7) / 8;
3603 memoff = readl(&hdrp->memp);
3604 if (memoff > brdp->memsize) {
3605 printk(KERN_ERR "STALLION: corrupted shared memory region?\n");
3607 goto stli_donestartup;
3609 memp = (cdkmem_t __iomem *) EBRDGETMEMPTR(brdp, memoff);
3610 if (readw(&memp->dtype) != TYP_ASYNCTRL) {
3611 printk(KERN_ERR "STALLION: no slave control device found\n");
3612 goto stli_donestartup;
3617 * Cycle through memory allocation of each port. We are guaranteed to
3618 * have all ports inside the first page of slave window, so no need to
3619 * change pages while reading memory map.
3621 for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++, memp++) {
3622 if (readw(&memp->dtype) != TYP_ASYNC)
3624 portp = brdp->ports[portnr];
3628 portp->addr = readl(&memp->offset);
3629 portp->reqbit = (unsigned char) (0x1 << (i * 8 / nrdevs));
3630 portp->portidx = (unsigned char) (i / 8);
3631 portp->portbit = (unsigned char) (0x1 << (i % 8));
3634 writeb(0xff, &hdrp->slavereq);
3637 * For each port setup a local copy of the RX and TX buffer offsets
3638 * and sizes. We do this separate from the above, because we need to
3639 * move the shared memory page...
3641 for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++) {
3642 portp = brdp->ports[portnr];
3645 if (portp->addr == 0)
3647 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
3649 portp->rxsize = readw(&ap->rxq.size);
3650 portp->txsize = readw(&ap->txq.size);
3651 portp->rxoffset = readl(&ap->rxq.offset);
3652 portp->txoffset = readl(&ap->txq.offset);
3658 spin_unlock_irqrestore(&brd_lock, flags);
3661 brdp->state |= BST_STARTED;
3663 if (! stli_timeron) {
3665 stli_timerlist.expires = STLI_TIMEOUT;
3666 add_timer(&stli_timerlist);
3672 /*****************************************************************************/
3675 * Probe and initialize the specified board.
3678 static int __devinit stli_brdinit(struct stlibrd *brdp)
3680 stli_brds[brdp->brdnr] = brdp;
3682 switch (brdp->brdtype) {
3697 printk(KERN_ERR "STALLION: board=%d is unknown board "
3698 "type=%d\n", brdp->brdnr, brdp->brdtype);
3702 if ((brdp->state & BST_FOUND) == 0) {
3703 printk(KERN_ERR "STALLION: %s board not found, board=%d "
3705 stli_brdnames[brdp->brdtype], brdp->brdnr,
3706 brdp->iobase, (int) brdp->memaddr);
3710 stli_initports(brdp);
3711 printk(KERN_INFO "STALLION: %s found, board=%d io=%x mem=%x "
3712 "nrpanels=%d nrports=%d\n", stli_brdnames[brdp->brdtype],
3713 brdp->brdnr, brdp->iobase, (int) brdp->memaddr,
3714 brdp->nrpanels, brdp->nrports);
3718 #if STLI_EISAPROBE != 0
3719 /*****************************************************************************/
3722 * Probe around trying to find where the EISA boards shared memory
3723 * might be. This is a bit if hack, but it is the best we can do.
3726 static int stli_eisamemprobe(struct stlibrd *brdp)
3728 cdkecpsig_t ecpsig, __iomem *ecpsigp;
3729 cdkonbsig_t onbsig, __iomem *onbsigp;
3733 * First up we reset the board, to get it into a known state. There
3734 * is only 2 board types here we need to worry about. Don;t use the
3735 * standard board init routine here, it programs up the shared
3736 * memory address, and we don't know it yet...
3738 if (brdp->brdtype == BRD_ECPE) {
3739 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
3740 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
3742 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
3744 stli_ecpeienable(brdp);
3745 } else if (brdp->brdtype == BRD_ONBOARDE) {
3746 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
3747 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3749 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3751 outb(0x1, brdp->iobase);
3753 stli_onbeenable(brdp);
3759 brdp->memsize = ECP_MEMSIZE;
3762 * Board shared memory is enabled, so now we have a poke around and
3763 * see if we can find it.
3765 for (i = 0; (i < stli_eisamempsize); i++) {
3766 brdp->memaddr = stli_eisamemprobeaddrs[i];
3767 brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
3768 if (brdp->membase == NULL)
3771 if (brdp->brdtype == BRD_ECPE) {
3772 ecpsigp = stli_ecpeigetmemptr(brdp,
3773 CDK_SIGADDR, __LINE__);
3774 memcpy_fromio(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
3775 if (ecpsig.magic == cpu_to_le32(ECP_MAGIC))
3778 onbsigp = (cdkonbsig_t __iomem *) stli_onbegetmemptr(brdp,
3779 CDK_SIGADDR, __LINE__);
3780 memcpy_fromio(&onbsig, onbsigp, sizeof(cdkonbsig_t));
3781 if ((onbsig.magic0 == cpu_to_le16(ONB_MAGIC0)) &&
3782 (onbsig.magic1 == cpu_to_le16(ONB_MAGIC1)) &&
3783 (onbsig.magic2 == cpu_to_le16(ONB_MAGIC2)) &&
3784 (onbsig.magic3 == cpu_to_le16(ONB_MAGIC3)))
3788 iounmap(brdp->membase);
3794 * Regardless of whether we found the shared memory or not we must
3795 * disable the region. After that return success or failure.
3797 if (brdp->brdtype == BRD_ECPE)
3798 stli_ecpeidisable(brdp);
3800 stli_onbedisable(brdp);
3804 brdp->membase = NULL;
3805 printk(KERN_ERR "STALLION: failed to probe shared memory "
3806 "region for %s in EISA slot=%d\n",
3807 stli_brdnames[brdp->brdtype], (brdp->iobase >> 12));
3814 static int stli_getbrdnr(void)
3818 for (i = 0; i < STL_MAXBRDS; i++) {
3819 if (!stli_brds[i]) {
3820 if (i >= stli_nrbrds)
3821 stli_nrbrds = i + 1;
3828 #if STLI_EISAPROBE != 0
3829 /*****************************************************************************/
3832 * Probe around and try to find any EISA boards in system. The biggest
3833 * problem here is finding out what memory address is associated with
3834 * an EISA board after it is found. The registers of the ECPE and
3835 * ONboardE are not readable - so we can't read them from there. We
3836 * don't have access to the EISA CMOS (or EISA BIOS) so we don't
3837 * actually have any way to find out the real value. The best we can
3838 * do is go probing around in the usual places hoping we can find it.
3841 static int stli_findeisabrds(void)
3843 struct stlibrd *brdp;
3844 unsigned int iobase, eid, i;
3848 * Firstly check if this is an EISA system. If this is not an EISA system then
3849 * don't bother going any further!
3855 * Looks like an EISA system, so go searching for EISA boards.
3857 for (iobase = 0x1000; (iobase <= 0xc000); iobase += 0x1000) {
3858 outb(0xff, (iobase + 0xc80));
3859 eid = inb(iobase + 0xc80);
3860 eid |= inb(iobase + 0xc81) << 8;
3861 if (eid != STL_EISAID)
3865 * We have found a board. Need to check if this board was
3866 * statically configured already (just in case!).
3868 for (i = 0; (i < STL_MAXBRDS); i++) {
3869 brdp = stli_brds[i];
3872 if (brdp->iobase == iobase)
3875 if (i < STL_MAXBRDS)
3879 * We have found a Stallion board and it is not configured already.
3880 * Allocate a board structure and initialize it.
3882 if ((brdp = stli_allocbrd()) == NULL)
3884 brdnr = stli_getbrdnr();
3887 brdp->brdnr = (unsigned int)brdnr;
3888 eid = inb(iobase + 0xc82);
3889 if (eid == ECP_EISAID)
3890 brdp->brdtype = BRD_ECPE;
3891 else if (eid == ONB_EISAID)
3892 brdp->brdtype = BRD_ONBOARDE;
3894 brdp->brdtype = BRD_UNKNOWN;
3895 brdp->iobase = iobase;
3896 outb(0x1, (iobase + 0xc84));
3897 if (stli_eisamemprobe(brdp))
3898 outb(0, (iobase + 0xc84));
3905 static inline int stli_findeisabrds(void) { return 0; }
3908 /*****************************************************************************/
3911 * Find the next available board number that is free.
3914 /*****************************************************************************/
3917 * We have a Stallion board. Allocate a board structure and
3918 * initialize it. Read its IO and MEMORY resources from PCI
3919 * configuration space.
3922 static int __devinit stli_pciprobe(struct pci_dev *pdev,
3923 const struct pci_device_id *ent)
3925 struct stlibrd *brdp;
3926 int brdnr, retval = -EIO;
3928 retval = pci_enable_device(pdev);
3931 brdp = stli_allocbrd();
3936 brdnr = stli_getbrdnr();
3937 if (brdnr < 0) { /* TODO: locking */
3938 printk(KERN_INFO "STALLION: too many boards found, "
3939 "maximum supported %d\n", STL_MAXBRDS);
3943 brdp->brdnr = (unsigned int)brdnr;
3944 brdp->brdtype = BRD_ECPPCI;
3946 * We have all resources from the board, so lets setup the actual
3947 * board structure now.
3949 brdp->iobase = pci_resource_start(pdev, 3);
3950 brdp->memaddr = pci_resource_start(pdev, 2);
3951 retval = stli_brdinit(brdp);
3955 pci_set_drvdata(pdev, brdp);
3964 static void stli_pciremove(struct pci_dev *pdev)
3966 struct stlibrd *brdp = pci_get_drvdata(pdev);
3968 stli_cleanup_ports(brdp);
3970 iounmap(brdp->membase);
3971 if (brdp->iosize > 0)
3972 release_region(brdp->iobase, brdp->iosize);
3974 stli_brds[brdp->brdnr] = NULL;
3978 static struct pci_driver stli_pcidriver = {
3979 .name = "istallion",
3980 .id_table = istallion_pci_tbl,
3981 .probe = stli_pciprobe,
3982 .remove = __devexit_p(stli_pciremove)
3984 /*****************************************************************************/
3987 * Allocate a new board structure. Fill out the basic info in it.
3990 static struct stlibrd *stli_allocbrd(void)
3992 struct stlibrd *brdp;
3994 brdp = kzalloc(sizeof(struct stlibrd), GFP_KERNEL);
3996 printk(KERN_ERR "STALLION: failed to allocate memory "
3997 "(size=%Zd)\n", sizeof(struct stlibrd));
4000 brdp->magic = STLI_BOARDMAGIC;
4004 /*****************************************************************************/
4007 * Scan through all the boards in the configuration and see what we
4011 static int stli_initbrds(void)
4013 struct stlibrd *brdp, *nxtbrdp;
4014 struct stlconf conf;
4018 for (stli_nrbrds = 0; stli_nrbrds < ARRAY_SIZE(stli_brdsp);
4020 memset(&conf, 0, sizeof(conf));
4021 if (stli_parsebrd(&conf, stli_brdsp[stli_nrbrds]) == 0)
4023 if ((brdp = stli_allocbrd()) == NULL)
4025 brdp->brdnr = stli_nrbrds;
4026 brdp->brdtype = conf.brdtype;
4027 brdp->iobase = conf.ioaddr1;
4028 brdp->memaddr = conf.memaddr;
4032 stli_findeisabrds();
4034 retval = pci_register_driver(&stli_pcidriver);
4035 /* TODO: check retval and do something */
4038 * All found boards are initialized. Now for a little optimization, if
4039 * no boards are sharing the "shared memory" regions then we can just
4040 * leave them all enabled. This is in fact the usual case.
4043 if (stli_nrbrds > 1) {
4044 for (i = 0; (i < stli_nrbrds); i++) {
4045 brdp = stli_brds[i];
4048 for (j = i + 1; (j < stli_nrbrds); j++) {
4049 nxtbrdp = stli_brds[j];
4050 if (nxtbrdp == NULL)
4052 if ((brdp->membase >= nxtbrdp->membase) &&
4053 (brdp->membase <= (nxtbrdp->membase +
4054 nxtbrdp->memsize - 1))) {
4062 if (stli_shared == 0) {
4063 for (i = 0; (i < stli_nrbrds); i++) {
4064 brdp = stli_brds[i];
4067 if (brdp->state & BST_FOUND) {
4069 brdp->enable = NULL;
4070 brdp->disable = NULL;
4078 /*****************************************************************************/
4081 * Code to handle an "staliomem" read operation. This device is the
4082 * contents of the board shared memory. It is used for down loading
4083 * the slave image (and debugging :-)
4086 static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp)
4088 unsigned long flags;
4089 void __iomem *memptr;
4090 struct stlibrd *brdp;
4096 brdnr = iminor(fp->f_path.dentry->d_inode);
4097 if (brdnr >= stli_nrbrds)
4099 brdp = stli_brds[brdnr];
4102 if (brdp->state == 0)
4104 if (off >= brdp->memsize || off + count < off)
4107 size = min(count, (size_t)(brdp->memsize - off));
4110 * Copy the data a page at a time
4113 p = (void *)__get_free_page(GFP_KERNEL);
4118 spin_lock_irqsave(&brd_lock, flags);
4120 memptr = EBRDGETMEMPTR(brdp, off);
4121 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
4122 n = min(n, (int)PAGE_SIZE);
4123 memcpy_fromio(p, memptr, n);
4125 spin_unlock_irqrestore(&brd_lock, flags);
4126 if (copy_to_user(buf, p, n)) {
4136 free_page((unsigned long)p);
4140 /*****************************************************************************/
4143 * Code to handle an "staliomem" write operation. This device is the
4144 * contents of the board shared memory. It is used for down loading
4145 * the slave image (and debugging :-)
4147 * FIXME: copy under lock
4150 static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp)
4152 unsigned long flags;
4153 void __iomem *memptr;
4154 struct stlibrd *brdp;
4161 brdnr = iminor(fp->f_path.dentry->d_inode);
4163 if (brdnr >= stli_nrbrds)
4165 brdp = stli_brds[brdnr];
4168 if (brdp->state == 0)
4170 if (off >= brdp->memsize || off + count < off)
4173 chbuf = (char __user *) buf;
4174 size = min(count, (size_t)(brdp->memsize - off));
4177 * Copy the data a page at a time
4180 p = (void *)__get_free_page(GFP_KERNEL);
4185 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
4186 n = min(n, (int)PAGE_SIZE);
4187 if (copy_from_user(p, chbuf, n)) {
4192 spin_lock_irqsave(&brd_lock, flags);
4194 memptr = EBRDGETMEMPTR(brdp, off);
4195 memcpy_toio(memptr, p, n);
4197 spin_unlock_irqrestore(&brd_lock, flags);
4203 free_page((unsigned long) p);
4208 /*****************************************************************************/
4211 * Return the board stats structure to user app.
4214 static int stli_getbrdstats(combrd_t __user *bp)
4216 struct stlibrd *brdp;
4219 if (copy_from_user(&stli_brdstats, bp, sizeof(combrd_t)))
4221 if (stli_brdstats.brd >= STL_MAXBRDS)
4223 brdp = stli_brds[stli_brdstats.brd];
4227 memset(&stli_brdstats, 0, sizeof(combrd_t));
4228 stli_brdstats.brd = brdp->brdnr;
4229 stli_brdstats.type = brdp->brdtype;
4230 stli_brdstats.hwid = 0;
4231 stli_brdstats.state = brdp->state;
4232 stli_brdstats.ioaddr = brdp->iobase;
4233 stli_brdstats.memaddr = brdp->memaddr;
4234 stli_brdstats.nrpanels = brdp->nrpanels;
4235 stli_brdstats.nrports = brdp->nrports;
4236 for (i = 0; (i < brdp->nrpanels); i++) {
4237 stli_brdstats.panels[i].panel = i;
4238 stli_brdstats.panels[i].hwid = brdp->panelids[i];
4239 stli_brdstats.panels[i].nrports = brdp->panels[i];
4242 if (copy_to_user(bp, &stli_brdstats, sizeof(combrd_t)))
4247 /*****************************************************************************/
4250 * Resolve the referenced port number into a port struct pointer.
4253 static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr,
4254 unsigned int portnr)
4256 struct stlibrd *brdp;
4259 if (brdnr >= STL_MAXBRDS)
4261 brdp = stli_brds[brdnr];
4264 for (i = 0; (i < panelnr); i++)
4265 portnr += brdp->panels[i];
4266 if (portnr >= brdp->nrports)
4268 return brdp->ports[portnr];
4271 /*****************************************************************************/
4274 * Return the port stats structure to user app. A NULL port struct
4275 * pointer passed in means that we need to find out from the app
4276 * what port to get stats for (used through board control device).
4279 static int stli_portcmdstats(struct stliport *portp)
4281 unsigned long flags;
4282 struct stlibrd *brdp;
4285 memset(&stli_comstats, 0, sizeof(comstats_t));
4289 brdp = stli_brds[portp->brdnr];
4293 if (brdp->state & BST_STARTED) {
4294 if ((rc = stli_cmdwait(brdp, portp, A_GETSTATS,
4295 &stli_cdkstats, sizeof(asystats_t), 1)) < 0)
4298 memset(&stli_cdkstats, 0, sizeof(asystats_t));
4301 stli_comstats.brd = portp->brdnr;
4302 stli_comstats.panel = portp->panelnr;
4303 stli_comstats.port = portp->portnr;
4304 stli_comstats.state = portp->state;
4305 stli_comstats.flags = portp->flags;
4307 spin_lock_irqsave(&brd_lock, flags);
4308 if (portp->tty != NULL) {
4309 if (portp->tty->driver_data == portp) {
4310 stli_comstats.ttystate = portp->tty->flags;
4311 stli_comstats.rxbuffered = -1;
4312 if (portp->tty->termios != NULL) {
4313 stli_comstats.cflags = portp->tty->termios->c_cflag;
4314 stli_comstats.iflags = portp->tty->termios->c_iflag;
4315 stli_comstats.oflags = portp->tty->termios->c_oflag;
4316 stli_comstats.lflags = portp->tty->termios->c_lflag;
4320 spin_unlock_irqrestore(&brd_lock, flags);
4322 stli_comstats.txtotal = stli_cdkstats.txchars;
4323 stli_comstats.rxtotal = stli_cdkstats.rxchars + stli_cdkstats.ringover;
4324 stli_comstats.txbuffered = stli_cdkstats.txringq;
4325 stli_comstats.rxbuffered += stli_cdkstats.rxringq;
4326 stli_comstats.rxoverrun = stli_cdkstats.overruns;
4327 stli_comstats.rxparity = stli_cdkstats.parity;
4328 stli_comstats.rxframing = stli_cdkstats.framing;
4329 stli_comstats.rxlost = stli_cdkstats.ringover;
4330 stli_comstats.rxbreaks = stli_cdkstats.rxbreaks;
4331 stli_comstats.txbreaks = stli_cdkstats.txbreaks;
4332 stli_comstats.txxon = stli_cdkstats.txstart;
4333 stli_comstats.txxoff = stli_cdkstats.txstop;
4334 stli_comstats.rxxon = stli_cdkstats.rxstart;
4335 stli_comstats.rxxoff = stli_cdkstats.rxstop;
4336 stli_comstats.rxrtsoff = stli_cdkstats.rtscnt / 2;
4337 stli_comstats.rxrtson = stli_cdkstats.rtscnt - stli_comstats.rxrtsoff;
4338 stli_comstats.modem = stli_cdkstats.dcdcnt;
4339 stli_comstats.hwid = stli_cdkstats.hwid;
4340 stli_comstats.signals = stli_mktiocm(stli_cdkstats.signals);
4345 /*****************************************************************************/
4348 * Return the port stats structure to user app. A NULL port struct
4349 * pointer passed in means that we need to find out from the app
4350 * what port to get stats for (used through board control device).
4353 static int stli_getportstats(struct stliport *portp, comstats_t __user *cp)
4355 struct stlibrd *brdp;
4359 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
4361 portp = stli_getport(stli_comstats.brd, stli_comstats.panel,
4362 stli_comstats.port);
4367 brdp = stli_brds[portp->brdnr];
4371 if ((rc = stli_portcmdstats(portp)) < 0)
4374 return copy_to_user(cp, &stli_comstats, sizeof(comstats_t)) ?
4378 /*****************************************************************************/
4381 * Clear the port stats structure. We also return it zeroed out...
4384 static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp)
4386 struct stlibrd *brdp;
4390 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
4392 portp = stli_getport(stli_comstats.brd, stli_comstats.panel,
4393 stli_comstats.port);
4398 brdp = stli_brds[portp->brdnr];
4402 if (brdp->state & BST_STARTED) {
4403 if ((rc = stli_cmdwait(brdp, portp, A_CLEARSTATS, NULL, 0, 0)) < 0)
4407 memset(&stli_comstats, 0, sizeof(comstats_t));
4408 stli_comstats.brd = portp->brdnr;
4409 stli_comstats.panel = portp->panelnr;
4410 stli_comstats.port = portp->portnr;
4412 if (copy_to_user(cp, &stli_comstats, sizeof(comstats_t)))
4417 /*****************************************************************************/
4420 * Return the entire driver ports structure to a user app.
4423 static int stli_getportstruct(struct stliport __user *arg)
4425 struct stliport stli_dummyport;
4426 struct stliport *portp;
4428 if (copy_from_user(&stli_dummyport, arg, sizeof(struct stliport)))
4430 portp = stli_getport(stli_dummyport.brdnr, stli_dummyport.panelnr,
4431 stli_dummyport.portnr);
4434 if (copy_to_user(arg, portp, sizeof(struct stliport)))
4439 /*****************************************************************************/
4442 * Return the entire driver board structure to a user app.
4445 static int stli_getbrdstruct(struct stlibrd __user *arg)
4447 struct stlibrd stli_dummybrd;
4448 struct stlibrd *brdp;
4450 if (copy_from_user(&stli_dummybrd, arg, sizeof(struct stlibrd)))
4452 if (stli_dummybrd.brdnr >= STL_MAXBRDS)
4454 brdp = stli_brds[stli_dummybrd.brdnr];
4457 if (copy_to_user(arg, brdp, sizeof(struct stlibrd)))
4462 /*****************************************************************************/
4465 * The "staliomem" device is also required to do some special operations on
4466 * the board. We need to be able to send an interrupt to the board,
4467 * reset it, and start/stop it.
4470 static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
4472 struct stlibrd *brdp;
4473 int brdnr, rc, done;
4474 void __user *argp = (void __user *)arg;
4477 * First up handle the board independent ioctls.
4483 case COM_GETPORTSTATS:
4484 rc = stli_getportstats(NULL, argp);
4487 case COM_CLRPORTSTATS:
4488 rc = stli_clrportstats(NULL, argp);
4491 case COM_GETBRDSTATS:
4492 rc = stli_getbrdstats(argp);
4496 rc = stli_getportstruct(argp);
4500 rc = stli_getbrdstruct(argp);
4509 * Now handle the board specific ioctls. These all depend on the
4510 * minor number of the device they were called from.
4513 if (brdnr >= STL_MAXBRDS)
4515 brdp = stli_brds[brdnr];
4518 if (brdp->state == 0)
4526 rc = stli_startbrd(brdp);
4529 brdp->state &= ~BST_STARTED;
4532 brdp->state &= ~BST_STARTED;
4534 if (stli_shared == 0) {
4535 if (brdp->reenable != NULL)
4536 (* brdp->reenable)(brdp);
4546 static const struct tty_operations stli_ops = {
4548 .close = stli_close,
4549 .write = stli_write,
4550 .put_char = stli_putchar,
4551 .flush_chars = stli_flushchars,
4552 .write_room = stli_writeroom,
4553 .chars_in_buffer = stli_charsinbuffer,
4554 .ioctl = stli_ioctl,
4555 .set_termios = stli_settermios,
4556 .throttle = stli_throttle,
4557 .unthrottle = stli_unthrottle,
4559 .start = stli_start,
4560 .hangup = stli_hangup,
4561 .flush_buffer = stli_flushbuffer,
4562 .break_ctl = stli_breakctl,
4563 .wait_until_sent = stli_waituntilsent,
4564 .send_xchar = stli_sendxchar,
4565 .read_proc = stli_readproc,
4566 .tiocmget = stli_tiocmget,
4567 .tiocmset = stli_tiocmset,
4570 /*****************************************************************************/
4572 static int __init stli_init(void)
4575 printk(KERN_INFO "%s: version %s\n", stli_drvtitle, stli_drvversion);
4577 spin_lock_init(&stli_lock);
4578 spin_lock_init(&brd_lock);
4582 stli_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
4587 * Allocate a temporary write buffer.
4589 stli_txcookbuf = kmalloc(STLI_TXBUFSIZE, GFP_KERNEL);
4590 if (!stli_txcookbuf)
4591 printk(KERN_ERR "STALLION: failed to allocate memory "
4592 "(size=%d)\n", STLI_TXBUFSIZE);
4595 * Set up a character driver for the shared memory region. We need this
4596 * to down load the slave code image. Also it is a useful debugging tool.
4598 if (register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stli_fsiomem))
4599 printk(KERN_ERR "STALLION: failed to register serial memory "
4602 istallion_class = class_create(THIS_MODULE, "staliomem");
4603 for (i = 0; i < 4; i++)
4604 class_device_create(istallion_class, NULL,
4605 MKDEV(STL_SIOMEMMAJOR, i),
4606 NULL, "staliomem%d", i);
4609 * Set up the tty driver structure and register us as a driver.
4611 stli_serial->owner = THIS_MODULE;
4612 stli_serial->driver_name = stli_drvname;
4613 stli_serial->name = stli_serialname;
4614 stli_serial->major = STL_SERIALMAJOR;
4615 stli_serial->minor_start = 0;
4616 stli_serial->type = TTY_DRIVER_TYPE_SERIAL;
4617 stli_serial->subtype = SERIAL_TYPE_NORMAL;
4618 stli_serial->init_termios = stli_deftermios;
4619 stli_serial->flags = TTY_DRIVER_REAL_RAW;
4620 tty_set_operations(stli_serial, &stli_ops);
4622 if (tty_register_driver(stli_serial)) {
4623 put_tty_driver(stli_serial);
4624 printk(KERN_ERR "STALLION: failed to register serial driver\n");
4630 /*****************************************************************************/