1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <sys/types.h> 28 #include <sys/dkio.h> 29 #include <sys/cdio.h> 30 #include <sys/file.h> 31 32 #include "ata_common.h" 33 #include "ata_disk.h" 34 35 /* 36 * this typedef really should be in dktp/cmpkt.h 37 */ 38 typedef struct cmpkt cmpkt_t; 39 40 41 /* 42 * DADA entry points 43 */ 44 45 static int ata_disk_abort(opaque_t ctl_data, cmpkt_t *pktp); 46 static int ata_disk_reset(opaque_t ctl_data, int level); 47 static int ata_disk_ioctl(opaque_t ctl_data, int cmd, intptr_t a, int flag); 48 static cmpkt_t *ata_disk_pktalloc(opaque_t ctl_data, int (*callback)(caddr_t), 49 caddr_t arg); 50 static void ata_disk_pktfree(opaque_t ctl_data, cmpkt_t *pktp); 51 static cmpkt_t *ata_disk_memsetup(opaque_t ctl_data, cmpkt_t *pktp, 52 struct buf *bp, int (*callback)(caddr_t), caddr_t arg); 53 static void ata_disk_memfree(opaque_t ctl_data, cmpkt_t *pktp); 54 static cmpkt_t *ata_disk_iosetup(opaque_t ctl_data, cmpkt_t *pktp); 55 static int ata_disk_transport(opaque_t ctl_data, cmpkt_t *pktp); 56 57 /* 58 * DADA packet callbacks 59 */ 60 61 static void ata_disk_complete(ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp, 62 int do_callback); 63 static int ata_disk_intr(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 64 ata_pkt_t *ata_pktp); 65 static int ata_disk_intr_dma(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 66 ata_pkt_t *ata_pktp); 67 static int ata_disk_intr_pio_in(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 68 ata_pkt_t *ata_pktp); 69 static int ata_disk_intr_pio_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 70 ata_pkt_t *ata_pktp); 71 static int ata_disk_start(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 72 ata_pkt_t *ata_pktp); 73 static int ata_disk_start_dma_in(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 74 ata_pkt_t *ata_pktp); 75 static int ata_disk_start_dma_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 76 ata_pkt_t *ata_pktp); 77 static int ata_disk_start_pio_in(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 78 ata_pkt_t *ata_pktp); 79 static int ata_disk_start_pio_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 80 ata_pkt_t *ata_pktp); 81 82 /* 83 * Local Function prototypes 84 */ 85 86 static int ata_disk_eject(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 87 ata_pkt_t *ata_pktp); 88 static void ata_disk_fake_inquiry(ata_drv_t *ata_drvp); 89 static void ata_disk_get_resid(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 90 ata_pkt_t *ata_pktp); 91 static int ata_disk_initialize_device_parameters(ata_ctl_t *ata_ctlp, 92 ata_drv_t *ata_drvp); 93 static int ata_disk_lock(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 94 ata_pkt_t *ata_pktp); 95 static int ata_disk_set_multiple(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp); 96 static void ata_disk_pio_xfer_data_in(ata_ctl_t *ata_ctlp, ata_pkt_t *ata_pktp); 97 static void ata_disk_pio_xfer_data_out(ata_ctl_t *ata_ctlp, 98 ata_pkt_t *ata_pktp); 99 static void ata_disk_set_standby_timer(ata_ctl_t *ata_ctlp, 100 ata_drv_t *ata_drvp); 101 static int ata_disk_recalibrate(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 102 ata_pkt_t *ata_pktp); 103 static int ata_disk_standby(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 104 ata_pkt_t *ata_pktp); 105 static int ata_disk_start_common(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 106 ata_pkt_t *ata_pktp); 107 static int ata_disk_state(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 108 ata_pkt_t *ata_pktp); 109 static int ata_disk_unlock(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, 110 ata_pkt_t *ata_pktp); 111 static int ata_get_capacity(ata_drv_t *ata_drvp, uint64_t *capacity); 112 static void ata_fix_large_disk_geometry(ata_drv_t *ata_drvp); 113 static uint64_t ata_calculate_28bits_capacity(ata_drv_t *ata_drvp); 114 static uint64_t ata_calculate_48bits_capacity(ata_drv_t *ata_drvp); 115 static int ata_copy_dk_ioc_string(intptr_t arg, char *source, int length, 116 int flag); 117 static void ata_set_write_cache(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp); 118 static int ata_disk_update_fw(gtgt_t *gtgtp, ata_ctl_t *ata_ctlp, 119 ata_drv_t *ata_drvp, caddr_t fwfile, uint_t size, 120 uint8_t type, int flag); 121 static int ata_disk_set_feature_spinup(ata_ctl_t *ata_ctlp, 122 ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp); 123 static int ata_disk_id_update(ata_ctl_t *ata_ctlp, 124 ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp); 125 126 127 /* 128 * Local static data 129 */ 130 131 uint_t ata_disk_init_dev_parm_wait = 4 * 1000000; 132 uint_t ata_disk_set_mult_wait = 4 * 1000000; 133 int ata_disk_do_standby_timer = TRUE; 134 135 /* timeout value for device update firmware */ 136 int ata_disk_updatefw_time = 60; 137 138 /* 139 * ata_write_cache == 1 force write cache on. 140 * ata_write_cache == 0 do not modify write cache. firmware defaults kept. 141 * ata_write_cache == -1 force write cache off. 142 */ 143 int ata_write_cache = 1; 144 145 146 static struct ctl_objops ata_disk_objops = { 147 ata_disk_pktalloc, 148 ata_disk_pktfree, 149 ata_disk_memsetup, 150 ata_disk_memfree, 151 ata_disk_iosetup, 152 ata_disk_transport, 153 ata_disk_reset, 154 ata_disk_abort, 155 nulldev, 156 nulldev, 157 ata_disk_ioctl, 158 0, 0 159 }; 160 161 162 163 /* 164 * 165 * initialize the ata_disk sub-system 166 * 167 */ 168 169 /*ARGSUSED*/ 170 int 171 ata_disk_attach( 172 ata_ctl_t *ata_ctlp) 173 { 174 ADBG_TRACE(("ata_disk_init entered\n")); 175 return (TRUE); 176 } 177 178 179 180 /* 181 * 182 * destroy the ata_disk sub-system 183 * 184 */ 185 186 /*ARGSUSED*/ 187 void 188 ata_disk_detach( 189 ata_ctl_t *ata_ctlp) 190 { 191 ADBG_TRACE(("ata_disk_destroy entered\n")); 192 } 193 194 195 /* 196 * Test whether the disk can support Logical Block Addressing 197 */ 198 199 int 200 ata_test_lba_support(struct ata_id *aidp) 201 { 202 #ifdef __old_version__ 203 /* 204 * determine if the drive supports LBA mode 205 */ 206 if (aidp->ai_cap & ATAC_LBA_SUPPORT) 207 return (TRUE); 208 #else 209 /* 210 * Determine if the drive supports LBA mode 211 * LBA mode is mandatory on ATA-3 (or newer) drives but is 212 * optional on ATA-2 (or older) drives. On ATA-2 drives 213 * the ai_majorversion word should be 0xffff or 0x0000 214 * (version not reported). 215 */ 216 if (aidp->ai_majorversion != 0xffff && 217 aidp->ai_majorversion >= (1 << 3)) { 218 /* ATA-3 or better */ 219 return (TRUE); 220 } else if (aidp->ai_cap & ATAC_LBA_SUPPORT) { 221 /* ATA-2 LBA capability bit set */ 222 return (TRUE); 223 } else { 224 return (FALSE); 225 } 226 #endif 227 } 228 229 /* 230 * ATA-6 drives do not provide geometry information, so words 231 * ai_heads, ai_sectors and ai_fixcyls may not be valid 232 */ 233 static void 234 ata_fixup_ata6_geometry(struct ata_id *aidp) 235 { 236 /* check cylinders, heads, and sectors for valid values */ 237 if (aidp->ai_heads != 0 && aidp->ai_heads != 0xffff && 238 aidp->ai_sectors != 0 && aidp->ai_sectors != 0xffff && 239 aidp->ai_fixcyls != 0) 240 return; /* assume valid geometry - do nothing */ 241 242 /* 243 * Pre-set standard geometry values - they are not necessarily 244 * optimal for a given capacity 245 */ 246 aidp->ai_heads = 0x10; 247 aidp->ai_sectors = 0x3f; 248 aidp->ai_fixcyls = 1; 249 /* 250 * The fixcyls value will get fixed up later in 251 * ata_fix_large_disk_geometry. 252 */ 253 } 254 255 /* 256 * 257 * initialize the soft-structure for an ATA (non-PACKET) drive and 258 * then configure the drive with the correct modes and options. 259 * 260 */ 261 262 int 263 ata_disk_init_drive( 264 ata_drv_t *ata_drvp) 265 { 266 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; 267 struct ata_id *aidp = &ata_drvp->ad_id; 268 struct ctl_obj *ctlobjp; 269 struct scsi_device *devp; 270 int len; 271 int val; 272 int mode; 273 short *chs; 274 char buf[80]; 275 276 ADBG_TRACE(("ata_disk_init_drive entered\n")); 277 278 /* ATA disks don't support LUNs */ 279 280 if (ata_drvp->ad_lun != 0) 281 return (FALSE); 282 283 /* 284 * set up drive structure 285 * ATA-6 drives do not provide geometry information, so words 286 * ai_heads, ai_sectors and ai_fixcyls may not be valid - they 287 * will be fixed later 288 */ 289 290 ata_drvp->ad_phhd = aidp->ai_heads; 291 ata_drvp->ad_phsec = aidp->ai_sectors; 292 ata_drvp->ad_drvrhd = aidp->ai_heads; 293 ata_drvp->ad_drvrsec = aidp->ai_sectors; 294 ata_drvp->ad_drvrcyl = aidp->ai_fixcyls; 295 ata_drvp->ad_acyl = 0; 296 297 if (ata_test_lba_support(&ata_drvp->ad_id)) 298 ata_drvp->ad_drive_bits |= ATDH_LBA; 299 300 /* Get capacity and check for 48-bit mode */ 301 mode = ata_get_capacity(ata_drvp, &ata_drvp->ad_capacity); 302 if (mode == AD_EXT48) { 303 ata_drvp->ad_flags |= AD_EXT48; 304 } 305 306 /* straighten out the geometry */ 307 (void) sprintf(buf, "SUNW-ata-%p-d%d-chs", (void *) ata_ctlp->ac_data, 308 ata_drvp->ad_targ+1); 309 if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(), 0, 310 buf, (caddr_t)&chs, &len) == DDI_PROP_SUCCESS) { 311 /* 312 * if the number of sectors and heads in bios matches the 313 * physical geometry, then so should the number of cylinders 314 * this is to prevent the 1023 limit in the older bios's 315 * causing loss of space. 316 */ 317 if (chs[1] == (ata_drvp->ad_drvrhd - 1) && 318 chs[2] == ata_drvp->ad_drvrsec) 319 /* Set chs[0] to zero-based number of cylinders. */ 320 chs[0] = aidp->ai_fixcyls - 1; 321 else if (!(ata_drvp->ad_drive_bits & ATDH_LBA)) { 322 /* 323 * if the the sector/heads do not match that of the 324 * bios and the drive does not support LBA. We go ahead 325 * and advertise the bios geometry but use the physical 326 * geometry for sector translation. 327 */ 328 cmn_err(CE_WARN, "!Disk 0x%p,%d: BIOS geometry " 329 "different from physical, and no LBA support.", 330 (void *)ata_ctlp->ac_data, ata_drvp->ad_targ); 331 } 332 333 /* 334 * chs[0,1] are zero-based; make them one-based. 335 */ 336 ata_drvp->ad_drvrcyl = chs[0] + 1; 337 ata_drvp->ad_drvrhd = chs[1] + 1; 338 ata_drvp->ad_drvrsec = chs[2]; 339 kmem_free(chs, len); 340 } else { 341 /* 342 * Property not present; this means that boot.bin has 343 * determined that the drive supports Int13 LBA. Note 344 * this, but just return a geometry with a large 345 * cylinder count; this will be the signal for dadk to 346 * fail DKIOCG_VIRTGEOM. 347 * ad_drvr* are already set; just recalculate ad_drvrcyl 348 * from capacity. 349 */ 350 351 ata_drvp->ad_flags |= AD_INT13LBA; 352 if (ata_drvp->ad_capacity != 0) { 353 ata_drvp->ad_drvrcyl = ata_drvp->ad_capacity / 354 (ata_drvp->ad_drvrhd * ata_drvp->ad_drvrsec); 355 } else { 356 /* 357 * Something's wrong; return something sure to 358 * fail the "cyls < 1024" test. This will 359 * never make it out of the DKIOCG_VIRTGEOM 360 * call, so its total bogosity won't matter. 361 */ 362 ata_drvp->ad_drvrcyl = 1025; 363 ata_drvp->ad_drvrhd = 1; 364 ata_drvp->ad_drvrsec = 1; 365 } 366 } 367 368 /* fix geometry for disks > 31GB, if needed */ 369 ata_fix_large_disk_geometry(ata_drvp); 370 371 /* 372 * set up the scsi_device and ctl_obj structures 373 */ 374 devp = kmem_zalloc(scsi_device_size(), KM_SLEEP); 375 ata_drvp->ad_device = devp; 376 ctlobjp = &ata_drvp->ad_ctl_obj; 377 378 devp->sd_inq = &ata_drvp->ad_inquiry; 379 devp->sd_address.a_hba_tran = (scsi_hba_tran_t *)ctlobjp; 380 devp->sd_address.a_target = (ushort_t)ata_drvp->ad_targ; 381 devp->sd_address.a_lun = (uchar_t)ata_drvp->ad_lun; 382 mutex_init(&devp->sd_mutex, NULL, MUTEX_DRIVER, NULL); 383 ata_drvp->ad_flags |= AD_MUTEX_INIT; 384 385 /* 386 * DADA ops vectors and cookie 387 */ 388 ctlobjp->c_ops = (struct ctl_objops *)&ata_disk_objops; 389 390 /* 391 * this is filled in with gtgtp by ata_disk_bus_ctl(INITCHILD) 392 */ 393 ctlobjp->c_data = NULL; 394 395 ctlobjp->c_ext = &(ctlobjp->c_extblk); 396 ctlobjp->c_extblk.c_ctldip = ata_ctlp->ac_dip; 397 ctlobjp->c_extblk.c_targ = ata_drvp->ad_targ; 398 ctlobjp->c_extblk.c_blksz = NBPSCTR; 399 400 /* 401 * Get highest block factor supported by the drive. 402 * Some drives report 0 if read/write multiple not supported, 403 * adjust their blocking factor to 1. 404 */ 405 ata_drvp->ad_block_factor = aidp->ai_mult1 & 0xff; 406 407 /* 408 * If a block factor property exists, use the smaller of the 409 * property value and the highest value the drive can support. 410 */ 411 (void) sprintf(buf, "drive%d_block_factor", ata_drvp->ad_targ); 412 val = ddi_prop_get_int(DDI_DEV_T_ANY, ata_ctlp->ac_dip, 0, buf, 413 ata_drvp->ad_block_factor); 414 415 ata_drvp->ad_block_factor = (short)min(val, ata_drvp->ad_block_factor); 416 417 if (ata_drvp->ad_block_factor == 0) 418 ata_drvp->ad_block_factor = 1; 419 420 if (!ata_disk_setup_parms(ata_ctlp, ata_drvp)) { 421 ata_drvp->ad_device = NULL; 422 kmem_free(devp, scsi_device_size()); 423 return (FALSE); 424 } 425 426 ata_disk_fake_inquiry(ata_drvp); 427 428 return (TRUE); 429 } 430 431 /* 432 * Test if a disk supports 48-bit (extended mode) addressing and 433 * get disk capacity. 434 * Return value: 435 * AD_EXT48 if 48-bit mode is available, 0 otherwise, 436 * capacity in sectors. 437 * There are several indicators for 48-bit addressing. If any of 438 * them is missing, assume 28-bit (non-extended) addressing. 439 */ 440 441 static int 442 ata_get_capacity(ata_drv_t *ata_drvp, uint64_t *capacity) 443 { 444 struct ata_id *aidp = &ata_drvp->ad_id; 445 uint64_t cap28; /* capacity in 28-bit mode */ 446 uint64_t cap48; /* capacity in 48-bit mode */ 447 448 /* 449 * First compute capacity in 28-bit mode, using 28-bit capacity 450 * words in IDENTIFY DEVICE response words 451 */ 452 cap28 = ata_calculate_28bits_capacity(ata_drvp); 453 *capacity = cap28; 454 455 if (!IS_ATA_VERSION_SUPPORTED(aidp, 6) && 456 !(ata_drvp->ad_flags & AD_BLLBA48)) 457 return (0); 458 459 /* Check that 48 bit addressing is supported & enabled */ 460 /* words 83 and 86 */ 461 if (!(aidp->ai_cmdset83 & ATACS_EXT48)) 462 return (0); 463 if (!(aidp->ai_features86 & ATACS_EXT48)) 464 return (0); 465 466 /* 467 * Drive supports ATA-6. Since ATA-6 drives may not provide 468 * geometry info, pre-set standard geometry values 469 */ 470 ata_fixup_ata6_geometry(aidp); 471 472 /* Compute 48-bit capacity */ 473 cap48 = ata_calculate_48bits_capacity(ata_drvp); 474 475 /* 476 * If capacity is smaller then the maximum capacity addressable 477 * in 28-bit mode, just use 28-bit capacity value. 478 * We will use 28-bit addressing read/write commands. 479 */ 480 if (cap48 <= MAX_28BIT_CAPACITY) 481 return (0); 482 483 /* 484 * Capacity is too big for 28-bits addressing. But, to make 485 * sure that the drive implements ATA-6 correctly, the 486 * final check: cap28 should be MAX for 28-bit addressing. 487 * If it's not, we shouldn't use 48-bit mode, so return 488 * the capacity reported in 28-bit capacity words. 489 */ 490 if (cap28 != MAX_28BIT_CAPACITY) 491 return (0); /* not max, use 28-bit value */ 492 493 /* 494 * All is well so return 48-bit capacity indicator 495 */ 496 ADBG_INIT(("ATA: using 48-bit mode for capacity %llx blocks\n", 497 (unsigned long long)cap48)); 498 499 *capacity = cap48; 500 return (AD_EXT48); 501 } 502 503 /* 504 * With the advent of disks that hold more than 31 GB, we run into a 505 * limitation in the sizes of the fields that describe the geometry. 506 * The cylinders, heads, and sectors-per-track are each described by a 507 * 16-bit number -- both in the structure returned from IDENTIFY 508 * DEVICE and in the structure returned from the DIOCTL_GETGEOM or 509 * DIOCTL_GETPHYGEOM ioctl. 510 * 511 * The typical disk has 32 heads per cylinder and 63 sectors per 512 * track. A 16 bit field can contain up to 65535. So the largest 513 * disk that can be described in these fields is 65535 * 32 * 63 * 512 514 * (bytes/sector), or about 31.5 GB. The cylinder count gets truncated 515 * when stored in a narrow field, so a 40GB disk appears to have only 516 * 8 GB! 517 * 518 * The solution (for the time being at least) is to lie about the 519 * geometry. If the number of cylinders is too large to fit in 16 520 * bits, we will halve the cylinders and double the heads, repeating 521 * until we can fit the geometry into 3 shorts. 522 * FUTURE ENHANCEMENT: If this ever isn't enough, we could 523 * add another step to double sectors/track as well. 524 */ 525 526 static void 527 ata_fix_large_disk_geometry( 528 ata_drv_t *ata_drvp) 529 { 530 struct ata_id *aidp = &ata_drvp->ad_id; 531 532 /* no hope for large disks if LBA not supported */ 533 if (!(ata_drvp->ad_drive_bits & ATDH_LBA)) 534 return; 535 536 /* 537 * Fix up the geometry to be returned by DIOCTL_GETGEOM. 538 * If number of cylinders > USHRT_MAX, double heads and 539 * halve cylinders until everything fits. 540 */ 541 while (ata_drvp->ad_drvrcyl > USHRT_MAX) { 542 int tempheads; 543 544 /* is there room in 16 bits to double the heads? */ 545 tempheads = 2 * ata_drvp->ad_drvrhd; 546 if (tempheads > USHRT_MAX) { 547 /* 548 * No room to double the heads. 549 * I give up, there's no way to represent this. 550 * Limit disk size. 551 */ 552 cmn_err(CE_WARN, 553 "Disk is too large: " 554 "Model %s, Serial# %s " 555 "Approximating...\n", 556 aidp->ai_model, aidp->ai_drvser); 557 ata_drvp->ad_drvrcyl = USHRT_MAX; 558 break; 559 } 560 561 /* OK, so double the heads and halve the cylinders */ 562 ata_drvp->ad_drvrcyl /= 2; 563 ata_drvp->ad_drvrhd *= 2; 564 } 565 } 566 567 /* 568 * Calculate capacity using 28-bit capacity words from IDENTIFY DEVICE 569 * return words 570 */ 571 uint64_t 572 ata_calculate_28bits_capacity(ata_drv_t *ata_drvp) 573 { 574 /* 575 * Asked x3t13 for advice; this implements Hale Landis' 576 * response, minus the "use ATA_INIT_DEVPARMS". 577 * See "capacity.notes". 578 */ 579 580 /* some local shorthand/renaming to clarify the meaning */ 581 582 ushort_t curcyls_w54, curhds_w55, cursect_w56; 583 uint32_t curcap_w57_58; 584 585 if ((ata_drvp->ad_drive_bits & ATDH_LBA) != 0) { 586 return ((uint64_t)(ata_drvp->ad_id.ai_addrsec[0] + 587 ata_drvp->ad_id.ai_addrsec[1] * 0x10000)); 588 } 589 590 /* 591 * If we're not LBA, then first try to validate "current" values. 592 */ 593 594 curcyls_w54 = ata_drvp->ad_id.ai_curcyls; 595 curhds_w55 = ata_drvp->ad_id.ai_curheads; 596 cursect_w56 = ata_drvp->ad_id.ai_cursectrk; 597 curcap_w57_58 = ata_drvp->ad_id.ai_cursccp[0] + 598 ata_drvp->ad_id.ai_cursccp[1] * 0x10000; 599 600 if (((ata_drvp->ad_id.ai_validinfo & 1) == 1) && 601 (curhds_w55 >= 1) && (curhds_w55 <= 16) && 602 (cursect_w56 >= 1) && (cursect_w56 <= 63) && 603 (curcap_w57_58 == curcyls_w54 * curhds_w55 * cursect_w56)) { 604 return ((uint64_t)curcap_w57_58); 605 } 606 607 /* 608 * At this point, Hale recommends ATA_INIT_DEVPARMS. 609 * I don't want to do that, so simply use 1/3/6 as 610 * a final fallback, and continue to assume the BIOS 611 * has done whatever INIT_DEVPARMS are necessary. 612 */ 613 614 return ((uint64_t)(ata_drvp->ad_id.ai_fixcyls * 615 ata_drvp->ad_id.ai_heads * ata_drvp->ad_id.ai_sectors)); 616 } 617 618 /* 619 * Calculate capacity using 48-bits capacity words from IDENTIFY DEVICE 620 * return words 621 */ 622 uint64_t 623 ata_calculate_48bits_capacity(ata_drv_t *ata_drvp) 624 { 625 uint64_t cap48 = 0; 626 int i; 627 628 for (i = 3; i >= 0; --i) { 629 cap48 <<= 16; 630 cap48 += ata_drvp->ad_id.ai_addrsecxt[i]; 631 } 632 return (cap48); 633 } 634 635 636 /* 637 * 638 * Setup the drives Read/Write Multiple Blocking factor and the 639 * current translation geometry. Necessary during attach and after 640 * Software Resets. 641 * 642 */ 643 644 int 645 ata_disk_setup_parms( 646 ata_ctl_t *ata_ctlp, 647 ata_drv_t *ata_drvp) 648 { 649 650 /* 651 * program geometry info back to the drive 652 */ 653 if (!ata_disk_initialize_device_parameters(ata_ctlp, ata_drvp)) { 654 return (FALSE); 655 } 656 657 /* 658 * Determine the blocking factor 659 */ 660 if (ata_drvp->ad_block_factor > 1) { 661 /* 662 * Program the block factor into the drive. If this 663 * fails, then go back to using a block size of 1. 664 */ 665 if (!ata_disk_set_multiple(ata_ctlp, ata_drvp)) 666 ata_drvp->ad_block_factor = 1; 667 } 668 669 670 if (ata_drvp->ad_block_factor > 1) { 671 ata_drvp->ad_rd_cmd = ATC_RDMULT; 672 ata_drvp->ad_wr_cmd = ATC_WRMULT; 673 } else { 674 ata_drvp->ad_rd_cmd = ATC_RDSEC; 675 ata_drvp->ad_wr_cmd = ATC_WRSEC; 676 } 677 678 ata_drvp->ad_bytes_per_block = ata_drvp->ad_block_factor << SCTRSHFT; 679 680 ADBG_INIT(("set block factor for drive %d to %d\n", 681 ata_drvp->ad_targ, ata_drvp->ad_block_factor)); 682 683 if (ata_disk_do_standby_timer) 684 ata_disk_set_standby_timer(ata_ctlp, ata_drvp); 685 686 ata_set_write_cache(ata_ctlp, ata_drvp); 687 688 return (TRUE); 689 } 690 691 692 /* 693 * Take the timeout value specified in the "standby" property 694 * and convert from seconds to the magic parm expected by the 695 * the drive. Then issue the IDLE command to set the drive's 696 * internal standby timer. 697 */ 698 699 static void 700 ata_disk_set_standby_timer( 701 ata_ctl_t *ata_ctlp, 702 ata_drv_t *ata_drvp) 703 { 704 uchar_t parm; 705 int timeout = ata_ctlp->ac_standby_time; 706 707 /* 708 * take the timeout value, specificed in seconds, and 709 * encode it into the proper command parm 710 */ 711 712 /* 713 * don't change it if no property specified or if 714 * the specified value is out of range 715 */ 716 if (timeout < 0 || timeout > (12 * 60 * 60)) 717 return; 718 719 /* 1 to 1200 seconds (20 minutes) == N * 5 seconds */ 720 if (timeout <= (240 * 5)) 721 parm = (timeout + 4) / 5; 722 723 /* 20 to 21 minutes == 21 minutes */ 724 else if (timeout <= (21 * 60)) 725 parm = 252; 726 727 /* 21 minutes to 21 minutes 15 seconds == 21:15 */ 728 else if (timeout <= ((21 * 60) + 15)) 729 parm = 255; 730 731 /* 21:15 to 330 minutes == N * 30 minutes */ 732 else if (timeout <= (11 * 30 * 60)) 733 parm = 240 + ((timeout + (30 * 60) - 1)/ (30 * 60)); 734 735 /* > 330 minutes == 8 to 12 hours */ 736 else 737 parm = 253; 738 739 (void) ata_command(ata_ctlp, ata_drvp, TRUE, FALSE, 5 * 1000000, 740 ATC_IDLE, 0, parm, 0, 0, 0, 0); 741 } 742 743 744 745 /* 746 * 747 * destroy an ata disk drive 748 * 749 */ 750 751 void 752 ata_disk_uninit_drive( 753 ata_drv_t *ata_drvp) 754 { 755 struct scsi_device *devp = ata_drvp->ad_device; 756 757 ADBG_TRACE(("ata_disk_uninit_drive entered\n")); 758 759 if (devp) { 760 if (ata_drvp->ad_flags & AD_MUTEX_INIT) 761 mutex_destroy(&devp->sd_mutex); 762 ata_drvp->ad_device = NULL; 763 kmem_free(devp, scsi_device_size()); 764 } 765 } 766 767 768 769 770 /* 771 * 772 * DADA compliant bus_ctl entry point 773 * 774 */ 775 776 /*ARGSUSED*/ 777 int 778 ata_disk_bus_ctl( 779 dev_info_t *d, 780 dev_info_t *r, 781 ddi_ctl_enum_t o, 782 void *a, 783 void *v) 784 { 785 ADBG_TRACE(("ata_disk_bus_ctl entered\n")); 786 787 switch (o) { 788 789 case DDI_CTLOPS_REPORTDEV: 790 { 791 int targ; 792 793 targ = ddi_prop_get_int(DDI_DEV_T_ANY, r, DDI_PROP_DONTPASS, 794 "target", 0); 795 cmn_err(CE_CONT, "?%s%d at %s%d target %d lun %d\n", 796 ddi_driver_name(r), ddi_get_instance(r), 797 ddi_driver_name(d), ddi_get_instance(d), targ, 0); 798 return (DDI_SUCCESS); 799 } 800 case DDI_CTLOPS_INITCHILD: 801 { 802 dev_info_t *cdip = (dev_info_t *)a; 803 ata_drv_t *ata_drvp; 804 ata_ctl_t *ata_ctlp; 805 ata_tgt_t *ata_tgtp; 806 struct scsi_device *devp; 807 struct ctl_obj *ctlobjp; 808 gtgt_t *gtgtp; 809 char name[MAXNAMELEN]; 810 811 /* 812 * save time by picking up ptr to drive struct left 813 * by ata_bus_ctl - isn't that convenient. 814 */ 815 ata_drvp = ddi_get_driver_private(cdip); 816 ata_ctlp = ata_drvp->ad_ctlp; 817 818 /* set up pointers to child dip */ 819 820 devp = ata_drvp->ad_device; 821 /* 822 * If sd_dev is set, it means that the target has already 823 * being initialized. The cdip is a duplicate node from 824 * reexpansion of driver.conf. Fail INITCHILD here. 825 */ 826 if ((devp == NULL) || (devp->sd_dev != NULL)) { 827 return (DDI_FAILURE); 828 } 829 devp->sd_dev = cdip; 830 831 ctlobjp = &ata_drvp->ad_ctl_obj; 832 ctlobjp->c_extblk.c_devdip = cdip; 833 834 /* 835 * Create the "ata" property for use by the target driver 836 */ 837 if (!ata_prop_create(cdip, ata_drvp, "ata")) { 838 return (DDI_FAILURE); 839 } 840 841 gtgtp = ghd_target_init(d, cdip, &ata_ctlp->ac_ccc, 842 sizeof (ata_tgt_t), ata_ctlp, 843 ata_drvp->ad_targ, 844 ata_drvp->ad_lun); 845 846 /* gt_tgt_private points to ata_tgt_t */ 847 ata_tgtp = GTGTP2ATATGTP(gtgtp); 848 ata_tgtp->at_drvp = ata_drvp; 849 ata_tgtp->at_dma_attr = ata_pciide_dma_attr; 850 ata_tgtp->at_dma_attr.dma_attr_maxxfer = 851 ata_ctlp->ac_max_transfer << SCTRSHFT; 852 853 /* gtgtp is the opaque arg to all my entry points */ 854 ctlobjp->c_data = gtgtp; 855 856 /* create device name */ 857 858 (void) sprintf(name, "%x,%x", ata_drvp->ad_targ, 859 ata_drvp->ad_lun); 860 ddi_set_name_addr(cdip, name); 861 ddi_set_driver_private(cdip, devp); 862 863 return (DDI_SUCCESS); 864 } 865 866 case DDI_CTLOPS_UNINITCHILD: 867 { 868 dev_info_t *cdip = (dev_info_t *)a; 869 struct scsi_device *devp; 870 struct ctl_obj *ctlobjp; 871 gtgt_t *gtgtp; 872 873 devp = ddi_get_driver_private(cdip); 874 ctlobjp = (struct ctl_obj *)devp->sd_address.a_hba_tran; 875 gtgtp = ctlobjp->c_data; 876 877 ghd_target_free(d, cdip, >GTP2ATAP(gtgtp)->ac_ccc, gtgtp); 878 879 ddi_set_driver_private(cdip, NULL); 880 ddi_set_name_addr(cdip, NULL); 881 return (DDI_SUCCESS); 882 } 883 884 default: 885 return (DDI_FAILURE); 886 } 887 } 888 889 890 /* 891 * 892 * DADA abort entry point - not currently used by dadk 893 * 894 */ 895 896 /* ARGSUSED */ 897 static int 898 ata_disk_abort(opaque_t ctl_data, cmpkt_t *pktp) 899 { 900 ADBG_TRACE(("ata_disk_abort entered\n")); 901 902 /* XXX - Note that this interface is currently not used by dadk */ 903 904 /* 905 * GHD abort functions take a pointer to a scsi_address 906 * and so they're unusable here. The ata driver used to 907 * return DDI_SUCCESS here without doing anything. Its 908 * seems that DDI_FAILURE is more appropriate. 909 */ 910 911 return (DDI_FAILURE); 912 } 913 914 915 916 /* 917 * 918 * DADA reset entry point - not currently used by dadk 919 * (except in debug versions of driver) 920 * 921 */ 922 923 /* ARGSUSED */ 924 static int 925 ata_disk_reset(opaque_t ctl_data, int level) 926 { 927 gtgt_t *gtgtp = (gtgt_t *)ctl_data; 928 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp); 929 int rc; 930 931 ADBG_TRACE(("ata_disk_reset entered\n")); 932 933 /* XXX - Note that this interface is currently not used by dadk */ 934 935 if (level == RESET_TARGET) { 936 rc = ghd_tran_reset_target(&ata_drvp->ad_ctlp->ac_ccc, gtgtp, 937 NULL); 938 } else if (level == RESET_ALL) { 939 rc = ghd_tran_reset_bus(&ata_drvp->ad_ctlp->ac_ccc, gtgtp, 940 NULL); 941 } 942 943 return (rc ? DDI_SUCCESS : DDI_FAILURE); 944 } 945 946 947 948 /* 949 * 950 * DADA ioctl entry point 951 * 952 */ 953 954 /* ARGSUSED */ 955 static int 956 ata_disk_ioctl(opaque_t ctl_data, int cmd, intptr_t arg, int flag) 957 { 958 gtgt_t *gtgtp = (gtgt_t *)ctl_data; 959 ata_ctl_t *ata_ctlp = GTGTP2ATAP(gtgtp); 960 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp); 961 int rc, rc2; 962 struct tgdk_geom tgdk; 963 int wce; 964 struct ata_id *aidp = &ata_drvp->ad_id; 965 dk_updatefw_t updatefw; 966 #ifdef _MULTI_DATAMODEL 967 dk_updatefw_32_t updatefw32; 968 #endif 969 dk_disk_id_t dk_disk_id; 970 char buf[80]; 971 int i; 972 973 974 ADBG_TRACE(("ata_disk_ioctl entered, cmd = %d\n", cmd)); 975 976 switch (cmd) { 977 978 case DIOCTL_GETGEOM: 979 case DIOCTL_GETPHYGEOM: 980 tgdk.g_cyl = ata_drvp->ad_drvrcyl; 981 tgdk.g_head = ata_drvp->ad_drvrhd; 982 tgdk.g_sec = ata_drvp->ad_drvrsec; 983 tgdk.g_acyl = ata_drvp->ad_acyl; 984 tgdk.g_secsiz = 512; 985 tgdk.g_cap = (diskaddr_t)tgdk.g_cyl * tgdk.g_head * tgdk.g_sec; 986 if (ddi_copyout(&tgdk, (caddr_t)arg, sizeof (tgdk), flag)) 987 return (EFAULT); 988 return (0); 989 990 case DCMD_UPDATE_GEOM: 991 /* ??? fix this to issue IDENTIFY DEVICE ??? */ 992 /* might not be necessary since I don't know of any ATA/IDE that */ 993 /* can change its geometry. On the other hand, ATAPI devices like the */ 994 /* LS-120 or PD/CD can change their geometry when new media is inserted */ 995 return (0); 996 997 /* copy the model number into the caller's buffer */ 998 case DIOCTL_GETMODEL: 999 rc = ata_copy_dk_ioc_string(arg, aidp->ai_model, 1000 sizeof (aidp->ai_model), flag); 1001 return (rc); 1002 1003 /* copy the serial number into the caller's buffer */ 1004 case DIOCTL_GETSERIAL: 1005 rc = ata_copy_dk_ioc_string(arg, aidp->ai_drvser, 1006 sizeof (aidp->ai_drvser), 1007 flag); 1008 return (rc); 1009 1010 case DIOCTL_GETWCE: 1011 /* 1012 * WCE is only supported in ATAPI-4 or higher, for 1013 * lower rev devices, must assume write cache is 1014 * enabled. 1015 * NOTE: Since there is currently no Solaris mechanism 1016 * to change the state of the Write Cache Enable feature, 1017 * this code just checks the value of the WCE bit 1018 * obtained at device init time. If a mechanism 1019 * is added to the driver to change WCE, this code 1020 * must be updated appropriately. 1021 */ 1022 wce = (aidp->ai_majorversion == 0xffff) || 1023 ((aidp->ai_majorversion & ATAC_MAJVER_4) == 0) || 1024 (aidp->ai_features85 & ATAC_FEATURES85_WCE) != 0; 1025 1026 if (ddi_copyout(&wce, (caddr_t)arg, sizeof (wce), flag) != 0) 1027 return (EFAULT); 1028 1029 return (0); 1030 1031 case DCMD_GET_STATE: 1032 rc = ata_queue_cmd(ata_disk_state, NULL, ata_ctlp, ata_drvp, 1033 gtgtp); 1034 break; 1035 1036 case DCMD_LOCK: 1037 case DKIOCLOCK: 1038 rc = ata_queue_cmd(ata_disk_lock, NULL, ata_ctlp, ata_drvp, 1039 gtgtp); 1040 break; 1041 1042 case DCMD_UNLOCK: 1043 case DKIOCUNLOCK: 1044 rc = ata_queue_cmd(ata_disk_unlock, NULL, ata_ctlp, ata_drvp, 1045 gtgtp); 1046 break; 1047 1048 case DCMD_START_MOTOR: 1049 case CDROMSTART: 1050 rc = ata_queue_cmd(ata_disk_recalibrate, NULL, ata_ctlp, 1051 ata_drvp, gtgtp); 1052 break; 1053 1054 case DCMD_STOP_MOTOR: 1055 case CDROMSTOP: 1056 rc = ata_queue_cmd(ata_disk_standby, NULL, ata_ctlp, ata_drvp, 1057 gtgtp); 1058 break; 1059 1060 case DKIOCEJECT: 1061 case CDROMEJECT: 1062 rc = ata_queue_cmd(ata_disk_eject, NULL, ata_ctlp, ata_drvp, 1063 gtgtp); 1064 break; 1065 1066 case DKIOC_UPDATEFW: 1067 1068 /* 1069 * Call DOWNLOAD MICROCODE command to update device 1070 * firmware. 1071 * 1072 * return value: 1073 * normal 0 Download microcode success 1074 * error EFAULT Bad address 1075 * ENXIO No such device or address 1076 * EINVAL Invalid argument 1077 * ENOMEM Not enough core 1078 * ENOTSUP Operation not supported 1079 * EIO I/O error 1080 * EPERM Not owner 1081 */ 1082 1083 /* 1084 * The following code deals with handling 32-bit request 1085 * in 64-bit kernel. 1086 */ 1087 #ifdef _MULTI_DATAMODEL 1088 if (ddi_model_convert_from(flag & FMODELS) == 1089 DDI_MODEL_ILP32) { 1090 if (ddi_copyin((void *)arg, &updatefw32, 1091 sizeof (dk_updatefw_32_t), flag)) 1092 return (EFAULT); 1093 1094 updatefw.dku_ptrbuf = 1095 (caddr_t)(uintptr_t)updatefw32.dku_ptrbuf; 1096 updatefw.dku_size = updatefw32.dku_size; 1097 updatefw.dku_type = updatefw32.dku_type; 1098 } else { 1099 if (ddi_copyin((void *)arg, &updatefw, 1100 sizeof (dk_updatefw_t), flag)) 1101 return (EFAULT); 1102 } 1103 #else 1104 if (ddi_copyin((void *)arg, &updatefw, 1105 sizeof (dk_updatefw_t), flag)) 1106 return (EFAULT); 1107 #endif 1108 rc = ata_disk_update_fw(gtgtp, ata_ctlp, ata_drvp, 1109 updatefw.dku_ptrbuf, updatefw.dku_size, 1110 updatefw.dku_type, flag); 1111 1112 /* 1113 * According to ATA8-ACS spec, the new microcode should 1114 * become effective immediately after the transfer of the 1115 * last data segment has completed, so here we will call 1116 * IDENTIFY DEVICE command immediately to update 1117 * ata_id content when success. 1118 */ 1119 if (rc == 0) { 1120 rc2 = ata_queue_cmd(ata_disk_id_update, NULL, 1121 ata_ctlp, ata_drvp, gtgtp); 1122 if (rc2 != TRUE) { 1123 return (ENXIO); 1124 } else { 1125 /* 1126 * Check whether the content of the IDENTIFY 1127 * DEVICE data is incomplete, if yes, it's 1128 * because the device supports the Power-up 1129 * in Standby feature set, and we will first 1130 * check word 2, and then decide whether need 1131 * to call set feature to spin-up the device, 1132 * and then call IDENTIFY DEVICE command again. 1133 */ 1134 aidp = &ata_drvp->ad_id; 1135 if (aidp->ai_config & ATA_ID_INCMPT) { 1136 if (aidp->ai_resv0 == 0x37c8 || 1137 aidp->ai_resv0 == 0x738c) { 1138 /* Spin-up the device */ 1139 (void) ata_queue_cmd( 1140 ata_disk_set_feature_spinup, 1141 NULL, 1142 ata_ctlp, 1143 ata_drvp, 1144 gtgtp); 1145 } 1146 1147 /* Try to update ata_id again */ 1148 rc2 = ata_queue_cmd( 1149 ata_disk_id_update, 1150 NULL, 1151 ata_ctlp, 1152 ata_drvp, 1153 gtgtp); 1154 if (rc2 != TRUE) { 1155 return (ENXIO); 1156 } else { 1157 aidp = &ata_drvp->ad_id; 1158 if (aidp->ai_config & 1159 ATA_ID_INCMPT) 1160 return (ENXIO); 1161 } 1162 } 1163 1164 /* 1165 * Dump the drive information. 1166 */ 1167 ATAPRT(("?\tUpdate firmware of %s device at " 1168 "targ %d, lun %d lastlun 0x%x\n", 1169 (ATAPIDRV(ata_drvp) ? "ATAPI":"IDE"), 1170 ata_drvp->ad_targ, ata_drvp->ad_lun, 1171 aidp->ai_lastlun)); 1172 1173 (void) strncpy(buf, aidp->ai_model, 1174 sizeof (aidp->ai_model)); 1175 buf[sizeof (aidp->ai_model)] = '\0'; 1176 for (i = sizeof (aidp->ai_model) - 1; 1177 buf[i] == ' '; i--) 1178 buf[i] = '\0'; 1179 ATAPRT(("?\tmodel %s\n", buf)); 1180 1181 (void) strncpy(buf, aidp->ai_fw, 1182 sizeof (aidp->ai_fw)); 1183 buf[sizeof (aidp->ai_fw)] = '\0'; 1184 for (i = sizeof (aidp->ai_fw) - 1; 1185 buf[i] == ' '; i--) 1186 buf[i] = '\0'; 1187 ATAPRT(("?\tfw %s\n", buf)); 1188 } 1189 } 1190 return (rc); 1191 1192 case DKIOC_GETDISKID: 1193 bzero(&dk_disk_id, sizeof (dk_disk_id_t)); 1194 1195 dk_disk_id.dkd_dtype = DKD_ATA_TYPE; 1196 1197 /* Get the model number */ 1198 (void) strncpy(dk_disk_id.disk_id.ata_disk_id.dkd_amodel, 1199 aidp->ai_model, sizeof (aidp->ai_model)); 1200 1201 /* Get the firmware revision */ 1202 (void) strncpy(dk_disk_id.disk_id.ata_disk_id.dkd_afwver, 1203 aidp->ai_fw, sizeof (aidp->ai_fw)); 1204 1205 /* Get the serial number */ 1206 (void) strncpy(dk_disk_id.disk_id.ata_disk_id.dkd_aserial, 1207 aidp->ai_drvser, sizeof (aidp->ai_drvser)); 1208 1209 if (ddi_copyout(&dk_disk_id, (void *)arg, 1210 sizeof (dk_disk_id_t), flag)) 1211 return (EFAULT); 1212 else 1213 return (0); 1214 1215 default: 1216 ADBG_WARN(("ata_disk_ioctl: unsupported cmd 0x%x\n", cmd)); 1217 return (ENOTTY); 1218 } 1219 1220 if (rc) 1221 return (0); 1222 return (ENXIO); 1223 1224 } 1225 1226 1227 #ifdef ___not___used___ 1228 /* 1229 * Issue an ATA command to the drive using the packet already 1230 * allocated by the target driver 1231 */ 1232 1233 int 1234 ata_disk_do_ioctl( 1235 int (*func)(ata_ctl_t *, ata_drv_t *, ata_pkt_t *), 1236 void *arg, 1237 ata_ctl_t *ata_ctlp, 1238 gtgt_t *gtgtp, 1239 cmpkt_t *pktp) 1240 { 1241 gcmd_t *gcmdp = CPKT2GCMD(pktp); 1242 ata_pkt_t *ata_pktp = GCMD2APKT(gcmdp); 1243 int rc; 1244 1245 ata_pktp->ap_start = func; 1246 ata_pktp->ap_intr = NULL; 1247 ata_pktp->ap_complete = NULL; 1248 ata_pktp->ap_v_addr = (caddr_t)arg; 1249 1250 /* 1251 * add it to the queue, when it gets to the front the 1252 * ap_start function is called. 1253 */ 1254 rc = ghd_transport(&ata_ctlp->ac_ccc, gcmdp, gcmdp->cmd_gtgtp, 1255 0, TRUE, NULL); 1256 1257 if (rc != TRAN_ACCEPT) { 1258 /* this should never, ever happen */ 1259 return (ENXIO); 1260 } 1261 1262 if (ata_pktp->ap_flags & AP_ERROR) 1263 return (ENXIO); 1264 return (0); 1265 } 1266 #endif 1267 1268 1269 1270 /* 1271 * 1272 * DADA pktalloc entry point 1273 * 1274 */ 1275 1276 /* ARGSUSED */ 1277 static cmpkt_t * 1278 ata_disk_pktalloc(opaque_t ctl_data, int (*callback)(caddr_t), caddr_t arg) 1279 { 1280 gtgt_t *gtgtp = (gtgt_t *)ctl_data; 1281 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp); 1282 cmpkt_t *pktp; 1283 ata_pkt_t *ata_pktp; 1284 gcmd_t *gcmdp; 1285 1286 ADBG_TRACE(("ata_disk_pktalloc entered\n")); 1287 1288 /* 1289 * Allocate and init the GHD gcmd_t structure and the 1290 * DADA cmpkt and the ata_pkt 1291 */ 1292 if ((gcmdp = ghd_gcmd_alloc(gtgtp, 1293 (sizeof (cmpkt_t) + sizeof (ata_pkt_t)), 1294 (callback == DDI_DMA_SLEEP))) == NULL) { 1295 return ((cmpkt_t *)NULL); 1296 } 1297 ASSERT(gcmdp != NULL); 1298 1299 ata_pktp = GCMD2APKT(gcmdp); 1300 ASSERT(ata_pktp != NULL); 1301 1302 pktp = (cmpkt_t *)(ata_pktp + 1); 1303 1304 pktp->cp_ctl_private = (void *)gcmdp; 1305 ata_pktp->ap_gcmdp = gcmdp; 1306 gcmdp->cmd_pktp = (void *)pktp; 1307 1308 /* 1309 * At this point the structures are linked like this: 1310 * 1311 * (struct cmpkt) <--> (struct gcmd) <--> (struct ata_pkt) 1312 */ 1313 1314 /* callback functions */ 1315 1316 ata_pktp->ap_start = ata_disk_start; 1317 ata_pktp->ap_intr = ata_disk_intr; 1318 ata_pktp->ap_complete = ata_disk_complete; 1319 1320 /* other ata_pkt setup */ 1321 1322 ata_pktp->ap_bytes_per_block = ata_drvp->ad_bytes_per_block; 1323 1324 /* cmpkt setup */ 1325 1326 pktp->cp_cdblen = 1; 1327 pktp->cp_cdbp = (opaque_t)&ata_pktp->ap_cdb; 1328 pktp->cp_scbp = (opaque_t)&ata_pktp->ap_scb; 1329 pktp->cp_scblen = 1; 1330 1331 return (pktp); 1332 } 1333 1334 1335 1336 /* 1337 * 1338 * DADA pktfree entry point 1339 * 1340 */ 1341 1342 /* ARGSUSED */ 1343 static void 1344 ata_disk_pktfree(opaque_t ctl_data, cmpkt_t *pktp) 1345 { 1346 ata_pkt_t *ata_pktp = CPKT2APKT(pktp); 1347 1348 ADBG_TRACE(("ata_disk_pktfree entered\n")); 1349 1350 /* check not free already */ 1351 1352 ASSERT(!(ata_pktp->ap_flags & AP_FREE)); 1353 ata_pktp->ap_flags = AP_FREE; 1354 1355 ghd_gcmd_free(CPKT2GCMD(pktp)); 1356 } 1357 1358 1359 /* 1360 * 1361 * DADA memsetup entry point 1362 * 1363 */ 1364 1365 /* ARGSUSED */ 1366 static cmpkt_t * 1367 ata_disk_memsetup( 1368 opaque_t ctl_data, 1369 cmpkt_t *pktp, 1370 struct buf *bp, 1371 int (*callback)(caddr_t), 1372 caddr_t arg) 1373 { 1374 gtgt_t *gtgtp = (gtgt_t *)ctl_data; 1375 ata_pkt_t *ata_pktp = CPKT2APKT(pktp); 1376 gcmd_t *gcmdp = APKT2GCMD(ata_pktp); 1377 int flags; 1378 1379 ADBG_TRACE(("ata_disk_memsetup entered\n")); 1380 1381 ata_pktp->ap_sg_cnt = 0; 1382 1383 if (bp->b_bcount == 0) { 1384 ata_pktp->ap_v_addr = NULL; 1385 return (pktp); 1386 } 1387 1388 if (GTGTP2ATADRVP(gtgtp)->ad_pciide_dma != ATA_DMA_ON) 1389 goto skip_dma_setup; 1390 1391 if (ata_dma_disabled) 1392 goto skip_dma_setup; 1393 1394 /* 1395 * The PCI-IDE DMA engine is brain-damaged and can't 1396 * DMA non-aligned buffers. 1397 */ 1398 if (!(bp->b_flags & B_PAGEIO) && 1399 ((uintptr_t)bp->b_un.b_addr) & PCIIDE_PRDE_ADDR_MASK) { 1400 goto skip_dma_setup; 1401 } 1402 1403 /* 1404 * It also insists that the byte count must be even. 1405 */ 1406 if (bp->b_bcount & 1) 1407 goto skip_dma_setup; 1408 1409 /* check direction for data transfer */ 1410 if (bp->b_flags & B_READ) { 1411 flags = DDI_DMA_READ | DDI_DMA_PARTIAL; 1412 } else { 1413 flags = DDI_DMA_WRITE | DDI_DMA_PARTIAL; 1414 } 1415 1416 /* 1417 * Bind the DMA handle to the buf 1418 */ 1419 if (ghd_dma_buf_bind_attr(>GTP2ATAP(gtgtp)->ac_ccc, gcmdp, bp, flags, 1420 callback, arg, >GTP2ATATGTP(gtgtp)->at_dma_attr)) { 1421 ata_pktp->ap_v_addr = 0; 1422 return (pktp); 1423 } 1424 1425 skip_dma_setup: 1426 bp_mapin(bp); 1427 ata_pktp->ap_v_addr = bp->b_un.b_addr; 1428 return (pktp); 1429 } 1430 1431 1432 1433 /* 1434 * 1435 * DADA memfree entry point 1436 * 1437 */ 1438 1439 /* 1440 * 1157317 sez that drivers shouldn't call bp_mapout(), as either 1441 * biodone() or biowait() will end up doing it, but after they 1442 * call bp->b_iodone(), which is a necessary sequence for 1443 * Online Disk Suite. However, the DDI group wants to rethink 1444 * bp_mapin()/bp_mapout() and how they should behave in the 1445 * presence of layered drivers, etc. For the moment, fix 1446 * the OLDS problem by removing the bp_mapout() call. 1447 */ 1448 1449 #define BUG_1157317 1450 1451 /* ARGSUSED */ 1452 static void 1453 ata_disk_memfree(opaque_t ctl_data, cmpkt_t *pktp) 1454 { 1455 gcmd_t *gcmdp = CPKT2GCMD(pktp); 1456 1457 ADBG_TRACE(("ata_disk_memfree entered\n")); 1458 1459 if (gcmdp->cmd_dma_handle) 1460 ghd_dmafree_attr(gcmdp); 1461 #if !defined(BUG_1157317) 1462 else 1463 bp_mapout(pktp->cp_bp); 1464 #endif 1465 } 1466 1467 1468 1469 /* 1470 * 1471 * DADA iosetup entry point 1472 * 1473 */ 1474 1475 static cmpkt_t * 1476 ata_disk_iosetup(opaque_t ctl_data, cmpkt_t *pktp) 1477 { 1478 gtgt_t *gtgtp = (gtgt_t *)ctl_data; 1479 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp); 1480 ata_pkt_t *ata_pktp = CPKT2APKT(pktp); 1481 gcmd_t *gcmdp = APKT2GCMD(ata_pktp); 1482 uint_t sec_count; 1483 daddr_t start_sec; 1484 uint_t byte_count; 1485 1486 ADBG_TRACE(("ata_disk_iosetup entered\n")); 1487 1488 /* 1489 * Check for DCMD_FLUSH_CACHE (which does no I/O) and 1490 * just do basic setup. 1491 */ 1492 if (pktp->cp_passthru == NULL && 1493 ata_pktp->ap_cdb == DCMD_FLUSH_CACHE) { 1494 ata_pktp->ap_cmd = ATC_FLUSH_CACHE; 1495 ata_pktp->ap_flags = 0; 1496 ata_pktp->ap_count = 0; 1497 ata_pktp->ap_startsec = 0; 1498 ata_pktp->ap_sg_cnt = 0; 1499 ata_pktp->ap_pciide_dma = FALSE; 1500 return (pktp); 1501 } 1502 1503 /* check for error retry */ 1504 if (ata_pktp->ap_flags & AP_ERROR) { 1505 /* 1506 * this is a temporary work-around for dadk calling 1507 * iosetup for retry. The correct 1508 * solution is changing dadk to not to call iosetup 1509 * for a retry. 1510 * We do not apply the work-around for pio mode since 1511 * that does not involve moving dma windows and reducing the 1512 * sector count would work for pio mode on a retry 1513 * for now. 1514 */ 1515 if (gcmdp->cmd_dma_handle != NULL) { 1516 ata_pktp->ap_flags = 0; 1517 return (NULL); 1518 } 1519 1520 ata_pktp->ap_bytes_per_block = NBPSCTR; 1521 sec_count = 1; 1522 1523 /* 1524 * Since we are retrying the last read or write operation, 1525 * restore the old values of the ap_v_addr and ap_resid. 1526 * This assumes CTL_IOSETUP is called again on retry; if not, 1527 * this needs to be done in CTL_TRANSPORT. 1528 */ 1529 if (ata_pktp->ap_flags & (AP_READ | AP_WRITE)) { 1530 ata_pktp->ap_v_addr = ata_pktp->ap_v_addr_sav; 1531 ata_pktp->ap_resid = ata_pktp->ap_resid_sav; 1532 } 1533 } else { 1534 /* 1535 * Limit request to ac_max_transfer sectors. 1536 * The value is specified by the user in the 1537 * max_transfer property. It must be in the range 1 to 256. 1538 * When max_transfer is 0x100 it is bigger than 8 bits. 1539 * The spec says 0 represents 256 so it should be OK. 1540 */ 1541 sec_count = min((pktp->cp_bytexfer >> SCTRSHFT), 1542 ata_drvp->ad_ctlp->ac_max_transfer); 1543 /* 1544 * Save the current values of ap_v_addr and ap_resid 1545 * in case a retry operation happens. During a retry 1546 * operation we need to restore these values. 1547 */ 1548 ata_pktp->ap_v_addr_sav = ata_pktp->ap_v_addr; 1549 ata_pktp->ap_resid_sav = ata_pktp->ap_resid; 1550 } 1551 1552 /* reset flags */ 1553 ata_pktp->ap_flags = 0; 1554 1555 #ifdef DADKIO_RWCMD_READ 1556 start_sec = pktp->cp_passthru ? RWCMDP(pktp)->blkaddr : pktp->cp_srtsec; 1557 #else 1558 start_sec = pktp->cp_srtsec; 1559 #endif 1560 1561 /* 1562 * Setup the PCIDE Bus Master Scatter/Gather list 1563 */ 1564 ata_pktp->ap_sg_cnt = 0; 1565 ata_pktp->ap_pciide_dma = FALSE; 1566 if (gcmdp->cmd_dma_handle != NULL && sec_count != 0) { 1567 byte_count = sec_count << SCTRSHFT; 1568 if ((ghd_dmaget_attr(>GTP2ATAP(gtgtp)->ac_ccc, gcmdp, 1569 byte_count, ATA_DMA_NSEGS, &byte_count) == FALSE) || 1570 (byte_count == 0)) { 1571 ADBG_ERROR(("ata_disk_iosetup: byte count zero\n")); 1572 return (NULL); 1573 } 1574 sec_count = byte_count >> SCTRSHFT; 1575 } 1576 1577 /* 1578 * In the non-48-bit mode addressing (CHS and LBA28) the sector 1579 * count is a 8-bit value and the sector count 0 represents 256 1580 * sectors. 1581 * In the extended addressing (LBA48) the sector count is a 16-bit 1582 * value, so max_transfer 0x100 cannot be truncated to 8-bits 1583 * because this would represent a zero sector count. 1584 */ 1585 ata_pktp->ap_count = (ushort_t)sec_count; 1586 if (!(ata_drvp->ad_flags & AD_EXT48)) { 1587 ata_pktp->ap_count &= 0xff; 1588 } 1589 ata_pktp->ap_startsec = start_sec; 1590 1591 #ifdef DADKIO_RWCMD_READ 1592 if (pktp->cp_passthru) { 1593 switch (RWCMDP(pktp)->cmd) { 1594 case DADKIO_RWCMD_READ: 1595 if (ata_pktp->ap_sg_cnt) { 1596 ata_pktp->ap_cmd = ATC_READ_DMA; 1597 ata_pktp->ap_pciide_dma = TRUE; 1598 ata_pktp->ap_start = ata_disk_start_dma_in; 1599 ata_pktp->ap_intr = ata_disk_intr_dma; 1600 } else { 1601 ata_pktp->ap_cmd = ATC_RDSEC; 1602 ata_pktp->ap_start = ata_disk_start_pio_in; 1603 ata_pktp->ap_intr = ata_disk_intr_pio_in; 1604 } 1605 ata_pktp->ap_flags |= AP_READ; 1606 break; 1607 case DADKIO_RWCMD_WRITE: 1608 if (ata_pktp->ap_sg_cnt) { 1609 ata_pktp->ap_cmd = ATC_WRITE_DMA; 1610 ata_pktp->ap_pciide_dma = TRUE; 1611 ata_pktp->ap_start = ata_disk_start_dma_out; 1612 ata_pktp->ap_intr = ata_disk_intr_dma; 1613 } else { 1614 ata_pktp->ap_cmd = ATC_WRSEC; 1615 ata_pktp->ap_start = ata_disk_start_pio_out; 1616 ata_pktp->ap_intr = ata_disk_intr_pio_out; 1617 } 1618 ata_pktp->ap_flags |= AP_WRITE; 1619 break; 1620 } 1621 1622 byte_count = RWCMDP(pktp)->buflen; 1623 pktp->cp_bytexfer = byte_count; 1624 pktp->cp_resid = byte_count; 1625 ata_pktp->ap_resid = byte_count; 1626 1627 /* 1628 * since we're not using READ/WRITE MULTIPLE, we 1629 * should set bytes_per_block to one sector 1630 * XXX- why wasn't this in the old driver?? 1631 */ 1632 ata_pktp->ap_bytes_per_block = NBPSCTR; 1633 } else 1634 #endif 1635 { 1636 byte_count = sec_count << SCTRSHFT; 1637 pktp->cp_bytexfer = byte_count; 1638 pktp->cp_resid = byte_count; 1639 ata_pktp->ap_resid = byte_count; 1640 1641 /* setup the task file registers */ 1642 1643 switch (ata_pktp->ap_cdb) { 1644 case DCMD_READ: 1645 if (ata_pktp->ap_sg_cnt) { 1646 ata_pktp->ap_cmd = ATC_READ_DMA; 1647 ata_pktp->ap_pciide_dma = TRUE; 1648 ata_pktp->ap_start = ata_disk_start_dma_in; 1649 ata_pktp->ap_intr = ata_disk_intr_dma; 1650 } else { 1651 ata_pktp->ap_cmd = ata_drvp->ad_rd_cmd; 1652 ata_pktp->ap_start = ata_disk_start_pio_in; 1653 ata_pktp->ap_intr = ata_disk_intr_pio_in; 1654 } 1655 ata_pktp->ap_flags |= AP_READ; 1656 break; 1657 1658 case DCMD_WRITE: 1659 if (ata_pktp->ap_sg_cnt) { 1660 ata_pktp->ap_cmd = ATC_WRITE_DMA; 1661 ata_pktp->ap_pciide_dma = TRUE; 1662 ata_pktp->ap_start = ata_disk_start_dma_out; 1663 ata_pktp->ap_intr = ata_disk_intr_dma; 1664 } else { 1665 ata_pktp->ap_cmd = ata_drvp->ad_wr_cmd; 1666 ata_pktp->ap_start = ata_disk_start_pio_out; 1667 ata_pktp->ap_intr = ata_disk_intr_pio_out; 1668 } 1669 ata_pktp->ap_flags |= AP_WRITE; 1670 break; 1671 1672 default: 1673 ADBG_WARN(("ata_disk_iosetup: unknown command 0x%x\n", 1674 ata_pktp->ap_cdb)); 1675 pktp = NULL; 1676 break; 1677 } 1678 } 1679 1680 /* If 48-bit mode is used, convert command to 48-bit mode cmd */ 1681 if (pktp != NULL && ata_drvp->ad_flags & AD_EXT48) { 1682 switch (ata_pktp->ap_cmd) { 1683 case ATC_RDSEC: 1684 ata_pktp->ap_cmd = ATC_RDSEC_EXT; 1685 break; 1686 case ATC_WRSEC: 1687 ata_pktp->ap_cmd = ATC_WRSEC_EXT; 1688 break; 1689 case ATC_RDMULT: 1690 ata_pktp->ap_cmd = ATC_RDMULT_EXT; 1691 break; 1692 case ATC_WRMULT: 1693 ata_pktp->ap_cmd = ATC_WRMULT_EXT; 1694 break; 1695 case ATC_READ_DMA: 1696 ata_pktp->ap_cmd = ATC_RDDMA_EXT; 1697 break; 1698 case ATC_WRITE_DMA: 1699 ata_pktp->ap_cmd = ATC_WRDMA_EXT; 1700 break; 1701 } 1702 } 1703 1704 return (pktp); 1705 } 1706 1707 1708 1709 /* 1710 * 1711 * DADA transport entry point 1712 * 1713 */ 1714 1715 static int 1716 ata_disk_transport(opaque_t ctl_data, cmpkt_t *pktp) 1717 { 1718 gtgt_t *gtgtp = (gtgt_t *)ctl_data; 1719 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp); 1720 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; 1721 ata_pkt_t *ata_pktp = CPKT2APKT(pktp); 1722 int rc; 1723 int polled = FALSE; 1724 1725 ADBG_TRACE(("ata_disk_transport entered\n")); 1726 1727 /* check for polling pkt */ 1728 1729 if (pktp->cp_flags & CPF_NOINTR) { 1730 polled = TRUE; 1731 } 1732 1733 /* call ghd transport routine */ 1734 1735 rc = ghd_transport(&ata_ctlp->ac_ccc, APKT2GCMD(ata_pktp), 1736 gtgtp, pktp->cp_time, polled, NULL); 1737 1738 /* see if pkt was not accepted */ 1739 1740 if (rc == TRAN_BUSY) 1741 return (CTL_SEND_BUSY); 1742 1743 if (rc == TRAN_ACCEPT) 1744 return (CTL_SEND_SUCCESS); 1745 1746 return (CTL_SEND_FAILURE); 1747 } 1748 1749 1750 /* 1751 * 1752 * routines to load the cylinder/head/sector/count 1753 * task file registers. 1754 * 1755 */ 1756 static void 1757 ata_disk_load_regs_lba28(ata_pkt_t *ata_pktp, ata_drv_t *ata_drvp) 1758 { 1759 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; 1760 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 1761 uint_t lba; /* LBA of first sector */ 1762 1763 lba = ata_pktp->ap_startsec; 1764 1765 ddi_put8(io_hdl1, ata_ctlp->ac_count, 1766 ata_pktp->ap_count); 1767 ddi_put8(io_hdl1, ata_ctlp->ac_sect, lba); 1768 lba >>= 8; 1769 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, lba); 1770 lba >>= 8; 1771 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, lba); 1772 lba >>= 8; 1773 /* 1774 * dev/head register can use only 4 bits 1775 * must also include drive selector. 1776 */ 1777 lba = (lba & 0xf) | ata_drvp->ad_drive_bits; 1778 ddi_put8(io_hdl1, ata_ctlp->ac_drvhd, lba); 1779 } 1780 1781 /* 1782 * In 48-bit extended mode, the sector count is 16 bits wide, and the 1783 * LBA is 48 bits wide, as follows: 1784 * register most recent previous 1785 * name value value 1786 * -------- ---------- --------- 1787 * sector cnt count(7:0) count(15:8) 1788 * sector num lba(7:0) lba(31:24) 1789 * cyl low lba(15:8) lba(39:32) 1790 * cyl hi lba(23:16) lba(47:40) 1791 * device/head 111D0000 N/A 1792 * ^ ^ 1793 * | | 1794 * | +-- drive number 1795 * | 1796 * +-- indicates LBA 1797 * The other two 1 bits are historical and are not used in 48bit 1798 * extended mode. 1799 */ 1800 /* 1801 * WARNING: 1802 * dada framework passes starting sector as daddr_t type, thus 1803 * limiting reachable disk space in 32-bit x86 architecture to 1 terabyte. 1804 * Therefore high 16 bits of the 48-bits address can be and 1805 * are currently ignored. 1806 */ 1807 static void 1808 ata_disk_load_regs_lba48(ata_pkt_t *ata_pktp, ata_drv_t *ata_drvp) 1809 { 1810 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; 1811 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 1812 uint16_t seccnt; /* 16-bit sector count */ 1813 uint_t lbalow; /* low-order 24 bits of LBA */ 1814 uint_t lbahi; /* high-order 24 bits of LBA */ 1815 1816 seccnt = ata_pktp->ap_count; 1817 /* high-order 8 bits of lbalow never get used */ 1818 lbalow = ata_pktp->ap_startsec; 1819 lbahi = ata_pktp->ap_startsec >> 24; 1820 1821 ddi_put8(io_hdl1, ata_ctlp->ac_count, seccnt >> 8); 1822 ddi_put8(io_hdl1, ata_ctlp->ac_count, seccnt); 1823 /* Send the high-order half first */ 1824 ddi_put8(io_hdl1, ata_ctlp->ac_sect, lbahi); 1825 lbahi >>= 8; 1826 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, lbahi); 1827 lbahi >>= 8; 1828 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, lbahi); 1829 /* Send the low-order half */ 1830 ddi_put8(io_hdl1, ata_ctlp->ac_sect, lbalow); 1831 lbalow >>= 8; 1832 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, lbalow); 1833 lbalow >>= 8; 1834 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, lbalow); 1835 ddi_put8(io_hdl1, ata_ctlp->ac_drvhd, 1836 ata_drvp->ad_drive_bits); 1837 } 1838 1839 static void 1840 ata_disk_load_regs_chs(ata_pkt_t *ata_pktp, ata_drv_t *ata_drvp) 1841 { 1842 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; 1843 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 1844 uint_t resid; 1845 uint_t cyl; 1846 uchar_t head; 1847 uchar_t drvheads; 1848 uchar_t drvsectors; 1849 1850 drvheads = ata_drvp->ad_phhd; 1851 drvsectors = ata_drvp->ad_phsec; 1852 1853 resid = ata_pktp->ap_startsec / drvsectors; 1854 head = (resid % drvheads) & 0xf; 1855 cyl = resid / drvheads; 1856 /* automatically truncate to char */ 1857 ddi_put8(io_hdl1, ata_ctlp->ac_sect, 1858 (ata_pktp->ap_startsec % drvsectors) + 1); 1859 ddi_put8(io_hdl1, ata_ctlp->ac_count, ata_pktp->ap_count); 1860 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, (cyl >> 8)); 1861 /* lcyl gets truncated to 8 bits */ 1862 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, cyl); 1863 ddi_put8(io_hdl1, ata_ctlp->ac_drvhd, 1864 ata_drvp->ad_drive_bits | head); 1865 } 1866 1867 1868 /* 1869 * 1870 * packet start callback routines 1871 * 1872 */ 1873 1874 /* ARGSUSED */ 1875 static int 1876 ata_disk_start_common( 1877 ata_ctl_t *ata_ctlp, 1878 ata_drv_t *ata_drvp, 1879 ata_pkt_t *ata_pktp) 1880 { 1881 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 1882 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2; 1883 1884 ADBG_TRACE(("ata_disk_start_common entered\n")); 1885 1886 ADBG_TRANSPORT(("ata_disk_start:\tpkt = 0x%p, pkt flags = 0x%x\n", 1887 ata_pktp, ata_pktp->ap_flags)); 1888 ADBG_TRANSPORT(("\tcommand=0x%x, sect=0x%lx\n", 1889 ata_pktp->ap_cmd, ata_pktp->ap_startsec)); 1890 ADBG_TRANSPORT(("\tcount=0x%x, drvhd = 0x%x\n", 1891 ata_pktp->ap_count, ata_drvp->ad_drive_bits)); 1892 1893 /* 1894 * If AC_BSY_WAIT is set, wait for controller to not be busy, 1895 * before issuing a command. If AC_BSY_WAIT is not set, 1896 * skip the wait. This is important for laptops that do 1897 * suspend/resume but do not correctly wait for the busy bit to 1898 * drop after a resume. 1899 * 1900 * NOTE: this test for ATS_BSY is also needed if/when we 1901 * implement the overlapped/queued command protocols. Currently, 1902 * the overlap/queued feature is not supported so the test is 1903 * conditional. 1904 */ 1905 if (ata_ctlp->ac_timing_flags & AC_BSY_WAIT) { 1906 if (!ata_wait(io_hdl2, ata_ctlp->ac_ioaddr2, 1907 0, ATS_BSY, 5000000)) { 1908 ADBG_ERROR(("ata_disk_start: BUSY\n")); 1909 return (FALSE); 1910 } 1911 } 1912 1913 ddi_put8(io_hdl1, ata_ctlp->ac_drvhd, ata_drvp->ad_drive_bits); 1914 ata_nsecwait(400); 1915 1916 /* 1917 * make certain the drive selected 1918 */ 1919 if (!ata_wait(io_hdl2, ata_ctlp->ac_ioaddr2, 1920 ATS_DRDY, ATS_BSY, 5 * 1000000)) { 1921 ADBG_ERROR(("ata_disk_start: select failed\n")); 1922 return (FALSE); 1923 } 1924 1925 if (ata_pktp->ap_cmd == ATC_LOAD_FW) { 1926 1927 /* the sector count is 16 bits wide */ 1928 ddi_put8(io_hdl1, ata_ctlp->ac_count, ata_pktp->ap_count); 1929 ddi_put8(io_hdl1, ata_ctlp->ac_sect, ata_pktp->ap_count >> 8); 1930 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, ata_pktp->ap_startsec); 1931 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, 1932 ata_pktp->ap_startsec >> 8); 1933 1934 /* put subcommand for DOWNLOAD MICROCODE */ 1935 ddi_put8(io_hdl1, ata_ctlp->ac_feature, ata_pktp->ap_bcount); 1936 } else { 1937 1938 /* 1939 * We use different methods for loading the task file 1940 * registers, depending on whether the disk 1941 * uses LBA or CHS addressing and whether 48-bit 1942 * extended addressing is to be used. 1943 */ 1944 if (!(ata_drvp->ad_drive_bits & ATDH_LBA)) 1945 ata_disk_load_regs_chs(ata_pktp, ata_drvp); 1946 else if (ata_drvp->ad_flags & AD_EXT48) 1947 ata_disk_load_regs_lba48(ata_pktp, ata_drvp); 1948 else 1949 ata_disk_load_regs_lba28(ata_pktp, ata_drvp); 1950 ddi_put8(io_hdl1, ata_ctlp->ac_feature, 0); 1951 } 1952 1953 /* 1954 * Always make certain interrupts are enabled. It's been reported 1955 * (but not confirmed) that some notebook computers don't 1956 * clear the interrupt disable bit after being resumed. The 1957 * easiest way to fix this is to always clear the disable bit 1958 * before every command. 1959 */ 1960 ddi_put8(io_hdl2, ata_ctlp->ac_devctl, ATDC_D3); 1961 return (TRUE); 1962 } 1963 1964 1965 /* 1966 * 1967 * Start a non-data ATA command (not DMA and not PIO): 1968 * 1969 */ 1970 1971 static int 1972 ata_disk_start( 1973 ata_ctl_t *ata_ctlp, 1974 ata_drv_t *ata_drvp, 1975 ata_pkt_t *ata_pktp) 1976 { 1977 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 1978 int rc; 1979 1980 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp); 1981 1982 if (!rc) 1983 return (ATA_FSM_RC_BUSY); 1984 1985 /* 1986 * This next one sets the controller in motion 1987 */ 1988 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd); 1989 1990 /* wait for the busy bit to settle */ 1991 ata_nsecwait(400); 1992 1993 return (ATA_FSM_RC_OKAY); 1994 } 1995 1996 1997 1998 static int 1999 ata_disk_start_dma_in( 2000 ata_ctl_t *ata_ctlp, 2001 ata_drv_t *ata_drvp, 2002 ata_pkt_t *ata_pktp) 2003 { 2004 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2005 int rc; 2006 2007 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp); 2008 2009 if (!rc) 2010 return (ATA_FSM_RC_BUSY); 2011 2012 /* 2013 * Copy the Scatter/Gather list to the controller's 2014 * Physical Region Descriptor Table 2015 */ 2016 ata_pciide_dma_setup(ata_ctlp, ata_pktp->ap_sg_list, 2017 ata_pktp->ap_sg_cnt); 2018 2019 /* 2020 * reset the PCIIDE Controller's interrupt and error status bits 2021 */ 2022 (void) ata_pciide_status_clear(ata_ctlp); 2023 2024 /* 2025 * This next one sets the drive in motion 2026 */ 2027 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd); 2028 2029 /* wait for the drive's busy bit to settle */ 2030 ata_nsecwait(400); 2031 2032 ata_pciide_dma_start(ata_ctlp, PCIIDE_BMICX_RWCON_WRITE_TO_MEMORY); 2033 2034 return (ATA_FSM_RC_OKAY); 2035 } 2036 2037 2038 2039 static int 2040 ata_disk_start_dma_out( 2041 ata_ctl_t *ata_ctlp, 2042 ata_drv_t *ata_drvp, 2043 ata_pkt_t *ata_pktp) 2044 { 2045 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2046 int rc; 2047 2048 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp); 2049 2050 if (!rc) 2051 return (ATA_FSM_RC_BUSY); 2052 2053 /* 2054 * Copy the Scatter/Gather list to the controller's 2055 * Physical Region Descriptor Table 2056 */ 2057 ata_pciide_dma_setup(ata_ctlp, ata_pktp->ap_sg_list, 2058 ata_pktp->ap_sg_cnt); 2059 2060 /* 2061 * reset the PCIIDE Controller's interrupt and error status bits 2062 */ 2063 (void) ata_pciide_status_clear(ata_ctlp); 2064 2065 /* 2066 * This next one sets the drive in motion 2067 */ 2068 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd); 2069 2070 /* wait for the drive's busy bit to settle */ 2071 ata_nsecwait(400); 2072 2073 ata_pciide_dma_start(ata_ctlp, PCIIDE_BMICX_RWCON_READ_FROM_MEMORY); 2074 2075 return (ATA_FSM_RC_OKAY); 2076 } 2077 2078 2079 2080 2081 2082 /* 2083 * 2084 * Start a PIO data-in ATA command: 2085 * 2086 */ 2087 2088 static int 2089 ata_disk_start_pio_in( 2090 ata_ctl_t *ata_ctlp, 2091 ata_drv_t *ata_drvp, 2092 ata_pkt_t *ata_pktp) 2093 { 2094 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2095 int rc; 2096 2097 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp); 2098 2099 if (!rc) 2100 return (ATA_FSM_RC_BUSY); 2101 /* 2102 * This next one sets the controller in motion 2103 */ 2104 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd); 2105 2106 /* wait for the busy bit to settle */ 2107 ata_nsecwait(400); 2108 2109 return (ATA_FSM_RC_OKAY); 2110 } 2111 2112 2113 2114 2115 /* 2116 * 2117 * Start a PIO data-out ATA command: 2118 * 2119 */ 2120 2121 static int 2122 ata_disk_start_pio_out( 2123 ata_ctl_t *ata_ctlp, 2124 ata_drv_t *ata_drvp, 2125 ata_pkt_t *ata_pktp) 2126 { 2127 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2128 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2; 2129 int rc; 2130 2131 ata_pktp->ap_wrt_count = 0; 2132 2133 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp); 2134 2135 if (!rc) 2136 return (ATA_FSM_RC_BUSY); 2137 /* 2138 * This next one sets the controller in motion 2139 */ 2140 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd); 2141 2142 /* wait for the busy bit to settle */ 2143 ata_nsecwait(400); 2144 2145 /* 2146 * Wait for the drive to assert DRQ to send the first chunk 2147 * of data. Have to busy wait because there's no interrupt for 2148 * the first chunk. This sucks (a lot of cycles) if the 2149 * drive responds too slowly or if the wait loop granularity 2150 * is too large. It's really bad if the drive is defective and 2151 * the loop times out. 2152 */ 2153 2154 if (!ata_wait3(io_hdl2, ata_ctlp->ac_ioaddr2, 2155 ATS_DRQ, ATS_BSY, /* okay */ 2156 ATS_ERR, ATS_BSY, /* cmd failed */ 2157 ATS_DF, ATS_BSY, /* drive failed */ 2158 4000000)) { 2159 ADBG_WARN(("ata_disk_start_pio_out: no DRQ\n")); 2160 ata_pktp->ap_flags |= AP_ERROR; 2161 return (ATA_FSM_RC_INTR); 2162 } 2163 2164 /* 2165 * Tell the upper layer to fake a hardware interrupt which 2166 * actually causes the first segment to be written to the drive. 2167 */ 2168 return (ATA_FSM_RC_INTR); 2169 } 2170 2171 2172 2173 /* 2174 * 2175 * packet complete callback routine 2176 * 2177 */ 2178 2179 static void 2180 ata_disk_complete( 2181 ata_drv_t *ata_drvp, 2182 ata_pkt_t *ata_pktp, 2183 int do_callback) 2184 { 2185 struct ata_id *aidp = &ata_drvp->ad_id; 2186 cmpkt_t *pktp; 2187 2188 ADBG_TRACE(("ata_disk_complete entered\n")); 2189 ADBG_TRANSPORT(("ata_disk_complete: pkt = 0x%p\n", ata_pktp)); 2190 2191 pktp = APKT2CPKT(ata_pktp); 2192 2193 /* update resid */ 2194 2195 pktp->cp_resid = ata_pktp->ap_resid; 2196 2197 if (ata_pktp->ap_flags & AP_ERROR) { 2198 2199 pktp->cp_reason = CPS_CHKERR; 2200 2201 if (ata_pktp->ap_error & ATE_BBK_ICRC) { 2202 if (IS_ATA_VERSION_GE(aidp, 4)) 2203 ata_pktp->ap_scb = DERR_ICRC; 2204 else 2205 ata_pktp->ap_scb = DERR_BBK; 2206 } else if (ata_pktp->ap_error & ATE_UNC) 2207 ata_pktp->ap_scb = DERR_UNC; 2208 else if (ata_pktp->ap_error & ATE_IDNF) 2209 ata_pktp->ap_scb = DERR_IDNF; 2210 else if (ata_pktp->ap_error & ATE_TKONF) 2211 ata_pktp->ap_scb = DERR_TKONF; 2212 else if (ata_pktp->ap_error & ATE_AMNF) 2213 ata_pktp->ap_scb = DERR_AMNF; 2214 else if (ata_pktp->ap_status & ATS_BSY) 2215 ata_pktp->ap_scb = DERR_BUSY; 2216 else if (ata_pktp->ap_status & ATS_DF) 2217 ata_pktp->ap_scb = DERR_DWF; 2218 else /* any unknown error */ 2219 ata_pktp->ap_scb = DERR_ABORT; 2220 } else if (ata_pktp->ap_flags & 2221 (AP_ABORT|AP_TIMEOUT|AP_BUS_RESET)) { 2222 2223 pktp->cp_reason = CPS_CHKERR; 2224 ata_pktp->ap_scb = DERR_ABORT; 2225 } else { 2226 pktp->cp_reason = CPS_SUCCESS; 2227 ata_pktp->ap_scb = DERR_SUCCESS; 2228 } 2229 2230 /* callback */ 2231 if (do_callback) 2232 (*pktp->cp_callback)(pktp); 2233 } 2234 2235 2236 /* 2237 * 2238 * Interrupt callbacks 2239 * 2240 */ 2241 2242 2243 /* 2244 * 2245 * ATA command, no data 2246 * 2247 */ 2248 2249 /* ARGSUSED */ 2250 static int 2251 ata_disk_intr( 2252 ata_ctl_t *ata_ctlp, 2253 ata_drv_t *ata_drvp, 2254 ata_pkt_t *ata_pktp) 2255 { 2256 uchar_t status; 2257 2258 ADBG_TRACE(("ata_disk_intr entered\n")); 2259 ADBG_TRANSPORT(("ata_disk_intr: pkt = 0x%p\n", ata_pktp)); 2260 2261 status = ata_get_status_clear_intr(ata_ctlp, ata_pktp); 2262 2263 ASSERT((status & (ATS_BSY | ATS_DRQ)) == 0); 2264 2265 /* 2266 * check for errors 2267 */ 2268 2269 if (status & (ATS_DF | ATS_ERR)) { 2270 ADBG_WARN(("ata_disk_intr: status 0x%x error 0x%x\n", status, 2271 ddi_get8(ata_ctlp->ac_iohandle1, ata_ctlp->ac_error))); 2272 ata_pktp->ap_flags |= AP_ERROR; 2273 } 2274 2275 if (ata_pktp->ap_flags & AP_ERROR) { 2276 ata_pktp->ap_status = ddi_get8(ata_ctlp->ac_iohandle2, 2277 ata_ctlp->ac_altstatus); 2278 ata_pktp->ap_error = ddi_get8(ata_ctlp->ac_iohandle1, 2279 ata_ctlp->ac_error); 2280 } 2281 2282 /* tell the upper layer this request is complete */ 2283 return (ATA_FSM_RC_FINI); 2284 } 2285 2286 2287 /* 2288 * 2289 * ATA command, PIO data in 2290 * 2291 */ 2292 2293 /* ARGSUSED */ 2294 static int 2295 ata_disk_intr_pio_in( 2296 ata_ctl_t *ata_ctlp, 2297 ata_drv_t *ata_drvp, 2298 ata_pkt_t *ata_pktp) 2299 { 2300 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2301 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2; 2302 uchar_t status; 2303 2304 ADBG_TRACE(("ata_disk_pio_in entered\n")); 2305 ADBG_TRANSPORT(("ata_disk_pio_in: pkt = 0x%p\n", ata_pktp)); 2306 2307 /* 2308 * first make certain DRQ is asserted (and no errors) 2309 */ 2310 (void) ata_wait3(io_hdl2, ata_ctlp->ac_ioaddr2, 2311 ATS_DRQ, ATS_BSY, ATS_ERR, ATS_BSY, ATS_DF, ATS_BSY, 2312 4000000); 2313 2314 status = ata_get_status_clear_intr(ata_ctlp, ata_pktp); 2315 2316 if (status & ATS_BSY) { 2317 ADBG_WARN(("ata_disk_pio_in: BUSY\n")); 2318 ata_pktp->ap_flags |= AP_ERROR; 2319 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2320 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error); 2321 return (ATA_FSM_RC_BUSY); 2322 } 2323 2324 /* 2325 * record any errors 2326 */ 2327 if ((status & (ATS_DRQ | ATS_DF | ATS_ERR)) != ATS_DRQ) { 2328 ADBG_WARN(("ata_disk_pio_in: status 0x%x error 0x%x\n", 2329 status, ddi_get8(io_hdl1, ata_ctlp->ac_error))); 2330 ata_pktp->ap_flags |= AP_ERROR; 2331 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2332 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error); 2333 } 2334 2335 /* 2336 * read the next chunk of data (if any) 2337 */ 2338 if (status & ATS_DRQ) { 2339 ata_disk_pio_xfer_data_in(ata_ctlp, ata_pktp); 2340 } 2341 2342 /* 2343 * If that was the last chunk, wait for the device to clear DRQ 2344 */ 2345 if (ata_pktp->ap_resid == 0) { 2346 if (ata_wait(io_hdl2, ata_ctlp->ac_ioaddr2, 2347 0, (ATS_DRQ | ATS_BSY), 4000000)) { 2348 /* tell the upper layer this request is complete */ 2349 return (ATA_FSM_RC_FINI); 2350 } 2351 2352 ADBG_WARN(("ata_disk_pio_in: DRQ stuck\n")); 2353 ata_pktp->ap_flags |= AP_ERROR; 2354 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2355 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error); 2356 } 2357 2358 /* 2359 * check for errors 2360 */ 2361 if (ata_pktp->ap_flags & AP_ERROR) { 2362 return (ATA_FSM_RC_FINI); 2363 } 2364 2365 /* 2366 * If the read command isn't done yet, 2367 * wait for the next interrupt. 2368 */ 2369 ADBG_TRACE(("ata_disk_pio_in: partial\n")); 2370 return (ATA_FSM_RC_OKAY); 2371 } 2372 2373 2374 2375 /* 2376 * 2377 * ATA command, PIO data out 2378 * 2379 */ 2380 2381 /* ARGSUSED */ 2382 static int 2383 ata_disk_intr_pio_out( 2384 ata_ctl_t *ata_ctlp, 2385 ata_drv_t *ata_drvp, 2386 ata_pkt_t *ata_pktp) 2387 { 2388 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2389 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2; 2390 int tmp_count = ata_pktp->ap_wrt_count; 2391 uchar_t status; 2392 2393 /* 2394 * clear the IRQ 2395 */ 2396 status = ata_get_status_clear_intr(ata_ctlp, ata_pktp); 2397 2398 ADBG_TRACE(("ata_disk_intr_pio_out entered\n")); 2399 ADBG_TRANSPORT(("ata_disk_intr_pio_out: pkt = 0x%p\n", ata_pktp)); 2400 2401 ASSERT(!(status & ATS_BSY)); 2402 2403 2404 /* 2405 * check for errors 2406 */ 2407 2408 if (status & (ATS_DF | ATS_ERR)) { 2409 ADBG_WARN(("ata_disk_intr_pio_out: status 0x%x error 0x%x\n", 2410 status, ddi_get8(io_hdl1, ata_ctlp->ac_error))); 2411 ata_pktp->ap_flags |= AP_ERROR; 2412 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2413 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error); 2414 /* tell the upper layer this request is complete */ 2415 return (ATA_FSM_RC_FINI); 2416 } 2417 2418 2419 /* 2420 * last write was okay, bump the ptr and 2421 * decr the resid count 2422 */ 2423 ata_pktp->ap_v_addr += tmp_count; 2424 ata_pktp->ap_resid -= tmp_count; 2425 2426 /* 2427 * check for final interrupt on write command 2428 */ 2429 if (ata_pktp->ap_resid == 0) { 2430 /* tell the upper layer this request is complete */ 2431 return (ATA_FSM_RC_FINI); 2432 } 2433 2434 /* 2435 * Perform the next data transfer 2436 * 2437 * First make certain DRQ is asserted and no error status. 2438 * (I'm not certain but I think some drives might deassert BSY 2439 * before asserting DRQ. This extra ata_wait3() will 2440 * compensate for such drives). 2441 * 2442 */ 2443 (void) ata_wait3(io_hdl2, ata_ctlp->ac_ioaddr2, 2444 ATS_DRQ, ATS_BSY, ATS_ERR, ATS_BSY, ATS_DF, ATS_BSY, 4000000); 2445 2446 status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2447 2448 if (status & ATS_BSY) { 2449 /* this should never happen */ 2450 ADBG_WARN(("ata_disk_intr_pio_out: BUSY\n")); 2451 ata_pktp->ap_flags |= AP_ERROR; 2452 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2453 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error); 2454 return (ATA_FSM_RC_BUSY); 2455 } 2456 2457 /* 2458 * bailout if any errors 2459 */ 2460 if ((status & (ATS_DRQ | ATS_DF | ATS_ERR)) != ATS_DRQ) { 2461 ADBG_WARN(("ata_disk_pio_out: status 0x%x error 0x%x\n", 2462 status, ddi_get8(io_hdl1, ata_ctlp->ac_error))); 2463 ata_pktp->ap_flags |= AP_ERROR; 2464 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2465 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error); 2466 return (ATA_FSM_RC_FINI); 2467 } 2468 2469 /* 2470 * write the next chunk of data 2471 */ 2472 ADBG_TRACE(("ata_disk_intr_pio_out: write xfer\n")); 2473 ata_disk_pio_xfer_data_out(ata_ctlp, ata_pktp); 2474 2475 /* 2476 * Wait for the next interrupt before checking the transfer 2477 * status and adjusting the transfer count. 2478 * 2479 */ 2480 return (ATA_FSM_RC_OKAY); 2481 } 2482 2483 2484 /* 2485 * 2486 * ATA command, DMA data in/out 2487 * 2488 */ 2489 2490 static int 2491 ata_disk_intr_dma( 2492 ata_ctl_t *ata_ctlp, 2493 ata_drv_t *ata_drvp, 2494 ata_pkt_t *ata_pktp) 2495 { 2496 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2497 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2; 2498 uchar_t status; 2499 2500 ADBG_TRACE(("ata_disk_intr_dma entered\n")); 2501 ADBG_TRANSPORT(("ata_disk_intr_dma: pkt = 0x%p\n", ata_pktp)); 2502 2503 /* 2504 * halt the DMA engine 2505 */ 2506 ata_pciide_dma_stop(ata_ctlp); 2507 2508 /* 2509 * wait for the device to clear DRQ 2510 */ 2511 if (!ata_wait(io_hdl2, ata_ctlp->ac_ioaddr2, 2512 0, (ATS_DRQ | ATS_BSY), 4000000)) { 2513 ADBG_WARN(("ata_disk_intr_dma: DRQ stuck\n")); 2514 ata_pktp->ap_flags |= AP_ERROR; 2515 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2516 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error); 2517 return (ATA_FSM_RC_BUSY); 2518 } 2519 2520 /* 2521 * get the status and clear the IRQ, and check for DMA error 2522 */ 2523 status = ata_get_status_clear_intr(ata_ctlp, ata_pktp); 2524 2525 /* 2526 * check for drive errors 2527 */ 2528 2529 if (status & (ATS_DF | ATS_ERR)) { 2530 ADBG_WARN(("ata_disk_intr_dma: status 0x%x error 0x%x\n", 2531 status, ddi_get8(io_hdl1, ata_ctlp->ac_error))); 2532 ata_pktp->ap_flags |= AP_ERROR; 2533 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus); 2534 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error); 2535 } 2536 2537 /* 2538 * If there was a drive or DMA error, compute a resid count 2539 */ 2540 if (ata_pktp->ap_flags & AP_ERROR) { 2541 /* 2542 * grab the last sector address from the drive regs 2543 * and use that to compute the resid 2544 */ 2545 ata_disk_get_resid(ata_ctlp, ata_drvp, ata_pktp); 2546 } else { 2547 ata_pktp->ap_resid = 0; 2548 } 2549 2550 /* tell the upper layer this request is complete */ 2551 return (ATA_FSM_RC_FINI); 2552 } 2553 2554 2555 /* 2556 * 2557 * Low level PIO routine that transfers data from the drive 2558 * 2559 */ 2560 2561 static void 2562 ata_disk_pio_xfer_data_in( 2563 ata_ctl_t *ata_ctlp, 2564 ata_pkt_t *ata_pktp) 2565 { 2566 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2567 int count; 2568 2569 count = min(ata_pktp->ap_resid, 2570 ata_pktp->ap_bytes_per_block); 2571 2572 ADBG_TRANSPORT(("ata_disk_pio_xfer_data_in: 0x%x bytes, addr = 0x%p\n", 2573 count, ata_pktp->ap_v_addr)); 2574 2575 /* 2576 * read count bytes 2577 */ 2578 2579 ASSERT(count != 0); 2580 2581 ddi_rep_get16(io_hdl1, (ushort_t *)ata_pktp->ap_v_addr, 2582 ata_ctlp->ac_data, (count >> 1), DDI_DEV_NO_AUTOINCR); 2583 2584 /* wait for the busy bit to settle */ 2585 ata_nsecwait(400); 2586 2587 /* 2588 * this read command completed okay, bump the ptr and 2589 * decr the resid count now. 2590 */ 2591 ata_pktp->ap_v_addr += count; 2592 ata_pktp->ap_resid -= count; 2593 } 2594 2595 2596 /* 2597 * 2598 * Low level PIO routine that transfers data to the drive 2599 * 2600 */ 2601 2602 static void 2603 ata_disk_pio_xfer_data_out( 2604 ata_ctl_t *ata_ctlp, 2605 ata_pkt_t *ata_pktp) 2606 { 2607 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2608 int count; 2609 2610 count = min(ata_pktp->ap_resid, 2611 ata_pktp->ap_bytes_per_block); 2612 2613 ADBG_TRANSPORT(("ata_disk_pio_xfer_data_out: 0x%x bytes, addr = 0x%p\n", 2614 count, ata_pktp->ap_v_addr)); 2615 2616 /* 2617 * read or write count bytes 2618 */ 2619 2620 ASSERT(count != 0); 2621 2622 ddi_rep_put16(io_hdl1, (ushort_t *)ata_pktp->ap_v_addr, 2623 ata_ctlp->ac_data, (count >> 1), DDI_DEV_NO_AUTOINCR); 2624 2625 /* wait for the busy bit to settle */ 2626 ata_nsecwait(400); 2627 2628 /* 2629 * save the count here so I can correctly adjust 2630 * the ap_v_addr and ap_resid values at the next 2631 * interrupt. 2632 */ 2633 ata_pktp->ap_wrt_count = count; 2634 } 2635 2636 2637 /* 2638 * 2639 * ATA Initialize Device Parameters (aka Set Params) command 2640 * 2641 * If the drive was put in some sort of CHS extended/logical geometry 2642 * mode by the BIOS, this function will reset it to its "native" 2643 * CHS geometry. This ensures that we don't run into any sort of 2644 * 1024 cylinder (or 65535 cylinder) limitation that may have been 2645 * created by a BIOS (or users) that chooses a bogus translated geometry. 2646 */ 2647 2648 static int 2649 ata_disk_initialize_device_parameters( 2650 ata_ctl_t *ata_ctlp, 2651 ata_drv_t *ata_drvp) 2652 { 2653 int rc; 2654 2655 rc = ata_command(ata_ctlp, ata_drvp, FALSE, FALSE, 2656 ata_disk_init_dev_parm_wait, 2657 ATC_SETPARAM, 2658 0, /* feature n/a */ 2659 ata_drvp->ad_phsec, /* max sector (1-based) */ 2660 0, /* sector n/a */ 2661 (ata_drvp->ad_phhd -1), /* max head (0-based) */ 2662 0, /* cyl_low n/a */ 2663 0); /* cyl_hi n/a */ 2664 2665 if (rc) 2666 return (TRUE); 2667 2668 ADBG_ERROR(("ata_init_dev_parms: failed\n")); 2669 return (FALSE); 2670 } 2671 2672 2673 2674 /* 2675 * 2676 * create fake inquiry data for DADA interface 2677 * 2678 */ 2679 2680 static void 2681 ata_disk_fake_inquiry( 2682 ata_drv_t *ata_drvp) 2683 { 2684 struct ata_id *ata_idp = &ata_drvp->ad_id; 2685 struct scsi_inquiry *inqp = &ata_drvp->ad_inquiry; 2686 2687 ADBG_TRACE(("ata_disk_fake_inquiry entered\n")); 2688 2689 if (ata_idp->ai_config & ATA_ID_REM_DRV) /* ide removable bit */ 2690 inqp->inq_rmb = 1; /* scsi removable bit */ 2691 2692 (void) strncpy(inqp->inq_vid, "Gen-ATA ", sizeof (inqp->inq_vid)); 2693 inqp->inq_dtype = DTYPE_DIRECT; 2694 inqp->inq_qual = DPQ_POSSIBLE; 2695 2696 (void) strncpy(inqp->inq_pid, ata_idp->ai_model, 2697 sizeof (inqp->inq_pid)); 2698 (void) strncpy(inqp->inq_revision, ata_idp->ai_fw, 2699 sizeof (inqp->inq_revision)); 2700 } 2701 2702 #define LOOP_COUNT 10000 2703 2704 2705 /* 2706 * 2707 * ATA Set Multiple Mode 2708 * 2709 */ 2710 2711 static int 2712 ata_disk_set_multiple( 2713 ata_ctl_t *ata_ctlp, 2714 ata_drv_t *ata_drvp) 2715 { 2716 int rc; 2717 2718 rc = ata_command(ata_ctlp, ata_drvp, TRUE, FALSE, 2719 ata_disk_set_mult_wait, 2720 ATC_SETMULT, 2721 0, /* feature n/a */ 2722 ata_drvp->ad_block_factor, /* count */ 2723 0, /* sector n/a */ 2724 0, /* head n/a */ 2725 0, /* cyl_low n/a */ 2726 0); /* cyl_hi n/a */ 2727 2728 if (rc) { 2729 return (TRUE); 2730 } 2731 2732 ADBG_ERROR(("ata_disk_set_multiple: failed\n")); 2733 return (FALSE); 2734 } 2735 2736 2737 /* 2738 * 2739 * ATA Identify Device command 2740 * 2741 */ 2742 2743 int 2744 ata_disk_id( 2745 ddi_acc_handle_t io_hdl1, 2746 caddr_t ioaddr1, 2747 ddi_acc_handle_t io_hdl2, 2748 caddr_t ioaddr2, 2749 struct ata_id *ata_idp) 2750 { 2751 int rc; 2752 2753 ADBG_TRACE(("ata_disk_id entered\n")); 2754 2755 rc = ata_id_common(ATC_ID_DEVICE, TRUE, io_hdl1, ioaddr1, io_hdl2, 2756 ioaddr2, ata_idp); 2757 2758 if (!rc) 2759 return (FALSE); 2760 2761 /* 2762 * If the disk is a CF/Microdrive that works under ATA mode 2763 * through CF<->ATA adapters, identify it as an ATA device 2764 * and a non removable media. 2765 */ 2766 if (ata_idp->ai_config == ATA_ID_COMPACT_FLASH) { 2767 ata_idp->ai_config = ATA_ID_CF_TO_ATA; 2768 } 2769 2770 if ((ata_idp->ai_config & ATAC_ATA_TYPE_MASK) != ATAC_ATA_TYPE) 2771 return (FALSE); 2772 2773 if (ata_idp->ai_heads == 0 || ata_idp->ai_sectors == 0) { 2774 return (FALSE); 2775 } 2776 2777 return (TRUE); 2778 } 2779 2780 static daddr_t 2781 ata_last_block_xferred_chs(ata_drv_t *ata_drvp) 2782 { 2783 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp; 2784 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2785 uchar_t drvheads = ata_drvp->ad_phhd; 2786 uchar_t drvsectors = ata_drvp->ad_phsec; 2787 uchar_t sector; 2788 uchar_t head; 2789 uchar_t low_cyl; 2790 uchar_t hi_cyl; 2791 daddr_t lbastop; 2792 2793 sector = ddi_get8(io_hdl1, ata_ctlp->ac_sect); 2794 head = ddi_get8(io_hdl1, ata_ctlp->ac_drvhd) & 0xf; 2795 low_cyl = ddi_get8(io_hdl1, ata_ctlp->ac_lcyl); 2796 hi_cyl = ddi_get8(io_hdl1, ata_ctlp->ac_hcyl); 2797 2798 lbastop = low_cyl; 2799 lbastop |= (uint_t)hi_cyl << 8; 2800 lbastop *= (uint_t)drvheads; 2801 lbastop += (uint_t)head; 2802 lbastop *= (uint_t)drvsectors; 2803 lbastop += (uint_t)sector - 1; 2804 return (lbastop); 2805 } 2806 2807 static daddr_t 2808 ata_last_block_xferred_lba28(ata_ctl_t *ata_ctlp) 2809 { 2810 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2811 daddr_t lbastop; 2812 2813 lbastop = ddi_get8(io_hdl1, ata_ctlp->ac_drvhd) & 0xf; 2814 lbastop <<= 8; 2815 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_hcyl); 2816 lbastop <<= 8; 2817 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_lcyl); 2818 lbastop <<= 8; 2819 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_sect); 2820 return (lbastop); 2821 } 2822 2823 static daddr_t 2824 ata_last_block_xferred_lba48(ata_ctl_t *ata_ctlp) 2825 { 2826 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 2827 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2; 2828 daddr_t lbastop; 2829 2830 /* turn on HOB and read the high-order 24 bits */ 2831 ddi_put8(io_hdl2, ata_ctlp->ac_devctl, (ATDC_D3 | ATDC_HOB)); 2832 lbastop = ddi_get8(io_hdl1, ata_ctlp->ac_hcyl); 2833 lbastop <<= 8; 2834 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_lcyl); 2835 lbastop <<= 8; 2836 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_sect); 2837 lbastop <<= 8; 2838 2839 /* Turn off HOB and read the low-order 24-bits */ 2840 ddi_put8(io_hdl2, ata_ctlp->ac_devctl, (ATDC_D3)); 2841 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_hcyl); 2842 lbastop <<= 8; 2843 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_lcyl); 2844 lbastop <<= 8; 2845 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_sect); 2846 return (lbastop); 2847 } 2848 2849 2850 /* 2851 * 2852 * Need to compute a value for ap_resid so that cp_resid can 2853 * be set by ata_disk_complete(). The cp_resid var is actually 2854 * misnamed. It's actually the offset to the block in which the 2855 * error occurred not the number of bytes transferred to the device. 2856 * At least that's how dadk actually uses the cp_resid when reporting 2857 * an error. In other words the sector that had the error and the 2858 * number of bytes transferred don't always indicate the same offset. 2859 * On top of that, when doing DMA transfers there's actually no 2860 * way to determine how many bytes have been transferred by the DMA 2861 * engine. On the other hand, the drive will report which sector 2862 * it faulted on. Using that address this routine computes the 2863 * number of residual bytes beyond that point which probably weren't 2864 * written to the drive (the drive is allowed to re-order sector 2865 * writes but on an ATA disk there's no way to deal with that 2866 * complication; in other words, the resid value calculated by 2867 * this routine is as good as we can manage). 2868 */ 2869 2870 static void 2871 ata_disk_get_resid( 2872 ata_ctl_t *ata_ctlp, 2873 ata_drv_t *ata_drvp, 2874 ata_pkt_t *ata_pktp) 2875 { 2876 uint_t lba_start; 2877 uint_t lba_stop; 2878 uint_t resid_bytes; 2879 uint_t resid_sectors; 2880 2881 lba_start = ata_pktp->ap_startsec; 2882 2883 if (ata_drvp->ad_flags & AD_EXT48) 2884 lba_stop = ata_last_block_xferred_lba48(ata_ctlp); 2885 else if (ata_drvp->ad_drive_bits & ATDH_LBA) 2886 lba_stop = ata_last_block_xferred_lba28(ata_ctlp); 2887 else /* CHS mode */ 2888 lba_stop = ata_last_block_xferred_chs(ata_drvp); 2889 2890 resid_sectors = lba_start + ata_pktp->ap_count - lba_stop; 2891 resid_bytes = resid_sectors << SCTRSHFT; 2892 2893 ADBG_TRACE(("ata_disk_get_resid start 0x%x cnt 0x%x stop 0x%x\n", 2894 lba_start, ata_pktp->ap_count, lba_stop)); 2895 ata_pktp->ap_resid = resid_bytes; 2896 } 2897 2898 2899 2900 /* 2901 * Removable media commands * 2902 */ 2903 2904 2905 2906 /* 2907 * get the media status 2908 * 2909 * NOTE: the error handling case probably isn't correct but it 2910 * will have to do until someone gives me a drive to test this on. 2911 */ 2912 static int 2913 ata_disk_state( 2914 ata_ctl_t *ata_ctlp, 2915 ata_drv_t *ata_drvp, 2916 ata_pkt_t *ata_pktp) 2917 { 2918 int *statep = (int *)ata_pktp->ap_v_addr; 2919 uchar_t err; 2920 2921 ADBG_TRACE(("ata_disk_state\n")); 2922 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000, 2923 ATC_DOOR_LOCK, 0, 0, 0, 0, 0, 0)) { 2924 *statep = DKIO_INSERTED; 2925 return (ATA_FSM_RC_FINI); 2926 } 2927 2928 err = ddi_get8(ata_ctlp->ac_iohandle1, ata_ctlp->ac_error); 2929 if (err & ATE_NM) 2930 *statep = DKIO_EJECTED; 2931 else 2932 *statep = DKIO_NONE; 2933 2934 return (ATA_FSM_RC_FINI); 2935 } 2936 2937 /* 2938 * eject the media 2939 */ 2940 2941 static int 2942 ata_disk_eject( 2943 ata_ctl_t *ata_ctlp, 2944 ata_drv_t *ata_drvp, 2945 ata_pkt_t *ata_pktp) 2946 { 2947 ADBG_TRACE(("ata_disk_eject\n")); 2948 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000, 2949 ATC_EJECT, 0, 0, 0, 0, 0, 0)) { 2950 return (ATA_FSM_RC_FINI); 2951 } 2952 ata_pktp->ap_flags |= AP_ERROR; 2953 return (ATA_FSM_RC_FINI); 2954 } 2955 2956 /* 2957 * lock the drive 2958 * 2959 */ 2960 static int 2961 ata_disk_lock( 2962 ata_ctl_t *ata_ctlp, 2963 ata_drv_t *ata_drvp, 2964 ata_pkt_t *ata_pktp) 2965 { 2966 ADBG_TRACE(("ata_disk_lock\n")); 2967 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000, 2968 ATC_DOOR_LOCK, 0, 0, 0, 0, 0, 0)) { 2969 return (ATA_FSM_RC_FINI); 2970 } 2971 ata_pktp->ap_flags |= AP_ERROR; 2972 return (ATA_FSM_RC_FINI); 2973 } 2974 2975 2976 /* 2977 * unlock the drive 2978 * 2979 */ 2980 static int 2981 ata_disk_unlock( 2982 ata_ctl_t *ata_ctlp, 2983 ata_drv_t *ata_drvp, 2984 ata_pkt_t *ata_pktp) 2985 { 2986 ADBG_TRACE(("ata_disk_unlock\n")); 2987 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000, 2988 ATC_DOOR_UNLOCK, 0, 0, 0, 0, 0, 0)) { 2989 return (ATA_FSM_RC_FINI); 2990 } 2991 ata_pktp->ap_flags |= AP_ERROR; 2992 return (ATA_FSM_RC_FINI); 2993 } 2994 2995 2996 /* 2997 * put the drive into standby mode 2998 */ 2999 static int 3000 ata_disk_standby( 3001 ata_ctl_t *ata_ctlp, 3002 ata_drv_t *ata_drvp, 3003 ata_pkt_t *ata_pktp) 3004 { 3005 ADBG_TRACE(("ata_disk_standby\n")); 3006 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000, 3007 ATC_STANDBY_IM, 0, 0, 0, 0, 0, 0)) { 3008 return (ATA_FSM_RC_FINI); 3009 } 3010 ata_pktp->ap_flags |= AP_ERROR; 3011 return (ATA_FSM_RC_FINI); 3012 } 3013 3014 3015 /* 3016 * Recalibrate 3017 * 3018 * Note the extra long timeout value. This is necessary in case 3019 * the drive was in standby mode and needs to spin up the media. 3020 * 3021 */ 3022 static int 3023 ata_disk_recalibrate( 3024 ata_ctl_t *ata_ctlp, 3025 ata_drv_t *ata_drvp, 3026 ata_pkt_t *ata_pktp) 3027 { 3028 ADBG_TRACE(("ata_disk_recalibrate\n")); 3029 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 31 * 1000000, 3030 ATC_RECAL, 0, 0, 0, 0, 0, 0)) { 3031 return (ATA_FSM_RC_FINI); 3032 } 3033 ata_pktp->ap_flags |= AP_ERROR; 3034 return (ATA_FSM_RC_FINI); 3035 } 3036 3037 /* 3038 * Copy a string of bytes that were obtained by Identify Device into a 3039 * string buffer provided by the caller. 3040 * 3041 * 1. Determine the amount to copy. This is the lesser of the 3042 * length of the source string or the space available in the user's 3043 * buffer. 3044 * 2. The true length of the source string is always returned to the 3045 * caller in the size field of the argument. 3046 * 3. Copy the string, add a terminating NUL character at the end. 3047 */ 3048 3049 static int 3050 ata_copy_dk_ioc_string(intptr_t arg, char *source, int length, int flag) 3051 { 3052 STRUCT_DECL(dadk_ioc_string, ds_arg); 3053 int destsize; 3054 char nulchar; 3055 caddr_t outp; 3056 3057 /* 3058 * The ioctls that use this routine are only available to 3059 * the kernel. 3060 */ 3061 if ((flag & FKIOCTL) == 0) 3062 return (EFAULT); 3063 3064 STRUCT_INIT(ds_arg, flag & FMODELS); 3065 3066 /* 1. determine size of user's buffer */ 3067 if (ddi_copyin((caddr_t)arg, STRUCT_BUF(ds_arg), STRUCT_SIZE(ds_arg), 3068 flag)) 3069 return (EFAULT); 3070 destsize = STRUCT_FGET(ds_arg, is_size); 3071 if (destsize > length + 1) 3072 destsize = length + 1; 3073 3074 /* 3075 * 2. Return the copied length to the caller. Note: for 3076 * convenience, we actually copy the entire structure back out, not 3077 * just the length. We don't change the is_buf field, so this 3078 * shouldn't break anything. 3079 */ 3080 STRUCT_FSET(ds_arg, is_size, length); 3081 if (ddi_copyout(STRUCT_BUF(ds_arg), (caddr_t)arg, STRUCT_SIZE(ds_arg), 3082 flag)) 3083 return (EFAULT); 3084 3085 /* 3. copy the string and add a NULL terminator */ 3086 outp = STRUCT_FGETP(ds_arg, is_buf); 3087 if (ddi_copyout(source, outp, destsize - 1, flag)) 3088 return (EFAULT); 3089 nulchar = '\0'; 3090 if (ddi_copyout(&nulchar, outp + (destsize - 1), 1, flag)) 3091 return (EFAULT); 3092 return (0); 3093 } 3094 3095 /* 3096 * Sun branded drives are shipped write cache disabled. The default is to 3097 * force write write caching on. 3098 */ 3099 static void 3100 ata_set_write_cache(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp) 3101 { 3102 char *path; 3103 3104 if (!(IS_WRITE_CACHE_SUPPORTED(ata_drvp->ad_id))) 3105 return; 3106 3107 if (ata_write_cache == 1) { 3108 if (ata_set_feature(ata_ctlp, ata_drvp, FC_WRITE_CACHE_ON, 0) 3109 == FALSE) { 3110 path = kmem_alloc(MAXPATHLEN + 1, KM_NOSLEEP); 3111 if (path != NULL) { 3112 cmn_err(CE_WARN, 3113 "%s unable to enable write cache targ=%d", 3114 ddi_pathname(ata_ctlp->ac_dip, path), 3115 ata_drvp->ad_targ); 3116 kmem_free(path, MAXPATHLEN + 1); 3117 } 3118 } 3119 } else if (ata_write_cache == -1) { 3120 if (ata_set_feature(ata_ctlp, ata_drvp, FC_WRITE_CACHE_OFF, 0) 3121 == FALSE) { 3122 path = kmem_alloc(MAXPATHLEN + 1, KM_NOSLEEP); 3123 if (path != NULL) { 3124 cmn_err(CE_WARN, 3125 "%s unable to disable write cache targ=%d", 3126 ddi_pathname(ata_ctlp->ac_dip, path), 3127 ata_drvp->ad_targ); 3128 kmem_free(path, MAXPATHLEN + 1); 3129 } 3130 } 3131 } 3132 } 3133 3134 /* 3135 * Call set feature to spin-up the device. 3136 */ 3137 static int 3138 ata_disk_set_feature_spinup( 3139 ata_ctl_t *ata_ctlp, 3140 ata_drv_t *ata_drvp, 3141 ata_pkt_t *ata_pktp) 3142 { 3143 int rc; 3144 3145 ADBG_TRACE(("ata_disk_set_feature_spinup entered\n")); 3146 3147 rc = ata_set_feature(ata_ctlp, ata_drvp, 0x07, 0); 3148 if (!rc) 3149 ata_pktp->ap_flags |= AP_ERROR; 3150 3151 return (ATA_FSM_RC_FINI); 3152 } 3153 3154 /* 3155 * Update device ata_id content - IDENTIFY DEVICE command. 3156 */ 3157 static int 3158 ata_disk_id_update( 3159 ata_ctl_t *ata_ctlp, 3160 ata_drv_t *ata_drvp, 3161 ata_pkt_t *ata_pktp) 3162 { 3163 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1; 3164 caddr_t ioaddr1 = ata_ctlp->ac_ioaddr1; 3165 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2; 3166 caddr_t ioaddr2 = ata_ctlp->ac_ioaddr2; 3167 struct ata_id *aidp = &ata_drvp->ad_id; 3168 int rc; 3169 3170 ADBG_TRACE(("ata_disk_id_update entered\n")); 3171 3172 /* 3173 * select the appropriate drive and LUN 3174 */ 3175 ddi_put8(io_hdl1, (uchar_t *)ioaddr1 + AT_DRVHD, 3176 ata_drvp->ad_drive_bits); 3177 ata_nsecwait(400); 3178 3179 /* 3180 * make certain the drive is selected, and wait for not busy 3181 */ 3182 if (!ata_wait(io_hdl2, ioaddr2, ATS_DRDY, ATS_BSY, 5 * 1000000)) { 3183 ADBG_ERROR(("ata_disk_id_update: select failed\n")); 3184 ata_pktp->ap_flags |= AP_ERROR; 3185 return (ATA_FSM_RC_FINI); 3186 } 3187 3188 rc = ata_disk_id(io_hdl1, ioaddr1, io_hdl2, ioaddr2, aidp); 3189 3190 if (!rc) { 3191 ata_pktp->ap_flags |= AP_ERROR; 3192 } else { 3193 swab(aidp->ai_drvser, aidp->ai_drvser, 3194 sizeof (aidp->ai_drvser)); 3195 swab(aidp->ai_fw, aidp->ai_fw, 3196 sizeof (aidp->ai_fw)); 3197 swab(aidp->ai_model, aidp->ai_model, 3198 sizeof (aidp->ai_model)); 3199 } 3200 3201 return (ATA_FSM_RC_FINI); 3202 } 3203 3204 /* 3205 * Update device firmware. 3206 */ 3207 static int 3208 ata_disk_update_fw(gtgt_t *gtgtp, ata_ctl_t *ata_ctlp, 3209 ata_drv_t *ata_drvp, caddr_t fwfile, 3210 uint_t size, uint8_t type, int flag) 3211 { 3212 ata_pkt_t *ata_pktp; 3213 gcmd_t *gcmdp = NULL; 3214 caddr_t fwfile_memp = NULL, tmp_fwfile_memp; 3215 uint_t total_sec_count, sec_count, start_sec = 0; 3216 uint8_t cmd_type; 3217 int rc; 3218 3219 /* 3220 * First check whether DOWNLOAD MICROCODE command is supported 3221 */ 3222 if (!(ata_drvp->ad_id.ai_cmdset83 & 0x1)) { 3223 ADBG_ERROR(("drive doesn't support download " 3224 "microcode command\n")); 3225 return (ENOTSUP); 3226 } 3227 3228 switch (type) { 3229 case FW_TYPE_TEMP: 3230 cmd_type = ATCM_FW_TEMP; 3231 break; 3232 3233 case FW_TYPE_PERM: 3234 cmd_type = ATCM_FW_PERM; 3235 break; 3236 3237 default: 3238 return (EINVAL); 3239 } 3240 3241 /* Temporary subcommand is obsolete in ATA/ATAPI-8 version */ 3242 if (cmd_type == ATCM_FW_TEMP) { 3243 if (ata_drvp->ad_id.ai_majorversion & ATAC_MAJVER_8) { 3244 ADBG_ERROR(("Temporary use is obsolete in " 3245 "ATA/ATAPI-8 version\n")); 3246 return (ENOTSUP); 3247 } 3248 } 3249 3250 total_sec_count = size >> SCTRSHFT; 3251 if (total_sec_count > MAX_FWFILE_SIZE_ONECMD) { 3252 if (cmd_type == ATCM_FW_TEMP) { 3253 ADBG_ERROR(("firmware size: %x sectors is too large\n", 3254 total_sec_count)); 3255 return (EINVAL); 3256 } else { 3257 ADBG_WARN(("firmware size: %x sectors is larger than" 3258 " one command, need to use the multicommand" 3259 " subcommand\n", total_sec_count)); 3260 3261 cmd_type = ATCM_FW_MULTICMD; 3262 if (!(ata_drvp->ad_id.ai_padding2[15] & 0x10)) { 3263 ADBG_ERROR(("This drive doesn't support " 3264 "the multicommand subcommand\n")); 3265 return (ENOTSUP); 3266 } 3267 } 3268 } 3269 3270 fwfile_memp = kmem_zalloc(size, KM_SLEEP); 3271 3272 if (ddi_copyin(fwfile, fwfile_memp, size, flag)) { 3273 ADBG_ERROR(("ata_disk_update_fw copyin failed\n")); 3274 rc = EFAULT; 3275 goto done; 3276 } 3277 3278 tmp_fwfile_memp = fwfile_memp; 3279 3280 for (; total_sec_count > 0; ) { 3281 if ((gcmdp == NULL) && !(gcmdp = 3282 ghd_gcmd_alloc(gtgtp, sizeof (*ata_pktp), TRUE))) { 3283 ADBG_ERROR(("ata_disk_update_fw alloc failed\n")); 3284 rc = ENOMEM; 3285 goto done; 3286 } 3287 3288 /* set the back ptr from the ata_pkt to the gcmd_t */ 3289 ata_pktp = GCMD2APKT(gcmdp); 3290 ata_pktp->ap_gcmdp = gcmdp; 3291 ata_pktp->ap_hd = ata_drvp->ad_drive_bits; 3292 ata_pktp->ap_bytes_per_block = ata_drvp->ad_bytes_per_block; 3293 3294 /* use PIO mode to update disk firmware */ 3295 ata_pktp->ap_start = ata_disk_start_pio_out; 3296 ata_pktp->ap_intr = ata_disk_intr_pio_out; 3297 ata_pktp->ap_complete = NULL; 3298 3299 ata_pktp->ap_cmd = ATC_LOAD_FW; 3300 /* use ap_bcount to set subcommand code */ 3301 ata_pktp->ap_bcount = (size_t)cmd_type; 3302 ata_pktp->ap_pciide_dma = FALSE; 3303 ata_pktp->ap_sg_cnt = 0; 3304 3305 sec_count = min(total_sec_count, MAX_FWFILE_SIZE_ONECMD); 3306 ata_pktp->ap_flags = 0; 3307 3308 ata_pktp->ap_count = (ushort_t)sec_count; 3309 ata_pktp->ap_startsec = start_sec; 3310 ata_pktp->ap_v_addr = tmp_fwfile_memp; 3311 ata_pktp->ap_resid = sec_count << SCTRSHFT; 3312 3313 /* add it to the queue, and use POLL mode */ 3314 rc = ghd_transport(&ata_ctlp->ac_ccc, gcmdp, gcmdp->cmd_gtgtp, 3315 ata_disk_updatefw_time, TRUE, NULL); 3316 3317 if (rc != TRAN_ACCEPT) { 3318 /* this should never, ever happen */ 3319 rc = ENOTSUP; 3320 goto done; 3321 } 3322 3323 if (ata_pktp->ap_flags & AP_ERROR) { 3324 if (ata_pktp->ap_error & ATE_ABORT) { 3325 rc = ENOTSUP; 3326 } else 3327 rc = EIO; 3328 goto done; 3329 3330 } else { 3331 total_sec_count -= sec_count; 3332 tmp_fwfile_memp += sec_count << SCTRSHFT; 3333 start_sec += sec_count; 3334 } 3335 } 3336 3337 rc = 0; 3338 done: 3339 if (gcmdp != NULL) 3340 ghd_gcmd_free(gcmdp); 3341 3342 kmem_free(fwfile_memp, size); 3343 3344 return (rc); 3345 } 3346
Indexes created Wed Feb 10 08:45:31 UTC 2010
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Site Map |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
© 2010, Oracle Corporation and/or its affiliates
