pciide.c revision 1.6.2.3
1 /* $NetBSD: pciide.c,v 1.6.2.3 1998/06/05 17:31:37 bouyer Exp $ */ 2 3 /* 4 * Copyright (c) 1996, 1998 Christopher G. Demetriou. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Christopher G. Demetriou 17 * for the NetBSD Project. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * PCI IDE controller driver. 35 * 36 * Author: Christopher G. Demetriou, March 2, 1998 (derived from NetBSD 37 * sys/dev/pci/ppb.c, revision 1.16). 38 * 39 * See "PCI IDE Controller Specification, Revision 1.0 3/4/94" and 40 * "Programming Interface for Bus Master IDE Controller, Revision 1.0 41 * 5/16/94" from the PCI SIG. 42 * 43 * XXX Does not yet support DMA (but does map the Bus Master DMA regs). 44 * 45 * XXX Does not support serializing the two channels for broken (at least 46 * XXX according to linux and freebsd) controllers, e.g. CMD PCI0640. 47 */ 48 49 #define WDCDEBUG 50 51 #define DEBUG_DMA 0x01 52 #define DEBUG_XFERS 0x02 53 #define DEBUG_FUNCS 0x08 54 #define DEBUG_PROBE 0x10 55 #ifdef WDCDEBUG 56 int wdcdebug_pciide_mask = DEBUG_PROBE; 57 #define WDCDEBUG_PRINT(args, level) \ 58 if (wdcdebug_pciide_mask & (level)) printf args 59 #else 60 #define WDCDEBUG_PRINT(args, level) 61 #endif 62 #include <sys/param.h> 63 #include <sys/systm.h> 64 #include <sys/device.h> 65 #include <sys/malloc.h> 66 67 #include <vm/vm.h> 68 #include <vm/vm_param.h> 69 #include <vm/vm_kern.h> 70 71 #include <dev/pci/pcireg.h> 72 #include <dev/pci/pcivar.h> 73 #include <dev/pci/pcidevs.h> 74 #include <dev/pci/pciidereg.h> 75 #include <dev/pci/pciidevar.h> 76 #include <dev/pci/pciide_pIIx_reg.h> 77 #include <dev/ata/atavar.h> 78 #include <dev/ic/wdcreg.h> 79 #include <dev/ic/wdcvar.h> 80 81 struct pciide_softc { 82 struct wdc_softc sc_wdcdev; /* common wdc definitions */ 83 84 void *sc_pci_ih; /* PCI interrupt handle */ 85 int sc_dma_ok; /* bus-master DMA info */ 86 bus_space_tag_t sc_dma_iot; 87 bus_space_handle_t sc_dma_ioh; 88 bus_dma_tag_t sc_dmat; 89 /* Chip description */ 90 const struct pciide_product_desc *sc_pp; 91 /* common definitions */ 92 struct channel_softc wdc_channels[PCIIDE_NUM_CHANNELS]; 93 /* internal bookkeeping */ 94 struct pciide_channel { /* per-channel data */ 95 int hw_ok; /* hardware mapped & OK? */ 96 int compat; /* is it compat? */ 97 void *ih; /* compat or pci handle */ 98 /* DMA tables and DMA map for xfer, for each drive */ 99 struct pciide_dma_maps { 100 bus_dmamap_t dmamap_table; 101 struct idedma_table *dma_table; 102 bus_dmamap_t dmamap_xfer; 103 } dma_maps[2]; 104 } pciide_channels[PCIIDE_NUM_CHANNELS]; 105 }; 106 107 void default_setup_cap __P((struct pciide_softc*)); 108 void default_setup_chip __P((struct pciide_softc*, 109 pci_chipset_tag_t, pcitag_t)); 110 void piix_setup_cap __P((struct pciide_softc*)); 111 void piix_setup_chip __P((struct pciide_softc*, 112 pci_chipset_tag_t, pcitag_t)); 113 void piix3_4_setup_chip __P((struct pciide_softc*, 114 pci_chipset_tag_t, pcitag_t)); 115 116 static u_int32_t piix_setup_idetim_timings __P((u_int8_t, u_int8_t, u_int8_t)); 117 static u_int32_t piix_setup_idetim_drvs __P((u_int8_t, u_int8_t, u_int8_t)); 118 static u_int32_t piix_setup_sidetim_timings __P((u_int8_t, u_int8_t, u_int8_t)); 119 120 int pciide_dma_table_setup __P((struct pciide_softc*, int, int)); 121 int pciide_dma_init __P((void*, int, int, void *, size_t, int)); 122 void pciide_dma_start __P((void*, int, int, int)); 123 int pciide_dma_finish __P((void*, int, int, int)); 124 125 struct pciide_product_desc { 126 u_int32_t ide_product; 127 int ide_flags; 128 const char *ide_name; 129 /* init controller's capabilities for drives probe */ 130 void (*setup_cap) __P((struct pciide_softc*)); 131 /* init controller after drives probe */ 132 void (*setup_chip) __P((struct pciide_softc*, pci_chipset_tag_t, pcitag_t)); 133 }; 134 135 /* Flags for ide_flags */ 136 #define NO_PCI_INTR 0x01 /* don't try to map the native PCI intr */ 137 #define ONE_QUEUE 0x02 /* device need serialised access */ 138 139 /* Default product description for devices not known from this controller */ 140 const struct pciide_product_desc default_product_desc = { 141 0, 142 0, 143 "Generic PCI IDE controller", 144 default_setup_cap, 145 default_setup_chip 146 }; 147 148 149 const struct pciide_product_desc pciide_intel_products[] = { 150 { PCI_PRODUCT_INTEL_82092AA, 151 0, 152 "Intel 82092AA IDE controller", 153 default_setup_cap, 154 default_setup_chip 155 }, 156 { PCI_PRODUCT_INTEL_82371FB_IDE, 157 0, 158 "Intel 82371FB IDE controller (PIIX)", 159 piix_setup_cap, 160 piix_setup_chip 161 }, 162 { PCI_PRODUCT_INTEL_82371SB_IDE, 163 0, 164 "Intel 82371SB IDE Interface (PIIX3)", 165 piix_setup_cap, 166 piix3_4_setup_chip 167 }, 168 { PCI_PRODUCT_INTEL_82371AB_IDE, 169 0, 170 "Intel 82371AB IDE controller (PIIX4)", 171 piix_setup_cap, 172 piix3_4_setup_chip 173 }, 174 { 0, 175 0, 176 NULL, 177 } 178 }; 179 const struct pciide_product_desc pciide_cmd_products[] = { 180 { PCI_PRODUCT_CMDTECH_640, 181 NO_PCI_INTR | ONE_QUEUE, 182 "CMD Technology PCI0640", 183 default_setup_cap, 184 default_setup_chip 185 }, 186 { 0, 187 0, 188 NULL, 189 } 190 }; 191 192 struct pciide_vendor_desc { 193 u_int32_t ide_vendor; 194 const struct pciide_product_desc *ide_products; 195 }; 196 197 const struct pciide_vendor_desc pciide_vendors[] = { 198 { PCI_VENDOR_INTEL, pciide_intel_products }, 199 { PCI_VENDOR_CMDTECH, pciide_cmd_products }, 200 { 0, NULL } 201 }; 202 203 204 #define PCIIDE_CHANNEL_NAME(chan) ((chan) == 0 ? "primary" : "secondary") 205 206 #ifdef __BROKEN_INDIRECT_CONFIG 207 int pciide_match __P((struct device *, void *, void *)); 208 #else 209 int pciide_match __P((struct device *, struct cfdata *, void *)); 210 #endif 211 void pciide_attach __P((struct device *, struct device *, void *)); 212 213 struct cfattach pciide_ca = { 214 sizeof(struct pciide_softc), pciide_match, pciide_attach 215 }; 216 217 int pciide_map_channel_compat __P((struct pciide_softc *, 218 struct pci_attach_args *, int)); 219 const char *pciide_compat_channel_probe __P((struct pciide_softc *, 220 struct pci_attach_args *, int)); 221 int pciide_map_channel_native __P((struct pciide_softc *, 222 struct pci_attach_args *, int)); 223 int pciide_print __P((void *, const char *pnp)); 224 int pciide_compat_intr __P((void *)); 225 int pciide_pci_intr __P((void *)); 226 const struct pciide_product_desc* pciide_lookup_product __P((u_int32_t)); 227 228 const struct pciide_product_desc* 229 pciide_lookup_product(id) 230 u_int32_t id; 231 { 232 const struct pciide_product_desc *pp; 233 const struct pciide_vendor_desc *vp; 234 235 for (vp = pciide_vendors; vp->ide_products != NULL; vp++) 236 if (PCI_VENDOR(id) == vp->ide_vendor) 237 break; 238 239 if ((pp = vp->ide_products) == NULL) 240 return NULL; 241 242 for (; pp->ide_name != NULL; pp++) 243 if (PCI_PRODUCT(id) == pp->ide_product) 244 break; 245 246 if (pp->ide_name == NULL) 247 return NULL; 248 return pp; 249 } 250 251 int 252 pciide_match(parent, match, aux) 253 struct device *parent; 254 #ifdef __BROKEN_INDIRECT_CONFIG 255 void *match; 256 #else 257 struct cfdata *match; 258 #endif 259 void *aux; 260 { 261 struct pci_attach_args *pa = aux; 262 263 /* 264 * Check the ID register to see that it's a PCI IDE controller. 265 * If it is, we assume that we can deal with it; it _should_ 266 * work in a standardized way... 267 */ 268 if (PCI_CLASS(pa->pa_class) == PCI_CLASS_MASS_STORAGE && 269 PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_MASS_STORAGE_IDE) { 270 return (1); 271 } 272 273 return (0); 274 } 275 276 void 277 pciide_attach(parent, self, aux) 278 struct device *parent, *self; 279 void *aux; 280 { 281 struct pci_attach_args *pa = aux; 282 pci_chipset_tag_t pc = pa->pa_pc; 283 pcitag_t tag = pa->pa_tag; 284 struct pciide_softc *sc = (struct pciide_softc *)self; 285 struct pciide_channel *cp; 286 pcireg_t class, interface, csr; 287 pci_intr_handle_t intrhandle; 288 const char *intrstr; 289 char devinfo[256]; 290 int i; 291 292 sc->sc_pp = pciide_lookup_product(pa->pa_id); 293 if (sc->sc_pp == NULL) { 294 sc->sc_pp = &default_product_desc; 295 pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo); 296 printf(": %s (rev. 0x%02x)\n", devinfo, 297 PCI_REVISION(pa->pa_class)); 298 } else { 299 printf(": %s\n", sc->sc_pp->ide_name); 300 } 301 302 if ((pa->pa_flags & PCI_FLAGS_IO_ENABLED) == 0) { 303 csr = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG); 304 printf("%s: device disabled (at %s)\n", 305 sc->sc_wdcdev.sc_dev.dv_xname, 306 (csr & PCI_COMMAND_IO_ENABLE) == 0 ? "device" : "bridge"); 307 return; 308 } 309 310 class = pci_conf_read(pc, tag, PCI_CLASS_REG); 311 interface = PCI_INTERFACE(class); 312 313 /* 314 * Set up PCI interrupt. 315 * 316 * If mapping fails, that's (probably) because there's no pin 317 * set to intr, which is (probably) because it's a compat-only 318 * device (or hard-wired in compatibility-only mode). Native-PCI 319 * channels will complain later if the interrupt was needed. 320 * 321 * If establishment fails, that's (probably) some other problem. 322 */ 323 if ((sc->sc_pp->ide_flags & NO_PCI_INTR) == 0) { 324 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin, 325 pa->pa_intrline, &intrhandle) == 0) { 326 intrstr = pci_intr_string(pa->pa_pc, intrhandle); 327 sc->sc_pci_ih = pci_intr_establish(pa->pa_pc, intrhandle, 328 IPL_BIO, pciide_pci_intr, sc); 329 330 if (sc->sc_pci_ih != NULL) { 331 printf("%s: using %s for native-PCI interrupt\n", 332 sc->sc_wdcdev.sc_dev.dv_xname, 333 intrstr ? intrstr : "unknown interrupt"); 334 } else { 335 printf("%s: couldn't establish native-PCI interrupt", 336 sc->sc_wdcdev.sc_dev.dv_xname); 337 if (intrstr != NULL) 338 printf(" at %s", intrstr); 339 printf("\n"); 340 } 341 } 342 } 343 344 /* 345 * Map DMA registers, if DMA is supported. 346 * 347 * Note that sc_dma_ok is the right variable to test to see if 348 * DMA can * be done. If the interface doesn't support DMA, 349 * sc_dma_ok * will never be non-zero. If the DMA regs couldn't 350 * be mapped, it'll be zero. I.e., sc_dma_ok will only be 351 * non-zero if the interface supports DMA and the registers 352 * could be mapped. 353 * 354 * XXX Note that despite the fact that the Bus Master IDE specs 355 * XXX say that "The bus master IDE functoin uses 16 bytes of IO 356 * XXX space," some controllers (at least the United 357 * XXX Microelectronics UM8886BF) place it in memory space. 358 * XXX eventually, we should probably read the register and check 359 * XXX which type it is. Either that or 'quirk' certain devices. 360 */ 361 if (interface & PCIIDE_INTERFACE_BUS_MASTER_DMA) { 362 sc->sc_dma_ok = (pci_mapreg_map(pa, 363 PCIIDE_REG_BUS_MASTER_DMA, PCI_MAPREG_TYPE_IO, 0, 364 &sc->sc_dma_iot, &sc->sc_dma_ioh, NULL, NULL) == 0); 365 sc->sc_dmat = pa->pa_dmat; 366 printf("%s: bus-master DMA support present", 367 sc->sc_wdcdev.sc_dev.dv_xname); 368 if (sc->sc_dma_ok == 0) { 369 printf(", but unused (couldn't map registers)"); 370 } else if (sc->sc_pp == 0) { 371 printf(", but unused (no driver support)"); 372 } else { 373 sc->sc_wdcdev.dma_arg = sc; 374 sc->sc_wdcdev.dma_init = pciide_dma_init; 375 sc->sc_wdcdev.dma_start = pciide_dma_start; 376 sc->sc_wdcdev.dma_finish = pciide_dma_finish; 377 } 378 printf("\n"); 379 } 380 if (sc->sc_pp == NULL) 381 default_setup_cap(sc); 382 else 383 sc->sc_pp->setup_cap(sc); 384 sc->sc_wdcdev.channels = sc->wdc_channels; 385 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 386 387 for (i = 0; i < PCIIDE_NUM_CHANNELS; i++) { 388 cp = &sc->pciide_channels[i]; 389 390 sc->wdc_channels[i].channel = i; 391 sc->wdc_channels[i].wdc = &sc->sc_wdcdev; 392 if (i > 0 && (sc->sc_pp->ide_flags & ONE_QUEUE)) { 393 sc->wdc_channels[i].ch_queue = 394 sc->wdc_channels[0].ch_queue; 395 } else { 396 sc->wdc_channels[i].ch_queue = 397 malloc(sizeof(struct channel_queue), M_DEVBUF, 398 M_NOWAIT); 399 } 400 if (sc->wdc_channels[i].ch_queue == NULL) { 401 printf("%s %s channel: " 402 "can't allocate memory for command queue", 403 sc->sc_wdcdev.sc_dev.dv_xname, 404 PCIIDE_CHANNEL_NAME(i)); 405 continue; 406 } 407 printf("%s: %s channel %s to %s mode\n", 408 sc->sc_wdcdev.sc_dev.dv_xname, 409 PCIIDE_CHANNEL_NAME(i), 410 (interface & PCIIDE_INTERFACE_SETTABLE(i)) ? 411 "configured" : "wired", 412 (interface & PCIIDE_INTERFACE_PCI(i)) ? "native-PCI" : 413 "compatibility"); 414 415 if (interface & PCIIDE_INTERFACE_PCI(i)) 416 cp->hw_ok = pciide_map_channel_native(sc, pa, i); 417 else 418 cp->hw_ok = pciide_map_channel_compat(sc, pa, i); 419 if (!cp->hw_ok) 420 continue; 421 /* Now call common attach routine */ 422 wdcattach(&sc->wdc_channels[i]); 423 } 424 if (sc->sc_pp == NULL) 425 default_setup_chip(sc, pc, tag); 426 else 427 sc->sc_pp->setup_chip(sc, pc, tag); 428 WDCDEBUG_PRINT(("pciide: command/status register=%x\n", 429 pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG)), DEBUG_PROBE); 430 } 431 432 int 433 pciide_map_channel_compat(sc, pa, chan) 434 struct pciide_softc *sc; 435 struct pci_attach_args *pa; 436 int chan; 437 { 438 struct pciide_channel *cp = &sc->pciide_channels[chan]; 439 struct channel_softc *wdc_cp = &sc->wdc_channels[chan]; 440 const char *probe_fail_reason; 441 int rv = 1; 442 443 cp->compat = 1; 444 445 wdc_cp->cmd_iot = pa->pa_iot; 446 if (bus_space_map(wdc_cp->cmd_iot, PCIIDE_COMPAT_CMD_BASE(chan), 447 PCIIDE_COMPAT_CMD_SIZE, 0, &wdc_cp->cmd_ioh) != 0) { 448 printf("%s: couldn't map %s channel cmd regs\n", 449 sc->sc_wdcdev.sc_dev.dv_xname, 450 PCIIDE_CHANNEL_NAME(chan)); 451 rv = 0; 452 } 453 454 wdc_cp->ctl_iot = pa->pa_iot; 455 if (bus_space_map(wdc_cp->ctl_iot, PCIIDE_COMPAT_CTL_BASE(chan), 456 PCIIDE_COMPAT_CTL_SIZE, 0, &wdc_cp->ctl_ioh) != 0) { 457 printf("%s: couldn't map %s channel ctl regs\n", 458 sc->sc_wdcdev.sc_dev.dv_xname, 459 PCIIDE_CHANNEL_NAME(chan)); 460 rv = 0; 461 } 462 463 /* 464 * If we weren't able to map the device successfully, 465 * we just give up now. Something else has already 466 * occupied those ports, indicating that the device has 467 * (probably) been completely disabled (by some nonstandard 468 * mechanism). 469 * 470 * XXX If we successfully map some ports, but not others, 471 * XXX it might make sense to unmap the ones that we mapped. 472 */ 473 if (rv == 0) 474 goto out; 475 476 /* 477 * If we were able to map the device successfully, try to 478 * make sure that there's a wdc there and that it's 479 * attributable to us. 480 * 481 * If there's not, then we assume that there's the device 482 * has been disabled and that other devices are free to use 483 * its ports. 484 */ 485 probe_fail_reason = pciide_compat_channel_probe(sc, pa, chan); 486 if (probe_fail_reason != NULL) { 487 printf("%s: %s channel ignored (%s)\n", 488 sc->sc_wdcdev.sc_dev.dv_xname, 489 PCIIDE_CHANNEL_NAME(chan), probe_fail_reason); 490 rv = 0; 491 492 bus_space_unmap(wdc_cp->cmd_iot, wdc_cp->cmd_ioh, 493 PCIIDE_COMPAT_CMD_SIZE); 494 bus_space_unmap(wdc_cp->ctl_iot, wdc_cp->ctl_ioh, 495 PCIIDE_COMPAT_CTL_SIZE); 496 497 goto out; 498 } 499 500 /* 501 * If we're here, we were able to map the device successfully 502 * and it really looks like there's a controller there. 503 * 504 * Unless those conditions are true, we don't map the 505 * compatibility interrupt. The spec indicates that if a 506 * channel is configured for compatibility mode and the PCI 507 * device's I/O space is enabled, the channel will be enabled. 508 * Hoewver, some devices seem to be able to disable invididual 509 * compatibility channels (via non-standard mechanisms). If 510 * the channel is disabled, the interrupt line can (probably) 511 * be used by other devices (and may be assigned to other 512 * devices by the BIOS). If we mapped the interrupt we might 513 * conflict with another interrupt assignment. 514 */ 515 cp->ih = pciide_machdep_compat_intr_establish(&sc->sc_wdcdev.sc_dev, 516 pa, chan, pciide_compat_intr, wdc_cp); 517 if (cp->ih == NULL) { 518 printf("%s: no compatibility interrupt for use by %s channel\n", 519 sc->sc_wdcdev.sc_dev.dv_xname, 520 PCIIDE_CHANNEL_NAME(chan)); 521 rv = 0; 522 } 523 524 out: 525 return (rv); 526 } 527 528 const char * 529 pciide_compat_channel_probe(sc, pa, chan) 530 struct pciide_softc *sc; 531 struct pci_attach_args *pa; 532 { 533 pcireg_t csr; 534 const char *failreason = NULL; 535 536 /* 537 * Check to see if something appears to be there. 538 */ 539 if (!wdcprobe(&sc->wdc_channels[chan])) { 540 failreason = "not responding; disabled or no drives?"; 541 goto out; 542 } 543 544 /* 545 * Now, make sure it's actually attributable to this PCI IDE 546 * channel by trying to access the channel again while the 547 * PCI IDE controller's I/O space is disabled. (If the 548 * channel no longer appears to be there, it belongs to 549 * this controller.) YUCK! 550 */ 551 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG); 552 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 553 csr & ~PCI_COMMAND_IO_ENABLE); 554 if (wdcprobe(&sc->wdc_channels[chan])) 555 failreason = "other hardware responding at addresses"; 556 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, csr); 557 558 out: 559 return (failreason); 560 } 561 562 int 563 pciide_map_channel_native(sc, pa, chan) 564 struct pciide_softc *sc; 565 struct pci_attach_args *pa; 566 int chan; 567 { 568 struct pciide_channel *cp = &sc->pciide_channels[chan]; 569 struct channel_softc *wdc_cp = &sc->wdc_channels[chan]; 570 int rv = 1; 571 572 cp->compat = 0; 573 574 if (pci_mapreg_map(pa, PCIIDE_REG_CMD_BASE(chan), PCI_MAPREG_TYPE_IO, 575 0, &wdc_cp->cmd_iot, &wdc_cp->cmd_ioh, NULL, NULL) != 0) { 576 printf("%s: couldn't map %s channel cmd regs\n", 577 sc->sc_wdcdev.sc_dev.dv_xname, 578 PCIIDE_CHANNEL_NAME(chan)); 579 rv = 0; 580 } 581 582 if (pci_mapreg_map(pa, PCIIDE_REG_CTL_BASE(chan), PCI_MAPREG_TYPE_IO, 583 0, &wdc_cp->ctl_iot, &wdc_cp->ctl_ioh, NULL, NULL) != 0) { 584 printf("%s: couldn't map %s channel ctl regs\n", 585 sc->sc_wdcdev.sc_dev.dv_xname, 586 PCIIDE_CHANNEL_NAME(chan)); 587 rv = 0; 588 } 589 590 if ((cp->ih = sc->sc_pci_ih) == NULL) { 591 printf("%s: no native-PCI interrupt for use by %s channel\n", 592 sc->sc_wdcdev.sc_dev.dv_xname, 593 PCIIDE_CHANNEL_NAME(chan)); 594 rv = 0; 595 } 596 597 return (rv); 598 } 599 600 int 601 pciide_compat_intr(arg) 602 void *arg; 603 { 604 struct channel_softc *wdc_cp = arg; 605 606 #ifdef DIAGNOSTIC 607 struct pciide_softc *sc = (struct pciide_softc*)wdc_cp->wdc; 608 struct pciide_channel *cp = &sc->pciide_channels[wdc_cp->channel]; 609 /* should only be called for a compat channel */ 610 if (cp->compat == 0) 611 panic("pciide compat intr called for non-compat chan %p\n", cp); 612 #endif 613 return (wdcintr(wdc_cp)); 614 } 615 616 int 617 pciide_pci_intr(arg) 618 void *arg; 619 { 620 struct pciide_softc *sc = arg; 621 struct pciide_channel *cp; 622 struct channel_softc *wdc_cp; 623 int i, rv, crv; 624 625 rv = 0; 626 for (i = 0; i < PCIIDE_NUM_CHANNELS; i++) { 627 cp = &sc->pciide_channels[i]; 628 wdc_cp = &sc->wdc_channels[i]; 629 630 /* If a compat channel skip. */ 631 if (cp->compat) 632 continue; 633 /* if this channel not waiting for intr, skip */ 634 if ((wdc_cp->ch_flags & WDCF_IRQ_WAIT) == 0) 635 continue; 636 637 crv = wdcintr(wdc_cp); 638 if (crv == 0) 639 ; /* leave rv alone */ 640 else if (crv == 1) 641 rv = 1; /* claim the intr */ 642 else if (rv == 0) /* crv should be -1 in this case */ 643 rv = crv; /* if we've done no better, take it */ 644 } 645 return (rv); 646 } 647 648 void 649 default_setup_cap(sc) 650 struct pciide_softc *sc; 651 { 652 if (sc->sc_dma_ok) 653 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA; 654 sc->sc_wdcdev.pio_mode = 0; 655 sc->sc_wdcdev.dma_mode = 0; 656 } 657 658 void 659 default_setup_chip(sc, pc, tag) 660 struct pciide_softc *sc; 661 pci_chipset_tag_t pc; 662 pcitag_t tag; 663 { 664 int channel, drive, idedma_ctl; 665 struct channel_softc *chp; 666 struct ata_drive_datas *drvp; 667 668 if (sc->sc_dma_ok == 0) 669 return; /* nothing to do */ 670 671 /* Allocate DMA maps */ 672 for (channel = 0; channel < PCIIDE_NUM_CHANNELS; channel++) { 673 idedma_ctl = 0; 674 chp = &sc->wdc_channels[channel]; 675 for (drive = 0; drive < 2; drive++) { 676 drvp = &chp->ch_drive[drive]; 677 /* If no drive, skip */ 678 if ((drvp->drive_flags & DRIVE) == 0) 679 continue; 680 if (pciide_dma_table_setup(sc, channel, drive) != 0) { 681 /* Abort DMA setup */ 682 printf("%s:%d:%d: can't allocate DMA maps, " 683 "using PIO transferts\n", 684 sc->sc_wdcdev.sc_dev.dv_xname, 685 channel, drive); 686 drvp->drive_flags &= ~DRIVE_DMA; 687 } 688 printf("%s:%d:%d: using DMA mode %d\n", 689 sc->sc_wdcdev.sc_dev.dv_xname, 690 channel, drive, 691 drvp->DMA_mode); 692 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 693 } 694 if (idedma_ctl != 0) { 695 /* Add software bits in status register */ 696 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 697 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * channel), 698 idedma_ctl); 699 } 700 } 701 702 } 703 704 void 705 piix_setup_cap(sc) 706 struct pciide_softc *sc; 707 { 708 #if 0 709 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82371AB_IDE) 710 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 711 #endif 712 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DATA32 | WDC_CAPABILITY_PIO | 713 WDC_CAPABILITY_DMA; 714 sc->sc_wdcdev.pio_mode = 4; 715 sc->sc_wdcdev.dma_mode = 2; 716 } 717 718 void 719 piix_setup_chip(sc, pc, tag) 720 struct pciide_softc *sc; 721 pci_chipset_tag_t pc; 722 pcitag_t tag; 723 { 724 struct channel_softc *chp; 725 u_int8_t mode[2]; 726 u_int8_t channel, drive; 727 u_int32_t idetim, sidetim, idedma_ctl; 728 struct ata_drive_datas *drvp; 729 730 idetim = sidetim = 0; 731 732 WDCDEBUG_PRINT(("piix_setup_chip: old idetim=0x%x, sidetim=0x%x\n", 733 pci_conf_read(pc, tag, PIIX_IDETIM), 734 pci_conf_read(pc, tag, PIIX_SIDETIM)), DEBUG_PROBE); 735 736 for (channel = 0; channel < PCIIDE_NUM_CHANNELS; channel++) { 737 chp = &sc->wdc_channels[channel]; 738 drvp = chp->ch_drive; 739 idedma_ctl = 0; 740 /* Enable IDE registers decode */ 741 idetim = PIIX_IDETIM_SET(idetim, PIIX_IDETIM_IDE, 742 channel); 743 744 /* setup DMA if needed */ 745 for (drive = 0; drive < 2; drive++) { 746 if (drvp[drive].drive_flags & DRIVE_DMA && 747 pciide_dma_table_setup(sc, channel, drive) != 0) { 748 drvp[drive].drive_flags &= ~DRIVE_DMA; 749 } 750 } 751 752 /* 753 * Here we have to mess up with drives mode: PIIX can't have 754 * different timings for master and slave drives. 755 * We need to find the best combination. 756 */ 757 758 /* If both drives supports DMA, takes the lower mode */ 759 if ((drvp[0].drive_flags & DRIVE_DMA) && 760 (drvp[1].drive_flags & DRIVE_DMA)) { 761 mode[0] = mode[1] = 762 min(drvp[0].DMA_mode, drvp[1].DMA_mode); 763 goto ok; 764 } 765 /* 766 * If only one drive supports DMA, use its mode, and 767 * put the other one in PIO mode 0 if mode not compatible 768 */ 769 if (drvp[0].drive_flags & DRIVE_DMA) { 770 mode[0] = drvp[0].DMA_mode; 771 mode[1] = drvp[1].PIO_mode; 772 if (piix_isp_pio[mode[1]] < piix_isp_dma[mode[0]] || 773 piix_rtc_pio[mode[1]] < piix_rtc_dma[mode[0]]) 774 mode[1] = 0; 775 goto ok; 776 } 777 if (drvp[1].drive_flags & DRIVE_DMA) { 778 mode[1] = drvp[1].DMA_mode; 779 mode[0] = drvp[0].PIO_mode; 780 if (piix_isp_pio[mode[0]] < piix_isp_dma[mode[1]] || 781 piix_rtc_pio[mode[0]] < piix_rtc_dma[mode[1]]) 782 mode[0] = 0; 783 goto ok; 784 } 785 /* 786 * If both drives are not DMA, takes the lower mode, unless 787 * one of them is PIO mode 0 788 */ 789 if (drvp[0].PIO_mode == 0) { 790 mode[0] = 0; 791 mode[1] = drvp[1].PIO_mode; 792 } else if (drvp[1].PIO_mode == 0) { 793 mode[1] = 0; 794 mode[0] = drvp[0].PIO_mode; 795 } else { 796 mode[0] = mode[1] = 797 min(drvp[1].PIO_mode, drvp[0].PIO_mode); 798 } 799 ok: /* The modes are setup */ 800 for (drive = 0; drive < 2; drive++) { 801 if (drvp[drive].drive_flags & DRIVE_DMA) { 802 idetim |= piix_setup_idetim_timings( 803 mode[drive], 1, channel); 804 goto end; 805 } 806 } 807 /* If we are there, none of the drives are DMA */ 808 if (mode[0] > 0) 809 idetim |= piix_setup_idetim_timings( 810 mode[0], 0, channel); 811 else 812 idetim |= piix_setup_idetim_timings( 813 mode[1], 0, channel); 814 end: /* 815 * timing mode is now set up in the controller. Enable 816 * it per-drive 817 */ 818 for (drive = 0; drive < 2; drive++) { 819 if (drvp[drive].drive_flags & DRIVE_DMA) { 820 idetim = PIIX_IDETIM_SET(idetim, 821 PIIX_IDETIM_DTE(drive), channel); 822 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 823 drvp[drive].DMA_mode = mode[drive]; 824 drvp[drive].PIO_mode = 0; 825 printf("%s:%d:%d: using DMA mode %d\n", 826 sc->sc_wdcdev.sc_dev.dv_xname, 827 channel, drive, mode[drive]); 828 } else { 829 if (mode[drive] > 0) 830 idetim |= piix_setup_idetim_drvs( 831 mode[drive], channel, drive); 832 drvp[drive].PIO_mode = mode[drive]; 833 printf("%s:%d:%d: using PIO mode %d\n", 834 sc->sc_wdcdev.sc_dev.dv_xname, 835 channel, drive, mode[drive]); 836 } 837 } 838 if (idedma_ctl != 0) { 839 /* Add software bits in status register */ 840 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 841 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * channel), 842 idedma_ctl); 843 } 844 } 845 WDCDEBUG_PRINT(("piix_setup_chip: idetim=0x%x, sidetim=0x%x\n", 846 idetim, sidetim), DEBUG_PROBE); 847 pci_conf_write(pc, tag, PIIX_IDETIM, idetim); 848 pci_conf_write(pc, tag, PIIX_SIDETIM, sidetim); 849 } 850 851 void 852 piix3_4_setup_chip(sc, pc, tag) 853 struct pciide_softc *sc; 854 pci_chipset_tag_t pc; 855 pcitag_t tag; 856 { 857 int channel, drive; 858 struct channel_softc *chp; 859 struct ata_drive_datas *drvp; 860 u_int32_t idetim, sidetim, udmactl, udmatim, idedma_ctl; 861 862 idetim = sidetim = udmactl = udmatim = 0; 863 864 WDCDEBUG_PRINT(("piix3_4_setup_chip: old idetim=0x%x, sidetim=0x%x\n", 865 pci_conf_read(pc, tag, PIIX_IDETIM), 866 pci_conf_read(pc, tag, PIIX_SIDETIM)), DEBUG_PROBE); 867 for (channel = 0; channel < PCIIDE_NUM_CHANNELS; channel++) { 868 chp = &sc->wdc_channels[channel]; 869 idedma_ctl = 0; 870 /* Enable IDE registers decode */ 871 idetim = PIIX_IDETIM_SET(idetim, PIIX_IDETIM_IDE, 872 channel); 873 for (drive = 0; drive < 2; drive++) { 874 drvp = &chp->ch_drive[drive]; 875 /* If no drive, skip */ 876 if ((drvp->drive_flags & DRIVE) == 0) 877 continue; 878 /* add timing values, setup DMA if needed */ 879 if (((drvp->drive_flags & DRIVE_DMA) == 0 && 880 (drvp->drive_flags & DRIVE_UDMA) == 0) || 881 sc->sc_dma_ok == 0) 882 goto pio; 883 if (pciide_dma_table_setup(sc, channel, drive) != 0) 884 goto pio; /* Abort DMA setup */ 885 drvp->PIO_mode = 0; /* use compatible timings for PIO */ 886 if ((chp->wdc->cap & WDC_CAPABILITY_UDMA) && 887 (drvp->drive_flags & DRIVE_UDMA)) { 888 /* use Ultra/DMA */ 889 drvp->drive_flags &= ~DRIVE_DMA; 890 udmactl |= PIIX_UDMACTL_DRV_EN( 891 channel, drive); 892 udmatim |= PIIX_UDMATIM_SET( 893 piix4_sct_udma[drvp->UDMA_mode], 894 channel, drive); 895 printf("%s:%d:%d: using Ultra DMA/33 mode %d\n", 896 sc->sc_wdcdev.sc_dev.dv_xname, 897 channel, drive, 898 drvp->UDMA_mode); 899 } else { 900 /* use Multiword DMA */ 901 drvp->drive_flags &= ~DRIVE_UDMA; 902 if (drive == 0) { 903 idetim |= piix_setup_idetim_timings( 904 drvp->DMA_mode, 1, channel); 905 } else { 906 sidetim |= piix_setup_sidetim_timings( 907 drvp->DMA_mode, 1, channel); 908 idetim =PIIX_IDETIM_SET(idetim, 909 PIIX_IDETIM_SITRE, channel); 910 } 911 printf("%s:%d:%d: using DMA mode %d\n", 912 sc->sc_wdcdev.sc_dev.dv_xname, 913 channel, drive, 914 drvp->DMA_mode); 915 } 916 /* Enable DMA only PIO modes may be wrong */ 917 idetim = PIIX_IDETIM_SET(idetim, 918 PIIX_IDETIM_DTE(drive), channel); 919 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 920 continue; 921 922 pio: /* use PIO mode */ 923 drvp->drive_flags &= ~DRIVE_DMA | DRIVE_UDMA; 924 if (drive == 0) { 925 idetim |= piix_setup_idetim_timings( 926 drvp->PIO_mode, 0, channel); 927 } else { 928 sidetim |= piix_setup_sidetim_timings( 929 drvp->PIO_mode, 0, channel); 930 idetim =PIIX_IDETIM_SET(idetim, 931 PIIX_IDETIM_SITRE, channel); 932 } 933 idetim |= piix_setup_idetim_drvs(drvp->PIO_mode, 934 channel, drive); 935 printf("%s:%d:%d: using PIO mode %d\n", 936 sc->sc_wdcdev.sc_dev.dv_xname, channel, drive, 937 drvp->PIO_mode); 938 } 939 if (idedma_ctl != 0) { 940 /* Add software bits in status register */ 941 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 942 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * channel), 943 idedma_ctl); 944 } 945 } 946 947 WDCDEBUG_PRINT(("piix3_4_setup_chip: idetim=0x%x, sidetim=0x%x", 948 idetim, sidetim), DEBUG_PROBE); 949 if (chp->wdc->cap & WDC_CAPABILITY_UDMA) { 950 WDCDEBUG_PRINT((", udmactl=0x%x, udmatim=0x%x", udmactl, 951 udmatim), DEBUG_PROBE); 952 pci_conf_write(pc, tag, PIIX_UDMACTL, udmactl); 953 pci_conf_write(pc, tag, PIIX_UDMATIM, udmatim); 954 } 955 WDCDEBUG_PRINT(("\n"), DEBUG_PROBE); 956 pci_conf_write(pc, tag, PIIX_IDETIM, idetim); 957 pci_conf_write(pc, tag, PIIX_SIDETIM, sidetim); 958 } 959 960 /* setup ISP and RTC fields, based on mode */ 961 static u_int32_t 962 piix_setup_idetim_timings(mode, dma, channel) 963 u_int8_t mode; 964 u_int8_t dma; 965 u_int8_t channel; 966 { 967 968 if (dma) 969 return PIIX_IDETIM_SET(0, 970 PIIX_IDETIM_ISP_SET(piix_isp_dma[mode]) | 971 PIIX_IDETIM_RTC_SET(piix_rtc_dma[mode]), 972 channel); 973 else 974 return PIIX_IDETIM_SET(0, 975 PIIX_IDETIM_ISP_SET(piix_isp_pio[mode]) | 976 PIIX_IDETIM_RTC_SET(piix_rtc_pio[mode]), 977 channel); 978 } 979 980 /* setup PPE, IE and TIME1 field based on PIO mode */ 981 static u_int32_t 982 piix_setup_idetim_drvs(mode, channel, drive) 983 u_int8_t mode; 984 u_int8_t channel; 985 u_int8_t drive; 986 { 987 u_int32_t ret = 0; 988 989 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_TIME(drive), channel); 990 /* I didn't read anything about this, it's just a guess */ 991 if (mode >= 2) 992 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_IE(drive), channel); 993 if (mode >= 3) 994 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_PPE(drive), channel); 995 return ret; 996 } 997 998 /* setup values in SIDETIM registers, based on mode */ 999 static u_int32_t 1000 piix_setup_sidetim_timings(mode, dma, channel) 1001 u_int8_t mode; 1002 u_int8_t dma; 1003 u_int8_t channel; 1004 { 1005 if (dma) 1006 return PIIX_SIDETIM_ISP_SET(piix_isp_dma[mode], channel) | 1007 PIIX_SIDETIM_RTC_SET(piix_rtc_dma[mode], channel); 1008 else 1009 return PIIX_SIDETIM_ISP_SET(piix_isp_pio[mode], channel) | 1010 PIIX_SIDETIM_RTC_SET(piix_rtc_pio[mode], channel); 1011 } 1012 1013 1014 1015 int 1016 pciide_dma_table_setup(sc, channel, drive) 1017 struct pciide_softc *sc; 1018 int channel, drive; 1019 { 1020 bus_dma_segment_t seg; 1021 int error, rseg; 1022 const bus_size_t dma_table_size = 1023 sizeof(struct idedma_table) * NIDEDMA_TABLES; 1024 struct pciide_dma_maps *dma_maps = 1025 &sc->pciide_channels[channel].dma_maps[drive]; 1026 1027 /* Allocate memory for the DMA tables and map it */ 1028 if ((error = bus_dmamem_alloc(sc->sc_dmat, dma_table_size, 1029 IDEDMA_TBL_ALIGN, IDEDMA_TBL_ALIGN, &seg, 1, &rseg, 1030 BUS_DMA_NOWAIT)) != 0) { 1031 printf("%s:%d: unable to allocate table DMA for" 1032 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1033 channel, drive, error); 1034 return error; 1035 } 1036 if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, 1037 dma_table_size, 1038 (caddr_t *)&dma_maps->dma_table, 1039 BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) { 1040 printf("%s:%d: unable to map table DMA for" 1041 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1042 channel, drive, error); 1043 return error; 1044 } 1045 WDCDEBUG_PRINT(("pciide_dma_table_setup: table at %p len %ld, " 1046 "phy 0x%lx\n", dma_maps->dma_table, dma_table_size, 1047 seg.ds_addr), DEBUG_PROBE); 1048 1049 /* Create and load table DMA map for this disk */ 1050 if ((error = bus_dmamap_create(sc->sc_dmat, dma_table_size, 1051 1, dma_table_size, IDEDMA_TBL_ALIGN, BUS_DMA_NOWAIT, 1052 &dma_maps->dmamap_table)) != 0) { 1053 printf("%s:%d: unable to create table DMA map for" 1054 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1055 channel, drive, error); 1056 return error; 1057 } 1058 if ((error = bus_dmamap_load(sc->sc_dmat, 1059 dma_maps->dmamap_table, 1060 dma_maps->dma_table, 1061 dma_table_size, NULL, BUS_DMA_NOWAIT)) != 0) { 1062 printf("%s:%d: unable to load table DMA map for" 1063 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1064 channel, drive, error); 1065 return error; 1066 } 1067 WDCDEBUG_PRINT(("pciide_dma_table_setup: phy addr of table 0x%lx\n", 1068 dma_maps->dmamap_table->dm_segs[0].ds_addr), DEBUG_PROBE); 1069 /* Create a xfer DMA map for this drive */ 1070 if ((error = bus_dmamap_create(sc->sc_dmat, IDEDMA_BYTE_COUNT_MAX, 1071 NIDEDMA_TABLES, IDEDMA_BYTE_COUNT_MAX, IDEDMA_BYTE_COUNT_ALIGN, 1072 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, 1073 &dma_maps->dmamap_xfer)) != 0) { 1074 printf("%s:%d: unable to create xfer DMA map for" 1075 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1076 channel, drive, error); 1077 return error; 1078 } 1079 return 0; 1080 } 1081 1082 int 1083 pciide_dma_init(v, channel, drive, databuf, datalen, read) 1084 void *v; 1085 int channel, drive; 1086 void *databuf; 1087 size_t datalen; 1088 int read; 1089 { 1090 struct pciide_softc *sc = v; 1091 int error, seg; 1092 struct pciide_dma_maps *dma_maps = 1093 &sc->pciide_channels[channel].dma_maps[drive]; 1094 1095 error = bus_dmamap_load(sc->sc_dmat, 1096 dma_maps->dmamap_xfer, 1097 databuf, datalen, NULL, BUS_DMA_NOWAIT); 1098 if (error) { 1099 printf("%s:%d: unable to load xfer DMA map for" 1100 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1101 channel, drive, error); 1102 return error; 1103 } 1104 1105 bus_dmamap_sync(sc->sc_dmat, dma_maps->dmamap_xfer, 0, 1106 dma_maps->dmamap_xfer->dm_mapsize, 1107 (read) ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); 1108 1109 WDCDEBUG_PRINT(("pciide_dma_init: %d segs for %p len %d (phy 0x%x)\n", 1110 dma_maps->dmamap_xfer->dm_nsegs, databuf, datalen, 1111 vtophys(databuf)), DEBUG_DMA|DEBUG_XFERS); 1112 for (seg = 0; seg < dma_maps->dmamap_xfer->dm_nsegs; seg++) { 1113 #ifdef DIAGNOSTIC 1114 /* A segment must not cross a 64k boundary */ 1115 { 1116 u_long phys = dma_maps->dmamap_xfer->dm_segs[seg].ds_addr; 1117 u_long len = dma_maps->dmamap_xfer->dm_segs[seg].ds_len; 1118 if ((phys & ~IDEDMA_BYTE_COUNT_MASK) != 1119 ((phys + len - 1) & ~IDEDMA_BYTE_COUNT_MASK)) { 1120 printf("pciide_dma: segment %d physical addr 0x%lx" 1121 " len 0x%lx not properly aligned\n", 1122 seg, phys, len); 1123 panic("pciide_dma: buf align"); 1124 } 1125 } 1126 #endif 1127 dma_maps->dma_table[seg].base_addr = 1128 dma_maps->dmamap_xfer->dm_segs[seg].ds_addr; 1129 dma_maps->dma_table[seg].byte_count = 1130 dma_maps->dmamap_xfer->dm_segs[seg].ds_len & 1131 IDEDMA_BYTE_COUNT_MASK; 1132 WDCDEBUG_PRINT(("\t seg %d len %d addr 0x%x\n", 1133 seg, dma_maps->dma_table[seg].byte_count, 1134 dma_maps->dma_table[seg].base_addr), DEBUG_DMA); 1135 1136 } 1137 dma_maps->dma_table[dma_maps->dmamap_xfer->dm_nsegs -1].byte_count |= 1138 IDEDMA_BYTE_COUNT_EOT; 1139 1140 bus_dmamap_sync(sc->sc_dmat, dma_maps->dmamap_table, 0, 1141 dma_maps->dmamap_table->dm_mapsize, 1142 BUS_DMASYNC_PREWRITE); 1143 1144 /* Maps are ready. Start DMA function */ 1145 #ifdef DIAGNOSTIC 1146 if (dma_maps->dmamap_table->dm_segs[0].ds_addr & ~IDEDMA_TBL_MASK) { 1147 printf("pciide_dma_init: addr 0x%lx not properly aligned\n", 1148 dma_maps->dmamap_table->dm_segs[0].ds_addr); 1149 panic("pciide_dma_init: table align"); 1150 } 1151 #endif 1152 1153 WDCDEBUG_PRINT(("phy addr of table at %p = 0x%lx len %ld (%d segs, " 1154 "phys 0x%x)\n", 1155 dma_maps->dma_table, 1156 dma_maps->dmamap_table->dm_segs[0].ds_addr, 1157 dma_maps->dmamap_table->dm_segs[0].ds_len, 1158 dma_maps->dmamap_table->dm_nsegs, 1159 vtophys(dma_maps->dma_table)), DEBUG_DMA); 1160 /* Clear status bits */ 1161 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1162 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel, 1163 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1164 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel)); 1165 /* Write table addr */ 1166 bus_space_write_4(sc->sc_dma_iot, sc->sc_dma_ioh, 1167 IDEDMA_TBL + IDEDMA_SCH_OFFSET * channel, 1168 dma_maps->dmamap_table->dm_segs[0].ds_addr); 1169 /* set read/write */ 1170 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1171 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel, 1172 (read) ? IDEDMA_CMD_WRITE: 0); 1173 return 0; 1174 } 1175 1176 void 1177 pciide_dma_start(v, channel, drive, read) 1178 void *v; 1179 int channel, drive; 1180 { 1181 struct pciide_softc *sc = v; 1182 1183 WDCDEBUG_PRINT(("pciide_dma_start\n"),DEBUG_XFERS); 1184 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1185 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel, 1186 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1187 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel) | IDEDMA_CMD_START); 1188 } 1189 1190 int 1191 pciide_dma_finish(v, channel, drive, read) 1192 void *v; 1193 int channel, drive; 1194 int read; 1195 { 1196 struct pciide_softc *sc = v; 1197 u_int8_t status; 1198 struct pciide_dma_maps *dma_maps = 1199 &sc->pciide_channels[channel].dma_maps[drive]; 1200 1201 /* Unload the map of the data buffer */ 1202 bus_dmamap_sync(sc->sc_dmat, dma_maps->dmamap_xfer, 0, 1203 dma_maps->dmamap_xfer->dm_mapsize, 1204 (read) ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); 1205 bus_dmamap_unload(sc->sc_dmat, dma_maps->dmamap_xfer); 1206 1207 status = bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1208 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel); 1209 WDCDEBUG_PRINT(("pciide_dma_finish: status 0x%x\n", status), 1210 DEBUG_XFERS); 1211 1212 /* stop DMA channel */ 1213 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1214 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel, 1215 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1216 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel) & ~IDEDMA_CMD_START); 1217 1218 /* Clear status bits */ 1219 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1220 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel, 1221 status); 1222 1223 if ((status & (IDEDMA_CTL_INTR | IDEDMA_CTL_ERR | IDEDMA_CTL_ACT)) != 1224 IDEDMA_CTL_INTR) { 1225 printf("%s:%d:%d: Bus-Master DMA error: status=0x%x\n", 1226 sc->sc_wdcdev.sc_dev.dv_xname, channel, drive, status); 1227 return 1; 1228 } 1229 return 0; 1230 } 1231
Indexes created Thu Oct 02 10:09:58 GMT 2025