root/dev/ic/pckbc.c

DEFINITIONS

1. pckbc_wait_output
2. pckbc_send_cmd
3. pckbc_poll_data1
4. pckbc_get8042cmd
5. pckbc_put8042cmd
6. pckbc_send_devcmd
7. pckbc_is_console
8. pckbc_submatch
9. pckbc_attach_slot
10. pckbc_attach
11. pckbcprint
12. pckbc_init_slotdata
13. pckbc_flush
14. pckbc_poll_data
15. pckbc_xt_translation
16. pckbc_slot_enable
17. pckbc_set_poll
18. pckbc_poll_cmd1
19. pckbc_poll_cmd
20. pckbc_cleanqueue
21. pckbc_cleanup
22. pckbc_start
23. pckbc_cmdresponse
24. pckbc_enqueue_cmd
25. pckbc_set_inputhandler
26. pckbc_poll
27. pckbcintr
28. pckbcintr_internal
29. pckbc_cnattach

    1 /* $OpenBSD: pckbc.c,v 1.14 2007/01/31 14:38:54 mickey Exp $ */
    2 /* $NetBSD: pckbc.c,v 1.5 2000/06/09 04:58:35 soda Exp $ */
    4 /*
    5  * Copyright (c) 1998
    6  *      Matthias Drochner.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   27  */
   29 #include <sys/param.h>
   30 #include <sys/systm.h>
   31 #include <sys/timeout.h>
   32 #include <sys/kernel.h>
   33 #include <sys/proc.h>
   34 #include <sys/device.h>
   35 #include <sys/malloc.h>
   36 #include <sys/errno.h>
   37 #include <sys/queue.h>
   38 #include <sys/lock.h>
   40 #include <machine/bus.h>
   42 #include <dev/ic/i8042reg.h>
   43 #include <dev/ic/pckbcvar.h>
   45 #include "pckbd.h"
   47 #if (NPCKBD > 0)
   48 #include <dev/pckbc/pckbdvar.h>
   49 #endif
   51 /* descriptor for one device command */
   52 struct pckbc_devcmd {
TAILQ_ENTRY(pckbc_devcmd) next;
   54         int flags;
   55 #define KBC_CMDFLAG_SYNC 1 /* give descriptor back to caller */
   56 #define KBC_CMDFLAG_SLOW 2
u_char cmd[4];
   58         int cmdlen, cmdidx, retries;
u_char response[4];
   60         int status, responselen, responseidx;
   61 };
   63 /* data per slave device */
   64 struct pckbc_slotdata {
   65         int polling; /* don't read data port in interrupt handler */
TAILQ_HEAD(, pckbc_devcmd) cmdqueue; /* active commands */
TAILQ_HEAD(, pckbc_devcmd) freequeue; /* free commands */
   68 #define NCMD 5
   69         struct pckbc_devcmd cmds[NCMD];
   70 };
   72 #define CMD_IN_QUEUE(q) (TAILQ_FIRST(&(q)->cmdqueue) != NULL)
   74 void pckbc_init_slotdata(struct pckbc_slotdata *);
   75 int pckbc_attach_slot(struct pckbc_softc *, pckbc_slot_t);
   76 int pckbc_submatch(struct device *, void *, void *);
   77 int pckbcprint(void *, const char *);
   79 struct pckbc_internal pckbc_consdata;
   80 int pckbc_console_attached;
   82 static int pckbc_console;
   83 static struct pckbc_slotdata pckbc_cons_slotdata;
   85 static int pckbc_wait_output(bus_space_tag_t, bus_space_handle_t);
   87 static int pckbc_get8042cmd(struct pckbc_internal *);
   88 static int pckbc_put8042cmd(struct pckbc_internal *);
   89 static int pckbc_send_devcmd(struct pckbc_internal *, pckbc_slot_t,
u_char);
   91 static void pckbc_poll_cmd1(struct pckbc_internal *, pckbc_slot_t,
   92                                  struct pckbc_devcmd *);
   94 void pckbc_cleanqueue(struct pckbc_slotdata *);
   95 void pckbc_cleanup(void *);
   96 void pckbc_poll(void *);
   97 int pckbc_cmdresponse(struct pckbc_internal *, pckbc_slot_t, u_char);
   98 void pckbc_start(struct pckbc_internal *, pckbc_slot_t);
   99 int pckbcintr_internal(struct pckbc_internal *, struct pckbc_softc *);
  101 const char *pckbc_slot_names[] = { "kbd", "aux" };
  103 #define KBC_DEVCMD_ACK 0xfa
  104 #define KBC_DEVCMD_RESEND 0xfe
  106 #define KBD_DELAY       DELAY(8)
  108 static inline int
