Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/arch/emips/ebus/icap_ebus.c

427 lines
10 KiB
C
Raw Blame History

/* $NetBSD: icap_ebus.c,v 1.7 2018/03/04 21:41:48 mrg Exp $ */
/*-
* Copyright (c) 2010 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code was written by Alessandro Forin and Neil Pittman
* at Microsoft Research and contributed to The NetBSD Foundation
* by Microsoft Corporation.
*
* 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.
*/
#include <sys/cdefs.h> /* RCS ID & Copyright macro defns */
__KERNEL_RCSID(0, "$NetBSD: icap_ebus.c,v 1.7 2018/03/04 21:41:48 mrg Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/bufq.h>
#include <sys/proc.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <uvm/uvm_param.h>
#include <emips/ebus/ebusvar.h>
#include <emips/emips/machdep.h>
#include <machine/emipsreg.h>
#define DEBUG_INTR 0x01
#define DEBUG_XFERS 0x02
#define DEBUG_STATUS 0x04
#define DEBUG_FUNCS 0x08
#define DEBUG_PROBE 0x10
#define DEBUG_WRITES 0x20
#define DEBUG_READS 0x40
#define DEBUG_ERRORS 0x80
#ifdef DEBUG
int icap_debug = DEBUG_ERRORS;
#define ICAP_DEBUG(x) (icap_debug & (x))
#define DBGME(_lev_,_x_) if ((_lev_) & icap_debug) _x_
#else
#define ICAP_DEBUG(x) (0)
#define DBGME(_lev_,_x_)
#endif
#define DEBUG_PRINT(_args_,_lev_) DBGME(_lev_,printf _args_)
/*
* Device softc
*/
struct icap_softc {
device_t sc_dev;
struct _Icap *sc_dp;
struct bufq_state *sc_buflist;
struct buf *sc_bp;
char *sc_data;
int sc_count;
};
/* Required funcs
*/
static int icap_ebus_match (device_t, cfdata_t, void *);
static void icap_ebus_attach (device_t, device_t, void *);
static dev_type_open(icapopen);
static dev_type_close(icapclose);
static dev_type_read(icapread);
static dev_type_write(icapwrite);
static dev_type_ioctl(icapioctl);
static dev_type_strategy(icapstrategy);
/* Other functions
*/
extern paddr_t kvtophys(vaddr_t);
static void icapstart(struct icap_softc *sc);
static int icap_ebus_intr(void *cookie, void *f);
static void icap_reset(struct icap_softc *sc);
/* Config stuff
*/
extern struct cfdriver icap_cd;
CFATTACH_DECL_NEW(icap_ebus, sizeof (struct icap_softc),
icap_ebus_match, icap_ebus_attach, NULL, NULL);
static int
icap_ebus_match(device_t parent, cfdata_t match, void *aux)
{
struct ebus_attach_args *ia = aux;
struct _Icap *f = (struct _Icap *)ia->ia_vaddr;
DEBUG_PRINT(("icap_match %x\n", (f) ? f->Tag : 0), DEBUG_PROBE);
if (strcmp("icap", ia->ia_name) != 0)
return (0);
if ((f == NULL) ||
(! (f->Tag == PMTTAG_ICAP)))
return (0);
return (1);
}
static void
icap_ebus_attach(device_t parent, device_t self, void *aux)
{
struct icap_softc *sc = device_private(self);
struct ebus_attach_args *ia =aux;
DEBUG_PRINT(("icap_attach %p\n", sc), DEBUG_PROBE);
sc->sc_dev = self;
sc->sc_dp = (struct _Icap*)ia->ia_vaddr;
bufq_alloc(&sc->sc_buflist, "fcfs", 0);
sc->sc_bp = NULL;
sc->sc_data = NULL;
sc->sc_count = 0;
#if DEBUG
printf(" virt=%p", (void*)sc->sc_dp);
#endif
printf(": %s\n", "Internal Configuration Access Port");
ebus_intr_establish(parent, (void*)ia->ia_cookie, IPL_BIO,
icap_ebus_intr, sc);
icap_reset(sc);
}
/* The character device handlers
*/
const struct cdevsw icap_cdevsw = {
.d_open = icapopen,
.d_close = icapclose,
.d_read = icapread,
.d_write = icapwrite,
.d_ioctl = icapioctl,
.d_stop = nostop,
.d_tty = notty,
.d_poll = nopoll,
.d_mmap = nommap,
.d_kqfilter = nokqfilter,
.d_discard = nodiscard,
.d_flag = 0
};
/*
* Handle an open request on the device.
*/
static int
icapopen(dev_t device, int flags, int fmt, struct lwp *process)
{
struct icap_softc *sc;
DEBUG_PRINT(("icapopen\n"), DEBUG_FUNCS);
sc = device_lookup_private(&icap_cd, minor(device));
if (sc == NULL)
return (ENXIO);
return 0;
}
/*
* Handle the close request for the device.
*/
static int
icapclose(dev_t device, int flags, int fmt, struct lwp *process)
{
DEBUG_PRINT(("icapclose\n"), DEBUG_FUNCS);
return 0; /* this always succeeds */
}
/*
* Handle the read request for the device.
*/
static int
icapread(dev_t dev, struct uio *uio, int flags)
{
DEBUG_PRINT(("icapread\n"), DEBUG_READS);
return (physio(icapstrategy, NULL, dev, B_READ, minphys, uio));
}
/*
* Handle the write request for the device.
*/
static int
icapwrite(dev_t dev, struct uio *uio, int flags)
{
DEBUG_PRINT(("icapwrite\n"), DEBUG_WRITES);
return (physio(icapstrategy, NULL, dev, B_WRITE, minphys, uio));
}
/*
* Handle the ioctl request for the device.
*/
static int
icapioctl(dev_t dev, u_long xfer, void *addr, int flag, struct lwp *l)
{
return ENOTTY;
}
/*
* Strategy function for the device.
*/
static void
icapstrategy(struct buf *bp)
{
struct icap_softc *sc;
int s;
DEBUG_PRINT(("icapstrategy\n"), DEBUG_FUNCS);
/* We did nothing lest we did */
bp->b_resid = bp->b_bcount;
/* Do we know you. */
sc = device_lookup_private(&icap_cd, minor(bp->b_dev));
if (sc == NULL) {
DEBUG_PRINT(("icapstrategy: nodev %" PRIx64 "\n",bp->b_dev),
DEBUG_ERRORS);
bp->b_error = ENXIO;
biodone(bp);
return;
}
/* Add to Q. If Q was empty get it started */
s = splbio();
bufq_put(sc->sc_buflist, bp);
if (bufq_peek(sc->sc_buflist) == bp) {
icapstart(sc);
}
splx(s);
}
/*
* Get the next I/O request started
*/
static void
icapstart(struct icap_softc *sc)
{
paddr_t phys, phys2;
vaddr_t virt;
size_t count;
uint32_t fl;
struct buf *bp = sc->sc_bp;
DEBUG_PRINT(("icapstart %p %p\n",sc,bp), DEBUG_FUNCS);
/* Were we idle?
*/
recheck:
if (bp == NULL) {
/* Yes, get the next request if any
*/
bp = bufq_get(sc->sc_buflist);
DEBUG_PRINT(("icapnext: %p\n",bp), DEBUG_XFERS);
if (bp == NULL)
return;
}
/* Done with this request?
*/
if ((bp->b_resid == 0) || bp->b_error) {
/* Yes, complete and move to next, if any
*/
sc->sc_bp = NULL;
biodone(bp);
DEBUG_PRINT(("icapdone %p\n",bp), DEBUG_XFERS);
bp = NULL;
goto recheck;
}
/* If new request init the xfer info
*/
if (sc->sc_bp == NULL) {
sc->sc_bp = bp;
sc->sc_data = bp->b_data;
sc->sc_count = bp->b_resid;
}
/* Loop filling as many buffers as will fit in the FIFO
*/
fl = (bp->b_flags & B_READ) ? ICAPS_F_RECV : ICAPS_F_XMIT;
for (;;) {
/* Make sure there's still room in the FIFO, no errors.
*/
if (sc->sc_dp->Control & (ICAPC_IF_FULL|ICAPC_ERROR))
break;
/* How much data do we xfer and where
*/
virt = (vaddr_t)sc->sc_data;
phys = kvtophys(virt);
count = round_page(virt) - virt;
if (count == 0) count = PAGE_SIZE;/* could(will) be aligned */
/* How much of it is contiguous
*/
while (count < sc->sc_count) {
phys2 = kvtophys(virt + count);
if (phys2 != (phys + count)) {
/* No longer contig, ship it
*/
break;
}
count += PAGE_SIZE;
}
/* Trim if we went too far
*/
if (count > sc->sc_count)
count = sc->sc_count;
/* Ship it
*/
DEBUG_PRINT(("icapship %" PRIxPADDR " %d\n",phys,count), DEBUG_XFERS);
sc->sc_dp->SizeAndFlags = fl | count;
sc->sc_dp->BufferAddressHi32 = 0; /* BUGBUG 64bit */
sc->sc_dp->BufferAddressLo32 = phys; /* this pushes the fifo */
/* Adjust pointers and continue
*/
sc->sc_data += count;
sc->sc_count -= count;
if (sc->sc_count <= 0)
break;
}
}
/*
* Interrupt handler
*/
static int
icap_ebus_intr(void *cookie, void *f)
{
struct icap_softc *sc = cookie;
struct buf *bp = sc->sc_bp;
u_int32_t isr, saf = 0, hi, lo;
isr = sc->sc_dp->Control;
DEBUG_PRINT(("i %x\n",isr), DEBUG_INTR);
/* Make sure there is an interrupt and that we should take it
*/
if ((isr & (ICAPC_INTEN|ICAPC_DONE)) != (ICAPC_INTEN|ICAPC_DONE))
return (0);
/* Pull out all completed buffers
*/
while ((isr & ICAPC_OF_EMPTY) == 0) {
if (isr & ICAPC_ERROR) {
printf("%s: internal error (%x)\n", device_xname(sc->sc_dev),isr);
icap_reset(sc);
if (bp) {
bp->b_error = EIO;
icapstart(sc);
}
return (1);
}
/* Beware, order matters */
saf = sc->sc_dp->SizeAndFlags;
hi = sc->sc_dp->BufferAddressHi32; /* BUGBUG 64bit */
lo = sc->sc_dp->BufferAddressLo32; /* this pops the fifo */
__USE(hi);
__USE(lo);
/* Say its done that much (and sanity)
*/
if (bp) {
size_t count = saf & ICAPS_S_MASK;
/* more sanity */
if (count > bp->b_resid)
count = bp->b_resid;
bp->b_resid -= count;
}
/* More? */
isr = sc->sc_dp->Control;
}
/* Did we pop at least one */
if (saf)
icapstart(sc);
return (1);
}
/*
* HW (re)Initialization
*/
static void
icap_reset(struct icap_softc *sc)
{
DEBUG_PRINT(("icap_reset %x\n",sc->sc_dp->Control), DEBUG_STATUS);
sc->sc_dp->Control = ICAPC_RESET;
DELAY(2);
sc->sc_dp->Control = ICAPC_INTEN;
}
Reference in New Issue View Git Blame Copy Permalink