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 ****************************************************************************/
41 #include "usb-target.h"
47 /* Conditions under which we want the entire driver */
48 #if !defined(BOOTLOADER) || (CONFIG_CPU == SH7034) || \
49 (defined(TOSHIBA_GIGABEAT_S) && defined(USE_ROCKBOX_USB) && defined(USB_STORAGE)) || \
50 (defined(HAVE_USBSTACK) && (defined(CREATIVE_ZVx) || \
51 defined(CPU_TCC77X) || defined(CPU_TCC780X))) || \
52 (CONFIG_USBOTG == USBOTG_JZ4740)
56 #ifdef HAVE_LCD_BITMAP
57 bool do_screendump_instead_of_usb
= false;
58 #if defined(USB_FULL_INIT) && defined(BOOTLOADER)
59 static void screen_dump(void) {}
61 void screen_dump(void); /* Nasty again. Defined in apps/ too */
65 #if !defined(SIMULATOR) && !defined(USB_NONE)
67 #define NUM_POLL_READINGS (HZ/5)
72 #if (CONFIG_STORAGE & STORAGE_MMC) && defined(USB_FULL_INIT)
73 static int usb_mmc_countdown
= 0;
76 /* FIXME: The extra 0x800 is consumed by fat_mount() when the fsinfo
79 static long usb_stack
[(DEFAULT_STACK_SIZE
+ 0x800)/sizeof(long)];
80 static const char usb_thread_name
[] = "usb";
81 static unsigned int usb_thread_entry
= 0;
83 static struct event_queue usb_queue
;
84 static int last_usb_status
;
85 static bool usb_monitor_enabled
;
87 static bool exclusive_storage_access
;
91 #if defined(IPOD_COLOR) || defined(IPOD_4G) \
92 || defined(IPOD_MINI) || defined(IPOD_MINI2G)
93 static int firewire_countdown
;
94 static bool last_firewire_status
;
99 static void usb_slave_mode(bool on
)
105 DEBUGF("Entering USB slave mode\n");
106 storage_soft_reset();
108 storage_enable(false);
113 DEBUGF("Leaving USB slave mode\n");
115 /* Let the ISDx00 settle */
122 panicf("storage: %d",rc
);
124 rc
= disk_mount_all();
125 if (rc
<= 0) /* no partition */
126 panicf("mount: %d",rc
);
131 static void try_reboot(void)
133 #ifdef HAVE_DISK_STORAGE
134 storage_sleepnow(); /* Immediately spindown the disk. */
138 #ifdef IPOD_ARCH /* The following code is based on ipodlinux */
139 #if CONFIG_CPU == PP5020
140 memcpy((void *)0x40017f00, "diskmode\0\0hotstuff\0\0\1", 21);
141 #elif CONFIG_CPU == PP5022
142 memcpy((void *)0x4001ff00, "diskmode\0\0hotstuff\0\0\1", 21);
143 #endif /* CONFIG_CPU */
144 #endif /* IPOD_ARCH */
146 system_reboot(); /* Reboot */
149 static void usb_thread(void)
151 int num_acks_to_expect
= -1;
152 bool waiting_for_ack
;
153 struct queue_event ev
;
155 waiting_for_ack
= false;
159 queue_wait(&usb_queue
, &ev
);
162 #ifdef USB_DRIVER_CLOSE
167 case USB_TRANSFER_COMPLETION
:
168 usb_core_handle_transfer_completion((struct usb_transfer_completion_event_data
*)ev
.data
);
171 #ifdef HAVE_USB_POWER
173 usb_state
= USB_POWERED
;
177 #ifdef HAVE_LCD_BITMAP
178 if(do_screendump_instead_of_usb
)
184 #ifdef HAVE_USB_POWER
185 #if defined(IRIVER_H10) || defined (IRIVER_H10_5GB)
186 if((button_status() & ~USBPOWER_BTN_IGNORE
) != USBPOWER_BUTTON
)
188 if((button_status() & ~USBPOWER_BTN_IGNORE
) == USBPOWER_BUTTON
)
191 usb_state
= USB_POWERED
;
193 usb_core_enable_driver(USB_DRIVER_MASS_STORAGE
,false);
194 usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY
,true);
202 /* Set the state to USB_POWERED for now. if a real
203 connection is detected it will switch to USB_INSERTED */
204 usb_state
= USB_POWERED
;
205 usb_core_enable_driver(USB_DRIVER_MASS_STORAGE
,true);
206 usb_core_enable_driver(USB_DRIVER_CHARGING_ONLY
,false);
209 /* Tell all threads that they have to back off the ATA.
210 We subtract one for our own thread. */
212 queue_broadcast(SYS_USB_CONNECTED
, 0) - 1;
213 waiting_for_ack
= true;
214 DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
220 case USB_REQUEST_DISK
:
223 /* Tell all threads that they have to back off the ATA.
224 We subtract one for our own thread. */
226 queue_broadcast(SYS_USB_CONNECTED
, 0) - 1;
227 waiting_for_ack
= true;
228 DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
232 case USB_RELEASE_DISK
:
235 /* Tell all threads that they have to back off the ATA.
236 We subtract one for our own thread. */
238 queue_broadcast(SYS_USB_DISCONNECTED
, 0) - 1;
239 waiting_for_ack
= true;
240 DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
245 case SYS_USB_CONNECTED_ACK
:
248 num_acks_to_expect
--;
249 if(num_acks_to_expect
== 0)
251 DEBUGF("All threads have acknowledged the connect.\n");
253 #ifndef USE_ROCKBOX_USB
254 /* until we have native mass-storage mode, we want to reboot on
257 #endif /* USE_ROCKBOX_USB */
258 #ifdef HAVE_PRIORITY_SCHEDULING
259 thread_set_priority(usb_thread_entry
,PRIORITY_REALTIME
);
261 exclusive_storage_access
= true;
264 usb_slave_mode(true);
267 usb_state
= USB_INSERTED
;
268 waiting_for_ack
= false;
272 DEBUGF("usb: got ack, %d to go...\n",
281 #ifdef HAVE_PRIORITY_SCHEDULING
282 thread_set_priority(usb_thread_entry
,PRIORITY_SYSTEM
);
285 #ifdef HAVE_LCD_BITMAP
286 if(do_screendump_instead_of_usb
)
289 #ifdef HAVE_USB_POWER
290 if(usb_state
== USB_POWERED
)
292 usb_state
= USB_EXTRACTED
;
296 #ifndef HAVE_USBSTACK
297 if(usb_state
== USB_INSERTED
)
299 /* Only disable the USB mode if we really have enabled it
300 some threads might not have acknowledged the
302 usb_slave_mode(false);
303 cpu_idle_mode(false);
307 usb_state
= USB_EXTRACTED
;
309 if(exclusive_storage_access
)
311 int rc
= disk_mount_all();
312 if (rc
<= 0) /* no partition */
313 panicf("mount: %d",rc
);
314 exclusive_storage_access
= false;
316 /* Tell all threads that we are back in business */
318 queue_broadcast(SYS_USB_DISCONNECTED
, 0) - 1;
319 waiting_for_ack
= true;
320 DEBUGF("USB extracted. Waiting for ack from %d threads...\n",
327 case SYS_USB_DISCONNECTED_ACK
:
330 num_acks_to_expect
--;
331 if(num_acks_to_expect
== 0)
333 DEBUGF("All threads have acknowledged. "
334 "We're in business.\n");
335 waiting_for_ack
= false;
339 DEBUGF("usb: got ack, %d to go...\n",
346 case SYS_HOTSWAP_INSERTED
:
347 case SYS_HOTSWAP_EXTRACTED
:
349 usb_core_hotswap_event(1,ev
.id
== SYS_HOTSWAP_INSERTED
);
351 if(usb_state
== USB_INSERTED
)
354 #if (CONFIG_STORAGE & STORAGE_MMC)
355 usb_mmc_countdown
= HZ
/2; /* re-enable after 0.5 sec */
362 if(usb_state
== USB_INSERTED
)
363 usb_enable(true); /* reenable only if still inserted */
365 #endif /* HAVE_HOTSWAP */
366 case USB_REQUEST_REBOOT
:
367 #ifdef HAVE_USB_POWER
368 if((button_status() & ~USBPOWER_BTN_IGNORE
) != USBPOWER_BUTTON
)
378 void usb_signal_transfer_completion(struct usb_transfer_completion_event_data
* event_data
)
380 queue_post(&usb_queue
, USB_TRANSFER_COMPLETION
, (intptr_t)event_data
);
385 static void usb_tick(void)
389 if(usb_monitor_enabled
)
391 #if defined(IPOD_COLOR) || defined(IPOD_4G) \
392 || defined(IPOD_MINI) || defined(IPOD_MINI2G)
393 int current_firewire_status
= firewire_detect();
394 if(current_firewire_status
!= last_firewire_status
)
396 last_firewire_status
= current_firewire_status
;
397 firewire_countdown
= NUM_POLL_READINGS
;
401 /* Count down until it gets negative */
402 if(firewire_countdown
>= 0)
403 firewire_countdown
--;
405 /* Report to the thread if we have had 3 identical status
407 if(firewire_countdown
== 0)
409 queue_post(&usb_queue
, USB_REQUEST_REBOOT
, 0);
414 current_status
= usb_detect();
416 /* Only report when the status has changed */
417 if(current_status
!= last_usb_status
)
419 last_usb_status
= current_status
;
420 countdown
= NUM_POLL_READINGS
;
424 /* Count down until it gets negative */
428 /* Report to the thread if we have had 3 identical status
432 queue_post(&usb_queue
, current_status
, 0);
436 #if (CONFIG_STORAGE & STORAGE_MMC)
437 if(usb_mmc_countdown
> 0)
440 if (usb_mmc_countdown
== 0)
441 queue_post(&usb_queue
, USB_REENABLE
, 0);
447 void usb_acknowledge(long id
)
449 queue_post(&usb_queue
, id
, 0);
454 usb_state
= USB_EXTRACTED
;
456 exclusive_storage_access
= false;
458 usb_monitor_enabled
= false;
461 #if defined(IPOD_COLOR) || defined(IPOD_4G) \
462 || defined(IPOD_MINI) || defined(IPOD_MINI2G)
463 firewire_countdown
= -1;
464 last_firewire_status
= false;
472 /* We assume that the USB cable is extracted */
473 last_usb_status
= USB_EXTRACTED
;
476 queue_init(&usb_queue
, true);
478 usb_thread_entry
= create_thread(usb_thread
, usb_stack
,
479 sizeof(usb_stack
), 0, usb_thread_name
480 IF_PRIO(, PRIORITY_SYSTEM
) IF_COP(, CPU
));
482 tick_add_task(usb_tick
);
487 void usb_wait_for_disconnect(struct event_queue
*q
)
490 struct queue_event ev
;
492 /* Don't return until we get SYS_USB_DISCONNECTED */
496 if(ev
.id
== SYS_USB_DISCONNECTED
)
498 usb_acknowledge(SYS_USB_DISCONNECTED_ACK
);
504 #endif /* USB_FULL_INIT */
507 int usb_wait_for_disconnect_w_tmo(struct event_queue
*q
, int ticks
)
510 struct queue_event ev
;
512 /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
515 queue_wait_w_tmo(q
, &ev
, ticks
);
518 case SYS_USB_DISCONNECTED
:
519 usb_acknowledge(SYS_USB_DISCONNECTED_ACK
);
528 (void)q
; (void)ticks
;
530 #endif /* USB_FULL_INIT */
533 void usb_start_monitoring(void)
535 usb_monitor_enabled
= true;
538 #ifdef USB_DRIVER_CLOSE
541 unsigned int thread
= usb_thread_entry
;
542 usb_thread_entry
= 0;
547 tick_remove_task(usb_tick
);
548 usb_monitor_enabled
= false;
550 queue_post(&usb_queue
, USB_QUIT
, 0);
553 #endif /* USB_DRIVER_CLOSE */
555 bool usb_inserted(void)
557 #ifdef HAVE_USB_POWER
558 return usb_state
== USB_INSERTED
|| usb_state
== USB_POWERED
;
560 return usb_state
== USB_INSERTED
;
565 void usb_request_exclusive_ata(void)
567 /* This is not really a clean place to start boosting the cpu. but it's
568 * currently the best one. We want to get rid of having to boost the cpu
571 if(!exclusive_storage_access
) {
572 queue_post(&usb_queue
, USB_REQUEST_DISK
, 0);
576 void usb_release_exclusive_ata(void)
579 if(exclusive_storage_access
) {
580 queue_post(&usb_queue
, USB_RELEASE_DISK
, 0);
581 exclusive_storage_access
= false;
585 bool usb_exclusive_ata(void)
587 return exclusive_storage_access
;
591 #ifdef HAVE_USB_POWER
592 bool usb_powered(void)
594 return usb_state
== USB_POWERED
;
601 bool usb_inserted(void)
607 /* Dummy simulator functions */
608 void usb_acknowledge(long id
)
617 void usb_start_monitoring(void)
623 return USB_EXTRACTED
;
626 void usb_wait_for_disconnect(struct event_queue
*q
)
631 #endif /* USB_NONE or SIMULATOR */