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