NetBSD-5.0.2/sys/arch/evbarm/tsarm/tspld.c
/* $NetBSD: tspld.c,v 1.15 2008/05/10 15:31:04 martin 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.15 2008/05/10 15:31:04 martin 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 __P((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(parent, match, aux)
struct device *parent;
struct cfdata *match;
void *aux;
{
return 1;
}
void
boardtemp_poll(arg)
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(parent, self, aux)
struct device *parent, *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(parent, cf, ldesc, aux)
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(aux, name)
void *aux;
const char *name;
{
return (UNCONF);
}
void
tspld_callback(self)
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(smw)
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(smw)
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 {
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;
}