1 /* $NetBSD: kbms_sbdio.c,v 1.15 2021/12/10 20:36:02 andvar Exp $ */
2
3 /*-
4 * Copyright (c) 2004, 2005 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by UCHIYAMA Yasushi.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: kbms_sbdio.c,v 1.15 2021/12/10 20:36:02 andvar Exp $");
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/device.h>
38
39 #include <dev/wscons/wsconsio.h>
40 #include <dev/wscons/wskbdvar.h>
41 #include <dev/wscons/wsmousevar.h>
42
43 #include <dev/wscons/wsksymdef.h>
44 #include <dev/wscons/wsksymvar.h>
45
46 #include <dev/ic/z8530reg.h>
47
48 #include <machine/sbdiovar.h>
49
50 #include <ews4800mips/dev/ews4800keymap.h>
51
52 /* 85C30 keyboard, mouse driver */
53
54 struct kbms_reg {
55 volatile uint8_t *kbd_csr;
56 volatile uint8_t *kbd_data;
57 volatile uint8_t *mouse_csr;
58 volatile uint8_t *mouse_data;
59 };
60
61 enum { MOUSE_PACKET_LEN = 5 };
62 struct kbms_softc {
63 device_t sc_dev;
64 device_t sc_wskbd;
65 device_t sc_wsmouse;
66 struct kbms_reg sc_reg;
67 int sc_leds;
68 int sc_flags;
69 int sc_mouse_sig;
70 int sc_mouse_cnt;
71 int8_t sc_mouse_buf[MOUSE_PACKET_LEN];
72 };
73
74 int kbms_sbdio_match(device_t, cfdata_t, void *);
75 void kbms_sbdio_attach(device_t, device_t, void *);
76 int kbms_sbdio_intr(void *);
77
78 CFATTACH_DECL_NEW(kbms_sbdio, sizeof(struct kbms_softc),
79 kbms_sbdio_match, kbms_sbdio_attach, NULL, NULL);
80
81 int kbd_enable(void *, int);
82 void kbd_set_leds(void *, int);
83 int kbd_ioctl(void *, u_long, void *, int, struct lwp *);
84
85 int mouse_enable(void *);
86 void mouse_disable(void *);
87 int mouse_ioctl(void *, u_long, void *, int, struct lwp *);
88
89 bool kbd_init(struct kbms_softc *);
90 bool kbd_reset(struct kbms_softc *, int);
91
92 void mouse_init(struct kbms_softc *);
93 #ifdef MOUSE_DEBUG
94 void mouse_debug_print(u_int, int, int);
95 #endif
96
97 int kbd_sbdio_cnattach(uint32_t, uint32_t);
98 void kbd_cngetc(void *, u_int *, int *);
99 void kbd_cnpollc(void *, int);
100
101 static struct kbms_reg kbms_consreg;
102
103 const struct wskbd_consops kbd_consops = {
104 kbd_cngetc,
105 kbd_cnpollc,
106 };
107
108 const struct wskbd_accessops kbd_accessops = {
109 kbd_enable,
110 kbd_set_leds,
111 kbd_ioctl,
112 };
113
114 struct wskbd_mapdata kbd_keymapdata = {
115 ews4800kbd_keydesctab,
116 KB_JP,
117 };
118
119 const struct wsmouse_accessops mouse_accessops = {
120 mouse_enable,
121 mouse_ioctl,
122 mouse_disable,
123 };
124
125 #define KBMS_PCLK (9600 * 512)
126
127
128 int
kbms_sbdio_match(device_t parent,cfdata_t cf,void * aux)129 kbms_sbdio_match(device_t parent, cfdata_t cf, void *aux)
130 {
131 struct sbdio_attach_args *sa = aux;
132
133 return strcmp(sa->sa_name, "zkbms") ? 0 : 1;
134 }
135
136 void
kbms_sbdio_attach(device_t parent,device_t self,void * aux)137 kbms_sbdio_attach(device_t parent, device_t self, void *aux)
138 {
139 struct kbms_softc *sc = device_private(self);
140 struct sbdio_attach_args *sa = aux;
141 struct wsmousedev_attach_args ma;
142 struct wskbddev_attach_args ka;
143 struct kbms_reg *reg = &sc->sc_reg;
144 uint8_t *base;
145
146 sc->sc_dev = self;
147 aprint_normal("\n");
148
149 base = (uint8_t *)MIPS_PHYS_TO_KSEG1(sa->sa_addr1);
150 reg->kbd_csr = base + 0x00; /* port B */
151 reg->kbd_data = base + 0x04;
152 reg->mouse_csr = base + 0x08; /* port A */
153 reg->mouse_data = base + 0x0c;
154
155 if (reg->kbd_csr == kbms_consreg.kbd_csr &&
156 reg->kbd_data == kbms_consreg.kbd_data)
157 ka.console = true;
158 else
159 ka.console = false;
160
161 ka.keymap = &kbd_keymapdata;
162 ka.accessops = &kbd_accessops;
163 ka.accesscookie = self;
164
165 if (kbd_init(sc) == false) {
166 printf("keyboard not connected\n");
167 return;
168 }
169
170 sc->sc_wskbd = config_found(self, &ka, wskbddevprint, CFARGS_NONE);
171
172 ma.accessops = &mouse_accessops;
173 ma.accesscookie = self;
174
175 if (sa->sa_flags == 0x0001)
176 sc->sc_flags = 1;
177 sc->sc_mouse_sig = 0x80;
178 if (sc->sc_flags == 1) /* ER/TR?? */
179 sc->sc_mouse_sig = 0x88;
180
181 mouse_init(sc);
182 sc->sc_wsmouse = config_found(self, &ma, wsmousedevprint, CFARGS_NONE);
183
184 intr_establish(sa->sa_irq, kbms_sbdio_intr, self);
185 }
186
187 int
kbms_sbdio_intr(void * arg)188 kbms_sbdio_intr(void *arg)
189 {
190 struct kbms_softc *sc = (void *)arg;
191 struct kbms_reg *reg = &sc->sc_reg;
192 int v;
193
194 if (*reg->kbd_csr & ZSRR0_RX_READY) {
195 v = *reg->kbd_data;
196 wskbd_input(sc->sc_wskbd,
197 v & 0x80 ? WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN,
198 v & 0x7f);
199 }
200
201 while (*reg->mouse_csr & ZSRR0_RX_READY) {
202 int8_t *buf = sc->sc_mouse_buf;
203 *reg->mouse_csr = 1;
204 if (((v = *reg->mouse_csr) &
205 (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) != 0) {
206 /* Error occurred. re-initialize */
207 printf("initialize mouse. error=%02x\n", v);
208 mouse_init(sc);
209 } else {
210 v = *reg->mouse_data;
211 if ((sc->sc_mouse_cnt == 0) &&
212 (v & 0xf8) != sc->sc_mouse_sig) {
213 printf("missing first packet. reset. %x\n", v);
214 mouse_init(sc);
215 continue;
216 }
217 buf[sc->sc_mouse_cnt++] = v;
218
219 if (sc->sc_mouse_cnt == MOUSE_PACKET_LEN) {
220 int x, y;
221 u_int buttons;
222 buttons = ~buf[0] & 0x7;
223 if (sc->sc_flags == 0) {
224 u_int b1 = (buttons & 0x1) << 2;
225 u_int b3 = (buttons & 0x4) >> 2;
226 buttons = (buttons & 0x2) | b1 | b3;
227 }
228 x = buf[1] + buf[3];
229 y = buf[2] + buf[4];
230 #ifdef MOUSE_DEBUG
231 mouse_debug_print(buttons, x, y);
232 #endif
233 wsmouse_input(sc->sc_wsmouse,
234 buttons,
235 x, y, 0, 0,
236 WSMOUSE_INPUT_DELTA);
237 sc->sc_mouse_cnt = 0;
238 }
239
240 }
241 *reg->mouse_csr = ZSWR1_REQ_RX | ZSWR1_RIE | ZSWR1_RIE_FIRST;
242 (void)*reg->mouse_csr;
243 }
244
245 return 0;
246 }
247
248 #define __REG_WR(r, v) \
249 do { \
250 *csr = (r); \
251 delay(1); \
252 *csr = (v); \
253 delay(1); \
254 } while (/*CONSTCOND*/ 0)
255
256 bool
kbd_init(struct kbms_softc * sc)257 kbd_init(struct kbms_softc *sc)
258 {
259 struct kbms_reg *reg = &sc->sc_reg;
260 volatile uint8_t *csr = reg->kbd_csr;
261 int retry = 2;
262 int reset_retry = 100;
263
264 do {
265 __REG_WR(9, ZSWR9_B_RESET);
266 delay(100);
267 __REG_WR(9, ZSWR9_MASTER_IE | ZSWR9_NO_VECTOR);
268 __REG_WR(1, 0);
269 __REG_WR(4, ZSWR4_CLK_X16 | ZSWR4_ONESB | ZSWR4_PARENB);
270 __REG_WR(12, BPS_TO_TCONST(KBMS_PCLK / 16, 4800));
271 __REG_WR(13, 0);
272 __REG_WR(5, ZSWR5_TX_8 | ZSWR5_RTS);
273 __REG_WR(3, ZSWR3_RX_8);
274 __REG_WR(10, 0);
275 __REG_WR(11, ZSWR11_RXCLK_BAUD | ZSWR11_TXCLK_BAUD |
276 ZSWR11_TRXC_OUT_ENA | ZSWR11_TRXC_BAUD);
277 __REG_WR(14, ZSWR14_BAUD_FROM_PCLK | ZSWR14_BAUD_ENA);
278 __REG_WR(15, 0);
279 __REG_WR(5, ZSWR5_TX_8 | ZSWR5_TX_ENABLE);
280 __REG_WR(3, ZSWR3_RX_8 | ZSWR3_RX_ENABLE);
281 reset_retry *= 2;
282 } while (!kbd_reset(sc, reset_retry) && --retry > 0);
283
284 if (retry == 0) {
285 printf("keyboard initialize failed.\n");
286 return false;
287 }
288
289 return true;
290 }
291
292 bool
kbd_reset(struct kbms_softc * sc,int retry)293 kbd_reset(struct kbms_softc *sc, int retry)
294 {
295 #define __RETRY_LOOP(x, y) \
296 do { \
297 for (i = 0; (x) && (i < retry); i++) { \
298 (void)(y); \
299 delay(10); \
300 } \
301 if (i == retry) \
302 goto error; \
303 } while (/*CONSTCOND*/ 0)
304 int i;
305 struct kbms_reg *reg = &sc->sc_reg;
306 volatile uint8_t *csr = reg->kbd_csr;
307 volatile uint8_t *data = reg->kbd_data;
308 volatile uint8_t dummy;
309
310 __REG_WR(5, ZSWR5_DTR | ZSWR5_TX_8 | ZSWR5_TX_ENABLE);
311 delay(100);
312 __RETRY_LOOP(*csr & ZSRR0_RX_READY, dummy = *data);
313 *csr = 48;
314 __REG_WR(5, ZSWR5_TX_8 | ZSWR5_TX_ENABLE | ZSWR5_RTS);
315 __RETRY_LOOP((*csr & ZSRR0_RX_READY) == 0, 0);
316 *csr = 1;
317 __RETRY_LOOP((*csr & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) != 0, 0);
318 __RETRY_LOOP(*data != 0xa0, 0);
319 __RETRY_LOOP((*csr & ZSRR0_RX_READY) == 0, 0);
320 *csr = 1;
321 __RETRY_LOOP((*csr & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) != 0, 0);
322 __REG_WR(1, ZSWR1_RIE);
323
324 /* drain buffer */
325 (void)*reg->kbd_data;
326 #undef __RETRY_LOOP
327 return true;
328 error:
329 printf("retry failed.\n");
330 return false;
331 }
332
333 void
mouse_init(struct kbms_softc * sc)334 mouse_init(struct kbms_softc *sc)
335 {
336 struct kbms_reg *reg = &sc->sc_reg;
337 volatile uint8_t *csr = reg->mouse_csr;
338 volatile uint8_t *data = reg->mouse_data;
339 uint8_t d[] = { 0x02, 0x52, 0x53, 0x3b, 0x4d, 0x54, 0x2c, 0x36, 0x0d };
340 int i;
341
342 __REG_WR(9, ZSWR9_A_RESET);
343 delay(100);
344 __REG_WR(9, ZSWR9_MASTER_IE | ZSWR9_NO_VECTOR);
345 __REG_WR(1, 0);
346 __REG_WR(4, ZSWR4_CLK_X16 | ZSWR4_ONESB);
347 if (sc->sc_flags & 0x1) {
348 __REG_WR(12, BPS_TO_TCONST(KBMS_PCLK / 16, 4800));
349 __REG_WR(13, 0);
350 } else {
351 __REG_WR(12, BPS_TO_TCONST(KBMS_PCLK / 16, 1200));
352 __REG_WR(13, 0);
353 }
354 __REG_WR(5, ZSWR5_DTR | ZSWR5_TX_8 | ZSWR5_RTS);
355 __REG_WR(3, ZSWR3_RX_8);
356 __REG_WR(10, 0);
357 __REG_WR(11, ZSWR11_RXCLK_BAUD | ZSWR11_TXCLK_BAUD |
358 ZSWR11_TRXC_OUT_ENA | ZSWR11_TRXC_BAUD);
359 __REG_WR(14, ZSWR14_BAUD_FROM_PCLK);
360 __REG_WR(15, 0);
361 __REG_WR(5, ZSWR5_DTR | ZSWR5_TX_8 | ZSWR5_TX_ENABLE);
362 __REG_WR(3, ZSWR3_RX_8 | ZSWR3_RX_ENABLE);
363
364 if (sc->sc_flags & 0x1) {
365 for (i = 0; i < sizeof d; i++) {
366 while ((*csr & ZSRR0_TX_READY) == 0)
367 ;
368 *data = d[i];
369 }
370 }
371
372 __REG_WR(1, ZSWR1_RIE);
373 }
374
375 int
kbd_enable(void * arg,int on)376 kbd_enable(void *arg, int on)
377 {
378
379 /* always active */
380 return 0;
381 }
382
383 void
kbd_set_leds(void * arg,int leds)384 kbd_set_leds(void *arg, int leds)
385 {
386 struct kbms_softc *sc = arg;
387 struct kbms_reg *reg = &sc->sc_reg;
388
389 sc->sc_leds = leds;
390 if (leds & WSKBD_LED_CAPS)
391 *reg->kbd_data = 0x92;
392 else
393 *reg->kbd_data = 0x90;
394 }
395
396 int
kbd_ioctl(void * arg,u_long cmd,void * data,int flag,struct lwp * l)397 kbd_ioctl(void *arg, u_long cmd, void *data, int flag, struct lwp *l)
398 {
399 struct kbms_softc *sc = arg;
400
401 switch (cmd) {
402 case WSKBDIO_GTYPE:
403 *(int *)data = WSKBD_TYPE_EWS4800;
404 return 0;
405 case WSKBDIO_SETLEDS:
406 kbd_set_leds(arg, *(int *)data);
407 return 0;
408 case WSKBDIO_GETLEDS:
409 *(int *)data = sc->sc_leds;
410 return 0;
411 case WSKBDIO_COMPLEXBELL:
412 return 0;
413 }
414
415 return EPASSTHROUGH;
416 }
417
418 int
kbd_sbdio_cnattach(uint32_t csr,uint32_t data)419 kbd_sbdio_cnattach(uint32_t csr, uint32_t data)
420 {
421 struct kbms_softc __softc, *sc;
422 struct kbms_reg *reg;
423
424 kbms_consreg.kbd_csr = (void *)csr;
425 kbms_consreg.kbd_data = (void *)data;
426
427 /* setup dummy softc for kbd_init() */
428 sc = &__softc;
429 memset(sc, 0, sizeof(struct kbms_softc));
430 reg = &sc->sc_reg;
431 reg->kbd_csr = (void *)csr;
432 reg->kbd_data = (void *)data;
433
434 if (kbd_init(sc) == false)
435 return false;
436
437 wskbd_cnattach(&kbd_consops, &kbms_consreg, &kbd_keymapdata);
438 return true;
439 }
440
441 void
kbd_cngetc(void * arg,u_int * type,int * data)442 kbd_cngetc(void *arg, u_int *type, int *data)
443 {
444 struct kbms_reg *reg = (void *)arg;
445 int v;
446
447 while ((*reg->kbd_csr & ZSRR0_RX_READY) == 0)
448 ;
449 v = *reg->kbd_data;
450 *type = v & 0x80 ? WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN;
451 *data = v & 0x7f;
452 }
453
454 void
kbd_cnpollc(void * arg,int on)455 kbd_cnpollc(void *arg, int on)
456 {
457 static bool __polling = false;
458 static int s;
459
460 if (on && !__polling) {
461 s = splhigh(); /* Disable interrupt driven I/O */
462 __polling = true;
463 } else if (!on && __polling) {
464 __polling = false;
465 splx(s); /* Enable interrupt driven I/O */
466 }
467 }
468
469 int
mouse_enable(void * arg)470 mouse_enable(void *arg)
471 {
472
473 /* always active */
474 return 0;
475 }
476
477 void
mouse_disable(void * arg)478 mouse_disable(void *arg)
479 {
480
481 /* always active */
482 }
483
484 int
mouse_ioctl(void * v,u_long cmd,void * data,int flag,struct lwp * l)485 mouse_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
486 {
487
488 return EPASSTHROUGH;
489 }
490
491 #ifdef MOUSE_DEBUG
492 void
mouse_debug_print(u_int buttons,int x,int y)493 mouse_debug_print(u_int buttons, int x, int y)
494 {
495 #define MINMAX(x, min, max) \
496 ((x) < (min) ? (min) : ((x) > (max) ? (max) : (x)))
497 static int k, __x, __y;
498 int i, j;
499 char buf[64];
500
501 __x = MINMAX(__x + x, 0, FB_WIDTH);
502 __y = MINMAX(__y + y, 0, FB_HEIGHT);
503 *(uint8_t *)(fb.fb_addr + __x + __y * FB_LINEBYTES) = 0xff;
504
505 snprintf(buf, sizeof(buf), "%8d %8d", x, y);
506 for (i = 0; i < 64 && buf[i]; i++)
507 fb_drawchar(480 + i * 12, k, buf[i]);
508
509 i += 12;
510 for (j = 0x80; j > 0; j >>= 1, i++) {
511 fb_drawchar(480 + i * 12, k, buttons & j ? '|' : '.');
512 }
513
514 k += 24;
515 if (k > 1000)
516 k = 0;
517
518 }
519 #endif
520