pckbc_wait_output(iot, ioh_c)
bus_space_tag_t iot;
bus_space_handle_t ioh_c;
  112 {
u_int i;
  115         for (i = 100000; i; i--)
  116                 if (!(bus_space_read_1(iot, ioh_c, 0) & KBS_IBF)) {
KBD_DELAY;
  118                         return (1);
  119                 }
  120         return (0);
  121 }
  123 int
pckbc_send_cmd(iot, ioh_c, val)
bus_space_tag_t iot;
bus_space_handle_t ioh_c;
u_char val;
  128 {
  129         if (!pckbc_wait_output(iot, ioh_c))
  130                 return (0);
bus_space_write_1(iot, ioh_c, 0, val);
  132         return (1);
  133 }
  135 int
pckbc_poll_data1(iot, ioh_d, ioh_c, slot, checkaux)
bus_space_tag_t iot;
bus_space_handle_t ioh_d, ioh_c;
pckbc_slot_t slot;
  140         int checkaux;
  141 {
  142         int i;
u_char stat;
  145         /* if 1 port read takes 1us (?), this polls for 100ms */
  146         for (i = 100000; i; i--) {
stat = bus_space_read_1(iot, ioh_c, 0);
  148                 if (stat & KBS_DIB) {
  149                         register u_char c;
KBD_DELAY;
c = bus_space_read_1(iot, ioh_d, 0);
  153                         if (checkaux && (stat & 0x20)) { /* aux data */
  154                                 if (slot != PCKBC_AUX_SLOT) {
  155 #ifdef PCKBCDEBUG
printf("lost aux 0x%x\n", c);
  157 #endif
  158                                         continue;
  159                                 }
  160                         } else {
  161                                 if (slot == PCKBC_AUX_SLOT) {
  162 #ifdef PCKBCDEBUG
printf("lost kbd 0x%x\n", c);
  164 #endif
  165                                         continue;
  166                                 }
  167                         }
  168                         return (c);
  169                 }
  170         }
  171         return (-1);
  172 }
  174 /*
  175  * Get the current command byte.
  176  */
  177 static int
pckbc_get8042cmd(t)
  179         struct pckbc_internal *t;
  180 {
bus_space_tag_t iot = t->t_iot;
bus_space_handle_t ioh_d = t->t_ioh_d;
bus_space_handle_t ioh_c = t->t_ioh_c;
  184         int data;
  186         if (!pckbc_send_cmd(iot, ioh_c, K_RDCMDBYTE))
  187                 return (0);
data = pckbc_poll_data1(iot, ioh_d, ioh_c, PCKBC_KBD_SLOT,
t->t_haveaux);
  190         if (data == -1)
  191                 return (0);
t->t_cmdbyte = data;
  193         return (1);
  194 }
  196 /*
  197  * Pass command byte to keyboard controller (8042).
  198  */
  199 static int
pckbc_put8042cmd(t)
  201         struct pckbc_internal *t;
  202 {
bus_space_tag_t iot = t->t_iot;
bus_space_handle_t ioh_d = t->t_ioh_d;
bus_space_handle_t ioh_c = t->t_ioh_c;
  207         if (!pckbc_send_cmd(iot, ioh_c, K_LDCMDBYTE))
  208                 return (0);
  209         if (!pckbc_wait_output(iot, ioh_c))
  210                 return (0);
bus_space_write_1(iot, ioh_d, 0, t->t_cmdbyte);
  212         return (1);
  213 }
  215 static int
pckbc_send_devcmd(t, slot, val)
  217         struct pckbc_internal *t;
pckbc_slot_t slot;
u_char val;
  220 {
bus_space_tag_t iot = t->t_iot;
bus_space_handle_t ioh_d = t->t_ioh_d;
bus_space_handle_t ioh_c = t->t_ioh_c;
  225         if (slot == PCKBC_AUX_SLOT) {
  226                 if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXWRITE))
  227                         return (0);
  228         }
  229         if (!pckbc_wait_output(iot, ioh_c))
  230                 return (0);
bus_space_write_1(iot, ioh_d, 0, val);
  232         return (1);
  233 }
  235 int
