/* $NetBSD: hil.c,v 1.19 1995/04/22 20:25:45 christos Exp $ */ /* * Copyright (c) 1988 University of Utah. * Copyright (c) 1990, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * the Systems Programming Group of the University of Utah Computer * Science Department. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: Utah $Hdr: hil.c 1.38 92/01/21$ * * @(#)hil.c 8.2 (Berkeley) 1/12/94 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef hp300 #define NHIL 1 /* XXX */ #else #include "hil.h" #endif struct hilloop hilloop[NHIL]; struct _hilbell default_bell = { BELLDUR, BELLFREQ }; #ifdef hp800 int hilspl; #endif #ifdef DEBUG int hildebug = 0; #define HDB_FOLLOW 0x01 #define HDB_MMAP 0x02 #define HDB_MASK 0x04 #define HDB_CONFIG 0x08 #define HDB_KEYBOARD 0x10 #define HDB_IDMODULE 0x20 #define HDB_EVENTS 0x80 #endif #ifdef COMPAT_HPUX extern struct emul emul_hpux; #endif /* symbolic sleep message strings */ char hilin[] = "hilin"; hilsoftinit(unit, hilbase) int unit; struct hil_dev *hilbase; { register struct hilloop *hilp = &hilloop[unit]; register int i; #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilsoftinit(%d, %x)\n", unit, hilbase); #endif /* * Initialize loop information */ hilp->hl_addr = hilbase; hilp->hl_cmdending = FALSE; hilp->hl_actdev = hilp->hl_cmddev = 0; hilp->hl_cmddone = FALSE; hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_pollbp = hilp->hl_pollbuf; hilp->hl_kbddev = 0; hilp->hl_kbdlang = KBD_DEFAULT; hilp->hl_kbdflags = 0; /* * Clear all queues and device associations with queues */ for (i = 0; i < NHILQ; i++) { hilp->hl_queue[i].hq_eventqueue = NULL; hilp->hl_queue[i].hq_procp = NULL; hilp->hl_queue[i].hq_devmask = 0; } for (i = 0; i < NHILD; i++) hilp->hl_device[i].hd_qmask = 0; hilp->hl_device[HILLOOPDEV].hd_flags = (HIL_ALIVE|HIL_PSEUDO); } hilinit(unit, hilbase) int unit; struct hil_dev *hilbase; { register struct hilloop *hilp = &hilloop[unit]; #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilinit(%d, %x)\n", unit, hilbase); #endif /* * Initialize software (if not already done). */ if ((hilp->hl_device[HILLOOPDEV].hd_flags & HIL_ALIVE) == 0) hilsoftinit(unit, hilbase); /* * Initialize hardware. * Reset the loop hardware, and collect keyboard/id info */ hilreset(hilp); hilinfo(unit); kbdenable(unit); } /* ARGSUSED */ hilopen(dev, flags, mode, p) dev_t dev; int flags, mode; struct proc *p; { register struct hilloop *hilp = &hilloop[HILLOOP(dev)]; register struct hilloopdev *dptr; u_char device = HILUNIT(dev); #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilopen(%d): loop %x device %x\n", p->p_pid, HILLOOP(dev), device); #endif if ((hilp->hl_device[HILLOOPDEV].hd_flags & HIL_ALIVE) == 0) return(ENXIO); dptr = &hilp->hl_device[device]; if ((dptr->hd_flags & HIL_ALIVE) == 0) return(ENODEV); /* * Pseudo-devices cannot be read, nothing more to do. */ if (dptr->hd_flags & HIL_PSEUDO) return(0); /* * Open semantics: * 1. Open devices have only one of HIL_READIN/HIL_QUEUEIN. * 2. HPUX processes always get read syscall interface and * must have exclusive use of the device. * 3. BSD processes default to shared queue interface. * Multiple processes can open the device. */ #ifdef COMPAT_HPUX if (p->p_emul == &emul_hpux) { if (dptr->hd_flags & (HIL_READIN|HIL_QUEUEIN)) return(EBUSY); dptr->hd_flags |= HIL_READIN; } else #endif { if (dptr->hd_flags & HIL_READIN) return(EBUSY); dptr->hd_flags |= HIL_QUEUEIN; } if (flags & FNONBLOCK) dptr->hd_flags |= HIL_NOBLOCK; /* * It is safe to flush the read buffer as we are guarenteed * that no one else is using it. */ if ((dptr->hd_flags & HIL_OPENED) == 0) { dptr->hd_flags |= HIL_OPENED; clalloc(&dptr->hd_queue, HILMAXCLIST, 0); } send_hil_cmd(hilp->hl_addr, HIL_INTON, NULL, 0, NULL); /* * Opened the keyboard, put in raw mode. */ (void) splhil(); if (device == hilp->hl_kbddev) { u_char mask = 0; send_hil_cmd(hilp->hl_addr, HIL_WRITEKBDSADR, &mask, 1, NULL); hilp->hl_kbdflags |= KBD_RAW; #ifdef DEBUG if (hildebug & HDB_KEYBOARD) printf("hilopen: keyboard %d raw\n", hilp->hl_kbddev); #endif } (void) spl0(); return (0); } /* ARGSUSED */ hilclose(dev, flags, mode, p) dev_t dev; int flags, mode; struct proc *p; { register struct hilloop *hilp = &hilloop[HILLOOP(dev)]; register struct hilloopdev *dptr; register int i; u_char device = HILUNIT(dev); char mask, lpctrl; extern struct emul emul_netbsd; #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilclose(%d): device %x\n", p->p_pid, device); #endif dptr = &hilp->hl_device[device]; if (device && (dptr->hd_flags & HIL_PSEUDO)) return (0); if (p && p->p_emul == &emul_netbsd) { /* * If this is the loop device, * free up all queues belonging to this process. */ if (device == 0) { for (i = 0; i < NHILQ; i++) if (hilp->hl_queue[i].hq_procp == p) (void) hilqfree(hilp, i); } else { mask = ~hildevmask(device); (void) splhil(); for (i = 0; i < NHILQ; i++) if (hilp->hl_queue[i].hq_procp == p) { dptr->hd_qmask &= ~hilqmask(i); hilp->hl_queue[i].hq_devmask &= mask; } (void) spl0(); } } /* * The read buffer can go away. */ dptr->hd_flags &= ~(HIL_QUEUEIN|HIL_READIN|HIL_NOBLOCK|HIL_OPENED); clfree(&dptr->hd_queue); /* * Set keyboard back to cooked mode when closed. */ (void) splhil(); if (device && device == hilp->hl_kbddev) { mask = 1 << (hilp->hl_kbddev - 1); send_hil_cmd(hilp->hl_addr, HIL_WRITEKBDSADR, &mask, 1, NULL); hilp->hl_kbdflags &= ~(KBD_RAW|KBD_AR1|KBD_AR2); /* * XXX: We have had trouble with keyboards remaining raw * after close due to the LPC_KBDCOOK bit getting cleared * somewhere along the line. Hence we check and reset * LPCTRL if necessary. */ send_hil_cmd(hilp->hl_addr, HIL_READLPCTRL, NULL, 0, &lpctrl); if ((lpctrl & LPC_KBDCOOK) == 0) { printf("hilclose: bad LPCTRL %x, reset to %x\n", lpctrl, lpctrl|LPC_KBDCOOK); lpctrl |= LPC_KBDCOOK; send_hil_cmd(hilp->hl_addr, HIL_WRITELPCTRL, &lpctrl, 1, NULL); } #ifdef DEBUG if (hildebug & HDB_KEYBOARD) printf("hilclose: keyboard %d cooked\n", hilp->hl_kbddev); #endif kbdenable(HILLOOP(dev)); } (void) spl0(); return (0); } /* * Read interface to HIL device. */ hilread(dev, uio) dev_t dev; register struct uio *uio; { struct hilloop *hilp = &hilloop[HILLOOP(dev)]; register struct hilloopdev *dptr; register int cc; u_char device = HILUNIT(dev); u_char buf[HILBUFSIZE]; int error; #if 0 /* * XXX: Don't do this since HP-UX doesn't. * * Check device number. * This check is necessary since loop can reconfigure. */ if (device > hilp->hl_maxdev) return(ENODEV); #endif dptr = &hilp->hl_device[device]; if ((dptr->hd_flags & HIL_READIN) == 0) return(ENODEV); (void) splhil(); while (dptr->hd_queue.c_cc == 0) { if (dptr->hd_flags & HIL_NOBLOCK) { spl0(); return(EWOULDBLOCK); } dptr->hd_flags |= HIL_ASLEEP; if (error = tsleep((caddr_t)dptr, TTIPRI | PCATCH, hilin, 0)) { (void) spl0(); return (error); } } (void) spl0(); error = 0; while (uio->uio_resid > 0 && error == 0) { cc = q_to_b(&dptr->hd_queue, buf, min(uio->uio_resid, HILBUFSIZE)); if (cc <= 0) break; error = uiomove(buf, cc, uio); } return(error); } hilioctl(dev, cmd, data, flag, p) dev_t dev; int cmd, flag; caddr_t data; struct proc *p; { register struct hilloop *hilp = &hilloop[HILLOOP(dev)]; char device = HILUNIT(dev); struct hilloopdev *dptr; register int i; u_char hold; int error; #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilioctl(%d): dev %x cmd %x\n", p->p_pid, device, cmd); #endif dptr = &hilp->hl_device[device]; if ((dptr->hd_flags & HIL_ALIVE) == 0) return (ENODEV); /* * Don't allow hardware ioctls on virtual devices. * Note that though these are the BSD names, they have the same * values as the HP-UX equivalents so we catch them as well. */ if (dptr->hd_flags & HIL_PSEUDO) { switch (cmd) { case HILIOCSC: case HILIOCID: case OHILIOCID: case HILIOCRN: case HILIOCRS: case HILIOCED: return(ENODEV); /* * XXX: should also return ENODEV but HP-UX compat * breaks if we do. They work ok right now because * we only recognize one keyboard on the loop. This * will have to change if we remove that restriction. */ case HILIOCAROFF: case HILIOCAR1: case HILIOCAR2: break; default: break; } } #ifdef COMPAT_HPUX if (p->p_emul == &emul_hpux) return(hpuxhilioctl(dev, cmd, data, flag)); #endif hilp->hl_cmdbp = hilp->hl_cmdbuf; bzero((caddr_t)hilp->hl_cmdbuf, HILBUFSIZE); hilp->hl_cmddev = device; error = 0; switch (cmd) { case HILIOCSBP: /* Send four data bytes to the tone gererator. */ send_hil_cmd(hilp->hl_addr, HIL_STARTCMD, data, 4, NULL); /* Send the trigger beeper command to the 8042. */ send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, NULL); break; case OHILIOCRRT: case HILIOCRRT: /* Transfer the real time to the 8042 data buffer */ send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, NULL); /* Read each byte of the real time */ for (i = 0; i < 5; i++) { send_hil_cmd(hilp->hl_addr, HIL_READTIME + i, NULL, 0, &hold); data[4-i] = hold; } break; case HILIOCRT: for (i = 0; i < 4; i++) { send_hil_cmd(hilp->hl_addr, (cmd & 0xFF) + i, NULL, 0, &hold); data[i] = hold; } break; case HILIOCID: case OHILIOCID: case HILIOCSC: case HILIOCRN: case HILIOCRS: case HILIOCED: send_hildev_cmd(hilp, device, (cmd & 0xFF)); bcopy(hilp->hl_cmdbuf, data, hilp->hl_cmdbp-hilp->hl_cmdbuf); break; case HILIOCAROFF: case HILIOCAR1: case HILIOCAR2: if (hilp->hl_kbddev) { hilp->hl_cmddev = hilp->hl_kbddev; send_hildev_cmd(hilp, hilp->hl_kbddev, (cmd & 0xFF)); hilp->hl_kbdflags &= ~(KBD_AR1|KBD_AR2); if (cmd == HILIOCAR1) hilp->hl_kbdflags |= KBD_AR1; else if (cmd == HILIOCAR2) hilp->hl_kbdflags |= KBD_AR2; } break; case HILIOCBEEP: hilbeep(hilp, (struct _hilbell *)data); break; case FIONBIO: dptr = &hilp->hl_device[device]; if (*(int *)data) dptr->hd_flags |= HIL_NOBLOCK; else dptr->hd_flags &= ~HIL_NOBLOCK; break; /* * FIOASYNC must be present for FIONBIO above to work! * (See fcntl in kern_descrip.c). */ case FIOASYNC: break; case HILIOCALLOCQ: error = hilqalloc(hilp, (struct hilqinfo *)data); break; case HILIOCFREEQ: error = hilqfree(hilp, ((struct hilqinfo *)data)->qid); break; case HILIOCMAPQ: error = hilqmap(hilp, *(int *)data, device); break; case HILIOCUNMAPQ: error = hilqunmap(hilp, *(int *)data, device); break; case HILIOCHPUX: dptr = &hilp->hl_device[device]; dptr->hd_flags |= HIL_READIN; dptr->hd_flags &= ~HIL_QUEUEIN; break; case HILIOCRESET: hilreset(hilp); break; #ifdef DEBUG case HILIOCTEST: hildebug = *(int *) data; break; #endif default: error = EINVAL; break; } hilp->hl_cmddev = 0; return(error); } #ifdef COMPAT_HPUX /* ARGSUSED */ hpuxhilioctl(dev, cmd, data, flag) dev_t dev; int cmd, flag; caddr_t data; { register struct hilloop *hilp = &hilloop[HILLOOP(dev)]; char device = HILUNIT(dev); struct hilloopdev *dptr; register int i; u_char hold; hilp->hl_cmdbp = hilp->hl_cmdbuf; bzero((caddr_t)hilp->hl_cmdbuf, HILBUFSIZE); hilp->hl_cmddev = device; switch (cmd) { case HILSC: case HILID: case HILRN: case HILRS: case HILED: case HILP1: case HILP2: case HILP3: case HILP4: case HILP5: case HILP6: case HILP7: case HILP: case HILA1: case HILA2: case HILA3: case HILA4: case HILA5: case HILA6: case HILA7: case HILA: send_hildev_cmd(hilp, device, (cmd & 0xFF)); bcopy(hilp->hl_cmdbuf, data, hilp->hl_cmdbp-hilp->hl_cmdbuf); break; case HILDKR: case HILER1: case HILER2: if (hilp->hl_kbddev) { hilp->hl_cmddev = hilp->hl_kbddev; send_hildev_cmd(hilp, hilp->hl_kbddev, (cmd & 0xFF)); hilp->hl_kbdflags &= ~(KBD_AR1|KBD_AR2); if (cmd == HILIOCAR1) hilp->hl_kbdflags |= KBD_AR1; else if (cmd == HILIOCAR2) hilp->hl_kbdflags |= KBD_AR2; } break; case EFTSBP: /* Send four data bytes to the tone gererator. */ send_hil_cmd(hilp->hl_addr, HIL_STARTCMD, data, 4, NULL); /* Send the trigger beeper command to the 8042. */ send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, NULL); break; case EFTRRT: /* Transfer the real time to the 8042 data buffer */ send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, NULL); /* Read each byte of the real time */ for (i = 0; i < 5; i++) { send_hil_cmd(hilp->hl_addr, HIL_READTIME + i, NULL, 0, &hold); data[4-i] = hold; } break; case EFTRT: for (i = 0; i < 4; i++) { send_hil_cmd(hilp->hl_addr, (cmd & 0xFF) + i, NULL, 0, &hold); data[i] = hold; } break; case EFTRLC: case EFTRCC: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, &hold); *data = hold; break; case EFTSRPG: case EFTSRD: case EFTSRR: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), data, 1, NULL); break; case EFTSBI: #ifdef hp800 /* XXX big magic */ hold = 7 - (*(u_char *)data >> 5); *(int *)data = 0x84069008 | (hold << 8); send_hil_cmd(hilp->hl_addr, HIL_STARTCMD, data, 4, NULL); send_hil_cmd(hilp->hl_addr, 0xC4, NULL, 0, NULL); break; #else hilbeep(hilp, (struct _hilbell *)data); #endif break; case FIONBIO: dptr = &hilp->hl_device[device]; if (*(int *)data) dptr->hd_flags |= HIL_NOBLOCK; else dptr->hd_flags &= ~HIL_NOBLOCK; break; case FIOASYNC: break; default: hilp->hl_cmddev = 0; return(EINVAL); } hilp->hl_cmddev = 0; return(0); } #endif /* ARGSUSED */ hilmmap(dev, off, prot) dev_t dev; int off, prot; { } /*ARGSUSED*/ hilselect(dev, rw, p) dev_t dev; int rw; struct proc *p; { register struct hilloop *hilp = &hilloop[HILLOOP(dev)]; register struct hilloopdev *dptr; register struct hiliqueue *qp; register int mask; int s, device; if (rw == FWRITE) return (1); device = HILUNIT(dev); /* * Read interface. * Return 1 if there is something in the queue, 0 ow. */ dptr = &hilp->hl_device[device]; if (dptr->hd_flags & HIL_READIN) { s = splhil(); if (dptr->hd_queue.c_cc) { splx(s); return (1); } selrecord(p, &dptr->hd_selr); splx(s); return (0); } /* * Make sure device is alive and real (or the loop device). * Note that we do not do this for the read interface. * This is primarily to be consistant with HP-UX. */ if (device && (dptr->hd_flags & (HIL_ALIVE|HIL_PSEUDO)) != HIL_ALIVE) return (1); /* * Select on loop device is special. * Check to see if there are any data for any loop device * provided it is associated with a queue belonging to this user. */ if (device == 0) mask = -1; else mask = hildevmask(device); /* * Must check everybody with interrupts blocked to prevent races. */ s = splhil(); for (qp = hilp->hl_queue; qp < &hilp->hl_queue[NHILQ]; qp++) if (qp->hq_procp == p && (mask & qp->hq_devmask) && qp->hq_eventqueue->hil_evqueue.head != qp->hq_eventqueue->hil_evqueue.tail) { splx(s); return (1); } selrecord(p, &dptr->hd_selr); splx(s); return (0); } /*ARGSUSED*/ hilint(unit) int unit; { #ifdef hp300 struct hilloop *hilp = &hilloop[0]; /* XXX how do we know on 300? */ #else struct hilloop *hilp = &hilloop[unit]; #endif register struct hil_dev *hildevice = hilp->hl_addr; u_char c, stat; stat = READHILSTAT(hildevice); c = READHILDATA(hildevice); /* clears interrupt */ hil_process_int(hilp, stat, c); } #include "ite.h" hil_process_int(hilp, stat, c) register struct hilloop *hilp; register u_char stat, c; { #ifdef DEBUG if (hildebug & HDB_EVENTS) printf("hilint: %x %x\n", stat, c); #endif /* the shift enables the compiler to generate a jump table */ switch ((stat>>HIL_SSHIFT) & HIL_SMASK) { #if NITE > 0 case HIL_KEY: case HIL_SHIFT: case HIL_CTRL: case HIL_CTRLSHIFT: itefilter(stat, c); return; #endif case HIL_STATUS: /* The status info. */ if (c & HIL_ERROR) { hilp->hl_cmddone = TRUE; if (c == HIL_RECONFIG) hilconfig(hilp); break; } if (c & HIL_COMMAND) { if (c & HIL_POLLDATA) /* End of data */ hilevent(hilp); else /* End of command */ hilp->hl_cmdending = TRUE; hilp->hl_actdev = 0; } else { if (c & HIL_POLLDATA) { /* Start of polled data */ if (hilp->hl_actdev != 0) hilevent(hilp); hilp->hl_actdev = (c & HIL_DEVMASK); hilp->hl_pollbp = hilp->hl_pollbuf; } else { /* Start of command */ if (hilp->hl_cmddev == (c & HIL_DEVMASK)) { hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_actdev = 0; } } } return; case HIL_DATA: if (hilp->hl_actdev != 0) /* Collecting poll data */ *hilp->hl_pollbp++ = c; else if (hilp->hl_cmddev != 0) /* Collecting cmd data */ if (hilp->hl_cmdending) { hilp->hl_cmddone = TRUE; hilp->hl_cmdending = FALSE; } else *hilp->hl_cmdbp++ = c; return; case 0: /* force full jump table */ default: return; } } #if (defined(DDB) || defined(DEBUG)) && !defined(PANICBUTTON) #define PANICBUTTON #endif /* * Optimized macro to compute: * eq->head == (eq->tail + 1) % eq->size * i.e. has tail caught up with head. We do this because 32 bit long * remaidering is expensive (a function call with our compiler). */ #define HQFULL(eq) (((eq)->head?(eq)->head:(eq)->size) == (eq)->tail+1) #define HQVALID(eq) \ ((eq)->size == HEVQSIZE && (eq)->tail >= 0 && (eq)->tail < HEVQSIZE) hilevent(hilp) struct hilloop *hilp; { register struct hilloopdev *dptr = &hilp->hl_device[hilp->hl_actdev]; register int len, mask, qnum; register u_char *cp, *pp; register HILQ *hq; struct timeval ourtime; hil_packet *proto; int s, len0; long tenths; #ifdef PANICBUTTON static int first; extern int panicbutton; cp = hilp->hl_pollbuf; if (panicbutton && (*cp & HIL_KBDDATA)) { if (*++cp == 0x4E) first = 1; else if (first && *cp == 0x46 && !panicstr) panic("are we having fun yet?"); else first = 0; } #endif #ifdef DEBUG if (hildebug & HDB_EVENTS) { printf("hilevent: dev %d pollbuf: ", hilp->hl_actdev); printhilpollbuf(hilp); printf("\n"); } #endif /* * Note that HIL_READIN effectively "shuts off" any queues * that may have been in use at the time of an HILIOCHPUX call. */ if (dptr->hd_flags & HIL_READIN) { hpuxhilevent(hilp, dptr); return; } /* * If this device isn't on any queue or there are no data * in the packet (can this happen?) do nothing. */ if (dptr->hd_qmask == 0 || (len0 = hilp->hl_pollbp - hilp->hl_pollbuf) <= 0) return; /* * Everybody gets the same time stamp */ s = splclock(); ourtime = time; splx(s); tenths = (ourtime.tv_sec * 100) + (ourtime.tv_usec / 10000); proto = NULL; mask = dptr->hd_qmask; for (qnum = 0; mask; qnum++) { if ((mask & hilqmask(qnum)) == 0) continue; mask &= ~hilqmask(qnum); hq = hilp->hl_queue[qnum].hq_eventqueue; /* * Ensure that queue fields that we rely on are valid * and that there is space in the queue. If either * test fails, we just skip this queue. */ if (!HQVALID(&hq->hil_evqueue) || HQFULL(&hq->hil_evqueue)) continue; /* * Copy data to queue. * If this is the first queue we construct the packet * with length, timestamp and poll buffer data. * For second and sucessive packets we just duplicate * the first packet. */ pp = (u_char *) &hq->hil_event[hq->hil_evqueue.tail]; if (proto == NULL) { proto = (hil_packet *)pp; cp = hilp->hl_pollbuf; len = len0; *pp++ = len + 6; *pp++ = hilp->hl_actdev; *(long *)pp = tenths; pp += sizeof(long); do *pp++ = *cp++; while (--len); } else *(hil_packet *)pp = *proto; if (++hq->hil_evqueue.tail == hq->hil_evqueue.size) hq->hil_evqueue.tail = 0; } /* * Wake up anyone selecting on this device or the loop itself */ selwakeup(&dptr->hd_selr); dptr = &hilp->hl_device[HILLOOPDEV]; selwakeup(&dptr->hd_selr); } #undef HQFULL hpuxhilevent(hilp, dptr) register struct hilloop *hilp; register struct hilloopdev *dptr; { register int len; struct timeval ourtime; long tstamp; int s; /* * Everybody gets the same time stamp */ s = splclock(); ourtime = time; splx(s); tstamp = (ourtime.tv_sec * 100) + (ourtime.tv_usec / 10000); /* * Each packet that goes into the buffer must be preceded by the * number of bytes in the packet, and the timestamp of the packet. * This adds 5 bytes to the packet size. Make sure there is enough * room in the buffer for it, and if not, toss the packet. */ len = hilp->hl_pollbp - hilp->hl_pollbuf; if (dptr->hd_queue.c_cc <= (HILMAXCLIST - (len+5))) { putc(len+5, &dptr->hd_queue); (void) b_to_q((u_char *)&tstamp, sizeof tstamp, &dptr->hd_queue); (void) b_to_q((u_char *)hilp->hl_pollbuf, len, &dptr->hd_queue); } /* * Wake up any one blocked on a read or select */ if (dptr->hd_flags & HIL_ASLEEP) { dptr->hd_flags &= ~HIL_ASLEEP; wakeup((caddr_t)dptr); } selwakeup(&dptr->hd_selr); } /* * Shared queue manipulation routines */ hilqalloc(hilp, qip) register struct hilloop *hilp; struct hilqinfo *qip; { struct proc *p = curproc; /* XXX */ #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilqalloc(%d): addr %x\n", p->p_pid, qip->addr); #endif return(EINVAL); } hilqfree(hilp, qnum) register struct hilloop *hilp; register int qnum; { struct proc *p = curproc; /* XXX */ #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilqfree(%d): qnum %d\n", p->p_pid, qnum); #endif return(EINVAL); } hilqmap(hilp, qnum, device) register struct hilloop *hilp; register int qnum, device; { struct proc *p = curproc; /* XXX */ register struct hilloopdev *dptr = &hilp->hl_device[device]; int s; #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilqmap(%d): qnum %d device %x\n", p->p_pid, qnum, device); #endif if (qnum >= NHILQ || hilp->hl_queue[qnum].hq_procp != p) return(EINVAL); if ((dptr->hd_flags & HIL_QUEUEIN) == 0) return(EINVAL); if (dptr->hd_qmask && p->p_ucred->cr_uid && p->p_ucred->cr_uid != dptr->hd_uid) return(EPERM); hilp->hl_queue[qnum].hq_devmask |= hildevmask(device); if (dptr->hd_qmask == 0) dptr->hd_uid = p->p_ucred->cr_uid; s = splhil(); dptr->hd_qmask |= hilqmask(qnum); splx(s); #ifdef DEBUG if (hildebug & HDB_MASK) printf("hilqmap(%d): devmask %x qmask %x\n", p->p_pid, hilp->hl_queue[qnum].hq_devmask, dptr->hd_qmask); #endif return(0); } hilqunmap(hilp, qnum, device) register struct hilloop *hilp; register int qnum, device; { struct proc *p = curproc; /* XXX */ int s; #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilqunmap(%d): qnum %d device %x\n", p->p_pid, qnum, device); #endif if (qnum >= NHILQ || hilp->hl_queue[qnum].hq_procp != p) return(EINVAL); hilp->hl_queue[qnum].hq_devmask &= ~hildevmask(device); s = splhil(); hilp->hl_device[device].hd_qmask &= ~hilqmask(qnum); splx(s); #ifdef DEBUG if (hildebug & HDB_MASK) printf("hilqunmap(%d): devmask %x qmask %x\n", p->p_pid, hilp->hl_queue[qnum].hq_devmask, hilp->hl_device[device].hd_qmask); #endif return(0); } /* * Cooked keyboard functions for ite driver. * There is only one "cooked" ITE keyboard (the first keyboard found) * per loop. There may be other keyboards, but they will always be "raw". */ kbdbell(unit) int unit; { struct hilloop *hilp = &hilloop[unit]; hilbeep(hilp, &default_bell); } kbdenable(unit) int unit; { struct hilloop *hilp = &hilloop[unit]; register struct hil_dev *hildevice = hilp->hl_addr; char db; /* Set the autorepeat rate register */ db = ar_format(KBD_ARR); send_hil_cmd(hildevice, HIL_SETARR, &db, 1, NULL); /* Set the autorepeat delay register */ db = ar_format(KBD_ARD); send_hil_cmd(hildevice, HIL_SETARD, &db, 1, NULL); /* Enable interrupts */ send_hil_cmd(hildevice, HIL_INTON, NULL, 0, NULL); } kbddisable(unit) int unit; { } /* * XXX: read keyboard directly and return code. * Used by console getchar routine. Could really screw up anybody * reading from the keyboard in the normal, interrupt driven fashion. */ kbdgetc(unit, statp) int unit, *statp; { struct hilloop *hilp = &hilloop[unit]; register struct hil_dev *hildevice = hilp->hl_addr; register int c, stat; int s; s = splhil(); while (((stat = READHILSTAT(hildevice)) & HIL_DATA_RDY) == 0) ; c = READHILDATA(hildevice); splx(s); *statp = stat; return(c); } /* * Recoginize and clear keyboard generated NMIs. * Returns 1 if it was ours, 0 otherwise. Note that we cannot use * send_hil_cmd() to issue the clear NMI command as that would actually * lower the priority to splimp() and it doesn't wait for the completion * of the command. Either of these conditions could result in the * interrupt reoccuring. Note that we issue the CNMT command twice. * This seems to be needed, once is not always enough!?! */ kbdnmi(unit) int unit; { #ifdef hp300 struct hilloop *hilp = &hilloop[0]; /* XXX how do we know on 300? */ #else struct hilloop *hilp = &hilloop[unit]; #endif #ifdef hp300 if ((*KBDNMISTAT & KBDNMI) == 0) return(0); #endif HILWAIT(hilp->hl_addr); WRITEHILCMD(hilp->hl_addr, HIL_CNMT); HILWAIT(hilp->hl_addr); WRITEHILCMD(hilp->hl_addr, HIL_CNMT); HILWAIT(hilp->hl_addr); return(1); } #define HILSECURITY 0x33 #define HILIDENTIFY 0x03 #define HILSCBIT 0x04 /* * Called at boot time to print out info about interesting devices */ hilinfo(unit) int unit; { register struct hilloop *hilp = &hilloop[unit]; register int id, len; register struct kbdmap *km; /* * Keyboard info. */ if (hilp->hl_kbddev) { printf("hil%d: ", hilp->hl_kbddev); for (km = kbd_map; km->kbd_code; km++) if (km->kbd_code == hilp->hl_kbdlang) { printf("%s ", km->kbd_desc); break; } printf("keyboard\n"); } /* * ID module. * Attempt to locate the first ID module and print out its * security code. Is this a good idea?? */ id = hiliddev(hilp); if (id) { hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_cmddev = id; send_hildev_cmd(hilp, id, HILSECURITY); len = hilp->hl_cmdbp - hilp->hl_cmdbuf; hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_cmddev = 0; printf("hil%d: security code", id); for (id = 0; id < len; id++) printf(" %x", hilp->hl_cmdbuf[id]); while (id++ < 16) printf(" 0"); printf("\n"); } } #define HILAR1 0x3E #define HILAR2 0x3F /* * Called after the loop has reconfigured. Here we need to: * - determine how many devices are on the loop * (some may have been added or removed) * - locate the ITE keyboard (if any) and ensure * that it is in the proper state (raw or cooked) * and is set to use the proper language mapping table * - ensure all other keyboards are raw * Note that our device state is now potentially invalid as * devices may no longer be where they were. What we should * do here is either track where the devices went and move * state around accordingly or, more simply, just mark all * devices as HIL_DERROR and don't allow any further use until * they are closed. This is a little too brutal for my tastes, * we prefer to just assume people won't move things around. */ hilconfig(hilp) register struct hilloop *hilp; { u_char db; int s; s = splhil(); #ifdef DEBUG if (hildebug & HDB_CONFIG) { printf("hilconfig: reconfigured: "); send_hil_cmd(hilp->hl_addr, HIL_READLPSTAT, NULL, 0, &db); printf("LPSTAT %x, ", db); send_hil_cmd(hilp->hl_addr, HIL_READLPCTRL, NULL, 0, &db); printf("LPCTRL %x, ", db); send_hil_cmd(hilp->hl_addr, HIL_READKBDSADR, NULL, 0, &db); printf("KBDSADR %x\n", db); hilreport(hilp); } #endif /* * Determine how many devices are on the loop. * Mark those as alive and real, all others as dead. */ db = 0; send_hil_cmd(hilp->hl_addr, HIL_READLPSTAT, NULL, 0, &db); hilp->hl_maxdev = db & LPS_DEVMASK; #ifdef DEBUG if (hildebug & HDB_CONFIG) printf("hilconfig: %d devices found\n", hilp->hl_maxdev); #endif for (db = 1; db < NHILD; db++) { if (db <= hilp->hl_maxdev) hilp->hl_device[db].hd_flags |= HIL_ALIVE; else hilp->hl_device[db].hd_flags &= ~HIL_ALIVE; hilp->hl_device[db].hd_flags &= ~HIL_PSEUDO; } #ifdef DEBUG if (hildebug & (HDB_CONFIG|HDB_KEYBOARD)) printf("hilconfig: max device %d\n", hilp->hl_maxdev); #endif if (hilp->hl_maxdev == 0) { hilp->hl_kbddev = 0; splx(s); return; } /* * Find out where the keyboards are and record the ITE keyboard * (first one found). If no keyboards found, we are all done. */ db = 0; send_hil_cmd(hilp->hl_addr, HIL_READKBDSADR, NULL, 0, &db); #ifdef DEBUG if (hildebug & HDB_KEYBOARD) printf("hilconfig: keyboard: KBDSADR %x, old %d, new %d\n", db, hilp->hl_kbddev, ffs((int)db)); #endif hilp->hl_kbddev = ffs((int)db); if (hilp->hl_kbddev == 0) { splx(s); return; } /* * Determine if the keyboard should be cooked or raw and configure it. */ db = (hilp->hl_kbdflags & KBD_RAW) ? 0 : 1 << (hilp->hl_kbddev - 1); send_hil_cmd(hilp->hl_addr, HIL_WRITEKBDSADR, &db, 1, NULL); /* * Re-enable autorepeat in raw mode, cooked mode AR is not affected. */ if (hilp->hl_kbdflags & (KBD_AR1|KBD_AR2)) { db = (hilp->hl_kbdflags & KBD_AR1) ? HILAR1 : HILAR2; hilp->hl_cmddev = hilp->hl_kbddev; send_hildev_cmd(hilp, hilp->hl_kbddev, db); hilp->hl_cmddev = 0; } /* * Determine the keyboard language configuration, but don't * override a user-specified setting. */ db = 0; send_hil_cmd(hilp->hl_addr, HIL_READKBDLANG, NULL, 0, &db); #ifdef DEBUG if (hildebug & HDB_KEYBOARD) printf("hilconfig: language: old %x new %x\n", hilp->hl_kbdlang, db); #endif if (hilp->hl_kbdlang != KBD_SPECIAL) { struct kbdmap *km; for (km = kbd_map; km->kbd_code; km++) if (km->kbd_code == db) { hilp->hl_kbdlang = db; /* XXX */ kbd_keymap = km->kbd_keymap; kbd_shiftmap = km->kbd_shiftmap; kbd_ctrlmap = km->kbd_ctrlmap; kbd_ctrlshiftmap = km->kbd_ctrlshiftmap; kbd_stringmap = km->kbd_stringmap; } } splx(s); } hilreset(hilp) struct hilloop *hilp; { register struct hil_dev *hildevice = hilp->hl_addr; u_char db; #ifdef DEBUG if (hildebug & HDB_FOLLOW) printf("hilreset(%x)\n", hilp); #endif /* * Initialize the loop: reconfigure, don't report errors, * cook keyboards, and enable autopolling. */ db = LPC_RECONF | LPC_KBDCOOK | LPC_NOERROR | LPC_AUTOPOLL; send_hil_cmd(hildevice, HIL_WRITELPCTRL, &db, 1, NULL); /* * Delay one second for reconfiguration and then read the the * data register to clear the interrupt (if the loop reconfigured). */ DELAY(1000000); if (READHILSTAT(hildevice) & HIL_DATA_RDY) db = READHILDATA(hildevice); /* * The HIL loop may have reconfigured. If so we proceed on, * if not we loop until a successful reconfiguration is reported * back to us. The HIL loop will continue to attempt forever. * Probably not very smart. */ do { send_hil_cmd(hildevice, HIL_READLPSTAT, NULL, 0, &db); } while ((db & (LPS_CONFFAIL|LPS_CONFGOOD)) == 0); /* * At this point, the loop should have reconfigured. * The reconfiguration interrupt has already called hilconfig() * so the keyboard has been determined. */ send_hil_cmd(hildevice, HIL_INTON, NULL, 0, NULL); } hilbeep(hilp, bp) struct hilloop *hilp; register struct _hilbell *bp; { u_char buf[2]; buf[0] = ~((bp->duration - 10) / 10); buf[1] = bp->frequency; send_hil_cmd(hilp->hl_addr, HIL_SETTONE, buf, 2, NULL); } /* * Locate and return the address of the first ID module, 0 if none present. */ hiliddev(hilp) register struct hilloop *hilp; { register int i, len; #ifdef DEBUG if (hildebug & HDB_IDMODULE) printf("hiliddev(%x): max %d, looking for idmodule...", hilp, hilp->hl_maxdev); #endif for (i = 1; i <= hilp->hl_maxdev; i++) { hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_cmddev = i; send_hildev_cmd(hilp, i, HILIDENTIFY); /* * XXX: the final condition checks to ensure that the * device ID byte is in the range of the ID module (0x30-0x3F) */ len = hilp->hl_cmdbp - hilp->hl_cmdbuf; if (len > 1 && (hilp->hl_cmdbuf[1] & HILSCBIT) && (hilp->hl_cmdbuf[0] & 0xF0) == 0x30) { hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_cmddev = i; send_hildev_cmd(hilp, i, HILSECURITY); break; } } hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_cmddev = 0; #ifdef DEBUG if (hildebug & HDB_IDMODULE) if (i <= hilp->hl_maxdev) printf("found at %d\n", i); else printf("not found\n"); #endif return(i <= hilp->hl_maxdev ? i : 0); } #ifdef COMPAT_HPUX /* * XXX map devno as expected by HP-UX */ hildevno(dev) dev_t dev; { int newdev; newdev = 24 << 24; #ifdef HILCOMPAT /* * XXX compat check * Don't convert old style specfiles already in correct format */ if (minor(dev) && (dev & 0xF) == 0) newdev |= minor(dev); else #endif newdev |= (HILLOOP(dev) << 8) | (HILUNIT(dev) << 4); return(newdev); } #endif /* * Low level routines which actually talk to the 8042 chip. */ /* * Send a command to the 8042 with zero or more bytes of data. * If rdata is non-null, wait for and return a byte of data. * We run at splimp() to make the transaction as atomic as * possible without blocking the clock (is this necessary?) */ send_hil_cmd(hildevice, cmd, data, dlen, rdata) register struct hil_dev *hildevice; u_char cmd, *data, dlen; u_char *rdata; { u_char status; int s = splimp(); HILWAIT(hildevice); WRITEHILCMD(hildevice, cmd); while (dlen--) { HILWAIT(hildevice); WRITEHILDATA(hildevice, *data++); } if (rdata) { do { HILDATAWAIT(hildevice); status = READHILSTAT(hildevice); *rdata = READHILDATA(hildevice); } while (((status >> HIL_SSHIFT) & HIL_SMASK) != HIL_68K); } splx(s); } /* * Send a command to a device on the loop. * Since only one command can be active on the loop at any time, * we must ensure that we are not interrupted during this process. * Hence we mask interrupts to prevent potential access from most * interrupt routines and turn off auto-polling to disable the * internally generated poll commands. * * splhigh is extremely conservative but insures atomic operation, * splimp (clock only interrupts) seems to be good enough in practice. */ send_hildev_cmd(hilp, device, cmd) register struct hilloop *hilp; char device, cmd; { register struct hil_dev *hildevice = hilp->hl_addr; u_char status, c; int s = splimp(); polloff(hildevice); /* * Transfer the command and device info to the chip */ HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_STARTCMD); HILWAIT(hildevice); WRITEHILDATA(hildevice, 8 + device); HILWAIT(hildevice); WRITEHILDATA(hildevice, cmd); HILWAIT(hildevice); WRITEHILDATA(hildevice, HIL_TIMEOUT); /* * Trigger the command and wait for completion */ HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_TRIGGER); hilp->hl_cmddone = FALSE; do { HILDATAWAIT(hildevice); status = READHILSTAT(hildevice); c = READHILDATA(hildevice); hil_process_int(hilp, status, c); } while (!hilp->hl_cmddone); pollon(hildevice); splx(s); } /* * Turn auto-polling off and on. * Also disables and enable auto-repeat. Why? */ polloff(hildevice) register struct hil_dev *hildevice; { register char db; /* * Turn off auto repeat */ HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_SETARR); HILWAIT(hildevice); WRITEHILDATA(hildevice, 0); /* * Turn off auto-polling */ HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_READLPCTRL); HILDATAWAIT(hildevice); db = READHILDATA(hildevice); db &= ~LPC_AUTOPOLL; HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_WRITELPCTRL); HILWAIT(hildevice); WRITEHILDATA(hildevice, db); /* * Must wait til polling is really stopped */ do { HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_READBUSY); HILDATAWAIT(hildevice); db = READHILDATA(hildevice); } while (db & BSY_LOOPBUSY); } pollon(hildevice) register struct hil_dev *hildevice; { register char db; /* * Turn on auto polling */ HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_READLPCTRL); HILDATAWAIT(hildevice); db = READHILDATA(hildevice); db |= LPC_AUTOPOLL; HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_WRITELPCTRL); HILWAIT(hildevice); WRITEHILDATA(hildevice, db); /* * Turn on auto repeat */ HILWAIT(hildevice); WRITEHILCMD(hildevice, HIL_SETARR); HILWAIT(hildevice); WRITEHILDATA(hildevice, ar_format(KBD_ARR)); } #ifdef DEBUG printhilpollbuf(hilp) register struct hilloop *hilp; { register u_char *cp; register int i, len; cp = hilp->hl_pollbuf; len = hilp->hl_pollbp - cp; for (i = 0; i < len; i++) printf("%x ", hilp->hl_pollbuf[i]); printf("\n"); } printhilcmdbuf(hilp) register struct hilloop *hilp; { register u_char *cp; register int i, len; cp = hilp->hl_cmdbuf; len = hilp->hl_cmdbp - cp; for (i = 0; i < len; i++) printf("%x ", hilp->hl_cmdbuf[i]); printf("\n"); } hilreport(hilp) register struct hilloop *hilp; { register int i, len; int s = splhil(); for (i = 1; i <= hilp->hl_maxdev; i++) { hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_cmddev = i; send_hildev_cmd(hilp, i, HILIDENTIFY); printf("hil%d: id: ", i); printhilcmdbuf(hilp); len = hilp->hl_cmdbp - hilp->hl_cmdbuf; if (len > 1 && (hilp->hl_cmdbuf[1] & HILSCBIT)) { hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_cmddev = i; send_hildev_cmd(hilp, i, HILSECURITY); printf("hil%d: sc: ", i); printhilcmdbuf(hilp); } } hilp->hl_cmdbp = hilp->hl_cmdbuf; hilp->hl_cmddev = 0; splx(s); } #endif