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)
 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                     usb_core_enable_driver(USB_DRIVER_MASS_STORAGE, false);
 274                     usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY, true);
 275                     usb_attach();
 276 #endif
 277                     break;
 278                 }
 279 #endif /* HAVE_USB_POWER */
 280 #ifdef HAVE_USBSTACK
 281 #ifdef HAVE_USB_POWER
 282                 /* Set the state to USB_POWERED for now. If permission to connect
 283                  * by threads and storage is granted it will be changed to
 284                  * USB_CONNECTED. */
 285                 usb_state = USB_POWERED;
 286 #endif
 287                 usb_core_enable_driver(USB_DRIVER_MASS_STORAGE, true);
 288                 usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY, false);
 289
 290                 /* Check any drivers enabled at this point for exclusive storage
 291                  * access requirements. */
 292                 exclusive_storage_access = usb_core_any_exclusive_storage();
 293
 294                 if(!exclusive_storage_access)
 295                 {
 296                     usb_attach();
 297                     break;
 298                 }
 299 #endif /* HAVE_USBSTACK */
 300                 /* Tell all threads that they have to back off the storage.
 301                    We subtract one for our own thread. */
 302                 num_acks_to_expect = queue_broadcast(SYS_USB_CONNECTED, 0) - 1;
 303                 DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
 304                        num_acks_for_connect);
 305                 break;
 306
 307             case SYS_USB_CONNECTED_ACK:
 308                 if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
 309                 {
 310                     DEBUGF("All threads have acknowledged the connect.\n");
 311                     usb_slave_mode(true);
 312                     usb_state = USB_INSERTED;
 313                 }
 314                 else
 315                 {
 316                     DEBUGF("usb: got ack, %d to go...\n",
 317                            num_acks_to_expect);
 318                 }
 319                 break;
 320
 321             case USB_EXTRACTED:
 322 #ifdef HAVE_LCD_BITMAP
 323                 if(usb_state == USB_SCREENDUMP)
 324                 {
 325                     usb_state = USB_EXTRACTED;
 326                     break; /* Connected for screendump only */
 327                 }
 328 #endif
 329 #ifndef HAVE_USBSTACK /* Stack must undo this if POWERED state was transitional */
 330 #ifdef HAVE_USB_POWER
 331                 if(usb_state == USB_POWERED)
 332                 {
 333                     usb_state = USB_EXTRACTED;
 334                     break;
 335                 }
 336 #endif
 337 #endif /* HAVE_USBSTACK */
 338                 if(usb_state == USB_INSERTED)
 339                 {
 340                     /* Only disable the USB mode if we really have enabled it
 341                        some threads might not have acknowledged the
 342                        insertion */
 343                     usb_slave_mode(false);
 344                 }
 345
 346                 usb_state = USB_EXTRACTED;
 347 #ifdef HAVE_USBSTACK
 348                 if(!exclusive_storage_access)
 349                 {
 350 #ifndef USB_DETECT_BY_DRV /* Disabled handling USB_UNPOWERED */
 351                     usb_enable(false);
 352 #endif
 353                     break;
 354                 }
 355
 356                 exclusive_storage_access = false;
 357 #endif /* HAVE_USBSTACK */
 358
 359                 /* Tell all threads that we are back in business */
 360                 num_acks_to_expect =
 361                     queue_broadcast(SYS_USB_DISCONNECTED, 0) - 1;
 362                 DEBUGF("USB extracted. Waiting for ack from %d threads...\n",
 363                        num_acks_to_expect);
 364                 break;
 365
 366             case SYS_USB_DISCONNECTED_ACK:
 367                 if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
 368                 {
 369                     DEBUGF("All threads have acknowledged. "
 370                            "We're in business.\n");
 371                 }
 372                 else
 373                 {
 374                     DEBUGF("usb: got ack, %d to go...\n",
 375                            num_acks_to_expect);
 376                 }
 377                 break;
 378
 379 #ifdef HAVE_HOTSWAP
 380             case SYS_HOTSWAP_INSERTED:
 381             case SYS_HOTSWAP_EXTRACTED:
 382 #ifdef HAVE_USBSTACK
 383                 usb_core_hotswap_event(1,ev.id == SYS_HOTSWAP_INSERTED);
 384 #else  /* !HAVE_USBSTACK */
 385                 if(usb_state == USB_INSERTED)
 386                 {
 387                     usb_enable(false);
 388 #if (CONFIG_STORAGE & STORAGE_MMC)
 389                     usb_mmc_countdown = HZ/2; /* re-enable after 0.5 sec */
 390 #endif /* STORAGE_MMC */
 391                 }
 392 #endif /* HAVE_USBSTACK */
 393                 break;
 394
 395 #if (CONFIG_STORAGE & STORAGE_MMC)
 396             case USB_REENABLE:
 397                 if(usb_state == USB_INSERTED)
 398                     usb_enable(true);  /* reenable only if still inserted */
 399                 break;
 400 #endif /* STORAGE_MMC */
 401 #endif /* HAVE_HOTSWAP */
 402
 403 #ifdef USB_FIREWIRE_HANDLING
 404             case USB_REQUEST_REBOOT:
 405 #ifdef HAVE_USB_POWER
 406                 if (usb_reboot_button())
 407 #endif
 408                     try_reboot();
 409                 break;
 410 #endif /* USB_FIREWIRE_HANDLING */
 411         }
 412     }
 413 }
 414
 415 #ifdef USB_STATUS_BY_EVENT
 416 void usb_status_event(int current_status)
 417 {
 418     /* Caller isn't expected to filter for changes in status.
 419      * current_status:
 420      *   USB_DETECT_BY_DRV: USB_POWERED, USB_UNPOWERED, USB_INSERTED (driver)
 421      *                else: USB_INSERTED, USB_EXTRACTED
 422      */
 423     if(usb_monitor_enabled)
 424     {
 425         int oldstatus = disable_irq_save(); /* Dual-use function */
 426
 427         if(last_usb_status != current_status)
 428         {
 429             last_usb_status = current_status;
 430             queue_post(&usb_queue, current_status, 0);
 431         }
 432
 433         restore_irq(oldstatus);
 434     }
 435 }
 436
 437 void usb_start_monitoring(void)
 438 {
 439     int oldstatus = disable_irq_save(); /* Sync to event */
 440     int status = usb_detect();
 441
 442     usb_monitor_enabled = true;
 443
 444 #ifdef USB_DETECT_BY_DRV
 445     status = (status == USB_INSERTED) ? USB_POWERED : USB_UNPOWERED;
 446 #endif
 447     usb_status_event(status);
 448
 449 #ifdef USB_FIREWIRE_HANDLING
 450     if (firewire_detect())
 451         usb_firewire_connect_event();
 452 #endif
 453
 454     restore_irq(oldstatus);
 455 }
 456
 457 #ifdef USB_FIREWIRE_HANDLING
 458 void usb_firewire_connect_event(void)
 459 {
 460     queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 461 }
 462 #endif /* USB_FIREWIRE_HANDLING */
 463 #else /* !USB_STATUS_BY_EVENT */
 464 static void usb_tick(void)
 465 {
 466     int current_status;
 467
 468     if(usb_monitor_enabled)
 469     {
 470 #ifdef USB_FIREWIRE_HANDLING
 471         int current_firewire_status = firewire_detect();
 472         if(current_firewire_status != last_firewire_status)
 473         {
 474             last_firewire_status = current_firewire_status;
 475             firewire_countdown = NUM_POLL_READINGS;
 476         }
 477         else
 478         {
 479             /* Count down until it gets negative */
 480             if(firewire_countdown >= 0)
 481                 firewire_countdown--;
 482
 483             /* Report to the thread if we have had 3 identical status
 484                readings in a row */
 485             if(firewire_countdown == 0)
 486             {
 487                 queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 488             }
 489         }
 490 #endif /* USB_FIREWIRE_HANDLING */
 491
 492         current_status = usb_detect();
 493
 494         /* Only report when the status has changed */
 495         if(current_status != last_usb_status)
 496         {
 497             last_usb_status = current_status;
 498             countdown = NUM_POLL_READINGS;
 499         }
 500         else
 501         {
 502             /* Count down until it gets negative */
 503             if(countdown >= 0)
 504                 countdown--;
 505
 506             /* Report to the thread if we have had 3 identical status
 507                readings in a row */
 508             if(countdown == 0)
 509             {
 510                 queue_post(&usb_queue, current_status, 0);
 511             }
 512         }
 513     }
 514 #if (CONFIG_STORAGE & STORAGE_MMC)
 515     if(usb_mmc_countdown > 0)
 516     {
 517         usb_mmc_countdown--;
 518         if (usb_mmc_countdown == 0)
 519             queue_post(&usb_queue, USB_REENABLE, 0);
 520     }
 521 #endif
 522 }
 523
 524 void usb_start_monitoring(void)
 525 {
 526     usb_monitor_enabled = true;
 527 }
 528 #endif /* USB_STATUS_BY_EVENT */
 529 #endif /* USB_FULL_INIT */
 530
 531 void usb_acknowledge(long id)
 532 {
 533     queue_post(&usb_queue, id, 0);
 534 }
 535
 536 void usb_init(void)
 537 {
 538     /* We assume that the USB cable is extracted */
 539     usb_state = USB_EXTRACTED;
 540 #ifdef USB_DETECT_BY_DRV
 541     last_usb_status = USB_UNPOWERED;
 542 #else
 543     last_usb_status = USB_EXTRACTED;
 544 #endif
 545     usb_monitor_enabled = false;
 546
 547 #ifdef HAVE_USBSTACK
 548     exclusive_storage_access = false;
 549 #endif
 550
 551 #ifdef USB_FIREWIRE_HANDLING
 552     firewire_countdown = -1;
 553     last_firewire_status = false;
 554 #endif
 555
 556     usb_init_device();
 557 #ifdef USB_FULL_INIT
 558     usb_enable(false);
 559
 560     queue_init(&usb_queue, true);
 561
 562     usb_thread_entry = create_thread(usb_thread, usb_stack,
 563                        sizeof(usb_stack), 0, usb_thread_name
 564                        IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU));
 565
 566 #ifndef USB_STATUS_BY_EVENT
 567     countdown = -1;
 568     tick_add_task(usb_tick);
 569 #endif
 570 #endif /* USB_FULL_INIT */
 571 }
 572
 573 void usb_wait_for_disconnect(struct event_queue *q)
 574 {
 575 #ifdef USB_FULL_INIT
 576     struct queue_event ev;
 577
 578     /* Don't return until we get SYS_USB_DISCONNECTED */
 579     while(1)
 580     {
 581         queue_wait(q, &ev);
 582         if(ev.id == SYS_USB_DISCONNECTED)
 583         {
 584             usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 585             return;
 586         }
 587     }
 588 #else
 589     (void)q;
 590 #endif /* USB_FULL_INIT */
 591 }
 592
 593 int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks)
 594 {
 595 #ifdef USB_FULL_INIT
 596     struct queue_event ev;
 597
 598     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
 599     while(1)
 600     {
 601         queue_wait_w_tmo(q, &ev, ticks);
 602         switch(ev.id)
 603         {
 604             case SYS_USB_DISCONNECTED:
 605                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 606                 return 0;
 607             case SYS_TIMEOUT:
 608                 return 1;
 609         }
 610     }
 611 #else
 612     (void)q; (void)ticks;
 613     return 0;
 614 #endif /* USB_FULL_INIT */
 615 }
 616
 617 #ifdef USB_DRIVER_CLOSE
 618 void usb_close(void)
 619 {
 620     unsigned int thread = usb_thread_entry;
 621     usb_thread_entry = 0;
 622
 623     if (thread == 0)
 624         return;
 625
 626 #ifndef USB_STATUS_BY_EVENT
 627     tick_remove_task(usb_tick);
 628 #endif
 629     usb_monitor_enabled = false;
 630
 631     queue_post(&usb_queue, USB_QUIT, 0);
 632     thread_wait(thread);
 633 }
 634 #endif /* USB_DRIVER_CLOSE */
 635
 636 bool usb_inserted(void)
 637 {
 638 #ifdef HAVE_USB_POWER
 639     return usb_state == USB_INSERTED || usb_state == USB_POWERED;
 640 #else
 641     return usb_state == USB_INSERTED;
 642 #endif
 643 }
 644
 645 #ifdef HAVE_USBSTACK
 646 bool usb_exclusive_storage(void)
 647 {
 648     return exclusive_storage_access;
 649 }
 650 #endif
 651
 652 #ifdef HAVE_USB_POWER
 653 bool usb_powered(void)
 654 {
 655     return usb_state == USB_POWERED;
 656 }
 657 #endif
 658
 659 #else
 660
 661 #ifdef USB_NONE
 662 bool usb_inserted(void)
 663 {
 664     return false;
 665 }
 666 #endif
 667
 668 /* Dummy simulator functions */
 669 void usb_acknowledge(long id)
 670 {
 671     id = id;
 672 }
 673
 674 void usb_init(void)
 675 {
 676 }
 677
 678 void usb_start_monitoring(void)
 679 {
 680 }
 681
 682 int usb_detect(void)
 683 {
 684     return USB_EXTRACTED;
 685 }
 686
 687 void usb_wait_for_disconnect(struct event_queue *q)
 688 {
 689    (void)q;
 690 }
 691
 692 #endif /* USB_NONE or SIMULATOR */