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/sched.h>
23 #include <linux/slab.h>
24 #include <linux/smp_lock.h>
25 #include <linux/interrupt.h>
26 #include <linux/tty.h>
27 #include <linux/tty_flip.h>
28 #include <linux/serial.h>
29 #include <linux/seq_file.h>
30 #include <linux/cdk.h>
31 #include <linux/comstats.h>
32 #include <linux/istallion.h>
33 #include <linux/ioport.h>
34 #include <linux/delay.h>
35 #include <linux/init.h>
36 #include <linux/device.h>
37 #include <linux/wait.h>
38 #include <linux/eisa.h>
39 #include <linux/ctype.h>
42 #include <asm/uaccess.h>
44 #include <linux/pci.h>
46 /*****************************************************************************/
49 * Define different board types. Not all of the following board types
50 * are supported by this driver. But I will use the standard "assigned"
51 * board numbers. Currently supported boards are abbreviated as:
52 * ECP = EasyConnection 8/64, ONB = ONboard, BBY = Brumby and
56 #define BRD_STALLION 1
58 #define BRD_ONBOARD2 3
60 #define BRD_ONBOARDE 7
66 #define BRD_BRUMBY BRD_BRUMBY4
69 * Define a configuration structure to hold the board configuration.
70 * Need to set this up in the code (for now) with the boards that are
71 * to be configured into the system. This is what needs to be modified
72 * when adding/removing/modifying boards. Each line entry in the
73 * stli_brdconf[] array is a board. Each line contains io/irq/memory
74 * ranges for that board (as well as what type of board it is).
76 * { BRD_ECP, 0x2a0, 0, 0xcc000, 0, 0 },
77 * This line will configure an EasyConnection 8/64 at io address 2a0,
78 * and shared memory address of cc000. Multiple EasyConnection 8/64
79 * boards can share the same shared memory address space. No interrupt
80 * is required for this board type.
82 * { BRD_ECPE, 0x5000, 0, 0x80000000, 0, 0 },
83 * This line will configure an EasyConnection 8/64 EISA in slot 5 and
84 * shared memory address of 0x80000000 (2 GByte). Multiple
85 * EasyConnection 8/64 EISA boards can share the same shared memory
86 * address space. No interrupt is required for this board type.
88 * { BRD_ONBOARD, 0x240, 0, 0xd0000, 0, 0 },
89 * This line will configure an ONboard (ISA type) at io address 240,
90 * and shared memory address of d0000. Multiple ONboards can share
91 * the same shared memory address space. No interrupt required.
93 * { BRD_BRUMBY4, 0x360, 0, 0xc8000, 0, 0 },
94 * This line will configure a Brumby board (any number of ports!) at
95 * io address 360 and shared memory address of c8000. All Brumby boards
96 * configured into a system must have their own separate io and memory
97 * addresses. No interrupt is required.
99 * { BRD_STALLION, 0x330, 0, 0xd0000, 0, 0 },
100 * This line will configure an original Stallion board at io address 330
101 * and shared memory address d0000 (this would only be valid for a "V4.0"
102 * or Rev.O Stallion board). All Stallion boards configured into the
103 * system must have their own separate io and memory addresses. No
104 * interrupt is required.
111 unsigned long memaddr;
116 static unsigned int stli_nrbrds;
118 /* stli_lock must NOT be taken holding brd_lock */
119 static spinlock_t stli_lock; /* TTY logic lock */
120 static spinlock_t brd_lock; /* Board logic lock */
123 * There is some experimental EISA board detection code in this driver.
124 * By default it is disabled, but for those that want to try it out,
125 * then set the define below to be 1.
127 #define STLI_EISAPROBE 0
129 /*****************************************************************************/
132 * Define some important driver characteristics. Device major numbers
133 * allocated as per Linux Device Registry.
135 #ifndef STL_SIOMEMMAJOR
136 #define STL_SIOMEMMAJOR 28
138 #ifndef STL_SERIALMAJOR
139 #define STL_SERIALMAJOR 24
141 #ifndef STL_CALLOUTMAJOR
142 #define STL_CALLOUTMAJOR 25
145 /*****************************************************************************/
148 * Define our local driver identity first. Set up stuff to deal with
149 * all the local structures required by a serial tty driver.
151 static char *stli_drvtitle = "Stallion Intelligent Multiport Serial Driver";
152 static char *stli_drvname = "istallion";
153 static char *stli_drvversion = "5.6.0";
154 static char *stli_serialname = "ttyE";
156 static struct tty_driver *stli_serial;
157 static const struct tty_port_operations stli_port_ops;
159 #define STLI_TXBUFSIZE 4096
162 * Use a fast local buffer for cooked characters. Typically a whole
163 * bunch of cooked characters come in for a port, 1 at a time. So we
164 * save those up into a local buffer, then write out the whole lot
165 * with a large memcpy. Just use 1 buffer for all ports, since its
166 * use it is only need for short periods of time by each port.
168 static char *stli_txcookbuf;
169 static int stli_txcooksize;
170 static int stli_txcookrealsize;
171 static struct tty_struct *stli_txcooktty;
174 * Define a local default termios struct. All ports will be created
175 * with this termios initially. Basically all it defines is a raw port
176 * at 9600 baud, 8 data bits, no parity, 1 stop bit.
178 static struct ktermios stli_deftermios = {
179 .c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
186 * Define global stats structures. Not used often, and can be
187 * re-used for each stats call.
189 static comstats_t stli_comstats;
190 static combrd_t stli_brdstats;
191 static struct asystats stli_cdkstats;
193 /*****************************************************************************/
195 static DEFINE_MUTEX(stli_brdslock);
196 static struct stlibrd *stli_brds[STL_MAXBRDS];
198 static int stli_shared;
201 * Per board state flags. Used with the state field of the board struct.
202 * Not really much here... All we need to do is keep track of whether
203 * the board has been detected, and whether it is actually running a slave
207 #define BST_STARTED 1
211 * Define the set of port state flags. These are marked for internal
212 * state purposes only, usually to do with the state of communications
213 * with the slave. Most of them need to be updated atomically, so always
214 * use the bit setting operations (unless protected by cli/sti).
221 #define ST_DOFLUSHRX 7
222 #define ST_DOFLUSHTX 8
225 #define ST_GETSIGS 11
228 * Define an array of board names as printable strings. Handy for
229 * referencing boards when printing trace and stuff.
231 static char *stli_brdnames[] = {
264 /*****************************************************************************/
267 * Define some string labels for arguments passed from the module
268 * load line. These allow for easy board definitions, and easy
269 * modification of the io, memory and irq resoucres.
272 static char *board0[8];
273 static char *board1[8];
274 static char *board2[8];
275 static char *board3[8];
277 static char **stli_brdsp[] = {
285 * Define a set of common board names, and types. This is used to
286 * parse any module arguments.
289 static struct stlibrdtype {
293 { "stallion", BRD_STALLION },
294 { "1", BRD_STALLION },
295 { "brumby", BRD_BRUMBY },
296 { "brumby4", BRD_BRUMBY },
297 { "brumby/4", BRD_BRUMBY },
298 { "brumby-4", BRD_BRUMBY },
299 { "brumby8", BRD_BRUMBY },
300 { "brumby/8", BRD_BRUMBY },
301 { "brumby-8", BRD_BRUMBY },
302 { "brumby16", BRD_BRUMBY },
303 { "brumby/16", BRD_BRUMBY },
304 { "brumby-16", BRD_BRUMBY },
306 { "onboard2", BRD_ONBOARD2 },
307 { "onboard-2", BRD_ONBOARD2 },
308 { "onboard/2", BRD_ONBOARD2 },
309 { "onboard-mc", BRD_ONBOARD2 },
310 { "onboard/mc", BRD_ONBOARD2 },
311 { "onboard-mca", BRD_ONBOARD2 },
312 { "onboard/mca", BRD_ONBOARD2 },
313 { "3", BRD_ONBOARD2 },
314 { "onboard", BRD_ONBOARD },
315 { "onboardat", BRD_ONBOARD },
316 { "4", BRD_ONBOARD },
317 { "onboarde", BRD_ONBOARDE },
318 { "onboard-e", BRD_ONBOARDE },
319 { "onboard/e", BRD_ONBOARDE },
320 { "onboard-ei", BRD_ONBOARDE },
321 { "onboard/ei", BRD_ONBOARDE },
322 { "7", BRD_ONBOARDE },
324 { "ecpat", BRD_ECP },
325 { "ec8/64", BRD_ECP },
326 { "ec8/64-at", BRD_ECP },
327 { "ec8/64-isa", BRD_ECP },
329 { "ecpe", BRD_ECPE },
330 { "ecpei", BRD_ECPE },
331 { "ec8/64-e", BRD_ECPE },
332 { "ec8/64-ei", BRD_ECPE },
334 { "ecpmc", BRD_ECPMC },
335 { "ec8/64-mc", BRD_ECPMC },
336 { "ec8/64-mca", BRD_ECPMC },
338 { "ecppci", BRD_ECPPCI },
339 { "ec/ra", BRD_ECPPCI },
340 { "ec/ra-pc", BRD_ECPPCI },
341 { "ec/ra-pci", BRD_ECPPCI },
342 { "29", BRD_ECPPCI },
346 * Define the module agruments.
348 MODULE_AUTHOR("Greg Ungerer");
349 MODULE_DESCRIPTION("Stallion Intelligent Multiport Serial Driver");
350 MODULE_LICENSE("GPL");
353 module_param_array(board0, charp, NULL, 0);
354 MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,memaddr]");
355 module_param_array(board1, charp, NULL, 0);
356 MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,memaddr]");
357 module_param_array(board2, charp, NULL, 0);
358 MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,memaddr]");
359 module_param_array(board3, charp, NULL, 0);
360 MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,memaddr]");
362 #if STLI_EISAPROBE != 0
364 * Set up a default memory address table for EISA board probing.
365 * The default addresses are all bellow 1Mbyte, which has to be the
366 * case anyway. They should be safe, since we only read values from
367 * them, and interrupts are disabled while we do it. If the higher
368 * memory support is compiled in then we also try probing around
369 * the 1Gb, 2Gb and 3Gb areas as well...
371 static unsigned long stli_eisamemprobeaddrs[] = {
372 0xc0000, 0xd0000, 0xe0000, 0xf0000,
373 0x80000000, 0x80010000, 0x80020000, 0x80030000,
374 0x40000000, 0x40010000, 0x40020000, 0x40030000,
375 0xc0000000, 0xc0010000, 0xc0020000, 0xc0030000,
376 0xff000000, 0xff010000, 0xff020000, 0xff030000,
379 static int stli_eisamempsize = ARRAY_SIZE(stli_eisamemprobeaddrs);
383 * Define the Stallion PCI vendor and device IDs.
385 #ifndef PCI_DEVICE_ID_ECRA
386 #define PCI_DEVICE_ID_ECRA 0x0004
389 static struct pci_device_id istallion_pci_tbl[] = {
390 { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA), },
393 MODULE_DEVICE_TABLE(pci, istallion_pci_tbl);
395 static struct pci_driver stli_pcidriver;
397 /*****************************************************************************/
400 * Hardware configuration info for ECP boards. These defines apply
401 * to the directly accessible io ports of the ECP. There is a set of
402 * defines for each ECP board type, ISA, EISA, MCA and PCI.
406 #define ECP_MEMSIZE (128 * 1024)
407 #define ECP_PCIMEMSIZE (256 * 1024)
409 #define ECP_ATPAGESIZE (4 * 1024)
410 #define ECP_MCPAGESIZE (4 * 1024)
411 #define ECP_EIPAGESIZE (64 * 1024)
412 #define ECP_PCIPAGESIZE (64 * 1024)
414 #define STL_EISAID 0x8c4e
417 * Important defines for the ISA class of ECP board.
420 #define ECP_ATCONFR 1
421 #define ECP_ATMEMAR 2
422 #define ECP_ATMEMPR 3
423 #define ECP_ATSTOP 0x1
424 #define ECP_ATINTENAB 0x10
425 #define ECP_ATENABLE 0x20
426 #define ECP_ATDISABLE 0x00
427 #define ECP_ATADDRMASK 0x3f000
428 #define ECP_ATADDRSHFT 12
431 * Important defines for the EISA class of ECP board.
434 #define ECP_EIMEMARL 1
435 #define ECP_EICONFR 2
436 #define ECP_EIMEMARH 3
437 #define ECP_EIENABLE 0x1
438 #define ECP_EIDISABLE 0x0
439 #define ECP_EISTOP 0x4
440 #define ECP_EIEDGE 0x00
441 #define ECP_EILEVEL 0x80
442 #define ECP_EIADDRMASKL 0x00ff0000
443 #define ECP_EIADDRSHFTL 16
444 #define ECP_EIADDRMASKH 0xff000000
445 #define ECP_EIADDRSHFTH 24
446 #define ECP_EIBRDENAB 0xc84
448 #define ECP_EISAID 0x4
451 * Important defines for the Micro-channel class of ECP board.
452 * (It has a lot in common with the ISA boards.)
455 #define ECP_MCCONFR 1
456 #define ECP_MCSTOP 0x20
457 #define ECP_MCENABLE 0x80
458 #define ECP_MCDISABLE 0x00
461 * Important defines for the PCI class of ECP board.
462 * (It has a lot in common with the other ECP boards.)
464 #define ECP_PCIIREG 0
465 #define ECP_PCICONFR 1
466 #define ECP_PCISTOP 0x01
469 * Hardware configuration info for ONboard and Brumby boards. These
470 * defines apply to the directly accessible io ports of these boards.
472 #define ONB_IOSIZE 16
473 #define ONB_MEMSIZE (64 * 1024)
474 #define ONB_ATPAGESIZE (64 * 1024)
475 #define ONB_MCPAGESIZE (64 * 1024)
476 #define ONB_EIMEMSIZE (128 * 1024)
477 #define ONB_EIPAGESIZE (64 * 1024)
480 * Important defines for the ISA class of ONboard board.
483 #define ONB_ATMEMAR 1
484 #define ONB_ATCONFR 2
485 #define ONB_ATSTOP 0x4
486 #define ONB_ATENABLE 0x01
487 #define ONB_ATDISABLE 0x00
488 #define ONB_ATADDRMASK 0xff0000
489 #define ONB_ATADDRSHFT 16
491 #define ONB_MEMENABLO 0
492 #define ONB_MEMENABHI 0x02
495 * Important defines for the EISA class of ONboard board.
498 #define ONB_EIMEMARL 1
499 #define ONB_EICONFR 2
500 #define ONB_EIMEMARH 3
501 #define ONB_EIENABLE 0x1
502 #define ONB_EIDISABLE 0x0
503 #define ONB_EISTOP 0x4
504 #define ONB_EIEDGE 0x00
505 #define ONB_EILEVEL 0x80
506 #define ONB_EIADDRMASKL 0x00ff0000
507 #define ONB_EIADDRSHFTL 16
508 #define ONB_EIADDRMASKH 0xff000000
509 #define ONB_EIADDRSHFTH 24
510 #define ONB_EIBRDENAB 0xc84
512 #define ONB_EISAID 0x1
515 * Important defines for the Brumby boards. They are pretty simple,
516 * there is not much that is programmably configurable.
518 #define BBY_IOSIZE 16
519 #define BBY_MEMSIZE (64 * 1024)
520 #define BBY_PAGESIZE (16 * 1024)
523 #define BBY_ATCONFR 1
524 #define BBY_ATSTOP 0x4
527 * Important defines for the Stallion boards. They are pretty simple,
528 * there is not much that is programmably configurable.
530 #define STAL_IOSIZE 16
531 #define STAL_MEMSIZE (64 * 1024)
532 #define STAL_PAGESIZE (64 * 1024)
535 * Define the set of status register values for EasyConnection panels.
536 * The signature will return with the status value for each panel. From
537 * this we can determine what is attached to the board - before we have
538 * actually down loaded any code to it.
540 #define ECH_PNLSTATUS 2
541 #define ECH_PNL16PORT 0x20
542 #define ECH_PNLIDMASK 0x07
543 #define ECH_PNLXPID 0x40
544 #define ECH_PNLINTRPEND 0x80
547 * Define some macros to do things to the board. Even those these boards
548 * are somewhat related there is often significantly different ways of
549 * doing some operation on it (like enable, paging, reset, etc). So each
550 * board class has a set of functions which do the commonly required
551 * operations. The macros below basically just call these functions,
552 * generally checking for a NULL function - which means that the board
553 * needs nothing done to it to achieve this operation!
555 #define EBRDINIT(brdp) \
556 if (brdp->init != NULL) \
559 #define EBRDENABLE(brdp) \
560 if (brdp->enable != NULL) \
561 (* brdp->enable)(brdp);
563 #define EBRDDISABLE(brdp) \
564 if (brdp->disable != NULL) \
565 (* brdp->disable)(brdp);
567 #define EBRDINTR(brdp) \
568 if (brdp->intr != NULL) \
569 (* brdp->intr)(brdp);
571 #define EBRDRESET(brdp) \
572 if (brdp->reset != NULL) \
573 (* brdp->reset)(brdp);
575 #define EBRDGETMEMPTR(brdp,offset) \
576 (* brdp->getmemptr)(brdp, offset, __LINE__)
579 * Define the maximal baud rate, and the default baud base for ports.
581 #define STL_MAXBAUD 460800
582 #define STL_BAUDBASE 115200
583 #define STL_CLOSEDELAY (5 * HZ / 10)
585 /*****************************************************************************/
588 * Define macros to extract a brd or port number from a minor number.
590 #define MINOR2BRD(min) (((min) & 0xc0) >> 6)
591 #define MINOR2PORT(min) ((min) & 0x3f)
593 /*****************************************************************************/
596 * Prototype all functions in this driver!
599 static int stli_parsebrd(struct stlconf *confp, char **argp);
600 static int stli_open(struct tty_struct *tty, struct file *filp);
601 static void stli_close(struct tty_struct *tty, struct file *filp);
602 static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count);
603 static int stli_putchar(struct tty_struct *tty, unsigned char ch);
604 static void stli_flushchars(struct tty_struct *tty);
605 static int stli_writeroom(struct tty_struct *tty);
606 static int stli_charsinbuffer(struct tty_struct *tty);
607 static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
608 static void stli_settermios(struct tty_struct *tty, struct ktermios *old);
609 static void stli_throttle(struct tty_struct *tty);
610 static void stli_unthrottle(struct tty_struct *tty);
611 static void stli_stop(struct tty_struct *tty);
612 static void stli_start(struct tty_struct *tty);
613 static void stli_flushbuffer(struct tty_struct *tty);
614 static int stli_breakctl(struct tty_struct *tty, int state);
615 static void stli_waituntilsent(struct tty_struct *tty, int timeout);
616 static void stli_sendxchar(struct tty_struct *tty, char ch);
617 static void stli_hangup(struct tty_struct *tty);
619 static int stli_brdinit(struct stlibrd *brdp);
620 static int stli_startbrd(struct stlibrd *brdp);
621 static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp);
622 static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp);
623 static long stli_memioctl(struct file *fp, unsigned int cmd, unsigned long arg);
624 static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp);
625 static void stli_poll(unsigned long arg);
626 static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp);
627 static int stli_initopen(struct tty_struct *tty, struct stlibrd *brdp, struct stliport *portp);
628 static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
629 static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
630 static int stli_setport(struct tty_struct *tty);
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 tty_struct *tty, 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 tty_struct *tty, struct serial_struct __user *sp);
641 static int stli_getbrdstats(combrd_t __user *bp);
642 static int stli_getportstats(struct tty_struct *tty, struct stliport *portp, comstats_t __user *cp);
643 static int stli_portcmdstats(struct tty_struct *tty, 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 .unlocked_ioctl = stli_memioctl,
707 .llseek = default_llseek,
710 /*****************************************************************************/
713 * Define a timer_list entry for our poll routine. The slave board
714 * is polled every so often to see if anything needs doing. This is
715 * much cheaper on host cpu than using interrupts. It turns out to
716 * not increase character latency by much either...
718 static DEFINE_TIMER(stli_timerlist, stli_poll, 0, 0);
720 static int stli_timeron;
723 * Define the calculation for the timeout routine.
725 #define STLI_TIMEOUT (jiffies + 1)
727 /*****************************************************************************/
729 static struct class *istallion_class;
731 static void stli_cleanup_ports(struct stlibrd *brdp)
733 struct stliport *portp;
735 struct tty_struct *tty;
737 for (j = 0; j < STL_MAXPORTS; j++) {
738 portp = brdp->ports[j];
740 tty = tty_port_tty_get(&portp->port);
750 /*****************************************************************************/
753 * Parse the supplied argument string, into the board conf struct.
756 static int stli_parsebrd(struct stlconf *confp, char **argp)
761 if (argp[0] == NULL || *argp[0] == 0)
764 for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
767 for (i = 0; i < ARRAY_SIZE(stli_brdstr); i++) {
768 if (strcmp(stli_brdstr[i].name, argp[0]) == 0)
771 if (i == ARRAY_SIZE(stli_brdstr)) {
772 printk(KERN_WARNING "istallion: unknown board name, %s?\n", argp[0]);
776 confp->brdtype = stli_brdstr[i].type;
777 if (argp[1] != NULL && *argp[1] != 0)
778 confp->ioaddr1 = simple_strtoul(argp[1], NULL, 0);
779 if (argp[2] != NULL && *argp[2] != 0)
780 confp->memaddr = simple_strtoul(argp[2], NULL, 0);
784 /*****************************************************************************/
787 * On the first open of the device setup the port hardware, and
788 * initialize the per port data structure. Since initializing the port
789 * requires several commands to the board we will need to wait for any
790 * other open that is already initializing the port.
792 * Locking: protected by the port mutex.
795 static int stli_activate(struct tty_port *port, struct tty_struct *tty)
797 struct stliport *portp = container_of(port, struct stliport, port);
798 struct stlibrd *brdp = stli_brds[portp->brdnr];
801 if ((rc = stli_initopen(tty, brdp, portp)) >= 0)
802 clear_bit(TTY_IO_ERROR, &tty->flags);
803 wake_up_interruptible(&portp->raw_wait);
807 static int stli_open(struct tty_struct *tty, struct file *filp)
809 struct stlibrd *brdp;
810 struct stliport *portp;
811 unsigned int minordev, brdnr, portnr;
813 minordev = tty->index;
814 brdnr = MINOR2BRD(minordev);
815 if (brdnr >= stli_nrbrds)
817 brdp = stli_brds[brdnr];
820 if (!test_bit(BST_STARTED, &brdp->state))
822 portnr = MINOR2PORT(minordev);
823 if (portnr > brdp->nrports)
826 portp = brdp->ports[portnr];
829 if (portp->devnr < 1)
832 tty->driver_data = portp;
833 return tty_port_open(&portp->port, tty, filp);
837 /*****************************************************************************/
839 static void stli_shutdown(struct tty_port *port)
841 struct stlibrd *brdp;
844 struct stliport *portp = container_of(port, struct stliport, port);
846 if (portp->brdnr >= stli_nrbrds)
848 brdp = stli_brds[portp->brdnr];
853 * May want to wait for data to drain before closing. The BUSY
854 * flag keeps track of whether we are still transmitting or not.
855 * It is updated by messages from the slave - indicating when all
856 * chars really have drained.
859 if (!test_bit(ST_CLOSING, &portp->state))
860 stli_rawclose(brdp, portp, 0, 0);
862 spin_lock_irqsave(&stli_lock, flags);
863 clear_bit(ST_TXBUSY, &portp->state);
864 clear_bit(ST_RXSTOP, &portp->state);
865 spin_unlock_irqrestore(&stli_lock, flags);
867 ftype = FLUSHTX | FLUSHRX;
868 stli_cmdwait(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
871 static void stli_close(struct tty_struct *tty, struct file *filp)
873 struct stliport *portp = tty->driver_data;
877 spin_lock_irqsave(&stli_lock, flags);
878 /* Flush any internal buffering out first */
879 if (tty == stli_txcooktty)
880 stli_flushchars(tty);
881 spin_unlock_irqrestore(&stli_lock, flags);
882 tty_port_close(&portp->port, tty, filp);
885 /*****************************************************************************/
888 * Carry out first open operations on a port. This involves a number of
889 * commands to be sent to the slave. We need to open the port, set the
890 * notification events, set the initial port settings, get and set the
891 * initial signal values. We sleep and wait in between each one. But
892 * this still all happens pretty quickly.
895 static int stli_initopen(struct tty_struct *tty,
896 struct stlibrd *brdp, struct stliport *portp)
902 if ((rc = stli_rawopen(brdp, portp, 0, 1)) < 0)
905 memset(&nt, 0, sizeof(asynotify_t));
906 nt.data = (DT_TXLOW | DT_TXEMPTY | DT_RXBUSY | DT_RXBREAK);
908 if ((rc = stli_cmdwait(brdp, portp, A_SETNOTIFY, &nt,
909 sizeof(asynotify_t), 0)) < 0)
912 stli_mkasyport(tty, portp, &aport, tty->termios);
913 if ((rc = stli_cmdwait(brdp, portp, A_SETPORT, &aport,
914 sizeof(asyport_t), 0)) < 0)
917 set_bit(ST_GETSIGS, &portp->state);
918 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS, &portp->asig,
919 sizeof(asysigs_t), 1)) < 0)
921 if (test_and_clear_bit(ST_GETSIGS, &portp->state))
922 portp->sigs = stli_mktiocm(portp->asig.sigvalue);
923 stli_mkasysigs(&portp->asig, 1, 1);
924 if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
925 sizeof(asysigs_t), 0)) < 0)
931 /*****************************************************************************/
934 * Send an open message to the slave. This will sleep waiting for the
935 * acknowledgement, so must have user context. We need to co-ordinate
936 * with close events here, since we don't want open and close events
940 static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
942 cdkhdr_t __iomem *hdrp;
943 cdkctrl_t __iomem *cp;
944 unsigned char __iomem *bits;
949 * Send a message to the slave to open this port.
953 * Slave is already closing this port. This can happen if a hangup
954 * occurs on this port. So we must wait until it is complete. The
955 * order of opens and closes may not be preserved across shared
956 * memory, so we must wait until it is complete.
958 wait_event_interruptible_tty(portp->raw_wait,
959 !test_bit(ST_CLOSING, &portp->state));
960 if (signal_pending(current)) {
965 * Everything is ready now, so write the open message into shared
966 * memory. Once the message is in set the service bits to say that
967 * this port wants service.
969 spin_lock_irqsave(&brd_lock, flags);
971 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
972 writel(arg, &cp->openarg);
973 writeb(1, &cp->open);
974 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
975 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
977 writeb(readb(bits) | portp->portbit, bits);
981 spin_unlock_irqrestore(&brd_lock, flags);
986 * Slave is in action, so now we must wait for the open acknowledgment
990 set_bit(ST_OPENING, &portp->state);
991 spin_unlock_irqrestore(&brd_lock, flags);
993 wait_event_interruptible_tty(portp->raw_wait,
994 !test_bit(ST_OPENING, &portp->state));
995 if (signal_pending(current))
998 if ((rc == 0) && (portp->rc != 0))
1003 /*****************************************************************************/
1006 * Send a close message to the slave. Normally this will sleep waiting
1007 * for the acknowledgement, but if wait parameter is 0 it will not. If
1008 * wait is true then must have user context (to sleep).
1011 static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
1013 cdkhdr_t __iomem *hdrp;
1014 cdkctrl_t __iomem *cp;
1015 unsigned char __iomem *bits;
1016 unsigned long flags;
1020 * Slave is already closing this port. This can happen if a hangup
1021 * occurs on this port.
1024 wait_event_interruptible_tty(portp->raw_wait,
1025 !test_bit(ST_CLOSING, &portp->state));
1026 if (signal_pending(current)) {
1027 return -ERESTARTSYS;
1032 * Write the close command into shared memory.
1034 spin_lock_irqsave(&brd_lock, flags);
1036 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1037 writel(arg, &cp->closearg);
1038 writeb(1, &cp->close);
1039 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1040 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1042 writeb(readb(bits) |portp->portbit, bits);
1045 set_bit(ST_CLOSING, &portp->state);
1046 spin_unlock_irqrestore(&brd_lock, flags);
1052 * Slave is in action, so now we must wait for the open acknowledgment
1056 wait_event_interruptible_tty(portp->raw_wait,
1057 !test_bit(ST_CLOSING, &portp->state));
1058 if (signal_pending(current))
1061 if ((rc == 0) && (portp->rc != 0))
1066 /*****************************************************************************/
1069 * Send a command to the slave and wait for the response. This must
1070 * have user context (it sleeps). This routine is generic in that it
1071 * can send any type of command. Its purpose is to wait for that command
1072 * to complete (as opposed to initiating the command then returning).
1075 static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
1078 * no need for wait_event_tty because clearing ST_CMDING cannot block
1081 wait_event_interruptible(portp->raw_wait,
1082 !test_bit(ST_CMDING, &portp->state));
1083 if (signal_pending(current))
1084 return -ERESTARTSYS;
1086 stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
1088 wait_event_interruptible(portp->raw_wait,
1089 !test_bit(ST_CMDING, &portp->state));
1090 if (signal_pending(current))
1091 return -ERESTARTSYS;
1098 /*****************************************************************************/
1101 * Send the termios settings for this port to the slave. This sleeps
1102 * waiting for the command to complete - so must have user context.
1105 static int stli_setport(struct tty_struct *tty)
1107 struct stliport *portp = tty->driver_data;
1108 struct stlibrd *brdp;
1113 if (portp->brdnr >= stli_nrbrds)
1115 brdp = stli_brds[portp->brdnr];
1119 stli_mkasyport(tty, portp, &aport, tty->termios);
1120 return(stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0));
1123 /*****************************************************************************/
1125 static int stli_carrier_raised(struct tty_port *port)
1127 struct stliport *portp = container_of(port, struct stliport, port);
1128 return (portp->sigs & TIOCM_CD) ? 1 : 0;
1131 static void stli_dtr_rts(struct tty_port *port, int on)
1133 struct stliport *portp = container_of(port, struct stliport, port);
1134 struct stlibrd *brdp = stli_brds[portp->brdnr];
1135 stli_mkasysigs(&portp->asig, on, on);
1136 if (stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1137 sizeof(asysigs_t), 0) < 0)
1138 printk(KERN_WARNING "istallion: dtr set failed.\n");
1142 /*****************************************************************************/
1145 * Write routine. Take the data and put it in the shared memory ring
1146 * queue. If port is not already sending chars then need to mark the
1147 * service bits for this port.
1150 static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count)
1152 cdkasy_t __iomem *ap;
1153 cdkhdr_t __iomem *hdrp;
1154 unsigned char __iomem *bits;
1155 unsigned char __iomem *shbuf;
1156 unsigned char *chbuf;
1157 struct stliport *portp;
1158 struct stlibrd *brdp;
1159 unsigned int len, stlen, head, tail, size;
1160 unsigned long flags;
1162 if (tty == stli_txcooktty)
1163 stli_flushchars(tty);
1164 portp = tty->driver_data;
1167 if (portp->brdnr >= stli_nrbrds)
1169 brdp = stli_brds[portp->brdnr];
1172 chbuf = (unsigned char *) buf;
1175 * All data is now local, shove as much as possible into shared memory.
1177 spin_lock_irqsave(&brd_lock, flags);
1179 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1180 head = (unsigned int) readw(&ap->txq.head);
1181 tail = (unsigned int) readw(&ap->txq.tail);
1182 if (tail != ((unsigned int) readw(&ap->txq.tail)))
1183 tail = (unsigned int) readw(&ap->txq.tail);
1184 size = portp->txsize;
1186 len = size - (head - tail) - 1;
1187 stlen = size - head;
1189 len = tail - head - 1;
1193 len = min(len, (unsigned int)count);
1195 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->txoffset);
1198 stlen = min(len, stlen);
1199 memcpy_toio(shbuf + head, chbuf, stlen);
1210 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1211 writew(head, &ap->txq.head);
1212 if (test_bit(ST_TXBUSY, &portp->state)) {
1213 if (readl(&ap->changed.data) & DT_TXEMPTY)
1214 writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
1216 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1217 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1219 writeb(readb(bits) | portp->portbit, bits);
1220 set_bit(ST_TXBUSY, &portp->state);
1222 spin_unlock_irqrestore(&brd_lock, flags);
1227 /*****************************************************************************/
1230 * Output a single character. We put it into a temporary local buffer
1231 * (for speed) then write out that buffer when the flushchars routine
1232 * is called. There is a safety catch here so that if some other port
1233 * writes chars before the current buffer has been, then we write them
1234 * first them do the new ports.
1237 static int stli_putchar(struct tty_struct *tty, unsigned char ch)
1239 if (tty != stli_txcooktty) {
1240 if (stli_txcooktty != NULL)
1241 stli_flushchars(stli_txcooktty);
1242 stli_txcooktty = tty;
1245 stli_txcookbuf[stli_txcooksize++] = ch;
1249 /*****************************************************************************/
1252 * Transfer characters from the local TX cooking buffer to the board.
1253 * We sort of ignore the tty that gets passed in here. We rely on the
1254 * info stored with the TX cook buffer to tell us which port to flush
1255 * the data on. In any case we clean out the TX cook buffer, for re-use
1259 static void stli_flushchars(struct tty_struct *tty)
1261 cdkhdr_t __iomem *hdrp;
1262 unsigned char __iomem *bits;
1263 cdkasy_t __iomem *ap;
1264 struct tty_struct *cooktty;
1265 struct stliport *portp;
1266 struct stlibrd *brdp;
1267 unsigned int len, stlen, head, tail, size, count, cooksize;
1269 unsigned char __iomem *shbuf;
1270 unsigned long flags;
1272 cooksize = stli_txcooksize;
1273 cooktty = stli_txcooktty;
1274 stli_txcooksize = 0;
1275 stli_txcookrealsize = 0;
1276 stli_txcooktty = NULL;
1278 if (cooktty == NULL)
1285 portp = tty->driver_data;
1288 if (portp->brdnr >= stli_nrbrds)
1290 brdp = stli_brds[portp->brdnr];
1294 spin_lock_irqsave(&brd_lock, flags);
1297 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1298 head = (unsigned int) readw(&ap->txq.head);
1299 tail = (unsigned int) readw(&ap->txq.tail);
1300 if (tail != ((unsigned int) readw(&ap->txq.tail)))
1301 tail = (unsigned int) readw(&ap->txq.tail);
1302 size = portp->txsize;
1304 len = size - (head - tail) - 1;
1305 stlen = size - head;
1307 len = tail - head - 1;
1311 len = min(len, cooksize);
1313 shbuf = EBRDGETMEMPTR(brdp, portp->txoffset);
1314 buf = stli_txcookbuf;
1317 stlen = min(len, stlen);
1318 memcpy_toio(shbuf + head, buf, stlen);
1329 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1330 writew(head, &ap->txq.head);
1332 if (test_bit(ST_TXBUSY, &portp->state)) {
1333 if (readl(&ap->changed.data) & DT_TXEMPTY)
1334 writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
1336 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1337 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1339 writeb(readb(bits) | portp->portbit, bits);
1340 set_bit(ST_TXBUSY, &portp->state);
1343 spin_unlock_irqrestore(&brd_lock, flags);
1346 /*****************************************************************************/
1348 static int stli_writeroom(struct tty_struct *tty)
1350 cdkasyrq_t __iomem *rp;
1351 struct stliport *portp;
1352 struct stlibrd *brdp;
1353 unsigned int head, tail, len;
1354 unsigned long flags;
1356 if (tty == stli_txcooktty) {
1357 if (stli_txcookrealsize != 0) {
1358 len = stli_txcookrealsize - stli_txcooksize;
1363 portp = tty->driver_data;
1366 if (portp->brdnr >= stli_nrbrds)
1368 brdp = stli_brds[portp->brdnr];
1372 spin_lock_irqsave(&brd_lock, flags);
1374 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1375 head = (unsigned int) readw(&rp->head);
1376 tail = (unsigned int) readw(&rp->tail);
1377 if (tail != ((unsigned int) readw(&rp->tail)))
1378 tail = (unsigned int) readw(&rp->tail);
1379 len = (head >= tail) ? (portp->txsize - (head - tail)) : (tail - head);
1382 spin_unlock_irqrestore(&brd_lock, flags);
1384 if (tty == stli_txcooktty) {
1385 stli_txcookrealsize = len;
1386 len -= stli_txcooksize;
1391 /*****************************************************************************/
1394 * Return the number of characters in the transmit buffer. Normally we
1395 * will return the number of chars in the shared memory ring queue.
1396 * We need to kludge around the case where the shared memory buffer is
1397 * empty but not all characters have drained yet, for this case just
1398 * return that there is 1 character in the buffer!
1401 static int stli_charsinbuffer(struct tty_struct *tty)
1403 cdkasyrq_t __iomem *rp;
1404 struct stliport *portp;
1405 struct stlibrd *brdp;
1406 unsigned int head, tail, len;
1407 unsigned long flags;
1409 if (tty == stli_txcooktty)
1410 stli_flushchars(tty);
1411 portp = tty->driver_data;
1414 if (portp->brdnr >= stli_nrbrds)
1416 brdp = stli_brds[portp->brdnr];
1420 spin_lock_irqsave(&brd_lock, flags);
1422 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1423 head = (unsigned int) readw(&rp->head);
1424 tail = (unsigned int) readw(&rp->tail);
1425 if (tail != ((unsigned int) readw(&rp->tail)))
1426 tail = (unsigned int) readw(&rp->tail);
1427 len = (head >= tail) ? (head - tail) : (portp->txsize - (tail - head));
1428 if ((len == 0) && test_bit(ST_TXBUSY, &portp->state))
1431 spin_unlock_irqrestore(&brd_lock, flags);
1436 /*****************************************************************************/
1439 * Generate the serial struct info.
1442 static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp)
1444 struct serial_struct sio;
1445 struct stlibrd *brdp;
1447 memset(&sio, 0, sizeof(struct serial_struct));
1448 sio.type = PORT_UNKNOWN;
1449 sio.line = portp->portnr;
1451 sio.flags = portp->port.flags;
1452 sio.baud_base = portp->baud_base;
1453 sio.close_delay = portp->port.close_delay;
1454 sio.closing_wait = portp->closing_wait;
1455 sio.custom_divisor = portp->custom_divisor;
1456 sio.xmit_fifo_size = 0;
1459 brdp = stli_brds[portp->brdnr];
1461 sio.port = brdp->iobase;
1463 return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ?
1467 /*****************************************************************************/
1470 * Set port according to the serial struct info.
1471 * At this point we do not do any auto-configure stuff, so we will
1472 * just quietly ignore any requests to change irq, etc.
1475 static int stli_setserial(struct tty_struct *tty, struct serial_struct __user *sp)
1477 struct serial_struct sio;
1479 struct stliport *portp = tty->driver_data;
1481 if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
1483 if (!capable(CAP_SYS_ADMIN)) {
1484 if ((sio.baud_base != portp->baud_base) ||
1485 (sio.close_delay != portp->port.close_delay) ||
1486 ((sio.flags & ~ASYNC_USR_MASK) !=
1487 (portp->port.flags & ~ASYNC_USR_MASK)))
1491 portp->port.flags = (portp->port.flags & ~ASYNC_USR_MASK) |
1492 (sio.flags & ASYNC_USR_MASK);
1493 portp->baud_base = sio.baud_base;
1494 portp->port.close_delay = sio.close_delay;
1495 portp->closing_wait = sio.closing_wait;
1496 portp->custom_divisor = sio.custom_divisor;
1498 if ((rc = stli_setport(tty)) < 0)
1503 /*****************************************************************************/
1505 static int stli_tiocmget(struct tty_struct *tty, struct file *file)
1507 struct stliport *portp = tty->driver_data;
1508 struct stlibrd *brdp;
1513 if (portp->brdnr >= stli_nrbrds)
1515 brdp = stli_brds[portp->brdnr];
1518 if (tty->flags & (1 << TTY_IO_ERROR))
1521 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS,
1522 &portp->asig, sizeof(asysigs_t), 1)) < 0)
1525 return stli_mktiocm(portp->asig.sigvalue);
1528 static int stli_tiocmset(struct tty_struct *tty, struct file *file,
1529 unsigned int set, unsigned int clear)
1531 struct stliport *portp = tty->driver_data;
1532 struct stlibrd *brdp;
1533 int rts = -1, dtr = -1;
1537 if (portp->brdnr >= stli_nrbrds)
1539 brdp = stli_brds[portp->brdnr];
1542 if (tty->flags & (1 << TTY_IO_ERROR))
1545 if (set & TIOCM_RTS)
1547 if (set & TIOCM_DTR)
1549 if (clear & TIOCM_RTS)
1551 if (clear & TIOCM_DTR)
1554 stli_mkasysigs(&portp->asig, dtr, rts);
1556 return stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1557 sizeof(asysigs_t), 0);
1560 static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1562 struct stliport *portp;
1563 struct stlibrd *brdp;
1565 void __user *argp = (void __user *)arg;
1567 portp = tty->driver_data;
1570 if (portp->brdnr >= stli_nrbrds)
1572 brdp = stli_brds[portp->brdnr];
1576 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1577 (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) {
1578 if (tty->flags & (1 << TTY_IO_ERROR))
1586 rc = stli_getserial(portp, argp);
1589 rc = stli_setserial(tty, argp);
1592 rc = put_user(portp->pflag, (unsigned __user *)argp);
1595 if ((rc = get_user(portp->pflag, (unsigned __user *)argp)) == 0)
1598 case COM_GETPORTSTATS:
1599 rc = stli_getportstats(tty, portp, argp);
1601 case COM_CLRPORTSTATS:
1602 rc = stli_clrportstats(portp, argp);
1608 case TIOCSERGSTRUCT:
1609 case TIOCSERGETMULTI:
1610 case TIOCSERSETMULTI:
1619 /*****************************************************************************/
1622 * This routine assumes that we have user context and can sleep.
1623 * Looks like it is true for the current ttys implementation..!!
1626 static void stli_settermios(struct tty_struct *tty, struct ktermios *old)
1628 struct stliport *portp;
1629 struct stlibrd *brdp;
1630 struct ktermios *tiosp;
1633 portp = tty->driver_data;
1636 if (portp->brdnr >= stli_nrbrds)
1638 brdp = stli_brds[portp->brdnr];
1642 tiosp = tty->termios;
1644 stli_mkasyport(tty, portp, &aport, tiosp);
1645 stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0);
1646 stli_mkasysigs(&portp->asig, ((tiosp->c_cflag & CBAUD) ? 1 : 0), -1);
1647 stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1648 sizeof(asysigs_t), 0);
1649 if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0))
1650 tty->hw_stopped = 0;
1651 if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL))
1652 wake_up_interruptible(&portp->port.open_wait);
1655 /*****************************************************************************/
1658 * Attempt to flow control who ever is sending us data. We won't really
1659 * do any flow control action here. We can't directly, and even if we
1660 * wanted to we would have to send a command to the slave. The slave
1661 * knows how to flow control, and will do so when its buffers reach its
1662 * internal high water marks. So what we will do is set a local state
1663 * bit that will stop us sending any RX data up from the poll routine
1664 * (which is the place where RX data from the slave is handled).
1667 static void stli_throttle(struct tty_struct *tty)
1669 struct stliport *portp = tty->driver_data;
1672 set_bit(ST_RXSTOP, &portp->state);
1675 /*****************************************************************************/
1678 * Unflow control the device sending us data... That means that all
1679 * we have to do is clear the RXSTOP state bit. The next poll call
1680 * will then be able to pass the RX data back up.
1683 static void stli_unthrottle(struct tty_struct *tty)
1685 struct stliport *portp = tty->driver_data;
1688 clear_bit(ST_RXSTOP, &portp->state);
1691 /*****************************************************************************/
1694 * Stop the transmitter.
1697 static void stli_stop(struct tty_struct *tty)
1701 /*****************************************************************************/
1704 * Start the transmitter again.
1707 static void stli_start(struct tty_struct *tty)
1711 /*****************************************************************************/
1715 * Hangup this port. This is pretty much like closing the port, only
1716 * a little more brutal. No waiting for data to drain. Shutdown the
1717 * port and maybe drop signals. This is rather tricky really. We want
1718 * to close the port as well.
1721 static void stli_hangup(struct tty_struct *tty)
1723 struct stliport *portp = tty->driver_data;
1724 tty_port_hangup(&portp->port);
1727 /*****************************************************************************/
1730 * Flush characters from the lower buffer. We may not have user context
1731 * so we cannot sleep waiting for it to complete. Also we need to check
1732 * if there is chars for this port in the TX cook buffer, and flush them
1736 static void stli_flushbuffer(struct tty_struct *tty)
1738 struct stliport *portp;
1739 struct stlibrd *brdp;
1740 unsigned long ftype, flags;
1742 portp = tty->driver_data;
1745 if (portp->brdnr >= stli_nrbrds)
1747 brdp = stli_brds[portp->brdnr];
1751 spin_lock_irqsave(&brd_lock, flags);
1752 if (tty == stli_txcooktty) {
1753 stli_txcooktty = NULL;
1754 stli_txcooksize = 0;
1755 stli_txcookrealsize = 0;
1757 if (test_bit(ST_CMDING, &portp->state)) {
1758 set_bit(ST_DOFLUSHTX, &portp->state);
1761 if (test_bit(ST_DOFLUSHRX, &portp->state)) {
1763 clear_bit(ST_DOFLUSHRX, &portp->state);
1765 __stli_sendcmd(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
1767 spin_unlock_irqrestore(&brd_lock, flags);
1771 /*****************************************************************************/
1773 static int stli_breakctl(struct tty_struct *tty, int state)
1775 struct stlibrd *brdp;
1776 struct stliport *portp;
1779 portp = tty->driver_data;
1782 if (portp->brdnr >= stli_nrbrds)
1784 brdp = stli_brds[portp->brdnr];
1788 arg = (state == -1) ? BREAKON : BREAKOFF;
1789 stli_cmdwait(brdp, portp, A_BREAK, &arg, sizeof(long), 0);
1793 /*****************************************************************************/
1795 static void stli_waituntilsent(struct tty_struct *tty, int timeout)
1797 struct stliport *portp;
1800 portp = tty->driver_data;
1806 tend = jiffies + timeout;
1808 while (test_bit(ST_TXBUSY, &portp->state)) {
1809 if (signal_pending(current))
1811 msleep_interruptible(20);
1812 if (time_after_eq(jiffies, tend))
1817 /*****************************************************************************/
1819 static void stli_sendxchar(struct tty_struct *tty, char ch)
1821 struct stlibrd *brdp;
1822 struct stliport *portp;
1825 portp = tty->driver_data;
1828 if (portp->brdnr >= stli_nrbrds)
1830 brdp = stli_brds[portp->brdnr];
1834 memset(&actrl, 0, sizeof(asyctrl_t));
1835 if (ch == STOP_CHAR(tty)) {
1836 actrl.rxctrl = CT_STOPFLOW;
1837 } else if (ch == START_CHAR(tty)) {
1838 actrl.rxctrl = CT_STARTFLOW;
1840 actrl.txctrl = CT_SENDCHR;
1843 stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0);
1846 static void stli_portinfo(struct seq_file *m, struct stlibrd *brdp, struct stliport *portp, int portnr)
1851 rc = stli_portcmdstats(NULL, portp);
1854 if (test_bit(BST_STARTED, &brdp->state)) {
1855 switch (stli_comstats.hwid) {
1856 case 0: uart = "2681"; break;
1857 case 1: uart = "SC26198"; break;
1858 default:uart = "CD1400"; break;
1861 seq_printf(m, "%d: uart:%s ", portnr, uart);
1863 if (test_bit(BST_STARTED, &brdp->state) && rc >= 0) {
1866 seq_printf(m, "tx:%d rx:%d", (int) stli_comstats.txtotal,
1867 (int) stli_comstats.rxtotal);
1869 if (stli_comstats.rxframing)
1870 seq_printf(m, " fe:%d",
1871 (int) stli_comstats.rxframing);
1872 if (stli_comstats.rxparity)
1873 seq_printf(m, " pe:%d",
1874 (int) stli_comstats.rxparity);
1875 if (stli_comstats.rxbreaks)
1876 seq_printf(m, " brk:%d",
1877 (int) stli_comstats.rxbreaks);
1878 if (stli_comstats.rxoverrun)
1879 seq_printf(m, " oe:%d",
1880 (int) stli_comstats.rxoverrun);
1883 if (stli_comstats.signals & TIOCM_RTS) {
1884 seq_printf(m, "%c%s", sep, "RTS");
1887 if (stli_comstats.signals & TIOCM_CTS) {
1888 seq_printf(m, "%c%s", sep, "CTS");
1891 if (stli_comstats.signals & TIOCM_DTR) {
1892 seq_printf(m, "%c%s", sep, "DTR");
1895 if (stli_comstats.signals & TIOCM_CD) {
1896 seq_printf(m, "%c%s", sep, "DCD");
1899 if (stli_comstats.signals & TIOCM_DSR) {
1900 seq_printf(m, "%c%s", sep, "DSR");
1907 /*****************************************************************************/
1910 * Port info, read from the /proc file system.
1913 static int stli_proc_show(struct seq_file *m, void *v)
1915 struct stlibrd *brdp;
1916 struct stliport *portp;
1917 unsigned int brdnr, portnr, totalport;
1921 seq_printf(m, "%s: version %s\n", stli_drvtitle, stli_drvversion);
1924 * We scan through for each board, panel and port. The offset is
1925 * calculated on the fly, and irrelevant ports are skipped.
1927 for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
1928 brdp = stli_brds[brdnr];
1931 if (brdp->state == 0)
1934 totalport = brdnr * STL_MAXPORTS;
1935 for (portnr = 0; (portnr < brdp->nrports); portnr++,
1937 portp = brdp->ports[portnr];
1940 stli_portinfo(m, brdp, portp, totalport);
1946 static int stli_proc_open(struct inode *inode, struct file *file)
1948 return single_open(file, stli_proc_show, NULL);
1951 static const struct file_operations stli_proc_fops = {
1952 .owner = THIS_MODULE,
1953 .open = stli_proc_open,
1955 .llseek = seq_lseek,
1956 .release = single_release,
1959 /*****************************************************************************/
1962 * Generic send command routine. This will send a message to the slave,
1963 * of the specified type with the specified argument. Must be very
1964 * careful of data that will be copied out from shared memory -
1965 * containing command results. The command completion is all done from
1966 * a poll routine that does not have user context. Therefore you cannot
1967 * copy back directly into user space, or to the kernel stack of a
1968 * process. This routine does not sleep, so can be called from anywhere.
1970 * The caller must hold the brd_lock (see also stli_sendcmd the usual
1974 static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
1976 cdkhdr_t __iomem *hdrp;
1977 cdkctrl_t __iomem *cp;
1978 unsigned char __iomem *bits;
1980 if (test_bit(ST_CMDING, &portp->state)) {
1981 printk(KERN_ERR "istallion: command already busy, cmd=%x!\n",
1987 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1989 memcpy_toio((void __iomem *) &(cp->args[0]), arg, size);
1992 portp->argsize = size;
1995 writel(0, &cp->status);
1996 writel(cmd, &cp->cmd);
1997 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1998 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
2000 writeb(readb(bits) | portp->portbit, bits);
2001 set_bit(ST_CMDING, &portp->state);
2005 static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
2007 unsigned long flags;
2009 spin_lock_irqsave(&brd_lock, flags);
2010 __stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
2011 spin_unlock_irqrestore(&brd_lock, flags);
2014 /*****************************************************************************/
2017 * Read data from shared memory. This assumes that the shared memory
2018 * is enabled and that interrupts are off. Basically we just empty out
2019 * the shared memory buffer into the tty buffer. Must be careful to
2020 * handle the case where we fill up the tty buffer, but still have
2021 * more chars to unload.
2024 static void stli_read(struct stlibrd *brdp, struct stliport *portp)
2026 cdkasyrq_t __iomem *rp;
2027 char __iomem *shbuf;
2028 struct tty_struct *tty;
2029 unsigned int head, tail, size;
2030 unsigned int len, stlen;
2032 if (test_bit(ST_RXSTOP, &portp->state))
2034 tty = tty_port_tty_get(&portp->port);
2038 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2039 head = (unsigned int) readw(&rp->head);
2040 if (head != ((unsigned int) readw(&rp->head)))
2041 head = (unsigned int) readw(&rp->head);
2042 tail = (unsigned int) readw(&rp->tail);
2043 size = portp->rxsize;
2048 len = size - (tail - head);
2049 stlen = size - tail;
2052 len = tty_buffer_request_room(tty, len);
2054 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->rxoffset);
2057 unsigned char *cptr;
2059 stlen = min(len, stlen);
2060 tty_prepare_flip_string(tty, &cptr, stlen);
2061 memcpy_fromio(cptr, shbuf + tail, stlen);
2069 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2070 writew(tail, &rp->tail);
2073 set_bit(ST_RXING, &portp->state);
2075 tty_schedule_flip(tty);
2079 /*****************************************************************************/
2082 * Set up and carry out any delayed commands. There is only a small set
2083 * of slave commands that can be done "off-level". So it is not too
2084 * difficult to deal with them here.
2087 static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp)
2091 if (test_bit(ST_DOSIGS, &portp->state)) {
2092 if (test_bit(ST_DOFLUSHTX, &portp->state) &&
2093 test_bit(ST_DOFLUSHRX, &portp->state))
2094 cmd = A_SETSIGNALSF;
2095 else if (test_bit(ST_DOFLUSHTX, &portp->state))
2096 cmd = A_SETSIGNALSFTX;
2097 else if (test_bit(ST_DOFLUSHRX, &portp->state))
2098 cmd = A_SETSIGNALSFRX;
2101 clear_bit(ST_DOFLUSHTX, &portp->state);
2102 clear_bit(ST_DOFLUSHRX, &portp->state);
2103 clear_bit(ST_DOSIGS, &portp->state);
2104 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &portp->asig,
2106 writel(0, &cp->status);
2107 writel(cmd, &cp->cmd);
2108 set_bit(ST_CMDING, &portp->state);
2109 } else if (test_bit(ST_DOFLUSHTX, &portp->state) ||
2110 test_bit(ST_DOFLUSHRX, &portp->state)) {
2111 cmd = ((test_bit(ST_DOFLUSHTX, &portp->state)) ? FLUSHTX : 0);
2112 cmd |= ((test_bit(ST_DOFLUSHRX, &portp->state)) ? FLUSHRX : 0);
2113 clear_bit(ST_DOFLUSHTX, &portp->state);
2114 clear_bit(ST_DOFLUSHRX, &portp->state);
2115 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &cmd, sizeof(int));
2116 writel(0, &cp->status);
2117 writel(A_FLUSH, &cp->cmd);
2118 set_bit(ST_CMDING, &portp->state);
2122 /*****************************************************************************/
2125 * Host command service checking. This handles commands or messages
2126 * coming from the slave to the host. Must have board shared memory
2127 * enabled and interrupts off when called. Notice that by servicing the
2128 * read data last we don't need to change the shared memory pointer
2129 * during processing (which is a slow IO operation).
2130 * Return value indicates if this port is still awaiting actions from
2131 * the slave (like open, command, or even TX data being sent). If 0
2132 * then port is still busy, otherwise no longer busy.
2135 static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp)
2137 cdkasy_t __iomem *ap;
2138 cdkctrl_t __iomem *cp;
2139 struct tty_struct *tty;
2141 unsigned long oldsigs;
2144 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
2148 * Check if we are waiting for an open completion message.
2150 if (test_bit(ST_OPENING, &portp->state)) {
2151 rc = readl(&cp->openarg);
2152 if (readb(&cp->open) == 0 && rc != 0) {
2155 writel(0, &cp->openarg);
2157 clear_bit(ST_OPENING, &portp->state);
2158 wake_up_interruptible(&portp->raw_wait);
2163 * Check if we are waiting for a close completion message.
2165 if (test_bit(ST_CLOSING, &portp->state)) {
2166 rc = (int) readl(&cp->closearg);
2167 if (readb(&cp->close) == 0 && rc != 0) {
2170 writel(0, &cp->closearg);
2172 clear_bit(ST_CLOSING, &portp->state);
2173 wake_up_interruptible(&portp->raw_wait);
2178 * Check if we are waiting for a command completion message. We may
2179 * need to copy out the command results associated with this command.
2181 if (test_bit(ST_CMDING, &portp->state)) {
2182 rc = readl(&cp->status);
2183 if (readl(&cp->cmd) == 0 && rc != 0) {
2186 if (portp->argp != NULL) {
2187 memcpy_fromio(portp->argp, (void __iomem *) &(cp->args[0]),
2191 writel(0, &cp->status);
2193 clear_bit(ST_CMDING, &portp->state);
2194 stli_dodelaycmd(portp, cp);
2195 wake_up_interruptible(&portp->raw_wait);
2200 * Check for any notification messages ready. This includes lots of
2201 * different types of events - RX chars ready, RX break received,
2202 * TX data low or empty in the slave, modem signals changed state.
2209 tty = tty_port_tty_get(&portp->port);
2211 if (nt.signal & SG_DCD) {
2212 oldsigs = portp->sigs;
2213 portp->sigs = stli_mktiocm(nt.sigvalue);
2214 clear_bit(ST_GETSIGS, &portp->state);
2215 if ((portp->sigs & TIOCM_CD) &&
2216 ((oldsigs & TIOCM_CD) == 0))
2217 wake_up_interruptible(&portp->port.open_wait);
2218 if ((oldsigs & TIOCM_CD) &&
2219 ((portp->sigs & TIOCM_CD) == 0)) {
2220 if (portp->port.flags & ASYNC_CHECK_CD) {
2227 if (nt.data & DT_TXEMPTY)
2228 clear_bit(ST_TXBUSY, &portp->state);
2229 if (nt.data & (DT_TXEMPTY | DT_TXLOW)) {
2236 if ((nt.data & DT_RXBREAK) && (portp->rxmarkmsk & BRKINT)) {
2238 tty_insert_flip_char(tty, 0, TTY_BREAK);
2239 if (portp->port.flags & ASYNC_SAK) {
2243 tty_schedule_flip(tty);
2248 if (nt.data & DT_RXBUSY) {
2250 stli_read(brdp, portp);
2255 * It might seem odd that we are checking for more RX chars here.
2256 * But, we need to handle the case where the tty buffer was previously
2257 * filled, but we had more characters to pass up. The slave will not
2258 * send any more RX notify messages until the RX buffer has been emptied.
2259 * But it will leave the service bits on (since the buffer is not empty).
2260 * So from here we can try to process more RX chars.
2262 if ((!donerx) && test_bit(ST_RXING, &portp->state)) {
2263 clear_bit(ST_RXING, &portp->state);
2264 stli_read(brdp, portp);
2267 return((test_bit(ST_OPENING, &portp->state) ||
2268 test_bit(ST_CLOSING, &portp->state) ||
2269 test_bit(ST_CMDING, &portp->state) ||
2270 test_bit(ST_TXBUSY, &portp->state) ||
2271 test_bit(ST_RXING, &portp->state)) ? 0 : 1);
2274 /*****************************************************************************/
2277 * Service all ports on a particular board. Assumes that the boards
2278 * shared memory is enabled, and that the page pointer is pointed
2279 * at the cdk header structure.
2282 static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp)
2284 struct stliport *portp;
2285 unsigned char hostbits[(STL_MAXCHANS / 8) + 1];
2286 unsigned char slavebits[(STL_MAXCHANS / 8) + 1];
2287 unsigned char __iomem *slavep;
2288 int bitpos, bitat, bitsize;
2289 int channr, nrdevs, slavebitchange;
2291 bitsize = brdp->bitsize;
2292 nrdevs = brdp->nrdevs;
2295 * Check if slave wants any service. Basically we try to do as
2296 * little work as possible here. There are 2 levels of service
2297 * bits. So if there is nothing to do we bail early. We check
2298 * 8 service bits at a time in the inner loop, so we can bypass
2299 * the lot if none of them want service.
2301 memcpy_fromio(&hostbits[0], (((unsigned char __iomem *) hdrp) + brdp->hostoffset),
2304 memset(&slavebits[0], 0, bitsize);
2307 for (bitpos = 0; (bitpos < bitsize); bitpos++) {
2308 if (hostbits[bitpos] == 0)
2310 channr = bitpos * 8;
2311 for (bitat = 0x1; (channr < nrdevs); channr++, bitat <<= 1) {
2312 if (hostbits[bitpos] & bitat) {
2313 portp = brdp->ports[(channr - 1)];
2314 if (stli_hostcmd(brdp, portp)) {
2316 slavebits[bitpos] |= bitat;
2323 * If any of the ports are no longer busy then update them in the
2324 * slave request bits. We need to do this after, since a host port
2325 * service may initiate more slave requests.
2327 if (slavebitchange) {
2328 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2329 slavep = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset;
2330 for (bitpos = 0; (bitpos < bitsize); bitpos++) {
2331 if (readb(slavebits + bitpos))
2332 writeb(readb(slavep + bitpos) & ~slavebits[bitpos], slavebits + bitpos);
2337 /*****************************************************************************/
2340 * Driver poll routine. This routine polls the boards in use and passes
2341 * messages back up to host when necessary. This is actually very
2342 * CPU efficient, since we will always have the kernel poll clock, it
2343 * adds only a few cycles when idle (since board service can be
2344 * determined very easily), but when loaded generates no interrupts
2345 * (with their expensive associated context change).
2348 static void stli_poll(unsigned long arg)
2350 cdkhdr_t __iomem *hdrp;
2351 struct stlibrd *brdp;
2354 mod_timer(&stli_timerlist, STLI_TIMEOUT);
2357 * Check each board and do any servicing required.
2359 for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
2360 brdp = stli_brds[brdnr];
2363 if (!test_bit(BST_STARTED, &brdp->state))
2366 spin_lock(&brd_lock);
2368 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2369 if (readb(&hdrp->hostreq))
2370 stli_brdpoll(brdp, hdrp);
2372 spin_unlock(&brd_lock);
2376 /*****************************************************************************/
2379 * Translate the termios settings into the port setting structure of
2383 static void stli_mkasyport(struct tty_struct *tty, struct stliport *portp,
2384 asyport_t *pp, struct ktermios *tiosp)
2386 memset(pp, 0, sizeof(asyport_t));
2389 * Start of by setting the baud, char size, parity and stop bit info.
2391 pp->baudout = tty_get_baud_rate(tty);
2392 if ((tiosp->c_cflag & CBAUD) == B38400) {
2393 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2394 pp->baudout = 57600;
2395 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2396 pp->baudout = 115200;
2397 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2398 pp->baudout = 230400;
2399 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2400 pp->baudout = 460800;
2401 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
2402 pp->baudout = (portp->baud_base / portp->custom_divisor);
2404 if (pp->baudout > STL_MAXBAUD)
2405 pp->baudout = STL_MAXBAUD;
2406 pp->baudin = pp->baudout;
2408 switch (tiosp->c_cflag & CSIZE) {
2423 if (tiosp->c_cflag & CSTOPB)
2424 pp->stopbs = PT_STOP2;
2426 pp->stopbs = PT_STOP1;
2428 if (tiosp->c_cflag & PARENB) {
2429 if (tiosp->c_cflag & PARODD)
2430 pp->parity = PT_ODDPARITY;
2432 pp->parity = PT_EVENPARITY;
2434 pp->parity = PT_NOPARITY;
2438 * Set up any flow control options enabled.
2440 if (tiosp->c_iflag & IXON) {
2442 if (tiosp->c_iflag & IXANY)
2443 pp->flow |= F_IXANY;
2445 if (tiosp->c_cflag & CRTSCTS)
2446 pp->flow |= (F_RTSFLOW | F_CTSFLOW);
2448 pp->startin = tiosp->c_cc[VSTART];
2449 pp->stopin = tiosp->c_cc[VSTOP];
2450 pp->startout = tiosp->c_cc[VSTART];
2451 pp->stopout = tiosp->c_cc[VSTOP];
2454 * Set up the RX char marking mask with those RX error types we must
2455 * catch. We can get the slave to help us out a little here, it will
2456 * ignore parity errors and breaks for us, and mark parity errors in
2459 if (tiosp->c_iflag & IGNPAR)
2460 pp->iflag |= FI_IGNRXERRS;
2461 if (tiosp->c_iflag & IGNBRK)
2462 pp->iflag |= FI_IGNBREAK;
2464 portp->rxmarkmsk = 0;
2465 if (tiosp->c_iflag & (INPCK | PARMRK))
2466 pp->iflag |= FI_1MARKRXERRS;
2467 if (tiosp->c_iflag & BRKINT)
2468 portp->rxmarkmsk |= BRKINT;
2471 * Set up clocal processing as required.
2473 if (tiosp->c_cflag & CLOCAL)
2474 portp->port.flags &= ~ASYNC_CHECK_CD;
2476 portp->port.flags |= ASYNC_CHECK_CD;
2479 * Transfer any persistent flags into the asyport structure.
2481 pp->pflag = (portp->pflag & 0xffff);
2482 pp->vmin = (portp->pflag & P_RXIMIN) ? 1 : 0;
2483 pp->vtime = (portp->pflag & P_RXITIME) ? 1 : 0;
2484 pp->cc[1] = (portp->pflag & P_RXTHOLD) ? 1 : 0;
2487 /*****************************************************************************/
2490 * Construct a slave signals structure for setting the DTR and RTS
2491 * signals as specified.
2494 static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts)
2496 memset(sp, 0, sizeof(asysigs_t));
2498 sp->signal |= SG_DTR;
2499 sp->sigvalue |= ((dtr > 0) ? SG_DTR : 0);
2502 sp->signal |= SG_RTS;
2503 sp->sigvalue |= ((rts > 0) ? SG_RTS : 0);
2507 /*****************************************************************************/
2510 * Convert the signals returned from the slave into a local TIOCM type
2511 * signals value. We keep them locally in TIOCM format.
2514 static long stli_mktiocm(unsigned long sigvalue)
2517 tiocm |= ((sigvalue & SG_DCD) ? TIOCM_CD : 0);
2518 tiocm |= ((sigvalue & SG_CTS) ? TIOCM_CTS : 0);
2519 tiocm |= ((sigvalue & SG_RI) ? TIOCM_RI : 0);
2520 tiocm |= ((sigvalue & SG_DSR) ? TIOCM_DSR : 0);
2521 tiocm |= ((sigvalue & SG_DTR) ? TIOCM_DTR : 0);
2522 tiocm |= ((sigvalue & SG_RTS) ? TIOCM_RTS : 0);
2526 /*****************************************************************************/
2529 * All panels and ports actually attached have been worked out. All
2530 * we need to do here is set up the appropriate per port data structures.
2533 static int stli_initports(struct stlibrd *brdp)
2535 struct stliport *portp;
2536 unsigned int i, panelnr, panelport;
2538 for (i = 0, panelnr = 0, panelport = 0; (i < brdp->nrports); i++) {
2539 portp = kzalloc(sizeof(struct stliport), GFP_KERNEL);
2541 printk(KERN_WARNING "istallion: failed to allocate port structure\n");
2544 tty_port_init(&portp->port);
2545 portp->port.ops = &stli_port_ops;
2546 portp->magic = STLI_PORTMAGIC;
2548 portp->brdnr = brdp->brdnr;
2549 portp->panelnr = panelnr;
2550 portp->baud_base = STL_BAUDBASE;
2551 portp->port.close_delay = STL_CLOSEDELAY;
2552 portp->closing_wait = 30 * HZ;
2553 init_waitqueue_head(&portp->port.open_wait);
2554 init_waitqueue_head(&portp->port.close_wait);
2555 init_waitqueue_head(&portp->raw_wait);
2557 if (panelport >= brdp->panels[panelnr]) {
2561 brdp->ports[i] = portp;
2567 /*****************************************************************************/
2570 * All the following routines are board specific hardware operations.
2573 static void stli_ecpinit(struct stlibrd *brdp)
2575 unsigned long memconf;
2577 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2579 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2582 memconf = (brdp->memaddr & ECP_ATADDRMASK) >> ECP_ATADDRSHFT;
2583 outb(memconf, (brdp->iobase + ECP_ATMEMAR));
2586 /*****************************************************************************/
2588 static void stli_ecpenable(struct stlibrd *brdp)
2590 outb(ECP_ATENABLE, (brdp->iobase + ECP_ATCONFR));
2593 /*****************************************************************************/
2595 static void stli_ecpdisable(struct stlibrd *brdp)
2597 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2600 /*****************************************************************************/
2602 static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2607 if (offset > brdp->memsize) {
2608 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2609 "range at line=%d(%d), brd=%d\n",
2610 (int) offset, line, __LINE__, brdp->brdnr);
2614 ptr = brdp->membase + (offset % ECP_ATPAGESIZE);
2615 val = (unsigned char) (offset / ECP_ATPAGESIZE);
2617 outb(val, (brdp->iobase + ECP_ATMEMPR));
2621 /*****************************************************************************/
2623 static void stli_ecpreset(struct stlibrd *brdp)
2625 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2627 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2631 /*****************************************************************************/
2633 static void stli_ecpintr(struct stlibrd *brdp)
2635 outb(0x1, brdp->iobase);
2638 /*****************************************************************************/
2641 * The following set of functions act on ECP EISA boards.
2644 static void stli_ecpeiinit(struct stlibrd *brdp)
2646 unsigned long memconf;
2648 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
2649 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2651 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2654 memconf = (brdp->memaddr & ECP_EIADDRMASKL) >> ECP_EIADDRSHFTL;
2655 outb(memconf, (brdp->iobase + ECP_EIMEMARL));
2656 memconf = (brdp->memaddr & ECP_EIADDRMASKH) >> ECP_EIADDRSHFTH;
2657 outb(memconf, (brdp->iobase + ECP_EIMEMARH));
2660 /*****************************************************************************/
2662 static void stli_ecpeienable(struct stlibrd *brdp)
2664 outb(ECP_EIENABLE, (brdp->iobase + ECP_EICONFR));
2667 /*****************************************************************************/
2669 static void stli_ecpeidisable(struct stlibrd *brdp)
2671 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2674 /*****************************************************************************/
2676 static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2681 if (offset > brdp->memsize) {
2682 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2683 "range at line=%d(%d), brd=%d\n",
2684 (int) offset, line, __LINE__, brdp->brdnr);
2688 ptr = brdp->membase + (offset % ECP_EIPAGESIZE);
2689 if (offset < ECP_EIPAGESIZE)
2692 val = ECP_EIENABLE | 0x40;
2694 outb(val, (brdp->iobase + ECP_EICONFR));
2698 /*****************************************************************************/
2700 static void stli_ecpeireset(struct stlibrd *brdp)
2702 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2704 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2708 /*****************************************************************************/
2711 * The following set of functions act on ECP MCA boards.
2714 static void stli_ecpmcenable(struct stlibrd *brdp)
2716 outb(ECP_MCENABLE, (brdp->iobase + ECP_MCCONFR));
2719 /*****************************************************************************/
2721 static void stli_ecpmcdisable(struct stlibrd *brdp)
2723 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2726 /*****************************************************************************/
2728 static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2733 if (offset > brdp->memsize) {
2734 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2735 "range at line=%d(%d), brd=%d\n",
2736 (int) offset, line, __LINE__, brdp->brdnr);
2740 ptr = brdp->membase + (offset % ECP_MCPAGESIZE);
2741 val = ((unsigned char) (offset / ECP_MCPAGESIZE)) | ECP_MCENABLE;
2743 outb(val, (brdp->iobase + ECP_MCCONFR));
2747 /*****************************************************************************/
2749 static void stli_ecpmcreset(struct stlibrd *brdp)
2751 outb(ECP_MCSTOP, (brdp->iobase + ECP_MCCONFR));
2753 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2757 /*****************************************************************************/
2760 * The following set of functions act on ECP PCI boards.
2763 static void stli_ecppciinit(struct stlibrd *brdp)
2765 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
2767 outb(0, (brdp->iobase + ECP_PCICONFR));
2771 /*****************************************************************************/
2773 static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2778 if (offset > brdp->memsize) {
2779 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2780 "range at line=%d(%d), board=%d\n",
2781 (int) offset, line, __LINE__, brdp->brdnr);
2785 ptr = brdp->membase + (offset % ECP_PCIPAGESIZE);
2786 val = (offset / ECP_PCIPAGESIZE) << 1;
2788 outb(val, (brdp->iobase + ECP_PCICONFR));
2792 /*****************************************************************************/
2794 static void stli_ecppcireset(struct stlibrd *brdp)
2796 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
2798 outb(0, (brdp->iobase + ECP_PCICONFR));
2802 /*****************************************************************************/
2805 * The following routines act on ONboards.
2808 static void stli_onbinit(struct stlibrd *brdp)
2810 unsigned long memconf;
2812 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
2814 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
2817 memconf = (brdp->memaddr & ONB_ATADDRMASK) >> ONB_ATADDRSHFT;
2818 outb(memconf, (brdp->iobase + ONB_ATMEMAR));
2819 outb(0x1, brdp->iobase);
2823 /*****************************************************************************/
2825 static void stli_onbenable(struct stlibrd *brdp)
2827 outb((brdp->enabval | ONB_ATENABLE), (brdp->iobase + ONB_ATCONFR));
2830 /*****************************************************************************/
2832 static void stli_onbdisable(struct stlibrd *brdp)
2834 outb((brdp->enabval | ONB_ATDISABLE), (brdp->iobase + ONB_ATCONFR));
2837 /*****************************************************************************/
2839 static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2843 if (offset > brdp->memsize) {
2844 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2845 "range at line=%d(%d), brd=%d\n",
2846 (int) offset, line, __LINE__, brdp->brdnr);
2849 ptr = brdp->membase + (offset % ONB_ATPAGESIZE);
2854 /*****************************************************************************/
2856 static void stli_onbreset(struct stlibrd *brdp)
2858 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
2860 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
2864 /*****************************************************************************/
2867 * The following routines act on ONboard EISA.
2870 static void stli_onbeinit(struct stlibrd *brdp)
2872 unsigned long memconf;
2874 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
2875 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
2877 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2880 memconf = (brdp->memaddr & ONB_EIADDRMASKL) >> ONB_EIADDRSHFTL;
2881 outb(memconf, (brdp->iobase + ONB_EIMEMARL));
2882 memconf = (brdp->memaddr & ONB_EIADDRMASKH) >> ONB_EIADDRSHFTH;
2883 outb(memconf, (brdp->iobase + ONB_EIMEMARH));
2884 outb(0x1, brdp->iobase);
2888 /*****************************************************************************/
2890 static void stli_onbeenable(struct stlibrd *brdp)
2892 outb(ONB_EIENABLE, (brdp->iobase + ONB_EICONFR));
2895 /*****************************************************************************/
2897 static void stli_onbedisable(struct stlibrd *brdp)
2899 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2902 /*****************************************************************************/
2904 static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2909 if (offset > brdp->memsize) {
2910 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2911 "range at line=%d(%d), brd=%d\n",
2912 (int) offset, line, __LINE__, brdp->brdnr);
2916 ptr = brdp->membase + (offset % ONB_EIPAGESIZE);
2917 if (offset < ONB_EIPAGESIZE)
2920 val = ONB_EIENABLE | 0x40;
2922 outb(val, (brdp->iobase + ONB_EICONFR));
2926 /*****************************************************************************/
2928 static void stli_onbereset(struct stlibrd *brdp)
2930 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
2932 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2936 /*****************************************************************************/
2939 * The following routines act on Brumby boards.
2942 static void stli_bbyinit(struct stlibrd *brdp)
2944 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
2946 outb(0, (brdp->iobase + BBY_ATCONFR));
2948 outb(0x1, brdp->iobase);
2952 /*****************************************************************************/
2954 static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2959 BUG_ON(offset > brdp->memsize);
2961 ptr = brdp->membase + (offset % BBY_PAGESIZE);
2962 val = (unsigned char) (offset / BBY_PAGESIZE);
2963 outb(val, (brdp->iobase + BBY_ATCONFR));
2967 /*****************************************************************************/
2969 static void stli_bbyreset(struct stlibrd *brdp)
2971 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
2973 outb(0, (brdp->iobase + BBY_ATCONFR));
2977 /*****************************************************************************/
2980 * The following routines act on original old Stallion boards.
2983 static void stli_stalinit(struct stlibrd *brdp)
2985 outb(0x1, brdp->iobase);
2989 /*****************************************************************************/
2991 static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2993 BUG_ON(offset > brdp->memsize);
2994 return brdp->membase + (offset % STAL_PAGESIZE);
2997 /*****************************************************************************/
2999 static void stli_stalreset(struct stlibrd *brdp)
3003 vecp = (u32 __iomem *) (brdp->membase + 0x30);
3004 writel(0xffff0000, vecp);
3005 outb(0, brdp->iobase);
3009 /*****************************************************************************/
3012 * Try to find an ECP board and initialize it. This handles only ECP
3016 static int stli_initecp(struct stlibrd *brdp)
3019 cdkecpsig_t __iomem *sigsp;
3020 unsigned int status, nxtid;
3022 int retval, panelnr, nrports;
3024 if ((brdp->iobase == 0) || (brdp->memaddr == 0)) {
3029 brdp->iosize = ECP_IOSIZE;
3031 if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
3037 * Based on the specific board type setup the common vars to access
3038 * and enable shared memory. Set all board specific information now
3041 switch (brdp->brdtype) {
3043 brdp->memsize = ECP_MEMSIZE;
3044 brdp->pagesize = ECP_ATPAGESIZE;
3045 brdp->init = stli_ecpinit;
3046 brdp->enable = stli_ecpenable;
3047 brdp->reenable = stli_ecpenable;
3048 brdp->disable = stli_ecpdisable;
3049 brdp->getmemptr = stli_ecpgetmemptr;
3050 brdp->intr = stli_ecpintr;
3051 brdp->reset = stli_ecpreset;
3052 name = "serial(EC8/64)";
3056 brdp->memsize = ECP_MEMSIZE;
3057 brdp->pagesize = ECP_EIPAGESIZE;
3058 brdp->init = stli_ecpeiinit;
3059 brdp->enable = stli_ecpeienable;
3060 brdp->reenable = stli_ecpeienable;
3061 brdp->disable = stli_ecpeidisable;
3062 brdp->getmemptr = stli_ecpeigetmemptr;
3063 brdp->intr = stli_ecpintr;
3064 brdp->reset = stli_ecpeireset;
3065 name = "serial(EC8/64-EI)";
3069 brdp->memsize = ECP_MEMSIZE;
3070 brdp->pagesize = ECP_MCPAGESIZE;
3072 brdp->enable = stli_ecpmcenable;
3073 brdp->reenable = stli_ecpmcenable;
3074 brdp->disable = stli_ecpmcdisable;
3075 brdp->getmemptr = stli_ecpmcgetmemptr;
3076 brdp->intr = stli_ecpintr;
3077 brdp->reset = stli_ecpmcreset;
3078 name = "serial(EC8/64-MCA)";
3082 brdp->memsize = ECP_PCIMEMSIZE;
3083 brdp->pagesize = ECP_PCIPAGESIZE;
3084 brdp->init = stli_ecppciinit;
3085 brdp->enable = NULL;
3086 brdp->reenable = NULL;
3087 brdp->disable = NULL;
3088 brdp->getmemptr = stli_ecppcigetmemptr;
3089 brdp->intr = stli_ecpintr;
3090 brdp->reset = stli_ecppcireset;
3091 name = "serial(EC/RA-PCI)";
3100 * The per-board operations structure is all set up, so now let's go
3101 * and get the board operational. Firstly initialize board configuration
3102 * registers. Set the memory mapping info so we can get at the boards
3107 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3108 if (brdp->membase == NULL) {
3114 * Now that all specific code is set up, enable the shared memory and
3115 * look for the a signature area that will tell us exactly what board
3116 * this is, and what it is connected to it.
3119 sigsp = (cdkecpsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3120 memcpy_fromio(&sig, sigsp, sizeof(cdkecpsig_t));
3123 if (sig.magic != cpu_to_le32(ECP_MAGIC)) {
3129 * Scan through the signature looking at the panels connected to the
3130 * board. Calculate the total number of ports as we go.
3132 for (panelnr = 0, nxtid = 0; (panelnr < STL_MAXPANELS); panelnr++) {
3133 status = sig.panelid[nxtid];
3134 if ((status & ECH_PNLIDMASK) != nxtid)
3137 brdp->panelids[panelnr] = status;
3138 nrports = (status & ECH_PNL16PORT) ? 16 : 8;
3139 if ((nrports == 16) && ((status & ECH_PNLXPID) == 0))
3141 brdp->panels[panelnr] = nrports;
3142 brdp->nrports += nrports;
3148 set_bit(BST_FOUND, &brdp->state);
3151 iounmap(brdp->membase);
3152 brdp->membase = NULL;
3154 release_region(brdp->iobase, brdp->iosize);
3159 /*****************************************************************************/
3162 * Try to find an ONboard, Brumby or Stallion board and initialize it.
3163 * This handles only these board types.
3166 static int stli_initonb(struct stlibrd *brdp)
3169 cdkonbsig_t __iomem *sigsp;
3174 * Do a basic sanity check on the IO and memory addresses.
3176 if (brdp->iobase == 0 || brdp->memaddr == 0) {
3181 brdp->iosize = ONB_IOSIZE;
3183 if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
3189 * Based on the specific board type setup the common vars to access
3190 * and enable shared memory. Set all board specific information now
3193 switch (brdp->brdtype) {
3196 brdp->memsize = ONB_MEMSIZE;
3197 brdp->pagesize = ONB_ATPAGESIZE;
3198 brdp->init = stli_onbinit;
3199 brdp->enable = stli_onbenable;
3200 brdp->reenable = stli_onbenable;
3201 brdp->disable = stli_onbdisable;
3202 brdp->getmemptr = stli_onbgetmemptr;
3203 brdp->intr = stli_ecpintr;
3204 brdp->reset = stli_onbreset;
3205 if (brdp->memaddr > 0x100000)
3206 brdp->enabval = ONB_MEMENABHI;
3208 brdp->enabval = ONB_MEMENABLO;
3209 name = "serial(ONBoard)";
3213 brdp->memsize = ONB_EIMEMSIZE;
3214 brdp->pagesize = ONB_EIPAGESIZE;
3215 brdp->init = stli_onbeinit;
3216 brdp->enable = stli_onbeenable;
3217 brdp->reenable = stli_onbeenable;
3218 brdp->disable = stli_onbedisable;
3219 brdp->getmemptr = stli_onbegetmemptr;
3220 brdp->intr = stli_ecpintr;
3221 brdp->reset = stli_onbereset;
3222 name = "serial(ONBoard/E)";
3226 brdp->memsize = BBY_MEMSIZE;
3227 brdp->pagesize = BBY_PAGESIZE;
3228 brdp->init = stli_bbyinit;
3229 brdp->enable = NULL;
3230 brdp->reenable = NULL;
3231 brdp->disable = NULL;
3232 brdp->getmemptr = stli_bbygetmemptr;
3233 brdp->intr = stli_ecpintr;
3234 brdp->reset = stli_bbyreset;
3235 name = "serial(Brumby)";
3239 brdp->memsize = STAL_MEMSIZE;
3240 brdp->pagesize = STAL_PAGESIZE;
3241 brdp->init = stli_stalinit;
3242 brdp->enable = NULL;
3243 brdp->reenable = NULL;
3244 brdp->disable = NULL;
3245 brdp->getmemptr = stli_stalgetmemptr;
3246 brdp->intr = stli_ecpintr;
3247 brdp->reset = stli_stalreset;
3248 name = "serial(Stallion)";
3257 * The per-board operations structure is all set up, so now let's go
3258 * and get the board operational. Firstly initialize board configuration
3259 * registers. Set the memory mapping info so we can get at the boards
3264 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3265 if (brdp->membase == NULL) {
3271 * Now that all specific code is set up, enable the shared memory and
3272 * look for the a signature area that will tell us exactly what board
3273 * this is, and how many ports.
3276 sigsp = (cdkonbsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3277 memcpy_fromio(&sig, sigsp, sizeof(cdkonbsig_t));
3280 if (sig.magic0 != cpu_to_le16(ONB_MAGIC0) ||
3281 sig.magic1 != cpu_to_le16(ONB_MAGIC1) ||
3282 sig.magic2 != cpu_to_le16(ONB_MAGIC2) ||
3283 sig.magic3 != cpu_to_le16(ONB_MAGIC3)) {
3289 * Scan through the signature alive mask and calculate how many ports
3290 * there are on this board.
3296 for (i = 0; (i < 16); i++) {
3297 if (((sig.amask0 << i) & 0x8000) == 0)
3302 brdp->panels[0] = brdp->nrports;
3305 set_bit(BST_FOUND, &brdp->state);
3308 iounmap(brdp->membase);
3309 brdp->membase = NULL;
3311 release_region(brdp->iobase, brdp->iosize);
3316 /*****************************************************************************/
3319 * Start up a running board. This routine is only called after the
3320 * code has been down loaded to the board and is operational. It will
3321 * read in the memory map, and get the show on the road...
3324 static int stli_startbrd(struct stlibrd *brdp)
3326 cdkhdr_t __iomem *hdrp;
3327 cdkmem_t __iomem *memp;
3328 cdkasy_t __iomem *ap;
3329 unsigned long flags;
3330 unsigned int portnr, nrdevs, i;
3331 struct stliport *portp;
3335 spin_lock_irqsave(&brd_lock, flags);
3337 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
3338 nrdevs = hdrp->nrdevs;
3341 printk("%s(%d): CDK version %d.%d.%d --> "
3342 "nrdevs=%d memp=%x hostp=%x slavep=%x\n",
3343 __FILE__, __LINE__, readb(&hdrp->ver_release), readb(&hdrp->ver_modification),
3344 readb(&hdrp->ver_fix), nrdevs, (int) readl(&hdrp->memp), readl(&hdrp->hostp),
3345 readl(&hdrp->slavep));
3348 if (nrdevs < (brdp->nrports + 1)) {
3349 printk(KERN_ERR "istallion: slave failed to allocate memory for "
3350 "all devices, devices=%d\n", nrdevs);
3351 brdp->nrports = nrdevs - 1;
3353 brdp->nrdevs = nrdevs;
3354 brdp->hostoffset = hdrp->hostp - CDK_CDKADDR;
3355 brdp->slaveoffset = hdrp->slavep - CDK_CDKADDR;
3356 brdp->bitsize = (nrdevs + 7) / 8;
3357 memoff = readl(&hdrp->memp);
3358 if (memoff > brdp->memsize) {
3359 printk(KERN_ERR "istallion: corrupted shared memory region?\n");
3361 goto stli_donestartup;
3363 memp = (cdkmem_t __iomem *) EBRDGETMEMPTR(brdp, memoff);
3364 if (readw(&memp->dtype) != TYP_ASYNCTRL) {
3365 printk(KERN_ERR "istallion: no slave control device found\n");
3366 goto stli_donestartup;
3371 * Cycle through memory allocation of each port. We are guaranteed to
3372 * have all ports inside the first page of slave window, so no need to
3373 * change pages while reading memory map.
3375 for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++, memp++) {
3376 if (readw(&memp->dtype) != TYP_ASYNC)
3378 portp = brdp->ports[portnr];
3382 portp->addr = readl(&memp->offset);
3383 portp->reqbit = (unsigned char) (0x1 << (i * 8 / nrdevs));
3384 portp->portidx = (unsigned char) (i / 8);
3385 portp->portbit = (unsigned char) (0x1 << (i % 8));
3388 writeb(0xff, &hdrp->slavereq);
3391 * For each port setup a local copy of the RX and TX buffer offsets
3392 * and sizes. We do this separate from the above, because we need to
3393 * move the shared memory page...
3395 for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++) {
3396 portp = brdp->ports[portnr];
3399 if (portp->addr == 0)
3401 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
3403 portp->rxsize = readw(&ap->rxq.size);
3404 portp->txsize = readw(&ap->txq.size);
3405 portp->rxoffset = readl(&ap->rxq.offset);
3406 portp->txoffset = readl(&ap->txq.offset);
3412 spin_unlock_irqrestore(&brd_lock, flags);
3415 set_bit(BST_STARTED, &brdp->state);
3417 if (! stli_timeron) {
3419 mod_timer(&stli_timerlist, STLI_TIMEOUT);
3425 /*****************************************************************************/
3428 * Probe and initialize the specified board.
3431 static int __devinit stli_brdinit(struct stlibrd *brdp)
3435 switch (brdp->brdtype) {
3440 retval = stli_initecp(brdp);
3447 retval = stli_initonb(brdp);
3450 printk(KERN_ERR "istallion: board=%d is unknown board "
3451 "type=%d\n", brdp->brdnr, brdp->brdtype);
3458 stli_initports(brdp);
3459 printk(KERN_INFO "istallion: %s found, board=%d io=%x mem=%x "
3460 "nrpanels=%d nrports=%d\n", stli_brdnames[brdp->brdtype],
3461 brdp->brdnr, brdp->iobase, (int) brdp->memaddr,
3462 brdp->nrpanels, brdp->nrports);
3466 #if STLI_EISAPROBE != 0
3467 /*****************************************************************************/
3470 * Probe around trying to find where the EISA boards shared memory
3471 * might be. This is a bit if hack, but it is the best we can do.
3474 static int stli_eisamemprobe(struct stlibrd *brdp)
3476 cdkecpsig_t ecpsig, __iomem *ecpsigp;
3477 cdkonbsig_t onbsig, __iomem *onbsigp;
3481 * First up we reset the board, to get it into a known state. There
3482 * is only 2 board types here we need to worry about. Don;t use the
3483 * standard board init routine here, it programs up the shared
3484 * memory address, and we don't know it yet...
3486 if (brdp->brdtype == BRD_ECPE) {
3487 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
3488 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
3490 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
3492 stli_ecpeienable(brdp);
3493 } else if (brdp->brdtype == BRD_ONBOARDE) {
3494 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
3495 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3497 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3499 outb(0x1, brdp->iobase);
3501 stli_onbeenable(brdp);
3507 brdp->memsize = ECP_MEMSIZE;
3510 * Board shared memory is enabled, so now we have a poke around and
3511 * see if we can find it.
3513 for (i = 0; (i < stli_eisamempsize); i++) {
3514 brdp->memaddr = stli_eisamemprobeaddrs[i];
3515 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3516 if (brdp->membase == NULL)
3519 if (brdp->brdtype == BRD_ECPE) {
3520 ecpsigp = stli_ecpeigetmemptr(brdp,
3521 CDK_SIGADDR, __LINE__);
3522 memcpy_fromio(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
3523 if (ecpsig.magic == cpu_to_le32(ECP_MAGIC))
3526 onbsigp = (cdkonbsig_t __iomem *) stli_onbegetmemptr(brdp,
3527 CDK_SIGADDR, __LINE__);
3528 memcpy_fromio(&onbsig, onbsigp, sizeof(cdkonbsig_t));
3529 if ((onbsig.magic0 == cpu_to_le16(ONB_MAGIC0)) &&
3530 (onbsig.magic1 == cpu_to_le16(ONB_MAGIC1)) &&
3531 (onbsig.magic2 == cpu_to_le16(ONB_MAGIC2)) &&
3532 (onbsig.magic3 == cpu_to_le16(ONB_MAGIC3)))
3536 iounmap(brdp->membase);
3542 * Regardless of whether we found the shared memory or not we must
3543 * disable the region. After that return success or failure.
3545 if (brdp->brdtype == BRD_ECPE)
3546 stli_ecpeidisable(brdp);
3548 stli_onbedisable(brdp);
3552 brdp->membase = NULL;
3553 printk(KERN_ERR "istallion: failed to probe shared memory "
3554 "region for %s in EISA slot=%d\n",
3555 stli_brdnames[brdp->brdtype], (brdp->iobase >> 12));
3562 static int stli_getbrdnr(void)
3566 for (i = 0; i < STL_MAXBRDS; i++) {
3567 if (!stli_brds[i]) {
3568 if (i >= stli_nrbrds)
3569 stli_nrbrds = i + 1;
3576 #if STLI_EISAPROBE != 0
3577 /*****************************************************************************/
3580 * Probe around and try to find any EISA boards in system. The biggest
3581 * problem here is finding out what memory address is associated with
3582 * an EISA board after it is found. The registers of the ECPE and
3583 * ONboardE are not readable - so we can't read them from there. We
3584 * don't have access to the EISA CMOS (or EISA BIOS) so we don't
3585 * actually have any way to find out the real value. The best we can
3586 * do is go probing around in the usual places hoping we can find it.
3589 static int __init stli_findeisabrds(void)
3591 struct stlibrd *brdp;
3592 unsigned int iobase, eid, i;
3593 int brdnr, found = 0;
3596 * Firstly check if this is an EISA system. If this is not an EISA system then
3597 * don't bother going any further!
3603 * Looks like an EISA system, so go searching for EISA boards.
3605 for (iobase = 0x1000; (iobase <= 0xc000); iobase += 0x1000) {
3606 outb(0xff, (iobase + 0xc80));
3607 eid = inb(iobase + 0xc80);
3608 eid |= inb(iobase + 0xc81) << 8;
3609 if (eid != STL_EISAID)
3613 * We have found a board. Need to check if this board was
3614 * statically configured already (just in case!).
3616 for (i = 0; (i < STL_MAXBRDS); i++) {
3617 brdp = stli_brds[i];
3620 if (brdp->iobase == iobase)
3623 if (i < STL_MAXBRDS)
3627 * We have found a Stallion board and it is not configured already.
3628 * Allocate a board structure and initialize it.
3630 if ((brdp = stli_allocbrd()) == NULL)
3631 return found ? : -ENOMEM;
3632 brdnr = stli_getbrdnr();
3634 return found ? : -ENOMEM;
3635 brdp->brdnr = (unsigned int)brdnr;
3636 eid = inb(iobase + 0xc82);
3637 if (eid == ECP_EISAID)
3638 brdp->brdtype = BRD_ECPE;
3639 else if (eid == ONB_EISAID)
3640 brdp->brdtype = BRD_ONBOARDE;
3642 brdp->brdtype = BRD_UNKNOWN;
3643 brdp->iobase = iobase;
3644 outb(0x1, (iobase + 0xc84));
3645 if (stli_eisamemprobe(brdp))
3646 outb(0, (iobase + 0xc84));
3647 if (stli_brdinit(brdp) < 0) {
3652 stli_brds[brdp->brdnr] = brdp;
3655 for (i = 0; i < brdp->nrports; i++)
3656 tty_register_device(stli_serial,
3657 brdp->brdnr * STL_MAXPORTS + i, NULL);
3663 static inline int stli_findeisabrds(void) { return 0; }
3666 /*****************************************************************************/
3669 * Find the next available board number that is free.
3672 /*****************************************************************************/
3675 * We have a Stallion board. Allocate a board structure and
3676 * initialize it. Read its IO and MEMORY resources from PCI
3677 * configuration space.
3680 static int __devinit stli_pciprobe(struct pci_dev *pdev,
3681 const struct pci_device_id *ent)
3683 struct stlibrd *brdp;
3685 int brdnr, retval = -EIO;
3687 retval = pci_enable_device(pdev);
3690 brdp = stli_allocbrd();
3695 mutex_lock(&stli_brdslock);
3696 brdnr = stli_getbrdnr();
3698 printk(KERN_INFO "istallion: too many boards found, "
3699 "maximum supported %d\n", STL_MAXBRDS);
3700 mutex_unlock(&stli_brdslock);
3704 brdp->brdnr = (unsigned int)brdnr;
3705 stli_brds[brdp->brdnr] = brdp;
3706 mutex_unlock(&stli_brdslock);
3707 brdp->brdtype = BRD_ECPPCI;
3709 * We have all resources from the board, so lets setup the actual
3710 * board structure now.
3712 brdp->iobase = pci_resource_start(pdev, 3);
3713 brdp->memaddr = pci_resource_start(pdev, 2);
3714 retval = stli_brdinit(brdp);
3718 set_bit(BST_PROBED, &brdp->state);
3719 pci_set_drvdata(pdev, brdp);
3722 brdp->enable = NULL;
3723 brdp->disable = NULL;
3725 for (i = 0; i < brdp->nrports; i++)
3726 tty_register_device(stli_serial, brdp->brdnr * STL_MAXPORTS + i,
3731 stli_brds[brdp->brdnr] = NULL;
3738 static void __devexit stli_pciremove(struct pci_dev *pdev)
3740 struct stlibrd *brdp = pci_get_drvdata(pdev);
3742 stli_cleanup_ports(brdp);
3744 iounmap(brdp->membase);
3745 if (brdp->iosize > 0)
3746 release_region(brdp->iobase, brdp->iosize);
3748 stli_brds[brdp->brdnr] = NULL;
3752 static struct pci_driver stli_pcidriver = {
3753 .name = "istallion",
3754 .id_table = istallion_pci_tbl,
3755 .probe = stli_pciprobe,
3756 .remove = __devexit_p(stli_pciremove)
3758 /*****************************************************************************/
3761 * Allocate a new board structure. Fill out the basic info in it.
3764 static struct stlibrd *stli_allocbrd(void)
3766 struct stlibrd *brdp;
3768 brdp = kzalloc(sizeof(struct stlibrd), GFP_KERNEL);
3770 printk(KERN_ERR "istallion: failed to allocate memory "
3771 "(size=%Zd)\n", sizeof(struct stlibrd));
3774 brdp->magic = STLI_BOARDMAGIC;
3778 /*****************************************************************************/
3781 * Scan through all the boards in the configuration and see what we
3785 static int __init stli_initbrds(void)
3787 struct stlibrd *brdp, *nxtbrdp;
3788 struct stlconf conf;
3789 unsigned int i, j, found = 0;
3792 for (stli_nrbrds = 0; stli_nrbrds < ARRAY_SIZE(stli_brdsp);
3794 memset(&conf, 0, sizeof(conf));
3795 if (stli_parsebrd(&conf, stli_brdsp[stli_nrbrds]) == 0)
3797 if ((brdp = stli_allocbrd()) == NULL)
3799 brdp->brdnr = stli_nrbrds;
3800 brdp->brdtype = conf.brdtype;
3801 brdp->iobase = conf.ioaddr1;
3802 brdp->memaddr = conf.memaddr;
3803 if (stli_brdinit(brdp) < 0) {
3807 stli_brds[brdp->brdnr] = brdp;
3810 for (i = 0; i < brdp->nrports; i++)
3811 tty_register_device(stli_serial,
3812 brdp->brdnr * STL_MAXPORTS + i, NULL);
3815 retval = stli_findeisabrds();
3820 * All found boards are initialized. Now for a little optimization, if
3821 * no boards are sharing the "shared memory" regions then we can just
3822 * leave them all enabled. This is in fact the usual case.
3825 if (stli_nrbrds > 1) {
3826 for (i = 0; (i < stli_nrbrds); i++) {
3827 brdp = stli_brds[i];
3830 for (j = i + 1; (j < stli_nrbrds); j++) {
3831 nxtbrdp = stli_brds[j];
3832 if (nxtbrdp == NULL)
3834 if ((brdp->membase >= nxtbrdp->membase) &&
3835 (brdp->membase <= (nxtbrdp->membase +
3836 nxtbrdp->memsize - 1))) {
3844 if (stli_shared == 0) {
3845 for (i = 0; (i < stli_nrbrds); i++) {
3846 brdp = stli_brds[i];
3849 if (test_bit(BST_FOUND, &brdp->state)) {
3851 brdp->enable = NULL;
3852 brdp->disable = NULL;
3857 retval = pci_register_driver(&stli_pcidriver);
3858 if (retval && found == 0) {
3859 printk(KERN_ERR "Neither isa nor eisa cards found nor pci "
3860 "driver can be registered!\n");
3869 /*****************************************************************************/
3872 * Code to handle an "staliomem" read operation. This device is the
3873 * contents of the board shared memory. It is used for down loading
3874 * the slave image (and debugging :-)
3877 static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp)
3879 unsigned long flags;
3880 void __iomem *memptr;
3881 struct stlibrd *brdp;
3887 brdnr = iminor(fp->f_path.dentry->d_inode);
3888 if (brdnr >= stli_nrbrds)
3890 brdp = stli_brds[brdnr];
3893 if (brdp->state == 0)
3895 if (off >= brdp->memsize || off + count < off)
3898 size = min(count, (size_t)(brdp->memsize - off));
3901 * Copy the data a page at a time
3904 p = (void *)__get_free_page(GFP_KERNEL);
3909 spin_lock_irqsave(&brd_lock, flags);
3911 memptr = EBRDGETMEMPTR(brdp, off);
3912 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
3913 n = min(n, (int)PAGE_SIZE);
3914 memcpy_fromio(p, memptr, n);
3916 spin_unlock_irqrestore(&brd_lock, flags);
3917 if (copy_to_user(buf, p, n)) {
3927 free_page((unsigned long)p);
3931 /*****************************************************************************/
3934 * Code to handle an "staliomem" write operation. This device is the
3935 * contents of the board shared memory. It is used for down loading
3936 * the slave image (and debugging :-)
3938 * FIXME: copy under lock
3941 static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp)
3943 unsigned long flags;
3944 void __iomem *memptr;
3945 struct stlibrd *brdp;
3952 brdnr = iminor(fp->f_path.dentry->d_inode);
3954 if (brdnr >= stli_nrbrds)
3956 brdp = stli_brds[brdnr];
3959 if (brdp->state == 0)
3961 if (off >= brdp->memsize || off + count < off)
3964 chbuf = (char __user *) buf;
3965 size = min(count, (size_t)(brdp->memsize - off));
3968 * Copy the data a page at a time
3971 p = (void *)__get_free_page(GFP_KERNEL);
3976 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
3977 n = min(n, (int)PAGE_SIZE);
3978 if (copy_from_user(p, chbuf, n)) {
3983 spin_lock_irqsave(&brd_lock, flags);
3985 memptr = EBRDGETMEMPTR(brdp, off);
3986 memcpy_toio(memptr, p, n);
3988 spin_unlock_irqrestore(&brd_lock, flags);
3994 free_page((unsigned long) p);
3999 /*****************************************************************************/
4002 * Return the board stats structure to user app.
4005 static int stli_getbrdstats(combrd_t __user *bp)
4007 struct stlibrd *brdp;
4010 if (copy_from_user(&stli_brdstats, bp, sizeof(combrd_t)))
4012 if (stli_brdstats.brd >= STL_MAXBRDS)
4014 brdp = stli_brds[stli_brdstats.brd];
4018 memset(&stli_brdstats, 0, sizeof(combrd_t));
4020 stli_brdstats.brd = brdp->brdnr;
4021 stli_brdstats.type = brdp->brdtype;
4022 stli_brdstats.hwid = 0;
4023 stli_brdstats.state = brdp->state;
4024 stli_brdstats.ioaddr = brdp->iobase;
4025 stli_brdstats.memaddr = brdp->memaddr;
4026 stli_brdstats.nrpanels = brdp->nrpanels;
4027 stli_brdstats.nrports = brdp->nrports;
4028 for (i = 0; (i < brdp->nrpanels); i++) {
4029 stli_brdstats.panels[i].panel = i;
4030 stli_brdstats.panels[i].hwid = brdp->panelids[i];
4031 stli_brdstats.panels[i].nrports = brdp->panels[i];
4034 if (copy_to_user(bp, &stli_brdstats, sizeof(combrd_t)))
4039 /*****************************************************************************/
4042 * Resolve the referenced port number into a port struct pointer.
4045 static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr,
4046 unsigned int portnr)
4048 struct stlibrd *brdp;
4051 if (brdnr >= STL_MAXBRDS)
4053 brdp = stli_brds[brdnr];
4056 for (i = 0; (i < panelnr); i++)
4057 portnr += brdp->panels[i];
4058 if (portnr >= brdp->nrports)
4060 return brdp->ports[portnr];
4063 /*****************************************************************************/
4066 * Return the port stats structure to user app. A NULL port struct
4067 * pointer passed in means that we need to find out from the app
4068 * what port to get stats for (used through board control device).
4071 static int stli_portcmdstats(struct tty_struct *tty, struct stliport *portp)
4073 unsigned long flags;
4074 struct stlibrd *brdp;
4077 memset(&stli_comstats, 0, sizeof(comstats_t));
4081 brdp = stli_brds[portp->brdnr];
4085 mutex_lock(&portp->port.mutex);
4086 if (test_bit(BST_STARTED, &brdp->state)) {
4087 if ((rc = stli_cmdwait(brdp, portp, A_GETSTATS,
4088 &stli_cdkstats, sizeof(asystats_t), 1)) < 0) {
4089 mutex_unlock(&portp->port.mutex);
4093 memset(&stli_cdkstats, 0, sizeof(asystats_t));
4096 stli_comstats.brd = portp->brdnr;
4097 stli_comstats.panel = portp->panelnr;
4098 stli_comstats.port = portp->portnr;
4099 stli_comstats.state = portp->state;
4100 stli_comstats.flags = portp->port.flags;
4102 spin_lock_irqsave(&brd_lock, flags);
4104 if (portp->port.tty == tty) {
4105 stli_comstats.ttystate = tty->flags;
4106 stli_comstats.rxbuffered = -1;
4107 if (tty->termios != NULL) {
4108 stli_comstats.cflags = tty->termios->c_cflag;
4109 stli_comstats.iflags = tty->termios->c_iflag;
4110 stli_comstats.oflags = tty->termios->c_oflag;
4111 stli_comstats.lflags = tty->termios->c_lflag;
4115 spin_unlock_irqrestore(&brd_lock, flags);
4117 stli_comstats.txtotal = stli_cdkstats.txchars;
4118 stli_comstats.rxtotal = stli_cdkstats.rxchars + stli_cdkstats.ringover;
4119 stli_comstats.txbuffered = stli_cdkstats.txringq;
4120 stli_comstats.rxbuffered += stli_cdkstats.rxringq;
4121 stli_comstats.rxoverrun = stli_cdkstats.overruns;
4122 stli_comstats.rxparity = stli_cdkstats.parity;
4123 stli_comstats.rxframing = stli_cdkstats.framing;
4124 stli_comstats.rxlost = stli_cdkstats.ringover;
4125 stli_comstats.rxbreaks = stli_cdkstats.rxbreaks;
4126 stli_comstats.txbreaks = stli_cdkstats.txbreaks;
4127 stli_comstats.txxon = stli_cdkstats.txstart;
4128 stli_comstats.txxoff = stli_cdkstats.txstop;
4129 stli_comstats.rxxon = stli_cdkstats.rxstart;
4130 stli_comstats.rxxoff = stli_cdkstats.rxstop;
4131 stli_comstats.rxrtsoff = stli_cdkstats.rtscnt / 2;
4132 stli_comstats.rxrtson = stli_cdkstats.rtscnt - stli_comstats.rxrtsoff;
4133 stli_comstats.modem = stli_cdkstats.dcdcnt;
4134 stli_comstats.hwid = stli_cdkstats.hwid;
4135 stli_comstats.signals = stli_mktiocm(stli_cdkstats.signals);
4136 mutex_unlock(&portp->port.mutex);
4141 /*****************************************************************************/
4144 * Return the port stats structure to user app. A NULL port struct
4145 * pointer passed in means that we need to find out from the app
4146 * what port to get stats for (used through board control device).
4149 static int stli_getportstats(struct tty_struct *tty, struct stliport *portp,
4150 comstats_t __user *cp)
4152 struct stlibrd *brdp;
4156 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
4158 portp = stli_getport(stli_comstats.brd, stli_comstats.panel,
4159 stli_comstats.port);
4164 brdp = stli_brds[portp->brdnr];
4168 if ((rc = stli_portcmdstats(tty, portp)) < 0)
4171 return copy_to_user(cp, &stli_comstats, sizeof(comstats_t)) ?
4175 /*****************************************************************************/
4178 * Clear the port stats structure. We also return it zeroed out...
4181 static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp)
4183 struct stlibrd *brdp;
4187 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
4189 portp = stli_getport(stli_comstats.brd, stli_comstats.panel,
4190 stli_comstats.port);
4195 brdp = stli_brds[portp->brdnr];
4199 mutex_lock(&portp->port.mutex);
4201 if (test_bit(BST_STARTED, &brdp->state)) {
4202 if ((rc = stli_cmdwait(brdp, portp, A_CLEARSTATS, NULL, 0, 0)) < 0) {
4203 mutex_unlock(&portp->port.mutex);
4208 memset(&stli_comstats, 0, sizeof(comstats_t));
4209 stli_comstats.brd = portp->brdnr;
4210 stli_comstats.panel = portp->panelnr;
4211 stli_comstats.port = portp->portnr;
4212 mutex_unlock(&portp->port.mutex);
4214 if (copy_to_user(cp, &stli_comstats, sizeof(comstats_t)))
4219 /*****************************************************************************/
4222 * Return the entire driver ports structure to a user app.
4225 static int stli_getportstruct(struct stliport __user *arg)
4227 struct stliport stli_dummyport;
4228 struct stliport *portp;
4230 if (copy_from_user(&stli_dummyport, arg, sizeof(struct stliport)))
4232 portp = stli_getport(stli_dummyport.brdnr, stli_dummyport.panelnr,
4233 stli_dummyport.portnr);
4236 if (copy_to_user(arg, portp, sizeof(struct stliport)))
4241 /*****************************************************************************/
4244 * Return the entire driver board structure to a user app.
4247 static int stli_getbrdstruct(struct stlibrd __user *arg)
4249 struct stlibrd stli_dummybrd;
4250 struct stlibrd *brdp;
4252 if (copy_from_user(&stli_dummybrd, arg, sizeof(struct stlibrd)))
4254 if (stli_dummybrd.brdnr >= STL_MAXBRDS)
4256 brdp = stli_brds[stli_dummybrd.brdnr];
4259 if (copy_to_user(arg, brdp, sizeof(struct stlibrd)))
4264 /*****************************************************************************/
4267 * The "staliomem" device is also required to do some special operations on
4268 * the board. We need to be able to send an interrupt to the board,
4269 * reset it, and start/stop it.
4272 static long stli_memioctl(struct file *fp, unsigned int cmd, unsigned long arg)
4274 struct stlibrd *brdp;
4275 int brdnr, rc, done;
4276 void __user *argp = (void __user *)arg;
4279 * First up handle the board independent ioctls.
4285 case COM_GETPORTSTATS:
4286 rc = stli_getportstats(NULL, NULL, argp);
4289 case COM_CLRPORTSTATS:
4290 rc = stli_clrportstats(NULL, argp);
4293 case COM_GETBRDSTATS:
4294 rc = stli_getbrdstats(argp);
4298 rc = stli_getportstruct(argp);
4302 rc = stli_getbrdstruct(argp);
4310 * Now handle the board specific ioctls. These all depend on the
4311 * minor number of the device they were called from.
4313 brdnr = iminor(fp->f_dentry->d_inode);
4314 if (brdnr >= STL_MAXBRDS)
4316 brdp = stli_brds[brdnr];
4319 if (brdp->state == 0)
4327 rc = stli_startbrd(brdp);
4330 clear_bit(BST_STARTED, &brdp->state);
4333 clear_bit(BST_STARTED, &brdp->state);
4335 if (stli_shared == 0) {
4336 if (brdp->reenable != NULL)
4337 (* brdp->reenable)(brdp);
4347 static const struct tty_operations stli_ops = {
4349 .close = stli_close,
4350 .write = stli_write,
4351 .put_char = stli_putchar,
4352 .flush_chars = stli_flushchars,
4353 .write_room = stli_writeroom,
4354 .chars_in_buffer = stli_charsinbuffer,
4355 .ioctl = stli_ioctl,
4356 .set_termios = stli_settermios,
4357 .throttle = stli_throttle,
4358 .unthrottle = stli_unthrottle,
4360 .start = stli_start,
4361 .hangup = stli_hangup,
4362 .flush_buffer = stli_flushbuffer,
4363 .break_ctl = stli_breakctl,
4364 .wait_until_sent = stli_waituntilsent,
4365 .send_xchar = stli_sendxchar,
4366 .tiocmget = stli_tiocmget,
4367 .tiocmset = stli_tiocmset,
4368 .proc_fops = &stli_proc_fops,
4371 static const struct tty_port_operations stli_port_ops = {
4372 .carrier_raised = stli_carrier_raised,
4373 .dtr_rts = stli_dtr_rts,
4374 .activate = stli_activate,
4375 .shutdown = stli_shutdown,
4378 /*****************************************************************************/
4380 * Loadable module initialization stuff.
4383 static void istallion_cleanup_isa(void)
4385 struct stlibrd *brdp;
4388 for (j = 0; (j < stli_nrbrds); j++) {
4389 if ((brdp = stli_brds[j]) == NULL ||
4390 test_bit(BST_PROBED, &brdp->state))
4393 stli_cleanup_ports(brdp);
4395 iounmap(brdp->membase);
4396 if (brdp->iosize > 0)
4397 release_region(brdp->iobase, brdp->iosize);
4399 stli_brds[j] = NULL;
4403 static int __init istallion_module_init(void)
4408 printk(KERN_INFO "%s: version %s\n", stli_drvtitle, stli_drvversion);
4410 spin_lock_init(&stli_lock);
4411 spin_lock_init(&brd_lock);
4413 stli_txcookbuf = kmalloc(STLI_TXBUFSIZE, GFP_KERNEL);
4414 if (!stli_txcookbuf) {
4415 printk(KERN_ERR "istallion: failed to allocate memory "
4416 "(size=%d)\n", STLI_TXBUFSIZE);
4421 stli_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
4427 stli_serial->owner = THIS_MODULE;
4428 stli_serial->driver_name = stli_drvname;
4429 stli_serial->name = stli_serialname;
4430 stli_serial->major = STL_SERIALMAJOR;
4431 stli_serial->minor_start = 0;
4432 stli_serial->type = TTY_DRIVER_TYPE_SERIAL;
4433 stli_serial->subtype = SERIAL_TYPE_NORMAL;
4434 stli_serial->init_termios = stli_deftermios;
4435 stli_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4436 tty_set_operations(stli_serial, &stli_ops);
4438 retval = tty_register_driver(stli_serial);
4440 printk(KERN_ERR "istallion: failed to register serial driver\n");
4444 retval = stli_initbrds();
4449 * Set up a character driver for the shared memory region. We need this
4450 * to down load the slave code image. Also it is a useful debugging tool.
4452 retval = register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stli_fsiomem);
4454 printk(KERN_ERR "istallion: failed to register serial memory "
4459 istallion_class = class_create(THIS_MODULE, "staliomem");
4460 for (i = 0; i < 4; i++)
4461 device_create(istallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
4462 NULL, "staliomem%d", i);
4466 pci_unregister_driver(&stli_pcidriver);
4467 istallion_cleanup_isa();
4469 tty_unregister_driver(stli_serial);
4471 put_tty_driver(stli_serial);
4473 kfree(stli_txcookbuf);
4478 /*****************************************************************************/
4480 static void __exit istallion_module_exit(void)
4484 printk(KERN_INFO "Unloading %s: version %s\n", stli_drvtitle,
4489 del_timer_sync(&stli_timerlist);
4492 unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
4494 for (j = 0; j < 4; j++)
4495 device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR, j));
4496 class_destroy(istallion_class);
4498 pci_unregister_driver(&stli_pcidriver);
4499 istallion_cleanup_isa();
4501 tty_unregister_driver(stli_serial);
4502 put_tty_driver(stli_serial);
4504 kfree(stli_txcookbuf);
4507 module_init(istallion_module_init);
4508 module_exit(istallion_module_exit);