firmware/usb.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Linus Nielsen Feltzing
  11  *
  12  * iPod driver based on code from the ipodlinux project - http://ipodlinux.org
  13  * Adapted for Rockbox in January 2006
  14  * Original file: podzilla/usb.c
  15  * Copyright (C) 2005 Adam Johnston
  16  *
  17  * This program is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU General Public License
  19  * as published by the Free Software Foundation; either version 2
  20  * of the License, or (at your option) any later version.
  21  *
  22  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  23  * KIND, either express or implied.
  24  *
  25  ****************************************************************************/
  26 #include "config.h"
  27 #include "cpu.h"
  28 #include "kernel.h"
  29 #include "thread.h"
  30 #include "system.h"
  31 #include "debug.h"
  32 #include "storage.h"
  33 #include "fat.h"
  34 #include "disk.h"
  35 #include "panic.h"
  36 #include "lcd.h"
  37 #include "usb-target.h"
  38 #include "usb.h"
  39 #include "button.h"
  40 #include "string.h"
  41 #ifdef HAVE_USBSTACK
  42 #include "usb_core.h"
  43 #endif
  44 #include "logf.h"
  45 #include "screendump.h"
  46
  47 /* Conditions under which we want the entire driver */
  48 #if !defined(BOOTLOADER) || (CONFIG_CPU == SH7034) || \
  49      (defined(TOSHIBA_GIGABEAT_S) && defined(USE_ROCKBOX_USB) && defined(USB_ENABLE_STORAGE)) || \
  50      (defined(HAVE_USBSTACK) && (defined(CREATIVE_ZVx))) || \
  51      (defined(HAVE_USBSTACK) && (defined(OLYMPUS_MROBE_500))) || \
  52      (defined(HAVE_USBSTACK) && (defined(IPOD_NANO2G))) || \
  53      defined(CPU_TCC77X) || defined(CPU_TCC780X) || \
  54      (CONFIG_USBOTG == USBOTG_JZ4740)
  55 #define USB_FULL_INIT
  56 #endif
  57
  58 #ifdef HAVE_LCD_BITMAP
  59 bool do_screendump_instead_of_usb = false;
  60 #endif
  61
  62 #if !defined(SIMULATOR) && !defined(USB_NONE)
  63
  64 static int usb_state;
  65
  66 #if (CONFIG_STORAGE & STORAGE_MMC) && defined(USB_FULL_INIT)
  67 static int usb_mmc_countdown = 0;
  68 #endif
  69
  70 /* FIXME: The extra 0x800 is consumed by fat_mount() when the fsinfo
  71    needs updating */
  72 #ifdef USB_FULL_INIT
  73 static long usb_stack[(DEFAULT_STACK_SIZE + 0x800)/sizeof(long)];
  74 static const char usb_thread_name[] = "usb";
  75 static unsigned int usb_thread_entry = 0;
  76 #ifndef USB_STATUS_BY_EVENT
  77 #define NUM_POLL_READINGS (HZ/5)
  78 static int countdown;
  79 #endif /* USB_STATUS_BY_EVENT */
  80 #endif /* USB_FULL_INIT */
  81 static struct event_queue usb_queue;
  82 static bool usb_monitor_enabled;
  83 static int last_usb_status;
  84 #ifdef HAVE_USBSTACK
  85 static bool exclusive_storage_access;
  86 #endif
  87
  88 #ifdef USB_FIREWIRE_HANDLING
  89 static int firewire_countdown;
  90 static bool last_firewire_status;
  91 #endif
  92
  93 #ifdef USB_FULL_INIT
  94
  95 #if defined(USB_FIREWIRE_HANDLING) \
  96     || (defined(HAVE_USBSTACK) && !defined(USE_ROCKBOX_USB))
  97 static void try_reboot(void)
  98 {
  99 #ifdef HAVE_DISK_STORAGE
 100     storage_sleepnow(); /* Immediately spindown the disk. */
 101     sleep(HZ*2);
 102 #endif
 103
 104 #ifdef IPOD_ARCH  /* The following code is based on ipodlinux */
 105 #if CONFIG_CPU == PP5020
 106     memcpy((void *)0x40017f00, "diskmode\0\0hotstuff\0\0\1", 21);
 107 #elif CONFIG_CPU == PP5022
 108     memcpy((void *)0x4001ff00, "diskmode\0\0hotstuff\0\0\1", 21);
 109 #endif /* CONFIG_CPU */
 110 #endif /* IPOD_ARCH */
 111
 112 #ifdef IPOD_NANO2G
 113     memcpy((void *)0x0002bf00, "diskmodehotstuff\1\0\0\0", 20);
 114 #endif
 115
 116     system_reboot(); /* Reboot */
 117 }
 118 #endif /* USB_FIRWIRE_HANDLING || (HAVE_USBSTACK && !USE_ROCKBOX_USB) */
 119
 120 #ifdef HAVE_USBSTACK
 121 /* inline since branch is chosen at compile time */
 122 static inline void usb_slave_mode(bool on)
 123 {
 124 #ifdef USE_ROCKBOX_USB
 125     int rc;
 126
 127     if (on)
 128     {
 129         trigger_cpu_boost();
 130 #ifdef HAVE_PRIORITY_SCHEDULING
 131         thread_set_priority(THREAD_ID_CURRENT, PRIORITY_REALTIME);
 132 #endif
 133         usb_attach();
 134     }
 135     else /* usb_state == USB_INSERTED (only!) */
 136     {
 137 #ifndef USB_DETECT_BY_DRV
 138         usb_enable(false);
 139 #endif
 140 #ifdef HAVE_PRIORITY_SCHEDULING
 141         thread_set_priority(THREAD_ID_CURRENT, PRIORITY_SYSTEM);
 142 #endif
 143         /* Entered exclusive mode */
 144         rc = disk_mount_all();
 145         if (rc <= 0) /* no partition */
 146             panicf("mount: %d",rc);
 147
 148         cancel_cpu_boost();
 149     }
 150 #else /* !USE_ROCKBOX_USB */
 151     if (on)
 152     {
 153         /* until we have native mass-storage mode, we want to reboot on
 154            usb host connect */
 155         try_reboot();
 156     }
 157 #endif /* USE_ROCKBOX_USB */
 158 }
 159
 160 void usb_signal_transfer_completion(
 161     struct usb_transfer_completion_event_data* event_data)
 162 {
 163     queue_post(&usb_queue, USB_TRANSFER_COMPLETION, (intptr_t)event_data);
 164 }
 165 #else  /* !HAVE_USBSTACK */
 166 /* inline since branch is chosen at compile time */
 167 static inline void usb_slave_mode(bool on)
 168 {
 169     int rc;
 170
 171     if(on)
 172     {
 173         DEBUGF("Entering USB slave mode\n");
 174         storage_soft_reset();
 175         storage_init();
 176         storage_enable(false);
 177         usb_enable(true);
 178         cpu_idle_mode(true);
 179     }
 180     else
 181     {
 182         DEBUGF("Leaving USB slave mode\n");
 183
 184         cpu_idle_mode(false);
 185
 186         /* Let the ISDx00 settle */
 187         sleep(HZ*1);
 188
 189         usb_enable(false);
 190
 191         rc = storage_init();
 192         if(rc)
 193             panicf("storage: %d",rc);
 194
 195         rc = disk_mount_all();
 196         if (rc <= 0) /* no partition */
 197             panicf("mount: %d",rc);
 198     }
 199 }
 200 #endif /* HAVE_USBSTACK */
 201
 202 #ifdef HAVE_USB_POWER
 203 static inline bool usb_power_button(void)
 204 {
 205 #if (defined(IRIVER_H10) || defined (IRIVER_H10_5GB)) && !defined(USE_ROCKBOX_USB)
 206     return (button_status() & ~USBPOWER_BTN_IGNORE) != USBPOWER_BUTTON;
 207 #else
 208     return (button_status() & ~USBPOWER_BTN_IGNORE) == USBPOWER_BUTTON;
 209 #endif
 210 }
 211
 212 #ifdef USB_FIREWIRE_HANDLING
 213 static inline bool usb_reboot_button(void)
 214 {
 215     return (button_status() & ~USBPOWER_BTN_IGNORE) != USBPOWER_BUTTON;
 216 }
 217 #endif
 218 #endif /* HAVE_USB_POWER */
 219
 220 #ifdef USB_ENABLE_HID
 221 static bool usb_hid = true;
 222 #endif
 223
 224 static void usb_thread(void)
 225 {
 226     int num_acks_to_expect = 0;
 227     struct queue_event ev;
 228
 229     while(1)
 230     {
 231         queue_wait(&usb_queue, &ev);
 232         switch(ev.id)
 233         {
 234 #ifdef USB_DRIVER_CLOSE
 235             case USB_QUIT:
 236                 return;
 237 #endif
 238 #ifdef HAVE_USBSTACK
 239             case USB_TRANSFER_COMPLETION:
 240                 usb_core_handle_transfer_completion(
 241                     (struct usb_transfer_completion_event_data*)ev.data);
 242                 break;
 243 #endif
 244 #ifdef USB_DETECT_BY_DRV
 245             /* In this case, these events the handle cable insertion USB
 246              * driver determines INSERTED/EXTRACTED state. */
 247             case USB_POWERED:
 248                 /* Set the state to USB_POWERED for now and enable the driver
 249                  * to detect a bus reset only. If a bus reset is detected,
 250                  * USB_INSERTED will be received. */
 251                 usb_state = USB_POWERED;
 252                 usb_enable(true);
 253                 break;
 254
 255             case USB_UNPOWERED:
 256                 usb_enable(false);
 257                 /* This part shouldn't be obligatory for anything that can
 258                  * reliably detect removal of the data lines. USB_EXTRACTED
 259                  * could be posted on that event while bus power remains
 260                  * available. */
 261                 queue_post(&usb_queue, USB_EXTRACTED, 0);
 262                 break;
 263 #endif /* USB_DETECT_BY_DRV */
 264             case USB_INSERTED:
 265 #ifdef HAVE_LCD_BITMAP
 266                 if(do_screendump_instead_of_usb)
 267                 {
 268                     usb_state = USB_SCREENDUMP;
 269                     screen_dump();
 270 #ifdef HAVE_REMOTE_LCD
 271                     remote_screen_dump();
 272 #endif
 273                     break;
 274                 }
 275 #endif
 276 #ifdef HAVE_USB_POWER
 277                 if(usb_power_button())
 278                 {
 279                     /* Only charging is desired */
 280                     usb_state = USB_POWERED;
 281 #ifdef HAVE_USBSTACK
 282 #ifdef USB_ENABLE_STORAGE
 283                     usb_core_enable_driver(USB_DRIVER_MASS_STORAGE, false);
 284 #endif
 285
 286 #ifdef USB_ENABLE_HID
 287 #ifdef USB_ENABLE_CHARGING_ONLY
 288                     usb_core_enable_driver(USB_DRIVER_HID, false);
 289 #else
 290                     usb_core_enable_driver(USB_DRIVER_HID, true);
 291 #endif /* USB_ENABLE_CHARGING_ONLY */
 292 #endif /* USB_ENABLE_HID */
 293
 294 #ifdef USB_ENABLE_CHARGING_ONLY
 295                     usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY, true);
 296 #endif
 297                     usb_attach();
 298 #endif
 299                     break;
 300                 }
 301 #endif /* HAVE_USB_POWER */
 302 #ifdef HAVE_USBSTACK
 303 #ifdef HAVE_USB_POWER
 304                 /* Set the state to USB_POWERED for now. If permission to connect
 305                  * by threads and storage is granted it will be changed to
 306                  * USB_CONNECTED. */
 307                 usb_state = USB_POWERED;
 308 #endif
 309 #ifdef USB_ENABLE_STORAGE
 310                 usb_core_enable_driver(USB_DRIVER_MASS_STORAGE, true);
 311 #endif
 312 #ifdef USB_ENABLE_HID
 313                 usb_core_enable_driver(USB_DRIVER_HID, usb_hid);
 314 #endif
 315 #ifdef USB_ENABLE_CHARGING_ONLY
 316                 usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY, false);
 317 #endif
 318
 319                 /* Check any drivers enabled at this point for exclusive storage
 320                  * access requirements. */
 321                 exclusive_storage_access = usb_core_any_exclusive_storage();
 322
 323                 if(!exclusive_storage_access)
 324                 {
 325                     usb_attach();
 326                     break;
 327                 }
 328 #endif /* HAVE_USBSTACK */
 329                 /* Tell all threads that they have to back off the storage.
 330                    We subtract one for our own thread. */
 331                 num_acks_to_expect = queue_broadcast(SYS_USB_CONNECTED, 0) - 1;
 332                 DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
 333                        num_acks_to_expect);
 334                 break;
 335
 336             case SYS_USB_CONNECTED_ACK:
 337                 if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
 338                 {
 339                     DEBUGF("All threads have acknowledged the connect.\n");
 340                     usb_slave_mode(true);
 341                     usb_state = USB_INSERTED;
 342                 }
 343                 else
 344                 {
 345                     DEBUGF("usb: got ack, %d to go...\n",
 346                            num_acks_to_expect);
 347                 }
 348                 break;
 349
 350             case USB_EXTRACTED:
 351 #ifdef HAVE_LCD_BITMAP
 352                 if(usb_state == USB_SCREENDUMP)
 353                 {
 354                     usb_state = USB_EXTRACTED;
 355                     break; /* Connected for screendump only */
 356                 }
 357 #endif
 358 #ifndef HAVE_USBSTACK /* Stack must undo this if POWERED state was transitional */
 359 #ifdef HAVE_USB_POWER
 360                 if(usb_state == USB_POWERED)
 361                 {
 362                     usb_state = USB_EXTRACTED;
 363                     break;
 364                 }
 365 #endif
 366 #endif /* HAVE_USBSTACK */
 367                 if(usb_state == USB_INSERTED)
 368                 {
 369                     /* Only disable the USB mode if we really have enabled it
 370                        some threads might not have acknowledged the
 371                        insertion */
 372                     usb_slave_mode(false);
 373                 }
 374
 375                 usb_state = USB_EXTRACTED;
 376 #ifdef HAVE_USBSTACK
 377                 if(!exclusive_storage_access)
 378                 {
 379 #ifndef USB_DETECT_BY_DRV /* Disabled handling USB_UNPOWERED */
 380                     usb_enable(false);
 381 #endif
 382                     break;
 383                 }
 384
 385 #endif /* HAVE_USBSTACK */
 386                 num_acks_to_expect = usb_release_exclusive_storage();
 387
 388                 break;
 389
 390             case SYS_USB_DISCONNECTED_ACK:
 391                 if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
 392                 {
 393                     DEBUGF("All threads have acknowledged. "
 394                            "We're in business.\n");
 395                 }
 396                 else
 397                 {
 398                     DEBUGF("usb: got ack, %d to go...\n",
 399                            num_acks_to_expect);
 400                 }
 401                 break;
 402
 403 #ifdef HAVE_HOTSWAP
 404             case SYS_HOTSWAP_INSERTED:
 405             case SYS_HOTSWAP_EXTRACTED:
 406 #ifdef HAVE_USBSTACK
 407                 usb_core_hotswap_event(1,ev.id == SYS_HOTSWAP_INSERTED);
 408 #else  /* !HAVE_USBSTACK */
 409                 if(usb_state == USB_INSERTED)
 410                 {
 411                     usb_enable(false);
 412 #if (CONFIG_STORAGE & STORAGE_MMC)
 413                     usb_mmc_countdown = HZ/2; /* re-enable after 0.5 sec */
 414 #endif /* STORAGE_MMC */
 415                 }
 416 #endif /* HAVE_USBSTACK */
 417                 break;
 418
 419 #if (CONFIG_STORAGE & STORAGE_MMC)
 420             case USB_REENABLE:
 421                 if(usb_state == USB_INSERTED)
 422                     usb_enable(true);  /* reenable only if still inserted */
 423                 break;
 424 #endif /* STORAGE_MMC */
 425 #endif /* HAVE_HOTSWAP */
 426
 427 #ifdef USB_FIREWIRE_HANDLING
 428             case USB_REQUEST_REBOOT:
 429 #ifdef HAVE_USB_POWER
 430                 if (usb_reboot_button())
 431 #endif
 432                     try_reboot();
 433                 break;
 434 #endif /* USB_FIREWIRE_HANDLING */
 435         }
 436     }
 437 }
 438
 439 #ifdef USB_STATUS_BY_EVENT
 440 void usb_status_event(int current_status)
 441 {
 442     /* Caller isn't expected to filter for changes in status.
 443      * current_status:
 444      *   USB_DETECT_BY_DRV: USB_POWERED, USB_UNPOWERED, USB_INSERTED (driver)
 445      *                else: USB_INSERTED, USB_EXTRACTED
 446      */
 447     if(usb_monitor_enabled)
 448     {
 449         int oldstatus = disable_irq_save(); /* Dual-use function */
 450
 451         if(last_usb_status != current_status)
 452         {
 453             last_usb_status = current_status;
 454             queue_post(&usb_queue, current_status, 0);
 455         }
 456
 457         restore_irq(oldstatus);
 458     }
 459 }
 460
 461 void usb_start_monitoring(void)
 462 {
 463     int oldstatus = disable_irq_save(); /* Sync to event */
 464     int status = usb_detect();
 465
 466     usb_monitor_enabled = true;
 467
 468 #ifdef USB_DETECT_BY_DRV
 469     status = (status == USB_INSERTED) ? USB_POWERED : USB_UNPOWERED;
 470 #endif
 471     usb_status_event(status);
 472
 473 #ifdef USB_FIREWIRE_HANDLING
 474     if (firewire_detect())
 475         usb_firewire_connect_event();
 476 #endif
 477
 478     restore_irq(oldstatus);
 479 }
 480
 481 #ifdef USB_FIREWIRE_HANDLING
 482 void usb_firewire_connect_event(void)
 483 {
 484     queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 485 }
 486 #endif /* USB_FIREWIRE_HANDLING */
 487 #else /* !USB_STATUS_BY_EVENT */
 488 static void usb_tick(void)
 489 {
 490     int current_status;
 491
 492     if(usb_monitor_enabled)
 493     {
 494 #ifdef USB_FIREWIRE_HANDLING
 495         int current_firewire_status = firewire_detect();
 496         if(current_firewire_status != last_firewire_status)
 497         {
 498             last_firewire_status = current_firewire_status;
 499             firewire_countdown = NUM_POLL_READINGS;
 500         }
 501         else
 502         {
 503             /* Count down until it gets negative */
 504             if(firewire_countdown >= 0)
 505                 firewire_countdown--;
 506
 507             /* Report to the thread if we have had 3 identical status
 508                readings in a row */
 509             if(firewire_countdown == 0)
 510             {
 511                 queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 512             }
 513         }
 514 #endif /* USB_FIREWIRE_HANDLING */
 515
 516         current_status = usb_detect();
 517
 518         /* Only report when the status has changed */
 519         if(current_status != last_usb_status)
 520         {
 521             last_usb_status = current_status;
 522             countdown = NUM_POLL_READINGS;
 523         }
 524         else
 525         {
 526             /* Count down until it gets negative */
 527             if(countdown >= 0)
 528                 countdown--;
 529
 530             /* Report to the thread if we have had 3 identical status
 531                readings in a row */
 532             if(countdown == 0)
 533             {
 534                 queue_post(&usb_queue, current_status, 0);
 535             }
 536         }
 537     }
 538 #if (CONFIG_STORAGE & STORAGE_MMC)
 539     if(usb_mmc_countdown > 0)
 540     {
 541         usb_mmc_countdown--;
 542         if (usb_mmc_countdown == 0)
 543             queue_post(&usb_queue, USB_REENABLE, 0);
 544     }
 545 #endif
 546 }
 547
 548 void usb_start_monitoring(void)
 549 {
 550     usb_monitor_enabled = true;
 551 }
 552 #endif /* USB_STATUS_BY_EVENT */
 553 #endif /* USB_FULL_INIT */
 554
 555 void usb_acknowledge(long id)
 556 {
 557     queue_post(&usb_queue, id, 0);
 558 }
 559
 560 void usb_init(void)
 561 {
 562     /* We assume that the USB cable is extracted */
 563     usb_state = USB_EXTRACTED;
 564 #ifdef USB_DETECT_BY_DRV
 565     last_usb_status = USB_UNPOWERED;
 566 #else
 567     last_usb_status = USB_EXTRACTED;
 568 #endif
 569     usb_monitor_enabled = false;
 570
 571 #ifdef HAVE_USBSTACK
 572     exclusive_storage_access = false;
 573 #endif
 574
 575 #ifdef USB_FIREWIRE_HANDLING
 576     firewire_countdown = -1;
 577     last_firewire_status = false;
 578 #endif
 579
 580     usb_init_device();
 581 #ifdef USB_FULL_INIT
 582     usb_enable(false);
 583
 584     queue_init(&usb_queue, true);
 585
 586     usb_thread_entry = create_thread(usb_thread, usb_stack,
 587                        sizeof(usb_stack), 0, usb_thread_name
 588                        IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU));
 589
 590 #ifndef USB_STATUS_BY_EVENT
 591     countdown = -1;
 592     tick_add_task(usb_tick);
 593 #endif
 594 #endif /* USB_FULL_INIT */
 595 }
 596
 597 void usb_wait_for_disconnect(struct event_queue *q)
 598 {
 599 #ifdef USB_FULL_INIT
 600     struct queue_event ev;
 601
 602     /* Don't return until we get SYS_USB_DISCONNECTED */
 603     while(1)
 604     {
 605         queue_wait(q, &ev);
 606         if(ev.id == SYS_USB_DISCONNECTED)
 607         {
 608             usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 609             return;
 610         }
 611     }
 612 #else
 613     (void)q;
 614 #endif /* USB_FULL_INIT */
 615 }
 616
 617 int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks)
 618 {
 619 #ifdef USB_FULL_INIT
 620     struct queue_event ev;
 621
 622     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
 623     while(1)
 624     {
 625         queue_wait_w_tmo(q, &ev, ticks);
 626         switch(ev.id)
 627         {
 628             case SYS_USB_DISCONNECTED:
 629                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 630                 return 0;
 631             case SYS_TIMEOUT:
 632                 return 1;
 633         }
 634     }
 635 #else
 636     (void)q; (void)ticks;
 637     return 0;
 638 #endif /* USB_FULL_INIT */
 639 }
 640
 641 #ifdef USB_DRIVER_CLOSE
 642 void usb_close(void)
 643 {
 644     unsigned int thread = usb_thread_entry;
 645     usb_thread_entry = 0;
 646
 647     if (thread == 0)
 648         return;
 649
 650 #ifndef USB_STATUS_BY_EVENT
 651     tick_remove_task(usb_tick);
 652 #endif
 653     usb_monitor_enabled = false;
 654
 655     queue_post(&usb_queue, USB_QUIT, 0);
 656     thread_wait(thread);
 657 }
 658 #endif /* USB_DRIVER_CLOSE */
 659
 660 bool usb_inserted(void)
 661 {
 662 #ifdef HAVE_USB_POWER
 663     return usb_state == USB_INSERTED || usb_state == USB_POWERED;
 664 #else
 665     return usb_state == USB_INSERTED;
 666 #endif
 667 }
 668
 669 #ifdef HAVE_USBSTACK
 670 bool usb_exclusive_storage(void)
 671 {
 672     return exclusive_storage_access;
 673 }
 674 #endif
 675
 676 int usb_release_exclusive_storage(void)
 677 {
 678     int num_acks_to_expect;
 679 #ifdef HAVE_USBSTACK
 680     exclusive_storage_access = false;
 681 #endif /* HAVE_USBSTACK */
 682     /* Tell all threads that we are back in business */
 683     num_acks_to_expect =
 684         queue_broadcast(SYS_USB_DISCONNECTED, 0) - 1;
 685     DEBUGF("USB extracted. Waiting for ack from %d threads...\n",
 686            num_acks_to_expect);
 687     return num_acks_to_expect;
 688 }
 689
 690 #ifdef HAVE_USB_POWER
 691 bool usb_powered(void)
 692 {
 693     return usb_state == USB_POWERED;
 694 }
 695 #endif
 696
 697 #ifdef USB_ENABLE_HID
 698 void usb_set_hid(bool enable)
 699 {
 700     usb_hid = enable;
 701     usb_core_enable_driver(USB_DRIVER_HID, usb_hid);
 702 }
 703 #endif
 704
 705 #else
 706
 707 #ifdef USB_NONE
 708 bool usb_inserted(void)
 709 {
 710     return false;
 711 }
 712 #endif
 713
 714 /* Dummy simulator functions */
 715 void usb_acknowledge(long id)
 716 {
 717     id = id;
 718 }
 719
 720 void usb_init(void)
 721 {
 722 }
 723
 724 void usb_start_monitoring(void)
 725 {
 726 }
 727
 728 int usb_detect(void)
 729 {
 730     return USB_EXTRACTED;
 731 }
 732
 733 void usb_wait_for_disconnect(struct event_queue *q)
 734 {
 735    (void)q;
 736 }
 737
 738 #endif /* USB_NONE or SIMULATOR */