adb_bus.c revision 1.12
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 75 nadb_match(device_t parent, cfdata_t cf, void *aux) 76 { 77 78 return 1; 79 } 80 81 static void 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 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 185 nadb_print(void *aux, const char *what) 186 { 187 aprint_normal(": Apple Desktop Bus\n"); 188 return 0; 189 } 190 191 static int 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 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 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 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 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
Indexes created Mon Sep 22 13:09:51 GMT 2025