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