1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Linus Nielsen Feltzing
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
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.
22 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
23 * KIND, either express or implied.
25 ****************************************************************************/
37 #include "usb-target.h"
46 #include "screendump.h"
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)
57 #ifdef HAVE_LCD_BITMAP
58 bool do_screendump_instead_of_usb
= false;
61 #if !defined(SIMULATOR) && !defined(USB_NONE)
65 #if (CONFIG_STORAGE & STORAGE_MMC) && defined(USB_FULL_INIT)
66 static int usb_mmc_countdown
= 0;
69 /* FIXME: The extra 0x800 is consumed by fat_mount() when the fsinfo
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)
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
;
84 static bool exclusive_storage_access
;
87 #ifdef USB_FIREWIRE_HANDLING
88 static int firewire_countdown
;
89 static bool last_firewire_status
;
94 #if defined(USB_FIREWIRE_HANDLING) \
95 || (defined(HAVE_USBSTACK) && !defined(USE_ROCKBOX_USB))
96 static void try_reboot(void)
98 #ifdef HAVE_DISK_STORAGE
99 storage_sleepnow(); /* Immediately spindown the disk. */
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 */
111 system_reboot(); /* Reboot */
113 #endif /* USB_FIRWIRE_HANDLING || (HAVE_USBSTACK && !USE_ROCKBOX_USB) */
116 /* inline since branch is chosen at compile time */
117 static inline void usb_slave_mode(bool on
)
119 #ifdef USE_ROCKBOX_USB
125 #ifdef HAVE_PRIORITY_SCHEDULING
126 thread_set_priority(THREAD_ID_CURRENT
, PRIORITY_REALTIME
);
130 else /* usb_state == USB_INSERTED (only!) */
132 #ifndef USB_DETECT_BY_DRV
135 #ifdef HAVE_PRIORITY_SCHEDULING
136 thread_set_priority(THREAD_ID_CURRENT
, PRIORITY_SYSTEM
);
138 /* Entered exclusive mode */
139 rc
= disk_mount_all();
140 if (rc
<= 0) /* no partition */
141 panicf("mount: %d",rc
);
145 #else /* !USB_ROCKBOX_USB */
148 /* until we have native mass-storage mode, we want to reboot on
152 #endif /* USE_ROCKBOX_USB */
155 void usb_signal_transfer_completion(
156 struct usb_transfer_completion_event_data
* event_data
)
158 queue_post(&usb_queue
, USB_TRANSFER_COMPLETION
, (intptr_t)event_data
);
160 #else /* !HAVE_USBSTACK */
161 /* inline since branch is chosen at compile time */
162 static inline void usb_slave_mode(bool on
)
168 DEBUGF("Entering USB slave mode\n");
169 storage_soft_reset();
171 storage_enable(false);
177 DEBUGF("Leaving USB slave mode\n");
179 cpu_idle_mode(false);
181 /* Let the ISDx00 settle */
188 panicf("storage: %d",rc
);
190 rc
= disk_mount_all();
191 if (rc
<= 0) /* no partition */
192 panicf("mount: %d",rc
);
195 #endif /* HAVE_USBSTACK */
197 #ifdef HAVE_USB_POWER
198 static inline bool usb_power_button(void)
200 #if defined(IRIVER_H10) || defined (IRIVER_H10_5GB)
201 return (button_status() & ~USBPOWER_BTN_IGNORE
) != USBPOWER_BUTTON
;
203 return (button_status() & ~USBPOWER_BTN_IGNORE
) == USBPOWER_BUTTON
;
207 #ifdef USB_FIREWIRE_HANDLING
208 static inline bool usb_reboot_button(void)
210 return (button_status() & ~USBPOWER_BTN_IGNORE
) != USBPOWER_BUTTON
;
213 #endif /* HAVE_USB_POWER */
215 static void usb_thread(void)
217 int num_acks_to_expect
= 0;
218 struct queue_event ev
;
222 queue_wait(&usb_queue
, &ev
);
225 #ifdef USB_DRIVER_CLOSE
230 case USB_TRANSFER_COMPLETION
:
231 usb_core_handle_transfer_completion(
232 (struct usb_transfer_completion_event_data
*)ev
.data
);
235 #ifdef USB_DETECT_BY_DRV
236 /* In this case, these events the handle cable insertion USB
237 * driver determines INSERTED/EXTRACTED state. */
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
;
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
252 queue_post(&usb_queue
, USB_EXTRACTED
, 0);
254 #endif /* USB_DETECT_BY_DRV */
256 #ifdef HAVE_LCD_BITMAP
257 if(do_screendump_instead_of_usb
)
259 usb_state
= USB_SCREENDUMP
;
261 #ifdef HAVE_REMOTE_LCD
262 remote_screen_dump();
267 #ifdef HAVE_USB_POWER
268 if(usb_power_button())
270 /* Only charging is desired */
271 usb_state
= USB_POWERED
;
274 usb_core_enable_driver(USB_DRIVER_MASS_STORAGE
, false);
276 #ifdef USB_CHARGING_ONLY
277 usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY
, true);
283 #endif /* HAVE_USB_POWER */
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
289 usb_state
= USB_POWERED
;
292 usb_core_enable_driver(USB_DRIVER_MASS_STORAGE
, true);
294 #ifdef USB_CHARGING_ONLY
295 usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY
, false);
298 /* Check any drivers enabled at this point for exclusive storage
299 * access requirements. */
300 exclusive_storage_access
= usb_core_any_exclusive_storage();
302 if(!exclusive_storage_access
)
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
);
315 case SYS_USB_CONNECTED_ACK
:
316 if(num_acks_to_expect
> 0 && --num_acks_to_expect
== 0)
318 DEBUGF("All threads have acknowledged the connect.\n");
319 usb_slave_mode(true);
320 usb_state
= USB_INSERTED
;
324 DEBUGF("usb: got ack, %d to go...\n",
330 #ifdef HAVE_LCD_BITMAP
331 if(usb_state
== USB_SCREENDUMP
)
333 usb_state
= USB_EXTRACTED
;
334 break; /* Connected for screendump only */
337 #ifndef HAVE_USBSTACK /* Stack must undo this if POWERED state was transitional */
338 #ifdef HAVE_USB_POWER
339 if(usb_state
== USB_POWERED
)
341 usb_state
= USB_EXTRACTED
;
345 #endif /* HAVE_USBSTACK */
346 if(usb_state
== USB_INSERTED
)
348 /* Only disable the USB mode if we really have enabled it
349 some threads might not have acknowledged the
351 usb_slave_mode(false);
354 usb_state
= USB_EXTRACTED
;
356 if(!exclusive_storage_access
)
358 #ifndef USB_DETECT_BY_DRV /* Disabled handling USB_UNPOWERED */
364 exclusive_storage_access
= false;
365 #endif /* HAVE_USBSTACK */
367 /* Tell all threads that we are back in business */
369 queue_broadcast(SYS_USB_DISCONNECTED
, 0) - 1;
370 DEBUGF("USB extracted. Waiting for ack from %d threads...\n",
374 case SYS_USB_DISCONNECTED_ACK
:
375 if(num_acks_to_expect
> 0 && --num_acks_to_expect
== 0)
377 DEBUGF("All threads have acknowledged. "
378 "We're in business.\n");
382 DEBUGF("usb: got ack, %d to go...\n",
388 case SYS_HOTSWAP_INSERTED
:
389 case SYS_HOTSWAP_EXTRACTED
:
391 usb_core_hotswap_event(1,ev
.id
== SYS_HOTSWAP_INSERTED
);
392 #else /* !HAVE_USBSTACK */
393 if(usb_state
== USB_INSERTED
)
396 #if (CONFIG_STORAGE & STORAGE_MMC)
397 usb_mmc_countdown
= HZ
/2; /* re-enable after 0.5 sec */
398 #endif /* STORAGE_MMC */
400 #endif /* HAVE_USBSTACK */
403 #if (CONFIG_STORAGE & STORAGE_MMC)
405 if(usb_state
== USB_INSERTED
)
406 usb_enable(true); /* reenable only if still inserted */
408 #endif /* STORAGE_MMC */
409 #endif /* HAVE_HOTSWAP */
411 #ifdef USB_FIREWIRE_HANDLING
412 case USB_REQUEST_REBOOT
:
413 #ifdef HAVE_USB_POWER
414 if (usb_reboot_button())
418 #endif /* USB_FIREWIRE_HANDLING */
423 #ifdef USB_STATUS_BY_EVENT
424 void usb_status_event(int current_status
)
426 /* Caller isn't expected to filter for changes in status.
428 * USB_DETECT_BY_DRV: USB_POWERED, USB_UNPOWERED, USB_INSERTED (driver)
429 * else: USB_INSERTED, USB_EXTRACTED
431 if(usb_monitor_enabled
)
433 int oldstatus
= disable_irq_save(); /* Dual-use function */
435 if(last_usb_status
!= current_status
)
437 last_usb_status
= current_status
;
438 queue_post(&usb_queue
, current_status
, 0);
441 restore_irq(oldstatus
);
445 void usb_start_monitoring(void)
447 int oldstatus
= disable_irq_save(); /* Sync to event */
448 int status
= usb_detect();
450 usb_monitor_enabled
= true;
452 #ifdef USB_DETECT_BY_DRV
453 status
= (status
== USB_INSERTED
) ? USB_POWERED
: USB_UNPOWERED
;
455 usb_status_event(status
);
457 #ifdef USB_FIREWIRE_HANDLING
458 if (firewire_detect())
459 usb_firewire_connect_event();
462 restore_irq(oldstatus
);
465 #ifdef USB_FIREWIRE_HANDLING
466 void usb_firewire_connect_event(void)
468 queue_post(&usb_queue
, USB_REQUEST_REBOOT
, 0);
470 #endif /* USB_FIREWIRE_HANDLING */
471 #else /* !USB_STATUS_BY_EVENT */
472 static void usb_tick(void)
476 if(usb_monitor_enabled
)
478 #ifdef USB_FIREWIRE_HANDLING
479 int current_firewire_status
= firewire_detect();
480 if(current_firewire_status
!= last_firewire_status
)
482 last_firewire_status
= current_firewire_status
;
483 firewire_countdown
= NUM_POLL_READINGS
;
487 /* Count down until it gets negative */
488 if(firewire_countdown
>= 0)
489 firewire_countdown
--;
491 /* Report to the thread if we have had 3 identical status
493 if(firewire_countdown
== 0)
495 queue_post(&usb_queue
, USB_REQUEST_REBOOT
, 0);
498 #endif /* USB_FIREWIRE_HANDLING */
500 current_status
= usb_detect();
502 /* Only report when the status has changed */
503 if(current_status
!= last_usb_status
)
505 last_usb_status
= current_status
;
506 countdown
= NUM_POLL_READINGS
;
510 /* Count down until it gets negative */
514 /* Report to the thread if we have had 3 identical status
518 queue_post(&usb_queue
, current_status
, 0);
522 #if (CONFIG_STORAGE & STORAGE_MMC)
523 if(usb_mmc_countdown
> 0)
526 if (usb_mmc_countdown
== 0)
527 queue_post(&usb_queue
, USB_REENABLE
, 0);
532 void usb_start_monitoring(void)
534 usb_monitor_enabled
= true;
536 #endif /* USB_STATUS_BY_EVENT */
537 #endif /* USB_FULL_INIT */
539 void usb_acknowledge(long id
)
541 queue_post(&usb_queue
, id
, 0);
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
;
551 last_usb_status
= USB_EXTRACTED
;
553 usb_monitor_enabled
= false;
556 exclusive_storage_access
= false;
559 #ifdef USB_FIREWIRE_HANDLING
560 firewire_countdown
= -1;
561 last_firewire_status
= false;
568 queue_init(&usb_queue
, true);
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
));
574 #ifndef USB_STATUS_BY_EVENT
576 tick_add_task(usb_tick
);
578 #endif /* USB_FULL_INIT */
581 void usb_wait_for_disconnect(struct event_queue
*q
)
584 struct queue_event ev
;
586 /* Don't return until we get SYS_USB_DISCONNECTED */
590 if(ev
.id
== SYS_USB_DISCONNECTED
)
592 usb_acknowledge(SYS_USB_DISCONNECTED_ACK
);
598 #endif /* USB_FULL_INIT */
601 int usb_wait_for_disconnect_w_tmo(struct event_queue
*q
, int ticks
)
604 struct queue_event ev
;
606 /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
609 queue_wait_w_tmo(q
, &ev
, ticks
);
612 case SYS_USB_DISCONNECTED
:
613 usb_acknowledge(SYS_USB_DISCONNECTED_ACK
);
620 (void)q
; (void)ticks
;
622 #endif /* USB_FULL_INIT */
625 #ifdef USB_DRIVER_CLOSE
628 unsigned int thread
= usb_thread_entry
;
629 usb_thread_entry
= 0;
634 #ifndef USB_STATUS_BY_EVENT
635 tick_remove_task(usb_tick
);
637 usb_monitor_enabled
= false;
639 queue_post(&usb_queue
, USB_QUIT
, 0);
642 #endif /* USB_DRIVER_CLOSE */
644 bool usb_inserted(void)
646 #ifdef HAVE_USB_POWER
647 return usb_state
== USB_INSERTED
|| usb_state
== USB_POWERED
;
649 return usb_state
== USB_INSERTED
;
654 bool usb_exclusive_storage(void)
656 return exclusive_storage_access
;
660 #ifdef HAVE_USB_POWER
661 bool usb_powered(void)
663 return usb_state
== USB_POWERED
;
670 bool usb_inserted(void)
676 /* Dummy simulator functions */
677 void usb_acknowledge(long id
)
686 void usb_start_monitoring(void)
692 return USB_EXTRACTED
;
695 void usb_wait_for_disconnect(struct event_queue
*q
)
700 #endif /* USB_NONE or SIMULATOR */