* Copyright (c) 2007, 2008 Juan Romero Pardines <xtraeme@netbsd.org>

/* $NetBSD: arcmsr.c,v 1.45 2024/02/09 17:57:03 andvar Exp $ */
/* $OpenBSD: arc.c,v 1.68 2007/10/27 03:28:27 dlg Exp $ */

/*
* Copyright (c) 2007, 2008 Juan Romero Pardines <[email protected]>
* Copyright (c) 2006 David Gwynne <[email protected]>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include "bio.h"

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: arcmsr.c,v 1.45 2024/02/09 17:57:03 andvar Exp $");

#include <sys/param.h>
#include <sys/buf.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/kmem.h>
#include <sys/kthread.h>
#include <sys/mutex.h>
#include <sys/condvar.h>
#include <sys/rwlock.h>

#if NBIO > 0
#include <sys/ioctl.h>
#include <dev/biovar.h>
#endif

#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include <dev/pci/pcidevs.h>

#include <dev/scsipi/scsipi_all.h>
#include <dev/scsipi/scsi_all.h>
#include <dev/scsipi/scsiconf.h>

#include <dev/sysmon/sysmonvar.h>

#include <sys/bus.h>

#include <dev/pci/arcmsrvar.h>

/* #define ARC_DEBUG */
#ifdef ARC_DEBUG
#define ARC_D_INIT (1<<0)
#define ARC_D_RW (1<<1)
#define ARC_D_DB (1<<2)

int arcdebug = 0;

#define DPRINTF(p...) do { if (arcdebug) printf(p); } while (0)
#define DNPRINTF(n, p...) do { if ((n) & arcdebug) printf(p); } while (0)

#else
#define DPRINTF(p, ...) /* p */
#define DNPRINTF(n, p, ...) /* n, p */
#endif

/*
* the fw header must always equal this.
*/
#if NBIO > 0
static struct arc_fw_hdr arc_fw_hdr = { 0x5e, 0x01, 0x61 };
#endif

/*
* autoconf(9) glue.
*/
static int arc_match(device_t, cfdata_t, void *);
static void arc_attach(device_t, device_t, void *);
static int arc_detach(device_t, int);
static bool arc_shutdown(device_t, int);
static int arc_intr(void *);
static void arc_minphys(struct buf *);

CFATTACH_DECL_NEW(arcmsr, sizeof(struct arc_softc),
arc_match, arc_attach, arc_detach, NULL);

/*
* bio(4) and sysmon_envsys(9) glue.
*/
#if NBIO > 0
static int arc_bioctl(device_t, u_long, void *);
static int arc_bio_inq(struct arc_softc *, struct bioc_inq *);
static int arc_bio_vol(struct arc_softc *, struct bioc_vol *);
static int arc_bio_disk_volume(struct arc_softc *, struct bioc_disk *);
static int arc_bio_disk_novol(struct arc_softc *, struct bioc_disk *);
static void arc_bio_disk_filldata(struct arc_softc *, struct bioc_disk *,
struct arc_fw_diskinfo *, int);
static int arc_bio_alarm(struct arc_softc *, struct bioc_alarm *);
static int arc_bio_alarm_state(struct arc_softc *, struct bioc_alarm *);
static int arc_bio_getvol(struct arc_softc *, int,
struct arc_fw_volinfo *);
static int arc_bio_setstate(struct arc_softc *, struct bioc_setstate *);
static int arc_bio_volops(struct arc_softc *, struct bioc_volops *);
static void arc_create_sensors(void *);
static void arc_refresh_sensors(struct sysmon_envsys *, envsys_data_t *);
static int arc_fw_parse_status_code(struct arc_softc *, uint8_t *);
#endif

/*
* interface for scsi midlayer to talk to.
*/
static void arc_scsi_cmd(struct scsipi_channel *, scsipi_adapter_req_t,
void *);

/*
* code to deal with getting bits in and out of the bus space.
*/
static uint32_t arc_read(struct arc_softc *, bus_size_t);
static void arc_read_region(struct arc_softc *, bus_size_t, void *,
size_t);
static void arc_write(struct arc_softc *, bus_size_t, uint32_t);
#if NBIO > 0
static void arc_write_region(struct arc_softc *, bus_size_t, void *,
size_t);
#endif
static int arc_wait_eq(struct arc_softc *, bus_size_t, uint32_t,
uint32_t);
#ifdef unused
static int arc_wait_ne(struct arc_softc *, bus_size_t, uint32_t,
uint32_t);
#endif
static int arc_msg0(struct arc_softc *, uint32_t);
static struct arc_dmamem *arc_dmamem_alloc(struct arc_softc *, size_t);
static void arc_dmamem_free(struct arc_softc *,
struct arc_dmamem *);

static int arc_alloc_ccbs(device_t);
static struct arc_ccb *arc_get_ccb(struct arc_softc *);
static void arc_put_ccb(struct arc_softc *, struct arc_ccb *);
static int arc_load_xs(struct arc_ccb *);
static int arc_complete(struct arc_softc *, struct arc_ccb *, int);
static void arc_scsi_cmd_done(struct arc_softc *, struct arc_ccb *,
uint32_t);

/*
* real stuff for dealing with the hardware.
*/
static int arc_map_pci_resources(device_t, struct pci_attach_args *);
static void arc_unmap_pci_resources(struct arc_softc *);
static int arc_query_firmware(device_t);

/*
* stuff to do messaging via the doorbells.
*/
#if NBIO > 0
static void arc_lock(struct arc_softc *);
static void arc_unlock(struct arc_softc *);
static void arc_wait(struct arc_softc *);
static uint8_t arc_msg_cksum(void *, uint16_t);
static int arc_msgbuf(struct arc_softc *, void *, size_t, void *, size_t);
#endif

#define arc_push(_s, _r) arc_write((_s), ARC_REG_POST_QUEUE, (_r))
#define arc_pop(_s) arc_read((_s), ARC_REG_REPLY_QUEUE)

static int
arc_match(device_t parent, cfdata_t match, void *aux)
{
struct pci_attach_args *pa = aux;

if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ARECA) {
switch (PCI_PRODUCT(pa->pa_id)) {
case PCI_PRODUCT_ARECA_ARC1110:
case PCI_PRODUCT_ARECA_ARC1120:
case PCI_PRODUCT_ARECA_ARC1130:
case PCI_PRODUCT_ARECA_ARC1160:
case PCI_PRODUCT_ARECA_ARC1170:
case PCI_PRODUCT_ARECA_ARC1200:
case PCI_PRODUCT_ARECA_ARC1202:
case PCI_PRODUCT_ARECA_ARC1210:
case PCI_PRODUCT_ARECA_ARC1220:
case PCI_PRODUCT_ARECA_ARC1230:
case PCI_PRODUCT_ARECA_ARC1260:
case PCI_PRODUCT_ARECA_ARC1270:
case PCI_PRODUCT_ARECA_ARC1280:
case PCI_PRODUCT_ARECA_ARC1380:
case PCI_PRODUCT_ARECA_ARC1381:
case PCI_PRODUCT_ARECA_ARC1680:
case PCI_PRODUCT_ARECA_ARC1681:
return 1;
default:
break;
}
}

return 0;
}

static void
arc_attach(device_t parent, device_t self, void *aux)
{
struct arc_softc *sc = device_private(self);
struct pci_attach_args *pa = aux;
struct scsipi_adapter *adapt = &sc->sc_adapter;
struct scsipi_channel *chan = &sc->sc_chan;

sc->sc_dev = self;
sc->sc_talking = 0;
rw_init(&sc->sc_rwlock);
mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_BIO);
cv_init(&sc->sc_condvar, "arcdb");

if (arc_map_pci_resources(self, pa) != 0) {
/* error message printed by arc_map_pci_resources */
return;
}

if (arc_query_firmware(self) != 0) {
/* error message printed by arc_query_firmware */
goto unmap_pci;
}

if (arc_alloc_ccbs(self) != 0) {
/* error message printed by arc_alloc_ccbs */
goto unmap_pci;
}

if (!pmf_device_register1(self, NULL, NULL, arc_shutdown))
panic("%s: couldn't establish shutdown handler\n",
device_xname(self));

memset(adapt, 0, sizeof(*adapt));
adapt->adapt_dev = self;
adapt->adapt_nchannels = 1;
adapt->adapt_openings = sc->sc_req_count / ARC_MAX_TARGET;
adapt->adapt_max_periph = adapt->adapt_openings;
adapt->adapt_minphys = arc_minphys;
adapt->adapt_request = arc_scsi_cmd;
adapt->adapt_flags = SCSIPI_ADAPT_MPSAFE;

memset(chan, 0, sizeof(*chan));
chan->chan_adapter = adapt;
chan->chan_bustype = &scsi_bustype;
chan->chan_nluns = ARC_MAX_LUN;
chan->chan_ntargets = ARC_MAX_TARGET;
chan->chan_id = ARC_MAX_TARGET;
chan->chan_flags = SCSIPI_CHAN_NOSETTLE;

