devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity

Merge functionality of wakeups and semaphores-- fewer APIs and object types. semaphore_wait takes a timeout now so codecs and plugins have to be made incompatible. Don't make semaphores for targets not using them.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@29492 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Michael Sevakis 2011-03-02 08:49:38 +00:00
parent 05e180a130
commit 12375d1d3a
38 changed files with 294 additions and 311 deletions
Download patch file Download diff file Expand all files Collapse all files

6
apps/codecs.h
View file

@ -75,12 +75,12 @@
#define CODEC_ENC_MAGIC 0x52454E43 /* RENC */ #define CODEC_ENC_MAGIC 0x52454E43 /* RENC */
/* increase this every time the api struct changes */ /* increase this every time the api struct changes */
#define CODEC_API_VERSION 38 #define CODEC_API_VERSION 39
/* update this to latest version if a change to the api struct breaks /* update this to latest version if a change to the api struct breaks
backwards compatibility (and please take the opportunity to sort in any backwards compatibility (and please take the opportunity to sort in any
new function which are "waiting" at the end of the function table) */ new function which are "waiting" at the end of the function table) */
#define CODEC_MIN_API_VERSION 38 #define CODEC_MIN_API_VERSION 39
/* codec return codes */ /* codec return codes */
enum codec_status { enum codec_status {
@ -166,7 +166,7 @@ struct codec_api {
void (*thread_thaw)(unsigned int thread_id); void (*thread_thaw)(unsigned int thread_id);
void (*thread_wait)(unsigned int thread_id); void (*thread_wait)(unsigned int thread_id);
void (*semaphore_init)(struct semaphore *s, int max, int start); void (*semaphore_init)(struct semaphore *s, int max, int start);
void (*semaphore_wait)(struct semaphore *s); int (*semaphore_wait)(struct semaphore *s, int timeout);
void (*semaphore_release)(struct semaphore *s); void (*semaphore_release)(struct semaphore *s);
#endif /* NUM_CORES */ #endif /* NUM_CORES */

4
apps/codecs/mpa.c
View file

@ -211,7 +211,7 @@ static void mad_synth_thread(void)
{ {
while(1) { while(1) {
ci->semaphore_release(&synth_done_sem); ci->semaphore_release(&synth_done_sem);
ci->semaphore_wait(&synth_pending_sem); ci->semaphore_wait(&synth_pending_sem, TIMEOUT_BLOCK);
if(die) if(die)
break; break;
@ -224,7 +224,7 @@ static void mad_synth_thread(void)
* synthesized */ * synthesized */
static inline void mad_synth_thread_wait_pcm(void) static inline void mad_synth_thread_wait_pcm(void)
{ {
ci->semaphore_wait(&synth_done_sem); ci->semaphore_wait(&synth_done_sem, TIMEOUT_BLOCK);
} }
/* increment the done semaphore - used after a wait for idle to preserve the /* increment the done semaphore - used after a wait for idle to preserve the

17
apps/codecs/spc.c
View file

@ -244,7 +244,7 @@ static inline void samples_release_wrbuf(void)
static inline struct sample_queue_chunk * samples_get_wrbuf(void) static inline struct sample_queue_chunk * samples_get_wrbuf(void)
{ {
ci->semaphore_wait(&sample_queue.emu_sem_tail); ci->semaphore_wait(&sample_queue.emu_sem_tail, TIMEOUT_BLOCK);
return &sample_queue.wav_chunk[sample_queue.tail & WAV_CHUNK_MASK]; return &sample_queue.wav_chunk[sample_queue.tail & WAV_CHUNK_MASK];
} }
@ -259,7 +259,7 @@ static inline void samples_release_rdbuf(void)
static inline int32_t * samples_get_rdbuf(void) static inline int32_t * samples_get_rdbuf(void)
{ {
ci->semaphore_wait(&sample_queue.emu_sem_head); ci->semaphore_wait(&sample_queue.emu_sem_head, TIMEOUT_BLOCK);
if (ci->stop_codec || ci->new_track) if (ci->stop_codec || ci->new_track)
{ {
@ -275,7 +275,7 @@ static intptr_t emu_thread_send_msg(long id, intptr_t data)
{ {
struct sample_queue_chunk *chunk; struct sample_queue_chunk *chunk;
/* Grab an audio output buffer */ /* Grab an audio output buffer */
ci->semaphore_wait(&sample_queue.emu_sem_head); ci->semaphore_wait(&sample_queue.emu_sem_head, TIMEOUT_BLOCK);
chunk = &sample_queue.wav_chunk[sample_queue.head & WAV_CHUNK_MASK]; chunk = &sample_queue.wav_chunk[sample_queue.head & WAV_CHUNK_MASK];
/* Place a message in it instead of audio */ /* Place a message in it instead of audio */
chunk->id = id; chunk->id = id;
@ -285,7 +285,7 @@ static intptr_t emu_thread_send_msg(long id, intptr_t data)
if (id != SPC_EMU_QUIT) { if (id != SPC_EMU_QUIT) {
/* Wait for a response */ /* Wait for a response */
ci->semaphore_wait(&sample_queue.emu_evt_reply); ci->semaphore_wait(&sample_queue.emu_evt_reply, TIMEOUT_BLOCK);
} }
return sample_queue.retval; return sample_queue.retval;
@ -308,11 +308,10 @@ static bool emu_thread_process_msg(struct sample_queue_chunk *chunk)
sample_queue.retval = SPC_load_spc(&spc_emu, ld->buf, ld->size); sample_queue.retval = SPC_load_spc(&spc_emu, ld->buf, ld->size);
/* Empty the audio queue */ /* Empty the audio queue */
/* This is a dirty hack a timeout based wait would make unnescessary but ci->semaphore_release(&sample_queue.emu_sem_tail);
still safe because the other thread is known to be waiting for a reply ci->semaphore_release(&sample_queue.emu_sem_tail);
and is not using the objects. */ ci->semaphore_wait(&sample_queue.emu_sem_head, TIMEOUT_NOBLOCK);
ci->semaphore_init(&sample_queue.emu_sem_tail, 2, 2); ci->semaphore_wait(&sample_queue.emu_sem_head, TIMEOUT_NOBLOCK);
ci->semaphore_init(&sample_queue.emu_sem_head, 2, 0);
sample_queue.head = sample_queue.tail = 0; sample_queue.head = sample_queue.tail = 0;
} }

6
apps/plugin.h
View file

@ -145,12 +145,12 @@ void* plugin_get_buffer(size_t *buffer_size);
#define PLUGIN_MAGIC 0x526F634B /* RocK */ #define PLUGIN_MAGIC 0x526F634B /* RocK */
/* increase this every time the api struct changes */ /* increase this every time the api struct changes */
#define PLUGIN_API_VERSION 199 #define PLUGIN_API_VERSION 200
/* update this to latest version if a change to the api struct breaks /* update this to latest version if a change to the api struct breaks
backwards compatibility (and please take the opportunity to sort in any backwards compatibility (and please take the opportunity to sort in any
new function which are "waiting" at the end of the function table) */ new function which are "waiting" at the end of the function table) */
#define PLUGIN_MIN_API_VERSION 199 #define PLUGIN_MIN_API_VERSION 200
/* plugin return codes */ /* plugin return codes */
/* internal returns start at 0x100 to make exit(1..255) work */ /* internal returns start at 0x100 to make exit(1..255) work */
@ -901,7 +901,7 @@ struct plugin_api {
#ifdef HAVE_SEMAPHORE_OBJECTS #ifdef HAVE_SEMAPHORE_OBJECTS
void (*semaphore_init)(struct semaphore *s, int max, int start); void (*semaphore_init)(struct semaphore *s, int max, int start);
void (*semaphore_wait)(struct semaphore *s); int (*semaphore_wait)(struct semaphore *s, int timeout);
void (*semaphore_release)(struct semaphore *s); void (*semaphore_release)(struct semaphore *s);
#endif #endif

4
firmware/export/config.h
View file

@ -741,8 +741,6 @@ Lyre prototype 1 */
#endif /* PLATFORM_NATIVE */ #endif /* PLATFORM_NATIVE */
#define HAVE_SEMAPHORE_OBJECTS
#ifdef HAVE_USBSTACK #ifdef HAVE_USBSTACK
#if CONFIG_USBOTG == USBOTG_ARC #if CONFIG_USBOTG == USBOTG_ARC
#define USB_STATUS_BY_EVENT #define USB_STATUS_BY_EVENT
@ -769,7 +767,7 @@ Lyre prototype 1 */
|| (CONFIG_CPU == AS3525) || (CONFIG_CPU == AS3525v2) \ || (CONFIG_CPU == AS3525) || (CONFIG_CPU == AS3525v2) \
|| defined(CPU_S5L870X) || (CONFIG_CPU == S3C2440) \ || defined(CPU_S5L870X) || (CONFIG_CPU == S3C2440) \
|| defined(APPLICATION) || defined(APPLICATION)
#define HAVE_WAKEUP_OBJECTS #define HAVE_SEMAPHORE_OBJECTS
#endif #endif
/*include support for crossfading - requires significant PCM buffer space*/ /*include support for crossfading - requires significant PCM buffer space*/

20
firmware/export/kernel.h
View file

@ -160,22 +160,12 @@ struct mutex
struct semaphore struct semaphore
{ {
struct thread_entry *queue; /* Waiter list */ struct thread_entry *queue; /* Waiter list */
int count; /* # of waits remaining before unsignaled */ int volatile count; /* # of waits remaining before unsignaled */
int max; /* maximum # of waits to remain signaled */ int max; /* maximum # of waits to remain signaled */
IF_COP( struct corelock cl; ) /* multiprocessor sync */ IF_COP( struct corelock cl; ) /* multiprocessor sync */
}; };
#endif #endif
#ifdef HAVE_WAKEUP_OBJECTS
struct wakeup
{
struct thread_entry *queue; /* waiter list */
bool volatile signalled; /* signalled status */
IF_COP( struct corelock cl; ) /* multiprocessor sync */
};
#endif
/* global tick variable */ /* global tick variable */
#if defined(CPU_PP) && defined(BOOTLOADER) && \ #if defined(CPU_PP) && defined(BOOTLOADER) && \
!defined(HAVE_BOOTLOADER_USB_MODE) !defined(HAVE_BOOTLOADER_USB_MODE)
@ -280,14 +270,8 @@ static inline bool mutex_test(const struct mutex *m)
#ifdef HAVE_SEMAPHORE_OBJECTS #ifdef HAVE_SEMAPHORE_OBJECTS
extern void semaphore_init(struct semaphore *s, int max, int start); extern void semaphore_init(struct semaphore *s, int max, int start);
extern void semaphore_wait(struct semaphore *s); extern int semaphore_wait(struct semaphore *s, int timeout);
extern void semaphore_release(struct semaphore *s); extern void semaphore_release(struct semaphore *s);
#endif /* HAVE_SEMAPHORE_OBJECTS */ #endif /* HAVE_SEMAPHORE_OBJECTS */
#ifdef HAVE_WAKEUP_OBJECTS
extern void wakeup_init(struct wakeup *w);
extern int wakeup_wait(struct wakeup *w, int timeout);
extern int wakeup_signal(struct wakeup *w);
#endif /* HAVE_WAKEUP_OBJECTS */
#endif /* _KERNEL_H_ */ #endif /* _KERNEL_H_ */

4
firmware/export/thread.h
View file

@ -284,7 +284,9 @@ struct thread_entry
and priority disinheritance */ and priority disinheritance */
/* Only enabled when using queue_send for now */ /* Only enabled when using queue_send for now */
#endif #endif
#if defined(HAVE_EXTENDED_MESSAGING_AND_NAME) || NUM_CORES > 1 #if defined(HAVE_SEMAPHORE_OBJECTS) || \
defined(HAVE_EXTENDED_MESSAGING_AND_NAME) || \
NUM_CORES > 1
volatile intptr_t retval; /* Return value from a blocked operation/ volatile intptr_t retval; /* Return value from a blocked operation/
misc. use */ misc. use */
#endif #endif

180
firmware/kernel.c
View file

@ -978,6 +978,9 @@ void mutex_unlock(struct mutex *m)
* Simple semaphore functions ;) * Simple semaphore functions ;)
****************************************************************************/ ****************************************************************************/
#ifdef HAVE_SEMAPHORE_OBJECTS #ifdef HAVE_SEMAPHORE_OBJECTS
/* Initialize the semaphore object.
* max = maximum up count the semaphore may assume (max >= 1)
* start = initial count of semaphore (0 <= count <= max) */
void semaphore_init(struct semaphore *s, int max, int start) void semaphore_init(struct semaphore *s, int max, int start)
{ {
KERNEL_ASSERT(max > 0 && start >= 0 && start <= max, KERNEL_ASSERT(max > 0 && start >= 0 && start <= max,
@ -988,132 +991,97 @@ void semaphore_init(struct semaphore *s, int max, int start)
corelock_init(&s->cl); corelock_init(&s->cl);
} }
void semaphore_wait(struct semaphore *s) /* Down the semaphore's count or wait for 'timeout' ticks for it to go up if
* it is already 0. 'timeout' as TIMEOUT_NOBLOCK (0) will not block and may
* safely be used in an ISR. */
int semaphore_wait(struct semaphore *s, int timeout)
{ {
struct thread_entry *current; int ret;
int oldlevel;
int count;
oldlevel = disable_irq_save();
corelock_lock(&s->cl); corelock_lock(&s->cl);
if(LIKELY(--s->count >= 0)) count = s->count;
if(LIKELY(count > 0))
{ {
/* wait satisfied */ /* count is not zero; down it */
corelock_unlock(&s->cl); s->count = count - 1;
return; ret = OBJ_WAIT_SUCCEEDED;
} }
else if(timeout == 0)
/* too many waits - block until dequeued... */ {
current = thread_id_entry(THREAD_ID_CURRENT); /* just polling it */
ret = OBJ_WAIT_TIMEDOUT;
}
else
{
/* too many waits - block until count is upped... */
struct thread_entry * current = thread_id_entry(THREAD_ID_CURRENT);
IF_COP( current->obj_cl = &s->cl; ) IF_COP( current->obj_cl = &s->cl; )
current->bqp = &s->queue; current->bqp = &s->queue;
/* return value will be OBJ_WAIT_SUCCEEDED after wait if wake was
* explicit in semaphore_release */
current->retval = OBJ_WAIT_TIMEDOUT;
disable_irq(); if(timeout > 0)
block_thread(current); block_thread_w_tmo(current, timeout); /* ...or timed out... */
else
block_thread(current); /* -timeout = infinite */
corelock_unlock(&s->cl); corelock_unlock(&s->cl);
/* ...and turn control over to next thread */ /* ...and turn control over to next thread */
switch_thread(); switch_thread();
}
void semaphore_release(struct semaphore *s) return current->retval;
{
IF_PRIO( unsigned int result = THREAD_NONE; )
corelock_lock(&s->cl);
if(s->count < s->max && ++s->count <= 0)
{
/* there should be threads in this queue */
KERNEL_ASSERT(s->queue != NULL, "semaphore->wakeup\n");
/* a thread was queued - wake it up */
int oldlevel = disable_irq_save();
IF_PRIO( result = ) wakeup_thread(&s->queue);
restore_irq(oldlevel);
} }
corelock_unlock(&s->cl); corelock_unlock(&s->cl);
restore_irq(oldlevel);
#ifdef HAVE_PRIORITY_SCHEDULING return ret;
if(result & THREAD_SWITCH) }
/* Up the semaphore's count and release any thread waiting at the head of the
* queue. The count is saturated to the value of the 'max' parameter specified
* in 'semaphore_init'. */
void semaphore_release(struct semaphore *s)
{
IF_PRIO( unsigned int result = THREAD_NONE; )
int oldlevel;
oldlevel = disable_irq_save();
corelock_lock(&s->cl);
if(LIKELY(s->queue != NULL))
{
/* a thread was queued - wake it up and keep count at 0 */
KERNEL_ASSERT(s->count == 0,
"semaphore_release->threads queued but count=%d!\n", s->count);
s->queue->retval = OBJ_WAIT_SUCCEEDED; /* indicate explicit wake */
IF_PRIO( result = ) wakeup_thread(&s->queue);
}
else
{
int count = s->count;
if(count < s->max)
{
/* nothing waiting - up it */
s->count = count + 1;
}
}
corelock_unlock(&s->cl);
restore_irq(oldlevel);
#if defined(HAVE_PRIORITY_SCHEDULING) && defined(irq_enabled_checkval)
/* No thread switch if IRQ disabled - it's probably called via ISR.
* switch_thread would as well enable them anyway. */
if((result & THREAD_SWITCH) && irq_enabled_checkval(oldlevel))
switch_thread(); switch_thread();
#endif #endif
} }
#endif /* HAVE_SEMAPHORE_OBJECTS */ #endif /* HAVE_SEMAPHORE_OBJECTS */
#ifdef HAVE_WAKEUP_OBJECTS
/****************************************************************************
* Lightweight IRQ-compatible wakeup object
*/
/* Initialize the wakeup object */
void wakeup_init(struct wakeup *w)
{
w->queue = NULL;
w->signalled = false;
IF_COP( corelock_init(&w->cl); )
}
/* Wait for a signal blocking indefinitely or for a specified period */
int wakeup_wait(struct wakeup *w, int timeout)
{
int ret = OBJ_WAIT_SUCCEEDED; /* Presume success */
int oldlevel = disable_irq_save();
corelock_lock(&w->cl);
if(LIKELY(!w->signalled && timeout != TIMEOUT_NOBLOCK))
{
struct thread_entry * current = thread_id_entry(THREAD_ID_CURRENT);
IF_COP( current->obj_cl = &w->cl; )
current->bqp = &w->queue;
if (timeout != TIMEOUT_BLOCK)
block_thread_w_tmo(current, timeout);
else
block_thread(current);
corelock_unlock(&w->cl);
switch_thread();
oldlevel = disable_irq_save();
corelock_lock(&w->cl);
}
if(UNLIKELY(!w->signalled))
{
/* Timed-out or failed */
ret = (timeout != TIMEOUT_BLOCK) ?
OBJ_WAIT_TIMEDOUT : OBJ_WAIT_FAILED;
}
w->signalled = false; /* Reset */
corelock_unlock(&w->cl);
restore_irq(oldlevel);
return ret;
}
/* Signal the thread waiting or leave the signal if the thread hasn't
* waited yet.
*
* returns THREAD_NONE or THREAD_OK
*/
int wakeup_signal(struct wakeup *w)
{
int oldlevel = disable_irq_save();
int ret;
corelock_lock(&w->cl);
w->signalled = true;
ret = wakeup_thread(&w->queue);
corelock_unlock(&w->cl);
restore_irq(oldlevel);
return ret;
}
#endif /* HAVE_WAKEUP_OBJECTS */

27
firmware/target/arm/as3525/ascodec-as3525.c
View file

@ -107,7 +107,7 @@ struct ascodec_request {
unsigned char status; unsigned char status;
unsigned char cnt; unsigned char cnt;
unsigned char data[ASCODEC_REQ_MAXLEN]; unsigned char data[ASCODEC_REQ_MAXLEN];
struct wakeup wkup; struct semaphore complete;
ascodec_cb_fn *callback; ascodec_cb_fn *callback;
struct ascodec_request *next; struct ascodec_request *next;
}; };
@ -121,7 +121,7 @@ static unsigned char *req_data_ptr = NULL;
static struct ascodec_request *req_head = NULL; static struct ascodec_request *req_head = NULL;
static struct ascodec_request *req_tail = NULL; static struct ascodec_request *req_tail = NULL;
static struct wakeup adc_wkup; static struct semaphore adc_done_sem;
static struct ascodec_request as_audio_req; static struct ascodec_request as_audio_req;
#ifdef DEBUG #ifdef DEBUG
@ -168,7 +168,7 @@ static void ascodec_finish_req(struct ascodec_request *req)
if (req->callback) { if (req->callback) {
req->callback(req->data, req_data_ptr - req->data); req->callback(req->data, req_data_ptr - req->data);
} }
wakeup_signal(&req->wkup); semaphore_release(&req->complete);
req_head = req->next; req_head = req->next;
req->next = NULL; req->next = NULL;
@ -263,7 +263,7 @@ void ascodec_init(void)
int prescaler; int prescaler;
mutex_init(&as_mtx); mutex_init(&as_mtx);
wakeup_init(&adc_wkup); semaphore_init(&adc_done_sem, 1, 0);
/* enable clock */ /* enable clock */
bitset32(&CGU_PERI, CGU_I2C_AUDIO_MASTER_CLOCK_ENABLE); bitset32(&CGU_PERI, CGU_I2C_AUDIO_MASTER_CLOCK_ENABLE);
@ -312,7 +312,7 @@ void ascodec_init(void)
static void ascodec_req_init(struct ascodec_request *req, int type, static void ascodec_req_init(struct ascodec_request *req, int type,
unsigned int index, unsigned int cnt) unsigned int index, unsigned int cnt)
{ {
wakeup_init(&req->wkup); semaphore_init(&req->complete, 1, 0);
req->next = NULL; req->next = NULL;
req->callback = NULL; req->callback = NULL;
req->type = type; req->type = type;
@ -337,19 +337,10 @@ static void ascodec_submit(struct ascodec_request *req)
restore_irq(oldlevel); restore_irq(oldlevel);
} }
static int irq_disabled(void)
{
unsigned long cpsr;
asm volatile ("mrs %0, cpsr" : "=r"(cpsr));
return (cpsr & IRQ_STATUS) == IRQ_DISABLED;
}
static void ascodec_wait(struct ascodec_request *req) static void ascodec_wait(struct ascodec_request *req)
{ {
if (!irq_disabled()) { if (irq_enabled()) {
wakeup_wait(&req->wkup, TIMEOUT_BLOCK); semaphore_wait(&req->complete, TIMEOUT_BLOCK);
return; return;
} }
@ -477,7 +468,7 @@ static void ascodec_read_cb(unsigned const char *data, unsigned int len)
} }
if (data[2] & IRQ_ADC) { /* adc finished */ if (data[2] & IRQ_ADC) { /* adc finished */
IFDEBUG(int_adc++); IFDEBUG(int_adc++);
wakeup_signal(&adc_wkup); semaphore_release(&adc_done_sem);
} }
VIC_INT_ENABLE = INTERRUPT_AUDIO; VIC_INT_ENABLE = INTERRUPT_AUDIO;
} }
@ -492,7 +483,7 @@ void INT_AUDIO(void)
void ascodec_wait_adc_finished(void) void ascodec_wait_adc_finished(void)
{ {
wakeup_wait(&adc_wkup, TIMEOUT_BLOCK); semaphore_wait(&adc_done_sem, TIMEOUT_BLOCK);
} }
#ifdef CONFIG_CHARGING #ifdef CONFIG_CHARGING

2
firmware/target/arm/as3525/ascodec-target.h
View file

@ -28,7 +28,7 @@
#ifndef SIMULATOR #ifndef SIMULATOR
#include "as3514.h" #include "as3514.h"
#include "kernel.h" /* for struct wakeup */ #include "kernel.h" /* for struct semaphore */
#include "clock-target.h" /* for AS3525_I2C_PRESCALER */ #include "clock-target.h" /* for AS3525_I2C_PRESCALER */
#include "system-arm.h" #include "system-arm.h"

12
firmware/target/arm/as3525/sd-as3525.c
View file

@ -136,7 +136,7 @@ static bool hs_card = false;
#define EXT_SD_BITS (1<<2) #define EXT_SD_BITS (1<<2)
#endif #endif
static struct wakeup transfer_completion_signal; static struct semaphore transfer_completion_signal;
static volatile unsigned int transfer_error[NUM_VOLUMES]; static volatile unsigned int transfer_error[NUM_VOLUMES];
#define PL180_MAX_TRANSFER_ERRORS 10 #define PL180_MAX_TRANSFER_ERRORS 10
@ -191,7 +191,7 @@ void INT_NAND(void)
transfer_error[INTERNAL_AS3525] = status & MCI_DATA_ERROR; transfer_error[INTERNAL_AS3525] = status & MCI_DATA_ERROR;
wakeup_signal(&transfer_completion_signal); semaphore_release(&transfer_completion_signal);
MCI_CLEAR(INTERNAL_AS3525) = status; MCI_CLEAR(INTERNAL_AS3525) = status;
} }
@ -202,7 +202,7 @@ void INT_MCI0(void)
transfer_error[SD_SLOT_AS3525] = status & MCI_DATA_ERROR; transfer_error[SD_SLOT_AS3525] = status & MCI_DATA_ERROR;
wakeup_signal(&transfer_completion_signal); semaphore_release(&transfer_completion_signal);
MCI_CLEAR(SD_SLOT_AS3525) = status; MCI_CLEAR(SD_SLOT_AS3525) = status;
} }
#endif #endif
@ -568,7 +568,7 @@ int sd_init(void)
bitset32(&CCU_IO, 1<<2); bitset32(&CCU_IO, 1<<2);
#endif #endif
wakeup_init(&transfer_completion_signal); semaphore_init(&transfer_completion_signal, 1, 0);
init_pl180_controller(INTERNAL_AS3525); init_pl180_controller(INTERNAL_AS3525);
ret = sd_init_card(INTERNAL_AS3525); ret = sd_init_card(INTERNAL_AS3525);
@ -678,7 +678,7 @@ static int sd_select_bank(signed char bank)
(9<<4) /* 2^9 = 512 */ ; (9<<4) /* 2^9 = 512 */ ;
/* Wakeup signal from NAND/MCIO isr on MCI_DATA_ERROR | MCI_DATA_END */ /* Wakeup signal from NAND/MCIO isr on MCI_DATA_ERROR | MCI_DATA_END */
wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK); semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
/* Wait for FIFO to empty, card may still be in PRG state */ /* Wait for FIFO to empty, card may still be in PRG state */
while(MCI_STATUS(INTERNAL_AS3525) & MCI_TX_ACTIVE ); while(MCI_STATUS(INTERNAL_AS3525) & MCI_TX_ACTIVE );
@ -837,7 +837,7 @@ static int sd_transfer_sectors(IF_MD2(int drive,) unsigned long start,
(9<<4) /* 2^9 = 512 */ ; (9<<4) /* 2^9 = 512 */ ;
/* Wakeup signal from NAND/MCIO isr on MCI_DATA_ERROR | MCI_DATA_END */ /* Wakeup signal from NAND/MCIO isr on MCI_DATA_ERROR | MCI_DATA_END */
wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK); semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
/* Wait for FIFO to empty, card may still be in PRG state for writes */ /* Wait for FIFO to empty, card may still be in PRG state for writes */
while(MCI_STATUS(drive) & MCI_TX_ACTIVE); while(MCI_STATUS(drive) & MCI_TX_ACTIVE);

