dect
/
libdect
Archived
13
0
Fork 0
Code Releases Activity

libdect: name timer related functions more consistently 

Signed-off-by: Patrick McHardy <kaber@trash.net>
This commit is contained in:
Patrick McHardy 2010-08-02 05:21:45 +02:00
parent 35dfe2ac3f
commit 3d125cbc83
10 changed files with 61 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
example/cc.c
View File

@ -54,8 +54,8 @@ static void dect_mncc_timer_schedule(struct dect_handle *dh, struct dect_call *c
{
struct call *priv = dect_call_priv(call);
dect_setup_timer(priv->timer, dect_mncc_timer, call);
dect_start_timer(dh, priv->timer, 1);
dect_timer_setup(priv->timer, dect_mncc_timer, call);
dect_timer_start(dh, priv->timer, 1);
}
static void dect_mncc_timer(struct dect_handle *dh, struct dect_timer *timer)
@ -102,7 +102,7 @@ static void dect_mncc_setup_ind(struct dect_handle *dh, struct dect_call *call,
dect_ie_init(&signal);
signal.code = DECT_SIGNAL_DIAL_TONE_ON;
priv->timer = dect_alloc_timer(dh);
priv->timer = dect_timer_alloc(dh);
priv->keybuf = dect_keypad_buffer_init(dh, 3, dect_keypad_complete, call);
priv->audio = dect_audio_open();
@ -181,8 +181,8 @@ static void dect_mncc_info_timer_schedule(struct dect_handle *dh, struct dect_ca
{
struct call *priv = dect_call_priv(call);
dect_setup_timer(priv->timer, dect_mncc_info_timer, call);
dect_start_timer(dh, priv->timer, 1);
dect_timer_setup(priv->timer, dect_mncc_info_timer, call);
dect_timer_start(dh, priv->timer, 1);
}
static void dect_mncc_info_timer(struct dect_handle *dh, struct dect_timer *timer)
@ -205,7 +205,7 @@ static void dect_mncc_reject_ind(struct dect_handle *dh, struct dect_call *call,
{
struct call *priv = dect_call_priv(call);
dect_stop_timer(dh, priv->timer);
dect_timer_stop(dh, priv->timer);
}
static void dect_mncc_release_ind(struct dect_handle *dh, struct dect_call *call,

2
example/event_ops.c
View File

@ -48,7 +48,7 @@ static void unregister_fd(const struct dect_handle *dh, struct dect_fd *dfd)
static void event_timer_callback(int fd, short mask, void *data)
{
dect_run_timer(dh, data);
dect_timer_run(dh, data);
}
static void start_timer(const struct dect_handle *dh,

10
example/hijack.c
View File

@ -88,7 +88,7 @@ static void dect_build_msg(struct dect_msg_buf *mb, uint8_t sn, uint8_t cn)
static void page_timer(struct dect_handle *dh, struct dect_timer *timer)
{
dect_lce_group_ring_req(dh, 0);
dect_start_timer(dh, timer, 1);
dect_timer_start(dh, timer, 1);
}
static struct dect_ops ops = {
@ -120,15 +120,15 @@ int main(int argc, char **argv)
if (dect_register_fd(dh, dfd, DECT_FD_WRITE) < 0)
pexit("dect_register_fd");
timer = dect_alloc_timer(dh);
timer = dect_timer_alloc(dh);
if (timer == NULL)
pexit("dect_alloc_timer");
dect_setup_timer(timer, page_timer, NULL);
dect_start_timer(dh, timer, 1);
dect_timer_setup(timer, page_timer, NULL);
dect_timer_start(dh, timer, 1);
dect_event_loop();
dect_stop_timer(dh, timer);
dect_timer_stop(dh, timer);
dect_unregister_fd(dh, dfd);
dect_close(dh, dfd);

2
include/dect/libdect.h
View File

@ -96,7 +96,7 @@ extern void dect_handle_fd(struct dect_handle *dh, struct dect_fd *dfd,
struct dect_timer;
extern void *dect_timer_priv(struct dect_timer *timer);
extern void dect_run_timer(struct dect_handle *dh, struct dect_timer *timer);
extern void dect_timer_run(struct dect_handle *dh, struct dect_timer *timer);
/** @} */

8
include/timer.h
View File

@ -32,13 +32,13 @@ struct dect_timer {
uint8_t priv[] __aligned(__alignof__(uint64_t));
};
extern struct dect_timer *dect_alloc_timer(const struct dect_handle *dh);
extern void dect_setup_timer(struct dect_timer *timer,
extern struct dect_timer *dect_timer_alloc(const struct dect_handle *dh);
extern void dect_timer_setup(struct dect_timer *timer,
void (*cb)(struct dect_handle *, struct dect_timer *),
void *data);
extern void dect_start_timer(const struct dect_handle *dh,
extern void dect_timer_start(const struct dect_handle *dh,
struct dect_timer *timer, unsigned int timeout);
extern void dect_stop_timer(const struct dect_handle *dh, struct dect_timer *timer);
extern void dect_timer_stop(const struct dect_handle *dh, struct dect_timer *timer);
extern bool dect_timer_running(const struct dect_timer *timer);
#endif /* _LIBDECT_TIMER_H */

14
src/cc.c
View File

@ -464,7 +464,7 @@ struct dect_call *dect_call_alloc(const struct dect_handle *dh)
if (call == NULL)
goto err1;
call->setup_timer = dect_alloc_timer(dh);
call->setup_timer = dect_timer_alloc(dh);
if (call->setup_timer == NULL)
goto err2;
@ -482,7 +482,7 @@ static void dect_call_destroy(const struct dect_handle *dh,
struct dect_call *call)
{
if (call->state == DECT_CC_CALL_PRESENT)
dect_stop_timer(dh, call->setup_timer);
dect_timer_stop(dh, call->setup_timer);
dect_free(dh, call->setup_timer);
dect_free(dh, call);
}
@ -577,8 +577,8 @@ int dect_mncc_setup_req(struct dect_handle *dh, struct dect_call *call,
goto err2;
call->state = DECT_CC_CALL_PRESENT;
dect_setup_timer(call->setup_timer, dect_cc_setup_timer, call);
dect_start_timer(dh, call->setup_timer, DECT_CC_SETUP_TIMEOUT);
dect_timer_setup(call->setup_timer, dect_cc_setup_timer, call);
dect_timer_start(dh, call->setup_timer, DECT_CC_SETUP_TIMEOUT);
return 0;
err2:
@ -1080,7 +1080,7 @@ static void dect_cc_rcv_alerting(struct dect_handle *dh, struct dect_call *call,
return;
if (call->setup_timer != NULL) {
dect_stop_timer(dh, call->setup_timer);
dect_timer_stop(dh, call->setup_timer);
dect_free(dh, call->setup_timer);
call->setup_timer = NULL;
}
@ -1126,7 +1126,7 @@ static void dect_cc_rcv_call_proc(struct dect_handle *dh, struct dect_call *call
return;
if (call->setup_timer != NULL) {
dect_stop_timer(dh, call->setup_timer);
dect_timer_stop(dh, call->setup_timer);
dect_free(dh, call->setup_timer);
call->setup_timer = NULL;
}
@ -1177,7 +1177,7 @@ static void dect_cc_rcv_connect(struct dect_handle *dh, struct dect_call *call,
return;
if (call->setup_timer != NULL) {
dect_stop_timer(dh, call->setup_timer);
dect_timer_stop(dh, call->setup_timer);
dect_free(dh, call->setup_timer);
call->setup_timer = NULL;
}

8
src/keypad.c
View File

@ -39,7 +39,7 @@ void dect_keypad_append(struct dect_handle *dh, struct dect_keypad_buffer *kb,
unsigned int len;
if (keypad->len > 0)
dect_stop_timer(dh, kb->timer);
dect_timer_stop(dh, kb->timer);
len = sizeof(kb->keypad.info) - kb->keypad.len;
len = min((unsigned int)keypad->len, len);
@ -49,7 +49,7 @@ void dect_keypad_append(struct dect_handle *dh, struct dect_keypad_buffer *kb,
if (sending_complete || kb->keypad.len == sizeof(kb->keypad.info))
kb->complete(dh, kb->priv, &kb->keypad);
else if (keypad->len > 0)
dect_start_timer(dh, kb->timer, kb->timeout);
dect_timer_start(dh, kb->timer, kb->timeout);
}
EXPORT_SYMBOL(dect_keypad_append);
@ -65,10 +65,10 @@ dect_keypad_buffer_init(const struct dect_handle *dh, uint8_t timeout,
if (kb == NULL)
goto err1;
kb->timer = dect_alloc_timer(dh);
kb->timer = dect_timer_alloc(dh);
if (kb->timer == NULL)
goto err2;
dect_setup_timer(kb->timer, dect_keypad_timer, kb);
dect_timer_setup(kb->timer, dect_keypad_timer, kb);
kb->complete = complete;
kb->priv = priv;

32
src/lce.c
View File

@ -199,7 +199,7 @@ static struct dect_data_link *dect_ddl_alloc(const struct dect_handle *dh)
ddl = dect_zalloc(dh, sizeof(*ddl));
if (ddl == NULL)
goto err1;
ddl->sdu_timer = dect_alloc_timer(dh);
ddl->sdu_timer = dect_timer_alloc(dh);
if (ddl->sdu_timer == NULL)
goto err2;
ddl->state = DECT_DATA_LINK_RELEASED;
@ -232,11 +232,11 @@ static void dect_ddl_destroy(struct dect_handle *dh, struct dect_data_link *ddl)
}
if (dect_timer_running(ddl->sdu_timer))
dect_stop_timer(dh, ddl->sdu_timer);
dect_timer_stop(dh, ddl->sdu_timer);
dect_free(dh, ddl->sdu_timer);
if (ddl->release_timer != NULL && dect_timer_running(ddl->release_timer))
dect_stop_timer(dh, ddl->release_timer);
dect_timer_stop(dh, ddl->release_timer);
dect_free(dh, ddl->release_timer);
dect_free(dh, ddl);
}
@ -254,7 +254,7 @@ static void dect_ddl_release_complete(struct dect_handle *dh,
{
ddl_debug(ddl, "normal release complete");
ddl->state = DECT_DATA_LINK_RELEASED;
dect_stop_timer(dh, ddl->release_timer);
dect_timer_stop(dh, ddl->release_timer);
dect_ddl_destroy(dh, ddl);
}
@ -270,11 +270,11 @@ static void dect_ddl_release(struct dect_handle *dh,
goto err1;
ddl->state = DECT_DATA_LINK_RELEASE_PENDING;
ddl->release_timer = dect_alloc_timer(dh);
ddl->release_timer = dect_timer_alloc(dh);
if (ddl->release_timer == NULL)
goto err1;
dect_setup_timer(ddl->release_timer, dect_ddl_release_timer, ddl);
dect_start_timer(dh, ddl->release_timer, DECT_DDL_RELEASE_TIMEOUT);
dect_timer_setup(ddl->release_timer, dect_ddl_release_timer, ddl);
dect_timer_start(dh, ddl->release_timer, DECT_DDL_RELEASE_TIMEOUT);
return;
err1:
@ -294,8 +294,8 @@ static void dect_ddl_partial_release(struct dect_handle *dh,
struct dect_data_link *ddl)
{
ddl_debug(ddl, "partial release");
dect_setup_timer(ddl->sdu_timer, dect_ddl_partial_release_timer, ddl);
dect_start_timer(dh, ddl->sdu_timer, DECT_DDL_ESTABLISH_SDU_TIMEOUT);
dect_timer_setup(ddl->sdu_timer, dect_ddl_partial_release_timer, ddl);
dect_timer_start(dh, ddl->sdu_timer, DECT_DDL_ESTABLISH_SDU_TIMEOUT);
}
static void dect_ddl_shutdown(struct dect_handle *dh,
@ -387,8 +387,8 @@ static void dect_ddl_sdu_timer(struct dect_handle *dh, struct dect_timer *timer)
static int dect_ddl_schedule_sdu_timer(const struct dect_handle *dh,
struct dect_data_link *ddl)
{
dect_setup_timer(ddl->sdu_timer, dect_ddl_sdu_timer, ddl);
dect_start_timer(dh, ddl->sdu_timer, DECT_DDL_ESTABLISH_SDU_TIMEOUT);
dect_timer_setup(ddl->sdu_timer, dect_ddl_sdu_timer, ddl);
dect_timer_start(dh, ddl->sdu_timer, DECT_DDL_ESTABLISH_SDU_TIMEOUT);
ddl_debug(ddl, "start SDU timer");
return 0;
}
@ -397,7 +397,7 @@ static void dect_ddl_stop_sdu_timer(const struct dect_handle *dh,
struct dect_data_link *ddl)
{
ddl_debug(ddl, "stop SDU timer");
dect_stop_timer(dh, ddl->sdu_timer);
dect_timer_stop(dh, ddl->sdu_timer);
}
static int dect_send(const struct dect_handle *dh,
@ -593,7 +593,7 @@ static void dect_ddl_complete_indirect_establish(struct dect_handle *dh,
struct dect_msg_buf *mb, *mb_next;
/* Stop page timer */
dect_stop_timer(dh, req->page_timer);
dect_timer_stop(dh, req->page_timer);
dect_free(dh, req->page_timer);
ddl_debug(ddl, "complete indirect link establishment req %p", req);
@ -636,10 +636,10 @@ static struct dect_data_link *dect_ddl_establish(struct dect_handle *dh,
ddl->ipui = *ipui;
if (dh->mode == DECT_MODE_FP) {
ddl->page_timer = dect_alloc_timer(dh);
ddl->page_timer = dect_timer_alloc(dh);
if (ddl->page_timer == NULL)
goto err2;
dect_setup_timer(ddl->page_timer, dect_ddl_page_timer, ddl);
dect_timer_setup(ddl->page_timer, dect_ddl_page_timer, ddl);
dect_ddl_page_timer(dh, ddl->page_timer);
} else {
ddl->dfd = dect_socket(dh, SOCK_SEQPACKET, DECT_S_SAP);
@ -821,7 +821,7 @@ static void dect_ddl_page_timer(struct dect_handle *dh, struct dect_timer *timer
dect_ddl_shutdown(dh, ddl);
else {
dect_lce_page(dh, &ddl->ipui);
dect_start_timer(dh, ddl->page_timer, DECT_DDL_PAGE_TIMEOUT);
dect_timer_start(dh, ddl->page_timer, DECT_DDL_PAGE_TIMEOUT);
}
}

12
src/mm.c
View File

@ -385,7 +385,7 @@ static int dect_mm_procedure_initiate(struct dect_handle *dh,
if (mp->type != DECT_MMP_NONE) {
mm_debug(mme, "cancel procedure");
if (dect_timer_running(mp->timer))
dect_stop_timer(dh, mp->timer);
dect_timer_stop(dh, mp->timer);
dect_mm_proc[mp->type].abort(dh, mme, mp);
} else {
err = dect_ddl_transaction_open(dh, &mp->transaction, mme->link, DECT_PD_MM);
@ -396,7 +396,7 @@ static int dect_mm_procedure_initiate(struct dect_handle *dh,
mp->type = type;
mp->priority = priority;
if (proc->param[dh->mode].timeout)
dect_start_timer(dh, mp->timer, proc->param[dh->mode].timeout);
dect_timer_start(dh, mp->timer, proc->param[dh->mode].timeout);
mme->current = mp;
return 0;
}
@ -438,7 +438,7 @@ static void dect_mm_procedure_complete(struct dect_handle *dh,
mm_debug(mme, "complete procedure");
if (dect_timer_running(mp->timer))
dect_stop_timer(dh, mp->timer);
dect_timer_stop(dh, mp->timer);
if (mp->iec != NULL)
__dect_ie_collection_put(dh, mp->iec);
@ -467,7 +467,7 @@ static void dect_mm_procedure_timeout(struct dect_handle *dh,
if (mp->retransmissions++ == 0) {
mm_debug(mme, "timeout, retransmitting");
dect_lce_retransmit(dh, &mp->transaction);
dect_start_timer(dh, mp->timer, proc->param[dh->mode].timeout);
dect_timer_start(dh, mp->timer, proc->param[dh->mode].timeout);
} else {
mm_debug(mme, "procedure timeout");
dect_mm_procedure_complete(dh, mme, mp);
@ -482,10 +482,10 @@ static int dect_mm_procedure_init(struct dect_handle *dh,
struct dect_mm_procedure *mp = &mme->procedure[role];
mp->role = role;
mp->timer = dect_alloc_timer(dh);
mp->timer = dect_timer_alloc(dh);
if (mp->timer == NULL)
return -1;
dect_setup_timer(mp->timer, dect_mm_procedure_timeout, mp);
dect_timer_setup(mp->timer, dect_mm_procedure_timeout, mp);
return 0;
}

22
src/timer.c
View File

@ -20,7 +20,7 @@
* register the callback functions dect_event_ops::start_timer() and
* dect_event_ops::stop_timer() to allow libdect to register it's timers with
* the application's event handler. When a timeout occurs, the function
* dect_run_timer() must be invoked.
* dect_timer_run() must be invoked.
*
* Each libdect timer contains a storage area of the size specified in
* dect_event_ops::timer_priv_size, which can be used by the application to
@ -36,12 +36,12 @@
#include <utils.h>
#include <timer.h>
struct dect_timer *dect_alloc_timer(const struct dect_handle *dh)
struct dect_timer *dect_timer_alloc(const struct dect_handle *dh)
{
return dect_zalloc(dh, sizeof(struct dect_timer) +
dh->ops->event_ops->timer_priv_size);
}
EXPORT_SYMBOL(dect_alloc_timer);
EXPORT_SYMBOL(dect_timer_alloc);
/**
* Get a pointer to the private data area from a DECT timer
@ -54,7 +54,7 @@ void *dect_timer_priv(struct dect_timer *timer)
}
EXPORT_SYMBOL(dect_timer_priv);
void dect_setup_timer(struct dect_timer *timer,
void dect_timer_setup(struct dect_timer *timer,
void (*cb)(struct dect_handle *, struct dect_timer *),
void *data)
{
@ -62,9 +62,9 @@ void dect_setup_timer(struct dect_timer *timer,
timer->data = data;
timer->state = DECT_TIMER_STOPPED;
}
EXPORT_SYMBOL(dect_setup_timer);
EXPORT_SYMBOL(dect_timer_setup);
void dect_start_timer(const struct dect_handle *dh,
void dect_timer_start(const struct dect_handle *dh,
struct dect_timer *timer, unsigned int timeout)
{
struct timeval tv = {
@ -78,14 +78,14 @@ void dect_start_timer(const struct dect_handle *dh,
timer->state = DECT_TIMER_RUNNING;
dh->ops->event_ops->start_timer(dh, timer, &tv);
}
EXPORT_SYMBOL(dect_start_timer);
EXPORT_SYMBOL(dect_timer_start);
void dect_stop_timer(const struct dect_handle *dh, struct dect_timer *timer)
void dect_timer_stop(const struct dect_handle *dh, struct dect_timer *timer)
{
dh->ops->event_ops->stop_timer(dh, timer);
timer->state = DECT_TIMER_STOPPED;
}
EXPORT_SYMBOL(dect_stop_timer);
EXPORT_SYMBOL(dect_timer_stop);
bool dect_timer_running(const struct dect_timer *timer)
{
@ -99,12 +99,12 @@ EXPORT_SYMBOL(dect_timer_running);
* @param dh libdect DECT handle
* @param timer DECT timer
*/
void dect_run_timer(struct dect_handle *dh, struct dect_timer *timer)
void dect_timer_run(struct dect_handle *dh, struct dect_timer *timer)
{
timer->state = DECT_TIMER_STOPPED;
timer->callback(dh, timer);
}
EXPORT_SYMBOL(dect_run_timer);
EXPORT_SYMBOL(dect_timer_run);
/** @} */
/** @} */