pckbc_is_console(iot, addr)
bus_space_tag_t iot;
bus_addr_t addr;
  239 {
  240         if (pckbc_console && !pckbc_console_attached &&
pckbc_consdata.t_iot == iot &&
pckbc_consdata.t_addr == addr)
  243                 return (1);
  244         return (0);
  245 }
  247 int
pckbc_submatch(parent, match, aux)
  249         struct device *parent;
  250         void *match;
  251         void *aux;
  252 {
  253         struct cfdata *cf = match;
  254         struct pckbc_attach_args *pa = aux;
  256         if (cf->cf_loc[PCKBCCF_SLOT] != PCKBCCF_SLOT_DEFAULT &&
cf->cf_loc[PCKBCCF_SLOT] != pa->pa_slot)
  258                 return (0);
  259         return ((*cf->cf_attach->ca_match)(parent, cf, aux));
  260 }
  262 int
pckbc_attach_slot(sc, slot)
  264         struct pckbc_softc *sc;
pckbc_slot_t slot;
  266 {
  267         struct pckbc_internal *t = sc->id;
  268         struct pckbc_attach_args pa;
  269         int found;
pa.pa_tag = t;
pa.pa_slot = slot;
found = (config_found_sm((struct device *)sc, &pa,
pckbcprint, pckbc_submatch) != NULL);
  276         if (found && !t->t_slotdata[slot]) {
t->t_slotdata[slot] = malloc(sizeof(struct pckbc_slotdata),
M_DEVBUF, M_NOWAIT);
  279                 if (t->t_slotdata[slot] == NULL)
  280                         return 0;
pckbc_init_slotdata(t->t_slotdata[slot]);
  282         }
  283         return (found);
  284 }
  286 void
pckbc_attach(sc)
  288         struct pckbc_softc *sc;
  289 {
  290         struct pckbc_internal *t;
bus_space_tag_t iot;
bus_space_handle_t ioh_d, ioh_c;
  293         int res;
u_char cmdbits = 0;
t = sc->id;
iot = t->t_iot;
ioh_d = t->t_ioh_d;
ioh_c = t->t_ioh_c;
  301         if (pckbc_console == 0) {
timeout_set(&t->t_cleanup, pckbc_cleanup, t);
timeout_set(&t->t_poll, pckbc_poll, t);
  304         }
  306         /* flush */
  307         (void) pckbc_poll_data1(iot, ioh_d, ioh_c, PCKBC_KBD_SLOT, 0);
  309         /* set initial cmd byte */
  310         if (!pckbc_put8042cmd(t)) {
printf("kbc: cmd word write error\n");
  312                 return;
  313         }
  315 /*
  316  * XXX Don't check the keyboard port. There are broken keyboard controllers
  317  * which don't pass the test but work normally otherwise.
  318  */
  319 #if 0
  320         /*
  321          * check kbd port ok
  322          */
  323         if (!pckbc_send_cmd(iot, ioh_c, KBC_KBDTEST))
  324                 return;
res = pckbc_poll_data1(iot, ioh_d, ioh_c, PCKBC_KBD_SLOT, 0);
  327         /*
  328          * Normally, we should get a "0" here.
  329          * But there are keyboard controllers behaving differently.
  330          */
  331         if (res == 0 || res == 0xfa || res == 0x01 || res == 0xab) {
  332 #ifdef PCKBCDEBUG
  333                 if (res != 0)
printf("kbc: returned %x on kbd slot test\n", res);
  335 #endif
  336                 if (pckbc_attach_slot(sc, PCKBC_KBD_SLOT))
cmdbits |= KC8_KENABLE;
  338         } else {
printf("kbc: kbd port test: %x\n", res);
  340                 return;
  341         }
  342 #else
  343         if (pckbc_attach_slot(sc, PCKBC_KBD_SLOT))
cmdbits |= KC8_KENABLE;
  345 #endif /* 0 */
  347         /*
  348          * Check aux port ok.
  349          * Avoid KBC_AUXTEST because it hangs some older controllers
  350          * (eg UMC880?).
  351          */
  352         if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXECHO)) {
printf("kbc: aux echo error 1\n");
  354                 goto nomouse;
  355         }
  356         if (!pckbc_wait_output(iot, ioh_c)) {
printf("kbc: aux echo error 2\n");
  358                 goto nomouse;
  359         }
bus_space_write_1(iot, ioh_d, 0, 0x5a); /* a random value */
res = pckbc_poll_data1(iot, ioh_d, ioh_c, PCKBC_AUX_SLOT, 1);
  362         if (res == -1) {
  363                 /* Read of aux echo timed out, try again */
  364                 if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXWRITE))
  365                         goto nomouse;
  366                 if (!pckbc_wait_output(iot, ioh_c))
  367                         goto nomouse;
