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