/*
* Save the device_t returned, because we could to attach
* devices via the management interface.
*/
sc->sc_scsibus_dv = config_found(self, &sc->sc_chan, scsiprint,
CFARGS_NONE);

/* enable interrupts */
arc_write(sc, ARC_REG_INTRMASK,
~(ARC_REG_INTRMASK_POSTQUEUE|ARC_REG_INTRSTAT_DOORBELL));

#if NBIO > 0
/*
* Register the driver to bio(4) and setup the sensors.
*/
if (bio_register(self, arc_bioctl) != 0)
panic("%s: bioctl registration failed\n", device_xname(self));

/*
* you need to talk to the firmware to get volume info. our firmware
* interface relies on being able to sleep, so we need to use a thread
* to do the work.
*/
if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
arc_create_sensors, sc, &sc->sc_lwp, "arcmsr_sensors") != 0)
panic("%s: unable to create a kernel thread for sensors\n",
device_xname(self));
#endif

return;

unmap_pci:
arc_unmap_pci_resources(sc);
}

static int
arc_detach(device_t self, int flags)
{
struct arc_softc *sc = device_private(self);

if (arc_msg0(sc, ARC_REG_INB_MSG0_STOP_BGRB) != 0)
aprint_error_dev(self, "timeout waiting to stop bg rebuild\n");

if (arc_msg0(sc, ARC_REG_INB_MSG0_FLUSH_CACHE) != 0)
aprint_error_dev(self, "timeout waiting to flush cache\n");

if (sc->sc_sme != NULL)
sysmon_envsys_unregister(sc->sc_sme);

return 0;
}

static bool
arc_shutdown(device_t self, int how)
{
struct arc_softc *sc = device_private(self);

if (arc_msg0(sc, ARC_REG_INB_MSG0_STOP_BGRB) != 0)
aprint_error_dev(self, "timeout waiting to stop bg rebuild\n");

if (arc_msg0(sc, ARC_REG_INB_MSG0_FLUSH_CACHE) != 0)
aprint_error_dev(self, "timeout waiting to flush cache\n");

return true;
}

static void
arc_minphys(struct buf *bp)
{
if (bp->b_bcount > MAXPHYS)
bp->b_bcount = MAXPHYS;
minphys(bp);
}

static int
arc_intr(void *arg)
{
struct arc_softc *sc = arg;
struct arc_ccb *ccb = NULL;
char *kva = ARC_DMA_KVA(sc->sc_requests);
struct arc_io_cmd *cmd;
uint32_t reg, intrstat;

mutex_spin_enter(&sc->sc_mutex);
intrstat = arc_read(sc, ARC_REG_INTRSTAT);
if (intrstat == 0x0) {
mutex_spin_exit(&sc->sc_mutex);
return 0;
}

intrstat &= ARC_REG_INTRSTAT_POSTQUEUE | ARC_REG_INTRSTAT_DOORBELL;
arc_write(sc, ARC_REG_INTRSTAT, intrstat);

if (intrstat & ARC_REG_INTRSTAT_DOORBELL) {
if (sc->sc_talking) {
arc_write(sc, ARC_REG_INTRMASK,
~ARC_REG_INTRMASK_POSTQUEUE);
cv_broadcast(&sc->sc_condvar);
} else {
/* otherwise drop it */
reg = arc_read(sc, ARC_REG_OUTB_DOORBELL);
arc_write(sc, ARC_REG_OUTB_DOORBELL, reg);
if (reg & ARC_REG_OUTB_DOORBELL_WRITE_OK)
arc_write(sc, ARC_REG_INB_DOORBELL,
ARC_REG_INB_DOORBELL_READ_OK);
}
}
mutex_spin_exit(&sc->sc_mutex);

while ((reg = arc_pop(sc)) != 0xffffffff) {
cmd = (struct arc_io_cmd *)(kva +
((reg << ARC_REG_REPLY_QUEUE_ADDR_SHIFT) -
(uint32_t)ARC_DMA_DVA(sc->sc_requests)));
ccb = &sc->sc_ccbs[htole32(cmd->cmd.context)];

bus_dmamap_sync(sc->sc_dmat, ARC_DMA_MAP(sc->sc_requests),
ccb->ccb_offset, ARC_MAX_IOCMDLEN,
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);

arc_scsi_cmd_done(sc, ccb, reg);
}

return 1;
}

void
arc_scsi_cmd(struct scsipi_channel *chan, scsipi_adapter_req_t req, void *arg)
{
struct scsipi_periph *periph;
struct scsipi_xfer *xs;
struct scsipi_adapter *adapt = chan->chan_adapter;
struct arc_softc *sc = device_private(adapt->adapt_dev);
struct arc_ccb *ccb;
struct arc_msg_scsicmd *cmd;
uint32_t reg;
uint8_t target;

switch (req) {
case ADAPTER_REQ_GROW_RESOURCES:
/* Not supported. */
return;
case ADAPTER_REQ_SET_XFER_MODE:
/* Not supported. */
return;
case ADAPTER_REQ_RUN_XFER:
break;
}

mutex_spin_enter(&sc->sc_mutex);

xs = arg;
periph = xs->xs_periph;
target = periph->periph_target;

if (xs->cmdlen > ARC_MSG_CDBLEN) {
memset(&xs->sense, 0, sizeof(xs->sense));
xs->sense.scsi_sense.response_code = SSD_RCODE_VALID | 0x70;
xs->sense.scsi_sense.flags = SKEY_ILLEGAL_REQUEST;
xs->sense.scsi_sense.asc = 0x20;
xs->error = XS_SENSE;
xs->status = SCSI_CHECK;
mutex_spin_exit(&sc->sc_mutex);
scsipi_done(xs);
return;
}

ccb = arc_get_ccb(sc);
if (ccb == NULL) {
xs->error = XS_RESOURCE_SHORTAGE;
mutex_spin_exit(&sc->sc_mutex);
scsipi_done(xs);
return;
}

ccb->ccb_xs = xs;

if (arc_load_xs(ccb) != 0) {
xs->error = XS_DRIVER_STUFFUP;
arc_put_ccb(sc, ccb);
mutex_spin_exit(&sc->sc_mutex);
scsipi_done(xs);
return;
}

cmd = &ccb->ccb_cmd->cmd;
reg = ccb->ccb_cmd_post;

/* bus is always 0 */
cmd->target = target;
cmd->lun = periph->periph_lun;
cmd->function = 1; /* XXX magic number */

cmd->cdb_len = xs->cmdlen;
cmd->sgl_len = ccb->ccb_dmamap->dm_nsegs;
if (xs->xs_control & XS_CTL_DATA_OUT)
cmd->flags = ARC_MSG_SCSICMD_FLAG_WRITE;
if (ccb->ccb_dmamap->dm_nsegs > ARC_SGL_256LEN) {
cmd->flags |= ARC_MSG_SCSICMD_FLAG_SGL_BSIZE_512;
reg |= ARC_REG_POST_QUEUE_BIGFRAME;
}

cmd->context = htole32(ccb->ccb_id);
cmd->data_len = htole32(xs->datalen);

memcpy(cmd->cdb, xs->cmd, xs->cmdlen);

/* we've built the command, let's put it on the hw */
bus_dmamap_sync(sc->sc_dmat, ARC_DMA_MAP(sc->sc_requests),
ccb->ccb_offset, ARC_MAX_IOCMDLEN,
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);

arc_push(sc, reg);
if (xs->xs_control & XS_CTL_POLL) {
if (arc_complete(sc, ccb, xs->timeout) != 0) {
xs->error = XS_DRIVER_STUFFUP;
mutex_spin_exit(&sc->sc_mutex);
scsipi_done(xs);
return;
}
}

mutex_spin_exit(&sc->sc_mutex);
}

