1 /* 2 * (C) Copyright 2000-2011 3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 /* 9 * IDE support 10 */ 11 12 #include <common.h> 13 #include <blk.h> 14 #include <config.h> 15 #include <watchdog.h> 16 #include <command.h> 17 #include <image.h> 18 #include <asm/byteorder.h> 19 #include <asm/io.h> 20 21 #if defined(CONFIG_IDE_8xx_DIRECT) || defined(CONFIG_IDE_PCMCIA) 22 # include <pcmcia.h> 23 #endif 24 25 #include <ide.h> 26 #include <ata.h> 27 28 #ifdef CONFIG_STATUS_LED 29 # include <status_led.h> 30 #endif 31 32 #ifdef __PPC__ 33 # define EIEIO __asm__ volatile ("eieio") 34 # define SYNC __asm__ volatile ("sync") 35 #else 36 # define EIEIO /* nothing */ 37 # define SYNC /* nothing */ 38 #endif 39 40 /* ------------------------------------------------------------------------- */ 41 42 /* Current I/O Device */ 43 static int curr_device = -1; 44 45 /* Current offset for IDE0 / IDE1 bus access */ 46 ulong ide_bus_offset[CONFIG_SYS_IDE_MAXBUS] = { 47 #if defined(CONFIG_SYS_ATA_IDE0_OFFSET) 48 CONFIG_SYS_ATA_IDE0_OFFSET, 49 #endif 50 #if defined(CONFIG_SYS_ATA_IDE1_OFFSET) && (CONFIG_SYS_IDE_MAXBUS > 1) 51 CONFIG_SYS_ATA_IDE1_OFFSET, 52 #endif 53 }; 54 55 static int ide_bus_ok[CONFIG_SYS_IDE_MAXBUS]; 56 57 struct blk_desc ide_dev_desc[CONFIG_SYS_IDE_MAXDEVICE]; 58 /* ------------------------------------------------------------------------- */ 59 60 #ifdef CONFIG_IDE_RESET 61 static void ide_reset (void); 62 #else 63 #define ide_reset() /* dummy */ 64 #endif 65 66 static void ide_ident(struct blk_desc *dev_desc); 67 static uchar ide_wait (int dev, ulong t); 68 69 #define IDE_TIME_OUT 2000 /* 2 sec timeout */ 70 71 #define ATAPI_TIME_OUT 7000 /* 7 sec timeout (5 sec seems to work...) */ 72 73 #define IDE_SPIN_UP_TIME_OUT 5000 /* 5 sec spin-up timeout */ 74 75 static void ident_cpy (unsigned char *dest, unsigned char *src, unsigned int len); 76 77 #ifndef CONFIG_SYS_ATA_PORT_ADDR 78 #define CONFIG_SYS_ATA_PORT_ADDR(port) (port) 79 #endif 80 81 #ifdef CONFIG_ATAPI 82 static void atapi_inquiry(struct blk_desc *dev_desc); 83 static ulong atapi_read(struct blk_desc *block_dev, lbaint_t blknr, 84 lbaint_t blkcnt, void *buffer); 85 #endif 86 87 88 /* ------------------------------------------------------------------------- */ 89 90 int do_ide(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) 91 { 92 int rcode = 0; 93 94 switch (argc) { 95 case 0: 96 case 1: 97 return CMD_RET_USAGE; 98 case 2: 99 if (strncmp(argv[1], "res", 3) == 0) { 100 puts("\nReset IDE" 101 #ifdef CONFIG_IDE_8xx_DIRECT 102 " on PCMCIA " PCMCIA_SLOT_MSG 103 #endif 104 ": "); 105 106 ide_init(); 107 return 0; 108 } else if (strncmp(argv[1], "inf", 3) == 0) { 109 int i; 110 111 putc('\n'); 112 113 for (i = 0; i < CONFIG_SYS_IDE_MAXDEVICE; ++i) { 114 if (ide_dev_desc[i].type == DEV_TYPE_UNKNOWN) 115 continue; /* list only known devices */ 116 printf("IDE device %d: ", i); 117 dev_print(&ide_dev_desc[i]); 118 } 119 return 0; 120 121 } else if (strncmp(argv[1], "dev", 3) == 0) { 122 if ((curr_device < 0) 123 || (curr_device >= CONFIG_SYS_IDE_MAXDEVICE)) { 124 puts("\nno IDE devices available\n"); 125 return 1; 126 } 127 printf("\nIDE device %d: ", curr_device); 128 dev_print(&ide_dev_desc[curr_device]); 129 return 0; 130 } else if (strncmp(argv[1], "part", 4) == 0) { 131 int dev, ok; 132 133 for (ok = 0, dev = 0; 134 dev < CONFIG_SYS_IDE_MAXDEVICE; 135 ++dev) { 136 if (ide_dev_desc[dev].part_type != 137 PART_TYPE_UNKNOWN) { 138 ++ok; 139 if (dev) 140 putc('\n'); 141 part_print(&ide_dev_desc[dev]); 142 } 143 } 144 if (!ok) { 145 puts("\nno IDE devices available\n"); 146 rcode++; 147 } 148 return rcode; 149 } 150 return CMD_RET_USAGE; 151 case 3: 152 if (strncmp(argv[1], "dev", 3) == 0) { 153 int dev = (int) simple_strtoul(argv[2], NULL, 10); 154 155 printf("\nIDE device %d: ", dev); 156 if (dev >= CONFIG_SYS_IDE_MAXDEVICE) { 157 puts("unknown device\n"); 158 return 1; 159 } 160 dev_print(&ide_dev_desc[dev]); 161 /*ide_print (dev); */ 162 163 if (ide_dev_desc[dev].type == DEV_TYPE_UNKNOWN) 164 return 1; 165 166 curr_device = dev; 167 168 puts("... is now current device\n"); 169 170 return 0; 171 } else if (strncmp(argv[1], "part", 4) == 0) { 172 int dev = (int) simple_strtoul(argv[2], NULL, 10); 173 174 if (ide_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) { 175 part_print(&ide_dev_desc[dev]); 176 } else { 177 printf("\nIDE device %d not available\n", 178 dev); 179 rcode = 1; 180 } 181 return rcode; 182 } 183 184 return CMD_RET_USAGE; 185 default: 186 /* at least 4 args */ 187 188 if (strcmp(argv[1], "read") == 0) { 189 ulong addr = simple_strtoul(argv[2], NULL, 16); 190 ulong cnt = simple_strtoul(argv[4], NULL, 16); 191 struct blk_desc *dev_desc; 192 ulong n; 193 194 #ifdef CONFIG_SYS_64BIT_LBA 195 lbaint_t blk = simple_strtoull(argv[3], NULL, 16); 196 197 printf("\nIDE read: device %d block # %lld, count %ld ... ", 198 curr_device, blk, cnt); 199 #else 200 lbaint_t blk = simple_strtoul(argv[3], NULL, 16); 201 202 printf("\nIDE read: device %d block # %ld, count %ld ... ", 203 curr_device, blk, cnt); 204 #endif 205 206 dev_desc = &ide_dev_desc[curr_device]; 207 n = blk_dread(dev_desc, blk, cnt, (ulong *)addr); 208 /* flush cache after read */ 209 flush_cache(addr, 210 cnt * ide_dev_desc[curr_device].blksz); 211 212 printf("%ld blocks read: %s\n", 213 n, (n == cnt) ? "OK" : "ERROR"); 214 if (n == cnt) 215 return 0; 216 else 217 return 1; 218 } else if (strcmp(argv[1], "write") == 0) { 219 ulong addr = simple_strtoul(argv[2], NULL, 16); 220 ulong cnt = simple_strtoul(argv[4], NULL, 16); 221 ulong n; 222 223 #ifdef CONFIG_SYS_64BIT_LBA 224 lbaint_t blk = simple_strtoull(argv[3], NULL, 16); 225 226 printf("\nIDE write: device %d block # %lld, count %ld ... ", 227 curr_device, blk, cnt); 228 #else 229 lbaint_t blk = simple_strtoul(argv[3], NULL, 16); 230 231 printf("\nIDE write: device %d block # %ld, count %ld ... ", 232 curr_device, blk, cnt); 233 #endif 234 n = ide_write(&ide_dev_desc[curr_device], blk, cnt, 235 (ulong *)addr); 236 237 printf("%ld blocks written: %s\n", 238 n, (n == cnt) ? "OK" : "ERROR"); 239 if (n == cnt) 240 return 0; 241 else 242 return 1; 243 } else { 244 return CMD_RET_USAGE; 245 } 246 247 return rcode; 248 } 249 } 250 251 int do_diskboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) 252 { 253 return common_diskboot(cmdtp, "ide", argc, argv); 254 } 255 256 /* ------------------------------------------------------------------------- */ 257 258 __weak void ide_led(uchar led, uchar status) 259 { 260 #if defined(CONFIG_IDE_LED) && defined(PER8_BASE) /* required by LED_PORT */ 261 static uchar led_buffer; /* Buffer for current LED status */ 262 263 uchar *led_port = LED_PORT; 264 265 if (status) /* switch LED on */ 266 led_buffer |= led; 267 else /* switch LED off */ 268 led_buffer &= ~led; 269 270 *led_port = led_buffer; 271 #endif 272 } 273 274 #ifndef CONFIG_IDE_LED /* define LED macros, they are not used anyways */ 275 # define DEVICE_LED(x) 0 276 # define LED_IDE1 1 277 # define LED_IDE2 2 278 #endif 279 280 /* ------------------------------------------------------------------------- */ 281 282 __weak void ide_outb(int dev, int port, unsigned char val) 283 { 284 debug("ide_outb (dev= %d, port= 0x%x, val= 0x%02x) : @ 0x%08lx\n", 285 dev, port, val, 286 (ATA_CURR_BASE(dev) + CONFIG_SYS_ATA_PORT_ADDR(port))); 287 288 #if defined(CONFIG_IDE_AHB) 289 if (port) { 290 /* write command */ 291 ide_write_register(dev, port, val); 292 } else { 293 /* write data */ 294 outb(val, (ATA_CURR_BASE(dev))); 295 } 296 #else 297 outb(val, (ATA_CURR_BASE(dev) + CONFIG_SYS_ATA_PORT_ADDR(port))); 298 #endif 299 } 300 301 __weak unsigned char ide_inb(int dev, int port) 302 { 303 uchar val; 304 305 #if defined(CONFIG_IDE_AHB) 306 val = ide_read_register(dev, port); 307 #else 308 val = inb((ATA_CURR_BASE(dev) + CONFIG_SYS_ATA_PORT_ADDR(port))); 309 #endif 310 311 debug("ide_inb (dev= %d, port= 0x%x) : @ 0x%08lx -> 0x%02x\n", 312 dev, port, 313 (ATA_CURR_BASE(dev) + CONFIG_SYS_ATA_PORT_ADDR(port)), val); 314 return val; 315 } 316 317 void ide_init(void) 318 { 319 unsigned char c; 320 int i, bus; 321 322 #ifdef CONFIG_IDE_8xx_PCCARD 323 extern int ide_devices_found; /* Initialized in check_ide_device() */ 324 #endif /* CONFIG_IDE_8xx_PCCARD */ 325 326 #ifdef CONFIG_IDE_PREINIT 327 WATCHDOG_RESET(); 328 329 if (ide_preinit()) { 330 puts("ide_preinit failed\n"); 331 return; 332 } 333 #endif /* CONFIG_IDE_PREINIT */ 334 335 WATCHDOG_RESET(); 336 337 /* 338 * Reset the IDE just to be sure. 339 * Light LED's to show 340 */ 341 ide_led((LED_IDE1 | LED_IDE2), 1); /* LED's on */ 342 343 /* ATAPI Drives seems to need a proper IDE Reset */ 344 ide_reset(); 345 346 #ifdef CONFIG_IDE_INIT_POSTRESET 347 WATCHDOG_RESET(); 348 349 if (ide_init_postreset()) { 350 puts("ide_preinit_postreset failed\n"); 351 return; 352 } 353 #endif /* CONFIG_IDE_INIT_POSTRESET */ 354 355 /* 356 * Wait for IDE to get ready. 357 * According to spec, this can take up to 31 seconds! 358 */ 359 for (bus = 0; bus < CONFIG_SYS_IDE_MAXBUS; ++bus) { 360 int dev = 361 bus * (CONFIG_SYS_IDE_MAXDEVICE / 362 CONFIG_SYS_IDE_MAXBUS); 363 364 #ifdef CONFIG_IDE_8xx_PCCARD 365 /* Skip non-ide devices from probing */ 366 if ((ide_devices_found & (1 << bus)) == 0) { 367 ide_led((LED_IDE1 | LED_IDE2), 0); /* LED's off */ 368 continue; 369 } 370 #endif 371 printf("Bus %d: ", bus); 372 373 ide_bus_ok[bus] = 0; 374 375 /* Select device 376 */ 377 udelay(100000); /* 100 ms */ 378 ide_outb(dev, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(dev)); 379 udelay(100000); /* 100 ms */ 380 i = 0; 381 do { 382 udelay(10000); /* 10 ms */ 383 384 c = ide_inb(dev, ATA_STATUS); 385 i++; 386 if (i > (ATA_RESET_TIME * 100)) { 387 puts("** Timeout **\n"); 388 /* LED's off */ 389 ide_led((LED_IDE1 | LED_IDE2), 0); 390 return; 391 } 392 if ((i >= 100) && ((i % 100) == 0)) 393 putc('.'); 394 395 } while (c & ATA_STAT_BUSY); 396 397 if (c & (ATA_STAT_BUSY | ATA_STAT_FAULT)) { 398 puts("not available "); 399 debug("Status = 0x%02X ", c); 400 #ifndef CONFIG_ATAPI /* ATAPI Devices do not set DRDY */ 401 } else if ((c & ATA_STAT_READY) == 0) { 402 puts("not available "); 403 debug("Status = 0x%02X ", c); 404 #endif 405 } else { 406 puts("OK "); 407 ide_bus_ok[bus] = 1; 408 } 409 WATCHDOG_RESET(); 410 } 411 412 putc('\n'); 413 414 ide_led((LED_IDE1 | LED_IDE2), 0); /* LED's off */ 415 416 curr_device = -1; 417 for (i = 0; i < CONFIG_SYS_IDE_MAXDEVICE; ++i) { 418 int led = (IDE_BUS(i) == 0) ? LED_IDE1 : LED_IDE2; 419 ide_dev_desc[i].type = DEV_TYPE_UNKNOWN; 420 ide_dev_desc[i].if_type = IF_TYPE_IDE; 421 ide_dev_desc[i].devnum = i; 422 ide_dev_desc[i].part_type = PART_TYPE_UNKNOWN; 423 ide_dev_desc[i].blksz = 0; 424 ide_dev_desc[i].log2blksz = 425 LOG2_INVALID(typeof(ide_dev_desc[i].log2blksz)); 426 ide_dev_desc[i].lba = 0; 427 ide_dev_desc[i].block_read = ide_read; 428 ide_dev_desc[i].block_write = ide_write; 429 if (!ide_bus_ok[IDE_BUS(i)]) 430 continue; 431 ide_led(led, 1); /* LED on */ 432 ide_ident(&ide_dev_desc[i]); 433 ide_led(led, 0); /* LED off */ 434 dev_print(&ide_dev_desc[i]); 435 436 if ((ide_dev_desc[i].lba > 0) && (ide_dev_desc[i].blksz > 0)) { 437 /* initialize partition type */ 438 part_init(&ide_dev_desc[i]); 439 if (curr_device < 0) 440 curr_device = i; 441 } 442 } 443 WATCHDOG_RESET(); 444 } 445 446 /* ------------------------------------------------------------------------- */ 447 448 #ifdef CONFIG_PARTITIONS 449 struct blk_desc *ide_get_dev(int dev) 450 { 451 return (dev < CONFIG_SYS_IDE_MAXDEVICE) ? &ide_dev_desc[dev] : NULL; 452 } 453 #endif 454 455 /* ------------------------------------------------------------------------- */ 456 457 /* We only need to swap data if we are running on a big endian cpu. */ 458 #if defined(__LITTLE_ENDIAN) 459 __weak void ide_input_swap_data(int dev, ulong *sect_buf, int words) 460 { 461 ide_input_data(dev, sect_buf, words); 462 } 463 #else 464 __weak void ide_input_swap_data(int dev, ulong *sect_buf, int words) 465 { 466 volatile ushort *pbuf = 467 (ushort *) (ATA_CURR_BASE(dev) + ATA_DATA_REG); 468 ushort *dbuf = (ushort *) sect_buf; 469 470 debug("in input swap data base for read is %lx\n", 471 (unsigned long) pbuf); 472 473 while (words--) { 474 #ifdef __MIPS__ 475 *dbuf++ = swab16p((u16 *) pbuf); 476 *dbuf++ = swab16p((u16 *) pbuf); 477 #else 478 *dbuf++ = ld_le16(pbuf); 479 *dbuf++ = ld_le16(pbuf); 480 #endif /* !MIPS */ 481 } 482 } 483 #endif /* __LITTLE_ENDIAN */ 484 485 486 #if defined(CONFIG_IDE_SWAP_IO) 487 __weak void ide_output_data(int dev, const ulong *sect_buf, int words) 488 { 489 ushort *dbuf; 490 volatile ushort *pbuf; 491 492 pbuf = (ushort *) (ATA_CURR_BASE(dev) + ATA_DATA_REG); 493 dbuf = (ushort *) sect_buf; 494 while (words--) { 495 EIEIO; 496 *pbuf = *dbuf++; 497 EIEIO; 498 *pbuf = *dbuf++; 499 } 500 } 501 #else /* ! CONFIG_IDE_SWAP_IO */ 502 __weak void ide_output_data(int dev, const ulong *sect_buf, int words) 503 { 504 #if defined(CONFIG_IDE_AHB) 505 ide_write_data(dev, sect_buf, words); 506 #else 507 outsw(ATA_CURR_BASE(dev) + ATA_DATA_REG, sect_buf, words << 1); 508 #endif 509 } 510 #endif /* CONFIG_IDE_SWAP_IO */ 511 512 #if defined(CONFIG_IDE_SWAP_IO) 513 __weak void ide_input_data(int dev, ulong *sect_buf, int words) 514 { 515 ushort *dbuf; 516 volatile ushort *pbuf; 517 518 pbuf = (ushort *) (ATA_CURR_BASE(dev) + ATA_DATA_REG); 519 dbuf = (ushort *) sect_buf; 520 521 debug("in input data base for read is %lx\n", (unsigned long) pbuf); 522 523 while (words--) { 524 EIEIO; 525 *dbuf++ = *pbuf; 526 EIEIO; 527 *dbuf++ = *pbuf; 528 } 529 } 530 #else /* ! CONFIG_IDE_SWAP_IO */ 531 __weak void ide_input_data(int dev, ulong *sect_buf, int words) 532 { 533 #if defined(CONFIG_IDE_AHB) 534 ide_read_data(dev, sect_buf, words); 535 #else 536 insw(ATA_CURR_BASE(dev) + ATA_DATA_REG, sect_buf, words << 1); 537 #endif 538 } 539 540 #endif /* CONFIG_IDE_SWAP_IO */ 541 542 /* ------------------------------------------------------------------------- 543 */ 544 static void ide_ident(struct blk_desc *dev_desc) 545 { 546 unsigned char c; 547 hd_driveid_t iop; 548 549 #ifdef CONFIG_ATAPI 550 int retries = 0; 551 #endif 552 int device; 553 554 device = dev_desc->devnum; 555 printf(" Device %d: ", device); 556 557 ide_led(DEVICE_LED(device), 1); /* LED on */ 558 /* Select device 559 */ 560 ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device)); 561 dev_desc->if_type = IF_TYPE_IDE; 562 #ifdef CONFIG_ATAPI 563 564 retries = 0; 565 566 /* Warning: This will be tricky to read */ 567 while (retries <= 1) { 568 /* check signature */ 569 if ((ide_inb(device, ATA_SECT_CNT) == 0x01) && 570 (ide_inb(device, ATA_SECT_NUM) == 0x01) && 571 (ide_inb(device, ATA_CYL_LOW) == 0x14) && 572 (ide_inb(device, ATA_CYL_HIGH) == 0xEB)) { 573 /* ATAPI Signature found */ 574 dev_desc->if_type = IF_TYPE_ATAPI; 575 /* 576 * Start Ident Command 577 */ 578 ide_outb(device, ATA_COMMAND, ATAPI_CMD_IDENT); 579 /* 580 * Wait for completion - ATAPI devices need more time 581 * to become ready 582 */ 583 c = ide_wait(device, ATAPI_TIME_OUT); 584 } else 585 #endif 586 { 587 /* 588 * Start Ident Command 589 */ 590 ide_outb(device, ATA_COMMAND, ATA_CMD_IDENT); 591 592 /* 593 * Wait for completion 594 */ 595 c = ide_wait(device, IDE_TIME_OUT); 596 } 597 ide_led(DEVICE_LED(device), 0); /* LED off */ 598 599 if (((c & ATA_STAT_DRQ) == 0) || 600 ((c & (ATA_STAT_FAULT | ATA_STAT_ERR)) != 0)) { 601 #ifdef CONFIG_ATAPI 602 { 603 /* 604 * Need to soft reset the device 605 * in case it's an ATAPI... 606 */ 607 debug("Retrying...\n"); 608 ide_outb(device, ATA_DEV_HD, 609 ATA_LBA | ATA_DEVICE(device)); 610 udelay(100000); 611 ide_outb(device, ATA_COMMAND, 0x08); 612 udelay(500000); /* 500 ms */ 613 } 614 /* 615 * Select device 616 */ 617 ide_outb(device, ATA_DEV_HD, 618 ATA_LBA | ATA_DEVICE(device)); 619 retries++; 620 #else 621 return; 622 #endif 623 } 624 #ifdef CONFIG_ATAPI 625 else 626 break; 627 } /* see above - ugly to read */ 628 629 if (retries == 2) /* Not found */ 630 return; 631 #endif 632 633 ide_input_swap_data(device, (ulong *)&iop, ATA_SECTORWORDS); 634 635 ident_cpy((unsigned char *) dev_desc->revision, iop.fw_rev, 636 sizeof(dev_desc->revision)); 637 ident_cpy((unsigned char *) dev_desc->vendor, iop.model, 638 sizeof(dev_desc->vendor)); 639 ident_cpy((unsigned char *) dev_desc->product, iop.serial_no, 640 sizeof(dev_desc->product)); 641 #ifdef __LITTLE_ENDIAN 642 /* 643 * firmware revision, model, and serial number have Big Endian Byte 644 * order in Word. Convert all three to little endian. 645 * 646 * See CF+ and CompactFlash Specification Revision 2.0: 647 * 6.2.1.6: Identify Drive, Table 39 for more details 648 */ 649 650 strswab(dev_desc->revision); 651 strswab(dev_desc->vendor); 652 strswab(dev_desc->product); 653 #endif /* __LITTLE_ENDIAN */ 654 655 if ((iop.config & 0x0080) == 0x0080) 656 dev_desc->removable = 1; 657 else 658 dev_desc->removable = 0; 659 660 #ifdef CONFIG_ATAPI 661 if (dev_desc->if_type == IF_TYPE_ATAPI) { 662 atapi_inquiry(dev_desc); 663 return; 664 } 665 #endif /* CONFIG_ATAPI */ 666 667 #ifdef __BIG_ENDIAN 668 /* swap shorts */ 669 dev_desc->lba = (iop.lba_capacity << 16) | (iop.lba_capacity >> 16); 670 #else /* ! __BIG_ENDIAN */ 671 /* 672 * do not swap shorts on little endian 673 * 674 * See CF+ and CompactFlash Specification Revision 2.0: 675 * 6.2.1.6: Identfy Drive, Table 39, Word Address 57-58 for details. 676 */ 677 dev_desc->lba = iop.lba_capacity; 678 #endif /* __BIG_ENDIAN */ 679 680 #ifdef CONFIG_LBA48 681 if (iop.command_set_2 & 0x0400) { /* LBA 48 support */ 682 dev_desc->lba48 = 1; 683 dev_desc->lba = (unsigned long long) iop.lba48_capacity[0] | 684 ((unsigned long long) iop.lba48_capacity[1] << 16) | 685 ((unsigned long long) iop.lba48_capacity[2] << 32) | 686 ((unsigned long long) iop.lba48_capacity[3] << 48); 687 } else { 688 dev_desc->lba48 = 0; 689 } 690 #endif /* CONFIG_LBA48 */ 691 /* assuming HD */ 692 dev_desc->type = DEV_TYPE_HARDDISK; 693 dev_desc->blksz = ATA_BLOCKSIZE; 694 dev_desc->log2blksz = LOG2(dev_desc->blksz); 695 dev_desc->lun = 0; /* just to fill something in... */ 696 697 #if 0 /* only used to test the powersaving mode, 698 * if enabled, the drive goes after 5 sec 699 * in standby mode */ 700 ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device)); 701 c = ide_wait(device, IDE_TIME_OUT); 702 ide_outb(device, ATA_SECT_CNT, 1); 703 ide_outb(device, ATA_LBA_LOW, 0); 704 ide_outb(device, ATA_LBA_MID, 0); 705 ide_outb(device, ATA_LBA_HIGH, 0); 706 ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device)); 707 ide_outb(device, ATA_COMMAND, 0xe3); 708 udelay(50); 709 c = ide_wait(device, IDE_TIME_OUT); /* can't take over 500 ms */ 710 #endif 711 } 712 713 714 /* ------------------------------------------------------------------------- */ 715 716 ulong ide_read(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt, 717 void *buffer) 718 { 719 int device = block_dev->devnum; 720 ulong n = 0; 721 unsigned char c; 722 unsigned char pwrsave = 0; /* power save */ 723 724 #ifdef CONFIG_LBA48 725 unsigned char lba48 = 0; 726 727 if (blknr & 0x0000fffff0000000ULL) { 728 /* more than 28 bits used, use 48bit mode */ 729 lba48 = 1; 730 } 731 #endif 732 debug("ide_read dev %d start " LBAF ", blocks " LBAF " buffer at %lX\n", 733 device, blknr, blkcnt, (ulong) buffer); 734 735 ide_led(DEVICE_LED(device), 1); /* LED on */ 736 737 /* Select device 738 */ 739 ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device)); 740 c = ide_wait(device, IDE_TIME_OUT); 741 742 if (c & ATA_STAT_BUSY) { 743 printf("IDE read: device %d not ready\n", device); 744 goto IDE_READ_E; 745 } 746 747 /* first check if the drive is in Powersaving mode, if yes, 748 * increase the timeout value */ 749 ide_outb(device, ATA_COMMAND, ATA_CMD_CHK_PWR); 750 udelay(50); 751 752 c = ide_wait(device, IDE_TIME_OUT); /* can't take over 500 ms */ 753 754 if (c & ATA_STAT_BUSY) { 755 printf("IDE read: device %d not ready\n", device); 756 goto IDE_READ_E; 757 } 758 if ((c & ATA_STAT_ERR) == ATA_STAT_ERR) { 759 printf("No Powersaving mode %X\n", c); 760 } else { 761 c = ide_inb(device, ATA_SECT_CNT); 762 debug("Powersaving %02X\n", c); 763 if (c == 0) 764 pwrsave = 1; 765 } 766 767 768 while (blkcnt-- > 0) { 769 770 c = ide_wait(device, IDE_TIME_OUT); 771 772 if (c & ATA_STAT_BUSY) { 773 printf("IDE read: device %d not ready\n", device); 774 break; 775 } 776 #ifdef CONFIG_LBA48 777 if (lba48) { 778 /* write high bits */ 779 ide_outb(device, ATA_SECT_CNT, 0); 780 ide_outb(device, ATA_LBA_LOW, (blknr >> 24) & 0xFF); 781 #ifdef CONFIG_SYS_64BIT_LBA 782 ide_outb(device, ATA_LBA_MID, (blknr >> 32) & 0xFF); 783 ide_outb(device, ATA_LBA_HIGH, (blknr >> 40) & 0xFF); 784 #else 785 ide_outb(device, ATA_LBA_MID, 0); 786 ide_outb(device, ATA_LBA_HIGH, 0); 787 #endif 788 } 789 #endif 790 ide_outb(device, ATA_SECT_CNT, 1); 791 ide_outb(device, ATA_LBA_LOW, (blknr >> 0) & 0xFF); 792 ide_outb(device, ATA_LBA_MID, (blknr >> 8) & 0xFF); 793 ide_outb(device, ATA_LBA_HIGH, (blknr >> 16) & 0xFF); 794 795 #ifdef CONFIG_LBA48 796 if (lba48) { 797 ide_outb(device, ATA_DEV_HD, 798 ATA_LBA | ATA_DEVICE(device)); 799 ide_outb(device, ATA_COMMAND, ATA_CMD_READ_EXT); 800 801 } else 802 #endif 803 { 804 ide_outb(device, ATA_DEV_HD, ATA_LBA | 805 ATA_DEVICE(device) | ((blknr >> 24) & 0xF)); 806 ide_outb(device, ATA_COMMAND, ATA_CMD_READ); 807 } 808 809 udelay(50); 810 811 if (pwrsave) { 812 /* may take up to 4 sec */ 813 c = ide_wait(device, IDE_SPIN_UP_TIME_OUT); 814 pwrsave = 0; 815 } else { 816 /* can't take over 500 ms */ 817 c = ide_wait(device, IDE_TIME_OUT); 818 } 819 820 if ((c & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR)) != 821 ATA_STAT_DRQ) { 822 printf("Error (no IRQ) dev %d blk " LBAF ": status " 823 "%#02x\n", device, blknr, c); 824 break; 825 } 826 827 ide_input_data(device, buffer, ATA_SECTORWORDS); 828 (void) ide_inb(device, ATA_STATUS); /* clear IRQ */ 829 830 ++n; 831 ++blknr; 832 buffer += ATA_BLOCKSIZE; 833 } 834 IDE_READ_E: 835 ide_led(DEVICE_LED(device), 0); /* LED off */ 836 return (n); 837 } 838 839 /* ------------------------------------------------------------------------- */ 840 841 842 ulong ide_write(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt, 843 const void *buffer) 844 { 845 int device = block_dev->devnum; 846 ulong n = 0; 847 unsigned char c; 848 849 #ifdef CONFIG_LBA48 850 unsigned char lba48 = 0; 851 852 if (blknr & 0x0000fffff0000000ULL) { 853 /* more than 28 bits used, use 48bit mode */ 854 lba48 = 1; 855 } 856 #endif 857 858 ide_led(DEVICE_LED(device), 1); /* LED on */ 859 860 /* Select device 861 */ 862 ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device)); 863 864 while (blkcnt-- > 0) { 865 866 c = ide_wait(device, IDE_TIME_OUT); 867 868 if (c & ATA_STAT_BUSY) { 869 printf("IDE read: device %d not ready\n", device); 870 goto WR_OUT; 871 } 872 #ifdef CONFIG_LBA48 873 if (lba48) { 874 /* write high bits */ 875 ide_outb(device, ATA_SECT_CNT, 0); 876 ide_outb(device, ATA_LBA_LOW, (blknr >> 24) & 0xFF); 877 #ifdef CONFIG_SYS_64BIT_LBA 878 ide_outb(device, ATA_LBA_MID, (blknr >> 32) & 0xFF); 879 ide_outb(device, ATA_LBA_HIGH, (blknr >> 40) & 0xFF); 880 #else 881 ide_outb(device, ATA_LBA_MID, 0); 882 ide_outb(device, ATA_LBA_HIGH, 0); 883 #endif 884 } 885 #endif 886 ide_outb(device, ATA_SECT_CNT, 1); 887 ide_outb(device, ATA_LBA_LOW, (blknr >> 0) & 0xFF); 888 ide_outb(device, ATA_LBA_MID, (blknr >> 8) & 0xFF); 889 ide_outb(device, ATA_LBA_HIGH, (blknr >> 16) & 0xFF); 890 891 #ifdef CONFIG_LBA48 892 if (lba48) { 893 ide_outb(device, ATA_DEV_HD, 894 ATA_LBA | ATA_DEVICE(device)); 895 ide_outb(device, ATA_COMMAND, ATA_CMD_WRITE_EXT); 896 897 } else 898 #endif 899 { 900 ide_outb(device, ATA_DEV_HD, ATA_LBA | 901 ATA_DEVICE(device) | ((blknr >> 24) & 0xF)); 902 ide_outb(device, ATA_COMMAND, ATA_CMD_WRITE); 903 } 904 905 udelay(50); 906 907 /* can't take over 500 ms */ 908 c = ide_wait(device, IDE_TIME_OUT); 909 910 if ((c & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR)) != 911 ATA_STAT_DRQ) { 912 printf("Error (no IRQ) dev %d blk " LBAF ": status " 913 "%#02x\n", device, blknr, c); 914 goto WR_OUT; 915 } 916 917 ide_output_data(device, buffer, ATA_SECTORWORDS); 918 c = ide_inb(device, ATA_STATUS); /* clear IRQ */ 919 ++n; 920 ++blknr; 921 buffer += ATA_BLOCKSIZE; 922 } 923 WR_OUT: 924 ide_led(DEVICE_LED(device), 0); /* LED off */ 925 return (n); 926 } 927 928 /* ------------------------------------------------------------------------- */ 929 930 /* 931 * copy src to dest, skipping leading and trailing blanks and null 932 * terminate the string 933 * "len" is the size of available memory including the terminating '\0' 934 */ 935 static void ident_cpy(unsigned char *dst, unsigned char *src, 936 unsigned int len) 937 { 938 unsigned char *end, *last; 939 940 last = dst; 941 end = src + len - 1; 942 943 /* reserve space for '\0' */ 944 if (len < 2) 945 goto OUT; 946 947 /* skip leading white space */ 948 while ((*src) && (src < end) && (*src == ' ')) 949 ++src; 950 951 /* copy string, omitting trailing white space */ 952 while ((*src) && (src < end)) { 953 *dst++ = *src; 954 if (*src++ != ' ') 955 last = dst; 956 } 957 OUT: 958 *last = '\0'; 959 } 960 961 /* ------------------------------------------------------------------------- */ 962 963 /* 964 * Wait until Busy bit is off, or timeout (in ms) 965 * Return last status 966 */ 967 static uchar ide_wait(int dev, ulong t) 968 { 969 ulong delay = 10 * t; /* poll every 100 us */ 970 uchar c; 971 972 while ((c = ide_inb(dev, ATA_STATUS)) & ATA_STAT_BUSY) { 973 udelay(100); 974 if (delay-- == 0) 975 break; 976 } 977 return (c); 978 } 979 980 /* ------------------------------------------------------------------------- */ 981 982 #ifdef CONFIG_IDE_RESET 983 extern void ide_set_reset(int idereset); 984 985 static void ide_reset(void) 986 { 987 int i; 988 989 curr_device = -1; 990 for (i = 0; i < CONFIG_SYS_IDE_MAXBUS; ++i) 991 ide_bus_ok[i] = 0; 992 for (i = 0; i < CONFIG_SYS_IDE_MAXDEVICE; ++i) 993 ide_dev_desc[i].type = DEV_TYPE_UNKNOWN; 994 995 ide_set_reset(1); /* assert reset */ 996 997 /* the reset signal shall be asserted for et least 25 us */ 998 udelay(25); 999 1000 WATCHDOG_RESET(); 1001 1002 /* de-assert RESET signal */ 1003 ide_set_reset(0); 1004 1005 /* wait 250 ms */ 1006 for (i = 0; i < 250; ++i) 1007 udelay(1000); 1008 } 1009 1010 #endif /* CONFIG_IDE_RESET */ 1011 1012 /* ------------------------------------------------------------------------- */ 1013 1014 #if defined(CONFIG_OF_IDE_FIXUP) 1015 int ide_device_present(int dev) 1016 { 1017 if (dev >= CONFIG_SYS_IDE_MAXBUS) 1018 return 0; 1019 return (ide_dev_desc[dev].type == DEV_TYPE_UNKNOWN ? 0 : 1); 1020 } 1021 #endif 1022 /* ------------------------------------------------------------------------- */ 1023 1024 #ifdef CONFIG_ATAPI 1025 /**************************************************************************** 1026 * ATAPI Support 1027 */ 1028 1029 #if defined(CONFIG_IDE_SWAP_IO) 1030 /* since ATAPI may use commands with not 4 bytes alligned length 1031 * we have our own transfer functions, 2 bytes alligned */ 1032 __weak void ide_output_data_shorts(int dev, ushort *sect_buf, int shorts) 1033 { 1034 ushort *dbuf; 1035 volatile ushort *pbuf; 1036 1037 pbuf = (ushort *) (ATA_CURR_BASE(dev) + ATA_DATA_REG); 1038 dbuf = (ushort *) sect_buf; 1039 1040 debug("in output data shorts base for read is %lx\n", 1041 (unsigned long) pbuf); 1042 1043 while (shorts--) { 1044 EIEIO; 1045 *pbuf = *dbuf++; 1046 } 1047 } 1048 1049 __weak void ide_input_data_shorts(int dev, ushort *sect_buf, int shorts) 1050 { 1051 ushort *dbuf; 1052 volatile ushort *pbuf; 1053 1054 pbuf = (ushort *) (ATA_CURR_BASE(dev) + ATA_DATA_REG); 1055 dbuf = (ushort *) sect_buf; 1056 1057 debug("in input data shorts base for read is %lx\n", 1058 (unsigned long) pbuf); 1059 1060 while (shorts--) { 1061 EIEIO; 1062 *dbuf++ = *pbuf; 1063 } 1064 } 1065 1066 #else /* ! CONFIG_IDE_SWAP_IO */ 1067 __weak void ide_output_data_shorts(int dev, ushort *sect_buf, int shorts) 1068 { 1069 outsw(ATA_CURR_BASE(dev) + ATA_DATA_REG, sect_buf, shorts); 1070 } 1071 1072 __weak void ide_input_data_shorts(int dev, ushort *sect_buf, int shorts) 1073 { 1074 insw(ATA_CURR_BASE(dev) + ATA_DATA_REG, sect_buf, shorts); 1075 } 1076 1077 #endif /* CONFIG_IDE_SWAP_IO */ 1078 1079 /* 1080 * Wait until (Status & mask) == res, or timeout (in ms) 1081 * Return last status 1082 * This is used since some ATAPI CD ROMs clears their Busy Bit first 1083 * and then they set their DRQ Bit 1084 */ 1085 static uchar atapi_wait_mask(int dev, ulong t, uchar mask, uchar res) 1086 { 1087 ulong delay = 10 * t; /* poll every 100 us */ 1088 uchar c; 1089 1090 /* prevents to read the status before valid */ 1091 c = ide_inb(dev, ATA_DEV_CTL); 1092 1093 while (((c = ide_inb(dev, ATA_STATUS)) & mask) != res) { 1094 /* break if error occurs (doesn't make sense to wait more) */ 1095 if ((c & ATA_STAT_ERR) == ATA_STAT_ERR) 1096 break; 1097 udelay(100); 1098 if (delay-- == 0) 1099 break; 1100 } 1101 return (c); 1102 } 1103 1104 /* 1105 * issue an atapi command 1106 */ 1107 unsigned char atapi_issue(int device, unsigned char *ccb, int ccblen, 1108 unsigned char *buffer, int buflen) 1109 { 1110 unsigned char c, err, mask, res; 1111 int n; 1112 1113 ide_led(DEVICE_LED(device), 1); /* LED on */ 1114 1115 /* Select device 1116 */ 1117 mask = ATA_STAT_BUSY | ATA_STAT_DRQ; 1118 res = 0; 1119 ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device)); 1120 c = atapi_wait_mask(device, ATAPI_TIME_OUT, mask, res); 1121 if ((c & mask) != res) { 1122 printf("ATAPI_ISSUE: device %d not ready status %X\n", device, 1123 c); 1124 err = 0xFF; 1125 goto AI_OUT; 1126 } 1127 /* write taskfile */ 1128 ide_outb(device, ATA_ERROR_REG, 0); /* no DMA, no overlaped */ 1129 ide_outb(device, ATA_SECT_CNT, 0); 1130 ide_outb(device, ATA_SECT_NUM, 0); 1131 ide_outb(device, ATA_CYL_LOW, (unsigned char) (buflen & 0xFF)); 1132 ide_outb(device, ATA_CYL_HIGH, 1133 (unsigned char) ((buflen >> 8) & 0xFF)); 1134 ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device)); 1135 1136 ide_outb(device, ATA_COMMAND, ATAPI_CMD_PACKET); 1137 udelay(50); 1138 1139 mask = ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR; 1140 res = ATA_STAT_DRQ; 1141 c = atapi_wait_mask(device, ATAPI_TIME_OUT, mask, res); 1142 1143 if ((c & mask) != res) { /* DRQ must be 1, BSY 0 */ 1144 printf("ATAPI_ISSUE: Error (no IRQ) before sending ccb dev %d status 0x%02x\n", 1145 device, c); 1146 err = 0xFF; 1147 goto AI_OUT; 1148 } 1149 1150 /* write command block */ 1151 ide_output_data_shorts(device, (unsigned short *) ccb, ccblen / 2); 1152 1153 /* ATAPI Command written wait for completition */ 1154 udelay(5000); /* device must set bsy */ 1155 1156 mask = ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR; 1157 /* 1158 * if no data wait for DRQ = 0 BSY = 0 1159 * if data wait for DRQ = 1 BSY = 0 1160 */ 1161 res = 0; 1162 if (buflen) 1163 res = ATA_STAT_DRQ; 1164 c = atapi_wait_mask(device, ATAPI_TIME_OUT, mask, res); 1165 if ((c & mask) != res) { 1166 if (c & ATA_STAT_ERR) { 1167 err = (ide_inb(device, ATA_ERROR_REG)) >> 4; 1168 debug("atapi_issue 1 returned sense key %X status %02X\n", 1169 err, c); 1170 } else { 1171 printf("ATAPI_ISSUE: (no DRQ) after sending ccb (%x) status 0x%02x\n", 1172 ccb[0], c); 1173 err = 0xFF; 1174 } 1175 goto AI_OUT; 1176 } 1177 n = ide_inb(device, ATA_CYL_HIGH); 1178 n <<= 8; 1179 n += ide_inb(device, ATA_CYL_LOW); 1180 if (n > buflen) { 1181 printf("ERROR, transfer bytes %d requested only %d\n", n, 1182 buflen); 1183 err = 0xff; 1184 goto AI_OUT; 1185 } 1186 if ((n == 0) && (buflen < 0)) { 1187 printf("ERROR, transfer bytes %d requested %d\n", n, buflen); 1188 err = 0xff; 1189 goto AI_OUT; 1190 } 1191 if (n != buflen) { 1192 debug("WARNING, transfer bytes %d not equal with requested %d\n", 1193 n, buflen); 1194 } 1195 if (n != 0) { /* data transfer */ 1196 debug("ATAPI_ISSUE: %d Bytes to transfer\n", n); 1197 /* we transfer shorts */ 1198 n >>= 1; 1199 /* ok now decide if it is an in or output */ 1200 if ((ide_inb(device, ATA_SECT_CNT) & 0x02) == 0) { 1201 debug("Write to device\n"); 1202 ide_output_data_shorts(device, 1203 (unsigned short *) buffer, n); 1204 } else { 1205 debug("Read from device @ %p shorts %d\n", buffer, n); 1206 ide_input_data_shorts(device, 1207 (unsigned short *) buffer, n); 1208 } 1209 } 1210 udelay(5000); /* seems that some CD ROMs need this... */ 1211 mask = ATA_STAT_BUSY | ATA_STAT_ERR; 1212 res = 0; 1213 c = atapi_wait_mask(device, ATAPI_TIME_OUT, mask, res); 1214 if ((c & ATA_STAT_ERR) == ATA_STAT_ERR) { 1215 err = (ide_inb(device, ATA_ERROR_REG) >> 4); 1216 debug("atapi_issue 2 returned sense key %X status %X\n", err, 1217 c); 1218 } else { 1219 err = 0; 1220 } 1221 AI_OUT: 1222 ide_led(DEVICE_LED(device), 0); /* LED off */ 1223 return (err); 1224 } 1225 1226 /* 1227 * sending the command to atapi_issue. If an status other than good 1228 * returns, an request_sense will be issued 1229 */ 1230 1231 #define ATAPI_DRIVE_NOT_READY 100 1232 #define ATAPI_UNIT_ATTN 10 1233 1234 unsigned char atapi_issue_autoreq(int device, 1235 unsigned char *ccb, 1236 int ccblen, 1237 unsigned char *buffer, int buflen) 1238 { 1239 unsigned char sense_data[18], sense_ccb[12]; 1240 unsigned char res, key, asc, ascq; 1241 int notready, unitattn; 1242 1243 unitattn = ATAPI_UNIT_ATTN; 1244 notready = ATAPI_DRIVE_NOT_READY; 1245 1246 retry: 1247 res = atapi_issue(device, ccb, ccblen, buffer, buflen); 1248 if (res == 0) 1249 return 0; /* Ok */ 1250 1251 if (res == 0xFF) 1252 return 0xFF; /* error */ 1253 1254 debug("(auto_req)atapi_issue returned sense key %X\n", res); 1255 1256 memset(sense_ccb, 0, sizeof(sense_ccb)); 1257 memset(sense_data, 0, sizeof(sense_data)); 1258 sense_ccb[0] = ATAPI_CMD_REQ_SENSE; 1259 sense_ccb[4] = 18; /* allocation Length */ 1260 1261 res = atapi_issue(device, sense_ccb, 12, sense_data, 18); 1262 key = (sense_data[2] & 0xF); 1263 asc = (sense_data[12]); 1264 ascq = (sense_data[13]); 1265 1266 debug("ATAPI_CMD_REQ_SENSE returned %x\n", res); 1267 debug(" Sense page: %02X key %02X ASC %02X ASCQ %02X\n", 1268 sense_data[0], key, asc, ascq); 1269 1270 if ((key == 0)) 1271 return 0; /* ok device ready */ 1272 1273 if ((key == 6) || (asc == 0x29) || (asc == 0x28)) { /* Unit Attention */ 1274 if (unitattn-- > 0) { 1275 udelay(200 * 1000); 1276 goto retry; 1277 } 1278 printf("Unit Attention, tried %d\n", ATAPI_UNIT_ATTN); 1279 goto error; 1280 } 1281 if ((asc == 0x4) && (ascq == 0x1)) { 1282 /* not ready, but will be ready soon */ 1283 if (notready-- > 0) { 1284 udelay(200 * 1000); 1285 goto retry; 1286 } 1287 printf("Drive not ready, tried %d times\n", 1288 ATAPI_DRIVE_NOT_READY); 1289 goto error; 1290 } 1291 if (asc == 0x3a) { 1292 debug("Media not present\n"); 1293 goto error; 1294 } 1295 1296 printf("ERROR: Unknown Sense key %02X ASC %02X ASCQ %02X\n", key, asc, 1297 ascq); 1298 error: 1299 debug("ERROR Sense key %02X ASC %02X ASCQ %02X\n", key, asc, ascq); 1300 return (0xFF); 1301 } 1302 1303 1304 static void atapi_inquiry(struct blk_desc *dev_desc) 1305 { 1306 unsigned char ccb[12]; /* Command descriptor block */ 1307 unsigned char iobuf[64]; /* temp buf */ 1308 unsigned char c; 1309 int device; 1310 1311 device = dev_desc->devnum; 1312 dev_desc->type = DEV_TYPE_UNKNOWN; /* not yet valid */ 1313 dev_desc->block_read = atapi_read; 1314 1315 memset(ccb, 0, sizeof(ccb)); 1316 memset(iobuf, 0, sizeof(iobuf)); 1317 1318 ccb[0] = ATAPI_CMD_INQUIRY; 1319 ccb[4] = 40; /* allocation Legnth */ 1320 c = atapi_issue_autoreq(device, ccb, 12, (unsigned char *) iobuf, 40); 1321 1322 debug("ATAPI_CMD_INQUIRY returned %x\n", c); 1323 if (c != 0) 1324 return; 1325 1326 /* copy device ident strings */ 1327 ident_cpy((unsigned char *) dev_desc->vendor, &iobuf[8], 8); 1328 ident_cpy((unsigned char *) dev_desc->product, &iobuf[16], 16); 1329 ident_cpy((unsigned char *) dev_desc->revision, &iobuf[32], 5); 1330 1331 dev_desc->lun = 0; 1332 dev_desc->lba = 0; 1333 dev_desc->blksz = 0; 1334 dev_desc->log2blksz = LOG2_INVALID(typeof(dev_desc->log2blksz)); 1335 dev_desc->type = iobuf[0] & 0x1f; 1336 1337 if ((iobuf[1] & 0x80) == 0x80) 1338 dev_desc->removable = 1; 1339 else 1340 dev_desc->removable = 0; 1341 1342 memset(ccb, 0, sizeof(ccb)); 1343 memset(iobuf, 0, sizeof(iobuf)); 1344 ccb[0] = ATAPI_CMD_START_STOP; 1345 ccb[4] = 0x03; /* start */ 1346 1347 c = atapi_issue_autoreq(device, ccb, 12, (unsigned char *) iobuf, 0); 1348 1349 debug("ATAPI_CMD_START_STOP returned %x\n", c); 1350 if (c != 0) 1351 return; 1352 1353 memset(ccb, 0, sizeof(ccb)); 1354 memset(iobuf, 0, sizeof(iobuf)); 1355 c = atapi_issue_autoreq(device, ccb, 12, (unsigned char *) iobuf, 0); 1356 1357 debug("ATAPI_CMD_UNIT_TEST_READY returned %x\n", c); 1358 if (c != 0) 1359 return; 1360 1361 memset(ccb, 0, sizeof(ccb)); 1362 memset(iobuf, 0, sizeof(iobuf)); 1363 ccb[0] = ATAPI_CMD_READ_CAP; 1364 c = atapi_issue_autoreq(device, ccb, 12, (unsigned char *) iobuf, 8); 1365 debug("ATAPI_CMD_READ_CAP returned %x\n", c); 1366 if (c != 0) 1367 return; 1368 1369 debug("Read Cap: LBA %02X%02X%02X%02X blksize %02X%02X%02X%02X\n", 1370 iobuf[0], iobuf[1], iobuf[2], iobuf[3], 1371 iobuf[4], iobuf[5], iobuf[6], iobuf[7]); 1372 1373 dev_desc->lba = ((unsigned long) iobuf[0] << 24) + 1374 ((unsigned long) iobuf[1] << 16) + 1375 ((unsigned long) iobuf[2] << 8) + ((unsigned long) iobuf[3]); 1376 dev_desc->blksz = ((unsigned long) iobuf[4] << 24) + 1377 ((unsigned long) iobuf[5] << 16) + 1378 ((unsigned long) iobuf[6] << 8) + ((unsigned long) iobuf[7]); 1379 dev_desc->log2blksz = LOG2(dev_desc->blksz); 1380 #ifdef CONFIG_LBA48 1381 /* ATAPI devices cannot use 48bit addressing (ATA/ATAPI v7) */ 1382 dev_desc->lba48 = 0; 1383 #endif 1384 return; 1385 } 1386 1387 1388 /* 1389 * atapi_read: 1390 * we transfer only one block per command, since the multiple DRQ per 1391 * command is not yet implemented 1392 */ 1393 #define ATAPI_READ_MAX_BYTES 2048 /* we read max 2kbytes */ 1394 #define ATAPI_READ_BLOCK_SIZE 2048 /* assuming CD part */ 1395 #define ATAPI_READ_MAX_BLOCK (ATAPI_READ_MAX_BYTES/ATAPI_READ_BLOCK_SIZE) 1396 1397 ulong atapi_read(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt, 1398 void *buffer) 1399 { 1400 int device = block_dev->devnum; 1401 ulong n = 0; 1402 unsigned char ccb[12]; /* Command descriptor block */ 1403 ulong cnt; 1404 1405 debug("atapi_read dev %d start " LBAF " blocks " LBAF " buffer at %lX\n", 1406 device, blknr, blkcnt, (ulong) buffer); 1407 1408 do { 1409 if (blkcnt > ATAPI_READ_MAX_BLOCK) 1410 cnt = ATAPI_READ_MAX_BLOCK; 1411 else 1412 cnt = blkcnt; 1413 1414 ccb[0] = ATAPI_CMD_READ_12; 1415 ccb[1] = 0; /* reserved */ 1416 ccb[2] = (unsigned char) (blknr >> 24) & 0xFF; /* MSB Block */ 1417 ccb[3] = (unsigned char) (blknr >> 16) & 0xFF; /* */ 1418 ccb[4] = (unsigned char) (blknr >> 8) & 0xFF; 1419 ccb[5] = (unsigned char) blknr & 0xFF; /* LSB Block */ 1420 ccb[6] = (unsigned char) (cnt >> 24) & 0xFF; /* MSB Block cnt */ 1421 ccb[7] = (unsigned char) (cnt >> 16) & 0xFF; 1422 ccb[8] = (unsigned char) (cnt >> 8) & 0xFF; 1423 ccb[9] = (unsigned char) cnt & 0xFF; /* LSB Block */ 1424 ccb[10] = 0; /* reserved */ 1425 ccb[11] = 0; /* reserved */ 1426 1427 if (atapi_issue_autoreq(device, ccb, 12, 1428 (unsigned char *) buffer, 1429 cnt * ATAPI_READ_BLOCK_SIZE) 1430 == 0xFF) { 1431 return (n); 1432 } 1433 n += cnt; 1434 blkcnt -= cnt; 1435 blknr += cnt; 1436 buffer += (cnt * ATAPI_READ_BLOCK_SIZE); 1437 } while (blkcnt > 0); 1438 return (n); 1439 } 1440 1441 /* ------------------------------------------------------------------------- */ 1442 1443 #endif /* CONFIG_ATAPI */ 1444 1445 U_BOOT_CMD(ide, 5, 1, do_ide, 1446 "IDE sub-system", 1447 "reset - reset IDE controller\n" 1448 "ide info - show available IDE devices\n" 1449 "ide device [dev] - show or set current device\n" 1450 "ide part [dev] - print partition table of one or all IDE devices\n" 1451 "ide read addr blk# cnt\n" 1452 "ide write addr blk# cnt - read/write `cnt'" 1453 " blocks starting at block `blk#'\n" 1454 " to/from memory address `addr'"); 1455 1456 U_BOOT_CMD(diskboot, 3, 1, do_diskboot, 1457 "boot from IDE device", "loadAddr dev:part"); 1458