piixide.c revision 1.8.2.1
1 /* $NetBSD: piixide.c,v 1.8.2.1 2004/07/28 11:21:02 tron Exp $ */ 2 3 /* 4 * Copyright (c) 1999, 2000, 2001 Manuel Bouyer. 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 Manuel Bouyer. 17 * 4. The name of the author may not be used to endorse or promote products 18 * derived from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 35 #include <dev/pci/pcivar.h> 36 #include <dev/pci/pcidevs.h> 37 #include <dev/pci/pciidereg.h> 38 #include <dev/pci/pciidevar.h> 39 #include <dev/pci/pciide_piix_reg.h> 40 41 static void piix_chip_map(struct pciide_softc*, struct pci_attach_args *); 42 static void piix_setup_channel(struct wdc_channel *); 43 static void piix3_4_setup_channel(struct wdc_channel *); 44 static u_int32_t piix_setup_idetim_timings(u_int8_t, u_int8_t, u_int8_t); 45 static u_int32_t piix_setup_idetim_drvs(struct ata_drive_datas *); 46 static u_int32_t piix_setup_sidetim_timings(u_int8_t, u_int8_t, u_int8_t); 47 static void piixsata_chip_map(struct pciide_softc*, struct pci_attach_args *); 48 49 static int piixide_match(struct device *, struct cfdata *, void *); 50 static void piixide_attach(struct device *, struct device *, void *); 51 52 static const struct pciide_product_desc pciide_intel_products[] = { 53 { PCI_PRODUCT_INTEL_82092AA, 54 0, 55 "Intel 82092AA IDE controller", 56 default_chip_map, 57 }, 58 { PCI_PRODUCT_INTEL_82371FB_IDE, 59 0, 60 "Intel 82371FB IDE controller (PIIX)", 61 piix_chip_map, 62 }, 63 { PCI_PRODUCT_INTEL_82371SB_IDE, 64 0, 65 "Intel 82371SB IDE Interface (PIIX3)", 66 piix_chip_map, 67 }, 68 { PCI_PRODUCT_INTEL_82371AB_IDE, 69 0, 70 "Intel 82371AB IDE controller (PIIX4)", 71 piix_chip_map, 72 }, 73 { PCI_PRODUCT_INTEL_82440MX_IDE, 74 0, 75 "Intel 82440MX IDE controller", 76 piix_chip_map 77 }, 78 { PCI_PRODUCT_INTEL_82801AA_IDE, 79 0, 80 "Intel 82801AA IDE Controller (ICH)", 81 piix_chip_map, 82 }, 83 { PCI_PRODUCT_INTEL_82801AB_IDE, 84 0, 85 "Intel 82801AB IDE Controller (ICH0)", 86 piix_chip_map, 87 }, 88 { PCI_PRODUCT_INTEL_82801BA_IDE, 89 0, 90 "Intel 82801BA IDE Controller (ICH2)", 91 piix_chip_map, 92 }, 93 { PCI_PRODUCT_INTEL_82801BAM_IDE, 94 0, 95 "Intel 82801BAM IDE Controller (ICH2-M)", 96 piix_chip_map, 97 }, 98 { PCI_PRODUCT_INTEL_82801CA_IDE_1, 99 0, 100 "Intel 82801CA IDE Controller (ICH3)", 101 piix_chip_map, 102 }, 103 { PCI_PRODUCT_INTEL_82801CA_IDE_2, 104 0, 105 "Intel 82801CA IDE Controller (ICH3)", 106 piix_chip_map, 107 }, 108 { PCI_PRODUCT_INTEL_82801DB_IDE, 109 0, 110 "Intel 82801DB IDE Controller (ICH4)", 111 piix_chip_map, 112 }, 113 { PCI_PRODUCT_INTEL_82801DBM_IDE, 114 0, 115 "Intel 82801DBM IDE Controller (ICH4-M)", 116 piix_chip_map, 117 }, 118 { PCI_PRODUCT_INTEL_82801EB_IDE, 119 0, 120 "Intel 82801EB IDE Controller (ICH5)", 121 piix_chip_map, 122 }, 123 { PCI_PRODUCT_INTEL_82801EB_SATA, 124 0, 125 "Intel 82801EB Serial ATA Controller", 126 piixsata_chip_map, 127 }, 128 { PCI_PRODUCT_INTEL_82801ER_SATA, 129 0, 130 "Intel 82801ER Serial ATA/Raid Controller", 131 piixsata_chip_map, 132 }, 133 { PCI_PRODUCT_INTEL_6300ESB_IDE, 134 0, 135 "Intel 6300ESB IDE Controller (ICH5)", 136 piix_chip_map, 137 }, 138 { PCI_PRODUCT_INTEL_6300ESB_SATA, 139 0, 140 "Intel 6300ESB Serial ATA Controller", 141 piixsata_chip_map, 142 }, 143 { 0, 144 0, 145 NULL, 146 NULL 147 } 148 }; 149 150 CFATTACH_DECL(piixide, sizeof(struct pciide_softc), 151 piixide_match, piixide_attach, NULL, NULL); 152 153 static int 154 piixide_match(struct device *parent, struct cfdata *match, void *aux) 155 { 156 struct pci_attach_args *pa = aux; 157 158 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_INTEL) { 159 if (pciide_lookup_product(pa->pa_id, pciide_intel_products)) 160 return (2); 161 } 162 return (0); 163 } 164 165 static void 166 piixide_attach(struct device *parent, struct device *self, void *aux) 167 { 168 struct pci_attach_args *pa = aux; 169 struct pciide_softc *sc = (struct pciide_softc *)self; 170 171 pciide_common_attach(sc, pa, 172 pciide_lookup_product(pa->pa_id, pciide_intel_products)); 173 174 } 175 176 static void 177 piix_chip_map(struct pciide_softc *sc, struct pci_attach_args *pa) 178 { 179 struct pciide_channel *cp; 180 int channel; 181 u_int32_t idetim; 182 bus_size_t cmdsize, ctlsize; 183 184 if (pciide_chipen(sc, pa) == 0) 185 return; 186 187 aprint_normal("%s: bus-master DMA support present", 188 sc->sc_wdcdev.sc_dev.dv_xname); 189 pciide_mapreg_dma(sc, pa); 190 aprint_normal("\n"); 191 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 192 WDC_CAPABILITY_MODE; 193 if (sc->sc_dma_ok) { 194 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 195 sc->sc_wdcdev.irqack = pciide_irqack; 196 switch(sc->sc_pp->ide_product) { 197 case PCI_PRODUCT_INTEL_82371AB_IDE: 198 case PCI_PRODUCT_INTEL_82440MX_IDE: 199 case PCI_PRODUCT_INTEL_82801AA_IDE: 200 case PCI_PRODUCT_INTEL_82801AB_IDE: 201 case PCI_PRODUCT_INTEL_82801BA_IDE: 202 case PCI_PRODUCT_INTEL_82801BAM_IDE: 203 case PCI_PRODUCT_INTEL_82801CA_IDE_1: 204 case PCI_PRODUCT_INTEL_82801CA_IDE_2: 205 case PCI_PRODUCT_INTEL_82801DB_IDE: 206 case PCI_PRODUCT_INTEL_82801DBM_IDE: 207 case PCI_PRODUCT_INTEL_82801EB_IDE: 208 case PCI_PRODUCT_INTEL_6300ESB_IDE: 209 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 210 } 211 } 212 sc->sc_wdcdev.PIO_cap = 4; 213 sc->sc_wdcdev.DMA_cap = 2; 214 switch(sc->sc_pp->ide_product) { 215 case PCI_PRODUCT_INTEL_82801AA_IDE: 216 sc->sc_wdcdev.UDMA_cap = 4; 217 break; 218 case PCI_PRODUCT_INTEL_82801BA_IDE: 219 case PCI_PRODUCT_INTEL_82801BAM_IDE: 220 case PCI_PRODUCT_INTEL_82801CA_IDE_1: 221 case PCI_PRODUCT_INTEL_82801CA_IDE_2: 222 case PCI_PRODUCT_INTEL_82801DB_IDE: 223 case PCI_PRODUCT_INTEL_82801DBM_IDE: 224 case PCI_PRODUCT_INTEL_82801EB_IDE: 225 case PCI_PRODUCT_INTEL_6300ESB_IDE: 226 sc->sc_wdcdev.UDMA_cap = 5; 227 break; 228 default: 229 sc->sc_wdcdev.UDMA_cap = 2; 230 } 231 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82371FB_IDE) 232 sc->sc_wdcdev.set_modes = piix_setup_channel; 233 else 234 sc->sc_wdcdev.set_modes = piix3_4_setup_channel; 235 sc->sc_wdcdev.channels = sc->wdc_chanarray; 236 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 237 238 WDCDEBUG_PRINT(("piix_setup_chip: old idetim=0x%x", 239 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM)), 240 DEBUG_PROBE); 241 if (sc->sc_pp->ide_product != PCI_PRODUCT_INTEL_82371FB_IDE) { 242 WDCDEBUG_PRINT((", sidetim=0x%x", 243 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_SIDETIM)), 244 DEBUG_PROBE); 245 if (sc->sc_wdcdev.cap & WDC_CAPABILITY_UDMA) { 246 WDCDEBUG_PRINT((", udamreg 0x%x", 247 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_UDMAREG)), 248 DEBUG_PROBE); 249 } 250 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AA_IDE || 251 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AB_IDE || 252 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BA_IDE || 253 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BAM_IDE || 254 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_1 || 255 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_2 || 256 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DB_IDE || 257 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DBM_IDE || 258 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801EB_IDE || 259 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_6300ESB_IDE) { 260 WDCDEBUG_PRINT((", IDE_CONTROL 0x%x", 261 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_CONFIG)), 262 DEBUG_PROBE); 263 } 264 265 } 266 WDCDEBUG_PRINT(("\n"), DEBUG_PROBE); 267 268 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 269 cp = &sc->pciide_channels[channel]; 270 /* PIIX is compat-only */ 271 if (pciide_chansetup(sc, channel, 0) == 0) 272 continue; 273 idetim = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM); 274 if ((PIIX_IDETIM_READ(idetim, channel) & 275 PIIX_IDETIM_IDE) == 0) { 276 #if 1 277 aprint_normal("%s: %s channel ignored (disabled)\n", 278 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 279 cp->wdc_channel.ch_flags |= WDCF_DISABLED; 280 continue; 281 #else 282 pcireg_t interface; 283 284 idetim = PIIX_IDETIM_SET(idetim, PIIX_IDETIM_IDE, 285 channel); 286 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_IDETIM, 287 idetim); 288 interface = PCI_INTERFACE(pci_conf_read(sc->sc_pc, 289 sc->sc_tag, PCI_CLASS_REG)); 290 aprint_normal("channel %d idetim=%08x interface=%02x\n", 291 channel, idetim, interface); 292 #endif 293 } 294 /* PIIX are compat-only pciide devices */ 295 pciide_mapchan(pa, cp, 0, &cmdsize, &ctlsize, pciide_pci_intr); 296 } 297 298 WDCDEBUG_PRINT(("piix_setup_chip: idetim=0x%x", 299 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM)), 300 DEBUG_PROBE); 301 if (sc->sc_pp->ide_product != PCI_PRODUCT_INTEL_82371FB_IDE) { 302 WDCDEBUG_PRINT((", sidetim=0x%x", 303 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_SIDETIM)), 304 DEBUG_PROBE); 305 if (sc->sc_wdcdev.cap & WDC_CAPABILITY_UDMA) { 306 WDCDEBUG_PRINT((", udamreg 0x%x", 307 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_UDMAREG)), 308 DEBUG_PROBE); 309 } 310 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AA_IDE || 311 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AB_IDE || 312 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BA_IDE || 313 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BAM_IDE || 314 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_1 || 315 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_2 || 316 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DB_IDE || 317 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DBM_IDE || 318 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801EB_IDE || 319 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_6300ESB_IDE) { 320 WDCDEBUG_PRINT((", IDE_CONTROL 0x%x", 321 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_CONFIG)), 322 DEBUG_PROBE); 323 } 324 } 325 WDCDEBUG_PRINT(("\n"), DEBUG_PROBE); 326 } 327 328 static void 329 piix_setup_channel(struct wdc_channel *chp) 330 { 331 u_int8_t mode[2], drive; 332 u_int32_t oidetim, idetim, idedma_ctl; 333 struct pciide_channel *cp = (struct pciide_channel*)chp; 334 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.ch_wdc; 335 struct ata_drive_datas *drvp = cp->wdc_channel.ch_drive; 336 337 oidetim = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM); 338 idetim = PIIX_IDETIM_CLEAR(oidetim, 0xffff, chp->ch_channel); 339 idedma_ctl = 0; 340 341 /* set up new idetim: Enable IDE registers decode */ 342 idetim = PIIX_IDETIM_SET(idetim, PIIX_IDETIM_IDE, 343 chp->ch_channel); 344 345 /* setup DMA */ 346 pciide_channel_dma_setup(cp); 347 348 /* 349 * Here we have to mess up with drives mode: PIIX can't have 350 * different timings for master and slave drives. 351 * We need to find the best combination. 352 */ 353 354 /* If both drives supports DMA, take the lower mode */ 355 if ((drvp[0].drive_flags & DRIVE_DMA) && 356 (drvp[1].drive_flags & DRIVE_DMA)) { 357 mode[0] = mode[1] = 358 min(drvp[0].DMA_mode, drvp[1].DMA_mode); 359 drvp[0].DMA_mode = mode[0]; 360 drvp[1].DMA_mode = mode[1]; 361 goto ok; 362 } 363 /* 364 * If only one drive supports DMA, use its mode, and 365 * put the other one in PIO mode 0 if mode not compatible 366 */ 367 if (drvp[0].drive_flags & DRIVE_DMA) { 368 mode[0] = drvp[0].DMA_mode; 369 mode[1] = drvp[1].PIO_mode; 370 if (piix_isp_pio[mode[1]] != piix_isp_dma[mode[0]] || 371 piix_rtc_pio[mode[1]] != piix_rtc_dma[mode[0]]) 372 mode[1] = drvp[1].PIO_mode = 0; 373 goto ok; 374 } 375 if (drvp[1].drive_flags & DRIVE_DMA) { 376 mode[1] = drvp[1].DMA_mode; 377 mode[0] = drvp[0].PIO_mode; 378 if (piix_isp_pio[mode[0]] != piix_isp_dma[mode[1]] || 379 piix_rtc_pio[mode[0]] != piix_rtc_dma[mode[1]]) 380 mode[0] = drvp[0].PIO_mode = 0; 381 goto ok; 382 } 383 /* 384 * If both drives are not DMA, takes the lower mode, unless 385 * one of them is PIO mode < 2 386 */ 387 if (drvp[0].PIO_mode < 2) { 388 mode[0] = drvp[0].PIO_mode = 0; 389 mode[1] = drvp[1].PIO_mode; 390 } else if (drvp[1].PIO_mode < 2) { 391 mode[1] = drvp[1].PIO_mode = 0; 392 mode[0] = drvp[0].PIO_mode; 393 } else { 394 mode[0] = mode[1] = 395 min(drvp[1].PIO_mode, drvp[0].PIO_mode); 396 drvp[0].PIO_mode = mode[0]; 397 drvp[1].PIO_mode = mode[1]; 398 } 399 ok: /* The modes are setup */ 400 for (drive = 0; drive < 2; drive++) { 401 if (drvp[drive].drive_flags & DRIVE_DMA) { 402 idetim |= piix_setup_idetim_timings( 403 mode[drive], 1, chp->ch_channel); 404 goto end; 405 } 406 } 407 /* If we are there, none of the drives are DMA */ 408 if (mode[0] >= 2) 409 idetim |= piix_setup_idetim_timings( 410 mode[0], 0, chp->ch_channel); 411 else 412 idetim |= piix_setup_idetim_timings( 413 mode[1], 0, chp->ch_channel); 414 end: /* 415 * timing mode is now set up in the controller. Enable 416 * it per-drive 417 */ 418 for (drive = 0; drive < 2; drive++) { 419 /* If no drive, skip */ 420 if ((drvp[drive].drive_flags & DRIVE) == 0) 421 continue; 422 idetim |= piix_setup_idetim_drvs(&drvp[drive]); 423 if (drvp[drive].drive_flags & DRIVE_DMA) 424 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 425 } 426 if (idedma_ctl != 0) { 427 /* Add software bits in status register */ 428 bus_space_write_1(sc->sc_dma_iot, cp->dma_iohs[IDEDMA_CTL], 0, 429 idedma_ctl); 430 } 431 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_IDETIM, idetim); 432 } 433 434 static void 435 piix3_4_setup_channel(struct wdc_channel *chp) 436 { 437 struct ata_drive_datas *drvp; 438 u_int32_t oidetim, idetim, sidetim, udmareg, ideconf, idedma_ctl; 439 struct pciide_channel *cp = (struct pciide_channel*)chp; 440 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.ch_wdc; 441 struct wdc_softc *wdc = &sc->sc_wdcdev; 442 int drive; 443 int channel = chp->ch_channel; 444 445 oidetim = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM); 446 sidetim = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_SIDETIM); 447 udmareg = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_UDMAREG); 448 ideconf = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_CONFIG); 449 idetim = PIIX_IDETIM_CLEAR(oidetim, 0xffff, channel); 450 sidetim &= ~(PIIX_SIDETIM_ISP_MASK(channel) | 451 PIIX_SIDETIM_RTC_MASK(channel)); 452 idedma_ctl = 0; 453 454 /* set up new idetim: Enable IDE registers decode */ 455 idetim = PIIX_IDETIM_SET(idetim, PIIX_IDETIM_IDE, channel); 456 457 /* setup DMA if needed */ 458 pciide_channel_dma_setup(cp); 459 460 for (drive = 0; drive < 2; drive++) { 461 udmareg &= ~(PIIX_UDMACTL_DRV_EN(channel, drive) | 462 PIIX_UDMATIM_SET(0x3, channel, drive)); 463 drvp = &chp->ch_drive[drive]; 464 /* If no drive, skip */ 465 if ((drvp->drive_flags & DRIVE) == 0) 466 continue; 467 if (((drvp->drive_flags & DRIVE_DMA) == 0 && 468 (drvp->drive_flags & DRIVE_UDMA) == 0)) 469 goto pio; 470 471 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AA_IDE || 472 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AB_IDE || 473 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BA_IDE || 474 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BAM_IDE || 475 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_1 || 476 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_2 || 477 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DB_IDE || 478 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DBM_IDE || 479 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801EB_IDE || 480 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_6300ESB_IDE) { 481 ideconf |= PIIX_CONFIG_PINGPONG; 482 } 483 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BA_IDE || 484 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BAM_IDE || 485 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_1 || 486 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_2 || 487 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DB_IDE || 488 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DBM_IDE || 489 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801EB_IDE || 490 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_6300ESB_IDE) { 491 /* setup Ultra/100 */ 492 if (drvp->UDMA_mode > 2 && 493 (ideconf & PIIX_CONFIG_CR(channel, drive)) == 0) 494 drvp->UDMA_mode = 2; 495 if (drvp->UDMA_mode > 4) { 496 ideconf |= PIIX_CONFIG_UDMA100(channel, drive); 497 } else { 498 ideconf &= ~PIIX_CONFIG_UDMA100(channel, drive); 499 if (drvp->UDMA_mode > 2) { 500 ideconf |= PIIX_CONFIG_UDMA66(channel, 501 drive); 502 } else { 503 ideconf &= ~PIIX_CONFIG_UDMA66(channel, 504 drive); 505 } 506 } 507 } 508 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AA_IDE) { 509 /* setup Ultra/66 */ 510 if (drvp->UDMA_mode > 2 && 511 (ideconf & PIIX_CONFIG_CR(channel, drive)) == 0) 512 drvp->UDMA_mode = 2; 513 if (drvp->UDMA_mode > 2) 514 ideconf |= PIIX_CONFIG_UDMA66(channel, drive); 515 else 516 ideconf &= ~PIIX_CONFIG_UDMA66(channel, drive); 517 } 518 if ((wdc->cap & WDC_CAPABILITY_UDMA) && 519 (drvp->drive_flags & DRIVE_UDMA)) { 520 /* use Ultra/DMA */ 521 drvp->drive_flags &= ~DRIVE_DMA; 522 udmareg |= PIIX_UDMACTL_DRV_EN( channel, drive); 523 udmareg |= PIIX_UDMATIM_SET( 524 piix4_sct_udma[drvp->UDMA_mode], channel, drive); 525 } else { 526 /* use Multiword DMA */ 527 drvp->drive_flags &= ~DRIVE_UDMA; 528 if (drive == 0) { 529 idetim |= piix_setup_idetim_timings( 530 drvp->DMA_mode, 1, channel); 531 } else { 532 sidetim |= piix_setup_sidetim_timings( 533 drvp->DMA_mode, 1, channel); 534 idetim =PIIX_IDETIM_SET(idetim, 535 PIIX_IDETIM_SITRE, channel); 536 } 537 } 538 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 539 540 pio: /* use PIO mode */ 541 idetim |= piix_setup_idetim_drvs(drvp); 542 if (drive == 0) { 543 idetim |= piix_setup_idetim_timings( 544 drvp->PIO_mode, 0, channel); 545 } else { 546 sidetim |= piix_setup_sidetim_timings( 547 drvp->PIO_mode, 0, channel); 548 idetim =PIIX_IDETIM_SET(idetim, 549 PIIX_IDETIM_SITRE, channel); 550 } 551 } 552 if (idedma_ctl != 0) { 553 /* Add software bits in status register */ 554 bus_space_write_1(sc->sc_dma_iot, cp->dma_iohs[IDEDMA_CTL], 0, 555 idedma_ctl); 556 } 557 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_IDETIM, idetim); 558 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_SIDETIM, sidetim); 559 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_UDMAREG, udmareg); 560 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_CONFIG, ideconf); 561 } 562 563 564 /* setup ISP and RTC fields, based on mode */ 565 static u_int32_t 566 piix_setup_idetim_timings(mode, dma, channel) 567 u_int8_t mode; 568 u_int8_t dma; 569 u_int8_t channel; 570 { 571 572 if (dma) 573 return PIIX_IDETIM_SET(0, 574 PIIX_IDETIM_ISP_SET(piix_isp_dma[mode]) | 575 PIIX_IDETIM_RTC_SET(piix_rtc_dma[mode]), 576 channel); 577 else 578 return PIIX_IDETIM_SET(0, 579 PIIX_IDETIM_ISP_SET(piix_isp_pio[mode]) | 580 PIIX_IDETIM_RTC_SET(piix_rtc_pio[mode]), 581 channel); 582 } 583 584 /* setup DTE, PPE, IE and TIME field based on PIO mode */ 585 static u_int32_t 586 piix_setup_idetim_drvs(drvp) 587 struct ata_drive_datas *drvp; 588 { 589 u_int32_t ret = 0; 590 struct wdc_channel *chp = drvp->chnl_softc; 591 u_int8_t channel = chp->ch_channel; 592 u_int8_t drive = drvp->drive; 593 594 /* 595 * If drive is using UDMA, timings setups are independant 596 * So just check DMA and PIO here. 597 */ 598 if (drvp->drive_flags & DRIVE_DMA) { 599 /* if mode = DMA mode 0, use compatible timings */ 600 if ((drvp->drive_flags & DRIVE_DMA) && 601 drvp->DMA_mode == 0) { 602 drvp->PIO_mode = 0; 603 return ret; 604 } 605 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_TIME(drive), channel); 606 /* 607 * PIO and DMA timings are the same, use fast timings for PIO 608 * too, else use compat timings. 609 */ 610 if ((piix_isp_pio[drvp->PIO_mode] != 611 piix_isp_dma[drvp->DMA_mode]) || 612 (piix_rtc_pio[drvp->PIO_mode] != 613 piix_rtc_dma[drvp->DMA_mode])) 614 drvp->PIO_mode = 0; 615 /* if PIO mode <= 2, use compat timings for PIO */ 616 if (drvp->PIO_mode <= 2) { 617 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_DTE(drive), 618 channel); 619 return ret; 620 } 621 } 622 623 /* 624 * Now setup PIO modes. If mode < 2, use compat timings. 625 * Else enable fast timings. Enable IORDY and prefetch/post 626 * if PIO mode >= 3. 627 */ 628 629 if (drvp->PIO_mode < 2) 630 return ret; 631 632 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_TIME(drive), channel); 633 if (drvp->PIO_mode >= 3) { 634 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_IE(drive), channel); 635 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_PPE(drive), channel); 636 } 637 return ret; 638 } 639 640 /* setup values in SIDETIM registers, based on mode */ 641 static u_int32_t 642 piix_setup_sidetim_timings(mode, dma, channel) 643 u_int8_t mode; 644 u_int8_t dma; 645 u_int8_t channel; 646 { 647 if (dma) 648 return PIIX_SIDETIM_ISP_SET(piix_isp_dma[mode], channel) | 649 PIIX_SIDETIM_RTC_SET(piix_rtc_dma[mode], channel); 650 else 651 return PIIX_SIDETIM_ISP_SET(piix_isp_pio[mode], channel) | 652 PIIX_SIDETIM_RTC_SET(piix_rtc_pio[mode], channel); 653 } 654 655 static void 656 piixsata_chip_map(struct pciide_softc *sc, struct pci_attach_args *pa) 657 { 658 struct pciide_channel *cp; 659 bus_size_t cmdsize, ctlsize; 660 pcireg_t interface; 661 int channel; 662 663 if (pciide_chipen(sc, pa) == 0) 664 return; 665 666 aprint_normal("%s: bus-master DMA support present", 667 sc->sc_wdcdev.sc_dev.dv_xname); 668 pciide_mapreg_dma(sc, pa); 669 aprint_normal("\n"); 670 671 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 672 WDC_CAPABILITY_MODE; 673 sc->sc_wdcdev.PIO_cap = 4; 674 if (sc->sc_dma_ok) { 675 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_UDMA; 676 sc->sc_wdcdev.cap |= WDC_CAPABILITY_IRQACK; 677 sc->sc_wdcdev.irqack = pciide_irqack; 678 sc->sc_wdcdev.DMA_cap = 2; 679 sc->sc_wdcdev.UDMA_cap = 6; 680 } 681 sc->sc_wdcdev.set_modes = sata_setup_channel; 682 683 sc->sc_wdcdev.channels = sc->wdc_chanarray; 684 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 685 686 interface = PCI_INTERFACE(pa->pa_class); 687 688 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 689 cp = &sc->pciide_channels[channel]; 690 if (pciide_chansetup(sc, channel, interface) == 0) 691 continue; 692 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 693 pciide_pci_intr); 694 } 695 } 696
Indexes created Wed Oct 15 16:09:53 GMT 2025