16
firmware/target/arm/as3525/sd-as3525v2.c
View file

@ -342,8 +342,8 @@ static struct event_queue sd_queue;
bool sd_enabled = false; bool sd_enabled = false;
#endif #endif
static struct wakeup transfer_completion_signal; static struct semaphore transfer_completion_signal;
static struct wakeup command_completion_signal; static struct semaphore command_completion_signal;
static volatile bool retry; static volatile bool retry;
static volatile int cmd_error; static volatile int cmd_error;
@ -365,12 +365,12 @@ void INT_NAND(void)
retry = true; retry = true;
if( status & (MCI_INT_DTO|MCI_DATA_ERROR)) if( status & (MCI_INT_DTO|MCI_DATA_ERROR))
wakeup_signal(&transfer_completion_signal); semaphore_release(&transfer_completion_signal);
cmd_error = status & MCI_CMD_ERROR; cmd_error = status & MCI_CMD_ERROR;
if(status & MCI_INT_CD) if(status & MCI_INT_CD)
wakeup_signal(&command_completion_signal); semaphore_release(&command_completion_signal);
MCI_CTRL |= INT_ENABLE; MCI_CTRL |= INT_ENABLE;
} }
@ -442,7 +442,7 @@ static bool send_cmd(const int drive, const int cmd, const int arg, const int fl
_buttonlight_off(); _buttonlight_off();
} }
#endif #endif
wakeup_wait(&command_completion_signal, TIMEOUT_BLOCK); semaphore_wait(&command_completion_signal, TIMEOUT_BLOCK);
/* Handle command responses & errors */ /* Handle command responses & errors */
if(flags & MCI_RESP) if(flags & MCI_RESP)
@ -769,8 +769,8 @@ int sd_init(void)
| (AS3525_SDSLOT_DIV << 2) | (AS3525_SDSLOT_DIV << 2)
| 1; /* clock source = PLLA */ | 1; /* clock source = PLLA */
wakeup_init(&transfer_completion_signal); semaphore_init(&transfer_completion_signal, 1, 0);
wakeup_init(&command_completion_signal); semaphore_init(&command_completion_signal, 1, 0);
#if defined(SANSA_FUZEV2) || defined(SANSA_CLIPPLUS) #if defined(SANSA_FUZEV2) || defined(SANSA_CLIPPLUS)
if (amsv2_variant == 1) if (amsv2_variant == 1)
@ -932,7 +932,7 @@ sd_transfer_retry_with_reinit:
goto sd_transfer_error; goto sd_transfer_error;
} }
wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK); semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
last_disk_activity = current_tick; last_disk_activity = current_tick;

