1 /*****************************************************************************/
4 * istallion.c -- stallion intelligent multiport serial driver.
6 * Copyright (c) 1994-1998 Greg Ungerer (gerg@stallion.oz.au).
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by Greg Ungerer.
20 * 4. Neither the name of the author nor the names of any co-contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * $FreeBSD: src/sys/i386/isa/istallion.c,v 1.36.2.2 2001/08/30 12:29:57 murray Exp $
37 * $DragonFly: src/sys/dev/serial/stli/istallion.c,v 1.21 2006/12/22 23:26:25 swildner Exp $
40 /*****************************************************************************/
42 #include "opt_compat.h"
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/kernel.h>
49 #include <sys/malloc.h>
53 #include <sys/fcntl.h>
55 #include <sys/thread2.h>
56 #include <machine/clock.h>
59 #include <bus/isa/i386/isa_device.h>
60 #include <machine/cdk.h>
61 #include <machine/comstats.h>
65 /*****************************************************************************/
68 * Define the version level of the kernel - so we can compile in the
69 * appropriate bits of code. By default this will compile for a 2.1
80 /*****************************************************************************/
83 * Define different board types. Not all of the following board types
84 * are supported by this driver. But I will use the standard "assigned"
85 * board numbers. Currently supported boards are abbreviated as:
86 * ECP = EasyConnection 8/64, ONB = ONboard, BBY = Brumby and
90 #define BRD_STALLION 1
92 #define BRD_ONBOARD2 3
95 #define BRD_BRUMBY16 6
96 #define BRD_ONBOARDE 7
97 #define BRD_ONBOARD32 9
98 #define BRD_ONBOARD2_32 10
99 #define BRD_ONBOARDRS 11
100 #define BRD_EASYIO 20
105 #define BRD_ECHPCI 26
106 #define BRD_ECH64PCI 27
107 #define BRD_EASYIOPCI 28
109 #define BRD_BRUMBY BRD_BRUMBY4
111 /*****************************************************************************/
114 * Define important driver limitations.
116 #define STL_MAXBRDS 8
117 #define STL_MAXPANELS 4
118 #define STL_PORTSPERPANEL 16
119 #define STL_PORTSPERBRD 64
121 #define STL_MAXCHANS STL_PORTSPERBRD
125 * Define the important minor number break down bits. These have been
126 * chosen to be "compatible" with the standard sio driver minor numbers.
127 * Extra high bits are used to distinguish between boards and also for
128 * really high port numbers (> 32).
130 #define STL_CALLOUTDEV 0x80
131 #define STL_CTRLLOCK 0x40
132 #define STL_CTRLINIT 0x20
133 #define STL_CTRLDEV (STL_CTRLLOCK | STL_CTRLINIT)
135 #define STL_MEMDEV 0x07000000
137 #define STL_DEFSPEED TTYDEF_SPEED
138 #define STL_DEFCFLAG (CS8 | CREAD | HUPCL)
140 /*****************************************************************************/
143 * Define our local driver identity first. Set up stuff to deal with
144 * all the local structures required by a serial tty driver.
146 static char stli_drvname
[] = "stli";
147 static char const stli_drvtitle
[] = "Stallion Multiport Serial Driver";
148 static char const stli_drvversion
[] = "2.0.0";
150 static int stli_nrbrds
= 0;
151 static int stli_doingtimeout
= 0;
152 static struct callout stli_poll_ch
;
155 * Define some macros to use to class define boards.
161 static unsigned char stli_stliprobed
[STL_MAXBRDS
];
163 /*****************************************************************************/
166 * Define a set of structures to hold all the board/panel/port info
167 * for our ports. These will be dynamically allocated as required at
168 * driver initialization time.
172 * Port and board structures to hold status info about each object.
173 * The board structure contains pointers to structures for each port
174 * connected to it. Panels are not distinguished here, since
175 * communication with the slave board will always be on a per port
195 struct termios initintios
;
196 struct termios initouttios
;
197 struct termios lockintios
;
198 struct termios lockouttios
;
199 struct timeval timestamp
;
202 unsigned long rxlost
;
203 unsigned long rxoffset
;
204 unsigned long txoffset
;
208 unsigned char reqidx
;
209 unsigned char reqbit
;
210 unsigned char portidx
;
211 unsigned char portbit
;
212 struct callout dtr_ch
;
216 * Use a structure of function pointers to do board level operations.
217 * These include, enable/disable, paging shared memory, interrupting, etc.
219 typedef struct stlibrd
{
236 void (*init
)(struct stlibrd
*brdp
);
237 void (*enable
)(struct stlibrd
*brdp
);
238 void (*reenable
)(struct stlibrd
*brdp
);
239 void (*disable
)(struct stlibrd
*brdp
);
240 void (*intr
)(struct stlibrd
*brdp
);
241 void (*reset
)(struct stlibrd
*brdp
);
242 char *(*getmemptr
)(struct stlibrd
*brdp
,
243 unsigned long offset
, int line
);
244 int panels
[STL_MAXPANELS
];
245 int panelids
[STL_MAXPANELS
];
246 stliport_t
*ports
[STL_PORTSPERBRD
];
249 static stlibrd_t
*stli_brds
[STL_MAXBRDS
];
251 static int stli_shared
= 0;
254 * Keep a local char buffer for processing chars into the LD. We
255 * do this to avoid copying from the boards shared memory one char
258 static int stli_rxtmplen
;
259 static stliport_t
*stli_rxtmpport
;
260 static char stli_rxtmpbuf
[TTYHOG
];
263 * Define global stats structures. Not used often, and can be re-used
264 * for each stats call.
266 static comstats_t stli_comstats
;
267 static combrd_t stli_brdstats
;
268 static asystats_t stli_cdkstats
;
271 * Per board state flags. Used with the state field of the board struct.
272 * Not really much here... All we need to do is keep track of whether
273 * the board has been detected, and whether it is actully running a slave
276 #define BST_FOUND 0x1
277 #define BST_STARTED 0x2
280 * Define the set of port state flags. These are marked for internal
281 * state purposes only, usually to do with the state of communications
282 * with the slave. They need to be updated atomically.
284 #define ST_INITIALIZING 0x1
285 #define ST_INITIALIZED 0x2
286 #define ST_OPENING 0x4
287 #define ST_CLOSING 0x8
288 #define ST_CMDING 0x10
289 #define ST_RXING 0x20
290 #define ST_TXBUSY 0x40
291 #define ST_DOFLUSHRX 0x80
292 #define ST_DOFLUSHTX 0x100
293 #define ST_DOSIGS 0x200
294 #define ST_GETSIGS 0x400
295 #define ST_DTRWAIT 0x800
298 * Define an array of board names as printable strings. Handy for
299 * referencing boards when printing trace and stuff.
301 static char *stli_brdnames
[] = {
331 /*****************************************************************************/
334 * Hardware configuration info for ECP boards. These defines apply
335 * to the directly accessable io ports of the ECP. There is a set of
336 * defines for each ECP board type, ISA and EISA.
339 #define ECP_MEMSIZE (128 * 1024)
340 #define ECP_ATPAGESIZE (4 * 1024)
341 #define ECP_EIPAGESIZE (64 * 1024)
343 #define STL_EISAID 0x8c4e
346 * Important defines for the ISA class of ECP board.
349 #define ECP_ATCONFR 1
350 #define ECP_ATMEMAR 2
351 #define ECP_ATMEMPR 3
352 #define ECP_ATSTOP 0x1
353 #define ECP_ATINTENAB 0x10
354 #define ECP_ATENABLE 0x20
355 #define ECP_ATDISABLE 0x00
356 #define ECP_ATADDRMASK 0x3f000
357 #define ECP_ATADDRSHFT 12
360 * Important defines for the EISA class of ECP board.
363 #define ECP_EIMEMARL 1
364 #define ECP_EICONFR 2
365 #define ECP_EIMEMARH 3
366 #define ECP_EIENABLE 0x1
367 #define ECP_EIDISABLE 0x0
368 #define ECP_EISTOP 0x4
369 #define ECP_EIEDGE 0x00
370 #define ECP_EILEVEL 0x80
371 #define ECP_EIADDRMASKL 0x00ff0000
372 #define ECP_EIADDRSHFTL 16
373 #define ECP_EIADDRMASKH 0xff000000
374 #define ECP_EIADDRSHFTH 24
375 #define ECP_EIBRDENAB 0xc84
377 #define ECP_EISAID 0x4
380 * Important defines for the Micro-channel class of ECP board.
381 * (It has a lot in common with the ISA boards.)
384 #define ECP_MCCONFR 1
385 #define ECP_MCSTOP 0x20
386 #define ECP_MCENABLE 0x80
387 #define ECP_MCDISABLE 0x00
390 * Hardware configuration info for ONboard and Brumby boards. These
391 * defines apply to the directly accessable io ports of these boards.
393 #define ONB_IOSIZE 16
394 #define ONB_MEMSIZE (64 * 1024)
395 #define ONB_ATPAGESIZE (64 * 1024)
396 #define ONB_MCPAGESIZE (64 * 1024)
397 #define ONB_EIMEMSIZE (128 * 1024)
398 #define ONB_EIPAGESIZE (64 * 1024)
401 * Important defines for the ISA class of ONboard board.
404 #define ONB_ATMEMAR 1
405 #define ONB_ATCONFR 2
406 #define ONB_ATSTOP 0x4
407 #define ONB_ATENABLE 0x01
408 #define ONB_ATDISABLE 0x00
409 #define ONB_ATADDRMASK 0xff0000
410 #define ONB_ATADDRSHFT 16
412 #define ONB_HIMEMENAB 0x02
415 * Important defines for the EISA class of ONboard board.
418 #define ONB_EIMEMARL 1
419 #define ONB_EICONFR 2
420 #define ONB_EIMEMARH 3
421 #define ONB_EIENABLE 0x1
422 #define ONB_EIDISABLE 0x0
423 #define ONB_EISTOP 0x4
424 #define ONB_EIEDGE 0x00
425 #define ONB_EILEVEL 0x80
426 #define ONB_EIADDRMASKL 0x00ff0000
427 #define ONB_EIADDRSHFTL 16
428 #define ONB_EIADDRMASKH 0xff000000
429 #define ONB_EIADDRSHFTH 24
430 #define ONB_EIBRDENAB 0xc84
432 #define ONB_EISAID 0x1
435 * Important defines for the Brumby boards. They are pretty simple,
436 * there is not much that is programmably configurable.
438 #define BBY_IOSIZE 16
439 #define BBY_MEMSIZE (64 * 1024)
440 #define BBY_PAGESIZE (16 * 1024)
443 #define BBY_ATCONFR 1
444 #define BBY_ATSTOP 0x4
447 * Important defines for the Stallion boards. They are pretty simple,
448 * there is not much that is programmably configurable.
450 #define STAL_IOSIZE 16
451 #define STAL_MEMSIZE (64 * 1024)
452 #define STAL_PAGESIZE (64 * 1024)
455 * Define the set of status register values for EasyConnection panels.
456 * The signature will return with the status value for each panel. From
457 * this we can determine what is attached to the board - before we have
458 * actually down loaded any code to it.
460 #define ECH_PNLSTATUS 2
461 #define ECH_PNL16PORT 0x20
462 #define ECH_PNLIDMASK 0x07
463 #define ECH_PNLXPID 0x40
464 #define ECH_PNLINTRPEND 0x80
467 * Define some macros to do things to the board. Even those these boards
468 * are somewhat related there is often significantly different ways of
469 * doing some operation on it (like enable, paging, reset, etc). So each
470 * board class has a set of functions which do the commonly required
471 * operations. The macros below basically just call these functions,
472 * generally checking for a NULL function - which means that the board
473 * needs nothing done to it to achieve this operation!
475 #define EBRDINIT(brdp) \
476 if (brdp->init != NULL) \
479 #define EBRDENABLE(brdp) \
480 if (brdp->enable != NULL) \
481 (* brdp->enable)(brdp);
483 #define EBRDDISABLE(brdp) \
484 if (brdp->disable != NULL) \
485 (* brdp->disable)(brdp);
487 #define EBRDINTR(brdp) \
488 if (brdp->intr != NULL) \
489 (* brdp->intr)(brdp);
491 #define EBRDRESET(brdp) \
492 if (brdp->reset != NULL) \
493 (* brdp->reset)(brdp);
495 #define EBRDGETMEMPTR(brdp,offset) \
496 (* brdp->getmemptr)(brdp, offset, __LINE__)
499 * Define the maximal baud rate.
501 #define STL_MAXBAUD 230400
503 /*****************************************************************************/
506 * Define macros to extract a brd and port number from a minor number.
507 * This uses the extended minor number range in the upper 2 bytes of
508 * the device number. This gives us plenty of minor numbers to play
511 #define MKDEV2BRD(m) ((minor(m) & 0x00700000) >> 20)
512 #define MKDEV2PORT(m) ((minor(m) & 0x1f) | ((minor(m) & 0x00010000) >> 11))
515 * Define some handy local macros...
518 #define MIN(a,b) (((a) <= (b)) ? (a) : (b))
521 /*****************************************************************************/
524 * Declare all those functions in this driver! First up is the set of
525 * externally visible functions.
527 static int stliprobe(struct isa_device
*idp
);
528 static int stliattach(struct isa_device
*idp
);
530 STATIC d_open_t stliopen
;
531 STATIC d_close_t stliclose
;
532 STATIC d_read_t stliread
;
533 STATIC d_write_t stliwrite
;
534 STATIC d_ioctl_t stliioctl
;
537 * Internal function prototypes.
539 static stliport_t
*stli_dev2port(cdev_t dev
);
540 static int stli_isaprobe(struct isa_device
*idp
);
541 static int stli_eisaprobe(struct isa_device
*idp
);
542 static int stli_brdinit(stlibrd_t
*brdp
);
543 static int stli_brdattach(stlibrd_t
*brdp
);
544 static int stli_initecp(stlibrd_t
*brdp
);
545 static int stli_initonb(stlibrd_t
*brdp
);
546 static int stli_initports(stlibrd_t
*brdp
);
547 static int stli_startbrd(stlibrd_t
*brdp
);
548 static void stli_poll(void *arg
);
549 static __inline
void stli_brdpoll(stlibrd_t
*brdp
, volatile cdkhdr_t
*hdrp
);
550 static __inline
int stli_hostcmd(stlibrd_t
*brdp
, stliport_t
*portp
);
551 static __inline
void stli_dodelaycmd(stliport_t
*portp
,
552 volatile cdkctrl_t
*cp
);
553 static void stli_mkasysigs(asysigs_t
*sp
, int dtr
, int rts
);
554 static long stli_mktiocm(unsigned long sigvalue
);
555 static void stli_rxprocess(stlibrd_t
*brdp
, stliport_t
*portp
);
556 static void stli_flush(stliport_t
*portp
, int flag
);
557 static void stli_start(struct tty
*tp
);
558 static void stli_stop(struct tty
*tp
, int rw
);
559 static int stli_param(struct tty
*tp
, struct termios
*tiosp
);
560 static void stli_ttyoptim(stliport_t
*portp
, struct termios
*tiosp
);
561 static void stli_dtrwakeup(void *arg
);
562 static int stli_initopen(stliport_t
*portp
);
563 static int stli_shutdownclose(stliport_t
*portp
);
564 static int stli_rawopen(stlibrd_t
*brdp
, stliport_t
*portp
,
565 unsigned long arg
, int wait
);
566 static int stli_rawclose(stlibrd_t
*brdp
, stliport_t
*portp
,
567 unsigned long arg
, int wait
);
568 static int stli_cmdwait(stlibrd_t
*brdp
, stliport_t
*portp
,
569 unsigned long cmd
, void *arg
, int size
, int copyback
);
570 static void stli_sendcmd(stlibrd_t
*brdp
, stliport_t
*portp
,
571 unsigned long cmd
, void *arg
, int size
, int copyback
);
572 static void stli_mkasyport(stliport_t
*portp
, asyport_t
*pp
,
573 struct termios
*tiosp
);
574 static int stli_memrw(cdev_t dev
, struct uio
*uiop
, int flag
);
575 static int stli_memioctl(cdev_t dev
, unsigned long cmd
, caddr_t data
,
577 static int stli_getbrdstats(caddr_t data
);
578 static int stli_getportstats(stliport_t
*portp
, caddr_t data
);
579 static int stli_clrportstats(stliport_t
*portp
, caddr_t data
);
580 static stliport_t
*stli_getport(int brdnr
, int panelnr
, int portnr
);
582 static void stli_ecpinit(stlibrd_t
*brdp
);
583 static void stli_ecpenable(stlibrd_t
*brdp
);
584 static void stli_ecpdisable(stlibrd_t
*brdp
);
585 static void stli_ecpreset(stlibrd_t
*brdp
);
586 static char *stli_ecpgetmemptr(stlibrd_t
*brdp
, unsigned long offset
,
588 static void stli_ecpintr(stlibrd_t
*brdp
);
589 static void stli_ecpeiinit(stlibrd_t
*brdp
);
590 static void stli_ecpeienable(stlibrd_t
*brdp
);
591 static void stli_ecpeidisable(stlibrd_t
*brdp
);
592 static void stli_ecpeireset(stlibrd_t
*brdp
);
593 static char *stli_ecpeigetmemptr(stlibrd_t
*brdp
, unsigned long offset
,
595 static void stli_onbinit(stlibrd_t
*brdp
);
596 static void stli_onbenable(stlibrd_t
*brdp
);
597 static void stli_onbdisable(stlibrd_t
*brdp
);
598 static void stli_onbreset(stlibrd_t
*brdp
);
599 static char *stli_onbgetmemptr(stlibrd_t
*brdp
, unsigned long offset
,
601 static void stli_onbeinit(stlibrd_t
*brdp
);
602 static void stli_onbeenable(stlibrd_t
*brdp
);
603 static void stli_onbedisable(stlibrd_t
*brdp
);
604 static void stli_onbereset(stlibrd_t
*brdp
);
605 static char *stli_onbegetmemptr(stlibrd_t
*brdp
, unsigned long offset
,
607 static void stli_bbyinit(stlibrd_t
*brdp
);
608 static void stli_bbyreset(stlibrd_t
*brdp
);
609 static char *stli_bbygetmemptr(stlibrd_t
*brdp
, unsigned long offset
,
611 static void stli_stalinit(stlibrd_t
*brdp
);
612 static void stli_stalreset(stlibrd_t
*brdp
);
613 static char *stli_stalgetmemptr(stlibrd_t
*brdp
, unsigned long offset
,
616 /*****************************************************************************/
619 * Declare the driver isa structure.
621 struct isa_driver stlidriver
= {
622 stliprobe
, stliattach
, stli_drvname
625 /*****************************************************************************/
630 * FreeBSD-2.2+ kernel linkage.
633 #define CDEV_MAJOR 75
634 static struct dev_ops stli_ops
= {
635 { stli_drvname
, CDEV_MAJOR
, D_TTY
| D_KQFILTER
},
637 .d_close
= stliclose
,
639 .d_write
= stliwrite
,
640 .d_ioctl
= stliioctl
,
642 .d_kqfilter
= ttykqfilter
647 /*****************************************************************************/
649 static stlibrd_t
*stli_brdalloc(void)
653 brdp
= kmalloc(sizeof(stlibrd_t
), M_TTYS
, M_WAITOK
| M_ZERO
);
657 /*****************************************************************************/
660 * Find an available internal board number (unit number). The problem
661 * is that the same unit numbers can be assigned to different class
662 * boards - but we only want to maintain one setup board structures.
665 static int stli_findfreeunit(void)
669 for (i
= 0; (i
< STL_MAXBRDS
); i
++)
670 if (stli_brds
[i
] == (stlibrd_t
*) NULL
)
672 return((i
>= STL_MAXBRDS
) ? -1 : i
);
675 /*****************************************************************************/
678 * Try and determine the ISA board type. Hopefully the board
679 * configuration entry will help us out, using the flags field.
680 * If not, we may ne be able to determine the board type...
683 static int stli_isaprobe(struct isa_device
*idp
)
688 kprintf("stli_isaprobe(idp=%x): unit=%d iobase=%x flags=%x\n",
689 (int) idp
, idp
->id_unit
, idp
->id_iobase
, idp
->id_flags
);
692 switch (idp
->id_flags
) {
700 btype
= idp
->id_flags
;
709 /*****************************************************************************/
712 * Probe for an EISA board type. We should be able to read the EISA ID,
713 * that will tell us if a board is present or not...
716 static int stli_eisaprobe(struct isa_device
*idp
)
721 kprintf("stli_eisaprobe(idp=%x): unit=%d iobase=%x flags=%x\n",
722 (int) idp
, idp
->id_unit
, idp
->id_iobase
, idp
->id_flags
);
726 * Firstly check if this is an EISA system. Do this by probing for
727 * the system board EISA ID. If this is not an EISA system then
728 * don't bother going any further!
731 if (inb(0xc80) == 0xff)
735 * Try and read the EISA ID from the board at specified address.
736 * If one is present it will tell us the board type as well.
738 outb((idp
->id_iobase
+ 0xc80), 0xff);
739 eid
= inb(idp
->id_iobase
+ 0xc80);
740 eid
|= inb(idp
->id_iobase
+ 0xc81) << 8;
741 if (eid
!= STL_EISAID
)
745 eid
= inb(idp
->id_iobase
+ 0xc82);
746 if (eid
== ECP_EISAID
)
748 else if (eid
== ONB_EISAID
)
749 btype
= BRD_ONBOARDE
;
751 outb((idp
->id_iobase
+ 0xc84), 0x1);
755 /*****************************************************************************/
758 * Probe for a board. This is involved, since we need to enable the
759 * shared memory region to see if the board is really there or not...
762 static int stliprobe(struct isa_device
*idp
)
768 kprintf("stliprobe(idp=%x): unit=%d iobase=%x flags=%x\n", (int) idp
,
769 idp
->id_unit
, idp
->id_iobase
, idp
->id_flags
);
772 if (idp
->id_unit
> STL_MAXBRDS
)
776 * First up determine what bus type of board we might be dealing
777 * with. It is easy to separate out the ISA from the EISA
778 * boards, based on their IO addresses.
781 if ((idp
->id_iobase
> 0) && (idp
->id_iobase
< 0x400))
783 else if ((idp
->id_iobase
& ~0xf000) == 0)
786 if ((bclass
== 0) || (idp
->id_iobase
== 0))
790 * Based on the board bus type, try and figure out what it might be...
793 if (bclass
& BRD_ISA
)
794 btype
= stli_isaprobe(idp
);
795 if ((btype
== 0) && (bclass
& BRD_EISA
))
796 btype
= stli_eisaprobe(idp
);
801 * Go ahead and try probing for the shared memory region now.
802 * This way we will really know if the board is here...
804 if ((brdp
= stli_brdalloc()) == (stlibrd_t
*) NULL
)
807 brdp
->brdnr
= stli_findfreeunit();
808 brdp
->brdtype
= btype
;
809 brdp
->unitid
= idp
->id_unit
;
810 brdp
->iobase
= idp
->id_iobase
;
811 brdp
->vaddr
= idp
->id_maddr
;
812 brdp
->paddr
= vtophys(idp
->id_maddr
);
815 kprintf("%s(%d): btype=%x unit=%d brd=%d io=%x mem=%lx(%p)\n",
816 __file__
, __LINE__
, btype
, brdp
->unitid
, brdp
->brdnr
,
817 brdp
->iobase
, brdp
->paddr
, (void *) brdp
->vaddr
);
820 stli_stliprobed
[idp
->id_unit
] = brdp
->brdnr
;
822 if ((brdp
->state
& BST_FOUND
) == 0) {
823 stli_brds
[brdp
->brdnr
] = (stlibrd_t
*) NULL
;
830 /*****************************************************************************/
833 * Allocate resources for and initialize a board.
836 static int stliattach(struct isa_device
*idp
)
842 kprintf("stliattach(idp=%p): unit=%d iobase=%x\n", (void *) idp
,
843 idp
->id_unit
, idp
->id_iobase
);
846 brdnr
= stli_stliprobed
[idp
->id_unit
];
847 brdp
= stli_brds
[brdnr
];
848 if (brdp
== (stlibrd_t
*) NULL
)
850 if (brdp
->state
& BST_FOUND
)
851 stli_brdattach(brdp
);
856 /*****************************************************************************/
858 STATIC
int stliopen(struct dev_open_args
*ap
)
860 cdev_t dev
= ap
->a_head
.a_dev
;
866 kprintf("stliopen(dev=%x,flag=%x,mode=%x,p=%x)\n", (int) dev
, flag
,
871 * Firstly check if the supplied device number is a valid device.
873 if (minor(dev
) & STL_MEMDEV
)
876 portp
= stli_dev2port(dev
);
877 if (portp
== (stliport_t
*) NULL
)
879 if (minor(dev
) & STL_CTRLDEV
)
883 callout
= minor(dev
) & STL_CALLOUTDEV
;
890 * Wait here for the DTR drop timeout period to expire.
892 while (portp
->state
& ST_DTRWAIT
) {
893 error
= tsleep(&portp
->dtrwait
, PCATCH
, "stlidtr", 0);
899 * If the port is in its raw hardware initialization phase, then
900 * hold up here 'till it is done.
902 while (portp
->state
& (ST_INITIALIZING
| ST_CLOSING
)) {
903 error
= tsleep(&portp
->state
, PCATCH
, "stliraw", 0);
909 * We have a valid device, so now we check if it is already open.
910 * If not then initialize the port hardware and set up the tty
911 * struct as required.
913 if ((tp
->t_state
& TS_ISOPEN
) == 0) {
914 tp
->t_oproc
= stli_start
;
915 tp
->t_param
= stli_param
;
916 tp
->t_stop
= stli_stop
;
918 tp
->t_termios
= callout
? portp
->initouttios
:
920 stli_initopen(portp
);
921 wakeup(&portp
->state
);
923 if ((portp
->sigs
& TIOCM_CD
) || callout
)
924 (*linesw
[tp
->t_line
].l_modem
)(tp
, 1);
927 if (portp
->callout
== 0) {
932 if (portp
->callout
!= 0) {
933 if (ap
->a_oflags
& O_NONBLOCK
) {
937 error
= tsleep(&portp
->callout
,
938 PCATCH
, "stlicall", 0);
941 goto stliopen_restart
;
944 if ((tp
->t_state
& TS_XCLUDE
) &&
945 suser_cred(ap
->a_cred
, 0)) {
952 * If this port is not the callout device and we do not have carrier
953 * then we need to sleep, waiting for it to be asserted.
955 if (((tp
->t_state
& TS_CARR_ON
) == 0) && !callout
&&
956 ((tp
->t_cflag
& CLOCAL
) == 0) &&
957 ((ap
->a_oflags
& O_NONBLOCK
) == 0)) {
959 error
= tsleep(TSA_CARR_ON(tp
), PCATCH
, "stlidcd",0);
963 goto stliopen_restart
;
967 * Open the line discipline.
969 error
= (*linesw
[tp
->t_line
].l_open
)(dev
, tp
);
970 stli_ttyoptim(portp
, &tp
->t_termios
);
971 if ((tp
->t_state
& TS_ISOPEN
) && callout
)
975 * If for any reason we get to here and the port is not actually
976 * open then close of the physical hardware - no point leaving it
977 * active when the open failed...
981 if (((tp
->t_state
& TS_ISOPEN
) == 0) && (portp
->waitopens
== 0))
982 stli_shutdownclose(portp
);
987 /*****************************************************************************/
989 STATIC
int stliclose(struct dev_close_args
*ap
)
991 cdev_t dev
= ap
->a_head
.a_dev
;
996 kprintf("stliclose(dev=%s,flag=%x,mode=%x,p=%p)\n",
997 devtoname(dev
), flag
, mode
, (void *) p
);
1000 if (minor(dev
) & STL_MEMDEV
)
1002 if (minor(dev
) & STL_CTRLDEV
)
1005 portp
= stli_dev2port(dev
);
1006 if (portp
== (stliport_t
*) NULL
)
1011 (*linesw
[tp
->t_line
].l_close
)(tp
, ap
->a_fflag
);
1012 stli_ttyoptim(portp
, &tp
->t_termios
);
1013 stli_shutdownclose(portp
);
1020 STATIC
int stliread(struct dev_read_args
*ap
)
1022 cdev_t dev
= ap
->a_head
.a_dev
;
1026 kprintf("stliread(dev=%s,uiop=%p,flag=%x)\n", devtoname(dev
),
1030 if (minor(dev
) & STL_MEMDEV
)
1031 return(stli_memrw(dev
, ap
->a_uio
, ap
->a_ioflag
));
1032 if (minor(dev
) & STL_CTRLDEV
)
1035 portp
= stli_dev2port(dev
);
1036 if (portp
== (stliport_t
*) NULL
)
1041 /*****************************************************************************/
1045 STATIC
void stli_stop(struct tty
*tp
, int rw
)
1048 kprintf("stli_stop(tp=%x,rw=%x)\n", (int) tp
, rw
);
1051 stli_flush((stliport_t
*) tp
, rw
);
1056 STATIC
int stlistop(struct tty
*tp
, int rw
)
1059 kprintf("stlistop(tp=%x,rw=%x)\n", (int) tp
, rw
);
1062 stli_flush((stliport_t
*) tp
, rw
);
1068 /*****************************************************************************/
1070 STATIC
int stliwrite(struct dev_write_args
*ap
)
1072 cdev_t dev
= ap
->a_head
.a_dev
;
1076 kprintf("stliwrite(dev=%s,uiop=%p,flag=%x)\n", devtoname(dev
),
1080 if (minor(dev
) & STL_MEMDEV
)
1081 return(stli_memrw(dev
, ap
->a_uio
, ap
->a_ioflag
));
1082 if (minor(dev
) & STL_CTRLDEV
)
1084 portp
= stli_dev2port(dev
);
1085 if (portp
== (stliport_t
*) NULL
)
1087 return ttywrite(ap
);
1090 /*****************************************************************************/
1092 STATIC
int stliioctl(struct dev_ioctl_args
*ap
)
1094 cdev_t dev
= ap
->a_head
.a_dev
;
1095 u_long cmd
= ap
->a_cmd
;
1096 caddr_t data
= ap
->a_data
;
1097 struct termios
*newtios
, *localtios
;
1105 kprintf("stliioctl(dev=%s,cmd=%lx,data=%p,flag=%x,p=%p)\n",
1106 devtoname(dev
), cmd
, (void *) data
, ap
->a_fflag
, (void *) p
);
1109 if (minor(dev
) & STL_MEMDEV
)
1110 return(stli_memioctl(dev
, cmd
, data
, ap
->a_fflag
));
1112 portp
= stli_dev2port(dev
);
1113 if (portp
== (stliport_t
*) NULL
)
1115 if ((brdp
= stli_brds
[portp
->brdnr
]) == (stlibrd_t
*) NULL
)
1121 * First up handle ioctls on the control devices.
1123 if (minor(dev
) & STL_CTRLDEV
) {
1124 if ((minor(dev
) & STL_CTRLDEV
) == STL_CTRLINIT
)
1125 localtios
= (minor(dev
) & STL_CALLOUTDEV
) ?
1126 &portp
->initouttios
: &portp
->initintios
;
1127 else if ((minor(dev
) & STL_CTRLDEV
) == STL_CTRLLOCK
)
1128 localtios
= (minor(dev
) & STL_CALLOUTDEV
) ?
1129 &portp
->lockouttios
: &portp
->lockintios
;
1135 if ((error
= suser_cred(ap
->a_cred
, 0)) == 0)
1136 *localtios
= *((struct termios
*) data
);
1139 *((struct termios
*) data
) = *localtios
;
1142 *((int *) data
) = TTYDISC
;
1145 bzero(data
, sizeof(struct winsize
));
1155 * Deal with 4.3 compatibility issues if we have too...
1157 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1159 struct termios tios
;
1160 unsigned long oldcmd
;
1162 tios
= tp
->t_termios
;
1164 if ((error
= ttsetcompat(tp
, &cmd
, data
, &tios
)))
1167 data
= (caddr_t
) &tios
;
1172 * Carry out some pre-cmd processing work first...
1173 * Hmmm, not so sure we want this, disable for now...
1175 if ((cmd
== TIOCSETA
) || (cmd
== TIOCSETAW
) || (cmd
== TIOCSETAF
)) {
1176 newtios
= (struct termios
*) data
;
1177 localtios
= (minor(dev
) & STL_CALLOUTDEV
) ? &portp
->lockouttios
:
1180 newtios
->c_iflag
= (tp
->t_iflag
& localtios
->c_iflag
) |
1181 (newtios
->c_iflag
& ~localtios
->c_iflag
);
1182 newtios
->c_oflag
= (tp
->t_oflag
& localtios
->c_oflag
) |
1183 (newtios
->c_oflag
& ~localtios
->c_oflag
);
1184 newtios
->c_cflag
= (tp
->t_cflag
& localtios
->c_cflag
) |
1185 (newtios
->c_cflag
& ~localtios
->c_cflag
);
1186 newtios
->c_lflag
= (tp
->t_lflag
& localtios
->c_lflag
) |
1187 (newtios
->c_lflag
& ~localtios
->c_lflag
);
1188 for (i
= 0; (i
< NCCS
); i
++) {
1189 if (localtios
->c_cc
[i
] != 0)
1190 newtios
->c_cc
[i
] = tp
->t_cc
[i
];
1192 if (localtios
->c_ispeed
!= 0)
1193 newtios
->c_ispeed
= tp
->t_ispeed
;
1194 if (localtios
->c_ospeed
!= 0)
1195 newtios
->c_ospeed
= tp
->t_ospeed
;
1199 * Call the line discipline and the common command processing to
1200 * process this command (if they can).
1202 error
= (*linesw
[tp
->t_line
].l_ioctl
)(tp
, cmd
, data
,
1203 ap
->a_fflag
, ap
->a_cred
);
1204 if (error
!= ENOIOCTL
)
1208 error
= ttioctl(tp
, cmd
, data
, ap
->a_fflag
);
1209 stli_ttyoptim(portp
, &tp
->t_termios
);
1210 if (error
!= ENOIOCTL
) {
1218 * Process local commands here. These are all commands that only we
1219 * can take care of (they all rely on actually doing something special
1220 * to the actual hardware).
1225 error
= stli_cmdwait(brdp
, portp
, A_BREAK
, &arg
,
1226 sizeof(unsigned long), 0);
1230 error
= stli_cmdwait(brdp
, portp
, A_BREAK
, &arg
,
1231 sizeof(unsigned long), 0);
1234 stli_mkasysigs(&portp
->asig
, 1, -1);
1235 error
= stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1236 sizeof(asysigs_t
), 0);
1239 stli_mkasysigs(&portp
->asig
, 0, -1);
1240 error
= stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1241 sizeof(asysigs_t
), 0);
1244 i
= *((int *) data
);
1245 stli_mkasysigs(&portp
->asig
, ((i
& TIOCM_DTR
) ? 1 : 0),
1246 ((i
& TIOCM_RTS
) ? 1 : 0));
1247 error
= stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1248 sizeof(asysigs_t
), 0);
1251 i
= *((int *) data
);
1252 stli_mkasysigs(&portp
->asig
, ((i
& TIOCM_DTR
) ? 1 : -1),
1253 ((i
& TIOCM_RTS
) ? 1 : -1));
1254 error
= stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1255 sizeof(asysigs_t
), 0);
1258 i
= *((int *) data
);
1259 stli_mkasysigs(&portp
->asig
, ((i
& TIOCM_DTR
) ? 0 : -1),
1260 ((i
& TIOCM_RTS
) ? 0 : -1));
1261 error
= stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1262 sizeof(asysigs_t
), 0);
1265 if ((error
= stli_cmdwait(brdp
, portp
, A_GETSIGNALS
,
1266 &portp
->asig
, sizeof(asysigs_t
), 1)) < 0)
1268 portp
->sigs
= stli_mktiocm(portp
->asig
.sigvalue
);
1269 *((int *) data
) = (portp
->sigs
| TIOCM_LE
);
1272 if ((error
= suser_cred(ap
->a_cred
, 0)) == 0)
1273 portp
->dtrwait
= *((int *) data
) * hz
/ 100;
1276 *((int *) data
) = portp
->dtrwait
* 100 / hz
;
1279 portp
->dotimestamp
= 1;
1280 *((struct timeval
*) data
) = portp
->timestamp
;
1283 *((unsigned long *) data
) = portp
->pflag
;
1286 portp
->pflag
= *((unsigned long *) data
);
1287 stli_param(&portp
->tty
, &portp
->tty
.t_termios
);
1298 /*****************************************************************************/
1301 * Convert the specified minor device number into a port struct
1302 * pointer. Return NULL if the device number is not a valid port.
1305 STATIC stliport_t
*stli_dev2port(cdev_t dev
)
1309 brdp
= stli_brds
[MKDEV2BRD(dev
)];
1310 if (brdp
== (stlibrd_t
*) NULL
)
1311 return((stliport_t
*) NULL
);
1312 if ((brdp
->state
& BST_STARTED
) == 0)
1313 return((stliport_t
*) NULL
);
1314 return(brdp
->ports
[MKDEV2PORT(dev
)]);
1317 /*****************************************************************************/
1320 * Carry out first open operations on a port. This involves a number of
1321 * commands to be sent to the slave. We need to open the port, set the
1322 * notification events, set the initial port settings, get and set the
1323 * initial signal values. We sleep and wait in between each one. But
1324 * this still all happens pretty quickly.
1327 static int stli_initopen(stliport_t
*portp
)
1335 kprintf("stli_initopen(portp=%x)\n", (int) portp
);
1338 if ((brdp
= stli_brds
[portp
->brdnr
]) == (stlibrd_t
*) NULL
)
1340 if (portp
->state
& ST_INITIALIZED
)
1342 portp
->state
|= ST_INITIALIZED
;
1344 if ((rc
= stli_rawopen(brdp
, portp
, 0, 1)) < 0)
1347 bzero(&nt
, sizeof(asynotify_t
));
1348 nt
.data
= (DT_TXLOW
| DT_TXEMPTY
| DT_RXBUSY
| DT_RXBREAK
);
1350 if ((rc
= stli_cmdwait(brdp
, portp
, A_SETNOTIFY
, &nt
,
1351 sizeof(asynotify_t
), 0)) < 0)
1354 stli_mkasyport(portp
, &aport
, &portp
->tty
.t_termios
);
1355 if ((rc
= stli_cmdwait(brdp
, portp
, A_SETPORT
, &aport
,
1356 sizeof(asyport_t
), 0)) < 0)
1359 portp
->state
|= ST_GETSIGS
;
1360 if ((rc
= stli_cmdwait(brdp
, portp
, A_GETSIGNALS
, &portp
->asig
,
1361 sizeof(asysigs_t
), 1)) < 0)
1363 if (portp
->state
& ST_GETSIGS
) {
1364 portp
->sigs
= stli_mktiocm(portp
->asig
.sigvalue
);
1365 portp
->state
&= ~ST_GETSIGS
;
1368 stli_mkasysigs(&portp
->asig
, 1, 1);
1369 if ((rc
= stli_cmdwait(brdp
, portp
, A_SETSIGNALS
, &portp
->asig
,
1370 sizeof(asysigs_t
), 0)) < 0)
1376 /*****************************************************************************/
1379 * Shutdown the hardware of a port.
1382 static int stli_shutdownclose(stliport_t
*portp
)
1388 kprintf("stli_shutdownclose(portp=%p): brdnr=%d panelnr=%d portnr=%d\n",
1389 (void *) portp
, portp
->brdnr
, portp
->panelnr
, portp
->portnr
);
1392 if ((brdp
= stli_brds
[portp
->brdnr
]) == (stlibrd_t
*) NULL
)
1396 stli_rawclose(brdp
, portp
, 0, 0);
1397 stli_flush(portp
, (FWRITE
| FREAD
));
1398 if (tp
->t_cflag
& HUPCL
) {
1400 stli_mkasysigs(&portp
->asig
, 0, 0);
1401 if (portp
->state
& ST_CMDING
) {
1402 portp
->state
|= ST_DOSIGS
;
1404 stli_sendcmd(brdp
, portp
, A_SETSIGNALS
,
1405 &portp
->asig
, sizeof(asysigs_t
), 0);
1408 if (portp
->dtrwait
!= 0) {
1409 portp
->state
|= ST_DTRWAIT
;
1410 callout_reset(&portp
->dtr_ch
, portp
->dtrwait
,
1411 stli_dtrwakeup
, portp
);
1415 portp
->state
&= ~ST_INITIALIZED
;
1416 wakeup(&portp
->callout
);
1417 wakeup(TSA_CARR_ON(tp
));
1421 /*****************************************************************************/
1424 * Clear the DTR waiting flag, and wake up any sleepers waiting for
1425 * DTR wait period to finish.
1428 static void stli_dtrwakeup(void *arg
)
1432 portp
= (stliport_t
*) arg
;
1433 portp
->state
&= ~ST_DTRWAIT
;
1434 wakeup(&portp
->dtrwait
);
1437 /*****************************************************************************/
1440 * Send an open message to the slave. This will sleep waiting for the
1441 * acknowledgement, so must have user context. We need to co-ordinate
1442 * with close events here, since we don't want open and close events
1446 static int stli_rawopen(stlibrd_t
*brdp
, stliport_t
*portp
, unsigned long arg
, int wait
)
1448 volatile cdkhdr_t
*hdrp
;
1449 volatile cdkctrl_t
*cp
;
1450 volatile unsigned char *bits
;
1454 kprintf("stli_rawopen(brdp=%x,portp=%x,arg=%x,wait=%d)\n", (int) brdp
,
1455 (int) portp
, (int) arg
, wait
);
1461 * Slave is already closing this port. This can happen if a hangup
1462 * occurs on this port. So we must wait until it is complete. The
1463 * order of opens and closes may not be preserved across shared
1464 * memory, so we must wait until it is complete.
1466 while (portp
->state
& ST_CLOSING
) {
1467 rc
= tsleep(&portp
->state
, PCATCH
, "stliraw", 0);
1475 * Everything is ready now, so write the open message into shared
1476 * memory. Once the message is in set the service bits to say that
1477 * this port wants service.
1480 cp
= &((volatile cdkasy_t
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->ctrl
;
1483 hdrp
= (volatile cdkhdr_t
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
1484 bits
= ((volatile unsigned char *) hdrp
) + brdp
->slaveoffset
+
1486 *bits
|= portp
->portbit
;
1495 * Slave is in action, so now we must wait for the open acknowledgment
1499 portp
->state
|= ST_OPENING
;
1500 while (portp
->state
& ST_OPENING
) {
1501 rc
= tsleep(&portp
->state
, PCATCH
, "stliraw", 0);
1509 if ((rc
== 0) && (portp
->rc
!= 0))
1514 /*****************************************************************************/
1517 * Send a close message to the slave. Normally this will sleep waiting
1518 * for the acknowledgement, but if wait parameter is 0 it will not. If
1519 * wait is true then must have user context (to sleep).
1522 static int stli_rawclose(stlibrd_t
*brdp
, stliport_t
*portp
, unsigned long arg
, int wait
)
1524 volatile cdkhdr_t
*hdrp
;
1525 volatile cdkctrl_t
*cp
;
1526 volatile unsigned char *bits
;
1530 kprintf("stli_rawclose(brdp=%x,portp=%x,arg=%x,wait=%d)\n", (int) brdp
,
1531 (int) portp
, (int) arg
, wait
);
1537 * Slave is already closing this port. This can happen if a hangup
1538 * occurs on this port.
1541 while (portp
->state
& ST_CLOSING
) {
1542 rc
= tsleep(&portp
->state
, PCATCH
, "stliraw", 0);
1551 * Write the close command into shared memory.
1554 cp
= &((volatile cdkasy_t
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->ctrl
;
1557 hdrp
= (volatile cdkhdr_t
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
1558 bits
= ((volatile unsigned char *) hdrp
) + brdp
->slaveoffset
+
1560 *bits
|= portp
->portbit
;
1563 portp
->state
|= ST_CLOSING
;
1570 * Slave is in action, so now we must wait for the open acknowledgment
1574 while (portp
->state
& ST_CLOSING
) {
1575 rc
= tsleep(&portp
->state
, PCATCH
, "stliraw", 0);
1583 if ((rc
== 0) && (portp
->rc
!= 0))
1588 /*****************************************************************************/
1591 * Send a command to the slave and wait for the response. This must
1592 * have user context (it sleeps). This routine is generic in that it
1593 * can send any type of command. Its purpose is to wait for that command
1594 * to complete (as opposed to initiating the command then returning).
1597 static int stli_cmdwait(stlibrd_t
*brdp
, stliport_t
*portp
, unsigned long cmd
, void *arg
, int size
, int copyback
)
1602 kprintf("stli_cmdwait(brdp=%x,portp=%x,cmd=%x,arg=%x,size=%d,"
1603 "copyback=%d)\n", (int) brdp
, (int) portp
, (int) cmd
,
1604 (int) arg
, size
, copyback
);
1608 while (portp
->state
& ST_CMDING
) {
1609 rc
= tsleep(&portp
->state
, PCATCH
, "stliraw", 0);
1616 stli_sendcmd(brdp
, portp
, cmd
, arg
, size
, copyback
);
1618 while (portp
->state
& ST_CMDING
) {
1619 rc
= tsleep(&portp
->state
, PCATCH
, "stliraw", 0);
1632 /*****************************************************************************/
1635 * Start (or continue) the transfer of TX data on this port. If the
1636 * port is not currently busy then load up the interrupt ring queue
1637 * buffer and kick of the transmitter. If the port is running low on
1638 * TX data then refill the ring queue. This routine is also used to
1639 * activate input flow control!
1642 static void stli_start(struct tty
*tp
)
1644 volatile cdkasy_t
*ap
;
1645 volatile cdkhdr_t
*hdrp
;
1646 volatile unsigned char *bits
;
1647 unsigned char *shbuf
;
1650 unsigned int len
, stlen
, head
, tail
, size
;
1653 portp
= (stliport_t
*) tp
;
1656 kprintf("stli_start(tp=%x): brdnr=%d portnr=%d\n", (int) tp
,
1657 portp
->brdnr
, portp
->portnr
);
1664 * Check if the output cooked clist buffers are near empty, wake up
1665 * the line discipline to fill it up.
1667 if (tp
->t_outq
.c_cc
<= tp
->t_lowat
) {
1668 if (tp
->t_state
& TS_ASLEEP
) {
1669 tp
->t_state
&= ~TS_ASLEEP
;
1670 wakeup(&tp
->t_outq
);
1672 selwakeup(&tp
->t_wsel
);
1676 if (tp
->t_state
& (TS_TIMEOUT
| TS_TTSTOP
)) {
1682 * Copy data from the clists into the interrupt ring queue. This will
1683 * require at most 2 copys... What we do is calculate how many chars
1684 * can fit into the ring queue, and how many can fit in 1 copy. If after
1685 * the first copy there is still more room then do the second copy.
1687 if (tp
->t_outq
.c_cc
!= 0) {
1688 brdp
= stli_brds
[portp
->brdnr
];
1689 if (brdp
== (stlibrd_t
*) NULL
) {
1695 ap
= (volatile cdkasy_t
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
1696 head
= (unsigned int) ap
->txq
.head
;
1697 tail
= (unsigned int) ap
->txq
.tail
;
1698 if (tail
!= ((unsigned int) ap
->txq
.tail
))
1699 tail
= (unsigned int) ap
->txq
.tail
;
1700 size
= portp
->txsize
;
1702 len
= size
- (head
- tail
) - 1;
1703 stlen
= size
- head
;
1705 len
= tail
- head
- 1;
1710 shbuf
= (char *) EBRDGETMEMPTR(brdp
, portp
->txoffset
);
1713 stlen
= MIN(len
, stlen
);
1714 count
= q_to_b(&tp
->t_outq
, (shbuf
+ head
), stlen
);
1720 stlen
= q_to_b(&tp
->t_outq
, shbuf
, len
);
1727 ap
= (volatile cdkasy_t
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
1728 ap
->txq
.head
= head
;
1729 hdrp
= (volatile cdkhdr_t
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
1730 bits
= ((volatile unsigned char *) hdrp
) + brdp
->slaveoffset
+
1732 *bits
|= portp
->portbit
;
1733 portp
->state
|= ST_TXBUSY
;
1734 tp
->t_state
|= TS_BUSY
;
1741 * Do any writer wakeups.
1749 /*****************************************************************************/
1752 * Send a new port configuration to the slave.
1755 static int stli_param(struct tty
*tp
, struct termios
*tiosp
)
1762 portp
= (stliport_t
*) tp
;
1763 if ((brdp
= stli_brds
[portp
->brdnr
]) == (stlibrd_t
*) NULL
)
1767 stli_mkasyport(portp
, &aport
, tiosp
);
1768 /* can we sleep here? */
1769 rc
= stli_cmdwait(brdp
, portp
, A_SETPORT
, &aport
, sizeof(asyport_t
), 0);
1770 stli_ttyoptim(portp
, tiosp
);
1775 /*****************************************************************************/
1778 * Flush characters from the lower buffer. We may not have user context
1779 * so we cannot sleep waiting for it to complete. Also we need to check
1780 * if there is chars for this port in the TX cook buffer, and flush them
1784 static void stli_flush(stliport_t
*portp
, int flag
)
1787 unsigned long ftype
;
1790 kprintf("stli_flush(portp=%x,flag=%x)\n", (int) portp
, flag
);
1793 if (portp
== (stliport_t
*) NULL
)
1795 if ((portp
->brdnr
< 0) || (portp
->brdnr
>= stli_nrbrds
))
1797 brdp
= stli_brds
[portp
->brdnr
];
1798 if (brdp
== (stlibrd_t
*) NULL
)
1802 if (portp
->state
& ST_CMDING
) {
1803 portp
->state
|= (flag
& FWRITE
) ? ST_DOFLUSHTX
: 0;
1804 portp
->state
|= (flag
& FREAD
) ? ST_DOFLUSHRX
: 0;
1806 ftype
= (flag
& FWRITE
) ? FLUSHTX
: 0;
1807 ftype
|= (flag
& FREAD
) ? FLUSHRX
: 0;
1808 portp
->state
&= ~(ST_DOFLUSHTX
| ST_DOFLUSHRX
);
1809 stli_sendcmd(brdp
, portp
, A_FLUSH
, &ftype
,
1810 sizeof(unsigned long), 0);
1812 if ((flag
& FREAD
) && (stli_rxtmpport
== portp
))
1817 /*****************************************************************************/
1820 * Generic send command routine. This will send a message to the slave,
1821 * of the specified type with the specified argument. Must be very
1822 * carefull of data that will be copied out from shared memory -
1823 * containing command results. The command completion is all done from
1824 * a poll routine that does not have user coontext. Therefore you cannot
1825 * copy back directly into user space, or to the kernel stack of a
1826 * process. This routine does not sleep, so can be called from anywhere,
1827 * and must be called with interrupt locks set.
1830 static void stli_sendcmd(stlibrd_t
*brdp
, stliport_t
*portp
, unsigned long cmd
, void *arg
, int size
, int copyback
)
1832 volatile cdkhdr_t
*hdrp
;
1833 volatile cdkctrl_t
*cp
;
1834 volatile unsigned char *bits
;
1837 kprintf("stli_sendcmd(brdp=%x,portp=%x,cmd=%x,arg=%x,size=%d,"
1838 "copyback=%d)\n", (int) brdp
, (int) portp
, (int) cmd
,
1839 (int) arg
, size
, copyback
);
1842 if (portp
->state
& ST_CMDING
) {
1843 kprintf("STALLION: command already busy, cmd=%x!\n", (int) cmd
);
1848 cp
= &((volatile cdkasy_t
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->ctrl
;
1850 bcopy(arg
, &(cp
->args
[0]), size
);
1853 portp
->argsize
= size
;
1858 hdrp
= (volatile cdkhdr_t
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
1859 bits
= ((volatile unsigned char *) hdrp
) + brdp
->slaveoffset
+
1861 *bits
|= portp
->portbit
;
1862 portp
->state
|= ST_CMDING
;
1866 /*****************************************************************************/
1869 * Read data from shared memory. This assumes that the shared memory
1870 * is enabled and that interrupts are off. Basically we just empty out
1871 * the shared memory buffer into the tty buffer. Must be carefull to
1872 * handle the case where we fill up the tty buffer, but still have
1873 * more chars to unload.
1876 static void stli_rxprocess(stlibrd_t
*brdp
, stliport_t
*portp
)
1878 volatile cdkasyrq_t
*rp
;
1879 volatile char *shbuf
;
1881 unsigned int head
, tail
, size
;
1882 unsigned int len
, stlen
, i
;
1886 kprintf("stli_rxprocess(brdp=%x,portp=%d)\n", (int) brdp
, (int) portp
);
1890 if ((tp
->t_state
& TS_ISOPEN
) == 0) {
1891 stli_flush(portp
, FREAD
);
1894 if (tp
->t_state
& TS_TBLOCK
)
1897 rp
= &((volatile cdkasy_t
*) EBRDGETMEMPTR(brdp
, portp
->addr
))->rxq
;
1898 head
= (unsigned int) rp
->head
;
1899 if (head
!= ((unsigned int) rp
->head
))
1900 head
= (unsigned int) rp
->head
;
1901 tail
= (unsigned int) rp
->tail
;
1902 size
= portp
->rxsize
;
1907 len
= size
- (tail
- head
);
1908 stlen
= size
- tail
;
1914 shbuf
= (volatile char *) EBRDGETMEMPTR(brdp
, portp
->rxoffset
);
1917 * If we can bypass normal LD processing then just copy direct
1918 * from board shared memory into the tty buffers.
1920 if (tp
->t_state
& TS_CAN_BYPASS_L_RINT
) {
1921 if (((tp
->t_rawq
.c_cc
+ len
) >= TTYHOG
) &&
1922 ((tp
->t_cflag
& CRTS_IFLOW
) || (tp
->t_iflag
& IXOFF
)) &&
1923 ((tp
->t_state
& TS_TBLOCK
) == 0)) {
1924 ch
= TTYHOG
- tp
->t_rawq
.c_cc
- 1;
1925 len
= (ch
> 0) ? ch
: 0;
1926 stlen
= MIN(stlen
, len
);
1927 tp
->t_state
|= TS_TBLOCK
;
1929 i
= b_to_q(__DEVOLATILE(char *, shbuf
+ tail
), stlen
,
1935 i
+= b_to_q(__DEVOLATILE(char *, shbuf
), len
,
1941 rp
= &((volatile cdkasy_t
*)
1942 EBRDGETMEMPTR(brdp
, portp
->addr
))->rxq
;
1947 * Copy the data from board shared memory into a local
1948 * memory buffer. Then feed them from here into the LD.
1949 * We don't want to go into board shared memory one char
1950 * at a time, it is too slow...
1954 stlen
= min(len
, stlen
);
1956 stli_rxtmpport
= portp
;
1957 stli_rxtmplen
= len
;
1958 bcopy(__DEVOLATILE(char *, shbuf
+ tail
), &stli_rxtmpbuf
[0],
1962 bcopy(shbuf
, &stli_rxtmpbuf
[stlen
], len
);
1964 for (i
= 0; (i
< stli_rxtmplen
); i
++) {
1965 ch
= (unsigned char) stli_rxtmpbuf
[i
];
1966 (*linesw
[tp
->t_line
].l_rint
)(ch
, tp
);
1969 rp
= &((volatile cdkasy_t
*)
1970 EBRDGETMEMPTR(brdp
, portp
->addr
))->rxq
;
1971 if (stli_rxtmplen
== 0) {
1972 head
= (unsigned int) rp
->head
;
1973 if (head
!= ((unsigned int) rp
->head
))
1974 head
= (unsigned int) rp
->head
;
1982 stli_rxtmpport
= (stliport_t
*) NULL
;
1986 portp
->state
|= ST_RXING
;
1989 /*****************************************************************************/
1992 * Set up and carry out any delayed commands. There is only a small set
1993 * of slave commands that can be done "off-level". So it is not too
1994 * difficult to deal with them as a special case here.
1997 static __inline
void stli_dodelaycmd(stliport_t
*portp
, volatile cdkctrl_t
*cp
)
2001 if (portp
->state
& ST_DOSIGS
) {
2002 if ((portp
->state
& ST_DOFLUSHTX
) &&
2003 (portp
->state
& ST_DOFLUSHRX
))
2004 cmd
= A_SETSIGNALSF
;
2005 else if (portp
->state
& ST_DOFLUSHTX
)
2006 cmd
= A_SETSIGNALSFTX
;
2007 else if (portp
->state
& ST_DOFLUSHRX
)
2008 cmd
= A_SETSIGNALSFRX
;
2011 portp
->state
&= ~(ST_DOFLUSHTX
| ST_DOFLUSHRX
| ST_DOSIGS
);
2012 bcopy(&portp
->asig
, &(cp
->args
[0]), sizeof(asysigs_t
));
2015 portp
->state
|= ST_CMDING
;
2016 } else if ((portp
->state
& ST_DOFLUSHTX
) ||
2017 (portp
->state
& ST_DOFLUSHRX
)) {
2018 cmd
= ((portp
->state
& ST_DOFLUSHTX
) ? FLUSHTX
: 0);
2019 cmd
|= ((portp
->state
& ST_DOFLUSHRX
) ? FLUSHRX
: 0);
2020 portp
->state
&= ~(ST_DOFLUSHTX
| ST_DOFLUSHRX
);
2021 bcopy(&cmd
, &(cp
->args
[0]), sizeof(int));
2024 portp
->state
|= ST_CMDING
;
2028 /*****************************************************************************/
2031 * Host command service checking. This handles commands or messages
2032 * coming from the slave to the host. Must have board shared memory
2033 * enabled and interrupts off when called. Notice that by servicing the
2034 * read data last we don't need to change the shared memory pointer
2035 * during processing (which is a slow IO operation).
2036 * Return value indicates if this port is still awaiting actions from
2037 * the slave (like open, command, or even TX data being sent). If 0
2038 * then port is still busy, otherwise the port request bit flag is
2042 static __inline
int stli_hostcmd(stlibrd_t
*brdp
, stliport_t
*portp
)
2044 volatile cdkasy_t
*ap
;
2045 volatile cdkctrl_t
*cp
;
2047 unsigned long oldsigs
;
2048 unsigned int head
, tail
;
2052 kprintf("stli_hostcmd(brdp=%x,portp=%x)\n", (int) brdp
, (int) portp
);
2055 ap
= (volatile cdkasy_t
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
2059 * Check if we are waiting for an open completion message.
2061 if (portp
->state
& ST_OPENING
) {
2062 rc
= (int) cp
->openarg
;
2063 if ((cp
->open
== 0) && (rc
!= 0)) {
2068 portp
->state
&= ~ST_OPENING
;
2069 wakeup(&portp
->state
);
2074 * Check if we are waiting for a close completion message.
2076 if (portp
->state
& ST_CLOSING
) {
2077 rc
= (int) cp
->closearg
;
2078 if ((cp
->close
== 0) && (rc
!= 0)) {
2083 portp
->state
&= ~ST_CLOSING
;
2084 wakeup(&portp
->state
);
2089 * Check if we are waiting for a command completion message. We may
2090 * need to copy out the command results associated with this command.
2092 if (portp
->state
& ST_CMDING
) {
2094 if ((cp
->cmd
== 0) && (rc
!= 0)) {
2097 if (portp
->argp
!= (void *) NULL
) {
2098 bcopy(&(cp
->args
[0]), portp
->argp
,
2100 portp
->argp
= (void *) NULL
;
2104 portp
->state
&= ~ST_CMDING
;
2105 stli_dodelaycmd(portp
, cp
);
2106 wakeup(&portp
->state
);
2111 * Check for any notification messages ready. This includes lots of
2112 * different types of events - RX chars ready, RX break received,
2113 * TX data low or empty in the slave, modem signals changed state.
2114 * Must be extremely carefull if we call to the LD, it may call
2115 * other routines of ours that will disable the memory...
2116 * Something else we need to be carefull of is race conditions on
2117 * marking the TX as empty...
2128 if (nt
.signal
& SG_DCD
) {
2129 oldsigs
= portp
->sigs
;
2130 portp
->sigs
= stli_mktiocm(nt
.sigvalue
);
2131 portp
->state
&= ~ST_GETSIGS
;
2132 (*linesw
[tp
->t_line
].l_modem
)(tp
,
2133 (portp
->sigs
& TIOCM_CD
));
2136 if (nt
.data
& DT_RXBUSY
) {
2138 stli_rxprocess(brdp
, portp
);
2140 if (nt
.data
& DT_RXBREAK
) {
2141 (*linesw
[tp
->t_line
].l_rint
)(TTY_BI
, tp
);
2144 if (nt
.data
& DT_TXEMPTY
) {
2145 ap
= (volatile cdkasy_t
*)
2146 EBRDGETMEMPTR(brdp
, portp
->addr
);
2147 head
= (unsigned int) ap
->txq
.head
;
2148 tail
= (unsigned int) ap
->txq
.tail
;
2149 if (tail
!= ((unsigned int) ap
->txq
.tail
))
2150 tail
= (unsigned int) ap
->txq
.tail
;
2151 head
= (head
>= tail
) ? (head
- tail
) :
2152 portp
->txsize
- (tail
- head
);
2154 portp
->state
&= ~ST_TXBUSY
;
2155 tp
->t_state
&= ~TS_BUSY
;
2158 if (nt
.data
& (DT_TXEMPTY
| DT_TXLOW
)) {
2159 (*linesw
[tp
->t_line
].l_start
)(tp
);
2165 * It might seem odd that we are checking for more RX chars here.
2166 * But, we need to handle the case where the tty buffer was previously
2167 * filled, but we had more characters to pass up. The slave will not
2168 * send any more RX notify messages until the RX buffer has been emptied.
2169 * But it will leave the service bits on (since the buffer is not empty).
2170 * So from here we can try to process more RX chars.
2172 if ((!donerx
) && (portp
->state
& ST_RXING
)) {
2173 portp
->state
&= ~ST_RXING
;
2174 stli_rxprocess(brdp
, portp
);
2177 return((portp
->state
& (ST_OPENING
| ST_CLOSING
| ST_CMDING
|
2178 ST_TXBUSY
| ST_RXING
)) ? 0 : 1);
2181 /*****************************************************************************/
2184 * Service all ports on a particular board. Assumes that the boards
2185 * shared memory is enabled, and that the page pointer is pointed
2186 * at the cdk header structure.
2189 static __inline
void stli_brdpoll(stlibrd_t
*brdp
, volatile cdkhdr_t
*hdrp
)
2192 unsigned char hostbits
[(STL_MAXCHANS
/ 8) + 1];
2193 unsigned char slavebits
[(STL_MAXCHANS
/ 8) + 1];
2194 unsigned char *slavep
;
2195 int bitpos
, bitat
, bitsize
;
2196 int channr
, nrdevs
, slavebitchange
;
2198 bitsize
= brdp
->bitsize
;
2199 nrdevs
= brdp
->nrdevs
;
2202 * Check if slave wants any service. Basically we try to do as
2203 * little work as possible here. There are 2 levels of service
2204 * bits. So if there is nothing to do we bail early. We check
2205 * 8 service bits at a time in the inner loop, so we can bypass
2206 * the lot if none of them want service.
2208 bcopy(__DEVOLATILE(unsigned char *, hdrp
) + brdp
->hostoffset
,
2209 &hostbits
[0], bitsize
);
2211 bzero(&slavebits
[0], bitsize
);
2214 for (bitpos
= 0; (bitpos
< bitsize
); bitpos
++) {
2215 if (hostbits
[bitpos
] == 0)
2217 channr
= bitpos
* 8;
2219 for (; (channr
< nrdevs
); channr
++, bitat
<<=1) {
2220 if (hostbits
[bitpos
] & bitat
) {
2221 portp
= brdp
->ports
[(channr
- 1)];
2222 if (stli_hostcmd(brdp
, portp
)) {
2224 slavebits
[bitpos
] |= bitat
;
2231 * If any of the ports are no longer busy then update them in the
2232 * slave request bits. We need to do this after, since a host port
2233 * service may initiate more slave requests...
2235 if (slavebitchange
) {
2236 hdrp
= (volatile cdkhdr_t
*)
2237 EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
2238 slavep
= __DEVOLATILE(unsigned char *, hdrp
) + brdp
->slaveoffset
;
2239 for (bitpos
= 0; (bitpos
< bitsize
); bitpos
++) {
2240 if (slavebits
[bitpos
])
2241 slavep
[bitpos
] &= ~slavebits
[bitpos
];
2246 /*****************************************************************************/
2249 * Driver poll routine. This routine polls the boards in use and passes
2250 * messages back up to host when neccesary. This is actually very
2251 * CPU efficient, since we will always have the kernel poll clock, it
2252 * adds only a few cycles when idle (since board service can be
2253 * determined very easily), but when loaded generates no interrupts
2254 * (with their expensive associated context change).
2257 static void stli_poll(void *arg
)
2259 volatile cdkhdr_t
*hdrp
;
2266 * Check each board and do any servicing required.
2268 for (brdnr
= 0; (brdnr
< stli_nrbrds
); brdnr
++) {
2269 brdp
= stli_brds
[brdnr
];
2270 if (brdp
== (stlibrd_t
*) NULL
)
2272 if ((brdp
->state
& BST_STARTED
) == 0)
2276 hdrp
= (volatile cdkhdr_t
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
2278 stli_brdpoll(brdp
, hdrp
);
2283 callout_reset(&stli_poll_ch
, 1, stli_poll
, NULL
);
2286 /*****************************************************************************/
2289 * Translate the termios settings into the port setting structure of
2293 static void stli_mkasyport(stliport_t
*portp
, asyport_t
*pp
, struct termios
*tiosp
)
2296 kprintf("stli_mkasyport(portp=%x,pp=%x,tiosp=%d)\n", (int) portp
,
2297 (int) pp
, (int) tiosp
);
2300 bzero(pp
, sizeof(asyport_t
));
2303 * Start of by setting the baud, char size, parity and stop bit info.
2305 if (tiosp
->c_ispeed
== 0)
2306 tiosp
->c_ispeed
= tiosp
->c_ospeed
;
2307 if ((tiosp
->c_ospeed
< 0) || (tiosp
->c_ospeed
> STL_MAXBAUD
))
2308 tiosp
->c_ospeed
= STL_MAXBAUD
;
2309 pp
->baudout
= tiosp
->c_ospeed
;
2310 pp
->baudin
= pp
->baudout
;
2312 switch (tiosp
->c_cflag
& CSIZE
) {
2327 if (tiosp
->c_cflag
& CSTOPB
)
2328 pp
->stopbs
= PT_STOP2
;
2330 pp
->stopbs
= PT_STOP1
;
2332 if (tiosp
->c_cflag
& PARENB
) {
2333 if (tiosp
->c_cflag
& PARODD
)
2334 pp
->parity
= PT_ODDPARITY
;
2336 pp
->parity
= PT_EVENPARITY
;
2338 pp
->parity
= PT_NOPARITY
;
2341 if (tiosp
->c_iflag
& ISTRIP
)
2342 pp
->iflag
|= FI_ISTRIP
;
2345 * Set up any flow control options enabled.
2347 if (tiosp
->c_iflag
& IXON
) {
2349 if (tiosp
->c_iflag
& IXANY
)
2350 pp
->flow
|= F_IXANY
;
2352 if (tiosp
->c_iflag
& IXOFF
)
2353 pp
->flow
|= F_IXOFF
;
2354 if (tiosp
->c_cflag
& CCTS_OFLOW
)
2355 pp
->flow
|= F_CTSFLOW
;
2356 if (tiosp
->c_cflag
& CRTS_IFLOW
)
2357 pp
->flow
|= F_RTSFLOW
;
2359 pp
->startin
= tiosp
->c_cc
[VSTART
];
2360 pp
->stopin
= tiosp
->c_cc
[VSTOP
];
2361 pp
->startout
= tiosp
->c_cc
[VSTART
];
2362 pp
->stopout
= tiosp
->c_cc
[VSTOP
];
2365 * Set up the RX char marking mask with those RX error types we must
2366 * catch. We can get the slave to help us out a little here, it will
2367 * ignore parity errors and breaks for us, and mark parity errors in
2370 if (tiosp
->c_iflag
& IGNPAR
)
2371 pp
->iflag
|= FI_IGNRXERRS
;
2372 if (tiosp
->c_iflag
& IGNBRK
)
2373 pp
->iflag
|= FI_IGNBREAK
;
2374 if (tiosp
->c_iflag
& (INPCK
| PARMRK
))
2375 pp
->iflag
|= FI_1MARKRXERRS
;
2378 * Transfer any persistent flags into the asyport structure.
2380 pp
->pflag
= (portp
->pflag
& 0xffff);
2381 pp
->vmin
= (portp
->pflag
& P_RXIMIN
) ? 1 : 0;
2382 pp
->vtime
= (portp
->pflag
& P_RXITIME
) ? 1 : 0;
2383 pp
->cc
[1] = (portp
->pflag
& P_RXTHOLD
) ? 1 : 0;
2386 /*****************************************************************************/
2389 * Construct a slave signals structure for setting the DTR and RTS
2390 * signals as specified.
2393 static void stli_mkasysigs(asysigs_t
*sp
, int dtr
, int rts
)
2396 kprintf("stli_mkasysigs(sp=%x,dtr=%d,rts=%d)\n", (int) sp
, dtr
, rts
);
2399 bzero(sp
, sizeof(asysigs_t
));
2401 sp
->signal
|= SG_DTR
;
2402 sp
->sigvalue
|= ((dtr
> 0) ? SG_DTR
: 0);
2405 sp
->signal
|= SG_RTS
;
2406 sp
->sigvalue
|= ((rts
> 0) ? SG_RTS
: 0);
2410 /*****************************************************************************/
2413 * Convert the signals returned from the slave into a local TIOCM type
2414 * signals value. We keep them localy in TIOCM format.
2417 static long stli_mktiocm(unsigned long sigvalue
)
2422 kprintf("stli_mktiocm(sigvalue=%x)\n", (int) sigvalue
);
2426 tiocm
|= ((sigvalue
& SG_DCD
) ? TIOCM_CD
: 0);
2427 tiocm
|= ((sigvalue
& SG_CTS
) ? TIOCM_CTS
: 0);
2428 tiocm
|= ((sigvalue
& SG_RI
) ? TIOCM_RI
: 0);
2429 tiocm
|= ((sigvalue
& SG_DSR
) ? TIOCM_DSR
: 0);
2430 tiocm
|= ((sigvalue
& SG_DTR
) ? TIOCM_DTR
: 0);
2431 tiocm
|= ((sigvalue
& SG_RTS
) ? TIOCM_RTS
: 0);
2435 /*****************************************************************************/
2438 * Enable l_rint processing bypass mode if tty modes allow it.
2441 static void stli_ttyoptim(stliport_t
*portp
, struct termios
*tiosp
)
2446 if (((tiosp
->c_iflag
& (ICRNL
| IGNCR
| IMAXBEL
| INLCR
)) == 0) &&
2447 (((tiosp
->c_iflag
& BRKINT
) == 0) || (tiosp
->c_iflag
& IGNBRK
)) &&
2448 (((tiosp
->c_iflag
& PARMRK
) == 0) ||
2449 ((tiosp
->c_iflag
& (IGNPAR
| IGNBRK
)) == (IGNPAR
| IGNBRK
))) &&
2450 ((tiosp
->c_lflag
& (ECHO
| ICANON
| IEXTEN
| ISIG
| PENDIN
)) ==0) &&
2451 (linesw
[tp
->t_line
].l_rint
== ttyinput
))
2452 tp
->t_state
|= TS_CAN_BYPASS_L_RINT
;
2454 tp
->t_state
&= ~TS_CAN_BYPASS_L_RINT
;
2455 portp
->hotchar
= linesw
[tp
->t_line
].l_hotchar
;
2458 /*****************************************************************************/
2461 * All panels and ports actually attached have been worked out. All
2462 * we need to do here is set up the appropriate per port data structures.
2465 static int stli_initports(stlibrd_t
*brdp
)
2468 int i
, panelnr
, panelport
;
2471 kprintf("stli_initports(brdp=%x)\n", (int) brdp
);
2474 for (i
= 0, panelnr
= 0, panelport
= 0; (i
< brdp
->nrports
); i
++) {
2475 portp
= kmalloc(sizeof(stliport_t
), M_TTYS
, M_WAITOK
| M_ZERO
);
2476 callout_init(&portp
->dtr_ch
);
2478 portp
->brdnr
= brdp
->brdnr
;
2479 portp
->panelnr
= panelnr
;
2480 portp
->initintios
.c_ispeed
= STL_DEFSPEED
;
2481 portp
->initintios
.c_ospeed
= STL_DEFSPEED
;
2482 portp
->initintios
.c_cflag
= STL_DEFCFLAG
;
2483 portp
->initintios
.c_iflag
= 0;
2484 portp
->initintios
.c_oflag
= 0;
2485 portp
->initintios
.c_lflag
= 0;
2486 bcopy(&ttydefchars
[0], &portp
->initintios
.c_cc
[0],
2487 sizeof(portp
->initintios
.c_cc
));
2488 portp
->initouttios
= portp
->initintios
;
2489 portp
->dtrwait
= 3 * hz
;
2492 if (panelport
>= brdp
->panels
[panelnr
]) {
2496 brdp
->ports
[i
] = portp
;
2503 /*****************************************************************************/
2506 * All the following routines are board specific hardware operations.
2509 static void stli_ecpinit(stlibrd_t
*brdp
)
2511 unsigned long memconf
;
2514 kprintf("stli_ecpinit(brdp=%d)\n", (int) brdp
);
2517 outb((brdp
->iobase
+ ECP_ATCONFR
), ECP_ATSTOP
);
2519 outb((brdp
->iobase
+ ECP_ATCONFR
), ECP_ATDISABLE
);
2522 memconf
= (brdp
->paddr
& ECP_ATADDRMASK
) >> ECP_ATADDRSHFT
;
2523 outb((brdp
->iobase
+ ECP_ATMEMAR
), memconf
);
2526 /*****************************************************************************/
2528 static void stli_ecpenable(stlibrd_t
*brdp
)
2531 kprintf("stli_ecpenable(brdp=%x)\n", (int) brdp
);
2533 outb((brdp
->iobase
+ ECP_ATCONFR
), ECP_ATENABLE
);
2536 /*****************************************************************************/
2538 static void stli_ecpdisable(stlibrd_t
*brdp
)
2541 kprintf("stli_ecpdisable(brdp=%x)\n", (int) brdp
);
2543 outb((brdp
->iobase
+ ECP_ATCONFR
), ECP_ATDISABLE
);
2546 /*****************************************************************************/
2548 static char *stli_ecpgetmemptr(stlibrd_t
*brdp
, unsigned long offset
, int line
)
2554 kprintf("stli_ecpgetmemptr(brdp=%x,offset=%x)\n", (int) brdp
,
2558 if (offset
> brdp
->memsize
) {
2559 kprintf("STALLION: shared memory pointer=%x out of range at "
2560 "line=%d(%d), brd=%d\n", (int) offset
, line
,
2561 __LINE__
, brdp
->brdnr
);
2565 ptr
= (char *) brdp
->vaddr
+ (offset
% ECP_ATPAGESIZE
);
2566 val
= (unsigned char) (offset
/ ECP_ATPAGESIZE
);
2568 outb((brdp
->iobase
+ ECP_ATMEMPR
), val
);
2572 /*****************************************************************************/
2574 static void stli_ecpreset(stlibrd_t
*brdp
)
2577 kprintf("stli_ecpreset(brdp=%x)\n", (int) brdp
);
2580 outb((brdp
->iobase
+ ECP_ATCONFR
), ECP_ATSTOP
);
2582 outb((brdp
->iobase
+ ECP_ATCONFR
), ECP_ATDISABLE
);
2586 /*****************************************************************************/
2588 static void stli_ecpintr(stlibrd_t
*brdp
)
2591 kprintf("stli_ecpintr(brdp=%x)\n", (int) brdp
);
2593 outb(brdp
->iobase
, 0x1);
2596 /*****************************************************************************/
2599 * The following set of functions act on ECP EISA boards.
2602 static void stli_ecpeiinit(stlibrd_t
*brdp
)
2604 unsigned long memconf
;
2607 kprintf("stli_ecpeiinit(brdp=%x)\n", (int) brdp
);
2610 outb((brdp
->iobase
+ ECP_EIBRDENAB
), 0x1);
2611 outb((brdp
->iobase
+ ECP_EICONFR
), ECP_EISTOP
);
2613 outb((brdp
->iobase
+ ECP_EICONFR
), ECP_EIDISABLE
);
2616 memconf
= (brdp
->paddr
& ECP_EIADDRMASKL
) >> ECP_EIADDRSHFTL
;
2617 outb((brdp
->iobase
+ ECP_EIMEMARL
), memconf
);
2618 memconf
= (brdp
->paddr
& ECP_EIADDRMASKH
) >> ECP_EIADDRSHFTH
;
2619 outb((brdp
->iobase
+ ECP_EIMEMARH
), memconf
);
2622 /*****************************************************************************/
2624 static void stli_ecpeienable(stlibrd_t
*brdp
)
2626 outb((brdp
->iobase
+ ECP_EICONFR
), ECP_EIENABLE
);
2629 /*****************************************************************************/
2631 static void stli_ecpeidisable(stlibrd_t
*brdp
)
2633 outb((brdp
->iobase
+ ECP_EICONFR
), ECP_EIDISABLE
);
2636 /*****************************************************************************/
2638 static char *stli_ecpeigetmemptr(stlibrd_t
*brdp
, unsigned long offset
, int line
)
2644 kprintf("stli_ecpeigetmemptr(brdp=%x,offset=%x,line=%d)\n",
2645 (int) brdp
, (int) offset
, line
);
2648 if (offset
> brdp
->memsize
) {
2649 kprintf("STALLION: shared memory pointer=%x out of range at "
2650 "line=%d(%d), brd=%d\n", (int) offset
, line
,
2651 __LINE__
, brdp
->brdnr
);
2655 ptr
= (char *) brdp
->vaddr
+ (offset
% ECP_EIPAGESIZE
);
2656 if (offset
< ECP_EIPAGESIZE
)
2659 val
= ECP_EIENABLE
| 0x40;
2661 outb((brdp
->iobase
+ ECP_EICONFR
), val
);
2665 /*****************************************************************************/
2667 static void stli_ecpeireset(stlibrd_t
*brdp
)
2669 outb((brdp
->iobase
+ ECP_EICONFR
), ECP_EISTOP
);
2671 outb((brdp
->iobase
+ ECP_EICONFR
), ECP_EIDISABLE
);
2675 /*****************************************************************************/
2678 * The following routines act on ONboards.
2681 static void stli_onbinit(stlibrd_t
*brdp
)
2683 unsigned long memconf
;
2687 kprintf("stli_onbinit(brdp=%d)\n", (int) brdp
);
2690 outb((brdp
->iobase
+ ONB_ATCONFR
), ONB_ATSTOP
);
2692 outb((brdp
->iobase
+ ONB_ATCONFR
), ONB_ATDISABLE
);
2693 for (i
= 0; (i
< 1000); i
++)
2696 memconf
= (brdp
->paddr
& ONB_ATADDRMASK
) >> ONB_ATADDRSHFT
;
2697 outb((brdp
->iobase
+ ONB_ATMEMAR
), memconf
);
2698 outb(brdp
->iobase
, 0x1);
2702 /*****************************************************************************/
2704 static void stli_onbenable(stlibrd_t
*brdp
)
2707 kprintf("stli_onbenable(brdp=%x)\n", (int) brdp
);
2709 outb((brdp
->iobase
+ ONB_ATCONFR
), (ONB_ATENABLE
| brdp
->confbits
));
2712 /*****************************************************************************/
2714 static void stli_onbdisable(stlibrd_t
*brdp
)
2717 kprintf("stli_onbdisable(brdp=%x)\n", (int) brdp
);
2719 outb((brdp
->iobase
+ ONB_ATCONFR
), (ONB_ATDISABLE
| brdp
->confbits
));
2722 /*****************************************************************************/
2724 static char *stli_onbgetmemptr(stlibrd_t
*brdp
, unsigned long offset
, int line
)
2729 kprintf("stli_onbgetmemptr(brdp=%x,offset=%x)\n", (int) brdp
,
2733 if (offset
> brdp
->memsize
) {
2734 kprintf("STALLION: shared memory pointer=%x out of range at "
2735 "line=%d(%d), brd=%d\n", (int) offset
, line
,
2736 __LINE__
, brdp
->brdnr
);
2739 ptr
= (char *) brdp
->vaddr
+ (offset
% ONB_ATPAGESIZE
);
2744 /*****************************************************************************/
2746 static void stli_onbreset(stlibrd_t
*brdp
)
2751 kprintf("stli_onbreset(brdp=%x)\n", (int) brdp
);
2754 outb((brdp
->iobase
+ ONB_ATCONFR
), ONB_ATSTOP
);
2756 outb((brdp
->iobase
+ ONB_ATCONFR
), ONB_ATDISABLE
);
2757 for (i
= 0; (i
< 1000); i
++)
2761 /*****************************************************************************/
2764 * The following routines act on ONboard EISA.
2767 static void stli_onbeinit(stlibrd_t
*brdp
)
2769 unsigned long memconf
;
2773 kprintf("stli_onbeinit(brdp=%d)\n", (int) brdp
);
2776 outb((brdp
->iobase
+ ONB_EIBRDENAB
), 0x1);
2777 outb((brdp
->iobase
+ ONB_EICONFR
), ONB_EISTOP
);
2779 outb((brdp
->iobase
+ ONB_EICONFR
), ONB_EIDISABLE
);
2780 for (i
= 0; (i
< 1000); i
++)
2783 memconf
= (brdp
->paddr
& ONB_EIADDRMASKL
) >> ONB_EIADDRSHFTL
;
2784 outb((brdp
->iobase
+ ONB_EIMEMARL
), memconf
);
2785 memconf
= (brdp
->paddr
& ONB_EIADDRMASKH
) >> ONB_EIADDRSHFTH
;
2786 outb((brdp
->iobase
+ ONB_EIMEMARH
), memconf
);
2787 outb(brdp
->iobase
, 0x1);
2791 /*****************************************************************************/
2793 static void stli_onbeenable(stlibrd_t
*brdp
)
2796 kprintf("stli_onbeenable(brdp=%x)\n", (int) brdp
);
2798 outb((brdp
->iobase
+ ONB_EICONFR
), ONB_EIENABLE
);
2801 /*****************************************************************************/
2803 static void stli_onbedisable(stlibrd_t
*brdp
)
2806 kprintf("stli_onbedisable(brdp=%x)\n", (int) brdp
);
2808 outb((brdp
->iobase
+ ONB_EICONFR
), ONB_EIDISABLE
);
2811 /*****************************************************************************/
2813 static char *stli_onbegetmemptr(stlibrd_t
*brdp
, unsigned long offset
, int line
)
2819 kprintf("stli_onbegetmemptr(brdp=%x,offset=%x,line=%d)\n", (int) brdp
,
2820 (int) offset
, line
);
2823 if (offset
> brdp
->memsize
) {
2824 kprintf("STALLION: shared memory pointer=%x out of range at "
2825 "line=%d(%d), brd=%d\n", (int) offset
, line
,
2826 __LINE__
, brdp
->brdnr
);
2830 ptr
= (char *) brdp
->vaddr
+ (offset
% ONB_EIPAGESIZE
);
2831 if (offset
< ONB_EIPAGESIZE
)
2834 val
= ONB_EIENABLE
| 0x40;
2836 outb((brdp
->iobase
+ ONB_EICONFR
), val
);
2840 /*****************************************************************************/
2842 static void stli_onbereset(stlibrd_t
*brdp
)
2847 kprintf("stli_onbereset(brdp=%x)\n", (int) brdp
);
2850 outb((brdp
->iobase
+ ONB_EICONFR
), ONB_EISTOP
);
2852 outb((brdp
->iobase
+ ONB_EICONFR
), ONB_EIDISABLE
);
2853 for (i
= 0; (i
< 1000); i
++)
2857 /*****************************************************************************/
2860 * The following routines act on Brumby boards.
2863 static void stli_bbyinit(stlibrd_t
*brdp
)
2868 kprintf("stli_bbyinit(brdp=%d)\n", (int) brdp
);
2871 outb((brdp
->iobase
+ BBY_ATCONFR
), BBY_ATSTOP
);
2873 outb((brdp
->iobase
+ BBY_ATCONFR
), 0);
2874 for (i
= 0; (i
< 1000); i
++)
2876 outb(brdp
->iobase
, 0x1);
2880 /*****************************************************************************/
2882 static char *stli_bbygetmemptr(stlibrd_t
*brdp
, unsigned long offset
, int line
)
2888 kprintf("stli_bbygetmemptr(brdp=%x,offset=%x)\n", (int) brdp
,
2892 if (offset
> brdp
->memsize
) {
2893 kprintf("STALLION: shared memory pointer=%x out of range at "
2894 "line=%d(%d), brd=%d\n", (int) offset
, line
,
2895 __LINE__
, brdp
->brdnr
);
2899 ptr
= (char *) brdp
->vaddr
+ (offset
% BBY_PAGESIZE
);
2900 val
= (unsigned char) (offset
/ BBY_PAGESIZE
);
2902 outb((brdp
->iobase
+ BBY_ATCONFR
), val
);
2906 /*****************************************************************************/
2908 static void stli_bbyreset(stlibrd_t
*brdp
)
2913 kprintf("stli_bbyreset(brdp=%x)\n", (int) brdp
);
2916 outb((brdp
->iobase
+ BBY_ATCONFR
), BBY_ATSTOP
);
2918 outb((brdp
->iobase
+ BBY_ATCONFR
), 0);
2919 for (i
= 0; (i
< 1000); i
++)
2923 /*****************************************************************************/
2926 * The following routines act on original old Stallion boards.
2929 static void stli_stalinit(stlibrd_t
*brdp
)
2934 kprintf("stli_stalinit(brdp=%d)\n", (int) brdp
);
2937 outb(brdp
->iobase
, 0x1);
2938 for (i
= 0; (i
< 1000); i
++)
2942 /*****************************************************************************/
2944 static char *stli_stalgetmemptr(stlibrd_t
*brdp
, unsigned long offset
, int line
)
2949 kprintf("stli_stalgetmemptr(brdp=%x,offset=%x)\n", (int) brdp
,
2953 if (offset
> brdp
->memsize
) {
2954 kprintf("STALLION: shared memory pointer=%x out of range at "
2955 "line=%d(%d), brd=%d\n", (int) offset
, line
,
2956 __LINE__
, brdp
->brdnr
);
2959 ptr
= (char *) brdp
->vaddr
+ (offset
% STAL_PAGESIZE
);
2964 /*****************************************************************************/
2966 static void stli_stalreset(stlibrd_t
*brdp
)
2968 volatile unsigned long *vecp
;
2972 kprintf("stli_stalreset(brdp=%x)\n", (int) brdp
);
2975 vecp
= (volatile unsigned long *) ((char *) brdp
->vaddr
+ 0x30);
2977 outb(brdp
->iobase
, 0);
2978 for (i
= 0; (i
< 1000); i
++)
2982 /*****************************************************************************/
2985 * Try to find an ECP board and initialize it. This handles only ECP
2989 static int stli_initecp(stlibrd_t
*brdp
)
2993 unsigned int status
, nxtid
;
2997 kprintf("stli_initecp(brdp=%x)\n", (int) brdp
);
3001 * Do a basic sanity check on the IO and memory addresses.
3003 if ((brdp
->iobase
== 0) || (brdp
->paddr
== 0))
3007 * Based on the specific board type setup the common vars to access
3008 * and enable shared memory. Set all board specific information now
3011 switch (brdp
->brdtype
) {
3013 brdp
->memsize
= ECP_MEMSIZE
;
3014 brdp
->pagesize
= ECP_ATPAGESIZE
;
3015 brdp
->init
= stli_ecpinit
;
3016 brdp
->enable
= stli_ecpenable
;
3017 brdp
->reenable
= stli_ecpenable
;
3018 brdp
->disable
= stli_ecpdisable
;
3019 brdp
->getmemptr
= stli_ecpgetmemptr
;
3020 brdp
->intr
= stli_ecpintr
;
3021 brdp
->reset
= stli_ecpreset
;
3025 brdp
->memsize
= ECP_MEMSIZE
;
3026 brdp
->pagesize
= ECP_EIPAGESIZE
;
3027 brdp
->init
= stli_ecpeiinit
;
3028 brdp
->enable
= stli_ecpeienable
;
3029 brdp
->reenable
= stli_ecpeienable
;
3030 brdp
->disable
= stli_ecpeidisable
;
3031 brdp
->getmemptr
= stli_ecpeigetmemptr
;
3032 brdp
->intr
= stli_ecpintr
;
3033 brdp
->reset
= stli_ecpeireset
;
3041 * The per-board operations structure is all setup, so now lets go
3042 * and get the board operational. Firstly initialize board configuration
3048 * Now that all specific code is set up, enable the shared memory and
3049 * look for the a signature area that will tell us exactly what board
3050 * this is, and what it is connected to it.
3053 sigsp
= (cdkecpsig_t
*) EBRDGETMEMPTR(brdp
, CDK_SIGADDR
);
3054 bcopy(sigsp
, &sig
, sizeof(cdkecpsig_t
));
3058 kprintf("%s(%d): sig-> magic=%x rom=%x panel=%x,%x,%x,%x,%x,%x,%x,%x\n",
3059 __file__
, __LINE__
, (int) sig
.magic
, sig
.romver
,
3060 sig
.panelid
[0], (int) sig
.panelid
[1], (int) sig
.panelid
[2],
3061 (int) sig
.panelid
[3], (int) sig
.panelid
[4],
3062 (int) sig
.panelid
[5], (int) sig
.panelid
[6],
3063 (int) sig
.panelid
[7]);
3066 if (sig
.magic
!= ECP_MAGIC
)
3070 * Scan through the signature looking at the panels connected to the
3071 * board. Calculate the total number of ports as we go.
3073 for (panelnr
= 0, nxtid
= 0; (panelnr
< STL_MAXPANELS
); panelnr
++) {
3074 status
= sig
.panelid
[nxtid
];
3075 if ((status
& ECH_PNLIDMASK
) != nxtid
)
3077 brdp
->panelids
[panelnr
] = status
;
3078 if (status
& ECH_PNL16PORT
) {
3079 brdp
->panels
[panelnr
] = 16;
3080 brdp
->nrports
+= 16;
3083 brdp
->panels
[panelnr
] = 8;
3090 brdp
->state
|= BST_FOUND
;
3094 /*****************************************************************************/
3097 * Try to find an ONboard, Brumby or Stallion board and initialize it.
3098 * This handles only these board types.
3101 static int stli_initonb(stlibrd_t
*brdp
)
3108 kprintf("stli_initonb(brdp=%x)\n", (int) brdp
);
3112 * Do a basic sanity check on the IO and memory addresses.
3114 if ((brdp
->iobase
== 0) || (brdp
->paddr
== 0))
3118 * Based on the specific board type setup the common vars to access
3119 * and enable shared memory. Set all board specific information now
3122 switch (brdp
->brdtype
) {
3126 case BRD_ONBOARD2_32
:
3128 brdp
->memsize
= ONB_MEMSIZE
;
3129 brdp
->pagesize
= ONB_ATPAGESIZE
;
3130 brdp
->init
= stli_onbinit
;
3131 brdp
->enable
= stli_onbenable
;
3132 brdp
->reenable
= stli_onbenable
;
3133 brdp
->disable
= stli_onbdisable
;
3134 brdp
->getmemptr
= stli_onbgetmemptr
;
3135 brdp
->intr
= stli_ecpintr
;
3136 brdp
->reset
= stli_onbreset
;
3137 brdp
->confbits
= (brdp
->paddr
> 0x100000) ? ONB_HIMEMENAB
: 0;
3141 brdp
->memsize
= ONB_EIMEMSIZE
;
3142 brdp
->pagesize
= ONB_EIPAGESIZE
;
3143 brdp
->init
= stli_onbeinit
;
3144 brdp
->enable
= stli_onbeenable
;
3145 brdp
->reenable
= stli_onbeenable
;
3146 brdp
->disable
= stli_onbedisable
;
3147 brdp
->getmemptr
= stli_onbegetmemptr
;
3148 brdp
->intr
= stli_ecpintr
;
3149 brdp
->reset
= stli_onbereset
;
3155 brdp
->memsize
= BBY_MEMSIZE
;
3156 brdp
->pagesize
= BBY_PAGESIZE
;
3157 brdp
->init
= stli_bbyinit
;
3158 brdp
->enable
= NULL
;
3159 brdp
->reenable
= NULL
;
3160 brdp
->disable
= NULL
;
3161 brdp
->getmemptr
= stli_bbygetmemptr
;
3162 brdp
->intr
= stli_ecpintr
;
3163 brdp
->reset
= stli_bbyreset
;
3167 brdp
->memsize
= STAL_MEMSIZE
;
3168 brdp
->pagesize
= STAL_PAGESIZE
;
3169 brdp
->init
= stli_stalinit
;
3170 brdp
->enable
= NULL
;
3171 brdp
->reenable
= NULL
;
3172 brdp
->disable
= NULL
;
3173 brdp
->getmemptr
= stli_stalgetmemptr
;
3174 brdp
->intr
= stli_ecpintr
;
3175 brdp
->reset
= stli_stalreset
;
3183 * The per-board operations structure is all setup, so now lets go
3184 * and get the board operational. Firstly initialize board configuration
3190 * Now that all specific code is set up, enable the shared memory and
3191 * look for the a signature area that will tell us exactly what board
3192 * this is, and how many ports.
3195 sigsp
= (cdkonbsig_t
*) EBRDGETMEMPTR(brdp
, CDK_SIGADDR
);
3196 bcopy(sigsp
, &sig
, sizeof(cdkonbsig_t
));
3200 kprintf("%s(%d): sig-> magic=%x:%x:%x:%x romver=%x amask=%x:%x:%x\n",
3201 __file__
, __LINE__
, sig
.magic0
, sig
.magic1
, sig
.magic2
,
3202 sig
.magic3
, sig
.romver
, sig
.amask0
, sig
.amask1
, sig
.amask2
);
3205 if ((sig
.magic0
!= ONB_MAGIC0
) || (sig
.magic1
!= ONB_MAGIC1
) ||
3206 (sig
.magic2
!= ONB_MAGIC2
) || (sig
.magic3
!= ONB_MAGIC3
))
3210 * Scan through the signature alive mask and calculate how many ports
3211 * there are on this board.
3217 for (i
= 0; (i
< 16); i
++) {
3218 if (((sig
.amask0
<< i
) & 0x8000) == 0)
3223 brdp
->panels
[0] = brdp
->nrports
;
3225 brdp
->state
|= BST_FOUND
;
3229 /*****************************************************************************/
3232 * Start up a running board. This routine is only called after the
3233 * code has been down loaded to the board and is operational. It will
3234 * read in the memory map, and get the show on the road...
3237 static int stli_startbrd(stlibrd_t
*brdp
)
3239 volatile cdkhdr_t
*hdrp
;
3240 volatile cdkmem_t
*memp
;
3241 volatile cdkasy_t
*ap
;
3243 int portnr
, nrdevs
, i
, rc
;
3246 kprintf("stli_startbrd(brdp=%x)\n", (int) brdp
);
3253 hdrp
= (volatile cdkhdr_t
*) EBRDGETMEMPTR(brdp
, CDK_CDKADDR
);
3254 nrdevs
= hdrp
->nrdevs
;
3257 kprintf("%s(%d): CDK version %d.%d.%d --> nrdevs=%d memp=%x hostp=%x "
3258 "slavep=%x\n", __file__
, __LINE__
, hdrp
->ver_release
,
3259 hdrp
->ver_modification
, hdrp
->ver_fix
, nrdevs
,
3260 (int) hdrp
->memp
, (int) hdrp
->hostp
, (int) hdrp
->slavep
);
3263 if (nrdevs
< (brdp
->nrports
+ 1)) {
3264 kprintf("STALLION: slave failed to allocate memory for all "
3265 "devices, devices=%d\n", nrdevs
);
3266 brdp
->nrports
= nrdevs
- 1;
3268 brdp
->nrdevs
= nrdevs
;
3269 brdp
->hostoffset
= hdrp
->hostp
- CDK_CDKADDR
;
3270 brdp
->slaveoffset
= hdrp
->slavep
- CDK_CDKADDR
;
3271 brdp
->bitsize
= (nrdevs
+ 7) / 8;
3272 memp
= (volatile cdkmem_t
*) (void *) (uintptr_t) hdrp
->memp
;
3273 if ((uintptr_t)(volatile void *)memp
> brdp
->memsize
) {
3274 kprintf("STALLION: corrupted shared memory region?\n");
3276 goto stli_donestartup
;
3278 memp
= (volatile cdkmem_t
*) EBRDGETMEMPTR(brdp
,
3279 (uintptr_t)(volatile void *)memp
);
3280 if (memp
->dtype
!= TYP_ASYNCTRL
) {
3281 kprintf("STALLION: no slave control device found\n");
3283 goto stli_donestartup
;
3288 * Cycle through memory allocation of each port. We are guaranteed to
3289 * have all ports inside the first page of slave window, so no need to
3290 * change pages while reading memory map.
3292 for (i
= 1, portnr
= 0; (i
< nrdevs
); i
++, portnr
++, memp
++) {
3293 if (memp
->dtype
!= TYP_ASYNC
)
3295 portp
= brdp
->ports
[portnr
];
3296 if (portp
== (stliport_t
*) NULL
)
3299 portp
->addr
= memp
->offset
;
3300 portp
->reqidx
= (unsigned char) (i
* 8 / nrdevs
);
3301 portp
->reqbit
= (unsigned char) (0x1 << portp
->reqidx
);
3302 portp
->portidx
= (unsigned char) (i
/ 8);
3303 portp
->portbit
= (unsigned char) (0x1 << (i
% 8));
3306 hdrp
->slavereq
= 0xff;
3309 * For each port setup a local copy of the RX and TX buffer offsets
3310 * and sizes. We do this separate from the above, because we need to
3311 * move the shared memory page...
3313 for (i
= 1, portnr
= 0; (i
< nrdevs
); i
++, portnr
++) {
3314 portp
= brdp
->ports
[portnr
];
3315 if (portp
== (stliport_t
*) NULL
)
3317 if (portp
->addr
== 0)
3319 ap
= (volatile cdkasy_t
*) EBRDGETMEMPTR(brdp
, portp
->addr
);
3320 if (ap
!= (volatile cdkasy_t
*) NULL
) {
3321 portp
->rxsize
= ap
->rxq
.size
;
3322 portp
->txsize
= ap
->txq
.size
;
3323 portp
->rxoffset
= ap
->rxq
.offset
;
3324 portp
->txoffset
= ap
->txq
.offset
;
3333 brdp
->state
|= BST_STARTED
;
3335 if (stli_doingtimeout
== 0) {
3336 stli_doingtimeout
++;
3337 callout_init(&stli_poll_ch
);
3338 callout_reset(&stli_poll_ch
, 1, stli_poll
, NULL
);
3344 /*****************************************************************************/
3347 * Probe and initialize the specified board.
3350 static int stli_brdinit(stlibrd_t
*brdp
)
3353 kprintf("stli_brdinit(brdp=%x)\n", (int) brdp
);
3356 stli_brds
[brdp
->brdnr
] = brdp
;
3358 switch (brdp
->brdtype
) {
3367 case BRD_ONBOARD2_32
:
3379 kprintf("STALLION: %s board type not supported in this driver\n",
3380 stli_brdnames
[brdp
->brdtype
]);
3383 kprintf("STALLION: unit=%d is unknown board type=%d\n",
3384 brdp
->brdnr
, brdp
->brdtype
);
3391 /*****************************************************************************/
3394 * Finish off the remaining initialization for a board.
3397 static int stli_brdattach(stlibrd_t
*brdp
)
3400 kprintf("stli_brdattach(brdp=%x)\n", (int) brdp
);
3404 if ((brdp
->state
& BST_FOUND
) == 0) {
3405 kprintf("STALLION: %s board not found, unit=%d io=%x mem=%x\n",
3406 stli_brdnames
[brdp
->brdtype
], brdp
->brdnr
,
3407 brdp
->iobase
, (int) brdp
->paddr
);
3412 stli_initports(brdp
);
3413 kprintf("stli%d: %s (driver version %s), unit=%d nrpanels=%d "
3414 "nrports=%d\n", brdp
->unitid
, stli_brdnames
[brdp
->brdtype
],
3415 stli_drvversion
, brdp
->brdnr
, brdp
->nrpanels
, brdp
->nrports
);
3416 dev_ops_add(&stli_ops
, -1, brdp
->unitid
);
3420 /*****************************************************************************/
3422 /*****************************************************************************/
3425 * Return the board stats structure to user app.
3428 static int stli_getbrdstats(caddr_t data
)
3434 kprintf("stli_getbrdstats(data=%p)\n", (void *) data
);
3437 stli_brdstats
= *((combrd_t
*) data
);
3438 if (stli_brdstats
.brd
>= STL_MAXBRDS
)
3440 brdp
= stli_brds
[stli_brdstats
.brd
];
3441 if (brdp
== (stlibrd_t
*) NULL
)
3444 bzero(&stli_brdstats
, sizeof(combrd_t
));
3445 stli_brdstats
.brd
= brdp
->brdnr
;
3446 stli_brdstats
.type
= brdp
->brdtype
;
3447 stli_brdstats
.hwid
= 0;
3448 stli_brdstats
.state
= brdp
->state
;
3449 stli_brdstats
.ioaddr
= brdp
->iobase
;
3450 stli_brdstats
.memaddr
= brdp
->paddr
;
3451 stli_brdstats
.nrpanels
= brdp
->nrpanels
;
3452 stli_brdstats
.nrports
= brdp
->nrports
;
3453 for (i
= 0; (i
< brdp
->nrpanels
); i
++) {
3454 stli_brdstats
.panels
[i
].panel
= i
;
3455 stli_brdstats
.panels
[i
].hwid
= brdp
->panelids
[i
];
3456 stli_brdstats
.panels
[i
].nrports
= brdp
->panels
[i
];
3459 *((combrd_t
*) data
) = stli_brdstats
;
3463 /*****************************************************************************/
3466 * Resolve the referenced port number into a port struct pointer.
3469 static stliport_t
*stli_getport(int brdnr
, int panelnr
, int portnr
)
3474 if ((brdnr
< 0) || (brdnr
>= STL_MAXBRDS
))
3475 return((stliport_t
*) NULL
);
3476 brdp
= stli_brds
[brdnr
];
3477 if (brdp
== (stlibrd_t
*) NULL
)
3478 return((stliport_t
*) NULL
);
3479 for (i
= 0; (i
< panelnr
); i
++)
3480 portnr
+= brdp
->panels
[i
];
3481 if ((portnr
< 0) || (portnr
>= brdp
->nrports
))
3482 return((stliport_t
*) NULL
);
3483 return(brdp
->ports
[portnr
]);
3486 /*****************************************************************************/
3489 * Return the port stats structure to user app. A NULL port struct
3490 * pointer passed in means that we need to find out from the app
3491 * what port to get stats for (used through board control device).
3494 static int stli_getportstats(stliport_t
*portp
, caddr_t data
)
3499 if (portp
== (stliport_t
*) NULL
) {
3500 stli_comstats
= *((comstats_t
*) data
);
3501 portp
= stli_getport(stli_comstats
.brd
, stli_comstats
.panel
,
3502 stli_comstats
.port
);
3503 if (portp
== (stliport_t
*) NULL
)
3507 brdp
= stli_brds
[portp
->brdnr
];
3508 if (brdp
== (stlibrd_t
*) NULL
)
3511 if (brdp
->state
& BST_STARTED
) {
3512 if ((rc
= stli_cmdwait(brdp
, portp
, A_GETSTATS
, &stli_cdkstats
,
3513 sizeof(asystats_t
), 1)) < 0)
3516 bzero(&stli_cdkstats
, sizeof(asystats_t
));
3519 stli_comstats
.brd
= portp
->brdnr
;
3520 stli_comstats
.panel
= portp
->panelnr
;
3521 stli_comstats
.port
= portp
->portnr
;
3522 stli_comstats
.state
= portp
->state
;
3523 /*stli_comstats.flags = portp->flags;*/
3524 stli_comstats
.ttystate
= portp
->tty
.t_state
;
3525 stli_comstats
.cflags
= portp
->tty
.t_cflag
;
3526 stli_comstats
.iflags
= portp
->tty
.t_iflag
;
3527 stli_comstats
.oflags
= portp
->tty
.t_oflag
;
3528 stli_comstats
.lflags
= portp
->tty
.t_lflag
;
3530 stli_comstats
.txtotal
= stli_cdkstats
.txchars
;
3531 stli_comstats
.rxtotal
= stli_cdkstats
.rxchars
+ stli_cdkstats
.ringover
;
3532 stli_comstats
.txbuffered
= stli_cdkstats
.txringq
;
3533 stli_comstats
.rxbuffered
= stli_cdkstats
.rxringq
;
3534 stli_comstats
.rxoverrun
= stli_cdkstats
.overruns
;
3535 stli_comstats
.rxparity
= stli_cdkstats
.parity
;
3536 stli_comstats
.rxframing
= stli_cdkstats
.framing
;
3537 stli_comstats
.rxlost
= stli_cdkstats
.ringover
+ portp
->rxlost
;
3538 stli_comstats
.rxbreaks
= stli_cdkstats
.rxbreaks
;
3539 stli_comstats
.txbreaks
= stli_cdkstats
.txbreaks
;
3540 stli_comstats
.txxon
= stli_cdkstats
.txstart
;
3541 stli_comstats
.txxoff
= stli_cdkstats
.txstop
;
3542 stli_comstats
.rxxon
= stli_cdkstats
.rxstart
;
3543 stli_comstats
.rxxoff
= stli_cdkstats
.rxstop
;
3544 stli_comstats
.rxrtsoff
= stli_cdkstats
.rtscnt
/ 2;
3545 stli_comstats
.rxrtson
= stli_cdkstats
.rtscnt
- stli_comstats
.rxrtsoff
;
3546 stli_comstats
.modem
= stli_cdkstats
.dcdcnt
;
3547 stli_comstats
.hwid
= stli_cdkstats
.hwid
;
3548 stli_comstats
.signals
= stli_mktiocm(stli_cdkstats
.signals
);
3550 *((comstats_t
*) data
) = stli_comstats
;
3554 /*****************************************************************************/
3557 * Clear the port stats structure. We also return it zeroed out...
3560 static int stli_clrportstats(stliport_t
*portp
, caddr_t data
)
3565 if (portp
== (stliport_t
*) NULL
) {
3566 stli_comstats
= *((comstats_t
*) data
);
3567 portp
= stli_getport(stli_comstats
.brd
, stli_comstats
.panel
,
3568 stli_comstats
.port
);
3569 if (portp
== (stliport_t
*) NULL
)
3573 brdp
= stli_brds
[portp
->brdnr
];
3574 if (brdp
== (stlibrd_t
*) NULL
)
3577 if ((rc
= stli_cmdwait(brdp
, portp
, A_CLEARSTATS
, 0, 0, 0)) < 0)
3581 bzero(&stli_comstats
, sizeof(comstats_t
));
3582 stli_comstats
.brd
= portp
->brdnr
;
3583 stli_comstats
.panel
= portp
->panelnr
;
3584 stli_comstats
.port
= portp
->portnr
;
3586 *((comstats_t
*) data
) = stli_comstats
;
3590 /*****************************************************************************/
3593 * Code to handle an "staliomem" read and write operations. This device
3594 * is the contents of the board shared memory. It is used for down
3595 * loading the slave image (and debugging :-)
3598 STATIC
int stli_memrw(cdev_t dev
, struct uio
*uiop
, int flag
)
3602 int brdnr
, size
, n
, error
;
3605 kprintf("stli_memrw(dev=%x,uiop=%x,flag=%x)\n", (int) dev
,
3609 brdnr
= minor(dev
) & 0x7;
3610 brdp
= stli_brds
[brdnr
];
3611 if (brdp
== (stlibrd_t
*) NULL
)
3613 if (brdp
->state
== 0)
3616 if (uiop
->uio_offset
>= brdp
->memsize
)
3620 size
= brdp
->memsize
- uiop
->uio_offset
;
3625 memptr
= (void *) EBRDGETMEMPTR(brdp
, uiop
->uio_offset
);
3626 n
= MIN(size
, (brdp
->pagesize
-
3627 (((unsigned long) uiop
->uio_offset
) % brdp
->pagesize
)));
3628 error
= uiomove(memptr
, n
, uiop
);
3629 if ((uiop
->uio_resid
== 0) || error
)
3638 /*****************************************************************************/
3641 * The "staliomem" device is also required to do some special operations
3642 * on the board. We need to be able to send an interrupt to the board,
3643 * reset it, and start/stop it.
3646 static int stli_memioctl(cdev_t dev
, unsigned long cmd
, caddr_t data
, int flag
)
3652 kprintf("stli_memioctl(dev=%s,cmd=%lx,data=%p,flag=%x)\n",
3653 devtoname(dev
), cmd
, (void *) data
, flag
);
3657 * Handle board independant ioctls first.
3660 case COM_GETPORTSTATS
:
3661 return(stli_getportstats((stliport_t
*) NULL
, data
));
3663 case COM_CLRPORTSTATS
:
3664 return(stli_clrportstats((stliport_t
*) NULL
, data
));
3666 case COM_GETBRDSTATS
:
3667 return(stli_getbrdstats(data
));
3674 * Handle board dependant ioctls now.
3676 brdnr
= minor(dev
) & 0x7;
3677 brdp
= stli_brds
[brdnr
];
3678 if (brdp
== (stlibrd_t
*) NULL
)
3680 if (brdp
->state
== 0)
3690 rc
= stli_startbrd(brdp
);
3693 brdp
->state
&= ~BST_STARTED
;
3696 brdp
->state
&= ~BST_STARTED
;
3698 if (stli_shared
== 0) {
3699 if (brdp
->reenable
!= NULL
)
3700 (* brdp
->reenable
)(brdp
);
3703 case COM_GETPORTSTATS
:
3704 rc
= stli_getportstats((stliport_t
*) NULL
, data
);
3706 case COM_CLRPORTSTATS
:
3707 rc
= stli_clrportstats((stliport_t
*) NULL
, data
);
3709 case COM_GETBRDSTATS
:
3710 rc
= stli_getbrdstats(data
);
3720 /*****************************************************************************/