int
arc_load_xs(struct arc_ccb *ccb)
{
struct arc_softc *sc = ccb->ccb_sc;
struct scsipi_xfer *xs = ccb->ccb_xs;
bus_dmamap_t dmap = ccb->ccb_dmamap;
struct arc_sge *sgl = ccb->ccb_cmd->sgl, *sge;
uint64_t addr;
int i, error;

if (xs->datalen == 0)
return 0;

error = bus_dmamap_load(sc->sc_dmat, dmap,
xs->data, xs->datalen, NULL,
(xs->xs_control & XS_CTL_NOSLEEP) ?
BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
if (error != 0) {
aprint_error("%s: error %d loading dmamap\n",
device_xname(sc->sc_dev), error);
return 1;
}

for (i = 0; i < dmap->dm_nsegs; i++) {
sge = &sgl[i];

sge->sg_hdr = htole32(ARC_SGE_64BIT | dmap->dm_segs[i].ds_len);
addr = dmap->dm_segs[i].ds_addr;
sge->sg_hi_addr = htole32((uint32_t)(addr >> 32));
sge->sg_lo_addr = htole32((uint32_t)addr);
}

bus_dmamap_sync(sc->sc_dmat, dmap, 0, dmap->dm_mapsize,
(xs->xs_control & XS_CTL_DATA_IN) ? BUS_DMASYNC_PREREAD :
BUS_DMASYNC_PREWRITE);

return 0;
}

void
arc_scsi_cmd_done(struct arc_softc *sc, struct arc_ccb *ccb, uint32_t reg)
{
struct scsipi_xfer *xs = ccb->ccb_xs;
struct arc_msg_scsicmd *cmd;

if (xs->datalen != 0) {
bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
ccb->ccb_dmamap->dm_mapsize,
(xs->xs_control & XS_CTL_DATA_IN) ?
BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
}

/* timeout_del */
xs->status |= XS_STS_DONE;

if (reg & ARC_REG_REPLY_QUEUE_ERR) {
cmd = &ccb->ccb_cmd->cmd;

switch (cmd->status) {
case ARC_MSG_STATUS_SELTIMEOUT:
case ARC_MSG_STATUS_ABORTED:
case ARC_MSG_STATUS_INIT_FAIL:
xs->status = SCSI_OK;
xs->error = XS_SELTIMEOUT;
break;

case SCSI_CHECK:
memset(&xs->sense, 0, sizeof(xs->sense));
memcpy(&xs->sense, cmd->sense_data,
uimin(ARC_MSG_SENSELEN, sizeof(xs->sense)));
xs->sense.scsi_sense.response_code =
SSD_RCODE_VALID | 0x70;
xs->status = SCSI_CHECK;
xs->error = XS_SENSE;
xs->resid = 0;
break;

default:
/* unknown device status */
xs->error = XS_BUSY; /* try again later? */
xs->status = SCSI_BUSY;
break;
}
} else {
xs->status = SCSI_OK;
xs->error = XS_NOERROR;
xs->resid = 0;
}

arc_put_ccb(sc, ccb);
scsipi_done(xs);
}

int
arc_complete(struct arc_softc *sc, struct arc_ccb *nccb, int timeout)
{
struct arc_ccb *ccb = NULL;
char *kva = ARC_DMA_KVA(sc->sc_requests);
struct arc_io_cmd *cmd;
uint32_t reg;

do {
reg = arc_pop(sc);
if (reg == 0xffffffff) {
if (timeout-- == 0)
return 1;

delay(1000);
continue;
}

cmd = (struct arc_io_cmd *)(kva +
((reg << ARC_REG_REPLY_QUEUE_ADDR_SHIFT) -
ARC_DMA_DVA(sc->sc_requests)));
ccb = &sc->sc_ccbs[htole32(cmd->cmd.context)];

bus_dmamap_sync(sc->sc_dmat, ARC_DMA_MAP(sc->sc_requests),
ccb->ccb_offset, ARC_MAX_IOCMDLEN,
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);

arc_scsi_cmd_done(sc, ccb, reg);
} while (nccb != ccb);

return 0;
}

int
arc_map_pci_resources(device_t self, struct pci_attach_args *pa)
{
struct arc_softc *sc = device_private(self);
pcireg_t memtype;
pci_intr_handle_t ih;
char intrbuf[PCI_INTRSTR_LEN];

sc->sc_pc = pa->pa_pc;
sc->sc_tag = pa->pa_tag;
sc->sc_dmat = pa->pa_dmat;

memtype = pci_mapreg_type(sc->sc_pc, sc->sc_tag, ARC_PCI_BAR);
if (pci_mapreg_map(pa, ARC_PCI_BAR, memtype, 0, &sc->sc_iot,
&sc->sc_ioh, NULL, &sc->sc_ios) != 0) {
aprint_error(": unable to map system interface register\n");
return 1;
}

if (pci_intr_map(pa, &ih) != 0) {
aprint_error(": unable to map interrupt\n");
goto unmap;
}

pci_intr_setattr(pa->pa_pc, &ih, PCI_INTR_MPSAFE, true);

sc->sc_ih = pci_intr_establish_xname(pa->pa_pc, ih, IPL_BIO,
arc_intr, sc, device_xname(self));
if (sc->sc_ih == NULL) {
aprint_error(": unable to map interrupt [2]\n");
goto unmap;
}

aprint_normal("\n");
aprint_normal_dev(self, "interrupting at %s\n",
pci_intr_string(pa->pa_pc, ih, intrbuf, sizeof(intrbuf)));

return 0;

unmap:
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
sc->sc_ios = 0;
return 1;
}

void
arc_unmap_pci_resources(struct arc_softc *sc)
{
pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
sc->sc_ios = 0;
}

int
arc_query_firmware(device_t self)
{
struct arc_softc *sc = device_private(self);
struct arc_msg_firmware_info fwinfo;
char string[81]; /* sizeof(vendor)*2+1 */

if (arc_wait_eq(sc, ARC_REG_OUTB_ADDR1, ARC_REG_OUTB_ADDR1_FIRMWARE_OK,
ARC_REG_OUTB_ADDR1_FIRMWARE_OK) != 0) {
aprint_debug_dev(self, "timeout waiting for firmware ok\n");
return 1;
}

if (arc_msg0(sc, ARC_REG_INB_MSG0_GET_CONFIG) != 0) {
aprint_debug_dev(self, "timeout waiting for get config\n");
return 1;
}

if (arc_msg0(sc, ARC_REG_INB_MSG0_START_BGRB) != 0) {
aprint_debug_dev(self, "timeout waiting to start bg rebuild\n");
return 1;
}

arc_read_region(sc, ARC_REG_MSGBUF, &fwinfo, sizeof(fwinfo));

DNPRINTF(ARC_D_INIT, "%s: signature: 0x%08x\n",
device_xname(self), htole32(fwinfo.signature));

if (htole32(fwinfo.signature) != ARC_FWINFO_SIGNATURE_GET_CONFIG) {
aprint_error_dev(self, "invalid firmware info from iop\n");
return 1;
}

DNPRINTF(ARC_D_INIT, "%s: request_len: %d\n",
device_xname(self), htole32(fwinfo.request_len));
DNPRINTF(ARC_D_INIT, "%s: queue_len: %d\n",
device_xname(self), htole32(fwinfo.queue_len));
DNPRINTF(ARC_D_INIT, "%s: sdram_size: %d\n",
device_xname(self), htole32(fwinfo.sdram_size));
DNPRINTF(ARC_D_INIT, "%s: sata_ports: %d\n",
device_xname(self), htole32(fwinfo.sata_ports));

strnvisx(string, sizeof(string), fwinfo.vendor, sizeof(fwinfo.vendor),
VIS_TRIM|VIS_SAFE|VIS_OCTAL);
DNPRINTF(ARC_D_INIT, "%s: vendor: \"%s\"\n",
device_xname(self), string);

strnvisx(string, sizeof(string), fwinfo.model, sizeof(fwinfo.model),
VIS_TRIM|VIS_SAFE|VIS_OCTAL);
aprint_normal_dev(self, "Areca %s Host Adapter RAID controller\n",
string);

strnvisx(string, sizeof(string), fwinfo.fw_version,
sizeof(fwinfo.fw_version), VIS_TRIM|VIS_SAFE|VIS_OCTAL);
DNPRINTF(ARC_D_INIT, "%s: version: \"%s\"\n",
device_xname(self), string);

aprint_normal_dev(self, "%d ports, %dMB SDRAM, firmware <%s>\n",
htole32(fwinfo.sata_ports), htole32(fwinfo.sdram_size), string);

if (htole32(fwinfo.request_len) != ARC_MAX_IOCMDLEN) {
aprint_error_dev(self,
"unexpected request frame size (%d != %d)\n",
htole32(fwinfo.request_len), ARC_MAX_IOCMDLEN);
return 1;
}

sc->sc_req_count = htole32(fwinfo.queue_len);

return 0;
}

#if NBIO > 0
static int
arc_bioctl(device_t self, u_long cmd, void *addr)
{
struct arc_softc *sc = device_private(self);
int error = 0;

switch (cmd) {
case BIOCINQ:
error = arc_bio_inq(sc, (struct bioc_inq *)addr);
break;

case BIOCVOL:
error = arc_bio_vol(sc, (struct bioc_vol *)addr);
break;

case BIOCDISK:
error = arc_bio_disk_volume(sc, (struct bioc_disk *)addr);
break;

case BIOCDISK_NOVOL:
error = arc_bio_disk_novol(sc, (struct bioc_disk *)addr);
break;

case BIOCALARM:
error = arc_bio_alarm(sc, (struct bioc_alarm *)addr);
break;

case BIOCSETSTATE:
error = arc_bio_setstate(sc, (struct bioc_setstate *)addr);
break;

case BIOCVOLOPS:
error = arc_bio_volops(sc, (struct bioc_volops *)addr);
break;

default:
error = ENOTTY;
break;
}

return error;
}

static int
arc_fw_parse_status_code(struct arc_softc *sc, uint8_t *reply)
{
switch (*reply) {
case ARC_FW_CMD_RAIDINVAL:
printf("%s: firmware error (invalid raid set)\n",
device_xname(sc->sc_dev));
return EINVAL;
case ARC_FW_CMD_VOLINVAL:
printf("%s: firmware error (invalid volume set)\n",
device_xname(sc->sc_dev));
return EINVAL;
case ARC_FW_CMD_NORAID:
printf("%s: firmware error (unexistent raid set)\n",
device_xname(sc->sc_dev));
return ENODEV;
case ARC_FW_CMD_NOVOLUME:
printf("%s: firmware error (unexistent volume set)\n",
device_xname(sc->sc_dev));
return ENODEV;
case ARC_FW_CMD_NOPHYSDRV:
printf("%s: firmware error (unexistent physical drive)\n",
device_xname(sc->sc_dev));
return ENODEV;
case ARC_FW_CMD_PARAM_ERR:
printf("%s: firmware error (parameter error)\n",
device_xname(sc->sc_dev));
return EINVAL;
case ARC_FW_CMD_UNSUPPORTED:
printf("%s: firmware error (unsupported command)\n",
device_xname(sc->sc_dev));
return EOPNOTSUPP;
case ARC_FW_CMD_DISKCFG_CHGD:
printf("%s: firmware error (disk configuration changed)\n",
device_xname(sc->sc_dev));
return EINVAL;
case ARC_FW_CMD_PASS_INVAL:
printf("%s: firmware error (invalid password)\n",
device_xname(sc->sc_dev));
return EINVAL;
case ARC_FW_CMD_NODISKSPACE:
printf("%s: firmware error (no disk space available)\n",
device_xname(sc->sc_dev));
return EOPNOTSUPP;
case ARC_FW_CMD_CHECKSUM_ERR:
printf("%s: firmware error (checksum error)\n",
device_xname(sc->sc_dev));
return EINVAL;
case ARC_FW_CMD_PASS_REQD:
printf("%s: firmware error (password required)\n",
device_xname(sc->sc_dev));
return EPERM;
case ARC_FW_CMD_OK:
default:
return 0;
}
}

static int
arc_bio_alarm(struct arc_softc *sc, struct bioc_alarm *ba)
{
uint8_t request[2], reply[1];
size_t len;
int error = 0;

switch (ba->ba_opcode) {
case BIOC_SAENABLE:
case BIOC_SADISABLE:
request[0] = ARC_FW_SET_ALARM;
request[1] = (ba->ba_opcode == BIOC_SAENABLE) ?
ARC_FW_SET_ALARM_ENABLE : ARC_FW_SET_ALARM_DISABLE;
len = sizeof(request);

break;

case BIOC_SASILENCE:
request[0] = ARC_FW_MUTE_ALARM;
len = 1;

break;

case BIOC_GASTATUS:
/* system info is too big/ugly to deal with here */
return arc_bio_alarm_state(sc, ba);

default:
return EOPNOTSUPP;
}

error = arc_msgbuf(sc, request, len, reply, sizeof(reply));
if (error != 0)
return error;

return arc_fw_parse_status_code(sc, &reply[0]);
}

static int
arc_bio_alarm_state(struct arc_softc *sc, struct bioc_alarm *ba)
{
struct arc_fw_sysinfo *sysinfo;
uint8_t request;
int error = 0;

sysinfo = kmem_zalloc(sizeof(*sysinfo), KM_SLEEP);

request = ARC_FW_SYSINFO;
error = arc_msgbuf(sc, &request, sizeof(request),
sysinfo, sizeof(struct arc_fw_sysinfo));

if (error != 0)
goto out;

ba->ba_status = sysinfo->alarm;

out:
kmem_free(sysinfo, sizeof(*sysinfo));
return error;
}

static int
arc_bio_volops(struct arc_softc *sc, struct bioc_volops *bc)
{
/* to create a raid set */
struct req_craidset {
uint8_t cmdcode;
uint32_t devmask;
uint8_t raidset_name[16];
} __packed;

/* to create a volume set */
struct req_cvolset {
uint8_t cmdcode;
uint8_t raidset;
uint8_t volset_name[16];
uint64_t capacity;
uint8_t raidlevel;
uint8_t stripe;
uint8_t scsi_chan;
uint8_t scsi_target;
uint8_t scsi_lun;
uint8_t tagqueue;
uint8_t cache;
uint8_t speed;
uint8_t quick_init;
} __packed;

struct scsibus_softc *scsibus_sc = NULL;
struct req_craidset req_craidset;
struct req_cvolset req_cvolset;
uint8_t request[2];
uint8_t reply[1];
int error = 0;

switch (bc->bc_opcode) {
case BIOC_VCREATE_VOLUME:
{
/*
* Zero out the structs so that we use some defaults
* in raid and volume sets.
*/
memset(&req_craidset, 0, sizeof(req_craidset));
memset(&req_cvolset, 0, sizeof(req_cvolset));

/*
* Firstly we have to create the raid set and
* use the default name for all them.
*/
req_craidset.cmdcode = ARC_FW_CREATE_RAIDSET;
req_craidset.devmask = bc->bc_devmask;
error = arc_msgbuf(sc, &req_craidset, sizeof(req_craidset),
reply, sizeof(reply));
if (error != 0)
return error;

error = arc_fw_parse_status_code(sc, &reply[0]);
if (error) {
printf("%s: create raidset%d failed\n",
device_xname(sc->sc_dev), bc->bc_volid);
return error;
}

/*
* At this point the raid set was created, so it's
* time to create the volume set.
*/
req_cvolset.cmdcode = ARC_FW_CREATE_VOLUME;
req_cvolset.raidset = bc->bc_volid;
req_cvolset.capacity = bc->bc_size * ARC_BLOCKSIZE;

/*
* Set the RAID level.
*/
switch (bc->bc_level) {
case 0:
case 1:
req_cvolset.raidlevel = bc->bc_level;
break;
case BIOC_SVOL_RAID10:
req_cvolset.raidlevel = 1;
break;
case 3:
req_cvolset.raidlevel = ARC_FW_VOL_RAIDLEVEL_3;
break;
case 5:
req_cvolset.raidlevel = ARC_FW_VOL_RAIDLEVEL_5;
break;
case 6:
req_cvolset.raidlevel = ARC_FW_VOL_RAIDLEVEL_6;
break;
default:
return EOPNOTSUPP;
}

/*
* Set the stripe size.
*/
switch (bc->bc_stripe) {
case 4:
req_cvolset.stripe = 0;
break;
case 8:
req_cvolset.stripe = 1;
break;
case 16:
req_cvolset.stripe = 2;
break;
case 32:
req_cvolset.stripe = 3;
break;
case 64:
req_cvolset.stripe = 4;
break;
case 128:
req_cvolset.stripe = 5;
break;
default:
req_cvolset.stripe = 4; /* by default 64K */
break;
}

req_cvolset.scsi_chan = bc->bc_channel;
req_cvolset.scsi_target = bc->bc_target;
req_cvolset.scsi_lun = bc->bc_lun;
req_cvolset.tagqueue = 1; /* always enabled */
req_cvolset.cache = 1; /* always enabled */
req_cvolset.speed = 4; /* always max speed */

/* RAID 1 and 1+0 levels need foreground initialization */
if (bc->bc_level == 1 || bc->bc_level == BIOC_SVOL_RAID10)
req_cvolset.quick_init = 1; /* foreground init */

error = arc_msgbuf(sc, &req_cvolset, sizeof(req_cvolset),
reply, sizeof(reply));
if (error != 0)
return error;

error = arc_fw_parse_status_code(sc, &reply[0]);
if (error) {
printf("%s: create volumeset%d failed\n",
device_xname(sc->sc_dev), bc->bc_volid);
return error;
}

/*
* If we are creating a RAID 1 or RAID 1+0 volume,
* the volume will be created immediately but it won't
* be available until the initialization is done... so
* don't bother attaching the sd(4) device.
*/
if (bc->bc_level == 1 || bc->bc_level == BIOC_SVOL_RAID10)
break;

/*
* Do a rescan on the bus to attach the device associated
* with the new volume.
*/
scsibus_sc = device_private(sc->sc_scsibus_dv);
(void)scsi_probe_bus(scsibus_sc, bc->bc_target, bc->bc_lun);

break;
}
case BIOC_VREMOVE_VOLUME:
{
/*
* Remove the volume set specified in bc_volid.
*/
request[0] = ARC_FW_DELETE_VOLUME;
request[1] = bc->bc_volid;
error = arc_msgbuf(sc, request, sizeof(request),
reply, sizeof(reply));
if (error != 0)
return error;

error = arc_fw_parse_status_code(sc, &reply[0]);
if (error) {
printf("%s: delete volumeset%d failed\n",
device_xname(sc->sc_dev), bc->bc_volid);
return error;
}

/*
* Detach the sd(4) device associated with the volume,
* but if there's an error don't make it a priority.
*/
error = scsipi_target_detach(&sc->sc_chan, bc->bc_target,
bc->bc_lun, 0);
if (error)
printf("%s: couldn't detach sd device for volume %d "
"at %u:%u.%u (error=%d)\n",
device_xname(sc->sc_dev), bc->bc_volid,
bc->bc_channel, bc->bc_target, bc->bc_lun, error);

/*
* and remove the raid set specified in bc_volid,
* we only care about volumes.
*/
request[0] = ARC_FW_DELETE_RAIDSET;
request[1] = bc->bc_volid;
error = arc_msgbuf(sc, request, sizeof(request),
reply, sizeof(reply));
if (error != 0)
return error;

error = arc_fw_parse_status_code(sc, &reply[0]);
if (error) {
printf("%s: delete raidset%d failed\n",
device_xname(sc->sc_dev), bc->bc_volid);
return error;
}

break;
}
default:
return EOPNOTSUPP;
}

return error;
}

static int
arc_bio_setstate(struct arc_softc *sc, struct bioc_setstate *bs)
{
/* for a hotspare disk */
struct request_hs {
uint8_t cmdcode;
uint32_t devmask;
} __packed;

/* for a pass-through disk */
struct request_pt {
uint8_t cmdcode;
uint8_t devid;
uint8_t scsi_chan;
uint8_t scsi_id;
uint8_t scsi_lun;
uint8_t tagged_queue;
uint8_t cache_mode;
uint8_t max_speed;
} __packed;

struct scsibus_softc *scsibus_sc = NULL;
struct request_hs req_hs; /* to add/remove hotspare */
struct request_pt req_pt; /* to add a pass-through */
uint8_t req_gen[2];
uint8_t reply[1];
int error = 0;

switch (bs->bs_status) {
case BIOC_SSHOTSPARE:
{
req_hs.cmdcode = ARC_FW_CREATE_HOTSPARE;
req_hs.devmask = (1 << bs->bs_target);
goto hotspare;
}
case BIOC_SSDELHOTSPARE:
{
req_hs.cmdcode = ARC_FW_DELETE_HOTSPARE;
req_hs.devmask = (1 << bs->bs_target);
goto hotspare;
}
case BIOC_SSPASSTHRU:
{
req_pt.cmdcode = ARC_FW_CREATE_PASSTHRU;
req_pt.devid = bs->bs_other_id; /* this wants device# */
req_pt.scsi_chan = bs->bs_channel;
req_pt.scsi_id = bs->bs_target;
req_pt.scsi_lun = bs->bs_lun;
req_pt.tagged_queue = 1; /* always enabled */
req_pt.cache_mode = 1; /* always enabled */
req_pt.max_speed = 4; /* always max speed */

error = arc_msgbuf(sc, &req_pt, sizeof(req_pt),
reply, sizeof(reply));
if (error != 0)
return error;

/*
* Do a rescan on the bus to attach the new device
* associated with the pass-through disk.
*/
scsibus_sc = device_private(sc->sc_scsibus_dv);
(void)scsi_probe_bus(scsibus_sc, bs->bs_target, bs->bs_lun);

goto out;
}
case BIOC_SSDELPASSTHRU:
{
req_gen[0] = ARC_FW_DELETE_PASSTHRU;
req_gen[1] = bs->bs_target;
error = arc_msgbuf(sc, &req_gen, sizeof(req_gen),
reply, sizeof(reply));
if (error != 0)
return error;

/*
* Detach the sd device associated with this pass-through disk.
*/
error = scsipi_target_detach(&sc->sc_chan, bs->bs_target,
bs->bs_lun, 0);
if (error)
printf("%s: couldn't detach sd device for the "
"pass-through disk at %u:%u.%u (error=%d)\n",
device_xname(sc->sc_dev),
bs->bs_channel, bs->bs_target, bs->bs_lun, error);

goto out;
}
case BIOC_SSCHECKSTART_VOL:
{
req_gen[0] = ARC_FW_START_CHECKVOL;
req_gen[1] = bs->bs_volid;
error = arc_msgbuf(sc, &req_gen, sizeof(req_gen),
reply, sizeof(reply));
if (error != 0)
return error;

goto out;
}
case BIOC_SSCHECKSTOP_VOL:
{
uint8_t req = ARC_FW_STOP_CHECKVOL;
error = arc_msgbuf(sc, &req, 1, reply, sizeof(reply));
if (error != 0)
return error;

goto out;
}
default:
return EOPNOTSUPP;
}

hotspare:
error = arc_msgbuf(sc, &req_hs, sizeof(req_hs),
reply, sizeof(reply));
if (error != 0)
return error;

out:
return arc_fw_parse_status_code(sc, &reply[0]);
}

static int
arc_bio_inq(struct arc_softc *sc, struct bioc_inq *bi)
{
uint8_t request[2];
struct arc_fw_sysinfo *sysinfo = NULL;
struct arc_fw_raidinfo *raidinfo;
int nvols = 0, i;
int error = 0;

raidinfo = kmem_zalloc(sizeof(*raidinfo), KM_SLEEP);

if (!sc->sc_maxraidset || !sc->sc_maxvolset || !sc->sc_cchans) {
sysinfo = kmem_zalloc(sizeof(*sysinfo), KM_SLEEP);

request[0] = ARC_FW_SYSINFO;
error = arc_msgbuf(sc, request, 1, sysinfo,
sizeof(struct arc_fw_sysinfo));
if (error != 0)
goto out;

sc->sc_maxraidset = sysinfo->max_raid_set;
sc->sc_maxvolset = sysinfo->max_volume_set;
sc->sc_cchans = sysinfo->ide_channels;
}

request[0] = ARC_FW_RAIDINFO;
for (i = 0; i < sc->sc_maxraidset; i++) {
request[1] = i;
error = arc_msgbuf(sc, request, sizeof(request), raidinfo,
sizeof(struct arc_fw_raidinfo));
if (error != 0)
goto out;

nvols += raidinfo->volumes;
}

strlcpy(bi->bi_dev, device_xname(sc->sc_dev), sizeof(bi->bi_dev));
bi->bi_novol = nvols;
bi->bi_nodisk = sc->sc_cchans;

out:
if (sysinfo)
kmem_free(sysinfo, sizeof(*sysinfo));
kmem_free(raidinfo, sizeof(*raidinfo));
return error;
}

static int
arc_bio_getvol(struct arc_softc *sc, int vol, struct arc_fw_volinfo *volinfo)
{
uint8_t request[2];
int error = 0;
int nvols = 0, i;

request[0] = ARC_FW_VOLINFO;
for (i = 0; i < sc->sc_maxvolset; i++) {
request[1] = i;
error = arc_msgbuf(sc, request, sizeof(request), volinfo,
sizeof(struct arc_fw_volinfo));
if (error != 0)
goto out;

if (volinfo->capacity == 0 && volinfo->capacity2 == 0)
continue;

if (nvols == vol)
break;

nvols++;
}

if (nvols != vol ||
(volinfo->capacity == 0 && volinfo->capacity2 == 0)) {
error = ENODEV;
goto out;
}

out:
return error;
}

static int
arc_bio_vol(struct arc_softc *sc, struct bioc_vol *bv)
{
struct arc_fw_volinfo *volinfo;
uint64_t blocks;
uint32_t status;
int error = 0;

volinfo = kmem_zalloc(sizeof(*volinfo), KM_SLEEP);

error = arc_bio_getvol(sc, bv->bv_volid, volinfo);
if (error != 0)
goto out;

bv->bv_percent = -1;
bv->bv_seconds = 0;

status = htole32(volinfo->volume_status);
if (status == 0x0) {
if (htole32(volinfo->fail_mask) == 0x0)
bv->bv_status = BIOC_SVONLINE;
else
bv->bv_status = BIOC_SVDEGRADED;
} else if (status & ARC_FW_VOL_STATUS_NEED_REGEN) {
bv->bv_status = BIOC_SVDEGRADED;
} else if (status & ARC_FW_VOL_STATUS_FAILED) {
bv->bv_status = BIOC_SVOFFLINE;
} else if (status & ARC_FW_VOL_STATUS_INITTING) {
bv->bv_status = BIOC_SVBUILDING;
bv->bv_percent = htole32(volinfo->progress);
} else if (status & ARC_FW_VOL_STATUS_REBUILDING) {
bv->bv_status = BIOC_SVREBUILD;
bv->bv_percent = htole32(volinfo->progress);
} else if (status & ARC_FW_VOL_STATUS_MIGRATING) {
bv->bv_status = BIOC_SVMIGRATING;
bv->bv_percent = htole32(volinfo->progress);
} else if (status & ARC_FW_VOL_STATUS_CHECKING) {
bv->bv_status = BIOC_SVCHECKING;
bv->bv_percent = htole32(volinfo->progress);
} else if (status & ARC_FW_VOL_STATUS_NEED_INIT) {
bv->bv_status = BIOC_SVOFFLINE;
} else {
printf("%s: volume %d status 0x%x\n",
device_xname(sc->sc_dev), bv->bv_volid, status);
}

blocks = (uint64_t)htole32(volinfo->capacity2) << 32;
blocks += (uint64_t)htole32(volinfo->capacity);
bv->bv_size = blocks * ARC_BLOCKSIZE; /* XXX */

switch (volinfo->raid_level) {
case ARC_FW_VOL_RAIDLEVEL_0:
bv->bv_level = 0;
break;
case ARC_FW_VOL_RAIDLEVEL_1:
if (volinfo->member_disks > 2)
bv->bv_level = BIOC_SVOL_RAID10;
else
bv->bv_level = 1;
break;
case ARC_FW_VOL_RAIDLEVEL_3:
bv->bv_level = 3;
break;
case ARC_FW_VOL_RAIDLEVEL_5:
bv->bv_level = 5;
break;
case ARC_FW_VOL_RAIDLEVEL_6:
bv->bv_level = 6;
break;
case ARC_FW_VOL_RAIDLEVEL_PASSTHRU:
bv->bv_level = BIOC_SVOL_PASSTHRU;
break;
default:
bv->bv_level = -1;
break;
}

bv->bv_nodisk = volinfo->member_disks;
bv->bv_stripe_size = volinfo->stripe_size / 2;
snprintf(bv->bv_dev, sizeof(bv->bv_dev), "sd%d", bv->bv_volid);
strnvisx(bv->bv_vendor, sizeof(bv->bv_vendor), volinfo->set_name,
sizeof(volinfo->set_name), VIS_TRIM|VIS_SAFE|VIS_OCTAL);

out:
kmem_free(volinfo, sizeof(*volinfo));
return error;
}

static int
arc_bio_disk_novol(struct arc_softc *sc, struct bioc_disk *bd)
{
struct arc_fw_diskinfo *diskinfo;
uint8_t request[2];
int error = 0;

diskinfo = kmem_zalloc(sizeof(*diskinfo), KM_SLEEP);

if (bd->bd_diskid >= sc->sc_cchans) {
error = ENODEV;
goto out;
}

request[0] = ARC_FW_DISKINFO;
request[1] = bd->bd_diskid;
error = arc_msgbuf(sc, request, sizeof(request),
diskinfo, sizeof(struct arc_fw_diskinfo));
if (error != 0)
goto out;

/* skip disks with no capacity */
if (htole32(diskinfo->capacity) == 0 &&
htole32(diskinfo->capacity2) == 0)
goto out;

bd->bd_disknovol = true;
arc_bio_disk_filldata(sc, bd, diskinfo, bd->bd_diskid);

out:
kmem_free(diskinfo, sizeof(*diskinfo));
return error;
}

static void
arc_bio_disk_filldata(struct arc_softc *sc, struct bioc_disk *bd,
struct arc_fw_diskinfo *diskinfo, int diskid)
{
uint64_t blocks;
char model[81];
char serial[41];
char rev[17];

/* Ignore bit zero for now, we don't know what it means */
diskinfo->device_state &= ~0x1;

switch (diskinfo->device_state) {
case ARC_FW_DISK_FAILED:
bd->bd_status = BIOC_SDFAILED;
break;
case ARC_FW_DISK_PASSTHRU:
bd->bd_status = BIOC_SDPASSTHRU;
break;
case ARC_FW_DISK_NORMAL:
bd->bd_status = BIOC_SDONLINE;
break;
case ARC_FW_DISK_HOTSPARE:
bd->bd_status = BIOC_SDHOTSPARE;
break;
case ARC_FW_DISK_UNUSED:
bd->bd_status = BIOC_SDUNUSED;
break;
case 0:
/* disk has been disconnected */
bd->bd_status = BIOC_SDOFFLINE;
bd->bd_channel = 1;
bd->bd_target = 0;
bd->bd_lun = 0;
strlcpy(bd->bd_vendor, "disk missing", sizeof(bd->bd_vendor));
break;
default:
printf("%s: unknown disk device_state: 0x%x\n", __func__,
diskinfo->device_state);
bd->bd_status = BIOC_SDINVALID;
return;
}

blocks = (uint64_t)htole32(diskinfo->capacity2) << 32;
blocks += (uint64_t)htole32(diskinfo->capacity);
bd->bd_size = blocks * ARC_BLOCKSIZE; /* XXX */

strnvisx(model, sizeof(model), diskinfo->model,
sizeof(diskinfo->model), VIS_TRIM|VIS_SAFE|VIS_OCTAL);
strnvisx(serial, sizeof(serial), diskinfo->serial,
sizeof(diskinfo->serial), VIS_TRIM|VIS_SAFE|VIS_OCTAL);
strnvisx(rev, sizeof(rev), diskinfo->firmware_rev,
sizeof(diskinfo->firmware_rev), VIS_TRIM|VIS_SAFE|VIS_OCTAL);

snprintf(bd->bd_vendor, sizeof(bd->bd_vendor), "%s %s", model, rev);
strlcpy(bd->bd_serial, serial, sizeof(bd->bd_serial));

#if 0
bd->bd_channel = diskinfo->scsi_attr.channel;
bd->bd_target = diskinfo->scsi_attr.target;
bd->bd_lun = diskinfo->scsi_attr.lun;
#endif

/*
* the firmware doesn't seem to fill scsi_attr in, so fake it with
* the diskid.
*/
bd->bd_channel = 0;
bd->bd_target = diskid;
bd->bd_lun = 0;
}

static int
arc_bio_disk_volume(struct arc_softc *sc, struct bioc_disk *bd)
{
struct arc_fw_raidinfo *raidinfo;
struct arc_fw_volinfo *volinfo;
struct arc_fw_diskinfo *diskinfo;
uint8_t request[2];
int error = 0;

volinfo = kmem_zalloc(sizeof(*volinfo), KM_SLEEP);
raidinfo = kmem_zalloc(sizeof(*raidinfo), KM_SLEEP);
diskinfo = kmem_zalloc(sizeof(*diskinfo), KM_SLEEP);

error = arc_bio_getvol(sc, bd->bd_volid, volinfo);
if (error != 0)
goto out;

request[0] = ARC_FW_RAIDINFO;
request[1] = volinfo->raid_set_number;

error = arc_msgbuf(sc, request, sizeof(request), raidinfo,
sizeof(struct arc_fw_raidinfo));
if (error != 0)
goto out;

if (bd->bd_diskid >= sc->sc_cchans ||
bd->bd_diskid >= raidinfo->member_devices) {
error = ENODEV;
goto out;
}

if (raidinfo->device_array[bd->bd_diskid] == 0xff) {
/*
* The disk has been disconnected, mark it offline
* and put it on another bus.
*/
bd->bd_channel = 1;
bd->bd_target = 0;
bd->bd_lun = 0;
bd->bd_status = BIOC_SDOFFLINE;
strlcpy(bd->bd_vendor, "disk missing", sizeof(bd->bd_vendor));
goto out;
}

request[0] = ARC_FW_DISKINFO;
request[1] = raidinfo->device_array[bd->bd_diskid];
error = arc_msgbuf(sc, request, sizeof(request), diskinfo,
sizeof(struct arc_fw_diskinfo));
if (error != 0)
goto out;

/* now fill our bio disk with data from the firmware */
arc_bio_disk_filldata(sc, bd, diskinfo,
raidinfo->device_array[bd->bd_diskid]);

out:
kmem_free(raidinfo, sizeof(*raidinfo));
kmem_free(volinfo, sizeof(*volinfo));
kmem_free(diskinfo, sizeof(*diskinfo));
return error;
}

static uint8_t
arc_msg_cksum(void *cmd, uint16_t len)
{
uint8_t *buf = cmd;
uint8_t cksum;
int i;

cksum = (uint8_t)(len >> 8) + (uint8_t)len;
for (i = 0; i < len; i++)
cksum += buf[i];

return cksum;
}

static int
arc_msgbuf(struct arc_softc *sc, void *wptr, size_t wbuflen, void *rptr,
size_t rbuflen)
{
uint8_t rwbuf[ARC_REG_IOC_RWBUF_MAXLEN];
uint8_t *wbuf, *rbuf;
int wlen, wdone = 0, rlen, rdone = 0;
struct arc_fw_bufhdr *bufhdr;
uint32_t reg, rwlen;
int error = 0;
#ifdef ARC_DEBUG
int i;
#endif

wbuf = rbuf = NULL;

DNPRINTF(ARC_D_DB, "%s: arc_msgbuf wbuflen: %d rbuflen: %d\n",
device_xname(sc->sc_dev), wbuflen, rbuflen);

wlen = sizeof(struct arc_fw_bufhdr) + wbuflen + 1; /* 1 for cksum */
wbuf = kmem_alloc(wlen, KM_SLEEP);

rlen = sizeof(struct arc_fw_bufhdr) + rbuflen + 1; /* 1 for cksum */
rbuf = kmem_alloc(rlen, KM_SLEEP);

DNPRINTF(ARC_D_DB, "%s: arc_msgbuf wlen: %d rlen: %d\n",
device_xname(sc->sc_dev), wlen, rlen);

bufhdr = (struct arc_fw_bufhdr *)wbuf;
bufhdr->hdr = arc_fw_hdr;
bufhdr->len = htole16(wbuflen);
memcpy(wbuf + sizeof(struct arc_fw_bufhdr), wptr, wbuflen);
wbuf[wlen - 1] = arc_msg_cksum(wptr, wbuflen);

arc_lock(sc);
if (arc_read(sc, ARC_REG_OUTB_DOORBELL) != 0) {
error = EBUSY;
goto out;
}

reg = ARC_REG_OUTB_DOORBELL_READ_OK;

do {
if ((reg & ARC_REG_OUTB_DOORBELL_READ_OK) && wdone < wlen) {
memset(rwbuf, 0, sizeof(rwbuf));
rwlen = (wlen - wdone) % sizeof(rwbuf);
memcpy(rwbuf, &wbuf[wdone], rwlen);

#ifdef ARC_DEBUG
if (arcdebug & ARC_D_DB) {
printf("%s: write %d:",
device_xname(sc->sc_dev), rwlen);
for (i = 0; i < rwlen; i++)
printf(" 0x%02x", rwbuf[i]);
printf("\n");
}
#endif

/* copy the chunk to the hw */
arc_write(sc, ARC_REG_IOC_WBUF_LEN, rwlen);
arc_write_region(sc, ARC_REG_IOC_WBUF, rwbuf,
sizeof(rwbuf));

/* say we have a buffer for the hw */
arc_write(sc, ARC_REG_INB_DOORBELL,
ARC_REG_INB_DOORBELL_WRITE_OK);

wdone += rwlen;
}

while ((reg = arc_read(sc, ARC_REG_OUTB_DOORBELL)) == 0)
arc_wait(sc);

arc_write(sc, ARC_REG_OUTB_DOORBELL, reg);

DNPRINTF(ARC_D_DB, "%s: reg: 0x%08x\n",
device_xname(sc->sc_dev), reg);

if ((reg & ARC_REG_OUTB_DOORBELL_WRITE_OK) && rdone < rlen) {
rwlen = arc_read(sc, ARC_REG_IOC_RBUF_LEN);
if (rwlen > sizeof(rwbuf)) {
DNPRINTF(ARC_D_DB, "%s: rwlen too big\n",
device_xname(sc->sc_dev));
error = EIO;
goto out;
}

arc_read_region(sc, ARC_REG_IOC_RBUF, rwbuf,
sizeof(rwbuf));

arc_write(sc, ARC_REG_INB_DOORBELL,
ARC_REG_INB_DOORBELL_READ_OK);

#ifdef ARC_DEBUG
printf("%s: len: %d+%d=%d/%d\n",
device_xname(sc->sc_dev),
rwlen, rdone, rwlen + rdone, rlen);
if (arcdebug & ARC_D_DB) {
printf("%s: read:",
device_xname(sc->sc_dev));
for (i = 0; i < rwlen; i++)
printf(" 0x%02x", rwbuf[i]);
printf("\n");
}
#endif

if ((rdone + rwlen) > rlen) {
DNPRINTF(ARC_D_DB, "%s: rwbuf too big\n",
device_xname(sc->sc_dev));
error = EIO;
goto out;
}

memcpy(&rbuf[rdone], rwbuf, rwlen);
rdone += rwlen;
}
} while (rdone != rlen);

bufhdr = (struct arc_fw_bufhdr *)rbuf;
if (memcmp(&bufhdr->hdr, &arc_fw_hdr, sizeof(bufhdr->hdr)) != 0 ||
bufhdr->len != htole16(rbuflen)) {
DNPRINTF(ARC_D_DB, "%s: rbuf hdr is wrong\n",
device_xname(sc->sc_dev));
error = EIO;
goto out;
}

memcpy(rptr, rbuf + sizeof(struct arc_fw_bufhdr), rbuflen);

if (rbuf[rlen - 1] != arc_msg_cksum(rptr, rbuflen)) {
DNPRINTF(ARC_D_DB, "%s: invalid cksum\n",
device_xname(sc->sc_dev));
error = EIO;
goto out;
}

out:
arc_unlock(sc);
kmem_free(wbuf, wlen);
kmem_free(rbuf, rlen);

return error;
}

static void
arc_lock(struct arc_softc *sc)
{
rw_enter(&sc->sc_rwlock, RW_WRITER);
mutex_spin_enter(&sc->sc_mutex);
arc_write(sc, ARC_REG_INTRMASK, ~ARC_REG_INTRMASK_POSTQUEUE);
sc->sc_talking = 1;
}

static void
arc_unlock(struct arc_softc *sc)
{
KASSERT(mutex_owned(&sc->sc_mutex));

arc_write(sc, ARC_REG_INTRMASK,
~(ARC_REG_INTRMASK_POSTQUEUE|ARC_REG_INTRMASK_DOORBELL));
sc->sc_talking = 0;
mutex_spin_exit(&sc->sc_mutex);
rw_exit(&sc->sc_rwlock);
}

static void
arc_wait(struct arc_softc *sc)
{
KASSERT(mutex_owned(&sc->sc_mutex));

arc_write(sc, ARC_REG_INTRMASK,
~(ARC_REG_INTRMASK_POSTQUEUE|ARC_REG_INTRMASK_DOORBELL));
if (cv_timedwait(&sc->sc_condvar, &sc->sc_mutex, hz) == EWOULDBLOCK)
arc_write(sc, ARC_REG_INTRMASK, ~ARC_REG_INTRMASK_POSTQUEUE);
}

static void
arc_create_sensors(void *arg)
{
struct arc_softc *sc = arg;
struct bioc_inq bi;
struct bioc_vol bv;
int i, j;
size_t slen, count = 0;

memset(&bi, 0, sizeof(bi));
if (arc_bio_inq(sc, &bi) != 0) {
aprint_error("%s: unable to query firmware for sensor info\n",
device_xname(sc->sc_dev));
kthread_exit(0);
}

/* There's no point to continue if there are no volumes */
if (!bi.bi_novol)
kthread_exit(0);

for (i = 0; i < bi.bi_novol; i++) {
memset(&bv, 0, sizeof(bv));
bv.bv_volid = i;
if (arc_bio_vol(sc, &bv) != 0)
kthread_exit(0);

/* Skip passthrough volumes */
if (bv.bv_level == BIOC_SVOL_PASSTHRU)
continue;

/* new volume found */
sc->sc_nsensors++;
/* new disk in a volume found */
sc->sc_nsensors+= bv.bv_nodisk;
}

/* No valid volumes */
if (!sc->sc_nsensors)
kthread_exit(0);

sc->sc_sme = sysmon_envsys_create();
slen = sizeof(arc_edata_t) * sc->sc_nsensors;
sc->sc_arc_sensors = kmem_zalloc(slen, KM_SLEEP);

/* Attach sensors for volumes and disks */
for (i = 0; i < bi.bi_novol; i++) {
memset(&bv, 0, sizeof(bv));
bv.bv_volid = i;
if (arc_bio_vol(sc, &bv) != 0)
goto bad;

sc->sc_arc_sensors[count].arc_sensor.units = ENVSYS_DRIVE;
sc->sc_arc_sensors[count].arc_sensor.state = ENVSYS_SINVALID;
sc->sc_arc_sensors[count].arc_sensor.value_cur =
ENVSYS_DRIVE_EMPTY;
sc->sc_arc_sensors[count].arc_sensor.flags =
ENVSYS_FMONSTCHANGED;

/* Skip passthrough volumes */
if (bv.bv_level == BIOC_SVOL_PASSTHRU)
continue;

if (bv.bv_level == BIOC_SVOL_RAID10)
snprintf(sc->sc_arc_sensors[count].arc_sensor.desc,
sizeof(sc->sc_arc_sensors[count].arc_sensor.desc),
"RAID 1+0 volume%d (%s)", i, bv.bv_dev);
else
snprintf(sc->sc_arc_sensors[count].arc_sensor.desc,
sizeof(sc->sc_arc_sensors[count].arc_sensor.desc),
"RAID %d volume%d (%s)", bv.bv_level, i,
bv.bv_dev);

sc->sc_arc_sensors[count].arc_volid = i;

if (sysmon_envsys_sensor_attach(sc->sc_sme,
&sc->sc_arc_sensors[count].arc_sensor))
goto bad;

count++;

/* Attach disk sensors for this volume */
for (j = 0; j < bv.bv_nodisk; j++) {
sc->sc_arc_sensors[count].arc_sensor.state =
ENVSYS_SINVALID;
sc->sc_arc_sensors[count].arc_sensor.units =
ENVSYS_DRIVE;
sc->sc_arc_sensors[count].arc_sensor.value_cur =
ENVSYS_DRIVE_EMPTY;
sc->sc_arc_sensors[count].arc_sensor.flags =
ENVSYS_FMONSTCHANGED;

snprintf(sc->sc_arc_sensors[count].arc_sensor.desc,
sizeof(sc->sc_arc_sensors[count].arc_sensor.desc),
"disk%d volume%d (%s)", j, i, bv.bv_dev);
sc->sc_arc_sensors[count].arc_volid = i;
sc->sc_arc_sensors[count].arc_diskid = j + 10;

if (sysmon_envsys_sensor_attach(sc->sc_sme,
&sc->sc_arc_sensors[count].arc_sensor))
goto bad;

count++;
}
}

/*
* Register our envsys driver with the framework now that the
* sensors were all attached.
*/
sc->sc_sme->sme_name = device_xname(sc->sc_dev);
sc->sc_sme->sme_cookie = sc;
sc->sc_sme->sme_refresh = arc_refresh_sensors;

if (sysmon_envsys_register(sc->sc_sme)) {
aprint_debug("%s: unable to register with sysmon\n",
device_xname(sc->sc_dev));
goto bad;
}
kthread_exit(0);

bad:
sysmon_envsys_destroy(sc->sc_sme);
sc->sc_sme = NULL;

kmem_free(sc->sc_arc_sensors, slen);
sc->sc_arc_sensors = NULL;

kthread_exit(0);
}

static void
arc_refresh_sensors(struct sysmon_envsys *sme, envsys_data_t *edata)
{
struct arc_softc *sc = sme->sme_cookie;
struct bioc_vol bv;
struct bioc_disk bd;
arc_edata_t *arcdata = (arc_edata_t *)edata;

/* sanity check */
if (edata->units != ENVSYS_DRIVE)
return;

memset(&bv, 0, sizeof(bv));
bv.bv_volid = arcdata->arc_volid;

if (arc_bio_vol(sc, &bv)) {
bv.bv_status = BIOC_SVINVALID;
bio_vol_to_envsys(edata, &bv);
return;
}

if (arcdata->arc_diskid) {
/* Current sensor is handling a disk volume member */
memset(&bd, 0, sizeof(bd));
bd.bd_volid = arcdata->arc_volid;
bd.bd_diskid = arcdata->arc_diskid - 10;

if (arc_bio_disk_volume(sc, &bd))
bd.bd_status = BIOC_SDOFFLINE;
bio_disk_to_envsys(edata, &bd);
} else {
/* Current sensor is handling a volume */
bio_vol_to_envsys(edata, &bv);
}
}
#endif /* NBIO > 0 */

static uint32_t
arc_read(struct arc_softc *sc, bus_size_t r)
{
uint32_t v;

bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
BUS_SPACE_BARRIER_READ);
v = bus_space_read_4(sc->sc_iot, sc->sc_ioh, r);

DNPRINTF(ARC_D_RW, "%s: arc_read 0x%lx 0x%08x\n",
device_xname(sc->sc_dev), r, v);

return v;
}