24
firmware/target/arm/as3525/usb-drv-as3525.c
View file

@ -40,6 +40,7 @@
static struct usb_endpoint endpoints[USB_NUM_EPS][2]; static struct usb_endpoint endpoints[USB_NUM_EPS][2];
static int got_set_configuration = 0; static int got_set_configuration = 0;
static int usb_enum_timeout = -1; static int usb_enum_timeout = -1;
static bool initialized = false;
/* /*
* dma/setup descriptors and buffers should avoid sharing * dma/setup descriptors and buffers should avoid sharing
@ -180,19 +181,19 @@ static void reset_endpoints(int init)
if (endpoints[i][0].state & EP_STATE_BUSY) { if (endpoints[i][0].state & EP_STATE_BUSY) {
if (endpoints[i][0].state & EP_STATE_ASYNC) { if (endpoints[i][0].state & EP_STATE_ASYNC) {
endpoints[i][0].rc = -1; endpoints[i][0].rc = -1;
wakeup_signal(&endpoints[i][0].complete); semaphore_release(&endpoints[i][0].complete);
} else { } else {
usb_core_transfer_complete(i, USB_DIR_IN, -1, 0); usb_core_transfer_complete(i, USB_DIR_IN, -1, 0);
} }
} }
endpoints[i][0].state = 0; endpoints[i][0].state = 0;
wakeup_init(&endpoints[i][0].complete); semaphore_wait(&endpoints[i][0].complete, TIMEOUT_NOBLOCK);
if (i != 2) { /* Skip the OUT EP0 alias */ if (i != 2) { /* Skip the OUT EP0 alias */
if (endpoints[i][1].state & EP_STATE_BUSY) if (endpoints[i][1].state & EP_STATE_BUSY)
usb_core_transfer_complete(i, USB_DIR_OUT, -1, 0); usb_core_transfer_complete(i, USB_DIR_OUT, -1, 0);
endpoints[i][1].state = 0; endpoints[i][1].state = 0;
wakeup_init(&endpoints[i][1].complete); semaphore_wait(&endpoints[i][1].complete, TIMEOUT_NOBLOCK);
USB_OEP_SUP_PTR(i) = 0; USB_OEP_SUP_PTR(i) = 0;
} }
} }
@ -225,6 +226,18 @@ void usb_drv_init(void)
{ {
logf("usb_drv_init() !!!!\n"); logf("usb_drv_init() !!!!\n");
if (!initialized)
{
int i;
for (i = 0; i < USB_NUM_EPS; i++)
{
semaphore_init(&endpoints[i][0].complete, 1, 0);
semaphore_init(&endpoints[i][1].complete, 1, 0);
}
initialized = true;
}
usb_enable_pll(); usb_enable_pll();
/* we have external power, so boost cpu */ /* we have external power, so boost cpu */
@ -322,6 +335,7 @@ void usb_drv_exit(void)
ascodec_write(AS3515_USB_UTIL, ascodec_read(AS3515_USB_UTIL) & ~(1<<4)); ascodec_write(AS3515_USB_UTIL, ascodec_read(AS3515_USB_UTIL) & ~(1<<4));
usb_disable_pll(); usb_disable_pll();
cpu_boost(0); cpu_boost(0);
initialized = false;
logf("usb_drv_exit() !!!!\n"); logf("usb_drv_exit() !!!!\n");
} }
@ -529,7 +543,7 @@ int usb_drv_send(int ep, void *ptr, int len)
} }
ep_send(ep, ptr, len); ep_send(ep, ptr, len);
if (wakeup_wait(&endpoints[ep][0].complete, HZ) == OBJ_WAIT_TIMEDOUT) if (semaphore_wait(&endpoints[ep][0].complete, HZ) == OBJ_WAIT_TIMEDOUT)
logf("send timed out!\n"); logf("send timed out!\n");
return endpoints[ep][0].rc; return endpoints[ep][0].rc;
@ -570,7 +584,7 @@ static void handle_in_ep(int ep)
endpoints[ep][0].state &= ~EP_STATE_ASYNC; endpoints[ep][0].state &= ~EP_STATE_ASYNC;
usb_core_transfer_complete(ep, USB_DIR_IN, 0, endpoints[ep][0].len); usb_core_transfer_complete(ep, USB_DIR_IN, 0, endpoints[ep][0].len);
} else { } else {
wakeup_signal(&endpoints[ep][0].complete); semaphore_release(&endpoints[ep][0].complete);
} }
ep_sts &= ~USB_EP_STAT_TDC; ep_sts &= ~USB_EP_STAT_TDC;
} }

2
firmware/target/arm/as3525/usb-drv-as3525.h
View file

@ -310,7 +310,7 @@ struct usb_endpoint
unsigned int len; unsigned int len;
volatile unsigned int state; volatile unsigned int state;
int rc; int rc;
struct wakeup complete; struct semaphore complete;
struct usb_dev_dma_desc *uc_desc; struct usb_dev_dma_desc *uc_desc;
}; };

22
firmware/target/arm/as3525/usb-drv-as3525v2.c
View file

