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  * All files in this archive are subject to the GNU General Public License.
  18  * See the file COPYING in the source tree root for full license agreement.
  19  *
  20  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  21  * KIND, either express or implied.
  22  *
  23  ****************************************************************************/
  24 #include "config.h"
  25 #include "cpu.h"
  26 #include "kernel.h"
  27 #include "thread.h"
  28 #include "system.h"
  29 #include "debug.h"
  30 #include "ata.h"
  31 #include "fat.h"
  32 #include "disk.h"
  33 #include "panic.h"
  34 #include "lcd.h"
  35 #include "usb.h"
  36 #include "button.h"
  37 #include "sprintf.h"
  38 #include "string.h"
  39 #include "usb-target.h"
  40 #ifdef HAVE_USBSTACK
  41 #include "usb_core.h"
  42 #endif
  43 #ifdef IRIVER_H300_SERIES
  44 #include "pcf50606.h"        /* for pcf50606_usb_charging_... */
  45 #endif
  46 #include "logf.h"
  47
  48 /* Conditions under which we want the entire driver */
  49 #if !defined(BOOTLOADER) || \
  50      (defined(TOSHIBA_GIGABEAT_S) && defined(USE_ROCKBOX_USB) && defined(USB_STORAGE)) || \
  51      (defined(CREATIVE_ZVM) && defined(HAVE_USBSTACK))
  52 #define USB_FULL_INIT
  53 #endif
  54
  55 extern void dbg_ports(void); /* NASTY! defined in apps/ */
  56
  57 #ifdef HAVE_LCD_BITMAP
  58 bool do_screendump_instead_of_usb = false;
  59 #if defined(USB_FULL_INIT) && defined(BOOTLOADER)
  60 static void screen_dump(void) {}
  61 #else
  62 void screen_dump(void);   /* Nasty again. Defined in apps/ too */
  63 #endif
  64 #endif
  65
  66 #if !defined(SIMULATOR) && !defined(USB_NONE)
  67
  68 #define NUM_POLL_READINGS (HZ/5)
  69 static int countdown;
  70
  71 static int usb_state;
  72
  73 #if defined(HAVE_MMC) && defined(USB_FULL_INIT)
  74 static int usb_mmc_countdown = 0;
  75 #endif
  76
  77 /* FIXME: The extra 0x800 is consumed by fat_mount() when the fsinfo
  78    needs updating */
  79 #ifdef USB_FULL_INIT
  80 static long usb_stack[(DEFAULT_STACK_SIZE + 0x800)/sizeof(long)];
  81 static const char usb_thread_name[] = "usb";
  82 static struct thread_entry *usb_thread_entry;
  83 #endif
  84 static struct event_queue usb_queue;
  85 static int last_usb_status;
  86 static bool usb_monitor_enabled;
  87 #ifdef HAVE_USBSTACK
  88 static bool exclusive_ata_access;
  89 #endif
  90
  91
  92 #if defined(IPOD_COLOR) || defined(IPOD_4G) \
  93  || defined(IPOD_MINI)  || defined(IPOD_MINI2G)
  94 static int firewire_countdown;
  95 static bool last_firewire_status;
  96 #endif
  97
  98 #ifdef USB_FULL_INIT
  99 #ifndef HAVE_USBSTACK
 100 static void usb_slave_mode(bool on)
 101 {
 102     int rc;
 103
 104     if(on)
 105     {
 106         DEBUGF("Entering USB slave mode\n");
 107         ata_soft_reset();
 108         ata_init();
 109         ata_enable(false);
 110         usb_enable(true);
 111     }
 112     else
 113     {
 114         DEBUGF("Leaving USB slave mode\n");
 115
 116         /* Let the ISDx00 settle */
 117         sleep(HZ*1);
 118
 119         usb_enable(false);
 120
 121         rc = ata_init();
 122         if(rc)
 123         {
 124             /* fixme: can we remove this? (already such in main.c) */
 125             char str[32];
 126             lcd_clear_display();
 127             snprintf(str, 31, "ATA error: %d", rc);
 128             lcd_puts(0, 0, str);
 129             lcd_puts(0, 1, "Press ON to debug");
 130             lcd_update();
 131             while(!(button_get(true) & BUTTON_REL)) {};
 132             dbg_ports();
 133             panicf("ata: %d",rc);
 134         }
 135
 136         rc = disk_mount_all();
 137         if (rc <= 0) /* no partition */
 138             panicf("mount: %d",rc);
 139
 140     }
 141 }
 142 #endif
 143
 144 static void try_reboot(void)
 145 {
 146 #ifndef HAVE_FLASH_STORAGE
 147     ata_sleepnow(); /* Immediately spindown the disk. */
 148     sleep(HZ*2);
 149 #endif
 150
 151 #ifdef IPOD_ARCH  /* The following code is based on ipodlinux */
 152 #if CONFIG_CPU == PP5020
 153     memcpy((void *)0x40017f00, "diskmode\0\0hotstuff\0\0\1", 21);
 154 #elif CONFIG_CPU == PP5022
 155     memcpy((void *)0x4001ff00, "diskmode\0\0hotstuff\0\0\1", 21);
 156 #endif /* CONFIG_CPU */
 157 #endif /* IPOD_ARCH */
 158
 159     system_reboot(); /* Reboot */
 160 }
 161
 162 static void usb_thread(void)
 163 {
 164     int num_acks_to_expect = -1;
 165     bool waiting_for_ack;
 166     struct queue_event ev;
 167
 168     waiting_for_ack = false;
 169
 170     while(1)
 171     {
 172         queue_wait(&usb_queue, &ev);
 173         switch(ev.id)
 174         {
 175 #ifdef HAVE_USBSTACK
 176             case USB_TRANSFER_COMPLETION:
 177                 usb_core_handle_transfer_completion((struct usb_transfer_completion_event_data*)ev.data);
 178                 break;
 179 #endif
 180 #ifdef HAVE_USB_POWER
 181             case USB_POWERED:
 182                 usb_state = USB_POWERED;
 183                 break;
 184 #endif
 185             case USB_INSERTED:
 186 #ifdef HAVE_LCD_BITMAP
 187                 if(do_screendump_instead_of_usb)
 188                 {
 189                     screen_dump();
 190                 }
 191                 else
 192 #endif
 193 #ifdef HAVE_USB_POWER
 194 #if defined(IRIVER_H10) || defined (IRIVER_H10_5GB)
 195                 if((button_status() & ~USBPOWER_BTN_IGNORE) != USBPOWER_BUTTON)
 196 #else
 197                 if((button_status() & ~USBPOWER_BTN_IGNORE) == USBPOWER_BUTTON)
 198 #endif
 199                 {
 200                     usb_state = USB_POWERED;
 201 #ifdef HAVE_USBSTACK
 202                     usb_core_enable_driver(USB_DRIVER_MASS_STORAGE,false);
 203                     usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY,true);
 204                     usb_enable(true);
 205 #endif
 206                 }
 207                 else
 208 #endif
 209                 {
 210 #ifdef HAVE_USBSTACK
 211                     /* Set the state to USB_POWERED for now. if a real
 212                        connection is detected it will switch to USB_INSERTED */
 213                     usb_state = USB_POWERED;
 214                     usb_core_enable_driver(USB_DRIVER_MASS_STORAGE,true);
 215                     usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY,false);
 216                     usb_enable(true);
 217 #else
 218                     /* Tell all threads that they have to back off the ATA.
 219                        We subtract one for our own thread. */
 220                     num_acks_to_expect =
 221                         queue_broadcast(SYS_USB_CONNECTED, 0) - 1;
 222                     waiting_for_ack = true;
 223                     DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
 224                            num_acks_to_expect);
 225 #endif
 226                 }
 227                 break;
 228 #ifdef HAVE_USBSTACK
 229             case USB_REQUEST_DISK:
 230                 if(!waiting_for_ack)
 231                 {
 232                     /* Tell all threads that they have to back off the ATA.
 233                        We subtract one for our own thread. */
 234                     num_acks_to_expect =
 235                         queue_broadcast(SYS_USB_CONNECTED, 0) - 1;
 236                     waiting_for_ack = true;
 237                     DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
 238                            num_acks_to_expect);
 239                 }
 240                 break;
 241             case USB_RELEASE_DISK:
 242                 if(!waiting_for_ack)
 243                 {
 244                     /* Tell all threads that they have to back off the ATA.
 245                        We subtract one for our own thread. */
 246                     num_acks_to_expect =
 247                         queue_broadcast(SYS_USB_DISCONNECTED, 0) - 1;
 248                     waiting_for_ack = true;
 249                     DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
 250                            num_acks_to_expect);
 251                 }
 252                 break;
 253 #endif
 254             case SYS_USB_CONNECTED_ACK:
 255                 if(waiting_for_ack)
 256                 {
 257                     num_acks_to_expect--;
 258                     if(num_acks_to_expect == 0)
 259                     {
 260                         DEBUGF("All threads have acknowledged the connect.\n");
 261 #ifdef HAVE_USBSTACK
 262 #ifndef USE_ROCKBOX_USB
 263                         /* until we have native mass-storage mode, we want to reboot on
 264                            usb host connect */
 265                         usb_enable(true);
 266                         try_reboot();
 267 #endif  /* USE_ROCKBOX_USB */
 268 #ifdef HAVE_PRIORITY_SCHEDULING
 269                         thread_set_priority(usb_thread_entry,PRIORITY_REALTIME);
 270 #endif
 271                         exclusive_ata_access = true;
 272
 273 #else
 274                         usb_slave_mode(true);
 275                         cpu_idle_mode(true);
 276 #endif
 277                         usb_state = USB_INSERTED;
 278                         waiting_for_ack = false;
 279                     }
 280                     else
 281                     {
 282                         DEBUGF("usb: got ack, %d to go...\n",
 283                                num_acks_to_expect);
 284                     }
 285                 }
 286                 break;
 287
 288             case USB_EXTRACTED:
 289 #ifdef HAVE_USBSTACK
 290                 usb_enable(false);
 291 #ifdef HAVE_PRIORITY_SCHEDULING
 292                 thread_set_priority(usb_thread_entry,PRIORITY_SYSTEM);
 293 #endif
 294 #endif
 295 #ifdef HAVE_LCD_BITMAP
 296                 if(do_screendump_instead_of_usb)
 297                     break;
 298 #endif
 299 #ifdef HAVE_USB_POWER
 300                 if(usb_state == USB_POWERED)
 301                 {
 302                     usb_state = USB_EXTRACTED;
 303                     break;
 304                 }
 305 #endif
 306 #ifndef HAVE_USBSTACK
 307                 if(usb_state == USB_INSERTED)
 308                 {
 309                     /* Only disable the USB mode if we really have enabled it
 310                        some threads might not have acknowledged the
 311                        insertion */
 312                     usb_slave_mode(false);
 313                     cpu_idle_mode(false);
 314                 }
 315 #endif
 316
 317                 usb_state = USB_EXTRACTED;
 318 #ifdef HAVE_USBSTACK
 319                 if(exclusive_ata_access)
 320                 {
 321                     exclusive_ata_access = false;
 322 #endif
 323                     /* Tell all threads that we are back in business */
 324                     num_acks_to_expect =
 325                         queue_broadcast(SYS_USB_DISCONNECTED, 0) - 1;
 326                     waiting_for_ack = true;
 327                     DEBUGF("USB extracted. Waiting for ack from %d threads...\n",
 328                            num_acks_to_expect);
 329 #ifdef HAVE_USBSTACK
 330                 }
 331 #endif
 332                 break;
 333
 334             case SYS_USB_DISCONNECTED_ACK:
 335                 if(waiting_for_ack)
 336                 {
 337                     num_acks_to_expect--;
 338                     if(num_acks_to_expect == 0)
 339                     {
 340                         DEBUGF("All threads have acknowledged. "
 341                                "We're in business.\n");
 342                         waiting_for_ack = false;
 343                     }
 344                     else
 345                     {
 346                         DEBUGF("usb: got ack, %d to go...\n",
 347                                num_acks_to_expect);
 348                     }
 349                 }
 350                 break;
 351
 352 #ifdef HAVE_HOTSWAP
 353             case SYS_HOTSWAP_INSERTED:
 354             case SYS_HOTSWAP_EXTRACTED:
 355 #ifdef HAVE_USBSTACK
 356                 usb_core_hotswap_event(1,ev.id == SYS_HOTSWAP_INSERTED);
 357 #else
 358                 if(usb_state == USB_INSERTED)
 359                 {
 360                     usb_enable(false);
 361                     usb_mmc_countdown = HZ/2; /* re-enable after 0.5 sec */
 362                 }
 363                 break;
 364 #endif
 365
 366             case USB_REENABLE:
 367                 if(usb_state == USB_INSERTED)
 368                     usb_enable(true);  /* reenable only if still inserted */
 369                 break;
 370 #endif
 371             case USB_REQUEST_REBOOT:
 372 #ifdef HAVE_USB_POWER
 373                 if((button_status() & ~USBPOWER_BTN_IGNORE) != USBPOWER_BUTTON)
 374 #endif
 375                     try_reboot();
 376                 break;
 377         }
 378     }
 379 }
 380 #endif
 381
 382 #ifdef HAVE_USBSTACK
 383 void usb_signal_transfer_completion(struct usb_transfer_completion_event_data* event_data)
 384 {
 385     queue_post(&usb_queue, USB_TRANSFER_COMPLETION, (intptr_t)event_data);
 386 }
 387 #endif
 388
 389 #ifdef USB_FULL_INIT
 390 static void usb_tick(void)
 391 {
 392     int current_status;
 393
 394     if(usb_monitor_enabled)
 395     {
 396 #if defined(IPOD_COLOR) || defined(IPOD_4G) \
 397  || defined(IPOD_MINI)  || defined(IPOD_MINI2G)
 398         int current_firewire_status = firewire_detect();
 399         if(current_firewire_status != last_firewire_status)
 400         {
 401             last_firewire_status = current_firewire_status;
 402             firewire_countdown = NUM_POLL_READINGS;
 403         }
 404         else
 405         {
 406             /* Count down until it gets negative */
 407             if(firewire_countdown >= 0)
 408                 firewire_countdown--;
 409
 410             /* Report to the thread if we have had 3 identical status
 411                readings in a row */
 412             if(firewire_countdown == 0)
 413             {
 414                 queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 415             }
 416         }
 417 #endif
 418
 419         current_status = usb_detect();
 420
 421         /* Only report when the status has changed */
 422         if(current_status != last_usb_status)
 423         {
 424             last_usb_status = current_status;
 425             countdown = NUM_POLL_READINGS;
 426         }
 427         else
 428         {
 429             /* Count down until it gets negative */
 430             if(countdown >= 0)
 431                 countdown--;
 432
 433             /* Report to the thread if we have had 3 identical status
 434                readings in a row */
 435             if(countdown == 0)
 436             {
 437                 queue_post(&usb_queue, current_status, 0);
 438             }
 439         }
 440     }
 441 #ifdef HAVE_MMC
 442     if(usb_mmc_countdown > 0)
 443     {
 444         usb_mmc_countdown--;
 445         if (usb_mmc_countdown == 0)
 446             queue_post(&usb_queue, USB_REENABLE, 0);
 447     }
 448 #endif
 449 }
 450 #endif
 451
 452 void usb_acknowledge(long id)
 453 {
 454     queue_post(&usb_queue, id, 0);
 455 }
 456
 457 void usb_init(void)
 458 {
 459     usb_state = USB_EXTRACTED;
 460 #ifdef HAVE_USBSTACK
 461     exclusive_ata_access = false;
 462 #endif
 463     usb_monitor_enabled = false;
 464     countdown = -1;
 465
 466 #if defined(IPOD_COLOR) || defined(IPOD_4G) \
 467  || defined(IPOD_MINI)  || defined(IPOD_MINI2G)
 468     firewire_countdown = -1;
 469     last_firewire_status = false;
 470 #endif
 471
 472     usb_init_device();
 473 #ifdef USB_FULL_INIT
 474     usb_enable(false);
 475 #endif
 476
 477     /* We assume that the USB cable is extracted */
 478     last_usb_status = USB_EXTRACTED;
 479
 480 #ifdef USB_FULL_INIT
 481     queue_init(&usb_queue, true);
 482
 483     usb_thread_entry = create_thread(usb_thread, usb_stack,
 484                        sizeof(usb_stack), 0, usb_thread_name
 485                        IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU));
 486
 487     tick_add_task(usb_tick);
 488 #endif
 489
 490 }
 491
 492 void usb_wait_for_disconnect(struct event_queue *q)
 493 {
 494     struct queue_event ev;
 495
 496     /* Don't return until we get SYS_USB_DISCONNECTED */
 497     while(1)
 498     {
 499         queue_wait(q, &ev);
 500         if(ev.id == SYS_USB_DISCONNECTED)
 501         {
 502             usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 503             return;
 504         }
 505     }
 506 }
 507
 508 int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks)
 509 {
 510     struct queue_event ev;
 511
 512     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
 513     while(1)
 514     {
 515         queue_wait_w_tmo(q, &ev, ticks);
 516         switch(ev.id)
 517         {
 518             case SYS_USB_DISCONNECTED:
 519                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 520                 return 0;
 521                 break;
 522             case SYS_TIMEOUT:
 523                 return 1;
 524                 break;
 525         }
 526     }
 527 }
 528
 529 void usb_start_monitoring(void)
 530 {
 531     usb_monitor_enabled = true;
 532 }
 533
 534 #ifdef TOSHIBA_GIGABEAT_S
 535 void usb_stop_monitoring(void)
 536 {
 537     tick_remove_task(usb_tick);
 538     usb_monitor_enabled = false;
 539 }
 540 #endif
 541
 542 bool usb_inserted(void)
 543 {
 544 #ifdef HAVE_USB_POWER
 545     return usb_state == USB_INSERTED || usb_state == USB_POWERED;
 546 #else
 547     return usb_state == USB_INSERTED;
 548 #endif
 549 }
 550
 551 #ifdef HAVE_USBSTACK
 552 void usb_request_exclusive_ata(void)
 553 {
 554     /* This is not really a clean place to start boosting the cpu. but it's
 555      * currently the best one. We want to get rid of having to boost the cpu
 556      * for usb anyway */
 557     trigger_cpu_boost();
 558     if(!exclusive_ata_access) {
 559         queue_post(&usb_queue, USB_REQUEST_DISK, 0);
 560     }
 561 }
 562
 563 void usb_release_exclusive_ata(void)
 564 {
 565     cancel_cpu_boost();
 566     if(exclusive_ata_access) {
 567         queue_post(&usb_queue, USB_RELEASE_DISK, 0);
 568         exclusive_ata_access = false;
 569     }
 570 }
 571
 572 bool usb_exclusive_ata(void)
 573 {
 574     return exclusive_ata_access;
 575 }
 576 #endif
 577
 578 #ifdef HAVE_USB_POWER
 579 bool usb_powered(void)
 580 {
 581     return usb_state == USB_POWERED;
 582 }
 583
 584 #if CONFIG_CHARGING
 585 bool usb_charging_enable(bool on)
 586 {
 587     bool rc = false;
 588 #ifdef IRIVER_H300_SERIES
 589     int irqlevel;
 590     logf("usb_charging_enable(%s)\n", on ? "on" : "off" );
 591     irqlevel = disable_irq_save();
 592     pcf50606_set_usb_charging(on);
 593     rc = on;
 594     restore_irq(irqlevel);
 595 #else
 596     /* TODO: implement it for other targets... */
 597     (void)on;
 598 #endif
 599     return rc;
 600 }
 601
 602 bool usb_charging_enabled(void)
 603 {
 604     bool rc = false;
 605 #ifdef IRIVER_H300_SERIES
 606     /* TODO: read the state of the GPOOD2 register...
 607      * (this also means to set the irq level here) */
 608     rc = pcf50606_usb_charging_enabled();
 609 #else
 610     /* TODO: implement it for other targets... */
 611 #endif
 612
 613     logf("usb charging %s", rc ? "enabled" : "disabled" );
 614     return rc;
 615 }
 616 #endif
 617 #endif
 618
 619 #else
 620
 621 #ifdef USB_NONE
 622 bool usb_inserted(void)
 623 {
 624     return false;
 625 }
 626 #endif
 627
 628 /* Dummy simulator functions */
 629 void usb_acknowledge(long id)
 630 {
 631     id = id;
 632 }
 633
 634 void usb_init(void)
 635 {
 636 }
 637
 638 void usb_start_monitoring(void)
 639 {
 640 }
 641
 642 int usb_detect(void)
 643 {
 644     return USB_EXTRACTED;
 645 }
 646
 647 void usb_wait_for_disconnect(struct event_queue *q)
 648 {
 649    (void)q;
 650 }
 651
 652 #endif /* USB_NONE or SIMULATOR */