static void
arc_read_region(struct arc_softc *sc, bus_size_t r, void *buf, size_t len)
{
bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, len,
BUS_SPACE_BARRIER_READ);
bus_space_read_region_4(sc->sc_iot, sc->sc_ioh, r,
(uint32_t *)buf, len >> 2);
}

static void
arc_write(struct arc_softc *sc, bus_size_t r, uint32_t v)
{
DNPRINTF(ARC_D_RW, "%s: arc_write 0x%lx 0x%08x\n",
device_xname(sc->sc_dev), r, v);

bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v);
bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
BUS_SPACE_BARRIER_WRITE);
}

#if NBIO > 0
static void
arc_write_region(struct arc_softc *sc, bus_size_t r, void *buf, size_t len)
{
bus_space_write_region_4(sc->sc_iot, sc->sc_ioh, r,
(const uint32_t *)buf, len >> 2);
bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, len,
BUS_SPACE_BARRIER_WRITE);
}
#endif /* NBIO > 0 */

static int
arc_wait_eq(struct arc_softc *sc, bus_size_t r, uint32_t mask,
uint32_t target)
{
int i;

DNPRINTF(ARC_D_RW, "%s: arc_wait_eq 0x%lx 0x%08x 0x%08x\n",
device_xname(sc->sc_dev), r, mask, target);

for (i = 0; i < 10000; i++) {
if ((arc_read(sc, r) & mask) == target)
return 0;
delay(1000);
}

return 1;
}