bus_space_write_1(iot, ioh_d, 0, 0x5a);
res = pckbc_poll_data1(iot, ioh_d, ioh_c, PCKBC_AUX_SLOT, 1);
  370 #ifdef PCKBCDEBUG
printf("kbc: aux echo: %x\n", res);
  372 #endif
  373         }
  374         if (res != -1) {
  375                 /*
  376                  * In most cases, the 0x5a gets echoed.
  377                  * Some old controllers (Gateway 2000 circa 1993)
  378                  * return 0xfe here.
  379                  * We are satisfied if there is anything in the
  380                  * aux output buffer.
  381                  */
  382 #ifdef PCKBCDEBUG
printf("kbc: aux echo: %x\n", res);
  384 #endif
t->t_haveaux = 1;
  386                 if (pckbc_attach_slot(sc, PCKBC_AUX_SLOT))
cmdbits |= KC8_MENABLE;
  388         }
  389 #ifdef PCKBCDEBUG
  390         else
printf("kbc: aux echo test failed\n");
  392 #endif
nomouse:
  395         /* enable needed interrupts */
t->t_cmdbyte |= cmdbits;
  397         if (!pckbc_put8042cmd(t))
printf("kbc: cmd word write error\n");
  399 }
  401 int
pckbcprint(aux, pnp)
  403         void *aux;
  404         const char *pnp;
  405 {
  406         struct pckbc_attach_args *pa = aux;
  408         if (!pnp)
printf(" (%s slot)", pckbc_slot_names[pa->pa_slot]);
  410         return (QUIET);
  411 }
  413 void
pckbc_init_slotdata(q)
  415         struct pckbc_slotdata *q;
  416 {
  417         int i;
TAILQ_INIT(&q->cmdqueue);
TAILQ_INIT(&q->freequeue);
  421         for (i = 0; i < NCMD; i++) {
TAILQ_INSERT_TAIL(&q->freequeue, &(q->cmds[i]), next);
  423         }
q->polling = 0;
  425 }
  427 void
pckbc_flush(self, slot)
pckbc_tag_t self;
pckbc_slot_t slot;
  431 {
  432         struct pckbc_internal *t = self;
  434         (void) pckbc_poll_data1(t->t_iot, t->t_ioh_d, t->t_ioh_c,
slot, t->t_haveaux);
  436 }
  438 int
pckbc_poll_data(self, slot)
pckbc_tag_t self;
pckbc_slot_t slot;
  442 {
  443         struct pckbc_internal *t = self;
  444         struct pckbc_slotdata *q = t->t_slotdata[slot];
  445         int c;
c = pckbc_poll_data1(t->t_iot, t->t_ioh_d, t->t_ioh_c,
slot, t->t_haveaux);
  449         if (c != -1 && q && CMD_IN_QUEUE(q)) {
  450                 /* we jumped into a running command - try to
  451                  deliver the response */
  452                 if (pckbc_cmdresponse(t, slot, c))
  453                         return (-1);
  454         }
  455         return (c);
  456 }
  458 /*
  459  * switch scancode translation on / off
  460  * return nonzero on success
  461  */
  462 int
pckbc_xt_translation(self, slot, on)
pckbc_tag_t self;
pckbc_slot_t slot;
  466         int on;
  467 {
  468         struct pckbc_internal *t = self;
  469         int ison;
  471         if (slot != PCKBC_KBD_SLOT) {
  472                 /* translation only for kbd slot */
  473                 if (on)
  474                         return (0);
  475                 else
  476                         return (1);
  477         }
ison = t->t_cmdbyte & KC8_TRANS;
  480         if ((on && ison) || (!on && !ison))
  481                 return (1);
t->t_cmdbyte ^= KC8_TRANS;
  484         if (!pckbc_put8042cmd(t))
  485                 return (0);
  487         /* read back to be sure */
  488         if (!pckbc_get8042cmd(t))
  489                 return (0);
ison = t->t_cmdbyte & KC8_TRANS;
  492         if ((on && ison) || (!on && !ison))
  493                 return (1);
  494         return (0);
  495 }
  497 static struct pckbc_portcmd {
u_char cmd_en, cmd_dis;
  499 } pckbc_portcmd[2] = {
  500         {
KBC_KBDENABLE, KBC_KBDDISABLE,
  502         }, {
KBC_AUXENABLE, KBC_AUXDISABLE,
  504         }
  505 };
  507 void
