FreeBSD/Linux Kernel Cross Reference
sys/dev/adb/adb_bus.c
1 /* $NetBSD: adb_bus.c,v 1.8 2008/04/29 06:53:02 martin 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.8 2008/04/29 06:53:02 martin 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 devmask |= (1 << i);
173 } else {
174 printf(" not configured\n");
175 }
176 }
177 }
178 /* now enable autopolling */
179 DPRINTF("devmask: %04x\n", devmask);
180 sc->sc_ops->autopoll(sc->sc_ops->cookie, devmask);
181 }
182
183 int
184 nadb_print(void *aux, const char *what)
185 {
186 printf(": Apple Desktop Bus\n");
187 return 0;
188 }
189
190 static int
191 nadb_devprint(void *aux, const char *what)
192 {
193 struct adb_attach_args *aaa = aux;
194
195 if (what == NULL)
196 return 0;
197
198 switch(aaa->dev->original_addr) {
199 case 2:
200 printf("%s: ADB Keyboard", what);
201 break;
202 case 3:
203 printf("%s: ADB relative pointing device", what);
204 break;
205 default:
206 printf("%s: something from address %d:%02x",
207 what,
208 aaa->dev->original_addr,
209 aaa->dev->handler_id);
210 break;
211 }
212 return 0;
213 }
214
215 static void
216 nadb_handler(void *cookie, int len, uint8_t *data)
217 {
218 struct nadb_softc *sc = cookie;
219 struct adb_device *dev;
220 int addr;
221
222 #ifdef ADB_DEBUG
223 int i;
224 printf("adb:");
225 for (i = 0; i < len; i++) {
226 printf(" %02x", data[i]);
227 }
228 printf("\n");
229 #endif
230
231 addr = data[1] >> 4;
232 dev = &sc->sc_devtable[addr];
233 if ((dev->current_addr != 0) && (dev->handler != NULL)) {
234
235 dev->handler(dev->cookie, len, data);
236 } else {
237 sc->sc_msg = 1;
238 sc->sc_len = len;
239 memcpy(sc->sc_data, data, len);
240 wakeup(&sc->sc_event);
241 }
242 }
243
244 static void
245 nadb_send_sync(void *cookie, int command, int len, uint8_t *data)
246 {
247 struct nadb_softc *sc = cookie;
248
249 sc->sc_msg = 0;
250 sc->sc_ops->send(sc->sc_ops->cookie, 0, command, len, data);
251 while (sc->sc_msg == 0) {
252 tsleep(&sc->sc_event, 0, "adb_send", 100);
253 }
254 }
255
256 static int
257 nadb_register(struct nadb_softc *sc, int current, int orig, int handler)
258 {
259 struct adb_device *dev;
260
261 if ((current > 0) && (current < 16)) {
262 dev = &sc->sc_devtable[current];
263 if (dev->current_addr != 0)
264 /* in use! */
265 return -1;
266 dev->current_addr = current;
267 dev->original_addr = orig;
268 dev->handler_id = handler;
269 return 0;
270 }
271 return -1;
272 }
273
274 static void
275 nadb_remove(struct nadb_softc *sc, int addr)
276 {
277
278 if ((addr > 0) && (addr < 16)) {
279 sc->sc_devtable[addr].current_addr = 0;
280 sc->sc_devtable[addr].original_addr = 0;
281 sc->sc_devtable[addr].handler_id = 0;
282 }
283 }
Cache object: 1f9f4441e0f668fc991cad9027543808
|