/* $NetBSD: maple.c,v 1.57 2022/07/05 19:21:26 andvar Exp $ */
/*-
* Copyright (c) 2002 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by ITOH Yasufumi.
*
* 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.
*
* 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.
*/
/*-
* Copyright (c) 2001 Marcus Comstedt
* 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 Marcus Comstedt.
* 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: maple.c,v 1.57 2022/07/05 19:21:26 andvar Exp $");
#include <sys/param.h>
#include <sys/device.h>
#include <sys/device_impl.h> /* XXX autoconf abuse */
#include <sys/fcntl.h>
#include <sys/kernel.h>
#include <sys/kthread.h>
#include <sys/poll.h>
#include <sys/select.h>
#include <sys/proc.h>
#include <sys/signalvar.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/bus.h>
#include <sys/mutex.h>
#include <sys/condvar.h>
#include <uvm/uvm.h>
#include <machine/cpu.h>
#include <machine/sysasicvar.h>
#include <sh3/pmap.h>
#include <dreamcast/dev/maple/maple.h>
#include <dreamcast/dev/maple/mapleconf.h>
#include <dreamcast/dev/maple/maplevar.h>
#include <dreamcast/dev/maple/maplereg.h>
#include <dreamcast/dev/maple/mapleio.h>
#include "ioconf.h"
#include "locators.h"
/* Internal macros, functions, and variables. */
#define MAPLE_CALLOUT_TICKS 2
#define MAPLEBUSUNIT(dev) (minor(dev)>>5)
#define MAPLEPORT(dev) ((minor(dev) & 0x18) >> 3)
#define MAPLESUBUNIT(dev) (minor(dev) & 0x7)
/* interrupt priority level */
#define IPL_MAPLE IPL_BIO
#define splmaple() splbio()
#define IRL_MAPLE SYSASIC_IRL9
/*
* Function declarations.
*/
static int maplematch(device_t, cfdata_t, void *);
static void mapleattach(device_t, device_t, void *);
static void maple_scanbus(struct maple_softc *);
static char * maple_unit_name(char *, size_t, int port, int subunit);
static void maple_begin_txbuf(struct maple_softc *);
static int maple_end_txbuf(struct maple_softc *);
static void maple_queue_command(struct maple_softc *, struct maple_unit *,
int command, int datalen, const void *dataaddr);
static void maple_write_command(struct maple_softc *, struct maple_unit *,
int, int, const void *);
static void maple_start(struct maple_softc *sc);
static void maple_start_poll(struct maple_softc *);
static void maple_check_subunit_change(struct maple_softc *,
struct maple_unit *);
static void maple_check_unit_change(struct maple_softc *,
struct maple_unit *);
static void maple_print_unit(void *, const char *);
static int maplesubmatch(device_t, cfdata_t, const int *, void *);
static int mapleprint(void *, const char *);
static void maple_attach_unit(struct maple_softc *, struct maple_unit *);
static void maple_detach_unit_nofix(struct maple_softc *,
struct maple_unit *);
static void maple_detach_unit(struct maple_softc *, struct maple_unit *);
static void maple_queue_cmds(struct maple_softc *,
struct maple_cmdq_head *);
static void maple_unit_probe(struct maple_softc *);
static void maple_unit_ping(struct maple_softc *);
static int maple_send_defered_periodic(struct maple_softc *);
static void maple_send_periodic(struct maple_softc *);
static void maple_remove_from_queues(struct maple_softc *,
struct maple_unit *);
static int maple_retry(struct maple_softc *, struct maple_unit *,
enum maple_dma_stat);
static void maple_queue_retry(struct maple_softc *);
static void maple_check_responses(struct maple_softc *);
static void maple_event_thread(void *);
static int maple_intr(void *);
static void maple_callout(void *);
int maple_alloc_dma(size_t, vaddr_t *, paddr_t *);
#if 0
void maple_free_dma(paddr_t, size_t);
#endif
/*
* Global variables.
*/
int maple_polling; /* Are we polling? (Debugger mode) */
CFATTACH_DECL_NEW(maple, sizeof(struct maple_softc),
maplematch, mapleattach, NULL, NULL);
dev_type_open(mapleopen);
dev_type_close(mapleclose);
dev_type_ioctl(mapleioctl);
const struct cdevsw maple_cdevsw = {
.d_open = mapleopen,
.d_close = mapleclose,
.d_read = noread,
.d_write = nowrite,
.d_ioctl = mapleioctl,
.d_stop = nostop,
.d_tty = notty,
.d_poll = nopoll,
.d_mmap = nommap,
.d_kqfilter = nokqfilter,
.d_discard = nodiscard,
.d_flag = 0
};
static int
maplematch(device_t parent, cfdata_t cf, void *aux)
{
return 1;
}
static void
mapleattach(device_t parent, device_t self, void *aux)
{
struct maple_softc *sc;
struct maple_unit *u;
vaddr_t dmabuffer;
paddr_t dmabuffer_phys;
uint32_t *p;
int port, subunit, f;
sc = device_private(self);
sc->sc_dev = self;
printf(": %s\n", sysasic_intr_string(IRL_MAPLE));
if (maple_alloc_dma(MAPLE_DMABUF_SIZE, &dmabuffer, &dmabuffer_phys)) {
printf("%s: unable to allocate DMA buffers.\n",
device_xname(self));
return;
}
p = (uint32_t *)dmabuffer;
for (port = 0; port < MAPLE_PORTS; port++) {
for (subunit = 0; subunit < MAPLE_SUBUNITS; subunit++) {
u = &sc->sc_unit[port][subunit];
u->port = port;
u->subunit = subunit;
u->u_dma_stat = MAPLE_DMA_IDLE;
u->u_rxbuf = p;
u->u_rxbuf_phys = SH3_P2SEG_TO_PHYS(p);
p += 256;
for (f = 0; f < MAPLE_NFUNC; f++) {
u->u_func[f].f_funcno = f;
u->u_func[f].f_unit = u;
}
}
}
sc->sc_txbuf = p;
sc->sc_txbuf_phys = SH3_P2SEG_TO_PHYS(p);
SIMPLEQ_INIT(&sc->sc_retryq);
TAILQ_INIT(&sc->sc_probeq);
TAILQ_INIT(&sc->sc_pingq);
TAILQ_INIT(&sc->sc_periodicq);
TAILQ_INIT(&sc->sc_periodicdeferq);
TAILQ_INIT(&sc->sc_acmdq);
TAILQ_INIT(&sc->sc_pcmdq);
MAPLE_RESET = RESET_MAGIC;
MAPLE_RESET2 = 0;
MAPLE_SPEED = SPEED_2MBPS | TIMEOUT(50000);
MAPLE_ENABLE = 1;
mutex_init(&sc->sc_dma_lock, MUTEX_DEFAULT, IPL_MAPLE);
cv_init(&sc->sc_dma_cv, device_xname(self));
mutex_init(&sc->sc_event_lock, MUTEX_DEFAULT, IPL_SOFTCLOCK);
cv_init(&sc->sc_event_cv, device_xname(self));
maple_polling = 1;
maple_scanbus(sc);
callout_init(&sc->maple_callout_ch, 0);
sc->sc_intrhand = sysasic_intr_establish(SYSASIC_EVENT_MAPLE_DMADONE,
IPL_MAPLE, IRL_MAPLE, maple_intr, sc);
config_pending_incr(self); /* create thread before mounting root */
if (kthread_create(PRI_NONE, 0, NULL, maple_event_thread, sc,
&sc->event_thread, "%s", device_xname(self)) == 0)
return;
panic("%s: unable to create event thread", device_xname(self));
}
/*
* initial device attach
*/
static void
maple_scanbus(struct maple_softc *sc)
{
struct maple_unit *u;
int port;
int last_port, last_subunit;
int i;
KASSERT(cold && maple_polling);
/* probe all ports */
for (port = 0; port < MAPLE_PORTS; port++) {
u = &sc->sc_unit[port][0];
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
{
char buf[16];
printf("%s: queued to probe 1\n",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit));
}
#endif
TAILQ_INSERT_TAIL(&sc->sc_probeq, u, u_q);
u->u_queuestat = MAPLE_QUEUE_PROBE;
}
last_port = last_subunit = -1;
maple_begin_txbuf(sc);
while ((u = TAILQ_FIRST(&sc->sc_probeq)) != NULL) {
/*
* Check wrap condition
*/
if (u->port < last_port || u->subunit <= last_subunit)
break;
last_port = u->port;
if (u->port == MAPLE_PORTS - 1)
last_subunit = u->subunit;
maple_unit_probe(sc);
for (i = 10 /* just not forever */; maple_end_txbuf(sc); i--) {
maple_start_poll(sc);
maple_check_responses(sc);
if (i == 0)
break;
/* attach may issue cmds */
maple_queue_cmds(sc, &sc->sc_acmdq);
}
}
}
void
maple_run_polling(device_t dev)
{
struct maple_softc *sc;
int port, subunit;
int i;
sc = device_private(dev);
/*
* first, make sure polling works
*/
while (MAPLE_STATE != 0) /* XXX may lost a DMA cycle */
;
/* XXX this will break internal state */
for (port = 0; port < MAPLE_PORTS; port++)
for (subunit = 0; subunit < MAPLE_SUBUNITS; subunit++)
sc->sc_unit[port][subunit].u_dma_stat = MAPLE_DMA_IDLE;
SIMPLEQ_INIT(&sc->sc_retryq); /* XXX discard current retries */
/*
* do polling (periodic status check only)
*/
maple_begin_txbuf(sc);
maple_send_defered_periodic(sc);
maple_send_periodic(sc);
for (i = 10 /* just not forever */; maple_end_txbuf(sc); i--) {
maple_start_poll(sc);
maple_check_responses(sc);
if (i == 0)
break;
/* maple_check_responses() has executed maple_begin_txbuf() */
maple_queue_retry(sc);
maple_send_defered_periodic(sc);
}
}
static char *
maple_unit_name(char *buf, size_t len, int port, int subunit)
{
size_t l = snprintf(buf, len, "maple%c", port + 'A');
if (l > len)
l = len;
if (subunit)
snprintf(buf + l, len - l, "%d", subunit);
return buf;
}
int
maple_alloc_dma(size_t size, vaddr_t *vap, paddr_t *pap)
{
extern paddr_t avail_start, avail_end; /* from pmap.c */
struct pglist mlist;
struct vm_page *m;
int error;
size = round_page(size);
error = uvm_pglistalloc(size, avail_start, avail_end - PAGE_SIZE,
0, 0, &mlist, 1, 0);
if (error)
return error;
m = TAILQ_FIRST(&mlist);
*pap = VM_PAGE_TO_PHYS(m);
*vap = SH3_PHYS_TO_P2SEG(VM_PAGE_TO_PHYS(m));
return 0;
}
#if 0 /* currently unused */
void
maple_free_dma(paddr_t paddr, size_t size)
{
struct pglist mlist;
struct vm_page *m;
bus_addr_t addr;
TAILQ_INIT(&mlist);
for (addr = paddr; addr < paddr + size; addr += PAGE_SIZE) {
m = PHYS_TO_VM_PAGE(addr);
TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);
}
uvm_pglistfree(&mlist);
}
#endif
static void
maple_begin_txbuf(struct maple_softc *sc)
{
sc->sc_txlink = sc->sc_txpos = sc->sc_txbuf;
SIMPLEQ_INIT(&sc->sc_dmaq);
}
static int
maple_end_txbuf(struct maple_softc *sc)
{
/* if no frame have been written, we can't mark the
list end, and so the DMA must not be activated */
if (sc->sc_txpos == sc->sc_txbuf)
return 0;
*sc->sc_txlink |= 0x80000000;
return 1;
}
static const int8_t subunit_code[] = { 0x20, 0x01, 0x02, 0x04, 0x08, 0x10 };
static void
maple_queue_command(struct maple_softc *sc, struct maple_unit *u,
int command, int datalen, const void *dataaddr)
{
int to, from;
uint32_t *p = sc->sc_txpos;
/* Max data length = 255 longs = 1020 bytes */
KASSERT(datalen >= 0 && datalen <= 255);
/* Compute sender and recipient address */
from = u->port << 6;
to = from | subunit_code[u->subunit];
sc->sc_txlink = p;
/* Set length of packet and destination port (A-D) */
*p++ = datalen | (u->port << 16);
/* Write address to receive buffer where the response
frame should be put */
*p++ = u->u_rxbuf_phys;
/* Create the frame header. The fields are assembled "backwards"
because of the Maple Bus big-endianness. */
*p++ = (command & 0xff) | (to << 8) | (from << 16) | (datalen << 24);
/* Copy parameter data, if any */
if (datalen > 0) {
const uint32_t *param = dataaddr;
int i;
for (i = 0; i < datalen; i++)
*p++ = *param++;
}
sc->sc_txpos = p;
SIMPLEQ_INSERT_TAIL(&sc->sc_dmaq, u, u_dmaq);
}
static void
maple_write_command(struct maple_softc *sc, struct maple_unit *u, int command,
int datalen, const void *dataaddr)
{
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
char buf[16];
if (u->u_retrycnt)
printf("%s: retrycnt %d\n", maple_unit_name(buf, sizeof(buf),
u->port, u->subunit), u->u_retrycnt);
#endif
u->u_retrycnt = 0;
u->u_command = command;
u->u_datalen = datalen;
u->u_dataaddr = dataaddr;
maple_queue_command(sc, u, command, datalen, dataaddr);
}
/* start DMA */
static void
maple_start(struct maple_softc *sc)
{
MAPLE_DMAADDR = sc->sc_txbuf_phys;
MAPLE_STATE = 1;
}
/* start DMA -- wait until DMA done */
static void
maple_start_poll(struct maple_softc *sc)
{
MAPLE_DMAADDR = sc->sc_txbuf_phys;
MAPLE_STATE = 1;
while (MAPLE_STATE != 0)
;
}
static void
maple_check_subunit_change(struct maple_softc *sc, struct maple_unit *u)
{
struct maple_unit *u1;
int port;
int8_t unit_map;
int units, un;
int i;
KASSERT(u->subunit == 0);
port = u->port;
unit_map = ((int8_t *) u->u_rxbuf)[2];
if (sc->sc_port_unit_map[port] == unit_map)
return;
units = ((unit_map & 0x1f) << 1) | 1;
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
{
char buf[16];
printf("%s: unit_map 0x%x -> 0x%x (units 0x%x)\n",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit),
sc->sc_port_unit_map[port], unit_map, units);
}
#endif
#if 0 /* this detects unit removal rapidly but is not reliable */
/* check for unit change */
un = sc->sc_port_units[port] & ~units;
/* detach removed devices */
for (i = MAPLE_SUBUNITS - 1; i > 0; i--)
if (un & (1 << i))
maple_detach_unit_nofix(sc, &sc->sc_unit[port][i]);
#endif
sc->sc_port_unit_map[port] = unit_map;
/* schedule scanning child devices */
un = units & ~sc->sc_port_units[port];
for (i = MAPLE_SUBUNITS - 1; i > 0; i--)
if (un & (1 << i)) {
u1 = &sc->sc_unit[port][i];
maple_remove_from_queues(sc, u1);
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
{
char buf[16];
printf("%s: queued to probe 2\n",
maple_unit_name(buf, sizeof(buf),
u1->port, u1->subunit));
}
#endif
TAILQ_INSERT_HEAD(&sc->sc_probeq, u1, u_q);
u1->u_queuestat = MAPLE_QUEUE_PROBE;
u1->u_proberetry = 0;
}
}
static void
maple_check_unit_change(struct maple_softc *sc, struct maple_unit *u)
{
struct maple_devinfo *newinfo = (void *) (u->u_rxbuf + 1);
if (memcmp(&u->devinfo, newinfo, sizeof(struct maple_devinfo)) == 0)
goto out; /* no change */
/* unit inserted */
/* attach this device */
u->devinfo = *newinfo;
maple_attach_unit(sc, u);
out:
maple_remove_from_queues(sc, u);
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
{
char buf[16];
printf("%s: queued to ping\n",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit));
}
#endif
TAILQ_INSERT_TAIL(&sc->sc_pingq, u, u_q);
u->u_queuestat = MAPLE_QUEUE_PING;
}
static void
maple_print_unit(void *aux, const char *pnp)
{
struct maple_attach_args *ma = aux;
int port, subunit;
char buf[16];
char *prod, *p, oc;
port = ma->ma_unit->port;
subunit = ma->ma_unit->subunit;
if (pnp != NULL)
printf("%s at %s", maple_unit_name(buf, sizeof(buf), port,
subunit), pnp);
printf(" port %d", port);
if (subunit != 0)
printf(" subunit %d", subunit);
#ifdef MAPLE_DEBUG
printf(": a %#x c %#x fn %#x d %#x,%#x,%#x",
ma->ma_devinfo->di_area_code,
ma->ma_devinfo->di_connector_direction,
be32toh(ma->ma_devinfo->di_func),
be32toh(ma->ma_devinfo->di_function_data[0]),
be32toh(ma->ma_devinfo->di_function_data[1]),
be32toh(ma->ma_devinfo->di_function_data[2]));
#endif
/* nul termination */
prod = ma->ma_devinfo->di_product_name;
for (p = prod + sizeof ma->ma_devinfo->di_product_name; p >= prod; p--)
if (p[-1] != '\0' && p[-1] != ' ')
break;
oc = *p;
*p = '\0';
printf(": %s", prod);
*p = oc; /* restore */
}
static int
maplesubmatch(device_t parent, cfdata_t match, const int *ldesc, void *aux)
{
struct maple_attach_args *ma = aux;
if (match->cf_loc[MAPLECF_PORT] != MAPLECF_PORT_DEFAULT &&
match->cf_loc[MAPLECF_PORT] != ma->ma_unit->port)
return 0;
if (match->cf_loc[MAPLECF_SUBUNIT] != MAPLECF_SUBUNIT_DEFAULT &&
match->cf_loc[MAPLECF_SUBUNIT] != ma->ma_unit->subunit)
return 0;
return config_match(parent, match, aux);
}
static int
mapleprint(void *aux, const char *str)
{
struct maple_attach_args *ma = aux;
#ifdef MAPLE_DEBUG
if (str)
aprint_normal("%s", str);
aprint_normal(" function %d", ma->ma_function);
return UNCONF;
#else /* quiet */
if (!str)
aprint_normal(" function %d", ma->ma_function);
return QUIET;
#endif
}
static void
maple_attach_unit(struct maple_softc *sc, struct maple_unit *u)
{
struct maple_attach_args ma;
uint32_t func;
int f;
char oldxname[16];
ma.ma_unit = u;
ma.ma_devinfo = &u->devinfo;
ma.ma_basedevinfo = &sc->sc_unit[u->port][0].devinfo;
func = be32toh(ma.ma_devinfo->di_func);
maple_print_unit(&ma, device_xname(sc->sc_dev));
printf("\n");
strcpy(oldxname, device_xname(sc->sc_dev));
maple_unit_name(sc->sc_dev->dv_xname, sizeof(sc->sc_dev->dv_xname),
u->port, u->subunit);
for (f = 0; f < MAPLE_NFUNC; f++) {
u->u_func[f].f_callback = NULL;
u->u_func[f].f_arg = NULL;
u->u_func[f].f_cmdstat = MAPLE_CMDSTAT_NONE;
u->u_func[f].f_dev = NULL;
if (func & MAPLE_FUNC(f)) {
ma.ma_function = f;
u->u_func[f].f_dev =
config_found(sc->sc_dev, &ma, mapleprint,
CFARGS(.submatch = maplesubmatch));
u->u_ping_func = f; /* XXX using largest func */
}
}
#ifdef MAPLE_MEMCARD_PING_HACK
/*
* Some 3rd party memory card pretend to be Visual Memory,
* but need special handling for ping.
*/
if (func == (MAPLE_FUNC(MAPLE_FN_MEMCARD) | MAPLE_FUNC(MAPLE_FN_LCD) |
MAPLE_FUNC(MAPLE_FN_CLOCK))) {
u->u_ping_func = MAPLE_FN_MEMCARD;
u->u_ping_stat = MAPLE_PING_MEMCARD;
} else {
u->u_ping_stat = MAPLE_PING_NORMAL;
}
#endif
strcpy(sc->sc_dev->dv_xname, oldxname);
sc->sc_port_units[u->port] |= 1 << u->subunit;
}
static void
maple_detach_unit_nofix(struct maple_softc *sc, struct maple_unit *u)
{
struct maple_func *fn;
device_t dev;
struct maple_unit *u1;
int port;
int error;
int i;
char buf[16];
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
printf("%s: remove\n", maple_unit_name(buf, sizeof(buf), u->port, u->subunit));
#endif
maple_remove_from_queues(sc, u);
port = u->port;
sc->sc_port_units[port] &= ~(1 << u->subunit);
if (u->subunit == 0) {
for (i = MAPLE_SUBUNITS - 1; i > 0; i--)
maple_detach_unit_nofix(sc, &sc->sc_unit[port][i]);
}
for (fn = u->u_func; fn < &u->u_func[MAPLE_NFUNC]; fn++) {
if ((dev = fn->f_dev) != NULL) {
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
printf("%s: detaching func %d\n",
maple_unit_name(buf, sizeof(buf), port, u->subunit),
fn->f_funcno);
#endif
/*
* Remove functions from command queue.
*/
switch (fn->f_cmdstat) {
case MAPLE_CMDSTAT_ASYNC:
case MAPLE_CMDSTAT_PERIODIC_DEFERED:
TAILQ_REMOVE(&sc->sc_acmdq, fn, f_cmdq);
break;
case MAPLE_CMDSTAT_ASYNC_PERIODICQ:
case MAPLE_CMDSTAT_PERIODIC:
TAILQ_REMOVE(&sc->sc_pcmdq, fn, f_cmdq);
break;
default:
break;
}
/*
* Detach devices.
*/
if ((error = config_detach(fn->f_dev, DETACH_FORCE))) {
printf("%s: failed to detach %s (func %d), errno %d\n",
maple_unit_name(buf, sizeof(buf), port, u->subunit),
device_xname(fn->f_dev), fn->f_funcno, error);
}
}
maple_enable_periodic(sc->sc_dev, u, fn->f_funcno, 0);
fn->f_dev = NULL;
fn->f_callback = NULL;
fn->f_arg = NULL;
fn->f_cmdstat = MAPLE_CMDSTAT_NONE;
}
if (u->u_dma_stat == MAPLE_DMA_RETRY) {
/* XXX expensive? */
SIMPLEQ_FOREACH(u1, &sc->sc_retryq, u_dmaq) {
if (u1 == u) {
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
printf("%s: abort retry\n",
maple_unit_name(buf, sizeof(buf), port, u->subunit));
#endif
SIMPLEQ_REMOVE(&sc->sc_retryq, u, maple_unit,
u_dmaq);
break;
}
}
}
u->u_dma_stat = MAPLE_DMA_IDLE;
u->u_noping = 0;
/* u->u_dma_func = uninitialized; */
KASSERT(u->getcond_func_set == 0);
memset(&u->devinfo, 0, sizeof(struct maple_devinfo));
if (u->subunit == 0) {
sc->sc_port_unit_map[port] = 0;
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
{
char buf2[16];
printf("%s: queued to probe 3\n",
maple_unit_name(buf2, sizeof(buf2), port, u->subunit));
}
#endif
TAILQ_INSERT_TAIL(&sc->sc_probeq, u, u_q);
u->u_queuestat = MAPLE_QUEUE_PROBE;
}
}
static void
maple_detach_unit(struct maple_softc *sc, struct maple_unit *u)
{
maple_detach_unit_nofix(sc, u);
if (u->subunit != 0)
sc->sc_port_unit_map[u->port] &= ~(1 << (u->subunit - 1));
}
/*
* Send a command (called by drivers)
*
* The "cataaddr" must not point at temporary storage like stack.
* Only one command (per function) is valid at a time.
*/
void
maple_command(device_t dev, struct maple_unit *u, int func,
int command, int datalen, const void *dataaddr, int flags)
{
struct maple_softc *sc = device_private(dev);
struct maple_func *fn;
KASSERT(func >= 0 && func < 32);
KASSERT(command);
KASSERT((flags & ~MAPLE_FLAG_CMD_PERIODIC_TIMING) == 0);
mutex_enter(&sc->sc_event_lock);
fn = &u->u_func[func];
#if 1 /*def DIAGNOSTIC*/
{char buf[16];
if (fn->f_cmdstat != MAPLE_CMDSTAT_NONE)
panic("maple_command: %s func %d: requesting more than one commands",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit), func);
}
#endif
fn->f_command = command;
fn->f_datalen = datalen;
fn->f_dataaddr = dataaddr;
if (flags & MAPLE_FLAG_CMD_PERIODIC_TIMING) {
fn->f_cmdstat = MAPLE_CMDSTAT_PERIODIC;
TAILQ_INSERT_TAIL(&sc->sc_pcmdq, fn, f_cmdq);
} else {
fn->f_cmdstat = MAPLE_CMDSTAT_ASYNC;
TAILQ_INSERT_TAIL(&sc->sc_acmdq, fn, f_cmdq);
cv_broadcast(&sc->sc_event_cv); /* wake for async event */
}
mutex_exit(&sc->sc_event_lock);
}
static void
maple_queue_cmds(struct maple_softc *sc,
struct maple_cmdq_head *head)
{
struct maple_func *fn, *nextfn;
struct maple_unit *u;
/*
* Note: since the queue element may be queued immediately,
* we can't use TAILQ_FOREACH.
*/
fn = TAILQ_FIRST(head);
TAILQ_INIT(head);
for ( ; fn; fn = nextfn) {
nextfn = TAILQ_NEXT(fn, f_cmdq);
KASSERT(fn->f_cmdstat != MAPLE_CMDSTAT_NONE);
u = fn->f_unit;
if (u->u_dma_stat == MAPLE_DMA_IDLE) {
maple_write_command(sc, u,
fn->f_command, fn->f_datalen, fn->f_dataaddr);
u->u_dma_stat = (fn->f_cmdstat == MAPLE_CMDSTAT_ASYNC ||
fn->f_cmdstat == MAPLE_CMDSTAT_ASYNC_PERIODICQ) ?
MAPLE_DMA_ACMD : MAPLE_DMA_PCMD;
u->u_dma_func = fn->f_funcno;
fn->f_cmdstat = MAPLE_CMDSTAT_NONE;
} else if (u->u_dma_stat == MAPLE_DMA_RETRY) {
/* unit is busy --- try again */
/*
* always add to periodic command queue
* (wait until the next periodic timing),
* since the unit will never be freed until the
* next periodic timing.
*/
switch (fn->f_cmdstat) {
case MAPLE_CMDSTAT_ASYNC:
fn->f_cmdstat = MAPLE_CMDSTAT_ASYNC_PERIODICQ;
break;
case MAPLE_CMDSTAT_PERIODIC_DEFERED:
fn->f_cmdstat = MAPLE_CMDSTAT_PERIODIC;
break;
default:
break;
}
TAILQ_INSERT_TAIL(&sc->sc_pcmdq, fn, f_cmdq);
} else {
/* unit is busy --- try again */
/*
* always add to async command queue
* (process immediately)
*/
switch (fn->f_cmdstat) {
case MAPLE_CMDSTAT_ASYNC_PERIODICQ:
fn->f_cmdstat = MAPLE_CMDSTAT_ASYNC;
break;
case MAPLE_CMDSTAT_PERIODIC:
fn->f_cmdstat = MAPLE_CMDSTAT_PERIODIC_DEFERED;
break;
default:
break;
}
TAILQ_INSERT_TAIL(&sc->sc_acmdq, fn, f_cmdq);
}
}
}
/* schedule probing a device */
static void
maple_unit_probe(struct maple_softc *sc)
{
struct maple_unit *u;
if ((u = TAILQ_FIRST(&sc->sc_probeq)) != NULL) {
KASSERT(u->u_dma_stat == MAPLE_DMA_IDLE);
KASSERT(u->u_queuestat == MAPLE_QUEUE_PROBE);
maple_remove_from_queues(sc, u);
maple_write_command(sc, u, MAPLE_COMMAND_DEVINFO, 0, NULL);
u->u_dma_stat = MAPLE_DMA_PROBE;
/* u->u_dma_func = ignored; */
}
}
/*
* Enable/disable unit pinging (called by drivers)
*/
/* ARGSUSED */
void
maple_enable_unit_ping(device_t dev, struct maple_unit *u, int func, int enable)
{
#if 0 /* currently unused */
struct maple_softc *sc = device_private(dev);
#endif
if (enable)
u->u_noping &= ~MAPLE_FUNC(func);
else
u->u_noping |= MAPLE_FUNC(func);
}
/* schedule pinging a device */
static void
maple_unit_ping(struct maple_softc *sc)
{
struct maple_unit *u;
struct maple_func *fn;
#ifdef MAPLE_MEMCARD_PING_HACK
static const uint32_t memcard_ping_arg[2] = {
0x02000000, /* htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD)) */
0 /* pt (1 byte) and unused 3 bytes */
};
#endif
if ((u = TAILQ_FIRST(&sc->sc_pingq)) != NULL) {
KASSERT(u->u_queuestat == MAPLE_QUEUE_PING);
maple_remove_from_queues(sc, u);
if (u->u_dma_stat == MAPLE_DMA_IDLE && u->u_noping == 0) {
#ifdef MAPLE_MEMCARD_PING_HACK
if (u->u_ping_stat == MAPLE_PING_MINFO) {
/* use MINFO for some memory cards */
maple_write_command(sc, u,
MAPLE_COMMAND_GETMINFO,
2, memcard_ping_arg);
} else
#endif
{
fn = &u->u_func[u->u_ping_func];
fn->f_work = htobe32(MAPLE_FUNC(u->u_ping_func));
maple_write_command(sc, u,
MAPLE_COMMAND_GETCOND,
1, &fn->f_work);
}
u->u_dma_stat = MAPLE_DMA_PING;
/* u->u_dma_func = XXX; */
} else {
/* no need if periodic */
TAILQ_INSERT_TAIL(&sc->sc_pingq, u, u_q);
u->u_queuestat = MAPLE_QUEUE_PING;
}
}
}
/*
* Enable/disable periodic GETCOND (called by drivers)
*/
void
maple_enable_periodic(device_t dev, struct maple_unit *u, int func, int on)
{
struct maple_softc *sc = device_private(dev);
struct maple_func *fn;
KASSERT(func >= 0 && func < 32);
fn = &u->u_func[func];
if (on) {
if (fn->f_periodic_stat == MAPLE_PERIODIC_NONE) {
TAILQ_INSERT_TAIL(&sc->sc_periodicq, fn, f_periodicq);
fn->f_periodic_stat = MAPLE_PERIODIC_INQ;
u->getcond_func_set |= MAPLE_FUNC(func);
}
} else {
if (fn->f_periodic_stat == MAPLE_PERIODIC_INQ)
TAILQ_REMOVE(&sc->sc_periodicq, fn, f_periodicq);
else if (fn->f_periodic_stat == MAPLE_PERIODIC_DEFERED)
TAILQ_REMOVE(&sc->sc_periodicdeferq, fn, f_periodicq);
fn->f_periodic_stat = MAPLE_PERIODIC_NONE;
u->getcond_func_set &= ~MAPLE_FUNC(func);
}
}
/*
* queue periodic GETCOND
*/
static int
maple_send_defered_periodic(struct maple_softc *sc)
{
struct maple_unit *u;
struct maple_func *fn, *nextfn;
int defer_remain = 0;
for (fn = TAILQ_FIRST(&sc->sc_periodicdeferq); fn; fn = nextfn) {
KASSERT(fn->f_periodic_stat == MAPLE_PERIODIC_DEFERED);
nextfn = TAILQ_NEXT(fn, f_periodicq);
u = fn->f_unit;
if (u->u_dma_stat == MAPLE_DMA_IDLE ||
u->u_dma_stat == MAPLE_DMA_RETRY) {
/*
* if IDLE -> queue this request
* if RETRY -> the unit never be freed until the next
* periodic timing, so just restore to
* the normal periodic queue.
*/
TAILQ_REMOVE(&sc->sc_periodicdeferq, fn, f_periodicq);
TAILQ_INSERT_TAIL(&sc->sc_periodicq, fn, f_periodicq);
fn->f_periodic_stat = MAPLE_PERIODIC_INQ;
if (u->u_dma_stat == MAPLE_DMA_IDLE) {
/*
* queue periodic command
*/
fn->f_work = htobe32(MAPLE_FUNC(fn->f_funcno));
maple_write_command(sc, u,
MAPLE_COMMAND_GETCOND, 1, &fn->f_work);
u->u_dma_stat = MAPLE_DMA_PERIODIC;
u->u_dma_func = fn->f_funcno;
}
} else {
defer_remain = 1;
}
}
return defer_remain;
}
static void
maple_send_periodic(struct maple_softc *sc)
{
struct maple_unit *u;
struct maple_func *fn, *nextfn;
for (fn = TAILQ_FIRST(&sc->sc_periodicq); fn; fn = nextfn) {
KASSERT(fn->f_periodic_stat == MAPLE_PERIODIC_INQ);
nextfn = TAILQ_NEXT(fn, f_periodicq);
u = fn->f_unit;
if (u->u_dma_stat != MAPLE_DMA_IDLE) {
if (u->u_dma_stat != MAPLE_DMA_RETRY) {
/*
* can't be queued --- move to defered queue
*/
TAILQ_REMOVE(&sc->sc_periodicq, fn,
f_periodicq);
TAILQ_INSERT_TAIL(&sc->sc_periodicdeferq, fn,
f_periodicq);
fn->f_periodic_stat = MAPLE_PERIODIC_DEFERED;
}
} else {
/*
* queue periodic command
*/
fn->f_work = htobe32(MAPLE_FUNC(fn->f_funcno));
maple_write_command(sc, u, MAPLE_COMMAND_GETCOND,
1, &fn->f_work);
u->u_dma_stat = MAPLE_DMA_PERIODIC;
u->u_dma_func = fn->f_funcno;
}
}
}
static void
maple_remove_from_queues(struct maple_softc *sc, struct maple_unit *u)
{
/* remove from queues */
if (u->u_queuestat == MAPLE_QUEUE_PROBE)
TAILQ_REMOVE(&sc->sc_probeq, u, u_q);
else if (u->u_queuestat == MAPLE_QUEUE_PING)
TAILQ_REMOVE(&sc->sc_pingq, u, u_q);
#ifdef DIAGNOSTIC
else if (u->u_queuestat != MAPLE_QUEUE_NONE)
panic("maple_remove_from_queues: queuestat %d", u->u_queuestat);
#endif
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
if (u->u_queuestat != MAPLE_QUEUE_NONE) {
char buf[16];
printf("%s: dequeued\n",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit));
}
#endif
u->u_queuestat = MAPLE_QUEUE_NONE;
}
/*
* retry current command at next periodic timing
*/
static int
maple_retry(struct maple_softc *sc, struct maple_unit *u,
enum maple_dma_stat st)
{
KASSERT(st != MAPLE_DMA_IDLE && st != MAPLE_DMA_RETRY);
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
if (u->u_retrycnt == 0) {
char buf[16];
printf("%s: retrying: %#x, %#x, %p\n",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit),
u->u_command, u->u_datalen, u->u_dataaddr);
}
#endif
if (u->u_retrycnt >= MAPLE_RETRY_MAX)
return 1;
u->u_retrycnt++;
u->u_saved_dma_stat = st;
u->u_dma_stat = MAPLE_DMA_RETRY; /* no new command before retry done */
SIMPLEQ_INSERT_TAIL(&sc->sc_retryq, u, u_dmaq);
return 0;
}
static void
maple_queue_retry(struct maple_softc *sc)
{
struct maple_unit *u, *nextu;
/*
* Note: since the queue element is queued immediately
* in maple_queue_command, we can't use SIMPLEQ_FOREACH.
*/
for (u = SIMPLEQ_FIRST(&sc->sc_retryq); u; u = nextu) {
nextu = SIMPLEQ_NEXT(u, u_dmaq);
/*
* Retrying is in the highest priority, and the unit shall
* always be free.
*/
KASSERT(u->u_dma_stat == MAPLE_DMA_RETRY);
maple_queue_command(sc, u, u->u_command, u->u_datalen,
u->u_dataaddr);
u->u_dma_stat = u->u_saved_dma_stat;
#ifdef DIAGNOSTIC
KASSERT(u->u_saved_dma_stat != MAPLE_DMA_IDLE);
u->u_saved_dma_stat = MAPLE_DMA_IDLE;
#endif
}
SIMPLEQ_INIT(&sc->sc_retryq);
}
/*
* Process DMA results.
* Requires kernel context.
*/
static void
maple_check_responses(struct maple_softc *sc)
{
struct maple_unit *u, *nextu;
struct maple_func *fn;
maple_response_t response;
int func_code, len;
int flags;
char buf[16];
/*
* Note: since the queue element may be queued immediately,
* we can't use SIMPLEQ_FOREACH.
*/
for (u = SIMPLEQ_FIRST(&sc->sc_dmaq), maple_begin_txbuf(sc);
u; u = nextu) {
nextu = SIMPLEQ_NEXT(u, u_dmaq);
if (u->u_dma_stat == MAPLE_DMA_IDLE)
continue; /* just detached or DDB was active */
/*
* check for retransmission
*/
if ((response = u->u_rxbuf[0]) == MAPLE_RESPONSE_AGAIN) {
if (maple_retry(sc, u, u->u_dma_stat) == 0)
continue;
/* else pass error to upper layer */
}
len = (u->u_rxbuf[0] >> 24); /* length in long */
len <<= 2; /* length in byte */
/*
* call handler
*/
if (u->u_dma_stat == MAPLE_DMA_PERIODIC) {
/*
* periodic GETCOND
*/
u->u_dma_stat = MAPLE_DMA_IDLE;
func_code = u->u_dma_func;
if (response == MAPLE_RESPONSE_DATATRF && len > 0 &&
be32toh(u->u_rxbuf[1]) == MAPLE_FUNC(func_code)) {
fn = &u->u_func[func_code];
if (fn->f_dev)
(*fn->f_callback)(fn->f_arg,
(void *)u->u_rxbuf, len,
MAPLE_FLAG_PERIODIC);
} else if (response == MAPLE_RESPONSE_NONE) {
/* XXX OK? */
/* detach */
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
printf("%s: func: %d: periodic response %d\n",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit),
u->u_dma_func,
response);
#endif
/*
* Some 3rd party devices sometimes
* do not respond.
*/
if (maple_retry(sc, u, MAPLE_DMA_PERIODIC))
maple_detach_unit(sc, u);
}
/* XXX check unexpected conditions? */
} else if (u->u_dma_stat == MAPLE_DMA_PROBE) {
KASSERT(u->u_queuestat == MAPLE_QUEUE_NONE);
u->u_dma_stat = MAPLE_DMA_IDLE;
switch (response) {
default:
case MAPLE_RESPONSE_NONE:
/*
* Do not use maple_retry(), which conflicts
* with probe structure.
*/
if (u->subunit != 0 &&
++u->u_proberetry > MAPLE_PROBERETRY_MAX) {
printf("%s: no response\n",
maple_unit_name(buf, sizeof(buf),
u->port, u->subunit));
} else {
/* probe again */
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 2
printf("%s: queued to probe 4\n",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit));
#endif
TAILQ_INSERT_TAIL(&sc->sc_probeq, u,
u_q);
u->u_queuestat = MAPLE_QUEUE_PROBE;
}
break;
case MAPLE_RESPONSE_DEVINFO:
/* check if the unit is changed */
maple_check_unit_change(sc, u);
break;
}
} else if (u->u_dma_stat == MAPLE_DMA_PING) {
KASSERT(u->u_queuestat == MAPLE_QUEUE_NONE);
u->u_dma_stat = MAPLE_DMA_IDLE;
switch (response) {
default:
case MAPLE_RESPONSE_NONE:
/*
* Some 3rd party devices sometimes
* do not respond.
*/
if (maple_retry(sc, u, MAPLE_DMA_PING)) {
/* detach */
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
printf("%s: ping response %d\n",
maple_unit_name(buf, sizeof(buf), u->port,
u->subunit),
response);
#endif
#ifdef MAPLE_MEMCARD_PING_HACK
if (u->u_ping_stat
== MAPLE_PING_MEMCARD) {
/*
* The unit claims itself to be
* a Visual Memory, and has
* never responded to GETCOND.
* Try again using MINFO, in
* case it is a poorly
* implemented 3rd party card.
*/
#ifdef MAPLE_DEBUG
printf("%s: switching ping method\n",
maple_unit_name(buf, sizeof(buf),
u->port, u->subunit));
#endif
u->u_ping_stat
= MAPLE_PING_MINFO;
TAILQ_INSERT_TAIL(&sc->sc_pingq,
u, u_q);
u->u_queuestat
= MAPLE_QUEUE_PING;
} else
#endif /* MAPLE_MEMCARD_PING_HACK */
maple_detach_unit(sc, u);
}
break;
case MAPLE_RESPONSE_BADCMD:
case MAPLE_RESPONSE_BADFUNC:
case MAPLE_RESPONSE_DATATRF:
TAILQ_INSERT_TAIL(&sc->sc_pingq, u, u_q);
u->u_queuestat = MAPLE_QUEUE_PING;
#ifdef MAPLE_MEMCARD_PING_HACK
/*
* If the unit responds to GETCOND, it is a
* normal implementation.
*/
if (u->u_ping_stat == MAPLE_PING_MEMCARD)
u->u_ping_stat = MAPLE_PING_NORMAL;
#endif
break;
}
} else {
/*
* Note: Do not rely on the consistency of responses.
*/
if (response == MAPLE_RESPONSE_NONE) {
if (maple_retry(sc, u, u->u_dma_stat)) {
/* detach */
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
printf("%s: command response %d\n",
maple_unit_name(buf, sizeof(buf), u->port,
u->subunit),
response);
#endif
maple_detach_unit(sc, u);
}
continue;
}
flags = (u->u_dma_stat == MAPLE_DMA_PCMD) ?
MAPLE_FLAG_CMD_PERIODIC_TIMING : 0;
u->u_dma_stat = MAPLE_DMA_IDLE;
func_code = u->u_dma_func;
fn = &u->u_func[func_code];
if (fn->f_dev == NULL) {
/* detached right now */
#ifdef MAPLE_DEBUG
printf("%s: unknown function: function %d, response %d\n",
maple_unit_name(buf, sizeof(buf), u->port, u->subunit),
func_code, response);
#endif
continue;
}
if (fn->f_callback != NULL) {
(*fn->f_callback)(fn->f_arg,
(void *)u->u_rxbuf, len, flags);
}
}
/*
* check for subunit change and schedule probing subunits
*/
if (u->subunit == 0 && response != MAPLE_RESPONSE_NONE &&
response != MAPLE_RESPONSE_AGAIN &&
((int8_t *) u->u_rxbuf)[2] != sc->sc_port_unit_map[u->port])
maple_check_subunit_change(sc, u);
}
}
/*
* Main Maple Bus thread
*/
static void
maple_event_thread(void *arg)
{
struct maple_softc *sc = arg;
unsigned cnt = 1; /* timing counter */
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
int noreq = 0;
#endif
#ifdef MAPLE_DEBUG
printf("%s: forked event thread, pid %d\n",
device_xname(sc->sc_dev), sc->event_thread->l_proc->p_pid);
#endif
/* begin first DMA cycle */
maple_begin_txbuf(sc);
sc->sc_event = 1;
/* OK, continue booting system */
maple_polling = 0;
config_pending_decr(sc->sc_dev);
for (;;) {
/*
* queue requests
*/
/* queue async commands */
if (!TAILQ_EMPTY(&sc->sc_acmdq))
maple_queue_cmds(sc, &sc->sc_acmdq);
/* send defered periodic command */
if (!TAILQ_EMPTY(&sc->sc_periodicdeferq))
maple_send_defered_periodic(sc);
/* queue periodic commands */
if (sc->sc_event) {
/* queue commands on periodic timing */
if (!TAILQ_EMPTY(&sc->sc_pcmdq))
maple_queue_cmds(sc, &sc->sc_pcmdq);
/* retry */
if (!SIMPLEQ_EMPTY(&sc->sc_retryq))
maple_queue_retry(sc);
if ((cnt & 31) == 0) /* XXX */
maple_unit_probe(sc);
cnt++;
maple_send_periodic(sc);
if ((cnt & 7) == 0) /* XXX */
maple_unit_ping(sc);
/*
* schedule periodic event
*/
sc->sc_event = 0;
callout_reset(&sc->maple_callout_ch,
MAPLE_CALLOUT_TICKS, maple_callout, sc);
}
if (maple_end_txbuf(sc)) {
/*
* start DMA
*/
mutex_enter(&sc->sc_dma_lock);
maple_start(sc);
/*
* wait until DMA done
*/
if (cv_timedwait(&sc->sc_dma_cv, &sc->sc_dma_lock, hz)
== EWOULDBLOCK) {
/* was DDB active? */
printf("%s: timed out\n",
device_xname(sc->sc_dev));
}
mutex_exit(&sc->sc_dma_lock);
/*
* call handlers
*/
maple_check_responses(sc);
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
noreq = 0;
#endif
}
#if defined(MAPLE_DEBUG) && MAPLE_DEBUG > 1
else {
/* weird if occurs in succession */
#if MAPLE_DEBUG <= 2
if (noreq) /* ignore first time */
#endif
printf("%s: no request %d\n",
device_xname(sc->sc_dev), noreq);
noreq++;
}
#endif
/*
* wait for an event
*/
mutex_enter(&sc->sc_event_lock);
if (TAILQ_EMPTY(&sc->sc_acmdq) && sc->sc_event == 0 &&
TAILQ_EMPTY(&sc->sc_periodicdeferq)) {
if (cv_timedwait(&sc->sc_event_cv, &sc->sc_event_lock,
hz) == EWOULDBLOCK) {
printf("%s: event timed out\n",
device_xname(sc->sc_dev));
}
}
mutex_exit(&sc->sc_event_lock);
}
#if 0 /* maple root device can't be detached */
kthread_exit(0);
/* NOTREACHED */
#endif
}
static int
maple_intr(void *arg)
{
struct maple_softc *sc = arg;
mutex_enter(&sc->sc_dma_lock);
cv_broadcast(&sc->sc_dma_cv);
mutex_exit(&sc->sc_dma_lock);
return 1;
}
static void
maple_callout(void *ctx)
{
struct maple_softc *sc = ctx;
mutex_enter(&sc->sc_event_lock);
sc->sc_event = 1; /* mark as periodic event */
cv_broadcast(&sc->sc_event_cv);
mutex_exit(&sc->sc_event_lock);
}
/*
* Install callback handler (called by drivers)
*/
/* ARGSUSED */
void
maple_set_callback(device_t dev, struct maple_unit *u, int func,
void (*callback)(void *, struct maple_response *, int, int), void *arg)
{
#if 0 /* currently unused */
struct maple_softc *sc = device_private(dev);
#endif
struct maple_func *fn;
KASSERT(func >= 0 && func < MAPLE_NFUNC);
fn = &u->u_func[func];
fn->f_callback = callback;
fn->f_arg = arg;
}
/*
* Return function definition data (called by drivers)
*/
uint32_t
maple_get_function_data(struct maple_devinfo *devinfo, int function_code)
{
int i, p = 0;
uint32_t func;
func = be32toh(devinfo->di_func);
for (i = 31; i >= 0; --i)
if (func & MAPLE_FUNC(i)) {
if (function_code == i)
return be32toh(devinfo->di_function_data[p]);
else
if (++p >= 3)
break;
}
return 0;
}
/* Generic maple device interface */
int
mapleopen(dev_t dev, int flag, int mode, struct lwp *l)
{
struct maple_softc *sc;
sc = device_lookup_private(&maple_cd, MAPLEBUSUNIT(dev));
if (sc == NULL) /* make sure it was attached */
return ENXIO;
if (MAPLEPORT(dev) >= MAPLE_PORTS)
return ENXIO;
if (MAPLESUBUNIT(dev) >= MAPLE_SUBUNITS)
return ENXIO;
if (!(sc->sc_port_units[MAPLEPORT(dev)] & (1 << MAPLESUBUNIT(dev))))
return ENXIO;
sc->sc_port_units_open[MAPLEPORT(dev)] |= 1 << MAPLESUBUNIT(dev);
return 0;
}
int
mapleclose(dev_t dev, int flag, int mode, struct lwp *l)
{
struct maple_softc *sc;
sc = device_lookup_private(&maple_cd, MAPLEBUSUNIT(dev));
sc->sc_port_units_open[MAPLEPORT(dev)] &= ~(1 << MAPLESUBUNIT(dev));
return 0;
}
int
maple_unit_ioctl(device_t dev, struct maple_unit *u, u_long cmd,
void *data, int flag, struct lwp *l)
{
struct maple_softc *sc = device_private(dev);
if (!(sc->sc_port_units[u->port] & (1 << u->subunit)))
return ENXIO;
switch(cmd) {
case MAPLEIO_GDEVINFO:
memcpy(data, &u->devinfo, sizeof(struct maple_devinfo));
break;
default:
return EPASSTHROUGH;
}
return 0;
}
int
mapleioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
struct maple_softc *sc;
struct maple_unit *u;
sc = device_lookup_private(&maple_cd, MAPLEBUSUNIT(dev));
u = &sc->sc_unit[MAPLEPORT(dev)][MAPLESUBUNIT(dev)];
return maple_unit_ioctl(sc->sc_dev, u, cmd, data, flag, l);
}