![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hil.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev|
Return to hil.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
9: *
10: * Redistribution is only permitted until one year after the first shipment
11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
12: * binary forms are permitted provided that: (1) source distributions retain
13: * this entire copyright notice and comment, and (2) distributions including
14: * binaries display the following acknowledgement: This product includes
15: * software developed by the University of California, Berkeley and its
16: * contributors'' in the documentation or other materials provided with the
17: * distribution and in all advertising materials mentioning features or use
18: * of this software. Neither the name of the University nor the names of
19: * its contributors may be used to endorse or promote products derived from
20: * this software without specific prior written permission.
21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24: *
25: * from: Utah $Hdr: hil.c 1.33 89/12/22$
26: *
27: * @(#)hil.c 7.4 (Berkeley) 6/22/90
28: */
29:
30: #include "param.h"
31: #include "conf.h"
32: #include "user.h"
33: #include "proc.h"
34: #include "ioctl.h"
35: #include "file.h"
36: #include "tty.h"
37: #include "systm.h"
38: #include "uio.h"
39: #include "kernel.h"
40: #include "mapmem.h"
41:
42: #include "hilreg.h"
43: #include "hilioctl.h"
44: #include "hilvar.h"
45: #include "kbdmap.h"
46:
47: #include "machine/cpu.h"
48:
49: struct hilloop hil0;
50: struct _hilbell default_bell = { BELLDUR, BELLFREQ };
51:
52: #ifdef MAPMEM
53: int hilqfork(), hilqvfork(), hilqexit();
54: struct mapmemops hilqops = { hilqfork, hilqvfork, hilqexit, hilqexit };
55: #endif
56:
57: #ifdef DEBUG
58: int hildebug = 0;
59: #define HDB_FOLLOW 0x01
60: #define HDB_MMAP 0x02
61: #define HDB_MASK 0x04
62: #define HDB_CONFIG 0x08
63: #define HDB_KEYBOARD 0x10
64: #define HDB_IDMODULE 0x20
65: #define HDB_EVENTS 0x80
66: #endif
67:
68: /* symbolic sleep message strings */
69: char hilin[] = "hilin";
70:
71: hilinit()
72: {
73: register struct hilloop *hilp = &hil0; /* XXX */
74: register int i;
75:
76: /*
77: * Initialize loop information
78: */
79: hilp->hl_addr = HILADDR;
80: hilp->hl_cmdending = FALSE;
81: hilp->hl_actdev = hilp->hl_cmddev = 0;
82: hilp->hl_cmddone = FALSE;
83: hilp->hl_cmdbp = hilp->hl_cmdbuf;
84: hilp->hl_pollbp = hilp->hl_pollbuf;
85: hilp->hl_kbddev = 0;
86: hilp->hl_kbdlang = KBD_DEFAULT;
87: hilp->hl_kbdflags = 0;
88: /*
89: * Clear all queues and device associations with queues
90: */
91: for (i = 0; i < NHILQ; i++) {
92: hilp->hl_queue[i].hq_eventqueue = NULL;
93: hilp->hl_queue[i].hq_procp = NULL;
94: hilp->hl_queue[i].hq_devmask = 0;
95: }
96: for (i = 0; i < NHILD; i++)
97: hilp->hl_device[i].hd_qmask = 0;
98: hilp->hl_device[HILLOOPDEV].hd_flags = (HIL_ALIVE|HIL_PSEUDO);
99: /*
100: * Reset the loop hardware, and collect keyboard/id info
101: */
102: hilreset(hilp);
103: hilinfo(hilp);
104: kbdenable();
105: }
106:
107: hilopen(dev, flags)
108: dev_t dev;
109: {
110: struct proc *p = u.u_procp; /* XXX */
111: register struct hilloop *hilp = &hil0; /* XXX */
112: register struct hilloopdev *dptr;
113: u_char device = HILUNIT(dev);
114:
115: #ifdef DEBUG
116: if (hildebug & HDB_FOLLOW)
117: printf("hilopen(%d): device %x\n", p->p_pid, device);
118: #endif
119:
120: if ((hilp->hl_device[HILLOOPDEV].hd_flags & HIL_ALIVE) == 0)
121: return(ENXIO);
122:
123: dptr = &hilp->hl_device[device];
124: if ((dptr->hd_flags & HIL_ALIVE) == 0)
125: return(ENODEV);
126:
127: /*
128: * Pseudo-devices cannot be read, nothing more to do.
129: */
130: if (dptr->hd_flags & HIL_PSEUDO)
131: return(0);
132:
133: /*
134: * Open semantics:
135: * 1. Open devices have only one of HIL_READIN/HIL_QUEUEIN.
136: * 2. HPUX processes always get read syscall interface and
137: * must have exclusive use of the device.
138: * 3. BSD processes default to shared queue interface.
139: * Multiple processes can open the device.
140: */
141: if (p->p_flag & SHPUX) {
142: if (dptr->hd_flags & (HIL_READIN|HIL_QUEUEIN))
143: return(EBUSY);
144: dptr->hd_flags |= HIL_READIN;
145: } else {
146: if (dptr->hd_flags & HIL_READIN)
147: return(EBUSY);
148: dptr->hd_flags |= HIL_QUEUEIN;
149: }
150: if (flags & FNDELAY)
151: dptr->hd_flags |= HIL_NOBLOCK;
152: /*
153: * It is safe to flush the read buffer as we are guarenteed
154: * that no one else is using it.
155: */
156: ndflush(&dptr->hd_queue, dptr->hd_queue.c_cc);
157:
158: send_hil_cmd(hilp->hl_addr, HIL_INTON, NULL, 0, NULL);
159: /*
160: * Opened the keyboard, put in raw mode.
161: */
162: (void) splhil();
163: if (device == hilp->hl_kbddev) {
164: u_char mask = 0;
165: send_hil_cmd(hilp->hl_addr, HIL_WRITEKBDSADR, &mask, 1, NULL);
166: hilp->hl_kbdflags |= KBD_RAW;
167: #ifdef DEBUG
168: if (hildebug & HDB_KEYBOARD)
169: printf("hilopen: keyboard %d raw\n", hilp->hl_kbddev);
170: #endif
171: }
172: (void) spl0();
173: return (0);
174: }
175:
176: /* ARGSUSED */
177: hilclose(dev, flags)
178: dev_t dev;
179: {
180: struct proc *p = u.u_procp; /* XXX */
181: register struct hilloop *hilp = &hil0; /* XXX */
182: register struct hilloopdev *dptr;
183: register int i;
184: u_char device = HILUNIT(dev);
185: char mask, lpctrl;
186:
187: #ifdef DEBUG
188: if (hildebug & HDB_FOLLOW)
189: printf("hilclose(%d): device %x\n", p->p_pid, device);
190: #endif
191:
192: dptr = &hilp->hl_device[device];
193: if (device && (dptr->hd_flags & HIL_PSEUDO))
194: return (0);
195:
196: if ((p->p_flag & SHPUX) == 0) {
197: /*
198: * If this is the loop device,
199: * free up all queues belonging to this process.
200: */
201: if (device == 0) {
202: for (i = 0; i < NHILQ; i++)
203: if (hilp->hl_queue[i].hq_procp == p)
204: (void) hilqfree(i);
205: } else {
206: mask = ~hildevmask(device);
207: (void) splhil();
208: for (i = 0; i < NHILQ; i++)
209: if (hilp->hl_queue[i].hq_procp == p) {
210: dptr->hd_qmask &= ~hilqmask(i);
211: hilp->hl_queue[i].hq_devmask &= mask;
212: }
213: (void) spl0();
214: }
215: }
216: /*
217: * Always flush the read buffer
218: */
219: dptr->hd_flags &= ~(HIL_QUEUEIN|HIL_READIN|HIL_NOBLOCK);
220: ndflush(&dptr->hd_queue, dptr->hd_queue.c_cc);
221: /*
222: * Set keyboard back to cooked mode when closed.
223: */
224: (void) splhil();
225: if (device && device == hilp->hl_kbddev) {
226: mask = 1 << (hilp->hl_kbddev - 1);
227: send_hil_cmd(hilp->hl_addr, HIL_WRITEKBDSADR, &mask, 1, NULL);
228: hilp->hl_kbdflags &= ~(KBD_RAW|KBD_AR1|KBD_AR2);
229: /*
230: * XXX: We have had trouble with keyboards remaining raw
231: * after close due to the LPC_KBDCOOK bit getting cleared
232: * somewhere along the line. Hence we check and reset
233: * LPCTRL if necessary.
234: */
235: send_hil_cmd(hilp->hl_addr, HIL_READLPCTRL, NULL, 0, &lpctrl);
236: if ((lpctrl & LPC_KBDCOOK) == 0) {
237: printf("hilclose: bad LPCTRL %x, reset to %x\n",
238: lpctrl, lpctrl|LPC_KBDCOOK);
239: lpctrl |= LPC_KBDCOOK;
240: send_hil_cmd(hilp->hl_addr, HIL_WRITELPCTRL,
241: &lpctrl, 1, NULL);
242: }
243: #ifdef DEBUG
244: if (hildebug & HDB_KEYBOARD)
245: printf("hilclose: keyboard %d cooked\n",
246: hilp->hl_kbddev);
247: #endif
248: kbdenable();
249: }
250: (void) spl0();
251: return (0);
252: }
253:
254: /*
255: * Read interface to HIL device.
256: */
257: hilread(dev, uio)
258: dev_t dev;
259: register struct uio *uio;
260: {
261: struct hilloop *hilp = &hil0; /* XXX */
262: register struct hilloopdev *dptr;
263: register int cc;
264: u_char device = HILUNIT(dev);
265: char buf[HILBUFSIZE];
266: int error;
267:
268: #if 0
269: /*
270: * XXX: Don't do this since HP-UX doesn't.
271: *
272: * Check device number.
273: * This check is necessary since loop can reconfigure.
274: */
275: if (device > hilp->hl_maxdev)
276: return(ENODEV);
277: #endif
278:
279: dptr = &hilp->hl_device[device];
280: if ((dptr->hd_flags & HIL_READIN) == 0)
281: return(ENODEV);
282:
283: (void) splhil();
284: while (dptr->hd_queue.c_cc == 0) {
285: if (dptr->hd_flags & HIL_NOBLOCK) {
286: spl0();
287: return(EWOULDBLOCK);
288: }
289: dptr->hd_flags |= HIL_ASLEEP;
290: if (error = tsleep((caddr_t)dptr, TTIPRI | PCATCH, hilin, 0)) {
291: (void) spl0();
292: return (error);
293: }
294: }
295: (void) spl0();
296:
297: error = 0;
298: while (uio->uio_resid > 0 && error == 0) {
299: cc = hilq_to_b(&dptr->hd_queue, buf,
300: MIN(uio->uio_resid, HILBUFSIZE));
301: if (cc <= 0)
302: break;
303: error = uiomove(buf, cc, uio);
304: }
305: return(error);
306: }
307:
308: hilioctl(dev, cmd, data, flag)
309: dev_t dev;
310: caddr_t data;
311: {
312: struct proc *p = u.u_procp; /* XXX */
313: register struct hilloop *hilp = &hil0; /* XXX */
314: char device = HILUNIT(dev);
315: struct hilloopdev *dptr;
316: register int i;
317: u_char hold;
318: int error;
319:
320: #ifdef DEBUG
321: if (hildebug & HDB_FOLLOW)
322: printf("hilioctl(%d): dev %x cmd %x\n",
323: p->p_pid, device, cmd);
324: #endif
325:
326: dptr = &hilp->hl_device[device];
327: if ((dptr->hd_flags & HIL_ALIVE) == 0)
328: return (ENODEV);
329:
330: /*
331: * Don't allow hardware ioctls on virtual devices.
332: * Note that though these are the BSD names, they have the same
333: * values as the HP-UX equivalents so we catch them as well.
334: */
335: if (dptr->hd_flags & HIL_PSEUDO) {
336: switch (cmd) {
337: case HILIOCSC:
338: case HILIOCID:
339: case HILIOCRN:
340: case HILIOCRS:
341: case HILIOCED:
342: return(ENODEV);
343:
344: /*
345: * XXX: should also return ENODEV but HP-UX compat
346: * breaks if we do. They work ok right now because
347: * we only recognize one keyboard on the loop. This
348: * will have to change if we remove that restriction.
349: */
350: case HILIOCAROFF:
351: case HILIOCAR1:
352: case HILIOCAR2:
353: break;
354:
355: default:
356: break;
357: }
358: }
359:
360: #ifdef HPUXCOMPAT
361: if (p->p_flag & SHPUX)
362: return(hpuxhilioctl(dev, cmd, data, flag));
363: #endif
364:
365: hilp->hl_cmdbp = hilp->hl_cmdbuf;
366: bzero((caddr_t)hilp->hl_cmdbuf, HILBUFSIZE);
367: hilp->hl_cmddev = device;
368: error = 0;
369: switch (cmd) {
370:
371: case HILIOCSBP:
372: /* Send four data bytes to the tone gererator. */
373: send_hil_cmd(hilp->hl_addr, HIL_STARTCMD, data, 4, NULL);
374: /* Send the trigger beeper command to the 8042. */
375: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, NULL);
376: break;
377:
378: case HILIOCRRT:
379: /* Transfer the real time to the 8042 data buffer */
380: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, NULL);
381: /* Read each byte of the real time */
382: for (i = 0; i < 5; i++) {
383: send_hil_cmd(hilp->hl_addr, HIL_READTIME + i, NULL,
384: 0, &hold);
385: data[4-i] = hold;
386: }
387: break;
388:
389: case HILIOCRT:
390: for (i = 0; i < 4; i++) {
391: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF) + i,
392: NULL, 0, &hold);
393: data[i] = hold;
394: }
395: break;
396:
397: case HILIOCID:
398: case HILIOCSC:
399: case HILIOCRN:
400: case HILIOCRS:
401: case HILIOCED:
402: send_hildev_cmd(hilp, device, (cmd & 0xFF));
403: bcopy(hilp->hl_cmdbuf, data, hilp->hl_cmdbp-hilp->hl_cmdbuf);
404: break;
405:
406: case HILIOCAROFF:
407: case HILIOCAR1:
408: case HILIOCAR2:
409: if (hilp->hl_kbddev) {
410: hilp->hl_cmddev = hilp->hl_kbddev;
411: send_hildev_cmd(hilp, hilp->hl_kbddev, (cmd & 0xFF));
412: hilp->hl_kbdflags &= ~(KBD_AR1|KBD_AR2);
413: if (cmd == HILIOCAR1)
414: hilp->hl_kbdflags |= KBD_AR1;
415: else if (cmd == HILIOCAR2)
416: hilp->hl_kbdflags |= KBD_AR2;
417: }
418: break;
419:
420: case HILIOCBEEP:
421: hilbeep(hilp, (struct _hilbell *)data);
422: break;
423:
424: case FIONBIO:
425: dptr = &hilp->hl_device[device];
426: if (*(int *)data)
427: dptr->hd_flags |= HIL_NOBLOCK;
428: else
429: dptr->hd_flags &= ~HIL_NOBLOCK;
430: break;
431:
432: /*
433: * FIOASYNC must be present for FIONBIO above to work!
434: * (See fcntl in kern_descrip.c).
435: */
436: case FIOASYNC:
437: break;
438:
439: case HILIOCALLOCQ:
440: error = hilqalloc((struct hilqinfo *)data);
441: break;
442:
443: case HILIOCFREEQ:
444: error = hilqfree(((struct hilqinfo *)data)->qid);
445: break;
446:
447: case HILIOCMAPQ:
448: error = hilqmap(*(int *)data, device);
449: break;
450:
451: case HILIOCUNMAPQ:
452: error = hilqunmap(*(int *)data, device);
453: break;
454:
455: case HILIOCHPUX:
456: dptr = &hilp->hl_device[device];
457: dptr->hd_flags |= HIL_READIN;
458: dptr->hd_flags &= ~HIL_QUEUEIN;
459: break;
460:
461: case HILIOCRESET:
462: hilreset(hilp);
463: break;
464:
465: #ifdef DEBUG
466: case HILIOCTEST:
467: hildebug = *(int *) data;
468: break;
469: #endif
470:
471: default:
472: error = EINVAL;
473: break;
474:
475: }
476: hilp->hl_cmddev = 0;
477: return(error);
478: }
479:
480: #ifdef HPUXCOMPAT
481: /* ARGSUSED */
482: hpuxhilioctl(dev, cmd, data, flag)
483: dev_t dev;
484: caddr_t data;
485: {
486: register struct hilloop *hilp = &hil0; /* XXX */
487: char device = HILUNIT(dev);
488: struct hilloopdev *dptr;
489: register int i;
490: u_char hold;
491:
492: hilp->hl_cmdbp = hilp->hl_cmdbuf;
493: bzero((caddr_t)hilp->hl_cmdbuf, HILBUFSIZE);
494: hilp->hl_cmddev = device;
495: switch (cmd) {
496:
497: case HILSC:
498: case HILID:
499: case HILRN:
500: case HILRS:
501: case HILED:
502: case HILP1:
503: case HILP2:
504: case HILP3:
505: case HILP4:
506: case HILP5:
507: case HILP6:
508: case HILP7:
509: case HILP:
510: case HILA1:
511: case HILA2:
512: case HILA3:
513: case HILA4:
514: case HILA5:
515: case HILA6:
516: case HILA7:
517: case HILA:
518: send_hildev_cmd(hilp, device, (cmd & 0xFF));
519: bcopy(hilp->hl_cmdbuf, data, hilp->hl_cmdbp-hilp->hl_cmdbuf);
520: break;
521:
522: case HILDKR:
523: case HILER1:
524: case HILER2:
525: if (hilp->hl_kbddev) {
526: hilp->hl_cmddev = hilp->hl_kbddev;
527: send_hildev_cmd(hilp, hilp->hl_kbddev, (cmd & 0xFF));
528: hilp->hl_kbdflags &= ~(KBD_AR1|KBD_AR2);
529: if (cmd == HILIOCAR1)
530: hilp->hl_kbdflags |= KBD_AR1;
531: else if (cmd == HILIOCAR2)
532: hilp->hl_kbdflags |= KBD_AR2;
533: }
534: break;
535:
536: case EFTSBP:
537: /* Send four data bytes to the tone gererator. */
538: send_hil_cmd(hilp->hl_addr, HIL_STARTCMD, data, 4, NULL);
539: /* Send the trigger beeper command to the 8042. */
540: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, NULL);
541: break;
542:
543: case EFTRRT:
544: /* Transfer the real time to the 8042 data buffer */
545: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, NULL);
546: /* Read each byte of the real time */
547: for (i = 0; i < 5; i++) {
548: send_hil_cmd(hilp->hl_addr, HIL_READTIME + i, NULL,
549: 0, &hold);
550: data[4-i] = hold;
551: }
552: break;
553:
554: case EFTRT:
555: for (i = 0; i < 4; i++) {
556: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF) + i,
557: NULL, 0, &hold);
558: data[i] = hold;
559: }
560: break;
561:
562: case EFTRLC:
563: case EFTRCC:
564: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), NULL, 0, &hold);
565: *data = hold;
566: break;
567:
568: case EFTSRPG:
569: case EFTSRD:
570: case EFTSRR:
571: send_hil_cmd(hilp->hl_addr, (cmd & 0xFF), data, 1, NULL);
572: break;
573:
574: case EFTSBI:
575: hilbeep(hilp, (struct _hilbell *)data);
576: break;
577:
578: case FIONBIO:
579: dptr = &hilp->hl_device[device];
580: if (*(int *)data)
581: dptr->hd_flags |= HIL_NOBLOCK;
582: else
583: dptr->hd_flags &= ~HIL_NOBLOCK;
584: break;
585:
586: case FIOASYNC:
587: break;
588:
589: default:
590: hilp->hl_cmddev = 0;
591: return(EINVAL);
592: }
593: hilp->hl_cmddev = 0;
594: return(0);
595: }
596: #endif
597:
598: /*
599: * XXX: the mmap inteface for HIL devices should be rethought.
600: * We used it only briefly in conjuntion with shared queues
601: * (instead of HILIOCMAPQ ioctl). Perhaps mmap()ing a device
602: * should give a single queue per process.
603: */
604: /* ARGSUSED */
605: hilmap(dev, off, prot)
606: dev_t dev;
607: register int off;
608: {
609: #ifdef MMAP
610: struct proc *p = u.u_procp; /* XXX */
611: register struct hilloop *hilp = &hil0; /* XXX */
612: register struct hiliqueue *qp;
613: register int qnum;
614:
615: /*
616: * Only allow mmap() on loop device
617: */
618: if (HILUNIT(dev) != 0 || off >= NHILQ*sizeof(HILQ))
619: return(-1);
620: /*
621: * Determine which queue we want based on the offset.
622: * Queue must belong to calling process.
623: */
624: qp = &hilp->hl_queue[off / sizeof(HILQ)];
625: if (qp->hq_procp != p)
626: return(-1);
627:
628: off %= sizeof(HILQ);
629: return(kvtop((u_int)qp->hq_eventqueue + off) >> PGSHIFT);
630: #endif
631: }
632:
633: /*ARGSUSED*/
634: hilselect(dev, rw)
635: dev_t dev;
636: {
637: struct proc *p = u.u_procp; /* XXX */
638: register struct hilloop *hilp = &hil0; /* XXX */
639: register struct hilloopdev *dptr;
640: register struct hiliqueue *qp;
641: register int mask;
642: int s, device;
643:
644: if (rw == FWRITE)
645: return (1);
646: device = HILUNIT(dev);
647:
648: /*
649: * Read interface.
650: * Return 1 if there is something in the queue, 0 ow.
651: */
652: dptr = &hilp->hl_device[device];
653: if (dptr->hd_flags & HIL_READIN) {
654: s = splhil();
655: if (dptr->hd_queue.c_cc) {
656: splx(s);
657: return (1);
658: }
659: if (dptr->hd_selr &&
660: dptr->hd_selr->p_wchan == (caddr_t)&selwait)
661: dptr->hd_flags |= HIL_SELCOLL;
662: else
663: dptr->hd_selr = p;
664: splx(s);
665: return (0);
666: }
667:
668: /*
669: * Make sure device is alive and real (or the loop device).
670: * Note that we do not do this for the read interface.
671: * This is primarily to be consistant with HP-UX.
672: */
673: if (device && (dptr->hd_flags & (HIL_ALIVE|HIL_PSEUDO)) != HIL_ALIVE)
674: return (1);
675:
676: /*
677: * Select on loop device is special.
678: * Check to see if there are any data for any loop device
679: * provided it is associated with a queue belonging to this user.
680: */
681: if (device == 0)
682: mask = -1;
683: else
684: mask = hildevmask(device);
685: /*
686: * Must check everybody with interrupts blocked to prevent races.
687: */
688: s = splhil();
689: for (qp = hilp->hl_queue; qp < &hilp->hl_queue[NHILQ]; qp++)
690: if (qp->hq_procp == p && (mask & qp->hq_devmask) &&
691: qp->hq_eventqueue->hil_evqueue.head !=
692: qp->hq_eventqueue->hil_evqueue.tail) {
693: splx(s);
694: return (1);
695: }
696:
697: if (dptr->hd_selr && dptr->hd_selr->p_wchan == (caddr_t)&selwait)
698: dptr->hd_flags |= HIL_SELCOLL;
699: else
700: dptr->hd_selr = p;
701: splx(s);
702: return (0);
703: }
704:
705: hilint()
706: {
707: struct hilloop *hilp = &hil0; /* XXX */
708: register struct hil_dev *hildevice = hilp->hl_addr;
709: u_char c, stat;
710:
711: stat = hildevice->hil_stat;
712: c = hildevice->hil_data; /* clears interrupt */
713: hil_process_int(stat, c);
714: }
715:
716: #include "ite.h"
717:
718: hil_process_int(stat, c)
719: register u_char stat, c;
720: {
721: register struct hilloop *hilp;
722:
723: #ifdef DEBUG
724: if (hildebug & HDB_EVENTS)
725: printf("hilint: %x %x\n", stat, c);
726: #endif
727:
728: /* the shift enables the compiler to generate a jump table */
729: switch ((stat>>HIL_SSHIFT) & HIL_SMASK) {
730:
731: #if NITE > 0
732: case HIL_KEY:
733: case HIL_SHIFT:
734: case HIL_CTRL:
735: case HIL_CTRLSHIFT:
736: itefilter(stat, c);
737: return;
738: #endif
739:
740: case HIL_STATUS: /* The status info. */
741: hilp = &hil0; /* XXX */
742: if (c & HIL_ERROR) {
743: hilp->hl_cmddone = TRUE;
744: if (c == HIL_RECONFIG)
745: hilconfig(hilp);
746: break;
747: }
748: if (c & HIL_COMMAND) {
749: if (c & HIL_POLLDATA) /* End of data */
750: hilevent(hilp);
751: else /* End of command */
752: hilp->hl_cmdending = TRUE;
753: hilp->hl_actdev = 0;
754: } else {
755: if (c & HIL_POLLDATA) { /* Start of polled data */
756: if (hilp->hl_actdev != 0)
757: hilevent(hilp);
758: hilp->hl_actdev = (c & HIL_DEVMASK);
759: hilp->hl_pollbp = hilp->hl_pollbuf;
760: } else { /* Start of command */
761: if (hilp->hl_cmddev == (c & HIL_DEVMASK)) {
762: hilp->hl_cmdbp = hilp->hl_cmdbuf;
763: hilp->hl_actdev = 0;
764: }
765: }
766: }
767: return;
768:
769: case HIL_DATA:
770: hilp = &hil0; /* XXX */
771: if (hilp->hl_actdev != 0) /* Collecting poll data */
772: *hilp->hl_pollbp++ = c;
773: else if (hilp->hl_cmddev != 0) /* Collecting cmd data */
774: if (hilp->hl_cmdending) {
775: hilp->hl_cmddone = TRUE;
776: hilp->hl_cmdending = FALSE;
777: } else
778: *hilp->hl_cmdbp++ = c;
779: return;
780:
781: case 0: /* force full jump table */
782: default:
783: return;
784: }
785: }
786:
787: #if defined(DEBUG) && !defined(PANICBUTTON)
788: #define PANICBUTTON
789: #endif
790:
791: /*
792: * Optimized macro to compute:
793: * eq->head == (eq->tail + 1) % eq->size
794: * i.e. has tail caught up with head. We do this because 32 bit long
795: * remaidering is expensive (a function call with our compiler).
796: */
797: #define HQFULL(eq) (((eq)->head?(eq)->head:(eq)->size) == (eq)->tail+1)
798: #define HQVALID(eq) \
799: ((eq)->size == HEVQSIZE && (eq)->tail >= 0 && (eq)->tail < HEVQSIZE)
800:
801: hilevent(hilp)
802: struct hilloop *hilp;
803: {
804: register struct hilloopdev *dptr = &hilp->hl_device[hilp->hl_actdev];
805: register int len, mask, qnum;
806: register u_char *cp, *pp;
807: register HILQ *hq;
808: struct timeval ourtime;
809: hil_packet *proto;
810: int s, len0;
811: long tenths;
812:
813: #ifdef PANICBUTTON
814: static int first;
815: extern int panicbutton;
816:
817: cp = hilp->hl_pollbuf;
818: if (panicbutton && (*cp & HIL_KBDDATA)) {
819: if (*++cp == 0x4E)
820: first = 1;
821: else if (first && *cp == 0x46 && !panicstr)
822: panic("are we having fun yet?");
823: else
824: first = 0;
825: }
826: #endif
827: #ifdef DEBUG
828: if (hildebug & HDB_EVENTS) {
829: printf("hilevent: dev %d pollbuf: ", hilp->hl_actdev);
830: printhilpollbuf(hilp);
831: printf("\n");
832: }
833: #endif
834:
835: /*
836: * Note that HIL_READIN effectively "shuts off" any queues
837: * that may have been in use at the time of an HILIOCHPUX call.
838: */
839: if (dptr->hd_flags & HIL_READIN) {
840: hpuxhilevent(hilp, dptr);
841: return;
842: }
843:
844: /*
845: * If this device isn't on any queue or there are no data
846: * in the packet (can this happen?) do nothing.
847: */
848: if (dptr->hd_qmask == 0 ||
849: (len0 = hilp->hl_pollbp - hilp->hl_pollbuf) <= 0)
850: return;
851:
852: /*
853: * Everybody gets the same time stamp
854: */
855: s = splclock();
856: ourtime = time;
857: splx(s);
858: tenths = (ourtime.tv_sec * 100) + (ourtime.tv_usec / 10000);
859:
860: proto = NULL;
861: mask = dptr->hd_qmask;
862: for (qnum = 0; mask; qnum++) {
863: if ((mask & hilqmask(qnum)) == 0)
864: continue;
865: mask &= ~hilqmask(qnum);
866: hq = hilp->hl_queue[qnum].hq_eventqueue;
867:
868: /*
869: * Ensure that queue fields that we rely on are valid
870: * and that there is space in the queue. If either
871: * test fails, we just skip this queue.
872: */
873: if (!HQVALID(&hq->hil_evqueue) || HQFULL(&hq->hil_evqueue))
874: continue;
875:
876: /*
877: * Copy data to queue.
878: * If this is the first queue we construct the packet
879: * with length, timestamp and poll buffer data.
880: * For second and sucessive packets we just duplicate
881: * the first packet.
882: */
883: pp = (u_char *) &hq->hil_event[hq->hil_evqueue.tail];
884: if (proto == NULL) {
885: proto = (hil_packet *)pp;
886: cp = hilp->hl_pollbuf;
887: len = len0;
888: *pp++ = len + 6;
889: *pp++ = hilp->hl_actdev;
890: *(long *)pp = tenths;
891: pp += sizeof(long);
892: do *pp++ = *cp++; while (--len);
893: } else
894: *(hil_packet *)pp = *proto;
895:
896: if (++hq->hil_evqueue.tail == hq->hil_evqueue.size)
897: hq->hil_evqueue.tail = 0;
898: }
899:
900: /*
901: * Wake up anyone selecting on this device or the loop itself
902: */
903: if (dptr->hd_selr) {
904: selwakeup(dptr->hd_selr, dptr->hd_flags & HIL_SELCOLL);
905: dptr->hd_selr = NULL;
906: dptr->hd_flags &= ~HIL_SELCOLL;
907: }
908: dptr = &hilp->hl_device[HILLOOPDEV];
909: if (dptr->hd_selr) {
910: selwakeup(dptr->hd_selr, dptr->hd_flags & HIL_SELCOLL);
911: dptr->hd_selr = NULL;
912: dptr->hd_flags &= ~HIL_SELCOLL;
913: }
914: }
915:
916: #undef HQFULL
917:
918: hpuxhilevent(hilp, dptr)
919: register struct hilloop *hilp;
920: register struct hilloopdev *dptr;
921: {
922: register int len;
923: struct timeval ourtime;
924: long tstamp;
925: int s;
926:
927: /*
928: * Everybody gets the same time stamp
929: */
930: s = splclock();
931: ourtime = time;
932: splx(s);
933: tstamp = (ourtime.tv_sec * 100) + (ourtime.tv_usec / 10000);
934:
935: /*
936: * Each packet that goes into the buffer must be preceded by the
937: * number of bytes in the packet, and the timestamp of the packet.
938: * This adds 5 bytes to the packet size. Make sure there is enough
939: * room in the buffer for it, and if not, toss the packet.
940: */
941: len = hilp->hl_pollbp - hilp->hl_pollbuf;
942: if (dptr->hd_queue.c_cc <= (HILMAXCLIST - (len+5))) {
943: putc(len+5, &dptr->hd_queue);
944: (void) b_to_q((char *)&tstamp, sizeof tstamp, &dptr->hd_queue);
945: (void) b_to_q((char *)hilp->hl_pollbuf, len, &dptr->hd_queue);
946: }
947:
948: /*
949: * Wake up any one blocked on a read or select
950: */
951: if (dptr->hd_flags & HIL_ASLEEP) {
952: dptr->hd_flags &= ~HIL_ASLEEP;
953: wakeup((caddr_t)dptr);
954: }
955: if (dptr->hd_selr) {
956: selwakeup(dptr->hd_selr, dptr->hd_flags & HIL_SELCOLL);
957: dptr->hd_selr = NULL;
958: dptr->hd_flags &= ~HIL_SELCOLL;
959: }
960: }
961:
962: /*
963: * Shared queue manipulation routines
964: */
965:
966: hilqalloc(qip)
967: struct hilqinfo *qip;
968: {
969: #ifdef MAPMEM
970: struct proc *p = u.u_procp; /* XXX */
971: register struct hilloop *hilp = &hil0; /* XXX */
972: register HILQ *hq;
973: register int qnum;
974: struct mapmem *mp;
975: int error, hilqmapin();
976:
977: #ifdef DEBUG
978: if (hildebug & HDB_FOLLOW)
979: printf("hilqalloc(%d): addr %x\n",
980: p->p_pid, qip->addr);
981: #endif
982: /*
983: * Find a free queue
984: */
985: for (qnum = 0; qnum < NHILQ; qnum++)
986: if (hilp->hl_queue[qnum].hq_procp == NULL)
987: break;
988: if (qnum == NHILQ)
989: return(EMFILE);
990:
991: /*
992: * Allocate and clear memory for the queue
993: */
994: if (hilp->hl_queue[qnum].hq_eventqueue)
995: panic("hilqalloc");
996: hq = (HILQ *) cialloc(sizeof(HILQ));
997: if (hq == NULL)
998: return(ENOMEM);
999: bzero((caddr_t)hq, sizeof(HILQ));
1000: hilp->hl_queue[qnum].hq_eventqueue = hq;
1001: hq->hil_evqueue.size = HEVQSIZE;
1002:
1003: /*
1004: * Map queue into user address space as instructed
1005: */
1006: error = mmalloc(p, qnum, &qip->addr, sizeof(HILQ), MM_RW|MM_CI,
1007: &hilqops, &mp);
1008: if (error) {
1009: cifree((caddr_t)hq, sizeof(HILQ));
1010: hilp->hl_queue[qnum].hq_eventqueue = NULL;
1011: return(error);
1012: }
1013: qip->qid = qnum;
1014: if (error = mmmapin(p, mp, hilqmapin)) {
1015: (void) mmfree(p, mp);
1016: cifree((caddr_t)hq, sizeof(HILQ));
1017: hilp->hl_queue[qnum].hq_eventqueue = NULL;
1018: return(error);
1019: }
1020: hilp->hl_queue[qnum].hq_procp = p;
1021: hilp->hl_queue[qnum].hq_devmask = 0;
1022: return(0);
1023: #else
1024: return(EINVAL);
1025: #endif
1026: }
1027:
1028: hilqfree(qnum)
1029: register int qnum;
1030: {
1031: #ifdef MAPMEM
1032: struct proc *p = u.u_procp; /* XXX */
1033: register struct hilloop *hilp = &hil0; /* XXX */
1034: register struct mapmem *mp;
1035:
1036: #ifdef DEBUG
1037: if (hildebug & HDB_FOLLOW)
1038: printf("hilqfree(%d): qnum %d\n",
1039: p->p_pid, qnum);
1040: #endif
1041: if (qnum >= NHILQ || hilp->hl_queue[qnum].hq_procp != p)
1042: return(EINVAL);
1043: for (mp = u.u_mmap; mp; mp = mp->mm_next)
1044: if (qnum == mp->mm_id && mp->mm_ops == &hilqops) {
1045: (void) hilqexit(mp);
1046: return(0);
1047: }
1048: panic("hilqfree");
1049: /* NOTREACHED */
1050: #else
1051: return(EINVAL);
1052: #endif
1053: }
1054:
1055: hilqmap(qnum, device)
1056: register int qnum, device;
1057: {
1058: struct proc *p = u.u_procp; /* XXX */
1059: register struct hilloop *hilp = &hil0; /* XXX */
1060: register struct hilloopdev *dptr = &hilp->hl_device[device];
1061: int s;
1062:
1063: #ifdef DEBUG
1064: if (hildebug & HDB_FOLLOW)
1065: printf("hilqmap(%d): qnum %d device %x\n",
1066: p->p_pid, qnum, device);
1067: #endif
1068: if (qnum >= NHILQ || hilp->hl_queue[qnum].hq_procp != p)
1069: return(EINVAL);
1070: if ((dptr->hd_flags & HIL_QUEUEIN) == 0)
1071: return(EINVAL);
1072: if (dptr->hd_qmask && u.u_uid && u.u_uid != dptr->hd_uid)
1073: return(EPERM);
1074:
1075: hilp->hl_queue[qnum].hq_devmask |= hildevmask(device);
1076: if (dptr->hd_qmask == 0)
1077: dptr->hd_uid = u.u_uid;
1078: s = splhil();
1079: dptr->hd_qmask |= hilqmask(qnum);
1080: splx(s);
1081: #ifdef DEBUG
1082: if (hildebug & HDB_MASK)
1083: printf("hilqmap(%d): devmask %x qmask %x\n",
1084: p->p_pid, hilp->hl_queue[qnum].hq_devmask,
1085: dptr->hd_qmask);
1086: #endif
1087: return(0);
1088: }
1089:
1090: hilqunmap(qnum, device)
1091: register int qnum, device;
1092: {
1093: struct proc *p = u.u_procp; /* XXX */
1094: register struct hilloop *hilp = &hil0; /* XXX */
1095: int s;
1096:
1097: #ifdef DEBUG
1098: if (hildebug & HDB_FOLLOW)
1099: printf("hilqunmap(%d): qnum %d device %x\n",
1100: p->p_pid, qnum, device);
1101: #endif
1102:
1103: if (qnum >= NHILQ || hilp->hl_queue[qnum].hq_procp != p)
1104: return(EINVAL);
1105:
1106: hilp->hl_queue[qnum].hq_devmask &= ~hildevmask(device);
1107: s = splhil();
1108: hilp->hl_device[device].hd_qmask &= ~hilqmask(qnum);
1109: splx(s);
1110: #ifdef DEBUG
1111: if (hildebug & HDB_MASK)
1112: printf("hilqunmap(%d): devmask %x qmask %x\n",
1113: p->p_pid, hilp->hl_queue[qnum].hq_devmask,
1114: hilp->hl_device[device].hd_qmask);
1115: #endif
1116: return(0);
1117: }
1118:
1119: #ifdef MAPMEM
1120: hilqmapin(mp, off)
1121: struct mapmem *mp;
1122: {
1123: struct hilloop *hilp = &hil0; /* XXX */
1124: register HILQ *hq = hilp->hl_queue[mp->mm_id].hq_eventqueue;
1125:
1126: if (hq == NULL || off >= sizeof(HILQ))
1127: return(-1);
1128: return(kvtop((u_int)hq + off) >> PGSHIFT);
1129: }
1130:
1131: /*
1132: * Fork hook.
1133: * Unmap queue from child's address space
1134: */
1135: hilqfork(mp, ischild)
1136: struct mapmem *mp;
1137: {
1138: struct proc *p = u.u_procp; /* XXX */
1139: #ifdef DEBUG
1140: if (hildebug & HDB_MMAP)
1141: printf("hilqfork(%d): %s qnum %d\n", p->p_pid,
1142: ischild ? "child" : "parent", mp->mm_id);
1143: #endif
1144: if (ischild) {
1145: mmmapout(p, mp);
1146: (void) mmfree(p, mp);
1147: }
1148: }
1149:
1150: /*
1151: * Vfork hook.
1152: * Associate queue with child when VM resources are passed.
1153: */
1154: hilqvfork(mp, fup, tup)
1155: struct mapmem *mp;
1156: struct user *fup, *tup;
1157: {
1158: struct hilloop *hilp = &hil0; /* XXX */
1159: register struct hiliqueue *qp = &hilp->hl_queue[mp->mm_id];
1160:
1161: #ifdef DEBUG
1162: if (hildebug & HDB_MMAP)
1163: printf("hilqvfork(%d): from %x to %x qnum %d, qprocp %x\n",
1164: u.u_procp->p_pid, fup->u_procp, tup->u_procp,
1165: mp->mm_id, qp->hq_procp);
1166: #endif
1167: if (qp->hq_procp == fup->u_procp)
1168: qp->hq_procp = tup->u_procp;
1169: }
1170:
1171: /*
1172: * Exit hook.
1173: * Unmap all devices and free all queues.
1174: */
1175: hilqexit(mp)
1176: struct mapmem *mp;
1177: {
1178: struct proc *p = u.u_procp; /* XXX */
1179: register struct hilloop *hilp = &hil0; /* XXX */
1180: register int mask, i;
1181: int s;
1182:
1183: #ifdef DEBUG
1184: if (hildebug & HDB_MMAP)
1185: printf("hilqexit(%d): qnum %d\n", p->p_pid, mp->mm_id);
1186: #endif
1187: /*
1188: * Atomically take all devices off the queue
1189: */
1190: mask = ~hilqmask(mp->mm_id);
1191: s = splhil();
1192: for (i = 0; i < NHILD; i++)
1193: hilp->hl_device[i].hd_qmask &= mask;
1194: splx(s);
1195: /*
1196: * Now unmap from user address space and free queue
1197: */
1198: i = mp->mm_id;
1199: cifree((caddr_t)hilp->hl_queue[i].hq_eventqueue, sizeof(HILQ));
1200: hilp->hl_queue[i].hq_eventqueue = NULL;
1201: hilp->hl_queue[i].hq_procp = NULL;
1202: return(mmfree(p, mp));
1203: }
1204: #endif
1205:
1206: #include "clist.h"
1207:
1208: /*
1209: * This is just a copy of the virgin q_to_b routine with minor
1210: * optimizations for HIL use. It is used for two reasons:
1211: * 1. If we have PAGE mode defined, the normal q_to_b processes
1212: * chars one at a time and breaks on newlines.
1213: * 2. We don't have to raise the priority to spltty() for most
1214: * of the clist manipulations.
1215: */
1216: hilq_to_b(q, cp, cc)
1217: register struct clist *q;
1218: register char *cp;
1219: {
1220: register struct cblock *bp;
1221: register int nc;
1222: char *acp;
1223: int s;
1224: extern char cwaiting;
1225:
1226: if (cc <= 0)
1227: return (0);
1228: s = splhil();
1229: if (q->c_cc <= 0) {
1230: q->c_cc = 0;
1231: q->c_cf = q->c_cl = NULL;
1232: splx(s);
1233: return (0);
1234: }
1235: acp = cp;
1236:
1237: while (cc) {
1238: nc = sizeof (struct cblock) - ((int)q->c_cf & CROUND);
1239: nc = MIN(nc, cc);
1240: nc = MIN(nc, q->c_cc);
1241: (void) bcopy(q->c_cf, cp, (unsigned)nc);
1242: q->c_cf += nc;
1243: q->c_cc -= nc;
1244: cc -= nc;
1245: cp += nc;
1246: if (q->c_cc <= 0) {
1247: bp = (struct cblock *)(q->c_cf - 1);
1248: bp = (struct cblock *)((int)bp & ~CROUND);
1249: q->c_cf = q->c_cl = NULL;
1250: spltty();
1251: bp->c_next = cfreelist;
1252: cfreelist = bp;
1253: cfreecount += CBSIZE;
1254: if (cwaiting) {
1255: wakeup(&cwaiting);
1256: cwaiting = 0;
1257: }
1258: break;
1259: }
1260: if (((int)q->c_cf & CROUND) == 0) {
1261: bp = (struct cblock *)(q->c_cf);
1262: bp--;
1263: q->c_cf = bp->c_next->c_info;
1264: spltty();
1265: bp->c_next = cfreelist;
1266: cfreelist = bp;
1267: cfreecount += CBSIZE;
1268: if (cwaiting) {
1269: wakeup(&cwaiting);
1270: cwaiting = 0;
1271: }
1272: splhil();
1273: }
1274: }
1275: splx(s);
1276: return (cp-acp);
1277: }
1278:
1279: /*
1280: * Cooked keyboard functions for ite driver.
1281: * There is only one "cooked" ITE keyboard (the first keyboard found)
1282: * per loop. There may be other keyboards, but they will always be "raw".
1283: */
1284:
1285: kbdbell()
1286: {
1287: struct hilloop *hilp = &hil0; /* XXX */
1288:
1289: hilbeep(hilp, &default_bell);
1290: }
1291:
1292: kbdenable()
1293: {
1294: struct hilloop *hilp = &hil0; /* XXX */
1295: register struct hil_dev *hildevice = hilp->hl_addr;
1296: char db;
1297:
1298: /* Set the autorepeat rate register */
1299: db = ar_format(KBD_ARR);
1300: send_hil_cmd(hildevice, HIL_SETARR, &db, 1, NULL);
1301:
1302: /* Set the autorepeat delay register */
1303: db = ar_format(KBD_ARD);
1304: send_hil_cmd(hildevice, HIL_SETARD, &db, 1, NULL);
1305:
1306: /* Enable interrupts */
1307: send_hil_cmd(hildevice, HIL_INTON, NULL, 0, NULL);
1308: }
1309:
1310: kbddisable()
1311: {
1312: }
1313:
1314: /*
1315: * XXX: read keyboard directly and return code.
1316: * Used by console getchar routine. Could really screw up anybody
1317: * reading from the keyboard in the normal, interrupt driven fashion.
1318: */
1319: kbdgetc(statp)
1320: int *statp;
1321: {
1322: struct hilloop *hilp = &hil0; /* XXX */
1323: register struct hil_dev *hildevice = hilp->hl_addr;
1324: register int c, stat;
1325: int s;
1326:
1327: s = splhil();
1328: while (((stat = hildevice->hil_stat) & HIL_DATA_RDY) == 0)
1329: ;
1330: c = hildevice->hil_data;
1331: splx(s);
1332: *statp = stat;
1333: return(c);
1334: }
1335:
1336: /*
1337: * Recoginize and clear keyboard generated NMIs.
1338: * Returns 1 if it was ours, 0 otherwise. Note that we cannot use
1339: * send_hil_cmd() to issue the clear NMI command as that would actually
1340: * lower the priority to splimp() and it doesn't wait for the completion
1341: * of the command. Either of these conditions could result in the
1342: * interrupt reoccuring. Note that we issue the CNMT command twice.
1343: * This seems to be needed, once is not always enough!?!
1344: */
1345: kbdnmi()
1346: {
1347: register struct hilloop *hilp = &hil0; /* XXX */
1348:
1349: if ((*KBDNMISTAT & KBDNMI) == 0)
1350: return(0);
1351: HILWAIT(hilp->hl_addr);
1352: hilp->hl_addr->hil_cmd = HIL_CNMT;
1353: HILWAIT(hilp->hl_addr);
1354: hilp->hl_addr->hil_cmd = HIL_CNMT;
1355: HILWAIT(hilp->hl_addr);
1356: return(1);
1357: }
1358:
1359: #define HILSECURITY 0x33
1360: #define HILIDENTIFY 0x03
1361: #define HILSCBIT 0x04
1362:
1363: /*
1364: * Called at boot time to print out info about interesting devices
1365: */
1366: hilinfo(hilp)
1367: register struct hilloop *hilp;
1368: {
1369: register int id, len;
1370: register struct kbdmap *km;
1371:
1372: /*
1373: * Keyboard info.
1374: */
1375: if (hilp->hl_kbddev) {
1376: printf("hil%d: ", hilp->hl_kbddev);
1377: for (km = kbd_map; km->kbd_code; km++)
1378: if (km->kbd_code == hilp->hl_kbdlang) {
1379: printf("%s ", km->kbd_desc);
1380: break;
1381: }
1382: printf("keyboard\n");
1383: }
1384: /*
1385: * ID module.
1386: * Attempt to locate the first ID module and print out its
1387: * security code. Is this a good idea??
1388: */
1389: id = hiliddev(hilp);
1390: if (id) {
1391: hilp->hl_cmdbp = hilp->hl_cmdbuf;
1392: hilp->hl_cmddev = id;
1393: send_hildev_cmd(hilp, id, HILSECURITY);
1394: len = hilp->hl_cmdbp - hilp->hl_cmdbuf;
1395: hilp->hl_cmdbp = hilp->hl_cmdbuf;
1396: hilp->hl_cmddev = 0;
1397: printf("hil%d: security code", id);
1398: for (id = 0; id < len; id++)
1399: printf(" %x", hilp->hl_cmdbuf[id]);
1400: while (id++ < 16)
1401: printf(" 0");
1402: printf("\n");
1403: }
1404: }
1405:
1406: #define HILAR1 0x3E
1407: #define HILAR2 0x3F
1408:
1409: /*
1410: * Called after the loop has reconfigured. Here we need to:
1411: * - determine how many devices are on the loop
1412: * (some may have been added or removed)
1413: * - locate the ITE keyboard (if any) and ensure
1414: * that it is in the proper state (raw or cooked)
1415: * and is set to use the proper language mapping table
1416: * - ensure all other keyboards are raw
1417: * Note that our device state is now potentially invalid as
1418: * devices may no longer be where they were. What we should
1419: * do here is either track where the devices went and move
1420: * state around accordingly or, more simply, just mark all
1421: * devices as HIL_DERROR and don't allow any further use until
1422: * they are closed. This is a little too brutal for my tastes,
1423: * we prefer to just assume people won't move things around.
1424: */
1425: hilconfig(hilp)
1426: register struct hilloop *hilp;
1427: {
1428: u_char db;
1429: int s;
1430:
1431: s = splhil();
1432: #ifdef DEBUG
1433: if (hildebug & HDB_CONFIG) {
1434: printf("hilconfig: reconfigured: ");
1435: send_hil_cmd(hilp->hl_addr, HIL_READLPSTAT, NULL, 0, &db);
1436: printf("LPSTAT %x, ", db);
1437: send_hil_cmd(hilp->hl_addr, HIL_READLPCTRL, NULL, 0, &db);
1438: printf("LPCTRL %x, ", db);
1439: send_hil_cmd(hilp->hl_addr, HIL_READKBDSADR, NULL, 0, &db);
1440: printf("KBDSADR %x\n", db);
1441: hilreport(hilp);
1442: }
1443: #endif
1444: /*
1445: * Determine how many devices are on the loop.
1446: * Mark those as alive and real, all others as dead.
1447: */
1448: db = 0;
1449: send_hil_cmd(hilp->hl_addr, HIL_READLPSTAT, NULL, 0, &db);
1450: hilp->hl_maxdev = db & LPS_DEVMASK;
1451: for (db = 1; db < NHILD; db++) {
1452: if (db <= hilp->hl_maxdev)
1453: hilp->hl_device[db].hd_flags |= HIL_ALIVE;
1454: else
1455: hilp->hl_device[db].hd_flags &= ~HIL_ALIVE;
1456: hilp->hl_device[db].hd_flags &= ~HIL_PSEUDO;
1457: }
1458: #ifdef DEBUG
1459: if (hildebug & (HDB_CONFIG|HDB_KEYBOARD))
1460: printf("hilconfig: max device %d\n", hilp->hl_maxdev);
1461: #endif
1462: if (hilp->hl_maxdev == 0) {
1463: hilp->hl_kbddev = 0;
1464: splx(s);
1465: return;
1466: }
1467: /*
1468: * Find out where the keyboards are and record the ITE keyboard
1469: * (first one found). If no keyboards found, we are all done.
1470: */
1471: db = 0;
1472: send_hil_cmd(hilp->hl_addr, HIL_READKBDSADR, NULL, 0, &db);
1473: #ifdef DEBUG
1474: if (hildebug & HDB_KEYBOARD)
1475: printf("hilconfig: keyboard: KBDSADR %x, old %d, new %d\n",
1476: db, hilp->hl_kbddev, ffs((int)db));
1477: #endif
1478: hilp->hl_kbddev = ffs((int)db);
1479: if (hilp->hl_kbddev == 0) {
1480: splx(s);
1481: return;
1482: }
1483: /*
1484: * Determine if the keyboard should be cooked or raw and configure it.
1485: */
1486: db = (hilp->hl_kbdflags & KBD_RAW) ? 0 : 1 << (hilp->hl_kbddev - 1);
1487: send_hil_cmd(hilp->hl_addr, HIL_WRITEKBDSADR, &db, 1, NULL);
1488: /*
1489: * Re-enable autorepeat in raw mode, cooked mode AR is not affected.
1490: */
1491: if (hilp->hl_kbdflags & (KBD_AR1|KBD_AR2)) {
1492: db = (hilp->hl_kbdflags & KBD_AR1) ? HILAR1 : HILAR2;
1493: hilp->hl_cmddev = hilp->hl_kbddev;
1494: send_hildev_cmd(hilp, hilp->hl_kbddev, db);
1495: hilp->hl_cmddev = 0;
1496: }
1497: /*
1498: * Determine the keyboard language configuration, but don't
1499: * override a user-specified setting.
1500: */
1501: db = 0;
1502: send_hil_cmd(hilp->hl_addr, HIL_READKBDLANG, NULL, 0, &db);
1503: #ifdef DEBUG
1504: if (hildebug & HDB_KEYBOARD)
1505: printf("hilconfig: language: old %x new %x\n",
1506: hilp->hl_kbdlang, db);
1507: #endif
1508: if (hilp->hl_kbdlang != KBD_SPECIAL) {
1509: struct kbdmap *km;
1510:
1511: for (km = kbd_map; km->kbd_code; km++)
1512: if (km->kbd_code == db) {
1513: hilp->hl_kbdlang = db;
1514: /* XXX */
1515: kbd_keymap = km->kbd_keymap;
1516: kbd_shiftmap = km->kbd_shiftmap;
1517: kbd_ctrlmap = km->kbd_ctrlmap;
1518: kbd_ctrlshiftmap = km->kbd_ctrlshiftmap;
1519: kbd_stringmap = km->kbd_stringmap;
1520: }
1521: }
1522: splx(s);
1523: }
1524:
1525: hilreset(hilp)
1526: struct hilloop *hilp;
1527: {
1528: register struct hil_dev *hildevice = hilp->hl_addr;
1529: u_char db;
1530:
1531: /*
1532: * Initialize the loop: reconfigure, don't report errors,
1533: * cook keyboards, and enable autopolling.
1534: */
1535: db = LPC_RECONF | LPC_KBDCOOK | LPC_NOERROR | LPC_AUTOPOLL;
1536: send_hil_cmd(hildevice, HIL_WRITELPCTRL, &db, 1, NULL);
1537: /*
1538: * Delay one second for reconfiguration and then read the the
1539: * data register to clear the interrupt (if the loop reconfigured).
1540: */
1541: DELAY(1000000);
1542: if (hildevice->hil_stat & HIL_DATA_RDY)
1543: db = hildevice->hil_data;
1544: /*
1545: * The HIL loop may have reconfigured. If so we proceed on,
1546: * if not we loop until a successful reconfiguration is reported
1547: * back to us. The HIL loop will continue to attempt forever.
1548: * Probably not very smart.
1549: */
1550: do {
1551: send_hil_cmd(hildevice, HIL_READLPSTAT, NULL, 0, &db);
1552: } while ((db & (LPS_CONFFAIL|LPS_CONFGOOD)) == 0);
1553: /*
1554: * At this point, the loop should have reconfigured.
1555: * The reconfiguration interrupt has already called hilconfig()
1556: * so the keyboard has been determined.
1557: */
1558: send_hil_cmd(hildevice, HIL_INTON, NULL, 0, NULL);
1559: }
1560:
1561: hilbeep(hilp, bp)
1562: struct hilloop *hilp;
1563: register struct _hilbell *bp;
1564: {
1565: u_char buf[2];
1566:
1567: buf[0] = ~((bp->duration - 10) / 10);
1568: buf[1] = bp->frequency;
1569: send_hil_cmd(hilp->hl_addr, HIL_SETTONE, buf, 2, NULL);
1570: }
1571:
1572: /*
1573: * Locate and return the address of the first ID module, 0 if none present.
1574: */
1575: hiliddev(hilp)
1576: register struct hilloop *hilp;
1577: {
1578: register int i, len;
1579:
1580: #ifdef DEBUG
1581: if (hildebug & HDB_IDMODULE)
1582: printf("hiliddev(%x): looking for idmodule...", hilp);
1583: #endif
1584: for (i = 1; i <= hilp->hl_maxdev; i++) {
1585: hilp->hl_cmdbp = hilp->hl_cmdbuf;
1586: hilp->hl_cmddev = i;
1587: send_hildev_cmd(hilp, i, HILIDENTIFY);
1588: /*
1589: * XXX: the final condition checks to ensure that the
1590: * device ID byte is in the range of the ID module (0x30-0x3F)
1591: */
1592: len = hilp->hl_cmdbp - hilp->hl_cmdbuf;
1593: if (len > 1 && (hilp->hl_cmdbuf[1] & HILSCBIT) &&
1594: (hilp->hl_cmdbuf[0] & 0xF0) == 0x30) {
1595: hilp->hl_cmdbp = hilp->hl_cmdbuf;
1596: hilp->hl_cmddev = i;
1597: send_hildev_cmd(hilp, i, HILSECURITY);
1598: break;
1599: }
1600: }
1601: hilp->hl_cmdbp = hilp->hl_cmdbuf;
1602: hilp->hl_cmddev = 0;
1603: #ifdef DEBUG
1604: if (hildebug & HDB_IDMODULE)
1605: if (i <= hilp->hl_maxdev)
1606: printf("found at %d\n", i);
1607: else
1608: printf("not found\n");
1609: #endif
1610: return(i <= hilp->hl_maxdev ? i : 0);
1611: }
1612:
1613: /*
1614: * Low level routines which actually talk to the 8042 chip.
1615: */
1616:
1617: /*
1618: * Send a command to the 8042 with zero or more bytes of data.
1619: * If rdata is non-null, wait for and return a byte of data.
1620: * We run at splimp() to make the transaction as atomic as
1621: * possible without blocking the clock (is this necessary?)
1622: */
1623: send_hil_cmd(hildevice, cmd, data, dlen, rdata)
1624: register struct hil_dev *hildevice;
1625: u_char cmd, *data, dlen;
1626: u_char *rdata;
1627: {
1628: u_char status;
1629: int s = splimp();
1630:
1631: HILWAIT(hildevice);
1632: hildevice->hil_cmd = cmd;
1633: while (dlen--) {
1634: HILWAIT(hildevice);
1635: hildevice->hil_data = *data++;
1636: }
1637: if (rdata) {
1638: do {
1639: HILDATAWAIT(hildevice);
1640: status = hildevice->hil_stat;
1641: *rdata = hildevice->hil_data;
1642: } while (((status >> HIL_SSHIFT) & HIL_SMASK) != HIL_68K);
1643: }
1644: splx(s);
1645: }
1646:
1647: /*
1648: * Send a command to a device on the loop.
1649: * Since only one command can be active on the loop at any time,
1650: * we must ensure that we are not interrupted during this process.
1651: * Hence we mask interrupts to prevent potential access from most
1652: * interrupt routines and turn off auto-polling to disable the
1653: * internally generated poll commands.
1654: *
1655: * splhigh is extremely conservative but insures atomic operation,
1656: * splimp (clock only interrupts) seems to be good enough in practice.
1657: */
1658: send_hildev_cmd(hilp, device, cmd)
1659: register struct hilloop *hilp;
1660: char device, cmd;
1661: {
1662: register struct hil_dev *hildevice = hilp->hl_addr;
1663: u_char status, c;
1664: int s = splimp();
1665:
1666: polloff(hildevice);
1667:
1668: /*
1669: * Transfer the command and device info to the chip
1670: */
1671: HILWAIT(hildevice);
1672: hildevice->hil_cmd = HIL_STARTCMD;
1673: HILWAIT(hildevice);
1674: hildevice->hil_data = 8 + device;
1675: HILWAIT(hildevice);
1676: hildevice->hil_data = cmd;
1677: HILWAIT(hildevice);
1678: hildevice->hil_data = HIL_TIMEOUT;
1679: /*
1680: * Trigger the command and wait for completion
1681: */
1682: HILWAIT(hildevice);
1683: hildevice->hil_cmd = HIL_TRIGGER;
1684: hilp->hl_cmddone = FALSE;
1685: do {
1686: HILDATAWAIT(hildevice);
1687: status = hildevice->hil_stat;
1688: c = hildevice->hil_data;
1689: hil_process_int(status, c);
1690: } while (!hilp->hl_cmddone);
1691:
1692: pollon(hildevice);
1693: splx(s);
1694: }
1695:
1696: /*
1697: * Turn auto-polling off and on.
1698: * Also disables and enable auto-repeat. Why?
1699: */
1700: polloff(hildevice)
1701: register struct hil_dev *hildevice;
1702: {
1703: register char db;
1704:
1705: /*
1706: * Turn off auto repeat
1707: */
1708: HILWAIT(hildevice);
1709: hildevice->hil_cmd = HIL_SETARR;
1710: HILWAIT(hildevice);
1711: hildevice->hil_data = 0;
1712: /*
1713: * Turn off auto-polling
1714: */
1715: HILWAIT(hildevice);
1716: hildevice->hil_cmd = HIL_READLPCTRL;
1717: HILDATAWAIT(hildevice);
1718: db = hildevice->hil_data;
1719: db &= ~LPC_AUTOPOLL;
1720: HILWAIT(hildevice);
1721: hildevice->hil_cmd = HIL_WRITELPCTRL;
1722: HILWAIT(hildevice);
1723: hildevice->hil_data = db;
1724: /*
1725: * Must wait til polling is really stopped
1726: */
1727: do {
1728: HILWAIT(hildevice);
1729: hildevice->hil_cmd = HIL_READBUSY;
1730: HILDATAWAIT(hildevice);
1731: db = hildevice->hil_data;
1732: } while (db & BSY_LOOPBUSY);
1733: }
1734:
1735: pollon(hildevice)
1736: register struct hil_dev *hildevice;
1737: {
1738: register char db;
1739:
1740: /*
1741: * Turn on auto polling
1742: */
1743: HILWAIT(hildevice);
1744: hildevice->hil_cmd = HIL_READLPCTRL;
1745: HILDATAWAIT(hildevice);
1746: db = hildevice->hil_data;
1747: db |= LPC_AUTOPOLL;
1748: HILWAIT(hildevice);
1749: hildevice->hil_cmd = HIL_WRITELPCTRL;
1750: HILWAIT(hildevice);
1751: hildevice->hil_data = db;
1752: /*
1753: * Turn on auto repeat
1754: */
1755: HILWAIT(hildevice);
1756: hildevice->hil_cmd = HIL_SETARR;
1757: HILWAIT(hildevice);
1758: hildevice->hil_data = ar_format(KBD_ARR);
1759: }
1760:
1761: #ifdef DEBUG
1762: printhilpollbuf(hilp)
1763: register struct hilloop *hilp;
1764: {
1765: register u_char *cp;
1766: register int i, len;
1767:
1768: cp = hilp->hl_pollbuf;
1769: len = hilp->hl_pollbp - cp;
1770: for (i = 0; i < len; i++)
1771: printf("%x ", hilp->hl_pollbuf[i]);
1772: printf("\n");
1773: }
1774:
1775: printhilcmdbuf(hilp)
1776: register struct hilloop *hilp;
1777: {
1778: register u_char *cp;
1779: register int i, len;
1780:
1781: cp = hilp->hl_cmdbuf;
1782: len = hilp->hl_cmdbp - cp;
1783: for (i = 0; i < len; i++)
1784: printf("%x ", hilp->hl_cmdbuf[i]);
1785: printf("\n");
1786: }
1787:
1788: hilreport(hilp)
1789: register struct hilloop *hilp;
1790: {
1791: register int i, len;
1792: int s = splhil();
1793:
1794: for (i = 1; i <= hilp->hl_maxdev; i++) {
1795: hilp->hl_cmdbp = hilp->hl_cmdbuf;
1796: hilp->hl_cmddev = i;
1797: send_hildev_cmd(hilp, i, HILIDENTIFY);
1798: printf("hil%d: id: ", i);
1799: printhilcmdbuf(hilp);
1800: len = hilp->hl_cmdbp - hilp->hl_cmdbuf;
1801: if (len > 1 && (hilp->hl_cmdbuf[1] & HILSCBIT)) {
1802: hilp->hl_cmdbp = hilp->hl_cmdbuf;
1803: hilp->hl_cmddev = i;
1804: send_hildev_cmd(hilp, i, HILSECURITY);
1805: printf("hil%d: sc: ", i);
1806: printhilcmdbuf(hilp);
1807: }
1808: }
1809: hilp->hl_cmdbp = hilp->hl_cmdbuf;
1810: hilp->hl_cmddev = 0;
1811: splx(s);
1812: }
1813: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.