@ -61,7 +61,7 @@ static const uint8_t out_ep_list[NUM_OUT_EP + 1] = {0, OUT_EP_LIST};
struct usb_endpoint struct usb_endpoint
{ {
unsigned int len; /* length of the data buffer */ unsigned int len; /* length of the data buffer */
struct wakeup complete; /* wait object */ struct semaphore complete; /* wait object */
int8_t status; /* completion status (0 for success) */ int8_t status; /* completion status (0 for success) */
bool active; /* true is endpoint has been requested (true for EP0) */ bool active; /* true is endpoint has been requested (true for EP0) */
bool wait; /* true if usb thread is blocked on completion */ bool wait; /* true if usb thread is blocked on completion */
@ -281,7 +281,7 @@ static void reset_endpoints(void)
if(endpoints[ep][DIR_IN].wait) if(endpoints[ep][DIR_IN].wait)
{ {
endpoints[ep][DIR_IN].wait = false; endpoints[ep][DIR_IN].wait = false;
wakeup_signal(&endpoints[ep][DIR_IN].complete); semaphore_release(&endpoints[ep][DIR_IN].complete);
} }
if(DIEPCTL(ep) & DEPCTL_epena) if(DIEPCTL(ep) & DEPCTL_epena)
DIEPCTL(ep) = DEPCTL_snak; DIEPCTL(ep) = DEPCTL_snak;
@ -297,7 +297,7 @@ static void reset_endpoints(void)
if(endpoints[ep][DIR_OUT].wait) if(endpoints[ep][DIR_OUT].wait)
{ {
endpoints[ep][DIR_OUT].wait = false; endpoints[ep][DIR_OUT].wait = false;
wakeup_signal(&endpoints[ep][DIR_OUT].complete); semaphore_release(&endpoints[ep][DIR_OUT].complete);
} }
if(DOEPCTL(ep) & DEPCTL_epena) if(DOEPCTL(ep) & DEPCTL_epena)
DOEPCTL(ep) = DEPCTL_snak; DOEPCTL(ep) = DEPCTL_snak;
@ -329,7 +329,7 @@ static void cancel_all_transfers(bool cancel_ep0)
if(endpoints[ep][DIR_IN].wait) if(endpoints[ep][DIR_IN].wait)
{ {
endpoints[ep][DIR_IN].wait = false; endpoints[ep][DIR_IN].wait = false;
wakeup_signal(&endpoints[ep][DIR_IN].complete); semaphore_release(&endpoints[ep][DIR_IN].complete);
} }
DIEPCTL(ep) = (DIEPCTL(ep) & ~DEPCTL_usbactep) | DEPCTL_snak; DIEPCTL(ep) = (DIEPCTL(ep) & ~DEPCTL_usbactep) | DEPCTL_snak;
} }
@ -340,7 +340,7 @@ static void cancel_all_transfers(bool cancel_ep0)
if(endpoints[ep][DIR_OUT].wait) if(endpoints[ep][DIR_OUT].wait)
{ {
endpoints[ep][DIR_OUT].wait = false; endpoints[ep][DIR_OUT].wait = false;
wakeup_signal(&endpoints[ep][DIR_OUT].complete); semaphore_release(&endpoints[ep][DIR_OUT].complete);
} }
DOEPCTL(ep) = (DOEPCTL(ep) & ~DEPCTL_usbactep) | DEPCTL_snak; DOEPCTL(ep) = (DOEPCTL(ep) & ~DEPCTL_usbactep) | DEPCTL_snak;
} }
@ -457,9 +457,9 @@ void usb_drv_init(void)
/* Core init */ /* Core init */
core_init(); core_init();
FOR_EACH_IN_EP_AND_EP0(i, ep) FOR_EACH_IN_EP_AND_EP0(i, ep)
wakeup_init(&endpoints[ep][DIR_IN].complete); semaphore_init(&endpoints[ep][DIR_IN].complete, 1, 0);
FOR_EACH_OUT_EP_AND_EP0(i, ep) FOR_EACH_OUT_EP_AND_EP0(i, ep)
wakeup_init(&endpoints[ep][DIR_OUT].complete); semaphore_init(&endpoints[ep][DIR_OUT].complete, 1, 0);
/* Enable global interrupts */ /* Enable global interrupts */
enable_global_interrupts(); enable_global_interrupts();
} }
@ -498,7 +498,7 @@ static void handle_ep_in_int(int ep)
if(endpoint->wait) if(endpoint->wait)
{ {
endpoint->wait = false; endpoint->wait = false;
wakeup_signal(&endpoint->complete); semaphore_release(&endpoint->complete);
} }
} }
} }
@ -515,7 +515,7 @@ static void handle_ep_in_int(int ep)
if(endpoint->wait) if(endpoint->wait)
{ {
endpoint->wait = false; endpoint->wait = false;
wakeup_signal(&endpoint->complete); semaphore_release(&endpoint->complete);
} }
} }
} }
@ -549,7 +549,7 @@ static void handle_ep_out_int(int ep)
if(endpoint->wait) if(endpoint->wait)
{ {
endpoint->wait = false; endpoint->wait = false;
wakeup_signal(&endpoint->complete); semaphore_release(&endpoint->complete);
} }
} }
} }
@ -798,7 +798,7 @@ static int usb_drv_transfer(int ep, void *ptr, int len, bool dir_in, bool blocki
if(blocking) if(blocking)
{ {
wakeup_wait(&endpoint->complete, TIMEOUT_BLOCK); semaphore_wait(&endpoint->complete, TIMEOUT_BLOCK);
return endpoint->status; return endpoint->status;
} }

12
firmware/target/arm/imx31/ata-imx31.c
View file

@ -246,7 +246,7 @@ static const struct ata_udma_timings
/** Threading **/ /** Threading **/
/* Signal to tell thread when DMA is done */ /* Signal to tell thread when DMA is done */
static struct wakeup ata_dma_wakeup; static struct semaphore ata_dma_complete;
/** SDMA **/ /** SDMA **/
/* Array of buffer descriptors for large transfers and alignnment */ /* Array of buffer descriptors for large transfers and alignnment */
@ -445,7 +445,7 @@ static void ata_dma_callback(void)
ATA_INTERRUPT_CLEAR = ATA_INTERRUPT_PENDING; ATA_INTERRUPT_CLEAR = ATA_INTERRUPT_PENDING;
ata_set_intrq(false); /* Return INTRQ to MCU */ ata_set_intrq(false); /* Return INTRQ to MCU */
wakeup_signal(&ata_dma_wakeup); /* Signal waiting thread */ semaphore_release(&ata_dma_complete); /* Signal waiting thread */
} }
bool ata_dma_setup(void *addr, unsigned long bytes, bool write) bool ata_dma_setup(void *addr, unsigned long bytes, bool write)
@ -580,7 +580,8 @@ bool ata_dma_finish(void)
{ {
int oldirq; int oldirq;
if (LIKELY(wakeup_wait(&ata_dma_wakeup, HZ/2) == OBJ_WAIT_SUCCEEDED)) if (LIKELY(semaphore_wait(&ata_dma_complete, HZ/2)
== OBJ_WAIT_SUCCEEDED))
break; break;
ata_keep_active(); ata_keep_active();
@ -594,7 +595,8 @@ bool ata_dma_finish(void)
sdma_channel_stop(channel); /* Stop DMA */ sdma_channel_stop(channel); /* Stop DMA */
restore_irq(oldirq); restore_irq(oldirq);
if (wakeup_wait(&ata_dma_wakeup, TIMEOUT_NOBLOCK) == OBJ_WAIT_SUCCEEDED) if (semaphore_wait(&ata_dma_complete, TIMEOUT_NOBLOCK)
== OBJ_WAIT_SUCCEEDED)
break; /* DMA really did finish after timeout */ break; /* DMA really did finish after timeout */
sdma_channel_reset(channel); /* Reset everything + clear error */ sdma_channel_reset(channel); /* Reset everything + clear error */
@ -716,7 +718,7 @@ void ata_device_init(void)
ata_dma_selected = ATA_DMA_PIO; ata_dma_selected = ATA_DMA_PIO;
/* Called for first time at startup */ /* Called for first time at startup */
wakeup_init(&ata_dma_wakeup); semaphore_init(&ata_dma_complete, 1, 0);
if (!sdma_channel_init(ATA_DMA_CH_NUM_RD, &ata_cd_rd, ata_bda) || if (!sdma_channel_init(ATA_DMA_CH_NUM_RD, &ata_cd_rd, ata_bda) ||
!sdma_channel_init(ATA_DMA_CH_NUM_WR, &ata_cd_wr, ata_bda)) !sdma_channel_init(ATA_DMA_CH_NUM_WR, &ata_cd_wr, ata_bda))

8
firmware/target/arm/imx31/gigabeat-s/adc-gigabeat-s.c
View file

@ -35,7 +35,7 @@ static const unsigned char reg_array[4] =
}; };
static uint32_t channels[2][4]; static uint32_t channels[2][4];
static struct wakeup adc_wake; static struct semaphore adc_done_signal;
static struct mutex adc_mtx; static struct mutex adc_mtx;
static long last_adc_read[2]; /* One for each input group */ static long last_adc_read[2]; /* One for each input group */
@ -67,7 +67,7 @@ unsigned short adc_read(int channel)
mc13783_write(MC13783_ADC1, adc1); mc13783_write(MC13783_ADC1, adc1);
/* Wait for done signal */ /* Wait for done signal */
wakeup_wait(&adc_wake, TIMEOUT_BLOCK); semaphore_wait(&adc_done_signal, TIMEOUT_BLOCK);
/* Read all 8 channels that are converted - two channels in each /* Read all 8 channels that are converted - two channels in each
* word. */ * word. */
@ -113,12 +113,12 @@ bool adc_enable_channel(int channel, bool enable)
/* Called by mc13783 interrupt thread when conversion is complete */ /* Called by mc13783 interrupt thread when conversion is complete */
void adc_done(void) void adc_done(void)
{ {
wakeup_signal(&adc_wake); semaphore_release(&adc_done_signal);
} }
void adc_init(void) void adc_init(void)
{ {
wakeup_init(&adc_wake); semaphore_init(&adc_done_signal, 1, 0);
mutex_init(&adc_mtx); mutex_init(&adc_mtx);
/* Init so first reads get data */ /* Init so first reads get data */

8
firmware/target/arm/imx31/gigabeat-s/headphone-gigabeat-s.c
View file

@ -29,7 +29,7 @@
#include "adc.h" #include "adc.h"
#include "button.h" #include "button.h"
static struct wakeup headphone_wakeup; static struct semaphore headphone_wakeup;
static unsigned int headphone_thread_id; static unsigned int headphone_thread_id;
static int headphone_stack[200/sizeof(int)]; /* Not much stack needed */ static int headphone_stack[200/sizeof(int)]; /* Not much stack needed */
static const char * const headphone_thread_name = "headphone"; static const char * const headphone_thread_name = "headphone";
@ -115,7 +115,7 @@ static void headphone_thread(void)
while (1) while (1)
{ {
int rc = wakeup_wait(&headphone_wakeup, headphone_wait_timeout); int rc = semaphore_wait(&headphone_wakeup, headphone_wait_timeout);
unsigned int data = adc_read(ADC_HPREMOTE); unsigned int data = adc_read(ADC_HPREMOTE);
if (rc == OBJ_WAIT_TIMEDOUT) if (rc == OBJ_WAIT_TIMEDOUT)
@ -175,7 +175,7 @@ static void headphone_thread(void)
void headphone_detect_event(void) void headphone_detect_event(void)
{ {
/* Trigger the thread immediately. */ /* Trigger the thread immediately. */
wakeup_signal(&headphone_wakeup); semaphore_release(&headphone_wakeup);
} }
/* Tell if anything is in the jack. */ /* Tell if anything is in the jack. */
@ -187,7 +187,7 @@ bool headphones_inserted(void)
void INIT_ATTR headphone_init(void) void INIT_ATTR headphone_init(void)
{ {
/* A thread is required to monitor the remote ADC and jack state. */ /* A thread is required to monitor the remote ADC and jack state. */
wakeup_init(&headphone_wakeup); semaphore_init(&headphone_wakeup, 1, 0);
headphone_thread_id = create_thread(headphone_thread, headphone_thread_id = create_thread(headphone_thread,
headphone_stack, headphone_stack,
sizeof(headphone_stack), sizeof(headphone_stack),

8
firmware/target/arm/imx31/i2c-imx31.c
View file

@ -48,7 +48,7 @@ static struct i2c_module_descriptor
volatile unsigned short * const base; /* Module base address */ volatile unsigned short * const base; /* Module base address */
void (* const handler)(void); /* Module interrupt handler */ void (* const handler)(void); /* Module interrupt handler */
struct mutex m; /* Node mutual-exclusion */ struct mutex m; /* Node mutual-exclusion */
struct wakeup w; /* I2C done signal */ struct semaphore complete; /* I2C completion signal */
unsigned char *addr_data; /* Additional addressing data */ unsigned char *addr_data; /* Additional addressing data */
int addr_count; /* Addressing byte count */ int addr_count; /* Addressing byte count */
unsigned char *data; /* TX/RX buffer (actual data) */ unsigned char *data; /* TX/RX buffer (actual data) */
@ -164,7 +164,7 @@ i2c_stop:
base[I2CR] &= ~(I2C_I2CR_MSTA | I2C_I2CR_IIEN); base[I2CR] &= ~(I2C_I2CR_MSTA | I2C_I2CR_IIEN);
i2c_done: i2c_done:
/* Signal thread we're done */ /* Signal thread we're done */
wakeup_signal(&desc->w); semaphore_release(&desc->complete);
} }
#if (I2C_MODULE_MASK & USE_I2C1_MODULE) #if (I2C_MODULE_MASK & USE_I2C1_MODULE)
@ -221,7 +221,7 @@ static int i2c_transfer(struct i2c_node * const node,
base[I2DR] = desc->addr; base[I2DR] = desc->addr;
/* Wait for transfer to complete */ /* Wait for transfer to complete */
if (wakeup_wait(&desc->w, HZ) == OBJ_WAIT_SUCCEEDED) if (semaphore_wait(&desc->complete, HZ) == OBJ_WAIT_SUCCEEDED)
{ {
count -= desc->data_count; count -= desc->data_count;
} }
@ -294,7 +294,7 @@ void i2c_init(void)
struct i2c_module_descriptor *const desc = &i2c_descs[i]; struct i2c_module_descriptor *const desc = &i2c_descs[i];
ccm_module_clock_gating(desc->cg, CGM_ON_RUN_WAIT); ccm_module_clock_gating(desc->cg, CGM_ON_RUN_WAIT);
mutex_init(&desc->m); mutex_init(&desc->m);
wakeup_init(&desc->w); semaphore_init(&desc->complete, 1, 0);
desc->base[I2CR] = 0; desc->base[I2CR] = 0;
ccm_module_clock_gating(desc->cg, CGM_OFF); ccm_module_clock_gating(desc->cg, CGM_OFF);
} }

20
firmware/target/arm/imx31/mc13783-imx31.c
View file

@ -32,11 +32,11 @@ extern struct spi_node mc13783_spi;
/* PMIC event service data */ /* PMIC event service data */
static int mc13783_thread_stack[DEFAULT_STACK_SIZE/sizeof(int)]; static int mc13783_thread_stack[DEFAULT_STACK_SIZE/sizeof(int)];
static const char *mc13783_thread_name = "pmic"; static const char *mc13783_thread_name = "pmic";
static struct wakeup mc13783_svc_wake; static struct semaphore mc13783_svc_wake;
/* Synchronous thread communication objects */ /* Synchronous thread communication objects */
static struct mutex mc13783_spi_mutex; static struct mutex mc13783_spi_mutex;
static struct wakeup mc13783_spi_wake; static struct semaphore mc13783_spi_complete;
/* Tracking for which interrupts are enabled */ /* Tracking for which interrupts are enabled */
static uint32_t pmic_int_enabled[2] = static uint32_t pmic_int_enabled[2] =
@ -69,13 +69,13 @@ static void mc13783_xfer_complete_cb(struct spi_transfer_desc *xfer)
if (xfer->count != 0) if (xfer->count != 0)
return; return;
wakeup_signal(&mc13783_spi_wake); semaphore_release(&mc13783_spi_complete);
} }
static inline bool wait_for_transfer_complete(void) static inline bool wait_for_transfer_complete(void)
{ {
return wakeup_wait(&mc13783_spi_wake, HZ*2) == OBJ_WAIT_SUCCEEDED && return semaphore_wait(&mc13783_spi_complete, HZ*2)
mc13783_transfer.count == 0; == OBJ_WAIT_SUCCEEDED && mc13783_transfer.count == 0;
} }
static void mc13783_interrupt_thread(void) static void mc13783_interrupt_thread(void)
@ -89,7 +89,7 @@ static void mc13783_interrupt_thread(void)
{ {
const struct mc13783_event *event, *event_last; const struct mc13783_event *event, *event_last;
wakeup_wait(&mc13783_svc_wake, TIMEOUT_BLOCK); semaphore_wait(&mc13783_svc_wake, TIMEOUT_BLOCK);
if (mc13783_thread_id == 0) if (mc13783_thread_id == 0)
break; break;
@ -140,16 +140,16 @@ void mc13783_event(void)
/* Mask the interrupt (unmasked when PMIC thread services it). */ /* Mask the interrupt (unmasked when PMIC thread services it). */
bitclr32(&MC13783_GPIO_IMR, 1ul << MC13783_GPIO_LINE); bitclr32(&MC13783_GPIO_IMR, 1ul << MC13783_GPIO_LINE);
MC13783_GPIO_ISR = (1ul << MC13783_GPIO_LINE); MC13783_GPIO_ISR = (1ul << MC13783_GPIO_LINE);
wakeup_signal(&mc13783_svc_wake); semaphore_release(&mc13783_svc_wake);
} }
void INIT_ATTR mc13783_init(void) void INIT_ATTR mc13783_init(void)
{ {
/* Serial interface must have been initialized first! */ /* Serial interface must have been initialized first! */
wakeup_init(&mc13783_svc_wake); semaphore_init(&mc13783_svc_wake, 1, 0);
mutex_init(&mc13783_spi_mutex); mutex_init(&mc13783_spi_mutex);
wakeup_init(&mc13783_spi_wake); semaphore_init(&mc13783_spi_complete, 1, 0);
/* Enable the PMIC SPI module */ /* Enable the PMIC SPI module */
spi_enable_module(&mc13783_spi); spi_enable_module(&mc13783_spi);
@ -175,7 +175,7 @@ void mc13783_close(void)
return; return;
mc13783_thread_id = 0; mc13783_thread_id = 0;
wakeup_signal(&mc13783_svc_wake); semaphore_release(&mc13783_svc_wake);
thread_wait(thread_id); thread_wait(thread_id);
spi_disable_module(&mc13783_spi); spi_disable_module(&mc13783_spi);
} }

8
firmware/target/arm/ipod/button-clickwheel.c
View file

@ -84,7 +84,7 @@ int int_btn = BUTTON_NONE;
#endif #endif
#if CONFIG_CPU==S5L8701 || CONFIG_CPU==S5L8702 #if CONFIG_CPU==S5L8701 || CONFIG_CPU==S5L8702
static struct wakeup button_init_wakeup; static struct semaphore button_init_wakeup;
#endif #endif
#if CONFIG_CPU==S5L8702 #if CONFIG_CPU==S5L8702
@ -273,7 +273,7 @@ static inline int ipod_4g_button_read(void)
btn |= BUTTON_PLAY; btn |= BUTTON_PLAY;
if (status & 0x00100000) if (status & 0x00100000)
btn |= BUTTON_MENU; btn |= BUTTON_MENU;
wakeup_signal(&button_init_wakeup); semaphore_release(&button_init_wakeup);
} }
#endif #endif
@ -373,7 +373,7 @@ void s5l_clickwheel_init(void)
void button_init_device(void) void button_init_device(void)
{ {
wakeup_init(&button_init_wakeup); semaphore_init(&button_init_wakeup, 1, 0);
#if CONFIG_CPU==S5L8701 #if CONFIG_CPU==S5L8701
INTMSK |= (1<<26); INTMSK |= (1<<26);
#elif CONFIG_CPU==S5L8702 #elif CONFIG_CPU==S5L8702
@ -381,7 +381,7 @@ void button_init_device(void)
holdswitch_last_value = (pmu_read(0x87) & 2) == 0; holdswitch_last_value = (pmu_read(0x87) & 2) == 0;
#endif #endif
s5l_clickwheel_init(); s5l_clickwheel_init();
wakeup_wait(&button_init_wakeup, HZ / 10); semaphore_wait(&button_init_wakeup, HZ / 10);
} }
bool button_hold(void) bool button_hold(void)

8
firmware/target/arm/ipod/video/lcd-video.c
View file

@ -107,7 +107,7 @@ struct
#ifdef HAVE_LCD_SLEEP #ifdef HAVE_LCD_SLEEP
bool display_on; bool display_on;
bool waking; bool waking;
struct wakeup initwakeup; struct semaphore initwakeup;
#endif #endif
} lcd_state IBSS_ATTR; } lcd_state IBSS_ATTR;
@ -188,7 +188,7 @@ static inline unsigned bcm_read32(unsigned address)
static void continue_lcd_awake(void) static void continue_lcd_awake(void)
{ {
lcd_state.waking = false; lcd_state.waking = false;
wakeup_signal(&(lcd_state.initwakeup)); semaphore_release(&(lcd_state.initwakeup));
} }
#endif #endif
@ -357,7 +357,7 @@ void lcd_init_device(void)
/* lcd_write_data needs an even number of 16 bit values */ /* lcd_write_data needs an even number of 16 bit values */
flash_vmcs_length = ((flash_vmcs_length + 3) >> 1) & ~1; flash_vmcs_length = ((flash_vmcs_length + 3) >> 1) & ~1;
} }
wakeup_init(&(lcd_state.initwakeup)); semaphore_init(&(lcd_state.initwakeup), 1, 0);
lcd_state.waking = false; lcd_state.waking = false;
if (GPO32_VAL & 0x4000) if (GPO32_VAL & 0x4000)
@ -620,7 +620,7 @@ void lcd_awake(void)
*/ */
lcd_state.waking = true; lcd_state.waking = true;
tick_add_task(&lcd_tick); tick_add_task(&lcd_tick);
wakeup_wait(&(lcd_state.initwakeup), TIMEOUT_BLOCK); semaphore_wait(&(lcd_state.initwakeup), TIMEOUT_BLOCK);
send_event(LCD_EVENT_ACTIVATION, NULL); send_event(LCD_EVENT_ACTIVATION, NULL);
} }

