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 + SECTOR_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;
  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_ID_CURRENT, 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_ID_CURRENT, 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         rc = disk_mount_all();
 335         if(rc <= 0) /* no partition */
 336             panicf("mount: %d",rc);
 337     }
 338 }
 339 #endif /* HAVE_USBSTACK */
 340
 341 #ifdef HAVE_USB_POWER
 342 static inline bool usb_power_button(void)
 343 {
 344 #if (defined(IRIVER_H10) || defined (IRIVER_H10_5GB)) && !defined(USE_ROCKBOX_USB)
 345     return (button_status() & ~USBPOWER_BTN_IGNORE) != USBPOWER_BUTTON;
 346 #else
 347     return (button_status() & ~USBPOWER_BTN_IGNORE) == USBPOWER_BUTTON;
 348 #endif
 349 }
 350
 351 #ifdef USB_FIREWIRE_HANDLING
 352 static inline bool usb_reboot_button(void)
 353 {
 354     return (button_status() & ~USBPOWER_BTN_IGNORE) != USBPOWER_BUTTON;
 355 }
 356 #endif
 357 #else /* !HAVE_USB_POWER */
 358 static inline bool usb_power_button(void)
 359 {
 360     return false;
 361 }
 362
 363 #ifdef USB_FIREWIRE_HANDLING
 364 static inline bool usb_reboot_button(void)
 365 {
 366     return false;
 367 }
 368 #endif
 369 #endif /* HAVE_USB_POWER */
 370
 371 #ifndef USB_DRIVER_CLOSE
 372 static void usb_thread(void) NORETURN_ATTR;
 373 #endif
 374 static void usb_thread(void)
 375 {
 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 #else /* !USB_DELAYED_INSERT */
 399             if(usb_state != USB_EXTRACTED)
 400                 break;
 401
 402             if(usb_do_screendump())
 403                 break;
 404
 405             usb_state = USB_POWERED;
 406 #endif /* USB_DELAYED_INSERT */
 407
 408             if(usb_power_button())
 409             {
 410                 /* Only charging is desired */
 411                 usb_configure_drivers(USB_POWERED);
 412                 break;
 413             }
 414
 415             if(!usb_configure_drivers(USB_INSERTED))
 416                 break; /* Exclusive storage access not required */
 417
 418             /* Tell all threads that they have to back off the storage.
 419                We subtract one for our own thread. Expect an ACK for every
 420                listener for each broadcast they received. If it has been too
 421                long, the user might have entered a screen that didn't ACK
 422                when inserting the cable, such as a debugging screen. In that
 423                case, reset the count or else USB would be locked out until
 424                rebooting because it most likely won't ever come. Simply
 425                resetting to the most recent broadcast count is racy. */
 426             if(TIME_AFTER(current_tick, last_broadcast_tick + HZ*5))
 427             {
 428                 num_acks_to_expect = 0;
 429                 last_broadcast_tick = current_tick;
 430             }
 431
 432             num_acks_to_expect += queue_broadcast(SYS_USB_CONNECTED, 0) - 1;
 433             DEBUGF("USB inserted. Waiting for %d acks...\n",
 434                    num_acks_to_expect);
 435
 436             /* Leave the state as USB_POWERED until the expected number of
 437                ACKS are received. */
 438             break;
 439             /* USB_INSERTED: */
 440
 441         case SYS_USB_CONNECTED_ACK:
 442             if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
 443             {
 444                 DEBUGF("All threads have acknowledged the connect.\n");
 445                 if(usb_state == USB_POWERED)
 446                 {
 447                     usb_slave_mode(true);
 448                     usb_state = USB_INSERTED;
 449                 }
 450             }
 451             else
 452             {
 453                 DEBUGF("usb: got ack, %d to go...\n",
 454                        num_acks_to_expect);
 455             }
 456             break;
 457             /* SYS_USB_CONNECTED_ACK */
 458
 459 #ifdef USB_DELAYED_INSERT
 460         /* In this case, these events handle cable insertion. USB driver or
 461            core determines USB_INSERTED. */
 462         case USB_POWERED:
 463             if(usb_state != USB_EXTRACTED)
 464                 break;
 465
 466             if(usb_do_screendump())
 467                 break;
 468
 469             usb_state = USB_POWERED;
 470             usb_enable(true);
 471             break;
 472             /* USB_POWERED: */
 473
 474         case USB_UNPOWERED:
 475             if(usb_state == USB_POWERED)
 476                 usb_enable(false);
 477             /* Fall-through - other legal states can be USB_INSERTED or
 478                USB_SCREENDUMP */
 479 #endif /* USB_DELAYED_INSERT */
 480         case USB_EXTRACTED:
 481             if(usb_state == USB_EXTRACTED)
 482                 break;
 483
 484             usb_configure_drivers(USB_EXTRACTED);
 485
 486             /* Only disable the USB slave mode if we really have enabled
 487                it. Some expected acks may not have been received. */
 488             if(usb_state == USB_INSERTED)
 489                 usb_slave_mode(false);
 490
 491             usb_state = USB_EXTRACTED;
 492             break;
 493             /* USB_UNPOWERED: USB_EXTRACTED: */
 494
 495         /*** Miscellaneous USB thread duties ***/
 496
 497         /* HOTSWAP */
 498 #ifdef HAVE_HOTSWAP
 499         case SYS_HOTSWAP_INSERTED:
 500         case SYS_HOTSWAP_EXTRACTED:
 501 #if (CONFIG_STORAGE & STORAGE_MMC)
 502         case USB_REENABLE:
 503 #endif
 504             usb_handle_hotswap(ev.id);
 505 #endif
 506
 507         /* FIREWIRE */
 508 #ifdef USB_FIREWIRE_HANDLING
 509         case USB_REQUEST_REBOOT:
 510             if(usb_reboot_button())
 511                 try_reboot();
 512             break;
 513 #endif
 514
 515         /* CHARGING */
 516 #if defined(HAVE_USB_CHARGING_ENABLE) && defined(HAVE_USBSTACK)
 517         case USB_CHARGER_UPDATE:
 518             usb_charging_maxcurrent_change(usb_charging_maxcurrent());
 519             break;
 520 #endif
 521
 522         /* CLOSE */
 523 #ifdef USB_DRIVER_CLOSE
 524         case USB_QUIT:
 525             return;
 526 #endif
 527         } /* switch */
 528     } /* while */
 529 }
 530
 531 #if defined(HAVE_USB_CHARGING_ENABLE) && defined(HAVE_USBSTACK)
 532 void usb_charger_update(void)
 533 {
 534     queue_post(&usb_queue, USB_CHARGER_UPDATE, 0);
 535 }
 536 #endif
 537
 538 #ifdef USB_STATUS_BY_EVENT
 539 void usb_status_event(int current_status)
 540 {
 541     /* Caller isn't expected to filter for changes in status.
 542      * current_status:
 543      *   USB_DETECT_BY_DRV/CORE: USB_POWERED, USB_UNPOWERED,
 544                                  USB_INSERTED (driver/core)
 545      *                     else: USB_INSERTED, USB_EXTRACTED
 546      */
 547     if(usb_monitor_enabled)
 548     {
 549         int oldstatus = disable_irq_save(); /* Dual-use function */
 550         queue_remove_from_head(&usb_queue, current_status);
 551         queue_post(&usb_queue, current_status, 0);
 552         restore_irq(oldstatus);
 553     }
 554 }
 555
 556 void usb_start_monitoring(void)
 557 {
 558     int oldstatus = disable_irq_save(); /* Sync to event */
 559     int status = usb_detect();
 560
 561     usb_monitor_enabled = true;
 562
 563     /* An event may have been missed because it was sent before monitoring
 564      * was enabled due to the connector already having been inserted before
 565      * before or during boot. */
 566 #ifdef USB_DELAYED_INSERT
 567     /* Filter the status - USB_INSERTED may happen later */
 568     status = (status == USB_INSERTED) ? USB_POWERED : USB_UNPOWERED;
 569 #endif
 570     usb_status_event(status);
 571
 572 #ifdef USB_FIREWIRE_HANDLING
 573     if(firewire_detect())
 574         usb_firewire_connect_event();
 575 #endif
 576
 577     restore_irq(oldstatus);
 578 }
 579
 580 #ifdef USB_FIREWIRE_HANDLING
 581 void usb_firewire_connect_event(void)
 582 {
 583     queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 584 }
 585 #endif /* USB_FIREWIRE_HANDLING */
 586
 587 #else /* !USB_STATUS_BY_EVENT */
 588
 589 static void usb_tick(void)
 590 {
 591     #define NUM_POLL_READINGS (HZ/5)
 592     static int usb_countdown = -1;
 593     static int last_usb_status = USB_EXTRACTED;
 594 #ifdef USB_FIREWIRE_HANDLING
 595     static int firewire_countdown = -1;
 596     static int last_firewire_status = false;
 597 #endif
 598
 599     if(usb_monitor_enabled)
 600     {
 601 #ifdef USB_FIREWIRE_HANDLING
 602         int current_firewire_status = firewire_detect();
 603         if(current_firewire_status != last_firewire_status)
 604         {
 605             last_firewire_status = current_firewire_status;
 606             firewire_countdown = NUM_POLL_READINGS;
 607         }
 608         else
 609         {
 610             /* Count down until it gets negative */
 611             if(firewire_countdown >= 0)
 612                 firewire_countdown--;
 613
 614             /* Report to the thread if we have had 3 identical status
 615                readings in a row */
 616             if(firewire_countdown == 0)
 617             {
 618                 queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 619             }
 620         }
 621 #endif /* USB_FIREWIRE_HANDLING */
 622
 623         int current_status = usb_detect();
 624
 625         /* Only report when the status has changed */
 626         if(current_status != last_usb_status)
 627         {
 628             last_usb_status = current_status;
 629             usb_countdown = NUM_POLL_READINGS;
 630         }
 631         else
 632         {
 633             /* Count down until it gets negative */
 634             if(usb_countdown >= 0)
 635                 usb_countdown--;
 636
 637             /* Report to the thread if we have had 3 identical status
 638                readings in a row */
 639             if(usb_countdown == 0)
 640             {
 641                 queue_post(&usb_queue, current_status, 0);
 642             }
 643         }
 644     }
 645 #if (CONFIG_STORAGE & STORAGE_MMC)
 646     if(usb_mmc_countdown > 0)
 647     {
 648         usb_mmc_countdown--;
 649         if(usb_mmc_countdown == 0)
 650             queue_post(&usb_queue, USB_REENABLE, 0);
 651     }
 652 #endif
 653 }
 654
 655 void usb_start_monitoring(void)
 656 {
 657     usb_monitor_enabled = true;
 658 }
 659 #endif /* USB_STATUS_BY_EVENT */
 660 #endif /* USB_FULL_INIT */
 661
 662 void usb_acknowledge(long id)
 663 {
 664     queue_post(&usb_queue, id, 0);
 665 }
 666
 667 void usb_init(void)
 668 {
 669     usb_init_device();
 670
 671 #ifdef USB_FULL_INIT
 672     usb_enable(false);
 673
 674     queue_init(&usb_queue, true);
 675
 676     usb_thread_entry = create_thread(usb_thread, usb_stack,
 677                        sizeof(usb_stack), 0, usb_thread_name
 678                        IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU));
 679
 680 #ifndef USB_STATUS_BY_EVENT
 681     tick_add_task(usb_tick);
 682 #endif
 683 #endif /* USB_FULL_INIT */
 684 }
 685
 686 void usb_wait_for_disconnect(struct event_queue *q)
 687 {
 688 #ifdef USB_FULL_INIT
 689     struct queue_event ev;
 690
 691     /* Don't return until we get SYS_USB_DISCONNECTED */
 692     while(1)
 693     {
 694         queue_wait(q, &ev);
 695         if(ev.id == SYS_USB_DISCONNECTED)
 696             return;
 697     }
 698 #endif /* USB_FULL_INIT */
 699     (void)q;
 700 }
 701
 702 int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks)
 703 {
 704 #ifdef USB_FULL_INIT
 705     struct queue_event ev;
 706
 707     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
 708     while(1)
 709     {
 710         queue_wait_w_tmo(q, &ev, ticks);
 711         switch(ev.id)
 712         {
 713             case SYS_USB_DISCONNECTED:
 714                 return 0;
 715             case SYS_TIMEOUT:
 716                 return 1;
 717         }
 718     }
 719 #endif /* USB_FULL_INIT */
 720     (void)q; (void)ticks;
 721     return 0;
 722 }
 723
 724 #ifdef USB_DRIVER_CLOSE
 725 void usb_close(void)
 726 {
 727     unsigned int thread = usb_thread_entry;
 728     usb_thread_entry = 0;
 729
 730     if(thread == 0)
 731         return;
 732
 733 #ifndef USB_STATUS_BY_EVENT
 734     tick_remove_task(usb_tick);
 735 #endif
 736     usb_monitor_enabled = false;
 737
 738     queue_post(&usb_queue, USB_QUIT, 0);
 739     thread_wait(thread);
 740 }
 741 #endif /* USB_DRIVER_CLOSE */
 742
 743 bool usb_inserted(void)
 744 {
 745     return usb_state == USB_INSERTED || usb_state == USB_POWERED;
 746 }
 747
 748 #ifdef HAVE_USBSTACK
 749 bool usb_exclusive_storage(void)
 750 {
 751     return exclusive_storage_access;
 752 }
 753 #endif /* HAVE_USBSTACK */
 754
 755 int usb_release_exclusive_storage(void)
 756 {
 757     int bccount;
 758     exclusive_storage_access = false;
 759     /* Tell all threads that we are back in business */
 760     bccount = queue_broadcast(SYS_USB_DISCONNECTED, 0) - 1;
 761     DEBUGF("USB extracted. Broadcast to %d threads...\n", bccount);
 762     return bccount;
 763 }
 764
 765 #ifdef HAVE_USB_POWER
 766 bool usb_powered(void)
 767 {
 768     return usb_state == USB_POWERED;
 769 }
 770 #endif /* HAVE_USB_POWER */
 771
 772 #ifdef USB_ENABLE_HID
 773 void usb_set_hid(bool enable)
 774 {
 775     usb_hid = enable;
 776     usb_core_enable_driver(USB_DRIVER_HID, usb_hid);
 777 }
 778 #endif /* USB_ENABLE_HID */
 779
 780 #else /* SIMULATOR || USB_NONE */
 781
 782 #ifdef USB_NONE
 783 bool usb_inserted(void)
 784 {
 785     return false;
 786 }
 787 #endif /* USB_NONE */
 788
 789 /* Dummy simulator functions */
 790 void usb_acknowledge(long id)
 791 {
 792     id = id;
 793 }
 794
 795 void usb_init(void)
 796 {
 797 }
 798
 799 void usb_start_monitoring(void)
 800 {
 801 }
 802
 803 int usb_detect(void)
 804 {
 805     return USB_EXTRACTED;
 806 }
 807
 808 void usb_wait_for_disconnect(struct event_queue *q)
 809 {
 810    (void)q;
 811 }
 812
 813 #endif /* !USB_NONE && !SIMULATOR */