firmware/drivers/ata.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Alan Korr
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <stdbool.h>
  22 #include <inttypes.h>
  23 #include "ata.h"
  24 #include "kernel.h"
  25 #include "thread.h"
  26 #include "led.h"
  27 #include "cpu.h"
  28 #include "system.h"
  29 #include "debug.h"
  30 #include "panic.h"
  31 #include "usb.h"
  32 #include "power.h"
  33 #include "string.h"
  34 #include "ata_idle_notify.h"
  35 #include "ata-driver.h"
  36 #include "ata-defines.h"
  37 #include "storage.h"
  38
  39 #define SECTOR_SIZE     512
  40
  41 #define SELECT_DEVICE1  0x10
  42 #define SELECT_LBA      0x40
  43
  44 #define CONTROL_nIEN    0x02
  45 #define CONTROL_SRST    0x04
  46
  47 #define CMD_READ_SECTORS           0x20
  48 #define CMD_WRITE_SECTORS          0x30
  49 #define CMD_WRITE_SECTORS_EXT      0x34
  50 #define CMD_READ_MULTIPLE          0xC4
  51 #define CMD_READ_MULTIPLE_EXT      0x29
  52 #define CMD_WRITE_MULTIPLE         0xC5
  53 #define CMD_WRITE_MULTIPLE_EXT     0x39
  54 #define CMD_SET_MULTIPLE_MODE      0xC6
  55 #define CMD_STANDBY_IMMEDIATE      0xE0
  56 #define CMD_STANDBY                0xE2
  57 #define CMD_IDENTIFY               0xEC
  58 #define CMD_SLEEP                  0xE6
  59 #define CMD_SET_FEATURES           0xEF
  60 #define CMD_SECURITY_FREEZE_LOCK   0xF5
  61 #ifdef HAVE_ATA_DMA
  62 #define CMD_READ_DMA               0xC8
  63 #define CMD_READ_DMA_EXT           0x25
  64 #define CMD_WRITE_DMA              0xCA
  65 #define CMD_WRITE_DMA_EXT          0x35
  66 #endif
  67
  68 /* Should all be < 0x100 (which are reserved for control messages) */
  69 #define Q_SLEEP    0
  70 #define Q_CLOSE    1
  71
  72 #define READWRITE_TIMEOUT 5*HZ
  73
  74 #ifdef HAVE_ATA_POWER_OFF
  75 #define ATA_POWER_OFF_TIMEOUT 2*HZ
  76 #endif
  77
  78 #ifdef ATA_DRIVER_CLOSE
  79 static unsigned int ata_thread_id = 0;
  80 #endif
  81
  82 #if defined(MAX_PHYS_SECTOR_SIZE) && MEMORYSIZE == 64
  83 /* Hack - what's the deal with 5g? */
  84 struct ata_lock
  85 {
  86     struct thread_entry *thread;
  87     int count;
  88     volatile unsigned char locked;
  89     IF_COP( struct corelock cl; )
  90 };
  91
  92 static void ata_lock_init(struct ata_lock *l)
  93 {
  94     corelock_init(&l->cl);
  95     l->locked = 0;
  96     l->count = 0;
  97     l->thread = NULL;
  98 }
  99
 100 static void ata_lock_lock(struct ata_lock *l)
 101 {
 102     struct thread_entry * const current = thread_self_entry();
 103
 104     if (current == l->thread)
 105     {
 106         l->count++;
 107         return;
 108     }
 109
 110     corelock_lock(&l->cl);
 111
 112     IF_PRIO( current->skip_count = -1; )
 113
 114     while (l->locked != 0)
 115     {
 116         corelock_unlock(&l->cl);
 117         switch_thread();
 118         corelock_lock(&l->cl);
 119     }
 120
 121     l->locked = 1;
 122     l->thread = current;
 123     corelock_unlock(&l->cl);
 124 }
 125
 126 static void ata_lock_unlock(struct ata_lock *l)
 127 {
 128     if (l->count > 0)
 129     {
 130         l->count--;
 131         return;
 132     }
 133
 134     corelock_lock(&l->cl);
 135
 136     IF_PRIO( l->thread->skip_count = 0; )
 137
 138     l->thread = NULL;
 139     l->locked = 0;
 140
 141     corelock_unlock(&l->cl);
 142 }
 143
 144 #define mutex           ata_lock
 145 #define mutex_init      ata_lock_init
 146 #define mutex_lock      ata_lock_lock
 147 #define mutex_unlock    ata_lock_unlock
 148 #endif /* MAX_PHYS_SECTOR_SIZE */
 149
 150 #if defined(HAVE_USBSTACK) && defined(USE_ROCKBOX_USB)
 151 #define ALLOW_USB_SPINDOWN
 152 #endif
 153
 154 static struct mutex ata_mtx SHAREDBSS_ATTR;
 155 static int ata_device; /* device 0 (master) or 1 (slave) */
 156
 157 static int spinup_time = 0;
 158 #if (CONFIG_LED == LED_REAL)
 159 static bool ata_led_enabled = true;
 160 static bool ata_led_on = false;
 161 #endif
 162 static bool spinup = false;
 163 static bool sleeping = true;
 164 #ifdef HAVE_ATA_POWER_OFF
 165 static bool poweroff = false;
 166 #endif
 167 static long sleep_timeout = 5*HZ;
 168 #ifdef HAVE_LBA48
 169 static bool lba48 = false; /* set for 48 bit addressing */
 170 #endif
 171 static long ata_stack[(DEFAULT_STACK_SIZE*3)/sizeof(long)];
 172 static const char ata_thread_name[] = "ata";
 173 static struct event_queue ata_queue SHAREDBSS_ATTR;
 174 static bool initialized = false;
 175
 176 static long last_user_activity = -1;
 177 static long last_disk_activity = -1;
 178
 179 static unsigned long total_sectors;
 180 static int multisectors; /* number of supported multisectors */
 181 static unsigned short identify_info[SECTOR_SIZE/2];
 182
 183 #ifdef MAX_PHYS_SECTOR_SIZE
 184
 185 struct sector_cache_entry {
 186     bool inuse;
 187     unsigned long sectornum;  /* logical sector */
 188     unsigned char data[MAX_PHYS_SECTOR_SIZE];
 189 };
 190 /* buffer for reading and writing large physical sectors */
 191 #define NUMCACHES 2
 192 static struct sector_cache_entry sector_cache;
 193 static int phys_sector_mult = 1;
 194 #endif
 195
 196 #ifdef HAVE_ATA_DMA
 197 static int dma_mode = 0;
 198 #endif
 199
 200 #ifdef HAVE_ATA_POWER_OFF
 201 static int ata_power_on(void);
 202 #endif
 203 static int perform_soft_reset(void);
 204 static int set_multiple_mode(int sectors);
 205 static int set_features(void);
 206
 207 #ifndef ATA_TARGET_POLLING
 208 STATICIRAM ICODE_ATTR int wait_for_bsy(void)
 209 {
 210     long timeout = current_tick + HZ*30;
 211
 212     do
 213     {
 214         if (!(ATA_IN8(ATA_STATUS) & STATUS_BSY))
 215             return 1;
 216         last_disk_activity = current_tick;
 217         yield();
 218     } while (TIME_BEFORE(current_tick, timeout));
 219
 220     return 0; /* timeout */
 221 }
 222
 223 STATICIRAM ICODE_ATTR int wait_for_rdy(void)
 224 {
 225     long timeout;
 226
 227     if (!wait_for_bsy())
 228         return 0;
 229
 230     timeout = current_tick + HZ*10;
 231
 232     do
 233     {
 234         if (ATA_IN8(ATA_ALT_STATUS) & STATUS_RDY)
 235             return 1;
 236         last_disk_activity = current_tick;
 237         yield();
 238     } while (TIME_BEFORE(current_tick, timeout));
 239
 240     return 0; /* timeout */
 241 }
 242 #else
 243 #define wait_for_bsy    ata_wait_for_bsy
 244 #define wait_for_rdy    ata_wait_for_rdy
 245 #endif
 246
 247 STATICIRAM ICODE_ATTR int wait_for_start_of_transfer(void)
 248 {
 249     if (!wait_for_bsy())
 250         return 0;
 251
 252     return (ATA_IN8(ATA_ALT_STATUS) & (STATUS_BSY|STATUS_DRQ)) == STATUS_DRQ;
 253 }
 254
 255 STATICIRAM ICODE_ATTR int wait_for_end_of_transfer(void)
 256 {
 257     if (!wait_for_bsy())
 258         return 0;
 259     return (ATA_IN8(ATA_ALT_STATUS) &
 260             (STATUS_BSY|STATUS_RDY|STATUS_DF|STATUS_DRQ|STATUS_ERR))
 261            == STATUS_RDY;
 262 }
 263
 264 #if (CONFIG_LED == LED_REAL)
 265 /* Conditionally block LED access for the ATA driver, so the LED can be
 266  * (mis)used for other purposes */
 267 static void ata_led(bool on)
 268 {
 269     ata_led_on = on;
 270     if (ata_led_enabled)
 271         led(ata_led_on);
 272 }
 273 #else
 274 #define ata_led(on) led(on)
 275 #endif
 276
 277 #ifndef ATA_OPTIMIZED_READING
 278 STATICIRAM ICODE_ATTR void copy_read_sectors(unsigned char* buf, int wordcount)
 279 {
 280     unsigned short tmp = 0;
 281
 282     if ( (unsigned long)buf & 1)
 283     {   /* not 16-bit aligned, copy byte by byte */
 284         unsigned char* bufend = buf + wordcount*2;
 285         do
 286         {
 287             tmp = ATA_IN16(ATA_DATA);
 288 #if defined(ROCKBOX_LITTLE_ENDIAN)
 289             *buf++ = tmp & 0xff; /* I assume big endian */
 290             *buf++ = tmp >> 8;   /*  and don't use the SWAB16 macro */
 291 #else
 292             *buf++ = tmp >> 8;
 293             *buf++ = tmp & 0xff;
 294 #endif
 295         } while (buf < bufend); /* tail loop is faster */
 296     }
 297     else
 298     {   /* 16-bit aligned, can do faster copy */
 299         unsigned short* wbuf = (unsigned short*)buf;
 300         unsigned short* wbufend = wbuf + wordcount;
 301         do
 302         {
 303             *wbuf = ATA_IN16(ATA_DATA);
 304         } while (++wbuf < wbufend); /* tail loop is faster */
 305     }
 306 }
 307 #endif /* !ATA_OPTIMIZED_READING */
 308
 309 #ifndef ATA_OPTIMIZED_WRITING
 310 STATICIRAM ICODE_ATTR void copy_write_sectors(const unsigned char* buf,
 311                                               int wordcount)
 312 {
 313     if ( (unsigned long)buf & 1)
 314     {   /* not 16-bit aligned, copy byte by byte */
 315         unsigned short tmp = 0;
 316         const unsigned char* bufend = buf + wordcount*2;
 317         do
 318         {
 319 #if defined(ROCKBOX_LITTLE_ENDIAN)
 320             tmp = (unsigned short) *buf++;
 321             tmp |= (unsigned short) *buf++ << 8;
 322 #else
 323             tmp = (unsigned short) *buf++ << 8;
 324             tmp |= (unsigned short) *buf++;
 325 #endif
 326             ATA_OUT16(ATA_DATA, tmp);
 327         } while (buf < bufend); /* tail loop is faster */
 328     }
 329     else
 330     {   /* 16-bit aligned, can do faster copy */
 331         unsigned short* wbuf = (unsigned short*)buf;
 332         unsigned short* wbufend = wbuf + wordcount;
 333         do
 334         {
 335             ATA_OUT16(ATA_DATA, *wbuf);
 336         } while (++wbuf < wbufend); /* tail loop is faster */
 337     }
 338 }
 339 #endif /* !ATA_OPTIMIZED_WRITING */
 340
 341 static int ata_transfer_sectors(unsigned long start,
 342                                 int incount,
 343                                 void* inbuf,
 344                                 int write)
 345 {
 346     int ret = 0;
 347     long timeout;
 348     int count;
 349     void* buf;
 350     long spinup_start;
 351 #ifdef HAVE_ATA_DMA
 352     bool usedma = false;
 353 #endif
 354
 355 #ifndef MAX_PHYS_SECTOR_SIZE
 356     mutex_lock(&ata_mtx);
 357 #endif
 358
 359     if (start + incount > total_sectors) {
 360         ret = -1;
 361         goto error;
 362     }
 363
 364     last_disk_activity = current_tick;
 365     spinup_start = current_tick;
 366
 367     ata_led(true);
 368
 369     if ( sleeping ) {
 370         sleeping = false; /* set this now since it'll be on */
 371         spinup = true;
 372 #ifdef HAVE_ATA_POWER_OFF
 373         if (poweroff) {
 374             if (ata_power_on()) {
 375                 ret = -2;
 376                 goto error;
 377             }
 378         }
 379         else
 380 #endif
 381         {
 382             if (perform_soft_reset()) {
 383                 ret = -2;
 384                 goto error;
 385             }
 386         }
 387     }
 388
 389     timeout = current_tick + READWRITE_TIMEOUT;
 390
 391     ATA_OUT8(ATA_SELECT, ata_device);
 392     if (!wait_for_rdy())
 393     {
 394         ret = -3;
 395         goto error;
 396     }
 397
 398  retry:
 399     buf = inbuf;
 400     count = incount;
 401     while (TIME_BEFORE(current_tick, timeout)) {
 402         ret = 0;
 403         last_disk_activity = current_tick;
 404
 405 #ifdef HAVE_ATA_DMA
 406         /* If DMA is supported and parameters are ok for DMA, use it */
 407         if (dma_mode && ata_dma_setup(inbuf, incount * SECTOR_SIZE, write))
 408             usedma = true;
 409 #endif
 410
 411 #ifdef HAVE_LBA48
 412         if (lba48)
 413         {
 414             ATA_OUT8(ATA_NSECTOR, count >> 8);
 415             ATA_OUT8(ATA_NSECTOR, count & 0xff);
 416             ATA_OUT8(ATA_SECTOR, (start >> 24) & 0xff); /* 31:24 */
 417             ATA_OUT8(ATA_SECTOR, start & 0xff); /* 7:0 */
 418             ATA_OUT8(ATA_LCYL, 0); /* 39:32 */
 419             ATA_OUT8(ATA_LCYL, (start >> 8) & 0xff); /* 15:8 */
 420             ATA_OUT8(ATA_HCYL, 0); /* 47:40 */
 421             ATA_OUT8(ATA_HCYL, (start >> 16) & 0xff); /* 23:16 */
 422             ATA_OUT8(ATA_SELECT, SELECT_LBA | ata_device);
 423 #ifdef HAVE_ATA_DMA
 424             if (write)
 425                 ATA_OUT8(ATA_COMMAND, usedma ? CMD_WRITE_DMA_EXT : CMD_WRITE_MULTIPLE_EXT);
 426             else
 427                 ATA_OUT8(ATA_COMMAND, usedma ? CMD_READ_DMA_EXT : CMD_READ_MULTIPLE_EXT);
 428 #else
 429             ATA_OUT8(ATA_COMMAND, write ? CMD_WRITE_MULTIPLE_EXT : CMD_READ_MULTIPLE_EXT);
 430 #endif
 431         }
 432         else
 433 #endif
 434         {
 435             ATA_OUT8(ATA_NSECTOR, count & 0xff); /* 0 means 256 sectors */
 436             ATA_OUT8(ATA_SECTOR, start & 0xff);
 437             ATA_OUT8(ATA_LCYL, (start >> 8) & 0xff);
 438             ATA_OUT8(ATA_HCYL, (start >> 16) & 0xff);
 439             ATA_OUT8(ATA_SELECT, ((start >> 24) & 0xf) | SELECT_LBA | ata_device);
 440 #ifdef HAVE_ATA_DMA
 441             if (write)
 442                 ATA_OUT8(ATA_COMMAND, usedma ? CMD_WRITE_DMA : CMD_WRITE_MULTIPLE);
 443             else
 444                 ATA_OUT8(ATA_COMMAND, usedma ? CMD_READ_DMA : CMD_READ_MULTIPLE);
 445 #else
 446             ATA_OUT8(ATA_COMMAND, write ? CMD_WRITE_MULTIPLE : CMD_READ_MULTIPLE);
 447 #endif
 448         }
 449
 450         /* wait at least 400ns between writing command and reading status */
 451         __asm__ volatile ("nop");
 452         __asm__ volatile ("nop");
 453         __asm__ volatile ("nop");
 454         __asm__ volatile ("nop");
 455         __asm__ volatile ("nop");
 456
 457 #ifdef HAVE_ATA_DMA
 458         if (usedma) {
 459             if (!ata_dma_finish())
 460                 ret = -7;
 461
 462             if (ret != 0) {
 463                 perform_soft_reset();
 464                 goto retry;
 465             }
 466
 467             if (spinup) {
 468                 spinup_time = current_tick - spinup_start;
 469                 spinup = false;
 470 #ifdef HAVE_ATA_POWER_OFF
 471                 poweroff = false;
 472 #endif
 473             }
 474         }
 475         else
 476 #endif /* HAVE_ATA_DMA */
 477         {
 478             while (count) {
 479                 int sectors;
 480                 int wordcount;
 481                 int status;
 482                 int error;
 483
 484                 if (!wait_for_start_of_transfer()) {
 485                     /* We have timed out waiting for RDY and/or DRQ, possibly
 486                        because the hard drive is shaking and has problems
 487                        reading the data. We have two options:
 488                        1) Wait some more
 489                        2) Perform a soft reset and try again.
 490
 491                        We choose alternative 2.
 492                     */
 493                     perform_soft_reset();
 494                     ret = -5;
 495                     goto retry;
 496                 }
 497
 498                 if (spinup) {
 499                     spinup_time = current_tick - spinup_start;
 500                     spinup = false;
 501 #ifdef HAVE_ATA_POWER_OFF
 502                     poweroff = false;
 503 #endif
 504                 }
 505
 506                 /* read the status register exactly once per loop */
 507                 status = ATA_IN8(ATA_STATUS);
 508                 error = ATA_IN8(ATA_ERROR);
 509
 510                 if (count >= multisectors)
 511                     sectors = multisectors;
 512                 else
 513                     sectors = count;
 514
 515                 wordcount = sectors * SECTOR_SIZE / 2;
 516
 517                 if (write)
 518                     copy_write_sectors(buf, wordcount);
 519                 else
 520                     copy_read_sectors(buf, wordcount);
 521
 522                 /*
 523                   "Device errors encountered during READ MULTIPLE commands
 524                   are posted at the beginning of the block or partial block
 525                   transfer, but the DRQ bit is still set to one and the data
 526                   transfer shall take place, including transfer of corrupted
 527                   data, if any."
 528                     -- ATA specification
 529                 */
 530                 if ( status & (STATUS_BSY | STATUS_ERR | STATUS_DF) ) {
 531                     perform_soft_reset();
 532                     ret = -6;
 533                     /* no point retrying IDNF, sector no. was invalid */
 534                     if (error & ERROR_IDNF)
 535                         break;
 536                     goto retry;
 537                 }
 538
 539                 buf += sectors * SECTOR_SIZE; /* Advance one chunk of sectors */
 540                 count -= sectors;
 541
 542                 last_disk_activity = current_tick;
 543             }
 544         }
 545
 546         if(!ret && !wait_for_end_of_transfer()) {
 547             int error;
 548
 549             error = ATA_IN8(ATA_ERROR);
 550             perform_soft_reset();
 551             ret = -4;
 552             /* no point retrying IDNF, sector no. was invalid */
 553             if (error & ERROR_IDNF)
 554                 break;
 555             goto retry;
 556         }
 557         break;
 558     }
 559
 560   error:
 561     ata_led(false);
 562 #ifndef MAX_PHYS_SECTOR_SIZE
 563     mutex_unlock(&ata_mtx);
 564 #endif
 565
 566     return ret;
 567 }
 568
 569 #ifndef MAX_PHYS_SECTOR_SIZE
 570 int ata_read_sectors(IF_MD2(int drive,)
 571                      unsigned long start,
 572                      int incount,
 573                      void* inbuf)
 574 {
 575 #ifdef HAVE_MULTIDRIVE
 576     (void)drive; /* unused for now */
 577 #endif
 578
 579     return ata_transfer_sectors(start, incount, inbuf, false);
 580 }
 581 #endif
 582
 583 #ifndef MAX_PHYS_SECTOR_SIZE
 584 int ata_write_sectors(IF_MD2(int drive,)
 585                       unsigned long start,
 586                       int count,
 587                       const void* buf)
 588 {
 589 #ifdef HAVE_MULTIDRIVE
 590     (void)drive; /* unused for now */
 591 #endif
 592
 593     return ata_transfer_sectors(start, count, (void*)buf, true);
 594 }
 595 #endif
 596
 597 #ifdef MAX_PHYS_SECTOR_SIZE
 598 static int cache_sector(unsigned long sector)
 599 {
 600     int rc;
 601
 602     sector &= ~(phys_sector_mult - 1);
 603               /* round down to physical sector boundary */
 604
 605     /* check whether the sector is already cached */
 606     if (sector_cache.inuse && (sector_cache.sectornum == sector))
 607         return 0;
 608
 609     /* not found: read the sector */
 610     sector_cache.inuse = false;
 611     rc = ata_transfer_sectors(sector, phys_sector_mult, sector_cache.data, false);
 612     if (!rc)
 613     {
 614         sector_cache.sectornum = sector;
 615         sector_cache.inuse = true;
 616     }
 617     return rc;
 618 }
 619
 620 static inline int flush_current_sector(void)
 621 {
 622     return ata_transfer_sectors(sector_cache.sectornum, phys_sector_mult,
 623                                 sector_cache.data, true);
 624 }
 625
 626 int ata_read_sectors(IF_MD2(int drive,)
 627                      unsigned long start,
 628                      int incount,
 629                      void* inbuf)
 630 {
 631     int rc = 0;
 632     int offset;
 633
 634 #ifdef HAVE_MULTIDRIVE
 635     (void)drive; /* unused for now */
 636 #endif
 637     mutex_lock(&ata_mtx);
 638
 639     offset = start & (phys_sector_mult - 1);
 640
 641     if (offset) /* first partial sector */
 642     {
 643         int partcount = MIN(incount, phys_sector_mult - offset);
 644
 645         rc = cache_sector(start);
 646         if (rc)
 647         {
 648             rc = rc * 10 - 1;
 649             goto error;
 650         }
 651         memcpy(inbuf, sector_cache.data + offset * SECTOR_SIZE,
 652                partcount * SECTOR_SIZE);
 653
 654         start += partcount;
 655         inbuf += partcount * SECTOR_SIZE;
 656         incount -= partcount;
 657     }
 658     if (incount)
 659     {
 660         offset = incount & (phys_sector_mult - 1);
 661         incount -= offset;
 662
 663         if (incount)
 664         {
 665             rc = ata_transfer_sectors(start, incount, inbuf, false);
 666             if (rc)
 667             {
 668                 rc = rc * 10 - 2;
 669                 goto error;
 670             }
 671             start += incount;
 672             inbuf += incount * SECTOR_SIZE;
 673         }
 674         if (offset)
 675         {
 676             rc = cache_sector(start);
 677             if (rc)
 678             {
 679                 rc = rc * 10 - 3;
 680                 goto error;
 681             }
 682             memcpy(inbuf, sector_cache.data, offset * SECTOR_SIZE);
 683         }
 684     }
 685
 686   error:
 687     mutex_unlock(&ata_mtx);
 688
 689     return rc;
 690 }
 691
 692 int ata_write_sectors(IF_MD2(int drive,)
 693                       unsigned long start,
 694                       int count,
 695                       const void* buf)
 696 {
 697     int rc = 0;
 698     int offset;
 699
 700 #ifdef HAVE_MULTIDRIVE
 701     (void)drive; /* unused for now */
 702 #endif
 703     mutex_lock(&ata_mtx);
 704
 705     offset = start & (phys_sector_mult - 1);
 706
 707     if (offset) /* first partial sector */
 708     {
 709         int partcount = MIN(count, phys_sector_mult - offset);
 710
 711         rc = cache_sector(start);
 712         if (rc)
 713         {
 714             rc = rc * 10 - 1;
 715             goto error;
 716         }
 717         memcpy(sector_cache.data + offset * SECTOR_SIZE, buf,
 718                partcount * SECTOR_SIZE);
 719         rc = flush_current_sector();
 720         if (rc)
 721         {
 722             rc = rc * 10 - 2;
 723             goto error;
 724         }
 725         start += partcount;
 726         buf += partcount * SECTOR_SIZE;
 727         count -= partcount;
 728     }
 729     if (count)
 730     {
 731         offset = count & (phys_sector_mult - 1);
 732         count -= offset;
 733
 734         if (count)
 735         {
 736             rc = ata_transfer_sectors(start, count, (void*)buf, true);
 737             if (rc)
 738             {
 739                 rc = rc * 10 - 3;
 740                 goto error;
 741             }
 742             start += count;
 743             buf += count * SECTOR_SIZE;
 744         }
 745         if (offset)
 746         {
 747             rc = cache_sector(start);
 748             if (rc)
 749             {
 750                 rc = rc * 10 - 4;
 751                 goto error;
 752             }
 753             memcpy(sector_cache.data, buf, offset * SECTOR_SIZE);
 754             rc = flush_current_sector();
 755             if (rc)
 756             {
 757                 rc = rc * 10 - 5;
 758                 goto error;
 759             }
 760         }
 761     }
 762
 763   error:
 764     mutex_unlock(&ata_mtx);
 765
 766     return rc;
 767 }
 768 #endif /* MAX_PHYS_SECTOR_SIZE */
 769
 770 static int STORAGE_INIT_ATTR check_registers(void)
 771 {
 772     int i;
 773     wait_for_bsy();
 774     if (ATA_IN8(ATA_STATUS) & STATUS_BSY)
 775             return -1;
 776
 777     for (i = 0; i<64; i++) {
 778         ATA_OUT8(ATA_NSECTOR, TEST_PATTERN1);
 779         ATA_OUT8(ATA_SECTOR,  TEST_PATTERN2);
 780         ATA_OUT8(ATA_LCYL,    TEST_PATTERN3);
 781         ATA_OUT8(ATA_HCYL,    TEST_PATTERN4);
 782
 783         if (((ATA_IN8(ATA_NSECTOR) & 0xff) == TEST_PATTERN1) &&
 784             ((ATA_IN8(ATA_SECTOR) & 0xff) == TEST_PATTERN2) &&
 785             ((ATA_IN8(ATA_LCYL) & 0xff) == TEST_PATTERN3) &&
 786             ((ATA_IN8(ATA_HCYL) & 0xff) == TEST_PATTERN4))
 787             return 0;
 788
 789         sleep(1);
 790     }
 791     return -2;
 792 }
 793
 794 static int freeze_lock(void)
 795 {
 796     /* does the disk support Security Mode feature set? */
 797     if (identify_info[82] & 2)
 798     {
 799         ATA_OUT8(ATA_SELECT, ata_device);
 800
 801         if (!wait_for_rdy())
 802             return -1;
 803
 804         ATA_OUT8(ATA_COMMAND, CMD_SECURITY_FREEZE_LOCK);
 805
 806         if (!wait_for_rdy())
 807             return -2;
 808     }
 809
 810     return 0;
 811 }
 812
 813 void ata_spindown(int seconds)
 814 {
 815     sleep_timeout = seconds * HZ;
 816 }
 817
 818 bool ata_disk_is_active(void)
 819 {
 820     return !sleeping;
 821 }
 822
 823 static int ata_perform_sleep(void)
 824 {
 825     /* guard against calls made with checks of these variables outside
 826        the mutex that may not be on the ata thread; status may have changed. */
 827     if (spinup || sleeping) {
 828         return 0;
 829     }
 830
 831     ATA_OUT8(ATA_SELECT, ata_device);
 832
 833     if(!wait_for_rdy()) {
 834         DEBUGF("ata_perform_sleep() - not RDY\n");
 835         return -1;
 836     }
 837
 838     ATA_OUT8(ATA_COMMAND, CMD_SLEEP);
 839
 840     if (!wait_for_rdy())
 841     {
 842         DEBUGF("ata_perform_sleep() - CMD failed\n");
 843         return -2;
 844     }
 845
 846     sleeping = true;
 847     return 0;
 848 }
 849
 850 void ata_sleep(void)
 851 {
 852     queue_post(&ata_queue, Q_SLEEP, 0);
 853 }
 854
 855 void ata_sleepnow(void)
 856 {
 857     if (!spinup && !sleeping && initialized)
 858     {
 859         call_storage_idle_notifys(false);
 860         mutex_lock(&ata_mtx);
 861         ata_perform_sleep();
 862         mutex_unlock(&ata_mtx);
 863     }
 864 }
 865
 866 void ata_spin(void)
 867 {
 868     last_user_activity = current_tick;
 869 }
 870
 871 static void ata_thread(void)
 872 {
 873 #ifdef HAVE_ATA_POWER_OFF
 874     static long last_sleep = 0;
 875 #endif
 876     struct queue_event ev;
 877 #ifdef ALLOW_USB_SPINDOWN
 878     static bool usb_mode = false;
 879 #endif
 880
 881     while (1) {
 882         queue_wait_w_tmo(&ata_queue, &ev, HZ/2);
 883
 884         switch ( ev.id ) {
 885             case SYS_TIMEOUT:
 886                 if (!spinup && !sleeping)
 887                 {
 888                     if (TIME_AFTER( current_tick,
 889                                     last_disk_activity + (HZ*2) ) )
 890                     {
 891 #ifdef ALLOW_USB_SPINDOWN
 892                         if(!usb_mode)
 893 #endif
 894                         {
 895                             call_storage_idle_notifys(false);
 896                         }
 897                     }
 898
 899                     if ( sleep_timeout &&
 900                          TIME_AFTER( current_tick,
 901                                     last_user_activity + sleep_timeout ) &&
 902                          TIME_AFTER( current_tick,
 903                                     last_disk_activity + sleep_timeout ) )
 904                     {
 905 #ifdef ALLOW_USB_SPINDOWN
 906                         if(!usb_mode)
 907 #endif
 908                         {
 909                             call_storage_idle_notifys(true);
 910                         }
 911                         mutex_lock(&ata_mtx);
 912                         ata_perform_sleep();
 913 #ifdef HAVE_ATA_POWER_OFF
 914                         last_sleep = current_tick;
 915 #endif
 916                         mutex_unlock(&ata_mtx);
 917                     }
 918                 }
 919
 920 #ifdef HAVE_ATA_POWER_OFF
 921                 if ( !spinup && sleeping && !poweroff &&
 922                      TIME_AFTER( current_tick, last_sleep + ATA_POWER_OFF_TIMEOUT ))
 923                 {
 924                     mutex_lock(&ata_mtx);
 925                     ide_power_enable(false);
 926                     poweroff = true;
 927                     mutex_unlock(&ata_mtx);
 928                 }
 929 #endif
 930                 break;
 931
 932 #ifndef USB_NONE
 933             case SYS_USB_CONNECTED:
 934                 /* Tell the USB thread that we are safe */
 935                 DEBUGF("ata_thread got SYS_USB_CONNECTED\n");
 936 #ifdef ALLOW_USB_SPINDOWN
 937                 usb_mode = true;
 938                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
 939                 /* There is no need to force ATA power on */
 940 #else
 941                 mutex_lock(&ata_mtx);
 942                 if (sleeping) {
 943                     ata_led(true);
 944                     sleeping = false; /* set this now since it'll be on */
 945
 946 #ifdef HAVE_ATA_POWER_OFF
 947                     if (poweroff) {
 948                         ata_power_on();
 949                         poweroff = false;
 950                     }
 951                     else
 952 #endif
 953                     {
 954                         perform_soft_reset();
 955                     }
 956
 957                     ata_led(false);
 958                 }
 959                 mutex_unlock(&ata_mtx);
 960
 961                 /* Wait until the USB cable is extracted again */
 962                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
 963                 usb_wait_for_disconnect(&ata_queue);
 964 #endif
 965                 break;
 966
 967 #ifdef ALLOW_USB_SPINDOWN
 968             case SYS_USB_DISCONNECTED:
 969                 /* Tell the USB thread that we are ready again */
 970                 DEBUGF("ata_thread got SYS_USB_DISCONNECTED\n");
 971                 usb_mode = false;
 972                 break;
 973 #endif
 974 #endif /* USB_NONE */
 975
 976             case Q_SLEEP:
 977 #ifdef ALLOW_USB_SPINDOWN
 978                 if(!usb_mode)
 979 #endif
 980                 {
 981                     call_storage_idle_notifys(false);
 982                 }
 983                 last_disk_activity = current_tick - sleep_timeout + (HZ/2);
 984                 break;
 985
 986 #ifdef ATA_DRIVER_CLOSE
 987             case Q_CLOSE:
 988                 return;
 989 #endif
 990         }
 991     }
 992 }
 993
 994 /* Hardware reset protocol as specified in chapter 9.1, ATA spec draft v5 */
 995 #ifdef HAVE_ATA_POWER_OFF
 996 static int ata_hard_reset(void)
 997 #else
 998 static int STORAGE_INIT_ATTR ata_hard_reset(void)
 999 #endif