10
firmware/target/arm/olympus/mrobe-100/lcd-remote-mr100.c
View file

@ -67,7 +67,7 @@ unsigned char rc_buf[5];
/* Remote thread functions */ /* Remote thread functions */
/* These functions are private to the remote thread */ /* These functions are private to the remote thread */
/* ================================================== */ /* ================================================== */
static struct wakeup rc_thread_wakeup; static struct semaphore rc_thread_wakeup;
static unsigned int remote_thread_id; static unsigned int remote_thread_id;
static int remote_stack[256/sizeof(int)]; static int remote_stack[256/sizeof(int)];
static const char * const remote_thread_name = "remote"; static const char * const remote_thread_name = "remote";
@ -368,7 +368,7 @@ static void remote_thread(void)
while (1) while (1)
{ {
wakeup_wait(&rc_thread_wakeup, rc_thread_wait_timeout); semaphore_wait(&rc_thread_wakeup, rc_thread_wait_timeout);
/* Error handling (most likely due to remote not present) */ /* Error handling (most likely due to remote not present) */
if (rc_status & RC_ERROR_MASK) if (rc_status & RC_ERROR_MASK)
@ -500,7 +500,7 @@ void lcd_remote_off(void)
{ {
/* should only be used to power off at shutdown */ /* should only be used to power off at shutdown */
rc_status |= RC_POWER_OFF; rc_status |= RC_POWER_OFF;
wakeup_signal(&rc_thread_wakeup); semaphore_release(&rc_thread_wakeup);
/* wait until the things are powered off */ /* wait until the things are powered off */
while (rc_status & RC_DEV_INIT) while (rc_status & RC_DEV_INIT)
@ -515,7 +515,7 @@ void lcd_remote_on(void)
{ {
rc_status &= ~RC_FORCE_DETECT; rc_status &= ~RC_FORCE_DETECT;
rc_status &= ~RC_POWER_OFF; rc_status &= ~RC_POWER_OFF;
wakeup_signal(&rc_thread_wakeup); semaphore_release(&rc_thread_wakeup);
} }
} }
@ -536,7 +536,7 @@ void lcd_remote_init_device(void)
GPIO_SET_BITWISE(GPIOL_OUTPUT_EN, 0x80); GPIO_SET_BITWISE(GPIOL_OUTPUT_EN, 0x80);
/* a thread is required to poll & update the remote */ /* a thread is required to poll & update the remote */
wakeup_init(&rc_thread_wakeup); semaphore_init(&rc_thread_wakeup, 1, 0);
remote_thread_id = create_thread(remote_thread, remote_stack, remote_thread_id = create_thread(remote_thread, remote_stack,
sizeof(remote_stack), 0, remote_thread_name sizeof(remote_stack), 0, remote_thread_name
IF_PRIO(, PRIORITY_SYSTEM) IF_PRIO(, PRIORITY_SYSTEM)

8
firmware/target/arm/s3c2440/i2c-s3c2440.c
View file

@ -21,7 +21,7 @@
#include "system.h" #include "system.h"
#include "i2c-s3c2440.h" #include "i2c-s3c2440.h"
static struct wakeup i2c_wake; /* Transfer completion signal */ static struct semaphore i2c_complete; /* Transfer completion signal */
static struct mutex i2c_mtx; /* Mutual exclusion */ static struct mutex i2c_mtx; /* Mutual exclusion */
static unsigned char *buf_ptr; /* Next byte to transfer */ static unsigned char *buf_ptr; /* Next byte to transfer */
static int buf_count; /* Number of bytes remaining to transfer */ static int buf_count; /* Number of bytes remaining to transfer */
@ -64,7 +64,7 @@ void i2c_write(int addr, const unsigned char *buf, int count)
/* Generate START */ /* Generate START */
IICSTAT = I2C_MODE_MASTER | I2C_MODE_TX | I2C_START | I2C_RXTX_ENB; IICSTAT = I2C_MODE_MASTER | I2C_MODE_TX | I2C_START | I2C_RXTX_ENB;
if (wakeup_wait(&i2c_wake, HZ) != OBJ_WAIT_SUCCEEDED) if (semaphore_wait(&i2c_complete, HZ) != OBJ_WAIT_SUCCEEDED)
{ {
/* Something went wrong - stop transmission */ /* Something went wrong - stop transmission */
int oldlevel = disable_irq_save(); int oldlevel = disable_irq_save();
@ -84,7 +84,7 @@ void i2c_write(int addr, const unsigned char *buf, int count)
void i2c_init(void) void i2c_init(void)
{ {
/* Init kernel objects */ /* Init kernel objects */
wakeup_init(&i2c_wake); semaphore_init(&i2c_complete, 1, 0);
mutex_init(&i2c_mtx); mutex_init(&i2c_mtx);
/* Clear pending source */ /* Clear pending source */
@ -134,7 +134,7 @@ void IIC(void)
i2c_stop(); i2c_stop();
/* Signal thread */ /* Signal thread */
wakeup_signal(&i2c_wake); semaphore_release(&i2c_complete);
break; break;
} }

10
firmware/target/arm/s3c2440/sd-s3c2440.c
View file

@ -119,7 +119,7 @@ static long sd_stack [(DEFAULT_STACK_SIZE*2 + 0x1c0)/sizeof(long)];
static const char sd_thread_name[] = "sd"; static const char sd_thread_name[] = "sd";
static struct mutex sd_mtx SHAREDBSS_ATTR; static struct mutex sd_mtx SHAREDBSS_ATTR;
static struct event_queue sd_queue; static struct event_queue sd_queue;
static struct wakeup transfer_completion_signal; static struct semaphore transfer_completion_signal;
static volatile unsigned int transfer_error[NUM_VOLUMES]; static volatile unsigned int transfer_error[NUM_VOLUMES];
/* align on cache line size */ /* align on cache line size */
static unsigned char aligned_buffer[UNALIGNED_NUM_SECTORS * SD_BLOCK_SIZE] static unsigned char aligned_buffer[UNALIGNED_NUM_SECTORS * SD_BLOCK_SIZE]
@ -223,7 +223,7 @@ void SDI (void)
dbgprintf ("SDI %x\n", transfer_error[curr_card]); dbgprintf ("SDI %x\n", transfer_error[curr_card]);
wakeup_signal(&transfer_completion_signal); semaphore_release(&transfer_completion_signal);
/* Ack the interrupt */ /* Ack the interrupt */
SRCPND = SDI_MASK; SRCPND = SDI_MASK;
@ -242,7 +242,7 @@ void dma_callback (void)
SDIDSTA |= S3C2410_SDIDSTA_CLEAR_BITS; /* needed to clear int */ SDIDSTA |= S3C2410_SDIDSTA_CLEAR_BITS; /* needed to clear int */
dbgprintf ("dma_cb\n"); dbgprintf ("dma_cb\n");
wakeup_signal(&transfer_completion_signal); semaphore_release(&transfer_completion_signal);
} }
#endif #endif
@ -783,7 +783,7 @@ static int sd_transfer_sectors(int card_no, unsigned long start,
(9<<4) /* 2^9 = 512 */ ; (9<<4) /* 2^9 = 512 */ ;
#endif #endif
wakeup_wait(&transfer_completion_signal, 100 /*TIMEOUT_BLOCK*/); semaphore_wait(&transfer_completion_signal, 100 /*TIMEOUT_BLOCK*/);
/* wait for DMA to finish */ /* wait for DMA to finish */
while (DSTAT0 & DSTAT_STAT_BUSY) while (DSTAT0 & DSTAT_STAT_BUSY)
@ -928,7 +928,7 @@ int sd_init(void)
sd_enabled = true; sd_enabled = true;
sd_enable(false); sd_enable(false);
#endif #endif
wakeup_init(&transfer_completion_signal); semaphore_init(&transfer_completion_signal, 1, 0);
/* init mutex */ /* init mutex */
mutex_init(&sd_mtx); mutex_init(&sd_mtx);
queue_init(&sd_queue, true); queue_init(&sd_queue, true);

8
firmware/target/arm/s5l8700/adc-s5l8700.c
View file

@ -42,11 +42,11 @@
static struct mutex adc_mtx; static struct mutex adc_mtx;
static struct wakeup adc_wakeup; static struct semaphore adc_wakeup;
void INT_ADC(void) void INT_ADC(void)
{ {
wakeup_signal(&adc_wakeup); semaphore_release(&adc_wakeup);
} }
unsigned short adc_read(int channel) unsigned short adc_read(int channel)
@ -61,7 +61,7 @@ unsigned short adc_read(int channel)
(1 << 0); /* enable start */ (1 << 0); /* enable start */
/* wait for conversion */ /* wait for conversion */
wakeup_wait(&adc_wakeup, TIMEOUT_BLOCK); semaphore_wait(&adc_wakeup, TIMEOUT_BLOCK);
/* get the converted data */ /* get the converted data */
data = ADCDAT0 & 0x3FF; data = ADCDAT0 & 0x3FF;
@ -77,7 +77,7 @@ unsigned short adc_read(int channel)
void adc_init(void) void adc_init(void)
{ {
mutex_init(&adc_mtx); mutex_init(&adc_mtx);
wakeup_init(&adc_wakeup); semaphore_init(&adc_wakeup, 1, 0);
/* enable clock to ADC */ /* enable clock to ADC */
PWRCON &= ~(1 << 10); PWRCON &= ~(1 << 10);

8
firmware/target/arm/s5l8700/ipodnano2g/nand-nano2g.c
View file

@ -94,9 +94,9 @@ static long nand_last_activity_value = -1;
static long nand_stack[DEFAULT_STACK_SIZE]; static long nand_stack[DEFAULT_STACK_SIZE];
static struct mutex nand_mtx; static struct mutex nand_mtx;
static struct wakeup nand_wakeup; static struct semaphore nand_complete;
static struct mutex ecc_mtx; static struct mutex ecc_mtx;
static struct wakeup ecc_wakeup; static struct semaphore ecc_complete;
static uint8_t nand_data[0x800] STORAGE_ALIGN_ATTR; static uint8_t nand_data[0x800] STORAGE_ALIGN_ATTR;
static uint8_t nand_ctrl[0x200] STORAGE_ALIGN_ATTR; static uint8_t nand_ctrl[0x200] STORAGE_ALIGN_ATTR;
@ -731,9 +731,9 @@ static void nand_thread(void)
int nand_device_init(void) int nand_device_init(void)
{ {
mutex_init(&nand_mtx); mutex_init(&nand_mtx);
wakeup_init(&nand_wakeup); semaphore_init(&nand_complete, 1, 0);
mutex_init(&ecc_mtx); mutex_init(&ecc_mtx);
wakeup_init(&ecc_wakeup); semaphore_init(&ecc_complete, 1, 0);
uint32_t type; uint32_t type;
uint32_t i, j; uint32_t i, j;

8
firmware/target/arm/s5l8702/ipod6g/lcd-ipod6g.c
View file

@ -50,7 +50,7 @@
int lcd_type; /* also needed in debug-s5l8702.c */ int lcd_type; /* also needed in debug-s5l8702.c */
static struct dma_lli lcd_lli[(LCD_WIDTH * LCD_HEIGHT - 1) / 0xfff] CACHEALIGN_ATTR; static struct dma_lli lcd_lli[(LCD_WIDTH * LCD_HEIGHT - 1) / 0xfff] CACHEALIGN_ATTR;
static struct wakeup lcd_wakeup; static struct semaphore lcd_wakeup;
static struct mutex lcd_mutex; static struct mutex lcd_mutex;
static uint16_t lcd_dblbuf[LCD_HEIGHT][LCD_WIDTH]; static uint16_t lcd_dblbuf[LCD_HEIGHT][LCD_WIDTH];
@ -149,7 +149,7 @@ void lcd_sleep(void)
void lcd_init_device(void) void lcd_init_device(void)
{ {
/* Detect lcd type */ /* Detect lcd type */
wakeup_init(&lcd_wakeup); semaphore_init(&lcd_wakeup, 1, 0);
mutex_init(&lcd_mutex); mutex_init(&lcd_mutex);
lcd_type = (PDAT6 & 0x30) >> 4; lcd_type = (PDAT6 & 0x30) >> 4;
} }
@ -180,7 +180,7 @@ static void displaylcd_setup(int x, int y, int width, int height) ICODE_ATTR;
static void displaylcd_setup(int x, int y, int width, int height) static void displaylcd_setup(int x, int y, int width, int height)
{ {
mutex_lock(&lcd_mutex); mutex_lock(&lcd_mutex);
while (DMAC0C4CONFIG & 1) wakeup_wait(&lcd_wakeup, HZ / 10); while (DMAC0C4CONFIG & 1) semaphore_wait(&lcd_wakeup, HZ / 10);
int xe = (x + width) - 1; /* max horiz */ int xe = (x + width) - 1; /* max horiz */
int ye = (y + height) - 1; /* max vert */ int ye = (y + height) - 1; /* max vert */
@ -237,7 +237,7 @@ void INT_DMAC0C4(void) ICODE_ATTR;
void INT_DMAC0C4(void) void INT_DMAC0C4(void)
{ {
DMAC0INTTCCLR = 0x10; DMAC0INTTCCLR = 0x10;
wakeup_signal(&lcd_wakeup); semaphore_release(&lcd_wakeup);
} }
/* Update a fraction of the display. */ /* Update a fraction of the display. */

35
firmware/target/arm/s5l8702/ipod6g/storage_ata-ipod6g.c
View file

@ -53,7 +53,7 @@ bool ata_lba48;
bool ata_dma; bool ata_dma;
uint64_t ata_total_sectors; uint64_t ata_total_sectors;
struct mutex ata_mutex; struct mutex ata_mutex;
static struct wakeup ata_wakeup; static struct semaphore ata_wakeup;
static uint32_t ata_dma_flags; static uint32_t ata_dma_flags;
static long ata_last_activity_value = -1; static long ata_last_activity_value = -1;
static long ata_sleep_timeout = 20 * HZ; static long ata_sleep_timeout = 20 * HZ;
@ -61,8 +61,8 @@ static uint32_t ata_stack[(DEFAULT_STACK_SIZE + 0x400) / 4];
static bool ata_powered; static bool ata_powered;
static const int ata_retries = ATA_RETRIES; static const int ata_retries = ATA_RETRIES;
static const bool ata_error_srst = true; static const bool ata_error_srst = true;
static struct wakeup mmc_wakeup; static struct semaphore mmc_wakeup;
static struct wakeup mmc_comp_wakeup; static struct semaphore mmc_comp_wakeup;
static int spinup_time = 0; static int spinup_time = 0;
static int dma_mode = 0; static int dma_mode = 0;
@ -319,7 +319,7 @@ void mmc_discard_irq(void)
{ {
SDCI_IRQ = SDCI_IRQ_DAT_DONE_INT | SDCI_IRQ_MASK_MASK_IOCARD_IRQ_INT SDCI_IRQ = SDCI_IRQ_DAT_DONE_INT | SDCI_IRQ_MASK_MASK_IOCARD_IRQ_INT
| SDCI_IRQ_MASK_MASK_READ_WAIT_INT; | SDCI_IRQ_MASK_MASK_READ_WAIT_INT;
wakeup_wait(&mmc_wakeup, 0); semaphore_wait(&mmc_wakeup, 0);
} }
int ceata_read_multiple_register(uint32_t addr, void* dest, uint32_t size) int ceata_read_multiple_register(uint32_t addr, void* dest, uint32_t size)
@ -338,7 +338,8 @@ int ceata_read_multiple_register(uint32_t addr, void* dest, uint32_t size)
| MMC_CMD_CEATA_RW_MULTIPLE_REG_ADDRESS(addr & 0xfc) | MMC_CMD_CEATA_RW_MULTIPLE_REG_ADDRESS(addr & 0xfc)
| MMC_CMD_CEATA_RW_MULTIPLE_REG_COUNT(size & 0xfc), | MMC_CMD_CEATA_RW_MULTIPLE_REG_COUNT(size & 0xfc),
NULL, CEATA_COMMAND_TIMEOUT), 2, 1); NULL, CEATA_COMMAND_TIMEOUT), 2, 1);
if (wakeup_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000) == OBJ_WAIT_TIMEDOUT) RET_ERR(2); if (semaphore_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000)
== OBJ_WAIT_TIMEDOUT) RET_ERR(2);
PASS_RC(mmc_dsta_check_data_success(), 2, 3); PASS_RC(mmc_dsta_check_data_success(), 2, 3);
return 0; return 0;
} }
@ -362,7 +363,8 @@ int ceata_write_multiple_register(uint32_t addr, void* dest, uint32_t size)
SDCI_DCTRL = SDCI_DCTRL_TRCONT_TX; SDCI_DCTRL = SDCI_DCTRL_TRCONT_TX;
for (i = 0; i < size / 4; i++) SDCI_DATA = ((uint32_t*)dest)[i]; for (i = 0; i < size / 4; i++) SDCI_DATA = ((uint32_t*)dest)[i];
long startusec = USEC_TIMER; long startusec = USEC_TIMER;
if (wakeup_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000) == OBJ_WAIT_TIMEDOUT) RET_ERR(2); if (semaphore_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000)
== OBJ_WAIT_TIMEDOUT) RET_ERR(2);
while ((SDCI_STATE & SDCI_STATE_DAT_STATE_MASK) != SDCI_STATE_DAT_STATE_IDLE) while ((SDCI_STATE & SDCI_STATE_DAT_STATE_MASK) != SDCI_STATE_DAT_STATE_IDLE)
{ {
if (TIMEOUT_EXPIRED(startusec, CEATA_COMMAND_TIMEOUT)) RET_ERR(3); if (TIMEOUT_EXPIRED(startusec, CEATA_COMMAND_TIMEOUT)) RET_ERR(3);
@ -479,13 +481,13 @@ int ceata_rw_multiple_block(bool write, void* buf, uint32_t count, long timeout)
direction | MMC_CMD_CEATA_RW_MULTIPLE_BLOCK_COUNT(count), direction | MMC_CMD_CEATA_RW_MULTIPLE_BLOCK_COUNT(count),
NULL, CEATA_COMMAND_TIMEOUT), 4, 0); NULL, CEATA_COMMAND_TIMEOUT), 4, 0);
if (write) SDCI_DCTRL = SDCI_DCTRL_TRCONT_TX; if (write) SDCI_DCTRL = SDCI_DCTRL_TRCONT_TX;
if (wakeup_wait(&mmc_wakeup, timeout) == OBJ_WAIT_TIMEDOUT) if (semaphore_wait(&mmc_wakeup, timeout) == OBJ_WAIT_TIMEDOUT)
{ {
PASS_RC(ceata_cancel_command(), 4, 1); PASS_RC(ceata_cancel_command(), 4, 1);
RET_ERR(2); RET_ERR(2);
} }
PASS_RC(mmc_dsta_check_data_success(), 4, 3); PASS_RC(mmc_dsta_check_data_success(), 4, 3);
if (wakeup_wait(&mmc_comp_wakeup, timeout) == OBJ_WAIT_TIMEDOUT) if (semaphore_wait(&mmc_comp_wakeup, timeout) == OBJ_WAIT_TIMEDOUT)
{ {
PASS_RC(ceata_cancel_command(), 4, 4); PASS_RC(ceata_cancel_command(), 4, 4);
RET_ERR(4); RET_ERR(4);
@ -750,11 +752,12 @@ int ata_rw_chunk_internal(uint64_t sector, uint32_t cnt, void* buffer, bool writ
ATA_XFR_NUM = SECTOR_SIZE * cnt - 1; ATA_XFR_NUM = SECTOR_SIZE * cnt - 1;
ATA_CFG |= ata_dma_flags; ATA_CFG |= ata_dma_flags;
ATA_CFG &= ~(BIT(7) | BIT(8)); ATA_CFG &= ~(BIT(7) | BIT(8));
wakeup_wait(&ata_wakeup, 0); semaphore_wait(&ata_wakeup, 0);
ATA_IRQ = BITRANGE(0, 4); ATA_IRQ = BITRANGE(0, 4);
ATA_IRQ_MASK = BIT(0); ATA_IRQ_MASK = BIT(0);
ATA_COMMAND = BIT(0); ATA_COMMAND = BIT(0);
if (wakeup_wait(&ata_wakeup, 500000 * HZ / 1000000) == OBJ_WAIT_TIMEDOUT) if (semaphore_wait(&ata_wakeup, 500000 * HZ / 1000000)
== OBJ_WAIT_TIMEDOUT)
{ {
ATA_COMMAND = BIT(1); ATA_COMMAND = BIT(1);
ATA_CFG &= ~(BITRANGE(2, 3) | BIT(12)); ATA_CFG &= ~(BITRANGE(2, 3) | BIT(12));
@ -1068,9 +1071,9 @@ void ata_bbt_reload(void)
int ata_init(void) int ata_init(void)
{ {
mutex_init(&ata_mutex); mutex_init(&ata_mutex);
wakeup_init(&ata_wakeup); semaphore_init(&ata_wakeup, 1, 0);
wakeup_init(&mmc_wakeup); semaphore_init(&mmc_wakeup, 1, 0);
wakeup_init(&mmc_comp_wakeup); semaphore_init(&mmc_comp_wakeup, 1, 0);
ceata = PDAT(11) & BIT(1); ceata = PDAT(11) & BIT(1);
if (ceata) if (ceata)
{ {
@ -1129,14 +1132,14 @@ void INT_ATA(void)
{ {
uint32_t ata_irq = ATA_IRQ; uint32_t ata_irq = ATA_IRQ;
ATA_IRQ = ata_irq; ATA_IRQ = ata_irq;
if (ata_irq & ATA_IRQ_MASK) wakeup_signal(&ata_wakeup); if (ata_irq & ATA_IRQ_MASK) semaphore_release(&ata_wakeup);
ATA_IRQ_MASK = 0; ATA_IRQ_MASK = 0;
} }
void INT_MMC(void) void INT_MMC(void)
{ {
uint32_t irq = SDCI_IRQ; uint32_t irq = SDCI_IRQ;
if (irq & SDCI_IRQ_DAT_DONE_INT) wakeup_signal(&mmc_wakeup); if (irq & SDCI_IRQ_DAT_DONE_INT) semaphore_release(&mmc_wakeup);
if (irq & SDCI_IRQ_IOCARD_IRQ_INT) wakeup_signal(&mmc_comp_wakeup); if (irq & SDCI_IRQ_IOCARD_IRQ_INT) semaphore_release(&mmc_comp_wakeup);
SDCI_IRQ = irq; SDCI_IRQ = irq;
} }

22
firmware/target/arm/system-arm.h
View file

@ -62,6 +62,21 @@ void __div0(void);
#define enable_fiq() \ #define enable_fiq() \
enable_interrupt(FIQ_STATUS) enable_interrupt(FIQ_STATUS)
#define irq_enabled() \
interrupt_enabled(IRQ_STATUS)
#define fiq_enabled() \
interrupt_enabled(FIQ_STATUS)
#define ints_enabled() \
interrupt_enabled(IRQ_FIQ_STATUS)
#define irq_enabled_checkval(val) \
(((val) & IRQ_STATUS) == 0)
#define fiq_enabled_checkval(val) \
(((val) & FIQ_STATUS) == 0)
#define ints_enabled_checkval(val) \
(((val) & IRQ_FIQ_STATUS) == 0)
/* Core-level interrupt masking */ /* Core-level interrupt masking */
static inline int set_interrupt_status(int status, int mask) static inline int set_interrupt_status(int status, int mask)
@ -87,6 +102,13 @@ static inline void restore_interrupt(int cpsr)
asm volatile ("msr cpsr_c, %0" : : "r"(cpsr)); asm volatile ("msr cpsr_c, %0" : : "r"(cpsr));
} }
static inline bool interrupt_enabled(int status)
{
unsigned long cpsr;
asm ("mrs %0, cpsr" : "=r"(cpsr));
return (cpsr & status) == 0;
}
/* ARM_ARCH version section for architecture*/ /* ARM_ARCH version section for architecture*/
#if ARM_ARCH >= 6 #if ARM_ARCH >= 6

14
firmware/target/arm/tms320dm320/creative-zvm/dma-creativezvm.c
View file

@ -37,14 +37,14 @@
#define CF_START 0x40000000 #define CF_START 0x40000000
#define SSFDC_START 0x48000000 #define SSFDC_START 0x48000000
static struct wakeup transfer_completion_signal; static struct semaphore transfer_completion_signal;
static bool dma_in_progress = false; static bool dma_in_progress = false;
void MTC0(void) void MTC0(void)
{ {
IO_INTC_IRQ1 = INTR_IRQ1_MTC0; IO_INTC_IRQ1 = INTR_IRQ1_MTC0;
wakeup_signal(&transfer_completion_signal); semaphore_release(&transfer_completion_signal);
dma_in_progress = false; dma_in_progress = false;
} }
@ -59,7 +59,7 @@ void dma_start(const void* addr, size_t size)
void dma_ata_read(unsigned char* buf, int shortcount) void dma_ata_read(unsigned char* buf, int shortcount)
{ {
if(dma_in_progress) if(dma_in_progress)
wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK); semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
while((unsigned long)buf & 0x1F) while((unsigned long)buf & 0x1F)
{ {
@ -83,7 +83,7 @@ void dma_ata_read(unsigned char* buf, int shortcount)
IO_EMIF_DMACTL = 3; /* Select MTC->AHB and start transfer */ IO_EMIF_DMACTL = 3; /* Select MTC->AHB and start transfer */
dma_in_progress = true; dma_in_progress = true;
wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK); semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
if(shortcount % 2) if(shortcount % 2)
{ {
@ -97,7 +97,7 @@ void dma_ata_read(unsigned char* buf, int shortcount)
void dma_ata_write(unsigned char* buf, int wordcount) void dma_ata_write(unsigned char* buf, int wordcount)
{ {
if(dma_in_progress) if(dma_in_progress)
wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK); semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
while((unsigned long)buf & 0x1F) while((unsigned long)buf & 0x1F)
{ {
@ -121,12 +121,12 @@ void dma_ata_write(unsigned char* buf, int wordcount)
IO_EMIF_DMACTL = 1; /* Select AHB->MTC and start transfer */ IO_EMIF_DMACTL = 1; /* Select AHB->MTC and start transfer */
dma_in_progress = true; dma_in_progress = true;
wakeup_wait(&transfer_completion_signal, TIMEOUT_BLOCK); semaphore_wait(&transfer_completion_signal, TIMEOUT_BLOCK);
} }
void dma_init(void) void dma_init(void)
{ {
IO_INTC_EINT1 |= INTR_EINT1_MTC0; /* enable MTC interrupt */ IO_INTC_EINT1 |= INTR_EINT1_MTC0; /* enable MTC interrupt */
wakeup_init(&transfer_completion_signal); semaphore_init(&transfer_completion_signal, 1, 0);
dma_in_progress = false; dma_in_progress = false;
} }

14
firmware/target/arm/usb-drv-arc.c
View file

@ -349,7 +349,7 @@ struct queue_head {
static struct queue_head qh_array[USB_NUM_ENDPOINTS*2] static struct queue_head qh_array[USB_NUM_ENDPOINTS*2]
USB_QHARRAY_ATTR; USB_QHARRAY_ATTR;
static struct wakeup transfer_completion_signal[USB_NUM_ENDPOINTS*2] static struct semaphore transfer_completion_signal[USB_NUM_ENDPOINTS*2]
SHAREDBSS_ATTR; SHAREDBSS_ATTR;
static const unsigned int pipe2mask[] = { static const unsigned int pipe2mask[] = {
@ -424,7 +424,7 @@ void usb_drv_startup(void)
/* Initialize all the signal objects once */ /* Initialize all the signal objects once */
int i; int i;
for(i=0;i<USB_NUM_ENDPOINTS*2;i++) { for(i=0;i<USB_NUM_ENDPOINTS*2;i++) {
wakeup_init(&transfer_completion_signal[i]); semaphore_init(&transfer_completion_signal[i], 1, 0);
} }
} }
@ -778,7 +778,7 @@ static int prime_transfer(int ep_num, void* ptr, int len, bool send, bool wait)
if (wait) { if (wait) {
/* wait for transfer to finish */ /* wait for transfer to finish */
wakeup_wait(&transfer_completion_signal[pipe], TIMEOUT_BLOCK); semaphore_wait(&transfer_completion_signal[pipe], TIMEOUT_BLOCK);
if(qh->status!=0) { if(qh->status!=0) {
/* No need to cancel wait here since it was done and the signal /* No need to cancel wait here since it was done and the signal
* came. */ * came. */
@ -797,7 +797,7 @@ pt_error:
qh->wait = 0; qh->wait = 0;
/* Make sure to remove any signal if interrupt fired before we zeroed /* Make sure to remove any signal if interrupt fired before we zeroed
* qh->wait. Could happen during a bus reset for example. */ * qh->wait. Could happen during a bus reset for example. */
wakeup_wait(&transfer_completion_signal[pipe], TIMEOUT_NOBLOCK); semaphore_wait(&transfer_completion_signal[pipe], TIMEOUT_NOBLOCK);
} }
return rc; return rc;
@ -814,7 +814,7 @@ void usb_drv_cancel_all_transfers(void)
if(qh_array[i].wait) { if(qh_array[i].wait) {
qh_array[i].wait=0; qh_array[i].wait=0;
qh_array[i].status=DTD_STATUS_HALTED; qh_array[i].status=DTD_STATUS_HALTED;
wakeup_signal(&transfer_completion_signal[i]); semaphore_release(&transfer_completion_signal[i]);
} }
} }
} }
@ -906,7 +906,7 @@ static void control_received(void)
if(qh_array[i].wait) { if(qh_array[i].wait) {
qh_array[i].wait=0; qh_array[i].wait=0;
qh_array[i].status=DTD_STATUS_HALTED; qh_array[i].status=DTD_STATUS_HALTED;
wakeup_signal(&transfer_completion_signal[i]); semaphore_release(&transfer_completion_signal[i]);
} }
} }
@ -945,7 +945,7 @@ static void transfer_completed(void)
} }
if(qh->wait) { if(qh->wait) {
qh->wait=0; qh->wait=0;
wakeup_signal(&transfer_completion_signal[pipe]); semaphore_release(&transfer_completion_signal[pipe]);
} }
usb_core_transfer_complete(ep, dir?USB_DIR_IN:USB_DIR_OUT, usb_core_transfer_complete(ep, dir?USB_DIR_IN:USB_DIR_OUT,

14
firmware/target/arm/usb-s3c6400x.c
View file

@ -44,7 +44,7 @@ struct ep_type
bool done; bool done;
int rc; int rc;
int size; int size;
struct wakeup complete; struct semaphore complete;
} ; } ;
static struct ep_type endpoints[USB_NUM_ENDPOINTS]; static struct ep_type endpoints[USB_NUM_ENDPOINTS];
@ -64,7 +64,7 @@ static void reset_endpoints(int reinit)
endpoints[i].busy = false; endpoints[i].busy = false;
endpoints[i].rc = -1; endpoints[i].rc = -1;
endpoints[i].done = true; endpoints[i].done = true;
wakeup_signal(&endpoints[i].complete); semaphore_release(&endpoints[i].complete);
} }
DIEPCTL0 = 0x8800; /* EP0 IN ACTIVE NEXT=1 */ DIEPCTL0 = 0x8800; /* EP0 IN ACTIVE NEXT=1 */
DOEPCTL0 = 0x8000; /* EP0 OUT ACTIVE */ DOEPCTL0 = 0x8000; /* EP0 OUT ACTIVE */
@ -201,7 +201,7 @@ void INT_USB_FUNC(void)
endpoints[i].rc = 0; endpoints[i].rc = 0;
endpoints[i].done = true; endpoints[i].done = true;
usb_core_transfer_complete(i, USB_DIR_IN, 0, bytes); usb_core_transfer_complete(i, USB_DIR_IN, 0, bytes);
wakeup_signal(&endpoints[i].complete); semaphore_release(&endpoints[i].complete);
} }
} }
if (epints & 4) /* AHB error */ if (epints & 4) /* AHB error */
@ -213,7 +213,7 @@ void INT_USB_FUNC(void)
endpoints[i].busy = false; endpoints[i].busy = false;
endpoints[i].rc = 1; endpoints[i].rc = 1;
endpoints[i].done = true; endpoints[i].done = true;
wakeup_signal(&endpoints[i].complete); semaphore_release(&endpoints[i].complete);
} }
} }
DIEPINT(i) = epints; DIEPINT(i) = epints;
@ -233,7 +233,7 @@ void INT_USB_FUNC(void)
endpoints[i].rc = 0; endpoints[i].rc = 0;
endpoints[i].done = true; endpoints[i].done = true;
usb_core_transfer_complete(i, USB_DIR_OUT, 0, bytes); usb_core_transfer_complete(i, USB_DIR_OUT, 0, bytes);
wakeup_signal(&endpoints[i].complete); semaphore_release(&endpoints[i].complete);
} }
} }
if (epints & 4) /* AHB error */ if (epints & 4) /* AHB error */
@ -325,7 +325,7 @@ int usb_drv_send(int endpoint, void *ptr, int length)
endpoints[endpoint].done = false; endpoints[endpoint].done = false;
ep_send(endpoint, ptr, length); ep_send(endpoint, ptr, length);
while (!endpoints[endpoint].done && endpoints[endpoint].busy) while (!endpoints[endpoint].done && endpoints[endpoint].busy)
wakeup_wait(&endpoints[endpoint].complete, TIMEOUT_BLOCK); semaphore_wait(&endpoints[endpoint].complete, TIMEOUT_BLOCK);
return endpoints[endpoint].rc; return endpoints[endpoint].rc;
} }
@ -412,7 +412,7 @@ void usb_init_device(void)
{ {
unsigned int i; unsigned int i;
for (i = 0; i < sizeof(endpoints)/sizeof(struct ep_type); i++) for (i = 0; i < sizeof(endpoints)/sizeof(struct ep_type); i++)
wakeup_init(&endpoints[i].complete); semaphore_init(&endpoints[i].complete, 1, 0);
/* Power up the core clocks to allow writing /* Power up the core clocks to allow writing
to some registers needed to power it down */ to some registers needed to power it down */

10
firmware/target/mips/ingenic_jz47xx/ata-nand-jz4740.c
View file

@ -117,7 +117,7 @@ static struct nand_param internal_param;
static struct mutex nand_mtx; static struct mutex nand_mtx;
#ifdef USE_DMA #ifdef USE_DMA
static struct mutex nand_dma_mtx; static struct mutex nand_dma_mtx;
static struct wakeup nand_wkup; static struct semaphore nand_dma_complete;
#endif #endif
static unsigned char temp_page[4096]; /* Max page size */ static unsigned char temp_page[4096]; /* Max page size */
@ -170,7 +170,7 @@ static void jz_nand_write_dma(void *source, unsigned int len, int bw)
yield(); yield();
#else #else
REG_DMAC_DCMD(DMA_NAND_CHANNEL) |= DMAC_DCMD_TIE; /* Enable DMA interrupt */ REG_DMAC_DCMD(DMA_NAND_CHANNEL) |= DMAC_DCMD_TIE; /* Enable DMA interrupt */
wakeup_wait(&nand_wkup, TIMEOUT_BLOCK); semaphore_wait(&nand_dma_complete, TIMEOUT_BLOCK);
#endif #endif
REG_DMAC_DCCSR(DMA_NAND_CHANNEL) &= ~DMAC_DCCSR_EN; /* Disable DMA channel */ REG_DMAC_DCCSR(DMA_NAND_CHANNEL) &= ~DMAC_DCCSR_EN; /* Disable DMA channel */
@ -202,7 +202,7 @@ static void jz_nand_read_dma(void *target, unsigned int len, int bw)
yield(); yield();
#else #else
REG_DMAC_DCMD(DMA_NAND_CHANNEL) |= DMAC_DCMD_TIE; /* Enable DMA interrupt */ REG_DMAC_DCMD(DMA_NAND_CHANNEL) |= DMAC_DCMD_TIE; /* Enable DMA interrupt */
wakeup_wait(&nand_wkup, TIMEOUT_BLOCK); semaphore_wait(&nand_dma_complete, TIMEOUT_BLOCK);
#endif #endif
//REG_DMAC_DCCSR(DMA_NAND_CHANNEL) &= ~DMAC_DCCSR_EN; /* Disable DMA channel */ //REG_DMAC_DCCSR(DMA_NAND_CHANNEL) &= ~DMAC_DCCSR_EN; /* Disable DMA channel */
@ -226,7 +226,7 @@ void DMA_CALLBACK(DMA_NAND_CHANNEL)(void)
if (REG_DMAC_DCCSR(DMA_NAND_CHANNEL) & DMAC_DCCSR_TT) if (REG_DMAC_DCCSR(DMA_NAND_CHANNEL) & DMAC_DCCSR_TT)
REG_DMAC_DCCSR(DMA_NAND_CHANNEL) &= ~DMAC_DCCSR_TT; REG_DMAC_DCCSR(DMA_NAND_CHANNEL) &= ~DMAC_DCCSR_TT;
wakeup_signal(&nand_wkup); semaphore_release(&nand_dma_complete);
} }
#endif /* USE_DMA */ #endif /* USE_DMA */
@ -603,7 +603,7 @@ int nand_init(void)
mutex_init(&nand_mtx); mutex_init(&nand_mtx);
#ifdef USE_DMA #ifdef USE_DMA
mutex_init(&nand_dma_mtx); mutex_init(&nand_dma_mtx);
wakeup_init(&nand_wkup); semaphore_init(&nand_dma_complete, 1, 0);
system_enable_irq(DMA_IRQ(DMA_NAND_CHANNEL)); system_enable_irq(DMA_IRQ(DMA_NAND_CHANNEL));
#endif #endif

