367 lines
9.1 KiB
C
367 lines
9.1 KiB
C
/* $NetBSD: weasel_isa.c,v 1.5 2008/04/08 20:08:50 cegger Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2000 Zembu Labs, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Author: Jason R. Thorpe <thorpej@zembu.com>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Zembu Labs, Inc.
|
|
* 4. Neither the name of Zembu Labs nor the names of its employees may
|
|
* be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY ZEMBU LABS, INC. ``AS IS'' AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WAR-
|
|
* RANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DIS-
|
|
* CLAIMED. IN NO EVENT SHALL ZEMBU LABS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* Device driver for the Middle Digital, Inc. PC-Weasel serial
|
|
* console board.
|
|
*
|
|
* We're glued into the MDA display driver (`pcdisplay'), and
|
|
* handle things like the watchdog timer.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: weasel_isa.c,v 1.5 2008/04/08 20:08:50 cegger Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/device.h>
|
|
#include <sys/wdog.h>
|
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <dev/isa/weaselreg.h>
|
|
#include <dev/isa/weaselvar.h>
|
|
|
|
#include <dev/sysmon/sysmonvar.h>
|
|
|
|
int weasel_isa_wdog_setmode(struct sysmon_wdog *);
|
|
int weasel_isa_wdog_tickle(struct sysmon_wdog *);
|
|
int weasel_isa_wdog_arm_disarm(struct weasel_handle *, u_int8_t);
|
|
int weasel_isa_wdog_query_state(struct weasel_handle *);
|
|
|
|
|
|
void pcweaselattach(int);
|
|
|
|
/* ARGSUSED */
|
|
void
|
|
pcweaselattach(int count)
|
|
{
|
|
|
|
/* Nothing to do; pseudo-device glue. */
|
|
}
|
|
|
|
void
|
|
weasel_isa_init(struct weasel_handle *wh)
|
|
{
|
|
struct weasel_config_block cfg;
|
|
int i, j;
|
|
u_int8_t *cp, sum;
|
|
const char *vers, *mode;
|
|
|
|
/*
|
|
* Write a NOP to the command register and see if it
|
|
* reverts back to READY within 1.5 seconds.
|
|
*/
|
|
bus_space_write_1(wh->wh_st, wh->wh_sh, WEASEL_MISC_COMMAND, OS_NOP);
|
|
for (i = 0; i < 1500; i++) {
|
|
delay(1000);
|
|
sum = bus_space_read_1(wh->wh_st, wh->wh_sh,
|
|
WEASEL_MISC_COMMAND);
|
|
if (sum == OS_READY)
|
|
break;
|
|
}
|
|
if (sum != OS_READY) {
|
|
/* This is not a Weasel. */
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* It can take a while for the config block to be copied
|
|
* into the offscreen area, as the Weasel may be busy
|
|
* sending data to the terminal. Wait up to 3 seconds,
|
|
* reading the block each time, and breaking out of the
|
|
* loop once the checksum passes.
|
|
*/
|
|
|
|
bus_space_write_1(wh->wh_st, wh->wh_sh, WEASEL_MISC_COMMAND,
|
|
OS_CONFIG_COPY);
|
|
|
|
/* ...one second to get it started... */
|
|
delay(1000 * 1000);
|
|
|
|
/* ...two seconds to let it finish... */
|
|
for (i = 0; i < 2000; i++) {
|
|
delay(1000);
|
|
bus_space_read_region_1(wh->wh_st, wh->wh_sh,
|
|
WEASEL_CONFIG_BLOCK, &cfg, sizeof(cfg));
|
|
/*
|
|
* Compute the checksum of the config block.
|
|
*/
|
|
for (cp = (u_int8_t *)&cfg, j = 0, sum = 1;
|
|
j < (sizeof(cfg) - 1); j++)
|
|
sum += cp[j];
|
|
if (sum == cfg.cksum)
|
|
break;
|
|
}
|
|
|
|
if (sum != cfg.cksum) {
|
|
/*
|
|
* Checksum doesn't match; either it's not a Weasel,
|
|
* or something is wrong with it.
|
|
*/
|
|
printf("%s: PC-Weasel config block checksum mismatch "
|
|
"0x%02x != 0x%02x\n", device_xname(wh->wh_parent),
|
|
sum, cfg.cksum);
|
|
return;
|
|
}
|
|
|
|
switch (cfg.cfg_version) {
|
|
case CFG_VERSION_1_0:
|
|
vers = "1.0";
|
|
switch (cfg.enable_duart_switching) {
|
|
case 0:
|
|
mode = "emulation";
|
|
break;
|
|
|
|
case 1:
|
|
mode = "autoswitch";
|
|
break;
|
|
|
|
default:
|
|
mode = "unknown";
|
|
}
|
|
break;
|
|
|
|
case CFG_VERSION_1_1:
|
|
vers = "1.1";
|
|
switch (cfg.enable_duart_switching) {
|
|
case 0:
|
|
mode = "emulation";
|
|
break;
|
|
|
|
case 1:
|
|
mode = "serial";
|
|
break;
|
|
|
|
case 2:
|
|
mode = "autoswitch";
|
|
break;
|
|
|
|
default:
|
|
mode = "unknown";
|
|
}
|
|
break;
|
|
|
|
default:
|
|
vers = mode = NULL;
|
|
}
|
|
|
|
printf("%s: PC-Weasel, ", device_xname(wh->wh_parent));
|
|
if (vers != NULL)
|
|
printf("version %s, %s mode", vers, mode);
|
|
else
|
|
printf("unknown version 0x%x", cfg.cfg_version);
|
|
printf("\n");
|
|
|
|
printf("%s: break passthrough %s", device_xname(wh->wh_parent),
|
|
cfg.break_passthru ? "enabled" : "disabled");
|
|
if (cfg.wdt_msec == 0) {
|
|
/*
|
|
* Old firmware -- these Weasels have
|
|
* a 3000ms watchdog period.
|
|
*/
|
|
cfg.wdt_msec = 3000;
|
|
}
|
|
|
|
if ((wh->wh_wdog_armed = weasel_isa_wdog_query_state(wh)) == -1)
|
|
wh->wh_wdog_armed = 0;
|
|
wh->wh_wdog_period = cfg.wdt_msec / 1000;
|
|
|
|
printf(", watchdog interval %d sec.\n", wh->wh_wdog_period);
|
|
|
|
/*
|
|
* Always register the Weasel watchdog timer in case user decides
|
|
* to set 'allow watchdog' to 'YES' after the machine has booted.
|
|
*/
|
|
wh->wh_smw.smw_name = "weasel";
|
|
wh->wh_smw.smw_cookie = wh;
|
|
wh->wh_smw.smw_setmode = weasel_isa_wdog_setmode;
|
|
wh->wh_smw.smw_tickle = weasel_isa_wdog_tickle;
|
|
wh->wh_smw.smw_period = wh->wh_wdog_period;
|
|
|
|
if (sysmon_wdog_register(&wh->wh_smw) != 0)
|
|
aprint_error_dev(wh->wh_parent, "unable to register PC-Weasel watchdog "
|
|
"with sysmon\n");
|
|
}
|
|
|
|
int
|
|
weasel_isa_wdog_setmode(struct sysmon_wdog *smw)
|
|
{
|
|
struct weasel_handle *wh = smw->smw_cookie;
|
|
int error = 0;
|
|
|
|
if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) {
|
|
error = weasel_isa_wdog_arm_disarm(wh, WDT_DISABLE);
|
|
} else {
|
|
if (smw->smw_period == WDOG_PERIOD_DEFAULT)
|
|
smw->smw_period = wh->wh_wdog_period;
|
|
else if (smw->smw_period != wh->wh_wdog_period) {
|
|
/* Can't change the period on the Weasel. */
|
|
return (EINVAL);
|
|
}
|
|
error = weasel_isa_wdog_arm_disarm(wh, WDT_ENABLE);
|
|
weasel_isa_wdog_tickle(smw);
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
int
|
|
weasel_isa_wdog_tickle(struct sysmon_wdog *smw)
|
|
{
|
|
struct weasel_handle *wh = smw->smw_cookie;
|
|
u_int8_t reg;
|
|
int x;
|
|
int s;
|
|
int error = 0;
|
|
|
|
s = splhigh();
|
|
/*
|
|
* first we tickle the watchdog
|
|
*/
|
|
reg = bus_space_read_1(wh->wh_st, wh->wh_sh, WEASEL_WDT_TICKLE);
|
|
bus_space_write_1(wh->wh_st, wh->wh_sh, WEASEL_WDT_TICKLE, ~reg);
|
|
|
|
/*
|
|
* then we check to make sure the weasel is still armed. If someone
|
|
* has rebooted the weasel for whatever reason (firmware update),
|
|
* then the watchdog timer would no longer be armed and we'd be
|
|
* servicing nothing. Let the user know that the machine is no
|
|
* longer being monitored by the weasel.
|
|
*/
|
|
if((x = weasel_isa_wdog_query_state(wh)) == -1)
|
|
error = EIO;
|
|
if (x == 1) {
|
|
error = 0;
|
|
} else {
|
|
aprint_error_dev(wh->wh_parent, "Watchdog timer disabled on PC/Weasel! Disarming wdog.\n");
|
|
wh->wh_wdog_armed = 0;
|
|
error = 1;
|
|
}
|
|
splx(s);
|
|
|
|
return (error);
|
|
}
|
|
|
|
int
|
|
weasel_isa_wdog_arm_disarm(struct weasel_handle *wh, u_int8_t mode)
|
|
{
|
|
u_int8_t reg;
|
|
int timeout;
|
|
int s, x;
|
|
int error = 0;
|
|
|
|
s = splhigh();
|
|
|
|
bus_space_write_1(wh->wh_st, wh->wh_sh, WEASEL_WDT_SEMAPHORE,
|
|
WDT_ATTENTION);
|
|
for (timeout = 5000; timeout; timeout--) {
|
|
delay(1500);
|
|
reg = bus_space_read_1(wh->wh_st, wh->wh_sh,
|
|
WEASEL_WDT_SEMAPHORE);
|
|
if (reg == WDT_OK)
|
|
break;
|
|
}
|
|
if (timeout == 0) {
|
|
splx(s);
|
|
return(EIO);
|
|
}
|
|
bus_space_write_1(wh->wh_st, wh->wh_sh, WEASEL_WDT_SEMAPHORE, mode);
|
|
for (timeout = 500 ; timeout; timeout--) {
|
|
delay(1500);
|
|
reg = bus_space_read_1(wh->wh_st, wh->wh_sh,
|
|
WEASEL_WDT_SEMAPHORE);
|
|
if (reg != mode)
|
|
break;
|
|
}
|
|
if (timeout == 0) {
|
|
splx(s);
|
|
return(EIO);
|
|
}
|
|
bus_space_write_1(wh->wh_st, wh->wh_sh, WEASEL_WDT_SEMAPHORE, ~reg);
|
|
for (timeout = 500; timeout; timeout--) {
|
|
delay(1500);
|
|
reg = bus_space_read_1(wh->wh_st, wh->wh_sh,
|
|
WEASEL_WDT_SEMAPHORE);
|
|
if (reg == WDT_OK)
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Ensure that the Weasel thinks it's in the same mode we want it to
|
|
* be in. EIO if not.
|
|
*/
|
|
x = weasel_isa_wdog_query_state(wh);
|
|
switch (x) {
|
|
case -1:
|
|
error = EIO;
|
|
break;
|
|
case 0:
|
|
if (mode == WDT_DISABLE) {
|
|
wh->wh_wdog_armed = 0;
|
|
error = 0;
|
|
} else
|
|
error = EIO;
|
|
break;
|
|
case 1:
|
|
if (mode == WDT_ENABLE) {
|
|
wh->wh_wdog_armed = 1;
|
|
error = 0;
|
|
} else
|
|
error = EIO;
|
|
break;
|
|
}
|
|
|
|
splx(s);
|
|
return(error);
|
|
}
|
|
|
|
int
|
|
weasel_isa_wdog_query_state(struct weasel_handle *wh)
|
|
{
|
|
int timeout, reg;
|
|
|
|
bus_space_write_1(wh->wh_st, wh->wh_sh,
|
|
WEASEL_MISC_COMMAND, OS_WDT_QUERY);
|
|
for (timeout = 0; timeout < 1500; timeout++) {
|
|
delay(1000);
|
|
reg = bus_space_read_1(wh->wh_st, wh->wh_sh,
|
|
WEASEL_MISC_COMMAND);
|
|
if (reg == OS_READY)
|
|
break;
|
|
}
|
|
return(bus_space_read_1(wh->wh_st, wh->wh_sh, WEASEL_MISC_RESPONSE));
|
|
}
|