pciide.c revision 1.153.2.16
1 /* $NetBSD: pciide.c,v 1.153.2.16 2004/03/28 08:50:41 jmc Exp $ */ 2 3 4 /* 5 * Copyright (c) 1999, 2000, 2001 Manuel Bouyer. 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 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Manuel Bouyer. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 */ 34 35 36 /* 37 * Copyright (c) 1996, 1998 Christopher G. Demetriou. All rights reserved. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 3. All advertising materials mentioning features or use of this software 48 * must display the following acknowledgement: 49 * This product includes software developed by Christopher G. Demetriou 50 * for the NetBSD Project. 51 * 4. The name of the author may not be used to endorse or promote products 52 * derived from this software without specific prior written permission 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 55 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 56 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 57 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 58 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 59 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 60 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 61 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 62 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 63 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 64 */ 65 66 /* 67 * PCI IDE controller driver. 68 * 69 * Author: Christopher G. Demetriou, March 2, 1998 (derived from NetBSD 70 * sys/dev/pci/ppb.c, revision 1.16). 71 * 72 * See "PCI IDE Controller Specification, Revision 1.0 3/4/94" and 73 * "Programming Interface for Bus Master IDE Controller, Revision 1.0 74 * 5/16/94" from the PCI SIG. 75 * 76 */ 77 78 #include <sys/cdefs.h> 79 __KERNEL_RCSID(0, "$NetBSD: pciide.c,v 1.153.2.16 2004/03/28 08:50:41 jmc Exp $"); 80 81 #ifndef WDCDEBUG 82 #define WDCDEBUG 83 #endif 84 85 #define DEBUG_DMA 0x01 86 #define DEBUG_XFERS 0x02 87 #define DEBUG_FUNCS 0x08 88 #define DEBUG_PROBE 0x10 89 #ifdef WDCDEBUG 90 int wdcdebug_pciide_mask = 0; 91 #define WDCDEBUG_PRINT(args, level) \ 92 if (wdcdebug_pciide_mask & (level)) printf args 93 #else 94 #define WDCDEBUG_PRINT(args, level) 95 #endif 96 #include <sys/param.h> 97 #include <sys/systm.h> 98 #include <sys/device.h> 99 #include <sys/malloc.h> 100 101 #include <uvm/uvm_extern.h> 102 103 #include <machine/endian.h> 104 105 #include <dev/pci/pcireg.h> 106 #include <dev/pci/pcivar.h> 107 #include <dev/pci/pcidevs.h> 108 #include <dev/pci/pciidereg.h> 109 #include <dev/pci/pciidevar.h> 110 #include <dev/pci/pciide_piix_reg.h> 111 #include <dev/pci/pciide_amd_reg.h> 112 #include <dev/pci/pciide_apollo_reg.h> 113 #include <dev/pci/pciide_cmd_reg.h> 114 #include <dev/pci/pciide_cy693_reg.h> 115 #include <dev/pci/pciide_sis_reg.h> 116 #include <dev/pci/pciide_acer_reg.h> 117 #include <dev/pci/pciide_pdc202xx_reg.h> 118 #include <dev/pci/pciide_opti_reg.h> 119 #include <dev/pci/pciide_hpt_reg.h> 120 #include <dev/pci/pciide_acard_reg.h> 121 #include <dev/pci/pciide_sl82c105_reg.h> 122 #include <dev/pci/cy82c693var.h> 123 124 #include "opt_pciide.h" 125 126 /* inlines for reading/writing 8-bit PCI registers */ 127 static __inline u_int8_t pciide_pci_read __P((pci_chipset_tag_t, pcitag_t, 128 int)); 129 static __inline void pciide_pci_write __P((pci_chipset_tag_t, pcitag_t, 130 int, u_int8_t)); 131 132 static __inline u_int8_t 133 pciide_pci_read(pc, pa, reg) 134 pci_chipset_tag_t pc; 135 pcitag_t pa; 136 int reg; 137 { 138 139 return (pci_conf_read(pc, pa, (reg & ~0x03)) >> 140 ((reg & 0x03) * 8) & 0xff); 141 } 142 143 static __inline void 144 pciide_pci_write(pc, pa, reg, val) 145 pci_chipset_tag_t pc; 146 pcitag_t pa; 147 int reg; 148 u_int8_t val; 149 { 150 pcireg_t pcival; 151 152 pcival = pci_conf_read(pc, pa, (reg & ~0x03)); 153 pcival &= ~(0xff << ((reg & 0x03) * 8)); 154 pcival |= (val << ((reg & 0x03) * 8)); 155 pci_conf_write(pc, pa, (reg & ~0x03), pcival); 156 } 157 158 void default_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 159 160 void piix_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 161 void piix_setup_channel __P((struct channel_softc*)); 162 void piix3_4_setup_channel __P((struct channel_softc*)); 163 static u_int32_t piix_setup_idetim_timings __P((u_int8_t, u_int8_t, u_int8_t)); 164 static u_int32_t piix_setup_idetim_drvs __P((struct ata_drive_datas*)); 165 static u_int32_t piix_setup_sidetim_timings __P((u_int8_t, u_int8_t, u_int8_t)); 166 167 void amd7x6_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 168 void amd7x6_setup_channel __P((struct channel_softc*)); 169 170 void apollo_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 171 void apollo_setup_channel __P((struct channel_softc*)); 172 173 void cmd_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 174 void cmd0643_9_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 175 void cmd0643_9_setup_channel __P((struct channel_softc*)); 176 void cmd_channel_map __P((struct pci_attach_args *, 177 struct pciide_softc *, int)); 178 int cmd_pci_intr __P((void *)); 179 void cmd646_9_irqack __P((struct channel_softc *)); 180 181 void cy693_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 182 void cy693_setup_channel __P((struct channel_softc*)); 183 184 void sis_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 185 void sis_setup_channel __P((struct channel_softc*)); 186 void sis96x_setup_channel __P((struct channel_softc*)); 187 static int sis_hostbr_match __P(( struct pci_attach_args *)); 188 static int sis_south_match __P(( struct pci_attach_args *)); 189 190 void acer_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 191 void acer_setup_channel __P((struct channel_softc*)); 192 int acer_pci_intr __P((void *)); 193 194 void pdc202xx_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 195 void pdc202xx_setup_channel __P((struct channel_softc*)); 196 void pdc20268_setup_channel __P((struct channel_softc*)); 197 int pdc202xx_pci_intr __P((void *)); 198 int pdc20265_pci_intr __P((void *)); 199 static void pdc20262_dma_start __P((void*, int, int)); 200 static int pdc20262_dma_finish __P((void*, int, int, int)); 201 202 void opti_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 203 void opti_setup_channel __P((struct channel_softc*)); 204 205 void hpt_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 206 void hpt_setup_channel __P((struct channel_softc*)); 207 int hpt_pci_intr __P((void *)); 208 209 void acard_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 210 void acard_setup_channel __P((struct channel_softc*)); 211 int acard_pci_intr __P((void *)); 212 213 void serverworks_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 214 void serverworks_setup_channel __P((struct channel_softc*)); 215 int serverworks_pci_intr __P((void *)); 216 217 void sl82c105_chip_map __P((struct pciide_softc*, struct pci_attach_args*)); 218 void sl82c105_setup_channel __P((struct channel_softc*)); 219 220 void pciide_channel_dma_setup __P((struct pciide_channel *)); 221 int pciide_dma_table_setup __P((struct pciide_softc*, int, int)); 222 int pciide_dma_init __P((void*, int, int, void *, size_t, int)); 223 void pciide_dma_start __P((void*, int, int)); 224 int pciide_dma_finish __P((void*, int, int, int)); 225 void pciide_irqack __P((struct channel_softc *)); 226 void pciide_print_modes __P((struct pciide_channel *)); 227 228 struct pciide_product_desc { 229 u_int32_t ide_product; 230 int ide_flags; 231 const char *ide_name; 232 /* map and setup chip, probe drives */ 233 void (*chip_map) __P((struct pciide_softc*, struct pci_attach_args*)); 234 }; 235 236 /* Flags for ide_flags */ 237 #define IDE_PCI_CLASS_OVERRIDE 0x0001 /* accept even if class != pciide */ 238 #define IDE_16BIT_IOSPACE 0x0002 /* I/O space BARS ignore upper word */ 239 240 /* Default product description for devices not known from this controller */ 241 const struct pciide_product_desc default_product_desc = { 242 0, 243 0, 244 "Generic PCI IDE controller", 245 default_chip_map, 246 }; 247 248 const struct pciide_product_desc pciide_intel_products[] = { 249 { PCI_PRODUCT_INTEL_82092AA, 250 0, 251 "Intel 82092AA IDE controller", 252 default_chip_map, 253 }, 254 { PCI_PRODUCT_INTEL_82371FB_IDE, 255 0, 256 "Intel 82371FB IDE controller (PIIX)", 257 piix_chip_map, 258 }, 259 { PCI_PRODUCT_INTEL_82371SB_IDE, 260 0, 261 "Intel 82371SB IDE Interface (PIIX3)", 262 piix_chip_map, 263 }, 264 { PCI_PRODUCT_INTEL_82371AB_IDE, 265 0, 266 "Intel 82371AB IDE controller (PIIX4)", 267 piix_chip_map, 268 }, 269 { PCI_PRODUCT_INTEL_82440MX_IDE, 270 0, 271 "Intel 82440MX IDE controller", 272 piix_chip_map 273 }, 274 { PCI_PRODUCT_INTEL_82801AA_IDE, 275 0, 276 "Intel 82801AA IDE Controller (ICH)", 277 piix_chip_map, 278 }, 279 { PCI_PRODUCT_INTEL_82801AB_IDE, 280 0, 281 "Intel 82801AB IDE Controller (ICH0)", 282 piix_chip_map, 283 }, 284 { PCI_PRODUCT_INTEL_82801BA_IDE, 285 0, 286 "Intel 82801BA IDE Controller (ICH2)", 287 piix_chip_map, 288 }, 289 { PCI_PRODUCT_INTEL_82801BAM_IDE, 290 0, 291 "Intel 82801BAM IDE Controller (ICH2)", 292 piix_chip_map, 293 }, 294 { PCI_PRODUCT_INTEL_82801CA_IDE_1, 295 0, 296 "Intel 82801CA IDE Controller", 297 piix_chip_map, 298 }, 299 { PCI_PRODUCT_INTEL_82801CA_IDE_2, 300 0, 301 "Intel 82801CA IDE Controller", 302 piix_chip_map, 303 }, 304 { PCI_PRODUCT_INTEL_82801DB_IDE, 305 0, 306 "Intel 82801DB IDE Controller (ICH4)", 307 piix_chip_map, 308 }, 309 { PCI_PRODUCT_INTEL_82801EB_IDE, 310 0, 311 "Intel 82801EB IDE Controller (ICH5)", 312 piix_chip_map, 313 }, 314 { 0, 315 0, 316 NULL, 317 NULL 318 } 319 }; 320 321 const struct pciide_product_desc pciide_amd_products[] = { 322 { PCI_PRODUCT_AMD_PBC756_IDE, 323 0, 324 "Advanced Micro Devices AMD756 IDE Controller", 325 amd7x6_chip_map 326 }, 327 { PCI_PRODUCT_AMD_PBC766_IDE, 328 0, 329 "Advanced Micro Devices AMD766 IDE Controller", 330 amd7x6_chip_map 331 }, 332 { PCI_PRODUCT_AMD_PBC768_IDE, 333 0, 334 "Advanced Micro Devices AMD768 IDE Controller", 335 amd7x6_chip_map 336 }, 337 { 0, 338 0, 339 NULL, 340 NULL 341 } 342 }; 343 344 const struct pciide_product_desc pciide_cmd_products[] = { 345 { PCI_PRODUCT_CMDTECH_640, 346 0, 347 "CMD Technology PCI0640", 348 cmd_chip_map 349 }, 350 { PCI_PRODUCT_CMDTECH_643, 351 0, 352 "CMD Technology PCI0643", 353 cmd0643_9_chip_map, 354 }, 355 { PCI_PRODUCT_CMDTECH_646, 356 0, 357 "CMD Technology PCI0646", 358 cmd0643_9_chip_map, 359 }, 360 { PCI_PRODUCT_CMDTECH_648, 361 IDE_PCI_CLASS_OVERRIDE, 362 "CMD Technology PCI0648", 363 cmd0643_9_chip_map, 364 }, 365 { PCI_PRODUCT_CMDTECH_649, 366 IDE_PCI_CLASS_OVERRIDE, 367 "CMD Technology PCI0649", 368 cmd0643_9_chip_map, 369 }, 370 { 0, 371 0, 372 NULL, 373 NULL 374 } 375 }; 376 377 const struct pciide_product_desc pciide_via_products[] = { 378 { PCI_PRODUCT_VIATECH_VT82C586_IDE, 379 0, 380 NULL, 381 apollo_chip_map, 382 }, 383 { PCI_PRODUCT_VIATECH_VT82C586A_IDE, 384 0, 385 NULL, 386 apollo_chip_map, 387 }, 388 { 0, 389 0, 390 NULL, 391 NULL 392 } 393 }; 394 395 const struct pciide_product_desc pciide_cypress_products[] = { 396 { PCI_PRODUCT_CONTAQ_82C693, 397 IDE_16BIT_IOSPACE, 398 "Cypress 82C693 IDE Controller", 399 cy693_chip_map, 400 }, 401 { 0, 402 0, 403 NULL, 404 NULL 405 } 406 }; 407 408 const struct pciide_product_desc pciide_sis_products[] = { 409 { PCI_PRODUCT_SIS_5597_IDE, 410 0, 411 NULL, 412 sis_chip_map, 413 }, 414 { 0, 415 0, 416 NULL, 417 NULL 418 } 419 }; 420 421 const struct pciide_product_desc pciide_acer_products[] = { 422 { PCI_PRODUCT_ALI_M5229, 423 0, 424 "Acer Labs M5229 UDMA IDE Controller", 425 acer_chip_map, 426 }, 427 { 0, 428 0, 429 NULL, 430 NULL 431 } 432 }; 433 434 const struct pciide_product_desc pciide_promise_products[] = { 435 { PCI_PRODUCT_PROMISE_ULTRA33, 436 IDE_PCI_CLASS_OVERRIDE, 437 "Promise Ultra33/ATA Bus Master IDE Accelerator", 438 pdc202xx_chip_map, 439 }, 440 { PCI_PRODUCT_PROMISE_ULTRA66, 441 IDE_PCI_CLASS_OVERRIDE, 442 "Promise Ultra66/ATA Bus Master IDE Accelerator", 443 pdc202xx_chip_map, 444 }, 445 { PCI_PRODUCT_PROMISE_ULTRA100, 446 IDE_PCI_CLASS_OVERRIDE, 447 "Promise Ultra100/ATA Bus Master IDE Accelerator", 448 pdc202xx_chip_map, 449 }, 450 { PCI_PRODUCT_PROMISE_ULTRA100X, 451 IDE_PCI_CLASS_OVERRIDE, 452 "Promise Ultra100/ATA Bus Master IDE Accelerator", 453 pdc202xx_chip_map, 454 }, 455 { PCI_PRODUCT_PROMISE_ULTRA100TX2, 456 IDE_PCI_CLASS_OVERRIDE, 457 "Promise Ultra100TX2/ATA Bus Master IDE Accelerator", 458 pdc202xx_chip_map, 459 }, 460 { PCI_PRODUCT_PROMISE_ULTRA100TX2v2, 461 IDE_PCI_CLASS_OVERRIDE, 462 "Promise Ultra100TX2v2/ATA Bus Master IDE Accelerator", 463 pdc202xx_chip_map, 464 }, 465 { PCI_PRODUCT_PROMISE_ULTRA133, 466 IDE_PCI_CLASS_OVERRIDE, 467 "Promise Ultra133/ATA Bus Master IDE Accelerator", 468 pdc202xx_chip_map, 469 }, 470 { PCI_PRODUCT_PROMISE_ULTRA133TX2, 471 IDE_PCI_CLASS_OVERRIDE, 472 "Promise Ultra133TX2/ATA Bus Master IDE Accelerator", 473 pdc202xx_chip_map, 474 }, 475 { PCI_PRODUCT_PROMISE_ULTRA133TX2v2, 476 IDE_PCI_CLASS_OVERRIDE, 477 "Promise Ultra133TX2v2/ATA Bus Master IDE Accelerator", 478 pdc202xx_chip_map, 479 }, 480 { 0, 481 0, 482 NULL, 483 NULL 484 } 485 }; 486 487 const struct pciide_product_desc pciide_opti_products[] = { 488 { PCI_PRODUCT_OPTI_82C621, 489 0, 490 "OPTi 82c621 PCI IDE controller", 491 opti_chip_map, 492 }, 493 { PCI_PRODUCT_OPTI_82C568, 494 0, 495 "OPTi 82c568 (82c621 compatible) PCI IDE controller", 496 opti_chip_map, 497 }, 498 { PCI_PRODUCT_OPTI_82D568, 499 0, 500 "OPTi 82d568 (82c621 compatible) PCI IDE controller", 501 opti_chip_map, 502 }, 503 { 0, 504 0, 505 NULL, 506 NULL 507 } 508 }; 509 510 const struct pciide_product_desc pciide_triones_products[] = { 511 { PCI_PRODUCT_TRIONES_HPT366, 512 IDE_PCI_CLASS_OVERRIDE, 513 NULL, 514 hpt_chip_map, 515 }, 516 { PCI_PRODUCT_TRIONES_HPT372, 517 IDE_PCI_CLASS_OVERRIDE, 518 NULL, 519 hpt_chip_map 520 }, 521 { PCI_PRODUCT_TRIONES_HPT374, 522 IDE_PCI_CLASS_OVERRIDE, 523 NULL, 524 hpt_chip_map 525 }, 526 { 0, 527 0, 528 NULL, 529 NULL 530 } 531 }; 532 533 const struct pciide_product_desc pciide_acard_products[] = { 534 { PCI_PRODUCT_ACARD_ATP850U, 535 IDE_PCI_CLASS_OVERRIDE, 536 "Acard ATP850U Ultra33 IDE Controller", 537 acard_chip_map, 538 }, 539 { PCI_PRODUCT_ACARD_ATP860, 540 IDE_PCI_CLASS_OVERRIDE, 541 "Acard ATP860 Ultra66 IDE Controller", 542 acard_chip_map, 543 }, 544 { PCI_PRODUCT_ACARD_ATP860A, 545 IDE_PCI_CLASS_OVERRIDE, 546 "Acard ATP860-A Ultra66 IDE Controller", 547 acard_chip_map, 548 }, 549 { 0, 550 0, 551 NULL, 552 NULL 553 } 554 }; 555 556 const struct pciide_product_desc pciide_serverworks_products[] = { 557 { PCI_PRODUCT_SERVERWORKS_OSB4_IDE, 558 0, 559 "ServerWorks OSB4 IDE Controller", 560 serverworks_chip_map, 561 }, 562 { PCI_PRODUCT_SERVERWORKS_CSB5_IDE, 563 0, 564 "ServerWorks CSB5 IDE Controller", 565 serverworks_chip_map, 566 }, 567 { 0, 568 0, 569 NULL, 570 } 571 }; 572 573 const struct pciide_product_desc pciide_symphony_products[] = { 574 { PCI_PRODUCT_SYMPHONY_82C105, 575 0, 576 "Symphony Labs 82C105 IDE controller", 577 sl82c105_chip_map, 578 }, 579 { 0, 580 0, 581 NULL, 582 } 583 }; 584 585 const struct pciide_product_desc pciide_winbond_products[] = { 586 { PCI_PRODUCT_WINBOND_W83C553F_1, 587 0, 588 "Winbond W83C553F IDE controller", 589 sl82c105_chip_map, 590 }, 591 { 0, 592 0, 593 NULL, 594 } 595 }; 596 597 struct pciide_vendor_desc { 598 u_int32_t ide_vendor; 599 const struct pciide_product_desc *ide_products; 600 }; 601 602 const struct pciide_vendor_desc pciide_vendors[] = { 603 { PCI_VENDOR_INTEL, pciide_intel_products }, 604 { PCI_VENDOR_CMDTECH, pciide_cmd_products }, 605 { PCI_VENDOR_VIATECH, pciide_via_products }, 606 { PCI_VENDOR_CONTAQ, pciide_cypress_products }, 607 { PCI_VENDOR_SIS, pciide_sis_products }, 608 { PCI_VENDOR_ALI, pciide_acer_products }, 609 { PCI_VENDOR_PROMISE, pciide_promise_products }, 610 { PCI_VENDOR_AMD, pciide_amd_products }, 611 { PCI_VENDOR_OPTI, pciide_opti_products }, 612 { PCI_VENDOR_TRIONES, pciide_triones_products }, 613 { PCI_VENDOR_ACARD, pciide_acard_products }, 614 { PCI_VENDOR_SERVERWORKS, pciide_serverworks_products }, 615 { PCI_VENDOR_SYMPHONY, pciide_symphony_products }, 616 { PCI_VENDOR_WINBOND, pciide_winbond_products }, 617 { 0, NULL } 618 }; 619 620 /* options passed via the 'flags' config keyword */ 621 #define PCIIDE_OPTIONS_DMA 0x01 622 #define PCIIDE_OPTIONS_NODMA 0x02 623 624 int pciide_match __P((struct device *, struct cfdata *, void *)); 625 void pciide_attach __P((struct device *, struct device *, void *)); 626 627 struct cfattach pciide_ca = { 628 sizeof(struct pciide_softc), pciide_match, pciide_attach 629 }; 630 int pciide_chipen __P((struct pciide_softc *, struct pci_attach_args *)); 631 int pciide_mapregs_compat __P(( struct pci_attach_args *, 632 struct pciide_channel *, int, bus_size_t *, bus_size_t*)); 633 int pciide_mapregs_native __P((struct pci_attach_args *, 634 struct pciide_channel *, bus_size_t *, bus_size_t *, 635 int (*pci_intr) __P((void *)))); 636 void pciide_mapreg_dma __P((struct pciide_softc *, 637 struct pci_attach_args *)); 638 int pciide_chansetup __P((struct pciide_softc *, int, pcireg_t)); 639 void pciide_mapchan __P((struct pci_attach_args *, 640 struct pciide_channel *, pcireg_t, bus_size_t *, bus_size_t *, 641 int (*pci_intr) __P((void *)))); 642 int pciide_chan_candisable __P((struct pciide_channel *)); 643 void pciide_map_compat_intr __P(( struct pci_attach_args *, 644 struct pciide_channel *, int, int)); 645 int pciide_compat_intr __P((void *)); 646 int pciide_pci_intr __P((void *)); 647 const struct pciide_product_desc* pciide_lookup_product __P((u_int32_t)); 648 649 const struct pciide_product_desc * 650 pciide_lookup_product(id) 651 u_int32_t id; 652 { 653 const struct pciide_product_desc *pp; 654 const struct pciide_vendor_desc *vp; 655 656 for (vp = pciide_vendors; vp->ide_products != NULL; vp++) 657 if (PCI_VENDOR(id) == vp->ide_vendor) 658 break; 659 660 if ((pp = vp->ide_products) == NULL) 661 return NULL; 662 663 for (; pp->chip_map != NULL; pp++) 664 if (PCI_PRODUCT(id) == pp->ide_product) 665 break; 666 667 if (pp->chip_map == NULL) 668 return NULL; 669 return pp; 670 } 671 672 int 673 pciide_match(parent, match, aux) 674 struct device *parent; 675 struct cfdata *match; 676 void *aux; 677 { 678 struct pci_attach_args *pa = aux; 679 const struct pciide_product_desc *pp; 680 681 /* 682 * Check the ID register to see that it's a PCI IDE controller. 683 * If it is, we assume that we can deal with it; it _should_ 684 * work in a standardized way... 685 */ 686 if (PCI_CLASS(pa->pa_class) == PCI_CLASS_MASS_STORAGE && 687 PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_MASS_STORAGE_IDE) { 688 return (1); 689 } 690 691 /* 692 * Some controllers (e.g. promise Utra-33) don't claim to be PCI IDE 693 * controllers. Let see if we can deal with it anyway. 694 */ 695 pp = pciide_lookup_product(pa->pa_id); 696 if (pp && (pp->ide_flags & IDE_PCI_CLASS_OVERRIDE)) { 697 return (1); 698 } 699 700 return (0); 701 } 702 703 void 704 pciide_attach(parent, self, aux) 705 struct device *parent, *self; 706 void *aux; 707 { 708 struct pci_attach_args *pa = aux; 709 pci_chipset_tag_t pc = pa->pa_pc; 710 pcitag_t tag = pa->pa_tag; 711 struct pciide_softc *sc = (struct pciide_softc *)self; 712 pcireg_t csr; 713 char devinfo[256]; 714 const char *displaydev; 715 716 sc->sc_pp = pciide_lookup_product(pa->pa_id); 717 if (sc->sc_pp == NULL) { 718 sc->sc_pp = &default_product_desc; 719 pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo); 720 displaydev = devinfo; 721 } else 722 displaydev = sc->sc_pp->ide_name; 723 724 /* if displaydev == NULL, printf is done in chip-specific map */ 725 if (displaydev) 726 printf(": %s (rev. 0x%02x)\n", displaydev, 727 PCI_REVISION(pa->pa_class)); 728 729 sc->sc_pc = pa->pa_pc; 730 sc->sc_tag = pa->pa_tag; 731 #ifdef WDCDEBUG 732 if (wdcdebug_pciide_mask & DEBUG_PROBE) 733 pci_conf_print(sc->sc_pc, sc->sc_tag, NULL); 734 #endif 735 sc->sc_pp->chip_map(sc, pa); 736 737 if (sc->sc_dma_ok) { 738 csr = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG); 739 csr |= PCI_COMMAND_MASTER_ENABLE; 740 pci_conf_write(pc, tag, PCI_COMMAND_STATUS_REG, csr); 741 } 742 WDCDEBUG_PRINT(("pciide: command/status register=%x\n", 743 pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG)), DEBUG_PROBE); 744 } 745 746 /* tell wether the chip is enabled or not */ 747 int 748 pciide_chipen(sc, pa) 749 struct pciide_softc *sc; 750 struct pci_attach_args *pa; 751 { 752 pcireg_t csr; 753 if ((pa->pa_flags & PCI_FLAGS_IO_ENABLED) == 0) { 754 csr = pci_conf_read(sc->sc_pc, sc->sc_tag, 755 PCI_COMMAND_STATUS_REG); 756 printf("%s: device disabled (at %s)\n", 757 sc->sc_wdcdev.sc_dev.dv_xname, 758 (csr & PCI_COMMAND_IO_ENABLE) == 0 ? 759 "device" : "bridge"); 760 return 0; 761 } 762 return 1; 763 } 764 765 int 766 pciide_mapregs_compat(pa, cp, compatchan, cmdsizep, ctlsizep) 767 struct pci_attach_args *pa; 768 struct pciide_channel *cp; 769 int compatchan; 770 bus_size_t *cmdsizep, *ctlsizep; 771 { 772 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 773 struct channel_softc *wdc_cp = &cp->wdc_channel; 774 775 cp->compat = 1; 776 *cmdsizep = PCIIDE_COMPAT_CMD_SIZE; 777 *ctlsizep = PCIIDE_COMPAT_CTL_SIZE; 778 779 wdc_cp->cmd_iot = pa->pa_iot; 780 if (bus_space_map(wdc_cp->cmd_iot, PCIIDE_COMPAT_CMD_BASE(compatchan), 781 PCIIDE_COMPAT_CMD_SIZE, 0, &wdc_cp->cmd_ioh) != 0) { 782 printf("%s: couldn't map %s channel cmd regs\n", 783 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 784 return (0); 785 } 786 787 wdc_cp->ctl_iot = pa->pa_iot; 788 if (bus_space_map(wdc_cp->ctl_iot, PCIIDE_COMPAT_CTL_BASE(compatchan), 789 PCIIDE_COMPAT_CTL_SIZE, 0, &wdc_cp->ctl_ioh) != 0) { 790 printf("%s: couldn't map %s channel ctl regs\n", 791 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 792 bus_space_unmap(wdc_cp->cmd_iot, wdc_cp->cmd_ioh, 793 PCIIDE_COMPAT_CMD_SIZE); 794 return (0); 795 } 796 797 return (1); 798 } 799 800 int 801 pciide_mapregs_native(pa, cp, cmdsizep, ctlsizep, pci_intr) 802 struct pci_attach_args * pa; 803 struct pciide_channel *cp; 804 bus_size_t *cmdsizep, *ctlsizep; 805 int (*pci_intr) __P((void *)); 806 { 807 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 808 struct channel_softc *wdc_cp = &cp->wdc_channel; 809 const char *intrstr; 810 pci_intr_handle_t intrhandle; 811 812 cp->compat = 0; 813 814 if (sc->sc_pci_ih == NULL) { 815 if (pci_intr_map(pa, &intrhandle) != 0) { 816 printf("%s: couldn't map native-PCI interrupt\n", 817 sc->sc_wdcdev.sc_dev.dv_xname); 818 return 0; 819 } 820 intrstr = pci_intr_string(pa->pa_pc, intrhandle); 821 sc->sc_pci_ih = pci_intr_establish(pa->pa_pc, 822 intrhandle, IPL_BIO, pci_intr, sc); 823 if (sc->sc_pci_ih != NULL) { 824 printf("%s: using %s for native-PCI interrupt\n", 825 sc->sc_wdcdev.sc_dev.dv_xname, 826 intrstr ? intrstr : "unknown interrupt"); 827 } else { 828 printf("%s: couldn't establish native-PCI interrupt", 829 sc->sc_wdcdev.sc_dev.dv_xname); 830 if (intrstr != NULL) 831 printf(" at %s", intrstr); 832 printf("\n"); 833 return 0; 834 } 835 } 836 cp->ih = sc->sc_pci_ih; 837 if (pci_mapreg_map(pa, PCIIDE_REG_CMD_BASE(wdc_cp->channel), 838 PCI_MAPREG_TYPE_IO, 0, 839 &wdc_cp->cmd_iot, &wdc_cp->cmd_ioh, NULL, cmdsizep) != 0) { 840 printf("%s: couldn't map %s channel cmd regs\n", 841 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 842 return 0; 843 } 844 845 if (pci_mapreg_map(pa, PCIIDE_REG_CTL_BASE(wdc_cp->channel), 846 PCI_MAPREG_TYPE_IO, 0, 847 &wdc_cp->ctl_iot, &cp->ctl_baseioh, NULL, ctlsizep) != 0) { 848 printf("%s: couldn't map %s channel ctl regs\n", 849 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 850 bus_space_unmap(wdc_cp->cmd_iot, wdc_cp->cmd_ioh, *cmdsizep); 851 return 0; 852 } 853 /* 854 * In native mode, 4 bytes of I/O space are mapped for the control 855 * register, the control register is at offset 2. Pass the generic 856 * code a handle for only one byte at the rigth offset. 857 */ 858 if (bus_space_subregion(wdc_cp->ctl_iot, cp->ctl_baseioh, 2, 1, 859 &wdc_cp->ctl_ioh) != 0) { 860 printf("%s: unable to subregion %s channel ctl regs\n", 861 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 862 bus_space_unmap(wdc_cp->cmd_iot, wdc_cp->cmd_ioh, *cmdsizep); 863 bus_space_unmap(wdc_cp->cmd_iot, cp->ctl_baseioh, *ctlsizep); 864 return 0; 865 } 866 return (1); 867 } 868 869 void 870 pciide_mapreg_dma(sc, pa) 871 struct pciide_softc *sc; 872 struct pci_attach_args *pa; 873 { 874 pcireg_t maptype; 875 bus_addr_t addr; 876 877 /* 878 * Map DMA registers 879 * 880 * Note that sc_dma_ok is the right variable to test to see if 881 * DMA can be done. If the interface doesn't support DMA, 882 * sc_dma_ok will never be non-zero. If the DMA regs couldn't 883 * be mapped, it'll be zero. I.e., sc_dma_ok will only be 884 * non-zero if the interface supports DMA and the registers 885 * could be mapped. 886 * 887 * XXX Note that despite the fact that the Bus Master IDE specs 888 * XXX say that "The bus master IDE function uses 16 bytes of IO 889 * XXX space," some controllers (at least the United 890 * XXX Microelectronics UM8886BF) place it in memory space. 891 */ 892 maptype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, 893 PCIIDE_REG_BUS_MASTER_DMA); 894 895 switch (maptype) { 896 case PCI_MAPREG_TYPE_IO: 897 sc->sc_dma_ok = (pci_mapreg_info(pa->pa_pc, pa->pa_tag, 898 PCIIDE_REG_BUS_MASTER_DMA, PCI_MAPREG_TYPE_IO, 899 &addr, NULL, NULL) == 0); 900 if (sc->sc_dma_ok == 0) { 901 printf(", but unused (couldn't query registers)"); 902 break; 903 } 904 if ((sc->sc_pp->ide_flags & IDE_16BIT_IOSPACE) 905 && addr >= 0x10000) { 906 sc->sc_dma_ok = 0; 907 printf(", but unused (registers at unsafe address " 908 "%#lx)", (unsigned long)addr); 909 break; 910 } 911 /* FALLTHROUGH */ 912 913 case PCI_MAPREG_MEM_TYPE_32BIT: 914 sc->sc_dma_ok = (pci_mapreg_map(pa, 915 PCIIDE_REG_BUS_MASTER_DMA, maptype, 0, 916 &sc->sc_dma_iot, &sc->sc_dma_ioh, NULL, NULL) == 0); 917 sc->sc_dmat = pa->pa_dmat; 918 if (sc->sc_dma_ok == 0) { 919 printf(", but unused (couldn't map registers)"); 920 } else { 921 sc->sc_wdcdev.dma_arg = sc; 922 sc->sc_wdcdev.dma_init = pciide_dma_init; 923 sc->sc_wdcdev.dma_start = pciide_dma_start; 924 sc->sc_wdcdev.dma_finish = pciide_dma_finish; 925 } 926 927 if (sc->sc_wdcdev.sc_dev.dv_cfdata->cf_flags & 928 PCIIDE_OPTIONS_NODMA) { 929 printf(", but unused (forced off by config file)"); 930 sc->sc_dma_ok = 0; 931 } 932 break; 933 934 default: 935 sc->sc_dma_ok = 0; 936 printf(", but unsupported register maptype (0x%x)", maptype); 937 } 938 } 939 940 int 941 pciide_compat_intr(arg) 942 void *arg; 943 { 944 struct pciide_channel *cp = arg; 945 946 #ifdef DIAGNOSTIC 947 /* should only be called for a compat channel */ 948 if (cp->compat == 0) 949 panic("pciide compat intr called for non-compat chan %p\n", cp); 950 #endif 951 return (wdcintr(&cp->wdc_channel)); 952 } 953 954 int 955 pciide_pci_intr(arg) 956 void *arg; 957 { 958 struct pciide_softc *sc = arg; 959 struct pciide_channel *cp; 960 struct channel_softc *wdc_cp; 961 int i, rv, crv; 962 963 rv = 0; 964 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 965 cp = &sc->pciide_channels[i]; 966 wdc_cp = &cp->wdc_channel; 967 968 /* If a compat channel skip. */ 969 if (cp->compat) 970 continue; 971 /* if this channel not waiting for intr, skip */ 972 if ((wdc_cp->ch_flags & WDCF_IRQ_WAIT) == 0) 973 continue; 974 975 crv = wdcintr(wdc_cp); 976 if (crv == 0) 977 ; /* leave rv alone */ 978 else if (crv == 1) 979 rv = 1; /* claim the intr */ 980 else if (rv == 0) /* crv should be -1 in this case */ 981 rv = crv; /* if we've done no better, take it */ 982 } 983 return (rv); 984 } 985 986 void 987 pciide_channel_dma_setup(cp) 988 struct pciide_channel *cp; 989 { 990 int drive; 991 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 992 struct ata_drive_datas *drvp; 993 994 for (drive = 0; drive < 2; drive++) { 995 drvp = &cp->wdc_channel.ch_drive[drive]; 996 /* If no drive, skip */ 997 if ((drvp->drive_flags & DRIVE) == 0) 998 continue; 999 /* setup DMA if needed */ 1000 if (((drvp->drive_flags & DRIVE_DMA) == 0 && 1001 (drvp->drive_flags & DRIVE_UDMA) == 0) || 1002 sc->sc_dma_ok == 0) { 1003 drvp->drive_flags &= ~(DRIVE_DMA | DRIVE_UDMA); 1004 continue; 1005 } 1006 if (pciide_dma_table_setup(sc, cp->wdc_channel.channel, drive) 1007 != 0) { 1008 /* Abort DMA setup */ 1009 drvp->drive_flags &= ~(DRIVE_DMA | DRIVE_UDMA); 1010 continue; 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 /* If table was already allocated, just return */ 1028 if (dma_maps->dma_table) 1029 return 0; 1030 1031 /* Allocate memory for the DMA tables and map it */ 1032 if ((error = bus_dmamem_alloc(sc->sc_dmat, dma_table_size, 1033 IDEDMA_TBL_ALIGN, IDEDMA_TBL_ALIGN, &seg, 1, &rseg, 1034 BUS_DMA_NOWAIT)) != 0) { 1035 printf("%s:%d: unable to allocate table DMA for " 1036 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1037 channel, drive, error); 1038 return error; 1039 } 1040 if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, 1041 dma_table_size, 1042 (caddr_t *)&dma_maps->dma_table, 1043 BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) { 1044 printf("%s:%d: unable to map table DMA for" 1045 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1046 channel, drive, error); 1047 return error; 1048 } 1049 WDCDEBUG_PRINT(("pciide_dma_table_setup: table at %p len %lu, " 1050 "phy 0x%lx\n", dma_maps->dma_table, (u_long)dma_table_size, 1051 (unsigned long)seg.ds_addr), DEBUG_PROBE); 1052 1053 /* Create and load table DMA map for this disk */ 1054 if ((error = bus_dmamap_create(sc->sc_dmat, dma_table_size, 1055 1, dma_table_size, IDEDMA_TBL_ALIGN, BUS_DMA_NOWAIT, 1056 &dma_maps->dmamap_table)) != 0) { 1057 printf("%s:%d: unable to create table DMA map for " 1058 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1059 channel, drive, error); 1060 return error; 1061 } 1062 if ((error = bus_dmamap_load(sc->sc_dmat, 1063 dma_maps->dmamap_table, 1064 dma_maps->dma_table, 1065 dma_table_size, NULL, BUS_DMA_NOWAIT)) != 0) { 1066 printf("%s:%d: unable to load table DMA map for " 1067 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1068 channel, drive, error); 1069 return error; 1070 } 1071 WDCDEBUG_PRINT(("pciide_dma_table_setup: phy addr of table 0x%lx\n", 1072 (unsigned long)dma_maps->dmamap_table->dm_segs[0].ds_addr), 1073 DEBUG_PROBE); 1074 /* Create a xfer DMA map for this drive */ 1075 if ((error = bus_dmamap_create(sc->sc_dmat, IDEDMA_BYTE_COUNT_MAX, 1076 NIDEDMA_TABLES, IDEDMA_BYTE_COUNT_MAX, IDEDMA_BYTE_COUNT_ALIGN, 1077 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, 1078 &dma_maps->dmamap_xfer)) != 0) { 1079 printf("%s:%d: unable to create xfer DMA map for " 1080 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1081 channel, drive, error); 1082 return error; 1083 } 1084 return 0; 1085 } 1086 1087 int 1088 pciide_dma_init(v, channel, drive, databuf, datalen, flags) 1089 void *v; 1090 int channel, drive; 1091 void *databuf; 1092 size_t datalen; 1093 int flags; 1094 { 1095 struct pciide_softc *sc = v; 1096 int error, seg; 1097 struct pciide_dma_maps *dma_maps = 1098 &sc->pciide_channels[channel].dma_maps[drive]; 1099 1100 error = bus_dmamap_load(sc->sc_dmat, 1101 dma_maps->dmamap_xfer, 1102 databuf, datalen, NULL, BUS_DMA_NOWAIT | BUS_DMA_STREAMING | 1103 ((flags & WDC_DMA_READ) ? BUS_DMA_READ : BUS_DMA_WRITE)); 1104 if (error) { 1105 printf("%s:%d: unable to load xfer DMA map for" 1106 "drive %d, error=%d\n", sc->sc_wdcdev.sc_dev.dv_xname, 1107 channel, drive, error); 1108 return error; 1109 } 1110 1111 bus_dmamap_sync(sc->sc_dmat, dma_maps->dmamap_xfer, 0, 1112 dma_maps->dmamap_xfer->dm_mapsize, 1113 (flags & WDC_DMA_READ) ? 1114 BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); 1115 1116 for (seg = 0; seg < dma_maps->dmamap_xfer->dm_nsegs; seg++) { 1117 #ifdef DIAGNOSTIC 1118 /* A segment must not cross a 64k boundary */ 1119 { 1120 u_long phys = dma_maps->dmamap_xfer->dm_segs[seg].ds_addr; 1121 u_long len = dma_maps->dmamap_xfer->dm_segs[seg].ds_len; 1122 if ((phys & ~IDEDMA_BYTE_COUNT_MASK) != 1123 ((phys + len - 1) & ~IDEDMA_BYTE_COUNT_MASK)) { 1124 printf("pciide_dma: segment %d physical addr 0x%lx" 1125 " len 0x%lx not properly aligned\n", 1126 seg, phys, len); 1127 panic("pciide_dma: buf align"); 1128 } 1129 } 1130 #endif 1131 dma_maps->dma_table[seg].base_addr = 1132 htole32(dma_maps->dmamap_xfer->dm_segs[seg].ds_addr); 1133 dma_maps->dma_table[seg].byte_count = 1134 htole32(dma_maps->dmamap_xfer->dm_segs[seg].ds_len & 1135 IDEDMA_BYTE_COUNT_MASK); 1136 WDCDEBUG_PRINT(("\t seg %d len %d addr 0x%x\n", 1137 seg, le32toh(dma_maps->dma_table[seg].byte_count), 1138 le32toh(dma_maps->dma_table[seg].base_addr)), DEBUG_DMA); 1139 1140 } 1141 dma_maps->dma_table[dma_maps->dmamap_xfer->dm_nsegs -1].byte_count |= 1142 htole32(IDEDMA_BYTE_COUNT_EOT); 1143 1144 bus_dmamap_sync(sc->sc_dmat, dma_maps->dmamap_table, 0, 1145 dma_maps->dmamap_table->dm_mapsize, 1146 BUS_DMASYNC_PREWRITE); 1147 1148 /* Maps are ready. Start DMA function */ 1149 #ifdef DIAGNOSTIC 1150 if (dma_maps->dmamap_table->dm_segs[0].ds_addr & ~IDEDMA_TBL_MASK) { 1151 printf("pciide_dma_init: addr 0x%lx not properly aligned\n", 1152 (u_long)dma_maps->dmamap_table->dm_segs[0].ds_addr); 1153 panic("pciide_dma_init: table align"); 1154 } 1155 #endif 1156 1157 /* Clear status bits */ 1158 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1159 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel, 1160 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1161 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel)); 1162 /* Write table addr */ 1163 bus_space_write_4(sc->sc_dma_iot, sc->sc_dma_ioh, 1164 IDEDMA_TBL + IDEDMA_SCH_OFFSET * channel, 1165 dma_maps->dmamap_table->dm_segs[0].ds_addr); 1166 /* set read/write */ 1167 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1168 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel, 1169 (flags & WDC_DMA_READ) ? IDEDMA_CMD_WRITE: 0); 1170 /* remember flags */ 1171 dma_maps->dma_flags = flags; 1172 return 0; 1173 } 1174 1175 void 1176 pciide_dma_start(v, channel, drive) 1177 void *v; 1178 int channel, drive; 1179 { 1180 struct pciide_softc *sc = v; 1181 1182 WDCDEBUG_PRINT(("pciide_dma_start\n"),DEBUG_XFERS); 1183 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1184 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel, 1185 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1186 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel) | IDEDMA_CMD_START); 1187 } 1188 1189 int 1190 pciide_dma_finish(v, channel, drive, force) 1191 void *v; 1192 int channel, drive; 1193 int force; 1194 { 1195 struct pciide_softc *sc = v; 1196 u_int8_t status; 1197 int error = 0; 1198 struct pciide_dma_maps *dma_maps = 1199 &sc->pciide_channels[channel].dma_maps[drive]; 1200 1201 status = bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1202 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel); 1203 WDCDEBUG_PRINT(("pciide_dma_finish: status 0x%x\n", status), 1204 DEBUG_XFERS); 1205 1206 if (force == 0 && (status & IDEDMA_CTL_INTR) == 0) 1207 return WDC_DMAST_NOIRQ; 1208 1209 /* stop DMA channel */ 1210 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1211 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel, 1212 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1213 IDEDMA_CMD + IDEDMA_SCH_OFFSET * channel) & ~IDEDMA_CMD_START); 1214 1215 /* Unload the map of the data buffer */ 1216 bus_dmamap_sync(sc->sc_dmat, dma_maps->dmamap_xfer, 0, 1217 dma_maps->dmamap_xfer->dm_mapsize, 1218 (dma_maps->dma_flags & WDC_DMA_READ) ? 1219 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); 1220 bus_dmamap_unload(sc->sc_dmat, dma_maps->dmamap_xfer); 1221 1222 if ((status & IDEDMA_CTL_ERR) != 0) { 1223 printf("%s:%d:%d: bus-master DMA error: status=0x%x\n", 1224 sc->sc_wdcdev.sc_dev.dv_xname, channel, drive, status); 1225 error |= WDC_DMAST_ERR; 1226 } 1227 1228 if ((status & IDEDMA_CTL_INTR) == 0) { 1229 printf("%s:%d:%d: bus-master DMA error: missing interrupt, " 1230 "status=0x%x\n", sc->sc_wdcdev.sc_dev.dv_xname, channel, 1231 drive, status); 1232 error |= WDC_DMAST_NOIRQ; 1233 } 1234 1235 if ((status & IDEDMA_CTL_ACT) != 0) { 1236 /* data underrun, may be a valid condition for ATAPI */ 1237 error |= WDC_DMAST_UNDER; 1238 } 1239 return error; 1240 } 1241 1242 void 1243 pciide_irqack(chp) 1244 struct channel_softc *chp; 1245 { 1246 struct pciide_channel *cp = (struct pciide_channel*)chp; 1247 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 1248 1249 /* clear status bits in IDE DMA registers */ 1250 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1251 IDEDMA_CTL + IDEDMA_SCH_OFFSET * chp->channel, 1252 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1253 IDEDMA_CTL + IDEDMA_SCH_OFFSET * chp->channel)); 1254 } 1255 1256 /* some common code used by several chip_map */ 1257 int 1258 pciide_chansetup(sc, channel, interface) 1259 struct pciide_softc *sc; 1260 int channel; 1261 pcireg_t interface; 1262 { 1263 struct pciide_channel *cp = &sc->pciide_channels[channel]; 1264 sc->wdc_chanarray[channel] = &cp->wdc_channel; 1265 cp->name = PCIIDE_CHANNEL_NAME(channel); 1266 cp->wdc_channel.channel = channel; 1267 cp->wdc_channel.wdc = &sc->sc_wdcdev; 1268 cp->wdc_channel.ch_queue = 1269 malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT); 1270 if (cp->wdc_channel.ch_queue == NULL) { 1271 printf("%s %s channel: " 1272 "can't allocate memory for command queue", 1273 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 1274 return 0; 1275 } 1276 printf("%s: %s channel %s to %s mode\n", 1277 sc->sc_wdcdev.sc_dev.dv_xname, cp->name, 1278 (interface & PCIIDE_INTERFACE_SETTABLE(channel)) ? 1279 "configured" : "wired", 1280 (interface & PCIIDE_INTERFACE_PCI(channel)) ? 1281 "native-PCI" : "compatibility"); 1282 return 1; 1283 } 1284 1285 /* some common code used by several chip channel_map */ 1286 void 1287 pciide_mapchan(pa, cp, interface, cmdsizep, ctlsizep, pci_intr) 1288 struct pci_attach_args *pa; 1289 struct pciide_channel *cp; 1290 pcireg_t interface; 1291 bus_size_t *cmdsizep, *ctlsizep; 1292 int (*pci_intr) __P((void *)); 1293 { 1294 struct channel_softc *wdc_cp = &cp->wdc_channel; 1295 1296 if (interface & PCIIDE_INTERFACE_PCI(wdc_cp->channel)) 1297 cp->hw_ok = pciide_mapregs_native(pa, cp, cmdsizep, ctlsizep, 1298 pci_intr); 1299 else 1300 cp->hw_ok = pciide_mapregs_compat(pa, cp, 1301 wdc_cp->channel, cmdsizep, ctlsizep); 1302 1303 if (cp->hw_ok == 0) 1304 return; 1305 wdc_cp->data32iot = wdc_cp->cmd_iot; 1306 wdc_cp->data32ioh = wdc_cp->cmd_ioh; 1307 wdcattach(wdc_cp); 1308 } 1309 1310 /* 1311 * Generic code to call to know if a channel can be disabled. Return 1 1312 * if channel can be disabled, 0 if not 1313 */ 1314 int 1315 pciide_chan_candisable(cp) 1316 struct pciide_channel *cp; 1317 { 1318 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 1319 struct channel_softc *wdc_cp = &cp->wdc_channel; 1320 1321 if ((wdc_cp->ch_drive[0].drive_flags & DRIVE) == 0 && 1322 (wdc_cp->ch_drive[1].drive_flags & DRIVE) == 0) { 1323 printf("%s: disabling %s channel (no drives)\n", 1324 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 1325 cp->hw_ok = 0; 1326 return 1; 1327 } 1328 return 0; 1329 } 1330 1331 /* 1332 * generic code to map the compat intr if hw_ok=1 and it is a compat channel. 1333 * Set hw_ok=0 on failure 1334 */ 1335 void 1336 pciide_map_compat_intr(pa, cp, compatchan, interface) 1337 struct pci_attach_args *pa; 1338 struct pciide_channel *cp; 1339 int compatchan, interface; 1340 { 1341 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 1342 struct channel_softc *wdc_cp = &cp->wdc_channel; 1343 1344 if (cp->hw_ok == 0) 1345 return; 1346 if ((interface & PCIIDE_INTERFACE_PCI(wdc_cp->channel)) != 0) 1347 return; 1348 1349 #ifdef __HAVE_PCIIDE_MACHDEP_COMPAT_INTR_ESTABLISH 1350 cp->ih = pciide_machdep_compat_intr_establish(&sc->sc_wdcdev.sc_dev, 1351 pa, compatchan, pciide_compat_intr, cp); 1352 if (cp->ih == NULL) { 1353 #endif 1354 printf("%s: no compatibility interrupt for use by %s " 1355 "channel\n", sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 1356 cp->hw_ok = 0; 1357 #ifdef __HAVE_PCIIDE_MACHDEP_COMPAT_INTR_ESTABLISH 1358 } 1359 #endif 1360 } 1361 1362 void 1363 pciide_print_modes(cp) 1364 struct pciide_channel *cp; 1365 { 1366 wdc_print_modes(&cp->wdc_channel); 1367 } 1368 1369 void 1370 default_chip_map(sc, pa) 1371 struct pciide_softc *sc; 1372 struct pci_attach_args *pa; 1373 { 1374 struct pciide_channel *cp; 1375 pcireg_t interface = PCI_INTERFACE(pa->pa_class); 1376 pcireg_t csr; 1377 int channel, drive; 1378 struct ata_drive_datas *drvp; 1379 u_int8_t idedma_ctl; 1380 bus_size_t cmdsize, ctlsize; 1381 char *failreason; 1382 1383 if (pciide_chipen(sc, pa) == 0) 1384 return; 1385 1386 if (interface & PCIIDE_INTERFACE_BUS_MASTER_DMA) { 1387 printf("%s: bus-master DMA support present", 1388 sc->sc_wdcdev.sc_dev.dv_xname); 1389 if (sc->sc_pp == &default_product_desc && 1390 (sc->sc_wdcdev.sc_dev.dv_cfdata->cf_flags & 1391 PCIIDE_OPTIONS_DMA) == 0) { 1392 printf(", but unused (no driver support)"); 1393 sc->sc_dma_ok = 0; 1394 } else { 1395 pciide_mapreg_dma(sc, pa); 1396 if (sc->sc_dma_ok != 0) 1397 printf(", used without full driver " 1398 "support"); 1399 } 1400 } else { 1401 printf("%s: hardware does not support DMA", 1402 sc->sc_wdcdev.sc_dev.dv_xname); 1403 sc->sc_dma_ok = 0; 1404 } 1405 printf("\n"); 1406 if (sc->sc_dma_ok) { 1407 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 1408 sc->sc_wdcdev.irqack = pciide_irqack; 1409 } 1410 sc->sc_wdcdev.PIO_cap = 0; 1411 sc->sc_wdcdev.DMA_cap = 0; 1412 1413 sc->sc_wdcdev.channels = sc->wdc_chanarray; 1414 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 1415 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DATA16; 1416 1417 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 1418 cp = &sc->pciide_channels[channel]; 1419 if (pciide_chansetup(sc, channel, interface) == 0) 1420 continue; 1421 if (interface & PCIIDE_INTERFACE_PCI(channel)) { 1422 cp->hw_ok = pciide_mapregs_native(pa, cp, &cmdsize, 1423 &ctlsize, pciide_pci_intr); 1424 } else { 1425 cp->hw_ok = pciide_mapregs_compat(pa, cp, 1426 channel, &cmdsize, &ctlsize); 1427 } 1428 if (cp->hw_ok == 0) 1429 continue; 1430 /* 1431 * Check to see if something appears to be there. 1432 */ 1433 failreason = NULL; 1434 if (!wdcprobe(&cp->wdc_channel)) { 1435 failreason = "not responding; disabled or no drives?"; 1436 goto next; 1437 } 1438 /* 1439 * Now, make sure it's actually attributable to this PCI IDE 1440 * channel by trying to access the channel again while the 1441 * PCI IDE controller's I/O space is disabled. (If the 1442 * channel no longer appears to be there, it belongs to 1443 * this controller.) YUCK! 1444 */ 1445 csr = pci_conf_read(sc->sc_pc, sc->sc_tag, 1446 PCI_COMMAND_STATUS_REG); 1447 pci_conf_write(sc->sc_pc, sc->sc_tag, PCI_COMMAND_STATUS_REG, 1448 csr & ~PCI_COMMAND_IO_ENABLE); 1449 if (wdcprobe(&cp->wdc_channel)) 1450 failreason = "other hardware responding at addresses"; 1451 pci_conf_write(sc->sc_pc, sc->sc_tag, 1452 PCI_COMMAND_STATUS_REG, csr); 1453 next: 1454 if (failreason) { 1455 printf("%s: %s channel ignored (%s)\n", 1456 sc->sc_wdcdev.sc_dev.dv_xname, cp->name, 1457 failreason); 1458 cp->hw_ok = 0; 1459 bus_space_unmap(cp->wdc_channel.cmd_iot, 1460 cp->wdc_channel.cmd_ioh, cmdsize); 1461 if (interface & PCIIDE_INTERFACE_PCI(channel)) 1462 bus_space_unmap(cp->wdc_channel.ctl_iot, 1463 cp->ctl_baseioh, ctlsize); 1464 else 1465 bus_space_unmap(cp->wdc_channel.ctl_iot, 1466 cp->wdc_channel.ctl_ioh, ctlsize); 1467 } else { 1468 pciide_map_compat_intr(pa, cp, channel, interface); 1469 } 1470 if (cp->hw_ok) { 1471 cp->wdc_channel.data32iot = cp->wdc_channel.cmd_iot; 1472 cp->wdc_channel.data32ioh = cp->wdc_channel.cmd_ioh; 1473 wdcattach(&cp->wdc_channel); 1474 } 1475 } 1476 1477 if (sc->sc_dma_ok == 0) 1478 return; 1479 1480 /* Allocate DMA maps */ 1481 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 1482 idedma_ctl = 0; 1483 cp = &sc->pciide_channels[channel]; 1484 for (drive = 0; drive < 2; drive++) { 1485 drvp = &cp->wdc_channel.ch_drive[drive]; 1486 /* If no drive, skip */ 1487 if ((drvp->drive_flags & DRIVE) == 0) 1488 continue; 1489 if ((drvp->drive_flags & DRIVE_DMA) == 0) 1490 continue; 1491 if (pciide_dma_table_setup(sc, channel, drive) != 0) { 1492 /* Abort DMA setup */ 1493 printf("%s:%d:%d: can't allocate DMA maps, " 1494 "using PIO transfers\n", 1495 sc->sc_wdcdev.sc_dev.dv_xname, 1496 channel, drive); 1497 drvp->drive_flags &= ~DRIVE_DMA; 1498 } 1499 printf("%s:%d:%d: using DMA data transfers\n", 1500 sc->sc_wdcdev.sc_dev.dv_xname, 1501 channel, drive); 1502 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 1503 } 1504 if (idedma_ctl != 0) { 1505 /* Add software bits in status register */ 1506 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1507 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * channel), 1508 idedma_ctl); 1509 } 1510 } 1511 } 1512 1513 void 1514 piix_chip_map(sc, pa) 1515 struct pciide_softc *sc; 1516 struct pci_attach_args *pa; 1517 { 1518 struct pciide_channel *cp; 1519 int channel; 1520 u_int32_t idetim; 1521 bus_size_t cmdsize, ctlsize; 1522 1523 if (pciide_chipen(sc, pa) == 0) 1524 return; 1525 1526 printf("%s: bus-master DMA support present", 1527 sc->sc_wdcdev.sc_dev.dv_xname); 1528 pciide_mapreg_dma(sc, pa); 1529 printf("\n"); 1530 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 1531 WDC_CAPABILITY_MODE; 1532 if (sc->sc_dma_ok) { 1533 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 1534 sc->sc_wdcdev.irqack = pciide_irqack; 1535 switch(sc->sc_pp->ide_product) { 1536 case PCI_PRODUCT_INTEL_82371AB_IDE: 1537 case PCI_PRODUCT_INTEL_82440MX_IDE: 1538 case PCI_PRODUCT_INTEL_82801AA_IDE: 1539 case PCI_PRODUCT_INTEL_82801AB_IDE: 1540 case PCI_PRODUCT_INTEL_82801BA_IDE: 1541 case PCI_PRODUCT_INTEL_82801BAM_IDE: 1542 case PCI_PRODUCT_INTEL_82801CA_IDE_1: 1543 case PCI_PRODUCT_INTEL_82801CA_IDE_2: 1544 case PCI_PRODUCT_INTEL_82801DB_IDE: 1545 case PCI_PRODUCT_INTEL_82801EB_IDE: 1546 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 1547 } 1548 } 1549 sc->sc_wdcdev.PIO_cap = 4; 1550 sc->sc_wdcdev.DMA_cap = 2; 1551 switch(sc->sc_pp->ide_product) { 1552 case PCI_PRODUCT_INTEL_82801AA_IDE: 1553 sc->sc_wdcdev.UDMA_cap = 4; 1554 break; 1555 case PCI_PRODUCT_INTEL_82801BA_IDE: 1556 case PCI_PRODUCT_INTEL_82801BAM_IDE: 1557 case PCI_PRODUCT_INTEL_82801CA_IDE_1: 1558 case PCI_PRODUCT_INTEL_82801CA_IDE_2: 1559 case PCI_PRODUCT_INTEL_82801DB_IDE: 1560 case PCI_PRODUCT_INTEL_82801EB_IDE: 1561 sc->sc_wdcdev.UDMA_cap = 5; 1562 break; 1563 default: 1564 sc->sc_wdcdev.UDMA_cap = 2; 1565 } 1566 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82371FB_IDE) 1567 sc->sc_wdcdev.set_modes = piix_setup_channel; 1568 else 1569 sc->sc_wdcdev.set_modes = piix3_4_setup_channel; 1570 sc->sc_wdcdev.channels = sc->wdc_chanarray; 1571 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 1572 1573 WDCDEBUG_PRINT(("piix_setup_chip: old idetim=0x%x", 1574 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM)), 1575 DEBUG_PROBE); 1576 if (sc->sc_pp->ide_product != PCI_PRODUCT_INTEL_82371FB_IDE) { 1577 WDCDEBUG_PRINT((", sidetim=0x%x", 1578 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_SIDETIM)), 1579 DEBUG_PROBE); 1580 if (sc->sc_wdcdev.cap & WDC_CAPABILITY_UDMA) { 1581 WDCDEBUG_PRINT((", udamreg 0x%x", 1582 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_UDMAREG)), 1583 DEBUG_PROBE); 1584 } 1585 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AA_IDE || 1586 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AB_IDE || 1587 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BA_IDE || 1588 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BAM_IDE || 1589 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_1 || 1590 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_2 || 1591 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DB_IDE || 1592 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801EB_IDE ) { 1593 WDCDEBUG_PRINT((", IDE_CONTROL 0x%x", 1594 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_CONFIG)), 1595 DEBUG_PROBE); 1596 } 1597 1598 } 1599 WDCDEBUG_PRINT(("\n"), DEBUG_PROBE); 1600 1601 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 1602 cp = &sc->pciide_channels[channel]; 1603 /* PIIX is compat-only */ 1604 if (pciide_chansetup(sc, channel, 0) == 0) 1605 continue; 1606 idetim = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM); 1607 if ((PIIX_IDETIM_READ(idetim, channel) & 1608 PIIX_IDETIM_IDE) == 0) { 1609 printf("%s: %s channel ignored (disabled)\n", 1610 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 1611 continue; 1612 } 1613 /* PIIX are compat-only pciide devices */ 1614 pciide_mapchan(pa, cp, 0, &cmdsize, &ctlsize, pciide_pci_intr); 1615 if (cp->hw_ok == 0) 1616 continue; 1617 if (pciide_chan_candisable(cp)) { 1618 idetim = PIIX_IDETIM_CLEAR(idetim, PIIX_IDETIM_IDE, 1619 channel); 1620 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_IDETIM, 1621 idetim); 1622 } 1623 pciide_map_compat_intr(pa, cp, channel, 0); 1624 if (cp->hw_ok == 0) 1625 continue; 1626 sc->sc_wdcdev.set_modes(&cp->wdc_channel); 1627 } 1628 1629 WDCDEBUG_PRINT(("piix_setup_chip: idetim=0x%x", 1630 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM)), 1631 DEBUG_PROBE); 1632 if (sc->sc_pp->ide_product != PCI_PRODUCT_INTEL_82371FB_IDE) { 1633 WDCDEBUG_PRINT((", sidetim=0x%x", 1634 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_SIDETIM)), 1635 DEBUG_PROBE); 1636 if (sc->sc_wdcdev.cap & WDC_CAPABILITY_UDMA) { 1637 WDCDEBUG_PRINT((", udamreg 0x%x", 1638 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_UDMAREG)), 1639 DEBUG_PROBE); 1640 } 1641 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AA_IDE || 1642 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AB_IDE || 1643 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BA_IDE || 1644 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BAM_IDE || 1645 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_1 || 1646 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_2 || 1647 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DB_IDE || 1648 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801EB_IDE ) { 1649 WDCDEBUG_PRINT((", IDE_CONTROL 0x%x", 1650 pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_CONFIG)), 1651 DEBUG_PROBE); 1652 } 1653 } 1654 WDCDEBUG_PRINT(("\n"), DEBUG_PROBE); 1655 } 1656 1657 void 1658 piix_setup_channel(chp) 1659 struct channel_softc *chp; 1660 { 1661 u_int8_t mode[2], drive; 1662 u_int32_t oidetim, idetim, idedma_ctl; 1663 struct pciide_channel *cp = (struct pciide_channel*)chp; 1664 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 1665 struct ata_drive_datas *drvp = cp->wdc_channel.ch_drive; 1666 1667 oidetim = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM); 1668 idetim = PIIX_IDETIM_CLEAR(oidetim, 0xffff, chp->channel); 1669 idedma_ctl = 0; 1670 1671 /* set up new idetim: Enable IDE registers decode */ 1672 idetim = PIIX_IDETIM_SET(idetim, PIIX_IDETIM_IDE, 1673 chp->channel); 1674 1675 /* setup DMA */ 1676 pciide_channel_dma_setup(cp); 1677 1678 /* 1679 * Here we have to mess up with drives mode: PIIX can't have 1680 * different timings for master and slave drives. 1681 * We need to find the best combination. 1682 */ 1683 1684 /* If both drives supports DMA, take the lower mode */ 1685 if ((drvp[0].drive_flags & DRIVE_DMA) && 1686 (drvp[1].drive_flags & DRIVE_DMA)) { 1687 mode[0] = mode[1] = 1688 min(drvp[0].DMA_mode, drvp[1].DMA_mode); 1689 drvp[0].DMA_mode = mode[0]; 1690 drvp[1].DMA_mode = mode[1]; 1691 goto ok; 1692 } 1693 /* 1694 * If only one drive supports DMA, use its mode, and 1695 * put the other one in PIO mode 0 if mode not compatible 1696 */ 1697 if (drvp[0].drive_flags & DRIVE_DMA) { 1698 mode[0] = drvp[0].DMA_mode; 1699 mode[1] = drvp[1].PIO_mode; 1700 if (piix_isp_pio[mode[1]] != piix_isp_dma[mode[0]] || 1701 piix_rtc_pio[mode[1]] != piix_rtc_dma[mode[0]]) 1702 mode[1] = drvp[1].PIO_mode = 0; 1703 goto ok; 1704 } 1705 if (drvp[1].drive_flags & DRIVE_DMA) { 1706 mode[1] = drvp[1].DMA_mode; 1707 mode[0] = drvp[0].PIO_mode; 1708 if (piix_isp_pio[mode[0]] != piix_isp_dma[mode[1]] || 1709 piix_rtc_pio[mode[0]] != piix_rtc_dma[mode[1]]) 1710 mode[0] = drvp[0].PIO_mode = 0; 1711 goto ok; 1712 } 1713 /* 1714 * If both drives are not DMA, takes the lower mode, unless 1715 * one of them is PIO mode < 2 1716 */ 1717 if (drvp[0].PIO_mode < 2) { 1718 mode[0] = drvp[0].PIO_mode = 0; 1719 mode[1] = drvp[1].PIO_mode; 1720 } else if (drvp[1].PIO_mode < 2) { 1721 mode[1] = drvp[1].PIO_mode = 0; 1722 mode[0] = drvp[0].PIO_mode; 1723 } else { 1724 mode[0] = mode[1] = 1725 min(drvp[1].PIO_mode, drvp[0].PIO_mode); 1726 drvp[0].PIO_mode = mode[0]; 1727 drvp[1].PIO_mode = mode[1]; 1728 } 1729 ok: /* The modes are setup */ 1730 for (drive = 0; drive < 2; drive++) { 1731 if (drvp[drive].drive_flags & DRIVE_DMA) { 1732 idetim |= piix_setup_idetim_timings( 1733 mode[drive], 1, chp->channel); 1734 goto end; 1735 } 1736 } 1737 /* If we are there, none of the drives are DMA */ 1738 if (mode[0] >= 2) 1739 idetim |= piix_setup_idetim_timings( 1740 mode[0], 0, chp->channel); 1741 else 1742 idetim |= piix_setup_idetim_timings( 1743 mode[1], 0, chp->channel); 1744 end: /* 1745 * timing mode is now set up in the controller. Enable 1746 * it per-drive 1747 */ 1748 for (drive = 0; drive < 2; drive++) { 1749 /* If no drive, skip */ 1750 if ((drvp[drive].drive_flags & DRIVE) == 0) 1751 continue; 1752 idetim |= piix_setup_idetim_drvs(&drvp[drive]); 1753 if (drvp[drive].drive_flags & DRIVE_DMA) 1754 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 1755 } 1756 if (idedma_ctl != 0) { 1757 /* Add software bits in status register */ 1758 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1759 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * chp->channel), 1760 idedma_ctl); 1761 } 1762 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_IDETIM, idetim); 1763 pciide_print_modes(cp); 1764 } 1765 1766 void 1767 piix3_4_setup_channel(chp) 1768 struct channel_softc *chp; 1769 { 1770 struct ata_drive_datas *drvp; 1771 u_int32_t oidetim, idetim, sidetim, udmareg, ideconf, idedma_ctl; 1772 struct pciide_channel *cp = (struct pciide_channel*)chp; 1773 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 1774 int drive; 1775 int channel = chp->channel; 1776 1777 oidetim = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_IDETIM); 1778 sidetim = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_SIDETIM); 1779 udmareg = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_UDMAREG); 1780 ideconf = pci_conf_read(sc->sc_pc, sc->sc_tag, PIIX_CONFIG); 1781 idetim = PIIX_IDETIM_CLEAR(oidetim, 0xffff, channel); 1782 sidetim &= ~(PIIX_SIDETIM_ISP_MASK(channel) | 1783 PIIX_SIDETIM_RTC_MASK(channel)); 1784 1785 idedma_ctl = 0; 1786 /* If channel disabled, no need to go further */ 1787 if ((PIIX_IDETIM_READ(oidetim, channel) & PIIX_IDETIM_IDE) == 0) 1788 return; 1789 /* set up new idetim: Enable IDE registers decode */ 1790 idetim = PIIX_IDETIM_SET(idetim, PIIX_IDETIM_IDE, channel); 1791 1792 /* setup DMA if needed */ 1793 pciide_channel_dma_setup(cp); 1794 1795 for (drive = 0; drive < 2; drive++) { 1796 udmareg &= ~(PIIX_UDMACTL_DRV_EN(channel, drive) | 1797 PIIX_UDMATIM_SET(0x3, channel, drive)); 1798 drvp = &chp->ch_drive[drive]; 1799 /* If no drive, skip */ 1800 if ((drvp->drive_flags & DRIVE) == 0) 1801 continue; 1802 if (((drvp->drive_flags & DRIVE_DMA) == 0 && 1803 (drvp->drive_flags & DRIVE_UDMA) == 0)) 1804 goto pio; 1805 1806 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AA_IDE || 1807 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AB_IDE || 1808 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BA_IDE || 1809 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BAM_IDE || 1810 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_1 || 1811 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_2 || 1812 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DB_IDE || 1813 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801EB_IDE) { 1814 ideconf |= PIIX_CONFIG_PINGPONG; 1815 } 1816 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BA_IDE || 1817 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801BAM_IDE || 1818 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_1 || 1819 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801CA_IDE_2 || 1820 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801DB_IDE || 1821 sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801EB_IDE) { 1822 /* setup Ultra/100 */ 1823 if (drvp->UDMA_mode > 2 && 1824 (ideconf & PIIX_CONFIG_CR(channel, drive)) == 0) 1825 drvp->UDMA_mode = 2; 1826 if (drvp->UDMA_mode > 4) { 1827 ideconf |= PIIX_CONFIG_UDMA100(channel, drive); 1828 } else { 1829 ideconf &= ~PIIX_CONFIG_UDMA100(channel, drive); 1830 if (drvp->UDMA_mode > 2) { 1831 ideconf |= PIIX_CONFIG_UDMA66(channel, 1832 drive); 1833 } else { 1834 ideconf &= ~PIIX_CONFIG_UDMA66(channel, 1835 drive); 1836 } 1837 } 1838 } 1839 if (sc->sc_pp->ide_product == PCI_PRODUCT_INTEL_82801AA_IDE) { 1840 /* setup Ultra/66 */ 1841 if (drvp->UDMA_mode > 2 && 1842 (ideconf & PIIX_CONFIG_CR(channel, drive)) == 0) 1843 drvp->UDMA_mode = 2; 1844 if (drvp->UDMA_mode > 2) 1845 ideconf |= PIIX_CONFIG_UDMA66(channel, drive); 1846 else 1847 ideconf &= ~PIIX_CONFIG_UDMA66(channel, drive); 1848 } 1849 if ((chp->wdc->cap & WDC_CAPABILITY_UDMA) && 1850 (drvp->drive_flags & DRIVE_UDMA)) { 1851 /* use Ultra/DMA */ 1852 drvp->drive_flags &= ~DRIVE_DMA; 1853 udmareg |= PIIX_UDMACTL_DRV_EN( channel, drive); 1854 udmareg |= PIIX_UDMATIM_SET( 1855 piix4_sct_udma[drvp->UDMA_mode], channel, drive); 1856 } else { 1857 /* use Multiword DMA */ 1858 drvp->drive_flags &= ~DRIVE_UDMA; 1859 if (drive == 0) { 1860 idetim |= piix_setup_idetim_timings( 1861 drvp->DMA_mode, 1, channel); 1862 } else { 1863 sidetim |= piix_setup_sidetim_timings( 1864 drvp->DMA_mode, 1, channel); 1865 idetim =PIIX_IDETIM_SET(idetim, 1866 PIIX_IDETIM_SITRE, channel); 1867 } 1868 } 1869 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 1870 1871 pio: /* use PIO mode */ 1872 idetim |= piix_setup_idetim_drvs(drvp); 1873 if (drive == 0) { 1874 idetim |= piix_setup_idetim_timings( 1875 drvp->PIO_mode, 0, channel); 1876 } else { 1877 sidetim |= piix_setup_sidetim_timings( 1878 drvp->PIO_mode, 0, channel); 1879 idetim =PIIX_IDETIM_SET(idetim, 1880 PIIX_IDETIM_SITRE, channel); 1881 } 1882 } 1883 if (idedma_ctl != 0) { 1884 /* Add software bits in status register */ 1885 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 1886 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * channel), 1887 idedma_ctl); 1888 } 1889 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_IDETIM, idetim); 1890 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_SIDETIM, sidetim); 1891 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_UDMAREG, udmareg); 1892 pci_conf_write(sc->sc_pc, sc->sc_tag, PIIX_CONFIG, ideconf); 1893 pciide_print_modes(cp); 1894 } 1895 1896 1897 /* setup ISP and RTC fields, based on mode */ 1898 static u_int32_t 1899 piix_setup_idetim_timings(mode, dma, channel) 1900 u_int8_t mode; 1901 u_int8_t dma; 1902 u_int8_t channel; 1903 { 1904 1905 if (dma) 1906 return PIIX_IDETIM_SET(0, 1907 PIIX_IDETIM_ISP_SET(piix_isp_dma[mode]) | 1908 PIIX_IDETIM_RTC_SET(piix_rtc_dma[mode]), 1909 channel); 1910 else 1911 return PIIX_IDETIM_SET(0, 1912 PIIX_IDETIM_ISP_SET(piix_isp_pio[mode]) | 1913 PIIX_IDETIM_RTC_SET(piix_rtc_pio[mode]), 1914 channel); 1915 } 1916 1917 /* setup DTE, PPE, IE and TIME field based on PIO mode */ 1918 static u_int32_t 1919 piix_setup_idetim_drvs(drvp) 1920 struct ata_drive_datas *drvp; 1921 { 1922 u_int32_t ret = 0; 1923 struct channel_softc *chp = drvp->chnl_softc; 1924 u_int8_t channel = chp->channel; 1925 u_int8_t drive = drvp->drive; 1926 1927 /* 1928 * If drive is using UDMA, timings setups are independant 1929 * So just check DMA and PIO here. 1930 */ 1931 if (drvp->drive_flags & DRIVE_DMA) { 1932 /* if mode = DMA mode 0, use compatible timings */ 1933 if ((drvp->drive_flags & DRIVE_DMA) && 1934 drvp->DMA_mode == 0) { 1935 drvp->PIO_mode = 0; 1936 return ret; 1937 } 1938 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_TIME(drive), channel); 1939 /* 1940 * PIO and DMA timings are the same, use fast timings for PIO 1941 * too, else use compat timings. 1942 */ 1943 if ((piix_isp_pio[drvp->PIO_mode] != 1944 piix_isp_dma[drvp->DMA_mode]) || 1945 (piix_rtc_pio[drvp->PIO_mode] != 1946 piix_rtc_dma[drvp->DMA_mode])) 1947 drvp->PIO_mode = 0; 1948 /* if PIO mode <= 2, use compat timings for PIO */ 1949 if (drvp->PIO_mode <= 2) { 1950 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_DTE(drive), 1951 channel); 1952 return ret; 1953 } 1954 } 1955 1956 /* 1957 * Now setup PIO modes. If mode < 2, use compat timings. 1958 * Else enable fast timings. Enable IORDY and prefetch/post 1959 * if PIO mode >= 3. 1960 */ 1961 1962 if (drvp->PIO_mode < 2) 1963 return ret; 1964 1965 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_TIME(drive), channel); 1966 if (drvp->PIO_mode >= 3) { 1967 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_IE(drive), channel); 1968 ret = PIIX_IDETIM_SET(ret, PIIX_IDETIM_PPE(drive), channel); 1969 } 1970 return ret; 1971 } 1972 1973 /* setup values in SIDETIM registers, based on mode */ 1974 static u_int32_t 1975 piix_setup_sidetim_timings(mode, dma, channel) 1976 u_int8_t mode; 1977 u_int8_t dma; 1978 u_int8_t channel; 1979 { 1980 if (dma) 1981 return PIIX_SIDETIM_ISP_SET(piix_isp_dma[mode], channel) | 1982 PIIX_SIDETIM_RTC_SET(piix_rtc_dma[mode], channel); 1983 else 1984 return PIIX_SIDETIM_ISP_SET(piix_isp_pio[mode], channel) | 1985 PIIX_SIDETIM_RTC_SET(piix_rtc_pio[mode], channel); 1986 } 1987 1988 void 1989 amd7x6_chip_map(sc, pa) 1990 struct pciide_softc *sc; 1991 struct pci_attach_args *pa; 1992 { 1993 struct pciide_channel *cp; 1994 pcireg_t interface = PCI_INTERFACE(pa->pa_class); 1995 int channel; 1996 pcireg_t chanenable; 1997 bus_size_t cmdsize, ctlsize; 1998 1999 if (pciide_chipen(sc, pa) == 0) 2000 return; 2001 printf("%s: bus-master DMA support present", 2002 sc->sc_wdcdev.sc_dev.dv_xname); 2003 pciide_mapreg_dma(sc, pa); 2004 printf("\n"); 2005 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 2006 WDC_CAPABILITY_MODE; 2007 if (sc->sc_dma_ok) { 2008 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_UDMA; 2009 sc->sc_wdcdev.cap |= WDC_CAPABILITY_IRQACK; 2010 sc->sc_wdcdev.irqack = pciide_irqack; 2011 } 2012 sc->sc_wdcdev.PIO_cap = 4; 2013 sc->sc_wdcdev.DMA_cap = 2; 2014 2015 switch (sc->sc_pp->ide_product) { 2016 case PCI_PRODUCT_AMD_PBC766_IDE: 2017 case PCI_PRODUCT_AMD_PBC768_IDE: 2018 sc->sc_wdcdev.UDMA_cap = 5; 2019 break; 2020 default: 2021 sc->sc_wdcdev.UDMA_cap = 4; 2022 } 2023 sc->sc_wdcdev.set_modes = amd7x6_setup_channel; 2024 sc->sc_wdcdev.channels = sc->wdc_chanarray; 2025 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 2026 chanenable = pci_conf_read(sc->sc_pc, sc->sc_tag, AMD7X6_CHANSTATUS_EN); 2027 2028 WDCDEBUG_PRINT(("amd7x6_chip_map: Channel enable=0x%x\n", chanenable), 2029 DEBUG_PROBE); 2030 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 2031 cp = &sc->pciide_channels[channel]; 2032 if (pciide_chansetup(sc, channel, interface) == 0) 2033 continue; 2034 2035 if ((chanenable & AMD7X6_CHAN_EN(channel)) == 0) { 2036 printf("%s: %s channel ignored (disabled)\n", 2037 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 2038 continue; 2039 } 2040 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 2041 pciide_pci_intr); 2042 2043 if (pciide_chan_candisable(cp)) 2044 chanenable &= ~AMD7X6_CHAN_EN(channel); 2045 pciide_map_compat_intr(pa, cp, channel, interface); 2046 if (cp->hw_ok == 0) 2047 continue; 2048 2049 amd7x6_setup_channel(&cp->wdc_channel); 2050 } 2051 pci_conf_write(sc->sc_pc, sc->sc_tag, AMD7X6_CHANSTATUS_EN, 2052 chanenable); 2053 return; 2054 } 2055 2056 void 2057 amd7x6_setup_channel(chp) 2058 struct channel_softc *chp; 2059 { 2060 u_int32_t udmatim_reg, datatim_reg; 2061 u_int8_t idedma_ctl; 2062 int mode, drive; 2063 struct ata_drive_datas *drvp; 2064 struct pciide_channel *cp = (struct pciide_channel*)chp; 2065 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 2066 #ifndef PCIIDE_AMD756_ENABLEDMA 2067 int rev = PCI_REVISION( 2068 pci_conf_read(sc->sc_pc, sc->sc_tag, PCI_CLASS_REG)); 2069 #endif 2070 2071 idedma_ctl = 0; 2072 datatim_reg = pci_conf_read(sc->sc_pc, sc->sc_tag, AMD7X6_DATATIM); 2073 udmatim_reg = pci_conf_read(sc->sc_pc, sc->sc_tag, AMD7X6_UDMA); 2074 datatim_reg &= ~AMD7X6_DATATIM_MASK(chp->channel); 2075 udmatim_reg &= ~AMD7X6_UDMA_MASK(chp->channel); 2076 2077 /* setup DMA if needed */ 2078 pciide_channel_dma_setup(cp); 2079 2080 for (drive = 0; drive < 2; drive++) { 2081 drvp = &chp->ch_drive[drive]; 2082 /* If no drive, skip */ 2083 if ((drvp->drive_flags & DRIVE) == 0) 2084 continue; 2085 /* add timing values, setup DMA if needed */ 2086 if (((drvp->drive_flags & DRIVE_DMA) == 0 && 2087 (drvp->drive_flags & DRIVE_UDMA) == 0)) { 2088 mode = drvp->PIO_mode; 2089 goto pio; 2090 } 2091 if ((chp->wdc->cap & WDC_CAPABILITY_UDMA) && 2092 (drvp->drive_flags & DRIVE_UDMA)) { 2093 /* use Ultra/DMA */ 2094 drvp->drive_flags &= ~DRIVE_DMA; 2095 udmatim_reg |= AMD7X6_UDMA_EN(chp->channel, drive) | 2096 AMD7X6_UDMA_EN_MTH(chp->channel, drive) | 2097 AMD7X6_UDMA_TIME(chp->channel, drive, 2098 amd7x6_udma_tim[drvp->UDMA_mode]); 2099 /* can use PIO timings, MW DMA unused */ 2100 mode = drvp->PIO_mode; 2101 } else { 2102 /* use Multiword DMA, but only if revision is OK */ 2103 drvp->drive_flags &= ~DRIVE_UDMA; 2104 #ifndef PCIIDE_AMD756_ENABLEDMA 2105 /* 2106 * The workaround doesn't seem to be necessary 2107 * with all drives, so it can be disabled by 2108 * PCIIDE_AMD756_ENABLEDMA. It causes a hard hang if 2109 * triggered. 2110 */ 2111 if (sc->sc_pp->ide_product == 2112 PCI_PRODUCT_AMD_PBC756_IDE && 2113 AMD756_CHIPREV_DISABLEDMA(rev)) { 2114 printf("%s:%d:%d: multi-word DMA disabled due " 2115 "to chip revision\n", 2116 sc->sc_wdcdev.sc_dev.dv_xname, 2117 chp->channel, drive); 2118 mode = drvp->PIO_mode; 2119 drvp->drive_flags &= ~DRIVE_DMA; 2120 goto pio; 2121 } 2122 #endif 2123 /* mode = min(pio, dma+2) */ 2124 if (drvp->PIO_mode <= (drvp->DMA_mode +2)) 2125 mode = drvp->PIO_mode; 2126 else 2127 mode = drvp->DMA_mode + 2; 2128 } 2129 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 2130 2131 pio: /* setup PIO mode */ 2132 if (mode <= 2) { 2133 drvp->DMA_mode = 0; 2134 drvp->PIO_mode = 0; 2135 mode = 0; 2136 } else { 2137 drvp->PIO_mode = mode; 2138 drvp->DMA_mode = mode - 2; 2139 } 2140 datatim_reg |= 2141 AMD7X6_DATATIM_PULSE(chp->channel, drive, 2142 amd7x6_pio_set[mode]) | 2143 AMD7X6_DATATIM_RECOV(chp->channel, drive, 2144 amd7x6_pio_rec[mode]); 2145 } 2146 if (idedma_ctl != 0) { 2147 /* Add software bits in status register */ 2148 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 2149 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * chp->channel), 2150 idedma_ctl); 2151 } 2152 pciide_print_modes(cp); 2153 pci_conf_write(sc->sc_pc, sc->sc_tag, AMD7X6_DATATIM, datatim_reg); 2154 pci_conf_write(sc->sc_pc, sc->sc_tag, AMD7X6_UDMA, udmatim_reg); 2155 } 2156 2157 void 2158 apollo_chip_map(sc, pa) 2159 struct pciide_softc *sc; 2160 struct pci_attach_args *pa; 2161 { 2162 struct pciide_channel *cp; 2163 pcireg_t interface = PCI_INTERFACE(pa->pa_class); 2164 int channel; 2165 u_int32_t ideconf; 2166 bus_size_t cmdsize, ctlsize; 2167 pcitag_t pcib_tag; 2168 pcireg_t pcib_id, pcib_class; 2169 2170 if (pciide_chipen(sc, pa) == 0) 2171 return; 2172 /* get a PCI tag for the ISA bridge (function 0 of the same device) */ 2173 pcib_tag = pci_make_tag(pa->pa_pc, pa->pa_bus, pa->pa_device, 0); 2174 /* and read ID and rev of the ISA bridge */ 2175 pcib_id = pci_conf_read(sc->sc_pc, pcib_tag, PCI_ID_REG); 2176 pcib_class = pci_conf_read(sc->sc_pc, pcib_tag, PCI_CLASS_REG); 2177 printf(": VIA Technologies "); 2178 switch (PCI_PRODUCT(pcib_id)) { 2179 case PCI_PRODUCT_VIATECH_VT82C586_ISA: 2180 printf("VT82C586 (Apollo VP) "); 2181 if(PCI_REVISION(pcib_class) >= 0x02) { 2182 printf("ATA33 controller\n"); 2183 sc->sc_wdcdev.UDMA_cap = 2; 2184 } else { 2185 printf("controller\n"); 2186 sc->sc_wdcdev.UDMA_cap = 0; 2187 } 2188 break; 2189 case PCI_PRODUCT_VIATECH_VT82C596A: 2190 printf("VT82C596A (Apollo Pro) "); 2191 if (PCI_REVISION(pcib_class) >= 0x12) { 2192 printf("ATA66 controller\n"); 2193 sc->sc_wdcdev.UDMA_cap = 4; 2194 } else { 2195 printf("ATA33 controller\n"); 2196 sc->sc_wdcdev.UDMA_cap = 2; 2197 } 2198 break; 2199 case PCI_PRODUCT_VIATECH_VT82C686A_ISA: 2200 printf("VT82C686A (Apollo KX133) "); 2201 if (PCI_REVISION(pcib_class) >= 0x40) { 2202 printf("ATA100 controller\n"); 2203 sc->sc_wdcdev.UDMA_cap = 5; 2204 } else { 2205 printf("ATA66 controller\n"); 2206 sc->sc_wdcdev.UDMA_cap = 4; 2207 } 2208 break; 2209 case PCI_PRODUCT_VIATECH_VT8231: 2210 printf("VT8231 ATA100 controller\n"); 2211 sc->sc_wdcdev.UDMA_cap = 5; 2212 break; 2213 case PCI_PRODUCT_VIATECH_VT8233: 2214 printf("VT8233 ATA100 controller\n"); 2215 sc->sc_wdcdev.UDMA_cap = 5; 2216 break; 2217 case PCI_PRODUCT_VIATECH_VT8233A: 2218 printf("VT8233A ATA133 controller\n"); 2219 sc->sc_wdcdev.UDMA_cap = 6; 2220 break; 2221 case PCI_PRODUCT_VIATECH_VT8235: 2222 printf("VT8235 ATA133 controller\n"); 2223 sc->sc_wdcdev.UDMA_cap = 6; 2224 break; 2225 case PCI_PRODUCT_VIATECH_VT8237_RAID: 2226 printf("VT8237 ATA133 controller\n"); 2227 sc->sc_wdcdev.UDMA_cap = 6; 2228 break; 2229 default: 2230 printf("unknown ATA controller\n"); 2231 sc->sc_wdcdev.UDMA_cap = 0; 2232 } 2233 2234 printf("%s: bus-master DMA support present", 2235 sc->sc_wdcdev.sc_dev.dv_xname); 2236 pciide_mapreg_dma(sc, pa); 2237 printf("\n"); 2238 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 2239 WDC_CAPABILITY_MODE; 2240 if (sc->sc_dma_ok) { 2241 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 2242 sc->sc_wdcdev.irqack = pciide_irqack; 2243 if (sc->sc_wdcdev.UDMA_cap > 0) 2244 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 2245 } 2246 sc->sc_wdcdev.PIO_cap = 4; 2247 sc->sc_wdcdev.DMA_cap = 2; 2248 sc->sc_wdcdev.set_modes = apollo_setup_channel; 2249 sc->sc_wdcdev.channels = sc->wdc_chanarray; 2250 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 2251 2252 WDCDEBUG_PRINT(("apollo_chip_map: old APO_IDECONF=0x%x, " 2253 "APO_CTLMISC=0x%x, APO_DATATIM=0x%x, APO_UDMA=0x%x\n", 2254 pci_conf_read(sc->sc_pc, sc->sc_tag, APO_IDECONF), 2255 pci_conf_read(sc->sc_pc, sc->sc_tag, APO_CTLMISC), 2256 pci_conf_read(sc->sc_pc, sc->sc_tag, APO_DATATIM), 2257 pci_conf_read(sc->sc_pc, sc->sc_tag, APO_UDMA)), 2258 DEBUG_PROBE); 2259 2260 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 2261 cp = &sc->pciide_channels[channel]; 2262 if (pciide_chansetup(sc, channel, interface) == 0) 2263 continue; 2264 2265 ideconf = pci_conf_read(sc->sc_pc, sc->sc_tag, APO_IDECONF); 2266 if ((ideconf & APO_IDECONF_EN(channel)) == 0) { 2267 printf("%s: %s channel ignored (disabled)\n", 2268 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 2269 continue; 2270 } 2271 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 2272 pciide_pci_intr); 2273 if (cp->hw_ok == 0) 2274 continue; 2275 if (pciide_chan_candisable(cp)) { 2276 ideconf &= ~APO_IDECONF_EN(channel); 2277 pci_conf_write(sc->sc_pc, sc->sc_tag, APO_IDECONF, 2278 ideconf); 2279 } 2280 pciide_map_compat_intr(pa, cp, channel, interface); 2281 2282 if (cp->hw_ok == 0) 2283 continue; 2284 apollo_setup_channel(&sc->pciide_channels[channel].wdc_channel); 2285 } 2286 WDCDEBUG_PRINT(("apollo_chip_map: APO_DATATIM=0x%x, APO_UDMA=0x%x\n", 2287 pci_conf_read(sc->sc_pc, sc->sc_tag, APO_DATATIM), 2288 pci_conf_read(sc->sc_pc, sc->sc_tag, APO_UDMA)), DEBUG_PROBE); 2289 } 2290 2291 void 2292 apollo_setup_channel(chp) 2293 struct channel_softc *chp; 2294 { 2295 u_int32_t udmatim_reg, datatim_reg; 2296 u_int8_t idedma_ctl; 2297 int mode, drive; 2298 struct ata_drive_datas *drvp; 2299 struct pciide_channel *cp = (struct pciide_channel*)chp; 2300 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 2301 2302 idedma_ctl = 0; 2303 datatim_reg = pci_conf_read(sc->sc_pc, sc->sc_tag, APO_DATATIM); 2304 udmatim_reg = pci_conf_read(sc->sc_pc, sc->sc_tag, APO_UDMA); 2305 datatim_reg &= ~APO_DATATIM_MASK(chp->channel); 2306 udmatim_reg &= ~APO_UDMA_MASK(chp->channel); 2307 2308 /* setup DMA if needed */ 2309 pciide_channel_dma_setup(cp); 2310 2311 for (drive = 0; drive < 2; drive++) { 2312 drvp = &chp->ch_drive[drive]; 2313 /* If no drive, skip */ 2314 if ((drvp->drive_flags & DRIVE) == 0) 2315 continue; 2316 /* add timing values, setup DMA if needed */ 2317 if (((drvp->drive_flags & DRIVE_DMA) == 0 && 2318 (drvp->drive_flags & DRIVE_UDMA) == 0)) { 2319 mode = drvp->PIO_mode; 2320 goto pio; 2321 } 2322 if ((chp->wdc->cap & WDC_CAPABILITY_UDMA) && 2323 (drvp->drive_flags & DRIVE_UDMA)) { 2324 /* use Ultra/DMA */ 2325 drvp->drive_flags &= ~DRIVE_DMA; 2326 udmatim_reg |= APO_UDMA_EN(chp->channel, drive) | 2327 APO_UDMA_EN_MTH(chp->channel, drive); 2328 if (sc->sc_wdcdev.UDMA_cap == 6) { 2329 /* 8233a */ 2330 udmatim_reg |= APO_UDMA_TIME(chp->channel, 2331 drive, apollo_udma133_tim[drvp->UDMA_mode]); 2332 } else if (sc->sc_wdcdev.UDMA_cap == 5) { 2333 /* 686b */ 2334 udmatim_reg |= APO_UDMA_TIME(chp->channel, 2335 drive, apollo_udma100_tim[drvp->UDMA_mode]); 2336 } else if (sc->sc_wdcdev.UDMA_cap == 4) { 2337 /* 596b or 686a */ 2338 udmatim_reg |= APO_UDMA_CLK66(chp->channel); 2339 udmatim_reg |= APO_UDMA_TIME(chp->channel, 2340 drive, apollo_udma66_tim[drvp->UDMA_mode]); 2341 } else { 2342 /* 596a or 586b */ 2343 udmatim_reg |= APO_UDMA_TIME(chp->channel, 2344 drive, apollo_udma33_tim[drvp->UDMA_mode]); 2345 } 2346 /* can use PIO timings, MW DMA unused */ 2347 mode = drvp->PIO_mode; 2348 } else { 2349 /* use Multiword DMA */ 2350 drvp->drive_flags &= ~DRIVE_UDMA; 2351 /* mode = min(pio, dma+2) */ 2352 if (drvp->PIO_mode <= (drvp->DMA_mode +2)) 2353 mode = drvp->PIO_mode; 2354 else 2355 mode = drvp->DMA_mode + 2; 2356 } 2357 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 2358 2359 pio: /* setup PIO mode */ 2360 if (mode <= 2) { 2361 drvp->DMA_mode = 0; 2362 drvp->PIO_mode = 0; 2363 mode = 0; 2364 } else { 2365 drvp->PIO_mode = mode; 2366 drvp->DMA_mode = mode - 2; 2367 } 2368 datatim_reg |= 2369 APO_DATATIM_PULSE(chp->channel, drive, 2370 apollo_pio_set[mode]) | 2371 APO_DATATIM_RECOV(chp->channel, drive, 2372 apollo_pio_rec[mode]); 2373 } 2374 if (idedma_ctl != 0) { 2375 /* Add software bits in status register */ 2376 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 2377 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * chp->channel), 2378 idedma_ctl); 2379 } 2380 pciide_print_modes(cp); 2381 pci_conf_write(sc->sc_pc, sc->sc_tag, APO_DATATIM, datatim_reg); 2382 pci_conf_write(sc->sc_pc, sc->sc_tag, APO_UDMA, udmatim_reg); 2383 } 2384 2385 void 2386 cmd_channel_map(pa, sc, channel) 2387 struct pci_attach_args *pa; 2388 struct pciide_softc *sc; 2389 int channel; 2390 { 2391 struct pciide_channel *cp = &sc->pciide_channels[channel]; 2392 bus_size_t cmdsize, ctlsize; 2393 u_int8_t ctrl = pciide_pci_read(sc->sc_pc, sc->sc_tag, CMD_CTRL); 2394 int interface, one_channel; 2395 2396 /* 2397 * The 0648/0649 can be told to identify as a RAID controller. 2398 * In this case, we have to fake interface 2399 */ 2400 if (PCI_SUBCLASS(pa->pa_class) != PCI_SUBCLASS_MASS_STORAGE_IDE) { 2401 interface = PCIIDE_INTERFACE_SETTABLE(0) | 2402 PCIIDE_INTERFACE_SETTABLE(1); 2403 if (pciide_pci_read(pa->pa_pc, pa->pa_tag, CMD_CONF) & 2404 CMD_CONF_DSA1) 2405 interface |= PCIIDE_INTERFACE_PCI(0) | 2406 PCIIDE_INTERFACE_PCI(1); 2407 } else { 2408 interface = PCI_INTERFACE(pa->pa_class); 2409 } 2410 2411 sc->wdc_chanarray[channel] = &cp->wdc_channel; 2412 cp->name = PCIIDE_CHANNEL_NAME(channel); 2413 cp->wdc_channel.channel = channel; 2414 cp->wdc_channel.wdc = &sc->sc_wdcdev; 2415 2416 /* 2417 * Older CMD64X doesn't have independant channels 2418 */ 2419 switch (sc->sc_pp->ide_product) { 2420 case PCI_PRODUCT_CMDTECH_649: 2421 one_channel = 0; 2422 break; 2423 default: 2424 one_channel = 1; 2425 break; 2426 } 2427 2428 if (channel > 0 && one_channel) { 2429 cp->wdc_channel.ch_queue = 2430 sc->pciide_channels[0].wdc_channel.ch_queue; 2431 } else { 2432 cp->wdc_channel.ch_queue = 2433 malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT); 2434 } 2435 if (cp->wdc_channel.ch_queue == NULL) { 2436 printf("%s %s channel: " 2437 "can't allocate memory for command queue", 2438 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 2439 return; 2440 } 2441 2442 printf("%s: %s channel %s to %s mode\n", 2443 sc->sc_wdcdev.sc_dev.dv_xname, cp->name, 2444 (interface & PCIIDE_INTERFACE_SETTABLE(channel)) ? 2445 "configured" : "wired", 2446 (interface & PCIIDE_INTERFACE_PCI(channel)) ? 2447 "native-PCI" : "compatibility"); 2448 2449 /* 2450 * with a CMD PCI64x, if we get here, the first channel is enabled: 2451 * there's no way to disable the first channel without disabling 2452 * the whole device 2453 */ 2454 if (channel != 0 && (ctrl & CMD_CTRL_2PORT) == 0) { 2455 printf("%s: %s channel ignored (disabled)\n", 2456 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 2457 return; 2458 } 2459 2460 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, cmd_pci_intr); 2461 if (cp->hw_ok == 0) 2462 return; 2463 if (channel == 1) { 2464 if (pciide_chan_candisable(cp)) { 2465 ctrl &= ~CMD_CTRL_2PORT; 2466 pciide_pci_write(pa->pa_pc, pa->pa_tag, 2467 CMD_CTRL, ctrl); 2468 } 2469 } 2470 pciide_map_compat_intr(pa, cp, channel, interface); 2471 } 2472 2473 int 2474 cmd_pci_intr(arg) 2475 void *arg; 2476 { 2477 struct pciide_softc *sc = arg; 2478 struct pciide_channel *cp; 2479 struct channel_softc *wdc_cp; 2480 int i, rv, crv; 2481 u_int32_t priirq, secirq; 2482 2483 rv = 0; 2484 priirq = pciide_pci_read(sc->sc_pc, sc->sc_tag, CMD_CONF); 2485 secirq = pciide_pci_read(sc->sc_pc, sc->sc_tag, CMD_ARTTIM23); 2486 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 2487 cp = &sc->pciide_channels[i]; 2488 wdc_cp = &cp->wdc_channel; 2489 /* If a compat channel skip. */ 2490 if (cp->compat) 2491 continue; 2492 if ((i == 0 && (priirq & CMD_CONF_DRV0_INTR)) || 2493 (i == 1 && (secirq & CMD_ARTTIM23_IRQ))) { 2494 crv = wdcintr(wdc_cp); 2495 if (crv == 0) 2496 printf("%s:%d: bogus intr\n", 2497 sc->sc_wdcdev.sc_dev.dv_xname, i); 2498 else 2499 rv = 1; 2500 } 2501 } 2502 return rv; 2503 } 2504 2505 void 2506 cmd_chip_map(sc, pa) 2507 struct pciide_softc *sc; 2508 struct pci_attach_args *pa; 2509 { 2510 int channel; 2511 2512 /* 2513 * For a CMD PCI064x, the use of PCI_COMMAND_IO_ENABLE 2514 * and base adresses registers can be disabled at 2515 * hardware level. In this case, the device is wired 2516 * in compat mode and its first channel is always enabled, 2517 * but we can't rely on PCI_COMMAND_IO_ENABLE. 2518 * In fact, it seems that the first channel of the CMD PCI0640 2519 * can't be disabled. 2520 */ 2521 2522 #ifdef PCIIDE_CMD064x_DISABLE 2523 if (pciide_chipen(sc, pa) == 0) 2524 return; 2525 #endif 2526 2527 printf("%s: hardware does not support DMA\n", 2528 sc->sc_wdcdev.sc_dev.dv_xname); 2529 sc->sc_dma_ok = 0; 2530 2531 sc->sc_wdcdev.channels = sc->wdc_chanarray; 2532 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 2533 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16; 2534 2535 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 2536 cmd_channel_map(pa, sc, channel); 2537 } 2538 } 2539 2540 void 2541 cmd0643_9_chip_map(sc, pa) 2542 struct pciide_softc *sc; 2543 struct pci_attach_args *pa; 2544 { 2545 struct pciide_channel *cp; 2546 int channel; 2547 pcireg_t rev = PCI_REVISION(pa->pa_class); 2548 2549 /* 2550 * For a CMD PCI064x, the use of PCI_COMMAND_IO_ENABLE 2551 * and base adresses registers can be disabled at 2552 * hardware level. In this case, the device is wired 2553 * in compat mode and its first channel is always enabled, 2554 * but we can't rely on PCI_COMMAND_IO_ENABLE. 2555 * In fact, it seems that the first channel of the CMD PCI0640 2556 * can't be disabled. 2557 */ 2558 2559 #ifdef PCIIDE_CMD064x_DISABLE 2560 if (pciide_chipen(sc, pa) == 0) 2561 return; 2562 #endif 2563 printf("%s: bus-master DMA support present", 2564 sc->sc_wdcdev.sc_dev.dv_xname); 2565 pciide_mapreg_dma(sc, pa); 2566 printf("\n"); 2567 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 2568 WDC_CAPABILITY_MODE; 2569 if (sc->sc_dma_ok) { 2570 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 2571 switch (sc->sc_pp->ide_product) { 2572 case PCI_PRODUCT_CMDTECH_649: 2573 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 2574 sc->sc_wdcdev.UDMA_cap = 5; 2575 sc->sc_wdcdev.irqack = cmd646_9_irqack; 2576 break; 2577 case PCI_PRODUCT_CMDTECH_648: 2578 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 2579 sc->sc_wdcdev.UDMA_cap = 4; 2580 sc->sc_wdcdev.irqack = cmd646_9_irqack; 2581 break; 2582 case PCI_PRODUCT_CMDTECH_646: 2583 if (rev >= CMD0646U2_REV) { 2584 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 2585 sc->sc_wdcdev.UDMA_cap = 2; 2586 } else if (rev >= CMD0646U_REV) { 2587 /* 2588 * Linux's driver claims that the 646U is broken 2589 * with UDMA. Only enable it if we know what we're 2590 * doing 2591 */ 2592 #ifdef PCIIDE_CMD0646U_ENABLEUDMA 2593 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 2594 sc->sc_wdcdev.UDMA_cap = 2; 2595 #endif 2596 /* explicitly disable UDMA */ 2597 pciide_pci_write(sc->sc_pc, sc->sc_tag, 2598 CMD_UDMATIM(0), 0); 2599 pciide_pci_write(sc->sc_pc, sc->sc_tag, 2600 CMD_UDMATIM(1), 0); 2601 } 2602 sc->sc_wdcdev.irqack = cmd646_9_irqack; 2603 break; 2604 default: 2605 sc->sc_wdcdev.irqack = pciide_irqack; 2606 } 2607 } 2608 2609 sc->sc_wdcdev.channels = sc->wdc_chanarray; 2610 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 2611 sc->sc_wdcdev.PIO_cap = 4; 2612 sc->sc_wdcdev.DMA_cap = 2; 2613 sc->sc_wdcdev.set_modes = cmd0643_9_setup_channel; 2614 2615 WDCDEBUG_PRINT(("cmd0643_9_chip_map: old timings reg 0x%x 0x%x\n", 2616 pci_conf_read(sc->sc_pc, sc->sc_tag, 0x54), 2617 pci_conf_read(sc->sc_pc, sc->sc_tag, 0x58)), 2618 DEBUG_PROBE); 2619 2620 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 2621 cp = &sc->pciide_channels[channel]; 2622 cmd_channel_map(pa, sc, channel); 2623 if (cp->hw_ok == 0) 2624 continue; 2625 cmd0643_9_setup_channel(&cp->wdc_channel); 2626 } 2627 /* 2628 * note - this also makes sure we clear the irq disable and reset 2629 * bits 2630 */ 2631 pciide_pci_write(sc->sc_pc, sc->sc_tag, CMD_DMA_MODE, CMD_DMA_MULTIPLE); 2632 WDCDEBUG_PRINT(("cmd0643_9_chip_map: timings reg now 0x%x 0x%x\n", 2633 pci_conf_read(sc->sc_pc, sc->sc_tag, 0x54), 2634 pci_conf_read(sc->sc_pc, sc->sc_tag, 0x58)), 2635 DEBUG_PROBE); 2636 } 2637 2638 void 2639 cmd0643_9_setup_channel(chp) 2640 struct channel_softc *chp; 2641 { 2642 struct ata_drive_datas *drvp; 2643 u_int8_t tim; 2644 u_int32_t idedma_ctl, udma_reg; 2645 int drive; 2646 struct pciide_channel *cp = (struct pciide_channel*)chp; 2647 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 2648 2649 idedma_ctl = 0; 2650 /* setup DMA if needed */ 2651 pciide_channel_dma_setup(cp); 2652 2653 for (drive = 0; drive < 2; drive++) { 2654 drvp = &chp->ch_drive[drive]; 2655 /* If no drive, skip */ 2656 if ((drvp->drive_flags & DRIVE) == 0) 2657 continue; 2658 /* add timing values, setup DMA if needed */ 2659 tim = cmd0643_9_data_tim_pio[drvp->PIO_mode]; 2660 if (drvp->drive_flags & (DRIVE_DMA | DRIVE_UDMA)) { 2661 if (drvp->drive_flags & DRIVE_UDMA) { 2662 /* UltraDMA on a 646U2, 0648 or 0649 */ 2663 drvp->drive_flags &= ~DRIVE_DMA; 2664 udma_reg = pciide_pci_read(sc->sc_pc, 2665 sc->sc_tag, CMD_UDMATIM(chp->channel)); 2666 if (drvp->UDMA_mode > 2 && 2667 (pciide_pci_read(sc->sc_pc, sc->sc_tag, 2668 CMD_BICSR) & 2669 CMD_BICSR_80(chp->channel)) == 0) 2670 drvp->UDMA_mode = 2; 2671 if (drvp->UDMA_mode > 2) 2672 udma_reg &= ~CMD_UDMATIM_UDMA33(drive); 2673 else if (sc->sc_wdcdev.UDMA_cap > 2) 2674 udma_reg |= CMD_UDMATIM_UDMA33(drive); 2675 udma_reg |= CMD_UDMATIM_UDMA(drive); 2676 udma_reg &= ~(CMD_UDMATIM_TIM_MASK << 2677 CMD_UDMATIM_TIM_OFF(drive)); 2678 udma_reg |= 2679 (cmd0646_9_tim_udma[drvp->UDMA_mode] << 2680 CMD_UDMATIM_TIM_OFF(drive)); 2681 pciide_pci_write(sc->sc_pc, sc->sc_tag, 2682 CMD_UDMATIM(chp->channel), udma_reg); 2683 } else { 2684 /* 2685 * use Multiword DMA. 2686 * Timings will be used for both PIO and DMA, 2687 * so adjust DMA mode if needed 2688 * if we have a 0646U2/8/9, turn off UDMA 2689 */ 2690 if (sc->sc_wdcdev.cap & WDC_CAPABILITY_UDMA) { 2691 udma_reg = pciide_pci_read(sc->sc_pc, 2692 sc->sc_tag, 2693 CMD_UDMATIM(chp->channel)); 2694 udma_reg &= ~CMD_UDMATIM_UDMA(drive); 2695 pciide_pci_write(sc->sc_pc, sc->sc_tag, 2696 CMD_UDMATIM(chp->channel), 2697 udma_reg); 2698 } 2699 if (drvp->PIO_mode >= 3 && 2700 (drvp->DMA_mode + 2) > drvp->PIO_mode) { 2701 drvp->DMA_mode = drvp->PIO_mode - 2; 2702 } 2703 tim = cmd0643_9_data_tim_dma[drvp->DMA_mode]; 2704 } 2705 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 2706 } 2707 pciide_pci_write(sc->sc_pc, sc->sc_tag, 2708 CMD_DATA_TIM(chp->channel, drive), tim); 2709 } 2710 if (idedma_ctl != 0) { 2711 /* Add software bits in status register */ 2712 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 2713 IDEDMA_CTL + (IDEDMA_SCH_OFFSET * chp->channel), 2714 idedma_ctl); 2715 } 2716 pciide_print_modes(cp); 2717 } 2718 2719 void 2720 cmd646_9_irqack(chp) 2721 struct channel_softc *chp; 2722 { 2723 u_int32_t priirq, secirq; 2724 struct pciide_channel *cp = (struct pciide_channel*)chp; 2725 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 2726 2727 if (chp->channel == 0) { 2728 priirq = pciide_pci_read(sc->sc_pc, sc->sc_tag, CMD_CONF); 2729 pciide_pci_write(sc->sc_pc, sc->sc_tag, CMD_CONF, priirq); 2730 } else { 2731 secirq = pciide_pci_read(sc->sc_pc, sc->sc_tag, CMD_ARTTIM23); 2732 pciide_pci_write(sc->sc_pc, sc->sc_tag, CMD_ARTTIM23, secirq); 2733 } 2734 pciide_irqack(chp); 2735 } 2736 2737 void 2738 cy693_chip_map(sc, pa) 2739 struct pciide_softc *sc; 2740 struct pci_attach_args *pa; 2741 { 2742 struct pciide_channel *cp; 2743 pcireg_t interface = PCI_INTERFACE(pa->pa_class); 2744 bus_size_t cmdsize, ctlsize; 2745 2746 if (pciide_chipen(sc, pa) == 0) 2747 return; 2748 /* 2749 * this chip has 2 PCI IDE functions, one for primary and one for 2750 * secondary. So we need to call pciide_mapregs_compat() with 2751 * the real channel 2752 */ 2753 if (pa->pa_function == 1) { 2754 sc->sc_cy_compatchan = 0; 2755 } else if (pa->pa_function == 2) { 2756 sc->sc_cy_compatchan = 1; 2757 } else { 2758 printf("%s: unexpected PCI function %d\n", 2759 sc->sc_wdcdev.sc_dev.dv_xname, pa->pa_function); 2760 return; 2761 } 2762 if (interface & PCIIDE_INTERFACE_BUS_MASTER_DMA) { 2763 printf("%s: bus-master DMA support present", 2764 sc->sc_wdcdev.sc_dev.dv_xname); 2765 pciide_mapreg_dma(sc, pa); 2766 } else { 2767 printf("%s: hardware does not support DMA", 2768 sc->sc_wdcdev.sc_dev.dv_xname); 2769 sc->sc_dma_ok = 0; 2770 } 2771 printf("\n"); 2772 2773 sc->sc_cy_handle = cy82c693_init(pa->pa_iot); 2774 if (sc->sc_cy_handle == NULL) { 2775 printf("%s: unable to map hyperCache control registers\n", 2776 sc->sc_wdcdev.sc_dev.dv_xname); 2777 sc->sc_dma_ok = 0; 2778 } 2779 2780 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 2781 WDC_CAPABILITY_MODE; 2782 if (sc->sc_dma_ok) { 2783 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 2784 sc->sc_wdcdev.irqack = pciide_irqack; 2785 } 2786 sc->sc_wdcdev.PIO_cap = 4; 2787 sc->sc_wdcdev.DMA_cap = 2; 2788 sc->sc_wdcdev.set_modes = cy693_setup_channel; 2789 2790 sc->sc_wdcdev.channels = sc->wdc_chanarray; 2791 sc->sc_wdcdev.nchannels = 1; 2792 2793 /* Only one channel for this chip; if we are here it's enabled */ 2794 cp = &sc->pciide_channels[0]; 2795 sc->wdc_chanarray[0] = &cp->wdc_channel; 2796 cp->name = PCIIDE_CHANNEL_NAME(0); 2797 cp->wdc_channel.channel = 0; 2798 cp->wdc_channel.wdc = &sc->sc_wdcdev; 2799 cp->wdc_channel.ch_queue = 2800 malloc(sizeof(struct channel_queue), M_DEVBUF, M_NOWAIT); 2801 if (cp->wdc_channel.ch_queue == NULL) { 2802 printf("%s primary channel: " 2803 "can't allocate memory for command queue", 2804 sc->sc_wdcdev.sc_dev.dv_xname); 2805 return; 2806 } 2807 printf("%s: primary channel %s to ", 2808 sc->sc_wdcdev.sc_dev.dv_xname, 2809 (interface & PCIIDE_INTERFACE_SETTABLE(0)) ? 2810 "configured" : "wired"); 2811 if (interface & PCIIDE_INTERFACE_PCI(0)) { 2812 printf("native-PCI"); 2813 cp->hw_ok = pciide_mapregs_native(pa, cp, &cmdsize, &ctlsize, 2814 pciide_pci_intr); 2815 } else { 2816 printf("compatibility"); 2817 cp->hw_ok = pciide_mapregs_compat(pa, cp, sc->sc_cy_compatchan, 2818 &cmdsize, &ctlsize); 2819 } 2820 printf(" mode\n"); 2821 cp->wdc_channel.data32iot = cp->wdc_channel.cmd_iot; 2822 cp->wdc_channel.data32ioh = cp->wdc_channel.cmd_ioh; 2823 wdcattach(&cp->wdc_channel); 2824 if (pciide_chan_candisable(cp)) { 2825 pci_conf_write(sc->sc_pc, sc->sc_tag, 2826 PCI_COMMAND_STATUS_REG, 0); 2827 } 2828 pciide_map_compat_intr(pa, cp, sc->sc_cy_compatchan, interface); 2829 if (cp->hw_ok == 0) 2830 return; 2831 WDCDEBUG_PRINT(("cy693_chip_map: old timings reg 0x%x\n", 2832 pci_conf_read(sc->sc_pc, sc->sc_tag, CY_CMD_CTRL)),DEBUG_PROBE); 2833 cy693_setup_channel(&cp->wdc_channel); 2834 WDCDEBUG_PRINT(("cy693_chip_map: new timings reg 0x%x\n", 2835 pci_conf_read(sc->sc_pc, sc->sc_tag, CY_CMD_CTRL)), DEBUG_PROBE); 2836 } 2837 2838 void 2839 cy693_setup_channel(chp) 2840 struct channel_softc *chp; 2841 { 2842 struct ata_drive_datas *drvp; 2843 int drive; 2844 u_int32_t cy_cmd_ctrl; 2845 u_int32_t idedma_ctl; 2846 struct pciide_channel *cp = (struct pciide_channel*)chp; 2847 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 2848 int dma_mode = -1; 2849 2850 cy_cmd_ctrl = idedma_ctl = 0; 2851 2852 /* setup DMA if needed */ 2853 pciide_channel_dma_setup(cp); 2854 2855 for (drive = 0; drive < 2; drive++) { 2856 drvp = &chp->ch_drive[drive]; 2857 /* If no drive, skip */ 2858 if ((drvp->drive_flags & DRIVE) == 0) 2859 continue; 2860 /* add timing values, setup DMA if needed */ 2861 if (drvp->drive_flags & DRIVE_DMA) { 2862 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 2863 /* use Multiword DMA */ 2864 if (dma_mode == -1 || dma_mode > drvp->DMA_mode) 2865 dma_mode = drvp->DMA_mode; 2866 } 2867 cy_cmd_ctrl |= (cy_pio_pulse[drvp->PIO_mode] << 2868 CY_CMD_CTRL_IOW_PULSE_OFF(drive)); 2869 cy_cmd_ctrl |= (cy_pio_rec[drvp->PIO_mode] << 2870 CY_CMD_CTRL_IOW_REC_OFF(drive)); 2871 cy_cmd_ctrl |= (cy_pio_pulse[drvp->PIO_mode] << 2872 CY_CMD_CTRL_IOR_PULSE_OFF(drive)); 2873 cy_cmd_ctrl |= (cy_pio_rec[drvp->PIO_mode] << 2874 CY_CMD_CTRL_IOR_REC_OFF(drive)); 2875 } 2876 pci_conf_write(sc->sc_pc, sc->sc_tag, CY_CMD_CTRL, cy_cmd_ctrl); 2877 chp->ch_drive[0].DMA_mode = dma_mode; 2878 chp->ch_drive[1].DMA_mode = dma_mode; 2879 2880 if (dma_mode == -1) 2881 dma_mode = 0; 2882 2883 if (sc->sc_cy_handle != NULL) { 2884 /* Note: `multiple' is implied. */ 2885 cy82c693_write(sc->sc_cy_handle, 2886 (sc->sc_cy_compatchan == 0) ? 2887 CY_DMA_IDX_PRIMARY : CY_DMA_IDX_SECONDARY, dma_mode); 2888 } 2889 2890 pciide_print_modes(cp); 2891 2892 if (idedma_ctl != 0) { 2893 /* Add software bits in status register */ 2894 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 2895 IDEDMA_CTL, idedma_ctl); 2896 } 2897 } 2898 2899 static struct sis_hostbr_type { 2900 u_int16_t id; 2901 u_int8_t rev; 2902 u_int8_t udma_mode; 2903 char *name; 2904 u_int8_t type; 2905 #define SIS_TYPE_NOUDMA 0 2906 #define SIS_TYPE_66 1 2907 #define SIS_TYPE_100OLD 2 2908 #define SIS_TYPE_100NEW 3 2909 #define SIS_TYPE_133OLD 4 2910 #define SIS_TYPE_133NEW 5 2911 #define SIS_TYPE_SOUTH 6 2912 } sis_hostbr_type[] = { 2913 /* Most infos here are from sos (at) freebsd.org */ 2914 {PCI_PRODUCT_SIS_530HB, 0x00, 4, "530", SIS_TYPE_66}, 2915 #if 0 2916 /* 2917 * controllers associated to a rev 0x2 530 Host to PCI Bridge 2918 * have problems with UDMA (info provided by Christos) 2919 */ 2920 {PCI_PRODUCT_SIS_530HB, 0x02, 0, "530 (buggy)", SIS_TYPE_NOUDMA}, 2921 #endif 2922 {PCI_PRODUCT_SIS_540HB, 0x00, 4, "540", SIS_TYPE_66}, 2923 {PCI_PRODUCT_SIS_550HB, 0x00, 4, "550", SIS_TYPE_66}, 2924 {PCI_PRODUCT_SIS_620, 0x00, 4, "620", SIS_TYPE_66}, 2925 {PCI_PRODUCT_SIS_630, 0x00, 4, "630", SIS_TYPE_66}, 2926 {PCI_PRODUCT_SIS_630, 0x30, 5, "630S", SIS_TYPE_100NEW}, 2927 {PCI_PRODUCT_SIS_633, 0x00, 5, "633", SIS_TYPE_100NEW}, 2928 {PCI_PRODUCT_SIS_635, 0x00, 5, "635", SIS_TYPE_100NEW}, 2929 {PCI_PRODUCT_SIS_640, 0x00, 4, "640", SIS_TYPE_SOUTH}, 2930 {PCI_PRODUCT_SIS_645, 0x00, 6, "645", SIS_TYPE_SOUTH}, 2931 {PCI_PRODUCT_SIS_646, 0x00, 6, "645DX", SIS_TYPE_SOUTH}, 2932 {PCI_PRODUCT_SIS_648, 0x00, 6, "648", SIS_TYPE_SOUTH}, 2933 {PCI_PRODUCT_SIS_650, 0x00, 6, "650", SIS_TYPE_SOUTH}, 2934 {PCI_PRODUCT_SIS_651, 0x00, 6, "651", SIS_TYPE_SOUTH}, 2935 {PCI_PRODUCT_SIS_652, 0x00, 6, "652", SIS_TYPE_SOUTH}, 2936 {PCI_PRODUCT_SIS_655, 0x00, 6, "655", SIS_TYPE_SOUTH}, 2937 {PCI_PRODUCT_SIS_658, 0x00, 6, "658", SIS_TYPE_SOUTH}, 2938 {PCI_PRODUCT_SIS_730, 0x00, 5, "730", SIS_TYPE_100OLD}, 2939 {PCI_PRODUCT_SIS_733, 0x00, 5, "733", SIS_TYPE_100NEW}, 2940 {PCI_PRODUCT_SIS_735, 0x00, 5, "735", SIS_TYPE_100NEW}, 2941 {PCI_PRODUCT_SIS_740, 0x00, 5, "740", SIS_TYPE_SOUTH}, 2942 {PCI_PRODUCT_SIS_745, 0x00, 5, "745", SIS_TYPE_100NEW}, 2943 {PCI_PRODUCT_SIS_746, 0x00, 6, "746", SIS_TYPE_SOUTH}, 2944 {PCI_PRODUCT_SIS_748, 0x00, 6, "748", SIS_TYPE_SOUTH}, 2945 {PCI_PRODUCT_SIS_750, 0x00, 6, "750", SIS_TYPE_SOUTH}, 2946 {PCI_PRODUCT_SIS_751, 0x00, 6, "751", SIS_TYPE_SOUTH}, 2947 {PCI_PRODUCT_SIS_752, 0x00, 6, "752", SIS_TYPE_SOUTH}, 2948 {PCI_PRODUCT_SIS_755, 0x00, 6, "755", SIS_TYPE_SOUTH}, 2949 /* 2950 * From sos (at) freebsd.org: the 0x961 ID will never be found in real world 2951 * {PCI_PRODUCT_SIS_961, 0x00, 6, "961", SIS_TYPE_133NEW}, 2952 */ 2953 {PCI_PRODUCT_SIS_962, 0x00, 6, "962", SIS_TYPE_133NEW}, 2954 {PCI_PRODUCT_SIS_963, 0x00, 6, "963", SIS_TYPE_133NEW}, 2955 }; 2956 2957 static struct sis_hostbr_type *sis_hostbr_type_match; 2958 2959 static int 2960 sis_hostbr_match(pa) 2961 struct pci_attach_args *pa; 2962 { 2963 int i; 2964 if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_SIS) 2965 return 0; 2966 sis_hostbr_type_match = NULL; 2967 for (i = 0; 2968 i < sizeof(sis_hostbr_type) / sizeof(sis_hostbr_type[0]); 2969 i++) { 2970 if (PCI_PRODUCT(pa->pa_id) == sis_hostbr_type[i].id && 2971 PCI_REVISION(pa->pa_class) >= sis_hostbr_type[i].rev) 2972 sis_hostbr_type_match = &sis_hostbr_type[i]; 2973 } 2974 return (sis_hostbr_type_match != NULL); 2975 } 2976 2977 static int sis_south_match(pa) 2978 struct pci_attach_args *pa; 2979 { 2980 return(PCI_VENDOR(pa->pa_id) == PCI_VENDOR_SIS && 2981 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_SIS_85C503 && 2982 PCI_REVISION(pa->pa_class) >= 0x10); 2983 } 2984 2985 void 2986 sis_chip_map(sc, pa) 2987 struct pciide_softc *sc; 2988 struct pci_attach_args *pa; 2989 { 2990 struct pciide_channel *cp; 2991 int channel; 2992 u_int8_t sis_ctr0 = pciide_pci_read(sc->sc_pc, sc->sc_tag, SIS_CTRL0); 2993 pcireg_t interface = PCI_INTERFACE(pa->pa_class); 2994 pcireg_t rev = PCI_REVISION(pa->pa_class); 2995 bus_size_t cmdsize, ctlsize; 2996 2997 if (pciide_chipen(sc, pa) == 0) 2998 return; 2999 printf(": Silicon Integrated System "); 3000 pci_find_device(NULL, sis_hostbr_match); 3001 if (sis_hostbr_type_match) { 3002 if (sis_hostbr_type_match->type == SIS_TYPE_SOUTH) { 3003 pciide_pci_write(sc->sc_pc, sc->sc_tag, SIS_REG_57, 3004 pciide_pci_read(sc->sc_pc, sc->sc_tag, 3005 SIS_REG_57) & 0x7f); 3006 if (PCI_PRODUCT(pci_conf_read(sc->sc_pc, sc->sc_tag, 3007 PCI_ID_REG)) == SIS_PRODUCT_5518) { 3008 printf("96X UDMA%d", 3009 sis_hostbr_type_match->udma_mode); 3010 sc->sis_type = SIS_TYPE_133NEW; 3011 sc->sc_wdcdev.UDMA_cap = 3012 sis_hostbr_type_match->udma_mode; 3013 } else { 3014 if (pci_find_device(NULL, sis_south_match)) { 3015 sc->sis_type = SIS_TYPE_133OLD; 3016 sc->sc_wdcdev.UDMA_cap = 3017 sis_hostbr_type_match->udma_mode; 3018 } else { 3019 sc->sis_type = SIS_TYPE_100NEW; 3020 sc->sc_wdcdev.UDMA_cap = 3021 sis_hostbr_type_match->udma_mode; 3022 } 3023 } 3024 } else { 3025 sc->sis_type = sis_hostbr_type_match->type; 3026 sc->sc_wdcdev.UDMA_cap = 3027 sis_hostbr_type_match->udma_mode; 3028 } 3029 printf(sis_hostbr_type_match->name); 3030 } else { 3031 printf("5597/5598"); 3032 if (rev >= 0xd0) { 3033 sc->sc_wdcdev.UDMA_cap = 2; 3034 sc->sis_type = SIS_TYPE_66; 3035 } else { 3036 sc->sc_wdcdev.UDMA_cap = 0; 3037 sc->sis_type = SIS_TYPE_NOUDMA; 3038 } 3039 } 3040 printf(" IDE controller (rev. 0x%02x)\n", PCI_REVISION(pa->pa_class)); 3041 printf("%s: bus-master DMA support present", 3042 sc->sc_wdcdev.sc_dev.dv_xname); 3043 pciide_mapreg_dma(sc, pa); 3044 printf("\n"); 3045 3046 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 3047 WDC_CAPABILITY_MODE; 3048 if (sc->sc_dma_ok) { 3049 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 3050 sc->sc_wdcdev.irqack = pciide_irqack; 3051 if (sc->sis_type >= SIS_TYPE_66) 3052 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 3053 } 3054 3055 sc->sc_wdcdev.PIO_cap = 4; 3056 sc->sc_wdcdev.DMA_cap = 2; 3057 3058 sc->sc_wdcdev.channels = sc->wdc_chanarray; 3059 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 3060 switch(sc->sis_type) { 3061 case SIS_TYPE_NOUDMA: 3062 case SIS_TYPE_66: 3063 case SIS_TYPE_100OLD: 3064 sc->sc_wdcdev.set_modes = sis_setup_channel; 3065 pciide_pci_write(sc->sc_pc, sc->sc_tag, SIS_MISC, 3066 pciide_pci_read(sc->sc_pc, sc->sc_tag, SIS_MISC) | 3067 SIS_MISC_TIM_SEL | SIS_MISC_FIFO_SIZE | SIS_MISC_GTC); 3068 break; 3069 case SIS_TYPE_100NEW: 3070 case SIS_TYPE_133OLD: 3071 sc->sc_wdcdev.set_modes = sis_setup_channel; 3072 pciide_pci_write(sc->sc_pc, sc->sc_tag, SIS_REG_49, 3073 pciide_pci_read(sc->sc_pc, sc->sc_tag, SIS_REG_49) | 0x01); 3074 break; 3075 case SIS_TYPE_133NEW: 3076 sc->sc_wdcdev.set_modes = sis96x_setup_channel; 3077 pciide_pci_write(sc->sc_pc, sc->sc_tag, SIS_REG_50, 3078 pciide_pci_read(sc->sc_pc, sc->sc_tag, SIS_REG_50) & 0xf7); 3079 pciide_pci_write(sc->sc_pc, sc->sc_tag, SIS_REG_52, 3080 pciide_pci_read(sc->sc_pc, sc->sc_tag, SIS_REG_52) & 0xf7); 3081 break; 3082 } 3083 3084 3085 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 3086 cp = &sc->pciide_channels[channel]; 3087 if (pciide_chansetup(sc, channel, interface) == 0) 3088 continue; 3089 if ((channel == 0 && (sis_ctr0 & SIS_CTRL0_CHAN0_EN) == 0) || 3090 (channel == 1 && (sis_ctr0 & SIS_CTRL0_CHAN1_EN) == 0)) { 3091 printf("%s: %s channel ignored (disabled)\n", 3092 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 3093 continue; 3094 } 3095 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 3096 pciide_pci_intr); 3097 if (cp->hw_ok == 0) 3098 continue; 3099 if (pciide_chan_candisable(cp)) { 3100 if (channel == 0) 3101 sis_ctr0 &= ~SIS_CTRL0_CHAN0_EN; 3102 else 3103 sis_ctr0 &= ~SIS_CTRL0_CHAN1_EN; 3104 pciide_pci_write(sc->sc_pc, sc->sc_tag, SIS_CTRL0, 3105 sis_ctr0); 3106 } 3107 pciide_map_compat_intr(pa, cp, channel, interface); 3108 if (cp->hw_ok == 0) 3109 continue; 3110 sc->sc_wdcdev.set_modes(&cp->wdc_channel); 3111 } 3112 } 3113 3114 void 3115 sis96x_setup_channel(chp) 3116 struct channel_softc *chp; 3117 { 3118 struct ata_drive_datas *drvp; 3119 int drive; 3120 u_int32_t sis_tim; 3121 u_int32_t idedma_ctl; 3122 int regtim; 3123 struct pciide_channel *cp = (struct pciide_channel*)chp; 3124 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 3125 3126 sis_tim = 0; 3127 idedma_ctl = 0; 3128 /* setup DMA if needed */ 3129 pciide_channel_dma_setup(cp); 3130 3131 for (drive = 0; drive < 2; drive++) { 3132 regtim = SIS_TIM133( 3133 pciide_pci_read(sc->sc_pc, sc->sc_tag, SIS_REG_57), 3134 chp->channel, drive); 3135 drvp = &chp->ch_drive[drive]; 3136 /* If no drive, skip */ 3137 if ((drvp->drive_flags & DRIVE) == 0) 3138 continue; 3139 /* add timing values, setup DMA if needed */ 3140 if (drvp->drive_flags & DRIVE_UDMA) { 3141 /* use Ultra/DMA */ 3142 drvp->drive_flags &= ~DRIVE_DMA; 3143 if (pciide_pci_read(sc->sc_pc, sc->sc_tag, 3144 SIS96x_REG_CBL(chp->channel)) & SIS96x_REG_CBL_33) { 3145 if (drvp->UDMA_mode > 2) 3146 drvp->UDMA_mode = 2; 3147 } 3148 sis_tim |= sis_udma133new_tim[drvp->UDMA_mode]; 3149 sis_tim |= sis_pio133new_tim[drvp->PIO_mode]; 3150 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 3151 } else if (drvp->drive_flags & DRIVE_DMA) { 3152 /* 3153 * use Multiword DMA 3154 * Timings will be used for both PIO and DMA, 3155 * so adjust DMA mode if needed 3156 */ 3157 if (drvp->PIO_mode > (drvp->DMA_mode + 2)) 3158 drvp->PIO_mode = drvp->DMA_mode + 2; 3159 if (drvp->DMA_mode + 2 > (drvp->PIO_mode)) 3160 drvp->DMA_mode = (drvp->PIO_mode > 2) ? 3161 drvp->PIO_mode - 2 : 0; 3162 sis_tim |= sis_dma133new_tim[drvp->DMA_mode]; 3163 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 3164 } else { 3165 sis_tim |= sis_pio133new_tim[drvp->PIO_mode]; 3166 } 3167 WDCDEBUG_PRINT(("sis96x_setup_channel: new timings reg for " 3168 "channel %d drive %d: 0x%x (reg 0x%x)\n", 3169 chp->channel, drive, sis_tim, regtim), DEBUG_PROBE); 3170 pci_conf_write(sc->sc_pc, sc->sc_tag, regtim, sis_tim); 3171 } 3172 if (idedma_ctl != 0) { 3173 /* Add software bits in status register */ 3174 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 3175 IDEDMA_CTL+ (IDEDMA_SCH_OFFSET * chp->channel), 3176 idedma_ctl); 3177 } 3178 pciide_print_modes(cp); 3179 } 3180 3181 void 3182 sis_setup_channel(chp) 3183 struct channel_softc *chp; 3184 { 3185 struct ata_drive_datas *drvp; 3186 int drive; 3187 u_int32_t sis_tim; 3188 u_int32_t idedma_ctl; 3189 struct pciide_channel *cp = (struct pciide_channel*)chp; 3190 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 3191 3192 WDCDEBUG_PRINT(("sis_setup_channel: old timings reg for " 3193 "channel %d 0x%x\n", chp->channel, 3194 pci_conf_read(sc->sc_pc, sc->sc_tag, SIS_TIM(chp->channel))), 3195 DEBUG_PROBE); 3196 sis_tim = 0; 3197 idedma_ctl = 0; 3198 /* setup DMA if needed */ 3199 pciide_channel_dma_setup(cp); 3200 3201 for (drive = 0; drive < 2; drive++) { 3202 drvp = &chp->ch_drive[drive]; 3203 /* If no drive, skip */ 3204 if ((drvp->drive_flags & DRIVE) == 0) 3205 continue; 3206 /* add timing values, setup DMA if needed */ 3207 if ((drvp->drive_flags & DRIVE_DMA) == 0 && 3208 (drvp->drive_flags & DRIVE_UDMA) == 0) 3209 goto pio; 3210 3211 if (drvp->drive_flags & DRIVE_UDMA) { 3212 /* use Ultra/DMA */ 3213 drvp->drive_flags &= ~DRIVE_DMA; 3214 if (pciide_pci_read(sc->sc_pc, sc->sc_tag, 3215 SIS_REG_CBL) & SIS_REG_CBL_33(chp->channel)) { 3216 if (drvp->UDMA_mode > 2) 3217 drvp->UDMA_mode = 2; 3218 } 3219 switch (sc->sis_type) { 3220 case SIS_TYPE_66: 3221 case SIS_TYPE_100OLD: 3222 sis_tim |= sis_udma66_tim[drvp->UDMA_mode] << 3223 SIS_TIM66_UDMA_TIME_OFF(drive); 3224 break; 3225 case SIS_TYPE_100NEW: 3226 sis_tim |= 3227 sis_udma100new_tim[drvp->UDMA_mode] << 3228 SIS_TIM100_UDMA_TIME_OFF(drive); 3229 case SIS_TYPE_133OLD: 3230 sis_tim |= 3231 sis_udma133old_tim[drvp->UDMA_mode] << 3232 SIS_TIM100_UDMA_TIME_OFF(drive); 3233 break; 3234 default: 3235 printf("unknown SiS IDE type %d\n", 3236 sc->sis_type); 3237 } 3238 } else { 3239 /* 3240 * use Multiword DMA 3241 * Timings will be used for both PIO and DMA, 3242 * so adjust DMA mode if needed 3243 */ 3244 if (drvp->PIO_mode > (drvp->DMA_mode + 2)) 3245 drvp->PIO_mode = drvp->DMA_mode + 2; 3246 if (drvp->DMA_mode + 2 > (drvp->PIO_mode)) 3247 drvp->DMA_mode = (drvp->PIO_mode > 2) ? 3248 drvp->PIO_mode - 2 : 0; 3249 if (drvp->DMA_mode == 0) 3250 drvp->PIO_mode = 0; 3251 } 3252 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 3253 pio: switch (sc->sis_type) { 3254 case SIS_TYPE_NOUDMA: 3255 case SIS_TYPE_66: 3256 case SIS_TYPE_100OLD: 3257 sis_tim |= sis_pio_act[drvp->PIO_mode] << 3258 SIS_TIM66_ACT_OFF(drive); 3259 sis_tim |= sis_pio_rec[drvp->PIO_mode] << 3260 SIS_TIM66_REC_OFF(drive); 3261 break; 3262 case SIS_TYPE_100NEW: 3263 case SIS_TYPE_133OLD: 3264 sis_tim |= sis_pio_act[drvp->PIO_mode] << 3265 SIS_TIM100_ACT_OFF(drive); 3266 sis_tim |= sis_pio_rec[drvp->PIO_mode] << 3267 SIS_TIM100_REC_OFF(drive); 3268 break; 3269 default: 3270 printf("unknown SiS IDE type %d\n", 3271 sc->sis_type); 3272 } 3273 } 3274 WDCDEBUG_PRINT(("sis_setup_channel: new timings reg for " 3275 "channel %d 0x%x\n", chp->channel, sis_tim), DEBUG_PROBE); 3276 pci_conf_write(sc->sc_pc, sc->sc_tag, SIS_TIM(chp->channel), sis_tim); 3277 if (idedma_ctl != 0) { 3278 /* Add software bits in status register */ 3279 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 3280 IDEDMA_CTL, idedma_ctl); 3281 } 3282 pciide_print_modes(cp); 3283 } 3284 3285 void 3286 acer_chip_map(sc, pa) 3287 struct pciide_softc *sc; 3288 struct pci_attach_args *pa; 3289 { 3290 struct pciide_channel *cp; 3291 int channel; 3292 pcireg_t cr, interface; 3293 bus_size_t cmdsize, ctlsize; 3294 pcireg_t rev = PCI_REVISION(pa->pa_class); 3295 3296 if (pciide_chipen(sc, pa) == 0) 3297 return; 3298 printf("%s: bus-master DMA support present", 3299 sc->sc_wdcdev.sc_dev.dv_xname); 3300 pciide_mapreg_dma(sc, pa); 3301 printf("\n"); 3302 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 3303 WDC_CAPABILITY_MODE; 3304 if (sc->sc_dma_ok) { 3305 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA; 3306 if (rev >= 0x20) { 3307 sc->sc_wdcdev.cap |= WDC_CAPABILITY_UDMA; 3308 if (rev >= 0xC4) 3309 sc->sc_wdcdev.UDMA_cap = 5; 3310 else if (rev >= 0xC2) 3311 sc->sc_wdcdev.UDMA_cap = 4; 3312 else 3313 sc->sc_wdcdev.UDMA_cap = 2; 3314 } 3315 sc->sc_wdcdev.cap |= WDC_CAPABILITY_IRQACK; 3316 sc->sc_wdcdev.irqack = pciide_irqack; 3317 } 3318 3319 sc->sc_wdcdev.PIO_cap = 4; 3320 sc->sc_wdcdev.DMA_cap = 2; 3321 sc->sc_wdcdev.set_modes = acer_setup_channel; 3322 sc->sc_wdcdev.channels = sc->wdc_chanarray; 3323 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 3324 3325 pciide_pci_write(sc->sc_pc, sc->sc_tag, ACER_CDRC, 3326 (pciide_pci_read(sc->sc_pc, sc->sc_tag, ACER_CDRC) | 3327 ACER_CDRC_DMA_EN) & ~ACER_CDRC_FIFO_DISABLE); 3328 3329 /* Enable "microsoft register bits" R/W. */ 3330 pciide_pci_write(sc->sc_pc, sc->sc_tag, ACER_CCAR3, 3331 pciide_pci_read(sc->sc_pc, sc->sc_tag, ACER_CCAR3) | ACER_CCAR3_PI); 3332 pciide_pci_write(sc->sc_pc, sc->sc_tag, ACER_CCAR1, 3333 pciide_pci_read(sc->sc_pc, sc->sc_tag, ACER_CCAR1) & 3334 ~(ACER_CHANSTATUS_RO|PCIIDE_CHAN_RO(0)|PCIIDE_CHAN_RO(1))); 3335 pciide_pci_write(sc->sc_pc, sc->sc_tag, ACER_CCAR2, 3336 pciide_pci_read(sc->sc_pc, sc->sc_tag, ACER_CCAR2) & 3337 ~ACER_CHANSTATUSREGS_RO); 3338 cr = pci_conf_read(sc->sc_pc, sc->sc_tag, PCI_CLASS_REG); 3339 cr |= (PCIIDE_CHANSTATUS_EN << PCI_INTERFACE_SHIFT); 3340 pci_conf_write(sc->sc_pc, sc->sc_tag, PCI_CLASS_REG, cr); 3341 /* Don't use cr, re-read the real register content instead */ 3342 interface = PCI_INTERFACE(pci_conf_read(sc->sc_pc, sc->sc_tag, 3343 PCI_CLASS_REG)); 3344 3345 /* From linux: enable "Cable Detection" */ 3346 if (rev >= 0xC2) { 3347 pciide_pci_write(sc->sc_pc, sc->sc_tag, ACER_0x4B, 3348 pciide_pci_read(sc->sc_pc, sc->sc_tag, ACER_0x4B) 3349 | ACER_0x4B_CDETECT); 3350 } 3351 3352 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 3353 cp = &sc->pciide_channels[channel]; 3354 if (pciide_chansetup(sc, channel, interface) == 0) 3355 continue; 3356 if ((interface & PCIIDE_CHAN_EN(channel)) == 0) { 3357 printf("%s: %s channel ignored (disabled)\n", 3358 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 3359 continue; 3360 } 3361 /* newer controllers seems to lack the ACER_CHIDS. Sigh */ 3362 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 3363 (rev >= 0xC2) ? pciide_pci_intr : acer_pci_intr); 3364 if (cp->hw_ok == 0) 3365 continue; 3366 if (pciide_chan_candisable(cp)) { 3367 cr &= ~(PCIIDE_CHAN_EN(channel) << PCI_INTERFACE_SHIFT); 3368 pci_conf_write(sc->sc_pc, sc->sc_tag, 3369 PCI_CLASS_REG, cr); 3370 } 3371 pciide_map_compat_intr(pa, cp, channel, interface); 3372 acer_setup_channel(&cp->wdc_channel); 3373 } 3374 } 3375 3376 void 3377 acer_setup_channel(chp) 3378 struct channel_softc *chp; 3379 { 3380 struct ata_drive_datas *drvp; 3381 int drive; 3382 u_int32_t acer_fifo_udma; 3383 u_int32_t idedma_ctl; 3384 struct pciide_channel *cp = (struct pciide_channel*)chp; 3385 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 3386 3387 idedma_ctl = 0; 3388 acer_fifo_udma = pci_conf_read(sc->sc_pc, sc->sc_tag, ACER_FTH_UDMA); 3389 WDCDEBUG_PRINT(("acer_setup_channel: old fifo/udma reg 0x%x\n", 3390 acer_fifo_udma), DEBUG_PROBE); 3391 /* setup DMA if needed */ 3392 pciide_channel_dma_setup(cp); 3393 3394 if ((chp->ch_drive[0].drive_flags | chp->ch_drive[1].drive_flags) & 3395 DRIVE_UDMA) { /* check 80 pins cable */ 3396 if (pciide_pci_read(sc->sc_pc, sc->sc_tag, ACER_0x4A) & 3397 ACER_0x4A_80PIN(chp->channel)) { 3398 if (chp->ch_drive[0].UDMA_mode > 2) 3399 chp->ch_drive[0].UDMA_mode = 2; 3400 if (chp->ch_drive[1].UDMA_mode > 2) 3401 chp->ch_drive[1].UDMA_mode = 2; 3402 } 3403 } 3404 3405 for (drive = 0; drive < 2; drive++) { 3406 drvp = &chp->ch_drive[drive]; 3407 /* If no drive, skip */ 3408 if ((drvp->drive_flags & DRIVE) == 0) 3409 continue; 3410 WDCDEBUG_PRINT(("acer_setup_channel: old timings reg for " 3411 "channel %d drive %d 0x%x\n", chp->channel, drive, 3412 pciide_pci_read(sc->sc_pc, sc->sc_tag, 3413 ACER_IDETIM(chp->channel, drive))), DEBUG_PROBE); 3414 /* clear FIFO/DMA mode */ 3415 acer_fifo_udma &= ~(ACER_FTH_OPL(chp->channel, drive, 0x3) | 3416 ACER_UDMA_EN(chp->channel, drive) | 3417 ACER_UDMA_TIM(chp->channel, drive, 0x7)); 3418 3419 /* add timing values, setup DMA if needed */ 3420 if ((drvp->drive_flags & DRIVE_DMA) == 0 && 3421 (drvp->drive_flags & DRIVE_UDMA) == 0) { 3422 acer_fifo_udma |= 3423 ACER_FTH_OPL(chp->channel, drive, 0x1); 3424 goto pio; 3425 } 3426 3427 acer_fifo_udma |= ACER_FTH_OPL(chp->channel, drive, 0x2); 3428 if (drvp->drive_flags & DRIVE_UDMA) { 3429 /* use Ultra/DMA */ 3430 drvp->drive_flags &= ~DRIVE_DMA; 3431 acer_fifo_udma |= ACER_UDMA_EN(chp->channel, drive); 3432 acer_fifo_udma |= 3433 ACER_UDMA_TIM(chp->channel, drive, 3434 acer_udma[drvp->UDMA_mode]); 3435 /* XXX disable if one drive < UDMA3 ? */ 3436 if (drvp->UDMA_mode >= 3) { 3437 pciide_pci_write(sc->sc_pc, sc->sc_tag, 3438 ACER_0x4B, 3439 pciide_pci_read(sc->sc_pc, sc->sc_tag, 3440 ACER_0x4B) | ACER_0x4B_UDMA66); 3441 } 3442 } else { 3443 /* 3444 * use Multiword DMA 3445 * Timings will be used for both PIO and DMA, 3446 * so adjust DMA mode if needed 3447 */ 3448 if (drvp->PIO_mode > (drvp->DMA_mode + 2)) 3449 drvp->PIO_mode = drvp->DMA_mode + 2; 3450 if (drvp->DMA_mode + 2 > (drvp->PIO_mode)) 3451 drvp->DMA_mode = (drvp->PIO_mode > 2) ? 3452 drvp->PIO_mode - 2 : 0; 3453 if (drvp->DMA_mode == 0) 3454 drvp->PIO_mode = 0; 3455 } 3456 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 3457 pio: pciide_pci_write(sc->sc_pc, sc->sc_tag, 3458 ACER_IDETIM(chp->channel, drive), 3459 acer_pio[drvp->PIO_mode]); 3460 } 3461 WDCDEBUG_PRINT(("acer_setup_channel: new fifo/udma reg 0x%x\n", 3462 acer_fifo_udma), DEBUG_PROBE); 3463 pci_conf_write(sc->sc_pc, sc->sc_tag, ACER_FTH_UDMA, acer_fifo_udma); 3464 if (idedma_ctl != 0) { 3465 /* Add software bits in status register */ 3466 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 3467 IDEDMA_CTL, idedma_ctl); 3468 } 3469 pciide_print_modes(cp); 3470 } 3471 3472 int 3473 acer_pci_intr(arg) 3474 void *arg; 3475 { 3476 struct pciide_softc *sc = arg; 3477 struct pciide_channel *cp; 3478 struct channel_softc *wdc_cp; 3479 int i, rv, crv; 3480 u_int32_t chids; 3481 3482 rv = 0; 3483 chids = pciide_pci_read(sc->sc_pc, sc->sc_tag, ACER_CHIDS); 3484 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 3485 cp = &sc->pciide_channels[i]; 3486 wdc_cp = &cp->wdc_channel; 3487 /* If a compat channel skip. */ 3488 if (cp->compat) 3489 continue; 3490 if (chids & ACER_CHIDS_INT(i)) { 3491 crv = wdcintr(wdc_cp); 3492 if (crv == 0) 3493 printf("%s:%d: bogus intr\n", 3494 sc->sc_wdcdev.sc_dev.dv_xname, i); 3495 else 3496 rv = 1; 3497 } 3498 } 3499 return rv; 3500 } 3501 3502 void 3503 hpt_chip_map(sc, pa) 3504 struct pciide_softc *sc; 3505 struct pci_attach_args *pa; 3506 { 3507 struct pciide_channel *cp; 3508 int i, compatchan, revision; 3509 pcireg_t interface; 3510 bus_size_t cmdsize, ctlsize; 3511 3512 if (pciide_chipen(sc, pa) == 0) 3513 return; 3514 revision = PCI_REVISION(pa->pa_class); 3515 printf(": Triones/Highpoint "); 3516 if (sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT374) 3517 printf("HPT374 IDE Controller\n"); 3518 else if (sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT372) 3519 printf("HPT372 IDE Controller\n"); 3520 else if (sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT366) { 3521 if (revision == HPT372_REV) 3522 printf("HPT372 IDE Controller\n"); 3523 else if (revision == HPT370_REV) 3524 printf("HPT370 IDE Controller\n"); 3525 else if (revision == HPT370A_REV) 3526 printf("HPT370A IDE Controller\n"); 3527 else if (revision == HPT366_REV) 3528 printf("HPT366 IDE Controller\n"); 3529 else 3530 printf("unknown HPT IDE controller rev %d\n", revision); 3531 } else 3532 printf("unknown HPT IDE controller 0x%x\n", 3533 sc->sc_pp->ide_product); 3534 3535 /* 3536 * when the chip is in native mode it identifies itself as a 3537 * 'misc mass storage'. Fake interface in this case. 3538 */ 3539 if (PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_MASS_STORAGE_IDE) { 3540 interface = PCI_INTERFACE(pa->pa_class); 3541 } else { 3542 interface = PCIIDE_INTERFACE_BUS_MASTER_DMA | 3543 PCIIDE_INTERFACE_PCI(0); 3544 if ((sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT366 && 3545 (revision == HPT370_REV || revision == HPT370A_REV || 3546 revision == HPT372_REV)) || 3547 sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT372 || 3548 sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT374) 3549 interface |= PCIIDE_INTERFACE_PCI(1); 3550 } 3551 3552 printf("%s: bus-master DMA support present", 3553 sc->sc_wdcdev.sc_dev.dv_xname); 3554 pciide_mapreg_dma(sc, pa); 3555 printf("\n"); 3556 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 3557 WDC_CAPABILITY_MODE; 3558 if (sc->sc_dma_ok) { 3559 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_UDMA; 3560 sc->sc_wdcdev.cap |= WDC_CAPABILITY_IRQACK; 3561 sc->sc_wdcdev.irqack = pciide_irqack; 3562 } 3563 sc->sc_wdcdev.PIO_cap = 4; 3564 sc->sc_wdcdev.DMA_cap = 2; 3565 3566 sc->sc_wdcdev.set_modes = hpt_setup_channel; 3567 sc->sc_wdcdev.channels = sc->wdc_chanarray; 3568 if (sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT366 && 3569 revision == HPT366_REV) { 3570 sc->sc_wdcdev.UDMA_cap = 4; 3571 /* 3572 * The 366 has 2 PCI IDE functions, one for primary and one 3573 * for secondary. So we need to call pciide_mapregs_compat() 3574 * with the real channel 3575 */ 3576 if (pa->pa_function == 0) { 3577 compatchan = 0; 3578 } else if (pa->pa_function == 1) { 3579 compatchan = 1; 3580 } else { 3581 printf("%s: unexpected PCI function %d\n", 3582 sc->sc_wdcdev.sc_dev.dv_xname, pa->pa_function); 3583 return; 3584 } 3585 sc->sc_wdcdev.nchannels = 1; 3586 } else { 3587 sc->sc_wdcdev.nchannels = 2; 3588 if (sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT374 || 3589 sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT372 || 3590 (sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT366 && 3591 revision == HPT372_REV)) 3592 sc->sc_wdcdev.UDMA_cap = 6; 3593 else 3594 sc->sc_wdcdev.UDMA_cap = 5; 3595 } 3596 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 3597 cp = &sc->pciide_channels[i]; 3598 if (sc->sc_wdcdev.nchannels > 1) { 3599 compatchan = i; 3600 if((pciide_pci_read(sc->sc_pc, sc->sc_tag, 3601 HPT370_CTRL1(i)) & HPT370_CTRL1_EN) == 0) { 3602 printf("%s: %s channel ignored (disabled)\n", 3603 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 3604 continue; 3605 } 3606 } 3607 if (pciide_chansetup(sc, i, interface) == 0) 3608 continue; 3609 if (interface & PCIIDE_INTERFACE_PCI(i)) { 3610 cp->hw_ok = pciide_mapregs_native(pa, cp, &cmdsize, 3611 &ctlsize, hpt_pci_intr); 3612 } else { 3613 cp->hw_ok = pciide_mapregs_compat(pa, cp, compatchan, 3614 &cmdsize, &ctlsize); 3615 } 3616 if (cp->hw_ok == 0) 3617 return; 3618 cp->wdc_channel.data32iot = cp->wdc_channel.cmd_iot; 3619 cp->wdc_channel.data32ioh = cp->wdc_channel.cmd_ioh; 3620 wdcattach(&cp->wdc_channel); 3621 hpt_setup_channel(&cp->wdc_channel); 3622 } 3623 if ((sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT366 && 3624 (revision == HPT370_REV || revision == HPT370A_REV || 3625 revision == HPT372_REV)) || 3626 sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT372 || 3627 sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT374) { 3628 /* 3629 * HPT370_REV and highter has a bit to disable interrupts, 3630 * make sure to clear it 3631 */ 3632 pciide_pci_write(sc->sc_pc, sc->sc_tag, HPT_CSEL, 3633 pciide_pci_read(sc->sc_pc, sc->sc_tag, HPT_CSEL) & 3634 ~HPT_CSEL_IRQDIS); 3635 } 3636 /* set clocks, etc (mandatory on 372/4, optional otherwise) */ 3637 if ((sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT366 && 3638 revision == HPT372_REV ) || 3639 sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT372 || 3640 sc->sc_pp->ide_product == PCI_PRODUCT_TRIONES_HPT374) 3641 pciide_pci_write(sc->sc_pc, sc->sc_tag, HPT_SC2, 3642 (pciide_pci_read(sc->sc_pc, sc->sc_tag, HPT_SC2) & 3643 HPT_SC2_MAEN) | HPT_SC2_OSC_EN); 3644 return; 3645 } 3646 3647 void 3648 hpt_setup_channel(chp) 3649 struct channel_softc *chp; 3650 { 3651 struct ata_drive_datas *drvp; 3652 int drive; 3653 int cable; 3654 u_int32_t before, after; 3655 u_int32_t idedma_ctl; 3656 struct pciide_channel *cp = (struct pciide_channel*)chp; 3657 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 3658 int revision = 3659 PCI_REVISION(pci_conf_read(sc->sc_pc, sc->sc_tag, PCI_CLASS_REG)); 3660 3661 cable = pciide_pci_read(sc->sc_pc, sc->sc_tag, HPT_CSEL); 3662 3663 /* setup DMA if needed */ 3664 pciide_channel_dma_setup(cp); 3665 3666 idedma_ctl = 0; 3667 3668 /* Per drive settings */ 3669 for (drive = 0; drive < 2; drive++) { 3670 drvp = &chp->ch_drive[drive]; 3671 /* If no drive, skip */ 3672 if ((drvp->drive_flags & DRIVE) == 0) 3673 continue; 3674 before = pci_conf_read(sc->sc_pc, sc->sc_tag, 3675 HPT_IDETIM(chp->channel, drive)); 3676 3677 /* add timing values, setup DMA if needed */ 3678 if (drvp->drive_flags & DRIVE_UDMA) { 3679 /* use Ultra/DMA */ 3680 drvp->drive_flags &= ~DRIVE_DMA; 3681 if ((cable & HPT_CSEL_CBLID(chp->channel)) != 0 && 3682 drvp->UDMA_mode > 2) 3683 drvp->UDMA_mode = 2; 3684 switch (sc->sc_pp->ide_product) { 3685 case PCI_PRODUCT_TRIONES_HPT374: 3686 after = hpt374_udma[drvp->UDMA_mode]; 3687 break; 3688 case PCI_PRODUCT_TRIONES_HPT372: 3689 after = hpt372_udma[drvp->UDMA_mode]; 3690 break; 3691 case PCI_PRODUCT_TRIONES_HPT366: 3692 default: 3693 switch(revision) { 3694 case HPT372_REV: 3695 after = hpt372_udma[drvp->UDMA_mode]; 3696 break; 3697 case HPT370_REV: 3698 case HPT370A_REV: 3699 after = hpt370_udma[drvp->UDMA_mode]; 3700 break; 3701 case HPT366_REV: 3702 default: 3703 after = hpt366_udma[drvp->UDMA_mode]; 3704 break; 3705 } 3706 } 3707 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 3708 } else if (drvp->drive_flags & DRIVE_DMA) { 3709 /* 3710 * use Multiword DMA. 3711 * Timings will be used for both PIO and DMA, so adjust 3712 * DMA mode if needed 3713 */ 3714 if (drvp->PIO_mode >= 3 && 3715 (drvp->DMA_mode + 2) > drvp->PIO_mode) { 3716 drvp->DMA_mode = drvp->PIO_mode - 2; 3717 } 3718 switch (sc->sc_pp->ide_product) { 3719 case PCI_PRODUCT_TRIONES_HPT374: 3720 after = hpt374_dma[drvp->DMA_mode]; 3721 break; 3722 case PCI_PRODUCT_TRIONES_HPT372: 3723 after = hpt372_dma[drvp->DMA_mode]; 3724 break; 3725 case PCI_PRODUCT_TRIONES_HPT366: 3726 default: 3727 switch(revision) { 3728 case HPT372_REV: 3729 after = hpt372_dma[drvp->DMA_mode]; 3730 break; 3731 case HPT370_REV: 3732 case HPT370A_REV: 3733 after = hpt370_dma[drvp->DMA_mode]; 3734 break; 3735 case HPT366_REV: 3736 default: 3737 after = hpt366_dma[drvp->DMA_mode]; 3738 break; 3739 } 3740 } 3741 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 3742 } else { 3743 /* PIO only */ 3744 switch (sc->sc_pp->ide_product) { 3745 case PCI_PRODUCT_TRIONES_HPT374: 3746 after = hpt374_pio[drvp->PIO_mode]; 3747 break; 3748 case PCI_PRODUCT_TRIONES_HPT372: 3749 after = hpt372_pio[drvp->PIO_mode]; 3750 break; 3751 case PCI_PRODUCT_TRIONES_HPT366: 3752 default: 3753 switch(revision) { 3754 case HPT372_REV: 3755 after = hpt372_pio[drvp->PIO_mode]; 3756 break; 3757 case HPT370_REV: 3758 case HPT370A_REV: 3759 after = hpt370_pio[drvp->PIO_mode]; 3760 break; 3761 case HPT366_REV: 3762 default: 3763 after = hpt366_pio[drvp->PIO_mode]; 3764 break; 3765 } 3766 } 3767 } 3768 pci_conf_write(sc->sc_pc, sc->sc_tag, 3769 HPT_IDETIM(chp->channel, drive), after); 3770 WDCDEBUG_PRINT(("%s: bus speed register set to 0x%08x " 3771 "(BIOS 0x%08x)\n", drvp->drv_softc->dv_xname, 3772 after, before), DEBUG_PROBE); 3773 } 3774 if (idedma_ctl != 0) { 3775 /* Add software bits in status register */ 3776 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 3777 IDEDMA_CTL, idedma_ctl); 3778 } 3779 pciide_print_modes(cp); 3780 } 3781 3782 int 3783 hpt_pci_intr(arg) 3784 void *arg; 3785 { 3786 struct pciide_softc *sc = arg; 3787 struct pciide_channel *cp; 3788 struct channel_softc *wdc_cp; 3789 int rv = 0; 3790 int dmastat, i, crv; 3791 3792 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 3793 dmastat = bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 3794 IDEDMA_CTL + IDEDMA_SCH_OFFSET * i); 3795 if((dmastat & ( IDEDMA_CTL_ACT | IDEDMA_CTL_INTR)) != 3796 IDEDMA_CTL_INTR) 3797 continue; 3798 cp = &sc->pciide_channels[i]; 3799 wdc_cp = &cp->wdc_channel; 3800 crv = wdcintr(wdc_cp); 3801 if (crv == 0) { 3802 printf("%s:%d: bogus intr\n", 3803 sc->sc_wdcdev.sc_dev.dv_xname, i); 3804 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 3805 IDEDMA_CTL + IDEDMA_SCH_OFFSET * i, dmastat); 3806 } else 3807 rv = 1; 3808 } 3809 return rv; 3810 } 3811 3812 3813 /* Macros to test product */ 3814 #define PDC_IS_262(sc) \ 3815 ((sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA66 || \ 3816 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100 || \ 3817 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100X || \ 3818 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100TX2 || \ 3819 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100TX2v2 || \ 3820 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133 || \ 3821 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133TX2 || \ 3822 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133TX2v2) 3823 #define PDC_IS_265(sc) \ 3824 ((sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100 || \ 3825 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100X || \ 3826 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100TX2 || \ 3827 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100TX2v2 || \ 3828 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133 || \ 3829 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133TX2 || \ 3830 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133TX2v2) 3831 #define PDC_IS_268(sc) \ 3832 ((sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100TX2 || \ 3833 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100TX2v2 || \ 3834 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133 || \ 3835 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133TX2 || \ 3836 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133TX2v2) 3837 #define PDC_IS_276(sc) \ 3838 ((sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133 || \ 3839 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133TX2 || \ 3840 (sc)->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA133TX2v2) 3841 3842 void 3843 pdc202xx_chip_map(sc, pa) 3844 struct pciide_softc *sc; 3845 struct pci_attach_args *pa; 3846 { 3847 struct pciide_channel *cp; 3848 int channel; 3849 pcireg_t interface, st, mode; 3850 bus_size_t cmdsize, ctlsize; 3851 3852 if (!PDC_IS_268(sc)) { 3853 st = pci_conf_read(sc->sc_pc, sc->sc_tag, PDC2xx_STATE); 3854 WDCDEBUG_PRINT(("pdc202xx_setup_chip: controller state 0x%x\n", 3855 st), DEBUG_PROBE); 3856 } 3857 if (pciide_chipen(sc, pa) == 0) 3858 return; 3859 3860 /* turn off RAID mode */ 3861 if (!PDC_IS_268(sc)) 3862 st &= ~PDC2xx_STATE_IDERAID; 3863 3864 /* 3865 * can't rely on the PCI_CLASS_REG content if the chip was in raid 3866 * mode. We have to fake interface 3867 */ 3868 interface = PCIIDE_INTERFACE_SETTABLE(0) | PCIIDE_INTERFACE_SETTABLE(1); 3869 if (PDC_IS_268(sc) || (st & PDC2xx_STATE_NATIVE)) 3870 interface |= PCIIDE_INTERFACE_PCI(0) | PCIIDE_INTERFACE_PCI(1); 3871 3872 printf("%s: bus-master DMA support present", 3873 sc->sc_wdcdev.sc_dev.dv_xname); 3874 pciide_mapreg_dma(sc, pa); 3875 printf("\n"); 3876 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 3877 WDC_CAPABILITY_MODE; 3878 if (sc->sc_dma_ok) { 3879 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_UDMA; 3880 sc->sc_wdcdev.cap |= WDC_CAPABILITY_IRQACK; 3881 sc->sc_wdcdev.irqack = pciide_irqack; 3882 } 3883 sc->sc_wdcdev.PIO_cap = 4; 3884 sc->sc_wdcdev.DMA_cap = 2; 3885 if (PDC_IS_276(sc)) 3886 sc->sc_wdcdev.UDMA_cap = 6; 3887 else if (PDC_IS_265(sc)) 3888 sc->sc_wdcdev.UDMA_cap = 5; 3889 else if (PDC_IS_262(sc)) 3890 sc->sc_wdcdev.UDMA_cap = 4; 3891 else 3892 sc->sc_wdcdev.UDMA_cap = 2; 3893 sc->sc_wdcdev.set_modes = PDC_IS_268(sc) ? 3894 pdc20268_setup_channel : pdc202xx_setup_channel; 3895 sc->sc_wdcdev.channels = sc->wdc_chanarray; 3896 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 3897 3898 if (sc->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA66 || 3899 sc->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100 || 3900 sc->sc_pp->ide_product == PCI_PRODUCT_PROMISE_ULTRA100X) { 3901 sc->sc_wdcdev.dma_start = pdc20262_dma_start; 3902 sc->sc_wdcdev.dma_finish = pdc20262_dma_finish; 3903 } 3904 3905 if (!PDC_IS_268(sc)) { 3906 /* setup failsafe defaults */ 3907 mode = 0; 3908 mode = PDC2xx_TIM_SET_PA(mode, pdc2xx_pa[0]); 3909 mode = PDC2xx_TIM_SET_PB(mode, pdc2xx_pb[0]); 3910 mode = PDC2xx_TIM_SET_MB(mode, pdc2xx_dma_mb[0]); 3911 mode = PDC2xx_TIM_SET_MC(mode, pdc2xx_dma_mc[0]); 3912 for (channel = 0; 3913 channel < sc->sc_wdcdev.nchannels; 3914 channel++) { 3915 WDCDEBUG_PRINT(("pdc202xx_setup_chip: channel %d " 3916 "drive 0 initial timings 0x%x, now 0x%x\n", 3917 channel, pci_conf_read(sc->sc_pc, sc->sc_tag, 3918 PDC2xx_TIM(channel, 0)), mode | PDC2xx_TIM_IORDYp), 3919 DEBUG_PROBE); 3920 pci_conf_write(sc->sc_pc, sc->sc_tag, 3921 PDC2xx_TIM(channel, 0), mode | PDC2xx_TIM_IORDYp); 3922 WDCDEBUG_PRINT(("pdc202xx_setup_chip: channel %d " 3923 "drive 1 initial timings 0x%x, now 0x%x\n", 3924 channel, pci_conf_read(sc->sc_pc, sc->sc_tag, 3925 PDC2xx_TIM(channel, 1)), mode), DEBUG_PROBE); 3926 pci_conf_write(sc->sc_pc, sc->sc_tag, 3927 PDC2xx_TIM(channel, 1), mode); 3928 } 3929 3930 mode = PDC2xx_SCR_DMA; 3931 if (PDC_IS_265(sc)) { 3932 mode = PDC2xx_SCR_SET_GEN(mode, PDC265_SCR_GEN_LAT); 3933 } else if (PDC_IS_262(sc)) { 3934 mode = PDC2xx_SCR_SET_GEN(mode, PDC262_SCR_GEN_LAT); 3935 } else { 3936 /* the BIOS set it up this way */ 3937 mode = PDC2xx_SCR_SET_GEN(mode, 0x1); 3938 } 3939 mode = PDC2xx_SCR_SET_I2C(mode, 0x3); /* ditto */ 3940 mode = PDC2xx_SCR_SET_POLL(mode, 0x1); /* ditto */ 3941 WDCDEBUG_PRINT(("pdc202xx_setup_chip: initial SCR 0x%x, " 3942 "now 0x%x\n", 3943 bus_space_read_4(sc->sc_dma_iot, sc->sc_dma_ioh, 3944 PDC2xx_SCR), 3945 mode), DEBUG_PROBE); 3946 bus_space_write_4(sc->sc_dma_iot, sc->sc_dma_ioh, 3947 PDC2xx_SCR, mode); 3948 3949 /* controller initial state register is OK even without BIOS */ 3950 /* Set DMA mode to IDE DMA compatibility */ 3951 mode = 3952 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, PDC2xx_PM); 3953 WDCDEBUG_PRINT(("pdc202xx_setup_chip: primary mode 0x%x", mode), 3954 DEBUG_PROBE); 3955 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, PDC2xx_PM, 3956 mode | 0x1); 3957 mode = 3958 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, PDC2xx_SM); 3959 WDCDEBUG_PRINT((", secondary mode 0x%x\n", mode ), DEBUG_PROBE); 3960 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, PDC2xx_SM, 3961 mode | 0x1); 3962 } 3963 3964 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 3965 cp = &sc->pciide_channels[channel]; 3966 if (pciide_chansetup(sc, channel, interface) == 0) 3967 continue; 3968 if (!PDC_IS_268(sc) && (st & (PDC_IS_262(sc) ? 3969 PDC262_STATE_EN(channel):PDC246_STATE_EN(channel))) == 0) { 3970 printf("%s: %s channel ignored (disabled)\n", 3971 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 3972 continue; 3973 } 3974 if (PDC_IS_265(sc)) 3975 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 3976 pdc20265_pci_intr); 3977 else 3978 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 3979 pdc202xx_pci_intr); 3980 if (cp->hw_ok == 0) 3981 continue; 3982 if (!PDC_IS_268(sc) && pciide_chan_candisable(cp)) 3983 st &= ~(PDC_IS_262(sc) ? 3984 PDC262_STATE_EN(channel):PDC246_STATE_EN(channel)); 3985 pciide_map_compat_intr(pa, cp, channel, interface); 3986 sc->sc_wdcdev.set_modes(&cp->wdc_channel); 3987 } 3988 if (!PDC_IS_268(sc)) { 3989 WDCDEBUG_PRINT(("pdc202xx_setup_chip: new controller state " 3990 "0x%x\n", st), DEBUG_PROBE); 3991 pci_conf_write(sc->sc_pc, sc->sc_tag, PDC2xx_STATE, st); 3992 } 3993 return; 3994 } 3995 3996 void 3997 pdc202xx_setup_channel(chp) 3998 struct channel_softc *chp; 3999 { 4000 struct ata_drive_datas *drvp; 4001 int drive; 4002 pcireg_t mode, st; 4003 u_int32_t idedma_ctl, scr, atapi; 4004 struct pciide_channel *cp = (struct pciide_channel*)chp; 4005 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 4006 int channel = chp->channel; 4007 4008 /* setup DMA if needed */ 4009 pciide_channel_dma_setup(cp); 4010 4011 idedma_ctl = 0; 4012 WDCDEBUG_PRINT(("pdc202xx_setup_channel %s: scr 0x%x\n", 4013 sc->sc_wdcdev.sc_dev.dv_xname, 4014 bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, PDC262_U66)), 4015 DEBUG_PROBE); 4016 4017 /* Per channel settings */ 4018 if (PDC_IS_262(sc)) { 4019 scr = bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4020 PDC262_U66); 4021 st = pci_conf_read(sc->sc_pc, sc->sc_tag, PDC2xx_STATE); 4022 /* Trim UDMA mode */ 4023 if ((st & PDC262_STATE_80P(channel)) != 0 || 4024 (chp->ch_drive[0].drive_flags & DRIVE_UDMA && 4025 chp->ch_drive[0].UDMA_mode <= 2) || 4026 (chp->ch_drive[1].drive_flags & DRIVE_UDMA && 4027 chp->ch_drive[1].UDMA_mode <= 2)) { 4028 if (chp->ch_drive[0].UDMA_mode > 2) 4029 chp->ch_drive[0].UDMA_mode = 2; 4030 if (chp->ch_drive[1].UDMA_mode > 2) 4031 chp->ch_drive[1].UDMA_mode = 2; 4032 } 4033 /* Set U66 if needed */ 4034 if ((chp->ch_drive[0].drive_flags & DRIVE_UDMA && 4035 chp->ch_drive[0].UDMA_mode > 2) || 4036 (chp->ch_drive[1].drive_flags & DRIVE_UDMA && 4037 chp->ch_drive[1].UDMA_mode > 2)) 4038 scr |= PDC262_U66_EN(channel); 4039 else 4040 scr &= ~PDC262_U66_EN(channel); 4041 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4042 PDC262_U66, scr); 4043 WDCDEBUG_PRINT(("pdc202xx_setup_channel %s:%d: ATAPI 0x%x\n", 4044 sc->sc_wdcdev.sc_dev.dv_xname, channel, 4045 bus_space_read_4(sc->sc_dma_iot, sc->sc_dma_ioh, 4046 PDC262_ATAPI(channel))), DEBUG_PROBE); 4047 if (chp->ch_drive[0].drive_flags & DRIVE_ATAPI || 4048 chp->ch_drive[1].drive_flags & DRIVE_ATAPI) { 4049 if (((chp->ch_drive[0].drive_flags & DRIVE_UDMA) && 4050 !(chp->ch_drive[1].drive_flags & DRIVE_UDMA) && 4051 (chp->ch_drive[1].drive_flags & DRIVE_DMA)) || 4052 ((chp->ch_drive[1].drive_flags & DRIVE_UDMA) && 4053 !(chp->ch_drive[0].drive_flags & DRIVE_UDMA) && 4054 (chp->ch_drive[0].drive_flags & DRIVE_DMA))) 4055 atapi = 0; 4056 else 4057 atapi = PDC262_ATAPI_UDMA; 4058 bus_space_write_4(sc->sc_dma_iot, sc->sc_dma_ioh, 4059 PDC262_ATAPI(channel), atapi); 4060 } 4061 } 4062 for (drive = 0; drive < 2; drive++) { 4063 drvp = &chp->ch_drive[drive]; 4064 /* If no drive, skip */ 4065 if ((drvp->drive_flags & DRIVE) == 0) 4066 continue; 4067 mode = 0; 4068 if (drvp->drive_flags & DRIVE_UDMA) { 4069 /* use Ultra/DMA */ 4070 drvp->drive_flags &= ~DRIVE_DMA; 4071 mode = PDC2xx_TIM_SET_MB(mode, 4072 pdc2xx_udma_mb[drvp->UDMA_mode]); 4073 mode = PDC2xx_TIM_SET_MC(mode, 4074 pdc2xx_udma_mc[drvp->UDMA_mode]); 4075 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 4076 } else if (drvp->drive_flags & DRIVE_DMA) { 4077 mode = PDC2xx_TIM_SET_MB(mode, 4078 pdc2xx_dma_mb[drvp->DMA_mode]); 4079 mode = PDC2xx_TIM_SET_MC(mode, 4080 pdc2xx_dma_mc[drvp->DMA_mode]); 4081 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 4082 } else { 4083 mode = PDC2xx_TIM_SET_MB(mode, 4084 pdc2xx_dma_mb[0]); 4085 mode = PDC2xx_TIM_SET_MC(mode, 4086 pdc2xx_dma_mc[0]); 4087 } 4088 mode = PDC2xx_TIM_SET_PA(mode, pdc2xx_pa[drvp->PIO_mode]); 4089 mode = PDC2xx_TIM_SET_PB(mode, pdc2xx_pb[drvp->PIO_mode]); 4090 if (drvp->drive_flags & DRIVE_ATA) 4091 mode |= PDC2xx_TIM_PRE; 4092 mode |= PDC2xx_TIM_SYNC | PDC2xx_TIM_ERRDY; 4093 if (drvp->PIO_mode >= 3) { 4094 mode |= PDC2xx_TIM_IORDY; 4095 if (drive == 0) 4096 mode |= PDC2xx_TIM_IORDYp; 4097 } 4098 WDCDEBUG_PRINT(("pdc202xx_setup_channel: %s:%d:%d " 4099 "timings 0x%x\n", 4100 sc->sc_wdcdev.sc_dev.dv_xname, 4101 chp->channel, drive, mode), DEBUG_PROBE); 4102 pci_conf_write(sc->sc_pc, sc->sc_tag, 4103 PDC2xx_TIM(chp->channel, drive), mode); 4104 } 4105 if (idedma_ctl != 0) { 4106 /* Add software bits in status register */ 4107 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4108 IDEDMA_CTL, idedma_ctl); 4109 } 4110 pciide_print_modes(cp); 4111 } 4112 4113 void 4114 pdc20268_setup_channel(chp) 4115 struct channel_softc *chp; 4116 { 4117 struct ata_drive_datas *drvp; 4118 int drive; 4119 u_int32_t idedma_ctl; 4120 struct pciide_channel *cp = (struct pciide_channel*)chp; 4121 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 4122 int u100; 4123 4124 /* setup DMA if needed */ 4125 pciide_channel_dma_setup(cp); 4126 4127 idedma_ctl = 0; 4128 4129 /* I don't know what this is for, FreeBSD does it ... */ 4130 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4131 IDEDMA_CMD + 0x1 + IDEDMA_SCH_OFFSET * chp->channel, 0x0b); 4132 4133 /* 4134 * cable type detect, from FreeBSD 4135 */ 4136 u100 = (bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4137 IDEDMA_CMD + 0x3 + IDEDMA_SCH_OFFSET * chp->channel) & 0x04) ? 4138 0 : 1; 4139 4140 for (drive = 0; drive < 2; drive++) { 4141 drvp = &chp->ch_drive[drive]; 4142 /* If no drive, skip */ 4143 if ((drvp->drive_flags & DRIVE) == 0) 4144 continue; 4145 if (drvp->drive_flags & DRIVE_UDMA) { 4146 /* use Ultra/DMA */ 4147 drvp->drive_flags &= ~DRIVE_DMA; 4148 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 4149 if (drvp->UDMA_mode > 2 && u100 == 0) 4150 drvp->UDMA_mode = 2; 4151 } else if (drvp->drive_flags & DRIVE_DMA) { 4152 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 4153 } 4154 } 4155 /* nothing to do to setup modes, the controller snoop SET_FEATURE cmd */ 4156 if (idedma_ctl != 0) { 4157 /* Add software bits in status register */ 4158 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4159 IDEDMA_CTL, idedma_ctl); 4160 } 4161 pciide_print_modes(cp); 4162 } 4163 4164 int 4165 pdc202xx_pci_intr(arg) 4166 void *arg; 4167 { 4168 struct pciide_softc *sc = arg; 4169 struct pciide_channel *cp; 4170 struct channel_softc *wdc_cp; 4171 int i, rv, crv; 4172 u_int32_t scr; 4173 4174 rv = 0; 4175 scr = bus_space_read_4(sc->sc_dma_iot, sc->sc_dma_ioh, PDC2xx_SCR); 4176 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 4177 cp = &sc->pciide_channels[i]; 4178 wdc_cp = &cp->wdc_channel; 4179 /* If a compat channel skip. */ 4180 if (cp->compat) 4181 continue; 4182 if (scr & PDC2xx_SCR_INT(i)) { 4183 crv = wdcintr(wdc_cp); 4184 if (crv == 0) 4185 printf("%s:%d: bogus intr (reg 0x%x)\n", 4186 sc->sc_wdcdev.sc_dev.dv_xname, i, scr); 4187 else 4188 rv = 1; 4189 } 4190 } 4191 return rv; 4192 } 4193 4194 int 4195 pdc20265_pci_intr(arg) 4196 void *arg; 4197 { 4198 struct pciide_softc *sc = arg; 4199 struct pciide_channel *cp; 4200 struct channel_softc *wdc_cp; 4201 int i, rv, crv; 4202 u_int32_t dmastat; 4203 4204 rv = 0; 4205 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 4206 cp = &sc->pciide_channels[i]; 4207 wdc_cp = &cp->wdc_channel; 4208 /* If a compat channel skip. */ 4209 if (cp->compat) 4210 continue; 4211 /* 4212 * The Ultra/100 seems to assert PDC2xx_SCR_INT * spuriously, 4213 * however it asserts INT in IDEDMA_CTL even for non-DMA ops. 4214 * So use it instead (requires 2 reg reads instead of 1, 4215 * but we can't do it another way). 4216 */ 4217 dmastat = bus_space_read_1(sc->sc_dma_iot, 4218 sc->sc_dma_ioh, IDEDMA_CTL + IDEDMA_SCH_OFFSET * i); 4219 if((dmastat & IDEDMA_CTL_INTR) == 0) 4220 continue; 4221 crv = wdcintr(wdc_cp); 4222 if (crv == 0) 4223 printf("%s:%d: bogus intr\n", 4224 sc->sc_wdcdev.sc_dev.dv_xname, i); 4225 else 4226 rv = 1; 4227 } 4228 return rv; 4229 } 4230 4231 static void 4232 pdc20262_dma_start(v, channel, drive) 4233 void *v; 4234 int channel, drive; 4235 { 4236 struct pciide_softc *sc = v; 4237 struct pciide_dma_maps *dma_maps = 4238 &sc->pciide_channels[channel].dma_maps[drive]; 4239 int atapi; 4240 4241 if (dma_maps->dma_flags & WDC_DMA_LBA48) { 4242 atapi = (dma_maps->dma_flags & WDC_DMA_READ) ? 4243 PDC262_ATAPI_LBA48_READ : PDC262_ATAPI_LBA48_WRITE; 4244 atapi |= dma_maps->dmamap_xfer->dm_mapsize >> 1; 4245 bus_space_write_4(sc->sc_dma_iot, sc->sc_dma_ioh, 4246 PDC262_ATAPI(channel), atapi); 4247 } 4248 4249 pciide_dma_start(v, channel, drive); 4250 } 4251 4252 int 4253 pdc20262_dma_finish(v, channel, drive, force) 4254 void *v; 4255 int channel, drive; 4256 int force; 4257 { 4258 struct pciide_softc *sc = v; 4259 struct pciide_dma_maps *dma_maps = 4260 &sc->pciide_channels[channel].dma_maps[drive]; 4261 struct channel_softc *chp; 4262 int atapi, error; 4263 4264 error = pciide_dma_finish(v, channel, drive, force); 4265 4266 if (dma_maps->dma_flags & WDC_DMA_LBA48) { 4267 chp = sc->wdc_chanarray[channel]; 4268 atapi = 0; 4269 if (chp->ch_drive[0].drive_flags & DRIVE_ATAPI || 4270 chp->ch_drive[1].drive_flags & DRIVE_ATAPI) { 4271 if ((!(chp->ch_drive[0].drive_flags & DRIVE_UDMA) || 4272 (chp->ch_drive[1].drive_flags & DRIVE_UDMA) || 4273 !(chp->ch_drive[1].drive_flags & DRIVE_DMA)) && 4274 (!(chp->ch_drive[1].drive_flags & DRIVE_UDMA) || 4275 (chp->ch_drive[0].drive_flags & DRIVE_UDMA) || 4276 !(chp->ch_drive[0].drive_flags & DRIVE_DMA))) 4277 atapi = PDC262_ATAPI_UDMA; 4278 } 4279 bus_space_write_4(sc->sc_dma_iot, sc->sc_dma_ioh, 4280 PDC262_ATAPI(channel), atapi); 4281 } 4282 4283 return error; 4284 } 4285 4286 void 4287 opti_chip_map(sc, pa) 4288 struct pciide_softc *sc; 4289 struct pci_attach_args *pa; 4290 { 4291 struct pciide_channel *cp; 4292 bus_size_t cmdsize, ctlsize; 4293 pcireg_t interface; 4294 u_int8_t init_ctrl; 4295 int channel; 4296 4297 if (pciide_chipen(sc, pa) == 0) 4298 return; 4299 printf("%s: bus-master DMA support present", 4300 sc->sc_wdcdev.sc_dev.dv_xname); 4301 4302 /* 4303 * XXXSCW: 4304 * There seem to be a couple of buggy revisions/implementations 4305 * of the OPTi pciide chipset. This kludge seems to fix one of 4306 * the reported problems (PR/11644) but still fails for the 4307 * other (PR/13151), although the latter may be due to other 4308 * issues too... 4309 */ 4310 if (PCI_REVISION(pa->pa_class) <= 0x12) { 4311 printf(" but disabled due to chip rev. <= 0x12"); 4312 sc->sc_dma_ok = 0; 4313 } else 4314 pciide_mapreg_dma(sc, pa); 4315 4316 printf("\n"); 4317 4318 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA32 | WDC_CAPABILITY_DATA16 | 4319 WDC_CAPABILITY_MODE; 4320 sc->sc_wdcdev.PIO_cap = 4; 4321 if (sc->sc_dma_ok) { 4322 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 4323 sc->sc_wdcdev.irqack = pciide_irqack; 4324 sc->sc_wdcdev.DMA_cap = 2; 4325 } 4326 sc->sc_wdcdev.set_modes = opti_setup_channel; 4327 4328 sc->sc_wdcdev.channels = sc->wdc_chanarray; 4329 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 4330 4331 init_ctrl = pciide_pci_read(sc->sc_pc, sc->sc_tag, 4332 OPTI_REG_INIT_CONTROL); 4333 4334 interface = PCI_INTERFACE(pa->pa_class); 4335 4336 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 4337 cp = &sc->pciide_channels[channel]; 4338 if (pciide_chansetup(sc, channel, interface) == 0) 4339 continue; 4340 if (channel == 1 && 4341 (init_ctrl & OPTI_INIT_CONTROL_CH2_DISABLE) != 0) { 4342 printf("%s: %s channel ignored (disabled)\n", 4343 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 4344 continue; 4345 } 4346 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 4347 pciide_pci_intr); 4348 if (cp->hw_ok == 0) 4349 continue; 4350 pciide_map_compat_intr(pa, cp, channel, interface); 4351 if (cp->hw_ok == 0) 4352 continue; 4353 opti_setup_channel(&cp->wdc_channel); 4354 } 4355 } 4356 4357 void 4358 opti_setup_channel(chp) 4359 struct channel_softc *chp; 4360 { 4361 struct ata_drive_datas *drvp; 4362 struct pciide_channel *cp = (struct pciide_channel*)chp; 4363 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 4364 int drive, spd; 4365 int mode[2]; 4366 u_int8_t rv, mr; 4367 4368 /* 4369 * The `Delay' and `Address Setup Time' fields of the 4370 * Miscellaneous Register are always zero initially. 4371 */ 4372 mr = opti_read_config(chp, OPTI_REG_MISC) & ~OPTI_MISC_INDEX_MASK; 4373 mr &= ~(OPTI_MISC_DELAY_MASK | 4374 OPTI_MISC_ADDR_SETUP_MASK | 4375 OPTI_MISC_INDEX_MASK); 4376 4377 /* Prime the control register before setting timing values */ 4378 opti_write_config(chp, OPTI_REG_CONTROL, OPTI_CONTROL_DISABLE); 4379 4380 /* Determine the clockrate of the PCIbus the chip is attached to */ 4381 spd = (int) opti_read_config(chp, OPTI_REG_STRAP); 4382 spd &= OPTI_STRAP_PCI_SPEED_MASK; 4383 4384 /* setup DMA if needed */ 4385 pciide_channel_dma_setup(cp); 4386 4387 for (drive = 0; drive < 2; drive++) { 4388 drvp = &chp->ch_drive[drive]; 4389 /* If no drive, skip */ 4390 if ((drvp->drive_flags & DRIVE) == 0) { 4391 mode[drive] = -1; 4392 continue; 4393 } 4394 4395 if ((drvp->drive_flags & DRIVE_DMA)) { 4396 /* 4397 * Timings will be used for both PIO and DMA, 4398 * so adjust DMA mode if needed 4399 */ 4400 if (drvp->PIO_mode > (drvp->DMA_mode + 2)) 4401 drvp->PIO_mode = drvp->DMA_mode + 2; 4402 if (drvp->DMA_mode + 2 > (drvp->PIO_mode)) 4403 drvp->DMA_mode = (drvp->PIO_mode > 2) ? 4404 drvp->PIO_mode - 2 : 0; 4405 if (drvp->DMA_mode == 0) 4406 drvp->PIO_mode = 0; 4407 4408 mode[drive] = drvp->DMA_mode + 5; 4409 } else 4410 mode[drive] = drvp->PIO_mode; 4411 4412 if (drive && mode[0] >= 0 && 4413 (opti_tim_as[spd][mode[0]] != opti_tim_as[spd][mode[1]])) { 4414 /* 4415 * Can't have two drives using different values 4416 * for `Address Setup Time'. 4417 * Slow down the faster drive to compensate. 4418 */ 4419 int d = (opti_tim_as[spd][mode[0]] > 4420 opti_tim_as[spd][mode[1]]) ? 0 : 1; 4421 4422 mode[d] = mode[1-d]; 4423 chp->ch_drive[d].PIO_mode = chp->ch_drive[1-d].PIO_mode; 4424 chp->ch_drive[d].DMA_mode = 0; 4425 chp->ch_drive[d].drive_flags &= ~DRIVE_DMA; 4426 } 4427 } 4428 4429 for (drive = 0; drive < 2; drive++) { 4430 int m; 4431 if ((m = mode[drive]) < 0) 4432 continue; 4433 4434 /* Set the Address Setup Time and select appropriate index */ 4435 rv = opti_tim_as[spd][m] << OPTI_MISC_ADDR_SETUP_SHIFT; 4436 rv |= OPTI_MISC_INDEX(drive); 4437 opti_write_config(chp, OPTI_REG_MISC, mr | rv); 4438 4439 /* Set the pulse width and recovery timing parameters */ 4440 rv = opti_tim_cp[spd][m] << OPTI_PULSE_WIDTH_SHIFT; 4441 rv |= opti_tim_rt[spd][m] << OPTI_RECOVERY_TIME_SHIFT; 4442 opti_write_config(chp, OPTI_REG_READ_CYCLE_TIMING, rv); 4443 opti_write_config(chp, OPTI_REG_WRITE_CYCLE_TIMING, rv); 4444 4445 /* Set the Enhanced Mode register appropriately */ 4446 rv = pciide_pci_read(sc->sc_pc, sc->sc_tag, OPTI_REG_ENH_MODE); 4447 rv &= ~OPTI_ENH_MODE_MASK(chp->channel, drive); 4448 rv |= OPTI_ENH_MODE(chp->channel, drive, opti_tim_em[m]); 4449 pciide_pci_write(sc->sc_pc, sc->sc_tag, OPTI_REG_ENH_MODE, rv); 4450 } 4451 4452 /* Finally, enable the timings */ 4453 opti_write_config(chp, OPTI_REG_CONTROL, OPTI_CONTROL_ENABLE); 4454 4455 pciide_print_modes(cp); 4456 } 4457 4458 #define ACARD_IS_850(sc) \ 4459 ((sc)->sc_pp->ide_product == PCI_PRODUCT_ACARD_ATP850U) 4460 4461 void 4462 acard_chip_map(sc, pa) 4463 struct pciide_softc *sc; 4464 struct pci_attach_args *pa; 4465 { 4466 struct pciide_channel *cp; 4467 int i; 4468 pcireg_t interface; 4469 bus_size_t cmdsize, ctlsize; 4470 4471 if (pciide_chipen(sc, pa) == 0) 4472 return; 4473 4474 /* 4475 * when the chip is in native mode it identifies itself as a 4476 * 'misc mass storage'. Fake interface in this case. 4477 */ 4478 if (PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_MASS_STORAGE_IDE) { 4479 interface = PCI_INTERFACE(pa->pa_class); 4480 } else { 4481 interface = PCIIDE_INTERFACE_BUS_MASTER_DMA | 4482 PCIIDE_INTERFACE_PCI(0) | PCIIDE_INTERFACE_PCI(1); 4483 } 4484 4485 printf("%s: bus-master DMA support present", 4486 sc->sc_wdcdev.sc_dev.dv_xname); 4487 pciide_mapreg_dma(sc, pa); 4488 printf("\n"); 4489 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 4490 WDC_CAPABILITY_MODE; 4491 4492 if (sc->sc_dma_ok) { 4493 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_UDMA; 4494 sc->sc_wdcdev.cap |= WDC_CAPABILITY_IRQACK; 4495 sc->sc_wdcdev.irqack = pciide_irqack; 4496 } 4497 sc->sc_wdcdev.PIO_cap = 4; 4498 sc->sc_wdcdev.DMA_cap = 2; 4499 sc->sc_wdcdev.UDMA_cap = ACARD_IS_850(sc) ? 2 : 4; 4500 4501 sc->sc_wdcdev.set_modes = acard_setup_channel; 4502 sc->sc_wdcdev.channels = sc->wdc_chanarray; 4503 sc->sc_wdcdev.nchannels = 2; 4504 4505 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 4506 cp = &sc->pciide_channels[i]; 4507 if (pciide_chansetup(sc, i, interface) == 0) 4508 continue; 4509 if (interface & PCIIDE_INTERFACE_PCI(i)) { 4510 cp->hw_ok = pciide_mapregs_native(pa, cp, &cmdsize, 4511 &ctlsize, pciide_pci_intr); 4512 } else { 4513 cp->hw_ok = pciide_mapregs_compat(pa, cp, i, 4514 &cmdsize, &ctlsize); 4515 } 4516 if (cp->hw_ok == 0) 4517 return; 4518 cp->wdc_channel.data32iot = cp->wdc_channel.cmd_iot; 4519 cp->wdc_channel.data32ioh = cp->wdc_channel.cmd_ioh; 4520 wdcattach(&cp->wdc_channel); 4521 acard_setup_channel(&cp->wdc_channel); 4522 } 4523 if (!ACARD_IS_850(sc)) { 4524 u_int32_t reg; 4525 reg = pci_conf_read(sc->sc_pc, sc->sc_tag, ATP8x0_CTRL); 4526 reg &= ~ATP860_CTRL_INT; 4527 pci_conf_write(sc->sc_pc, sc->sc_tag, ATP8x0_CTRL, reg); 4528 } 4529 } 4530 4531 void 4532 acard_setup_channel(chp) 4533 struct channel_softc *chp; 4534 { 4535 struct ata_drive_datas *drvp; 4536 struct pciide_channel *cp = (struct pciide_channel*)chp; 4537 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 4538 int channel = chp->channel; 4539 int drive; 4540 u_int32_t idetime, udma_mode; 4541 u_int32_t idedma_ctl; 4542 4543 /* setup DMA if needed */ 4544 pciide_channel_dma_setup(cp); 4545 4546 if (ACARD_IS_850(sc)) { 4547 idetime = 0; 4548 udma_mode = pci_conf_read(sc->sc_pc, sc->sc_tag, ATP850_UDMA); 4549 udma_mode &= ~ATP850_UDMA_MASK(channel); 4550 } else { 4551 idetime = pci_conf_read(sc->sc_pc, sc->sc_tag, ATP860_IDETIME); 4552 idetime &= ~ATP860_SETTIME_MASK(channel); 4553 udma_mode = pci_conf_read(sc->sc_pc, sc->sc_tag, ATP860_UDMA); 4554 udma_mode &= ~ATP860_UDMA_MASK(channel); 4555 4556 /* check 80 pins cable */ 4557 if ((chp->ch_drive[0].drive_flags & DRIVE_UDMA) || 4558 (chp->ch_drive[1].drive_flags & DRIVE_UDMA)) { 4559 if (pci_conf_read(sc->sc_pc, sc->sc_tag, ATP8x0_CTRL) 4560 & ATP860_CTRL_80P(chp->channel)) { 4561 if (chp->ch_drive[0].UDMA_mode > 2) 4562 chp->ch_drive[0].UDMA_mode = 2; 4563 if (chp->ch_drive[1].UDMA_mode > 2) 4564 chp->ch_drive[1].UDMA_mode = 2; 4565 } 4566 } 4567 } 4568 4569 idedma_ctl = 0; 4570 4571 /* Per drive settings */ 4572 for (drive = 0; drive < 2; drive++) { 4573 drvp = &chp->ch_drive[drive]; 4574 /* If no drive, skip */ 4575 if ((drvp->drive_flags & DRIVE) == 0) 4576 continue; 4577 /* add timing values, setup DMA if needed */ 4578 if ((chp->wdc->cap & WDC_CAPABILITY_UDMA) && 4579 (drvp->drive_flags & DRIVE_UDMA)) { 4580 /* use Ultra/DMA */ 4581 if (ACARD_IS_850(sc)) { 4582 idetime |= ATP850_SETTIME(drive, 4583 acard_act_udma[drvp->UDMA_mode], 4584 acard_rec_udma[drvp->UDMA_mode]); 4585 udma_mode |= ATP850_UDMA_MODE(channel, drive, 4586 acard_udma_conf[drvp->UDMA_mode]); 4587 } else { 4588 idetime |= ATP860_SETTIME(channel, drive, 4589 acard_act_udma[drvp->UDMA_mode], 4590 acard_rec_udma[drvp->UDMA_mode]); 4591 udma_mode |= ATP860_UDMA_MODE(channel, drive, 4592 acard_udma_conf[drvp->UDMA_mode]); 4593 } 4594 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 4595 } else if ((chp->wdc->cap & WDC_CAPABILITY_DMA) && 4596 (drvp->drive_flags & DRIVE_DMA)) { 4597 /* use Multiword DMA */ 4598 drvp->drive_flags &= ~DRIVE_UDMA; 4599 if (ACARD_IS_850(sc)) { 4600 idetime |= ATP850_SETTIME(drive, 4601 acard_act_dma[drvp->DMA_mode], 4602 acard_rec_dma[drvp->DMA_mode]); 4603 } else { 4604 idetime |= ATP860_SETTIME(channel, drive, 4605 acard_act_dma[drvp->DMA_mode], 4606 acard_rec_dma[drvp->DMA_mode]); 4607 } 4608 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 4609 } else { 4610 /* PIO only */ 4611 drvp->drive_flags &= ~(DRIVE_UDMA | DRIVE_DMA); 4612 if (ACARD_IS_850(sc)) { 4613 idetime |= ATP850_SETTIME(drive, 4614 acard_act_pio[drvp->PIO_mode], 4615 acard_rec_pio[drvp->PIO_mode]); 4616 } else { 4617 idetime |= ATP860_SETTIME(channel, drive, 4618 acard_act_pio[drvp->PIO_mode], 4619 acard_rec_pio[drvp->PIO_mode]); 4620 } 4621 pci_conf_write(sc->sc_pc, sc->sc_tag, ATP8x0_CTRL, 4622 pci_conf_read(sc->sc_pc, sc->sc_tag, ATP8x0_CTRL) 4623 | ATP8x0_CTRL_EN(channel)); 4624 } 4625 } 4626 4627 if (idedma_ctl != 0) { 4628 /* Add software bits in status register */ 4629 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4630 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel, idedma_ctl); 4631 } 4632 pciide_print_modes(cp); 4633 4634 if (ACARD_IS_850(sc)) { 4635 pci_conf_write(sc->sc_pc, sc->sc_tag, 4636 ATP850_IDETIME(channel), idetime); 4637 pci_conf_write(sc->sc_pc, sc->sc_tag, ATP850_UDMA, udma_mode); 4638 } else { 4639 pci_conf_write(sc->sc_pc, sc->sc_tag, ATP860_IDETIME, idetime); 4640 pci_conf_write(sc->sc_pc, sc->sc_tag, ATP860_UDMA, udma_mode); 4641 } 4642 } 4643 4644 int 4645 acard_pci_intr(arg) 4646 void *arg; 4647 { 4648 struct pciide_softc *sc = arg; 4649 struct pciide_channel *cp; 4650 struct channel_softc *wdc_cp; 4651 int rv = 0; 4652 int dmastat, i, crv; 4653 4654 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 4655 dmastat = bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4656 IDEDMA_CTL + IDEDMA_SCH_OFFSET * i); 4657 if ((dmastat & IDEDMA_CTL_INTR) == 0) 4658 continue; 4659 cp = &sc->pciide_channels[i]; 4660 wdc_cp = &cp->wdc_channel; 4661 if ((wdc_cp->ch_flags & WDCF_IRQ_WAIT) == 0) { 4662 (void)wdcintr(wdc_cp); 4663 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4664 IDEDMA_CTL + IDEDMA_SCH_OFFSET * i, dmastat); 4665 continue; 4666 } 4667 crv = wdcintr(wdc_cp); 4668 if (crv == 0) 4669 printf("%s:%d: bogus intr\n", 4670 sc->sc_wdcdev.sc_dev.dv_xname, i); 4671 else if (crv == 1) 4672 rv = 1; 4673 else if (rv == 0) 4674 rv = crv; 4675 } 4676 return rv; 4677 } 4678 4679 static int 4680 sl82c105_bugchk(struct pci_attach_args *pa) 4681 { 4682 4683 if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_WINBOND || 4684 PCI_PRODUCT(pa->pa_id) != PCI_PRODUCT_WINBOND_W83C553F_0) 4685 return (0); 4686 4687 if (PCI_REVISION(pa->pa_class) <= 0x05) 4688 return (1); 4689 4690 return (0); 4691 } 4692 4693 void 4694 sl82c105_chip_map(sc, pa) 4695 struct pciide_softc *sc; 4696 struct pci_attach_args *pa; 4697 { 4698 struct pciide_channel *cp; 4699 bus_size_t cmdsize, ctlsize; 4700 pcireg_t interface, idecr; 4701 int channel; 4702 4703 if (pciide_chipen(sc, pa) == 0) 4704 return; 4705 4706 printf("%s: bus-master DMA support present", 4707 sc->sc_wdcdev.sc_dev.dv_xname); 4708 4709 /* 4710 * Check to see if we're part of the Winbond 83c553 Southbridge. 4711 * If so, we need to disable DMA on rev. <= 5 of that chip. 4712 */ 4713 if (pci_find_device(pa, sl82c105_bugchk)) { 4714 printf(" but disabled due to 83c553 rev. <= 0x05"); 4715 sc->sc_dma_ok = 0; 4716 } else 4717 pciide_mapreg_dma(sc, pa); 4718 printf("\n"); 4719 4720 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA32 | WDC_CAPABILITY_DATA16 | 4721 WDC_CAPABILITY_MODE; 4722 sc->sc_wdcdev.PIO_cap = 4; 4723 if (sc->sc_dma_ok) { 4724 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_IRQACK; 4725 sc->sc_wdcdev.irqack = pciide_irqack; 4726 sc->sc_wdcdev.DMA_cap = 2; 4727 } 4728 sc->sc_wdcdev.set_modes = sl82c105_setup_channel; 4729 4730 sc->sc_wdcdev.channels = sc->wdc_chanarray; 4731 sc->sc_wdcdev.nchannels = PCIIDE_NUM_CHANNELS; 4732 4733 idecr = pci_conf_read(sc->sc_pc, sc->sc_tag, SYMPH_IDECSR); 4734 4735 interface = PCI_INTERFACE(pa->pa_class); 4736 4737 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 4738 cp = &sc->pciide_channels[channel]; 4739 if (pciide_chansetup(sc, channel, interface) == 0) 4740 continue; 4741 if ((channel == 0 && (idecr & IDECR_P0EN) == 0) || 4742 (channel == 1 && (idecr & IDECR_P1EN) == 0)) { 4743 printf("%s: %s channel ignored (disabled)\n", 4744 sc->sc_wdcdev.sc_dev.dv_xname, cp->name); 4745 continue; 4746 } 4747 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 4748 pciide_pci_intr); 4749 if (cp->hw_ok == 0) 4750 continue; 4751 pciide_map_compat_intr(pa, cp, channel, interface); 4752 if (cp->hw_ok == 0) 4753 continue; 4754 sl82c105_setup_channel(&cp->wdc_channel); 4755 } 4756 } 4757 4758 void 4759 sl82c105_setup_channel(chp) 4760 struct channel_softc *chp; 4761 { 4762 struct ata_drive_datas *drvp; 4763 struct pciide_channel *cp = (struct pciide_channel*)chp; 4764 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 4765 int pxdx_reg, drive; 4766 pcireg_t pxdx; 4767 4768 /* Set up DMA if needed. */ 4769 pciide_channel_dma_setup(cp); 4770 4771 for (drive = 0; drive < 2; drive++) { 4772 pxdx_reg = ((chp->channel == 0) ? SYMPH_P0D0CR 4773 : SYMPH_P1D0CR) + (drive * 4); 4774 4775 pxdx = pci_conf_read(sc->sc_pc, sc->sc_tag, pxdx_reg); 4776 4777 pxdx &= ~(PxDx_CMD_ON_MASK|PxDx_CMD_OFF_MASK); 4778 pxdx &= ~(PxDx_PWEN|PxDx_RDYEN|PxDx_RAEN); 4779 4780 drvp = &chp->ch_drive[drive]; 4781 /* If no drive, skip. */ 4782 if ((drvp->drive_flags & DRIVE) == 0) { 4783 pci_conf_write(sc->sc_pc, sc->sc_tag, pxdx_reg, pxdx); 4784 continue; 4785 } 4786 4787 if (drvp->drive_flags & DRIVE_DMA) { 4788 /* 4789 * Timings will be used for both PIO and DMA, 4790 * so adjust DMA mode if needed. 4791 */ 4792 if (drvp->PIO_mode >= 3) { 4793 if ((drvp->DMA_mode + 2) > drvp->PIO_mode) 4794 drvp->DMA_mode = drvp->PIO_mode - 2; 4795 if (drvp->DMA_mode < 1) { 4796 /* 4797 * Can't mix both PIO and DMA. 4798 * Disable DMA. 4799 */ 4800 drvp->drive_flags &= ~DRIVE_DMA; 4801 } 4802 } else { 4803 /* 4804 * Can't mix both PIO and DMA. Disable 4805 * DMA. 4806 */ 4807 drvp->drive_flags &= ~DRIVE_DMA; 4808 } 4809 } 4810 4811 if (drvp->drive_flags & DRIVE_DMA) { 4812 /* Use multi-word DMA. */ 4813 pxdx |= symph_mw_dma_times[drvp->DMA_mode].cmd_on << 4814 PxDx_CMD_ON_SHIFT; 4815 pxdx |= symph_mw_dma_times[drvp->DMA_mode].cmd_off; 4816 } else { 4817 pxdx |= symph_pio_times[drvp->PIO_mode].cmd_on << 4818 PxDx_CMD_ON_SHIFT; 4819 pxdx |= symph_pio_times[drvp->PIO_mode].cmd_off; 4820 } 4821 4822 /* XXX PxDx_PWEN? PxDx_RDYEN? PxDx_RAEN? */ 4823 4824 /* ...and set the mode for this drive. */ 4825 pci_conf_write(sc->sc_pc, sc->sc_tag, pxdx_reg, pxdx); 4826 } 4827 4828 pciide_print_modes(cp); 4829 } 4830 4831 void 4832 serverworks_chip_map(sc, pa) 4833 struct pciide_softc *sc; 4834 struct pci_attach_args *pa; 4835 { 4836 struct pciide_channel *cp; 4837 pcireg_t interface = PCI_INTERFACE(pa->pa_class); 4838 pcitag_t pcib_tag; 4839 int channel; 4840 bus_size_t cmdsize, ctlsize; 4841 4842 if (pciide_chipen(sc, pa) == 0) 4843 return; 4844 4845 printf("%s: bus-master DMA support present", 4846 sc->sc_wdcdev.sc_dev.dv_xname); 4847 pciide_mapreg_dma(sc, pa); 4848 printf("\n"); 4849 sc->sc_wdcdev.cap = WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_DATA32 | 4850 WDC_CAPABILITY_MODE; 4851 4852 if (sc->sc_dma_ok) { 4853 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_UDMA; 4854 sc->sc_wdcdev.cap |= WDC_CAPABILITY_IRQACK; 4855 sc->sc_wdcdev.irqack = pciide_irqack; 4856 } 4857 sc->sc_wdcdev.PIO_cap = 4; 4858 sc->sc_wdcdev.DMA_cap = 2; 4859 switch (sc->sc_pp->ide_product) { 4860 case PCI_PRODUCT_SERVERWORKS_OSB4_IDE: 4861 sc->sc_wdcdev.UDMA_cap = 2; 4862 break; 4863 case PCI_PRODUCT_SERVERWORKS_CSB5_IDE: 4864 if (PCI_REVISION(pa->pa_class) < 0x92) 4865 sc->sc_wdcdev.UDMA_cap = 4; 4866 else 4867 sc->sc_wdcdev.UDMA_cap = 5; 4868 break; 4869 } 4870 4871 sc->sc_wdcdev.set_modes = serverworks_setup_channel; 4872 sc->sc_wdcdev.channels = sc->wdc_chanarray; 4873 sc->sc_wdcdev.nchannels = 2; 4874 4875 for (channel = 0; channel < sc->sc_wdcdev.nchannels; channel++) { 4876 cp = &sc->pciide_channels[channel]; 4877 if (pciide_chansetup(sc, channel, interface) == 0) 4878 continue; 4879 pciide_mapchan(pa, cp, interface, &cmdsize, &ctlsize, 4880 serverworks_pci_intr); 4881 if (cp->hw_ok == 0) 4882 return; 4883 pciide_map_compat_intr(pa, cp, channel, interface); 4884 if (cp->hw_ok == 0) 4885 return; 4886 serverworks_setup_channel(&cp->wdc_channel); 4887 } 4888 4889 pcib_tag = pci_make_tag(pa->pa_pc, pa->pa_bus, pa->pa_device, 0); 4890 pci_conf_write(pa->pa_pc, pcib_tag, 0x64, 4891 (pci_conf_read(pa->pa_pc, pcib_tag, 0x64) & ~0x2000) | 0x4000); 4892 } 4893 4894 void 4895 serverworks_setup_channel(chp) 4896 struct channel_softc *chp; 4897 { 4898 struct ata_drive_datas *drvp; 4899 struct pciide_channel *cp = (struct pciide_channel*)chp; 4900 struct pciide_softc *sc = (struct pciide_softc *)cp->wdc_channel.wdc; 4901 int channel = chp->channel; 4902 int drive, unit; 4903 u_int32_t pio_time, dma_time, pio_mode, udma_mode; 4904 u_int32_t idedma_ctl; 4905 static const u_int8_t pio_modes[5] = {0x5d, 0x47, 0x34, 0x22, 0x20}; 4906 static const u_int8_t dma_modes[3] = {0x77, 0x21, 0x20}; 4907 4908 /* setup DMA if needed */ 4909 pciide_channel_dma_setup(cp); 4910 4911 pio_time = pci_conf_read(sc->sc_pc, sc->sc_tag, 0x40); 4912 dma_time = pci_conf_read(sc->sc_pc, sc->sc_tag, 0x44); 4913 pio_mode = pci_conf_read(sc->sc_pc, sc->sc_tag, 0x48); 4914 udma_mode = pci_conf_read(sc->sc_pc, sc->sc_tag, 0x54); 4915 4916 pio_time &= ~(0xffff << (16 * channel)); 4917 dma_time &= ~(0xffff << (16 * channel)); 4918 pio_mode &= ~(0xff << (8 * channel + 16)); 4919 udma_mode &= ~(0xff << (8 * channel + 16)); 4920 udma_mode &= ~(3 << (2 * channel)); 4921 4922 idedma_ctl = 0; 4923 4924 /* Per drive settings */ 4925 for (drive = 0; drive < 2; drive++) { 4926 drvp = &chp->ch_drive[drive]; 4927 /* If no drive, skip */ 4928 if ((drvp->drive_flags & DRIVE) == 0) 4929 continue; 4930 unit = drive + 2 * channel; 4931 /* add timing values, setup DMA if needed */ 4932 pio_time |= pio_modes[drvp->PIO_mode] << (8 * (unit^1)); 4933 pio_mode |= drvp->PIO_mode << (4 * unit + 16); 4934 if ((chp->wdc->cap & WDC_CAPABILITY_UDMA) && 4935 (drvp->drive_flags & DRIVE_UDMA)) { 4936 /* use Ultra/DMA, check for 80-pin cable */ 4937 if (drvp->UDMA_mode > 2 && 4938 (PCI_PRODUCT(pci_conf_read(sc->sc_pc, sc->sc_tag, PCI_SUBSYS_ID_REG)) & (1 << (14 + channel))) == 0) 4939 drvp->UDMA_mode = 2; 4940 dma_time |= dma_modes[drvp->DMA_mode] << (8 * (unit^1)); 4941 udma_mode |= drvp->UDMA_mode << (4 * unit + 16); 4942 udma_mode |= 1 << unit; 4943 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 4944 } else if ((chp->wdc->cap & WDC_CAPABILITY_DMA) && 4945 (drvp->drive_flags & DRIVE_DMA)) { 4946 /* use Multiword DMA */ 4947 drvp->drive_flags &= ~DRIVE_UDMA; 4948 dma_time |= dma_modes[drvp->DMA_mode] << (8 * (unit^1)); 4949 idedma_ctl |= IDEDMA_CTL_DRV_DMA(drive); 4950 } else { 4951 /* PIO only */ 4952 drvp->drive_flags &= ~(DRIVE_UDMA | DRIVE_DMA); 4953 } 4954 } 4955 4956 pci_conf_write(sc->sc_pc, sc->sc_tag, 0x40, pio_time); 4957 pci_conf_write(sc->sc_pc, sc->sc_tag, 0x44, dma_time); 4958 if (sc->sc_pp->ide_product != PCI_PRODUCT_SERVERWORKS_OSB4_IDE) 4959 pci_conf_write(sc->sc_pc, sc->sc_tag, 0x48, pio_mode); 4960 pci_conf_write(sc->sc_pc, sc->sc_tag, 0x54, udma_mode); 4961 4962 if (idedma_ctl != 0) { 4963 /* Add software bits in status register */ 4964 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4965 IDEDMA_CTL + IDEDMA_SCH_OFFSET * channel, idedma_ctl); 4966 } 4967 pciide_print_modes(cp); 4968 } 4969 4970 int 4971 serverworks_pci_intr(arg) 4972 void *arg; 4973 { 4974 struct pciide_softc *sc = arg; 4975 struct pciide_channel *cp; 4976 struct channel_softc *wdc_cp; 4977 int rv = 0; 4978 int dmastat, i, crv; 4979 4980 for (i = 0; i < sc->sc_wdcdev.nchannels; i++) { 4981 dmastat = bus_space_read_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4982 IDEDMA_CTL + IDEDMA_SCH_OFFSET * i); 4983 if ((dmastat & (IDEDMA_CTL_ACT | IDEDMA_CTL_INTR)) != 4984 IDEDMA_CTL_INTR) 4985 continue; 4986 cp = &sc->pciide_channels[i]; 4987 wdc_cp = &cp->wdc_channel; 4988 crv = wdcintr(wdc_cp); 4989 if (crv == 0) { 4990 printf("%s:%d: bogus intr\n", 4991 sc->sc_wdcdev.sc_dev.dv_xname, i); 4992 bus_space_write_1(sc->sc_dma_iot, sc->sc_dma_ioh, 4993 IDEDMA_CTL + IDEDMA_SCH_OFFSET * i, dmastat); 4994 } else 4995 rv = 1; 4996 } 4997 return rv; 4998 } 4999
Indexes created Thu Oct 02 14:10:14 GMT 2025