pckbc_slot_enable(self, slot, on)
pckbc_tag_t self;
pckbc_slot_t slot;
  511         int on;
  512 {
  513         struct pckbc_internal *t = (struct pckbc_internal *)self;
  514         struct pckbc_portcmd *cmd;
cmd = &pckbc_portcmd[slot];
  518         if (!pckbc_send_cmd(t->t_iot, t->t_ioh_c,
on ? cmd->cmd_en : cmd->cmd_dis))
printf("pckbc_slot_enable(%d) failed\n", on);
  522         if (slot == PCKBC_KBD_SLOT) {
  523                 if (on)
timeout_add(&t->t_poll, hz);
  525                 else
timeout_del(&t->t_poll);
  527         }
  528 }
  530 void
pckbc_set_poll(self, slot, on)
pckbc_tag_t self;
pckbc_slot_t slot;
  534         int on;
  535 {
  536         struct pckbc_internal *t = (struct pckbc_internal *)self;
t->t_slotdata[slot]->polling = on;
  540         if (!on) {
  541                 int s;
  543                 /*
  544                  * If disabling polling on a device that's been configured,
  545                  * make sure there are no bytes left in the FIFO, holding up
  546                  * the interrupt line.  Otherwise we won't get any further
  547                  * interrupts.
  548                  */
  549                 if (t->t_sc) {
s = spltty();
pckbcintr_internal(t, t->t_sc);
splx(s);
  553                 }
  554         }
  555 }
  557 /*
  558  * Pass command to device, poll for ACK and data.
  559  * to be called at spltty()
  560  */
  561 static void
pckbc_poll_cmd1(t, slot, cmd)
  563         struct pckbc_internal *t;
pckbc_slot_t slot;
  565         struct pckbc_devcmd *cmd;
  566 {
bus_space_tag_t iot = t->t_iot;
bus_space_handle_t ioh_d = t->t_ioh_d;
bus_space_handle_t ioh_c = t->t_ioh_c;
  570         int i, c = 0;
  572         while (cmd->cmdidx < cmd->cmdlen) {
  573                 if (!pckbc_send_devcmd(t, slot, cmd->cmd[cmd->cmdidx])) {
printf("pckbc_cmd: send error\n");
cmd->status = EIO;
  576                         return;
  577                 }
  578                 for (i = 10; i; i--) { /* 1s ??? */
c = pckbc_poll_data1(iot, ioh_d, ioh_c, slot,
t->t_haveaux);
  581                         if (c != -1)
  582                                 break;
  583                 }
  585                 if (c == KBC_DEVCMD_ACK) {
cmd->cmdidx++;
  587                         continue;
  588                 }
  589                 if (c == KBC_DEVCMD_RESEND) {
  590 #ifdef PCKBCDEBUG
printf("pckbc_cmd: RESEND\n");
  592 #endif
  593                         if (cmd->retries++ < 5)
  594                                 continue;
  595                         else {
  596 #ifdef PCKBCDEBUG
printf("pckbc: cmd failed\n");
  598 #endif
cmd->status = EIO;
  600                                 return;
  601                         }
  602                 }
  603                 if (c == -1) {
  604 #ifdef PCKBCDEBUG
printf("pckbc_cmd: timeout\n");
  606 #endif
cmd->status = EIO;
  608                         return;
  609                 }
  610 #ifdef PCKBCDEBUG
printf("pckbc_cmd: lost 0x%x\n", c);
  612 #endif
  613         }
  615         while (cmd->responseidx < cmd->responselen) {
  616                 if (cmd->flags & KBC_CMDFLAG_SLOW)
i = 100; /* 10s ??? */
  618                 else
i = 10; /* 1s ??? */
  620                 while (i--) {
c = pckbc_poll_data1(iot, ioh_d, ioh_c, slot,
t->t_haveaux);
  623                         if (c != -1)
  624                                 break;
  625                 }
  626                 if (c == -1) {
  627 #ifdef PCKBCDEBUG
printf("pckbc_cmd: no data\n");
  629 #endif
cmd->status = ETIMEDOUT;
  631                         return;
  632                 } else
cmd->response[cmd->responseidx++] = c;
  634         }
  635 }
  637 /* for use in autoconfiguration */
  638 int
pckbc_poll_cmd(self, slot, cmd, len, responselen, respbuf, slow)
pckbc_tag_t self;
pckbc_slot_t slot;
u_char *cmd;
  643         int len, responselen;
