1/*- 2 * Copyright (c) 1998,1999,2000,2001 S�ren Schmidt 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer, 10 * without modification, immediately at the beginning of the file. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 *
| 1/*- 2 * Copyright (c) 1998,1999,2000,2001 S�ren Schmidt 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer, 10 * without modification, immediately at the beginning of the file. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 *
|
28 * $FreeBSD: head/sys/dev/ata/ata-all.c 72096 2001-02-06 12:49:33Z sos $
| 28 * $FreeBSD: head/sys/dev/ata/ata-all.c 72106 2001-02-06 16:44:25Z sos $
|
29 */ 30 31#include "card.h" 32#include "pci.h" 33#include "opt_global.h" 34#include "opt_isa.h" 35#include "opt_ata.h" 36#include <sys/param.h> 37#include <sys/systm.h> 38#include <sys/kernel.h> 39#include <sys/disk.h> 40#include <sys/module.h> 41#include <sys/bus.h> 42#include <sys/bio.h> 43#include <sys/malloc.h> 44#include <sys/devicestat.h> 45#include <sys/sysctl.h> 46#include <machine/stdarg.h> 47#include <machine/resource.h> 48#include <machine/bus.h> 49#include <sys/rman.h> 50#if NPCI > 0 51#include <pci/pcivar.h> 52#include <pci/pcireg.h> 53#endif 54#include <isa/isavar.h> 55#include <isa/isareg.h> 56#ifdef __alpha__ 57#include <machine/md_var.h> 58#endif 59#include <dev/ata/ata-all.h> 60#include <dev/ata/ata-disk.h> 61#include <dev/ata/atapi-all.h> 62 63/* misc defines */ 64#define IOMASK 0xfffffffc 65#define ATA_IOADDR_RID 0 66#define ATA_ALTADDR_RID 1 67#define ATA_BMADDR_RID 2
| 29 */ 30 31#include "card.h" 32#include "pci.h" 33#include "opt_global.h" 34#include "opt_isa.h" 35#include "opt_ata.h" 36#include <sys/param.h> 37#include <sys/systm.h> 38#include <sys/kernel.h> 39#include <sys/disk.h> 40#include <sys/module.h> 41#include <sys/bus.h> 42#include <sys/bio.h> 43#include <sys/malloc.h> 44#include <sys/devicestat.h> 45#include <sys/sysctl.h> 46#include <machine/stdarg.h> 47#include <machine/resource.h> 48#include <machine/bus.h> 49#include <sys/rman.h> 50#if NPCI > 0 51#include <pci/pcivar.h> 52#include <pci/pcireg.h> 53#endif 54#include <isa/isavar.h> 55#include <isa/isareg.h> 56#ifdef __alpha__ 57#include <machine/md_var.h> 58#endif 59#include <dev/ata/ata-all.h> 60#include <dev/ata/ata-disk.h> 61#include <dev/ata/atapi-all.h> 62 63/* misc defines */ 64#define IOMASK 0xfffffffc 65#define ATA_IOADDR_RID 0 66#define ATA_ALTADDR_RID 1 67#define ATA_BMADDR_RID 2
|
68#if NPCI > 0
| 68#define ATA_IRQ_RID 0
|
69#define ATA_MASTERDEV(dev) ((pci_get_progif(dev) & 0x80) && \ 70 (pci_get_progif(dev) & 0x05) != 0x05)
| 69#define ATA_MASTERDEV(dev) ((pci_get_progif(dev) & 0x80) && \ 70 (pci_get_progif(dev) & 0x05) != 0x05)
|
71#else 72#define ATA_MASTERDEV(dev) (1) 73#endif
| |
74 75/* prototypes */ 76static int ata_probe(device_t); 77static int ata_attach(device_t); 78static int ata_detach(device_t); 79static int ata_resume(device_t); 80static void ata_boot_attach(void); 81static void ata_intr(void *); 82static int ata_getparam(struct ata_softc *, int, u_int8_t); 83static int ata_service(struct ata_softc *); 84static char *active2str(int); 85static void bswap(int8_t *, int); 86static void btrim(int8_t *, int); 87static void bpack(int8_t *, int8_t *, int); 88 89/* local vars */ 90static devclass_t ata_devclass; 91static devclass_t ata_pci_devclass; 92static struct intr_config_hook *ata_delayed_attach = NULL; 93static char ata_conf[256]; 94static MALLOC_DEFINE(M_ATA, "ATA generic", "ATA driver generic layer"); 95 96#ifdef DEV_ISA 97static struct isa_pnp_id ata_ids[] = { 98 {0x0006d041, "Generic ESDI/IDE/ATA controller"}, /* PNP0600 */ 99 {0x0106d041, "Plus Hardcard II"}, /* PNP0601 */ 100 {0x0206d041, "Plus Hardcard IIXL/EZ"}, /* PNP0602 */ 101 {0x0306d041, "Generic ATA"}, /* PNP0603 */ 102 {0} 103}; 104 105static int 106ata_isa_probe(device_t dev) 107{ 108 struct ata_softc *scp = device_get_softc(dev);
| 71 72/* prototypes */ 73static int ata_probe(device_t); 74static int ata_attach(device_t); 75static int ata_detach(device_t); 76static int ata_resume(device_t); 77static void ata_boot_attach(void); 78static void ata_intr(void *); 79static int ata_getparam(struct ata_softc *, int, u_int8_t); 80static int ata_service(struct ata_softc *); 81static char *active2str(int); 82static void bswap(int8_t *, int); 83static void btrim(int8_t *, int); 84static void bpack(int8_t *, int8_t *, int); 85 86/* local vars */ 87static devclass_t ata_devclass; 88static devclass_t ata_pci_devclass; 89static struct intr_config_hook *ata_delayed_attach = NULL; 90static char ata_conf[256]; 91static MALLOC_DEFINE(M_ATA, "ATA generic", "ATA driver generic layer"); 92 93#ifdef DEV_ISA 94static struct isa_pnp_id ata_ids[] = { 95 {0x0006d041, "Generic ESDI/IDE/ATA controller"}, /* PNP0600 */ 96 {0x0106d041, "Plus Hardcard II"}, /* PNP0601 */ 97 {0x0206d041, "Plus Hardcard IIXL/EZ"}, /* PNP0602 */ 98 {0x0306d041, "Generic ATA"}, /* PNP0603 */ 99 {0} 100}; 101 102static int 103ata_isa_probe(device_t dev) 104{ 105 struct ata_softc *scp = device_get_softc(dev);
|
109 struct resource *port;
| 106 struct resource *io;
|
110 int rid; 111 u_long tmp; 112 113 /* check isapnp ids */ 114 if (ISA_PNP_PROBE(device_get_parent(dev), dev, ata_ids) == ENXIO) 115 return ENXIO; 116
| 107 int rid; 108 u_long tmp; 109 110 /* check isapnp ids */ 111 if (ISA_PNP_PROBE(device_get_parent(dev), dev, ata_ids) == ENXIO) 112 return ENXIO; 113
|
117 /* allocate the port range */
| 114 /* allocate the io port range to get the start address */
|
118 rid = ATA_IOADDR_RID;
| 115 rid = ATA_IOADDR_RID;
|
119 port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 120 ATA_IOSIZE, RF_ACTIVE); 121 if (!port)
| 116 io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 117 ATA_IOSIZE, RF_ACTIVE); 118 if (!io)
|
122 return ENOMEM; 123
| 119 return ENOMEM; 120
|
124 /* alloctate the altport range */ 125 if (bus_get_resource(dev, SYS_RES_IOPORT, 1, &tmp, &tmp)) { 126 bus_set_resource(dev, SYS_RES_IOPORT, 1, 127 rman_get_start(port) + ATA_ALTOFFSET, 128 ATA_ALTIOSIZE);
| 121 /* set the altport range */ 122 if (bus_get_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, &tmp, &tmp)) { 123 bus_set_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, 124 rman_get_start(io) + ATA_ALTOFFSET, ATA_ALTIOSIZE);
|
129 }
| 125 }
|
130 bus_release_resource(dev, SYS_RES_IOPORT, 0, port);
| 126 127 bus_release_resource(dev, SYS_RES_IOPORT, rid, io);
|
131 scp->channel = 0; 132 scp->flags |= ATA_USE_16BIT; 133 return ata_probe(dev); 134} 135 136static device_method_t ata_isa_methods[] = { 137 /* device interface */ 138 DEVMETHOD(device_probe, ata_isa_probe), 139 DEVMETHOD(device_attach, ata_attach), 140 DEVMETHOD(device_resume, ata_resume), 141 { 0, 0 } 142}; 143 144static driver_t ata_isa_driver = { 145 "ata", 146 ata_isa_methods, 147 sizeof(struct ata_softc), 148}; 149 150DRIVER_MODULE(ata, isa, ata_isa_driver, ata_devclass, 0, 0); 151#endif 152 153#if NCARD > 0 154static int 155ata_pccard_probe(device_t dev) 156{ 157 struct ata_softc *scp = device_get_softc(dev);
| 128 scp->channel = 0; 129 scp->flags |= ATA_USE_16BIT; 130 return ata_probe(dev); 131} 132 133static device_method_t ata_isa_methods[] = { 134 /* device interface */ 135 DEVMETHOD(device_probe, ata_isa_probe), 136 DEVMETHOD(device_attach, ata_attach), 137 DEVMETHOD(device_resume, ata_resume), 138 { 0, 0 } 139}; 140 141static driver_t ata_isa_driver = { 142 "ata", 143 ata_isa_methods, 144 sizeof(struct ata_softc), 145}; 146 147DRIVER_MODULE(ata, isa, ata_isa_driver, ata_devclass, 0, 0); 148#endif 149 150#if NCARD > 0 151static int 152ata_pccard_probe(device_t dev) 153{ 154 struct ata_softc *scp = device_get_softc(dev);
|
158 struct resource *port; 159 int rid, len;
| 155 struct resource *io; 156 int rid, len, start, end; 157 u_long tmp;
|
160
| 158
|
161 /* allocate the port range */
| 159 /* allocate the io range to get start and length */
|
162 rid = ATA_IOADDR_RID; 163 len = bus_get_resource_count(dev, SYS_RES_IOPORT, rid);
| 160 rid = ATA_IOADDR_RID; 161 len = bus_get_resource_count(dev, SYS_RES_IOPORT, rid);
|
164 port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, len, RF_ACTIVE); 165 if (!port)
| 162 io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 163 ATA_IOSIZE, RF_ACTIVE); 164 if (!io)
|
166 return ENOMEM; 167
| 165 return ENOMEM; 166
|
| 167 /* reallocate the io address to only cover the io ports */ 168 start = rman_get_start(io); 169 end = start + ATA_IOSIZE - 1; 170 bus_release_resource(dev, SYS_RES_IOPORT, rid, io); 171 io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 172 start, end, ATA_IOSIZE, RF_ACTIVE); 173 bus_release_resource(dev, SYS_RES_IOPORT, rid, io); 174
|
168 /* 169 * if we got more than the default ATA_IOSIZE ports, this is likely
| 175 /* 176 * if we got more than the default ATA_IOSIZE ports, this is likely
|
170 * a pccard system where the altio ports are located just after the 171 * normal io ports, so no need to allocate them.
| 177 * a pccard system where the altio ports are located at offset 14 178 * otherwise its the normal altio offset
|
172 */
| 179 */
|
173 if (len <= ATA_IOSIZE) { 174 bus_set_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, 175 rman_get_start(port) + ATA_ALTOFFSET, ATA_ALTIOSIZE);
| 180 if (bus_get_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, &tmp, &tmp)) { 181 if (len > ATA_IOSIZE) { 182 bus_set_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, 183 start + ATA_PCCARD_ALTOFFSET, ATA_ALTIOSIZE); 184 } 185 else { 186 bus_set_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, 187 start + ATA_ALTOFFSET, ATA_ALTIOSIZE); 188 }
|
176 }
| 189 }
|
177 bus_release_resource(dev, SYS_RES_IOPORT, 0, port);
| 190 else 191 return ENOMEM; 192
|
178 scp->channel = 0; 179 scp->flags |= (ATA_USE_16BIT | ATA_NO_SLAVE); 180 return ata_probe(dev); 181} 182 183static device_method_t ata_pccard_methods[] = { 184 /* device interface */ 185 DEVMETHOD(device_probe, ata_pccard_probe), 186 DEVMETHOD(device_attach, ata_attach), 187 DEVMETHOD(device_detach, ata_detach), 188 { 0, 0 } 189}; 190 191static driver_t ata_pccard_driver = { 192 "ata", 193 ata_pccard_methods, 194 sizeof(struct ata_softc), 195}; 196 197DRIVER_MODULE(ata, pccard, ata_pccard_driver, ata_devclass, 0, 0); 198#endif 199 200#if NPCI > 0 201struct ata_pci_softc { 202 struct resource *bmio;
| 193 scp->channel = 0; 194 scp->flags |= (ATA_USE_16BIT | ATA_NO_SLAVE); 195 return ata_probe(dev); 196} 197 198static device_method_t ata_pccard_methods[] = { 199 /* device interface */ 200 DEVMETHOD(device_probe, ata_pccard_probe), 201 DEVMETHOD(device_attach, ata_attach), 202 DEVMETHOD(device_detach, ata_detach), 203 { 0, 0 } 204}; 205 206static driver_t ata_pccard_driver = { 207 "ata", 208 ata_pccard_methods, 209 sizeof(struct ata_softc), 210}; 211 212DRIVER_MODULE(ata, pccard, ata_pccard_driver, ata_devclass, 0, 0); 213#endif 214 215#if NPCI > 0 216struct ata_pci_softc { 217 struct resource *bmio;
|
203 struct resource bmio_1; 204 struct resource bmio_2;
| 218 int bmaddr;
|
205 struct resource *irq; 206 int irqcnt; 207}; 208 209int 210ata_find_dev(device_t dev, u_int32_t type, u_int32_t revid) 211{ 212 device_t *children, child; 213 int nchildren, i; 214 215 if (device_get_children(device_get_parent(dev), &children, &nchildren)) 216 return 0; 217 218 for (i = 0; i < nchildren; i++) { 219 child = children[i]; 220 221 /* check that it's on the same silicon and the device we want */ 222 if (pci_get_slot(dev) == pci_get_slot(child) && 223 pci_get_vendor(child) == (type & 0xffff) && 224 pci_get_device(child) == ((type & 0xffff0000) >> 16) && 225 pci_get_revid(child) >= revid) { 226 free(children, M_TEMP); 227 return 1; 228 } 229 } 230 free(children, M_TEMP); 231 return 0; 232} 233 234static const char * 235ata_pci_match(device_t dev) 236{ 237 if (pci_get_class(dev) != PCIC_STORAGE) 238 return NULL; 239 240 switch (pci_get_devid(dev)) { 241 /* supported chipsets */ 242 case 0x12308086: 243 return "Intel PIIX ATA controller"; 244 245 case 0x70108086: 246 return "Intel PIIX3 ATA controller"; 247 248 case 0x71118086: 249 case 0x71998086: 250 return "Intel PIIX4 ATA33 controller"; 251 252 case 0x24218086: 253 return "Intel ICH0 ATA33 controller"; 254 255 case 0x24118086: 256 return "Intel ICH ATA66 controller"; 257 258 case 0x244b8086: 259 return "Intel ICH2 ATA100 controller"; 260 261 case 0x522910b9: 262 if (pci_get_revid(dev) < 0x20) 263 return "AcerLabs Aladdin ATA controller"; 264 else 265 return "AcerLabs Aladdin ATA33 controller"; 266 267 case 0x05711106: 268 if (ata_find_dev(dev, 0x05861106, 0)) 269 return "VIA 82C586 ATA33 controller"; 270 if (ata_find_dev(dev, 0x05961106, 0x12)) 271 return "VIA 82C596 ATA66 controller"; 272 if (ata_find_dev(dev, 0x05961106, 0)) 273 return "VIA 82C596 ATA33 controller"; 274 if (ata_find_dev(dev, 0x06861106, 0x40)) 275 return "VIA 82C686 ATA100 controller"; 276 if (ata_find_dev(dev, 0x06861106, 0)) 277 return "VIA 82C686 ATA66 controller"; 278 return "VIA Apollo ATA controller"; 279 280 case 0x55131039: 281 return "SiS 5591 ATA33 controller"; 282 283 case 0x06491095: 284 return "CMD 649 ATA100 controller"; 285 286 case 0x06481095: 287 return "CMD 648 ATA66 controller"; 288 289 case 0x06461095: 290 return "CMD 646 ATA controller"; 291 292 case 0xc6931080: 293 if (pci_get_subclass(dev) == PCIS_STORAGE_IDE) 294 return "Cypress 82C693 ATA controller"; 295 break; 296 297 case 0x01021078: 298 return "Cyrix 5530 ATA33 controller"; 299 300 case 0x74091022: 301 return "AMD 756 ATA66 controller"; 302 303 case 0x02111166: 304 return "ServerWorks ROSB4 ATA33 controller"; 305 306 case 0x4d33105a: 307 return "Promise ATA33 controller"; 308 309 case 0x4d38105a: 310 return "Promise ATA66 controller"; 311 312 case 0x0d30105a: 313 case 0x4d30105a: 314 return "Promise ATA100 controller"; 315 316 case 0x00041103: 317 switch (pci_get_revid(dev)) { 318 case 0x00: 319 case 0x01: 320 return "HighPoint HPT366 ATA66 controller"; 321 case 0x02: 322 return "HighPoint HPT368 ATA66 controller"; 323 case 0x03: 324 case 0x04: 325 return "HighPoint HPT370 ATA100 controller"; 326 default: 327 return "Unknown revision HighPoint ATA controller"; 328 } 329 330 /* unsupported but known chipsets, generic DMA only */ 331 case 0x10001042: 332 case 0x10011042: 333 return "RZ 100? ATA controller !WARNING! buggy chip data loss possible"; 334 335 case 0x06401095: 336 return "CMD 640 ATA controller !WARNING! buggy chip data loss possible"; 337 338 /* unknown chipsets, try generic DMA if it seems possible */ 339 default: 340 if (pci_get_class(dev) == PCIC_STORAGE && 341 (pci_get_subclass(dev) == PCIS_STORAGE_IDE)) 342 return "Generic PCI ATA controller"; 343 } 344 return NULL; 345} 346 347static int 348ata_pci_probe(device_t dev) 349{ 350 const char *desc = ata_pci_match(dev); 351 352 if (desc) { 353 device_set_desc(dev, desc); 354 return 0; 355 } 356 else 357 return ENXIO; 358} 359 360static int 361ata_pci_add_child(device_t dev, int unit) 362{ 363 device_t child; 364 365 /* check if this is located at one of the std addresses */ 366 if (ATA_MASTERDEV(dev)) { 367 if (!(child = device_add_child(dev, "ata", unit))) 368 return ENOMEM; 369 } 370 else { 371 if (!(child = device_add_child(dev, "ata", 2))) 372 return ENOMEM; 373 } 374 return 0; 375} 376 377static int 378ata_pci_attach(device_t dev) 379{ 380 struct ata_pci_softc *sc = device_get_softc(dev); 381 u_int8_t class, subclass; 382 u_int32_t type, cmd; 383 int rid; 384 385 /* set up vendor-specific stuff */ 386 type = pci_get_devid(dev); 387 class = pci_get_class(dev); 388 subclass = pci_get_subclass(dev); 389 cmd = pci_read_config(dev, PCIR_COMMAND, 4); 390 391 /* is busmastering supported ? */ 392 if ((cmd & (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN)) == 393 (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN)) { 394 395 /* is there a valid port range to connect to ? */ 396 rid = 0x20; 397 sc->bmio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 398 0, ~0, 1, RF_ACTIVE); 399 if (!sc->bmio) 400 device_printf(dev, "Busmastering DMA not configured\n"); 401 } 402 else 403 device_printf(dev, "Busmastering DMA not supported\n"); 404 405 /* do extra chipset specific setups */ 406 switch (type) { 407 case 0x522910b9: /* Aladdin need to activate the ATAPI FIFO */ 408 pci_write_config(dev, 0x53, 409 (pci_read_config(dev, 0x53, 1) & ~0x01) | 0x02, 1); 410 break; 411 412 case 0x4d38105a: /* Promise 66 & 100 need their clock changed */ 413 case 0x4d30105a: 414 case 0x0d30105a:
| 219 struct resource *irq; 220 int irqcnt; 221}; 222 223int 224ata_find_dev(device_t dev, u_int32_t type, u_int32_t revid) 225{ 226 device_t *children, child; 227 int nchildren, i; 228 229 if (device_get_children(device_get_parent(dev), &children, &nchildren)) 230 return 0; 231 232 for (i = 0; i < nchildren; i++) { 233 child = children[i]; 234 235 /* check that it's on the same silicon and the device we want */ 236 if (pci_get_slot(dev) == pci_get_slot(child) && 237 pci_get_vendor(child) == (type & 0xffff) && 238 pci_get_device(child) == ((type & 0xffff0000) >> 16) && 239 pci_get_revid(child) >= revid) { 240 free(children, M_TEMP); 241 return 1; 242 } 243 } 244 free(children, M_TEMP); 245 return 0; 246} 247 248static const char * 249ata_pci_match(device_t dev) 250{ 251 if (pci_get_class(dev) != PCIC_STORAGE) 252 return NULL; 253 254 switch (pci_get_devid(dev)) { 255 /* supported chipsets */ 256 case 0x12308086: 257 return "Intel PIIX ATA controller"; 258 259 case 0x70108086: 260 return "Intel PIIX3 ATA controller"; 261 262 case 0x71118086: 263 case 0x71998086: 264 return "Intel PIIX4 ATA33 controller"; 265 266 case 0x24218086: 267 return "Intel ICH0 ATA33 controller"; 268 269 case 0x24118086: 270 return "Intel ICH ATA66 controller"; 271 272 case 0x244b8086: 273 return "Intel ICH2 ATA100 controller"; 274 275 case 0x522910b9: 276 if (pci_get_revid(dev) < 0x20) 277 return "AcerLabs Aladdin ATA controller"; 278 else 279 return "AcerLabs Aladdin ATA33 controller"; 280 281 case 0x05711106: 282 if (ata_find_dev(dev, 0x05861106, 0)) 283 return "VIA 82C586 ATA33 controller"; 284 if (ata_find_dev(dev, 0x05961106, 0x12)) 285 return "VIA 82C596 ATA66 controller"; 286 if (ata_find_dev(dev, 0x05961106, 0)) 287 return "VIA 82C596 ATA33 controller"; 288 if (ata_find_dev(dev, 0x06861106, 0x40)) 289 return "VIA 82C686 ATA100 controller"; 290 if (ata_find_dev(dev, 0x06861106, 0)) 291 return "VIA 82C686 ATA66 controller"; 292 return "VIA Apollo ATA controller"; 293 294 case 0x55131039: 295 return "SiS 5591 ATA33 controller"; 296 297 case 0x06491095: 298 return "CMD 649 ATA100 controller"; 299 300 case 0x06481095: 301 return "CMD 648 ATA66 controller"; 302 303 case 0x06461095: 304 return "CMD 646 ATA controller"; 305 306 case 0xc6931080: 307 if (pci_get_subclass(dev) == PCIS_STORAGE_IDE) 308 return "Cypress 82C693 ATA controller"; 309 break; 310 311 case 0x01021078: 312 return "Cyrix 5530 ATA33 controller"; 313 314 case 0x74091022: 315 return "AMD 756 ATA66 controller"; 316 317 case 0x02111166: 318 return "ServerWorks ROSB4 ATA33 controller"; 319 320 case 0x4d33105a: 321 return "Promise ATA33 controller"; 322 323 case 0x4d38105a: 324 return "Promise ATA66 controller"; 325 326 case 0x0d30105a: 327 case 0x4d30105a: 328 return "Promise ATA100 controller"; 329 330 case 0x00041103: 331 switch (pci_get_revid(dev)) { 332 case 0x00: 333 case 0x01: 334 return "HighPoint HPT366 ATA66 controller"; 335 case 0x02: 336 return "HighPoint HPT368 ATA66 controller"; 337 case 0x03: 338 case 0x04: 339 return "HighPoint HPT370 ATA100 controller"; 340 default: 341 return "Unknown revision HighPoint ATA controller"; 342 } 343 344 /* unsupported but known chipsets, generic DMA only */ 345 case 0x10001042: 346 case 0x10011042: 347 return "RZ 100? ATA controller !WARNING! buggy chip data loss possible"; 348 349 case 0x06401095: 350 return "CMD 640 ATA controller !WARNING! buggy chip data loss possible"; 351 352 /* unknown chipsets, try generic DMA if it seems possible */ 353 default: 354 if (pci_get_class(dev) == PCIC_STORAGE && 355 (pci_get_subclass(dev) == PCIS_STORAGE_IDE)) 356 return "Generic PCI ATA controller"; 357 } 358 return NULL; 359} 360 361static int 362ata_pci_probe(device_t dev) 363{ 364 const char *desc = ata_pci_match(dev); 365 366 if (desc) { 367 device_set_desc(dev, desc); 368 return 0; 369 } 370 else 371 return ENXIO; 372} 373 374static int 375ata_pci_add_child(device_t dev, int unit) 376{ 377 device_t child; 378 379 /* check if this is located at one of the std addresses */ 380 if (ATA_MASTERDEV(dev)) { 381 if (!(child = device_add_child(dev, "ata", unit))) 382 return ENOMEM; 383 } 384 else { 385 if (!(child = device_add_child(dev, "ata", 2))) 386 return ENOMEM; 387 } 388 return 0; 389} 390 391static int 392ata_pci_attach(device_t dev) 393{ 394 struct ata_pci_softc *sc = device_get_softc(dev); 395 u_int8_t class, subclass; 396 u_int32_t type, cmd; 397 int rid; 398 399 /* set up vendor-specific stuff */ 400 type = pci_get_devid(dev); 401 class = pci_get_class(dev); 402 subclass = pci_get_subclass(dev); 403 cmd = pci_read_config(dev, PCIR_COMMAND, 4); 404 405 /* is busmastering supported ? */ 406 if ((cmd & (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN)) == 407 (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN)) { 408 409 /* is there a valid port range to connect to ? */ 410 rid = 0x20; 411 sc->bmio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 412 0, ~0, 1, RF_ACTIVE); 413 if (!sc->bmio) 414 device_printf(dev, "Busmastering DMA not configured\n"); 415 } 416 else 417 device_printf(dev, "Busmastering DMA not supported\n"); 418 419 /* do extra chipset specific setups */ 420 switch (type) { 421 case 0x522910b9: /* Aladdin need to activate the ATAPI FIFO */ 422 pci_write_config(dev, 0x53, 423 (pci_read_config(dev, 0x53, 1) & ~0x01) | 0x02, 1); 424 break; 425 426 case 0x4d38105a: /* Promise 66 & 100 need their clock changed */ 427 case 0x4d30105a: 428 case 0x0d30105a:
|
415 outb(rman_get_start(sc->bmio) + 0x11, 416 inb(rman_get_start(sc->bmio) + 0x11) | 0x0a);
| 429 ATA_OUTB(sc->bmio, 0x11, ATA_INB(sc->bmio, 0x11) | 0x0a);
|
417 /* FALLTHROUGH */ 418 419 case 0x4d33105a: /* Promise (all) need burst mode to be turned on */
| 430 /* FALLTHROUGH */ 431 432 case 0x4d33105a: /* Promise (all) need burst mode to be turned on */
|
420 outb(rman_get_start(sc->bmio) + 0x1f, 421 inb(rman_get_start(sc->bmio) + 0x1f) | 0x01);
| 433 ATA_OUTB(sc->bmio, 0x1f, ATA_INB(sc->bmio, 0x1f) | 0x01);
|
422 break; 423 424 case 0x00041103: /* HighPoint */ 425 switch (pci_get_revid(dev)) { 426 case 0x00: 427 case 0x01: 428 /* turn off interrupt prediction */ 429 pci_write_config(dev, 0x51, 430 (pci_read_config(dev, 0x51, 1) & ~0x80), 1); 431 break; 432 433 case 0x02: 434 case 0x03: 435 case 0x04: 436 /* turn off interrupt prediction */ 437 pci_write_config(dev, 0x51, 438 (pci_read_config(dev, 0x51, 1) & ~0x02), 1); 439 pci_write_config(dev, 0x55, 440 (pci_read_config(dev, 0x55, 1) & ~0x02), 1); 441 /* turn on interrupts */ 442 pci_write_config(dev, 0x5a, 443 (pci_read_config(dev, 0x5a, 1) & ~0x10), 1); 444 445 } 446 break; 447 448 case 0x05711106: 449 case 0x74091022: /* VIA 82C586, 82C596, 82C686 & AMD 756 default setup */ 450 451 /* set prefetch, postwrite */ 452 pci_write_config(dev, 0x41, pci_read_config(dev, 0x41, 1) | 0xf0, 1); 453 454 /* set fifo configuration half'n'half */ 455 pci_write_config(dev, 0x43, 456 (pci_read_config(dev, 0x43, 1) & 0x90) | 0x2a, 1); 457 458 /* set status register read retry */ 459 pci_write_config(dev, 0x44, pci_read_config(dev, 0x44, 1) | 0x08, 1); 460 461 /* set DMA read & end-of-sector fifo flush */ 462 pci_write_config(dev, 0x46, 463 (pci_read_config(dev, 0x46, 1) & 0x0c) | 0xf0, 1); 464 465 /* set sector size */ 466 pci_write_config(dev, 0x60, DEV_BSIZE, 2); 467 pci_write_config(dev, 0x68, DEV_BSIZE, 2); 468 469 /* prepare for ATA-66 on the 82C686 and rev 0x12 and newer 82C596's */ 470 if (ata_find_dev(dev, 0x06861106, 0) || 471 ata_find_dev(dev, 0x05961106, 0x12)) { 472 pci_write_config(dev, 0x50, 473 pci_read_config(dev, 0x50, 4) | 0x070f070f, 4); 474 } 475 break; 476 477 case 0x10001042: /* RZ 100? known bad, no DMA */ 478 case 0x10011042: 479 case 0x06401095: /* CMD 640 known bad, no DMA */
| 434 break; 435 436 case 0x00041103: /* HighPoint */ 437 switch (pci_get_revid(dev)) { 438 case 0x00: 439 case 0x01: 440 /* turn off interrupt prediction */ 441 pci_write_config(dev, 0x51, 442 (pci_read_config(dev, 0x51, 1) & ~0x80), 1); 443 break; 444 445 case 0x02: 446 case 0x03: 447 case 0x04: 448 /* turn off interrupt prediction */ 449 pci_write_config(dev, 0x51, 450 (pci_read_config(dev, 0x51, 1) & ~0x02), 1); 451 pci_write_config(dev, 0x55, 452 (pci_read_config(dev, 0x55, 1) & ~0x02), 1); 453 /* turn on interrupts */ 454 pci_write_config(dev, 0x5a, 455 (pci_read_config(dev, 0x5a, 1) & ~0x10), 1); 456 457 } 458 break; 459 460 case 0x05711106: 461 case 0x74091022: /* VIA 82C586, 82C596, 82C686 & AMD 756 default setup */ 462 463 /* set prefetch, postwrite */ 464 pci_write_config(dev, 0x41, pci_read_config(dev, 0x41, 1) | 0xf0, 1); 465 466 /* set fifo configuration half'n'half */ 467 pci_write_config(dev, 0x43, 468 (pci_read_config(dev, 0x43, 1) & 0x90) | 0x2a, 1); 469 470 /* set status register read retry */ 471 pci_write_config(dev, 0x44, pci_read_config(dev, 0x44, 1) | 0x08, 1); 472 473 /* set DMA read & end-of-sector fifo flush */ 474 pci_write_config(dev, 0x46, 475 (pci_read_config(dev, 0x46, 1) & 0x0c) | 0xf0, 1); 476 477 /* set sector size */ 478 pci_write_config(dev, 0x60, DEV_BSIZE, 2); 479 pci_write_config(dev, 0x68, DEV_BSIZE, 2); 480 481 /* prepare for ATA-66 on the 82C686 and rev 0x12 and newer 82C596's */ 482 if (ata_find_dev(dev, 0x06861106, 0) || 483 ata_find_dev(dev, 0x05961106, 0x12)) { 484 pci_write_config(dev, 0x50, 485 pci_read_config(dev, 0x50, 4) | 0x070f070f, 4); 486 } 487 break; 488 489 case 0x10001042: /* RZ 100? known bad, no DMA */ 490 case 0x10011042: 491 case 0x06401095: /* CMD 640 known bad, no DMA */
|
480 sc->bmio = 0x0;
| 492 sc->bmio = NULL;
|
481 device_printf(dev, "Busmastering DMA disabled\n"); 482 } 483
| 493 device_printf(dev, "Busmastering DMA disabled\n"); 494 } 495
|
| 496 if (sc->bmio) { 497 sc->bmaddr = rman_get_start(sc->bmio); 498 BUS_RELEASE_RESOURCE(device_get_parent(dev), dev, 499 SYS_RES_IOPORT, rid, sc->bmio); 500 sc->bmio = NULL; 501 } 502
|
484 /* 485 * the Cypress chip is a mess, it contains two ATA functions, but 486 * both channels are visible on the first one. 487 * simply ignore the second function for now, as the right 488 * solution (ignoring the second channel on the first function) 489 * doesn't work with the crappy ATA interrupt setup on the alpha. 490 */ 491 if (pci_get_devid(dev) == 0xc6931080 && pci_get_function(dev) > 1) 492 return 0; 493 494 ata_pci_add_child(dev, 0); 495 496 if (ATA_MASTERDEV(dev) || pci_read_config(dev, 0x18, 4) & IOMASK) 497 ata_pci_add_child(dev, 1); 498 499 return bus_generic_attach(dev); 500} 501 502static int 503ata_pci_print_child(device_t dev, device_t child) 504{ 505 struct ata_softc *scp = device_get_softc(child); 506 int retval = 0; 507 508 retval += bus_print_child_header(dev, child);
| 503 /* 504 * the Cypress chip is a mess, it contains two ATA functions, but 505 * both channels are visible on the first one. 506 * simply ignore the second function for now, as the right 507 * solution (ignoring the second channel on the first function) 508 * doesn't work with the crappy ATA interrupt setup on the alpha. 509 */ 510 if (pci_get_devid(dev) == 0xc6931080 && pci_get_function(dev) > 1) 511 return 0; 512 513 ata_pci_add_child(dev, 0); 514 515 if (ATA_MASTERDEV(dev) || pci_read_config(dev, 0x18, 4) & IOMASK) 516 ata_pci_add_child(dev, 1); 517 518 return bus_generic_attach(dev); 519} 520 521static int 522ata_pci_print_child(device_t dev, device_t child) 523{ 524 struct ata_softc *scp = device_get_softc(child); 525 int retval = 0; 526 527 retval += bus_print_child_header(dev, child);
|
509 retval += printf(": at 0x%x", scp->ioaddr);
| 528 retval += printf(": at 0x%lx", rman_get_start(scp->r_io));
|
510 511 if (ATA_MASTERDEV(dev)) 512 retval += printf(" irq %d", 14 + scp->channel); 513 514 retval += bus_print_child_footer(dev, child); 515 516 return retval; 517} 518 519static struct resource * 520ata_pci_alloc_resource(device_t dev, device_t child, int type, int *rid, 521 u_long start, u_long end, u_long count, u_int flags) 522{ 523 struct ata_pci_softc *sc = device_get_softc(dev);
| 529 530 if (ATA_MASTERDEV(dev)) 531 retval += printf(" irq %d", 14 + scp->channel); 532 533 retval += bus_print_child_footer(dev, child); 534 535 return retval; 536} 537 538static struct resource * 539ata_pci_alloc_resource(device_t dev, device_t child, int type, int *rid, 540 u_long start, u_long end, u_long count, u_int flags) 541{ 542 struct ata_pci_softc *sc = device_get_softc(dev);
|
| 543 struct resource *res = NULL;
|
524 int channel = ((struct ata_softc *)device_get_softc(child))->channel; 525 int myrid; 526 527 if (type == SYS_RES_IOPORT) { 528 switch (*rid) { 529 case ATA_IOADDR_RID: 530 if (ATA_MASTERDEV(dev)) { 531 myrid = 0; 532 start = (channel == 0 ? IO_WD1 : IO_WD2); 533 end = start + ATA_IOSIZE - 1; 534 count = ATA_IOSIZE;
| 544 int channel = ((struct ata_softc *)device_get_softc(child))->channel; 545 int myrid; 546 547 if (type == SYS_RES_IOPORT) { 548 switch (*rid) { 549 case ATA_IOADDR_RID: 550 if (ATA_MASTERDEV(dev)) { 551 myrid = 0; 552 start = (channel == 0 ? IO_WD1 : IO_WD2); 553 end = start + ATA_IOSIZE - 1; 554 count = ATA_IOSIZE;
|
| 555 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 556 SYS_RES_IOPORT, &myrid, 557 start, end, count, flags);
|
535 }
| 558 }
|
536 else
| 559 else {
|
537 myrid = 0x10 + 8 * channel;
| 560 myrid = 0x10 + 8 * channel;
|
| 561 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, 562 SYS_RES_IOPORT, &myrid, 563 start, end, count, flags); 564 }
|
538 break; 539 540 case ATA_ALTADDR_RID: 541 if (ATA_MASTERDEV(dev)) { 542 myrid = 0; 543 start = (channel == 0 ? IO_WD1 : IO_WD2) + ATA_ALTOFFSET; 544 end = start + ATA_ALTIOSIZE - 1; 545 count = ATA_ALTIOSIZE;
| 565 break; 566 567 case ATA_ALTADDR_RID: 568 if (ATA_MASTERDEV(dev)) { 569 myrid = 0; 570 start = (channel == 0 ? IO_WD1 : IO_WD2) + ATA_ALTOFFSET; 571 end = start + ATA_ALTIOSIZE - 1; 572 count = ATA_ALTIOSIZE;
|
| 573 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 574 SYS_RES_IOPORT, &myrid, 575 start, end, count, flags);
|
546 }
| 576 }
|
547 else
| 577 else {
|
548 myrid = 0x14 + 8 * channel;
| 578 myrid = 0x14 + 8 * channel;
|
| 579 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, 580 SYS_RES_IOPORT, &myrid, 581 start, end, count, flags); 582 if (res) { 583 start = rman_get_start(res) + 2; 584 end = start + ATA_ALTIOSIZE - 1; 585 count = ATA_ALTIOSIZE; 586 BUS_RELEASE_RESOURCE(device_get_parent(dev), dev, 587 SYS_RES_IOPORT, myrid, res); 588 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, 589 SYS_RES_IOPORT, &myrid, 590 start, end, count, flags); 591 } 592 }
|
549 break; 550 551 case ATA_BMADDR_RID:
| 593 break; 594 595 case ATA_BMADDR_RID:
|
552 /* the busmaster resource is shared between the two channels */ 553 if (sc->bmio) { 554 if (channel == 0) { 555 sc->bmio_1 = *sc->bmio; 556 sc->bmio_1.r_end = sc->bmio->r_start + ATA_BM_OFFSET1; 557 return &sc->bmio_1; 558 } else { 559 sc->bmio_2 = *sc->bmio; 560 sc->bmio_2.r_start = sc->bmio->r_start + ATA_BM_OFFSET1; 561 sc->bmio_2.r_end = sc->bmio_2.r_start + ATA_BM_OFFSET1; 562 return &sc->bmio_2; 563 }
| 596 if (sc->bmaddr) { 597 myrid = 0x20; 598 start = (channel == 0 ? sc->bmaddr : sc->bmaddr + ATA_BMIOSIZE); 599 end = start + ATA_BMIOSIZE - 1; 600 count = ATA_BMIOSIZE; 601 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 602 SYS_RES_IOPORT, &myrid, 603 start, end, count, flags);
|
564 }
| 604 }
|
565 return 0; 566 567 default: 568 return 0;
| |
569 }
| 605 }
|
570 571 if (ATA_MASTERDEV(dev)) 572 /* make the parent just pass through the allocation. */ 573 return BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 574 SYS_RES_IOPORT, &myrid, 575 start, end, count, flags); 576 else 577 /* we are using the parent resource directly. */ 578 return BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, 579 SYS_RES_IOPORT, &myrid, 580 start, end, count, flags);
| 606 return res;
|
581 } 582
| 607 } 608
|
583 if (type == SYS_RES_IRQ) { 584 if (*rid != 0) 585 return 0; 586
| 609 if (type == SYS_RES_IRQ && *rid == ATA_IRQ_RID) {
|
587 if (ATA_MASTERDEV(dev)) { 588#ifdef __alpha__ 589 return alpha_platform_alloc_ide_intr(channel); 590#else 591 int irq = (channel == 0 ? 14 : 15); 592 593 return BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 594 SYS_RES_IRQ, rid, 595 irq, irq, 1, flags & ~RF_SHAREABLE); 596#endif
| 610 if (ATA_MASTERDEV(dev)) { 611#ifdef __alpha__ 612 return alpha_platform_alloc_ide_intr(channel); 613#else 614 int irq = (channel == 0 ? 14 : 15); 615 616 return BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 617 SYS_RES_IRQ, rid, 618 irq, irq, 1, flags & ~RF_SHAREABLE); 619#endif
|
597 } else {
| 620 } 621 else {
|
598 /* primary and secondary channels share the same interrupt */ 599 sc->irqcnt++; 600 if (!sc->irq) 601 sc->irq = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, 602 SYS_RES_IRQ, rid, 0, ~0, 1, flags); 603 return sc->irq; 604 } 605 } 606 return 0; 607} 608 609static int 610ata_pci_release_resource(device_t dev, device_t child, int type, int rid, 611 struct resource *r) 612{ 613 struct ata_pci_softc *sc = device_get_softc(dev); 614 int channel = ((struct ata_softc *)device_get_softc(child))->channel; 615 int myrid = 0; 616 617 if (type == SYS_RES_IOPORT) { 618 switch (rid) { 619 case ATA_IOADDR_RID: 620 if (ATA_MASTERDEV(dev)) 621 myrid = 0; 622 else 623 myrid = 0x10 + 8 * channel; 624 break; 625 626 case ATA_ALTADDR_RID: 627 if (ATA_MASTERDEV(dev)) 628 myrid = 0; 629 else 630 myrid = 0x14 + 8 * channel; 631 break; 632 633 case ATA_BMADDR_RID:
| 622 /* primary and secondary channels share the same interrupt */ 623 sc->irqcnt++; 624 if (!sc->irq) 625 sc->irq = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, 626 SYS_RES_IRQ, rid, 0, ~0, 1, flags); 627 return sc->irq; 628 } 629 } 630 return 0; 631} 632 633static int 634ata_pci_release_resource(device_t dev, device_t child, int type, int rid, 635 struct resource *r) 636{ 637 struct ata_pci_softc *sc = device_get_softc(dev); 638 int channel = ((struct ata_softc *)device_get_softc(child))->channel; 639 int myrid = 0; 640 641 if (type == SYS_RES_IOPORT) { 642 switch (rid) { 643 case ATA_IOADDR_RID: 644 if (ATA_MASTERDEV(dev)) 645 myrid = 0; 646 else 647 myrid = 0x10 + 8 * channel; 648 break; 649 650 case ATA_ALTADDR_RID: 651 if (ATA_MASTERDEV(dev)) 652 myrid = 0; 653 else 654 myrid = 0x14 + 8 * channel; 655 break; 656 657 case ATA_BMADDR_RID:
|
634 return 0;
| 658 myrid = 0x20; 659 break;
|
635 636 default: 637 return ENOENT; 638 } 639 640 if (ATA_MASTERDEV(dev)) 641 /* make the parent just pass through the allocation. */ 642 return BUS_RELEASE_RESOURCE(device_get_parent(dev), child, 643 SYS_RES_IOPORT, myrid, r); 644 else 645 /* we are using the parent resource directly. */ 646 return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev, 647 SYS_RES_IOPORT, myrid, r); 648 } 649 if (type == SYS_RES_IRQ) {
| 660 661 default: 662 return ENOENT; 663 } 664 665 if (ATA_MASTERDEV(dev)) 666 /* make the parent just pass through the allocation. */ 667 return BUS_RELEASE_RESOURCE(device_get_parent(dev), child, 668 SYS_RES_IOPORT, myrid, r); 669 else 670 /* we are using the parent resource directly. */ 671 return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev, 672 SYS_RES_IOPORT, myrid, r); 673 } 674 if (type == SYS_RES_IRQ) {
|
650 if (rid != 0)
| 675 if (rid != ATA_IRQ_RID)
|
651 return ENOENT; 652 653 if (ATA_MASTERDEV(dev)) { 654#ifdef __alpha__ 655 return alpha_platform_release_ide_intr(channel, r); 656#else 657 return BUS_RELEASE_RESOURCE(device_get_parent(dev), 658 child, SYS_RES_IRQ, rid, r); 659#endif 660 } 661 else { 662 if (--sc->irqcnt) 663 return 0; 664 665 return BUS_RELEASE_RESOURCE(device_get_parent(dev), 666 dev, SYS_RES_IRQ, rid, r); 667 } 668 } 669 return EINVAL; 670} 671 672static int 673ata_pci_setup_intr(device_t dev, device_t child, struct resource *irq, 674 int flags, driver_intr_t *intr, void *arg, 675 void **cookiep) 676{ 677 if (ATA_MASTERDEV(dev)) { 678#ifdef __alpha__ 679 return alpha_platform_setup_ide_intr(child, irq, intr, arg, cookiep); 680#else 681 return BUS_SETUP_INTR(device_get_parent(dev), child, irq, 682 flags, intr, arg, cookiep); 683#endif 684 } 685 else 686 return BUS_SETUP_INTR(device_get_parent(dev), dev, irq, 687 flags, intr, arg, cookiep); 688} 689 690static int 691ata_pci_teardown_intr(device_t dev, device_t child, struct resource *irq, 692 void *cookie) 693{ 694 if (ATA_MASTERDEV(dev)) { 695#ifdef __alpha__ 696 return alpha_platform_teardown_ide_intr(child, irq, cookie); 697#else 698 return BUS_TEARDOWN_INTR(device_get_parent(dev), child, irq, cookie); 699#endif 700 } 701 else 702 return BUS_TEARDOWN_INTR(device_get_parent(dev), dev, irq, cookie); 703} 704 705static device_method_t ata_pci_methods[] = { 706 /* device interface */ 707 DEVMETHOD(device_probe, ata_pci_probe), 708 DEVMETHOD(device_attach, ata_pci_attach), 709 DEVMETHOD(device_shutdown, bus_generic_shutdown), 710 DEVMETHOD(device_suspend, bus_generic_suspend), 711 DEVMETHOD(device_resume, bus_generic_resume), 712 713 /* bus methods */ 714 DEVMETHOD(bus_print_child, ata_pci_print_child), 715 DEVMETHOD(bus_alloc_resource, ata_pci_alloc_resource), 716 DEVMETHOD(bus_release_resource, ata_pci_release_resource), 717 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 718 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 719 DEVMETHOD(bus_setup_intr, ata_pci_setup_intr), 720 DEVMETHOD(bus_teardown_intr, ata_pci_teardown_intr), 721 { 0, 0 } 722}; 723 724static driver_t ata_pci_driver = { 725 "atapci", 726 ata_pci_methods, 727 sizeof(struct ata_pci_softc), 728}; 729 730DRIVER_MODULE(atapci, pci, ata_pci_driver, ata_pci_devclass, 0, 0); 731 732static int 733ata_pcisub_probe(device_t dev) 734{ 735 struct ata_softc *scp = device_get_softc(dev); 736 device_t *list; 737 int count, i; 738 739 /* find channel number on this controller */ 740 device_get_children(device_get_parent(dev), &list, &count); 741 for (i = 0; i < count; i++) { 742 if (list[i] == dev) 743 scp->channel = i; 744 } 745 746 scp->chiptype = pci_get_devid(device_get_parent(dev)); 747 748 return ata_probe(dev); 749} 750 751static device_method_t ata_pcisub_methods[] = { 752 /* device interface */ 753 DEVMETHOD(device_probe, ata_pcisub_probe), 754 DEVMETHOD(device_attach, ata_attach), 755 DEVMETHOD(device_detach, ata_detach), 756 DEVMETHOD(device_resume, ata_resume), 757 { 0, 0 } 758}; 759 760static driver_t ata_pcisub_driver = { 761 "ata", 762 ata_pcisub_methods, 763 sizeof(struct ata_softc), 764}; 765 766DRIVER_MODULE(ata, atapci, ata_pcisub_driver, ata_devclass, 0, 0); 767#endif 768 769static int 770ata_probe(device_t dev) 771{ 772 struct ata_softc *scp = device_get_softc(dev);
| 676 return ENOENT; 677 678 if (ATA_MASTERDEV(dev)) { 679#ifdef __alpha__ 680 return alpha_platform_release_ide_intr(channel, r); 681#else 682 return BUS_RELEASE_RESOURCE(device_get_parent(dev), 683 child, SYS_RES_IRQ, rid, r); 684#endif 685 } 686 else { 687 if (--sc->irqcnt) 688 return 0; 689 690 return BUS_RELEASE_RESOURCE(device_get_parent(dev), 691 dev, SYS_RES_IRQ, rid, r); 692 } 693 } 694 return EINVAL; 695} 696 697static int 698ata_pci_setup_intr(device_t dev, device_t child, struct resource *irq, 699 int flags, driver_intr_t *intr, void *arg, 700 void **cookiep) 701{ 702 if (ATA_MASTERDEV(dev)) { 703#ifdef __alpha__ 704 return alpha_platform_setup_ide_intr(child, irq, intr, arg, cookiep); 705#else 706 return BUS_SETUP_INTR(device_get_parent(dev), child, irq, 707 flags, intr, arg, cookiep); 708#endif 709 } 710 else 711 return BUS_SETUP_INTR(device_get_parent(dev), dev, irq, 712 flags, intr, arg, cookiep); 713} 714 715static int 716ata_pci_teardown_intr(device_t dev, device_t child, struct resource *irq, 717 void *cookie) 718{ 719 if (ATA_MASTERDEV(dev)) { 720#ifdef __alpha__ 721 return alpha_platform_teardown_ide_intr(child, irq, cookie); 722#else 723 return BUS_TEARDOWN_INTR(device_get_parent(dev), child, irq, cookie); 724#endif 725 } 726 else 727 return BUS_TEARDOWN_INTR(device_get_parent(dev), dev, irq, cookie); 728} 729 730static device_method_t ata_pci_methods[] = { 731 /* device interface */ 732 DEVMETHOD(device_probe, ata_pci_probe), 733 DEVMETHOD(device_attach, ata_pci_attach), 734 DEVMETHOD(device_shutdown, bus_generic_shutdown), 735 DEVMETHOD(device_suspend, bus_generic_suspend), 736 DEVMETHOD(device_resume, bus_generic_resume), 737 738 /* bus methods */ 739 DEVMETHOD(bus_print_child, ata_pci_print_child), 740 DEVMETHOD(bus_alloc_resource, ata_pci_alloc_resource), 741 DEVMETHOD(bus_release_resource, ata_pci_release_resource), 742 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 743 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 744 DEVMETHOD(bus_setup_intr, ata_pci_setup_intr), 745 DEVMETHOD(bus_teardown_intr, ata_pci_teardown_intr), 746 { 0, 0 } 747}; 748 749static driver_t ata_pci_driver = { 750 "atapci", 751 ata_pci_methods, 752 sizeof(struct ata_pci_softc), 753}; 754 755DRIVER_MODULE(atapci, pci, ata_pci_driver, ata_pci_devclass, 0, 0); 756 757static int 758ata_pcisub_probe(device_t dev) 759{ 760 struct ata_softc *scp = device_get_softc(dev); 761 device_t *list; 762 int count, i; 763 764 /* find channel number on this controller */ 765 device_get_children(device_get_parent(dev), &list, &count); 766 for (i = 0; i < count; i++) { 767 if (list[i] == dev) 768 scp->channel = i; 769 } 770 771 scp->chiptype = pci_get_devid(device_get_parent(dev)); 772 773 return ata_probe(dev); 774} 775 776static device_method_t ata_pcisub_methods[] = { 777 /* device interface */ 778 DEVMETHOD(device_probe, ata_pcisub_probe), 779 DEVMETHOD(device_attach, ata_attach), 780 DEVMETHOD(device_detach, ata_detach), 781 DEVMETHOD(device_resume, ata_resume), 782 { 0, 0 } 783}; 784 785static driver_t ata_pcisub_driver = { 786 "ata", 787 ata_pcisub_methods, 788 sizeof(struct ata_softc), 789}; 790 791DRIVER_MODULE(ata, atapci, ata_pcisub_driver, ata_devclass, 0, 0); 792#endif 793 794static int 795ata_probe(device_t dev) 796{ 797 struct ata_softc *scp = device_get_softc(dev);
|
773 struct resource *io = 0; 774 struct resource *altio = 0; 775 struct resource *bmio = 0;
| |
776 int rid;
| 798 int rid;
|
777 u_int32_t ioaddr, altioaddr, bmaddr;
| |
778 int mask = 0; 779 u_int8_t status0, status1; 780 781 if (!scp || scp->flags & ATA_ATTACHED) 782 return ENXIO; 783 784 /* initialize the softc basics */ 785 scp->active = ATA_IDLE; 786 scp->dev = dev; 787 scp->devices = 0; 788 789 rid = ATA_IOADDR_RID;
| 799 int mask = 0; 800 u_int8_t status0, status1; 801 802 if (!scp || scp->flags & ATA_ATTACHED) 803 return ENXIO; 804 805 /* initialize the softc basics */ 806 scp->active = ATA_IDLE; 807 scp->dev = dev; 808 scp->devices = 0; 809 810 rid = ATA_IOADDR_RID;
|
790 io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 791 ATA_IOSIZE, RF_ACTIVE); 792 if (!io)
| 811 scp->r_io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 812 ATA_IOSIZE, RF_ACTIVE); 813 if (!scp->r_io)
|
793 goto failure;
| 814 goto failure;
|
794 ioaddr = rman_get_start(io);
| |
795 796 rid = ATA_ALTADDR_RID;
| 815 816 rid = ATA_ALTADDR_RID;
|
797 altio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 798 ATA_ALTIOSIZE, RF_ACTIVE); 799 if (altio) { 800 if (scp->flags & ATA_USE_16BIT || ATA_MASTERDEV(device_get_parent(dev))) 801 altioaddr = rman_get_start(altio); 802 else 803 altioaddr = rman_get_start(altio) + 0x02; 804 } 805 else 806 altioaddr = ioaddr + ATA_PCCARD_ALTOFFSET;
| 817 scp->r_altio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 818 ATA_ALTIOSIZE, RF_ACTIVE); 819 if (!scp->r_altio) 820 goto failure;
|
807 808 rid = ATA_BMADDR_RID;
| 821 822 rid = ATA_BMADDR_RID;
|
809 bmio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1, RF_ACTIVE); 810 bmaddr = bmio ? rman_get_start(bmio) : 0;
| 823 scp->r_bmio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 824 ATA_BMIOSIZE, RF_ACTIVE);
|
811
| 825
|
812 /* store the IO resources for eventual later release */ 813 scp->r_io = io; 814 scp->r_altio = altio; 815 scp->r_bmio = bmio; 816 817 /* store the physical IO addresse for easy access */ 818 scp->ioaddr = ioaddr; 819 scp->altioaddr = altioaddr; 820 scp->bmaddr = bmaddr; 821
| |
822 if (bootverbose) 823 ata_printf(scp, -1, "iobase=0x%04x altiobase=0x%04x bmaddr=0x%04x\n",
| 826 if (bootverbose) 827 ata_printf(scp, -1, "iobase=0x%04x altiobase=0x%04x bmaddr=0x%04x\n",
|
824 scp->ioaddr, scp->altioaddr, scp->bmaddr);
| 828 (int)rman_get_start(scp->r_io), 829 (int)rman_get_start(scp->r_altio), 830 (scp->r_bmio) ? (int)rman_get_start(scp->r_bmio) : 0);
|
825 826 /* do we have any signs of ATA/ATAPI HW being present ? */
| 831 832 /* do we have any signs of ATA/ATAPI HW being present ? */
|
827 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
| 833 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
|
828 DELAY(1);
| 834 DELAY(1);
|
829 status0 = inb(scp->ioaddr + ATA_STATUS);
| 835 status0 = ATA_INB(scp->r_io, ATA_STATUS);
|
830 if ((status0 & 0xf8) != 0xf8 && status0 != 0xa5) 831 mask |= 0x01;
| 836 if ((status0 & 0xf8) != 0xf8 && status0 != 0xa5) 837 mask |= 0x01;
|
832 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
| 838 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
|
833 DELAY(1);
| 839 DELAY(1);
|
834 status1 = inb(scp->ioaddr + ATA_STATUS);
| 840 status1 = ATA_INB(scp->r_io, ATA_STATUS);
|
835 if ((status1 & 0xf8) != 0xf8 && status1 != 0xa5) 836 mask |= 0x02; 837 838 if (bootverbose) 839 ata_printf(scp, -1, "mask=%02x status0=%02x status1=%02x\n", 840 mask, status0, status1); 841 if (!mask) 842 goto failure; 843 844 ata_reset(scp, &mask); 845 846 if (!mask) 847 goto failure; 848 849 TAILQ_INIT(&scp->ata_queue); 850 TAILQ_INIT(&scp->atapi_queue); 851 return 0; 852 853failure:
| 841 if ((status1 & 0xf8) != 0xf8 && status1 != 0xa5) 842 mask |= 0x02; 843 844 if (bootverbose) 845 ata_printf(scp, -1, "mask=%02x status0=%02x status1=%02x\n", 846 mask, status0, status1); 847 if (!mask) 848 goto failure; 849 850 ata_reset(scp, &mask); 851 852 if (!mask) 853 goto failure; 854 855 TAILQ_INIT(&scp->ata_queue); 856 TAILQ_INIT(&scp->atapi_queue); 857 return 0; 858 859failure:
|
854 if (io) 855 bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, io); 856 if (altio) 857 bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, altio); 858 if (bmio) 859 bus_release_resource(dev, SYS_RES_IOPORT, ATA_BMADDR_RID, bmio);
| 860 if (scp->r_io) 861 bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, scp->r_io); 862 if (scp->r_altio) 863 bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID,scp->r_altio); 864 if (scp->r_bmio) 865 bus_release_resource(dev, SYS_RES_IOPORT, ATA_BMADDR_RID, scp->r_bmio);
|
860 if (bootverbose) 861 ata_printf(scp, -1, "probe allocation failed\n"); 862 return ENXIO; 863} 864 865static int 866ata_attach(device_t dev) 867{ 868 struct ata_softc *scp = device_get_softc(dev);
| 866 if (bootverbose) 867 ata_printf(scp, -1, "probe allocation failed\n"); 868 return ENXIO; 869} 870 871static int 872ata_attach(device_t dev) 873{ 874 struct ata_softc *scp = device_get_softc(dev);
|
869 int error, rid = 0;
| 875 int error, rid;
|
870 871 if (!scp || scp->flags & ATA_ATTACHED) 872 return ENXIO; 873
| 876 877 if (!scp || scp->flags & ATA_ATTACHED) 878 return ENXIO; 879
|
| 880 rid = ATA_IRQ_RID;
|
874 scp->r_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1, 875 RF_SHAREABLE | RF_ACTIVE); 876 if (!scp->r_irq) { 877 ata_printf(scp, -1, "unable to allocate interrupt\n"); 878 return ENXIO; 879 } 880 if ((error = bus_setup_intr(dev, scp->r_irq, INTR_TYPE_BIO, ata_intr, 881 scp, &scp->ih))) 882 return error; 883 884 /* 885 * do not attach devices if we are in early boot, this is done later 886 * when interrupts are enabled by a hook into the boot process. 887 * otherwise attach what the probe has found in scp->devices. 888 */ 889 if (!ata_delayed_attach) { 890 if (scp->devices & ATA_ATA_SLAVE) 891 if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATA_IDENTIFY)) 892 scp->devices &= ~ATA_ATA_SLAVE; 893 if (scp->devices & ATA_ATAPI_SLAVE) 894 if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATAPI_IDENTIFY)) 895 scp->devices &= ~ATA_ATAPI_SLAVE; 896 if (scp->devices & ATA_ATA_MASTER) 897 if (ata_getparam(scp, ATA_MASTER, ATA_C_ATA_IDENTIFY)) 898 scp->devices &= ~ATA_ATA_MASTER; 899 if (scp->devices & ATA_ATAPI_MASTER) 900 if (ata_getparam(scp, ATA_MASTER,ATA_C_ATAPI_IDENTIFY)) 901 scp->devices &= ~ATA_ATAPI_MASTER; 902#ifdef DEV_ATADISK 903 if (scp->devices & ATA_ATA_MASTER) 904 ad_attach(scp, ATA_MASTER); 905 if (scp->devices & ATA_ATA_SLAVE) 906 ad_attach(scp, ATA_SLAVE); 907#endif 908#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 909 if (scp->devices & ATA_ATAPI_MASTER) 910 atapi_attach(scp, ATA_MASTER); 911 if (scp->devices & ATA_ATAPI_SLAVE) 912 atapi_attach(scp, ATA_SLAVE); 913#endif 914 } 915 scp->flags |= ATA_ATTACHED; 916 return 0; 917} 918 919static int 920ata_detach(device_t dev) 921{ 922 struct ata_softc *scp = device_get_softc(dev); 923 924 if (!scp || !(scp->flags & ATA_ATTACHED)) 925 return ENXIO; 926
| 881 scp->r_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1, 882 RF_SHAREABLE | RF_ACTIVE); 883 if (!scp->r_irq) { 884 ata_printf(scp, -1, "unable to allocate interrupt\n"); 885 return ENXIO; 886 } 887 if ((error = bus_setup_intr(dev, scp->r_irq, INTR_TYPE_BIO, ata_intr, 888 scp, &scp->ih))) 889 return error; 890 891 /* 892 * do not attach devices if we are in early boot, this is done later 893 * when interrupts are enabled by a hook into the boot process. 894 * otherwise attach what the probe has found in scp->devices. 895 */ 896 if (!ata_delayed_attach) { 897 if (scp->devices & ATA_ATA_SLAVE) 898 if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATA_IDENTIFY)) 899 scp->devices &= ~ATA_ATA_SLAVE; 900 if (scp->devices & ATA_ATAPI_SLAVE) 901 if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATAPI_IDENTIFY)) 902 scp->devices &= ~ATA_ATAPI_SLAVE; 903 if (scp->devices & ATA_ATA_MASTER) 904 if (ata_getparam(scp, ATA_MASTER, ATA_C_ATA_IDENTIFY)) 905 scp->devices &= ~ATA_ATA_MASTER; 906 if (scp->devices & ATA_ATAPI_MASTER) 907 if (ata_getparam(scp, ATA_MASTER,ATA_C_ATAPI_IDENTIFY)) 908 scp->devices &= ~ATA_ATAPI_MASTER; 909#ifdef DEV_ATADISK 910 if (scp->devices & ATA_ATA_MASTER) 911 ad_attach(scp, ATA_MASTER); 912 if (scp->devices & ATA_ATA_SLAVE) 913 ad_attach(scp, ATA_SLAVE); 914#endif 915#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 916 if (scp->devices & ATA_ATAPI_MASTER) 917 atapi_attach(scp, ATA_MASTER); 918 if (scp->devices & ATA_ATAPI_SLAVE) 919 atapi_attach(scp, ATA_SLAVE); 920#endif 921 } 922 scp->flags |= ATA_ATTACHED; 923 return 0; 924} 925 926static int 927ata_detach(device_t dev) 928{ 929 struct ata_softc *scp = device_get_softc(dev); 930 931 if (!scp || !(scp->flags & ATA_ATTACHED)) 932 return ENXIO; 933
|
| 934 /* disable interrupts on devices */ 935 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER); 936 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_IDS | ATA_A_4BIT); 937 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_SLAVE); 938 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_IDS | ATA_A_4BIT); 939
|
927#ifdef DEV_ATADISK 928 if (scp->devices & ATA_ATA_MASTER) 929 ad_detach(scp->dev_softc[0]); 930 if (scp->devices & ATA_ATA_SLAVE) 931 ad_detach(scp->dev_softc[1]); 932#endif 933#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 934 if (scp->devices & ATA_ATAPI_MASTER) 935 atapi_detach(scp->dev_softc[0]); 936 if (scp->devices & ATA_ATAPI_SLAVE) 937 atapi_detach(scp->dev_softc[1]); 938#endif
| 940#ifdef DEV_ATADISK 941 if (scp->devices & ATA_ATA_MASTER) 942 ad_detach(scp->dev_softc[0]); 943 if (scp->devices & ATA_ATA_SLAVE) 944 ad_detach(scp->dev_softc[1]); 945#endif 946#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 947 if (scp->devices & ATA_ATAPI_MASTER) 948 atapi_detach(scp->dev_softc[0]); 949 if (scp->devices & ATA_ATAPI_SLAVE) 950 atapi_detach(scp->dev_softc[1]); 951#endif
|
| 952
|
939 if (scp->dev_param[ATA_DEV(ATA_MASTER)]) { 940 free(scp->dev_param[ATA_DEV(ATA_MASTER)], M_ATA); 941 scp->dev_param[ATA_DEV(ATA_MASTER)] = NULL; 942 } 943 if (scp->dev_param[ATA_DEV(ATA_SLAVE)]) { 944 free(scp->dev_param[ATA_DEV(ATA_SLAVE)], M_ATA); 945 scp->dev_param[ATA_DEV(ATA_SLAVE)] = NULL; 946 } 947 scp->dev_softc[ATA_DEV(ATA_MASTER)] = NULL; 948 scp->dev_softc[ATA_DEV(ATA_SLAVE)] = NULL; 949 scp->mode[ATA_DEV(ATA_MASTER)] = ATA_PIO; 950 scp->mode[ATA_DEV(ATA_SLAVE)] = ATA_PIO;
| 953 if (scp->dev_param[ATA_DEV(ATA_MASTER)]) { 954 free(scp->dev_param[ATA_DEV(ATA_MASTER)], M_ATA); 955 scp->dev_param[ATA_DEV(ATA_MASTER)] = NULL; 956 } 957 if (scp->dev_param[ATA_DEV(ATA_SLAVE)]) { 958 free(scp->dev_param[ATA_DEV(ATA_SLAVE)], M_ATA); 959 scp->dev_param[ATA_DEV(ATA_SLAVE)] = NULL; 960 } 961 scp->dev_softc[ATA_DEV(ATA_MASTER)] = NULL; 962 scp->dev_softc[ATA_DEV(ATA_SLAVE)] = NULL; 963 scp->mode[ATA_DEV(ATA_MASTER)] = ATA_PIO; 964 scp->mode[ATA_DEV(ATA_SLAVE)] = ATA_PIO;
|
| 965
|
951 bus_teardown_intr(dev, scp->r_irq, scp->ih);
| 966 bus_teardown_intr(dev, scp->r_irq, scp->ih);
|
952 bus_release_resource(dev, SYS_RES_IRQ, 0, scp->r_irq);
| 967 bus_release_resource(dev, SYS_RES_IRQ, ATA_IRQ_RID, scp->r_irq);
|
953 if (scp->r_bmio) 954 bus_release_resource(dev, SYS_RES_IOPORT, ATA_BMADDR_RID, scp->r_bmio);
| 968 if (scp->r_bmio) 969 bus_release_resource(dev, SYS_RES_IOPORT, ATA_BMADDR_RID, scp->r_bmio);
|
955 if (scp->r_altio) 956 bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID,scp->r_altio);
| 970 bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, scp->r_altio);
|
957 bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, scp->r_io); 958 scp->flags &= ~ATA_ATTACHED; 959 return 0; 960} 961 962static int 963ata_resume(device_t dev) 964{ 965 struct ata_softc *scp = device_get_softc(dev); 966 967 ata_reinit(scp); 968 return 0; 969} 970 971static int 972ata_getparam(struct ata_softc *scp, int device, u_int8_t command) 973{ 974 struct ata_params *ata_parm; 975 int8_t buffer[DEV_BSIZE]; 976 int retry = 0; 977 978 /* select drive */
| 971 bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, scp->r_io); 972 scp->flags &= ~ATA_ATTACHED; 973 return 0; 974} 975 976static int 977ata_resume(device_t dev) 978{ 979 struct ata_softc *scp = device_get_softc(dev); 980 981 ata_reinit(scp); 982 return 0; 983} 984 985static int 986ata_getparam(struct ata_softc *scp, int device, u_int8_t command) 987{ 988 struct ata_params *ata_parm; 989 int8_t buffer[DEV_BSIZE]; 990 int retry = 0; 991 992 /* select drive */
|
979 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | device);
| 993 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | device);
|
980 DELAY(1); 981 982 /* enable interrupt */
| 994 DELAY(1); 995 996 /* enable interrupt */
|
983 outb(scp->altioaddr, ATA_A_4BIT);
| 997 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_4BIT);
|
984 DELAY(1); 985 986 /* apparently some devices needs this repeated */ 987 do { 988 if (ata_command(scp, device, command, 0, 0, 0, 0, 0, ATA_WAIT_INTR)) { 989 ata_printf(scp, device, "identify failed\n"); 990 return -1; 991 } 992 if (retry++ > 4) { 993 ata_printf(scp, device, "identify retries exceeded\n"); 994 return -1; 995 } 996 } while (ata_wait(scp, device, 997 ((command == ATA_C_ATAPI_IDENTIFY) ? 998 ATA_S_DRQ : (ATA_S_READY | ATA_S_DSC | ATA_S_DRQ)))); 999
| 998 DELAY(1); 999 1000 /* apparently some devices needs this repeated */ 1001 do { 1002 if (ata_command(scp, device, command, 0, 0, 0, 0, 0, ATA_WAIT_INTR)) { 1003 ata_printf(scp, device, "identify failed\n"); 1004 return -1; 1005 } 1006 if (retry++ > 4) { 1007 ata_printf(scp, device, "identify retries exceeded\n"); 1008 return -1; 1009 } 1010 } while (ata_wait(scp, device, 1011 ((command == ATA_C_ATAPI_IDENTIFY) ? 1012 ATA_S_DRQ : (ATA_S_READY | ATA_S_DSC | ATA_S_DRQ)))); 1013
|
1000 insw(scp->ioaddr + ATA_DATA, buffer, sizeof(buffer)/sizeof(int16_t));
| 1014 ATA_INSW(scp->r_io, ATA_DATA, (int16_t *)buffer, 1015 sizeof(buffer)/sizeof(int16_t));
|
1001 ata_parm = malloc(sizeof(struct ata_params), M_ATA, M_NOWAIT); 1002 if (!ata_parm) { 1003 ata_printf(scp, device, "malloc for identify data failed\n"); 1004 return -1; 1005 } 1006 bcopy(buffer, ata_parm, sizeof(struct ata_params)); 1007 if (command == ATA_C_ATA_IDENTIFY || 1008 !((ata_parm->model[0] == 'N' && ata_parm->model[1] == 'E') || 1009 (ata_parm->model[0] == 'F' && ata_parm->model[1] == 'X'))) 1010 bswap(ata_parm->model, sizeof(ata_parm->model)); 1011 btrim(ata_parm->model, sizeof(ata_parm->model)); 1012 bpack(ata_parm->model, ata_parm->model, sizeof(ata_parm->model)); 1013 bswap(ata_parm->revision, sizeof(ata_parm->revision)); 1014 btrim(ata_parm->revision, sizeof(ata_parm->revision)); 1015 bpack(ata_parm->revision, ata_parm->revision, sizeof(ata_parm->revision)); 1016 scp->dev_param[ATA_DEV(device)] = ata_parm; 1017 return 0; 1018} 1019 1020static void 1021ata_boot_attach(void) 1022{ 1023 struct ata_softc *scp; 1024 int ctlr; 1025 1026 /* 1027 * run through all ata devices and look for real ATA & ATAPI devices 1028 * using the hints we found in the early probe, this avoids some of 1029 * the delays probing of non-exsistent devices can cause. 1030 */ 1031 for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) { 1032 if (!(scp = devclass_get_softc(ata_devclass, ctlr))) 1033 continue; 1034 if (scp->devices & ATA_ATA_SLAVE) 1035 if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATA_IDENTIFY)) 1036 scp->devices &= ~ATA_ATA_SLAVE; 1037 if (scp->devices & ATA_ATAPI_SLAVE) 1038 if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATAPI_IDENTIFY)) 1039 scp->devices &= ~ATA_ATAPI_SLAVE; 1040 if (scp->devices & ATA_ATA_MASTER) 1041 if (ata_getparam(scp, ATA_MASTER, ATA_C_ATA_IDENTIFY)) 1042 scp->devices &= ~ATA_ATA_MASTER; 1043 if (scp->devices & ATA_ATAPI_MASTER) 1044 if (ata_getparam(scp, ATA_MASTER,ATA_C_ATAPI_IDENTIFY)) 1045 scp->devices &= ~ATA_ATAPI_MASTER; 1046 } 1047 1048#ifdef DEV_ATADISK 1049 /* now we know whats there, do the real attach, first the ATA disks */ 1050 for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) { 1051 if (!(scp = devclass_get_softc(ata_devclass, ctlr))) 1052 continue; 1053 if (scp->devices & ATA_ATA_MASTER) 1054 ad_attach(scp, ATA_MASTER); 1055 if (scp->devices & ATA_ATA_SLAVE) 1056 ad_attach(scp, ATA_SLAVE); 1057 } 1058#endif 1059#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1060 /* then the atapi devices */ 1061 for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) { 1062 if (!(scp = devclass_get_softc(ata_devclass, ctlr))) 1063 continue; 1064 if (scp->devices & ATA_ATAPI_MASTER) 1065 atapi_attach(scp, ATA_MASTER); 1066 if (scp->devices & ATA_ATAPI_SLAVE) 1067 atapi_attach(scp, ATA_SLAVE); 1068 } 1069#endif 1070 if (ata_delayed_attach) { 1071 config_intrhook_disestablish(ata_delayed_attach); 1072 free(ata_delayed_attach, M_ATA); 1073 ata_delayed_attach = NULL; 1074 } 1075} 1076 1077static void 1078ata_intr(void *data) 1079{ 1080 struct ata_softc *scp = (struct ata_softc *)data;
| 1016 ata_parm = malloc(sizeof(struct ata_params), M_ATA, M_NOWAIT); 1017 if (!ata_parm) { 1018 ata_printf(scp, device, "malloc for identify data failed\n"); 1019 return -1; 1020 } 1021 bcopy(buffer, ata_parm, sizeof(struct ata_params)); 1022 if (command == ATA_C_ATA_IDENTIFY || 1023 !((ata_parm->model[0] == 'N' && ata_parm->model[1] == 'E') || 1024 (ata_parm->model[0] == 'F' && ata_parm->model[1] == 'X'))) 1025 bswap(ata_parm->model, sizeof(ata_parm->model)); 1026 btrim(ata_parm->model, sizeof(ata_parm->model)); 1027 bpack(ata_parm->model, ata_parm->model, sizeof(ata_parm->model)); 1028 bswap(ata_parm->revision, sizeof(ata_parm->revision)); 1029 btrim(ata_parm->revision, sizeof(ata_parm->revision)); 1030 bpack(ata_parm->revision, ata_parm->revision, sizeof(ata_parm->revision)); 1031 scp->dev_param[ATA_DEV(device)] = ata_parm; 1032 return 0; 1033} 1034 1035static void 1036ata_boot_attach(void) 1037{ 1038 struct ata_softc *scp; 1039 int ctlr; 1040 1041 /* 1042 * run through all ata devices and look for real ATA & ATAPI devices 1043 * using the hints we found in the early probe, this avoids some of 1044 * the delays probing of non-exsistent devices can cause. 1045 */ 1046 for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) { 1047 if (!(scp = devclass_get_softc(ata_devclass, ctlr))) 1048 continue; 1049 if (scp->devices & ATA_ATA_SLAVE) 1050 if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATA_IDENTIFY)) 1051 scp->devices &= ~ATA_ATA_SLAVE; 1052 if (scp->devices & ATA_ATAPI_SLAVE) 1053 if (ata_getparam(scp, ATA_SLAVE, ATA_C_ATAPI_IDENTIFY)) 1054 scp->devices &= ~ATA_ATAPI_SLAVE; 1055 if (scp->devices & ATA_ATA_MASTER) 1056 if (ata_getparam(scp, ATA_MASTER, ATA_C_ATA_IDENTIFY)) 1057 scp->devices &= ~ATA_ATA_MASTER; 1058 if (scp->devices & ATA_ATAPI_MASTER) 1059 if (ata_getparam(scp, ATA_MASTER,ATA_C_ATAPI_IDENTIFY)) 1060 scp->devices &= ~ATA_ATAPI_MASTER; 1061 } 1062 1063#ifdef DEV_ATADISK 1064 /* now we know whats there, do the real attach, first the ATA disks */ 1065 for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) { 1066 if (!(scp = devclass_get_softc(ata_devclass, ctlr))) 1067 continue; 1068 if (scp->devices & ATA_ATA_MASTER) 1069 ad_attach(scp, ATA_MASTER); 1070 if (scp->devices & ATA_ATA_SLAVE) 1071 ad_attach(scp, ATA_SLAVE); 1072 } 1073#endif 1074#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1075 /* then the atapi devices */ 1076 for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) { 1077 if (!(scp = devclass_get_softc(ata_devclass, ctlr))) 1078 continue; 1079 if (scp->devices & ATA_ATAPI_MASTER) 1080 atapi_attach(scp, ATA_MASTER); 1081 if (scp->devices & ATA_ATAPI_SLAVE) 1082 atapi_attach(scp, ATA_SLAVE); 1083 } 1084#endif 1085 if (ata_delayed_attach) { 1086 config_intrhook_disestablish(ata_delayed_attach); 1087 free(ata_delayed_attach, M_ATA); 1088 ata_delayed_attach = NULL; 1089 } 1090} 1091 1092static void 1093ata_intr(void *data) 1094{ 1095 struct ata_softc *scp = (struct ata_softc *)data;
|
1081 struct ata_pci_softc *sc = device_get_softc(device_get_parent(scp->dev));
| |
1082 u_int8_t dmastat = 0; 1083 1084 /* 1085 * since we might share the IRQ with another device, and in some 1086 * cases with our twin channel, we only want to process interrupts 1087 * that we know this channel generated. 1088 */ 1089 switch (scp->chiptype) { 1090#if NPCI > 0 1091 case 0x00041103: /* HighPoint HPT366/368/370 */ 1092 if (((dmastat = ata_dmastatus(scp)) & 1093 (ATA_BMSTAT_ACTIVE | ATA_BMSTAT_INTERRUPT)) != ATA_BMSTAT_INTERRUPT) 1094 return;
| 1096 u_int8_t dmastat = 0; 1097 1098 /* 1099 * since we might share the IRQ with another device, and in some 1100 * cases with our twin channel, we only want to process interrupts 1101 * that we know this channel generated. 1102 */ 1103 switch (scp->chiptype) { 1104#if NPCI > 0 1105 case 0x00041103: /* HighPoint HPT366/368/370 */ 1106 if (((dmastat = ata_dmastatus(scp)) & 1107 (ATA_BMSTAT_ACTIVE | ATA_BMSTAT_INTERRUPT)) != ATA_BMSTAT_INTERRUPT) 1108 return;
|
1095 outb(scp->bmaddr + ATA_BMSTAT_PORT, dmastat | ATA_BMSTAT_INTERRUPT);
| 1109 ATA_OUTB(scp->r_bmio, ATA_BMSTAT_PORT, dmastat | ATA_BMSTAT_INTERRUPT);
|
1096 break; 1097 1098 case 0x06481095: /* CMD 648 */ 1099 case 0x06491095: /* CMD 649 */ 1100 if (!(pci_read_config(device_get_parent(scp->dev), 0x71, 1) & 1101 (scp->channel ? 0x08 : 0x04))) 1102 return; 1103 goto out; 1104 1105 case 0x4d33105a: /* Promise Ultra/Fasttrak 33 */ 1106 case 0x4d38105a: /* Promise Ultra/Fasttrak 66 */ 1107 case 0x4d30105a: /* Promise Ultra/Fasttrak 100 */ 1108 case 0x0d30105a: /* Promise OEM ATA100 */
| 1110 break; 1111 1112 case 0x06481095: /* CMD 648 */ 1113 case 0x06491095: /* CMD 649 */ 1114 if (!(pci_read_config(device_get_parent(scp->dev), 0x71, 1) & 1115 (scp->channel ? 0x08 : 0x04))) 1116 return; 1117 goto out; 1118 1119 case 0x4d33105a: /* Promise Ultra/Fasttrak 33 */ 1120 case 0x4d38105a: /* Promise Ultra/Fasttrak 66 */ 1121 case 0x4d30105a: /* Promise Ultra/Fasttrak 100 */ 1122 case 0x0d30105a: /* Promise OEM ATA100 */
|
1109 if (!(inl(rman_get_start(sc->bmio) + 0x1c) &
| 1123 if (!(ATA_INL(scp->r_bmio, (scp->channel ? 0x14 : 0x1c)) &
|
1110 (scp->channel ? 0x00004000 : 0x00000400))) 1111 return; 1112 /* FALLTHROUGH */ 1113out: 1114#endif 1115 default: 1116 if (scp->flags & ATA_DMA_ACTIVE) { 1117 if (!((dmastat = ata_dmastatus(scp)) & ATA_BMSTAT_INTERRUPT)) 1118 return;
| 1124 (scp->channel ? 0x00004000 : 0x00000400))) 1125 return; 1126 /* FALLTHROUGH */ 1127out: 1128#endif 1129 default: 1130 if (scp->flags & ATA_DMA_ACTIVE) { 1131 if (!((dmastat = ata_dmastatus(scp)) & ATA_BMSTAT_INTERRUPT)) 1132 return;
|
1119 outb(scp->bmaddr + ATA_BMSTAT_PORT, dmastat | ATA_BMSTAT_INTERRUPT);
| 1133 ATA_OUTB(scp->r_bmio, ATA_BMSTAT_PORT, 1134 dmastat | ATA_BMSTAT_INTERRUPT);
|
1120 } 1121 } 1122 DELAY(1); 1123 1124 /* if drive is busy it didn't interrupt */
| 1135 } 1136 } 1137 DELAY(1); 1138 1139 /* if drive is busy it didn't interrupt */
|
1125 if (inb(scp->altioaddr) & ATA_S_BUSY)
| 1140 if (ATA_INB(scp->r_altio, ATA_ALTSTAT) & ATA_S_BUSY)
|
1126 return; 1127 1128 /* clear interrupt and get status */
| 1141 return; 1142 1143 /* clear interrupt and get status */
|
1129 scp->status = inb(scp->ioaddr + ATA_STATUS);
| 1144 scp->status = ATA_INB(scp->r_io, ATA_STATUS);
|
1130 1131 if (scp->status & ATA_S_ERROR)
| 1145 1146 if (scp->status & ATA_S_ERROR)
|
1132 scp->error = inb(scp->ioaddr + ATA_ERROR);
| 1147 scp->error = ATA_INB(scp->r_io, ATA_ERROR);
|
1133 1134 /* find & call the responsible driver to process this interrupt */ 1135 switch (scp->active) { 1136#ifdef DEV_ATADISK 1137 case ATA_ACTIVE_ATA: 1138 if (!scp->running || ad_interrupt(scp->running) == ATA_OP_CONTINUES) 1139 return; 1140 break; 1141#endif 1142#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1143 case ATA_ACTIVE_ATAPI: 1144 if (!scp->running || atapi_interrupt(scp->running) == ATA_OP_CONTINUES) 1145 return; 1146 break; 1147#endif 1148 case ATA_WAIT_INTR: 1149 wakeup((caddr_t)scp); 1150 break; 1151 1152 case ATA_WAIT_READY: 1153 break; 1154 1155 case ATA_REINITING: 1156 return; 1157 1158 case ATA_IDLE: 1159 if (scp->flags & ATA_QUEUED) { 1160 scp->active = ATA_ACTIVE; /* XXX */ 1161 if (ata_service(scp) == ATA_OP_CONTINUES) 1162 return; 1163 } 1164 /* FALLTHROUGH */ 1165 1166 default: 1167#ifdef ATA_DEBUG 1168 { 1169 static int intr_count = 0; 1170 1171 if (intr_count++ < 10) 1172 ata_printf(scp, -1, "unwanted interrupt %d status = %02x\n", 1173 intr_count, scp->status); 1174 } 1175#endif 1176 } 1177 scp->active = ATA_IDLE; 1178 scp->running = NULL; 1179 ata_start(scp); 1180 return; 1181} 1182 1183void 1184ata_start(struct ata_softc *scp) 1185{ 1186#ifdef DEV_ATADISK 1187 struct ad_request *ad_request; 1188#endif 1189#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1190 struct atapi_request *atapi_request; 1191#endif 1192 1193 if (!atomic_cmpset_int(&scp->active, ATA_IDLE, ATA_ACTIVE)) 1194 return; 1195 1196#ifdef DEV_ATADISK 1197 /* find & call the responsible driver if anything on the ATA queue */ 1198 if (TAILQ_EMPTY(&scp->ata_queue)) { 1199 if (scp->devices & (ATA_ATA_MASTER) && scp->dev_softc[0]) 1200 ad_start((struct ad_softc *)scp->dev_softc[0]); 1201 if (scp->devices & (ATA_ATA_SLAVE) && scp->dev_softc[1]) 1202 ad_start((struct ad_softc *)scp->dev_softc[1]); 1203 } 1204 if ((ad_request = TAILQ_FIRST(&scp->ata_queue))) { 1205 TAILQ_REMOVE(&scp->ata_queue, ad_request, chain); 1206 scp->active = ATA_ACTIVE_ATA; 1207 scp->running = ad_request; 1208 if (ad_transfer(ad_request) == ATA_OP_CONTINUES) 1209 return; 1210 } 1211 1212#endif 1213#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1214 /* find & call the responsible driver if anything on the ATAPI queue */ 1215 if (TAILQ_EMPTY(&scp->atapi_queue)) { 1216 if (scp->devices & (ATA_ATAPI_MASTER) && scp->dev_softc[0]) 1217 atapi_start((struct atapi_softc *)scp->dev_softc[0]); 1218 if (scp->devices & (ATA_ATAPI_SLAVE) && scp->dev_softc[1]) 1219 atapi_start((struct atapi_softc *)scp->dev_softc[1]); 1220 } 1221 if ((atapi_request = TAILQ_FIRST(&scp->atapi_queue))) { 1222 TAILQ_REMOVE(&scp->atapi_queue, atapi_request, chain); 1223 scp->active = ATA_ACTIVE_ATAPI; 1224 scp->running = atapi_request; 1225 atapi_transfer(atapi_request); 1226 return; 1227 } 1228#endif 1229 scp->active = ATA_IDLE; 1230} 1231 1232void 1233ata_reset(struct ata_softc *scp, int *mask) 1234{ 1235 int timeout; 1236 u_int8_t a, b, ostat0, ostat1; 1237 u_int8_t status0 = ATA_S_BUSY, status1 = ATA_S_BUSY; 1238 1239 /* get the current status of the devices */
| 1148 1149 /* find & call the responsible driver to process this interrupt */ 1150 switch (scp->active) { 1151#ifdef DEV_ATADISK 1152 case ATA_ACTIVE_ATA: 1153 if (!scp->running || ad_interrupt(scp->running) == ATA_OP_CONTINUES) 1154 return; 1155 break; 1156#endif 1157#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1158 case ATA_ACTIVE_ATAPI: 1159 if (!scp->running || atapi_interrupt(scp->running) == ATA_OP_CONTINUES) 1160 return; 1161 break; 1162#endif 1163 case ATA_WAIT_INTR: 1164 wakeup((caddr_t)scp); 1165 break; 1166 1167 case ATA_WAIT_READY: 1168 break; 1169 1170 case ATA_REINITING: 1171 return; 1172 1173 case ATA_IDLE: 1174 if (scp->flags & ATA_QUEUED) { 1175 scp->active = ATA_ACTIVE; /* XXX */ 1176 if (ata_service(scp) == ATA_OP_CONTINUES) 1177 return; 1178 } 1179 /* FALLTHROUGH */ 1180 1181 default: 1182#ifdef ATA_DEBUG 1183 { 1184 static int intr_count = 0; 1185 1186 if (intr_count++ < 10) 1187 ata_printf(scp, -1, "unwanted interrupt %d status = %02x\n", 1188 intr_count, scp->status); 1189 } 1190#endif 1191 } 1192 scp->active = ATA_IDLE; 1193 scp->running = NULL; 1194 ata_start(scp); 1195 return; 1196} 1197 1198void 1199ata_start(struct ata_softc *scp) 1200{ 1201#ifdef DEV_ATADISK 1202 struct ad_request *ad_request; 1203#endif 1204#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1205 struct atapi_request *atapi_request; 1206#endif 1207 1208 if (!atomic_cmpset_int(&scp->active, ATA_IDLE, ATA_ACTIVE)) 1209 return; 1210 1211#ifdef DEV_ATADISK 1212 /* find & call the responsible driver if anything on the ATA queue */ 1213 if (TAILQ_EMPTY(&scp->ata_queue)) { 1214 if (scp->devices & (ATA_ATA_MASTER) && scp->dev_softc[0]) 1215 ad_start((struct ad_softc *)scp->dev_softc[0]); 1216 if (scp->devices & (ATA_ATA_SLAVE) && scp->dev_softc[1]) 1217 ad_start((struct ad_softc *)scp->dev_softc[1]); 1218 } 1219 if ((ad_request = TAILQ_FIRST(&scp->ata_queue))) { 1220 TAILQ_REMOVE(&scp->ata_queue, ad_request, chain); 1221 scp->active = ATA_ACTIVE_ATA; 1222 scp->running = ad_request; 1223 if (ad_transfer(ad_request) == ATA_OP_CONTINUES) 1224 return; 1225 } 1226 1227#endif 1228#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1229 /* find & call the responsible driver if anything on the ATAPI queue */ 1230 if (TAILQ_EMPTY(&scp->atapi_queue)) { 1231 if (scp->devices & (ATA_ATAPI_MASTER) && scp->dev_softc[0]) 1232 atapi_start((struct atapi_softc *)scp->dev_softc[0]); 1233 if (scp->devices & (ATA_ATAPI_SLAVE) && scp->dev_softc[1]) 1234 atapi_start((struct atapi_softc *)scp->dev_softc[1]); 1235 } 1236 if ((atapi_request = TAILQ_FIRST(&scp->atapi_queue))) { 1237 TAILQ_REMOVE(&scp->atapi_queue, atapi_request, chain); 1238 scp->active = ATA_ACTIVE_ATAPI; 1239 scp->running = atapi_request; 1240 atapi_transfer(atapi_request); 1241 return; 1242 } 1243#endif 1244 scp->active = ATA_IDLE; 1245} 1246 1247void 1248ata_reset(struct ata_softc *scp, int *mask) 1249{ 1250 int timeout; 1251 u_int8_t a, b, ostat0, ostat1; 1252 u_int8_t status0 = ATA_S_BUSY, status1 = ATA_S_BUSY; 1253 1254 /* get the current status of the devices */
|
1240 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
| 1255 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
|
1241 DELAY(10);
| 1256 DELAY(10);
|
1242 ostat1 = inb(scp->ioaddr + ATA_STATUS); 1243 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
| 1257 ostat1 = ATA_INB(scp->r_io, ATA_STATUS); 1258 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
|
1244 DELAY(10);
| 1259 DELAY(10);
|
1245 ostat0 = inb(scp->ioaddr + ATA_STATUS);
| 1260 ostat0 = ATA_INB(scp->r_io, ATA_STATUS);
|
1246 1247 /* in some setups we dont want to test for a slave */ 1248 if (scp->flags & ATA_NO_SLAVE) 1249 *mask &= ~0x02; 1250 1251 if (bootverbose) 1252 ata_printf(scp, -1, "mask=%02x ostat0=%02x ostat2=%02x\n", 1253 *mask, ostat0, ostat1); 1254 1255 /* reset channel */
| 1261 1262 /* in some setups we dont want to test for a slave */ 1263 if (scp->flags & ATA_NO_SLAVE) 1264 *mask &= ~0x02; 1265 1266 if (bootverbose) 1267 ata_printf(scp, -1, "mask=%02x ostat0=%02x ostat2=%02x\n", 1268 *mask, ostat0, ostat1); 1269 1270 /* reset channel */
|
1256 outb(scp->altioaddr, ATA_A_IDS | ATA_A_RESET);
| 1271 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_IDS | ATA_A_RESET);
|
1257 DELAY(10000);
| 1272 DELAY(10000);
|
1258 outb(scp->altioaddr, ATA_A_IDS);
| 1273 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_IDS);
|
1259 DELAY(100000);
| 1274 DELAY(100000);
|
1260 inb(scp->ioaddr + ATA_ERROR);
| 1275 ATA_INB(scp->r_io, ATA_ERROR);
|
1261 scp->devices = 0; 1262 1263 /* wait for BUSY to go inactive */ 1264 for (timeout = 0; timeout < 310000; timeout++) { 1265 if (status0 & ATA_S_BUSY) {
| 1276 scp->devices = 0; 1277 1278 /* wait for BUSY to go inactive */ 1279 for (timeout = 0; timeout < 310000; timeout++) { 1280 if (status0 & ATA_S_BUSY) {
|
1266 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
| 1281 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
|
1267 DELAY(10);
| 1282 DELAY(10);
|
1268 status0 = inb(scp->ioaddr + ATA_STATUS);
| 1283 status0 = ATA_INB(scp->r_io, ATA_STATUS);
|
1269 if (!(status0 & ATA_S_BUSY)) { 1270 /* check for ATAPI signature while its still there */
| 1284 if (!(status0 & ATA_S_BUSY)) { 1285 /* check for ATAPI signature while its still there */
|
1271 a = inb(scp->ioaddr + ATA_CYL_LSB); 1272 b = inb(scp->ioaddr + ATA_CYL_MSB);
| 1286 a = ATA_INB(scp->r_io, ATA_CYL_LSB); 1287 b = ATA_INB(scp->r_io, ATA_CYL_MSB);
|
1273 if (bootverbose) 1274 ata_printf(scp, ATA_MASTER, 1275 "ATAPI probe a=%02x b=%02x\n", a, b); 1276 if (a == ATAPI_MAGIC_LSB && b == ATAPI_MAGIC_MSB) 1277 scp->devices |= ATA_ATAPI_MASTER; 1278 } 1279 } 1280 if (status1 & ATA_S_BUSY) {
| 1288 if (bootverbose) 1289 ata_printf(scp, ATA_MASTER, 1290 "ATAPI probe a=%02x b=%02x\n", a, b); 1291 if (a == ATAPI_MAGIC_LSB && b == ATAPI_MAGIC_MSB) 1292 scp->devices |= ATA_ATAPI_MASTER; 1293 } 1294 } 1295 if (status1 & ATA_S_BUSY) {
|
1281 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
| 1296 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
|
1282 DELAY(10);
| 1297 DELAY(10);
|
1283 status1 = inb(scp->ioaddr + ATA_STATUS);
| 1298 status1 = ATA_INB(scp->r_io, ATA_STATUS);
|
1284 if (!(status1 & ATA_S_BUSY)) { 1285 /* check for ATAPI signature while its still there */
| 1299 if (!(status1 & ATA_S_BUSY)) { 1300 /* check for ATAPI signature while its still there */
|
1286 a = inb(scp->ioaddr + ATA_CYL_LSB); 1287 b = inb(scp->ioaddr + ATA_CYL_MSB);
| 1301 a = ATA_INB(scp->r_io, ATA_CYL_LSB); 1302 b = ATA_INB(scp->r_io, ATA_CYL_MSB);
|
1288 if (bootverbose) 1289 ata_printf(scp, ATA_SLAVE, 1290 "ATAPI probe a=%02x b=%02x\n", a, b); 1291 if (a == ATAPI_MAGIC_LSB && b == ATAPI_MAGIC_MSB) 1292 scp->devices |= ATA_ATAPI_SLAVE; 1293 } 1294 } 1295 if (*mask == 0x01) /* wait for master only */ 1296 if (!(status0 & ATA_S_BUSY)) 1297 break; 1298 if (*mask == 0x02) /* wait for slave only */ 1299 if (!(status1 & ATA_S_BUSY)) 1300 break; 1301 if (*mask == 0x03) /* wait for both master & slave */ 1302 if (!(status0 & ATA_S_BUSY) && !(status1 & ATA_S_BUSY)) 1303 break; 1304 DELAY(100); 1305 } 1306 DELAY(10);
| 1303 if (bootverbose) 1304 ata_printf(scp, ATA_SLAVE, 1305 "ATAPI probe a=%02x b=%02x\n", a, b); 1306 if (a == ATAPI_MAGIC_LSB && b == ATAPI_MAGIC_MSB) 1307 scp->devices |= ATA_ATAPI_SLAVE; 1308 } 1309 } 1310 if (*mask == 0x01) /* wait for master only */ 1311 if (!(status0 & ATA_S_BUSY)) 1312 break; 1313 if (*mask == 0x02) /* wait for slave only */ 1314 if (!(status1 & ATA_S_BUSY)) 1315 break; 1316 if (*mask == 0x03) /* wait for both master & slave */ 1317 if (!(status0 & ATA_S_BUSY) && !(status1 & ATA_S_BUSY)) 1318 break; 1319 DELAY(100); 1320 } 1321 DELAY(10);
|
1307 outb(scp->altioaddr, ATA_A_4BIT);
| 1322 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_4BIT);
|
1308 1309 if (status0 & ATA_S_BUSY) 1310 *mask &= ~0x01; 1311 if (status1 & ATA_S_BUSY) 1312 *mask &= ~0x02; 1313 if (bootverbose) 1314 ata_printf(scp, -1, "mask=%02x status0=%02x status1=%02x\n", 1315 *mask, status0, status1); 1316 if (!*mask) 1317 return; 1318 1319 if (*mask & 0x01 && ostat0 != 0x00 && !(scp->devices & ATA_ATAPI_MASTER)) {
| 1323 1324 if (status0 & ATA_S_BUSY) 1325 *mask &= ~0x01; 1326 if (status1 & ATA_S_BUSY) 1327 *mask &= ~0x02; 1328 if (bootverbose) 1329 ata_printf(scp, -1, "mask=%02x status0=%02x status1=%02x\n", 1330 *mask, status0, status1); 1331 if (!*mask) 1332 return; 1333 1334 if (*mask & 0x01 && ostat0 != 0x00 && !(scp->devices & ATA_ATAPI_MASTER)) {
|
1320 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
| 1335 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_MASTER);
|
1321 DELAY(10);
| 1336 DELAY(10);
|
1322 outb(scp->ioaddr + ATA_ERROR, 0x58); 1323 outb(scp->ioaddr + ATA_CYL_LSB, 0xa5); 1324 a = inb(scp->ioaddr + ATA_ERROR); 1325 b = inb(scp->ioaddr + ATA_CYL_LSB);
| 1337 ATA_OUTB(scp->r_io, ATA_ERROR, 0x58); 1338 ATA_OUTB(scp->r_io, ATA_CYL_LSB, 0xa5); 1339 a = ATA_INB(scp->r_io, ATA_ERROR); 1340 b = ATA_INB(scp->r_io, ATA_CYL_LSB);
|
1326 if (bootverbose) 1327 ata_printf(scp, ATA_MASTER, "ATA probe a=%02x b=%02x\n", a, b); 1328 if (a != 0x58 && b == 0xa5) 1329 scp->devices |= ATA_ATA_MASTER; 1330 } 1331 if (*mask & 0x02 && ostat1 != 0x00 && !(scp->devices & ATA_ATAPI_SLAVE)) {
| 1341 if (bootverbose) 1342 ata_printf(scp, ATA_MASTER, "ATA probe a=%02x b=%02x\n", a, b); 1343 if (a != 0x58 && b == 0xa5) 1344 scp->devices |= ATA_ATA_MASTER; 1345 } 1346 if (*mask & 0x02 && ostat1 != 0x00 && !(scp->devices & ATA_ATAPI_SLAVE)) {
|
1332 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
| 1347 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | ATA_SLAVE);
|
1333 DELAY(10);
| 1348 DELAY(10);
|
1334 outb(scp->ioaddr + ATA_ERROR, 0x58); 1335 outb(scp->ioaddr + ATA_CYL_LSB, 0xa5); 1336 a = inb(scp->ioaddr + ATA_ERROR); 1337 b = inb(scp->ioaddr + ATA_CYL_LSB);
| 1349 ATA_OUTB(scp->r_io, ATA_ERROR, 0x58); 1350 ATA_OUTB(scp->r_io, ATA_CYL_LSB, 0xa5); 1351 a = ATA_INB(scp->r_io, ATA_ERROR); 1352 b = ATA_INB(scp->r_io, ATA_CYL_LSB);
|
1338 if (bootverbose) 1339 ata_printf(scp, ATA_SLAVE, "ATA probe a=%02x b=%02x\n", a, b); 1340 if (a != 0x58 && b == 0xa5) 1341 scp->devices |= ATA_ATA_SLAVE; 1342 } 1343 if (bootverbose) 1344 ata_printf(scp, -1, "devices=%02x\n", scp->devices); 1345} 1346 1347int 1348ata_reinit(struct ata_softc *scp) 1349{ 1350 int mask = 0, omask; 1351 1352 scp->active = ATA_REINITING; 1353 scp->running = NULL; 1354 if (scp->devices & (ATA_ATA_MASTER | ATA_ATAPI_MASTER)) 1355 mask |= 0x01; 1356 if (scp->devices & (ATA_ATA_SLAVE | ATA_ATAPI_SLAVE)) 1357 mask |= 0x02; 1358 if (mask) { 1359 omask = mask; 1360 ata_printf(scp, -1, "resetting devices .. "); 1361 ata_reset(scp, &mask); 1362 if (omask != mask) 1363 printf(" device dissapeared! %d ", omask & ~mask); 1364 1365#ifdef DEV_ATADISK 1366 if (scp->devices & (ATA_ATA_MASTER) && scp->dev_softc[0]) 1367 ad_reinit((struct ad_softc *)scp->dev_softc[0]); 1368 if (scp->devices & (ATA_ATA_SLAVE) && scp->dev_softc[1]) 1369 ad_reinit((struct ad_softc *)scp->dev_softc[1]); 1370#endif 1371#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1372 if (scp->devices & (ATA_ATAPI_MASTER) && scp->dev_softc[0]) 1373 atapi_reinit((struct atapi_softc *)scp->dev_softc[0]); 1374 if (scp->devices & (ATA_ATAPI_SLAVE) && scp->dev_softc[1]) 1375 atapi_reinit((struct atapi_softc *)scp->dev_softc[1]); 1376#endif 1377 printf("done\n"); 1378 } 1379 scp->active = ATA_IDLE; 1380 ata_start(scp); 1381 return 0; 1382} 1383 1384static int 1385ata_service(struct ata_softc *scp) 1386{ 1387 /* do we have a SERVICE request from the drive ? */ 1388 if ((scp->status & (ATA_S_SERVICE|ATA_S_ERROR|ATA_S_DRQ)) == ATA_S_SERVICE){
| 1353 if (bootverbose) 1354 ata_printf(scp, ATA_SLAVE, "ATA probe a=%02x b=%02x\n", a, b); 1355 if (a != 0x58 && b == 0xa5) 1356 scp->devices |= ATA_ATA_SLAVE; 1357 } 1358 if (bootverbose) 1359 ata_printf(scp, -1, "devices=%02x\n", scp->devices); 1360} 1361 1362int 1363ata_reinit(struct ata_softc *scp) 1364{ 1365 int mask = 0, omask; 1366 1367 scp->active = ATA_REINITING; 1368 scp->running = NULL; 1369 if (scp->devices & (ATA_ATA_MASTER | ATA_ATAPI_MASTER)) 1370 mask |= 0x01; 1371 if (scp->devices & (ATA_ATA_SLAVE | ATA_ATAPI_SLAVE)) 1372 mask |= 0x02; 1373 if (mask) { 1374 omask = mask; 1375 ata_printf(scp, -1, "resetting devices .. "); 1376 ata_reset(scp, &mask); 1377 if (omask != mask) 1378 printf(" device dissapeared! %d ", omask & ~mask); 1379 1380#ifdef DEV_ATADISK 1381 if (scp->devices & (ATA_ATA_MASTER) && scp->dev_softc[0]) 1382 ad_reinit((struct ad_softc *)scp->dev_softc[0]); 1383 if (scp->devices & (ATA_ATA_SLAVE) && scp->dev_softc[1]) 1384 ad_reinit((struct ad_softc *)scp->dev_softc[1]); 1385#endif 1386#if defined(DEV_ATAPICD) || defined(DEV_ATAPIFD) || defined(DEV_ATAPIST) 1387 if (scp->devices & (ATA_ATAPI_MASTER) && scp->dev_softc[0]) 1388 atapi_reinit((struct atapi_softc *)scp->dev_softc[0]); 1389 if (scp->devices & (ATA_ATAPI_SLAVE) && scp->dev_softc[1]) 1390 atapi_reinit((struct atapi_softc *)scp->dev_softc[1]); 1391#endif 1392 printf("done\n"); 1393 } 1394 scp->active = ATA_IDLE; 1395 ata_start(scp); 1396 return 0; 1397} 1398 1399static int 1400ata_service(struct ata_softc *scp) 1401{ 1402 /* do we have a SERVICE request from the drive ? */ 1403 if ((scp->status & (ATA_S_SERVICE|ATA_S_ERROR|ATA_S_DRQ)) == ATA_S_SERVICE){
|
1389 outb(scp->bmaddr + ATA_BMSTAT_PORT, ata_dmastatus(scp) | ATA_BMSTAT_INTERRUPT);
| 1404 ATA_OUTB(scp->r_bmio, ATA_BMSTAT_PORT, 1405 ata_dmastatus(scp) | ATA_BMSTAT_INTERRUPT);
|
1390#ifdef DEV_ATADISK
| 1406#ifdef DEV_ATADISK
|
1391 if ((inb(scp->ioaddr + ATA_DRIVE) & ATA_SLAVE) == ATA_MASTER) {
| 1407 if ((ATA_INB(scp->r_io, ATA_DRIVE) & ATA_SLAVE) == ATA_MASTER) {
|
1392 if ((scp->devices & ATA_ATA_MASTER) && scp->dev_softc[0]) 1393 return ad_service((struct ad_softc *)scp->dev_softc[0], 0); 1394 } 1395 else { 1396 if ((scp->devices & ATA_ATA_SLAVE) && scp->dev_softc[1]) 1397 return ad_service((struct ad_softc *)scp->dev_softc[1], 0); 1398 } 1399#endif 1400 } 1401 return ATA_OP_FINISHED; 1402} 1403 1404int 1405ata_wait(struct ata_softc *scp, int device, u_int8_t mask) 1406{ 1407 int timeout = 0;
| 1408 if ((scp->devices & ATA_ATA_MASTER) && scp->dev_softc[0]) 1409 return ad_service((struct ad_softc *)scp->dev_softc[0], 0); 1410 } 1411 else { 1412 if ((scp->devices & ATA_ATA_SLAVE) && scp->dev_softc[1]) 1413 return ad_service((struct ad_softc *)scp->dev_softc[1], 0); 1414 } 1415#endif 1416 } 1417 return ATA_OP_FINISHED; 1418} 1419 1420int 1421ata_wait(struct ata_softc *scp, int device, u_int8_t mask) 1422{ 1423 int timeout = 0;
|
1408 int statio = scp->ioaddr + ATA_STATUS;
| |
1409 1410 DELAY(1); 1411 while (timeout < 5000000) { /* timeout 5 secs */
| 1424 1425 DELAY(1); 1426 while (timeout < 5000000) { /* timeout 5 secs */
|
1412 scp->status = inb(statio);
| 1427 scp->status = ATA_INB(scp->r_io, ATA_STATUS);
|
1413 1414 /* if drive fails status, reselect the drive just to be sure */ 1415 if (scp->status == 0xff) { 1416 ata_printf(scp, device, "no status, reselecting device\n");
| 1428 1429 /* if drive fails status, reselect the drive just to be sure */ 1430 if (scp->status == 0xff) { 1431 ata_printf(scp, device, "no status, reselecting device\n");
|
1417 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | device);
| 1432 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | device);
|
1418 DELAY(1);
| 1433 DELAY(1);
|
1419 scp->status = inb(statio);
| 1434 scp->status = ATA_INB(scp->r_io, ATA_STATUS);
|
1420 } 1421 1422 /* are we done ? */ 1423 if (!(scp->status & ATA_S_BUSY)) 1424 break; 1425 1426 if (timeout > 1000) { 1427 timeout += 1000; 1428 DELAY(1000); 1429 } 1430 else { 1431 timeout += 10; 1432 DELAY(10); 1433 } 1434 } 1435 if (scp->status & ATA_S_ERROR)
| 1435 } 1436 1437 /* are we done ? */ 1438 if (!(scp->status & ATA_S_BUSY)) 1439 break; 1440 1441 if (timeout > 1000) { 1442 timeout += 1000; 1443 DELAY(1000); 1444 } 1445 else { 1446 timeout += 10; 1447 DELAY(10); 1448 } 1449 } 1450 if (scp->status & ATA_S_ERROR)
|
1436 scp->error = inb(scp->ioaddr + ATA_ERROR);
| 1451 scp->error = ATA_INB(scp->r_io, ATA_ERROR);
|
1437 if (timeout >= 5000000) 1438 return -1; 1439 if (!mask) 1440 return (scp->status & ATA_S_ERROR); 1441 1442 /* Wait 50 msec for bits wanted. */ 1443 timeout = 5000; 1444 while (timeout--) {
| 1452 if (timeout >= 5000000) 1453 return -1; 1454 if (!mask) 1455 return (scp->status & ATA_S_ERROR); 1456 1457 /* Wait 50 msec for bits wanted. */ 1458 timeout = 5000; 1459 while (timeout--) {
|
1445 scp->status = inb(statio);
| 1460 scp->status = ATA_INB(scp->r_io, ATA_STATUS);
|
1446 if ((scp->status & mask) == mask) { 1447 if (scp->status & ATA_S_ERROR)
| 1461 if ((scp->status & mask) == mask) { 1462 if (scp->status & ATA_S_ERROR)
|
1448 scp->error = inb(scp->ioaddr + ATA_ERROR);
| 1463 scp->error = ATA_INB(scp->r_io, ATA_ERROR);
|
1449 return (scp->status & ATA_S_ERROR); 1450 } 1451 DELAY (10); 1452 } 1453 return -1; 1454} 1455 1456int 1457ata_command(struct ata_softc *scp, int device, u_int8_t command, 1458 u_int16_t cylinder, u_int8_t head, u_int8_t sector, 1459 u_int8_t count, u_int8_t feature, int flags) 1460{ 1461 int error = 0; 1462#ifdef ATA_DEBUG 1463 ata_printf(scp, device, "ata_command: addr=%04x, cmd=%02x, " 1464 "c=%d, h=%d, s=%d, count=%d, feature=%d, flags=%02x\n",
| 1464 return (scp->status & ATA_S_ERROR); 1465 } 1466 DELAY (10); 1467 } 1468 return -1; 1469} 1470 1471int 1472ata_command(struct ata_softc *scp, int device, u_int8_t command, 1473 u_int16_t cylinder, u_int8_t head, u_int8_t sector, 1474 u_int8_t count, u_int8_t feature, int flags) 1475{ 1476 int error = 0; 1477#ifdef ATA_DEBUG 1478 ata_printf(scp, device, "ata_command: addr=%04x, cmd=%02x, " 1479 "c=%d, h=%d, s=%d, count=%d, feature=%d, flags=%02x\n",
|
1465 scp->ioaddr, command, cylinder, head, sector,
| 1480 rman_get_start(scp->r_io), command, cylinder, head, sector,
|
1466 count, feature, flags); 1467#endif 1468 1469 /* disable interrupt from device */ 1470 if (scp->flags & ATA_QUEUED)
| 1481 count, feature, flags); 1482#endif 1483 1484 /* disable interrupt from device */ 1485 if (scp->flags & ATA_QUEUED)
|
1471 outb(scp->altioaddr, ATA_A_IDS | ATA_A_4BIT);
| 1486 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_IDS | ATA_A_4BIT);
|
1472 1473 /* select device */
| 1487 1488 /* select device */
|
1474 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | device);
| 1489 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | device);
|
1475 1476 /* ready to issue command ? */ 1477 if (ata_wait(scp, device, 0) < 0) { 1478 ata_printf(scp, device, 1479 "timeout waiting to give command=%02x s=%02x e=%02x\n", 1480 command, scp->status, scp->error); 1481 return -1; 1482 } 1483
| 1490 1491 /* ready to issue command ? */ 1492 if (ata_wait(scp, device, 0) < 0) { 1493 ata_printf(scp, device, 1494 "timeout waiting to give command=%02x s=%02x e=%02x\n", 1495 command, scp->status, scp->error); 1496 return -1; 1497 } 1498
|
1484 outb(scp->ioaddr + ATA_FEATURE, feature); 1485 outb(scp->ioaddr + ATA_COUNT, count); 1486 outb(scp->ioaddr + ATA_SECTOR, sector); 1487 outb(scp->ioaddr + ATA_CYL_MSB, cylinder >> 8); 1488 outb(scp->ioaddr + ATA_CYL_LSB, cylinder); 1489 outb(scp->ioaddr + ATA_DRIVE, ATA_D_IBM | device | head);
| 1499 ATA_OUTB(scp->r_io, ATA_FEATURE, feature); 1500 ATA_OUTB(scp->r_io, ATA_COUNT, count); 1501 ATA_OUTB(scp->r_io, ATA_SECTOR, sector); 1502 ATA_OUTB(scp->r_io, ATA_CYL_MSB, cylinder >> 8); 1503 ATA_OUTB(scp->r_io, ATA_CYL_LSB, cylinder); 1504 ATA_OUTB(scp->r_io, ATA_DRIVE, ATA_D_IBM | device | head);
|
1490 1491 switch (flags) { 1492 case ATA_WAIT_INTR: 1493 scp->active = ATA_WAIT_INTR; 1494 asleep((caddr_t)scp, PRIBIO, "atacmd", 10 * hz);
| 1505 1506 switch (flags) { 1507 case ATA_WAIT_INTR: 1508 scp->active = ATA_WAIT_INTR; 1509 asleep((caddr_t)scp, PRIBIO, "atacmd", 10 * hz);
|
1495 outb(scp->ioaddr + ATA_CMD, command);
| 1510 ATA_OUTB(scp->r_io, ATA_CMD, command);
|
1496 1497 /* enable interrupt */ 1498 if (scp->flags & ATA_QUEUED)
| 1511 1512 /* enable interrupt */ 1513 if (scp->flags & ATA_QUEUED)
|
1499 outb(scp->altioaddr, ATA_A_4BIT);
| 1514 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_4BIT);
|
1500 1501 if (await(PRIBIO, 10 * hz)) { 1502 ata_printf(scp, device, "ata_command: timeout waiting for intr\n"); 1503 scp->active = ATA_IDLE; 1504 error = -1; 1505 } 1506 break; 1507 1508 case ATA_WAIT_READY: 1509 if (scp->active != ATA_REINITING) 1510 scp->active = ATA_WAIT_READY;
| 1515 1516 if (await(PRIBIO, 10 * hz)) { 1517 ata_printf(scp, device, "ata_command: timeout waiting for intr\n"); 1518 scp->active = ATA_IDLE; 1519 error = -1; 1520 } 1521 break; 1522 1523 case ATA_WAIT_READY: 1524 if (scp->active != ATA_REINITING) 1525 scp->active = ATA_WAIT_READY;
|
1511 outb(scp->ioaddr + ATA_CMD, command);
| 1526 ATA_OUTB(scp->r_io, ATA_CMD, command);
|
1512 if (ata_wait(scp, device, ATA_S_READY) < 0) { 1513 ata_printf(scp, device, 1514 "timeout waiting for command=%02x s=%02x e=%02x\n", 1515 command, scp->status, scp->error); 1516 error = -1; 1517 } 1518 if (scp->active != ATA_REINITING) 1519 scp->active = ATA_IDLE; 1520 break; 1521 1522 case ATA_IMMEDIATE:
| 1527 if (ata_wait(scp, device, ATA_S_READY) < 0) { 1528 ata_printf(scp, device, 1529 "timeout waiting for command=%02x s=%02x e=%02x\n", 1530 command, scp->status, scp->error); 1531 error = -1; 1532 } 1533 if (scp->active != ATA_REINITING) 1534 scp->active = ATA_IDLE; 1535 break; 1536 1537 case ATA_IMMEDIATE:
|
1523 outb(scp->ioaddr + ATA_CMD, command);
| 1538 ATA_OUTB(scp->r_io, ATA_CMD, command);
|
1524 break; 1525 1526 default: 1527 ata_printf(scp, device, "DANGER: illegal interrupt flag=%s\n", 1528 active2str(flags)); 1529 } 1530 /* enable interrupt */ 1531 if (scp->flags & ATA_QUEUED)
| 1539 break; 1540 1541 default: 1542 ata_printf(scp, device, "DANGER: illegal interrupt flag=%s\n", 1543 active2str(flags)); 1544 } 1545 /* enable interrupt */ 1546 if (scp->flags & ATA_QUEUED)
|
1532 outb(scp->altioaddr, ATA_A_4BIT);
| 1547 ATA_OUTB(scp->r_altio, ATA_ALTSTAT, ATA_A_4BIT);
|
1533 return error; 1534} 1535 1536int 1537ata_get_lun(u_int32_t *map) 1538{ 1539 int lun = ffs(~*map) - 1; 1540 1541 *map |= (1 << lun); 1542 return lun; 1543} 1544 1545int 1546ata_test_lun(u_int32_t *map, int lun) 1547{ 1548 return (*map & (1 << lun)); 1549} 1550 1551void 1552ata_free_lun(u_int32_t *map, int lun) 1553{ 1554 *map &= ~(1 << lun); 1555} 1556 1557int 1558ata_printf(struct ata_softc *scp, int device, const char * fmt, ...) 1559{ 1560 va_list ap; 1561 int ret; 1562 1563 if (device == -1) 1564 ret = printf("ata%d: ", device_get_unit(scp->dev)); 1565 else 1566 ret = printf("ata%d-%s: ", device_get_unit(scp->dev), 1567 (device == ATA_MASTER) ? "master" : "slave"); 1568 va_start(ap, fmt); 1569 ret += vprintf(fmt, ap); 1570 va_end(ap); 1571 return ret; 1572} 1573 1574char * 1575ata_mode2str(int mode) 1576{ 1577 switch (mode) { 1578 case ATA_PIO: return "BIOSPIO"; 1579 case ATA_PIO0: return "PIO0"; 1580 case ATA_PIO1: return "PIO1"; 1581 case ATA_PIO2: return "PIO2"; 1582 case ATA_PIO3: return "PIO3"; 1583 case ATA_PIO4: return "PIO4"; 1584 case ATA_WDMA2: return "WDMA2"; 1585 case ATA_UDMA2: return "UDMA33"; 1586 case ATA_UDMA4: return "UDMA66"; 1587 case ATA_UDMA5: return "UDMA100"; 1588 case ATA_DMA: return "BIOSDMA"; 1589 default: return "???"; 1590 } 1591} 1592 1593int 1594ata_pio2mode(int pio) 1595{ 1596 switch (pio) { 1597 default: 1598 case 0: return ATA_PIO0; 1599 case 1: return ATA_PIO1; 1600 case 2: return ATA_PIO2; 1601 case 3: return ATA_PIO3; 1602 case 4: return ATA_PIO4; 1603 } 1604} 1605 1606int 1607ata_pmode(struct ata_params *ap) 1608{ 1609 if (ap->atavalid & ATA_FLAG_64_70) { 1610 if (ap->apiomodes & 2) 1611 return 4; 1612 if (ap->apiomodes & 1) 1613 return 3; 1614 } 1615 if (ap->opiomode == 2) 1616 return 2; 1617 if (ap->opiomode == 1) 1618 return 1; 1619 if (ap->opiomode == 0) 1620 return 0; 1621 return -1; 1622} 1623 1624int 1625ata_wmode(struct ata_params *ap) 1626{ 1627 if (ap->wdmamodes & 4) 1628 return 2; 1629 if (ap->wdmamodes & 2) 1630 return 1; 1631 if (ap->wdmamodes & 1) 1632 return 0; 1633 return -1; 1634} 1635 1636int 1637ata_umode(struct ata_params *ap) 1638{ 1639 if (ap->atavalid & ATA_FLAG_88) { 1640 if (ap->udmamodes & 0x20) 1641 return 5; 1642 if (ap->udmamodes & 0x10) 1643 return 4; 1644 if (ap->udmamodes & 0x08) 1645 return 3; 1646 if (ap->udmamodes & 0x04) 1647 return 2; 1648 if (ap->udmamodes & 0x02) 1649 return 1; 1650 if (ap->udmamodes & 0x01) 1651 return 0; 1652 } 1653 return -1; 1654} 1655 1656static char * 1657active2str(int active) 1658{ 1659 static char buf[8]; 1660 1661 switch (active) { 1662 case ATA_IDLE: 1663 return("ATA_IDLE"); 1664 case ATA_IMMEDIATE: 1665 return("ATA_IMMEDIATE"); 1666 case ATA_WAIT_INTR: 1667 return("ATA_WAIT_INTR"); 1668 case ATA_WAIT_READY: 1669 return("ATA_WAIT_READY"); 1670 case ATA_ACTIVE: 1671 return("ATA_ACTIVE"); 1672 case ATA_ACTIVE_ATA: 1673 return("ATA_ACTIVE_ATA"); 1674 case ATA_ACTIVE_ATAPI: 1675 return("ATA_ACTIVE_ATAPI"); 1676 case ATA_REINITING: 1677 return("ATA_REINITING"); 1678 default: 1679 sprintf(buf, "0x%02x", active); 1680 return buf; 1681 } 1682} 1683 1684static void 1685bswap(int8_t *buf, int len) 1686{ 1687 u_int16_t *ptr = (u_int16_t*)(buf + len); 1688 1689 while (--ptr >= (u_int16_t*)buf) 1690 *ptr = ntohs(*ptr); 1691} 1692 1693static void 1694btrim(int8_t *buf, int len) 1695{ 1696 int8_t *ptr; 1697 1698 for (ptr = buf; ptr < buf+len; ++ptr) 1699 if (!*ptr) 1700 *ptr = ' '; 1701 for (ptr = buf + len - 1; ptr >= buf && *ptr == ' '; --ptr) 1702 *ptr = 0; 1703} 1704 1705static void 1706bpack(int8_t *src, int8_t *dst, int len) 1707{ 1708 int i, j, blank; 1709 1710 for (i = j = blank = 0 ; i < len; i++) { 1711 if (blank && src[i] == ' ') continue; 1712 if (blank && src[i] != ' ') { 1713 dst[j++] = src[i]; 1714 blank = 0; 1715 continue; 1716 } 1717 if (src[i] == ' ') { 1718 blank = 1; 1719 if (i == 0) 1720 continue; 1721 } 1722 dst[j++] = src[i]; 1723 } 1724 if (j < len) 1725 dst[j] = 0x00; 1726} 1727 1728static void 1729ata_change_mode(struct ata_softc *scp, int device, int mode) 1730{ 1731 int s = splbio(); 1732 1733 while (!atomic_cmpset_int(&scp->active, ATA_IDLE, ATA_ACTIVE)) 1734 tsleep((caddr_t)&s, PRIBIO, "atachm", hz/4); 1735 1736 ata_dmainit(scp, device, ata_pmode(ATA_PARAM(scp, device)), 1737 mode < ATA_DMA ? -1 : ata_wmode(ATA_PARAM(scp, device)), 1738 mode < ATA_DMA ? -1 : ata_umode(ATA_PARAM(scp, device))); 1739 scp->active = ATA_IDLE; 1740 ata_start(scp); 1741 splx(s); 1742} 1743 1744static int 1745sysctl_hw_ata(SYSCTL_HANDLER_ARGS) 1746{ 1747 struct ata_softc *scp; 1748 int ctlr, error, i; 1749 1750 /* readout internal state */ 1751 bzero(ata_conf, sizeof(ata_conf)); 1752 for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) { 1753 if (!(scp = devclass_get_softc(ata_devclass, ctlr))) 1754 continue; 1755 for (i = 0; i < 2; i++) { 1756 if (!scp->dev_softc[i]) 1757 strcat(ata_conf, "---,"); 1758 else if (scp->mode[i] >= ATA_DMA) 1759 strcat(ata_conf, "dma,"); 1760 else 1761 strcat(ata_conf, "pio,"); 1762 } 1763 } 1764 error = sysctl_handle_string(oidp, ata_conf, sizeof(ata_conf), req); 1765 if (error == 0 && req->newptr != NULL) { 1766 char *ptr = ata_conf; 1767 1768 /* update internal state */ 1769 i = 0; 1770 while (*ptr) { 1771 if (!strncmp(ptr, "pio", 3) || !strncmp(ptr, "PIO", 3)) { 1772 if ((scp = devclass_get_softc(ata_devclass, i >> 1)) && 1773 scp->dev_softc[i & 1] && scp->mode[i & 1] >= ATA_DMA) 1774 ata_change_mode(scp, (i & 1)?ATA_SLAVE:ATA_MASTER, ATA_PIO); 1775 } 1776 else if (!strncmp(ptr, "dma", 3) || !strncmp(ptr, "DMA", 3)) { 1777 if ((scp = devclass_get_softc(ata_devclass, i >> 1)) && 1778 scp->dev_softc[i & 1] && scp->mode[i & 1] < ATA_DMA) 1779 ata_change_mode(scp, (i & 1)?ATA_SLAVE:ATA_MASTER, ATA_DMA); 1780 } 1781 else if (strncmp(ptr, "---", 3)) 1782 break; 1783 ptr+=3; 1784 if (*ptr++ != ',' || 1785 ++i > (devclass_get_maxunit(ata_devclass) << 1)) 1786 break; 1787 } 1788 } 1789 return error; 1790} 1791SYSCTL_PROC(_hw, OID_AUTO, atamodes, CTLTYPE_STRING | CTLFLAG_RW, 1792 0, sizeof(ata_conf), sysctl_hw_ata, "A", ""); 1793 1794static void 1795ata_init(void) 1796{ 1797 /* register boot attach to be run when interrupts are enabled */ 1798 if (!(ata_delayed_attach = (struct intr_config_hook *) 1799 malloc(sizeof(struct intr_config_hook), 1800 M_TEMP, M_NOWAIT | M_ZERO))) { 1801 printf("ata: malloc of delayed attach hook failed\n"); 1802 return; 1803 } 1804 1805 ata_delayed_attach->ich_func = (void*)ata_boot_attach; 1806 if (config_intrhook_establish(ata_delayed_attach) != 0) { 1807 printf("ata: config_intrhook_establish failed\n"); 1808 free(ata_delayed_attach, M_TEMP); 1809 } 1810} 1811SYSINIT(atadev, SI_SUB_DRIVERS, SI_ORDER_SECOND, ata_init, NULL)
| 1548 return error; 1549} 1550 1551int 1552ata_get_lun(u_int32_t *map) 1553{ 1554 int lun = ffs(~*map) - 1; 1555 1556 *map |= (1 << lun); 1557 return lun; 1558} 1559 1560int 1561ata_test_lun(u_int32_t *map, int lun) 1562{ 1563 return (*map & (1 << lun)); 1564} 1565 1566void 1567ata_free_lun(u_int32_t *map, int lun) 1568{ 1569 *map &= ~(1 << lun); 1570} 1571 1572int 1573ata_printf(struct ata_softc *scp, int device, const char * fmt, ...) 1574{ 1575 va_list ap; 1576 int ret; 1577 1578 if (device == -1) 1579 ret = printf("ata%d: ", device_get_unit(scp->dev)); 1580 else 1581 ret = printf("ata%d-%s: ", device_get_unit(scp->dev), 1582 (device == ATA_MASTER) ? "master" : "slave"); 1583 va_start(ap, fmt); 1584 ret += vprintf(fmt, ap); 1585 va_end(ap); 1586 return ret; 1587} 1588 1589char * 1590ata_mode2str(int mode) 1591{ 1592 switch (mode) { 1593 case ATA_PIO: return "BIOSPIO"; 1594 case ATA_PIO0: return "PIO0"; 1595 case ATA_PIO1: return "PIO1"; 1596 case ATA_PIO2: return "PIO2"; 1597 case ATA_PIO3: return "PIO3"; 1598 case ATA_PIO4: return "PIO4"; 1599 case ATA_WDMA2: return "WDMA2"; 1600 case ATA_UDMA2: return "UDMA33"; 1601 case ATA_UDMA4: return "UDMA66"; 1602 case ATA_UDMA5: return "UDMA100"; 1603 case ATA_DMA: return "BIOSDMA"; 1604 default: return "???"; 1605 } 1606} 1607 1608int 1609ata_pio2mode(int pio) 1610{ 1611 switch (pio) { 1612 default: 1613 case 0: return ATA_PIO0; 1614 case 1: return ATA_PIO1; 1615 case 2: return ATA_PIO2; 1616 case 3: return ATA_PIO3; 1617 case 4: return ATA_PIO4; 1618 } 1619} 1620 1621int 1622ata_pmode(struct ata_params *ap) 1623{ 1624 if (ap->atavalid & ATA_FLAG_64_70) { 1625 if (ap->apiomodes & 2) 1626 return 4; 1627 if (ap->apiomodes & 1) 1628 return 3; 1629 } 1630 if (ap->opiomode == 2) 1631 return 2; 1632 if (ap->opiomode == 1) 1633 return 1; 1634 if (ap->opiomode == 0) 1635 return 0; 1636 return -1; 1637} 1638 1639int 1640ata_wmode(struct ata_params *ap) 1641{ 1642 if (ap->wdmamodes & 4) 1643 return 2; 1644 if (ap->wdmamodes & 2) 1645 return 1; 1646 if (ap->wdmamodes & 1) 1647 return 0; 1648 return -1; 1649} 1650 1651int 1652ata_umode(struct ata_params *ap) 1653{ 1654 if (ap->atavalid & ATA_FLAG_88) { 1655 if (ap->udmamodes & 0x20) 1656 return 5; 1657 if (ap->udmamodes & 0x10) 1658 return 4; 1659 if (ap->udmamodes & 0x08) 1660 return 3; 1661 if (ap->udmamodes & 0x04) 1662 return 2; 1663 if (ap->udmamodes & 0x02) 1664 return 1; 1665 if (ap->udmamodes & 0x01) 1666 return 0; 1667 } 1668 return -1; 1669} 1670 1671static char * 1672active2str(int active) 1673{ 1674 static char buf[8]; 1675 1676 switch (active) { 1677 case ATA_IDLE: 1678 return("ATA_IDLE"); 1679 case ATA_IMMEDIATE: 1680 return("ATA_IMMEDIATE"); 1681 case ATA_WAIT_INTR: 1682 return("ATA_WAIT_INTR"); 1683 case ATA_WAIT_READY: 1684 return("ATA_WAIT_READY"); 1685 case ATA_ACTIVE: 1686 return("ATA_ACTIVE"); 1687 case ATA_ACTIVE_ATA: 1688 return("ATA_ACTIVE_ATA"); 1689 case ATA_ACTIVE_ATAPI: 1690 return("ATA_ACTIVE_ATAPI"); 1691 case ATA_REINITING: 1692 return("ATA_REINITING"); 1693 default: 1694 sprintf(buf, "0x%02x", active); 1695 return buf; 1696 } 1697} 1698 1699static void 1700bswap(int8_t *buf, int len) 1701{ 1702 u_int16_t *ptr = (u_int16_t*)(buf + len); 1703 1704 while (--ptr >= (u_int16_t*)buf) 1705 *ptr = ntohs(*ptr); 1706} 1707 1708static void 1709btrim(int8_t *buf, int len) 1710{ 1711 int8_t *ptr; 1712 1713 for (ptr = buf; ptr < buf+len; ++ptr) 1714 if (!*ptr) 1715 *ptr = ' '; 1716 for (ptr = buf + len - 1; ptr >= buf && *ptr == ' '; --ptr) 1717 *ptr = 0; 1718} 1719 1720static void 1721bpack(int8_t *src, int8_t *dst, int len) 1722{ 1723 int i, j, blank; 1724 1725 for (i = j = blank = 0 ; i < len; i++) { 1726 if (blank && src[i] == ' ') continue; 1727 if (blank && src[i] != ' ') { 1728 dst[j++] = src[i]; 1729 blank = 0; 1730 continue; 1731 } 1732 if (src[i] == ' ') { 1733 blank = 1; 1734 if (i == 0) 1735 continue; 1736 } 1737 dst[j++] = src[i]; 1738 } 1739 if (j < len) 1740 dst[j] = 0x00; 1741} 1742 1743static void 1744ata_change_mode(struct ata_softc *scp, int device, int mode) 1745{ 1746 int s = splbio(); 1747 1748 while (!atomic_cmpset_int(&scp->active, ATA_IDLE, ATA_ACTIVE)) 1749 tsleep((caddr_t)&s, PRIBIO, "atachm", hz/4); 1750 1751 ata_dmainit(scp, device, ata_pmode(ATA_PARAM(scp, device)), 1752 mode < ATA_DMA ? -1 : ata_wmode(ATA_PARAM(scp, device)), 1753 mode < ATA_DMA ? -1 : ata_umode(ATA_PARAM(scp, device))); 1754 scp->active = ATA_IDLE; 1755 ata_start(scp); 1756 splx(s); 1757} 1758 1759static int 1760sysctl_hw_ata(SYSCTL_HANDLER_ARGS) 1761{ 1762 struct ata_softc *scp; 1763 int ctlr, error, i; 1764 1765 /* readout internal state */ 1766 bzero(ata_conf, sizeof(ata_conf)); 1767 for (ctlr=0; ctlr<devclass_get_maxunit(ata_devclass); ctlr++) { 1768 if (!(scp = devclass_get_softc(ata_devclass, ctlr))) 1769 continue; 1770 for (i = 0; i < 2; i++) { 1771 if (!scp->dev_softc[i]) 1772 strcat(ata_conf, "---,"); 1773 else if (scp->mode[i] >= ATA_DMA) 1774 strcat(ata_conf, "dma,"); 1775 else 1776 strcat(ata_conf, "pio,"); 1777 } 1778 } 1779 error = sysctl_handle_string(oidp, ata_conf, sizeof(ata_conf), req); 1780 if (error == 0 && req->newptr != NULL) { 1781 char *ptr = ata_conf; 1782 1783 /* update internal state */ 1784 i = 0; 1785 while (*ptr) { 1786 if (!strncmp(ptr, "pio", 3) || !strncmp(ptr, "PIO", 3)) { 1787 if ((scp = devclass_get_softc(ata_devclass, i >> 1)) && 1788 scp->dev_softc[i & 1] && scp->mode[i & 1] >= ATA_DMA) 1789 ata_change_mode(scp, (i & 1)?ATA_SLAVE:ATA_MASTER, ATA_PIO); 1790 } 1791 else if (!strncmp(ptr, "dma", 3) || !strncmp(ptr, "DMA", 3)) { 1792 if ((scp = devclass_get_softc(ata_devclass, i >> 1)) && 1793 scp->dev_softc[i & 1] && scp->mode[i & 1] < ATA_DMA) 1794 ata_change_mode(scp, (i & 1)?ATA_SLAVE:ATA_MASTER, ATA_DMA); 1795 } 1796 else if (strncmp(ptr, "---", 3)) 1797 break; 1798 ptr+=3; 1799 if (*ptr++ != ',' || 1800 ++i > (devclass_get_maxunit(ata_devclass) << 1)) 1801 break; 1802 } 1803 } 1804 return error; 1805} 1806SYSCTL_PROC(_hw, OID_AUTO, atamodes, CTLTYPE_STRING | CTLFLAG_RW, 1807 0, sizeof(ata_conf), sysctl_hw_ata, "A", ""); 1808 1809static void 1810ata_init(void) 1811{ 1812 /* register boot attach to be run when interrupts are enabled */ 1813 if (!(ata_delayed_attach = (struct intr_config_hook *) 1814 malloc(sizeof(struct intr_config_hook), 1815 M_TEMP, M_NOWAIT | M_ZERO))) { 1816 printf("ata: malloc of delayed attach hook failed\n"); 1817 return; 1818 } 1819 1820 ata_delayed_attach->ich_func = (void*)ata_boot_attach; 1821 if (config_intrhook_establish(ata_delayed_attach) != 0) { 1822 printf("ata: config_intrhook_establish failed\n"); 1823 free(ata_delayed_attach, M_TEMP); 1824 } 1825} 1826SYSINIT(atadev, SI_SUB_DRIVERS, SI_ORDER_SECOND, ata_init, NULL)
|