static void
njata32_clearirq(struct ata_channel *chp, int irq)
{
struct njata32_softc *sc = (void *)chp->ch_atac;
aprint_error("%s: unhandled intr: irq %#x, bm %#x, ",
NJATA32NAME(sc), irq,
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_BM));
/* disable busmaster */
njata32_irqack(chp);
/* clear device interrupt */
aprint_normal("err %#x, seccnt %#x, cyl %#x, sdh %#x, ",
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_WD_ERROR),
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_WD_SECCNT),
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_WD_CYL_LO) |
(bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_WD_CYL_HI) << 8),
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_WD_SDH));
aprint_normal("status %#x\n",
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_WD_STATUS));
}
static void
njata32_irqack(struct ata_channel *chp)
{
struct njata32_softc *sc = (void *)chp->ch_atac;
/* disable busmaster */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_BM, NJATA32_BM_WAIT0);
}
/*
* map DMA buffer
*/
int
njata32_dma_init(void *v, int channel, int drive, void *databuf,
size_t datalen, int flags)
{
struct njata32_softc *sc = v;
int error;
struct njata32_device *dev = &sc->sc_dev[drive];
KASSERT(channel == 0);
KASSERT((dev->d_flags & NJATA32_DEV_DMA_MAPPED) == 0);
KASSERT((dev->d_flags & NJATA32_DEV_DMA_STARTED) == 0);
KASSERT(flags & (WDC_DMA_PIOBM_ATA | WDC_DMA_PIOBM_ATAPI));
/* use PIO for short transfer */
if (datalen < 64 /* needs tune */) {
DPRINTF(("%s: njata32_dma_init: short transfer (%u)\n",
NJATA32NAME(sc), (unsigned)datalen));
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_TIMING, sc->sc_timing_pio);
return EINVAL;
}
/* use PIO for unaligned transfer (word alignment seems OK) */
if (((uintptr_t)databuf & 1) || (datalen & 1)) {
DPRINTF(("%s: njata32_dma_init: unaligned: buf %p, len %u\n",
NJATA32NAME(sc), databuf, (unsigned)datalen));
return EINVAL;
}
DPRINTF(("%s: njata32_dma_init: %s: databuf %p, datalen %u\n",
NJATA32NAME(sc), (flags & WDC_DMA_READ) ? "read" : "write",
databuf, (unsigned)datalen));
error = bus_dmamap_load(sc->sc_dmat, dev->d_dmamap_xfer,
databuf, datalen, NULL, BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
((flags & WDC_DMA_READ) ? BUS_DMA_READ : BUS_DMA_WRITE));
if (error) {
printf("%s: load xfer failed, error %d\n",
NJATA32NAME(sc), error);
return error;
}
bus_dmamap_sync(sc->sc_dmat, dev->d_dmamap_xfer, 0,
dev->d_dmamap_xfer->dm_mapsize,
(flags & WDC_DMA_READ) ?
BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
dev->d_flags =
((flags & WDC_DMA_READ) ? NJATA32_DEV_DMA_READ : 0) |
((flags & WDC_DMA_PIOBM_ATAPI) ? NJATA32_DEV_DMA_ATAPI : 0) |
NJATA32_DEV_DMA_MAPPED;
return 0;
}
static void
njata32_init(struct njata32_softc *sc, int nosleep)
{
/* disable interrupts */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_IRQ_SELECT, 0);
/* bus reset */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_AS,
NJATA32_AS_WAIT0 | NJATA32_AS_BUS_RESET);
if (nosleep)
delay(50000);
else
tsleep(sc, PRIBIO, "njaini", mstohz(50));
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_AS,
NJATA32_AS_WAIT0);
/* initial transfer speed */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_TIMING, NJATA32_TIMING_PIO0 + sc->sc_atawait);
/* setup busmaster mode */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_IOBM,
NJATA32_IOBM_DEFAULT);
/* enable interrupts */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_IRQ_SELECT, NJATA32_IRQ_XFER | NJATA32_IRQ_DEV);
}
static int
njata_cardbus_detach(device_t self, int flags)
{
struct njata32_cardbus_softc *csc = device_private(self);
struct njata32_softc *sc = &csc->sc_njata32;
int rv;
rv = njata32_detach(sc, flags);
if (rv)
return rv;
if (sc->sc_ih)
Cardbus_intr_disestablish(csc->sc_ct, sc->sc_ih);
if (sc->sc_flags & NJATA32_IO_MAPPED)
Cardbus_mapreg_unmap(csc->sc_ct, NJATA32_CARDBUS_BASEADDR_IO,
NJATA32_REGT(sc), NJATA32_REGH(sc), csc->sc_regmap_size);
if (sc->sc_flags & NJATA32_MEM_MAPPED)
Cardbus_mapreg_unmap(csc->sc_ct, NJATA32_CARDBUS_BASEADDR_MEM,
NJATA32_REGT(sc), csc->sc_regmaph, csc->sc_regmap_size);
return 0;
}
static void
njata32_setup_channel(struct ata_channel *chp)
{
struct njata32_softc *sc = (void *)chp->ch_atac;
struct ata_drive_datas *drvp;
int drive;
uint8_t mode;
KASSERT(chp->ch_ndrive != 0);
sc->sc_timing_pio = 0;
#if 0 /* ATA DMA is currently unused */
sc->sc_timing_dma = 0;
#endif
for (drive = 0; drive < chp->ch_ndrive; drive++) {
drvp = &chp->ch_drive[drive];
if ((drvp->drive_flags & DRIVE) == 0)
continue; /* no drive */
#if 0 /* ATA DMA is currently unused */
if ((drvp->drive_flags & DRIVE_DMA) != 0) {
/*
* Multiword DMA
*/
if ((mode = drvp->DMA_mode) > NJATA32_MODE_MAX_DMA)
mode = NJATA32_MODE_MAX_DMA;
if (sc->sc_timing_dma < njata32_timing_dma[mode])
sc->sc_timing_dma = njata32_timing_dma[mode];
}
#endif
/*
* PIO
*/
if ((mode = drvp->PIO_mode) > NJATA32_MODE_MAX_PIO)
mode = NJATA32_MODE_MAX_PIO;
if (sc->sc_timing_pio < njata32_timing_pio[mode])
sc->sc_timing_pio = njata32_timing_pio[mode];
}
sc->sc_timing_pio += sc->sc_atawait;
/* set timing for PIO */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_TIMING, sc->sc_timing_pio);
}
static void
njata_cardbus_attach(device_t parent, device_t self, void *aux)
{
struct cardbus_attach_args *ca = aux;
struct njata32_cardbus_softc *csc = device_private(self);
struct njata32_softc *sc = &csc->sc_njata32;
const struct njata32_cardbus_product *prod;
cardbus_devfunc_t ct = ca->ca_ct;
pcireg_t reg;
int csr;
uint8_t latency = 0x20;
sc->sc_wdcdev.sc_atac.atac_dev = self;
if ((prod = njata_cardbus_lookup(ca)) == NULL)
panic("njata_cardbus_attach");
aprint_normal(": Workbit NinjaATA-32 IDE controller\n");
csc->sc_ct = ct;
csc->sc_tag = ca->ca_tag;
/*
* Map the device.
*/
csr = PCI_COMMAND_MASTER_ENABLE;
/*
* Map registers.
* Try memory map first, and then try I/O.
*/
if ((prod->p_flags & NJATA32_FL_IOMAP_ONLY) == 0 &&
Cardbus_mapreg_map(csc->sc_ct, NJATA32_CARDBUS_BASEADDR_MEM,
PCI_MAPREG_TYPE_MEM|PCI_MAPREG_MEM_TYPE_32BIT, 0,
&NJATA32_REGT(sc), &csc->sc_regmaph, NULL, &csc->sc_regmap_size)
== 0) {
if (bus_space_subregion(NJATA32_REGT(sc), csc->sc_regmaph,
NJATA32_MEMOFFSET_REG, NJATA32_REGSIZE, &NJATA32_REGH(sc))
!= 0) {
/* failed -- undo map and try I/O */
Cardbus_mapreg_unmap(csc->sc_ct,
NJATA32_CARDBUS_BASEADDR_MEM, NJATA32_REGT(sc),
csc->sc_regmaph, csc->sc_regmap_size);
goto try_io;
}
#ifdef NJATA32_DEBUG
aprint_normal("%s: memory space mapped, size %u\n",
NJATA32NAME(sc), (unsigned)csc->sc_regmap_size);
#endif
csr |= PCI_COMMAND_MEM_ENABLE;
sc->sc_flags = NJATA32_MEM_MAPPED;
} else {
try_io:
if (Cardbus_mapreg_map(csc->sc_ct, NJATA32_CARDBUS_BASEADDR_IO,
PCI_MAPREG_TYPE_IO, 0, &NJATA32_REGT(sc),
&NJATA32_REGH(sc), NULL, &csc->sc_regmap_size) == 0) {
#ifdef NJATA32_DEBUG
aprint_normal("%s: io space mapped, size %u\n",
NJATA32NAME(sc), (unsigned)csc->sc_regmap_size);
#endif
csr |= PCI_COMMAND_IO_ENABLE;
sc->sc_flags = NJATA32_IO_MAPPED;
} else {
aprint_error("%s: unable to map device registers\n",
NJATA32NAME(sc));
return;
}
}
/* Enable the appropriate bits in the PCI CSR. */
reg = Cardbus_conf_read(ct, ca->ca_tag, PCI_COMMAND_STATUS_REG);
reg &= ~(PCI_COMMAND_IO_ENABLE|PCI_COMMAND_MEM_ENABLE);
reg |= csr;
Cardbus_conf_write(ct, ca->ca_tag, PCI_COMMAND_STATUS_REG, reg);
/*
* Make sure the latency timer is set to some reasonable
* value.
*/
reg = Cardbus_conf_read(ct, ca->ca_tag, PCI_BHLC_REG);
if (PCI_LATTIMER(reg) < latency) {
reg &= ~(PCI_LATTIMER_MASK << PCI_LATTIMER_SHIFT);
reg |= (latency << PCI_LATTIMER_SHIFT);
Cardbus_conf_write(ct, ca->ca_tag, PCI_BHLC_REG, reg);
}
sc->sc_dmat = ca->ca_dmat;
/*
* Establish the interrupt.
*/
sc->sc_ih = Cardbus_intr_establish(ct, IPL_BIO, njata32_intr, sc);
if (sc->sc_ih == NULL) {
aprint_error("%s: unable to establish interrupt\n",
NJATA32NAME(sc));
return;
}
/* attach */
njata32_attach(sc);
}
/*
* end of DMA
*/
int
njata32_dma_finish(void *v, int channel, int drive,
int force)
{
struct njata32_softc *sc = v;
struct njata32_device *dev = &sc->sc_dev[drive];
int bm;
int error = 0;
DPRINTF(("%s: njata32_dma_finish: bm = %#x\n", NJATA32NAME(sc),
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_BM)));
KASSERT(channel == 0);
KASSERT(dev->d_flags & NJATA32_DEV_DMA_MAPPED);
KASSERT(dev->d_flags & NJATA32_DEV_DMA_STARTED);
bm = bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_BM);
#ifdef NJATA32_DEBUG
printf("%s: irq %#x, bm %#x, 18 %#x, 1c %#x\n", NJATA32NAME(sc),
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_IRQ_STAT),
bm,
bus_space_read_4(NJATA32_REGT(sc), NJATA32_REGH(sc), 0x18),
bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 0x1c));
#endif
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_sgt,
(char *)dev->d_sgt - (char *)sc->sc_sgtpg,
sizeof(struct njata32_sgtable) * sc->sc_piobm_nsegs,
BUS_DMASYNC_POSTWRITE);
/* check if DMA is active */
if (bm & NJATA32_BM_GO) {
error = WDC_DMAST_NOIRQ;
switch (force) {
case WDC_DMAEND_END:
return error;
case WDC_DMAEND_ABRT:
printf("%s: aborting DMA\n", NJATA32NAME(sc));
break;
}
}
/*
* ???
* For unknown reason, PIOBM transfer sometimes fails in the middle,
* in which case the bit #7 of BM register becomes 0.
* Increasing the wait value seems to improve the situation.
*
* XXX
* PIO transfer may also fail, but it seems it can't be detected.
*/
if ((bm & NJATA32_BM_DONE) == 0) {
error |= WDC_DMAST_ERR;
printf("%s: busmaster error", NJATA32NAME(sc));
if (sc->sc_atawait < 0x11) {
if ((sc->sc_atawait & 0xf) == 0)
sc->sc_atawait++;
else
sc->sc_atawait += 0x10;
printf(", new ATA wait = %#x", sc->sc_atawait);
njata32_setup_channel(&sc->sc_ch[0].ch_ata_channel);
}
printf("\n");
}
/* stop command */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_AS,
NJATA32_AS_WAIT0);
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_BM,
NJATA32_BM_WAIT0);
/* set timing for PIO */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_TIMING, sc->sc_timing_pio);
/*
* reenable device interrupt in case it was disabled for
* this transfer
*/
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_IRQ_SELECT, NJATA32_IRQ_XFER | NJATA32_IRQ_DEV);
#if 1 /* should be? */
if ((sc->sc_devflags & NJATA32_DEV_GOT_XFER_INTR) == 0)
error |= WDC_DMAST_ERR;
#endif
sc->sc_devflags = 0;
#ifdef DIAGNOSTIC
dev->d_flags &= ~NJATA32_DEV_DMA_STARTED;
#endif
return error;
}
/*
* start DMA
*
* top: databuf + skip
* size: xferlen
*/
void
njata32_piobm_start(void *v, int channel, int drive,
int skip, int xferlen, int flags)
{
struct njata32_softc *sc = v;
struct njata32_device *dev = &sc->sc_dev[drive];
int i, nsegs, seglen;
uint8_t bmreg;
DPRINTF(("%s: njata32_piobm_start: ch%d, dv%d, skip %d, xferlen %d\n",
NJATA32NAME(sc), channel, drive, skip, xferlen));
KASSERT(channel == 0);
KASSERT(dev->d_flags & NJATA32_DEV_DMA_MAPPED);
KASSERT((dev->d_flags & NJATA32_DEV_DMA_STARTED) == 0);
/*
* create scatter/gather table
* XXX this code may be slow
*/
for (i = nsegs = 0;
i < dev->d_dmamap_xfer->dm_nsegs && xferlen > 0; i++) {
if (dev->d_dmamap_xfer->dm_segs[i].ds_len <= skip) {
skip -= dev->d_dmamap_xfer->dm_segs[i].ds_len;
continue;
}
seglen = dev->d_dmamap_xfer->dm_segs[i].ds_len - skip;
if (seglen > xferlen)
seglen = xferlen;
dev->d_sgt[nsegs].sg_addr =
htole32(dev->d_dmamap_xfer->dm_segs[i].ds_addr + skip);
dev->d_sgt[nsegs].sg_len = htole32(seglen);
xferlen -= seglen;
nsegs++;
skip = 0;
}
sc->sc_piobm_nsegs = nsegs;
/* end mark */
dev->d_sgt[nsegs - 1].sg_len |= htole32(NJATA32_SGT_ENDMARK);
#ifdef DIAGNOSTIC
if (xferlen)
panic("%s: njata32_piobm_start: xferlen residue %d\n",
NJATA32NAME(sc), xferlen);
#endif
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_sgt,
(char *)dev->d_sgt - (char *)sc->sc_sgtpg,
sizeof(struct njata32_sgtable) * nsegs,
BUS_DMASYNC_PREWRITE);
/* set timing for PIO */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_TIMING, sc->sc_timing_pio);
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_IOBM,
NJATA32_IOBM_DEFAULT);
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_AS,
NJATA32_AS_WAIT0);
/*
* interrupt configuration
*/
if ((dev->d_flags & (NJATA32_DEV_DMA_READ | NJATA32_DEV_DMA_ATAPI)) ==
NJATA32_DEV_DMA_READ) {
/*
* ATA piobm read is executed while device interrupt is active,
* so disable device interrupt here
*/
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_IRQ_SELECT, NJATA32_IRQ_XFER);
}
/* enable scatter/gather busmaster transfer */
bmreg = NJATA32_BM_EN | NJATA32_BM_SG | NJATA32_BM_WAIT0 |
((dev->d_flags & NJATA32_DEV_DMA_READ) ? NJATA32_BM_RD : 0);
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_BM,
bmreg);
/* load scatter/gather table */
bus_space_write_4(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_DMAADDR, dev->d_sgt_dma);
bus_space_write_4(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_DMALENGTH, sizeof(struct njata32_sgtable) * nsegs);
/* start transfer */
bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_BM,
(bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_BM)
& ~(NJATA32_BM_RD|NJATA32_BM_SG|NJATA32_BM_WAIT_MASK)) |
bmreg | NJATA32_BM_GO);
sc->sc_devflags = dev->d_flags;
if (flags & WDC_PIOBM_XFER_IRQ)
sc->sc_devflags |= NJATA32_DEV_XFER_INTR;
#ifdef DIAGNOSTIC
dev->d_flags |= NJATA32_DEV_DMA_STARTED;
#endif
}
void
njata32_attach(struct njata32_softc *sc)
{
bus_addr_t dmaaddr;
int i, devno, error;
struct wdc_regs *wdr;
/*
* allocate DMA resource
*/
if ((error = bus_dmamem_alloc(sc->sc_dmat,
sizeof(struct njata32_dma_page), PAGE_SIZE, 0,
&sc->sc_sgt_seg, 1, &sc->sc_sgt_nsegs, BUS_DMA_NOWAIT)) != 0) {
aprint_error("%s: unable to allocate sgt page, error = %d\n",
NJATA32NAME(sc), error);
return;
}
if ((error = bus_dmamem_map(sc->sc_dmat, &sc->sc_sgt_seg,
sc->sc_sgt_nsegs, sizeof(struct njata32_dma_page),
(void **)&sc->sc_sgtpg,
BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
aprint_error("%s: unable to map sgt page, error = %d\n",
NJATA32NAME(sc), error);
goto fail1;
}
if ((error = bus_dmamap_create(sc->sc_dmat,
sizeof(struct njata32_dma_page), 1,
sizeof(struct njata32_dma_page), 0, BUS_DMA_NOWAIT,
&sc->sc_dmamap_sgt)) != 0) {
aprint_error("%s: unable to create sgt DMA map, error = %d\n",
NJATA32NAME(sc), error);
goto fail2;
}
if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap_sgt,
sc->sc_sgtpg, sizeof(struct njata32_dma_page),
NULL, BUS_DMA_NOWAIT)) != 0) {
aprint_error("%s: unable to load sgt DMA map, error = %d\n",
NJATA32NAME(sc), error);
goto fail3;
}
dmaaddr = sc->sc_dmamap_sgt->dm_segs[0].ds_addr;
for (devno = 0; devno < NJATA32_NUM_DEV; devno++) {
sc->sc_dev[devno].d_sgt = sc->sc_sgtpg->dp_sg[devno];
sc->sc_dev[devno].d_sgt_dma = dmaaddr +
offsetof(struct njata32_dma_page, dp_sg[devno]);
error = bus_dmamap_create(sc->sc_dmat,
NJATA32_MAX_XFER, /* max total map size */
NJATA32_NUM_SG, /* max number of segments */
NJATA32_SGT_MAXSEGLEN, /* max size of a segment */
0, /* boundary */
BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
&sc->sc_dev[devno].d_dmamap_xfer);
if (error) {
aprint_error("%s: failed to create DMA map "
"(error = %d)\n", NJATA32NAME(sc), error);
goto fail4;
}
}
/* device properties */
sc->sc_wdcdev.sc_atac.atac_cap =
ATAC_CAP_DATA16 | ATAC_CAP_DATA32 | ATAC_CAP_PIOBM;
sc->sc_wdcdev.irqack = njata32_irqack;
sc->sc_wdcdev.sc_atac.atac_channels = sc->sc_wdc_chanarray;
sc->sc_wdcdev.sc_atac.atac_nchannels = NJATA32_NCHAN; /* 1 */
sc->sc_wdcdev.sc_atac.atac_pio_cap = NJATA32_MODE_MAX_PIO;
#if 0 /* ATA DMA is currently unused */
sc->sc_wdcdev.sc_atac.atac_dma_cap = NJATA32_MODE_MAX_DMA;
#endif
sc->sc_wdcdev.sc_atac.atac_set_modes = njata32_setup_channel;
/* DMA control functions */
sc->sc_wdcdev.dma_arg = sc;
sc->sc_wdcdev.dma_init = njata32_dma_init;
sc->sc_wdcdev.piobm_start = njata32_piobm_start;
sc->sc_wdcdev.dma_finish = njata32_dma_finish;
sc->sc_wdcdev.piobm_done = njata32_piobm_done;
sc->sc_wdcdev.cap |= WDC_CAPABILITY_NO_EXTRA_RESETS;
sc->sc_wdcdev.regs = wdr = &sc->sc_wdc_regs;
/* only one channel */
sc->sc_wdc_chanarray[0] = &sc->sc_ch[0].ch_ata_channel;
sc->sc_ch[0].ch_ata_channel.ch_channel = 0;
sc->sc_ch[0].ch_ata_channel.ch_atac = &sc->sc_wdcdev.sc_atac;
sc->sc_ch[0].ch_ata_channel.ch_queue = &sc->sc_wdc_chqueue;
sc->sc_ch[0].ch_ata_channel.ch_ndrive = 2; /* max number of drives */
/* map ATA registers */
for (i = 0; i < WDC_NREG; i++) {
if (bus_space_subregion(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_OFFSET_WDCREGS + i,
i == wd_data ? 4 : 1, &wdr->cmd_iohs[i]) != 0) {
aprint_error("%s: couldn't subregion cmd regs\n",
NJATA32NAME(sc));
goto fail4;
}
}
wdc_init_shadow_regs(&sc->sc_ch[0].ch_ata_channel);
wdr->data32iot = NJATA32_REGT(sc);
wdr->data32ioh = wdr->cmd_iohs[wd_data];
/* map ATA ctl reg */
wdr->ctl_iot = NJATA32_REGT(sc);
if (bus_space_subregion(NJATA32_REGT(sc), NJATA32_REGH(sc),
NJATA32_REG_WD_ALTSTATUS, 1, &wdr->ctl_ioh) != 0) {
aprint_error("%s: couldn't subregion ctl regs\n",
NJATA32NAME(sc));
goto fail4;
}
sc->sc_flags |= NJATA32_CMDPG_MAPPED;
/* use flags value as busmaster wait */
if ((sc->sc_atawait =
(uint8_t)device_cfdata(sc->sc_wdcdev.sc_atac.atac_dev)->cf_flags))
aprint_normal("%s: ATA wait = %#x\n",
NJATA32NAME(sc), sc->sc_atawait);
njata32_init(sc, cold);
wdcattach(&sc->sc_ch[0].ch_ata_channel);
return;
/*
* cleanup
*/
fail4: while (--devno >= 0) {
bus_dmamap_destroy(sc->sc_dmat,
sc->sc_dev[devno].d_dmamap_xfer);
}
bus_dmamap_unload(sc->sc_dmat, sc->sc_dmamap_sgt);
fail3: bus_dmamap_destroy(sc->sc_dmat, sc->sc_dmamap_sgt);
fail2: bus_dmamem_unmap(sc->sc_dmat, (void *)sc->sc_sgtpg,
sizeof(struct njata32_dma_page));
fail1: bus_dmamem_free(sc->sc_dmat, &sc->sc_sgt_seg, sc->sc_sgt_nsegs);
}