u_char *respbuf;
  645         int slow;
  646 {
  647         struct pckbc_devcmd nc;
  649         if ((len > 4) || (responselen > 4))
  650                 return (EINVAL);
bzero(&nc, sizeof(nc));
bcopy(cmd, nc.cmd, len);
nc.cmdlen = len;
nc.responselen = responselen;
nc.flags = (slow ? KBC_CMDFLAG_SLOW : 0);
pckbc_poll_cmd1(self, slot, &nc);
  660         if (nc.status == 0 && respbuf)
bcopy(nc.response, respbuf, responselen);
  663         return (nc.status);
  664 }
  666 /*
  667  * Clean up a command queue, throw away everything.
  668  */
  669 void
pckbc_cleanqueue(q)
  671         struct pckbc_slotdata *q;
  672 {
  673         struct pckbc_devcmd *cmd;
  674 #ifdef PCKBCDEBUG
  675         int i;
  676 #endif
  678         while ((cmd = TAILQ_FIRST(&q->cmdqueue))) {
TAILQ_REMOVE(&q->cmdqueue, cmd, next);
  680 #ifdef PCKBCDEBUG
printf("pckbc_cleanqueue: removing");
  682                 for (i = 0; i < cmd->cmdlen; i++)
printf(" %02x", cmd->cmd[i]);
printf("\n");
  685 #endif
TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
  687         }
  688 }
  690 /*
  691  * Timeout error handler: clean queues and data port.
  692  * XXX could be less invasive.
  693  */
  694 void
pckbc_cleanup(self)
  696         void *self;
  697 {
  698         struct pckbc_internal *t = self;
  699         int s;
printf("pckbc: command timeout\n");
s = spltty();
  705         if (t->t_slotdata[PCKBC_KBD_SLOT])
pckbc_cleanqueue(t->t_slotdata[PCKBC_KBD_SLOT]);
  707         if (t->t_slotdata[PCKBC_AUX_SLOT])
pckbc_cleanqueue(t->t_slotdata[PCKBC_AUX_SLOT]);
  710         while (bus_space_read_1(t->t_iot, t->t_ioh_c, 0) & KBS_DIB) {
KBD_DELAY;
  712                 (void) bus_space_read_1(t->t_iot, t->t_ioh_d, 0);
  713         }
  715         /* reset KBC? */
splx(s);
  718 }
  720 /*
  721  * Pass command to device during normal operation.
  722  * to be called at spltty()
  723  */
  724 void
pckbc_start(t, slot)
  726         struct pckbc_internal *t;
pckbc_slot_t slot;
  728 {
  729         struct pckbc_slotdata *q = t->t_slotdata[slot];
  730         struct pckbc_devcmd *cmd = TAILQ_FIRST(&q->cmdqueue);
  732         if (q->polling) {
  733                 do {
pckbc_poll_cmd1(t, slot, cmd);
  735                         if (cmd->status)
printf("pckbc_start: command error\n");
TAILQ_REMOVE(&q->cmdqueue, cmd, next);
  739                         if (cmd->flags & KBC_CMDFLAG_SYNC)
wakeup(cmd);
  741                         else {
timeout_del(&t->t_cleanup);
TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
  744                         }
cmd = TAILQ_FIRST(&q->cmdqueue);
  746                 } while (cmd);
  747                 return;
  748         }
  750         if (!pckbc_send_devcmd(t, slot, cmd->cmd[cmd->cmdidx])) {
printf("pckbc_start: send error\n");
  752                 /* XXX what now? */
  753                 return;
  754         }
  755 }
  757 /*
  758  * Handle command responses coming in asynchronously,
  759  * return nonzero if valid response.
  760  * to be called at spltty()
  761  */
  762 int
pckbc_cmdresponse(t, slot, data)
  764         struct pckbc_internal *t;
