1 /*****************************************************************************/
4 * istallion.c -- stallion intelligent multiport serial driver.
6 * Copyright (C) 1996-1999 Stallion Technologies
7 * Copyright (C) 1994-1996 Greg Ungerer.
9 * This code is loosely based on the Linux serial driver, written by
10 * Linus Torvalds, Theodore T'so and others.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
19 /*****************************************************************************/
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/tty.h>
25 #include <linux/tty_flip.h>
26 #include <linux/serial.h>
27 #include <linux/cdk.h>
28 #include <linux/comstats.h>
29 #include <linux/istallion.h>
30 #include <linux/ioport.h>
31 #include <linux/delay.h>
32 #include <linux/init.h>
33 #include <linux/device.h>
34 #include <linux/wait.h>
35 #include <linux/eisa.h>
36 #include <linux/ctype.h>
39 #include <asm/uaccess.h>
41 #include <linux/pci.h>
43 /*****************************************************************************/
46 * Define different board types. Not all of the following board types
47 * are supported by this driver. But I will use the standard "assigned"
48 * board numbers. Currently supported boards are abbreviated as:
49 * ECP = EasyConnection 8/64, ONB = ONboard, BBY = Brumby and
53 #define BRD_STALLION 1
55 #define BRD_ONBOARD2 3
57 #define BRD_ONBOARDE 7
63 #define BRD_BRUMBY BRD_BRUMBY4
66 * Define a configuration structure to hold the board configuration.
67 * Need to set this up in the code (for now) with the boards that are
68 * to be configured into the system. This is what needs to be modified
69 * when adding/removing/modifying boards. Each line entry in the
70 * stli_brdconf[] array is a board. Each line contains io/irq/memory
71 * ranges for that board (as well as what type of board it is).
73 * { BRD_ECP, 0x2a0, 0, 0xcc000, 0, 0 },
74 * This line will configure an EasyConnection 8/64 at io address 2a0,
75 * and shared memory address of cc000. Multiple EasyConnection 8/64
76 * boards can share the same shared memory address space. No interrupt
77 * is required for this board type.
79 * { BRD_ECPE, 0x5000, 0, 0x80000000, 0, 0 },
80 * This line will configure an EasyConnection 8/64 EISA in slot 5 and
81 * shared memory address of 0x80000000 (2 GByte). Multiple
82 * EasyConnection 8/64 EISA boards can share the same shared memory
83 * address space. No interrupt is required for this board type.
85 * { BRD_ONBOARD, 0x240, 0, 0xd0000, 0, 0 },
86 * This line will configure an ONboard (ISA type) at io address 240,
87 * and shared memory address of d0000. Multiple ONboards can share
88 * the same shared memory address space. No interrupt required.
90 * { BRD_BRUMBY4, 0x360, 0, 0xc8000, 0, 0 },
91 * This line will configure a Brumby board (any number of ports!) at
92 * io address 360 and shared memory address of c8000. All Brumby boards
93 * configured into a system must have their own separate io and memory
94 * addresses. No interrupt is required.
96 * { BRD_STALLION, 0x330, 0, 0xd0000, 0, 0 },
97 * This line will configure an original Stallion board at io address 330
98 * and shared memory address d0000 (this would only be valid for a "V4.0"
99 * or Rev.O Stallion board). All Stallion boards configured into the
100 * system must have their own separate io and memory addresses. No
101 * interrupt is required.
108 unsigned long memaddr
;
113 static unsigned int stli_nrbrds
;
115 /* stli_lock must NOT be taken holding brd_lock */
116 static spinlock_t stli_lock
; /* TTY logic lock */
117 static spinlock_t brd_lock
; /* Board logic lock */
120 * There is some experimental EISA board detection code in this driver.
121 * By default it is disabled, but for those that want to try it out,
122 * then set the define below to be 1.
124 #define STLI_EISAPROBE 0
126 /*****************************************************************************/
129 * Define some important driver characteristics. Device major numbers
130 * allocated as per Linux Device Registry.
132 #ifndef STL_SIOMEMMAJOR
133 #define STL_SIOMEMMAJOR 28
135 #ifndef STL_SERIALMAJOR
136 #define STL_SERIALMAJOR 24
138 #ifndef STL_CALLOUTMAJOR
139 #define STL_CALLOUTMAJOR 25
142 /*****************************************************************************/
145 * Define our local driver identity first. Set up stuff to deal with
146 * all the local structures required by a serial tty driver.
148 static char *stli_drvtitle
= "Stallion Intelligent Multiport Serial Driver";
149 static char *stli_drvname
= "istallion";
150 static char *stli_drvversion
= "5.6.0";
151 static char *stli_serialname
= "ttyE";
153 static struct tty_driver
*stli_serial
;
156 #define STLI_TXBUFSIZE 4096
159 * Use a fast local buffer for cooked characters. Typically a whole
160 * bunch of cooked characters come in for a port, 1 at a time. So we
161 * save those up into a local buffer, then write out the whole lot
162 * with a large memcpy. Just use 1 buffer for all ports, since its
163 * use it is only need for short periods of time by each port.
165 static char *stli_txcookbuf
;
166 static int stli_txcooksize
;
167 static int stli_txcookrealsize
;
168 static struct tty_struct
*stli_txcooktty
;
171 * Define a local default termios struct. All ports will be created
172 * with this termios initially. Basically all it defines is a raw port
173 * at 9600 baud, 8 data bits, no parity, 1 stop bit.
175 static struct ktermios stli_deftermios
= {
176 .c_cflag
= (B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
),
183 * Define global stats structures. Not used often, and can be
184 * re-used for each stats call.
186 static comstats_t stli_comstats
;
187 static combrd_t stli_brdstats
;
188 static struct asystats stli_cdkstats
;
190 /*****************************************************************************/
192 static struct stlibrd
*stli_brds
[STL_MAXBRDS
];
194 static int stli_shared
;
197 * Per board state flags. Used with the state field of the board struct.
198 * Not really much here... All we need to do is keep track of whether
199 * the board has been detected, and whether it is actually running a slave
202 #define BST_FOUND 0x1
203 #define BST_STARTED 0x2
206 * Define the set of port state flags. These are marked for internal
207 * state purposes only, usually to do with the state of communications
208 * with the slave. Most of them need to be updated atomically, so always
209 * use the bit setting operations (unless protected by cli/sti).
211 #define ST_INITIALIZING 1
217 #define ST_DOFLUSHRX 7
218 #define ST_DOFLUSHTX 8
221 #define ST_GETSIGS 11
224 * Define an array of board names as printable strings. Handy for
225 * referencing boards when printing trace and stuff.
227 static char *stli_brdnames
[] = {
260 /*****************************************************************************/
263 * Define some string labels for arguments passed from the module
264 * load line. These allow for easy board definitions, and easy
265 * modification of the io, memory and irq resoucres.
268 static char *board0
[8];
269 static char *board1
[8];
270 static char *board2
[8];
271 static char *board3
[8];
273 static char **stli_brdsp
[] = {
281 * Define a set of common board names, and types. This is used to
282 * parse any module arguments.
285 static struct stlibrdtype
{
289 { "stallion", BRD_STALLION
},
290 { "1", BRD_STALLION
},
291 { "brumby", BRD_BRUMBY
},
292 { "brumby4", BRD_BRUMBY
},
293 { "brumby/4", BRD_BRUMBY
},
294 { "brumby-4", BRD_BRUMBY
},
295 { "brumby8", BRD_BRUMBY
},
296 { "brumby/8", BRD_BRUMBY
},
297 { "brumby-8", BRD_BRUMBY
},
298 { "brumby16", BRD_BRUMBY
},
299 { "brumby/16", BRD_BRUMBY
},
300 { "brumby-16", BRD_BRUMBY
},
302 { "onboard2", BRD_ONBOARD2
},
303 { "onboard-2", BRD_ONBOARD2
},
304 { "onboard/2", BRD_ONBOARD2
},
305 { "onboard-mc", BRD_ONBOARD2
},
306 { "onboard/mc", BRD_ONBOARD2
},
307 { "onboard-mca", BRD_ONBOARD2
},
308 { "onboard/mca", BRD_ONBOARD2
},
309 { "3", BRD_ONBOARD2
},
310 { "onboard", BRD_ONBOARD
},
311 { "onboardat", BRD_ONBOARD
},
312 { "4", BRD_ONBOARD
},
313 { "onboarde", BRD_ONBOARDE
},
314 { "onboard-e", BRD_ONBOARDE
},
315 { "onboard/e", BRD_ONBOARDE
},
316 { "onboard-ei", BRD_ONBOARDE
},
317 { "onboard/ei", BRD_ONBOARDE
},
318 { "7", BRD_ONBOARDE
},
320 { "ecpat", BRD_ECP
},
321 { "ec8/64", BRD_ECP
},
322 { "ec8/64-at", BRD_ECP
},
323 { "ec8/64-isa", BRD_ECP
},
325 { "ecpe", BRD_ECPE
},
326 { "ecpei", BRD_ECPE
},
327 { "ec8/64-e", BRD_ECPE
},
328 { "ec8/64-ei", BRD_ECPE
},
330 { "ecpmc", BRD_ECPMC
},
331 { "ec8/64-mc", BRD_ECPMC
},
332 { "ec8/64-mca", BRD_ECPMC
},
334 { "ecppci", BRD_ECPPCI
},
335 { "ec/ra", BRD_ECPPCI
},
336 { "ec/ra-pc", BRD_ECPPCI
},
337 { "ec/ra-pci", BRD_ECPPCI
},
338 { "29", BRD_ECPPCI
},
342 * Define the module agruments.
344 MODULE_AUTHOR("Greg Ungerer");
345 MODULE_DESCRIPTION("Stallion Intelligent Multiport Serial Driver");
346 MODULE_LICENSE("GPL");
349 module_param_array(board0
, charp
, NULL
, 0);
350 MODULE_PARM_DESC(board0
, "Board 0 config -> name[,ioaddr[,memaddr]");
351 module_param_array(board1
, charp
, NULL
, 0);
352 MODULE_PARM_DESC(board1
, "Board 1 config -> name[,ioaddr[,memaddr]");
353 module_param_array(board2
, charp
, NULL
, 0);
354 MODULE_PARM_DESC(board2
, "Board 2 config -> name[,ioaddr[,memaddr]");
355 module_param_array(board3
, charp
, NULL
, 0);
356 MODULE_PARM_DESC(board3
, "Board 3 config -> name[,ioaddr[,memaddr]");
359 * Set up a default memory address table for EISA board probing.
360 * The default addresses are all bellow 1Mbyte, which has to be the
361 * case anyway. They should be safe, since we only read values from
362 * them, and interrupts are disabled while we do it. If the higher
363 * memory support is compiled in then we also try probing around
364 * the 1Gb, 2Gb and 3Gb areas as well...
366 static unsigned long stli_eisamemprobeaddrs
[] = {
367 0xc0000, 0xd0000, 0xe0000, 0xf0000,
368 0x80000000, 0x80010000, 0x80020000, 0x80030000,
369 0x40000000, 0x40010000, 0x40020000, 0x40030000,
370 0xc0000000, 0xc0010000, 0xc0020000, 0xc0030000,
371 0xff000000, 0xff010000, 0xff020000, 0xff030000,
374 static int stli_eisamempsize
= ARRAY_SIZE(stli_eisamemprobeaddrs
);
377 * Define the Stallion PCI vendor and device IDs.
379 #ifndef PCI_DEVICE_ID_ECRA
380 #define PCI_DEVICE_ID_ECRA 0x0004
383 static struct pci_device_id istallion_pci_tbl
[] = {
384 { PCI_DEVICE(PCI_VENDOR_ID_STALLION
, PCI_DEVICE_ID_ECRA
), },
387 MODULE_DEVICE_TABLE(pci
, istallion_pci_tbl
);
389 static struct pci_driver stli_pcidriver
;
391 /*****************************************************************************/
394 * Hardware configuration info for ECP boards. These defines apply
395 * to the directly accessible io ports of the ECP. There is a set of
396 * defines for each ECP board type, ISA, EISA, MCA and PCI.
400 #define ECP_MEMSIZE (128 * 1024)
401 #define ECP_PCIMEMSIZE (256 * 1024)
403 #define ECP_ATPAGESIZE (4 * 1024)
404 #define ECP_MCPAGESIZE (4 * 1024)
405 #define ECP_EIPAGESIZE (64 * 1024)
406 #define ECP_PCIPAGESIZE (64 * 1024)
408 #define STL_EISAID 0x8c4e
411 * Important defines for the ISA class of ECP board.
414 #define ECP_ATCONFR 1
415 #define ECP_ATMEMAR 2
416 #define ECP_ATMEMPR 3
417 #define ECP_ATSTOP 0x1
418 #define ECP_ATINTENAB 0x10
419 #define ECP_ATENABLE 0x20
420 #define ECP_ATDISABLE 0x00
421 #define ECP_ATADDRMASK 0x3f000
422 #define ECP_ATADDRSHFT 12
425 * Important defines for the EISA class of ECP board.
428 #define ECP_EIMEMARL 1
429 #define ECP_EICONFR 2
430 #define ECP_EIMEMARH 3
431 #define ECP_EIENABLE 0x1
432 #define ECP_EIDISABLE 0x0
433 #define ECP_EISTOP 0x4
434 #define ECP_EIEDGE 0x00
435 #define ECP_EILEVEL 0x80
436 #define ECP_EIADDRMASKL 0x00ff0000
437 #define ECP_EIADDRSHFTL 16
438 #define ECP_EIADDRMASKH 0xff000000
439 #define ECP_EIADDRSHFTH 24
440 #define ECP_EIBRDENAB 0xc84
442 #define ECP_EISAID 0x4
445 * Important defines for the Micro-channel class of ECP board.
446 * (It has a lot in common with the ISA boards.)
449 #define ECP_MCCONFR 1
450 #define ECP_MCSTOP 0x20
451 #define ECP_MCENABLE 0x80
452 #define ECP_MCDISABLE 0x00
455 * Important defines for the PCI class of ECP board.
456 * (It has a lot in common with the other ECP boards.)
458 #define ECP_PCIIREG 0
459 #define ECP_PCICONFR 1
460 #define ECP_PCISTOP 0x01
463 * Hardware configuration info for ONboard and Brumby boards. These
464 * defines apply to the directly accessible io ports of these boards.
466 #define ONB_IOSIZE 16
467 #define ONB_MEMSIZE (64 * 1024)
468 #define ONB_ATPAGESIZE (64 * 1024)
469 #define ONB_MCPAGESIZE (64 * 1024)
470 #define ONB_EIMEMSIZE (128 * 1024)
471 #define ONB_EIPAGESIZE (64 * 1024)
474 * Important defines for the ISA class of ONboard board.
477 #define ONB_ATMEMAR 1
478 #define ONB_ATCONFR 2
479 #define ONB_ATSTOP 0x4
480 #define ONB_ATENABLE 0x01
481 #define ONB_ATDISABLE 0x00
482 #define ONB_ATADDRMASK 0xff0000
483 #define ONB_ATADDRSHFT 16
485 #define ONB_MEMENABLO 0
486 #define ONB_MEMENABHI 0x02
489 * Important defines for the EISA class of ONboard board.
492 #define ONB_EIMEMARL 1
493 #define ONB_EICONFR 2
494 #define ONB_EIMEMARH 3
495 #define ONB_EIENABLE 0x1
496 #define ONB_EIDISABLE 0x0
497 #define ONB_EISTOP 0x4
498 #define ONB_EIEDGE 0x00
499 #define ONB_EILEVEL 0x80
500 #define ONB_EIADDRMASKL 0x00ff0000
501 #define ONB_EIADDRSHFTL 16
502 #define ONB_EIADDRMASKH 0xff000000
503 #define ONB_EIADDRSHFTH 24
504 #define ONB_EIBRDENAB 0xc84
506 #define ONB_EISAID 0x1
509 * Important defines for the Brumby boards. They are pretty simple,
510 * there is not much that is programmably configurable.
512 #define BBY_IOSIZE 16
513 #define BBY_MEMSIZE (64 * 1024)
514 #define BBY_PAGESIZE (16 * 1024)
517 #define BBY_ATCONFR 1
518 #define BBY_ATSTOP 0x4
521 * Important defines for the Stallion boards. They are pretty simple,
522 * there is not much that is programmably configurable.
524 #define STAL_IOSIZE 16
525 #define STAL_MEMSIZE (64 * 1024)
526 #define STAL_PAGESIZE (64 * 1024)
529 * Define the set of status register values for EasyConnection panels.
530 * The signature will return with the status value for each panel. From
531 * this we can determine what is attached to the board - before we have
532 * actually down loaded any code to it.
534 #define ECH_PNLSTATUS 2
535 #define ECH_PNL16PORT 0x20
536 #define ECH_PNLIDMASK 0x07
537 #define ECH_PNLXPID 0x40
538 #define ECH_PNLINTRPEND 0x80
541 * Define some macros to do things to the board. Even those these boards
542 * are somewhat related there is often significantly different ways of
543 * doing some operation on it (like enable, paging, reset, etc). So each
544 * board class has a set of functions which do the commonly required
545 * operations. The macros below basically just call these functions,
546 * generally checking for a NULL function - which means that the board
547 * needs nothing done to it to achieve this operation!
549 #define EBRDINIT(brdp) \
550 if (brdp->init != NULL) \
553 #define EBRDENABLE(brdp) \
554 if (brdp->enable != NULL) \
555 (* brdp->enable)(brdp);
557 #define EBRDDISABLE(brdp) \
558 if (brdp->disable != NULL) \
559 (* brdp->disable)(brdp);
561 #define EBRDINTR(brdp) \
562 if (brdp->intr != NULL) \
563 (* brdp->intr)(brdp);
565 #define EBRDRESET(brdp) \
566 if (brdp->reset != NULL) \
567 (* brdp->reset)(brdp);
569 #define EBRDGETMEMPTR(brdp,offset) \
570 (* brdp->getmemptr)(brdp, offset, __LINE__)
573 * Define the maximal baud rate, and the default baud base for ports.
575 #define STL_MAXBAUD 460800
576 #define STL_BAUDBASE 115200
577 #define STL_CLOSEDELAY (5 * HZ / 10)
579 /*****************************************************************************/
582 * Define macros to extract a brd or port number from a minor number.
584 #define MINOR2BRD(min) (((min) & 0xc0) >> 6)
585 #define MINOR2PORT(min) ((min) & 0x3f)
587 /*****************************************************************************/
590 * Prototype all functions in this driver!
593 static int stli_parsebrd(struct stlconf
*confp
, char **argp
);
594 static int stli_init(void);
595 static int stli_open(struct tty_struct
*tty
, struct file
*filp
);
596 static void stli_close(struct tty_struct
*tty
, struct file
*filp
);
597 static int stli_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
);
598 static void stli_putchar(struct tty_struct
*tty
, unsigned char ch
);
599 static void stli_flushchars(struct tty_struct
*tty
);
600 static int stli_writeroom(struct tty_struct
*tty
);
601 static int stli_charsinbuffer(struct tty_struct
*tty
);
602 static int stli_ioctl(struct tty_struct
*tty
, struct file
*file
, unsigned int cmd
, unsigned long arg
);
603 static void stli_settermios(struct tty_struct
*tty
, struct ktermios
*old
);
604 static void stli_throttle(struct tty_struct
*tty
);
605 static void stli_unthrottle(struct tty_struct
*tty
);
606 static void stli_stop(struct tty_struct
*tty
);
607 static void stli_start(struct tty_struct
*tty
);
608 static void stli_flushbuffer(struct tty_struct
*tty
);
609 static void stli_breakctl(struct tty_struct
*tty
, int state
);
610 static void stli_waituntilsent(struct tty_struct
*tty
, int timeout
);
611 static void stli_sendxchar(struct tty_struct
*tty
, char ch
);
612 static void stli_hangup(struct tty_struct
*tty
);
613 static int stli_portinfo(struct stlibrd
*brdp
, struct stliport
*portp
, int portnr
, char *pos
);
615 static int stli_brdinit(struct stlibrd
*brdp
);
616 static int stli_startbrd(struct stlibrd
*brdp
);
617 static ssize_t
stli_memread(struct file
*fp
, char __user
*buf
, size_t count
, loff_t
*offp
);
618 static ssize_t
stli_memwrite(struct file
*fp
, const char __user
*buf
, size_t count
, loff_t
*offp
);
619 static int stli_memioctl(struct inode
*ip
, struct file
*fp
, unsigned int cmd
, unsigned long arg
);
620 static void stli_brdpoll(struct stlibrd
*brdp
, cdkhdr_t __iomem
*hdrp
);
621 static void stli_poll(unsigned long arg
);
622 static int stli_hostcmd(struct stlibrd
*brdp
, struct stliport
*portp
);
623 static int stli_initopen(struct stlibrd
*brdp
, struct stliport
*portp
);
624 static int stli_rawopen(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long arg
, int wait
);
625 static int stli_rawclose(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long arg
, int wait
);
626 static int stli_waitcarrier(struct stlibrd
*brdp
, struct stliport
*portp
, struct file
*filp
);
627 static void stli_dohangup(struct work_struct
*);
628 static int stli_setport(struct stliport
*portp
);
629 static int stli_cmdwait(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long cmd
, void *arg
, int size
, int copyback
);
630 static void stli_sendcmd(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long cmd
, void *arg
, int size
, int copyback
);
631 static void __stli_sendcmd(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long cmd
, void *arg
, int size
, int copyback
);
632 static void stli_dodelaycmd(struct stliport
*portp
, cdkctrl_t __iomem
*cp
);
633 static void stli_mkasyport(struct stliport
*portp
, asyport_t
*pp
, struct ktermios
*tiosp
);
634 static void stli_mkasysigs(asysigs_t
*sp
, int dtr
, int rts
);
635 static long stli_mktiocm(unsigned long sigvalue
);
636 static void stli_read(struct stlibrd
*brdp
, struct stliport
*portp
);
637 static int stli_getserial(struct stliport
*portp
, struct serial_struct __user
*sp
);
638 static int stli_setserial(struct stliport
*portp
, struct serial_struct __user
*sp
);
639 static int stli_getbrdstats(combrd_t __user
*bp
);
640 static int stli_getportstats(struct stliport
*portp
, comstats_t __user
*cp
);
641 static int stli_portcmdstats(struct stliport
*portp
);
642 static int stli_clrportstats(struct stliport
*portp
, comstats_t __user
*cp
);
643 static int stli_getportstruct(struct stliport __user
*arg
);
644 static int stli_getbrdstruct(struct stlibrd __user
*arg
);
645 static struct stlibrd
*stli_allocbrd(void);
647 static void stli_ecpinit(struct stlibrd
*brdp
);
648 static void stli_ecpenable(struct stlibrd
*brdp
);
649 static void stli_ecpdisable(struct stlibrd
*brdp
);
650 static void __iomem
*stli_ecpgetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
);
651 static void stli_ecpreset(struct stlibrd
*brdp
);
652 static void stli_ecpintr(struct stlibrd
*brdp
);
653 static void stli_ecpeiinit(struct stlibrd
*brdp
);
654 static void stli_ecpeienable(struct stlibrd
*brdp
);
655 static void stli_ecpeidisable(struct stlibrd
*brdp
);
656 static void __iomem
*stli_ecpeigetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
);
657 static void stli_ecpeireset(struct stlibrd
*brdp
);
658 static void stli_ecpmcenable(struct stlibrd
*brdp
);
659 static void stli_ecpmcdisable(struct stlibrd
*brdp
);
660 static void __iomem
*stli_ecpmcgetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
);
661 static void stli_ecpmcreset(struct stlibrd
*brdp
);
662 static void stli_ecppciinit(struct stlibrd
*brdp
);
663 static void __iomem
*stli_ecppcigetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
);
664 static void stli_ecppcireset(struct stlibrd
*brdp
);
666 static void stli_onbinit(struct stlibrd
*brdp
);
667 static void stli_onbenable(struct stlibrd
*brdp
);
668 static void stli_onbdisable(struct stlibrd
*brdp
);
669 static void __iomem
*stli_onbgetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
);
670 static void stli_onbreset(struct stlibrd
*brdp
);
671 static void stli_onbeinit(struct stlibrd
*brdp
);
672 static void stli_onbeenable(struct stlibrd
*brdp
);
673 static void stli_onbedisable(struct stlibrd
*brdp
);
674 static void __iomem
*stli_onbegetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
);
675 static void stli_onbereset(struct stlibrd
*brdp
);
676 static void stli_bbyinit(struct stlibrd
*brdp
);
677 static void __iomem
*stli_bbygetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
);
678 static void stli_bbyreset(struct stlibrd
*brdp
);
679 static void stli_stalinit(struct stlibrd
*brdp
);
680 static void __iomem
*stli_stalgetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
);
681 static void stli_stalreset(struct stlibrd
*brdp
);
683 static struct stliport
*stli_getport(unsigned int brdnr
, unsigned int panelnr
, unsigned int portnr
);
685 static int stli_initecp(struct stlibrd
*brdp
);
686 static int stli_initonb(struct stlibrd
*brdp
);
687 static int stli_eisamemprobe(struct stlibrd
*brdp
);
688 static int stli_initports(struct stlibrd
*brdp
);
690 /*****************************************************************************/
693 * Define the driver info for a user level shared memory device. This
694 * device will work sort of like the /dev/kmem device - except that it
695 * will give access to the shared memory on the Stallion intelligent
696 * board. This is also a very useful debugging tool.
698 static const struct file_operations stli_fsiomem
= {
699 .owner
= THIS_MODULE
,
700 .read
= stli_memread
,
701 .write
= stli_memwrite
,
702 .ioctl
= stli_memioctl
,
705 /*****************************************************************************/
708 * Define a timer_list entry for our poll routine. The slave board
709 * is polled every so often to see if anything needs doing. This is
710 * much cheaper on host cpu than using interrupts. It turns out to
711 * not increase character latency by much either...
713 static DEFINE_TIMER(stli_timerlist
, stli_poll
, 0, 0);
715 static int stli_timeron
;
718 * Define the calculation for the timeout routine.
720 #define STLI_TIMEOUT (jiffies + 1)
722 /*****************************************************************************/
724 static struct class *istallion_class
;
726 static void stli_cleanup_ports(struct stlibrd
*brdp
)
728 struct stliport
*portp
;
731 for (j
= 0; j
< STL_MAXPORTS
; j
++) {
732 portp
= brdp
->ports
[j
];
734 if (portp
->tty
!= NULL
)
735 tty_hangup(portp
->tty
);
742 * Loadable module initialization stuff.
745 static int __init
istallion_module_init(void)
751 /*****************************************************************************/
753 static void __exit
istallion_module_exit(void)
755 struct stlibrd
*brdp
;
759 printk(KERN_INFO
"Unloading %s: version %s\n", stli_drvtitle
,
762 pci_unregister_driver(&stli_pcidriver
);
764 * Free up all allocated resources used by the ports. This includes
765 * memory and interrupts.
769 del_timer_sync(&stli_timerlist
);
772 i
= tty_unregister_driver(stli_serial
);
774 printk("STALLION: failed to un-register tty driver, "
778 put_tty_driver(stli_serial
);
779 for (j
= 0; j
< 4; j
++)
780 class_device_destroy(istallion_class
, MKDEV(STL_SIOMEMMAJOR
, j
));
781 class_destroy(istallion_class
);
782 if ((i
= unregister_chrdev(STL_SIOMEMMAJOR
, "staliomem")))
783 printk("STALLION: failed to un-register serial memory device, "
786 kfree(stli_txcookbuf
);
788 for (j
= 0; (j
< stli_nrbrds
); j
++) {
789 if ((brdp
= stli_brds
[j
]) == NULL
)
792 stli_cleanup_ports(brdp
);
794 iounmap(brdp
->membase
);
795 if (brdp
->iosize
> 0)
796 release_region(brdp
->iobase
, brdp
->iosize
);
802 module_init(istallion_module_init
);
803 module_exit(istallion_module_exit
);
805 /*****************************************************************************/
808 * Parse the supplied argument string, into the board conf struct.
811 static int stli_parsebrd(struct stlconf
*confp
, char **argp
)
816 if (argp
[0] == NULL
|| *argp
[0] == 0)
819 for (sp
= argp
[0], i
= 0; ((*sp
!= 0) && (i
< 25)); sp
++, i
++)
822 for (i
= 0; i
< ARRAY_SIZE(stli_brdstr
); i
++) {
823 if (strcmp(stli_brdstr
[i
].name
, argp
[0]) == 0)
826 if (i
== ARRAY_SIZE(stli_brdstr
)) {
827 printk("STALLION: unknown board name, %s?\n", argp
[0]);
831 confp
->brdtype
= stli_brdstr
[i
].type
;
832 if (argp
[1] != NULL
&& *argp
[1] != 0)
833 confp
->ioaddr1
= simple_strtoul(argp
[1], NULL
, 0);
834 if (argp
[2] != NULL
&& *argp
[2] != 0)
835 confp
->memaddr
= simple_strtoul(argp
[2], NULL
, 0);
839 /*****************************************************************************/
841 static int stli_open(struct tty_struct
*tty
, struct file
*filp
)
843 struct stlibrd
*brdp
;
844 struct stliport
*portp
;
845 unsigned int minordev
, brdnr
, portnr
;
848 minordev
= tty
->index
;
849 brdnr
= MINOR2BRD(minordev
);
850 if (brdnr
>= stli_nrbrds
)
852 brdp
= stli_brds
[brdnr
];
855 if ((brdp
->state
& BST_STARTED
) == 0)
857 portnr
= MINOR2PORT(minordev
);
858 if (portnr
> brdp
->nrports
)
861 portp
= brdp
->ports
[portnr
];
864 if (portp
->devnr
< 1)
869 * Check if this port is in the middle of closing. If so then wait
870 * until it is closed then return error status based on flag settings.
871 * The sleep here does not need interrupt protection since the wakeup
872 * for it is done with the same context.
874 if (portp
->flags
& ASYNC_CLOSING
) {
875 interruptible_sleep_on(&portp
->close_wait
);
876 if (portp
->flags
& ASYNC_HUP_NOTIFY
)
882 * On the first open of the device setup the port hardware, and
883 * initialize the per port data structure. Since initializing the port
884 * requires several commands to the board we will need to wait for any
885 * other open that is already initializing the port.
888 tty
->driver_data
= portp
;
891 wait_event_interruptible(portp
->raw_wait
,
892 !test_bit(ST_INITIALIZING
, &portp
->state
));
893 if (signal_pending(current
))
896 if ((portp
->flags
& ASYNC_INITIALIZED
) == 0) {
897 set_bit(ST_INITIALIZING
, &portp
->state
);
898 if ((rc
= stli_initopen(brdp
, portp
)) >= 0) {
899 portp
->flags
|= ASYNC_INITIALIZED
;
900 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
902 clear_bit(ST_INITIALIZING
, &portp
->state
);
903 wake_up_interruptible(&portp
->raw_wait
);
909 * Check if this port is in the middle of closing. If so then wait
910 * until it is closed then return error status, based on flag settings.
911 * The sleep here does not need interrupt protection since the wakeup
912 * for it is done with the same context.
914 if (portp
->flags
& ASYNC_CLOSING
) {
915 interruptible_sleep_on(&portp
->close_wait
);
916 if (portp
->flags
& ASYNC_HUP_NOTIFY
)
922 * Based on type of open being done check if it can overlap with any
923 * previous opens still in effect. If we are a normal serial device
924 * then also we might have to wait for carrier.
926 if (!(filp
->f_flags
& O_NONBLOCK
)) {
927 if ((rc
= stli_waitcarrier(brdp
, portp
, filp
)) != 0)
930 portp
->flags
|= ASYNC_NORMAL_ACTIVE
;
934 /*****************************************************************************/
936 static void stli_close(struct tty_struct
*tty
, struct file
*filp
)
938 struct stlibrd
*brdp
;
939 struct stliport
*portp
;
942 portp
= tty
->driver_data
;
946 spin_lock_irqsave(&stli_lock
, flags
);
947 if (tty_hung_up_p(filp
)) {
948 spin_unlock_irqrestore(&stli_lock
, flags
);
951 if ((tty
->count
== 1) && (portp
->refcount
!= 1))
953 if (portp
->refcount
-- > 1) {
954 spin_unlock_irqrestore(&stli_lock
, flags
);
958 portp
->flags
|= ASYNC_CLOSING
;
961 * May want to wait for data to drain before closing. The BUSY flag
962 * keeps track of whether we are still transmitting or not. It is
963 * updated by messages from the slave - indicating when all chars
964 * really have drained.
966 if (tty
== stli_txcooktty
)
967 stli_flushchars(tty
);
969 spin_unlock_irqrestore(&stli_lock
, flags
);
971 if (portp
->closing_wait
!= ASYNC_CLOSING_WAIT_NONE
)
972 tty_wait_until_sent(tty
, portp
->closing_wait
);
974 portp
->flags
&= ~ASYNC_INITIALIZED
;
975 brdp
= stli_brds
[portp
->brdnr
];
976 stli_rawclose(brdp
, portp
, 0, 0);
977 if (tty
->termios
->c_cflag
& HUPCL
) {
978 stli_mkasysigs(&portp
->asig
, 0, 0);
979 if (test_bit(ST_CMDING
, &portp
->state
))
980 set_bit(ST_DOSIGS
, &portp
->state
);
982 stli_sendcmd(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
983 sizeof(asysigs_t
), 0);
985 clear_bit(ST_TXBUSY
, &portp
->state
);
986 clear_bit(ST_RXSTOP
, &portp
->state
);
987 set_bit(TTY_IO_ERROR
, &tty
->flags
);
988 if (tty
->ldisc
.flush_buffer
)
989 (tty
->ldisc
.flush_buffer
)(tty
);
990 set_bit(ST_DOFLUSHRX
, &portp
->state
);
991 stli_flushbuffer(tty
);
996 if (portp
->openwaitcnt
) {
997 if (portp
->close_delay
)
998 msleep_interruptible(jiffies_to_msecs(portp
->close_delay
));
999 wake_up_interruptible(&portp
->open_wait
);
1002 portp
->flags
&= ~(ASYNC_NORMAL_ACTIVE
|ASYNC_CLOSING
);
1003 wake_up_interruptible(&portp
->close_wait
);
1006 /*****************************************************************************/
1009 * Carry out first open operations on a port. This involves a number of
1010 * commands to be sent to the slave. We need to open the port, set the
1011 * notification events, set the initial port settings, get and set the
1012 * initial signal values. We sleep and wait in between each one. But
1013 * this still all happens pretty quickly.
1016 static int stli_initopen(struct stlibrd
*brdp
, struct stliport
*portp
)
1018 struct tty_struct
*tty
;
1023 if ((rc
= stli_rawopen(brdp
, portp
, 0, 1)) < 0)
1026 memset(&nt
, 0, sizeof(asynotify_t
));
1027 nt
.data
= (DT_TXLOW
| DT_TXEMPTY
| DT_RXBUSY
| DT_RXBREAK
);
1029 if ((rc
= stli_cmdwait(brdp
, portp
, A_SETNOTIFY
, &nt
,
1030 sizeof(asynotify_t
), 0)) < 0)
1036 stli_mkasyport(portp
, &aport
, tty
->termios
);
1037 if ((rc
= stli_cmdwait(brdp
, portp
, A_SETPORT
, &aport
,
1038 sizeof(asyport_t
), 0)) < 0)
1041 set_bit(ST_GETSIGS
, &portp
->state
);
1042 if ((rc
= stli_cmdwait(brdp
, portp
, A_GETSIGNALS
, &portp
->asig
,
1043 sizeof(asysigs_t
), 1)) < 0)
1045 if (test_and_clear_bit(ST_GETSIGS
, &portp
->state
))
1046 portp
->sigs
= stli_mktiocm(portp
->asig
.sigvalue
);
1047 stli_mkasysigs(&portp
->asig
, 1, 1);
1048 if ((rc
= stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1049 sizeof(asysigs_t
), 0)) < 0)
1055 /*****************************************************************************/
1058 * Send an open message to the slave. This will sleep waiting for the
1059 * acknowledgement, so must have user context. We need to co-ordinate
1060 * with close events here, since we don't want open and close events
1064 static int stli_rawopen(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long arg
, int wait
)
1066 cdkhdr_t __iomem
*hdrp
;
1067 cdkctrl_t __iomem
*cp
;
1068 unsigned char __iomem
*bits
;
1069 unsigned long flags
;
1073 * Send a message to the slave to open this port.
1077 * Slave is already closing this port. This can happen if a hangup
1078 * occurs on this port. So we must wait until it is complete. The
1079 * order of opens and closes may not be preserved across shared
1080 * memory, so we must wait until it is complete.
1082 wait_event_interruptible(portp
->raw_wait
,
1083 !test_bit(ST_CLOSING
, &portp
->state
));
1084 if (signal_pending(current
)) {
1085 return -ERESTARTSYS
;
1089 * Everything is ready now, so write the open message into shared
1090 * memory. Once the message is in set the service bits to say that
1091 * this port wants service.
1093 spin_lock_irqsave(&brd_lock
, flags
);
1095 cp
= &((cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->ctrl
;
1096 writel(arg
, &cp
->openarg
);
1097 writeb(1, &cp
->open
);
1098 hdrp
= (cdkhdr_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
1099 bits
= ((unsigned char __iomem
*) hdrp
) + brdp
->slaveoffset
+
1101 writeb(readb(bits
) | portp
->portbit
, bits
);
1105 spin_unlock_irqrestore(&brd_lock
, flags
);
1110 * Slave is in action, so now we must wait for the open acknowledgment
1114 set_bit(ST_OPENING
, &portp
->state
);
1115 spin_unlock_irqrestore(&brd_lock
, flags
);
1117 wait_event_interruptible(portp
->raw_wait
,
1118 !test_bit(ST_OPENING
, &portp
->state
));
1119 if (signal_pending(current
))
1122 if ((rc
== 0) && (portp
->rc
!= 0))
1127 /*****************************************************************************/
1130 * Send a close message to the slave. Normally this will sleep waiting
1131 * for the acknowledgement, but if wait parameter is 0 it will not. If
1132 * wait is true then must have user context (to sleep).
1135 static int stli_rawclose(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long arg
, int wait
)
1137 cdkhdr_t __iomem
*hdrp
;
1138 cdkctrl_t __iomem
*cp
;
1139 unsigned char __iomem
*bits
;
1140 unsigned long flags
;
1144 * Slave is already closing this port. This can happen if a hangup
1145 * occurs on this port.
1148 wait_event_interruptible(portp
->raw_wait
,
1149 !test_bit(ST_CLOSING
, &portp
->state
));
1150 if (signal_pending(current
)) {
1151 return -ERESTARTSYS
;
1156 * Write the close command into shared memory.
1158 spin_lock_irqsave(&brd_lock
, flags
);
1160 cp
= &((cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->ctrl
;
1161 writel(arg
, &cp
->closearg
);
1162 writeb(1, &cp
->close
);
1163 hdrp
= (cdkhdr_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
1164 bits
= ((unsigned char __iomem
*) hdrp
) + brdp
->slaveoffset
+
1166 writeb(readb(bits
) |portp
->portbit
, bits
);
1169 set_bit(ST_CLOSING
, &portp
->state
);
1170 spin_unlock_irqrestore(&brd_lock
, flags
);
1176 * Slave is in action, so now we must wait for the open acknowledgment
1180 wait_event_interruptible(portp
->raw_wait
,
1181 !test_bit(ST_CLOSING
, &portp
->state
));
1182 if (signal_pending(current
))
1185 if ((rc
== 0) && (portp
->rc
!= 0))
1190 /*****************************************************************************/
1193 * Send a command to the slave and wait for the response. This must
1194 * have user context (it sleeps). This routine is generic in that it
1195 * can send any type of command. Its purpose is to wait for that command
1196 * to complete (as opposed to initiating the command then returning).
1199 static int stli_cmdwait(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long cmd
, void *arg
, int size
, int copyback
)
1201 wait_event_interruptible(portp
->raw_wait
,
1202 !test_bit(ST_CMDING
, &portp
->state
));
1203 if (signal_pending(current
))
1204 return -ERESTARTSYS
;
1206 stli_sendcmd(brdp
, portp
, cmd
, arg
, size
, copyback
);
1208 wait_event_interruptible(portp
->raw_wait
,
1209 !test_bit(ST_CMDING
, &portp
->state
));
1210 if (signal_pending(current
))
1211 return -ERESTARTSYS
;
1218 /*****************************************************************************/
1221 * Send the termios settings for this port to the slave. This sleeps
1222 * waiting for the command to complete - so must have user context.
1225 static int stli_setport(struct stliport
*portp
)
1227 struct stlibrd
*brdp
;
1232 if (portp
->tty
== NULL
)
1234 if (portp
->brdnr
>= stli_nrbrds
)
1236 brdp
= stli_brds
[portp
->brdnr
];
1240 stli_mkasyport(portp
, &aport
, portp
->tty
->termios
);
1241 return(stli_cmdwait(brdp
, portp
, A_SETPORT
, &aport
, sizeof(asyport_t
), 0));
1244 /*****************************************************************************/
1247 * Possibly need to wait for carrier (DCD signal) to come high. Say
1248 * maybe because if we are clocal then we don't need to wait...
1251 static int stli_waitcarrier(struct stlibrd
*brdp
, struct stliport
*portp
, struct file
*filp
)
1253 unsigned long flags
;
1259 if (portp
->tty
->termios
->c_cflag
& CLOCAL
)
1262 spin_lock_irqsave(&stli_lock
, flags
);
1263 portp
->openwaitcnt
++;
1264 if (! tty_hung_up_p(filp
))
1266 spin_unlock_irqrestore(&stli_lock
, flags
);
1269 stli_mkasysigs(&portp
->asig
, 1, 1);
1270 if ((rc
= stli_cmdwait(brdp
, portp
, A_SETSIGNALS
,
1271 &portp
->asig
, sizeof(asysigs_t
), 0)) < 0)
1273 if (tty_hung_up_p(filp
) ||
1274 ((portp
->flags
& ASYNC_INITIALIZED
) == 0)) {
1275 if (portp
->flags
& ASYNC_HUP_NOTIFY
)
1281 if (((portp
->flags
& ASYNC_CLOSING
) == 0) &&
1282 (doclocal
|| (portp
->sigs
& TIOCM_CD
))) {
1285 if (signal_pending(current
)) {
1289 interruptible_sleep_on(&portp
->open_wait
);
1292 spin_lock_irqsave(&stli_lock
, flags
);
1293 if (! tty_hung_up_p(filp
))
1295 portp
->openwaitcnt
--;
1296 spin_unlock_irqrestore(&stli_lock
, flags
);
1301 /*****************************************************************************/
1304 * Write routine. Take the data and put it in the shared memory ring
1305 * queue. If port is not already sending chars then need to mark the
1306 * service bits for this port.
1309 static int stli_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
1311 cdkasy_t __iomem
*ap
;
1312 cdkhdr_t __iomem
*hdrp
;
1313 unsigned char __iomem
*bits
;
1314 unsigned char __iomem
*shbuf
;
1315 unsigned char *chbuf
;
1316 struct stliport
*portp
;
1317 struct stlibrd
*brdp
;
1318 unsigned int len
, stlen
, head
, tail
, size
;
1319 unsigned long flags
;
1321 if (tty
== stli_txcooktty
)
1322 stli_flushchars(tty
);
1323 portp
= tty
->driver_data
;
1326 if (portp
->brdnr
>= stli_nrbrds
)
1328 brdp
= stli_brds
[portp
->brdnr
];
1331 chbuf
= (unsigned char *) buf
;
1334 * All data is now local, shove as much as possible into shared memory.
1336 spin_lock_irqsave(&brd_lock
, flags
);
1338 ap
= (cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
1339 head
= (unsigned int) readw(&ap
->txq
.head
);
1340 tail
= (unsigned int) readw(&ap
->txq
.tail
);
1341 if (tail
!= ((unsigned int) readw(&ap
->txq
.tail
)))
1342 tail
= (unsigned int) readw(&ap
->txq
.tail
);
1343 size
= portp
->txsize
;
1345 len
= size
- (head
- tail
) - 1;
1346 stlen
= size
- head
;
1348 len
= tail
- head
- 1;
1352 len
= min(len
, (unsigned int)count
);
1354 shbuf
= (char __iomem
*) EBRDGETMEMPTR(brdp
, portp
->txoffset
);
1357 stlen
= min(len
, stlen
);
1358 memcpy_toio(shbuf
+ head
, chbuf
, stlen
);
1369 ap
= (cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
1370 writew(head
, &ap
->txq
.head
);
1371 if (test_bit(ST_TXBUSY
, &portp
->state
)) {
1372 if (readl(&ap
->changed
.data
) & DT_TXEMPTY
)
1373 writel(readl(&ap
->changed
.data
) & ~DT_TXEMPTY
, &ap
->changed
.data
);
1375 hdrp
= (cdkhdr_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
1376 bits
= ((unsigned char __iomem
*) hdrp
) + brdp
->slaveoffset
+
1378 writeb(readb(bits
) | portp
->portbit
, bits
);
1379 set_bit(ST_TXBUSY
, &portp
->state
);
1381 spin_unlock_irqrestore(&brd_lock
, flags
);
1386 /*****************************************************************************/
1389 * Output a single character. We put it into a temporary local buffer
1390 * (for speed) then write out that buffer when the flushchars routine
1391 * is called. There is a safety catch here so that if some other port
1392 * writes chars before the current buffer has been, then we write them
1393 * first them do the new ports.
1396 static void stli_putchar(struct tty_struct
*tty
, unsigned char ch
)
1398 if (tty
!= stli_txcooktty
) {
1399 if (stli_txcooktty
!= NULL
)
1400 stli_flushchars(stli_txcooktty
);
1401 stli_txcooktty
= tty
;
1404 stli_txcookbuf
[stli_txcooksize
++] = ch
;
1407 /*****************************************************************************/
1410 * Transfer characters from the local TX cooking buffer to the board.
1411 * We sort of ignore the tty that gets passed in here. We rely on the
1412 * info stored with the TX cook buffer to tell us which port to flush
1413 * the data on. In any case we clean out the TX cook buffer, for re-use
1417 static void stli_flushchars(struct tty_struct
*tty
)
1419 cdkhdr_t __iomem
*hdrp
;
1420 unsigned char __iomem
*bits
;
1421 cdkasy_t __iomem
*ap
;
1422 struct tty_struct
*cooktty
;
1423 struct stliport
*portp
;
1424 struct stlibrd
*brdp
;
1425 unsigned int len
, stlen
, head
, tail
, size
, count
, cooksize
;
1427 unsigned char __iomem
*shbuf
;
1428 unsigned long flags
;
1430 cooksize
= stli_txcooksize
;
1431 cooktty
= stli_txcooktty
;
1432 stli_txcooksize
= 0;
1433 stli_txcookrealsize
= 0;
1434 stli_txcooktty
= NULL
;
1438 if (cooktty
== NULL
)
1445 portp
= tty
->driver_data
;
1448 if (portp
->brdnr
>= stli_nrbrds
)
1450 brdp
= stli_brds
[portp
->brdnr
];
1454 spin_lock_irqsave(&brd_lock
, flags
);
1457 ap
= (cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
1458 head
= (unsigned int) readw(&ap
->txq
.head
);
1459 tail
= (unsigned int) readw(&ap
->txq
.tail
);
1460 if (tail
!= ((unsigned int) readw(&ap
->txq
.tail
)))
1461 tail
= (unsigned int) readw(&ap
->txq
.tail
);
1462 size
= portp
->txsize
;
1464 len
= size
- (head
- tail
) - 1;
1465 stlen
= size
- head
;
1467 len
= tail
- head
- 1;
1471 len
= min(len
, cooksize
);
1473 shbuf
= EBRDGETMEMPTR(brdp
, portp
->txoffset
);
1474 buf
= stli_txcookbuf
;
1477 stlen
= min(len
, stlen
);
1478 memcpy_toio(shbuf
+ head
, buf
, stlen
);
1489 ap
= (cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
1490 writew(head
, &ap
->txq
.head
);
1492 if (test_bit(ST_TXBUSY
, &portp
->state
)) {
1493 if (readl(&ap
->changed
.data
) & DT_TXEMPTY
)
1494 writel(readl(&ap
->changed
.data
) & ~DT_TXEMPTY
, &ap
->changed
.data
);
1496 hdrp
= (cdkhdr_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
1497 bits
= ((unsigned char __iomem
*) hdrp
) + brdp
->slaveoffset
+
1499 writeb(readb(bits
) | portp
->portbit
, bits
);
1500 set_bit(ST_TXBUSY
, &portp
->state
);
1503 spin_unlock_irqrestore(&brd_lock
, flags
);
1506 /*****************************************************************************/
1508 static int stli_writeroom(struct tty_struct
*tty
)
1510 cdkasyrq_t __iomem
*rp
;
1511 struct stliport
*portp
;
1512 struct stlibrd
*brdp
;
1513 unsigned int head
, tail
, len
;
1514 unsigned long flags
;
1516 if (tty
== stli_txcooktty
) {
1517 if (stli_txcookrealsize
!= 0) {
1518 len
= stli_txcookrealsize
- stli_txcooksize
;
1523 portp
= tty
->driver_data
;
1526 if (portp
->brdnr
>= stli_nrbrds
)
1528 brdp
= stli_brds
[portp
->brdnr
];
1532 spin_lock_irqsave(&brd_lock
, flags
);
1534 rp
= &((cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->txq
;
1535 head
= (unsigned int) readw(&rp
->head
);
1536 tail
= (unsigned int) readw(&rp
->tail
);
1537 if (tail
!= ((unsigned int) readw(&rp
->tail
)))
1538 tail
= (unsigned int) readw(&rp
->tail
);
1539 len
= (head
>= tail
) ? (portp
->txsize
- (head
- tail
)) : (tail
- head
);
1542 spin_unlock_irqrestore(&brd_lock
, flags
);
1544 if (tty
== stli_txcooktty
) {
1545 stli_txcookrealsize
= len
;
1546 len
-= stli_txcooksize
;
1551 /*****************************************************************************/
1554 * Return the number of characters in the transmit buffer. Normally we
1555 * will return the number of chars in the shared memory ring queue.
1556 * We need to kludge around the case where the shared memory buffer is
1557 * empty but not all characters have drained yet, for this case just
1558 * return that there is 1 character in the buffer!
1561 static int stli_charsinbuffer(struct tty_struct
*tty
)
1563 cdkasyrq_t __iomem
*rp
;
1564 struct stliport
*portp
;
1565 struct stlibrd
*brdp
;
1566 unsigned int head
, tail
, len
;
1567 unsigned long flags
;
1569 if (tty
== stli_txcooktty
)
1570 stli_flushchars(tty
);
1571 portp
= tty
->driver_data
;
1574 if (portp
->brdnr
>= stli_nrbrds
)
1576 brdp
= stli_brds
[portp
->brdnr
];
1580 spin_lock_irqsave(&brd_lock
, flags
);
1582 rp
= &((cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->txq
;
1583 head
= (unsigned int) readw(&rp
->head
);
1584 tail
= (unsigned int) readw(&rp
->tail
);
1585 if (tail
!= ((unsigned int) readw(&rp
->tail
)))
1586 tail
= (unsigned int) readw(&rp
->tail
);
1587 len
= (head
>= tail
) ? (head
- tail
) : (portp
->txsize
- (tail
- head
));
1588 if ((len
== 0) && test_bit(ST_TXBUSY
, &portp
->state
))
1591 spin_unlock_irqrestore(&brd_lock
, flags
);
1596 /*****************************************************************************/
1599 * Generate the serial struct info.
1602 static int stli_getserial(struct stliport
*portp
, struct serial_struct __user
*sp
)
1604 struct serial_struct sio
;
1605 struct stlibrd
*brdp
;
1607 memset(&sio
, 0, sizeof(struct serial_struct
));
1608 sio
.type
= PORT_UNKNOWN
;
1609 sio
.line
= portp
->portnr
;
1611 sio
.flags
= portp
->flags
;
1612 sio
.baud_base
= portp
->baud_base
;
1613 sio
.close_delay
= portp
->close_delay
;
1614 sio
.closing_wait
= portp
->closing_wait
;
1615 sio
.custom_divisor
= portp
->custom_divisor
;
1616 sio
.xmit_fifo_size
= 0;
1619 brdp
= stli_brds
[portp
->brdnr
];
1621 sio
.port
= brdp
->iobase
;
1623 return copy_to_user(sp
, &sio
, sizeof(struct serial_struct
)) ?
1627 /*****************************************************************************/
1630 * Set port according to the serial struct info.
1631 * At this point we do not do any auto-configure stuff, so we will
1632 * just quietly ignore any requests to change irq, etc.
1635 static int stli_setserial(struct stliport
*portp
, struct serial_struct __user
*sp
)
1637 struct serial_struct sio
;
1640 if (copy_from_user(&sio
, sp
, sizeof(struct serial_struct
)))
1642 if (!capable(CAP_SYS_ADMIN
)) {
1643 if ((sio
.baud_base
!= portp
->baud_base
) ||
1644 (sio
.close_delay
!= portp
->close_delay
) ||
1645 ((sio
.flags
& ~ASYNC_USR_MASK
) !=
1646 (portp
->flags
& ~ASYNC_USR_MASK
)))
1650 portp
->flags
= (portp
->flags
& ~ASYNC_USR_MASK
) |
1651 (sio
.flags
& ASYNC_USR_MASK
);
1652 portp
->baud_base
= sio
.baud_base
;
1653 portp
->close_delay
= sio
.close_delay
;
1654 portp
->closing_wait
= sio
.closing_wait
;
1655 portp
->custom_divisor
= sio
.custom_divisor
;
1657 if ((rc
= stli_setport(portp
)) < 0)
1662 /*****************************************************************************/
1664 static int stli_tiocmget(struct tty_struct
*tty
, struct file
*file
)
1666 struct stliport
*portp
= tty
->driver_data
;
1667 struct stlibrd
*brdp
;
1672 if (portp
->brdnr
>= stli_nrbrds
)
1674 brdp
= stli_brds
[portp
->brdnr
];
1677 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1680 if ((rc
= stli_cmdwait(brdp
, portp
, A_GETSIGNALS
,
1681 &portp
->asig
, sizeof(asysigs_t
), 1)) < 0)
1684 return stli_mktiocm(portp
->asig
.sigvalue
);
1687 static int stli_tiocmset(struct tty_struct
*tty
, struct file
*file
,
1688 unsigned int set
, unsigned int clear
)
1690 struct stliport
*portp
= tty
->driver_data
;
1691 struct stlibrd
*brdp
;
1692 int rts
= -1, dtr
= -1;
1696 if (portp
->brdnr
>= stli_nrbrds
)
1698 brdp
= stli_brds
[portp
->brdnr
];
1701 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1704 if (set
& TIOCM_RTS
)
1706 if (set
& TIOCM_DTR
)
1708 if (clear
& TIOCM_RTS
)
1710 if (clear
& TIOCM_DTR
)
1713 stli_mkasysigs(&portp
->asig
, dtr
, rts
);
1715 return stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1716 sizeof(asysigs_t
), 0);
1719 static int stli_ioctl(struct tty_struct
*tty
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1721 struct stliport
*portp
;
1722 struct stlibrd
*brdp
;
1725 void __user
*argp
= (void __user
*)arg
;
1727 portp
= tty
->driver_data
;
1730 if (portp
->brdnr
>= stli_nrbrds
)
1732 brdp
= stli_brds
[portp
->brdnr
];
1736 if ((cmd
!= TIOCGSERIAL
) && (cmd
!= TIOCSSERIAL
) &&
1737 (cmd
!= COM_GETPORTSTATS
) && (cmd
!= COM_CLRPORTSTATS
)) {
1738 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1746 rc
= put_user(((tty
->termios
->c_cflag
& CLOCAL
) ? 1 : 0),
1747 (unsigned __user
*) arg
);
1750 if ((rc
= get_user(ival
, (unsigned __user
*) arg
)) == 0)
1751 tty
->termios
->c_cflag
=
1752 (tty
->termios
->c_cflag
& ~CLOCAL
) |
1753 (ival
? CLOCAL
: 0);
1756 rc
= stli_getserial(portp
, argp
);
1759 rc
= stli_setserial(portp
, argp
);
1762 rc
= put_user(portp
->pflag
, (unsigned __user
*)argp
);
1765 if ((rc
= get_user(portp
->pflag
, (unsigned __user
*)argp
)) == 0)
1766 stli_setport(portp
);
1768 case COM_GETPORTSTATS
:
1769 rc
= stli_getportstats(portp
, argp
);
1771 case COM_CLRPORTSTATS
:
1772 rc
= stli_clrportstats(portp
, argp
);
1778 case TIOCSERGSTRUCT
:
1779 case TIOCSERGETMULTI
:
1780 case TIOCSERSETMULTI
:
1789 /*****************************************************************************/
1792 * This routine assumes that we have user context and can sleep.
1793 * Looks like it is true for the current ttys implementation..!!
1796 static void stli_settermios(struct tty_struct
*tty
, struct ktermios
*old
)
1798 struct stliport
*portp
;
1799 struct stlibrd
*brdp
;
1800 struct ktermios
*tiosp
;
1805 portp
= tty
->driver_data
;
1808 if (portp
->brdnr
>= stli_nrbrds
)
1810 brdp
= stli_brds
[portp
->brdnr
];
1814 tiosp
= tty
->termios
;
1815 if ((tiosp
->c_cflag
== old
->c_cflag
) &&
1816 (tiosp
->c_iflag
== old
->c_iflag
))
1819 stli_mkasyport(portp
, &aport
, tiosp
);
1820 stli_cmdwait(brdp
, portp
, A_SETPORT
, &aport
, sizeof(asyport_t
), 0);
1821 stli_mkasysigs(&portp
->asig
, ((tiosp
->c_cflag
& CBAUD
) ? 1 : 0), -1);
1822 stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1823 sizeof(asysigs_t
), 0);
1824 if ((old
->c_cflag
& CRTSCTS
) && ((tiosp
->c_cflag
& CRTSCTS
) == 0))
1825 tty
->hw_stopped
= 0;
1826 if (((old
->c_cflag
& CLOCAL
) == 0) && (tiosp
->c_cflag
& CLOCAL
))
1827 wake_up_interruptible(&portp
->open_wait
);
1830 /*****************************************************************************/
1833 * Attempt to flow control who ever is sending us data. We won't really
1834 * do any flow control action here. We can't directly, and even if we
1835 * wanted to we would have to send a command to the slave. The slave
1836 * knows how to flow control, and will do so when its buffers reach its
1837 * internal high water marks. So what we will do is set a local state
1838 * bit that will stop us sending any RX data up from the poll routine
1839 * (which is the place where RX data from the slave is handled).
1842 static void stli_throttle(struct tty_struct
*tty
)
1844 struct stliport
*portp
= tty
->driver_data
;
1847 set_bit(ST_RXSTOP
, &portp
->state
);
1850 /*****************************************************************************/
1853 * Unflow control the device sending us data... That means that all
1854 * we have to do is clear the RXSTOP state bit. The next poll call
1855 * will then be able to pass the RX data back up.
1858 static void stli_unthrottle(struct tty_struct
*tty
)
1860 struct stliport
*portp
= tty
->driver_data
;
1863 clear_bit(ST_RXSTOP
, &portp
->state
);
1866 /*****************************************************************************/
1869 * Stop the transmitter.
1872 static void stli_stop(struct tty_struct
*tty
)
1876 /*****************************************************************************/
1879 * Start the transmitter again.
1882 static void stli_start(struct tty_struct
*tty
)
1886 /*****************************************************************************/
1889 * Scheduler called hang up routine. This is called from the scheduler,
1890 * not direct from the driver "poll" routine. We can't call it there
1891 * since the real local hangup code will enable/disable the board and
1892 * other things that we can't do while handling the poll. Much easier
1893 * to deal with it some time later (don't really care when, hangups
1894 * aren't that time critical).
1897 static void stli_dohangup(struct work_struct
*ugly_api
)
1899 struct stliport
*portp
= container_of(ugly_api
, struct stliport
, tqhangup
);
1900 if (portp
->tty
!= NULL
) {
1901 tty_hangup(portp
->tty
);
1905 /*****************************************************************************/
1908 * Hangup this port. This is pretty much like closing the port, only
1909 * a little more brutal. No waiting for data to drain. Shutdown the
1910 * port and maybe drop signals. This is rather tricky really. We want
1911 * to close the port as well.
1914 static void stli_hangup(struct tty_struct
*tty
)
1916 struct stliport
*portp
;
1917 struct stlibrd
*brdp
;
1918 unsigned long flags
;
1920 portp
= tty
->driver_data
;
1923 if (portp
->brdnr
>= stli_nrbrds
)
1925 brdp
= stli_brds
[portp
->brdnr
];
1929 portp
->flags
&= ~ASYNC_INITIALIZED
;
1931 if (!test_bit(ST_CLOSING
, &portp
->state
))
1932 stli_rawclose(brdp
, portp
, 0, 0);
1934 spin_lock_irqsave(&stli_lock
, flags
);
1935 if (tty
->termios
->c_cflag
& HUPCL
) {
1936 stli_mkasysigs(&portp
->asig
, 0, 0);
1937 if (test_bit(ST_CMDING
, &portp
->state
)) {
1938 set_bit(ST_DOSIGS
, &portp
->state
);
1939 set_bit(ST_DOFLUSHTX
, &portp
->state
);
1940 set_bit(ST_DOFLUSHRX
, &portp
->state
);
1942 stli_sendcmd(brdp
, portp
, A_SETSIGNALSF
,
1943 &portp
->asig
, sizeof(asysigs_t
), 0);
1947 clear_bit(ST_TXBUSY
, &portp
->state
);
1948 clear_bit(ST_RXSTOP
, &portp
->state
);
1949 set_bit(TTY_IO_ERROR
, &tty
->flags
);
1951 portp
->flags
&= ~ASYNC_NORMAL_ACTIVE
;
1952 portp
->refcount
= 0;
1953 spin_unlock_irqrestore(&stli_lock
, flags
);
1955 wake_up_interruptible(&portp
->open_wait
);
1958 /*****************************************************************************/
1961 * Flush characters from the lower buffer. We may not have user context
1962 * so we cannot sleep waiting for it to complete. Also we need to check
1963 * if there is chars for this port in the TX cook buffer, and flush them
1967 static void stli_flushbuffer(struct tty_struct
*tty
)
1969 struct stliport
*portp
;
1970 struct stlibrd
*brdp
;
1971 unsigned long ftype
, flags
;
1973 portp
= tty
->driver_data
;
1976 if (portp
->brdnr
>= stli_nrbrds
)
1978 brdp
= stli_brds
[portp
->brdnr
];
1982 spin_lock_irqsave(&brd_lock
, flags
);
1983 if (tty
== stli_txcooktty
) {
1984 stli_txcooktty
= NULL
;
1985 stli_txcooksize
= 0;
1986 stli_txcookrealsize
= 0;
1988 if (test_bit(ST_CMDING
, &portp
->state
)) {
1989 set_bit(ST_DOFLUSHTX
, &portp
->state
);
1992 if (test_bit(ST_DOFLUSHRX
, &portp
->state
)) {
1994 clear_bit(ST_DOFLUSHRX
, &portp
->state
);
1996 __stli_sendcmd(brdp
, portp
, A_FLUSH
, &ftype
, sizeof(u32
), 0);
1998 spin_unlock_irqrestore(&brd_lock
, flags
);
2002 /*****************************************************************************/
2004 static void stli_breakctl(struct tty_struct
*tty
, int state
)
2006 struct stlibrd
*brdp
;
2007 struct stliport
*portp
;
2010 portp
= tty
->driver_data
;
2013 if (portp
->brdnr
>= stli_nrbrds
)
2015 brdp
= stli_brds
[portp
->brdnr
];
2019 arg
= (state
== -1) ? BREAKON
: BREAKOFF
;
2020 stli_cmdwait(brdp
, portp
, A_BREAK
, &arg
, sizeof(long), 0);
2023 /*****************************************************************************/
2025 static void stli_waituntilsent(struct tty_struct
*tty
, int timeout
)
2027 struct stliport
*portp
;
2032 portp
= tty
->driver_data
;
2038 tend
= jiffies
+ timeout
;
2040 while (test_bit(ST_TXBUSY
, &portp
->state
)) {
2041 if (signal_pending(current
))
2043 msleep_interruptible(20);
2044 if (time_after_eq(jiffies
, tend
))
2049 /*****************************************************************************/
2051 static void stli_sendxchar(struct tty_struct
*tty
, char ch
)
2053 struct stlibrd
*brdp
;
2054 struct stliport
*portp
;
2057 portp
= tty
->driver_data
;
2060 if (portp
->brdnr
>= stli_nrbrds
)
2062 brdp
= stli_brds
[portp
->brdnr
];
2066 memset(&actrl
, 0, sizeof(asyctrl_t
));
2067 if (ch
== STOP_CHAR(tty
)) {
2068 actrl
.rxctrl
= CT_STOPFLOW
;
2069 } else if (ch
== START_CHAR(tty
)) {
2070 actrl
.rxctrl
= CT_STARTFLOW
;
2072 actrl
.txctrl
= CT_SENDCHR
;
2075 stli_cmdwait(brdp
, portp
, A_PORTCTRL
, &actrl
, sizeof(asyctrl_t
), 0);
2078 /*****************************************************************************/
2083 * Format info for a specified port. The line is deliberately limited
2084 * to 80 characters. (If it is too long it will be truncated, if too
2085 * short then padded with spaces).
2088 static int stli_portinfo(struct stlibrd
*brdp
, struct stliport
*portp
, int portnr
, char *pos
)
2093 rc
= stli_portcmdstats(portp
);
2096 if (brdp
->state
& BST_STARTED
) {
2097 switch (stli_comstats
.hwid
) {
2098 case 0: uart
= "2681"; break;
2099 case 1: uart
= "SC26198"; break;
2100 default:uart
= "CD1400"; break;
2105 sp
+= sprintf(sp
, "%d: uart:%s ", portnr
, uart
);
2107 if ((brdp
->state
& BST_STARTED
) && (rc
>= 0)) {
2108 sp
+= sprintf(sp
, "tx:%d rx:%d", (int) stli_comstats
.txtotal
,
2109 (int) stli_comstats
.rxtotal
);
2111 if (stli_comstats
.rxframing
)
2112 sp
+= sprintf(sp
, " fe:%d",
2113 (int) stli_comstats
.rxframing
);
2114 if (stli_comstats
.rxparity
)
2115 sp
+= sprintf(sp
, " pe:%d",
2116 (int) stli_comstats
.rxparity
);
2117 if (stli_comstats
.rxbreaks
)
2118 sp
+= sprintf(sp
, " brk:%d",
2119 (int) stli_comstats
.rxbreaks
);
2120 if (stli_comstats
.rxoverrun
)
2121 sp
+= sprintf(sp
, " oe:%d",
2122 (int) stli_comstats
.rxoverrun
);
2124 cnt
= sprintf(sp
, "%s%s%s%s%s ",
2125 (stli_comstats
.signals
& TIOCM_RTS
) ? "|RTS" : "",
2126 (stli_comstats
.signals
& TIOCM_CTS
) ? "|CTS" : "",
2127 (stli_comstats
.signals
& TIOCM_DTR
) ? "|DTR" : "",
2128 (stli_comstats
.signals
& TIOCM_CD
) ? "|DCD" : "",
2129 (stli_comstats
.signals
& TIOCM_DSR
) ? "|DSR" : "");
2134 for (cnt
= (sp
- pos
); (cnt
< (MAXLINE
- 1)); cnt
++)
2137 pos
[(MAXLINE
- 2)] = '+';
2138 pos
[(MAXLINE
- 1)] = '\n';
2143 /*****************************************************************************/
2146 * Port info, read from the /proc file system.
2149 static int stli_readproc(char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
2151 struct stlibrd
*brdp
;
2152 struct stliport
*portp
;
2153 unsigned int brdnr
, portnr
, totalport
;
2162 pos
+= sprintf(pos
, "%s: version %s", stli_drvtitle
,
2164 while (pos
< (page
+ MAXLINE
- 1))
2171 * We scan through for each board, panel and port. The offset is
2172 * calculated on the fly, and irrelevant ports are skipped.
2174 for (brdnr
= 0; (brdnr
< stli_nrbrds
); brdnr
++) {
2175 brdp
= stli_brds
[brdnr
];
2178 if (brdp
->state
== 0)
2181 maxoff
= curoff
+ (brdp
->nrports
* MAXLINE
);
2182 if (off
>= maxoff
) {
2187 totalport
= brdnr
* STL_MAXPORTS
;
2188 for (portnr
= 0; (portnr
< brdp
->nrports
); portnr
++,
2190 portp
= brdp
->ports
[portnr
];
2193 if (off
>= (curoff
+= MAXLINE
))
2195 if ((pos
- page
+ MAXLINE
) > count
)
2197 pos
+= stli_portinfo(brdp
, portp
, totalport
, pos
);
2208 /*****************************************************************************/
2211 * Generic send command routine. This will send a message to the slave,
2212 * of the specified type with the specified argument. Must be very
2213 * careful of data that will be copied out from shared memory -
2214 * containing command results. The command completion is all done from
2215 * a poll routine that does not have user context. Therefore you cannot
2216 * copy back directly into user space, or to the kernel stack of a
2217 * process. This routine does not sleep, so can be called from anywhere.
2219 * The caller must hold the brd_lock (see also stli_sendcmd the usual
2223 static void __stli_sendcmd(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long cmd
, void *arg
, int size
, int copyback
)
2225 cdkhdr_t __iomem
*hdrp
;
2226 cdkctrl_t __iomem
*cp
;
2227 unsigned char __iomem
*bits
;
2228 unsigned long flags
;
2230 spin_lock_irqsave(&brd_lock
, flags
);
2232 if (test_bit(ST_CMDING
, &portp
->state
)) {
2233 printk(KERN_ERR
"STALLION: command already busy, cmd=%x!\n",
2235 spin_unlock_irqrestore(&brd_lock
, flags
);
2240 cp
= &((cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->ctrl
;
2242 memcpy_toio((void __iomem
*) &(cp
->args
[0]), arg
, size
);
2245 portp
->argsize
= size
;
2248 writel(0, &cp
->status
);
2249 writel(cmd
, &cp
->cmd
);
2250 hdrp
= (cdkhdr_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
2251 bits
= ((unsigned char __iomem
*) hdrp
) + brdp
->slaveoffset
+
2253 writeb(readb(bits
) | portp
->portbit
, bits
);
2254 set_bit(ST_CMDING
, &portp
->state
);
2256 spin_unlock_irqrestore(&brd_lock
, flags
);
2259 static void stli_sendcmd(struct stlibrd
*brdp
, struct stliport
*portp
, unsigned long cmd
, void *arg
, int size
, int copyback
)
2261 unsigned long flags
;
2263 spin_lock_irqsave(&brd_lock
, flags
);
2264 __stli_sendcmd(brdp
, portp
, cmd
, arg
, size
, copyback
);
2265 spin_unlock_irqrestore(&brd_lock
, flags
);
2268 /*****************************************************************************/
2271 * Read data from shared memory. This assumes that the shared memory
2272 * is enabled and that interrupts are off. Basically we just empty out
2273 * the shared memory buffer into the tty buffer. Must be careful to
2274 * handle the case where we fill up the tty buffer, but still have
2275 * more chars to unload.
2278 static void stli_read(struct stlibrd
*brdp
, struct stliport
*portp
)
2280 cdkasyrq_t __iomem
*rp
;
2281 char __iomem
*shbuf
;
2282 struct tty_struct
*tty
;
2283 unsigned int head
, tail
, size
;
2284 unsigned int len
, stlen
;
2286 if (test_bit(ST_RXSTOP
, &portp
->state
))
2292 rp
= &((cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->rxq
;
2293 head
= (unsigned int) readw(&rp
->head
);
2294 if (head
!= ((unsigned int) readw(&rp
->head
)))
2295 head
= (unsigned int) readw(&rp
->head
);
2296 tail
= (unsigned int) readw(&rp
->tail
);
2297 size
= portp
->rxsize
;
2302 len
= size
- (tail
- head
);
2303 stlen
= size
- tail
;
2306 len
= tty_buffer_request_room(tty
, len
);
2308 shbuf
= (char __iomem
*) EBRDGETMEMPTR(brdp
, portp
->rxoffset
);
2311 unsigned char *cptr
;
2313 stlen
= min(len
, stlen
);
2314 tty_prepare_flip_string(tty
, &cptr
, stlen
);
2315 memcpy_fromio(cptr
, shbuf
+ tail
, stlen
);
2323 rp
= &((cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->rxq
;
2324 writew(tail
, &rp
->tail
);
2327 set_bit(ST_RXING
, &portp
->state
);
2329 tty_schedule_flip(tty
);
2332 /*****************************************************************************/
2335 * Set up and carry out any delayed commands. There is only a small set
2336 * of slave commands that can be done "off-level". So it is not too
2337 * difficult to deal with them here.
2340 static void stli_dodelaycmd(struct stliport
*portp
, cdkctrl_t __iomem
*cp
)
2344 if (test_bit(ST_DOSIGS
, &portp
->state
)) {
2345 if (test_bit(ST_DOFLUSHTX
, &portp
->state
) &&
2346 test_bit(ST_DOFLUSHRX
, &portp
->state
))
2347 cmd
= A_SETSIGNALSF
;
2348 else if (test_bit(ST_DOFLUSHTX
, &portp
->state
))
2349 cmd
= A_SETSIGNALSFTX
;
2350 else if (test_bit(ST_DOFLUSHRX
, &portp
->state
))
2351 cmd
= A_SETSIGNALSFRX
;
2354 clear_bit(ST_DOFLUSHTX
, &portp
->state
);
2355 clear_bit(ST_DOFLUSHRX
, &portp
->state
);
2356 clear_bit(ST_DOSIGS
, &portp
->state
);
2357 memcpy_toio((void __iomem
*) &(cp
->args
[0]), (void *) &portp
->asig
,
2359 writel(0, &cp
->status
);
2360 writel(cmd
, &cp
->cmd
);
2361 set_bit(ST_CMDING
, &portp
->state
);
2362 } else if (test_bit(ST_DOFLUSHTX
, &portp
->state
) ||
2363 test_bit(ST_DOFLUSHRX
, &portp
->state
)) {
2364 cmd
= ((test_bit(ST_DOFLUSHTX
, &portp
->state
)) ? FLUSHTX
: 0);
2365 cmd
|= ((test_bit(ST_DOFLUSHRX
, &portp
->state
)) ? FLUSHRX
: 0);
2366 clear_bit(ST_DOFLUSHTX
, &portp
->state
);
2367 clear_bit(ST_DOFLUSHRX
, &portp
->state
);
2368 memcpy_toio((void __iomem
*) &(cp
->args
[0]), (void *) &cmd
, sizeof(int));
2369 writel(0, &cp
->status
);
2370 writel(A_FLUSH
, &cp
->cmd
);
2371 set_bit(ST_CMDING
, &portp
->state
);
2375 /*****************************************************************************/
2378 * Host command service checking. This handles commands or messages
2379 * coming from the slave to the host. Must have board shared memory
2380 * enabled and interrupts off when called. Notice that by servicing the
2381 * read data last we don't need to change the shared memory pointer
2382 * during processing (which is a slow IO operation).
2383 * Return value indicates if this port is still awaiting actions from
2384 * the slave (like open, command, or even TX data being sent). If 0
2385 * then port is still busy, otherwise no longer busy.
2388 static int stli_hostcmd(struct stlibrd
*brdp
, struct stliport
*portp
)
2390 cdkasy_t __iomem
*ap
;
2391 cdkctrl_t __iomem
*cp
;
2392 struct tty_struct
*tty
;
2394 unsigned long oldsigs
;
2397 ap
= (cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
2401 * Check if we are waiting for an open completion message.
2403 if (test_bit(ST_OPENING
, &portp
->state
)) {
2404 rc
= readl(&cp
->openarg
);
2405 if (readb(&cp
->open
) == 0 && rc
!= 0) {
2408 writel(0, &cp
->openarg
);
2410 clear_bit(ST_OPENING
, &portp
->state
);
2411 wake_up_interruptible(&portp
->raw_wait
);
2416 * Check if we are waiting for a close completion message.
2418 if (test_bit(ST_CLOSING
, &portp
->state
)) {
2419 rc
= (int) readl(&cp
->closearg
);
2420 if (readb(&cp
->close
) == 0 && rc
!= 0) {
2423 writel(0, &cp
->closearg
);
2425 clear_bit(ST_CLOSING
, &portp
->state
);
2426 wake_up_interruptible(&portp
->raw_wait
);
2431 * Check if we are waiting for a command completion message. We may
2432 * need to copy out the command results associated with this command.
2434 if (test_bit(ST_CMDING
, &portp
->state
)) {
2435 rc
= readl(&cp
->status
);
2436 if (readl(&cp
->cmd
) == 0 && rc
!= 0) {
2439 if (portp
->argp
!= NULL
) {
2440 memcpy_fromio(portp
->argp
, (void __iomem
*) &(cp
->args
[0]),
2444 writel(0, &cp
->status
);
2446 clear_bit(ST_CMDING
, &portp
->state
);
2447 stli_dodelaycmd(portp
, cp
);
2448 wake_up_interruptible(&portp
->raw_wait
);
2453 * Check for any notification messages ready. This includes lots of
2454 * different types of events - RX chars ready, RX break received,
2455 * TX data low or empty in the slave, modem signals changed state.
2464 if (nt
.signal
& SG_DCD
) {
2465 oldsigs
= portp
->sigs
;
2466 portp
->sigs
= stli_mktiocm(nt
.sigvalue
);
2467 clear_bit(ST_GETSIGS
, &portp
->state
);
2468 if ((portp
->sigs
& TIOCM_CD
) &&
2469 ((oldsigs
& TIOCM_CD
) == 0))
2470 wake_up_interruptible(&portp
->open_wait
);
2471 if ((oldsigs
& TIOCM_CD
) &&
2472 ((portp
->sigs
& TIOCM_CD
) == 0)) {
2473 if (portp
->flags
& ASYNC_CHECK_CD
) {
2475 schedule_work(&portp
->tqhangup
);
2480 if (nt
.data
& DT_TXEMPTY
)
2481 clear_bit(ST_TXBUSY
, &portp
->state
);
2482 if (nt
.data
& (DT_TXEMPTY
| DT_TXLOW
)) {
2486 wake_up_interruptible(&tty
->write_wait
);
2490 if ((nt
.data
& DT_RXBREAK
) && (portp
->rxmarkmsk
& BRKINT
)) {
2492 tty_insert_flip_char(tty
, 0, TTY_BREAK
);
2493 if (portp
->flags
& ASYNC_SAK
) {
2497 tty_schedule_flip(tty
);
2501 if (nt
.data
& DT_RXBUSY
) {
2503 stli_read(brdp
, portp
);
2508 * It might seem odd that we are checking for more RX chars here.
2509 * But, we need to handle the case where the tty buffer was previously
2510 * filled, but we had more characters to pass up. The slave will not
2511 * send any more RX notify messages until the RX buffer has been emptied.
2512 * But it will leave the service bits on (since the buffer is not empty).
2513 * So from here we can try to process more RX chars.
2515 if ((!donerx
) && test_bit(ST_RXING
, &portp
->state
)) {
2516 clear_bit(ST_RXING
, &portp
->state
);
2517 stli_read(brdp
, portp
);
2520 return((test_bit(ST_OPENING
, &portp
->state
) ||
2521 test_bit(ST_CLOSING
, &portp
->state
) ||
2522 test_bit(ST_CMDING
, &portp
->state
) ||
2523 test_bit(ST_TXBUSY
, &portp
->state
) ||
2524 test_bit(ST_RXING
, &portp
->state
)) ? 0 : 1);
2527 /*****************************************************************************/
2530 * Service all ports on a particular board. Assumes that the boards
2531 * shared memory is enabled, and that the page pointer is pointed
2532 * at the cdk header structure.
2535 static void stli_brdpoll(struct stlibrd
*brdp
, cdkhdr_t __iomem
*hdrp
)
2537 struct stliport
*portp
;
2538 unsigned char hostbits
[(STL_MAXCHANS
/ 8) + 1];
2539 unsigned char slavebits
[(STL_MAXCHANS
/ 8) + 1];
2540 unsigned char __iomem
*slavep
;
2541 int bitpos
, bitat
, bitsize
;
2542 int channr
, nrdevs
, slavebitchange
;
2544 bitsize
= brdp
->bitsize
;
2545 nrdevs
= brdp
->nrdevs
;
2548 * Check if slave wants any service. Basically we try to do as
2549 * little work as possible here. There are 2 levels of service
2550 * bits. So if there is nothing to do we bail early. We check
2551 * 8 service bits at a time in the inner loop, so we can bypass
2552 * the lot if none of them want service.
2554 memcpy_fromio(&hostbits
[0], (((unsigned char __iomem
*) hdrp
) + brdp
->hostoffset
),
2557 memset(&slavebits
[0], 0, bitsize
);
2560 for (bitpos
= 0; (bitpos
< bitsize
); bitpos
++) {
2561 if (hostbits
[bitpos
] == 0)
2563 channr
= bitpos
* 8;
2564 for (bitat
= 0x1; (channr
< nrdevs
); channr
++, bitat
<<= 1) {
2565 if (hostbits
[bitpos
] & bitat
) {
2566 portp
= brdp
->ports
[(channr
- 1)];
2567 if (stli_hostcmd(brdp
, portp
)) {
2569 slavebits
[bitpos
] |= bitat
;
2576 * If any of the ports are no longer busy then update them in the
2577 * slave request bits. We need to do this after, since a host port
2578 * service may initiate more slave requests.
2580 if (slavebitchange
) {
2581 hdrp
= (cdkhdr_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
2582 slavep
= ((unsigned char __iomem
*) hdrp
) + brdp
->slaveoffset
;
2583 for (bitpos
= 0; (bitpos
< bitsize
); bitpos
++) {
2584 if (readb(slavebits
+ bitpos
))
2585 writeb(readb(slavep
+ bitpos
) & ~slavebits
[bitpos
], slavebits
+ bitpos
);
2590 /*****************************************************************************/
2593 * Driver poll routine. This routine polls the boards in use and passes
2594 * messages back up to host when necessary. This is actually very
2595 * CPU efficient, since we will always have the kernel poll clock, it
2596 * adds only a few cycles when idle (since board service can be
2597 * determined very easily), but when loaded generates no interrupts
2598 * (with their expensive associated context change).
2601 static void stli_poll(unsigned long arg
)
2603 cdkhdr_t __iomem
*hdrp
;
2604 struct stlibrd
*brdp
;
2607 stli_timerlist
.expires
= STLI_TIMEOUT
;
2608 add_timer(&stli_timerlist
);
2611 * Check each board and do any servicing required.
2613 for (brdnr
= 0; (brdnr
< stli_nrbrds
); brdnr
++) {
2614 brdp
= stli_brds
[brdnr
];
2617 if ((brdp
->state
& BST_STARTED
) == 0)
2620 spin_lock(&brd_lock
);
2622 hdrp
= (cdkhdr_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
2623 if (readb(&hdrp
->hostreq
))
2624 stli_brdpoll(brdp
, hdrp
);
2626 spin_unlock(&brd_lock
);
2630 /*****************************************************************************/
2633 * Translate the termios settings into the port setting structure of
2637 static void stli_mkasyport(struct stliport
*portp
, asyport_t
*pp
, struct ktermios
*tiosp
)
2639 memset(pp
, 0, sizeof(asyport_t
));
2642 * Start of by setting the baud, char size, parity and stop bit info.
2644 pp
->baudout
= tty_get_baud_rate(portp
->tty
);
2645 if ((tiosp
->c_cflag
& CBAUD
) == B38400
) {
2646 if ((portp
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_HI
)
2647 pp
->baudout
= 57600;
2648 else if ((portp
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_VHI
)
2649 pp
->baudout
= 115200;
2650 else if ((portp
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_SHI
)
2651 pp
->baudout
= 230400;
2652 else if ((portp
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_WARP
)
2653 pp
->baudout
= 460800;
2654 else if ((portp
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_CUST
)
2655 pp
->baudout
= (portp
->baud_base
/ portp
->custom_divisor
);
2657 if (pp
->baudout
> STL_MAXBAUD
)
2658 pp
->baudout
= STL_MAXBAUD
;
2659 pp
->baudin
= pp
->baudout
;
2661 switch (tiosp
->c_cflag
& CSIZE
) {
2676 if (tiosp
->c_cflag
& CSTOPB
)
2677 pp
->stopbs
= PT_STOP2
;
2679 pp
->stopbs
= PT_STOP1
;
2681 if (tiosp
->c_cflag
& PARENB
) {
2682 if (tiosp
->c_cflag
& PARODD
)
2683 pp
->parity
= PT_ODDPARITY
;
2685 pp
->parity
= PT_EVENPARITY
;
2687 pp
->parity
= PT_NOPARITY
;
2691 * Set up any flow control options enabled.
2693 if (tiosp
->c_iflag
& IXON
) {
2695 if (tiosp
->c_iflag
& IXANY
)
2696 pp
->flow
|= F_IXANY
;
2698 if (tiosp
->c_cflag
& CRTSCTS
)
2699 pp
->flow
|= (F_RTSFLOW
| F_CTSFLOW
);
2701 pp
->startin
= tiosp
->c_cc
[VSTART
];
2702 pp
->stopin
= tiosp
->c_cc
[VSTOP
];
2703 pp
->startout
= tiosp
->c_cc
[VSTART
];
2704 pp
->stopout
= tiosp
->c_cc
[VSTOP
];
2707 * Set up the RX char marking mask with those RX error types we must
2708 * catch. We can get the slave to help us out a little here, it will
2709 * ignore parity errors and breaks for us, and mark parity errors in
2712 if (tiosp
->c_iflag
& IGNPAR
)
2713 pp
->iflag
|= FI_IGNRXERRS
;
2714 if (tiosp
->c_iflag
& IGNBRK
)
2715 pp
->iflag
|= FI_IGNBREAK
;
2717 portp
->rxmarkmsk
= 0;
2718 if (tiosp
->c_iflag
& (INPCK
| PARMRK
))
2719 pp
->iflag
|= FI_1MARKRXERRS
;
2720 if (tiosp
->c_iflag
& BRKINT
)
2721 portp
->rxmarkmsk
|= BRKINT
;
2724 * Set up clocal processing as required.
2726 if (tiosp
->c_cflag
& CLOCAL
)
2727 portp
->flags
&= ~ASYNC_CHECK_CD
;
2729 portp
->flags
|= ASYNC_CHECK_CD
;
2732 * Transfer any persistent flags into the asyport structure.
2734 pp
->pflag
= (portp
->pflag
& 0xffff);
2735 pp
->vmin
= (portp
->pflag
& P_RXIMIN
) ? 1 : 0;
2736 pp
->vtime
= (portp
->pflag
& P_RXITIME
) ? 1 : 0;
2737 pp
->cc
[1] = (portp
->pflag
& P_RXTHOLD
) ? 1 : 0;
2740 /*****************************************************************************/
2743 * Construct a slave signals structure for setting the DTR and RTS
2744 * signals as specified.
2747 static void stli_mkasysigs(asysigs_t
*sp
, int dtr
, int rts
)
2749 memset(sp
, 0, sizeof(asysigs_t
));
2751 sp
->signal
|= SG_DTR
;
2752 sp
->sigvalue
|= ((dtr
> 0) ? SG_DTR
: 0);
2755 sp
->signal
|= SG_RTS
;
2756 sp
->sigvalue
|= ((rts
> 0) ? SG_RTS
: 0);
2760 /*****************************************************************************/
2763 * Convert the signals returned from the slave into a local TIOCM type
2764 * signals value. We keep them locally in TIOCM format.
2767 static long stli_mktiocm(unsigned long sigvalue
)
2770 tiocm
|= ((sigvalue
& SG_DCD
) ? TIOCM_CD
: 0);
2771 tiocm
|= ((sigvalue
& SG_CTS
) ? TIOCM_CTS
: 0);
2772 tiocm
|= ((sigvalue
& SG_RI
) ? TIOCM_RI
: 0);
2773 tiocm
|= ((sigvalue
& SG_DSR
) ? TIOCM_DSR
: 0);
2774 tiocm
|= ((sigvalue
& SG_DTR
) ? TIOCM_DTR
: 0);
2775 tiocm
|= ((sigvalue
& SG_RTS
) ? TIOCM_RTS
: 0);
2779 /*****************************************************************************/
2782 * All panels and ports actually attached have been worked out. All
2783 * we need to do here is set up the appropriate per port data structures.
2786 static int stli_initports(struct stlibrd
*brdp
)
2788 struct stliport
*portp
;
2789 unsigned int i
, panelnr
, panelport
;
2791 for (i
= 0, panelnr
= 0, panelport
= 0; (i
< brdp
->nrports
); i
++) {
2792 portp
= kzalloc(sizeof(struct stliport
), GFP_KERNEL
);
2794 printk("STALLION: failed to allocate port structure\n");
2798 portp
->magic
= STLI_PORTMAGIC
;
2800 portp
->brdnr
= brdp
->brdnr
;
2801 portp
->panelnr
= panelnr
;
2802 portp
->baud_base
= STL_BAUDBASE
;
2803 portp
->close_delay
= STL_CLOSEDELAY
;
2804 portp
->closing_wait
= 30 * HZ
;
2805 INIT_WORK(&portp
->tqhangup
, stli_dohangup
);
2806 init_waitqueue_head(&portp
->open_wait
);
2807 init_waitqueue_head(&portp
->close_wait
);
2808 init_waitqueue_head(&portp
->raw_wait
);
2810 if (panelport
>= brdp
->panels
[panelnr
]) {
2814 brdp
->ports
[i
] = portp
;
2820 /*****************************************************************************/
2823 * All the following routines are board specific hardware operations.
2826 static void stli_ecpinit(struct stlibrd
*brdp
)
2828 unsigned long memconf
;
2830 outb(ECP_ATSTOP
, (brdp
->iobase
+ ECP_ATCONFR
));
2832 outb(ECP_ATDISABLE
, (brdp
->iobase
+ ECP_ATCONFR
));
2835 memconf
= (brdp
->memaddr
& ECP_ATADDRMASK
) >> ECP_ATADDRSHFT
;
2836 outb(memconf
, (brdp
->iobase
+ ECP_ATMEMAR
));
2839 /*****************************************************************************/
2841 static void stli_ecpenable(struct stlibrd
*brdp
)
2843 outb(ECP_ATENABLE
, (brdp
->iobase
+ ECP_ATCONFR
));
2846 /*****************************************************************************/
2848 static void stli_ecpdisable(struct stlibrd
*brdp
)
2850 outb(ECP_ATDISABLE
, (brdp
->iobase
+ ECP_ATCONFR
));
2853 /*****************************************************************************/
2855 static void __iomem
*stli_ecpgetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
)
2860 if (offset
> brdp
->memsize
) {
2861 printk(KERN_ERR
"STALLION: shared memory pointer=%x out of "
2862 "range at line=%d(%d), brd=%d\n",
2863 (int) offset
, line
, __LINE__
, brdp
->brdnr
);
2867 ptr
= brdp
->membase
+ (offset
% ECP_ATPAGESIZE
);
2868 val
= (unsigned char) (offset
/ ECP_ATPAGESIZE
);
2870 outb(val
, (brdp
->iobase
+ ECP_ATMEMPR
));
2874 /*****************************************************************************/
2876 static void stli_ecpreset(struct stlibrd
*brdp
)
2878 outb(ECP_ATSTOP
, (brdp
->iobase
+ ECP_ATCONFR
));
2880 outb(ECP_ATDISABLE
, (brdp
->iobase
+ ECP_ATCONFR
));
2884 /*****************************************************************************/
2886 static void stli_ecpintr(struct stlibrd
*brdp
)
2888 outb(0x1, brdp
->iobase
);
2891 /*****************************************************************************/
2894 * The following set of functions act on ECP EISA boards.
2897 static void stli_ecpeiinit(struct stlibrd
*brdp
)
2899 unsigned long memconf
;
2901 outb(0x1, (brdp
->iobase
+ ECP_EIBRDENAB
));
2902 outb(ECP_EISTOP
, (brdp
->iobase
+ ECP_EICONFR
));
2904 outb(ECP_EIDISABLE
, (brdp
->iobase
+ ECP_EICONFR
));
2907 memconf
= (brdp
->memaddr
& ECP_EIADDRMASKL
) >> ECP_EIADDRSHFTL
;
2908 outb(memconf
, (brdp
->iobase
+ ECP_EIMEMARL
));
2909 memconf
= (brdp
->memaddr
& ECP_EIADDRMASKH
) >> ECP_EIADDRSHFTH
;
2910 outb(memconf
, (brdp
->iobase
+ ECP_EIMEMARH
));
2913 /*****************************************************************************/
2915 static void stli_ecpeienable(struct stlibrd
*brdp
)
2917 outb(ECP_EIENABLE
, (brdp
->iobase
+ ECP_EICONFR
));
2920 /*****************************************************************************/
2922 static void stli_ecpeidisable(struct stlibrd
*brdp
)
2924 outb(ECP_EIDISABLE
, (brdp
->iobase
+ ECP_EICONFR
));
2927 /*****************************************************************************/
2929 static void __iomem
*stli_ecpeigetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
)
2934 if (offset
> brdp
->memsize
) {
2935 printk(KERN_ERR
"STALLION: shared memory pointer=%x out of "
2936 "range at line=%d(%d), brd=%d\n",
2937 (int) offset
, line
, __LINE__
, brdp
->brdnr
);
2941 ptr
= brdp
->membase
+ (offset
% ECP_EIPAGESIZE
);
2942 if (offset
< ECP_EIPAGESIZE
)
2945 val
= ECP_EIENABLE
| 0x40;
2947 outb(val
, (brdp
->iobase
+ ECP_EICONFR
));
2951 /*****************************************************************************/
2953 static void stli_ecpeireset(struct stlibrd
*brdp
)
2955 outb(ECP_EISTOP
, (brdp
->iobase
+ ECP_EICONFR
));
2957 outb(ECP_EIDISABLE
, (brdp
->iobase
+ ECP_EICONFR
));
2961 /*****************************************************************************/
2964 * The following set of functions act on ECP MCA boards.
2967 static void stli_ecpmcenable(struct stlibrd
*brdp
)
2969 outb(ECP_MCENABLE
, (brdp
->iobase
+ ECP_MCCONFR
));
2972 /*****************************************************************************/
2974 static void stli_ecpmcdisable(struct stlibrd
*brdp
)
2976 outb(ECP_MCDISABLE
, (brdp
->iobase
+ ECP_MCCONFR
));
2979 /*****************************************************************************/
2981 static void __iomem
*stli_ecpmcgetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
)
2986 if (offset
> brdp
->memsize
) {
2987 printk(KERN_ERR
"STALLION: shared memory pointer=%x out of "
2988 "range at line=%d(%d), brd=%d\n",
2989 (int) offset
, line
, __LINE__
, brdp
->brdnr
);
2993 ptr
= brdp
->membase
+ (offset
% ECP_MCPAGESIZE
);
2994 val
= ((unsigned char) (offset
/ ECP_MCPAGESIZE
)) | ECP_MCENABLE
;
2996 outb(val
, (brdp
->iobase
+ ECP_MCCONFR
));
3000 /*****************************************************************************/
3002 static void stli_ecpmcreset(struct stlibrd
*brdp
)
3004 outb(ECP_MCSTOP
, (brdp
->iobase
+ ECP_MCCONFR
));
3006 outb(ECP_MCDISABLE
, (brdp
->iobase
+ ECP_MCCONFR
));
3010 /*****************************************************************************/
3013 * The following set of functions act on ECP PCI boards.
3016 static void stli_ecppciinit(struct stlibrd
*brdp
)
3018 outb(ECP_PCISTOP
, (brdp
->iobase
+ ECP_PCICONFR
));
3020 outb(0, (brdp
->iobase
+ ECP_PCICONFR
));
3024 /*****************************************************************************/
3026 static void __iomem
*stli_ecppcigetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
)
3031 if (offset
> brdp
->memsize
) {
3032 printk(KERN_ERR
"STALLION: shared memory pointer=%x out of "
3033 "range at line=%d(%d), board=%d\n",
3034 (int) offset
, line
, __LINE__
, brdp
->brdnr
);
3038 ptr
= brdp
->membase
+ (offset
% ECP_PCIPAGESIZE
);
3039 val
= (offset
/ ECP_PCIPAGESIZE
) << 1;
3041 outb(val
, (brdp
->iobase
+ ECP_PCICONFR
));
3045 /*****************************************************************************/
3047 static void stli_ecppcireset(struct stlibrd
*brdp
)
3049 outb(ECP_PCISTOP
, (brdp
->iobase
+ ECP_PCICONFR
));
3051 outb(0, (brdp
->iobase
+ ECP_PCICONFR
));
3055 /*****************************************************************************/
3058 * The following routines act on ONboards.
3061 static void stli_onbinit(struct stlibrd
*brdp
)
3063 unsigned long memconf
;
3065 outb(ONB_ATSTOP
, (brdp
->iobase
+ ONB_ATCONFR
));
3067 outb(ONB_ATDISABLE
, (brdp
->iobase
+ ONB_ATCONFR
));
3070 memconf
= (brdp
->memaddr
& ONB_ATADDRMASK
) >> ONB_ATADDRSHFT
;
3071 outb(memconf
, (brdp
->iobase
+ ONB_ATMEMAR
));
3072 outb(0x1, brdp
->iobase
);
3076 /*****************************************************************************/
3078 static void stli_onbenable(struct stlibrd
*brdp
)
3080 outb((brdp
->enabval
| ONB_ATENABLE
), (brdp
->iobase
+ ONB_ATCONFR
));
3083 /*****************************************************************************/
3085 static void stli_onbdisable(struct stlibrd
*brdp
)
3087 outb((brdp
->enabval
| ONB_ATDISABLE
), (brdp
->iobase
+ ONB_ATCONFR
));
3090 /*****************************************************************************/
3092 static void __iomem
*stli_onbgetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
)
3096 if (offset
> brdp
->memsize
) {
3097 printk(KERN_ERR
"STALLION: shared memory pointer=%x out of "
3098 "range at line=%d(%d), brd=%d\n",
3099 (int) offset
, line
, __LINE__
, brdp
->brdnr
);
3102 ptr
= brdp
->membase
+ (offset
% ONB_ATPAGESIZE
);
3107 /*****************************************************************************/
3109 static void stli_onbreset(struct stlibrd
*brdp
)
3111 outb(ONB_ATSTOP
, (brdp
->iobase
+ ONB_ATCONFR
));
3113 outb(ONB_ATDISABLE
, (brdp
->iobase
+ ONB_ATCONFR
));
3117 /*****************************************************************************/
3120 * The following routines act on ONboard EISA.
3123 static void stli_onbeinit(struct stlibrd
*brdp
)
3125 unsigned long memconf
;
3127 outb(0x1, (brdp
->iobase
+ ONB_EIBRDENAB
));
3128 outb(ONB_EISTOP
, (brdp
->iobase
+ ONB_EICONFR
));
3130 outb(ONB_EIDISABLE
, (brdp
->iobase
+ ONB_EICONFR
));
3133 memconf
= (brdp
->memaddr
& ONB_EIADDRMASKL
) >> ONB_EIADDRSHFTL
;
3134 outb(memconf
, (brdp
->iobase
+ ONB_EIMEMARL
));
3135 memconf
= (brdp
->memaddr
& ONB_EIADDRMASKH
) >> ONB_EIADDRSHFTH
;
3136 outb(memconf
, (brdp
->iobase
+ ONB_EIMEMARH
));
3137 outb(0x1, brdp
->iobase
);
3141 /*****************************************************************************/
3143 static void stli_onbeenable(struct stlibrd
*brdp
)
3145 outb(ONB_EIENABLE
, (brdp
->iobase
+ ONB_EICONFR
));
3148 /*****************************************************************************/
3150 static void stli_onbedisable(struct stlibrd
*brdp
)
3152 outb(ONB_EIDISABLE
, (brdp
->iobase
+ ONB_EICONFR
));
3155 /*****************************************************************************/
3157 static void __iomem
*stli_onbegetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
)
3162 if (offset
> brdp
->memsize
) {
3163 printk(KERN_ERR
"STALLION: shared memory pointer=%x out of "
3164 "range at line=%d(%d), brd=%d\n",
3165 (int) offset
, line
, __LINE__
, brdp
->brdnr
);
3169 ptr
= brdp
->membase
+ (offset
% ONB_EIPAGESIZE
);
3170 if (offset
< ONB_EIPAGESIZE
)
3173 val
= ONB_EIENABLE
| 0x40;
3175 outb(val
, (brdp
->iobase
+ ONB_EICONFR
));
3179 /*****************************************************************************/
3181 static void stli_onbereset(struct stlibrd
*brdp
)
3183 outb(ONB_EISTOP
, (brdp
->iobase
+ ONB_EICONFR
));
3185 outb(ONB_EIDISABLE
, (brdp
->iobase
+ ONB_EICONFR
));
3189 /*****************************************************************************/
3192 * The following routines act on Brumby boards.
3195 static void stli_bbyinit(struct stlibrd
*brdp
)
3197 outb(BBY_ATSTOP
, (brdp
->iobase
+ BBY_ATCONFR
));
3199 outb(0, (brdp
->iobase
+ BBY_ATCONFR
));
3201 outb(0x1, brdp
->iobase
);
3205 /*****************************************************************************/
3207 static void __iomem
*stli_bbygetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
)
3212 BUG_ON(offset
> brdp
->memsize
);
3214 ptr
= brdp
->membase
+ (offset
% BBY_PAGESIZE
);
3215 val
= (unsigned char) (offset
/ BBY_PAGESIZE
);
3216 outb(val
, (brdp
->iobase
+ BBY_ATCONFR
));
3220 /*****************************************************************************/
3222 static void stli_bbyreset(struct stlibrd
*brdp
)
3224 outb(BBY_ATSTOP
, (brdp
->iobase
+ BBY_ATCONFR
));
3226 outb(0, (brdp
->iobase
+ BBY_ATCONFR
));
3230 /*****************************************************************************/
3233 * The following routines act on original old Stallion boards.
3236 static void stli_stalinit(struct stlibrd
*brdp
)
3238 outb(0x1, brdp
->iobase
);
3242 /*****************************************************************************/
3244 static void __iomem
*stli_stalgetmemptr(struct stlibrd
*brdp
, unsigned long offset
, int line
)
3246 BUG_ON(offset
> brdp
->memsize
);
3247 return brdp
->membase
+ (offset
% STAL_PAGESIZE
);
3250 /*****************************************************************************/
3252 static void stli_stalreset(struct stlibrd
*brdp
)
3256 vecp
= (u32 __iomem
*) (brdp
->membase
+ 0x30);
3257 writel(0xffff0000, vecp
);
3258 outb(0, brdp
->iobase
);
3262 /*****************************************************************************/
3265 * Try to find an ECP board and initialize it. This handles only ECP
3269 static int stli_initecp(struct stlibrd
*brdp
)
3272 cdkecpsig_t __iomem
*sigsp
;
3273 unsigned int status
, nxtid
;
3275 int panelnr
, nrports
;
3277 if (!request_region(brdp
->iobase
, brdp
->iosize
, "istallion"))
3280 if ((brdp
->iobase
== 0) || (brdp
->memaddr
== 0))
3282 release_region(brdp
->iobase
, brdp
->iosize
);
3286 brdp
->iosize
= ECP_IOSIZE
;
3289 * Based on the specific board type setup the common vars to access
3290 * and enable shared memory. Set all board specific information now
3293 switch (brdp
->brdtype
) {
3295 brdp
->memsize
= ECP_MEMSIZE
;
3296 brdp
->pagesize
= ECP_ATPAGESIZE
;
3297 brdp
->init
= stli_ecpinit
;
3298 brdp
->enable
= stli_ecpenable
;
3299 brdp
->reenable
= stli_ecpenable
;
3300 brdp
->disable
= stli_ecpdisable
;
3301 brdp
->getmemptr
= stli_ecpgetmemptr
;
3302 brdp
->intr
= stli_ecpintr
;
3303 brdp
->reset
= stli_ecpreset
;
3304 name
= "serial(EC8/64)";
3308 brdp
->memsize
= ECP_MEMSIZE
;
3309 brdp
->pagesize
= ECP_EIPAGESIZE
;
3310 brdp
->init
= stli_ecpeiinit
;
3311 brdp
->enable
= stli_ecpeienable
;
3312 brdp
->reenable
= stli_ecpeienable
;
3313 brdp
->disable
= stli_ecpeidisable
;
3314 brdp
->getmemptr
= stli_ecpeigetmemptr
;
3315 brdp
->intr
= stli_ecpintr
;
3316 brdp
->reset
= stli_ecpeireset
;
3317 name
= "serial(EC8/64-EI)";
3321 brdp
->memsize
= ECP_MEMSIZE
;
3322 brdp
->pagesize
= ECP_MCPAGESIZE
;
3324 brdp
->enable
= stli_ecpmcenable
;
3325 brdp
->reenable
= stli_ecpmcenable
;
3326 brdp
->disable
= stli_ecpmcdisable
;
3327 brdp
->getmemptr
= stli_ecpmcgetmemptr
;
3328 brdp
->intr
= stli_ecpintr
;
3329 brdp
->reset
= stli_ecpmcreset
;
3330 name
= "serial(EC8/64-MCA)";
3334 brdp
->memsize
= ECP_PCIMEMSIZE
;
3335 brdp
->pagesize
= ECP_PCIPAGESIZE
;
3336 brdp
->init
= stli_ecppciinit
;
3337 brdp
->enable
= NULL
;
3338 brdp
->reenable
= NULL
;
3339 brdp
->disable
= NULL
;
3340 brdp
->getmemptr
= stli_ecppcigetmemptr
;
3341 brdp
->intr
= stli_ecpintr
;
3342 brdp
->reset
= stli_ecppcireset
;
3343 name
= "serial(EC/RA-PCI)";
3347 release_region(brdp
->iobase
, brdp
->iosize
);
3352 * The per-board operations structure is all set up, so now let's go
3353 * and get the board operational. Firstly initialize board configuration
3354 * registers. Set the memory mapping info so we can get at the boards
3359 brdp
->membase
= ioremap(brdp
->memaddr
, brdp
->memsize
);
3360 if (brdp
->membase
== NULL
)
3362 release_region(brdp
->iobase
, brdp
->iosize
);
3367 * Now that all specific code is set up, enable the shared memory and
3368 * look for the a signature area that will tell us exactly what board
3369 * this is, and what it is connected to it.
3372 sigsp
= (cdkecpsig_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_SIGADDR
);
3373 memcpy_fromio(&sig
, sigsp
, sizeof(cdkecpsig_t
));
3376 if (sig
.magic
!= cpu_to_le32(ECP_MAGIC
))
3378 release_region(brdp
->iobase
, brdp
->iosize
);
3379 iounmap(brdp
->membase
);
3380 brdp
->membase
= NULL
;
3385 * Scan through the signature looking at the panels connected to the
3386 * board. Calculate the total number of ports as we go.
3388 for (panelnr
= 0, nxtid
= 0; (panelnr
< STL_MAXPANELS
); panelnr
++) {
3389 status
= sig
.panelid
[nxtid
];
3390 if ((status
& ECH_PNLIDMASK
) != nxtid
)
3393 brdp
->panelids
[panelnr
] = status
;
3394 nrports
= (status
& ECH_PNL16PORT
) ? 16 : 8;
3395 if ((nrports
== 16) && ((status
& ECH_PNLXPID
) == 0))
3397 brdp
->panels
[panelnr
] = nrports
;
3398 brdp
->nrports
+= nrports
;
3404 brdp
->state
|= BST_FOUND
;
3408 /*****************************************************************************/
3411 * Try to find an ONboard, Brumby or Stallion board and initialize it.
3412 * This handles only these board types.
3415 static int stli_initonb(struct stlibrd
*brdp
)
3418 cdkonbsig_t __iomem
*sigsp
;
3423 * Do a basic sanity check on the IO and memory addresses.
3425 if (brdp
->iobase
== 0 || brdp
->memaddr
== 0)
3428 brdp
->iosize
= ONB_IOSIZE
;
3430 if (!request_region(brdp
->iobase
, brdp
->iosize
, "istallion"))
3434 * Based on the specific board type setup the common vars to access
3435 * and enable shared memory. Set all board specific information now
3438 switch (brdp
->brdtype
) {
3441 brdp
->memsize
= ONB_MEMSIZE
;
3442 brdp
->pagesize
= ONB_ATPAGESIZE
;
3443 brdp
->init
= stli_onbinit
;
3444 brdp
->enable
= stli_onbenable
;
3445 brdp
->reenable
= stli_onbenable
;
3446 brdp
->disable
= stli_onbdisable
;
3447 brdp
->getmemptr
= stli_onbgetmemptr
;
3448 brdp
->intr
= stli_ecpintr
;
3449 brdp
->reset
= stli_onbreset
;
3450 if (brdp
->memaddr
> 0x100000)
3451 brdp
->enabval
= ONB_MEMENABHI
;
3453 brdp
->enabval
= ONB_MEMENABLO
;
3454 name
= "serial(ONBoard)";
3458 brdp
->memsize
= ONB_EIMEMSIZE
;
3459 brdp
->pagesize
= ONB_EIPAGESIZE
;
3460 brdp
->init
= stli_onbeinit
;
3461 brdp
->enable
= stli_onbeenable
;
3462 brdp
->reenable
= stli_onbeenable
;
3463 brdp
->disable
= stli_onbedisable
;
3464 brdp
->getmemptr
= stli_onbegetmemptr
;
3465 brdp
->intr
= stli_ecpintr
;
3466 brdp
->reset
= stli_onbereset
;
3467 name
= "serial(ONBoard/E)";
3471 brdp
->memsize
= BBY_MEMSIZE
;
3472 brdp
->pagesize
= BBY_PAGESIZE
;
3473 brdp
->init
= stli_bbyinit
;
3474 brdp
->enable
= NULL
;
3475 brdp
->reenable
= NULL
;
3476 brdp
->disable
= NULL
;
3477 brdp
->getmemptr
= stli_bbygetmemptr
;
3478 brdp
->intr
= stli_ecpintr
;
3479 brdp
->reset
= stli_bbyreset
;
3480 name
= "serial(Brumby)";
3484 brdp
->memsize
= STAL_MEMSIZE
;
3485 brdp
->pagesize
= STAL_PAGESIZE
;
3486 brdp
->init
= stli_stalinit
;
3487 brdp
->enable
= NULL
;
3488 brdp
->reenable
= NULL
;
3489 brdp
->disable
= NULL
;
3490 brdp
->getmemptr
= stli_stalgetmemptr
;
3491 brdp
->intr
= stli_ecpintr
;
3492 brdp
->reset
= stli_stalreset
;
3493 name
= "serial(Stallion)";
3497 release_region(brdp
->iobase
, brdp
->iosize
);
3502 * The per-board operations structure is all set up, so now let's go
3503 * and get the board operational. Firstly initialize board configuration
3504 * registers. Set the memory mapping info so we can get at the boards
3509 brdp
->membase
= ioremap(brdp
->memaddr
, brdp
->memsize
);
3510 if (brdp
->membase
== NULL
)
3512 release_region(brdp
->iobase
, brdp
->iosize
);
3517 * Now that all specific code is set up, enable the shared memory and
3518 * look for the a signature area that will tell us exactly what board
3519 * this is, and how many ports.
3522 sigsp
= (cdkonbsig_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_SIGADDR
);
3523 memcpy_fromio(&sig
, sigsp
, sizeof(cdkonbsig_t
));
3526 if (sig
.magic0
!= cpu_to_le16(ONB_MAGIC0
) ||
3527 sig
.magic1
!= cpu_to_le16(ONB_MAGIC1
) ||
3528 sig
.magic2
!= cpu_to_le16(ONB_MAGIC2
) ||
3529 sig
.magic3
!= cpu_to_le16(ONB_MAGIC3
))
3531 release_region(brdp
->iobase
, brdp
->iosize
);
3532 iounmap(brdp
->membase
);
3533 brdp
->membase
= NULL
;
3538 * Scan through the signature alive mask and calculate how many ports
3539 * there are on this board.
3545 for (i
= 0; (i
< 16); i
++) {
3546 if (((sig
.amask0
<< i
) & 0x8000) == 0)
3551 brdp
->panels
[0] = brdp
->nrports
;
3554 brdp
->state
|= BST_FOUND
;
3558 /*****************************************************************************/
3561 * Start up a running board. This routine is only called after the
3562 * code has been down loaded to the board and is operational. It will
3563 * read in the memory map, and get the show on the road...
3566 static int stli_startbrd(struct stlibrd
*brdp
)
3568 cdkhdr_t __iomem
*hdrp
;
3569 cdkmem_t __iomem
*memp
;
3570 cdkasy_t __iomem
*ap
;
3571 unsigned long flags
;
3572 unsigned int portnr
, nrdevs
, i
;
3573 struct stliport
*portp
;
3577 spin_lock_irqsave(&brd_lock
, flags
);
3579 hdrp
= (cdkhdr_t __iomem
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
3580 nrdevs
= hdrp
->nrdevs
;
3583 printk("%s(%d): CDK version %d.%d.%d --> "
3584 "nrdevs=%d memp=%x hostp=%x slavep=%x\n",
3585 __FILE__
, __LINE__
, readb(&hdrp
->ver_release
), readb(&hdrp
->ver_modification
),
3586 readb(&hdrp
->ver_fix
), nrdevs
, (int) readl(&hdrp
->memp
), readl(&hdrp
->hostp
),
3587 readl(&hdrp
->slavep
));
3590 if (nrdevs
< (brdp
->nrports
+ 1)) {
3591 printk(KERN_ERR
"STALLION: slave failed to allocate memory for "
3592 "all devices, devices=%d\n", nrdevs
);
3593 brdp
->nrports
= nrdevs
- 1;
3595 brdp
->nrdevs
= nrdevs
;
3596 brdp
->hostoffset
= hdrp
->hostp
- CDK_CDKADDR
;
3597 brdp
->slaveoffset
= hdrp
->slavep
- CDK_CDKADDR
;
3598 brdp
->bitsize
= (nrdevs
+ 7) / 8;
3599 memoff
= readl(&hdrp
->memp
);
3600 if (memoff
> brdp
->memsize
) {
3601 printk(KERN_ERR
"STALLION: corrupted shared memory region?\n");
3603 goto stli_donestartup
;
3605 memp
= (cdkmem_t __iomem
*) EBRDGETMEMPTR(brdp
, memoff
);
3606 if (readw(&memp
->dtype
) != TYP_ASYNCTRL
) {
3607 printk(KERN_ERR
"STALLION: no slave control device found\n");
3608 goto stli_donestartup
;
3613 * Cycle through memory allocation of each port. We are guaranteed to
3614 * have all ports inside the first page of slave window, so no need to
3615 * change pages while reading memory map.
3617 for (i
= 1, portnr
= 0; (i
< nrdevs
); i
++, portnr
++, memp
++) {
3618 if (readw(&memp
->dtype
) != TYP_ASYNC
)
3620 portp
= brdp
->ports
[portnr
];
3624 portp
->addr
= readl(&memp
->offset
);
3625 portp
->reqbit
= (unsigned char) (0x1 << (i
* 8 / nrdevs
));
3626 portp
->portidx
= (unsigned char) (i
/ 8);
3627 portp
->portbit
= (unsigned char) (0x1 << (i
% 8));
3630 writeb(0xff, &hdrp
->slavereq
);
3633 * For each port setup a local copy of the RX and TX buffer offsets
3634 * and sizes. We do this separate from the above, because we need to
3635 * move the shared memory page...
3637 for (i
= 1, portnr
= 0; (i
< nrdevs
); i
++, portnr
++) {
3638 portp
= brdp
->ports
[portnr
];
3641 if (portp
->addr
== 0)
3643 ap
= (cdkasy_t __iomem
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
3645 portp
->rxsize
= readw(&ap
->rxq
.size
);
3646 portp
->txsize
= readw(&ap
->txq
.size
);
3647 portp
->rxoffset
= readl(&ap
->rxq
.offset
);
3648 portp
->txoffset
= readl(&ap
->txq
.offset
);
3654 spin_unlock_irqrestore(&brd_lock
, flags
);
3657 brdp
->state
|= BST_STARTED
;
3659 if (! stli_timeron
) {
3661 stli_timerlist
.expires
= STLI_TIMEOUT
;
3662 add_timer(&stli_timerlist
);
3668 /*****************************************************************************/
3671 * Probe and initialize the specified board.
3674 static int __devinit
stli_brdinit(struct stlibrd
*brdp
)
3676 stli_brds
[brdp
->brdnr
] = brdp
;
3678 switch (brdp
->brdtype
) {
3693 printk(KERN_ERR
"STALLION: board=%d is unknown board "
3694 "type=%d\n", brdp
->brdnr
, brdp
->brdtype
);
3698 if ((brdp
->state
& BST_FOUND
) == 0) {
3699 printk(KERN_ERR
"STALLION: %s board not found, board=%d "
3701 stli_brdnames
[brdp
->brdtype
], brdp
->brdnr
,
3702 brdp
->iobase
, (int) brdp
->memaddr
);
3706 stli_initports(brdp
);
3707 printk(KERN_INFO
"STALLION: %s found, board=%d io=%x mem=%x "
3708 "nrpanels=%d nrports=%d\n", stli_brdnames
[brdp
->brdtype
],
3709 brdp
->brdnr
, brdp
->iobase
, (int) brdp
->memaddr
,
3710 brdp
->nrpanels
, brdp
->nrports
);
3714 /*****************************************************************************/
3717 * Probe around trying to find where the EISA boards shared memory
3718 * might be. This is a bit if hack, but it is the best we can do.
3721 static int stli_eisamemprobe(struct stlibrd
*brdp
)
3723 cdkecpsig_t ecpsig
, __iomem
*ecpsigp
;
3724 cdkonbsig_t onbsig
, __iomem
*onbsigp
;
3728 * First up we reset the board, to get it into a known state. There
3729 * is only 2 board types here we need to worry about. Don;t use the
3730 * standard board init routine here, it programs up the shared
3731 * memory address, and we don't know it yet...
3733 if (brdp
->brdtype
== BRD_ECPE
) {
3734 outb(0x1, (brdp
->iobase
+ ECP_EIBRDENAB
));
3735 outb(ECP_EISTOP
, (brdp
->iobase
+ ECP_EICONFR
));
3737 outb(ECP_EIDISABLE
, (brdp
->iobase
+ ECP_EICONFR
));
3739 stli_ecpeienable(brdp
);
3740 } else if (brdp
->brdtype
== BRD_ONBOARDE
) {
3741 outb(0x1, (brdp
->iobase
+ ONB_EIBRDENAB
));
3742 outb(ONB_EISTOP
, (brdp
->iobase
+ ONB_EICONFR
));
3744 outb(ONB_EIDISABLE
, (brdp
->iobase
+ ONB_EICONFR
));
3746 outb(0x1, brdp
->iobase
);
3748 stli_onbeenable(brdp
);
3754 brdp
->memsize
= ECP_MEMSIZE
;
3757 * Board shared memory is enabled, so now we have a poke around and
3758 * see if we can find it.
3760 for (i
= 0; (i
< stli_eisamempsize
); i
++) {
3761 brdp
->memaddr
= stli_eisamemprobeaddrs
[i
];
3762 brdp
->membase
= ioremap(brdp
->memaddr
, brdp
->memsize
);
3763 if (brdp
->membase
== NULL
)
3766 if (brdp
->brdtype
== BRD_ECPE
) {
3767 ecpsigp
= stli_ecpeigetmemptr(brdp
,
3768 CDK_SIGADDR
, __LINE__
);
3769 memcpy_fromio(&ecpsig
, ecpsigp
, sizeof(cdkecpsig_t
));
3770 if (ecpsig
.magic
== cpu_to_le32(ECP_MAGIC
))
3773 onbsigp
= (cdkonbsig_t __iomem
*) stli_onbegetmemptr(brdp
,
3774 CDK_SIGADDR
, __LINE__
);
3775 memcpy_fromio(&onbsig
, onbsigp
, sizeof(cdkonbsig_t
));
3776 if ((onbsig
.magic0
== cpu_to_le16(ONB_MAGIC0
)) &&
3777 (onbsig
.magic1
== cpu_to_le16(ONB_MAGIC1
)) &&
3778 (onbsig
.magic2
== cpu_to_le16(ONB_MAGIC2
)) &&
3779 (onbsig
.magic3
== cpu_to_le16(ONB_MAGIC3
)))
3783 iounmap(brdp
->membase
);
3789 * Regardless of whether we found the shared memory or not we must
3790 * disable the region. After that return success or failure.
3792 if (brdp
->brdtype
== BRD_ECPE
)
3793 stli_ecpeidisable(brdp
);
3795 stli_onbedisable(brdp
);
3799 brdp
->membase
= NULL
;
3800 printk(KERN_ERR
"STALLION: failed to probe shared memory "
3801 "region for %s in EISA slot=%d\n",
3802 stli_brdnames
[brdp
->brdtype
], (brdp
->iobase
>> 12));
3808 static int stli_getbrdnr(void)
3812 for (i
= 0; i
< STL_MAXBRDS
; i
++) {
3813 if (!stli_brds
[i
]) {
3814 if (i
>= stli_nrbrds
)
3815 stli_nrbrds
= i
+ 1;
3822 /*****************************************************************************/
3825 * Probe around and try to find any EISA boards in system. The biggest
3826 * problem here is finding out what memory address is associated with
3827 * an EISA board after it is found. The registers of the ECPE and
3828 * ONboardE are not readable - so we can't read them from there. We
3829 * don't have access to the EISA CMOS (or EISA BIOS) so we don't
3830 * actually have any way to find out the real value. The best we can
3831 * do is go probing around in the usual places hoping we can find it.
3834 static int stli_findeisabrds(void)
3836 struct stlibrd
*brdp
;
3837 unsigned int iobase
, eid
, i
;
3841 * Firstly check if this is an EISA system. If this is not an EISA system then
3842 * don't bother going any further!
3848 * Looks like an EISA system, so go searching for EISA boards.
3850 for (iobase
= 0x1000; (iobase
<= 0xc000); iobase
+= 0x1000) {
3851 outb(0xff, (iobase
+ 0xc80));
3852 eid
= inb(iobase
+ 0xc80);
3853 eid
|= inb(iobase
+ 0xc81) << 8;
3854 if (eid
!= STL_EISAID
)
3858 * We have found a board. Need to check if this board was
3859 * statically configured already (just in case!).
3861 for (i
= 0; (i
< STL_MAXBRDS
); i
++) {
3862 brdp
= stli_brds
[i
];
3865 if (brdp
->iobase
== iobase
)
3868 if (i
< STL_MAXBRDS
)
3872 * We have found a Stallion board and it is not configured already.
3873 * Allocate a board structure and initialize it.
3875 if ((brdp
= stli_allocbrd()) == NULL
)
3877 brdnr
= stli_getbrdnr();
3880 brdp
->brdnr
= (unsigned int)brdnr
;
3881 eid
= inb(iobase
+ 0xc82);
3882 if (eid
== ECP_EISAID
)
3883 brdp
->brdtype
= BRD_ECPE
;
3884 else if (eid
== ONB_EISAID
)
3885 brdp
->brdtype
= BRD_ONBOARDE
;
3887 brdp
->brdtype
= BRD_UNKNOWN
;
3888 brdp
->iobase
= iobase
;
3889 outb(0x1, (iobase
+ 0xc84));
3890 if (stli_eisamemprobe(brdp
))
3891 outb(0, (iobase
+ 0xc84));
3898 /*****************************************************************************/
3901 * Find the next available board number that is free.
3904 /*****************************************************************************/
3907 * We have a Stallion board. Allocate a board structure and
3908 * initialize it. Read its IO and MEMORY resources from PCI
3909 * configuration space.
3912 static int __devinit
stli_pciprobe(struct pci_dev
*pdev
,
3913 const struct pci_device_id
*ent
)
3915 struct stlibrd
*brdp
;
3916 int brdnr
, retval
= -EIO
;
3918 retval
= pci_enable_device(pdev
);
3921 brdp
= stli_allocbrd();
3926 brdnr
= stli_getbrdnr();
3927 if (brdnr
< 0) { /* TODO: locking */
3928 printk(KERN_INFO
"STALLION: too many boards found, "
3929 "maximum supported %d\n", STL_MAXBRDS
);
3933 brdp
->brdnr
= (unsigned int)brdnr
;
3934 brdp
->brdtype
= BRD_ECPPCI
;
3936 * We have all resources from the board, so lets setup the actual
3937 * board structure now.
3939 brdp
->iobase
= pci_resource_start(pdev
, 3);
3940 brdp
->memaddr
= pci_resource_start(pdev
, 2);
3941 retval
= stli_brdinit(brdp
);
3945 pci_set_drvdata(pdev
, brdp
);
3954 static void stli_pciremove(struct pci_dev
*pdev
)
3956 struct stlibrd
*brdp
= pci_get_drvdata(pdev
);
3958 stli_cleanup_ports(brdp
);
3960 iounmap(brdp
->membase
);
3961 if (brdp
->iosize
> 0)
3962 release_region(brdp
->iobase
, brdp
->iosize
);
3964 stli_brds
[brdp
->brdnr
] = NULL
;
3968 static struct pci_driver stli_pcidriver
= {
3969 .name
= "istallion",
3970 .id_table
= istallion_pci_tbl
,
3971 .probe
= stli_pciprobe
,
3972 .remove
= __devexit_p(stli_pciremove
)
3974 /*****************************************************************************/
3977 * Allocate a new board structure. Fill out the basic info in it.
3980 static struct stlibrd
*stli_allocbrd(void)
3982 struct stlibrd
*brdp
;
3984 brdp
= kzalloc(sizeof(struct stlibrd
), GFP_KERNEL
);
3986 printk(KERN_ERR
"STALLION: failed to allocate memory "
3987 "(size=%Zd)\n", sizeof(struct stlibrd
));
3990 brdp
->magic
= STLI_BOARDMAGIC
;
3994 /*****************************************************************************/
3997 * Scan through all the boards in the configuration and see what we
4001 static int stli_initbrds(void)
4003 struct stlibrd
*brdp
, *nxtbrdp
;
4004 struct stlconf conf
;
4008 for (stli_nrbrds
= 0; stli_nrbrds
< ARRAY_SIZE(stli_brdsp
);
4010 memset(&conf
, 0, sizeof(conf
));
4011 if (stli_parsebrd(&conf
, stli_brdsp
[stli_nrbrds
]) == 0)
4013 if ((brdp
= stli_allocbrd()) == NULL
)
4015 brdp
->brdnr
= stli_nrbrds
;
4016 brdp
->brdtype
= conf
.brdtype
;
4017 brdp
->iobase
= conf
.ioaddr1
;
4018 brdp
->memaddr
= conf
.memaddr
;
4023 stli_findeisabrds();
4025 retval
= pci_register_driver(&stli_pcidriver
);
4026 /* TODO: check retval and do something */
4029 * All found boards are initialized. Now for a little optimization, if
4030 * no boards are sharing the "shared memory" regions then we can just
4031 * leave them all enabled. This is in fact the usual case.
4034 if (stli_nrbrds
> 1) {
4035 for (i
= 0; (i
< stli_nrbrds
); i
++) {
4036 brdp
= stli_brds
[i
];
4039 for (j
= i
+ 1; (j
< stli_nrbrds
); j
++) {
4040 nxtbrdp
= stli_brds
[j
];
4041 if (nxtbrdp
== NULL
)
4043 if ((brdp
->membase
>= nxtbrdp
->membase
) &&
4044 (brdp
->membase
<= (nxtbrdp
->membase
+
4045 nxtbrdp
->memsize
- 1))) {
4053 if (stli_shared
== 0) {
4054 for (i
= 0; (i
< stli_nrbrds
); i
++) {
4055 brdp
= stli_brds
[i
];
4058 if (brdp
->state
& BST_FOUND
) {
4060 brdp
->enable
= NULL
;
4061 brdp
->disable
= NULL
;
4069 /*****************************************************************************/
4072 * Code to handle an "staliomem" read operation. This device is the
4073 * contents of the board shared memory. It is used for down loading
4074 * the slave image (and debugging :-)
4077 static ssize_t
stli_memread(struct file
*fp
, char __user
*buf
, size_t count
, loff_t
*offp
)
4079 unsigned long flags
;
4080 void __iomem
*memptr
;
4081 struct stlibrd
*brdp
;
4087 brdnr
= iminor(fp
->f_path
.dentry
->d_inode
);
4088 if (brdnr
>= stli_nrbrds
)
4090 brdp
= stli_brds
[brdnr
];
4093 if (brdp
->state
== 0)
4095 if (off
>= brdp
->memsize
|| off
+ count
< off
)
4098 size
= min(count
, (size_t)(brdp
->memsize
- off
));
4101 * Copy the data a page at a time
4104 p
= (void *)__get_free_page(GFP_KERNEL
);
4109 spin_lock_irqsave(&brd_lock
, flags
);
4111 memptr
= EBRDGETMEMPTR(brdp
, off
);
4112 n
= min(size
, (int)(brdp
->pagesize
- (((unsigned long) off
) % brdp
->pagesize
)));
4113 n
= min(n
, (int)PAGE_SIZE
);
4114 memcpy_fromio(p
, memptr
, n
);
4116 spin_unlock_irqrestore(&brd_lock
, flags
);
4117 if (copy_to_user(buf
, p
, n
)) {
4127 free_page((unsigned long)p
);
4131 /*****************************************************************************/
4134 * Code to handle an "staliomem" write operation. This device is the
4135 * contents of the board shared memory. It is used for down loading
4136 * the slave image (and debugging :-)
4138 * FIXME: copy under lock
4141 static ssize_t
stli_memwrite(struct file
*fp
, const char __user
*buf
, size_t count
, loff_t
*offp
)
4143 unsigned long flags
;
4144 void __iomem
*memptr
;
4145 struct stlibrd
*brdp
;
4152 brdnr
= iminor(fp
->f_path
.dentry
->d_inode
);
4154 if (brdnr
>= stli_nrbrds
)
4156 brdp
= stli_brds
[brdnr
];
4159 if (brdp
->state
== 0)
4161 if (off
>= brdp
->memsize
|| off
+ count
< off
)
4164 chbuf
= (char __user
*) buf
;
4165 size
= min(count
, (size_t)(brdp
->memsize
- off
));
4168 * Copy the data a page at a time
4171 p
= (void *)__get_free_page(GFP_KERNEL
);
4176 n
= min(size
, (int)(brdp
->pagesize
- (((unsigned long) off
) % brdp
->pagesize
)));
4177 n
= min(n
, (int)PAGE_SIZE
);
4178 if (copy_from_user(p
, chbuf
, n
)) {
4183 spin_lock_irqsave(&brd_lock
, flags
);
4185 memptr
= EBRDGETMEMPTR(brdp
, off
);
4186 memcpy_toio(memptr
, p
, n
);
4188 spin_unlock_irqrestore(&brd_lock
, flags
);
4194 free_page((unsigned long) p
);
4199 /*****************************************************************************/
4202 * Return the board stats structure to user app.
4205 static int stli_getbrdstats(combrd_t __user
*bp
)
4207 struct stlibrd
*brdp
;
4210 if (copy_from_user(&stli_brdstats
, bp
, sizeof(combrd_t
)))
4212 if (stli_brdstats
.brd
>= STL_MAXBRDS
)
4214 brdp
= stli_brds
[stli_brdstats
.brd
];
4218 memset(&stli_brdstats
, 0, sizeof(combrd_t
));
4219 stli_brdstats
.brd
= brdp
->brdnr
;
4220 stli_brdstats
.type
= brdp
->brdtype
;
4221 stli_brdstats
.hwid
= 0;
4222 stli_brdstats
.state
= brdp
->state
;
4223 stli_brdstats
.ioaddr
= brdp
->iobase
;
4224 stli_brdstats
.memaddr
= brdp
->memaddr
;
4225 stli_brdstats
.nrpanels
= brdp
->nrpanels
;
4226 stli_brdstats
.nrports
= brdp
->nrports
;
4227 for (i
= 0; (i
< brdp
->nrpanels
); i
++) {
4228 stli_brdstats
.panels
[i
].panel
= i
;
4229 stli_brdstats
.panels
[i
].hwid
= brdp
->panelids
[i
];
4230 stli_brdstats
.panels
[i
].nrports
= brdp
->panels
[i
];
4233 if (copy_to_user(bp
, &stli_brdstats
, sizeof(combrd_t
)))
4238 /*****************************************************************************/
4241 * Resolve the referenced port number into a port struct pointer.
4244 static struct stliport
*stli_getport(unsigned int brdnr
, unsigned int panelnr
,
4245 unsigned int portnr
)
4247 struct stlibrd
*brdp
;
4250 if (brdnr
>= STL_MAXBRDS
)
4252 brdp
= stli_brds
[brdnr
];
4255 for (i
= 0; (i
< panelnr
); i
++)
4256 portnr
+= brdp
->panels
[i
];
4257 if (portnr
>= brdp
->nrports
)
4259 return brdp
->ports
[portnr
];
4262 /*****************************************************************************/
4265 * Return the port stats structure to user app. A NULL port struct
4266 * pointer passed in means that we need to find out from the app
4267 * what port to get stats for (used through board control device).
4270 static int stli_portcmdstats(struct stliport
*portp
)
4272 unsigned long flags
;
4273 struct stlibrd
*brdp
;
4276 memset(&stli_comstats
, 0, sizeof(comstats_t
));
4280 brdp
= stli_brds
[portp
->brdnr
];
4284 if (brdp
->state
& BST_STARTED
) {
4285 if ((rc
= stli_cmdwait(brdp
, portp
, A_GETSTATS
,
4286 &stli_cdkstats
, sizeof(asystats_t
), 1)) < 0)
4289 memset(&stli_cdkstats
, 0, sizeof(asystats_t
));
4292 stli_comstats
.brd
= portp
->brdnr
;
4293 stli_comstats
.panel
= portp
->panelnr
;
4294 stli_comstats
.port
= portp
->portnr
;
4295 stli_comstats
.state
= portp
->state
;
4296 stli_comstats
.flags
= portp
->flags
;
4298 spin_lock_irqsave(&brd_lock
, flags
);
4299 if (portp
->tty
!= NULL
) {
4300 if (portp
->tty
->driver_data
== portp
) {
4301 stli_comstats
.ttystate
= portp
->tty
->flags
;
4302 stli_comstats
.rxbuffered
= -1;
4303 if (portp
->tty
->termios
!= NULL
) {
4304 stli_comstats
.cflags
= portp
->tty
->termios
->c_cflag
;
4305 stli_comstats
.iflags
= portp
->tty
->termios
->c_iflag
;
4306 stli_comstats
.oflags
= portp
->tty
->termios
->c_oflag
;
4307 stli_comstats
.lflags
= portp
->tty
->termios
->c_lflag
;
4311 spin_unlock_irqrestore(&brd_lock
, flags
);
4313 stli_comstats
.txtotal
= stli_cdkstats
.txchars
;
4314 stli_comstats
.rxtotal
= stli_cdkstats
.rxchars
+ stli_cdkstats
.ringover
;
4315 stli_comstats
.txbuffered
= stli_cdkstats
.txringq
;
4316 stli_comstats
.rxbuffered
+= stli_cdkstats
.rxringq
;
4317 stli_comstats
.rxoverrun
= stli_cdkstats
.overruns
;
4318 stli_comstats
.rxparity
= stli_cdkstats
.parity
;
4319 stli_comstats
.rxframing
= stli_cdkstats
.framing
;
4320 stli_comstats
.rxlost
= stli_cdkstats
.ringover
;
4321 stli_comstats
.rxbreaks
= stli_cdkstats
.rxbreaks
;
4322 stli_comstats
.txbreaks
= stli_cdkstats
.txbreaks
;
4323 stli_comstats
.txxon
= stli_cdkstats
.txstart
;
4324 stli_comstats
.txxoff
= stli_cdkstats
.txstop
;
4325 stli_comstats
.rxxon
= stli_cdkstats
.rxstart
;
4326 stli_comstats
.rxxoff
= stli_cdkstats
.rxstop
;
4327 stli_comstats
.rxrtsoff
= stli_cdkstats
.rtscnt
/ 2;
4328 stli_comstats
.rxrtson
= stli_cdkstats
.rtscnt
- stli_comstats
.rxrtsoff
;
4329 stli_comstats
.modem
= stli_cdkstats
.dcdcnt
;
4330 stli_comstats
.hwid
= stli_cdkstats
.hwid
;
4331 stli_comstats
.signals
= stli_mktiocm(stli_cdkstats
.signals
);
4336 /*****************************************************************************/
4339 * Return the port stats structure to user app. A NULL port struct
4340 * pointer passed in means that we need to find out from the app
4341 * what port to get stats for (used through board control device).
4344 static int stli_getportstats(struct stliport
*portp
, comstats_t __user
*cp
)
4346 struct stlibrd
*brdp
;
4350 if (copy_from_user(&stli_comstats
, cp
, sizeof(comstats_t
)))
4352 portp
= stli_getport(stli_comstats
.brd
, stli_comstats
.panel
,
4353 stli_comstats
.port
);
4358 brdp
= stli_brds
[portp
->brdnr
];
4362 if ((rc
= stli_portcmdstats(portp
)) < 0)
4365 return copy_to_user(cp
, &stli_comstats
, sizeof(comstats_t
)) ?
4369 /*****************************************************************************/
4372 * Clear the port stats structure. We also return it zeroed out...
4375 static int stli_clrportstats(struct stliport
*portp
, comstats_t __user
*cp
)
4377 struct stlibrd
*brdp
;
4381 if (copy_from_user(&stli_comstats
, cp
, sizeof(comstats_t
)))
4383 portp
= stli_getport(stli_comstats
.brd
, stli_comstats
.panel
,
4384 stli_comstats
.port
);
4389 brdp
= stli_brds
[portp
->brdnr
];
4393 if (brdp
->state
& BST_STARTED
) {
4394 if ((rc
= stli_cmdwait(brdp
, portp
, A_CLEARSTATS
, NULL
, 0, 0)) < 0)
4398 memset(&stli_comstats
, 0, sizeof(comstats_t
));
4399 stli_comstats
.brd
= portp
->brdnr
;
4400 stli_comstats
.panel
= portp
->panelnr
;
4401 stli_comstats
.port
= portp
->portnr
;
4403 if (copy_to_user(cp
, &stli_comstats
, sizeof(comstats_t
)))
4408 /*****************************************************************************/
4411 * Return the entire driver ports structure to a user app.
4414 static int stli_getportstruct(struct stliport __user
*arg
)
4416 struct stliport stli_dummyport
;
4417 struct stliport
*portp
;
4419 if (copy_from_user(&stli_dummyport
, arg
, sizeof(struct stliport
)))
4421 portp
= stli_getport(stli_dummyport
.brdnr
, stli_dummyport
.panelnr
,
4422 stli_dummyport
.portnr
);
4425 if (copy_to_user(arg
, portp
, sizeof(struct stliport
)))
4430 /*****************************************************************************/
4433 * Return the entire driver board structure to a user app.
4436 static int stli_getbrdstruct(struct stlibrd __user
*arg
)
4438 struct stlibrd stli_dummybrd
;
4439 struct stlibrd
*brdp
;
4441 if (copy_from_user(&stli_dummybrd
, arg
, sizeof(struct stlibrd
)))
4443 if (stli_dummybrd
.brdnr
>= STL_MAXBRDS
)
4445 brdp
= stli_brds
[stli_dummybrd
.brdnr
];
4448 if (copy_to_user(arg
, brdp
, sizeof(struct stlibrd
)))
4453 /*****************************************************************************/
4456 * The "staliomem" device is also required to do some special operations on
4457 * the board. We need to be able to send an interrupt to the board,
4458 * reset it, and start/stop it.
4461 static int stli_memioctl(struct inode
*ip
, struct file
*fp
, unsigned int cmd
, unsigned long arg
)
4463 struct stlibrd
*brdp
;
4464 int brdnr
, rc
, done
;
4465 void __user
*argp
= (void __user
*)arg
;
4468 * First up handle the board independent ioctls.
4474 case COM_GETPORTSTATS
:
4475 rc
= stli_getportstats(NULL
, argp
);
4478 case COM_CLRPORTSTATS
:
4479 rc
= stli_clrportstats(NULL
, argp
);
4482 case COM_GETBRDSTATS
:
4483 rc
= stli_getbrdstats(argp
);
4487 rc
= stli_getportstruct(argp
);
4491 rc
= stli_getbrdstruct(argp
);
4500 * Now handle the board specific ioctls. These all depend on the
4501 * minor number of the device they were called from.
4504 if (brdnr
>= STL_MAXBRDS
)
4506 brdp
= stli_brds
[brdnr
];
4509 if (brdp
->state
== 0)
4517 rc
= stli_startbrd(brdp
);
4520 brdp
->state
&= ~BST_STARTED
;
4523 brdp
->state
&= ~BST_STARTED
;
4525 if (stli_shared
== 0) {
4526 if (brdp
->reenable
!= NULL
)
4527 (* brdp
->reenable
)(brdp
);
4537 static const struct tty_operations stli_ops
= {
4539 .close
= stli_close
,
4540 .write
= stli_write
,
4541 .put_char
= stli_putchar
,
4542 .flush_chars
= stli_flushchars
,
4543 .write_room
= stli_writeroom
,
4544 .chars_in_buffer
= stli_charsinbuffer
,
4545 .ioctl
= stli_ioctl
,
4546 .set_termios
= stli_settermios
,
4547 .throttle
= stli_throttle
,
4548 .unthrottle
= stli_unthrottle
,
4550 .start
= stli_start
,
4551 .hangup
= stli_hangup
,
4552 .flush_buffer
= stli_flushbuffer
,
4553 .break_ctl
= stli_breakctl
,
4554 .wait_until_sent
= stli_waituntilsent
,
4555 .send_xchar
= stli_sendxchar
,
4556 .read_proc
= stli_readproc
,
4557 .tiocmget
= stli_tiocmget
,
4558 .tiocmset
= stli_tiocmset
,
4561 /*****************************************************************************/
4563 static int __init
stli_init(void)
4566 printk(KERN_INFO
"%s: version %s\n", stli_drvtitle
, stli_drvversion
);
4568 spin_lock_init(&stli_lock
);
4569 spin_lock_init(&brd_lock
);
4573 stli_serial
= alloc_tty_driver(STL_MAXBRDS
* STL_MAXPORTS
);
4578 * Allocate a temporary write buffer.
4580 stli_txcookbuf
= kmalloc(STLI_TXBUFSIZE
, GFP_KERNEL
);
4581 if (!stli_txcookbuf
)
4582 printk(KERN_ERR
"STALLION: failed to allocate memory "
4583 "(size=%d)\n", STLI_TXBUFSIZE
);
4586 * Set up a character driver for the shared memory region. We need this
4587 * to down load the slave code image. Also it is a useful debugging tool.
4589 if (register_chrdev(STL_SIOMEMMAJOR
, "staliomem", &stli_fsiomem
))
4590 printk(KERN_ERR
"STALLION: failed to register serial memory "
4593 istallion_class
= class_create(THIS_MODULE
, "staliomem");
4594 for (i
= 0; i
< 4; i
++)
4595 class_device_create(istallion_class
, NULL
,
4596 MKDEV(STL_SIOMEMMAJOR
, i
),
4597 NULL
, "staliomem%d", i
);
4600 * Set up the tty driver structure and register us as a driver.
4602 stli_serial
->owner
= THIS_MODULE
;
4603 stli_serial
->driver_name
= stli_drvname
;
4604 stli_serial
->name
= stli_serialname
;
4605 stli_serial
->major
= STL_SERIALMAJOR
;
4606 stli_serial
->minor_start
= 0;
4607 stli_serial
->type
= TTY_DRIVER_TYPE_SERIAL
;
4608 stli_serial
->subtype
= SERIAL_TYPE_NORMAL
;
4609 stli_serial
->init_termios
= stli_deftermios
;
4610 stli_serial
->flags
= TTY_DRIVER_REAL_RAW
;
4611 tty_set_operations(stli_serial
, &stli_ops
);
4613 if (tty_register_driver(stli_serial
)) {
4614 put_tty_driver(stli_serial
);
4615 printk(KERN_ERR
"STALLION: failed to register serial driver\n");
4621 /*****************************************************************************/