@@ -19,6 +19,7 @@
#ifndef _SYNC_H
#define _SYNC_H
+#include <dspbridge/errbase.h>
#define SIGNATURECS 0x53435953 /* "SYCS" (in reverse) */
#define SIGNATUREDPCCS 0x53445953 /* "SYDS" (in reverse) */
@@ -28,8 +29,16 @@
/* Maximum string length of a named event */
#define SYNC_MAXNAMELENGTH 32
-/* Generic SYNC object: */
-struct sync_object;
+/**
+ * struct sync_object - the basic sync_object structure
+ * @comp: use to signal events
+ * @multi_comp: use to signal multiple events.
+ *
+ */
+struct sync_object{
+ struct completion comp;
+ struct completion *multi_comp;
+};
/* Generic SYNC CS object: */
struct sync_csobject {
@@ -46,25 +55,6 @@ struct sync_attrs {
};
/*
- * ======== sync_close_event ========
- * Purpose:
- * Close this event handle, freeing resources allocated in sync_open_event
- * if necessary.
- * Parameters:
- * event_obj: Handle to a synchronization event, created/opened in
- * sync_open_event.
- * Returns:
- * DSP_SOK: Success;
- * DSP_EFAIL: Failed to close event handle.
- * DSP_EHANDLE: Invalid handle.
- * Requires:
- * SYNC initialized.
- * Ensures:
- * Any subsequent usage of event_obj would be invalid.
- */
-extern dsp_status sync_close_event(IN struct sync_object *event_obj);
-
-/*
* ======== sync_delete_cs ========
* Purpose:
* Delete a critical section.
@@ -162,39 +152,18 @@ extern dsp_status sync_initialize_dpccs(OUT struct sync_csobject
*/
extern dsp_status sync_leave_cs(IN struct sync_csobject *hcs_obj);
-/*
- * ======== sync_open_event ========
- * Purpose:
- * Create/open and initialize an event object for thread synchronization,
- * which is initially in the non-signalled state.
- * Parameters:
- * ph_event: Pointer to location to receive the event object handle.
- * pattrs: Pointer to sync_attrs object containing initial SYNC
- * sync_object attributes. If this pointer is NULL, then
- * sync_open_event will create and manage an OS specific
- * syncronization object.
- * pattrs->user_event: Platform's User Mode synchronization object.
- *
- * The behaviour of the SYNC methods depend on the value of
- * the user_event attr:
+/**
+ * sync_init_event() - set initial state for a sync_event element
+ * @event: event to be initialized.
*
- * 1. (user_event == NULL):
- * A user mode event is created.
- * 2. (user_event != NULL):
- * A user mode event is supplied by the caller of sync_open_event().
- * Returns:
- * DSP_SOK: Success.
- * DSP_EFAIL: Unable to create user mode event.
- * DSP_EMEMORY: Insufficient memory.
- * DSP_EINVALIDARG sync_attrs values are invalid.
- * Requires:
- * - SYNC initialized.
- * - ph_event != NULL.
- * Ensures:
- * If function succeeded, event->event_obj must be a valid event handle.
+ * Set the initial state for a sync_event element.
*/
-extern dsp_status sync_open_event(OUT struct sync_object **ph_event,
- IN OPTIONAL struct sync_attrs *pattrs);
+
+static inline void sync_init_event(struct sync_object *event)
+{
+ init_completion(&event->comp);
+ event->multi_comp = NULL;
+}
/*
* ========= sync_post_message ========
@@ -213,91 +182,61 @@ extern dsp_status sync_open_event(OUT struct sync_object **ph_event,
*/
extern dsp_status sync_post_message(IN bhandle hWindow, IN u32 uMsg);
-/*
- * ======== sync_reset_event ========
- * Purpose:
- * Reset a syncronization event object state to non-signalled.
- * Parameters:
- * event_obj: Handle to a sync event.
- * Returns:
- * DSP_SOK: Success;
- * DSP_EFAIL: Failed to reset event.
- * DSP_EHANDLE: Invalid handle.
- * Requires:
- * SYNC initialized.
- * Ensures:
+/**
+ * sync_reset_event() - reset a sync_event element
+ * @event: event to be reset.
+ *
+ * This function reset to the initial state to @event.
*/
-extern dsp_status sync_reset_event(IN struct sync_object *event_obj);
-/*
- * ======== sync_set_event ========
- * Purpose:
- * Signal the event. Will unblock one waiting thread.
- * Parameters:
- * event_obj: Handle to an event object.
- * Returns:
- * DSP_SOK: Success.
- * DSP_EFAIL: Failed to signal event.
- * DSP_EHANDLE: Invalid handle.
- * Requires:
- * SYNC initialized.
- * Ensures:
+static inline void sync_reset_event(struct sync_object *event)
+{
+ INIT_COMPLETION(event->comp);
+ event->multi_comp = NULL;
+}
+
+/**
+ * sync_set_event() - set or signal and specified event
+ * @event: Event to be set..
+ *
+ * set the @event, if there is an thread waiting for the event
+ * it will be waken up, this function only wakes one thread.
*/
-extern dsp_status sync_set_event(IN struct sync_object *event_obj);
-/*
- * ======== sync_wait_on_event ========
- * Purpose:
- * Wait for an event to be signalled, up to the specified timeout.
- * Parameters:
- * event_obj: Handle to an event object.
- * dwTimeOut: The time-out interval, in milliseconds.
- * The function returns if the interval elapses, even if
- * the object's state is nonsignaled.
- * If zero, the function tests the object's state and
- * returns immediately.
- * If SYNC_INFINITE, the function's time-out interval
- * never elapses.
- * Returns:
- * DSP_SOK: The object was signalled.
- * DSP_EHANDLE: Invalid handle.
- * SYNC_E_FAIL: Wait failed, possibly because the process terminated.
- * SYNC_E_TIMEOUT: Timeout expired while waiting for event to be signalled.
- * Requires:
- * Ensures:
+void sync_set_event(struct sync_object *event);
+
+/**
+ * sync_wait_on_event() - waits for a event to be set.
+ * @event: events to wait for it.
+ * @timeout timeout on waiting for the evetn.
+ *
+ * This functios will wait until @event is set or until timeout. In case of
+ * success the function will return DSP_SOK and
+ * in case of timeout the function will return DSP_ETIMEOUT
*/
-extern dsp_status sync_wait_on_event(IN struct sync_object *event_obj,
- IN u32 dwTimeOut);
-/*
- * ======== sync_wait_on_multiple_events ========
- * Purpose:
- * Wait for any of an array of events to be signalled, up to the
- * specified timeout.
- * Note: dwTimeOut must be SYNC_INFINITE to signal infinite wait.
- * Parameters:
- * sync_events: Array of handles to event objects.
- * count: Number of event handles.
- * dwTimeOut: The time-out interval, in milliseconds.
- * The function returns if the interval elapses, even if
- * no event is signalled.
- * If zero, the function tests the object's state and
- * returns immediately.
- * If SYNC_INFINITE, the function's time-out interval
- * never elapses.
- * pu_index: Location to store index of event that was signalled.
- * Returns:
- * DSP_SOK: The object was signalled.
- * SYNC_E_FAIL: Wait failed, possibly because the process terminated.
- * SYNC_E_TIMEOUT: Timeout expired before event was signalled.
- * DSP_EMEMORY: Memory allocation failed.
- * Requires:
- * Ensures:
+static inline dsp_status sync_wait_on_event(struct sync_object *event,
+ unsigned timeout)
+{
+ return wait_for_completion_timeout(&event->comp,
+ msecs_to_jiffies(timeout)) ? DSP_SOK : DSP_ETIMEOUT;
+}
+
+/**
+ * sync_wait_on_multiple_events() - waits for multiple events to be set.
+ * @events: Array of events to wait for them.
+ * @count: number of elements of the array.
+ * @timeout timeout on waiting for the evetns.
+ * @pu_index index of the event set.
+ *
+ * This functios will wait until any of the array element is set or until
+ * timeout. In case of success the function will return DSP_SOK and
+ * @pu_index will store the index of the array element set and in case
+ * of timeout the function will return DSP_ETIMEOUT.
*/
-extern dsp_status sync_wait_on_multiple_events(IN struct sync_object
- **sync_events,
- IN u32 count,
- IN u32 dwTimeout,
- OUT u32 *pu_index);
+
+dsp_status sync_wait_on_multiple_events(struct sync_object **events,
+ unsigned count, unsigned timeout,
+ unsigned *index);
#endif /* _SYNC_H */
@@ -515,7 +515,13 @@ func_cont:
if (DSP_SUCCEEDED(status) && (node_type != NODE_DEVICE)) {
/* Create an event that will be posted when RMS_EXIT is
* received. */
- status = sync_open_event(&pnode->sync_done, NULL);
+ pnode->sync_done = kzalloc(sizeof(struct sync_object),
+ GFP_KERNEL);
+ if (pnode->sync_done)
+ sync_init_event(pnode->sync_done);
+ else
+ status = DSP_EMEMORY;
+
if (DSP_SUCCEEDED(status)) {
/*Get the shared mem mgr for this nodes dev object */
status = cmm_get_handle(hprocessor, &hcmm_mgr);
@@ -2533,8 +2539,8 @@ static void delete_node(struct node_object *hnode,
msg_queue_obj);
hnode->msg_queue_obj = NULL;
}
- if (hnode->sync_done)
- (void)sync_close_event(hnode->sync_done);
+
+ kfree(hnode->sync_done);
/* Free all stream info */
if (hnode->inputs) {
@@ -789,8 +789,8 @@ dsp_status strm_select(IN struct strm_object **strm_tab, u32 nStrms,
if (DSP_SUCCEEDED(status) && utimeout > 0 && *pmask == 0) {
/* Non-zero timeout */
sync_events = (struct sync_object **)mem_alloc(nStrms *
- sizeof(struct sync_object *),
- MEM_PAGED);
+ sizeof(struct sync_object *), MEM_PAGED);
+
if (sync_events == NULL) {
status = DSP_EMEMORY;
} else {
@@ -201,7 +201,6 @@ dsp_status ntfy_register(struct ntfy_object *ntfy_obj,
u32 event_mask, u32 notify_type)
{
struct notifier *notifier_obj;
- struct sync_attrs sync_attrs_obj;
dsp_status status = DSP_SOK;
DBC_REQUIRE(MEM_IS_VALID_HANDLE(ntfy_obj, NTFY_SIGNATURE));
@@ -251,9 +250,14 @@ dsp_status ntfy_register(struct ntfy_object *ntfy_obj,
lst_init_elem((struct list_head *)notifier_obj);
/* If there is more than one notification type, each
* type may require its own handler code. */
- status =
- sync_open_event(¬ifier_obj->sync_obj,
- &sync_attrs_obj);
+ notifier_obj->sync_obj = kzalloc(
+ sizeof(struct sync_object), GFP_KERNEL);
+
+ if (notifier_obj->sync_obj)
+ sync_init_event(notifier_obj->sync_obj);
+ else
+ status = DSP_EMEMORY;
+
hnotification->handle = notifier_obj->sync_obj;
if (DSP_SUCCEEDED(status)) {
@@ -288,9 +292,7 @@ dsp_status ntfy_register(struct ntfy_object *ntfy_obj,
*/
static void delete_notify(struct notifier *notifier_obj)
{
- if (notifier_obj->sync_obj)
- (void)sync_close_event(notifier_obj->sync_obj);
-
+ kfree(notifier_obj->sync_obj);
kfree(notifier_obj->pstr_name);
kfree(notifier_obj);
@@ -33,6 +33,8 @@
/* ----------------------------------- This */
#include <dspbridge/sync.h>
+DEFINE_SPINLOCK(sync_lock);
+
/* ----------------------------------- Defines, Data Structures, Typedefs */
#define SIGNATURE 0x434e5953 /* "SYNC" (in reverse) */
@@ -52,14 +54,6 @@ struct wait_object {
struct semaphore sem;
};
-/* Generic SYNC object: */
-struct sync_object {
- u32 dw_signature; /* Used for object validation. */
- enum sync_state state;
- spinlock_t sync_lock;
- struct wait_object *wait_obj;
-};
-
struct sync_dpccsobject {
u32 dw_signature; /* used for object validation */
spinlock_t sync_dpccs_lock;
@@ -76,31 +70,6 @@ static int test_and_set(volatile void *ptr, int val)
static void timeout_callback(unsigned long hWaitObj);
/*
- * ======== sync_close_event ========
- * Purpose:
- * Close an existing SYNC event object.
- */
-dsp_status sync_close_event(struct sync_object *event_obj)
-{
- dsp_status status = DSP_SOK;
- struct sync_object *event = (struct sync_object *)event_obj;
-
- DBC_REQUIRE(event != NULL && event->wait_obj == NULL);
-
- if (MEM_IS_VALID_HANDLE(event_obj, SIGNATURE)) {
- if (event->wait_obj)
- status = DSP_EFAIL;
-
- MEM_FREE_OBJECT(event);
-
- } else {
- status = DSP_EHANDLE;
- }
-
- return status;
-}
-
-/*
* ======== sync_exit ========
* Purpose:
* Cleanup SYNC module.
@@ -120,190 +89,84 @@ bool sync_init(void)
return true;
}
-/*
- * ======== sync_open_event ========
- * Purpose:
- * Open a new synchronization event object.
+/**
+ * sync_set_event() - set or signal and specified event
+ * @event: Event to be set..
+ *
+ * set the @event, if there is an thread waiting for the event
+ * it will be waken up, this function only wakes one thread.
*/
-dsp_status sync_open_event(OUT struct sync_object **ph_event,
- IN OPTIONAL struct sync_attrs *pattrs)
-{
- struct sync_object *event = NULL;
- dsp_status status = DSP_SOK;
-
- DBC_REQUIRE(ph_event != NULL);
-
- /* Allocate memory for sync object */
- MEM_ALLOC_OBJECT(event, struct sync_object, SIGNATURE);
- if (event != NULL) {
- event->state = SO_RESET;
- event->wait_obj = NULL;
- spin_lock_init(&event->sync_lock);
- } else {
- status = DSP_EMEMORY;
- }
-
- *ph_event = event;
- return status;
-}
-
-/*
- * ======== sync_reset_event ========
- * Purpose:
- * Reset an event to non-signalled.
- */
-dsp_status sync_reset_event(struct sync_object *event_obj)
+void sync_set_event(struct sync_object *event)
{
- dsp_status status = DSP_SOK;
- struct sync_object *event = (struct sync_object *)event_obj;
-
- if (MEM_IS_VALID_HANDLE(event_obj, SIGNATURE))
- event->state = SO_RESET;
- else
- status = DSP_EHANDLE;
-
- return status;
+ spin_lock_bh(&sync_lock);
+ complete(&event->comp);
+ if (event->multi_comp)
+ complete(event->multi_comp);
+ spin_unlock_bh(&sync_lock);
}
-/*
- * ======== sync_set_event ========
- * Purpose:
- * Set an event to signaled and unblock one waiting thread.
+/**
+ * sync_wait_on_multiple_events() - waits for multiple events to be set.
+ * @events: Array of events to wait for them.
+ * @count: number of elements of the array.
+ * @timeout timeout on waiting for the evetns.
+ * @pu_index index of the event set.
*
- * This function is called from ISR, DPC and user context. Hence interrupts
- * are disabled to ensure atomicity.
+ * This functios will wait until any of the array element is set or until
+ * timeout. In case of success the function will return DSP_SOK and
+ * @pu_index will store the index of the array element set or in case
+ * of timeout the function will return DSP_ETIMEOUT or in case of
+ * interrupting by a signal it will return DSP_EFAIL.
*/
-dsp_status sync_set_event(struct sync_object *event_obj)
+dsp_status sync_wait_on_multiple_events(struct sync_object **events,
+ unsigned count, unsigned timeout,
+ unsigned *index)
{
- dsp_status status = DSP_SOK;
- struct sync_object *event = (struct sync_object *)event_obj;
- unsigned long flags;
-
- if (MEM_IS_VALID_HANDLE(event_obj, SIGNATURE)) {
- spin_lock_irqsave(&event_obj->sync_lock, flags);
-
- if (event->wait_obj != NULL &&
- test_and_set(&event->wait_obj->state,
- WO_SIGNALLED) == WO_WAITING) {
- event->state = SO_RESET;
- event->wait_obj->signalling_event = event;
- up(&event->wait_obj->sem);
- } else {
- event->state = SO_SIGNALLED;
+ unsigned i;
+ dsp_status status = DSP_EFAIL;
+ struct completion *m_comp;
+
+ m_comp = kmalloc(sizeof(struct completion), GFP_KERNEL);
+ if (!m_comp) {
+ status = DSP_EMEMORY;
+ goto func_end;
+ }
+ init_completion(m_comp);
+
+ spin_lock_bh(&sync_lock);
+ for (i = 0; i < count; i++) {
+ if (completion_done(&events[i]->comp)) {
+ INIT_COMPLETION(events[i]->comp);
+ *index = i;
+ spin_unlock_bh(&sync_lock);
+ status = DSP_SOK;
+ goto func_end;
}
- spin_unlock_irqrestore(&event_obj->sync_lock, flags);
- } else {
- status = DSP_EHANDLE;
}
- return status;
-}
-
-/*
- * ======== sync_wait_on_event ========
- * Purpose:
- * Wait for an event to be signalled, up to the specified timeout.
- * Note: dwTimeOut must be 0xffffffff to signal infinite wait.
- */
-dsp_status sync_wait_on_event(struct sync_object *event_obj, u32 dwTimeout)
-{
- dsp_status status = DSP_SOK;
- struct sync_object *event = (struct sync_object *)event_obj;
- u32 temp;
- if (MEM_IS_VALID_HANDLE(event_obj, SIGNATURE))
- status = sync_wait_on_multiple_events(&event, 1, dwTimeout,
- &temp);
- else
- status = DSP_EHANDLE;
-
- return status;
-}
-
-/*
- * ======== sync_wait_on_multiple_events ========
- * Purpose:
- * Wait for any of an array of events to be signalled, up to the
- * specified timeout.
- */
-dsp_status sync_wait_on_multiple_events(struct sync_object **sync_events,
- u32 count, u32 dwTimeout,
- OUT u32 *pu_index)
-{
- u32 i;
- dsp_status status = DSP_SOK;
- u32 curr;
- struct wait_object *wp;
+ for (i = 0; i < count; i++)
+ events[i]->multi_comp = m_comp;
- DBC_REQUIRE(count > 0);
- DBC_REQUIRE(sync_events != NULL);
- DBC_REQUIRE(pu_index != NULL);
+ spin_unlock_bh(&sync_lock);
- for (i = 0; i < count; i++)
- DBC_REQUIRE(MEM_IS_VALID_HANDLE(sync_events[i], SIGNATURE));
-
- wp = mem_calloc(sizeof(struct wait_object), MEM_NONPAGED);
- if (wp == NULL)
- return DSP_EMEMORY;
-
- wp->state = WO_WAITING;
- wp->signalling_event = NULL;
- init_MUTEX_LOCKED(&(wp->sem));
-
- for (curr = 0; curr < count; curr++) {
- sync_events[curr]->wait_obj = wp;
- if (sync_events[curr]->state == SO_SIGNALLED) {
- if (test_and_set(&(wp->state), WO_SIGNALLED) ==
- WO_WAITING) {
- sync_events[curr]->state = SO_RESET;
- wp->signalling_event = sync_events[curr];
- }
- curr++; /* Will try optimizing later */
- break;
- }
- }
+ if (!wait_for_completion_interruptible_timeout(m_comp,
+ msecs_to_jiffies(timeout)))
+ status = DSP_ETIMEOUT;
- curr--; /* Will try optimizing later */
- if (wp->state != WO_SIGNALLED && dwTimeout > 0) {
- struct timer_list timeout;
- if (dwTimeout != SYNC_INFINITE) {
- init_timer_on_stack(&timeout);
- timeout.function = timeout_callback;
- timeout.data = (unsigned long)wp;
- timeout.expires = jiffies + dwTimeout * HZ / 1000;
- add_timer(&timeout);
- }
- if (down_interruptible(&(wp->sem))) {
- /*
- * Most probably we are interrupted by a fake signal
- * from freezer. Return -ERESTARTSYS so that this
- * ioctl is restarted, and user space doesn't notice
- * it.
- */
- status = -ERESTARTSYS;
- }
- if (dwTimeout != SYNC_INFINITE) {
- if (in_interrupt()) {
- del_timer(&timeout);
- } else {
- del_timer_sync(&timeout);
- }
+ spin_lock_bh(&sync_lock);
+ for (i = 0; i < count; i++) {
+ if (completion_done(&events[i]->comp)) {
+ INIT_COMPLETION(events[i]->comp);
+ *index = i;
+ status = DSP_SOK;
}
+ events[i]->multi_comp = NULL;
}
- for (i = 0; i <= curr; i++) {
- if (MEM_IS_VALID_HANDLE(sync_events[i], SIGNATURE)) {
- /* Memory corruption here if sync_events[i] is
- * freed before following statememt. */
- sync_events[i]->wait_obj = NULL;
- }
- if (sync_events[i] == wp->signalling_event)
- *pu_index = i;
-
- }
- if (wp->signalling_event == NULL && DSP_SUCCEEDED(status))
- status = DSP_ETIMEOUT;
- kfree(wp);
+ spin_unlock_bh(&sync_lock);
+ kfree(m_comp);
+func_end:
return status;
}
@@ -353,7 +353,7 @@ func_cont:
* context.). */
if (pchnl->sync_event) {
sync_reset_event(pchnl->sync_event);
- sync_close_event(pchnl->sync_event);
+ kfree(pchnl->sync_event);
pchnl->sync_event = NULL;
}
/* Free I/O request and I/O completion queues: */
@@ -789,7 +789,6 @@ dsp_status bridge_chnl_open(OUT struct chnl_object **phChnl,
dsp_status status = DSP_SOK;
struct chnl_mgr *chnl_mgr_obj = hchnl_mgr;
struct chnl_object *pchnl = NULL;
- struct sync_attrs *sync_attr_obj = NULL;
struct sync_object *sync_event = NULL;
/* Ensure DBC requirements: */
DBC_REQUIRE(phChnl != NULL);
@@ -835,7 +834,12 @@ dsp_status bridge_chnl_open(OUT struct chnl_object **phChnl,
pchnl->chnl_packets = pattrs->uio_reqs;
pchnl->cio_cs = 0;
pchnl->cio_reqs = 0;
- status = sync_open_event(&sync_event, sync_attr_obj);
+ sync_event = kzalloc(sizeof(struct sync_object), GFP_KERNEL);
+ if (sync_event)
+ sync_init_event(sync_event);
+ else
+ status = DSP_EMEMORY;
+
if (DSP_SUCCEEDED(status))
status = ntfy_create(&pchnl->ntfy_obj);
@@ -874,10 +878,9 @@ dsp_status bridge_chnl_open(OUT struct chnl_object **phChnl,
free_chirp_list(pchnl->free_packets_list);
pchnl->free_packets_list = NULL;
}
- if (sync_event) {
- sync_close_event(sync_event);
- sync_event = NULL;
- }
+ kfree(sync_event);
+ sync_event = NULL;
+
if (pchnl->ntfy_obj) {
ntfy_delete(pchnl->ntfy_obj);
pchnl->ntfy_obj = NULL;
@@ -100,7 +100,12 @@ dsp_status bridge_msg_create(OUT struct msg_mgr **phMsgMgr,
/* Create an event to be used by bridge_msg_put() in waiting
* for an available free frame from the message manager. */
- status = sync_open_event(&msg_mgr_obj->sync_event, NULL);
+ msg_mgr_obj->sync_event =
+ kzalloc(sizeof(struct sync_object), GFP_KERNEL);
+ if (!msg_mgr_obj->sync_event)
+ status = DSP_EMEMORY;
+ else
+ sync_init_event(msg_mgr_obj->sync_event);
if (DSP_SUCCEEDED(status))
*phMsgMgr = msg_mgr_obj;
@@ -160,8 +165,14 @@ dsp_status bridge_msg_create_queue(struct msg_mgr *hmsg_mgr,
/* Create event that will be signalled when a message from
* the DSP is available. */
- if (DSP_SUCCEEDED(status))
- status = sync_open_event(&msg_q->sync_event, NULL);
+ if (DSP_SUCCEEDED(status)) {
+ msg_q->sync_event = kzalloc(sizeof(struct sync_object),
+ GFP_KERNEL);
+ if (msg_q->sync_event)
+ sync_init_event(msg_q->sync_event);
+ else
+ status = DSP_EMEMORY;
+ }
/* Create a notification list for message ready notification. */
if (DSP_SUCCEEDED(status))
@@ -172,11 +183,23 @@ dsp_status bridge_msg_create_queue(struct msg_mgr *hmsg_mgr,
* unblock threads in MSG_Put() or MSG_Get(). sync_done_ack
* will be set by the unblocked thread to signal that it
* is unblocked and will no longer reference the object. */
- if (DSP_SUCCEEDED(status))
- status = sync_open_event(&msg_q->sync_done, NULL);
+ if (DSP_SUCCEEDED(status)) {
+ msg_q->sync_done = kzalloc(sizeof(struct sync_object),
+ GFP_KERNEL);
+ if (msg_q->sync_event)
+ sync_init_event(msg_q->sync_event);
+ else
+ status = DSP_EMEMORY;
+ }
- if (DSP_SUCCEEDED(status))
- status = sync_open_event(&msg_q->sync_done_ack, NULL);
+ if (DSP_SUCCEEDED(status)) {
+ msg_q->sync_done_ack = kzalloc(sizeof(struct sync_object),
+ GFP_KERNEL);
+ if (msg_q->sync_event)
+ sync_init_event(msg_q->sync_done_ack);
+ else
+ status = DSP_EMEMORY;
+ }
if (DSP_SUCCEEDED(status)) {
/* Enter critical section */
@@ -573,8 +596,7 @@ static void delete_msg_mgr(struct msg_mgr *hmsg_mgr)
hmsg_mgr->msg_used_list = NULL;
}
- if (hmsg_mgr->sync_event)
- sync_close_event(hmsg_mgr->sync_event);
+ kfree(hmsg_mgr->sync_event);
MEM_FREE_OBJECT(hmsg_mgr);
func_end:
@@ -622,14 +644,9 @@ static void delete_msg_queue(struct msg_queue *msg_queue_obj, u32 uNumToDSP)
if (msg_queue_obj->ntfy_obj)
ntfy_delete(msg_queue_obj->ntfy_obj);
- if (msg_queue_obj->sync_event)
- sync_close_event(msg_queue_obj->sync_event);
-
- if (msg_queue_obj->sync_done)
- sync_close_event(msg_queue_obj->sync_done);
-
- if (msg_queue_obj->sync_done_ack)
- sync_close_event(msg_queue_obj->sync_done_ack);
+ kfree(msg_queue_obj->sync_event);
+ kfree(msg_queue_obj->sync_done);
+ kfree(msg_queue_obj->sync_done_ack);
MEM_FREE_OBJECT(msg_queue_obj);
func_end: