weasel_pci.c revision 1.6 1 /* $NetBSD: weasel_pci.c,v 1.6 2005/06/28 00:28:42 thorpej Exp $ */
2
3 /*-
4 * Copyright (c) 2001 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Herb Peyerl and Jason Thorpe.
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 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39 /*
40 * Device driver for the control space on the Middle Digital, Inc.
41 * PCI-Weasel serial console board.
42 *
43 * Since the other functions of the PCI-Weasel already appear in
44 * PCI configuration space, we just need to hook up the watchdog
45 * timer.
46 */
47
48 #include <sys/cdefs.h>
49 __KERNEL_RCSID(0, "$NetBSD: weasel_pci.c,v 1.6 2005/06/28 00:28:42 thorpej Exp $");
50
51 #include <sys/param.h>
52 #include <sys/systm.h>
53 #include <sys/device.h>
54 #include <sys/wdog.h>
55 #include <sys/endian.h>
56
57 #include <machine/bus.h>
58
59 #include <dev/pci/pcireg.h>
60 #include <dev/pci/pcivar.h>
61 #include <dev/pci/pcidevs.h>
62
63 #include <dev/pci/weaselreg.h>
64
65 #include <dev/sysmon/sysmonvar.h>
66
67 struct weasel_softc {
68 struct device sc_dev; /* generic device glue */
69
70 bus_space_tag_t sc_st;
71 bus_space_handle_t sc_sh;
72
73 struct sysmon_wdog sc_smw;
74
75 int sc_wdog_armed;
76 int sc_wdog_period;
77 };
78
79 /* XXX */
80 extern int sysmon_wdog_setmode(struct sysmon_wdog *, int, u_int);
81
82 static int weasel_pci_wdog_setmode(struct sysmon_wdog *);
83 static int weasel_pci_wdog_tickle(struct sysmon_wdog *);
84
85 static int weasel_wait_response(struct weasel_softc *);
86 static int weasel_issue_command(struct weasel_softc *, uint8_t cmd);
87
88 static int weasel_pci_wdog_arm(struct weasel_softc *);
89 static int weasel_pci_wdog_disarm(struct weasel_softc *);
90
91 static int weasel_pci_wdog_query_state(struct weasel_softc *);
92
93 static int
94 weasel_pci_match(struct device *parent, struct cfdata *cf, void *aux)
95 {
96 struct pci_attach_args *pa = aux;
97
98 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_MIDDLE_DIGITAL &&
99 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_MIDDLE_DIGITAL_WEASEL_CONTROL)
100 return (1);
101
102 return (0);
103 }
104
105 static void
106 weasel_pci_attach(struct device *parent, struct device *self, void *aux)
107 {
108 struct weasel_softc *sc = (void *) self;
109 struct pci_attach_args *pa = aux;
110 struct weasel_config_block cfg;
111 const char *vers, *mode;
112 uint8_t v, *cp;
113 uint16_t cfg_size;
114 uint8_t buf[8];
115
116 printf(": PCI-Weasel watchdog timer\n");
117
118 if (pci_mapreg_map(pa, PCI_MAPREG_START,
119 PCI_MAPREG_TYPE_MEM|PCI_MAPREG_MEM_TYPE_32BIT, 0,
120 &sc->sc_st, &sc->sc_sh, NULL, NULL) != 0) {
121 printf("%s: unable to map device registers\n",
122 sc->sc_dev.dv_xname);
123 return;
124 }
125
126 /* Ping the Weasel to see if it's alive. */
127 if (weasel_issue_command(sc, OS_CMD_PING)) {
128 printf("%s: Weasel didn't respond to PING\n",
129 sc->sc_dev.dv_xname);
130 return;
131 }
132 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
133 if ((v = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD)) !=
134 OS_RET_PONG) {
135 printf("%s: unexpected PING response from Weasel: 0x%02x\n",
136 sc->sc_dev.dv_xname, v);
137 return;
138 }
139
140 /* Read the config block. */
141 if (weasel_issue_command(sc, OS_CMD_SHOW_CONFIG)) {
142 printf("%s: Weasel didn't respond to SHOW_CONFIG\n",
143 sc->sc_dev.dv_xname);
144 return;
145 }
146 cfg_size = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
147 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
148
149 if (++cfg_size != sizeof(cfg)) {
150 printf("%s: weird config block size from Weasel: 0x%03x\n",
151 sc->sc_dev.dv_xname, cfg_size);
152 return;
153 }
154
155 for (cp = (uint8_t *) &cfg; cfg_size != 0; cfg_size--) {
156 if (weasel_wait_response(sc)) {
157 printf("%s: Weasel stopped providing config block(%d)\n",
158 sc->sc_dev.dv_xname, cfg_size);
159 return;
160 }
161 *cp++ = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
162 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
163 }
164
165 switch (cfg.cfg_version) {
166 case CFG_VERSION_2:
167 vers="2";
168 switch (cfg.enable_duart_switching) {
169 case 0:
170 mode = "emulation";
171 break;
172 case 1:
173 mode = "serial";
174 break;
175 case 2:
176 mode = "autoswitch";
177 break;
178 default:
179 mode = "unknown";
180 }
181 break;
182
183 default:
184 vers = mode = NULL;
185 }
186
187 if (vers != NULL)
188 printf("%s: %s mode\n", sc->sc_dev.dv_xname,
189 mode);
190 else
191 printf("%s: unknown config version 0x%02x\n", sc->sc_dev.dv_xname,
192 cfg.cfg_version);
193
194 /*
195 * Fetch sw version.
196 */
197 if (weasel_issue_command(sc, OS_CMD_QUERY_SW_VER)) {
198 printf("%s: didn't reply to software version query.\n",
199 sc->sc_dev.dv_xname);
200 }
201 else {
202 v = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
203 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
204 if (v>7)
205 printf("%s: weird length for version string(%d).\n",
206 sc->sc_dev.dv_xname, v);
207 bzero(buf, sizeof(buf));
208 for (cp = buf; v != 0; v--) {
209 if (weasel_wait_response(sc)) {
210 printf("%s: Weasel stopped providing version\n",
211 sc->sc_dev.dv_xname);
212 }
213 *cp++ = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
214 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
215 }
216 printf("%s: sw: %s", sc->sc_dev.dv_xname, buf);
217 }
218 /*
219 * Fetch logic version.
220 */
221 if (weasel_issue_command(sc, OS_CMD_QUERY_L_VER)) {
222 printf("\n%s: didn't reply to logic version query.\n",
223 sc->sc_dev.dv_xname);
224 }
225 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
226 v = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
227 printf(" logic: %03d", v);
228 /*
229 * Fetch vga bios version.
230 */
231 if (weasel_issue_command(sc, OS_CMD_QUERY_VB_VER)) {
232 printf("\n%s: didn't reply to vga bios version query.\n",
233 sc->sc_dev.dv_xname);
234 }
235 v = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
236 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
237 printf(" vga bios: %d.%d", (v>>4), (v&0x0f));
238 /*
239 * Fetch hw version.
240 */
241 if (weasel_issue_command(sc, OS_CMD_QUERY_HW_VER)) {
242 printf("\n%s: didn't reply to hardware version query.\n",
243 sc->sc_dev.dv_xname);
244 }
245 v = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
246 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
247 printf(" hw: %d.%d", (v>>4), (v&0x0f));
248
249 printf("\n%s: break passthrough %s", sc->sc_dev.dv_xname,
250 cfg.break_passthru ? "enabled" : "disabled");
251
252 if ((sc->sc_wdog_armed = weasel_pci_wdog_query_state(sc)) == -1)
253 sc->sc_wdog_armed = 0;
254
255 /* Weasel is big-endian */
256 sc->sc_wdog_period = be16toh(cfg.wdt_msec) / 1000;
257
258 printf(", watchdog timer %d sec.\n", sc->sc_wdog_period);
259 sc->sc_smw.smw_name = "weasel";
260 sc->sc_smw.smw_cookie = sc;
261 sc->sc_smw.smw_setmode = weasel_pci_wdog_setmode;
262 sc->sc_smw.smw_tickle = weasel_pci_wdog_tickle;
263 sc->sc_smw.smw_period = sc->sc_wdog_period;
264
265 if (sysmon_wdog_register(&sc->sc_smw) != 0)
266 printf("%s: unable to register PC-Weasel watchdog "
267 "with sysmon\n", sc->sc_dev.dv_xname);
268 }
269
270 CFATTACH_DECL(weasel_pci, sizeof(struct weasel_softc),
271 weasel_pci_match, weasel_pci_attach, NULL, NULL);
272
273 static int
274 weasel_wait_response(struct weasel_softc *sc)
275 {
276 int i;
277
278 for (i = 10000; i ; i--) {
279 delay(100);
280 if (bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS) ==
281 OS_WS_HOST_READ)
282 return(0);
283 }
284 return (1);
285 }
286
287 static int
288 weasel_issue_command(struct weasel_softc *sc, uint8_t cmd)
289 {
290 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_WR, cmd);
291 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_HOST_STATUS, OS_HS_WEASEL_READ);
292 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
293 return (weasel_wait_response(sc));
294 }
295
296 static int
297 weasel_pci_wdog_setmode(struct sysmon_wdog *smw)
298 {
299 struct weasel_softc *sc = smw->smw_cookie;
300 int error = 0;
301
302 if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) {
303 error = weasel_pci_wdog_disarm(sc);
304 } else {
305 if (smw->smw_period == WDOG_PERIOD_DEFAULT)
306 smw->smw_period = sc->sc_wdog_period;
307 else if (smw->smw_period != sc->sc_wdog_period) {
308 /* Can't change the period on the Weasel. */
309 return (EINVAL);
310 }
311 error = weasel_pci_wdog_arm(sc);
312 weasel_pci_wdog_tickle(smw);
313 }
314
315 return (error);
316 }
317
318 static int
319 weasel_pci_wdog_tickle(struct sysmon_wdog *smw)
320 {
321 struct weasel_softc *sc = smw->smw_cookie;
322 u_int8_t reg;
323 int x;
324 int s;
325 int error = 0;
326
327 s = splhigh();
328 /*
329 * first we tickle the watchdog
330 */
331 reg = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_CHALLENGE);
332 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_RESPONSE, ~reg);
333
334 /*
335 * then we check to make sure the weasel is still armed. If someone
336 * has rebooted the weasel for whatever reason (firmware update),
337 * then the watchdog timer would no longer be armed and we'd be
338 * servicing nothing. Let the user know that the machine is no
339 * longer being monitored by the weasel.
340 */
341 if((x = weasel_pci_wdog_query_state(sc)) == -1)
342 error = EIO;
343 if (x == 1) {
344 error = 0;
345 } else {
346 printf("%s: Watchdog timer disabled on PC/Weasel! Disarming wdog.\n",
347 sc->sc_dev.dv_xname);
348 sc->sc_wdog_armed = 0;
349 sysmon_wdog_setmode(smw, WDOG_MODE_DISARMED, 0);
350 error = 1;
351 }
352 splx(s);
353
354 return (error);
355 }
356
357 static int
358 weasel_pci_wdog_arm(struct weasel_softc *sc)
359 {
360 u_int8_t reg;
361 int x;
362 int s;
363 int error = 0;
364
365 s = splhigh();
366 if (weasel_issue_command(sc, OS_CMD_WDT_ENABLE)) {
367 printf("%s: no reply to watchdog enable. Check Weasel \"Allow Watchdog\" setting.\n",
368 sc->sc_dev.dv_xname);
369 error = EIO;
370 }
371 reg = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
372 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
373
374 /*
375 * Ensure that the Weasel thinks it's in the same mode we want it to
376 * be in. EIO if not.
377 */
378 x = weasel_pci_wdog_query_state(sc);
379 switch (x) {
380 case -1:
381 error = EIO;
382 break;
383 case 0:
384 sc->sc_wdog_armed = 0;
385 error = EIO;
386 break;
387 case 1:
388 sc->sc_wdog_armed = 1;
389 error = 0;
390 break;
391 }
392
393 splx(s);
394 return(error);
395 }
396
397
398 static int
399 weasel_pci_wdog_disarm(struct weasel_softc *sc)
400 {
401 u_int8_t reg;
402 int x;
403 int s;
404 int error = 0;
405
406 s = splhigh();
407
408 if (weasel_issue_command(sc, OS_CMD_WDT_DISABLE)) {
409 printf("%s: didn't reply to watchdog disable.\n",
410 sc->sc_dev.dv_xname);
411 error = EIO;
412 }
413 reg = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
414 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
415
416 /*
417 * Ensure that the Weasel thinks it's in the same mode we want it to
418 * be in. EIO if not.
419 */
420 x = weasel_pci_wdog_query_state(sc);
421 switch (x) {
422 case -1:
423 error = EIO;
424 break;
425 case 0:
426 sc->sc_wdog_armed = 0;
427 error = 0;
428 break;
429 case 1:
430 sc->sc_wdog_armed = 1;
431 error = EIO;
432 break;
433 }
434
435 splx(s);
436 return(error);
437 }
438
439 static int
440 weasel_pci_wdog_query_state(struct weasel_softc *sc)
441 {
442
443 u_int8_t v;
444
445 if (weasel_issue_command(sc, OS_CMD_WDT_QUERY)) {
446 printf("%s: didn't reply to watchdog state query.\n",
447 sc->sc_dev.dv_xname);
448 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
449 return(-1);
450 }
451 v = bus_space_read_1(sc->sc_st, sc->sc_sh, WEASEL_DATA_RD);
452 bus_space_write_1(sc->sc_st, sc->sc_sh, WEASEL_STATUS, 0);
453 return(v);
454 }
455