#if unused
static int
arc_wait_ne(struct arc_softc *sc, bus_size_t r, uint32_t mask,
uint32_t target)
{
int i;

DNPRINTF(ARC_D_RW, "%s: arc_wait_ne 0x%lx 0x%08x 0x%08x\n",
device_xname(sc->sc_dev), r, mask, target);

for (i = 0; i < 10000; i++) {
if ((arc_read(sc, r) & mask) != target)
return 0;
delay(1000);
}

return 1;
}
#endif

static int
arc_msg0(struct arc_softc *sc, uint32_t m)
{
/* post message */
arc_write(sc, ARC_REG_INB_MSG0, m);
/* wait for the fw to do it */
if (arc_wait_eq(sc, ARC_REG_INTRSTAT, ARC_REG_INTRSTAT_MSG0,
ARC_REG_INTRSTAT_MSG0) != 0)
return 1;

/* ack it */
arc_write(sc, ARC_REG_INTRSTAT, ARC_REG_INTRSTAT_MSG0);

return 0;
}

static struct arc_dmamem *
arc_dmamem_alloc(struct arc_softc *sc, size_t size)
{
struct arc_dmamem *adm;
int nsegs;

adm = kmem_zalloc(sizeof(*adm), KM_SLEEP);
adm->adm_size = size;

if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW, &adm->adm_map) != 0)
goto admfree;

