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 #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                 exclusive_storage_access = false;
 365 #endif /* HAVE_USBSTACK */
 366
 367                 /* Tell all threads that we are back in business */
 368                 num_acks_to_expect =
 369                     queue_broadcast(SYS_USB_DISCONNECTED, 0) - 1;
 370                 DEBUGF("USB extracted. Waiting for ack from %d threads...\n",
 371                        num_acks_to_expect);
 372                 break;
 373
 374             case SYS_USB_DISCONNECTED_ACK:
 375                 if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
 376                 {
 377                     DEBUGF("All threads have acknowledged. "
 378                            "We're in business.\n");
 379                 }
 380                 else
 381                 {
 382                     DEBUGF("usb: got ack, %d to go...\n",
 383                            num_acks_to_expect);
 384                 }
 385                 break;
 386
 387 #ifdef HAVE_HOTSWAP
 388             case SYS_HOTSWAP_INSERTED:
 389             case SYS_HOTSWAP_EXTRACTED:
 390 #ifdef HAVE_USBSTACK
 391                 usb_core_hotswap_event(1,ev.id == SYS_HOTSWAP_INSERTED);
 392 #else  /* !HAVE_USBSTACK */
 393                 if(usb_state == USB_INSERTED)
 394                 {
 395                     usb_enable(false);
 396 #if (CONFIG_STORAGE & STORAGE_MMC)
 397                     usb_mmc_countdown = HZ/2; /* re-enable after 0.5 sec */
 398 #endif /* STORAGE_MMC */
 399                 }
 400 #endif /* HAVE_USBSTACK */
 401                 break;
 402
 403 #if (CONFIG_STORAGE & STORAGE_MMC)
 404             case USB_REENABLE:
 405                 if(usb_state == USB_INSERTED)
 406                     usb_enable(true);  /* reenable only if still inserted */
 407                 break;
 408 #endif /* STORAGE_MMC */
 409 #endif /* HAVE_HOTSWAP */
 410
 411 #ifdef USB_FIREWIRE_HANDLING
 412             case USB_REQUEST_REBOOT:
 413 #ifdef HAVE_USB_POWER
 414                 if (usb_reboot_button())
 415 #endif
 416                     try_reboot();
 417                 break;
 418 #endif /* USB_FIREWIRE_HANDLING */
 419         }
 420     }
 421 }
 422
 423 #ifdef USB_STATUS_BY_EVENT
 424 void usb_status_event(int current_status)
 425 {
 426     /* Caller isn't expected to filter for changes in status.
 427      * current_status:
 428      *   USB_DETECT_BY_DRV: USB_POWERED, USB_UNPOWERED, USB_INSERTED (driver)
 429      *                else: USB_INSERTED, USB_EXTRACTED
 430      */
 431     if(usb_monitor_enabled)
 432     {
 433         int oldstatus = disable_irq_save(); /* Dual-use function */
 434
 435         if(last_usb_status != current_status)
 436         {
 437             last_usb_status = current_status;
 438             queue_post(&usb_queue, current_status, 0);
 439         }
 440
 441         restore_irq(oldstatus);
 442     }
 443 }
 444
 445 void usb_start_monitoring(void)
 446 {
 447     int oldstatus = disable_irq_save(); /* Sync to event */
 448     int status = usb_detect();
 449
 450     usb_monitor_enabled = true;
 451
 452 #ifdef USB_DETECT_BY_DRV
 453     status = (status == USB_INSERTED) ? USB_POWERED : USB_UNPOWERED;
 454 #endif
 455     usb_status_event(status);
 456
 457 #ifdef USB_FIREWIRE_HANDLING
 458     if (firewire_detect())
 459         usb_firewire_connect_event();
 460 #endif
 461
 462     restore_irq(oldstatus);
 463 }
 464
 465 #ifdef USB_FIREWIRE_HANDLING
 466 void usb_firewire_connect_event(void)
 467 {
 468     queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 469 }
 470 #endif /* USB_FIREWIRE_HANDLING */
 471 #else /* !USB_STATUS_BY_EVENT */
 472 static void usb_tick(void)
 473 {
 474     int current_status;
 475
 476     if(usb_monitor_enabled)
 477     {
 478 #ifdef USB_FIREWIRE_HANDLING
 479         int current_firewire_status = firewire_detect();
 480         if(current_firewire_status != last_firewire_status)
 481         {
 482             last_firewire_status = current_firewire_status;
 483             firewire_countdown = NUM_POLL_READINGS;
 484         }
 485         else
 486         {
 487             /* Count down until it gets negative */
 488             if(firewire_countdown >= 0)
 489                 firewire_countdown--;
 490
 491             /* Report to the thread if we have had 3 identical status
 492                readings in a row */
 493             if(firewire_countdown == 0)
 494             {
 495                 queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
 496             }
 497         }
 498 #endif /* USB_FIREWIRE_HANDLING */
 499
 500         current_status = usb_detect();
 501
 502         /* Only report when the status has changed */
 503         if(current_status != last_usb_status)
 504         {
 505             last_usb_status = current_status;
 506             countdown = NUM_POLL_READINGS;
 507         }
 508         else
 509         {
 510             /* Count down until it gets negative */
 511             if(countdown >= 0)
 512                 countdown--;
 513
 514             /* Report to the thread if we have had 3 identical status
 515                readings in a row */
 516             if(countdown == 0)
 517             {
 518                 queue_post(&usb_queue, current_status, 0);
 519             }
 520         }
 521     }
 522 #if (CONFIG_STORAGE & STORAGE_MMC)
 523     if(usb_mmc_countdown > 0)
 524     {
 525         usb_mmc_countdown--;
 526         if (usb_mmc_countdown == 0)
 527             queue_post(&usb_queue, USB_REENABLE, 0);
 528     }
 529 #endif
 530 }
 531
 532 void usb_start_monitoring(void)
 533 {
 534     usb_monitor_enabled = true;
 535 }
 536 #endif /* USB_STATUS_BY_EVENT */
 537 #endif /* USB_FULL_INIT */
 538
 539 void usb_acknowledge(long id)
 540 {
 541     queue_post(&usb_queue, id, 0);
 542 }
 543
 544 void usb_init(void)
 545 {
 546     /* We assume that the USB cable is extracted */
 547     usb_state = USB_EXTRACTED;
 548 #ifdef USB_DETECT_BY_DRV
 549     last_usb_status = USB_UNPOWERED;
 550 #else
 551     last_usb_status = USB_EXTRACTED;
 552 #endif
 553     usb_monitor_enabled = false;
 554
 555 #ifdef HAVE_USBSTACK
 556     exclusive_storage_access = false;
 557 #endif
 558
 559 #ifdef USB_FIREWIRE_HANDLING
 560     firewire_countdown = -1;
 561     last_firewire_status = false;
 562 #endif
 563
 564     usb_init_device();
 565 #ifdef USB_FULL_INIT
 566     usb_enable(false);
 567
 568     queue_init(&usb_queue, true);
 569
 570     usb_thread_entry = create_thread(usb_thread, usb_stack,
 571                        sizeof(usb_stack), 0, usb_thread_name
 572                        IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU));
 573
 574 #ifndef USB_STATUS_BY_EVENT
 575     countdown = -1;
 576     tick_add_task(usb_tick);
 577 #endif
 578 #endif /* USB_FULL_INIT */
 579 }
 580
 581 void usb_wait_for_disconnect(struct event_queue *q)
 582 {
 583 #ifdef USB_FULL_INIT
 584     struct queue_event ev;
 585
 586     /* Don't return until we get SYS_USB_DISCONNECTED */
 587     while(1)
 588     {
 589         queue_wait(q, &ev);
 590         if(ev.id == SYS_USB_DISCONNECTED)
 591         {
 592             usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 593             return;
 594         }
 595     }
 596 #else
 597     (void)q;
 598 #endif /* USB_FULL_INIT */
 599 }
 600
 601 int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks)
 602 {
 603 #ifdef USB_FULL_INIT
 604     struct queue_event ev;
 605
 606     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
 607     while(1)
 608     {
 609         queue_wait_w_tmo(q, &ev, ticks);
 610         switch(ev.id)
 611         {
 612             case SYS_USB_DISCONNECTED:
 613                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 614                 return 0;
 615             case SYS_TIMEOUT:
 616                 return 1;
 617         }
 618     }
 619 #else
 620     (void)q; (void)ticks;
 621     return 0;
 622 #endif /* USB_FULL_INIT */
 623 }
 624
 625 #ifdef USB_DRIVER_CLOSE
 626 void usb_close(void)
 627 {
 628     unsigned int thread = usb_thread_entry;
 629     usb_thread_entry = 0;
 630
 631     if (thread == 0)
 632         return;
 633
 634 #ifndef USB_STATUS_BY_EVENT
 635     tick_remove_task(usb_tick);
 636 #endif
 637     usb_monitor_enabled = false;
 638
 639     queue_post(&usb_queue, USB_QUIT, 0);
 640     thread_wait(thread);
 641 }
 642 #endif /* USB_DRIVER_CLOSE */
 643
 644 bool usb_inserted(void)
 645 {
 646 #ifdef HAVE_USB_POWER
 647     return usb_state == USB_INSERTED || usb_state == USB_POWERED;
 648 #else
 649     return usb_state == USB_INSERTED;
 650 #endif
 651 }
 652
 653 #ifdef HAVE_USBSTACK
 654 bool usb_exclusive_storage(void)
 655 {
 656     return exclusive_storage_access;
 657 }
 658 #endif
 659
 660 #ifdef HAVE_USB_POWER
 661 bool usb_powered(void)
 662 {
 663     return usb_state == USB_POWERED;
 664 }
 665 #endif
 666
 667 #else
 668
 669 #ifdef USB_NONE
 670 bool usb_inserted(void)
 671 {
 672     return false;
 673 }
 674 #endif
 675
 676 /* Dummy simulator functions */
 677 void usb_acknowledge(long id)
 678 {
 679     id = id;
 680 }
 681
 682 void usb_init(void)
 683 {
 684 }
 685
 686 void usb_start_monitoring(void)
 687 {
 688 }
 689
 690 int usb_detect(void)
 691 {
 692     return USB_EXTRACTED;
 693 }
 694
 695 void usb_wait_for_disconnect(struct event_queue *q)
 696 {
 697    (void)q;
 698 }
 699
 700 #endif /* USB_NONE or SIMULATOR */