pckbc_slot_t slot;
u_char data;
  767 {
  768         struct pckbc_slotdata *q = t->t_slotdata[slot];
  769         struct pckbc_devcmd *cmd = TAILQ_FIRST(&q->cmdqueue);
  770 #ifdef DIAGNOSTIC
  771         if (!cmd)
panic("pckbc_cmdresponse: no active command");
  773 #endif
  774         if (cmd->cmdidx < cmd->cmdlen) {
  775                 if (data != KBC_DEVCMD_ACK && data != KBC_DEVCMD_RESEND)
  776                         return (0);
  778                 if (data == KBC_DEVCMD_RESEND) {
  779                         if (cmd->retries++ < 5) {
  780                                 /* try again last command */
  781                                 goto restart;
  782                         } else {
  783 #ifdef PCKBCDEBUG
printf("pckbc: cmd failed\n");
  785 #endif
cmd->status = EIO;
  787                                 /* dequeue */
  788                         }
  789                 } else {
  790                         if (++cmd->cmdidx < cmd->cmdlen)
  791                                 goto restart;
  792                         if (cmd->responselen)
  793                                 return (1);
  794                         /* else dequeue */
  795                 }
  796         } else if (cmd->responseidx < cmd->responselen) {
cmd->response[cmd->responseidx++] = data;
  798                 if (cmd->responseidx < cmd->responselen)
  799                         return (1);
  800                 /* else dequeue */
  801         } else
  802                 return (0);
  804         /* dequeue: */
TAILQ_REMOVE(&q->cmdqueue, cmd, next);
  806         if (cmd->flags & KBC_CMDFLAG_SYNC)
wakeup(cmd);
  808         else {
timeout_del(&t->t_cleanup);
TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
  811         }
  812         if (!CMD_IN_QUEUE(q))
  813                 return (1);
restart:
pckbc_start(t, slot);
  816         return (1);
  817 }
  819 /*
  820  * Put command into the device's command queue, return zero or errno.
  821  */
  822 int
pckbc_enqueue_cmd(self, slot, cmd, len, responselen, sync, respbuf)
pckbc_tag_t self;
pckbc_slot_t slot;
u_char *cmd;
  827         int len, responselen, sync;
u_char *respbuf;
  829 {
  830         struct pckbc_internal *t = self;
  831         struct pckbc_slotdata *q = t->t_slotdata[slot];
  832         struct pckbc_devcmd *nc;
  833         int s, isactive, res = 0;
  835         if ((len > 4) || (responselen > 4))
  836                 return (EINVAL);
s = spltty();
nc = TAILQ_FIRST(&q->freequeue);
  839         if (nc) {
TAILQ_REMOVE(&q->freequeue, nc, next);
  841         }
splx(s);
  843         if (!nc)
  844                 return (ENOMEM);
bzero(nc, sizeof(*nc));
bcopy(cmd, nc->cmd, len);
nc->cmdlen = len;
nc->responselen = responselen;
nc->flags = (sync ? KBC_CMDFLAG_SYNC : 0);
s = spltty();
  854         if (q->polling && sync) {
  855                 /*
  856                  * XXX We should poll until the queue is empty.
  857                  * But we don't come here normally, so make
  858                  * it simple and throw away everything.
  859                  */
pckbc_cleanqueue(q);
  861         }
isactive = CMD_IN_QUEUE(q);
TAILQ_INSERT_TAIL(&q->cmdqueue, nc, next);
  865         if (!isactive)
pckbc_start(t, slot);
  868         if (q->polling)
res = (sync ? nc->status : 0);
  870         else if (sync) {
  871                 if ((res = tsleep(nc, 0, "kbccmd", 1*hz))) {
TAILQ_REMOVE(&q->cmdqueue, nc, next);
pckbc_cleanup(t);
  874                 } else
res = nc->status;
  876         } else
timeout_add(&t->t_cleanup, hz);
  879         if (sync) {
  880                 if (respbuf)
bcopy(nc->response, respbuf, responselen);
TAILQ_INSERT_TAIL(&q->freequeue, nc, next);
  883         }
splx(s);
  887         return (res);
  888 }
  890 void
pckbc_set_inputhandler(self, slot, func, arg, name)
pckbc_tag_t self;
pckbc_slot_t slot;
pckbc_inputfcn func;
  895         void *arg;
  896         char *name;
  897 {
  898         struct pckbc_internal *t = (struct pckbc_internal *)self;
  899         struct pckbc_softc *sc = t->t_sc;
  901         if (slot >= PCKBC_NSLOTS)
panic("pckbc_set_inputhandler: bad slot %d", slot);
  904         (*sc->intr_establish)(sc, slot);
sc->inputhandler[slot] = func;
sc->inputarg[slot] = arg;
sc->subname[slot] = name;
  910         if (pckbc_console && slot == PCKBC_KBD_SLOT)
timeout_add(&t->t_poll, hz);
  912 }
  914 void
pckbc_poll(v)
  916         void *v;
  917 {
  918         struct pckbc_internal *t = v;
  919         int s;
s = spltty();
  922         (void)pckbcintr_internal(t, t->t_sc);
timeout_add(&t->t_poll, hz);
splx(s);
  925 }
  927 int