if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &adm->adm_seg,
1, &nsegs, BUS_DMA_NOWAIT) != 0)
goto destroy;

if (bus_dmamem_map(sc->sc_dmat, &adm->adm_seg, nsegs, size,
&adm->adm_kva, BUS_DMA_NOWAIT|BUS_DMA_COHERENT) != 0)
goto free;

if (bus_dmamap_load(sc->sc_dmat, adm->adm_map, adm->adm_kva, size,
NULL, BUS_DMA_NOWAIT) != 0)
goto unmap;

memset(adm->adm_kva, 0, size);

return adm;

unmap:
bus_dmamem_unmap(sc->sc_dmat, adm->adm_kva, size);
free:
bus_dmamem_free(sc->sc_dmat, &adm->adm_seg, 1);
destroy:
bus_dmamap_destroy(sc->sc_dmat, adm->adm_map);
admfree:
kmem_free(adm, sizeof(*adm));

return NULL;
}

static void
arc_dmamem_free(struct arc_softc *sc, struct arc_dmamem *adm)
{
bus_dmamap_unload(sc->sc_dmat, adm->adm_map);
bus_dmamem_unmap(sc->sc_dmat, adm->adm_kva, adm->adm_size);
bus_dmamem_free(sc->sc_dmat, &adm->adm_seg, 1);
bus_dmamap_destroy(sc->sc_dmat, adm->adm_map);
kmem_free(adm, sizeof(*adm));
}

