pckbport.c revision 1.15 
1/* $NetBSD: pckbport.c,v 1.15 2013/03/06 03:26:17 christos Exp $ */
2
3/*
4 * Copyright (c) 2004 Ben Harris
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 */
28
29#include <sys/cdefs.h>
30__KERNEL_RCSID(0, "$NetBSD: pckbport.c,v 1.15 2013/03/06 03:26:17 christos Exp $");
31
32#include <sys/param.h>
33#include <sys/systm.h>
34#include <sys/callout.h>
35#include <sys/kernel.h>
36#include <sys/proc.h>
37#include <sys/device.h>
38#include <sys/malloc.h>
39#include <sys/errno.h>
40#include <sys/queue.h>
41
42#include <dev/pckbport/pckbdreg.h>
43#include <dev/pckbport/pckbportvar.h>
44
45#include "locators.h"
46
47#include "pckbd.h"
48#if (NPCKBD > 0)
49#include <dev/pckbport/pckbdvar.h>
50#endif
51
52/* descriptor for one device command */
53struct pckbport_devcmd {
54	TAILQ_ENTRY(pckbport_devcmd) next;
55	int flags;
56#define KBC_CMDFLAG_SYNC 1 /* give descriptor back to caller */
57#define KBC_CMDFLAG_SLOW 2
58	u_char cmd[4];
59	int cmdlen, cmdidx, retries;
60	u_char response[4];
61	int status, responselen, responseidx;
62};
63
64/* data per slave device */
65struct pckbport_slotdata {
66	int polling;	/* don't process data in interrupt handler */
67	TAILQ_HEAD(, pckbport_devcmd) cmdqueue; /* active commands */
68	TAILQ_HEAD(, pckbport_devcmd) freequeue; /* free commands */
69#define NCMD 5
70	struct pckbport_devcmd cmds[NCMD];
71};
72
73#define CMD_IN_QUEUE(q) (TAILQ_FIRST(&(q)->cmdqueue) != NULL)
74
75static void pckbport_init_slotdata(struct pckbport_slotdata *);
76static int pckbportprint(void *, const char *);
77
78static struct pckbport_slotdata pckbport_cons_slotdata;
79
80static int pckbport_poll_data1(pckbport_tag_t, pckbport_slot_t);
81static int pckbport_send_devcmd(struct pckbport_tag *, pckbport_slot_t,
82				  u_char);
83static void pckbport_poll_cmd1(struct pckbport_tag *, pckbport_slot_t,
84				 struct pckbport_devcmd *);
85
86static void pckbport_cleanqueue(struct pckbport_slotdata *);
87static void pckbport_cleanup(void *);
88static int pckbport_cmdresponse(struct pckbport_tag *, pckbport_slot_t,
89					u_char);
90static void pckbport_start(struct pckbport_tag *, pckbport_slot_t);
91
92static const char * const pckbport_slot_names[] = { "kbd", "aux" };
93
94static struct pckbport_tag pckbport_cntag;
95
96#define	KBD_DELAY	DELAY(8)
97
98#ifdef PCKBPORTDEBUG
99#define DPRINTF(a)	printf a
100#else
101#define DPRINTF(a)
102#endif
103
104static int
105pckbport_poll_data1(pckbport_tag_t t, pckbport_slot_t slot)
106{
107
108	return t->t_ops->t_poll_data1(t->t_cookie, slot);
109}
110
111static int
112pckbport_send_devcmd(struct pckbport_tag *t, pckbport_slot_t slot, u_char val)
113{
114
115	return t->t_ops->t_send_devcmd(t->t_cookie, slot, val);
116}
117
118pckbport_tag_t
119pckbport_attach(void *cookie, struct pckbport_accessops const *ops)
120{
121	pckbport_tag_t t;
122
123	if (cookie == pckbport_cntag.t_cookie &&
124	    ops == pckbport_cntag.t_ops)
125		return &pckbport_cntag;
126	t = malloc(sizeof(struct pckbport_tag), M_DEVBUF, M_NOWAIT | M_ZERO);
127	if (t == NULL) return NULL;
128	callout_init(&t->t_cleanup, 0);
129	t->t_cookie = cookie;
130	t->t_ops = ops;
131	return t;
132}
133
134device_t
135pckbport_attach_slot(device_t dev, pckbport_tag_t t,
136    pckbport_slot_t slot)
137{
138	struct pckbport_attach_args pa;
139	void *sdata;
140	device_t found;
141	int alloced = 0;
142	int locs[PCKBPORTCF_NLOCS];
143
144	pa.pa_tag = t;
145	pa.pa_slot = slot;
146
147	if (t->t_slotdata[slot] == NULL) {
148		sdata = malloc(sizeof(struct pckbport_slotdata),
149		    M_DEVBUF, M_NOWAIT);
150		if (sdata == NULL) {
151			aprint_error_dev(dev, "no memory\n");
152			return 0;
153		}
154		t->t_slotdata[slot] = sdata;
155		pckbport_init_slotdata(t->t_slotdata[slot]);
156		alloced++;
157	}
158
159	locs[PCKBPORTCF_SLOT] = slot;
160
161	found = config_found_sm_loc(dev, "pckbport", locs, &pa,
162				    pckbportprint, config_stdsubmatch);
163
164	if (found == NULL && alloced) {
165		free(t->t_slotdata[slot], M_DEVBUF);
166		t->t_slotdata[slot] = NULL;
167	}
168
169	return found;
170}
171
172int
173pckbportprint(void *aux, const char *pnp)
174{
175	struct pckbport_attach_args *pa = aux;
176
177	if (!pnp)
178		aprint_normal(" (%s slot)", pckbport_slot_names[pa->pa_slot]);
179	return QUIET;
180}
181
182void
183pckbport_init_slotdata(struct pckbport_slotdata *q)
184{
185	int i;
186
187	TAILQ_INIT(&q->cmdqueue);
188	TAILQ_INIT(&q->freequeue);
189
190	for (i = 0; i < NCMD; i++)
191		TAILQ_INSERT_TAIL(&q->freequeue, &(q->cmds[i]), next);
192
193	q->polling = 0;
194}
195
196void
197pckbport_flush(pckbport_tag_t t, pckbport_slot_t slot)
198{
199
200	(void)pckbport_poll_data1(t, slot);
201}
202
203int
204pckbport_poll_data(pckbport_tag_t t, pckbport_slot_t slot)
205{
206	struct pckbport_slotdata *q = t->t_slotdata[slot];
207	int c;
208
209	c = pckbport_poll_data1(t, slot);
210	if (c != -1 && q && CMD_IN_QUEUE(q))
211		/*
212		 * we jumped into a running command - try to deliver
213		 * the response
214		 */
215		if (pckbport_cmdresponse(t, slot, c))
216			return -1;
217	return c;
218}
219
220/*
221 * switch scancode translation on / off
222 * return nonzero on success
223 */
224int
225pckbport_xt_translation(pckbport_tag_t t, pckbport_slot_t slot,	int on)
226{
227
228	return t->t_ops->t_xt_translation(t->t_cookie, slot, on);
229}
230
231void
232pckbport_slot_enable(pckbport_tag_t t, pckbport_slot_t slot, int on)
233{
234
235	t->t_ops->t_slot_enable(t->t_cookie, slot, on);
236}
237
238void
239pckbport_set_poll(pckbport_tag_t t, pckbport_slot_t slot, int on)
240{
241
242	t->t_slotdata[slot]->polling = on;
243	t->t_ops->t_set_poll(t->t_cookie, slot, on);
244}
245
246/*
247 * Pass command to device, poll for ACK and data.
248 * to be called at spltty()
249 */
250static void
251pckbport_poll_cmd1(struct pckbport_tag *t, pckbport_slot_t slot,
252    struct pckbport_devcmd *cmd)
253{
254	int i, c = 0;
255
256	while (cmd->cmdidx < cmd->cmdlen) {
257		if (!pckbport_send_devcmd(t, slot, cmd->cmd[cmd->cmdidx])) {
258			printf("pckbport_cmd: send error\n");
259			cmd->status = EIO;
260			return;
261		}
262		for (i = 10; i; i--) { /* 1s ??? */
263			c = pckbport_poll_data1(t, slot);
264			if (c != -1)
265				break;
266		}
267		switch (c) {
268		case KBR_ACK:
269			cmd->cmdidx++;
270			continue;
271		case KBR_BAT_DONE:
272		case KBR_BAT_FAIL:
273		case KBR_RESEND:
274			DPRINTF(("%s: %s\n", __func__, c == KBR_RESEND ?
275			    "RESEND" : (c == KBR_BAT_DONE ? "BAT_DONE" :
276			    "BAT_FAIL")));
277			if (cmd->retries++ < 5)
278				continue;
279			else {
280				DPRINTF(("%s: cmd failed\n", __func__));
281				cmd->status = EIO;
282				return;
283			}
284		case -1:
285			DPRINTF(("%s: timeout\n", __func__));
286			cmd->status = EIO;
287			return;
288		}
289		DPRINTF(("%s: lost 0x%x\n", __func__, c));
290	}
291
292	while (cmd->responseidx < cmd->responselen) {
293		if (cmd->flags & KBC_CMDFLAG_SLOW)
294			i = 100; /* 10s ??? */
295		else
296			i = 10; /* 1s ??? */
297		while (i--) {
298			c = pckbport_poll_data1(t, slot);
299			if (c != -1)
300				break;
301		}
302		if (c == -1) {
303			DPRINTF(("%s: no data\n", __func__));
304			cmd->status = ETIMEDOUT;
305			return;
306		} else
307			cmd->response[cmd->responseidx++] = c;
308	}
309}
310
311/* for use in autoconfiguration */
312int
313pckbport_poll_cmd(pckbport_tag_t t, pckbport_slot_t slot, const u_char *cmd,
314    int len, int responselen, u_char *respbuf, int slow)
315{
316	struct pckbport_devcmd nc;
317
318	if ((len > 4) || (responselen > 4))
319		return (EINVAL);
320
321	memset(&nc, 0, sizeof(nc));
322	memcpy(nc.cmd, cmd, len);
323	nc.cmdlen = len;
324	nc.responselen = responselen;
325	nc.flags = (slow ? KBC_CMDFLAG_SLOW : 0);
326
327	pckbport_poll_cmd1(t, slot, &nc);
328
329	if (nc.status == 0 && respbuf)
330		memcpy(respbuf, nc.response, responselen);
331
332	return nc.status;
333}
334
335/*
336 * Clean up a command queue, throw away everything.
337 */
338void
339pckbport_cleanqueue(struct pckbport_slotdata *q)
340{
341	struct pckbport_devcmd *cmd;
342
343	while ((cmd = TAILQ_FIRST(&q->cmdqueue))) {
344		TAILQ_REMOVE(&q->cmdqueue, cmd, next);
345#ifdef PCKBPORTDEBUG
346		printf("%s: removing", __func__);
347		for (int i = 0; i < cmd->cmdlen; i++)
348			printf(" %02x", cmd->cmd[i]);
349		printf("\n");
350#endif
351		TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
352	}
353}
354
355/*
356 * Timeout error handler: clean queues and data port.
357 * XXX could be less invasive.
358 */
359void
360pckbport_cleanup(void *self)
361{
362	struct pckbport_tag *t = self;
363	int s;
364	u_char cmd[1], resp[2];
365
366	printf("pckbport: command timeout\n");
367
368	s = spltty();
369
370	if (t->t_slotdata[PCKBPORT_KBD_SLOT])
371		pckbport_cleanqueue(t->t_slotdata[PCKBPORT_KBD_SLOT]);
372	if (t->t_slotdata[PCKBPORT_AUX_SLOT])
373		pckbport_cleanqueue(t->t_slotdata[PCKBPORT_AUX_SLOT]);
374
375#if 0 /* XXXBJH Move to controller driver? */
376	while (bus_space_read_1(t->t_iot, t->t_ioh_c, 0) & KBS_DIB) {
377		KBD_DELAY;
378		(void) bus_space_read_1(t->t_iot, t->t_ioh_d, 0);
379	}
380#endif
381
382	cmd[0] = KBC_RESET;
383	(void)pckbport_poll_cmd(t, PCKBPORT_KBD_SLOT, cmd, 1, 2, resp, 1);
384	pckbport_flush(t, PCKBPORT_KBD_SLOT);
385
386	splx(s);
387}
388
389/*
390 * Pass command to device during normal operation.
391 * to be called at spltty()
392 */
393void
394pckbport_start(struct pckbport_tag *t, pckbport_slot_t slot)
395{
396	struct pckbport_slotdata *q = t->t_slotdata[slot];
397	struct pckbport_devcmd *cmd = TAILQ_FIRST(&q->cmdqueue);
398
399	if (q->polling) {
400		do {
401			pckbport_poll_cmd1(t, slot, cmd);
402			if (cmd->status)
403				printf("pckbport_start: command error\n");
404
405			TAILQ_REMOVE(&q->cmdqueue, cmd, next);
406			if (cmd->flags & KBC_CMDFLAG_SYNC)
407				wakeup(cmd);
408			else {
409				callout_stop(&t->t_cleanup);
410				TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
411			}
412			cmd = TAILQ_FIRST(&q->cmdqueue);
413		} while (cmd);
414		return;
415	}
416
417	if (!pckbport_send_devcmd(t, slot, cmd->cmd[cmd->cmdidx])) {
418		printf("pckbport_start: send error\n");
419		/* XXX what now? */
420		return;
421	}
422}
423
424/*
425 * Handle command responses coming in asynchronously,
426 * return nonzero if valid response.
427 * to be called at spltty()
428 */
429int
430pckbport_cmdresponse(struct pckbport_tag *t, pckbport_slot_t slot, u_char data)
431{
432	struct pckbport_slotdata *q = t->t_slotdata[slot];
433	struct pckbport_devcmd *cmd = TAILQ_FIRST(&q->cmdqueue);
434
435#ifdef DIAGNOSTIC
436	if (!cmd)
437		panic("pckbport_cmdresponse: no active command");
438#endif
439	if (cmd->cmdidx < cmd->cmdlen) {
440		if (data != KBR_ACK && data != KBR_RESEND)
441			return 0;
442
443		if (data == KBR_RESEND) {
444			if (cmd->retries++ < 5)
445				/* try again last command */
446				goto restart;
447			else {
448				DPRINTF(("%s: cmd failed\n", __func__));
449				cmd->status = EIO;
450				/* dequeue */
451			}
452		} else {
453			if (++cmd->cmdidx < cmd->cmdlen)
454				goto restart;
455			if (cmd->responselen)
456				return 1;
457			/* else dequeue */
458		}
459	} else if (cmd->responseidx < cmd->responselen) {
460		cmd->response[cmd->responseidx++] = data;
461		if (cmd->responseidx < cmd->responselen)
462			return 1;
463		/* else dequeue */
464	} else
465		return 0;
466
467	/* dequeue: */
468	TAILQ_REMOVE(&q->cmdqueue, cmd, next);
469	if (cmd->flags & KBC_CMDFLAG_SYNC)
470		wakeup(cmd);
471	else {
472		callout_stop(&t->t_cleanup);
473		TAILQ_INSERT_TAIL(&q->freequeue, cmd, next);
474	}
475	if (!CMD_IN_QUEUE(q))
476		return 1;
477restart:
478	pckbport_start(t, slot);
479	return 1;
480}
481
482/*
483 * Put command into the device's command queue, return zero or errno.
484 */
485int
486pckbport_enqueue_cmd(pckbport_tag_t t, pckbport_slot_t slot, const u_char *cmd,
487    int len, int responselen, int sync, u_char *respbuf)
488{
489	struct pckbport_slotdata *q = t->t_slotdata[slot];
490	struct pckbport_devcmd *nc;
491	int s, isactive, res = 0;
492
493	if ((len > 4) || (responselen > 4))
494		return EINVAL;
495	s = spltty();
496	nc = TAILQ_FIRST(&q->freequeue);
497	if (nc)
498		TAILQ_REMOVE(&q->freequeue, nc, next);
499	splx(s);
500	if (!nc)
501		return ENOMEM;
502
503	memset(nc, 0, sizeof(*nc));
504	memcpy(nc->cmd, cmd, len);
505	nc->cmdlen = len;
506	nc->responselen = responselen;
507	nc->flags = (sync ? KBC_CMDFLAG_SYNC : 0);
508
509	s = spltty();
510
511	if (q->polling && sync)
512		/*
513		 * XXX We should poll until the queue is empty.
514		 * But we don't come here normally, so make
515		 * it simple and throw away everything.
516		 */
517		pckbport_cleanqueue(q);
518
519	isactive = CMD_IN_QUEUE(q);
520	TAILQ_INSERT_TAIL(&q->cmdqueue, nc, next);
521	if (!isactive)
522		pckbport_start(t, slot);
523
524	if (q->polling)
525		res = (sync ? nc->status : 0);
526	else if (sync) {
527		if ((res = tsleep(nc, 0, "kbccmd", 1*hz))) {
528			TAILQ_REMOVE(&q->cmdqueue, nc, next);
529			pckbport_cleanup(t);
530		} else
531			res = nc->status;
532	} else
533		callout_reset(&t->t_cleanup, hz, pckbport_cleanup, t);
534
535	if (sync) {
536		if (respbuf)
537			memcpy(respbuf, nc->response, responselen);
538		TAILQ_INSERT_TAIL(&q->freequeue, nc, next);
539	}
540
541	splx(s);
542
543	return res;
544}
545
546void
547pckbport_set_inputhandler(pckbport_tag_t t, pckbport_slot_t slot,
548    pckbport_inputfcn func, void *arg, const char *name)
549{
550
551	if (slot >= PCKBPORT_NSLOTS)
552		panic("pckbport_set_inputhandler: bad slot %d", slot);
553
554	t->t_ops->t_intr_establish(t->t_cookie, slot);
555
556	t->t_inputhandler[slot] = func;
557	t->t_inputarg[slot] = arg;
558	t->t_subname[slot] = name;
559}
560
561void
562pckbportintr(pckbport_tag_t t, pckbport_slot_t slot, int data)
563{
564	struct pckbport_slotdata *q;
565
566	q = t->t_slotdata[slot];
567
568	if (!q) {
569		/* XXX do something for live insertion? */
570		printf("pckbportintr: no dev for slot %d\n", slot);
571		return;
572	}
573
574	if (CMD_IN_QUEUE(q) && pckbport_cmdresponse(t, slot, data))
575		return;
576
577	if (t->t_inputhandler[slot]) {
578		(*t->t_inputhandler[slot])(t->t_inputarg[slot], data);
579		return;
580	}
581	DPRINTF(("%s: slot %d lost %d\n", slot, data, __func__));
582}
583
584int
585pckbport_cnattach(void *cookie, struct pckbport_accessops const *ops,
586    pckbport_slot_t slot)
587{
588	int res = 0;
589	pckbport_tag_t t = &pckbport_cntag;
590
591	callout_init(&t->t_cleanup, 0);
592	t->t_cookie = cookie;
593	t->t_ops = ops;
594
595	/* flush */
596	pckbport_flush(t, slot);
597
598#if (NPCKBD > 0)
599	res = pckbd_cnattach(t, slot);
600#elif (NPCKBPORT_MACHDEP_CNATTACH > 0)
601	res = pckbport_machdep_cnattach(t, slot);
602#else
603	res = ENXIO;
604#endif /* NPCKBPORT_MACHDEP_CNATTACH > 0 */
605
606	if (res == 0) {
607		t->t_slotdata[slot] = &pckbport_cons_slotdata;
608		pckbport_init_slotdata(&pckbport_cons_slotdata);
609	}
610
611	return res;
612}
613