2002-06-29 22:41:39 +00:00
|
|
|
/***************************************************************************
|
|
|
|
* __________ __ ___.
|
|
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
|
|
* \/ \/ \/ \/ \/
|
|
|
|
* $Id$
|
|
|
|
*
|
|
|
|
* Copyright (C) 2002 by Linus Nielsen Feltzing
|
|
|
|
*
|
2006-01-07 00:43:48 +00:00
|
|
|
* iPod driver based on code from the ipodlinux project - http://ipodlinux.org
|
|
|
|
* Adapted for Rockbox in January 2006
|
|
|
|
* Original file: podzilla/usb.c
|
|
|
|
* Copyright (C) 2005 Adam Johnston
|
|
|
|
*
|
2008-06-28 18:10:04 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-06-29 22:41:39 +00:00
|
|
|
*
|
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
#include "config.h"
|
2004-11-02 22:57:51 +00:00
|
|
|
#include "cpu.h"
|
2002-06-29 22:41:39 +00:00
|
|
|
#include "kernel.h"
|
|
|
|
#include "thread.h"
|
|
|
|
#include "system.h"
|
|
|
|
#include "debug.h"
|
2008-11-01 16:14:28 +00:00
|
|
|
#include "storage.h"
|
2002-06-30 13:13:13 +00:00
|
|
|
#include "fat.h"
|
|
|
|
#include "disk.h"
|
|
|
|
#include "panic.h"
|
2002-06-30 14:11:28 +00:00
|
|
|
#include "lcd.h"
|
2009-01-19 13:41:25 +00:00
|
|
|
#include "usb-target.h"
|
2002-07-01 12:19:12 +00:00
|
|
|
#include "usb.h"
|
2002-07-02 18:30:39 +00:00
|
|
|
#include "button.h"
|
2006-01-07 00:43:48 +00:00
|
|
|
#include "string.h"
|
2008-02-27 19:08:30 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
|
|
|
#include "usb_core.h"
|
|
|
|
#endif
|
2009-04-18 21:32:41 +00:00
|
|
|
#include "logf.h"
|
2009-02-10 23:43:37 +00:00
|
|
|
#include "screendump.h"
|
2002-06-30 13:13:13 +00:00
|
|
|
|
2008-04-18 16:42:50 +00:00
|
|
|
/* Conditions under which we want the entire driver */
|
2008-09-24 21:17:53 +00:00
|
|
|
#if !defined(BOOTLOADER) || (CONFIG_CPU == SH7034) || \
|
2009-05-23 14:30:20 +00:00
|
|
|
(defined(TOSHIBA_GIGABEAT_S) && defined(USE_ROCKBOX_USB) && defined(USB_ENABLE_STORAGE)) || \
|
2009-10-20 07:21:08 +00:00
|
|
|
(defined(HAVE_USBSTACK) && (defined(CREATIVE_ZVx))) || \
|
|
|
|
(defined(HAVE_USBSTACK) && (defined(OLYMPUS_MROBE_500))) || \
|
|
|
|
(defined(HAVE_USBSTACK) && (defined(IPOD_NANO2G))) || \
|
|
|
|
defined(CPU_TCC77X) || defined(CPU_TCC780X) || \
|
2008-11-21 12:50:06 +00:00
|
|
|
(CONFIG_USBOTG == USBOTG_JZ4740)
|
2008-04-18 16:42:50 +00:00
|
|
|
#define USB_FULL_INIT
|
|
|
|
#endif
|
|
|
|
|
2004-06-30 13:31:14 +00:00
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
|
|
bool do_screendump_instead_of_usb = false;
|
2008-04-18 16:42:50 +00:00
|
|
|
#endif
|
2004-06-30 13:31:14 +00:00
|
|
|
|
2003-12-12 13:30:15 +00:00
|
|
|
#if !defined(SIMULATOR) && !defined(USB_NONE)
|
2002-06-29 22:41:39 +00:00
|
|
|
|
2002-07-01 11:02:54 +00:00
|
|
|
static int usb_state;
|
|
|
|
|
2008-10-31 21:25:04 +00:00
|
|
|
#if (CONFIG_STORAGE & STORAGE_MMC) && defined(USB_FULL_INIT)
|
2004-10-10 19:51:11 +00:00
|
|
|
static int usb_mmc_countdown = 0;
|
|
|
|
#endif
|
|
|
|
|
2005-02-11 14:34:32 +00:00
|
|
|
/* FIXME: The extra 0x800 is consumed by fat_mount() when the fsinfo
|
2004-03-25 14:08:58 +00:00
|
|
|
needs updating */
|
2008-04-18 16:42:50 +00:00
|
|
|
#ifdef USB_FULL_INIT
|
2005-02-11 14:34:32 +00:00
|
|
|
static long usb_stack[(DEFAULT_STACK_SIZE + 0x800)/sizeof(long)];
|
2004-08-03 19:22:56 +00:00
|
|
|
static const char usb_thread_name[] = "usb";
|
2008-12-10 08:57:10 +00:00
|
|
|
static unsigned int usb_thread_entry = 0;
|
2009-01-14 07:01:49 +00:00
|
|
|
#ifndef USB_STATUS_BY_EVENT
|
|
|
|
#define NUM_POLL_READINGS (HZ/5)
|
|
|
|
static int countdown;
|
|
|
|
#endif /* USB_STATUS_BY_EVENT */
|
2009-01-14 07:23:41 +00:00
|
|
|
#endif /* USB_FULL_INIT */
|
|
|
|
static struct event_queue usb_queue;
|
2002-06-30 13:13:13 +00:00
|
|
|
static bool usb_monitor_enabled;
|
2009-01-14 07:01:49 +00:00
|
|
|
static int last_usb_status;
|
2008-03-02 00:43:45 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
2008-11-01 16:14:28 +00:00
|
|
|
static bool exclusive_storage_access;
|
2008-03-02 00:43:45 +00:00
|
|
|
#endif
|
2002-06-30 13:13:13 +00:00
|
|
|
|
2009-01-13 16:27:35 +00:00
|
|
|
#ifdef USB_FIREWIRE_HANDLING
|
2008-02-27 19:08:30 +00:00
|
|
|
static int firewire_countdown;
|
|
|
|
static bool last_firewire_status;
|
|
|
|
#endif
|
|
|
|
|
2008-04-18 16:42:50 +00:00
|
|
|
#ifdef USB_FULL_INIT
|
2009-01-13 16:27:35 +00:00
|
|
|
|
|
|
|
#if defined(USB_FIREWIRE_HANDLING) \
|
|
|
|
|| (defined(HAVE_USBSTACK) && !defined(USE_ROCKBOX_USB))
|
|
|
|
static void try_reboot(void)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_DISK_STORAGE
|
|
|
|
storage_sleepnow(); /* Immediately spindown the disk. */
|
|
|
|
sleep(HZ*2);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef IPOD_ARCH /* The following code is based on ipodlinux */
|
|
|
|
#if CONFIG_CPU == PP5020
|
|
|
|
memcpy((void *)0x40017f00, "diskmode\0\0hotstuff\0\0\1", 21);
|
|
|
|
#elif CONFIG_CPU == PP5022
|
|
|
|
memcpy((void *)0x4001ff00, "diskmode\0\0hotstuff\0\0\1", 21);
|
|
|
|
#endif /* CONFIG_CPU */
|
|
|
|
#endif /* IPOD_ARCH */
|
|
|
|
|
2009-10-20 06:37:07 +00:00
|
|
|
#ifdef IPOD_NANO2G
|
|
|
|
memcpy((void *)0x0002bf00, "diskmodehotstuff\1\0\0\0", 20);
|
|
|
|
#endif
|
|
|
|
|
2009-01-13 16:27:35 +00:00
|
|
|
system_reboot(); /* Reboot */
|
|
|
|
}
|
|
|
|
#endif /* USB_FIRWIRE_HANDLING || (HAVE_USBSTACK && !USE_ROCKBOX_USB) */
|
|
|
|
|
|
|
|
#ifdef HAVE_USBSTACK
|
|
|
|
/* inline since branch is chosen at compile time */
|
|
|
|
static inline void usb_slave_mode(bool on)
|
|
|
|
{
|
|
|
|
#ifdef USE_ROCKBOX_USB
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (on)
|
|
|
|
{
|
|
|
|
trigger_cpu_boost();
|
|
|
|
#ifdef HAVE_PRIORITY_SCHEDULING
|
|
|
|
thread_set_priority(THREAD_ID_CURRENT, PRIORITY_REALTIME);
|
|
|
|
#endif
|
2009-01-19 13:41:25 +00:00
|
|
|
usb_attach();
|
2009-01-13 16:27:35 +00:00
|
|
|
}
|
|
|
|
else /* usb_state == USB_INSERTED (only!) */
|
|
|
|
{
|
2009-01-19 13:41:25 +00:00
|
|
|
#ifndef USB_DETECT_BY_DRV
|
2009-01-13 16:27:35 +00:00
|
|
|
usb_enable(false);
|
2009-01-19 13:41:25 +00:00
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
#ifdef HAVE_PRIORITY_SCHEDULING
|
|
|
|
thread_set_priority(THREAD_ID_CURRENT, PRIORITY_SYSTEM);
|
|
|
|
#endif
|
|
|
|
/* Entered exclusive mode */
|
|
|
|
rc = disk_mount_all();
|
|
|
|
if (rc <= 0) /* no partition */
|
|
|
|
panicf("mount: %d",rc);
|
|
|
|
|
|
|
|
cancel_cpu_boost();
|
|
|
|
}
|
2009-10-13 10:07:13 +00:00
|
|
|
#else /* !USE_ROCKBOX_USB */
|
2009-01-13 16:27:35 +00:00
|
|
|
if (on)
|
|
|
|
{
|
|
|
|
/* until we have native mass-storage mode, we want to reboot on
|
|
|
|
usb host connect */
|
|
|
|
try_reboot();
|
|
|
|
}
|
|
|
|
#endif /* USE_ROCKBOX_USB */
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_signal_transfer_completion(
|
|
|
|
struct usb_transfer_completion_event_data* event_data)
|
|
|
|
{
|
|
|
|
queue_post(&usb_queue, USB_TRANSFER_COMPLETION, (intptr_t)event_data);
|
|
|
|
}
|
|
|
|
#else /* !HAVE_USBSTACK */
|
|
|
|
/* inline since branch is chosen at compile time */
|
|
|
|
static inline void usb_slave_mode(bool on)
|
2002-06-30 13:13:13 +00:00
|
|
|
{
|
|
|
|
int rc;
|
2009-04-18 21:32:41 +00:00
|
|
|
|
2002-06-30 13:13:13 +00:00
|
|
|
if(on)
|
|
|
|
{
|
2002-07-01 11:02:54 +00:00
|
|
|
DEBUGF("Entering USB slave mode\n");
|
2008-11-01 16:14:28 +00:00
|
|
|
storage_soft_reset();
|
|
|
|
storage_init();
|
|
|
|
storage_enable(false);
|
2002-07-01 11:02:54 +00:00
|
|
|
usb_enable(true);
|
2009-01-13 16:27:35 +00:00
|
|
|
cpu_idle_mode(true);
|
2002-06-30 13:13:13 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2002-07-01 11:02:54 +00:00
|
|
|
DEBUGF("Leaving USB slave mode\n");
|
2007-11-22 20:51:00 +00:00
|
|
|
|
2009-01-13 16:27:35 +00:00
|
|
|
cpu_idle_mode(false);
|
|
|
|
|
2002-07-01 11:02:54 +00:00
|
|
|
/* Let the ISDx00 settle */
|
|
|
|
sleep(HZ*1);
|
2009-04-18 21:32:41 +00:00
|
|
|
|
2002-07-01 11:02:54 +00:00
|
|
|
usb_enable(false);
|
2002-06-30 13:13:13 +00:00
|
|
|
|
2008-11-01 16:14:28 +00:00
|
|
|
rc = storage_init();
|
2002-07-01 11:02:54 +00:00
|
|
|
if(rc)
|
2008-11-01 16:14:28 +00:00
|
|
|
panicf("storage: %d",rc);
|
2009-04-18 21:32:41 +00:00
|
|
|
|
2004-12-29 22:10:24 +00:00
|
|
|
rc = disk_mount_all();
|
|
|
|
if (rc <= 0) /* no partition */
|
2002-07-01 11:02:54 +00:00
|
|
|
panicf("mount: %d",rc);
|
2002-06-30 13:13:13 +00:00
|
|
|
}
|
|
|
|
}
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* HAVE_USBSTACK */
|
2008-02-27 19:08:30 +00:00
|
|
|
|
2009-01-13 16:27:35 +00:00
|
|
|
#ifdef HAVE_USB_POWER
|
|
|
|
static inline bool usb_power_button(void)
|
2008-02-27 19:08:30 +00:00
|
|
|
{
|
2009-02-25 22:36:35 +00:00
|
|
|
#if (defined(IRIVER_H10) || defined (IRIVER_H10_5GB)) && !defined(USE_ROCKBOX_USB)
|
2009-01-13 16:27:35 +00:00
|
|
|
return (button_status() & ~USBPOWER_BTN_IGNORE) != USBPOWER_BUTTON;
|
|
|
|
#else
|
|
|
|
return (button_status() & ~USBPOWER_BTN_IGNORE) == USBPOWER_BUTTON;
|
2008-02-27 19:08:30 +00:00
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
}
|
2008-02-27 19:08:30 +00:00
|
|
|
|
2009-01-13 16:27:35 +00:00
|
|
|
#ifdef USB_FIREWIRE_HANDLING
|
|
|
|
static inline bool usb_reboot_button(void)
|
|
|
|
{
|
|
|
|
return (button_status() & ~USBPOWER_BTN_IGNORE) != USBPOWER_BUTTON;
|
2008-02-27 19:08:30 +00:00
|
|
|
}
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif
|
|
|
|
#endif /* HAVE_USB_POWER */
|
2002-06-29 22:41:39 +00:00
|
|
|
|
2009-10-23 13:29:19 +00:00
|
|
|
#ifdef USB_ENABLE_HID
|
|
|
|
static bool usb_hid = true;
|
|
|
|
#endif
|
|
|
|
|
2002-06-29 22:41:39 +00:00
|
|
|
static void usb_thread(void)
|
|
|
|
{
|
2009-01-13 16:27:35 +00:00
|
|
|
int num_acks_to_expect = 0;
|
2007-10-16 01:25:17 +00:00
|
|
|
struct queue_event ev;
|
2002-06-29 22:41:39 +00:00
|
|
|
|
|
|
|
while(1)
|
|
|
|
{
|
2002-07-01 11:02:54 +00:00
|
|
|
queue_wait(&usb_queue, &ev);
|
|
|
|
switch(ev.id)
|
|
|
|
{
|
2008-05-10 18:00:11 +00:00
|
|
|
#ifdef USB_DRIVER_CLOSE
|
|
|
|
case USB_QUIT:
|
|
|
|
return;
|
|
|
|
#endif
|
2008-02-27 19:08:30 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
|
|
|
case USB_TRANSFER_COMPLETION:
|
2009-01-13 16:27:35 +00:00
|
|
|
usb_core_handle_transfer_completion(
|
|
|
|
(struct usb_transfer_completion_event_data*)ev.data);
|
2007-09-04 08:03:07 +00:00
|
|
|
break;
|
|
|
|
#endif
|
2009-01-19 13:41:25 +00:00
|
|
|
#ifdef USB_DETECT_BY_DRV
|
|
|
|
/* In this case, these events the handle cable insertion USB
|
|
|
|
* driver determines INSERTED/EXTRACTED state. */
|
|
|
|
case USB_POWERED:
|
|
|
|
/* Set the state to USB_POWERED for now and enable the driver
|
|
|
|
* to detect a bus reset only. If a bus reset is detected,
|
|
|
|
* USB_INSERTED will be received. */
|
|
|
|
usb_state = USB_POWERED;
|
|
|
|
usb_enable(true);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_UNPOWERED:
|
|
|
|
usb_enable(false);
|
|
|
|
/* This part shouldn't be obligatory for anything that can
|
|
|
|
* reliably detect removal of the data lines. USB_EXTRACTED
|
|
|
|
* could be posted on that event while bus power remains
|
|
|
|
* available. */
|
|
|
|
queue_post(&usb_queue, USB_EXTRACTED, 0);
|
|
|
|
break;
|
|
|
|
#endif /* USB_DETECT_BY_DRV */
|
2002-07-01 11:02:54 +00:00
|
|
|
case USB_INSERTED:
|
2004-06-30 13:31:14 +00:00
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
|
|
if(do_screendump_instead_of_usb)
|
|
|
|
{
|
2009-01-13 16:27:35 +00:00
|
|
|
usb_state = USB_SCREENDUMP;
|
2004-06-30 13:31:14 +00:00
|
|
|
screen_dump();
|
2009-02-10 23:43:37 +00:00
|
|
|
#ifdef HAVE_REMOTE_LCD
|
|
|
|
remote_screen_dump();
|
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
break;
|
2004-06-30 13:31:14 +00:00
|
|
|
}
|
2005-06-23 02:18:29 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_USB_POWER
|
2009-01-19 13:41:25 +00:00
|
|
|
if(usb_power_button())
|
2004-06-30 13:31:14 +00:00
|
|
|
{
|
2009-01-13 16:27:35 +00:00
|
|
|
/* Only charging is desired */
|
2005-06-23 02:18:29 +00:00
|
|
|
usb_state = USB_POWERED;
|
2008-02-27 19:08:30 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
2009-05-23 14:30:20 +00:00
|
|
|
#ifdef USB_ENABLE_STORAGE
|
2009-01-13 16:27:35 +00:00
|
|
|
usb_core_enable_driver(USB_DRIVER_MASS_STORAGE, false);
|
2009-04-18 21:32:41 +00:00
|
|
|
#endif
|
2009-05-23 14:30:20 +00:00
|
|
|
|
|
|
|
#ifdef USB_ENABLE_HID
|
|
|
|
#ifdef USB_ENABLE_CHARGING_ONLY
|
2009-05-16 15:30:09 +00:00
|
|
|
usb_core_enable_driver(USB_DRIVER_HID, false);
|
2009-05-23 14:30:20 +00:00
|
|
|
#else
|
2009-10-23 13:52:21 +00:00
|
|
|
usb_core_enable_driver(USB_DRIVER_HID, true);
|
2009-05-23 14:30:20 +00:00
|
|
|
#endif /* USB_ENABLE_CHARGING_ONLY */
|
|
|
|
#endif /* USB_ENABLE_HID */
|
|
|
|
|
|
|
|
#ifdef USB_ENABLE_CHARGING_ONLY
|
2009-01-13 16:27:35 +00:00
|
|
|
usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY, true);
|
2009-04-18 21:32:41 +00:00
|
|
|
#endif
|
2009-01-19 13:41:25 +00:00
|
|
|
usb_attach();
|
2008-03-02 00:15:02 +00:00
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
break;
|
2004-06-30 13:31:14 +00:00
|
|
|
}
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* HAVE_USB_POWER */
|
2008-03-02 00:15:02 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
2009-01-13 17:04:31 +00:00
|
|
|
#ifdef HAVE_USB_POWER
|
2009-01-13 16:27:35 +00:00
|
|
|
/* Set the state to USB_POWERED for now. If permission to connect
|
|
|
|
* by threads and storage is granted it will be changed to
|
|
|
|
* USB_CONNECTED. */
|
|
|
|
usb_state = USB_POWERED;
|
2009-01-13 17:04:31 +00:00
|
|
|
#endif
|
2009-05-23 14:30:20 +00:00
|
|
|
#ifdef USB_ENABLE_STORAGE
|
2009-01-13 16:27:35 +00:00
|
|
|
usb_core_enable_driver(USB_DRIVER_MASS_STORAGE, true);
|
2009-04-18 21:32:41 +00:00
|
|
|
#endif
|
2009-05-23 14:30:20 +00:00
|
|
|
#ifdef USB_ENABLE_HID
|
2009-10-23 13:29:19 +00:00
|
|
|
usb_core_enable_driver(USB_DRIVER_HID, usb_hid);
|
2009-05-16 15:30:09 +00:00
|
|
|
#endif
|
2009-05-23 14:30:20 +00:00
|
|
|
#ifdef USB_ENABLE_CHARGING_ONLY
|
2009-01-13 16:27:35 +00:00
|
|
|
usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY, false);
|
2009-04-18 21:32:41 +00:00
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
|
|
|
|
/* Check any drivers enabled at this point for exclusive storage
|
|
|
|
* access requirements. */
|
|
|
|
exclusive_storage_access = usb_core_any_exclusive_storage();
|
|
|
|
|
2009-01-14 07:01:49 +00:00
|
|
|
if(!exclusive_storage_access)
|
2008-03-02 00:15:02 +00:00
|
|
|
{
|
2009-01-19 13:41:25 +00:00
|
|
|
usb_attach();
|
2009-01-14 07:01:49 +00:00
|
|
|
break;
|
2008-03-02 00:15:02 +00:00
|
|
|
}
|
2009-01-14 07:01:49 +00:00
|
|
|
#endif /* HAVE_USBSTACK */
|
|
|
|
/* Tell all threads that they have to back off the storage.
|
|
|
|
We subtract one for our own thread. */
|
|
|
|
num_acks_to_expect = queue_broadcast(SYS_USB_CONNECTED, 0) - 1;
|
|
|
|
DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
|
2009-05-16 15:33:22 +00:00
|
|
|
num_acks_to_expect);
|
2008-03-02 00:15:02 +00:00
|
|
|
break;
|
2009-01-13 16:27:35 +00:00
|
|
|
|
|
|
|
case SYS_USB_CONNECTED_ACK:
|
|
|
|
if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
|
2008-03-10 20:55:24 +00:00
|
|
|
{
|
2009-01-13 16:27:35 +00:00
|
|
|
DEBUGF("All threads have acknowledged the connect.\n");
|
|
|
|
usb_slave_mode(true);
|
|
|
|
usb_state = USB_INSERTED;
|
2008-03-10 20:55:24 +00:00
|
|
|
}
|
2009-01-13 16:27:35 +00:00
|
|
|
else
|
2002-07-01 11:02:54 +00:00
|
|
|
{
|
2009-01-13 16:27:35 +00:00
|
|
|
DEBUGF("usb: got ack, %d to go...\n",
|
|
|
|
num_acks_to_expect);
|
2002-07-01 11:02:54 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_EXTRACTED:
|
2004-06-30 13:31:14 +00:00
|
|
|
#ifdef HAVE_LCD_BITMAP
|
2009-01-13 16:27:35 +00:00
|
|
|
if(usb_state == USB_SCREENDUMP)
|
|
|
|
{
|
|
|
|
usb_state = USB_EXTRACTED;
|
|
|
|
break; /* Connected for screendump only */
|
|
|
|
}
|
2009-01-19 13:41:25 +00:00
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
#ifndef HAVE_USBSTACK /* Stack must undo this if POWERED state was transitional */
|
2009-01-13 16:45:36 +00:00
|
|
|
#ifdef HAVE_USB_POWER
|
2005-06-23 02:18:29 +00:00
|
|
|
if(usb_state == USB_POWERED)
|
|
|
|
{
|
2004-06-30 13:31:14 +00:00
|
|
|
usb_state = USB_EXTRACTED;
|
2005-06-23 02:18:29 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-01-19 13:41:25 +00:00
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* HAVE_USBSTACK */
|
2005-06-23 02:18:29 +00:00
|
|
|
if(usb_state == USB_INSERTED)
|
|
|
|
{
|
|
|
|
/* Only disable the USB mode if we really have enabled it
|
|
|
|
some threads might not have acknowledged the
|
|
|
|
insertion */
|
|
|
|
usb_slave_mode(false);
|
2004-06-30 13:31:14 +00:00
|
|
|
}
|
2005-06-23 02:18:29 +00:00
|
|
|
|
|
|
|
usb_state = USB_EXTRACTED;
|
2008-03-10 21:16:31 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
2009-01-19 13:41:25 +00:00
|
|
|
if(!exclusive_storage_access)
|
2009-01-14 07:01:49 +00:00
|
|
|
{
|
2009-01-19 13:41:25 +00:00
|
|
|
#ifndef USB_DETECT_BY_DRV /* Disabled handling USB_UNPOWERED */
|
2009-01-14 07:01:49 +00:00
|
|
|
usb_enable(false);
|
2009-01-19 13:41:25 +00:00
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
break;
|
2009-01-14 07:01:49 +00:00
|
|
|
}
|
2009-01-13 16:27:35 +00:00
|
|
|
|
|
|
|
#endif /* HAVE_USBSTACK */
|
2009-02-28 15:16:54 +00:00
|
|
|
num_acks_to_expect = usb_release_exclusive_storage();
|
2009-01-14 07:01:49 +00:00
|
|
|
|
2002-07-01 11:02:54 +00:00
|
|
|
break;
|
2005-06-23 02:18:29 +00:00
|
|
|
|
2002-07-01 11:02:54 +00:00
|
|
|
case SYS_USB_DISCONNECTED_ACK:
|
2009-01-13 16:27:35 +00:00
|
|
|
if(num_acks_to_expect > 0 && --num_acks_to_expect == 0)
|
2002-07-01 11:02:54 +00:00
|
|
|
{
|
2009-01-13 16:27:35 +00:00
|
|
|
DEBUGF("All threads have acknowledged. "
|
|
|
|
"We're in business.\n");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DEBUGF("usb: got ack, %d to go...\n",
|
|
|
|
num_acks_to_expect);
|
2002-07-01 11:02:54 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-10-10 19:51:11 +00:00
|
|
|
|
2008-03-10 20:55:24 +00:00
|
|
|
#ifdef HAVE_HOTSWAP
|
2007-06-30 02:08:27 +00:00
|
|
|
case SYS_HOTSWAP_INSERTED:
|
|
|
|
case SYS_HOTSWAP_EXTRACTED:
|
2008-03-10 20:55:24 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
|
|
|
usb_core_hotswap_event(1,ev.id == SYS_HOTSWAP_INSERTED);
|
2009-01-13 16:27:35 +00:00
|
|
|
#else /* !HAVE_USBSTACK */
|
2004-10-10 19:51:11 +00:00
|
|
|
if(usb_state == USB_INSERTED)
|
|
|
|
{
|
2008-11-09 14:40:42 +00:00
|
|
|
#if (CONFIG_STORAGE & STORAGE_MMC)
|
2010-06-05 22:04:14 +00:00
|
|
|
usb_enable(false);
|
2004-10-10 19:51:11 +00:00
|
|
|
usb_mmc_countdown = HZ/2; /* re-enable after 0.5 sec */
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* STORAGE_MMC */
|
2004-10-10 19:51:11 +00:00
|
|
|
}
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* HAVE_USBSTACK */
|
2008-09-16 21:59:01 +00:00
|
|
|
break;
|
2004-10-10 19:51:11 +00:00
|
|
|
|
2009-01-13 16:27:35 +00:00
|
|
|
#if (CONFIG_STORAGE & STORAGE_MMC)
|
2004-10-10 19:51:11 +00:00
|
|
|
case USB_REENABLE:
|
|
|
|
if(usb_state == USB_INSERTED)
|
|
|
|
usb_enable(true); /* reenable only if still inserted */
|
|
|
|
break;
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* STORAGE_MMC */
|
2008-09-16 21:59:01 +00:00
|
|
|
#endif /* HAVE_HOTSWAP */
|
2009-01-13 16:27:35 +00:00
|
|
|
|
|
|
|
#ifdef USB_FIREWIRE_HANDLING
|
2008-02-27 19:08:30 +00:00
|
|
|
case USB_REQUEST_REBOOT:
|
2008-02-28 10:11:29 +00:00
|
|
|
#ifdef HAVE_USB_POWER
|
2009-01-13 16:27:35 +00:00
|
|
|
if (usb_reboot_button())
|
2008-02-27 19:23:16 +00:00
|
|
|
#endif
|
2008-02-27 19:08:30 +00:00
|
|
|
try_reboot();
|
|
|
|
break;
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* USB_FIREWIRE_HANDLING */
|
2010-06-05 20:43:30 +00:00
|
|
|
|
|
|
|
#if defined(HAVE_USB_CHARGING_ENABLE) && defined(HAVE_USBSTACK)
|
|
|
|
case USB_CHARGER_UPDATE:
|
|
|
|
usb_charging_maxcurrent_change(usb_charging_maxcurrent());
|
|
|
|
break;
|
|
|
|
#endif
|
2002-07-01 11:02:54 +00:00
|
|
|
}
|
2002-06-29 22:41:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-05 20:43:30 +00:00
|
|
|
#if defined(HAVE_USB_CHARGING_ENABLE) && defined(HAVE_USBSTACK)
|
|
|
|
void usb_charger_update(void)
|
|
|
|
{
|
|
|
|
queue_post(&usb_queue, USB_CHARGER_UPDATE, 0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-01-14 07:01:49 +00:00
|
|
|
#ifdef USB_STATUS_BY_EVENT
|
|
|
|
void usb_status_event(int current_status)
|
|
|
|
{
|
2009-01-22 22:05:04 +00:00
|
|
|
/* Caller isn't expected to filter for changes in status.
|
|
|
|
* current_status:
|
|
|
|
* USB_DETECT_BY_DRV: USB_POWERED, USB_UNPOWERED, USB_INSERTED (driver)
|
|
|
|
* else: USB_INSERTED, USB_EXTRACTED
|
|
|
|
*/
|
2009-01-19 13:41:25 +00:00
|
|
|
if(usb_monitor_enabled)
|
2009-01-14 07:01:49 +00:00
|
|
|
{
|
2009-01-19 13:41:25 +00:00
|
|
|
int oldstatus = disable_irq_save(); /* Dual-use function */
|
|
|
|
|
|
|
|
if(last_usb_status != current_status)
|
|
|
|
{
|
|
|
|
last_usb_status = current_status;
|
|
|
|
queue_post(&usb_queue, current_status, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
restore_irq(oldstatus);
|
2009-01-14 07:01:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_start_monitoring(void)
|
|
|
|
{
|
2009-01-22 22:05:04 +00:00
|
|
|
int oldstatus = disable_irq_save(); /* Sync to event */
|
2009-01-19 13:41:25 +00:00
|
|
|
int status = usb_detect();
|
2009-01-22 22:05:04 +00:00
|
|
|
|
|
|
|
usb_monitor_enabled = true;
|
|
|
|
|
2009-01-19 13:41:25 +00:00
|
|
|
#ifdef USB_DETECT_BY_DRV
|
2009-01-22 22:05:04 +00:00
|
|
|
status = (status == USB_INSERTED) ? USB_POWERED : USB_UNPOWERED;
|
2009-01-19 13:41:25 +00:00
|
|
|
#endif
|
|
|
|
usb_status_event(status);
|
2009-01-22 22:05:04 +00:00
|
|
|
|
|
|
|
#ifdef USB_FIREWIRE_HANDLING
|
|
|
|
if (firewire_detect())
|
|
|
|
usb_firewire_connect_event();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
restore_irq(oldstatus);
|
2009-01-14 07:01:49 +00:00
|
|
|
}
|
2009-01-22 22:05:04 +00:00
|
|
|
|
|
|
|
#ifdef USB_FIREWIRE_HANDLING
|
|
|
|
void usb_firewire_connect_event(void)
|
|
|
|
{
|
|
|
|
queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
|
|
|
|
}
|
|
|
|
#endif /* USB_FIREWIRE_HANDLING */
|
2009-01-14 07:01:49 +00:00
|
|
|
#else /* !USB_STATUS_BY_EVENT */
|
2003-07-03 22:11:14 +00:00
|
|
|
static void usb_tick(void)
|
|
|
|
{
|
2007-09-04 08:03:07 +00:00
|
|
|
int current_status;
|
2003-07-03 22:11:14 +00:00
|
|
|
|
|
|
|
if(usb_monitor_enabled)
|
|
|
|
{
|
2009-01-13 16:27:35 +00:00
|
|
|
#ifdef USB_FIREWIRE_HANDLING
|
2008-02-27 19:08:30 +00:00
|
|
|
int current_firewire_status = firewire_detect();
|
|
|
|
if(current_firewire_status != last_firewire_status)
|
|
|
|
{
|
|
|
|
last_firewire_status = current_firewire_status;
|
|
|
|
firewire_countdown = NUM_POLL_READINGS;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Count down until it gets negative */
|
|
|
|
if(firewire_countdown >= 0)
|
|
|
|
firewire_countdown--;
|
|
|
|
|
|
|
|
/* Report to the thread if we have had 3 identical status
|
|
|
|
readings in a row */
|
|
|
|
if(firewire_countdown == 0)
|
|
|
|
{
|
|
|
|
queue_post(&usb_queue, USB_REQUEST_REBOOT, 0);
|
|
|
|
}
|
|
|
|
}
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* USB_FIREWIRE_HANDLING */
|
2008-02-27 19:08:30 +00:00
|
|
|
|
2003-07-03 22:11:14 +00:00
|
|
|
current_status = usb_detect();
|
2009-04-18 21:32:41 +00:00
|
|
|
|
2002-07-01 11:02:54 +00:00
|
|
|
/* Only report when the status has changed */
|
|
|
|
if(current_status != last_usb_status)
|
|
|
|
{
|
|
|
|
last_usb_status = current_status;
|
2002-07-01 19:32:54 +00:00
|
|
|
countdown = NUM_POLL_READINGS;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Count down until it gets negative */
|
|
|
|
if(countdown >= 0)
|
|
|
|
countdown--;
|
|
|
|
|
|
|
|
/* Report to the thread if we have had 3 identical status
|
|
|
|
readings in a row */
|
|
|
|
if(countdown == 0)
|
|
|
|
{
|
2007-09-04 08:03:07 +00:00
|
|
|
queue_post(&usb_queue, current_status, 0);
|
2002-07-01 19:32:54 +00:00
|
|
|
}
|
2002-07-01 11:02:54 +00:00
|
|
|
}
|
2002-06-29 22:41:39 +00:00
|
|
|
}
|
2008-10-31 21:25:04 +00:00
|
|
|
#if (CONFIG_STORAGE & STORAGE_MMC)
|
2004-10-10 19:51:11 +00:00
|
|
|
if(usb_mmc_countdown > 0)
|
|
|
|
{
|
|
|
|
usb_mmc_countdown--;
|
|
|
|
if (usb_mmc_countdown == 0)
|
2006-12-19 16:50:07 +00:00
|
|
|
queue_post(&usb_queue, USB_REENABLE, 0);
|
2004-10-10 19:51:11 +00:00
|
|
|
}
|
|
|
|
#endif
|
2002-06-29 22:41:39 +00:00
|
|
|
}
|
2009-01-14 07:01:49 +00:00
|
|
|
|
|
|
|
void usb_start_monitoring(void)
|
|
|
|
{
|
|
|
|
usb_monitor_enabled = true;
|
|
|
|
}
|
|
|
|
#endif /* USB_STATUS_BY_EVENT */
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* USB_FULL_INIT */
|
2002-06-29 22:41:39 +00:00
|
|
|
|
2005-01-30 15:16:58 +00:00
|
|
|
void usb_acknowledge(long id)
|
2002-06-29 22:41:39 +00:00
|
|
|
{
|
2006-12-19 16:50:07 +00:00
|
|
|
queue_post(&usb_queue, id, 0);
|
2002-06-29 22:41:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void usb_init(void)
|
|
|
|
{
|
2009-01-14 07:01:49 +00:00
|
|
|
/* We assume that the USB cable is extracted */
|
2002-07-01 11:02:54 +00:00
|
|
|
usb_state = USB_EXTRACTED;
|
2009-01-22 22:05:04 +00:00
|
|
|
#ifdef USB_DETECT_BY_DRV
|
|
|
|
last_usb_status = USB_UNPOWERED;
|
|
|
|
#else
|
2009-01-14 07:01:49 +00:00
|
|
|
last_usb_status = USB_EXTRACTED;
|
2009-01-22 22:05:04 +00:00
|
|
|
#endif
|
2009-01-14 07:01:49 +00:00
|
|
|
usb_monitor_enabled = false;
|
|
|
|
|
2008-03-02 00:53:24 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
2008-11-01 16:14:28 +00:00
|
|
|
exclusive_storage_access = false;
|
2008-03-02 00:53:24 +00:00
|
|
|
#endif
|
2002-07-03 14:16:20 +00:00
|
|
|
|
2009-01-13 16:27:35 +00:00
|
|
|
#ifdef USB_FIREWIRE_HANDLING
|
2008-02-27 19:08:30 +00:00
|
|
|
firewire_countdown = -1;
|
|
|
|
last_firewire_status = false;
|
|
|
|
#endif
|
|
|
|
|
2006-10-05 10:58:51 +00:00
|
|
|
usb_init_device();
|
2008-04-18 16:42:50 +00:00
|
|
|
#ifdef USB_FULL_INIT
|
2002-06-30 13:13:13 +00:00
|
|
|
usb_enable(false);
|
|
|
|
|
2006-09-16 16:18:11 +00:00
|
|
|
queue_init(&usb_queue, true);
|
2009-04-18 21:32:41 +00:00
|
|
|
|
2008-02-27 19:08:30 +00:00
|
|
|
usb_thread_entry = create_thread(usb_thread, usb_stack,
|
|
|
|
sizeof(usb_stack), 0, usb_thread_name
|
|
|
|
IF_PRIO(, PRIORITY_SYSTEM) IF_COP(, CPU));
|
2002-06-29 22:41:39 +00:00
|
|
|
|
2009-01-14 07:01:49 +00:00
|
|
|
#ifndef USB_STATUS_BY_EVENT
|
|
|
|
countdown = -1;
|
2002-06-30 13:13:13 +00:00
|
|
|
tick_add_task(usb_tick);
|
2009-01-14 07:01:49 +00:00
|
|
|
#endif
|
2009-01-13 16:27:35 +00:00
|
|
|
#endif /* USB_FULL_INIT */
|
2002-06-30 13:13:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void usb_wait_for_disconnect(struct event_queue *q)
|
|
|
|
{
|
2008-12-03 21:15:44 +00:00
|
|
|
#ifdef USB_FULL_INIT
|
2007-10-16 01:25:17 +00:00
|
|
|
struct queue_event ev;
|
2002-06-30 13:13:13 +00:00
|
|
|
|
|
|
|
/* Don't return until we get SYS_USB_DISCONNECTED */
|
|
|
|
while(1)
|
|
|
|
{
|
2002-07-01 11:02:54 +00:00
|
|
|
queue_wait(q, &ev);
|
|
|
|
if(ev.id == SYS_USB_DISCONNECTED)
|
|
|
|
{
|
|
|
|
usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
|
|
|
|
return;
|
|
|
|
}
|
2002-06-30 13:13:13 +00:00
|
|
|
}
|
2008-12-03 21:15:44 +00:00
|
|
|
#else
|
|
|
|
(void)q;
|
|
|
|
#endif /* USB_FULL_INIT */
|
2002-06-30 13:13:13 +00:00
|
|
|
}
|
|
|
|
|
2002-10-11 08:56:23 +00:00
|
|
|
int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks)
|
|
|
|
{
|
2008-12-03 21:15:44 +00:00
|
|
|
#ifdef USB_FULL_INIT
|
2007-10-16 01:25:17 +00:00
|
|
|
struct queue_event ev;
|
2002-10-11 08:56:23 +00:00
|
|
|
|
|
|
|
/* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
|
|
|
|
while(1)
|
|
|
|
{
|
|
|
|
queue_wait_w_tmo(q, &ev, ticks);
|
|
|
|
switch(ev.id)
|
|
|
|
{
|
|
|
|
case SYS_USB_DISCONNECTED:
|
|
|
|
usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
|
|
|
|
return 0;
|
|
|
|
case SYS_TIMEOUT:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2008-12-03 21:15:44 +00:00
|
|
|
#else
|
|
|
|
(void)q; (void)ticks;
|
|
|
|
return 0;
|
|
|
|
#endif /* USB_FULL_INIT */
|
2002-10-11 08:56:23 +00:00
|
|
|
}
|
|
|
|
|
2008-05-10 18:00:11 +00:00
|
|
|
#ifdef USB_DRIVER_CLOSE
|
|
|
|
void usb_close(void)
|
2008-04-18 16:42:50 +00:00
|
|
|
{
|
2008-12-10 09:11:43 +00:00
|
|
|
unsigned int thread = usb_thread_entry;
|
2008-12-10 08:57:10 +00:00
|
|
|
usb_thread_entry = 0;
|
2008-05-10 18:00:11 +00:00
|
|
|
|
2008-12-10 08:57:10 +00:00
|
|
|
if (thread == 0)
|
2008-05-10 18:00:11 +00:00
|
|
|
return;
|
|
|
|
|
2009-01-14 07:01:49 +00:00
|
|
|
#ifndef USB_STATUS_BY_EVENT
|
2008-04-18 16:42:50 +00:00
|
|
|
tick_remove_task(usb_tick);
|
2009-01-14 07:01:49 +00:00
|
|
|
#endif
|
2008-04-18 16:42:50 +00:00
|
|
|
usb_monitor_enabled = false;
|
2008-05-10 18:00:11 +00:00
|
|
|
|
|
|
|
queue_post(&usb_queue, USB_QUIT, 0);
|
|
|
|
thread_wait(thread);
|
2008-04-18 16:42:50 +00:00
|
|
|
}
|
2008-05-10 18:00:11 +00:00
|
|
|
#endif /* USB_DRIVER_CLOSE */
|
2008-04-18 16:42:50 +00:00
|
|
|
|
2002-09-25 19:25:10 +00:00
|
|
|
bool usb_inserted(void)
|
|
|
|
{
|
2006-02-19 12:27:21 +00:00
|
|
|
#ifdef HAVE_USB_POWER
|
2006-02-19 11:37:30 +00:00
|
|
|
return usb_state == USB_INSERTED || usb_state == USB_POWERED;
|
2006-02-19 12:27:21 +00:00
|
|
|
#else
|
|
|
|
return usb_state == USB_INSERTED;
|
|
|
|
#endif
|
2002-09-25 19:25:10 +00:00
|
|
|
}
|
|
|
|
|
2008-03-02 00:15:02 +00:00
|
|
|
#ifdef HAVE_USBSTACK
|
2009-01-13 16:27:35 +00:00
|
|
|
bool usb_exclusive_storage(void)
|
2008-03-02 00:15:02 +00:00
|
|
|
{
|
2008-11-01 16:14:28 +00:00
|
|
|
return exclusive_storage_access;
|
2008-03-02 00:15:02 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-02-28 15:16:54 +00:00
|
|
|
int usb_release_exclusive_storage(void)
|
|
|
|
{
|
|
|
|
int num_acks_to_expect;
|
|
|
|
#ifdef HAVE_USBSTACK
|
|
|
|
exclusive_storage_access = false;
|
|
|
|
#endif /* HAVE_USBSTACK */
|
|
|
|
/* Tell all threads that we are back in business */
|
|
|
|
num_acks_to_expect =
|
|
|
|
queue_broadcast(SYS_USB_DISCONNECTED, 0) - 1;
|
|
|
|
DEBUGF("USB extracted. Waiting for ack from %d threads...\n",
|
|
|
|
num_acks_to_expect);
|
|
|
|
return num_acks_to_expect;
|
|
|
|
}
|
|
|
|
|
2005-06-23 02:18:29 +00:00
|
|
|
#ifdef HAVE_USB_POWER
|
|
|
|
bool usb_powered(void)
|
|
|
|
{
|
|
|
|
return usb_state == USB_POWERED;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-10-23 13:29:19 +00:00
|
|
|
#ifdef USB_ENABLE_HID
|
|
|
|
void usb_set_hid(bool enable)
|
|
|
|
{
|
|
|
|
usb_hid = enable;
|
|
|
|
usb_core_enable_driver(USB_DRIVER_HID, usb_hid);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-06-29 22:41:39 +00:00
|
|
|
#else
|
|
|
|
|
2003-12-12 13:30:15 +00:00
|
|
|
#ifdef USB_NONE
|
|
|
|
bool usb_inserted(void)
|
|
|
|
{
|
2003-12-15 11:44:06 +00:00
|
|
|
return false;
|
2003-12-12 13:30:15 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-06-29 22:41:39 +00:00
|
|
|
/* Dummy simulator functions */
|
2005-01-30 15:16:58 +00:00
|
|
|
void usb_acknowledge(long id)
|
2002-06-29 22:41:39 +00:00
|
|
|
{
|
|
|
|
id = id;
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_init(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2002-06-30 13:13:13 +00:00
|
|
|
void usb_start_monitoring(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-09-04 08:03:07 +00:00
|
|
|
int usb_detect(void)
|
2003-07-20 00:08:09 +00:00
|
|
|
{
|
2007-09-04 08:03:07 +00:00
|
|
|
return USB_EXTRACTED;
|
2003-07-20 00:08:09 +00:00
|
|
|
}
|
|
|
|
|
2006-02-24 20:54:09 +00:00
|
|
|
void usb_wait_for_disconnect(struct event_queue *q)
|
|
|
|
{
|
2006-02-24 21:09:34 +00:00
|
|
|
(void)q;
|
2006-02-24 20:54:09 +00:00
|
|
|
}
|
|
|
|
|
2003-12-12 13:30:15 +00:00
|
|
|
#endif /* USB_NONE or SIMULATOR */
|