546 lines
16 KiB
C
546 lines
16 KiB
C
/* $NetBSD: tspld.c,v 1.19 2009/03/14 21:04:08 dsl Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2004 Jesse Off
|
|
* All rights reserved.
|
|
*
|
|
* 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 the NetBSD
|
|
* Foundation, Inc. and its contributors.
|
|
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: tspld.c,v 1.19 2009/03/14 21:04:08 dsl Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/callout.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/device.h>
|
|
#include <sys/wdog.h>
|
|
|
|
#include <machine/bus.h>
|
|
#include <machine/cpu.h>
|
|
#include <machine/autoconf.h>
|
|
#include "isa.h"
|
|
#if NISA > 0
|
|
#include <dev/isa/isavar.h>
|
|
#include <machine/isa_machdep.h>
|
|
#endif
|
|
|
|
#include <evbarm/tsarm/tsarmreg.h>
|
|
#include <evbarm/tsarm/tspldvar.h>
|
|
#include <arm/ep93xx/ep93xxvar.h>
|
|
#include <arm/ep93xx/ep93xxreg.h>
|
|
#include <arm/ep93xx/epgpioreg.h>
|
|
#include <arm/arm32/machdep.h>
|
|
#include <arm/cpufunc.h>
|
|
#include <dev/sysmon/sysmonvar.h>
|
|
|
|
int tspldmatch (struct device *, struct cfdata *, void *);
|
|
void tspldattach (struct device *, struct device *, void *);
|
|
static int tspld_wdog_setmode (struct sysmon_wdog *);
|
|
static int tspld_wdog_tickle (struct sysmon_wdog *);
|
|
int tspld_search (struct device *, struct cfdata *, const int *, void *);
|
|
int tspld_print (void *, const char *);
|
|
void boardtemp_poll (void *);
|
|
|
|
struct tspld_softc {
|
|
struct device sc_dev;
|
|
bus_space_tag_t sc_iot;
|
|
bus_space_handle_t sc_wdogfeed_ioh;
|
|
bus_space_handle_t sc_wdogctrl_ioh;
|
|
struct sysmon_wdog sc_wdog;
|
|
bus_space_handle_t sc_ssph;
|
|
bus_space_handle_t sc_gpioh;
|
|
unsigned const char * sc_com2mode;
|
|
unsigned const char * sc_model;
|
|
unsigned char sc_pldrev[4];
|
|
uint32_t sc_rs485;
|
|
uint32_t sc_adc;
|
|
uint32_t sc_jp[6];
|
|
uint32_t sc_blaster_present;
|
|
uint32_t sc_blaster_boot;
|
|
uint32_t boardtemp;
|
|
uint32_t boardtemp_5s;
|
|
uint32_t boardtemp_30s;
|
|
struct callout boardtemp_callout;
|
|
};
|
|
|
|
CFATTACH_DECL(tspld, sizeof(struct tspld_softc),
|
|
tspldmatch, tspldattach, NULL, NULL);
|
|
|
|
void tspld_callback(struct device *);
|
|
|
|
#define GPIO_GET(x) bus_space_read_4(sc->sc_iot, sc->sc_gpioh, \
|
|
(EP93XX_GPIO_ ## x))
|
|
|
|
#define GPIO_SET(x, y) bus_space_write_4(sc->sc_iot, sc->sc_gpioh, \
|
|
(EP93XX_GPIO_ ## x), (y))
|
|
|
|
#define GPIO_SETBITS(x, y) bus_space_write_4(sc->sc_iot, sc->sc_gpioh, \
|
|
(EP93XX_GPIO_ ## x), GPIO_GET(x) | (y))
|
|
|
|
#define GPIO_CLEARBITS(x, y) bus_space_write_4(sc->sc_iot, sc->sc_gpioh, \
|
|
(EP93XX_GPIO_ ## x), GPIO_GET(x) & (~(y)))
|
|
|
|
#define SSP_GET(x) bus_space_read_4(sc->sc_iot, sc->sc_ssph, \
|
|
(EP93XX_SSP_ ## x))
|
|
|
|
#define SSP_SET(x, y) bus_space_write_4(sc->sc_iot, sc->sc_ssph, \
|
|
(EP93XX_SSP_ ## x), (y))
|
|
|
|
#define SSP_SETBITS(x, y) bus_space_write_4(sc->sc_iot, sc->sc_ssph, \
|
|
(EP93XX_SSP_ ## x), SSP_GET(x) | (y))
|
|
|
|
#define SSP_CLEARBITS(x, y) bus_space_write_4(sc->sc_iot, sc->sc_ssph, \
|
|
(EP93XX_SSP_ ## x), SSP_GET(x) & (~(y)))
|
|
|
|
int
|
|
tspldmatch(struct device *parent, struct cfdata *match, void *aux)
|
|
{
|
|
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
boardtemp_poll(void *arg)
|
|
{
|
|
struct tspld_softc *sc = arg;
|
|
u_int16_t val;
|
|
|
|
/* Disable chip select */
|
|
GPIO_SET(PFDDR, 0x0);
|
|
|
|
val = SSP_GET(SSPDR) & 0xffff;
|
|
sc->boardtemp = ((int16_t)val >> 3) * 62500;
|
|
sc->boardtemp_5s = sc->boardtemp_5s / 20 * 19 + sc->boardtemp / 20;
|
|
sc->boardtemp_30s = sc->boardtemp_30s / 120 * 119 + sc->boardtemp / 120;
|
|
|
|
callout_schedule(&sc->boardtemp_callout, hz / 4);
|
|
|
|
/* Enable chip select */
|
|
GPIO_SET(PFDDR, 0x4);
|
|
|
|
/* Send read command */
|
|
SSP_SET(SSPDR, 0x8000);
|
|
}
|
|
|
|
void
|
|
tspldattach(struct device *parent, struct device *self, void *aux)
|
|
{
|
|
int i, rev, features, jp, model;
|
|
struct tspld_softc *sc = (struct tspld_softc *)self;
|
|
bus_space_handle_t ioh;
|
|
const struct sysctlnode *node;
|
|
|
|
if (sysctl_createv(NULL, 0, NULL, NULL,
|
|
CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw",
|
|
NULL, NULL, 0, NULL, 0,
|
|
CTL_HW, CTL_EOL) != 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
if (sysctl_createv(NULL, 0, NULL, &node,
|
|
0, CTLTYPE_NODE, sc->sc_dev.dv_xname,
|
|
NULL,
|
|
NULL, 0, NULL, 0,
|
|
CTL_HW, CTL_CREATE, CTL_EOL) != 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
|
|
sc->sc_iot = &ep93xx_bs_tag;
|
|
bus_space_map(sc->sc_iot, TS7XXX_IO16_HWBASE + TS7XXX_MODEL, 2, 0,
|
|
&ioh);
|
|
model = bus_space_read_2(sc->sc_iot, ioh, 0) & 0x7;
|
|
sc->sc_model = (model ? "TS-7250" : "TS-7200");
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_STRING, "boardmodel",
|
|
SYSCTL_DESCR("Technologic Systems board model"),
|
|
NULL, 0, __UNCONST(sc->sc_model), 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
bus_space_unmap(sc->sc_iot, ioh, 2);
|
|
|
|
bus_space_map(sc->sc_iot, TS7XXX_IO16_HWBASE + TS7XXX_PLDREV, 2, 0,
|
|
&ioh);
|
|
rev = bus_space_read_2(sc->sc_iot, ioh, 0) & 0x7;
|
|
rev = 'A' + rev - 1;
|
|
sc->sc_pldrev[0] = rev;
|
|
sc->sc_pldrev[1] = 0;
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_STRING, "pldrev",
|
|
SYSCTL_DESCR("CPLD revision"),
|
|
NULL, 0, sc->sc_pldrev, 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
bus_space_unmap(sc->sc_iot, ioh, 2);
|
|
|
|
bus_space_map(sc->sc_iot, TS7XXX_IO16_HWBASE + TS7XXX_FEATURES, 2, 0,
|
|
&ioh);
|
|
features = bus_space_read_2(sc->sc_iot, ioh, 0) & 0x7;
|
|
bus_space_unmap(sc->sc_iot, ioh, 2);
|
|
|
|
bus_space_map(sc->sc_iot, TS7XXX_IO8_HWBASE + TS7XXX_STATUS1, 1, 0,
|
|
&ioh);
|
|
i = bus_space_read_1(sc->sc_iot, ioh, 0) & 0x1f;
|
|
jp = (~((i & 0x18) >> 1) & 0xc) | (i & 0x3);
|
|
bus_space_unmap(sc->sc_iot, ioh, 1);
|
|
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "blaster_present",
|
|
SYSCTL_DESCR("Whether or not a TS-9420/TS-9202 blaster board is connected"),
|
|
NULL, 0, &sc->sc_blaster_present, 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "blaster_boot",
|
|
SYSCTL_DESCR("Whether or not a blast board was used to boot"),
|
|
NULL, 0, &sc->sc_blaster_boot, 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
bus_space_map(sc->sc_iot, TS7XXX_IO16_HWBASE + TS7XXX_STATUS2, 2, 0,
|
|
&ioh);
|
|
i = bus_space_read_2(sc->sc_iot, ioh, 0) & 0x6;
|
|
sc->sc_blaster_boot = sc->sc_blaster_present = 0;
|
|
if (i & 0x2)
|
|
sc->sc_blaster_boot = 1;
|
|
if (i & 0x4)
|
|
sc->sc_blaster_present = 1;
|
|
jp |= (i << 4);
|
|
bus_space_unmap(sc->sc_iot, ioh, 1);
|
|
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "rs485_avail",
|
|
SYSCTL_DESCR("RS485 level driver for COM2 available"),
|
|
NULL, 0, &sc->sc_rs485, 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
sc->sc_com2mode = "rs232";
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_STRING, "com2_mode",
|
|
SYSCTL_DESCR("line driver type for COM2"),
|
|
NULL, 0, __UNCONST(sc->sc_com2mode), 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "max197adc_avail",
|
|
SYSCTL_DESCR("Maxim 197 Analog to Digital Converter available"),
|
|
NULL, 0, &sc->sc_adc, 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
printf(": Technologic Systems %s rev %c, features 0x%x",
|
|
sc->sc_model, rev, features);
|
|
sc->sc_adc = sc->sc_rs485 = 0;
|
|
if (features == 0x1) {
|
|
printf("<MAX197-ADC>");
|
|
sc->sc_adc = 1;
|
|
} else if (features == 0x2) {
|
|
printf("<RS485>");
|
|
sc->sc_rs485 = 1;
|
|
} else if (features == 0x3) {
|
|
printf("<MAX197-ADC,RS485>");
|
|
sc->sc_adc = sc->sc_rs485 = 1;
|
|
}
|
|
printf("\n");
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "jp1",
|
|
SYSCTL_DESCR("onboard jumper setting"),
|
|
NULL, 0, &sc->sc_jp[0], 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "jp2",
|
|
SYSCTL_DESCR("onboard jumper setting"),
|
|
NULL, 0, &sc->sc_jp[1], 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "jp3",
|
|
SYSCTL_DESCR("onboard jumper setting"),
|
|
NULL, 0, &sc->sc_jp[2], 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "jp4",
|
|
SYSCTL_DESCR("onboard jumper setting"),
|
|
NULL, 0, &sc->sc_jp[3], 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "jp5",
|
|
SYSCTL_DESCR("onboard jumper setting"),
|
|
NULL, 0, &sc->sc_jp[4], 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "jp6",
|
|
SYSCTL_DESCR("onboard jumper setting"),
|
|
NULL, 0, &sc->sc_jp[5], 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
printf("%s: jumpers 0x%x", sc->sc_dev.dv_xname, jp);
|
|
if (jp) {
|
|
printf("<");
|
|
for(i = 0; i < 5; i++) {
|
|
if (jp & (1 << i)) {
|
|
sc->sc_jp[i + 1] = 1;
|
|
printf("JP%d", i + 2);
|
|
jp &= ~(1 << i);
|
|
if (jp) printf(",");
|
|
} else {
|
|
sc->sc_jp[i + 2] = 0;
|
|
}
|
|
}
|
|
printf(">");
|
|
}
|
|
printf("\n");
|
|
|
|
|
|
bus_space_map(sc->sc_iot, EP93XX_APB_HWBASE + EP93XX_APB_SSP,
|
|
EP93XX_APB_SSP_SIZE, 0, &sc->sc_ssph);
|
|
bus_space_map(sc->sc_iot, EP93XX_APB_HWBASE + EP93XX_APB_GPIO,
|
|
EP93XX_APB_GPIO_SIZE, 0, &sc->sc_gpioh);
|
|
SSP_SETBITS(SSPCR1, 0x10);
|
|
SSP_SET(SSPCR0, 0xf);
|
|
SSP_SET(SSPCPSR, 0xfe);
|
|
SSP_CLEARBITS(SSPCR1, 0x10);
|
|
SSP_SETBITS(SSPCR1, 0x10);
|
|
GPIO_SET(PFDR, 0x0);
|
|
callout_init(&sc->boardtemp_callout, 0);
|
|
callout_setfunc(&sc->boardtemp_callout, boardtemp_poll, sc);
|
|
boardtemp_poll(sc);
|
|
delay(1000);
|
|
boardtemp_poll(sc);
|
|
sc->boardtemp_5s = sc->boardtemp_30s = sc->boardtemp;
|
|
#define DEGF(c) ((c) * 9 / 5 + 32000000)
|
|
printf("%s: board temperature %d.%02d degC (%d.%02d degF)\n",
|
|
sc->sc_dev.dv_xname,
|
|
sc->boardtemp / 1000000, sc->boardtemp / 10000 % 100,
|
|
DEGF(sc->boardtemp) / 1000000, DEGF(sc->boardtemp) / 10000 % 100);
|
|
#undef DEGF
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "board_temp",
|
|
SYSCTL_DESCR("board temperature in micro degrees Celsius"),
|
|
NULL, 0, &sc->boardtemp, 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "board_temp_5s",
|
|
SYSCTL_DESCR("5 second average board temperature in micro degrees Celsius"),
|
|
NULL, 0, &sc->boardtemp_5s, 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
|
|
if ((i = sysctl_createv(NULL, 0, NULL, NULL,
|
|
0, CTLTYPE_INT, "board_temp_30s",
|
|
SYSCTL_DESCR("30 second average board temperature in micro degrees Celsius"),
|
|
NULL, 0, &sc->boardtemp_30s, 0,
|
|
CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
|
|
!= 0) {
|
|
printf("%s: could not create sysctl\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
|
|
bus_space_map(sc->sc_iot, TS7XXX_IO16_HWBASE + TS7XXX_WDOGCTRL, 2, 0,
|
|
&sc->sc_wdogctrl_ioh);
|
|
bus_space_map(sc->sc_iot, TS7XXX_IO16_HWBASE + TS7XXX_WDOGFEED, 2, 0,
|
|
&sc->sc_wdogfeed_ioh);
|
|
|
|
sc->sc_wdog.smw_name = sc->sc_dev.dv_xname;
|
|
sc->sc_wdog.smw_cookie = sc;
|
|
sc->sc_wdog.smw_setmode = tspld_wdog_setmode;
|
|
sc->sc_wdog.smw_tickle = tspld_wdog_tickle;
|
|
sc->sc_wdog.smw_period = 8;
|
|
sysmon_wdog_register(&sc->sc_wdog);
|
|
tspld_wdog_setmode(&sc->sc_wdog);
|
|
|
|
/* Set the on board peripherals bus callback */
|
|
config_defer(self, tspld_callback);
|
|
}
|
|
|
|
int
|
|
tspld_search(struct device *parent, struct cfdata *cf, const int *ldesc, void *aux)
|
|
{
|
|
struct tspld_softc *sc = (struct tspld_softc *)parent;
|
|
struct tspld_attach_args sa;
|
|
|
|
sa.ta_iot = sc->sc_iot;
|
|
|
|
if (config_match(parent, cf, &sa) > 0)
|
|
config_attach(parent, cf, &sa, tspld_print);
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
tspld_print(void *aux, const char *name)
|
|
{
|
|
|
|
return (UNCONF);
|
|
}
|
|
|
|
void
|
|
tspld_callback(struct device *self)
|
|
{
|
|
#if NISA > 0
|
|
extern void isa_bs_mallocok(void);
|
|
struct isabus_attach_args iba;
|
|
|
|
/*
|
|
* Attach the ISA bus behind this bridge.
|
|
*/
|
|
memset(&iba, 0, sizeof(iba));
|
|
iba.iba_iot = &isa_io_bs_tag;
|
|
iba.iba_memt = &isa_mem_bs_tag;
|
|
isa_bs_mallocok();
|
|
config_found_ia(self, "isabus", &iba, isabusprint);
|
|
#endif
|
|
/*
|
|
* Attach each devices
|
|
*/
|
|
config_search_ia(tspld_search, self, "tspldbus", NULL);
|
|
|
|
}
|
|
|
|
static int
|
|
tspld_wdog_tickle(struct sysmon_wdog *smw)
|
|
{
|
|
struct tspld_softc *sc = (struct tspld_softc *)smw->smw_cookie;
|
|
|
|
bus_space_write_2(sc->sc_iot, sc->sc_wdogfeed_ioh, 0, 0x5);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
tspld_wdog_setmode(struct sysmon_wdog *smw)
|
|
{
|
|
int i, ret = 0;
|
|
struct tspld_softc *sc = (struct tspld_softc *)smw->smw_cookie;
|
|
|
|
i = disable_interrupts(I32_bit|F32_bit);
|
|
if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) {
|
|
bus_space_write_2(sc->sc_iot, sc->sc_wdogfeed_ioh, 0, 0x5);
|
|
bus_space_write_2(sc->sc_iot, sc->sc_wdogctrl_ioh, 0, 0);
|
|
} else {
|
|
if (smw->smw_period == WDOG_PERIOD_DEFAULT) {
|
|
smw->smw_period = 8;
|
|
}
|
|
|
|
bus_space_write_2(sc->sc_iot, sc->sc_wdogfeed_ioh, 0, 0x5);
|
|
switch (smw->smw_period) {
|
|
case 1:
|
|
bus_space_write_2(sc->sc_iot, sc->sc_wdogctrl_ioh, 0,
|
|
0x3);
|
|
break;
|
|
case 2:
|
|
bus_space_write_2(sc->sc_iot, sc->sc_wdogctrl_ioh, 0,
|
|
0x5);
|
|
break;
|
|
case 4:
|
|
bus_space_write_2(sc->sc_iot, sc->sc_wdogctrl_ioh, 0,
|
|
0x6);
|
|
break;
|
|
case 8:
|
|
bus_space_write_2(sc->sc_iot, sc->sc_wdogctrl_ioh, 0,
|
|
0x7);
|
|
break;
|
|
default:
|
|
ret = EINVAL;
|
|
}
|
|
}
|
|
restore_interrupts(i);
|
|
return ret;
|
|
}
|