pckbcintr(vsc)
  929         void *vsc;
  930 {
  931         struct pckbc_softc *sc = (struct pckbc_softc *)vsc;
  933         return (pckbcintr_internal(sc->id, sc));
  934 }
  936 int
pckbcintr_internal(t, sc)
  938         struct pckbc_internal *t;
  939         struct pckbc_softc *sc;
  940 {
u_char stat;
pckbc_slot_t slot;
  943         struct pckbc_slotdata *q;
  944         int served = 0, data;
  946         /* reschedule timeout further into the idle times */
  947         if (timeout_pending(&t->t_poll))
timeout_add(&t->t_poll, hz);
  950         for(;;) {
stat = bus_space_read_1(t->t_iot, t->t_ioh_c, 0);
  952                 if (!(stat & KBS_DIB))
  953                         break;
served = 1;
slot = (t->t_haveaux && (stat & 0x20)) ?
PCKBC_AUX_SLOT : PCKBC_KBD_SLOT;
q = t->t_slotdata[slot];
  961                 if (!q) {
  962                         /* XXX do something for live insertion? */
printf("pckbcintr: no dev for slot %d\n", slot);
KBD_DELAY;
  965                         (void) bus_space_read_1(t->t_iot, t->t_ioh_d, 0);
  966                         continue;
  967                 }
  969                 if (q->polling)
  970                         break; /* pckbc_poll_data() will get it */
KBD_DELAY;
data = bus_space_read_1(t->t_iot, t->t_ioh_d, 0);
  975                 if (CMD_IN_QUEUE(q) && pckbc_cmdresponse(t, slot, data))
  976                         continue;
  978                 if (sc != NULL) {
  979                         if (sc->inputhandler[slot])
  980                                 (*sc->inputhandler[slot])(sc->inputarg[slot],
data);
  982 #ifdef PCKBCDEBUG
  983                         else
printf("pckbcintr: slot %d lost %d\n",
slot, data);
  986 #endif
  987                 }
  988         }
  990         return (served);
  991 }
  993 int
pckbc_cnattach(iot, addr, cmd_offset, slot)
bus_space_tag_t iot;
bus_addr_t addr;
bus_size_t cmd_offset;
pckbc_slot_t slot;
  999 {
bus_space_handle_t ioh_d, ioh_c;
 1001         int res = 0;
 1003         if (bus_space_map(iot, addr + KBDATAP, 1, 0, &ioh_d))
 1004                 return (ENXIO);
 1005         if (bus_space_map(iot, addr + cmd_offset, 1, 0, &ioh_c)) {
bus_space_unmap(iot, ioh_d, 1);
 1007                 return (ENXIO);
 1008         }
pckbc_consdata.t_iot = iot;
pckbc_consdata.t_ioh_d = ioh_d;
pckbc_consdata.t_ioh_c = ioh_c;
pckbc_consdata.t_addr = addr;
timeout_set(&pckbc_consdata.t_cleanup, pckbc_cleanup, &pckbc_consdata);
timeout_set(&pckbc_consdata.t_poll, pckbc_poll, &pckbc_consdata);
 1017         /* flush */
 1018         (void) pckbc_poll_data1(iot, ioh_d, ioh_c, PCKBC_KBD_SLOT, 0);
 1020         /* selftest? */
 1022         /* init cmd byte, enable ports */
pckbc_consdata.t_cmdbyte = KC8_CPU;
 1024         if (!pckbc_put8042cmd(&pckbc_consdata)) {
printf("kbc: cmd word write error\n");
res = EIO;
 1027         }
 1029         if (!res) {
 1030 #if (NPCKBD > 0)
res = pckbd_cnattach(&pckbc_consdata, slot);
 1032 #else
res = ENXIO;
 1034 #endif /* NPCKBD > 0 */
 1035         }
 1037         if (res) {
bus_space_unmap(iot, pckbc_consdata.t_ioh_d, 1);
bus_space_unmap(iot, pckbc_consdata.t_ioh_c, 1);
 1040         } else {
pckbc_consdata.t_slotdata[slot] = &pckbc_cons_slotdata;
pckbc_init_slotdata(&pckbc_cons_slotdata);
pckbc_console = 1;
 1044         }
 1046         return (res);
 1047 }
 1049 struct cfdriver pckbc_cd = {
NULL, "pckbc", DV_DULL
 1051 };