ninjaata32.c revision 1.2
1 /* $Id: ninjaata32.c,v 1.2 2006/10/01 09:53:09 itohy Exp $ */ 2 3 /* 4 * Copyright (c) 2006 ITOH Yasufumi <itohy (at) NetBSD.org>. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' 17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 18 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 26 * THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: ninjaata32.c,v 1.2 2006/10/01 09:53:09 itohy Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/kernel.h> 34 #include <sys/device.h> 35 36 #include <machine/bus.h> 37 #include <machine/intr.h> 38 39 #include <uvm/uvm_extern.h> 40 41 #include <dev/ata/atavar.h> 42 #include <dev/ic/wdcreg.h> 43 #include <dev/ic/wdcvar.h> 44 45 #include <dev/ic/ninjaata32reg.h> 46 #include <dev/ic/ninjaata32var.h> 47 48 #ifdef NJATA32_DEBUG 49 #define DPRINTF(x) printf x 50 #else 51 #define DPRINTF(x) 52 #endif 53 54 static void njata32_init(struct njata32_softc *, int nosleep); 55 static void njata32_irqack(struct ata_channel *); 56 static void njata32_clearirq(struct ata_channel *, int); 57 static void njata32_setup_channel(struct ata_channel *); 58 static int njata32_dma_init(void *, int channel, int drive, 59 void *databuf, size_t datalen, int flags); 60 static void njata32_piobm_start(void *, int channel, int drive, int skip, 61 int xferlen, int flags); 62 static int njata32_dma_finish(void *, int channel, int drive, int force); 63 static void njata32_piobm_done(void *, int channel, int drive); 64 65 #if 0 /* ATA DMA is currently unused */ 66 static const uint8_t njata32_timing_dma[NJATA32_MODE_MAX_DMA + 1] = { 67 NJATA32_TIMING_DMA0, NJATA32_TIMING_DMA1, NJATA32_TIMING_DMA2 68 }; 69 #endif 70 static const uint8_t njata32_timing_pio[NJATA32_MODE_MAX_PIO + 1] = { 71 NJATA32_TIMING_PIO0, NJATA32_TIMING_PIO1, NJATA32_TIMING_PIO2, 72 NJATA32_TIMING_PIO3, NJATA32_TIMING_PIO4 73 }; 74 75 static void 76 njata32_init(sc, nosleep) 77 struct njata32_softc *sc; 78 int nosleep; /* can't sleep (during cold boot and in interrupt) */ 79 { 80 81 /* disable interrupts */ 82 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 83 NJATA32_REG_IRQ_SELECT, 0); 84 85 /* bus reset */ 86 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_AS, 87 NJATA32_AS_WAIT0 | NJATA32_AS_BUS_RESET); 88 if (nosleep) 89 delay(50000); 90 else 91 tsleep(sc, PRIBIO, "njaini", mstohz(50)); 92 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_AS, 93 NJATA32_AS_WAIT0); 94 95 /* initial transfer speed */ 96 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 97 NJATA32_REG_TIMING, NJATA32_TIMING_PIO0 + sc->sc_atawait); 98 99 /* setup busmaster mode */ 100 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_IOBM, 101 NJATA32_IOBM_DEFAULT); 102 103 /* enable interrupts */ 104 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 105 NJATA32_REG_IRQ_SELECT, NJATA32_IRQ_XFER | NJATA32_IRQ_DEV); 106 } 107 108 void 109 njata32_attach(sc) 110 struct njata32_softc *sc; 111 { 112 bus_addr_t dmaaddr; 113 int i, devno, error; 114 struct wdc_regs *wdr; 115 116 /* 117 * allocate DMA resource 118 */ 119 if ((error = bus_dmamem_alloc(sc->sc_dmat, 120 sizeof(struct njata32_dma_page), PAGE_SIZE, 0, 121 &sc->sc_sgt_seg, 1, &sc->sc_sgt_nsegs, BUS_DMA_NOWAIT)) != 0) { 122 printf("%s: unable to allocate sgt page, error = %d\n", 123 NJATA32NAME(sc), error); 124 return; 125 } 126 if ((error = bus_dmamem_map(sc->sc_dmat, &sc->sc_sgt_seg, 127 sc->sc_sgt_nsegs, sizeof(struct njata32_dma_page), 128 (caddr_t *)&sc->sc_sgtpg, 129 BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) { 130 printf("%s: unable to map sgt page, error = %d\n", 131 NJATA32NAME(sc), error); 132 goto fail1; 133 } 134 if ((error = bus_dmamap_create(sc->sc_dmat, 135 sizeof(struct njata32_dma_page), 1, 136 sizeof(struct njata32_dma_page), 0, BUS_DMA_NOWAIT, 137 &sc->sc_dmamap_sgt)) != 0) { 138 printf("%s: unable to create sgt DMA map, error = %d\n", 139 NJATA32NAME(sc), error); 140 goto fail2; 141 } 142 if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap_sgt, 143 sc->sc_sgtpg, sizeof(struct njata32_dma_page), 144 NULL, BUS_DMA_NOWAIT)) != 0) { 145 printf("%s: unable to load sgt DMA map, error = %d\n", 146 NJATA32NAME(sc), error); 147 goto fail3; 148 } 149 150 dmaaddr = sc->sc_dmamap_sgt->dm_segs[0].ds_addr; 151 152 for (devno = 0; devno < NJATA32_NUM_DEV; devno++) { 153 sc->sc_dev[devno].d_sgt = sc->sc_sgtpg->dp_sg[devno]; 154 sc->sc_dev[devno].d_sgt_dma = dmaaddr + 155 offsetof(struct njata32_dma_page, dp_sg[devno]); 156 157 error = bus_dmamap_create(sc->sc_dmat, 158 NJATA32_MAX_XFER, /* max total map size */ 159 NJATA32_NUM_SG, /* max number of segments */ 160 NJATA32_SGT_MAXSEGLEN, /* max size of a segment */ 161 0, /* boundary */ 162 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, 163 &sc->sc_dev[devno].d_dmamap_xfer); 164 if (error) { 165 printf("%s: failed to create DMA map (error = %d)\n", 166 NJATA32NAME(sc), error); 167 goto fail4; 168 } 169 } 170 171 /* device properties */ 172 sc->sc_wdcdev.sc_atac.atac_cap = 173 ATAC_CAP_DATA16 | ATAC_CAP_DATA32 | ATAC_CAP_PIOBM; 174 sc->sc_wdcdev.irqack = njata32_irqack; 175 sc->sc_wdcdev.sc_atac.atac_channels = sc->sc_wdc_chanarray; 176 sc->sc_wdcdev.sc_atac.atac_nchannels = NJATA32_NCHAN; /* 1 */ 177 sc->sc_wdcdev.sc_atac.atac_pio_cap = NJATA32_MODE_MAX_PIO; 178 #if 0 /* ATA DMA is currently unused */ 179 sc->sc_wdcdev.sc_atac.atac_dma_cap = NJATA32_MODE_MAX_DMA; 180 #endif 181 sc->sc_wdcdev.sc_atac.atac_set_modes = njata32_setup_channel; 182 183 /* DMA control functions */ 184 sc->sc_wdcdev.dma_arg = sc; 185 sc->sc_wdcdev.dma_init = njata32_dma_init; 186 sc->sc_wdcdev.piobm_start = njata32_piobm_start; 187 sc->sc_wdcdev.dma_finish = njata32_dma_finish; 188 sc->sc_wdcdev.piobm_done = njata32_piobm_done; 189 190 sc->sc_wdcdev.cap |= WDC_CAPABILITY_NO_EXTRA_RESETS; 191 192 sc->sc_wdcdev.regs = wdr = &sc->sc_wdc_regs; 193 194 /* only one channel */ 195 sc->sc_wdc_chanarray[0] = &sc->sc_ch[0].ch_ata_channel; 196 sc->sc_ch[0].ch_ata_channel.ch_channel = 0; 197 sc->sc_ch[0].ch_ata_channel.ch_atac = &sc->sc_wdcdev.sc_atac; 198 sc->sc_ch[0].ch_ata_channel.ch_queue = &sc->sc_wdc_chqueue; 199 sc->sc_ch[0].ch_ata_channel.ch_ndrive = 2; /* max number of drives */ 200 201 /* map ATA registers */ 202 for (i = 0; i < WDC_NREG; i++) { 203 if (bus_space_subregion(NJATA32_REGT(sc), NJATA32_REGH(sc), 204 NJATA32_OFFSET_WDCREGS + i, 205 i == wd_data ? 4 : 1, &wdr->cmd_iohs[i]) != 0) { 206 aprint_error("%s: couldn't subregion cmd regs\n", 207 NJATA32NAME(sc)); 208 goto fail4; 209 } 210 } 211 wdc_init_shadow_regs(&sc->sc_ch[0].ch_ata_channel); 212 wdr->data32iot = NJATA32_REGT(sc); 213 wdr->data32ioh = wdr->cmd_iohs[wd_data]; 214 215 /* map ATA ctl reg */ 216 wdr->ctl_iot = NJATA32_REGT(sc); 217 if (bus_space_subregion(NJATA32_REGT(sc), NJATA32_REGH(sc), 218 NJATA32_REG_WD_ALTSTATUS, 1, &wdr->ctl_ioh) != 0) { 219 aprint_error("%s: couldn't subregion ctl regs\n", 220 NJATA32NAME(sc)); 221 goto fail4; 222 } 223 224 sc->sc_flags |= NJATA32_CMDPG_MAPPED; 225 226 /* use flags value as busmaster wait */ 227 if ((sc->sc_atawait = 228 (uint8_t)device_cfdata(&sc->sc_wdcdev.sc_atac.atac_dev)->cf_flags)) 229 aprint_normal("%s: ATA wait = %#x\n", 230 NJATA32NAME(sc), sc->sc_atawait); 231 232 njata32_init(sc, cold); 233 234 wdcattach(&sc->sc_ch[0].ch_ata_channel); 235 236 return; 237 238 /* 239 * cleanup 240 */ 241 fail4: while (--devno >= 0) { 242 bus_dmamap_destroy(sc->sc_dmat, 243 sc->sc_dev[devno].d_dmamap_xfer); 244 } 245 bus_dmamap_unload(sc->sc_dmat, sc->sc_dmamap_sgt); 246 fail3: bus_dmamap_destroy(sc->sc_dmat, sc->sc_dmamap_sgt); 247 fail2: bus_dmamem_unmap(sc->sc_dmat, (caddr_t)sc->sc_sgtpg, 248 sizeof(struct njata32_dma_page)); 249 fail1: bus_dmamem_free(sc->sc_dmat, &sc->sc_sgt_seg, sc->sc_sgt_nsegs); 250 } 251 252 int 253 njata32_detach(sc, flags) 254 struct njata32_softc *sc; 255 int flags; 256 { 257 int rv, devno; 258 259 if (sc->sc_flags & NJATA32_CMDPG_MAPPED) { 260 if ((rv = wdcdetach(&sc->sc_wdcdev.sc_atac.atac_dev, flags))) 261 return rv; 262 263 /* free DMA resource */ 264 for (devno = 0; devno < NJATA32_NUM_DEV; devno++) { 265 bus_dmamap_destroy(sc->sc_dmat, 266 sc->sc_dev[devno].d_dmamap_xfer); 267 } 268 bus_dmamap_unload(sc->sc_dmat, sc->sc_dmamap_sgt); 269 bus_dmamap_destroy(sc->sc_dmat, sc->sc_dmamap_sgt); 270 bus_dmamem_unmap(sc->sc_dmat, (caddr_t)sc->sc_sgtpg, 271 sizeof(struct njata32_dma_page)); 272 bus_dmamem_free(sc->sc_dmat, &sc->sc_sgt_seg, sc->sc_sgt_nsegs); 273 } 274 275 return 0; 276 } 277 278 static void 279 njata32_irqack(chp) 280 struct ata_channel *chp; 281 { 282 struct njata32_softc *sc = (void *)chp->ch_atac; 283 284 /* disable busmaster */ 285 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 286 NJATA32_REG_BM, NJATA32_BM_WAIT0); 287 } 288 289 static void 290 njata32_clearirq(chp, irq) 291 struct ata_channel *chp; 292 int irq; 293 { 294 struct njata32_softc *sc = (void *)chp->ch_atac; 295 296 printf("%s: unhandled intr: irq %#x, bm %#x, ", 297 NJATA32NAME(sc), irq, 298 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 299 NJATA32_REG_BM)); 300 301 /* disable busmaster */ 302 njata32_irqack(chp); 303 304 /* clear device interrupt */ 305 printf("err %#x, seccnt %#x, cyl %#x, sdh %#x, ", 306 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 307 NJATA32_REG_WD_ERROR), 308 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 309 NJATA32_REG_WD_SECCNT), 310 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 311 NJATA32_REG_WD_CYL_LO) | 312 (bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 313 NJATA32_REG_WD_CYL_HI) << 8), 314 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 315 NJATA32_REG_WD_SDH)); 316 printf("status %#x\n", 317 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 318 NJATA32_REG_WD_STATUS)); 319 } 320 321 static void 322 njata32_setup_channel(chp) 323 struct ata_channel *chp; 324 { 325 struct njata32_softc *sc = (void *)chp->ch_atac; 326 struct ata_drive_datas *drvp; 327 int drive; 328 uint8_t mode; 329 330 KASSERT(chp->ch_ndrive != 0); 331 332 sc->sc_timing_pio = 0; 333 #if 0 /* ATA DMA is currently unused */ 334 sc->sc_timing_dma = 0; 335 #endif 336 337 for (drive = 0; drive < chp->ch_ndrive; drive++) { 338 drvp = &chp->ch_drive[drive]; 339 if ((drvp->drive_flags & DRIVE) == 0) 340 continue; /* no drive */ 341 342 #if 0 /* ATA DMA is currently unused */ 343 if ((drvp->drive_flags & DRIVE_DMA) != 0) { 344 /* 345 * Multiword DMA 346 */ 347 if ((mode = drvp->DMA_mode) > NJATA32_MODE_MAX_DMA) 348 mode = NJATA32_MODE_MAX_DMA; 349 if (sc->sc_timing_dma < njata32_timing_dma[mode]) 350 sc->sc_timing_dma = njata32_timing_dma[mode]; 351 } 352 #endif 353 /* 354 * PIO 355 */ 356 if ((mode = drvp->PIO_mode) > NJATA32_MODE_MAX_PIO) 357 mode = NJATA32_MODE_MAX_PIO; 358 if (sc->sc_timing_pio < njata32_timing_pio[mode]) 359 sc->sc_timing_pio = njata32_timing_pio[mode]; 360 } 361 362 sc->sc_timing_pio += sc->sc_atawait; 363 364 /* set timing for PIO */ 365 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 366 NJATA32_REG_TIMING, sc->sc_timing_pio); 367 } 368 369 /* 370 * map DMA buffer 371 */ 372 int 373 njata32_dma_init(v, channel, drive, databuf, datalen, flags) 374 void *v; 375 int channel, drive; 376 void *databuf; 377 size_t datalen; 378 int flags; 379 { 380 struct njata32_softc *sc = v; 381 int error; 382 struct njata32_device *dev = &sc->sc_dev[drive]; 383 384 KASSERT(channel == 0); 385 KASSERT((dev->d_flags & NJATA32_DEV_DMA_MAPPED) == 0); 386 KASSERT((dev->d_flags & NJATA32_DEV_DMA_STARTED) == 0); 387 388 KASSERT(flags & (WDC_DMA_PIOBM_ATA | WDC_DMA_PIOBM_ATAPI)); 389 390 /* use PIO for short transfer */ 391 if (datalen < 64 /* needs tune */) { 392 DPRINTF(("%s: njata32_dma_init: short transfer (%u)\n", 393 NJATA32NAME(sc), (unsigned)datalen)); 394 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 395 NJATA32_REG_TIMING, sc->sc_timing_pio); 396 return EINVAL; 397 } 398 399 /* use PIO for unaligned transfer (word alignment seems OK) */ 400 if (((uintptr_t)databuf & 1) || (datalen & 1)) { 401 DPRINTF(("%s: njata32_dma_init: unaligned: buf %p, len %u\n", 402 NJATA32NAME(sc), databuf, (unsigned)datalen)); 403 return EINVAL; 404 } 405 406 DPRINTF(("%s: njata32_dma_init: %s: databuf %p, datalen %u\n", 407 NJATA32NAME(sc), (flags & WDC_DMA_READ) ? "read" : "write", 408 databuf, (unsigned)datalen)); 409 410 error = bus_dmamap_load(sc->sc_dmat, dev->d_dmamap_xfer, 411 databuf, datalen, NULL, BUS_DMA_NOWAIT | BUS_DMA_STREAMING | 412 ((flags & WDC_DMA_READ) ? BUS_DMA_READ : BUS_DMA_WRITE)); 413 if (error) { 414 printf("%s: load xfer failed, error %d\n", 415 NJATA32NAME(sc), error); 416 return error; 417 } 418 419 bus_dmamap_sync(sc->sc_dmat, dev->d_dmamap_xfer, 0, 420 dev->d_dmamap_xfer->dm_mapsize, 421 (flags & WDC_DMA_READ) ? 422 BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); 423 424 dev->d_flags = 425 ((flags & WDC_DMA_READ) ? NJATA32_DEV_DMA_READ : 0) | 426 ((flags & WDC_DMA_PIOBM_ATAPI) ? NJATA32_DEV_DMA_ATAPI : 0) | 427 NJATA32_DEV_DMA_MAPPED; 428 429 return 0; 430 } 431 432 /* 433 * start DMA 434 * 435 * top: databuf + skip 436 * size: xferlen 437 */ 438 void 439 njata32_piobm_start(v, channel, drive, skip, xferlen, flags) 440 void *v; 441 int channel, drive; 442 int skip, xferlen; /* offset/size in mapped DMA buffer */ 443 int flags; 444 { 445 struct njata32_softc *sc = v; 446 struct njata32_device *dev = &sc->sc_dev[drive]; 447 int i, nsegs, seglen; 448 uint8_t bmreg; 449 450 DPRINTF(("%s: njata32_piobm_start: ch%d, dv%d, skip %d, xferlen %d\n", 451 NJATA32NAME(sc), channel, drive, skip, xferlen)); 452 453 KASSERT(channel == 0); 454 KASSERT(dev->d_flags & NJATA32_DEV_DMA_MAPPED); 455 KASSERT((dev->d_flags & NJATA32_DEV_DMA_STARTED) == 0); 456 457 /* 458 * create scatter/gather table 459 * XXX this code may be slow 460 */ 461 for (i = nsegs = 0; 462 i < dev->d_dmamap_xfer->dm_nsegs && xferlen > 0; i++) { 463 if (dev->d_dmamap_xfer->dm_segs[i].ds_len <= skip) { 464 skip -= dev->d_dmamap_xfer->dm_segs[i].ds_len; 465 continue; 466 } 467 468 seglen = dev->d_dmamap_xfer->dm_segs[i].ds_len - skip; 469 if (seglen > xferlen) 470 seglen = xferlen; 471 472 dev->d_sgt[nsegs].sg_addr = 473 htole32(dev->d_dmamap_xfer->dm_segs[i].ds_addr + skip); 474 dev->d_sgt[nsegs].sg_len = htole32(seglen); 475 476 xferlen -= seglen; 477 nsegs++; 478 skip = 0; 479 } 480 sc->sc_piobm_nsegs = nsegs; 481 /* end mark */ 482 dev->d_sgt[nsegs - 1].sg_len |= htole32(NJATA32_SGT_ENDMARK); 483 484 #ifdef DIAGNOSTIC 485 if (xferlen) 486 panic("%s: njata32_piobm_start: xferlen residue %d\n", 487 NJATA32NAME(sc), xferlen); 488 #endif 489 490 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_sgt, 491 (char *)dev->d_sgt - (char *)sc->sc_sgtpg, 492 sizeof(struct njata32_sgtable) * nsegs, 493 BUS_DMASYNC_PREWRITE); 494 495 /* set timing for PIO */ 496 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 497 NJATA32_REG_TIMING, sc->sc_timing_pio); 498 499 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_IOBM, 500 NJATA32_IOBM_DEFAULT); 501 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_AS, 502 NJATA32_AS_WAIT0); 503 504 /* 505 * interrupt configuration 506 */ 507 if ((dev->d_flags & (NJATA32_DEV_DMA_READ | NJATA32_DEV_DMA_ATAPI)) == 508 NJATA32_DEV_DMA_READ) { 509 /* 510 * ATA piobm read is executed while device interrupt is active, 511 * so disable device interrupt here 512 */ 513 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 514 NJATA32_REG_IRQ_SELECT, NJATA32_IRQ_XFER); 515 } 516 517 /* enable scatter/gather busmaster transfer */ 518 bmreg = NJATA32_BM_EN | NJATA32_BM_SG | NJATA32_BM_WAIT0 | 519 ((dev->d_flags & NJATA32_DEV_DMA_READ) ? NJATA32_BM_RD : 0); 520 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_BM, 521 bmreg); 522 523 /* load scatter/gather table */ 524 bus_space_write_4(NJATA32_REGT(sc), NJATA32_REGH(sc), 525 NJATA32_REG_DMAADDR, dev->d_sgt_dma); 526 bus_space_write_4(NJATA32_REGT(sc), NJATA32_REGH(sc), 527 NJATA32_REG_DMALENGTH, sizeof(struct njata32_sgtable) * nsegs); 528 529 /* start transfer */ 530 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_BM, 531 (bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 532 NJATA32_REG_BM) 533 & ~(NJATA32_BM_RD|NJATA32_BM_SG|NJATA32_BM_WAIT_MASK)) | 534 bmreg | NJATA32_BM_GO); 535 536 sc->sc_devflags = dev->d_flags; 537 if (flags & WDC_PIOBM_XFER_IRQ) 538 sc->sc_devflags |= NJATA32_DEV_XFER_INTR; 539 #ifdef DIAGNOSTIC 540 dev->d_flags |= NJATA32_DEV_DMA_STARTED; 541 #endif 542 } 543 544 /* 545 * end of DMA 546 */ 547 int 548 njata32_dma_finish(v, channel, drive, force) 549 void *v; 550 int channel, drive; 551 int force; 552 { 553 struct njata32_softc *sc = v; 554 int bm; 555 int error = 0; 556 557 DPRINTF(("%s: njata32_dma_finish: bm = %#x\n", NJATA32NAME(sc), 558 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 559 NJATA32_REG_BM))); 560 561 KASSERT(channel == 0); 562 KASSERT(sc->sc_dev[drive].d_flags & NJATA32_DEV_DMA_MAPPED); 563 KASSERT(sc->sc_dev[drive].d_flags & NJATA32_DEV_DMA_STARTED); 564 565 bm = bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 566 NJATA32_REG_BM); 567 568 #ifdef NJATA32_DEBUG 569 printf("%s: irq %#x, bm %#x, 18 %#x, 1c %#x\n", NJATA32NAME(sc), 570 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 571 NJATA32_REG_IRQ_STAT), 572 bm, 573 bus_space_read_4(NJATA32_REGT(sc), NJATA32_REGH(sc), 0x18), 574 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 0x1c)); 575 #endif 576 577 /* check if DMA is active */ 578 if (bm & NJATA32_BM_GO) { 579 error = WDC_DMAST_NOIRQ; 580 581 switch (force) { 582 case WDC_DMAEND_END: 583 return error; 584 585 case WDC_DMAEND_ABRT: 586 printf("%s: aborting DMA\n", NJATA32NAME(sc)); 587 break; 588 } 589 } 590 591 /* 592 * ??? 593 * For unknown reason, PIOBM transfer sometimes fails in the middle, 594 * in which case the bit #7 of BM register becomes 0. 595 * Increasing the wait value seems to improve the situation. 596 * 597 * XXX 598 * PIO transfer may also fail, but it seems it can't be detected. 599 */ 600 if ((bm & NJATA32_BM_DONE) == 0) { 601 error |= WDC_DMAST_ERR; 602 printf("%s: busmaster error", NJATA32NAME(sc)); 603 if (sc->sc_atawait < 0x11) { 604 if ((sc->sc_atawait & 0xf) == 0) 605 sc->sc_atawait++; 606 else 607 sc->sc_atawait += 0x10; 608 printf(", new ATA wait = %#x", sc->sc_atawait); 609 njata32_setup_channel(&sc->sc_ch[0].ch_ata_channel); 610 } 611 printf("\n"); 612 } 613 614 /* stop command */ 615 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_AS, 616 NJATA32_AS_WAIT0); 617 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), NJATA32_REG_BM, 618 NJATA32_BM_WAIT0); 619 620 /* set timing for PIO */ 621 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 622 NJATA32_REG_TIMING, sc->sc_timing_pio); 623 624 /* 625 * reenable device interrupt in case it was disabled for 626 * this transfer 627 */ 628 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 629 NJATA32_REG_IRQ_SELECT, NJATA32_IRQ_XFER | NJATA32_IRQ_DEV); 630 631 #if 1 /* should be? */ 632 if ((sc->sc_devflags & NJATA32_DEV_GOT_XFER_INTR) == 0) 633 error |= WDC_DMAST_ERR; 634 #endif 635 sc->sc_devflags = 0; 636 637 #ifdef DIAGNOSTIC 638 sc->sc_dev[drive].d_flags &= ~NJATA32_DEV_DMA_STARTED; 639 #endif 640 641 return error; 642 } 643 644 /* 645 * unmap DMA buffer 646 */ 647 void 648 njata32_piobm_done(v, channel, drive) 649 void *v; 650 int channel, drive; 651 { 652 struct njata32_softc *sc = v; 653 struct njata32_device *dev = &sc->sc_dev[drive]; 654 655 DPRINTF(("%s: njata32_piobm_done: ch%d dv%d\n", 656 NJATA32NAME(sc), channel, drive)); 657 658 KASSERT(channel == 0); 659 KASSERT(dev->d_flags & NJATA32_DEV_DMA_MAPPED); 660 KASSERT((dev->d_flags & NJATA32_DEV_DMA_STARTED) == 0); 661 662 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_sgt, 663 (char *)dev->d_sgt - (char *)sc->sc_sgtpg, 664 sizeof(struct njata32_sgtable) * sc->sc_piobm_nsegs, 665 BUS_DMASYNC_POSTWRITE); 666 667 /* unload dma map */ 668 bus_dmamap_sync(sc->sc_dmat, dev->d_dmamap_xfer, 669 0, dev->d_dmamap_xfer->dm_mapsize, 670 (dev->d_flags & NJATA32_DEV_DMA_READ) ? 671 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); 672 673 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_sgt, 674 (char *)dev->d_sgt - (char *)sc->sc_sgtpg, 675 sizeof(struct njata32_sgtable) * NJATA32_NUM_SG, 676 BUS_DMASYNC_POSTWRITE); 677 678 bus_dmamap_unload(sc->sc_dmat, dev->d_dmamap_xfer); 679 dev->d_flags &= ~NJATA32_DEV_DMA_MAPPED; 680 } 681 682 int 683 njata32_intr(arg) 684 void *arg; 685 { 686 struct njata32_softc *sc = arg; 687 struct ata_channel *chp; 688 int irq; 689 690 irq = bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 691 NJATA32_REG_IRQ_STAT); 692 if ((irq & (NJATA32_IRQ_XFER | NJATA32_IRQ_DEV)) == 0) 693 return 0; /* not mine */ 694 695 DPRINTF(("%s: njata32_intr: irq = %#x, altstatus = %#x\n", 696 NJATA32NAME(sc), irq, 697 bus_space_read_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 698 NJATA32_REG_WD_ALTSTATUS))); 699 700 chp = &sc->sc_ch[0].ch_ata_channel; 701 702 if (irq & NJATA32_IRQ_XFER) 703 sc->sc_devflags |= NJATA32_DEV_GOT_XFER_INTR; 704 705 if ((irq & (NJATA32_IRQ_XFER | NJATA32_IRQ_DEV)) == NJATA32_IRQ_XFER && 706 (sc->sc_devflags & NJATA32_DEV_XFER_INTR) == 0) { 707 /* 708 * transfer done, wait for device interrupt 709 */ 710 bus_space_write_1(NJATA32_REGT(sc), NJATA32_REGH(sc), 711 NJATA32_REG_BM, NJATA32_BM_WAIT0); 712 return 1; 713 } 714 715 /* 716 * If both transfer done interrupt and device interrupt are 717 * active for ATAPI transfer, call wdcintr() twice. 718 */ 719 if ((sc->sc_devflags & NJATA32_DEV_DMA_ATAPI) && 720 (irq & (NJATA32_IRQ_XFER | NJATA32_IRQ_DEV)) == 721 (NJATA32_IRQ_XFER | NJATA32_IRQ_DEV) && 722 (sc->sc_devflags & NJATA32_DEV_XFER_INTR)) { 723 if (wdcintr(chp) == 0) { 724 njata32_clearirq(&sc->sc_ch[0].ch_ata_channel, irq); 725 } 726 } 727 728 if (wdcintr(chp) == 0) { 729 njata32_clearirq(&sc->sc_ch[0].ch_ata_channel, irq); 730 } 731 732 return 1; 733 } 734
Indexes created Wed Sep 24 15:09:51 GMT 2025