669 lines
15 KiB
C
669 lines
15 KiB
C
/* $NetBSD: maple.c,v 1.9 2001/07/22 15:46:41 wiz Exp $ */
|
|
|
|
/*-
|
|
* 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/param.h>
|
|
#include <sys/device.h>
|
|
#include <sys/fcntl.h>
|
|
#include <sys/poll.h>
|
|
#include <sys/select.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/signalvar.h>
|
|
#include <sys/systm.h>
|
|
|
|
#include <uvm/uvm_extern.h>
|
|
|
|
#include <machine/cpu.h>
|
|
#include <machine/bus.h>
|
|
#include <sh3/shbvar.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>
|
|
|
|
|
|
/* 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)
|
|
|
|
/*
|
|
* Function declarations.
|
|
*/
|
|
static int maplematch __P((struct device *, struct cfdata *, void *));
|
|
static void mapleattach __P((struct device *, struct device *, void *));
|
|
static int mapleprint __P((void *, const char *));
|
|
static int maplesubmatch __P((struct device *, struct cfdata *, void *));
|
|
static void maple_attach_dev __P((struct maple_softc *, int, int));
|
|
static void maple_begin_txbuf __P((struct maple_softc *));
|
|
static int maple_end_txbuf __P((struct maple_softc *));
|
|
static void maple_write_command __P((struct maple_softc *, int, int,
|
|
int, int, void *));
|
|
static void maple_scanbus __P((struct maple_softc *));
|
|
static void maple_callout __P((void *));
|
|
static void maple_send_commands __P((struct maple_softc *));
|
|
static void maple_check_responses __P((struct maple_softc *));
|
|
|
|
int maple_alloc_dma __P((size_t, vaddr_t *, paddr_t *));
|
|
void maple_free_dma __P((paddr_t, size_t));
|
|
|
|
int mapleopen __P((dev_t, int, int, struct proc *));
|
|
int mapleclose __P((dev_t, int, int, struct proc *));
|
|
int maple_internal_ioctl __P((struct maple_softc *, int, int, u_long, caddr_t, int, struct proc *));
|
|
int mapleioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
|
|
|
|
|
|
|
|
/*
|
|
* Global variables.
|
|
*/
|
|
int maple_polling = 0; /* Are we polling? (Debugger mode) */
|
|
|
|
/*
|
|
* Driver definition.
|
|
*/
|
|
struct cfattach maple_ca = {
|
|
sizeof(struct maple_softc), maplematch, mapleattach
|
|
};
|
|
|
|
extern struct cfdriver maple_cd;
|
|
|
|
static int
|
|
maplematch(parent, cf, aux)
|
|
struct device *parent;
|
|
struct cfdata *cf;
|
|
void *aux;
|
|
{
|
|
struct shb_attach_args *sa = aux;
|
|
|
|
if (strcmp("maple", cf->cf_driver->cd_name))
|
|
return (0);
|
|
|
|
sa->ia_iosize = 0 /* 0x100 */;
|
|
return (1);
|
|
}
|
|
|
|
static void
|
|
maple_attach_dev(sc, port, subunit)
|
|
struct maple_softc *sc;
|
|
int port;
|
|
int subunit;
|
|
{
|
|
struct maple_attach_args ma;
|
|
u_int32_t func;
|
|
int f;
|
|
char oldxname[16];
|
|
|
|
ma.ma_port = port;
|
|
ma.ma_subunit = subunit;
|
|
ma.ma_devinfo = &sc->sc_unit[port][subunit].devinfo;
|
|
ma.ma_function = 1;
|
|
func = ma.ma_devinfo->di_func;
|
|
|
|
mapleprint(&ma, sc->sc_dev.dv_xname);
|
|
printf("\n");
|
|
strcpy(oldxname, sc->sc_dev.dv_xname);
|
|
sprintf(sc->sc_dev.dv_xname, "maple%c", port+'A');
|
|
if(subunit)
|
|
sprintf(sc->sc_dev.dv_xname+6, "%d", subunit);
|
|
for(f=0; f<32; f++, ma.ma_function<<=1)
|
|
if(func & ma.ma_function)
|
|
(void) config_found_sm(&sc->sc_dev, &ma,
|
|
NULL, maplesubmatch);
|
|
strcpy(sc->sc_dev.dv_xname, oldxname);
|
|
}
|
|
|
|
static void
|
|
maple_begin_txbuf(sc)
|
|
struct maple_softc *sc;
|
|
{
|
|
sc->sc_txlink = sc->sc_txpos = sc->sc_txbuf;
|
|
}
|
|
|
|
static int
|
|
maple_end_txbuf(sc)
|
|
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 int8_t subunit_code[] = { 0x20, 0x01, 0x02, 0x04, 0x08, 0x10 };
|
|
|
|
static void
|
|
maple_write_command(sc, port, subunit, command, datalen, dataaddr)
|
|
struct maple_softc *sc;
|
|
int port;
|
|
int subunit;
|
|
int command;
|
|
int datalen;
|
|
void *dataaddr;
|
|
{
|
|
int to, from;
|
|
u_int32_t *p = sc->sc_txpos;
|
|
|
|
if ((port & ~(MAPLE_PORTS-1)) != 0 ||
|
|
subunit < 0 || subunit >= MAPLE_SUBUNITS)
|
|
return;
|
|
|
|
/* Compute sender and recipient address */
|
|
from = port << 6;
|
|
to = from | subunit_code[subunit];
|
|
|
|
/* Max data length = 255 longs = 1020 bytes */
|
|
if(datalen > 255)
|
|
datalen = 255;
|
|
else if(datalen < 0)
|
|
datalen = 0;
|
|
|
|
sc->sc_txlink = p;
|
|
|
|
/* Set length of packet and destination port (A-D) */
|
|
*p++ = datalen | (port << 16);
|
|
|
|
/* Write address to receive buffer where the response
|
|
frame should be put */
|
|
*p++ = sc->sc_rxbuf_phys[port][subunit];
|
|
|
|
/* 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) {
|
|
u_int32_t *param = dataaddr;
|
|
int i;
|
|
for (i = 0; i < datalen; i++)
|
|
*p++ = *param++;
|
|
}
|
|
|
|
sc->sc_txpos = p;
|
|
}
|
|
|
|
static void
|
|
maple_scanbus(sc)
|
|
struct maple_softc *sc;
|
|
{
|
|
int p, s;
|
|
|
|
maple_polling = 1;
|
|
|
|
maple_begin_txbuf(sc);
|
|
|
|
for (p = 0; p < MAPLE_PORTS; p++) {
|
|
maple_write_command(sc, p, 0, MAPLE_COMMAND_DEVINFO, 0, NULL);
|
|
}
|
|
|
|
if (maple_end_txbuf(sc)) {
|
|
|
|
MAPLE_DMAADDR = sc->sc_txbuf_phys;
|
|
MAPLE_STATE = 1;
|
|
while (MAPLE_STATE != 0)
|
|
;
|
|
|
|
for (p = 0; p < MAPLE_PORTS; p++)
|
|
if ((sc->sc_rxbuf[p][0][0] & 0xff) == MAPLE_RESPONSE_DEVINFO)
|
|
|
|
sc->sc_port_units[p] = ((sc->sc_rxbuf[p][0][0]>>15)&0x3e)|1;
|
|
|
|
else
|
|
|
|
sc->sc_port_units[p] = 0;
|
|
|
|
|
|
maple_begin_txbuf(sc);
|
|
|
|
for (p = 0; p < MAPLE_PORTS; p++) {
|
|
for (s = 0; s < MAPLE_SUBUNITS; s++) {
|
|
if (sc->sc_port_units[p] & (1<<s))
|
|
maple_write_command(sc, p, s, MAPLE_COMMAND_DEVINFO, 0, NULL);
|
|
}
|
|
}
|
|
|
|
if (maple_end_txbuf(sc)) {
|
|
|
|
MAPLE_DMAADDR = sc->sc_txbuf_phys;
|
|
MAPLE_STATE = 1;
|
|
while (MAPLE_STATE != 0)
|
|
;
|
|
|
|
for (p = 0; p < MAPLE_PORTS; p++)
|
|
for (s = 0; s < MAPLE_SUBUNITS; s++)
|
|
if (sc->sc_port_units[p] & (1<<s)) {
|
|
|
|
if ((sc->sc_rxbuf[p][s][0] & 0xff) ==
|
|
MAPLE_RESPONSE_DEVINFO) {
|
|
|
|
u_int32_t *to_swap;
|
|
int i;
|
|
|
|
memcpy((to_swap = &sc->sc_unit[p][s].devinfo.di_func),
|
|
sc->sc_rxbuf[p][s]+1, sizeof(struct maple_devinfo));
|
|
|
|
for (i = 0; i < 4; i++, to_swap++)
|
|
*to_swap = ntohl(*to_swap);
|
|
|
|
maple_attach_dev(sc, p, s);
|
|
|
|
} else {
|
|
|
|
printf("%s: no response from port %d subunit %d\n",
|
|
sc->sc_dev.dv_xname, p, s);
|
|
|
|
sc->sc_port_units[p] &= ~(1<<s);
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
maple_polling = 0;
|
|
|
|
}
|
|
|
|
static void
|
|
maple_send_commands(sc)
|
|
struct maple_softc *sc;
|
|
{
|
|
int p, s;
|
|
|
|
if (sc->maple_commands_pending || MAPLE_STATE != 0)
|
|
return;
|
|
|
|
maple_begin_txbuf(sc);
|
|
|
|
for (p = 0; p < MAPLE_PORTS; p++) {
|
|
|
|
for (s = 0; s < MAPLE_SUBUNITS; s++) {
|
|
|
|
if (sc->sc_unit[p][s].getcond_callback != NULL) {
|
|
|
|
u_int32_t func = ntohl(sc->sc_unit[p][s].getcond_func);
|
|
|
|
maple_write_command(sc, p, s, MAPLE_COMMAND_GETCOND, 1, &func);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!maple_end_txbuf(sc))
|
|
return;
|
|
|
|
MAPLE_DMAADDR = sc->sc_txbuf_phys;
|
|
MAPLE_STATE = 1;
|
|
|
|
sc->maple_commands_pending = 1;
|
|
}
|
|
|
|
static void
|
|
maple_check_responses(sc)
|
|
struct maple_softc *sc;
|
|
{
|
|
int p, s;
|
|
|
|
if (!sc->maple_commands_pending || MAPLE_STATE != 0)
|
|
return;
|
|
|
|
for (p = 0; p < MAPLE_PORTS; p++) {
|
|
for (s = 0; s < MAPLE_SUBUNITS; s++) {
|
|
struct maple_unit * u = &sc->sc_unit[p][s];
|
|
if (u->getcond_callback != NULL &&
|
|
(sc->sc_rxbuf[p][s][0] & 0xff) == MAPLE_RESPONSE_DATATRF &&
|
|
(sc->sc_rxbuf[p][s][0]>>24) >= 1 &&
|
|
htonl(sc->sc_rxbuf[p][s][1]) == u->getcond_func) {
|
|
(*u->getcond_callback)(u->getcond_data,
|
|
(void *)(sc->sc_rxbuf[p][s]+2),
|
|
((sc->sc_rxbuf[p][s][0]>>22)&1020)-4);
|
|
}
|
|
}
|
|
}
|
|
|
|
sc->maple_commands_pending = 0;
|
|
}
|
|
|
|
void
|
|
maple_run_polling(dev)
|
|
struct device *dev;
|
|
{
|
|
struct maple_softc *sc;
|
|
|
|
sc = (struct maple_softc *)dev;
|
|
|
|
if (MAPLE_STATE != 0)
|
|
return;
|
|
|
|
maple_send_commands(sc);
|
|
|
|
while (MAPLE_STATE != 0)
|
|
;
|
|
|
|
maple_check_responses(sc);
|
|
}
|
|
|
|
void
|
|
maple_set_condition_callback(dev, port, subunit, func, callback, data)
|
|
struct device *dev;
|
|
int port;
|
|
int subunit;
|
|
u_int32_t func;
|
|
void (*callback)(void *, void *, int);
|
|
void *data;
|
|
{
|
|
struct maple_softc *sc;
|
|
|
|
sc = (struct maple_softc *)dev;
|
|
|
|
if ((port & ~(MAPLE_PORTS-1)) != 0 ||
|
|
subunit < 0 || subunit >= MAPLE_SUBUNITS)
|
|
return;
|
|
|
|
sc->sc_unit[port][subunit].getcond_func = func;
|
|
sc->sc_unit[port][subunit].getcond_callback = callback;
|
|
sc->sc_unit[port][subunit].getcond_data = data;
|
|
}
|
|
|
|
static void
|
|
maple_callout(ctx)
|
|
void *ctx;
|
|
{
|
|
struct maple_softc *sc = ctx;
|
|
|
|
if(!maple_polling) {
|
|
|
|
maple_check_responses(sc);
|
|
|
|
maple_send_commands(sc);
|
|
|
|
}
|
|
|
|
callout_reset(&sc->maple_callout_ch, MAPLE_CALLOUT_TICKS,
|
|
(void *)maple_callout, sc);
|
|
}
|
|
|
|
int
|
|
maple_alloc_dma(size, vap, pap)
|
|
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);
|
|
|
|
TAILQ_INIT(&mlist);
|
|
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);
|
|
}
|
|
|
|
void
|
|
maple_free_dma(paddr, size)
|
|
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);
|
|
}
|
|
uvm_pglistfree(&mlist);
|
|
}
|
|
|
|
static void
|
|
mapleattach(parent, self, aux)
|
|
struct device *parent, *self;
|
|
void *aux;
|
|
{
|
|
struct maple_softc *sc;
|
|
vaddr_t dmabuffer;
|
|
paddr_t dmabuffer_phys;
|
|
u_int32_t *p;
|
|
int i, j;
|
|
|
|
sc = (struct maple_softc *)self;
|
|
|
|
printf("\n");
|
|
|
|
if (maple_alloc_dma(MAPLE_DMABUF_SIZE, &dmabuffer, &dmabuffer_phys)) {
|
|
printf("%s: unable to allocate DMA buffers.\n", sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
|
|
p = (u_int32_t *) dmabuffer;
|
|
|
|
for (i = 0; i < MAPLE_PORTS; i++)
|
|
for (j = 0; j < MAPLE_SUBUNITS; j++) {
|
|
|
|
sc->sc_rxbuf[i][j] = p;
|
|
sc->sc_rxbuf_phys[i][j] = SH3_P2SEG_TO_PHYS(p);
|
|
p += 256;
|
|
|
|
}
|
|
|
|
sc->sc_txbuf = p;
|
|
sc->sc_txbuf_phys = SH3_P2SEG_TO_PHYS(p);
|
|
|
|
sc->maple_commands_pending = 0;
|
|
|
|
MAPLE_RESET = RESET_MAGIC;
|
|
MAPLE_RESET2 = 0;
|
|
|
|
MAPLE_SPEED = SPEED_2MBPS | TIMEOUT(50000);
|
|
|
|
MAPLE_ENABLE = 1;
|
|
|
|
maple_scanbus(sc);
|
|
|
|
memset(&sc->maple_callout_ch, 0, sizeof(sc->maple_callout_ch));
|
|
|
|
callout_reset(&sc->maple_callout_ch, MAPLE_CALLOUT_TICKS,
|
|
(void *)maple_callout, sc);
|
|
}
|
|
|
|
int
|
|
mapleprint(aux, pnp)
|
|
void *aux;
|
|
const char *pnp;
|
|
{
|
|
struct maple_attach_args *ma = aux;
|
|
|
|
if (pnp != NULL) {
|
|
printf("maple%c", 'A'+ma->ma_port);
|
|
if (ma->ma_subunit != 0)
|
|
printf("%d", ma->ma_subunit);
|
|
printf(" at %s", pnp);
|
|
}
|
|
|
|
printf(" port %d", ma->ma_port);
|
|
|
|
if (ma->ma_subunit != 0)
|
|
printf(" subunit %d", ma->ma_subunit);
|
|
|
|
printf(": %.*s",
|
|
(int)sizeof(ma->ma_devinfo->di_product_name),
|
|
ma->ma_devinfo->di_product_name);
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
maplesubmatch(parent, match, aux)
|
|
struct device *parent;
|
|
struct cfdata *match;
|
|
void *aux;
|
|
{
|
|
struct maple_attach_args *ma = aux;
|
|
|
|
if (match->cf_loc[MAPLECF_PORT] != MAPLECF_PORT_DEFAULT &&
|
|
match->cf_loc[MAPLECF_PORT] != ma->ma_port)
|
|
return (0);
|
|
|
|
if (match->cf_loc[MAPLECF_SUBUNIT] != MAPLECF_SUBUNIT_DEFAULT &&
|
|
match->cf_loc[MAPLECF_SUBUNIT] != ma->ma_subunit)
|
|
return (0);
|
|
|
|
return ((*match->cf_attach->ca_match)(parent, match, aux));
|
|
}
|
|
|
|
u_int32_t
|
|
maple_get_function_data(devinfo, function_code)
|
|
struct maple_devinfo *devinfo;
|
|
u_int32_t function_code;
|
|
{
|
|
int i, p = 0;
|
|
|
|
for (i = 31; i >= 0; --i)
|
|
if (devinfo->di_func & (1U<<i))
|
|
if (function_code & (1U<<i))
|
|
return devinfo->di_function_data[p];
|
|
else
|
|
if (++p >= 3)
|
|
break;
|
|
return (0);
|
|
}
|
|
|
|
/* Generic maple device interface */
|
|
|
|
int
|
|
mapleopen(dev, flag, mode, p)
|
|
dev_t dev;
|
|
int flag, mode;
|
|
struct proc *p;
|
|
{
|
|
struct maple_softc *sc;
|
|
|
|
sc = device_lookup(&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, flag, mode, p)
|
|
dev_t dev;
|
|
int flag, mode;
|
|
struct proc *p;
|
|
{
|
|
struct maple_softc *sc;
|
|
|
|
sc = device_lookup(&maple_cd, MAPLEBUSUNIT(dev));
|
|
|
|
sc->sc_port_units_open[MAPLEPORT(dev)] &= ~(1<<MAPLESUBUNIT(dev));
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
maple_internal_ioctl(sc, port, subunit, cmd, data, flag, p)
|
|
struct maple_softc *sc;
|
|
int port;
|
|
int subunit;
|
|
u_long cmd;
|
|
caddr_t data;
|
|
int flag;
|
|
struct proc *p;
|
|
{
|
|
struct maple_unit *u = &sc->sc_unit[port][subunit];
|
|
|
|
if(!(sc->sc_port_units[port] & (1<<subunit)))
|
|
return (ENXIO);
|
|
|
|
switch(cmd) {
|
|
case MAPLEIO_GDEVINFO:
|
|
memcpy(data, &u->devinfo, sizeof(struct maple_devinfo));
|
|
return (0);
|
|
default:
|
|
return (EINVAL);
|
|
}
|
|
}
|
|
|
|
int
|
|
mapleioctl(dev, cmd, data, flag, p)
|
|
dev_t dev;
|
|
u_long cmd;
|
|
caddr_t data;
|
|
int flag;
|
|
struct proc *p;
|
|
{
|
|
struct maple_softc *sc;
|
|
|
|
sc = device_lookup(&maple_cd, MAPLEBUSUNIT(dev));
|
|
|
|
return maple_internal_ioctl(sc, MAPLEPORT(dev), MAPLESUBUNIT(dev),
|
|
cmd, data, flag, p);
|
|
}
|