Annotation of sys/arch/hppa/gsc/gsckbc.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: gsckbc.c,v 1.9 2006/12/17 21:27:20 miod Exp $ */
2: /*
3: * Copyright (c) 2003, Miodrag Vallat.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: *
15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF MIND,
21: * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25: */
26:
27: /*
28: * Derived from /sys/dev/ic/pckbd.c under the following terms:
29: * OpenBSD: pckbc.c,v 1.5 2002/06/09 00:58:03 nordin Exp
30: * NetBSD: pckbc.c,v 1.5 2000/06/09 04:58:35 soda Exp
31: */
32: /*
33: * Copyright (c) 1998
34: * Matthias Drochner. All rights reserved.
35: *
36: * Redistribution and use in source and binary forms, with or without
37: * modification, are permitted provided that the following conditions
38: * are met:
39: * 1. Redistributions of source code must retain the above copyright
40: * notice, this list of conditions and the following disclaimer.
41: * 2. Redistributions in binary form must reproduce the above copyright
42: * notice, this list of conditions and the following disclaimer in the
43: * documentation and/or other materials provided with the distribution.
44: * 3. All advertising materials mentioning features or use of this software
45: * must display the following acknowledgement:
46: * This product includes software developed for the NetBSD Project
47: * by Matthias Drochner.
48: * 4. The name of the author may not be used to endorse or promote products
49: * derived from this software without specific prior written permission.
50: *
51: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
52: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
53: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
54: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
55: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
56: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
60: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61: */
62:
63: /*
64: * Driver for the PS/2-like keyboard and mouse ports found on 712 and 715
65: * models, among others.
66: *
67: * Contrary to the ``pckbc'' port set found on other arches, the
68: * keyboard and mouse port are two separate entities on the snakes, and
69: * they are driven by a custom chip not 8042-compatible.
70: */
71:
72: #include <sys/param.h>
73: #include <sys/systm.h>
74: #include <sys/device.h>
75: #include <sys/kernel.h>
76: #include <sys/malloc.h>
77: #include <sys/proc.h>
78:
79: #include <machine/autoconf.h>
80: #include <machine/bus.h>
81: #include <machine/intr.h>
82: #include <machine/iomod.h>
83:
84: #include <hppa/dev/cpudevs.h>
85: #include <hppa/gsc/gscbusvar.h>
86:
87: #include <hppa/gsc/gsckbcreg.h>
88: #include <dev/ic/pckbcvar.h>
89:
90: #include <dev/pckbc/pckbdreg.h> /* constants for probe magic */
91: #include <hppa/gsc/gsckbdvar.h>
92:
93: int gsckbc_match(struct device *, void *, void *);
94: void gsckbc_attach(struct device *, struct device *, void *);
95:
96: struct gsckbc_softc {
97: struct pckbc_softc sc_pckbc;
98:
99: int sc_irq;
100: void *sc_ih;
101: int sc_type;
102: };
103:
104: struct cfattach gsckbc_ca = {
105: sizeof(struct gsckbc_softc), gsckbc_match, gsckbc_attach
106: };
107:
108: struct cfdriver gsckbc_cd = {
109: NULL, "gsckbc", DV_DULL
110: };
111:
112: void gsckbc_intr_establish(struct pckbc_softc *, pckbc_slot_t);
113:
114: #include "gsckbd.h"
115: #if (NGSCKBD > 0)
116: #include <dev/pckbc/pckbdvar.h>
117: #endif
118:
119: /* descriptor for one device command */
120: struct pckbc_devcmd {
121: TAILQ_ENTRY(pckbc_devcmd) next;
122: int flags;
123: #define KBC_CMDFLAG_SYNC 1 /* give descriptor back to caller */
124: #define KBC_CMDFLAG_SLOW 2
125: u_char cmd[4];
126: int cmdlen, cmdidx, retries;
127: u_char response[4];
128: int status, responselen, responseidx;
129: };
130:
131: /* data per slave device */
132: struct pckbc_slotdata {
133: int polling; /* don't read data port in interrupt handler */
134: TAILQ_HEAD(, pckbc_devcmd) cmdqueue; /* active commands */
135: TAILQ_HEAD(, pckbc_devcmd) freequeue; /* free commands */
136: #define NCMD 5
137: struct pckbc_devcmd cmds[NCMD];
138: };
139:
140: #define CMD_IN_QUEUE(q) (TAILQ_FIRST(&(q)->cmdqueue) != NULL)
141: /* Force polling mode behaviour for boot -a XXX */
142: #define IS_POLLING(q) ((q)->polling || cold)
143:
144: void pckbc_init_slotdata(struct pckbc_slotdata *);
145: int pckbc_attach_slot(struct pckbc_softc *, pckbc_slot_t);
146: int pckbc_submatch(struct device *, void *, void *);
147: int pckbcprint(void *, const char *);
148:
149: int pckbc_wait_output(bus_space_tag_t, bus_space_handle_t);
150: int pckbc_send_devcmd(struct pckbc_internal *, pckbc_slot_t,
151: u_char);
152: void pckbc_poll_cmd1(struct pckbc_internal *, pckbc_slot_t,
153: struct pckbc_devcmd *);
154:
155: void pckbc_cleanqueue(struct pckbc_slotdata *);
156: void pckbc_cleanup(void *);
157: int pckbc_cmdresponse(struct pckbc_internal *, pckbc_slot_t, u_char);
158: void pckbc_start(struct pckbc_internal *, pckbc_slot_t);
159: int gsckbcintr(void *);
160:
161: const char *pckbc_slot_names[] = { "kbd", "mouse" };
162:
163: #define KBC_DEVCMD_ACK 0xfa
164: #define KBC_DEVCMD_RESEND 0xfe
165:
166: #define KBD_DELAY DELAY(8)
167:
168: int
169: gsckbc_match(struct device *parent, void *match, void *aux)
170: {
171: struct gsc_attach_args *ga = aux;
172: bus_space_handle_t ioh;
173: u_int8_t rv;
174:
175: if (ga->ga_type.iodc_type != HPPA_TYPE_FIO ||
176: ga->ga_type.iodc_sv_model != HPPA_FIO_GPCIO)
177: return (0);
178:
179: /* Map the i/o space. */
180: if (bus_space_map(ga->ga_ca.ca_iot, ga->ga_ca.ca_hpa,
181: KBMAPSIZE, 0, &ioh))
182: return 0;
183:
184: rv = bus_space_read_1(ga->ga_ca.ca_iot, ioh, KBIDP);
185: bus_space_unmap(ga->ga_ca.ca_iot, ioh, KBMAPSIZE);
186:
187: if (rv == PCKBC_KBD_SLOT || rv == PCKBC_AUX_SLOT)
188: return (1); /* keyboard or mouse port */
189:
190: return (0);
191: }
192:
193: /*
194: * Attachment helper functions
195: */
196:
197: /* state machine values */
198: #define PROBE_SUCCESS 0
199: #define PROBE_TIMEOUT 1
200: #define PROBE_RETRANS 2
201: #define PROBE_NOACK 3
202:
203: int probe_readtmo(bus_space_tag_t iot, bus_space_handle_t ioh, int *reply);
204: int probe_readretry(bus_space_tag_t iot, bus_space_handle_t ioh, int *reply);
205: int probe_sendtmo(bus_space_tag_t iot, bus_space_handle_t ioh, int cmdbyte);
206: int probe_sendack(bus_space_tag_t iot, bus_space_handle_t ioh, int cmdbyte);
207: int probe_ident(bus_space_tag_t iot, bus_space_handle_t ioh);
208:
209: #define PROBE_TRIES 1000
210:
211: int
212: probe_readtmo(bus_space_tag_t iot, bus_space_handle_t ioh, int *reply)
213: {
214: int numtries = PROBE_TRIES;
215:
216: while (numtries--) {
217: if (bus_space_read_1(iot, ioh, KBSTATP) &
218: (KBS_DIB | KBS_TERR | KBS_PERR))
219: break;
220: DELAY(500);
221: }
222:
223: if (numtries <= 0)
224: return (PROBE_TIMEOUT);
225:
226: if (bus_space_read_1(iot, ioh, KBSTATP) & (KBS_PERR | KBS_TERR)) {
227: if (!(bus_space_read_1(iot, ioh, KBSTATP) & KBS_DIB)) {
228: bus_space_write_1(iot, ioh, KBRESETP, 0xff);
229: bus_space_write_1(iot, ioh, KBRESETP, 0x00);
230: bus_space_write_1(iot, ioh, KBCMDP,
231: bus_space_read_1(iot, ioh, KBCMDP) | KBCP_ENABLE);
232: return (PROBE_TIMEOUT);
233: }
234:
235: *reply = bus_space_read_1(iot, ioh, KBDATAP);
236: if (!(bus_space_read_1(iot, ioh, KBSTATP) & KBS_DIB)) {
237: bus_space_write_1(iot, ioh, KBRESETP, 0xff);
238: bus_space_write_1(iot, ioh, KBRESETP, 0x00);
239: bus_space_write_1(iot, ioh, KBCMDP,
240: bus_space_read_1(iot, ioh, KBCMDP) | KBCP_ENABLE);
241: if (probe_sendtmo(iot, ioh, KBR_RESEND))
242: return (PROBE_TIMEOUT);
243: else
244: return (PROBE_RETRANS);
245: } else
246: return (PROBE_SUCCESS);
247: } else {
248: *reply = bus_space_read_1(iot, ioh, KBDATAP);
249: return (PROBE_SUCCESS);
250: }
251: }
252:
253: int
254: probe_readretry(bus_space_tag_t iot, bus_space_handle_t ioh, int *reply)
255: {
256: int read_status;
257: int retrans = KB_MAX_RETRANS;
258:
259: do {
260: read_status = probe_readtmo(iot, ioh, reply);
261: } while ((read_status == PROBE_RETRANS) && retrans--);
262:
263: return (read_status);
264: }
265:
266: int
267: probe_sendtmo(bus_space_tag_t iot, bus_space_handle_t ioh, int cmdbyte)
268: {
269: int numtries = PROBE_TRIES;
270:
271: while (numtries--) {
272: if ((bus_space_read_1(iot, ioh, KBSTATP) & KBS_OCMD) == 0)
273: break;
274: DELAY(500);
275: }
276:
277: if (numtries <= 0)
278: return (1);
279:
280: bus_space_write_1(iot, ioh, KBDATAP, cmdbyte);
281: bus_space_write_1(iot, ioh, KBCMDP, KBCP_ENABLE);
282: return (0);
283: }
284:
285: int
286: probe_sendack(bus_space_tag_t iot, bus_space_handle_t ioh, int cmdbyte)
287: {
288: int retranscount;
289: int reply;
290:
291: for (retranscount = 0; retranscount < KB_MAX_RETRANS; retranscount++) {
292: if (probe_sendtmo(iot, ioh, cmdbyte))
293: return (PROBE_TIMEOUT);
294: if (probe_readretry(iot, ioh, &reply))
295: return (PROBE_TIMEOUT);
296:
297: switch (reply) {
298: case KBR_ACK:
299: return (PROBE_SUCCESS);
300: case KBR_RESEND:
301: break;
302: default:
303: return (PROBE_NOACK);
304: }
305: }
306: return (PROBE_TIMEOUT);
307:
308: }
309:
310: int
311: probe_ident(bus_space_tag_t iot, bus_space_handle_t ioh)
312: {
313: int status;
314:
315: bus_space_write_1(iot, ioh, KBRESETP, 0);
316: bus_space_write_1(iot, ioh, KBCMDP, KBCP_ENABLE);
317: DELAY(0x20000); /* XXX why 0x? */
318: bus_space_write_1(iot, ioh, KBCMDP, 0);
319: DELAY(20000);
320: bus_space_write_1(iot, ioh, KBRESETP, 0);
321: bus_space_write_1(iot, ioh, KBCMDP, KBCP_DIAG);
322: DELAY(20000);
323:
324: status = probe_sendack(iot, ioh, KBC_DISABLE);
325: switch (status) {
326: case PROBE_TIMEOUT:
327: if (bus_space_read_1(iot, ioh, KBSTATP) & KBS_OCMD) {
328: bus_space_write_1(iot, ioh, KBRESETP, 0);
329: bus_space_write_1(iot, ioh, KBCMDP, KBCP_ENABLE);
330: }
331: return (-1);
332: case PROBE_NOACK:
333: return (-1);
334: }
335:
336: if (probe_sendack(iot, ioh, KBC_ID) != PROBE_SUCCESS)
337: return (-1);
338:
339: if (probe_readretry(iot, ioh, &status))
340: return (-1);
341:
342: switch (status) {
343: case KBR_MOUSE_ID:
344: return PCKBC_AUX_SLOT;
345: case KBR_KBD_ID1:
346: if (probe_readretry(iot, ioh, &status))
347: return (-1);
348: if (status == KBR_KBD_ID2) {
349: if (probe_sendack(iot, ioh, KBC_ENABLE) ==
350: PROBE_TIMEOUT) {
351: bus_space_write_1(iot, ioh, KBRESETP, 0);
352: bus_space_write_1(iot, ioh, KBCMDP,
353: KBCP_ENABLE);
354: }
355: return PCKBC_KBD_SLOT;
356: }
357: }
358: return (-1);
359: }
360:
361: void
362: gsckbc_attach(struct device *parent, struct device *self, void *aux)
363: {
364: struct gsc_attach_args *ga = aux;
365: struct gsckbc_softc *gsc = (void *)self;
366: struct pckbc_softc *sc = &gsc->sc_pckbc;
367: struct pckbc_internal *t;
368: bus_space_tag_t iot;
369: bus_space_handle_t ioh;
370: int ident;
371:
372: iot = ga->ga_ca.ca_iot;
373: gsc->sc_irq = ga->ga_ca.ca_irq;
374:
375: if (bus_space_map(iot, ga->ga_ca.ca_hpa, KBMAPSIZE, 0, &ioh))
376: panic("gsckbc_attach: couldn't map port");
377:
378: gsc->sc_type = bus_space_read_1(iot, ioh, KBIDP);
379:
380: switch (gsc->sc_type) {
381: case PCKBC_KBD_SLOT:
382: case PCKBC_AUX_SLOT:
383: break;
384: default:
385: printf(": unknown port type %x\n", gsc->sc_type);
386: /* play nice and don't really attach. */
387: bus_space_unmap(iot, ioh, KBMAPSIZE);
388: return;
389: }
390:
391: printf("\n");
392:
393: sc->intr_establish = gsckbc_intr_establish;
394:
395: t = malloc(sizeof(struct pckbc_internal), M_DEVBUF, M_WAITOK);
396: bzero(t, sizeof(struct pckbc_internal));
397: t->t_iot = iot;
398: /* XXX it does not make sense to only map two ports here */
399: t->t_ioh_d = t->t_ioh_c = ioh;
400: t->t_addr = ga->ga_ca.ca_hpa;
401: t->t_sc = sc;
402: timeout_set(&t->t_cleanup, pckbc_cleanup, t);
403: sc->id = t;
404:
405: /*
406: * Reset port and probe device, if plugged
407: */
408: ident = probe_ident(iot, ioh);
409: if (ident != gsc->sc_type) {
410: /* don't whine for unplugged ports */
411: if (ident != -1)
412: printf("%s: expecting device type %d, got %d\n",
413: sc->sc_dv.dv_xname, gsc->sc_type, ident);
414: } else {
415: #if (NGSCKBD > 0)
416: if (gsc->sc_type == PCKBC_KBD_SLOT &&
417: ga->ga_dp.dp_mod == PAGE0->mem_kbd.pz_dp.dp_mod &&
418: bcmp(ga->ga_dp.dp_bc, PAGE0->mem_kbd.pz_dp.dp_bc, 6) == 0)
419: gsckbd_cnattach(t, PCKBC_KBD_SLOT);
420: #endif
421: pckbc_attach_slot(sc, gsc->sc_type);
422: }
423: }
424:
425: void
426: gsckbc_intr_establish(struct pckbc_softc *sc, pckbc_slot_t slot)
427: {
428: struct gsckbc_softc *gsc = (void *)sc;
429:
430: gsc->sc_ih = gsc_intr_establish((struct gsc_softc *)sc->sc_dv.dv_parent,
431: gsc->sc_irq, IPL_TTY, gsckbcintr, sc, sc->sc_dv.dv_xname);
432: }
433:
434: /*
435: * pckbc-like interfaces
436: */
437:
438: int
439: pckbc_wait_output(iot, ioh)
440: bus_space_tag_t iot;
441: bus_space_handle_t ioh;
442: {
443: u_int i;
444:
445: for (i = 100000; i; i--) {
446: if ((bus_space_read_1(iot, ioh, KBSTATP) & KBS_OCMD)) {
447: KBD_DELAY;
448: } else
449: return (1);
450: }
451: return (0);
452: }
453:
454: int
455: pckbc_send_cmd(iot, ioh, val)
456: bus_space_tag_t iot;
457: bus_space_handle_t ioh;
458: u_char val;
459: {
460: if (!pckbc_wait_output(iot, ioh))
461: return (0);
462: bus_space_write_1(iot, ioh, KBOUTP, val);
463: bus_space_write_1(iot, ioh, KBCMDP, KBCP_ENABLE);
464: return (1);
465: }
466:
467: /* XXX logic */
468: int
469: pckbc_poll_data1(iot, ioh, ioh_c, slot, checkaux)
470: bus_space_tag_t iot;
471: bus_space_handle_t ioh, ioh_c;
472: pckbc_slot_t slot;
473: int checkaux; /* ignored on hppa */
474: {
475: int i;
476: u_char stat;
477:
478: /* if 1 port read takes 1us (?), this polls for 100ms */
479: for (i = 100000; i; i--) {
480: stat = bus_space_read_1(iot, ioh, KBSTATP);
481: if (stat & KBS_DIB) {
482: KBD_DELAY;
483: return bus_space_read_1(iot, ioh, KBDATAP);
484: }
485: }
486: return (-1);
487: }
488:
489: int
490: pckbc_send_devcmd(t, slot, val)
491: struct pckbc_internal *t;
492: pckbc_slot_t slot;
493: u_char val;
494: {
495: return pckbc_send_cmd(t->t_iot, t->t_ioh_d, val);
496: }
497:
498: int
499: pckbc_submatch(parent, match, aux)
500: struct device *parent;
501: void *match;
502: void *aux;
503: {
504: struct cfdata *cf = match;
505: struct pckbc_attach_args *pa = aux;
506:
507: if (cf->cf_loc[PCKBCCF_SLOT] != PCKBCCF_SLOT_DEFAULT &&
508: cf->cf_loc[PCKBCCF_SLOT] != pa->pa_slot)
509: return (0);
510: return ((*cf->cf_attach->ca_match)(parent, cf, aux));
511: }
512:
513: int
514: pckbc_attach_slot(sc, slot)
515: struct pckbc_softc *sc;
516: pckbc_slot_t slot;
517: {
518: struct pckbc_internal *t = sc->id;
519: struct pckbc_attach_args pa;
520: int found;
521:
522: pa.pa_tag = t;
523: pa.pa_slot = slot;
524: found = (config_found_sm((struct device *)sc, &pa,
525: pckbcprint, pckbc_submatch) != NULL);
526:
527: if (found && !t->t_slotdata[slot]) {
528: t->t_slotdata[slot] = malloc(sizeof(struct pckbc_slotdata),
529: M_DEVBUF, M_NOWAIT);
530: if (t->t_slotdata[slot] == NULL)
531: return 0;
532: pckbc_init_slotdata(t->t_slotdata[slot]);
533: }
534: return (found);
535: }
536:
537: int
538: pckbcprint(aux, pnp)
539: void *aux;
540: const char *pnp;
541: {
542: #if 0 /* hppa having devices for each slot, this is barely useful */
543: struct pckbc_attach_args *pa = aux;
544:
545: if (!pnp)
546: printf(" (%s slot)", pckbc_slot_names[pa->pa_slot]);
547: #endif
548: return (QUIET);
549: }
550:
551: void
552: pckbc_init_slotdata(q)
553: struct pckbc_slotdata *q;
554: {
555: int i;
556: TAILQ_INIT(&q->cmdqueue);
557: TAILQ_INIT(&q->freequeue);
558:
559: for (i = 0; i < NCMD; i++) {
560: TAILQ_INSERT_TAIL(&q->freequeue, &(q->cmds[i]), next);
561: }
562: q->polling = 0;
563: }
564:
565: void
566: pckbc_flush(self, slot)
567: pckbc_tag_t self;
568: pckbc_slot_t slot;
569: {
570: struct pckbc_internal *t = self;
571:
572: pckbc_poll_data1(t->t_iot, t->t_ioh_d, t->t_ioh_d, slot, 0);
573: }
574:
575: int
576: pckbc_poll_data(self, slot)
577: pckbc_tag_t self;
578: pckbc_slot_t slot;
579: {
580: struct pckbc_internal *t = self;
581: struct pckbc_slotdata *q = t->t_slotdata[slot];
582: int c;
583:
584: c = pckbc_poll_data1(t->t_iot, t->t_ioh_d, t->t_ioh_d, slot, 0);
585: if (c != -1 && q && CMD_IN_QUEUE(q)) {
586: /* we jumped into a running command - try to
587: deliver the response */
588: if (pckbc_cmdresponse(t, slot, c))
589: return (-1);
590: }
591: return (c);
592: }
593:
594: void
595: pckbc_slot_enable(self, slot, on)
596: pckbc_tag_t self;
597: pckbc_slot_t slot;
598: int on;
599: {
600: /* can't enable slots here as they are different devices */
601: }
602:
603: void
604: pckbc_set_poll(self, slot, on)
605: pckbc_tag_t self;
606: pckbc_slot_t slot;
607: int on;
608: {
609: struct pckbc_internal *t = (struct pckbc_internal *)self;
610:
611: t->t_slotdata[slot]->polling = on;
612:
613: if (!on) {
614: int s;
615:
616: /*
617: * If disabling polling on a device that's been configured,
618: * make sure there are no bytes left in the FIFO, holding up
619: * the interrupt line. Otherwise we won't get any further
620: * interrupts.
621: */
622: if (t->t_sc) {
623: s = spltty();
624: gsckbcintr(t->t_sc);
625: splx(s);
626: }
627: }
628: }
629:
630: /*
631: * Pass command to device, poll for ACK and data.
632: * to be called at spltty()
633: */
634: void
635: pckbc_poll_cmd1(t, slot, cmd)
636: struct pckbc_internal *t;
637: pckbc_slot_t slot;
638: struct pckbc_devcmd *cmd;
639: {
640: bus_space_tag_t iot = t->t_iot;
641: bus_space_handle_t ioh = t->t_ioh_d;
642: int i, c = 0;
643:
644: while (cmd->cmdidx < cmd->cmdlen) {
645: if (!pckbc_send_devcmd(t, slot, cmd->cmd[cmd->cmdidx])) {
646: printf("pckbc_cmd: send error\n");
647: cmd->status = EIO;
648: return;
649: }
650: for (i = 10; i; i--) { /* 1s ??? */
651: c = pckbc_poll_data1(iot, ioh, ioh, slot, 0);
652: if (c != -1)
653: break;
654: }
655:
656: if (c == KBC_DEVCMD_ACK) {
657: cmd->cmdidx++;
658: continue;
659: }
660: if (c == KBC_DEVCMD_RESEND) {
661: #ifdef PCKBCDEBUG
662: printf("pckbc_cmd: RESEND\n");
663: #endif
664: if (cmd->retries++ < KB_MAX_RETRANS)
665: continue;
666: else {
667: #ifdef PCKBCDEBUG
668: printf("pckbc: cmd failed\n");
669: #endif
670: cmd->status = EIO;
671: return;
672: }
673: }
674: if (c == -1) {
675: #ifdef PCKBCDEBUG
676: printf("pckbc_cmd: timeout\n");
677: #endif
678: cmd->status = EIO;
679: return;
680: }
681: #ifdef PCKBCDEBUG
682: printf("pckbc_cmd: lost 0x%x\n", c);
683: #endif
684: }
685:
686: while (cmd->responseidx < cmd->responselen) {
687: if (cmd->flags & KBC_CMDFLAG_SLOW)
688: i = 100; /* 10s ??? */
689: else
690: i = 10; /* 1s ??? */
691: while (i--) {
692: c = pckbc_poll_data1(iot, ioh, ioh, slot, 0);
693: if (c != -1)
694: break;
695: }
696: if (c == -1) {
697: #ifdef PCKBCDEBUG
698: printf("pckbc_cmd: no data\n");
699: #endif
700: cmd->status = ETIMEDOUT;
701: return;
702: } else
703: cmd->response[cmd->responseidx++] = c;
704: }
705: }
706:
707: /* for use in autoconfiguration */
708: int
709: pckbc_poll_cmd(self, slot, cmd, len, responselen, respbuf, slow)
710: pckbc_tag_t self;
711: pckbc_slot_t slot;
712: u_char *cmd;
713: int len, responselen;
714: u_char *respbuf;
715: int slow;
716: {
717: struct pckbc_devcmd nc;
718:
719: if ((len > 4) || (responselen > 4))
720: return (EINVAL);
721:
722: bzero(&nc, sizeof(nc));
723: bcopy(cmd, nc.cmd, len);
724: nc.cmdlen = len;
725: nc.responselen = responselen;
726: nc.flags = (slow ? KBC_CMDFLAG_SLOW : 0);
727:
728: pckbc_poll_cmd1(self, slot, &nc);
729:
730: if (nc.status == 0 && respbuf)
731: bcopy(nc.response, respbuf, responselen);
732:
733: return (nc.status);
734: }
735:
736: /*
737: * Clean up a command queue, throw away everything.
738: */
739: void
740: pckbc_cleanqueue(q)
741: struct pckbc_slotdata *q;
742: {
743: struct pckbc_devcmd *cmd;
744: #ifdef PCKBCDEBUG
745: int i;
746: #endif
747:
748: while ((cmd = TAILQ_FIRST(&q->cmdqueue))) {
749: TAILQ_REMOVE(&q->cmdqueue, cmd, next);
750: #ifdef PCKBCDEBUG
751: printf("pckbc_cleanqueue: removing");
752: for (i = 0; i < cmd->cmdlen; i++)
753: printf(" %02x", cmd->cmd[i]);
754: printf("\n");
755: #endif
756: TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
757: }
758: }
759:
760: /*
761: * Timeout error handler: clean queues and data port.
762: * XXX could be less invasive.
763: */
764: void
765: pckbc_cleanup(self)
766: void *self;
767: {
768: struct pckbc_internal *t = self;
769: int s;
770:
771: printf("pckbc: command timeout\n");
772:
773: s = spltty();
774:
775: if (t->t_slotdata[PCKBC_KBD_SLOT])
776: pckbc_cleanqueue(t->t_slotdata[PCKBC_KBD_SLOT]);
777: if (t->t_slotdata[PCKBC_AUX_SLOT])
778: pckbc_cleanqueue(t->t_slotdata[PCKBC_AUX_SLOT]);
779:
780: while (bus_space_read_1(t->t_iot, t->t_ioh_d, KBSTATP) & KBS_DIB) {
781: KBD_DELAY;
782: (void) bus_space_read_1(t->t_iot, t->t_ioh_d, KBDATAP);
783: }
784:
785: /* reset KBC? */
786:
787: splx(s);
788: }
789:
790: /*
791: * Pass command to device during normal operation.
792: * to be called at spltty()
793: */
794: void
795: pckbc_start(t, slot)
796: struct pckbc_internal *t;
797: pckbc_slot_t slot;
798: {
799: struct pckbc_slotdata *q = t->t_slotdata[slot];
800: struct pckbc_devcmd *cmd = TAILQ_FIRST(&q->cmdqueue);
801:
802: if (IS_POLLING(q)) {
803: do {
804: pckbc_poll_cmd1(t, slot, cmd);
805: if (cmd->status)
806: printf("pckbc_start: command error\n");
807:
808: TAILQ_REMOVE(&q->cmdqueue, cmd, next);
809: if (cmd->flags & KBC_CMDFLAG_SYNC)
810: wakeup(cmd);
811: else {
812: timeout_del(&t->t_cleanup);
813: TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
814: }
815: cmd = TAILQ_FIRST(&q->cmdqueue);
816: } while (cmd);
817: return;
818: }
819:
820: if (!pckbc_send_devcmd(t, slot, cmd->cmd[cmd->cmdidx])) {
821: printf("pckbc_start: send error\n");
822: /* XXX what now? */
823: return;
824: }
825: }
826:
827: /*
828: * Handle command responses coming in asynchronously,
829: * return nonzero if valid response.
830: * to be called at spltty()
831: */
832: int
833: pckbc_cmdresponse(t, slot, data)
834: struct pckbc_internal *t;
835: pckbc_slot_t slot;
836: u_char data;
837: {
838: struct pckbc_slotdata *q = t->t_slotdata[slot];
839: struct pckbc_devcmd *cmd = TAILQ_FIRST(&q->cmdqueue);
840:
841: #ifdef DIAGNOSTIC
842: if (!cmd)
843: panic("pckbc_cmdresponse: no active command");
844: #endif
845: if (cmd->cmdidx < cmd->cmdlen) {
846: if (data != KBC_DEVCMD_ACK && data != KBC_DEVCMD_RESEND)
847: return (0);
848:
849: if (data == KBC_DEVCMD_RESEND) {
850: if (cmd->retries++ < KB_MAX_RETRANS) {
851: /* try again last command */
852: goto restart;
853: } else {
854: #ifdef PCKBCDEBUG
855: printf("pckbc: cmd failed\n");
856: #endif
857: cmd->status = EIO;
858: /* dequeue */
859: }
860: } else {
861: if (++cmd->cmdidx < cmd->cmdlen)
862: goto restart;
863: if (cmd->responselen)
864: return (1);
865: /* else dequeue */
866: }
867: } else if (cmd->responseidx < cmd->responselen) {
868: cmd->response[cmd->responseidx++] = data;
869: if (cmd->responseidx < cmd->responselen)
870: return (1);
871: /* else dequeue */
872: } else
873: return (0);
874:
875: /* dequeue: */
876: TAILQ_REMOVE(&q->cmdqueue, cmd, next);
877: if (cmd->flags & KBC_CMDFLAG_SYNC)
878: wakeup(cmd);
879: else {
880: timeout_del(&t->t_cleanup);
881: TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
882: }
883: if (!CMD_IN_QUEUE(q))
884: return (1);
885: restart:
886: pckbc_start(t, slot);
887: return (1);
888: }
889:
890: /*
891: * Put command into the device's command queue, return zero or errno.
892: */
893: int
894: pckbc_enqueue_cmd(self, slot, cmd, len, responselen, sync, respbuf)
895: pckbc_tag_t self;
896: pckbc_slot_t slot;
897: u_char *cmd;
898: int len, responselen, sync;
899: u_char *respbuf;
900: {
901: struct pckbc_internal *t = self;
902: struct pckbc_slotdata *q = t->t_slotdata[slot];
903: struct pckbc_devcmd *nc;
904: int s, isactive, res = 0;
905:
906: if ((len > 4) || (responselen > 4))
907: return (EINVAL);
908: s = spltty();
909: nc = TAILQ_FIRST(&q->freequeue);
910: if (nc) {
911: TAILQ_REMOVE(&q->freequeue, nc, next);
912: }
913: splx(s);
914: if (!nc)
915: return (ENOMEM);
916:
917: bzero(nc, sizeof(*nc));
918: bcopy(cmd, nc->cmd, len);
919: nc->cmdlen = len;
920: nc->responselen = responselen;
921: nc->flags = (sync ? KBC_CMDFLAG_SYNC : 0);
922:
923: s = spltty();
924:
925: if (IS_POLLING(q) && sync) {
926: /*
927: * XXX We should poll until the queue is empty.
928: * But we don't come here normally, so make
929: * it simple and throw away everything.
930: */
931: pckbc_cleanqueue(q);
932: }
933:
934: isactive = CMD_IN_QUEUE(q);
935: TAILQ_INSERT_TAIL(&q->cmdqueue, nc, next);
936: if (!isactive)
937: pckbc_start(t, slot);
938:
939: if (IS_POLLING(q))
940: res = (sync ? nc->status : 0);
941: else if (sync) {
942: if ((res = tsleep(nc, 0, "kbccmd", 1*hz))) {
943: TAILQ_REMOVE(&q->cmdqueue, nc, next);
944: pckbc_cleanup(t);
945: } else
946: res = nc->status;
947: } else
948: timeout_add(&t->t_cleanup, hz);
949:
950: if (sync) {
951: if (respbuf)
952: bcopy(nc->response, respbuf, responselen);
953: TAILQ_INSERT_TAIL(&q->freequeue, nc, next);
954: }
955:
956: splx(s);
957:
958: return (res);
959: }
960:
961: void
962: pckbc_set_inputhandler(self, slot, func, arg, name)
963: pckbc_tag_t self;
964: pckbc_slot_t slot;
965: pckbc_inputfcn func;
966: void *arg;
967: char *name;
968: {
969: struct pckbc_internal *t = (struct pckbc_internal *)self;
970: struct pckbc_softc *sc = t->t_sc;
971:
972: if (slot >= PCKBC_NSLOTS)
973: panic("pckbc_set_inputhandler: bad slot %d", slot);
974:
975: (*sc->intr_establish)(sc, slot);
976:
977: sc->inputhandler[slot] = func;
978: sc->inputarg[slot] = arg;
979: sc->subname[slot] = name;
980: }
981:
982: int
983: gsckbcintr(void *v)
984: {
985: struct gsckbc_softc *gsc = v;
986: struct pckbc_softc *sc = (struct pckbc_softc *)gsc;
987: struct pckbc_internal *t = sc->id;
988: pckbc_slot_t slot;
989: struct pckbc_slotdata *q;
990: int served = 0, data;
991:
992: while (bus_space_read_1(t->t_iot, t->t_ioh_d, KBSTATP) & KBS_DIB) {
993: served = 1;
994:
995: slot = gsc->sc_type;
996: q = t->t_slotdata[slot];
997:
998: if (!q) {
999: /* XXX do something for live insertion? */
1000: #ifdef PCKBCDEBUG
1001: printf("gsckbcintr: no dev for slot %d\n", slot);
1002: #endif
1003: KBD_DELAY;
1004: (void) bus_space_read_1(t->t_iot, t->t_ioh_d, KBDATAP);
1005: continue;
1006: }
1007:
1008: if (IS_POLLING(q))
1009: break; /* pckbc_poll_data() will get it */
1010:
1011: KBD_DELAY;
1012: data = bus_space_read_1(t->t_iot, t->t_ioh_d, KBDATAP);
1013:
1014: if (CMD_IN_QUEUE(q) && pckbc_cmdresponse(t, slot, data))
1015: continue;
1016:
1017: if (sc->inputhandler[slot])
1018: (*sc->inputhandler[slot])(sc->inputarg[slot], data);
1019: #ifdef PCKBCDEBUG
1020: else
1021: printf("gsckbcintr: slot %d lost %d\n", slot, data);
1022: #endif
1023: }
1024:
1025: return (served);
1026: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to gsckbc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / gsc