1 /* $NetBSD: adb_bus.c,v 1.12 2021/08/07 16:19:09 thorpej Exp $ */
2
3 /*-
4 * Copyright (c) 2006 Michael Lorenz
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __KERNEL_RCSID(0, "$NetBSD: adb_bus.c,v 1.12 2021/08/07 16:19:09 thorpej Exp $");
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/kernel.h>
35 #include <sys/device.h>
36 #include <sys/proc.h>
37
38 #include <sys/bus.h>
39 #include <machine/autoconf.h>
40 #include <dev/adb/adbvar.h>
41
42 #include "adbdebug.h"
43
44 #ifdef ADB_DEBUG
45 #define DPRINTF printf
46 #else
47 #define DPRINTF while (0) printf
48 #endif
49
50 static int nadb_match(device_t, cfdata_t, void *);
51 static void nadb_attach(device_t, device_t, void *);
52
53 struct nadb_softc {
54 device_t sc_dev;
55 struct adb_bus_accessops *sc_ops;
56 uint32_t sc_msg;
57 uint32_t sc_event;
58 struct adb_device sc_devtable[16];
59 int sc_free; /* highest free address */
60 int sc_len; /* length of received message */
61 uint8_t sc_data[16];
62 };
63
64 CFATTACH_DECL_NEW(nadb, sizeof(struct nadb_softc),
65 nadb_match, nadb_attach, NULL, NULL);
66
67 static void nadb_init(device_t);
68 static void nadb_handler(void *, int, uint8_t *);
69 static void nadb_send_sync(void *, int, int, uint8_t *);
70 static int nadb_register(struct nadb_softc *, int, int, int);
71 static void nadb_remove(struct nadb_softc *, int);
72 static int nadb_devprint(void *, const char *);
73
74 static int
nadb_match(device_t parent,cfdata_t cf,void * aux)75 nadb_match(device_t parent, cfdata_t cf, void *aux)
76 {
77
78 return 1;
79 }
80
81 static void
nadb_attach(device_t parent,device_t self,void * aux)82 nadb_attach(device_t parent, device_t self, void *aux)
83 {
84 struct nadb_softc *sc = device_private(self);
85 struct adb_bus_accessops *ops = aux;
86
87 sc->sc_dev = self;
88 sc->sc_ops = ops;
89 sc->sc_ops->set_handler(sc->sc_ops->cookie, nadb_handler, sc);
90
91 config_interrupts(self, nadb_init);
92 }
93
94 static void
nadb_init(device_t dev)95 nadb_init(device_t dev)
96 {
97 struct nadb_softc *sc = device_private(dev);
98 struct adb_attach_args aaa;
99 int i, last_moved_up, devmask = 0;
100 uint8_t cmd[2];
101
102 sc->sc_free = 15;
103 for (i = 0; i < 16; i++) {
104 sc->sc_devtable[i].original_addr = 0;
105 sc->sc_devtable[i].current_addr = 0;
106 sc->sc_devtable[i].handler_id = 0;
107 sc->sc_devtable[i].cookie = NULL;
108 sc->sc_devtable[i].handler = NULL;
109 }
110
111 /* bus reset (?) */
112 nadb_send_sync(sc, 0, 0, NULL);
113 delay(200000);
114
115 /*
116 * scan only addresses 1 - 7
117 * if something responds move it to >7 and see if something else is
118 * there. If not move the previous one back.
119 * XXX we don't check for collisions if we use up all addresses >7
120 */
121 for (i = 1; i < 8; i++) {
122 DPRINTF("\n%d: ", i);
123 last_moved_up = 0;
124 nadb_send_sync(sc, ADBTALK(i, 3), 0, NULL);
125 /* found something? */
126 while (sc->sc_len > 2) {
127 /* something answered, so move it up */
128
129 DPRINTF("Found a device on address %d\n", i);
130 cmd[0] = sc->sc_free | 0x60;
131 cmd[1] = 0xfe;
132 nadb_send_sync(sc, ADBLISTEN(i, 3), 2, cmd);
133
134 /* see if it really moved */
135 nadb_send_sync(sc, ADBTALK(sc->sc_free, 3), 0, NULL);
136 if (sc->sc_len > 2) {
137 /* ok */
138 DPRINTF("moved it to %d\n", sc->sc_free);
139 nadb_register(sc, sc->sc_free, i, sc->sc_data[3]);
140 last_moved_up = sc->sc_free;
141 sc->sc_free--;
142 }
143 /* see if something else is there */
144 nadb_send_sync(sc, ADBTALK(i, 3), 0, NULL);
145 }
146 if (last_moved_up != 0) {
147 /* move last one back to original address */
148 cmd[0] = i | 0x60;
149 cmd[1] = 0xfe;
150 nadb_send_sync(sc, ADBLISTEN(last_moved_up, 3), 2, cmd);
151
152 nadb_send_sync(sc, ADBTALK(i, 3), 0, NULL);
153 if (sc->sc_len > 2) {
154 DPRINTF("moved %d back to %d\n", last_moved_up, i);
155 nadb_remove(sc, last_moved_up);
156 nadb_register(sc, i, i, sc->sc_data[3]);
157 sc->sc_free = last_moved_up;
158 }
159 }
160 }
161
162 /* now attach the buggers we've found */
163 aaa.ops = sc->sc_ops;
164 for (i = 0; i < 16; i++) {
165 if (sc->sc_devtable[i].current_addr != 0) {
166 DPRINTF("dev: %d %d %02x\n",
167 sc->sc_devtable[i].current_addr,
168 sc->sc_devtable[i].original_addr,
169 sc->sc_devtable[i].handler_id);
170 aaa.dev = &sc->sc_devtable[i];
171 if (config_found(sc->sc_dev, &aaa, nadb_devprint,
172 CFARGS_NONE)) {
173 devmask |= (1 << i);
174 } else {
175 aprint_normal(" not configured\n");
176 }
177 }
178 }
179 /* now enable autopolling */
180 DPRINTF("devmask: %04x\n", devmask);
181 sc->sc_ops->autopoll(sc->sc_ops->cookie, devmask);
182 }
183
184 int
nadb_print(void * aux,const char * what)185 nadb_print(void *aux, const char *what)
186 {
187 aprint_normal(": Apple Desktop Bus\n");
188 return 0;
189 }
190
191 static int
nadb_devprint(void * aux,const char * what)192 nadb_devprint(void *aux, const char *what)
193 {
194 struct adb_attach_args *aaa = aux;
195
196 if (what == NULL)
197 return 0;
198
199 switch(aaa->dev->original_addr) {
200 case 2:
201 aprint_normal("%s: ADB Keyboard", what);
202 break;
203 case 3:
204 aprint_normal("%s: ADB relative pointing device", what);
205 break;
206 default:
207 aprint_normal("%s: something from address %d:%02x",
208 what,
209 aaa->dev->original_addr,
210 aaa->dev->handler_id);
211 break;
212 }
213 return 0;
214 }
215
216 static void
nadb_handler(void * cookie,int len,uint8_t * data)217 nadb_handler(void *cookie, int len, uint8_t *data)
218 {
219 struct nadb_softc *sc = cookie;
220 struct adb_device *dev;
221 int addr;
222
223 #ifdef ADB_DEBUG
224 int i;
225 printf("adb:");
226 for (i = 0; i < len; i++) {
227 printf(" %02x", data[i]);
228 }
229 printf("\n");
230 #endif
231
232 addr = data[1] >> 4;
233 dev = &sc->sc_devtable[addr];
234 if ((dev->current_addr != 0) && (dev->handler != NULL)) {
235
236 dev->handler(dev->cookie, len, data);
237 } else {
238 sc->sc_msg = 1;
239 sc->sc_len = len;
240 memcpy(sc->sc_data, data, len);
241 wakeup(&sc->sc_event);
242 }
243 }
244
245 static void
nadb_send_sync(void * cookie,int command,int len,uint8_t * data)246 nadb_send_sync(void *cookie, int command, int len, uint8_t *data)
247 {
248 struct nadb_softc *sc = cookie;
249
250 sc->sc_msg = 0;
251 sc->sc_ops->send(sc->sc_ops->cookie, 0, command, len, data);
252 while (sc->sc_msg == 0) {
253 tsleep(&sc->sc_event, 0, "adb_send", 100);
254 }
255 }
256
257 static int
nadb_register(struct nadb_softc * sc,int current,int orig,int handler)258 nadb_register(struct nadb_softc *sc, int current, int orig, int handler)
259 {
260 struct adb_device *dev;
261
262 if ((current > 0) && (current < 16)) {
263 dev = &sc->sc_devtable[current];
264 if (dev->current_addr != 0)
265 /* in use! */
266 return -1;
267 dev->current_addr = current;
268 dev->original_addr = orig;
269 dev->handler_id = handler;
270 return 0;
271 }
272 return -1;
273 }
274
275 static void
nadb_remove(struct nadb_softc * sc,int addr)276 nadb_remove(struct nadb_softc *sc, int addr)
277 {
278
279 if ((addr > 0) && (addr < 16)) {
280 sc->sc_devtable[addr].current_addr = 0;
281 sc->sc_devtable[addr].original_addr = 0;
282 sc->sc_devtable[addr].handler_id = 0;
283 }
284 }
285