12
firmware/target/mips/ingenic_jz47xx/ata-sd-jz4740.c
View file

@ -47,7 +47,7 @@ static long sd_stack[(DEFAULT_STACK_SIZE*2 + 0x1c0)/sizeof(long)];
static const char sd_thread_name[] = "ata/sd"; static const char sd_thread_name[] = "ata/sd";
static struct event_queue sd_queue; static struct event_queue sd_queue;
static struct mutex sd_mtx; static struct mutex sd_mtx;
static struct wakeup sd_wakeup; static struct semaphore sd_wakeup;
static void sd_thread(void) NORETURN_ATTR; static void sd_thread(void) NORETURN_ATTR;
static int use_4bit; static int use_4bit;
@ -831,7 +831,7 @@ static int jz_sd_exec_cmd(struct sd_request *request)
/* Wait for command completion */ /* Wait for command completion */
//__intc_unmask_irq(IRQ_MSC); //__intc_unmask_irq(IRQ_MSC);
//wakeup_wait(&sd_wakeup, 100); //semaphore_wait(&sd_wakeup, 100);
while (timeout-- && !(REG_MSC_STAT & MSC_STAT_END_CMD_RES)); while (timeout-- && !(REG_MSC_STAT & MSC_STAT_END_CMD_RES));
@ -881,7 +881,7 @@ static int jz_sd_exec_cmd(struct sd_request *request)
#endif #endif
} }
//__intc_unmask_irq(IRQ_MSC); //__intc_unmask_irq(IRQ_MSC);
//wakeup_wait(&sd_wakeup, 100); //semaphore_wait(&sd_wakeup, 100);
/* Wait for Data Done */ /* Wait for Data Done */
while (!(REG_MSC_IREG & MSC_IREG_DATA_TRAN_DONE)); while (!(REG_MSC_IREG & MSC_IREG_DATA_TRAN_DONE));
REG_MSC_IREG = MSC_IREG_DATA_TRAN_DONE; /* clear status */ REG_MSC_IREG = MSC_IREG_DATA_TRAN_DONE; /* clear status */
@ -891,7 +891,7 @@ static int jz_sd_exec_cmd(struct sd_request *request)
if (events & SD_EVENT_PROG_DONE) if (events & SD_EVENT_PROG_DONE)
{ {
//__intc_unmask_irq(IRQ_MSC); //__intc_unmask_irq(IRQ_MSC);
//wakeup_wait(&sd_wakeup, 100); //semaphore_wait(&sd_wakeup, 100);
while (!(REG_MSC_IREG & MSC_IREG_PRG_DONE)); while (!(REG_MSC_IREG & MSC_IREG_PRG_DONE));
REG_MSC_IREG = MSC_IREG_PRG_DONE; /* clear status */ REG_MSC_IREG = MSC_IREG_PRG_DONE; /* clear status */
} }
@ -945,7 +945,7 @@ static void jz_sd_rx_handler(unsigned int arg)
/* MSC interrupt handler */ /* MSC interrupt handler */
void MSC(void) void MSC(void)
{ {
//wakeup_signal(&sd_wakeup); //semaphore_release(&sd_wakeup);
logf("MSC interrupt"); logf("MSC interrupt");
} }
@ -1228,7 +1228,7 @@ int sd_init(void)
static bool inited = false; static bool inited = false;
if(!inited) if(!inited)
{ {
wakeup_init(&sd_wakeup); semaphore_init(&sd_wakeup, 1, 0);
mutex_init(&sd_mtx); mutex_init(&sd_mtx);
queue_init(&sd_queue, true); queue_init(&sd_queue, true);
create_thread(sd_thread, sd_stack, sizeof(sd_stack), 0, create_thread(sd_thread, sd_stack, sizeof(sd_stack), 0,

8
firmware/target/mips/ingenic_jz47xx/lcd-jz4740.c
View file

@ -34,7 +34,7 @@
static volatile bool lcd_is_on = false; static volatile bool lcd_is_on = false;
static struct mutex lcd_mtx; static struct mutex lcd_mtx;
static struct wakeup lcd_wkup; static struct semaphore lcd_wkup;
static int lcd_count = 0; static int lcd_count = 0;
void lcd_clock_enable(void) void lcd_clock_enable(void)
@ -56,7 +56,7 @@ void lcd_init_device(void)
lcd_is_on = true; lcd_is_on = true;
mutex_init(&lcd_mtx); mutex_init(&lcd_mtx);
wakeup_init(&lcd_wkup); semaphore_init(&lcd_wkup, 1, 0);
system_enable_irq(DMA_IRQ(DMA_LCD_CHANNEL)); system_enable_irq(DMA_IRQ(DMA_LCD_CHANNEL));
} }
@ -118,7 +118,7 @@ void lcd_update_rect(int x, int y, int width, int height)
REG_DMAC_DCCSR(DMA_LCD_CHANNEL) |= DMAC_DCCSR_EN; /* Enable DMA channel */ REG_DMAC_DCCSR(DMA_LCD_CHANNEL) |= DMAC_DCCSR_EN; /* Enable DMA channel */
REG_DMAC_DCMD(DMA_LCD_CHANNEL) |= DMAC_DCMD_TIE; /* Enable DMA interrupt */ REG_DMAC_DCMD(DMA_LCD_CHANNEL) |= DMAC_DCMD_TIE; /* Enable DMA interrupt */
wakeup_wait(&lcd_wkup, TIMEOUT_BLOCK); /* Sleeping in lcd_update() should be safe */ semaphore_wait(&lcd_wkup, TIMEOUT_BLOCK); /* Sleeping in lcd_update() should be safe */
REG_DMAC_DCCSR(DMA_LCD_CHANNEL) &= ~DMAC_DCCSR_EN; /* Disable DMA channel */ REG_DMAC_DCCSR(DMA_LCD_CHANNEL) &= ~DMAC_DCCSR_EN; /* Disable DMA channel */
dma_disable(); dma_disable();
@ -145,7 +145,7 @@ void DMA_CALLBACK(DMA_LCD_CHANNEL)(void)
if (REG_DMAC_DCCSR(DMA_LCD_CHANNEL) & DMAC_DCCSR_TT) if (REG_DMAC_DCCSR(DMA_LCD_CHANNEL) & DMAC_DCCSR_TT)
REG_DMAC_DCCSR(DMA_LCD_CHANNEL) &= ~DMAC_DCCSR_TT; REG_DMAC_DCCSR(DMA_LCD_CHANNEL) &= ~DMAC_DCCSR_TT;
wakeup_signal(&lcd_wkup); semaphore_release(&lcd_wkup);
} }
/* Update the display. /* Update the display.

8
firmware/target/mips/ingenic_jz47xx/onda_vx747/sadc-onda_vx747.c
View file

@ -74,7 +74,7 @@ static int datacount = 0;
static volatile int cur_touch = 0; static volatile int cur_touch = 0;
static volatile bool pen_down = false; static volatile bool pen_down = false;
static struct mutex battery_mtx; static struct mutex battery_mtx;
static struct wakeup battery_wkup; static struct semaphore battery_done;
const unsigned short battery_level_dangerous[BATTERY_TYPES_COUNT] = const unsigned short battery_level_dangerous[BATTERY_TYPES_COUNT] =
{ {
@ -113,7 +113,7 @@ unsigned int battery_adc_voltage(void)
REG_SADC_ENA |= SADC_ENA_PBATEN; REG_SADC_ENA |= SADC_ENA_PBATEN;
wakeup_wait(&battery_wkup, HZ/4); semaphore_wait(&battery_done, HZ/4);
bat_val = REG_SADC_BATDAT; bat_val = REG_SADC_BATDAT;
logf("%d %d", bat_val, (bat_val * BATTERY_SCALE_FACTOR) / 4096); logf("%d %d", bat_val, (bat_val * BATTERY_SCALE_FACTOR) / 4096);
@ -268,7 +268,7 @@ void SADC(void)
if(state & SADC_CTRL_PBATRDYM) if(state & SADC_CTRL_PBATRDYM)
{ {
/* Battery AD IRQ */ /* Battery AD IRQ */
wakeup_signal(&battery_wkup); semaphore_release(&battery_done);
} }
} }
@ -290,7 +290,7 @@ void adc_init(void)
REG_SADC_ENA = SADC_ENA_TSEN; REG_SADC_ENA = SADC_ENA_TSEN;
mutex_init(&battery_mtx); mutex_init(&battery_mtx);
wakeup_init(&battery_wkup); semaphore_init(&battery_done, 1, 0);
} }
void adc_close(void) void adc_close(void)