static int
arc_alloc_ccbs(device_t self)
{
struct arc_softc *sc = device_private(self);
struct arc_ccb *ccb;
uint8_t *cmd;
int i;
size_t ccbslen;

TAILQ_INIT(&sc->sc_ccb_free);

ccbslen = sizeof(struct arc_ccb) * sc->sc_req_count;
sc->sc_ccbs = kmem_zalloc(ccbslen, KM_SLEEP);

sc->sc_requests = arc_dmamem_alloc(sc,
ARC_MAX_IOCMDLEN * sc->sc_req_count);
if (sc->sc_requests == NULL) {
aprint_error_dev(self, "unable to allocate ccb dmamem\n");
goto free_ccbs;
}
cmd = ARC_DMA_KVA(sc->sc_requests);

for (i = 0; i < sc->sc_req_count; i++) {
ccb = &sc->sc_ccbs[i];

if (bus_dmamap_create(sc->sc_dmat, MAXPHYS, ARC_SGL_MAXLEN,
MAXPHYS, 0, 0, &ccb->ccb_dmamap) != 0) {
aprint_error_dev(self,
"unable to create dmamap for ccb %d\n", i);
goto free_maps;
}

ccb->ccb_sc = sc;
ccb->ccb_id = i;
ccb->ccb_offset = ARC_MAX_IOCMDLEN * i;

ccb->ccb_cmd = (struct arc_io_cmd *)&cmd[ccb->ccb_offset];
ccb->ccb_cmd_post = (ARC_DMA_DVA(sc->sc_requests) +
ccb->ccb_offset) >> ARC_REG_POST_QUEUE_ADDR_SHIFT;

arc_put_ccb(sc, ccb);
}

return 0;

free_maps:
while ((ccb = arc_get_ccb(sc)) != NULL)
bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmamap);
arc_dmamem_free(sc, sc->sc_requests);

free_ccbs:
kmem_free(sc->sc_ccbs, ccbslen);

return 1;
}

static struct arc_ccb *
arc_get_ccb(struct arc_softc *sc)
{
struct arc_ccb *ccb;

ccb = TAILQ_FIRST(&sc->sc_ccb_free);
if (ccb != NULL)
TAILQ_REMOVE(&sc->sc_ccb_free, ccb, ccb_link);

return ccb;
}

static void
arc_put_ccb(struct arc_softc *sc, struct arc_ccb *ccb)
{
ccb->ccb_xs = NULL;
memset(ccb->ccb_cmd, 0, ARC_MAX_IOCMDLEN);
TAILQ_INSERT_TAIL(&sc->sc_ccb_free, ccb, ccb_link);
}