firmware/storage.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2008 by Frank Gevaerts
  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 "storage.h"
  22
  23 #define DRIVER_MASK     0xff000000
  24 #define DRIVER_OFFSET   24
  25 #define DRIVE_MASK      0x00ff0000
  26 #define DRIVE_OFFSET    16
  27 #define PARTITION_MASK  0x0000ff00
  28
  29 static unsigned int storage_drivers[NUM_DRIVES];
  30 static unsigned int num_drives;
  31
  32 int storage_num_drives(void)
  33 {
  34     return num_drives;
  35 }
  36
  37 int storage_init(void)
  38 {
  39     int rc=0;
  40     int i;
  41     num_drives=0;
  42
  43 #if (CONFIG_STORAGE & STORAGE_ATA)
  44     if ((rc=ata_init())) return rc;
  45
  46     int ata_drives = ata_num_drives(num_drives);
  47     for (i=0; i<ata_drives; i++)
  48     {
  49         storage_drivers[num_drives++] =
  50             (STORAGE_ATA<<DRIVER_OFFSET) | (i << DRIVE_OFFSET);
  51     }
  52 #endif
  53
  54 #if (CONFIG_STORAGE & STORAGE_MMC)
  55     if ((rc=mmc_init())) return rc;
  56
  57     int mmc_drives = mmc_num_drives(num_drives);
  58     for (i=0; i<mmc_drives ;i++)
  59     {
  60         storage_drivers[num_drives++] =
  61             (STORAGE_MMC<<DRIVER_OFFSET) | (i << DRIVE_OFFSET);
  62     }
  63 #endif
  64
  65 #if (CONFIG_STORAGE & STORAGE_SD)
  66     if ((rc=sd_init())) return rc;
  67
  68     int sd_drives = sd_num_drives(num_drives);
  69     for (i=0; i<sd_drives; i++)
  70     {
  71         storage_drivers[num_drives++] =
  72             (STORAGE_SD<<DRIVER_OFFSET) | (i << DRIVE_OFFSET);
  73     }
  74 #endif
  75
  76 #if (CONFIG_STORAGE & STORAGE_NAND)
  77     if ((rc=nand_init())) return rc;
  78
  79     int nand_drives = nand_num_drives(num_drives);
  80     for (i=0; i<nand_drives; i++)
  81     {
  82         storage_drivers[num_drives++] =
  83             (STORAGE_NAND<<DRIVER_OFFSET) | (i << DRIVE_OFFSET);
  84     }
  85 #endif
  86
  87 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
  88     if ((rc=ramdisk_init())) return rc;
  89
  90     int ramdisk_drives = ramdisk_num_drives(num_drives);
  91     for (i=0; i<ramdisk_drives; i++)
  92     {
  93         storage_drivers[num_drives++] =
  94             (STORAGE_RAMDISK<<DRIVER_OFFSET) | (i << DRIVE_OFFSET);
  95     }
  96 #endif
  97
  98     return 0;
  99 }
 100
 101 int storage_read_sectors(int drive, unsigned long start, int count,
 102                          void* buf)
 103 {
 104     int driver=(storage_drivers[drive] & DRIVER_MASK)>>DRIVER_OFFSET;
 105     int ldrive=(storage_drivers[drive] & DRIVE_MASK)>>DRIVE_OFFSET;
 106
 107     switch (driver)
 108     {
 109 #if (CONFIG_STORAGE & STORAGE_ATA)
 110     case STORAGE_ATA:
 111         return ata_read_sectors(ldrive,start,count,buf);
 112 #endif
 113
 114 #if (CONFIG_STORAGE & STORAGE_MMC)
 115     case STORAGE_MMC:
 116         return mmc_read_sectors(ldrive,start,count,buf);
 117 #endif
 118
 119 #if (CONFIG_STORAGE & STORAGE_SD)
 120     case STORAGE_SD:
 121         return sd_read_sectors(ldrive,start,count,buf);
 122 #endif
 123
 124 #if (CONFIG_STORAGE & STORAGE_NAND)
 125     case STORAGE_NAND:
 126         return nand_read_sectors(ldrive,start,count,buf);
 127 #endif
 128
 129 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 130     case STORAGE_RAMDISK:
 131         return ramdisk_read_sectors(ldrive,start,count,buf);
 132 #endif
 133     }
 134
 135     return -1;
 136 }
 137
 138 int storage_write_sectors(int drive, unsigned long start, int count,
 139                           const void* buf)
 140 {
 141     int driver=(storage_drivers[drive] & DRIVER_MASK)>>DRIVER_OFFSET;
 142     int ldrive=(storage_drivers[drive] & DRIVE_MASK)>>DRIVE_OFFSET;
 143
 144     switch (driver)
 145     {
 146 #if (CONFIG_STORAGE & STORAGE_ATA)
 147     case STORAGE_ATA:
 148         return ata_write_sectors(ldrive,start,count,buf);
 149 #endif
 150
 151 #if (CONFIG_STORAGE & STORAGE_MMC)
 152     case STORAGE_MMC:
 153         return mmc_write_sectors(ldrive,start,count,buf);
 154 #endif
 155
 156 #if (CONFIG_STORAGE & STORAGE_SD)
 157     case STORAGE_SD:
 158         return sd_write_sectors(ldrive,start,count,buf);
 159 #endif
 160
 161 #if (CONFIG_STORAGE & STORAGE_NAND)
 162     case STORAGE_NAND:
 163         return nand_write_sectors(ldrive,start,count,buf);
 164 #endif
 165
 166 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 167     case STORAGE_RAMDISK:
 168         return ramdisk_write_sectors(ldrive,start,count,buf);
 169 #endif
 170     }
 171
 172     return -1;
 173 }
 174
 175 void storage_enable(bool on)
 176 {
 177 #if (CONFIG_STORAGE & STORAGE_ATA)
 178     ata_enable(on);
 179 #endif
 180
 181 #if (CONFIG_STORAGE & STORAGE_MMC)
 182     mmc_enable(on);
 183 #endif
 184
 185 #if (CONFIG_STORAGE & STORAGE_SD)
 186     sd_enable(on);
 187 #endif
 188
 189 #if (CONFIG_STORAGE & STORAGE_NAND)
 190     nand_enable(on);
 191 #endif
 192
 193 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 194     ramdisk_enable(on);
 195 #endif
 196 }
 197
 198 void storage_sleep(void)
 199 {
 200 #if (CONFIG_STORAGE & STORAGE_ATA)
 201     ata_sleep();
 202 #endif
 203
 204 #if (CONFIG_STORAGE & STORAGE_MMC)
 205     mmc_sleep();
 206 #endif
 207
 208 #if (CONFIG_STORAGE & STORAGE_SD)
 209     sd_sleep();
 210 #endif
 211
 212 #if (CONFIG_STORAGE & STORAGE_NAND)
 213     nand_sleep();
 214 #endif
 215
 216 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 217     ramdisk_sleep();
 218 #endif
 219 }
 220
 221 void storage_sleepnow(void)
 222 {
 223 #if (CONFIG_STORAGE & STORAGE_ATA)
 224     ata_sleepnow();
 225 #endif
 226
 227 #if (CONFIG_STORAGE & STORAGE_MMC)
 228     mmc_sleepnow();
 229 #endif
 230
 231 #if (CONFIG_STORAGE & STORAGE_SD)
 232     //sd_sleepnow();
 233 #endif
 234
 235 #if (CONFIG_STORAGE & STORAGE_NAND)
 236     nand_sleepnow();
 237 #endif
 238
 239 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 240     ramdisk_sleepnow();
 241 #endif
 242 }
 243
 244 bool storage_disk_is_active(void)
 245 {
 246 #if (CONFIG_STORAGE & STORAGE_ATA)
 247     if (ata_disk_is_active()) return true;
 248 #endif
 249
 250 #if (CONFIG_STORAGE & STORAGE_MMC)
 251     if (mmc_disk_is_active()) return true;
 252 #endif
 253
 254 #if (CONFIG_STORAGE & STORAGE_SD)
 255     //if (sd_disk_is_active()) return true;
 256 #endif
 257
 258 #if (CONFIG_STORAGE & STORAGE_NAND)
 259     //if (nand_disk_is_active()) return true;
 260 #endif
 261
 262 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 263     if (ramdisk_disk_is_active()) return true;
 264 #endif
 265
 266     return false;
 267 }
 268
 269 int storage_soft_reset(void)
 270 {
 271     int rc=0;
 272
 273 #if (CONFIG_STORAGE & STORAGE_ATA)
 274     if ((rc=ata_soft_reset())) return rc;
 275 #endif
 276
 277 #if (CONFIG_STORAGE & STORAGE_MMC)
 278     if ((rc=mmc_soft_reset())) return rc;
 279 #endif
 280
 281 #if (CONFIG_STORAGE & STORAGE_SD)
 282     //if ((rc=sd_soft_reset())) return rc;
 283 #endif
 284
 285 #if (CONFIG_STORAGE & STORAGE_NAND)
 286     //if ((rc=nand_soft_reset())) return rc;
 287 #endif
 288
 289 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 290     if ((rc=ramdisk_soft_reset())) return rc;
 291 #endif
 292
 293     return rc;
 294 }
 295
 296 #ifdef HAVE_STORAGE_FLUSH
 297 int storage_flush(void)
 298 {
 299     int rc=0;
 300
 301 #if (CONFIG_STORAGE & STORAGE_ATA)
 302     //if ((rc=ata_flush())) return rc;
 303 #endif
 304
 305 #if (CONFIG_STORAGE & STORAGE_MMC)
 306     //if ((rc=mmc_flush())) return rc;
 307 #endif
 308
 309 #if (CONFIG_STORAGE & STORAGE_SD)
 310     //if ((rc=sd_flush())) return rc;
 311 #endif
 312
 313 #if (CONFIG_STORAGE & STORAGE_NAND)
 314     if ((rc=nand_flush())) return rc;
 315 #endif
 316
 317 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 318     //if ((rc=ramdisk_flush())) return rc;
 319 #endif
 320
 321     return rc;
 322 }
 323 #endif
 324
 325 void storage_spin(void)
 326 {
 327 #if (CONFIG_STORAGE & STORAGE_ATA)
 328     ata_spin();
 329 #endif
 330
 331 #if (CONFIG_STORAGE & STORAGE_MMC)
 332     mmc_spin();
 333 #endif
 334
 335 #if (CONFIG_STORAGE & STORAGE_SD)
 336     sd_spin();
 337 #endif
 338
 339 #if (CONFIG_STORAGE & STORAGE_NAND)
 340     nand_spin();
 341 #endif
 342
 343 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 344     ramdisk_spin();
 345 #endif
 346 }
 347
 348 void storage_spindown(int seconds)
 349 {
 350 #if (CONFIG_STORAGE & STORAGE_ATA)
 351     ata_spindown(seconds);
 352 #endif
 353
 354 #if (CONFIG_STORAGE & STORAGE_MMC)
 355     mmc_spindown(seconds);
 356 #endif
 357
 358 #if (CONFIG_STORAGE & STORAGE_SD)
 359     sd_spindown(seconds);
 360 #endif
 361
 362 #if (CONFIG_STORAGE & STORAGE_NAND)
 363     nand_spindown(seconds);
 364 #endif
 365
 366 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 367     ramdisk_spindown(seconds);
 368 #endif
 369 }
 370
 371 #if (CONFIG_LED == LED_REAL)
 372 void storage_set_led_enabled(bool enabled)
 373 {
 374 #if (CONFIG_STORAGE & STORAGE_ATA)
 375     ata_set_led_enabled(enabled);
 376 #endif
 377
 378 #if (CONFIG_STORAGE & STORAGE_MMC)
 379     mmc_set_led_enabled(enabled);
 380 #endif
 381
 382 #if (CONFIG_STORAGE & STORAGE_SD)
 383     sd_set_led_enabled(enabled);
 384 #endif
 385
 386 #if (CONFIG_STORAGE & STORAGE_NAND)
 387     nand_set_led_enabled(enabled);
 388 #endif
 389
 390 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 391     ramdisk_set_led_enabled(enabled);
 392 #endif
 393 }
 394 #endif /* CONFIG_LED == LED_REAL */
 395
 396 long storage_last_disk_activity(void)
 397 {
 398     long max=0;
 399     long t;
 400
 401 #if (CONFIG_STORAGE & STORAGE_ATA)
 402     t=ata_last_disk_activity();
 403     if (t>max) max=t;
 404 #endif
 405
 406 #if (CONFIG_STORAGE & STORAGE_MMC)
 407     t=mmc_last_disk_activity();
 408     if (t>max) max=t;
 409 #endif
 410
 411 #if (CONFIG_STORAGE & STORAGE_SD)
 412     t=sd_last_disk_activity();
 413     if (t>max) max=t;
 414 #endif
 415
 416 #if (CONFIG_STORAGE & STORAGE_NAND)
 417     t=nand_last_disk_activity();
 418     if (t>max) max=t;
 419 #endif
 420
 421 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 422     t=ramdisk_last_disk_activity();
 423     if (t>max) max=t;
 424 #endif
 425
 426     return max;
 427 }
 428
 429 int storage_spinup_time(void)
 430 {
 431     int max=0;
 432     int t;
 433
 434 #if (CONFIG_STORAGE & STORAGE_ATA)
 435     t=ata_spinup_time();
 436     if (t>max) max=t;
 437 #endif
 438
 439 #if (CONFIG_STORAGE & STORAGE_MMC)
 440     t=mmc_spinup_time();
 441     if (t>max) max=t;
 442 #endif
 443
 444 #if (CONFIG_STORAGE & STORAGE_SD)
 445     //t=sd_spinup_time();
 446     //if (t>max) max=t;
 447 #endif
 448
 449 #if (CONFIG_STORAGE & STORAGE_NAND)
 450     t=nand_spinup_time();
 451     if (t>max) max=t;
 452 #endif
 453
 454 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 455     t=ramdisk_spinup_time();
 456     if (t>max) max=t;
 457 #endif
 458
 459     return max;
 460 }
 461
 462 #ifdef STORAGE_GET_INFO
 463 void storage_get_info(int drive, struct storage_info *info)
 464 {
 465     int driver=(storage_drivers[drive] & DRIVER_MASK)>>DRIVER_OFFSET;
 466     int ldrive=(storage_drivers[drive] & DRIVE_MASK)>>DRIVE_OFFSET;
 467
 468     switch(driver)
 469     {
 470 #if (CONFIG_STORAGE & STORAGE_ATA)
 471     case STORAGE_ATA:
 472         return ata_get_info(ldrive,info);
 473 #endif
 474
 475 #if (CONFIG_STORAGE & STORAGE_MMC)
 476     case STORAGE_MMC:
 477         return mmc_get_info(ldrive,info);
 478 #endif
 479
 480 #if (CONFIG_STORAGE & STORAGE_SD)
 481     case STORAGE_SD:
 482         return sd_get_info(ldrive,info);
 483 #endif
 484
 485 #if (CONFIG_STORAGE & STORAGE_NAND)
 486     case STORAGE_NAND:
 487         return nand_get_info(ldrive,info);
 488 #endif
 489
 490 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 491     case STORAGE_RAMDISK:
 492         return ramdisk_get_info(ldrive,info);
 493 #endif
 494     }
 495 }
 496 #endif /* STORAGE_GET_INFO */
 497
 498 #ifdef HAVE_HOTSWAP
 499 bool storage_removable(int drive)
 500 {
 501     bool ret = false;
 502
 503     int driver=(storage_drivers[drive] & DRIVER_MASK)>>DRIVER_OFFSET;
 504     int ldrive=(storage_drivers[drive] & DRIVE_MASK)>>DRIVE_OFFSET;
 505
 506     switch(driver)
 507     {
 508 #if (CONFIG_STORAGE & STORAGE_ATA)
 509     case STORAGE_ATA:
 510         ret = ata_removable(ldrive);
 511 #endif
 512
 513 #if (CONFIG_STORAGE & STORAGE_MMC)
 514     case STORAGE_MMC:
 515         ret = mmc_removable(ldrive);
 516 #endif
 517
 518 #if (CONFIG_STORAGE & STORAGE_SD)
 519     case STORAGE_SD:
 520         ret = sd_removable(ldrive);
 521 #endif
 522
 523 #if (CONFIG_STORAGE & STORAGE_NAND)
 524     case STORAGE_NAND:
 525         ret = false;
 526 #endif
 527
 528 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 529     case STORAGE_RAMDISK:
 530         ret = false;
 531 #endif
 532     }
 533
 534     return ret;
 535 }
 536
 537 bool storage_present(int drive)
 538 {
 539     bool ret = false;
 540
 541     int driver=(storage_drivers[drive] & DRIVER_MASK)>>DRIVER_OFFSET;
 542     int ldrive=(storage_drivers[drive] & DRIVE_MASK)>>DRIVE_OFFSET;
 543
 544     switch(driver)
 545     {
 546 #if (CONFIG_STORAGE & STORAGE_ATA)
 547     case STORAGE_ATA:
 548         ret = ata_present(ldrive);
 549 #endif
 550
 551 #if (CONFIG_STORAGE & STORAGE_MMC)
 552     case STORAGE_MMC:
 553         ret = mmc_present(ldrive);
 554 #endif
 555
 556 #if (CONFIG_STORAGE & STORAGE_SD)
 557     case STORAGE_SD:
 558         ret = sd_present(ldrive);
 559 #endif
 560
 561 #if (CONFIG_STORAGE & STORAGE_NAND)
 562     case STORAGE_NAND:
 563         ret = true;
 564 #endif
 565
 566 #if (CONFIG_STORAGE & STORAGE_RAMDISK)
 567     case STORAGE_RAMDISK:
 568         ret = true;
 569 #endif
 570     }
 571
 572     return ret;
 573 }
 574 #endif