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(HAVE_USBSTACK) && defined(HAVE_BOOTLOADER_USB_MODE)) || \
  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      (defined(USE_ROCKBOX_USB) && CONFIG_USBOTG == USBOTG_AS3525) || \
  56      (defined(USE_ROCKBOX_USB) && CONFIG_USBOTG == USBOTG_AS3525v2)
  57 #define USB_FULL_INIT
  58 #endif
  59
  60 #if defined(USB_DETECT_BY_DRV) || defined(USB_DETECT_BY_CORE)
  61 /* These aren't treated differently here */
  62 #define USB_DELAYED_INSERT
  63 #endif
  64
  65 #ifdef HAVE_LCD_BITMAP
  66 bool do_screendump_instead_of_usb = false;
  67 #endif
  68
  69 #if !defined(SIMULATOR) && !defined(USB_NONE)
  70
  71 /* We assume that the USB cable is extracted */
  72 static int usb_state = USB_EXTRACTED;
  73
  74 #if (CONFIG_STORAGE & STORAGE_MMC) && defined(USB_FULL_INIT)
  75 static int usb_mmc_countdown = 0;
  76 #endif
  77
  78 /* Make sure there's enough stack space for screendump */
  79 #ifdef USB_FULL_INIT
  80 static long usb_stack[(DEFAULT_STACK_SIZE + DUMP_BMP_LINESIZE)/sizeof(long)];
  81 static const char usb_thread_name[] = "usb";
  82 static unsigned int usb_thread_entry = 0;
  83 static bool usb_monitor_enabled = false;
  84 #endif /* USB_FULL_INIT */
  85 static struct event_queue usb_queue SHAREDBSS_ATTR;
  86 static bool exclusive_storage_access = false;
  87 #ifdef USB_ENABLE_HID
  88 static bool usb_hid = true;
  89 #endif
  90
  91 #ifdef USB_FULL_INIT
  92
  93 #if defined(USB_FIREWIRE_HANDLING) \
  94     || (defined(HAVE_USBSTACK) && !defined(USE_ROCKBOX_USB))
  95 static void try_reboot(void)
  96 {
  97 #ifdef HAVE_DISK_STORAGE
  98     storage_sleepnow(); /* Immediately spindown the disk. */
  99     sleep(HZ*2);
 100 #endif
 101
 102 #ifdef IPOD_ARCH  /* The following code is based on ipodlinux */
 103 #if CONFIG_CPU == PP5020
 104     memcpy((void *)0x40017f00, "diskmode\0\0hotstuff\0\0\1", 21);
 105 #elif CONFIG_CPU == PP5022
 106     memcpy((void *)0x4001ff00, "diskmode\0\0hotstuff\0\0\1", 21);
 107 #endif /* CONFIG_CPU */
 108 #endif /* IPOD_ARCH */
 109
 110 #ifdef IPOD_NANO2G
 111     memcpy((void *)0x0002bf00, "diskmodehotstuff\1\0\0\0", 20);
 112 #endif
 113
 114     system_reboot(); /* Reboot */
 115 }
 116 #endif /* USB_FIRWIRE_HANDLING || (HAVE_USBSTACK && !USE_ROCKBOX_USB) */
 117
 118
 119 #ifdef HAVE_LCD_BITMAP
 120 static inline bool usb_do_screendump(void)
 121 {
 122     if(do_screendump_instead_of_usb)
 123     {
 124         usb_state = USB_SCREENDUMP;
 125         screen_dump();
 126 #ifdef HAVE_REMOTE_LCD
 127         remote_screen_dump();
 128 #endif
 129         return true;
 130     }
 131
 132     return false;
 133 }
 134 #else /* !HAVE_LCD_BITMAP */
 135 static inline bool usb_do_screendump(void)
 136 {
 137     return false;
 138 }
 139 #endif /* HAVE_LCD_BITMAP */
 140
 141
 142 #ifdef HAVE_USBSTACK
 143
 144 #ifdef HAVE_HOTSWAP
 145 static inline void usb_handle_hotswap(long id)
 146 {
 147     switch(id)
 148     {
 149     case SYS_HOTSWAP_INSERTED:
 150     case SYS_HOTSWAP_EXTRACTED:
 151         usb_core_hotswap_event(1, id == SYS_HOTSWAP_INSERTED);
 152         break;
 153     }
 154     /* Note: No MMC storage handling is needed with the stack atm. */
 155 }
 156 #endif /* HAVE_HOTSWAP */
 157
 158 static inline bool usb_configure_drivers(int for_state)
 159 {
 160     switch(for_state)
 161     {
 162     case USB_POWERED:
 163 #ifdef USB_ENABLE_STORAGE
 164         usb_core_enable_driver(USB_DRIVER_MASS_STORAGE, false);
 165 #endif
 166 #ifdef USB_ENABLE_HID
 167 #ifdef USB_ENABLE_CHARGING_ONLY
 168         usb_core_enable_driver(USB_DRIVER_HID, false);
 169 #else
 170         usb_core_enable_driver(USB_DRIVER_HID, true);
 171 #endif /* USB_ENABLE_CHARGING_ONLY */
 172 #endif /* USB_ENABLE_HID */
 173
 174 #ifdef USB_ENABLE_CHARGING_ONLY
 175         usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY, true);
 176 #endif
 177         exclusive_storage_access = false;
 178
 179         usb_attach(); /* Powered only: attach now. */
 180         break;
 181         /* USB_POWERED: */
 182
 183     case USB_INSERTED:
 184 #ifdef USB_ENABLE_STORAGE
 185         usb_core_enable_driver(USB_DRIVER_MASS_STORAGE, true);
 186 #endif
 187 #ifdef USB_ENABLE_HID
 188         usb_core_enable_driver(USB_DRIVER_HID, usb_hid);
 189 #endif
 190 #ifdef USB_ENABLE_CHARGING_ONLY
 191         usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY, false);
 192 #endif
 193         /* Check any drivers enabled at this point for exclusive storage
 194          * access requirements. */
 195         exclusive_storage_access = usb_core_any_exclusive_storage();
 196
 197         if(exclusive_storage_access)
 198             return true;
 199
 200         usb_attach(); /* Not exclusive: attach now. */
 201         break;
 202         /* USB_INSERTED: */
 203
 204     case USB_EXTRACTED:
 205         if(exclusive_storage_access)
 206             usb_release_exclusive_storage();
 207         break;
 208         /* USB_EXTRACTED: */
 209     }
 210
 211     return false;
 212 }
 213
 214 #ifdef USE_ROCKBOX_USB
 215 static inline void usb_slave_mode(bool on)
 216 {
 217     int rc;
 218
 219     if(on)
 220     {
 221         trigger_cpu_boost();
 222 #ifdef HAVE_PRIORITY_SCHEDULING
 223         thread_set_priority(thread_self(), PRIORITY_REALTIME);
 224 #endif
 225         disk_unmount_all();
 226         usb_attach();
 227     }
 228     else /* usb_state == USB_INSERTED (only!) */
 229     {
 230         usb_enable(false);
 231 #ifdef HAVE_PRIORITY_SCHEDULING
 232         thread_set_priority(thread_self(), PRIORITY_SYSTEM);
 233 #endif
 234         /* Entered exclusive mode */
 235         rc = disk_mount_all();
 236         if(rc <= 0) /* no partition */
 237             panicf("mount: %d",rc);
 238
 239         cancel_cpu_boost();
 240     }
 241 }
 242 #else /* !USB_ROCKBOX_USB */
 243 static inline void usb_slave_mode(bool on)
 244 {
 245     if(on)
 246     {
 247         /* until we have native mass-storage mode, we want to reboot on
 248            usb host connect */
 249         try_reboot();
 250     }
 251 }
 252 #endif /* USE_ROCKBOX_USB */
 253
 254 void usb_signal_transfer_completion(
 255     struct usb_transfer_completion_event_data* event_data)
 256 {
 257     queue_post(&usb_queue, USB_TRANSFER_COMPLETION, (intptr_t)event_data);
 258 }
 259
 260 #else  /* !HAVE_USBSTACK */
 261
 262 #ifdef HAVE_HOTSWAP
 263 static inline void usb_handle_hotswap(long id)
 264 {
 265 #if (CONFIG_STORAGE & STORAGE_MMC)
 266     switch(id)
 267     {
 268     case SYS_HOTSWAP_INSERTED:
 269     case SYS_HOTSWAP_EXTRACTED:
 270         if(usb_state == USB_INSERTED)
 271         {
 272             usb_enable(false);
 273             usb_mmc_countdown = HZ/2; /* re-enable after 0.5 sec */
 274         }
 275         break;
 276     case USB_REENABLE:
 277         if(usb_state == USB_INSERTED)
 278             usb_enable(true);  /* reenable only if still inserted */
 279         break;
 280     }
 281 #endif /* STORAGE_MMC */
 282     (void)id;
 283 }
 284 #endif /* HAVE_HOTSWAP */
 285
 286 static inline bool usb_configure_drivers(int for_state)
 287 {
 288     switch(for_state)
 289     {
 290     case USB_POWERED:
 291         exclusive_storage_access = false;
 292         break;
 293     case USB_INSERTED:
 294         exclusive_storage_access = true;
 295         return true;
 296     case USB_EXTRACTED:
 297         if(exclusive_storage_access)
 298             usb_release_exclusive_storage();
 299         break;
 300     }
 301
 302     return false;
 303 }
 304
 305 static inline void usb_slave_mode(bool on)
 306 {
 307     int rc;
 308
 309     if(on)
 310     {
 311         DEBUGF("Entering USB slave mode\n");
 312         disk_unmount_all();
 313         storage_soft_reset();
 314         storage_init();
 315         storage_enable(false);
 316         usb_enable(true);
 317         cpu_idle_mode(true);
 318     }
 319     else
 320     {
 321         DEBUGF("Leaving USB slave mode\n");
 322
 323         cpu_idle_mode(false);
 324
 325         /* Let the ISDx00 settle */
 326         sleep(HZ*1);
 327
 328         usb_enable(false);
 329
 330         rc = storage_init();
 331         if(rc)
 332             panicf("storage: %d",rc);
 333
 334         sleep(HZ/10);
 335         rc = disk_mount_all();
 336         if(rc <= 0) /* no partition */
 337             panicf("mount: %d",rc);
 338     }
 339 }
 340 #endif /* HAVE_USBSTACK */
 341
 342 #ifdef HAVE_USB_POWER
 343 static inline bool usb_power_button(void)
 344 {
 345     return (button_status() & ~USBPOWER_BTN_IGNORE);
 346 }
 347
 348 #ifdef USB_FIREWIRE_HANDLING
 349 static inline bool usb_reboot_button(void)
 350 {
 351     return (button_status() & ~USBPOWER_BTN_IGNORE);
 352 }
 353 #endif
 354 #else /* !HAVE_USB_POWER */
 355 static inline bool usb_power_button(void)
 356 {
 357     return false;
 358 }
 359
 360 #ifdef USB_FIREWIRE_HANDLING
 361 static inline bool usb_reboot_button(void)
 362 {
 363     return false;
 364 }
 365 #endif
 366 #endif /* HAVE_USB_POWER */
 367
 368 #ifndef USB_DRIVER_CLOSE
 369 static void usb_thread(void) NORETURN_ATTR;
 370 #endif
 371 static void usb_thread(void)
 372 {
 373 #ifdef USB_DELAYED_INSERT
 374     bool host_detected = false;
 375 #endif
 376     int num_acks_to_expect = 0;
 377     long last_broadcast_tick = current_tick;
 378     struct queue_event ev;
 379
 380     while(1)
 381     {
 382         queue_wait(&usb_queue, &ev);
 383         switch(ev.id)
 384         {
 385         /*** Main USB thread duties ***/
 386
 387 #ifdef HAVE_USBSTACK
 388         case USB_TRANSFER_COMPLETION:
 389             usb_core_handle_transfer_completion(
 390                 (struct usb_transfer_completion_event_data*)ev.data);
 391             break;
 392 #endif /* HAVE_USBSTACK */
 393
 394         case USB_INSERTED:
 395 #ifdef USB_DELAYED_INSERT
 396             if(usb_state != USB_POWERED)
 397                 break;
 398
 399             if (host_detected)
 400                 break; /* Drivers configured but we're still USB_POWERED */
 401
 402             host_detected = true;
 403 #else /* !USB_DELAYED_INSERT */
 404             if(usb_state != USB_EXTRACTED)
 405                 break;
 406
 407             if(usb_do_screendump())
 408                 break;
 409
 410             usb_state = USB_POWERED;
 411 #endif /* USB_DELAYED_INSERT */
 412
 413             if(usb_power_button())
 414             {
 415                 /* Only charging is desired */
 416                 usb_configure_drivers(USB_POWERED);
 417                 break;
 418             }
 419
 420             if(!usb_configure_drivers(USB_INSERTED))
 421                 break; /* Exclusive storage access not required */
 422
 423             /* Tell all threads that they have to back off the storage.
 424                We subtract one for our own thread. Expect an ACK for every
 425                listener for each broadcast they received. If it has been too
 426                long, the user might have entered a screen that didn't ACK
 427                when inserting the cable, such as a debugging screen. In that
 428                case, reset the count or else USB would be locked out until
 429                rebooting because it most likely won't ever come. Simply
 430                resetting to the most recent broadcast count is racy. */
 431             if(TIME_AFTER(current_tick, last_broadcast_tick + HZ*5))
 432             {
 433                 num_acks_to_expect = 0;
 434                 last_broadcast_tick = current_tick;
 435             }
 436
 437             num_acks_to_expect += queue_broadcast(SYS_USB_CONNECTED, 0) - 1;
 438             DEBUGF("USB inserted. Waiting for %d acks...\n",
 439                    num_acks_to_expect);
 440
 441             /* Leave the state as USB_POWERED until the expected number of
 442                ACKS are received. */
 443             break;
 444             /* USB_INSERTED: */
 445
 446         case SYS_USB_CONNECTED_ACK:
 447             if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
 448             {
 449                 DEBUGF("All threads have acknowledged the connect.\n");
 450                 if(usb_state == USB_POWERED)
 451                 {
 452                     usb_slave_mode(true);
 453                     usb_state = USB_INSERTED;
 454                 }
 455             }
 456             else
 457             {
 458                 DEBUGF("usb: got ack, %d to go...\n",
 459                        num_acks_to_expect);
 460             }
 461             break;
 462             /* SYS_USB_CONNECTED_ACK */
 463
 464 #ifdef USB_DELAYED_INSERT
 465         /* In this case, these events handle cable insertion. USB driver or
 466            core determines USB_INSERTED. */
 467         case USB_POWERED:
 468             if(usb_state != USB_EXTRACTED)
 469                 break;
 470
 471             if(usb_do_screendump())
 472                 break;
 473
 474             usb_state = USB_POWERED;
 475             usb_enable(true);
 476             break;
 477             /* USB_POWERED: */
 478
 479         case USB_UNPOWERED:
 480             if(usb_state == USB_POWERED)
 481                 usb_enable(false);
 482             /* Fall-through - other legal states can be USB_INSERTED or
 483                USB_SCREENDUMP */
 484 #endif /* USB_DELAYED_INSERT */
 485         case USB_EXTRACTED:
 486             if(usb_state == USB_EXTRACTED)
 487                 break;
 488
 489             /* Only disable the USB slave mode if we really have enabled
 490                it. Some expected acks may not have been received. */
 491             if(usb_state == USB_INSERTED)
 492                 usb_slave_mode(false);
 493
 494             usb_state = USB_EXTRACTED;
 495
 496             /* Ok to broadcast disconnect now */
 497             usb_configure_drivers(USB_EXTRACTED);
 498 #ifdef USB_DELAYED_INSERT
 499             host_detected = false;
 500 #endif
 501             break;
 502             /* USB_UNPOWERED: USB_EXTRACTED: */
 503
 504         /*** Miscellaneous USB thread duties ***/
 505
 506         /* HOTSWAP */
 507 #ifdef HAVE_HOTSWAP
 508         case SYS_HOTSWAP_INSERTED:
 509         case SYS_HOTSWAP_EXTRACTED:
 510 #if (CONFIG_STORAGE & STORAGE_MMC)
 511         case USB_REENABLE:
 512 #endif
 513             usb_handle_hotswap(ev.id);
 514 #endif
 515
 516         /* FIREWIRE */
 517 #ifdef USB_FIREWIRE_HANDLING
 518         case USB_REQUEST_REBOOT:
 519             if(usb_reboot_button())
 520                 try_reboot();
 521             break;
 522 #endif
 523
 524         /* CHARGING */
 525 #if defined(HAVE_USB_CHARGING_ENABLE) && defined(HAVE_USBSTACK)
 526         case USB_CHARGER_UPDATE:
 527             usb_charging_maxcurrent_change(usb_charging_maxcurrent());
 528             break;
 529 #endif
 530
 531         /* CLOSE */
 532 #ifdef USB_DRIVER_CLOSE
 533         case USB_QUIT:
 534             return;
 535 #endif
 536         } /* switch */
 537     } /* while */
 538 }
 539
 540 #if defined(HAVE_USB_CHARGING_ENABLE) && defined(HAVE_USBSTACK)
 541 void usb_charger_update(void)
 542 {
 543     queue_post(&usb_queue, USB_CHARGER_UPDATE, 0);
 544 }
 545 #endif
 546
 547 #ifdef USB_STATUS_BY_EVENT
 548 void usb_status_event(int current_status)
 549 {
 550     /* Caller isn't expected to filter for changes in status.
 551      * current_status:
 552      *   USB_DETECT_BY_DRV/CORE: USB_POWERED, USB_UNPOWERED,
 553                                  USB_INSERTED (driver/core)
 554      *                     else: USB_INSERTED, USB_EXTRACTED
 555      */
 556     if(usb_monitor_enabled)
 557     {
 558         int oldstatus = disable_irq_save(); /* Dual-use function */
 559         queue_remove_from_head(&usb_queue, current_status);
 560         queue_post(&usb_queue, current_status, 0);
 561         restore_irq(oldstatus);
 562     }
 563 }
 564
 565 void usb_start_monitoring(void)
 566 {
 567     int oldstatus = disable_irq_save(); /* Sync to event */
 568     int status = usb_detect();
 569
 570     usb_monitor_enabled = true;
 571
 572     /* An event may have been missed because it was sent before monitoring
 573      * was enabled due to the connector already having been inserted before
 574      * before or during boot. */
 575 #ifdef USB_DELAYED_INSERT
 576     /* Filter the status - USB_INSERTED may happen later */
 577     status = (status == USB_EXTRACTED) ? USB_UNPOWERED : USB_POWERED;
 578 #endif
 579     usb_status_event(status);
 580
 581 #ifdef USB_FIREWIRE_HANDLING
 582     if(firewire_detect())
 583         usb_firewire_connect_event();
 584 #endif
 585
 586     restore_irq(oldstatus);
 587 }
 588
 589 #ifdef USB_FIREWIRE_HANDLING
 590 void usb_firewire_connect_event(void)
 591 {
 592     queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 593 }
 594 #endif /* USB_FIREWIRE_HANDLING */
 595
 596 #else /* !USB_STATUS_BY_EVENT */
 597
 598 static void usb_tick(void)
 599 {
 600     #define NUM_POLL_READINGS (HZ/5)
 601     static int usb_countdown = -1;
 602     static int last_usb_status = USB_EXTRACTED;
 603 #ifdef USB_FIREWIRE_HANDLING
 604     static int firewire_countdown = -1;
 605     static int last_firewire_status = false;
 606 #endif
 607
 608     if(usb_monitor_enabled)
 609     {
 610 #ifdef USB_FIREWIRE_HANDLING
 611         int current_firewire_status = firewire_detect();
 612         if(current_firewire_status != last_firewire_status)
 613         {
 614             last_firewire_status = current_firewire_status;
 615             firewire_countdown = NUM_POLL_READINGS;
 616         }
 617         else
 618         {
 619             /* Count down until it gets negative */
 620             if(firewire_countdown >= 0)
 621                 firewire_countdown--;
 622
 623             /* Report to the thread if we have had 3 identical status
 624                readings in a row */
 625             if(firewire_countdown == 0)
 626             {
 627                 queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 628             }
 629         }
 630 #endif /* USB_FIREWIRE_HANDLING */
 631
 632         int current_status = usb_detect();
 633
 634         /* Only report when the status has changed */
 635         if(current_status != last_usb_status)
 636         {
 637             last_usb_status = current_status;
 638             usb_countdown = NUM_POLL_READINGS;
 639         }
 640         else
 641         {
 642             /* Count down until it gets negative */
 643             if(usb_countdown >= 0)
 644                 usb_countdown--;
 645
 646             /* Report to the thread if we have had 3 identical status
 647                readings in a row */
 648             if(usb_countdown == 0)
 649             {
 650                 queue_post(&usb_queue, current_status, 0);
 651             }
 652         }
 653     }
 654 #if (CONFIG_STORAGE & STORAGE_MMC)
 655     if(usb_mmc_countdown > 0)
 656     {
 657         usb_mmc_countdown--;
 658         if(usb_mmc_countdown == 0)
 659             queue_post(&usb_queue, USB_REENABLE, 0);
 660     }
 661 #endif
 662 }
 663
 664 void usb_start_monitoring(void)
 665 {
 666     usb_monitor_enabled = true;
 667 }
 668 #endif /* USB_STATUS_BY_EVENT */
 669 #endif /* USB_FULL_INIT */
 670
 671 void usb_acknowledge(long id)
 672 {
 673     queue_post(&usb_queue, id, 0);
 674 }
 675
 676 void usb_init(void)
 677 {
 678 #ifdef USB_FULL_INIT
 679     usb_enable(false);
 680
 681     queue_init(&usb_queue, true);
 682
 683     usb_thread_entry = create_thread(usb_thread, usb_stack,
 684                        sizeof(usb_stack), 0, usb_thread_name
 685                        IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU));
 686
 687 #ifndef USB_STATUS_BY_EVENT
 688     tick_add_task(usb_tick);
 689 #endif
 690 #endif /* USB_FULL_INIT */
 691
 692     usb_init_device();
 693 }
 694
 695 void usb_wait_for_disconnect(struct event_queue *q)
 696 {
 697 #ifdef USB_FULL_INIT
 698     struct queue_event ev;
 699
 700     /* Don't return until we get SYS_USB_DISCONNECTED */
 701     while(1)
 702     {
 703         queue_wait(q, &ev);
 704         if(ev.id == SYS_USB_DISCONNECTED)
 705             return;
 706     }
 707 #endif /* USB_FULL_INIT */
 708     (void)q;
 709 }
 710
 711 int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks)
 712 {
 713 #ifdef USB_FULL_INIT
 714     struct queue_event ev;
 715
 716     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
 717     while(1)
 718     {
 719         queue_wait_w_tmo(q, &ev, ticks);
 720         switch(ev.id)
 721         {
 722             case SYS_USB_DISCONNECTED:
 723                 return 0;
 724             case SYS_TIMEOUT:
 725                 return 1;
 726         }
 727     }
 728 #endif /* USB_FULL_INIT */
 729     (void)q; (void)ticks;
 730     return 0;
 731 }
 732
 733 #ifdef USB_DRIVER_CLOSE
 734 void usb_close(void)
 735 {
 736     unsigned int thread = usb_thread_entry;
 737     usb_thread_entry = 0;
 738
 739     if(thread == 0)
 740         return;
 741
 742 #ifndef USB_STATUS_BY_EVENT
 743     tick_remove_task(usb_tick);
 744 #endif
 745     usb_monitor_enabled = false;
 746
 747     queue_post(&usb_queue, USB_QUIT, 0);
 748     thread_wait(thread);
 749 }
 750 #endif /* USB_DRIVER_CLOSE */
 751
 752 bool usb_inserted(void)
 753 {
 754     return usb_state == USB_INSERTED || usb_state == USB_POWERED;
 755 }
 756
 757 #ifdef HAVE_USBSTACK
 758 bool usb_exclusive_storage(void)
 759 {
 760     /* Storage isn't actually exclusive until slave mode has been entered */
 761     return exclusive_storage_access && usb_state == USB_INSERTED;
 762 }
 763 #endif /* HAVE_USBSTACK */
 764
 765 int usb_release_exclusive_storage(void)
 766 {
 767     int bccount;
 768     exclusive_storage_access = false;
 769     /* Tell all threads that we are back in business */
 770     bccount = queue_broadcast(SYS_USB_DISCONNECTED, 0) - 1;
 771     DEBUGF("USB extracted. Broadcast to %d threads...\n", bccount);
 772     return bccount;
 773 }
 774
 775 #ifdef HAVE_USB_POWER
 776 bool usb_powered(void)
 777 {
 778     return usb_state == USB_POWERED;
 779 }
 780 #endif /* HAVE_USB_POWER */
 781
 782 #ifdef USB_ENABLE_HID
 783 void usb_set_hid(bool enable)
 784 {
 785     usb_hid = enable;
 786     usb_core_enable_driver(USB_DRIVER_HID, usb_hid);
 787 }
 788 #endif /* USB_ENABLE_HID */
 789
 790 #else /* SIMULATOR || USB_NONE */
 791
 792 #ifdef USB_NONE
 793 bool usb_inserted(void)
 794 {
 795     return false;
 796 }
 797 #endif /* USB_NONE */
 798
 799 /* Dummy simulator functions */
 800 void usb_acknowledge(long id)
 801 {
 802     id = id;
 803 }
 804
 805 void usb_init(void)
 806 {
 807 }
 808
 809 void usb_start_monitoring(void)
 810 {
 811 }
 812
 813 int usb_detect(void)
 814 {
 815     return USB_EXTRACTED;
 816 }
 817
 818 void usb_wait_for_disconnect(struct event_queue *q)
 819 {
 820    (void)q;
 821 }
 822
 823 #endif /* !USB_NONE && !SIMULATOR */