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