8
firmware/target/mips/ingenic_jz47xx/usb-jz4740.c
View file

@ -69,7 +69,7 @@ struct usb_endpoint
unsigned short fifo_size; unsigned short fifo_size;
bool wait; bool wait;
struct wakeup wakeup; struct semaphore complete;
}; };
static unsigned char ep0_rx_buf[64]; static unsigned char ep0_rx_buf[64];
@ -171,7 +171,7 @@ static inline void ep_transfer_completed(struct usb_endpoint* ep)
ep->buf = NULL; ep->buf = NULL;
ep->busy = false; ep->busy = false;
if(ep->wait) if(ep->wait)
wakeup_signal(&ep->wakeup); semaphore_release(&ep->complete);
} }
static void EP0_send(void) static void EP0_send(void)
@ -598,7 +598,7 @@ void usb_init_device(void)
system_enable_irq(IRQ_UDC); system_enable_irq(IRQ_UDC);
for(i=0; i<TOTAL_EP(); i++) for(i=0; i<TOTAL_EP(); i++)
wakeup_init(&endpoints[i].wakeup); semaphore_init(&endpoints[i].complete, 1, 0);
} }
#ifdef USB_GPIO_IRQ #ifdef USB_GPIO_IRQ
@ -715,7 +715,7 @@ static void usb_drv_send_internal(struct usb_endpoint* ep, void* ptr, int length
if(blocking) if(blocking)
{ {
wakeup_wait(&ep->wakeup, TIMEOUT_BLOCK); semaphore_wait(&ep->complete, TIMEOUT_BLOCK);
ep->wait = false; ep->wait = false;
} }
} }