1000 {
1001     int ret;
1002
1003     mutex_lock(&ata_mtx);
1004
1005     ata_reset();
1006
1007     /* state HRR2 */
1008     ATA_OUT8(ATA_SELECT, ata_device); /* select the right device */
1009     ret = wait_for_bsy();
1010
1011     /* Massage the return code so it is 0 on success and -1 on failure */
1012     ret = ret?0:-1;
1013
1014     mutex_unlock(&ata_mtx);
1015
1016     return ret;
1017 }
1018
1019 static int perform_soft_reset(void)
1020 {
1021 /* If this code is allowed to run on a Nano, the next reads from the flash will
1022  * time out, so we disable it. It shouldn't be necessary anyway, since the
1023  * ATA -> Flash interface automatically sleeps almost immediately after the
1024  * last command.
1025  */
1026     int ret;
1027     int retry_count;
1028
1029     ATA_OUT8(ATA_SELECT, SELECT_LBA | ata_device );
1030     ATA_OUT8(ATA_CONTROL, CONTROL_nIEN|CONTROL_SRST );
1031     sleep(1); /* >= 5us */
1032
1033 #ifdef HAVE_ATA_DMA
1034     /* DMA requires INTRQ be enabled */
1035     ATA_OUT8(ATA_CONTROL, 0);
1036 #else
1037     ATA_OUT8(ATA_CONTROL, CONTROL_nIEN);
1038 #endif
1039     sleep(1); /* >2ms */
1040
1041     /* This little sucker can take up to 30 seconds */
1042     retry_count = 8;
1043     do
1044     {
1045         ret = wait_for_rdy();
1046     } while(!ret && retry_count--);
1047
1048     if (!ret)
1049         return -1;
1050
1051     if (set_features())
1052         return -2;
1053
1054     if (set_multiple_mode(multisectors))
1055         return -3;
1056
1057     if (freeze_lock())
1058         return -4;
1059
1060     return 0;
1061 }
1062
1063 int ata_soft_reset(void)
1064 {
1065     int ret;
1066
1067     mutex_lock(&ata_mtx);
1068
1069     ret = perform_soft_reset();
1070
1071     mutex_unlock(&ata_mtx);
1072     return ret;
1073 }
1074
1075 #ifdef HAVE_ATA_POWER_OFF
1076 static int ata_power_on(void)
1077 {
1078     int rc;
1079
1080     ide_power_enable(true);
1081     sleep(HZ/4); /* allow voltage to build up */
1082
1083     /* Accessing the PP IDE controller too early after powering up the disk
1084      * makes the core hang for a short time, causing an audio dropout. This
1085      * also depends on the disk; iPod Mini G2 needs at least HZ/5 to get rid
1086      * of the dropout. Since this time isn't additive (the wait_for_bsy() in
1087      * ata_hard_reset() will shortened by the same amount), it's a good idea
1088      * to do this on all HDD based targets. */
1089
1090     if( ata_hard_reset() )
1091         return -1;
1092
1093     rc = set_features();
1094     if (rc)
1095         return rc * 10 - 2;
1096
1097     if (set_multiple_mode(multisectors))
1098         return -3;
1099
1100     if (freeze_lock())
1101         return -4;
1102
1103     return 0;
1104 }
1105 #endif
1106
1107 static int STORAGE_INIT_ATTR master_slave_detect(void)
1108 {
1109     /* master? */
1110     ATA_OUT8(ATA_SELECT, 0);
1111     if (ATA_IN8(ATA_STATUS) & (STATUS_RDY|STATUS_BSY)) {
1112         ata_device = 0;
1113         DEBUGF("Found master harddisk\n");
1114     }
1115     else {
1116         /* slave? */
1117         ATA_OUT8(ATA_SELECT, SELECT_DEVICE1);
1118         if (ATA_IN8(ATA_STATUS) & (STATUS_RDY|STATUS_BSY)) {
1119             ata_device = SELECT_DEVICE1;
1120             DEBUGF("Found slave harddisk\n");
1121         }
1122         else
1123             return -1;
1124     }
1125     return 0;
1126 }
1127
1128 static int STORAGE_INIT_ATTR identify(void)
1129 {
1130     int i;
1131
1132     ATA_OUT8(ATA_SELECT, ata_device);
1133
1134     if(!wait_for_rdy()) {
1135         DEBUGF("identify() - not RDY\n");
1136         return -1;
1137     }
1138     ATA_OUT8(ATA_COMMAND, CMD_IDENTIFY);
1139
1140     if (!wait_for_start_of_transfer())
1141     {
1142         DEBUGF("identify() - CMD failed\n");
1143         return -2;
1144     }
1145
1146     for (i=0; i<SECTOR_SIZE/2; i++) {
1147         /* the IDENTIFY words are already swapped, so we need to treat
1148            this info differently that normal sector data */
1149         identify_info[i] = ATA_SWAP_IDENTIFY(ATA_IN16(ATA_DATA));
1150     }
1151
1152     return 0;
1153 }
1154
1155 static int set_multiple_mode(int sectors)
1156 {
1157     ATA_OUT8(ATA_SELECT, ata_device);
1158
1159     if(!wait_for_rdy()) {
1160         DEBUGF("set_multiple_mode() - not RDY\n");
1161         return -1;
1162     }
1163
1164     ATA_OUT8(ATA_NSECTOR, sectors);
1165     ATA_OUT8(ATA_COMMAND, CMD_SET_MULTIPLE_MODE);
1166
1167     if (!wait_for_rdy())
1168     {
1169         DEBUGF("set_multiple_mode() - CMD failed\n");
1170         return -2;
1171     }
1172
1173     return 0;
1174 }
1175
1176 #ifdef HAVE_ATA_DMA
1177 static int get_best_mode(unsigned short identword, int max, int modetype)
1178 {
1179     unsigned short testbit = BIT_N(max);
1180
1181     while (1) {
1182         if (identword & testbit)
1183             return max | modetype;
1184         testbit >>= 1;
1185         if (!testbit)
1186             return 0;
1187         max--;
1188     }
1189 }
1190 #endif
1191
1192 static int set_features(void)
1193 {
1194     static struct {
1195         unsigned char id_word;
1196         unsigned char id_bit;
1197         unsigned char subcommand;
1198         unsigned char parameter;
1199     } features[] = {
1200         { 83, 14, 0x03, 0 },   /* force PIO mode */
1201         { 83, 3, 0x05, 0x80 }, /* adv. power management: lowest w/o standby */
1202         { 83, 9, 0x42, 0x80 }, /* acoustic management: lowest noise */
1203         { 82, 6, 0xaa, 0 },    /* enable read look-ahead */
1204 #ifdef HAVE_ATA_DMA
1205         { 0, 0, 0x03, 0 },     /* DMA mode */
1206 #endif
1207     };
1208     int i;
1209     int pio_mode = 2;
1210
1211     /* Find out the highest supported PIO mode */
1212     if(identify_info[64] & 2)
1213         pio_mode = 4;
1214     else
1215         if(identify_info[64] & 1)
1216             pio_mode = 3;
1217
1218     /* Update the table: set highest supported pio mode that we also support */
1219     features[0].parameter = 8 + pio_mode;
1220
1221 #ifdef HAVE_ATA_DMA
1222     if (identify_info[53] & (1<<2))
1223         /* Ultra DMA mode info present, find a mode */
1224         dma_mode = get_best_mode(identify_info[88], ATA_MAX_UDMA, 0x40);
1225
1226     if (!dma_mode) {
1227         /* No UDMA mode found, try to find a multi-word DMA mode */
1228         dma_mode = get_best_mode(identify_info[63], ATA_MAX_MWDMA, 0x20);
1229         features[4].id_word = 63;
1230     }
1231     else
1232         features[4].id_word = 88;
1233
1234     features[4].id_bit = dma_mode & 7;
1235     features[4].parameter = dma_mode;
1236 #endif /* HAVE_ATA_DMA */
1237
1238     ATA_OUT8(ATA_SELECT, ata_device);
1239
1240     if (!wait_for_rdy()) {
1241         DEBUGF("set_features() - not RDY\n");
1242         return -1;
1243     }
1244
1245     for (i=0; i < (int)(sizeof(features)/sizeof(features[0])); i++) {
1246         if (identify_info[features[i].id_word] & BIT_N(features[i].id_bit)) {
1247             ATA_OUT8(ATA_FEATURE, features[i].subcommand);
1248             ATA_OUT8(ATA_NSECTOR, features[i].parameter);
1249             ATA_OUT8(ATA_COMMAND, CMD_SET_FEATURES);
1250
1251             if (!wait_for_rdy()) {
1252                 DEBUGF("set_features() - CMD failed\n");
1253                 return -10 - i;
1254             }
1255
1256             if((ATA_IN8(ATA_ALT_STATUS) & STATUS_ERR) && (i != 1)) {
1257                 /* some CF cards don't like advanced powermanagement
1258                    even if they mark it as supported - go figure... */
1259                 if(ATA_IN8(ATA_ERROR) & ERROR_ABRT) {
1260                     return -20 - i;
1261                 }
1262             }
1263         }
1264     }
1265
1266 #ifdef ATA_SET_PIO_TIMING
1267     ata_set_pio_timings(pio_mode);
1268 #endif
1269
1270 #ifdef HAVE_ATA_DMA
1271     ata_dma_set_mode(dma_mode);
1272 #endif
1273
1274     return 0;
1275 }
1276
1277 unsigned short* ata_get_identify(void)
1278 {
1279     return identify_info;
1280 }
1281
1282 static int STORAGE_INIT_ATTR init_and_check(bool hard_reset)
1283 {
1284     int rc;
1285
1286     if (hard_reset)
1287     {
1288         /* This should reset both master and slave, we don't yet know what's in */
1289         ata_device = 0;
1290         if (ata_hard_reset())
1291             return -1;
1292     }
1293
1294     rc = master_slave_detect();
1295     if (rc)
1296         return -10 + rc;
1297
1298     /* symptom fix: else check_registers() below may fail */
1299     if (hard_reset && !wait_for_bsy())
1300         return -20;
1301
1302     rc = check_registers();
1303     if (rc)
1304         return -30 + rc;
1305
1306     return 0;
1307 }
1308
1309 int STORAGE_INIT_ATTR ata_init(void)
1310 {
1311     int rc = 0;
1312     bool coldstart;
1313
1314     if ( !initialized ) {
1315         mutex_init(&ata_mtx);
1316         queue_init(&ata_queue, true);
1317     }
1318
1319     mutex_lock(&ata_mtx);
1320
1321     /* must be called before ata_device_init() */
1322     coldstart = ata_is_coldstart();
1323     ata_led(false);
1324     ata_device_init();
1325     sleeping = false;
1326     ata_enable(true);
1327 #ifdef MAX_PHYS_SECTOR_SIZE
1328     memset(&sector_cache, 0, sizeof(sector_cache));
1329 #endif
1330
1331     if ( !initialized ) {
1332         /* First call won't have multiple thread contention - this
1333          * may return at any point without having to unlock */
1334         mutex_unlock(&ata_mtx);
1335
1336         if (!ide_powered()) /* somebody has switched it off */
1337         {
1338             ide_power_enable(true);
1339             sleep(HZ/4); /* allow voltage to build up */
1340         }
1341
1342 #ifdef HAVE_ATA_DMA
1343         /* DMA requires INTRQ be enabled */
1344         ATA_OUT8(ATA_CONTROL, 0);
1345 #endif
1346
1347         /* first try, hard reset at cold start only */
1348         rc = init_and_check(coldstart);
1349
1350         if (rc)
1351         {   /* failed? -> second try, always with hard reset */
1352             DEBUGF("ata: init failed, retrying...\n");
1353             rc  = init_and_check(true);
1354             if (rc)
1355                 return rc;
1356         }
1357
1358         rc = identify();
1359
1360         if (rc)
1361             return -40 + rc;
1362
1363         multisectors = identify_info[47] & 0xff;
1364         if (multisectors == 0) /* Invalid multisector info, try with 16 */
1365             multisectors = 16;
1366
1367         DEBUGF("ata: %d sectors per ata request\n",multisectors);
1368
1369         total_sectors = identify_info[60] | (identify_info[61] << 16);
1370
1371 #ifdef HAVE_LBA48
1372         if (identify_info[83] & 0x0400       /* 48 bit address support */
1373             && total_sectors == 0x0FFFFFFF)  /* and disk size >= 128 GiB */
1374         {                                    /* (needs BigLBA addressing) */
1375             if (identify_info[102] || identify_info[103])
1376                 panicf("Unsupported disk size: >= 2^32 sectors");
1377
1378             total_sectors = identify_info[100] | (identify_info[101] << 16);
1379             lba48 = true; /* use BigLBA */
1380         }
1381 #endif
1382         rc = freeze_lock();
1383
1384         if (rc)
1385             return -50 + rc;
1386
1387         rc = set_features();
1388         if (rc)
1389             return -60 + rc;
1390
1391 #ifdef MAX_PHYS_SECTOR_SIZE
1392         /* Find out the physical sector size */
1393         if((identify_info[106] & 0xe000) == 0x6000)
1394             phys_sector_mult = BIT_N(identify_info[106] & 0x000f);
1395         else
1396             phys_sector_mult = 1;
1397
1398         DEBUGF("ata: %d logical sectors per phys sector", phys_sector_mult);
1399
1400         if (phys_sector_mult > 1)
1401         {
1402             /* Check if drive really needs emulation  - if we can access
1403              * sector 1 then assume the drive will handle it better than
1404              * us, and ignore the large physical sectors.
1405              */
1406             char throwaway[SECTOR_SIZE];
1407             rc = ata_transfer_sectors(1, 1, &throwaway, false);
1408             if (rc == 0)
1409                 phys_sector_mult = 1;
1410         }
1411
1412         if (phys_sector_mult > (MAX_PHYS_SECTOR_SIZE/SECTOR_SIZE))
1413             panicf("Unsupported physical sector size: %d",
1414                    phys_sector_mult * SECTOR_SIZE);
1415 #endif
1416
1417         mutex_lock(&ata_mtx); /* Balance unlock below */
1418
1419         last_disk_activity = current_tick;
1420 #ifdef ATA_DRIVER_CLOSE
1421         ata_thread_id =
1422 #endif
1423         create_thread(ata_thread, ata_stack,
1424                       sizeof(ata_stack), 0, ata_thread_name
1425                       IF_PRIO(, PRIORITY_USER_INTERFACE)
1426                       IF_COP(, CPU));
1427         initialized = true;
1428
1429     }
1430     rc = set_multiple_mode(multisectors);
1431     if (rc)
1432         rc = -70 + rc;
1433
1434     mutex_unlock(&ata_mtx);
1435     return rc;
1436 }
1437
1438 #ifdef ATA_DRIVER_CLOSE
1439 void ata_close(void)
1440 {
1441     unsigned int thread_id = ata_thread_id;
1442
1443     if (thread_id == 0)
1444         return;
1445
1446     ata_thread_id = 0;
1447
1448     queue_post(&ata_queue, Q_CLOSE, 0);
1449     thread_wait(thread_id);
1450 }
1451 #endif /* ATA_DRIVER_CLOSE */
1452
1453 #if (CONFIG_LED == LED_REAL)
1454 void ata_set_led_enabled(bool enabled)
1455 {
1456     ata_led_enabled = enabled;
1457     if (ata_led_enabled)
1458         led(ata_led_on);
1459     else
1460         led(false);
1461 }
1462 #endif
1463
1464 long ata_last_disk_activity(void)
1465 {
1466     return last_disk_activity;
1467 }
1468
1469 int ata_spinup_time(void)
1470 {
1471     return spinup_time;
1472 }
1473
1474 #ifdef STORAGE_GET_INFO
1475 void ata_get_info(IF_MD2(int drive,)struct storage_info *info)
1476 {
1477     unsigned short *src,*dest;
1478     static char vendor[8];
1479     static char product[16];
1480     static char revision[4];
1481 #ifdef HAVE_MULTIDRIVE
1482     (void)drive; /* unused for now */
1483 #endif
1484     int i;
1485     info->sector_size = SECTOR_SIZE;
1486     info->num_sectors = total_sectors;
1487
1488     src = (unsigned short*)&identify_info[27];
1489     dest = (unsigned short*)vendor;
1490     for (i=0;i<4;i++)
1491         dest[i] = htobe16(src[i]);
1492     info->vendor=vendor;
1493
1494     src = (unsigned short*)&identify_info[31];
1495     dest = (unsigned short*)product;
1496     for (i=0;i<8;i++)
1497         dest[i] = htobe16(src[i]);
1498     info->product=product;
1499
1500     src = (unsigned short*)&identify_info[23];
1501     dest = (unsigned short*)revision;
1502     for (i=0;i<2;i++)
1503         dest[i] = htobe16(src[i]);
1504     info->revision=revision;
1505 }
1506 #endif
1507
1508 #ifdef HAVE_ATA_DMA
1509 /* Returns last DMA mode as set by set_features() */
1510 int ata_get_dma_mode(void)
1511 {
1512     return dma_mode;
1513 }
1514
1515 /* Needed to allow updating while waiting for DMA to complete */
1516 void ata_keep_active(void)
1517 {
1518     last_disk_activity = current_tick;
1519 }
1520 #endif
1521
1522 #ifdef CONFIG_STORAGE_MULTI
1523 int ata_num_drives(int first_drive)
1524 {
1525     /* We don't care which logical drive number(s) we have been assigned */
1526     (void)first_drive;
1527
1528     return 1;
1529 }
1530 #endif