/* Handles message for test command */
static void ui_svc_tcmd_handle_message(struct cfw_message *msg, void *param)
{
int ui_status;
ui_srv_data_t *priv = CFW_MESSAGE_PRIV(msg);
struct tcmd_handler_ctx *ctx = priv->context;
char *message = balloc(BUFFER_LENGTH, NULL);
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_UI_LED_RSP:
case MSG_ID_UI_VIBR_RSP:
ui_status = ((struct cfw_rsp_message *)msg)->status;
if (ui_status == DRV_RC_OK) {
TCMD_RSP_FINAL(ctx, NULL);
} else {
snprintf(message, BUFFER_LENGTH, "KO (status: %d)", ui_status);
TCMD_RSP_ERROR(ctx, message);
}
break;
default:
/* default cfw handler */
snprintf(message, BUFFER_LENGTH,
"Wrong ui_svc rsp (id: 0x%X)", CFW_MESSAGE_ID(msg));
TCMD_RSP_ERROR(ctx, message);
break;
}
cproxy_disconnect(priv->ui_service_conn);
cfw_msg_free(msg);
bfree(priv);
bfree(message);
}
static void handle_message(struct cfw_message *msg, void *param)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CIRCULAR_STORAGE_PUSH_REQ:
handle_push(msg);
break;
case MSG_ID_CIRCULAR_STORAGE_POP_REQ:
handle_pop(msg);
break;
case MSG_ID_CIRCULAR_STORAGE_PEEK_REQ:
handle_peek(msg);
break;
case MSG_ID_CIRCULAR_STORAGE_CLEAR_REQ:
handle_clear(msg);
break;
case MSG_ID_LL_CIRCULAR_STORAGE_SHUTDOWN_REQ:
cfw_send_message(CFW_MESSAGE_PRIV(msg));
break;
case MSG_ID_CIRCULAR_STORAGE_GET_REQ:
handle_get(msg);
default:
cfw_print_default_handle_error_msg(LOG_MODULE_MAIN,
CFW_MESSAGE_ID(
msg));
break;
}
cfw_msg_free(msg);
}
void my_handle_message(struct cfw_message * msg, void * param) {
pr_info(LOG_MODULE_MAIN, "%s:%s for param: %s conn:%p", __FILE__, __func__, (char*)param, msg->conn);
cfw_dump_message(msg);
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_OPEN_SERVICE_RSP: {
pr_info(LOG_MODULE_MAIN, "%s:%s for conn: %s", __FILE__, __func__, (char*)msg->priv);
cfw_open_conn_rsp_msg_t * cnf = (cfw_open_conn_rsp_msg_t*)msg;
int events[1] = {MSG_ID_TEST_1_EVT};
test_service_conn = cnf->service_conn;
cfw_register_events(test_service_conn, events, 1, msg->priv);
}
break;
case MSG_ID_CFW_REGISTER_EVT_RSP:
if (!strcmp(msg->priv, "Conn2")) {
test_service_test_1(test_service_conn, "Coucou");
}
break;
case MSG_ID_TEST_1_RSP: {
pr_info(LOG_MODULE_MAIN, "got MSG_ID_TEST_1_RSP Priv: %s", (char*)msg->priv);
test_service_test_2(test_service_conn, "Testing 2");
break;
}
case MSG_ID_TEST_2_RSP: {
pr_info(LOG_MODULE_MAIN, "got MSG_ID_TEST_2_RSP Priv: %s", (char*)msg->priv);
test_service_test_1(test_service_conn, "Testing 1");
break;
}
}
cfw_msg_free(msg);
}
static void _handle_client_message(struct cfw_message *msg, void *data)
{
(void)data;
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_OPEN_SERVICE:
{
/* We have passed the allocated cnx as an opaque data */
struct _svc_cnx *cnx = CFW_MESSAGE_PRIV(msg);
/* Get the service parameters from the message and store them locally */
cfw_open_conn_rsp_msg_t *con_msg = (cfw_open_conn_rsp_msg_t *)msg;
cnx->sh = (svc_client_handle_t *)(con_msg->client_handle);
cnx->src_port = con_msg->port;
cfw_msg_free(msg);
list_add(&_services, (list_t *)cnx);
break;
}
case MSG_ID_CFW_CLOSE_SERVICE:
{
struct _svc_cnx *cnx = CFW_MESSAGE_PRIV(msg);
list_remove(&_services, (list_t *)cnx);
bfree(cnx);
cfw_msg_free(msg);
break;
}
case MSG_ID_CFW_SVC_AVAIL_EVT:
{
struct _svc_cnx *cnx = CFW_MESSAGE_PRIV(msg);
if (((cfw_svc_available_evt_msg_t*)msg)->service_id == cnx->service_id) {
cfw_open_service(_proxy_handle, cnx->service_id, cnx);
}
cfw_msg_free(msg);
break;
}
default:
{
/* Find the service connection based on the message source port */
struct _svc_cnx *cnx = (struct _svc_cnx*)
list_find_first(&_services, _cmp_port, &(CFW_MESSAGE_SRC(msg)));
if (cnx) {
cnx->cb(msg, cnx->data);
} else {
cfw_msg_free(msg);
}
break;
}
}
}
/**
* Callback function for gpio service response
*/
void pwrbtn_tst_handle_msg(struct cfw_message *msg, void *data)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_OPEN_SERVICE_RSP:
*((cfw_service_conn_t **)(msg->priv)) =
(cfw_service_conn_t *)((cfw_open_conn_rsp_msg_t *)msg)
->
service_conn;
cu_print("TST_PWRBTN service opened \n");
break;
case MSG_ID_GPIO_SERVICE_CONFIGURE_RSP:
cu_print("TST_PWRBTN %s state=%d\n", msg->priv,
((gpio_service_configure_rsp_msg_t *)msg)->status);
tst_pwrbtn_configure = 1;
break;
case MSG_ID_GPIO_SERVICE_SET_STATE_RSP:
tst_pwrbtn_set_state = 1;
cu_print("TST_PWRBTN %s: state=%d\n", msg->priv,
((gpio_service_set_state_rsp_msg_t *)msg)->status);
break;
case MSG_ID_GPIO_SERVICE_GET_STATE_RSP:
tst_pwrbtn_get_state = 1;
tst_pwrbtn_get_value =
((gpio_service_get_state_rsp_msg_t *)msg)->state;
cu_print("TST_PWRBTN %s: state=%d, pin=0x%x\n", msg->priv,
((gpio_service_set_state_rsp_msg_t *)msg)->status,
((gpio_service_get_state_rsp_msg_t *)msg)->state);
case MSG_ID_GPIO_SERVICE_GET_BANK_STATE_RSP:
tst_pwrbtn_get_bank_state = 1;
tst_pwrbtn_get_bank_value =
((gpio_service_get_bank_state_rsp_msg_t *)msg)->state;
cu_print("TST_PWRBTN %s: state=%d, pin=0x%x\n", msg->priv,
((gpio_service_set_state_rsp_msg_t *)msg)->status,
((gpio_service_get_bank_state_rsp_msg_t *)msg)->state);
break;
case MSG_ID_GPIO_SERVICE_LISTEN_RSP:
tst_pwrbtn_listen = 1;
cu_print("TST_PWRBTN %s: state=%d, pin=%d\n", msg->priv,
((gpio_service_listen_rsp_msg_t *)msg)->status,
((gpio_service_listen_rsp_msg_t *)msg)->index);
break;
case MSG_ID_GPIO_SERVICE_UNLISTEN_RSP:
tst_pwrbtn_unlisten = 1;
cu_print("TST_PWRBTN %s: state=%d, pin=%d\n", msg->priv,
((gpio_service_unlisten_rsp_msg_t *)msg)->status,
((gpio_service_listen_rsp_msg_t *)msg)->index);
break;
case MSG_ID_GPIO_SERVICE_EVT:
tst_pwrbtn_event = 1;
cu_print("TST_PWRBTN EVT %s: state=%d, pin=%d\n", msg->priv,
((gpio_service_listen_evt_msg_t *)msg)->pin_state,
((gpio_service_listen_evt_msg_t *)msg)->index);
break;
default:
cu_print("default cfw handler\n");
break;
}
cfw_msg_free(msg);
}
static void sensor_handle_msg(struct cfw_message *msg, void *data)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_SS_START_SENSOR_SCANNING_EVT:
handle_start_scanning_evt(msg);
break;
case MSG_ID_SS_SENSOR_SUBSCRIBE_DATA_EVT:
handle_sensor_subscribe_data(msg);
break;
}
cfw_msg_free(msg);
}
void process_msg_cb(struct nfc_msg_cb *msg_cb, uint8_t status)
{
if(msg_cb){
if(msg_cb->msg_cb && msg_cb->msg){
msg_cb->msg_cb(msg_cb->msg, status);
cfw_msg_free(msg_cb->msg);
msg_cb->msg = NULL;
msg_cb->msg_cb = NULL;
bfree(msg_cb);
msg_cb = NULL;
}
}
}
/**@brief Function to handle terminated audio streams.
*
* @details In this function played stream is freed. A new stream is
* initialized if necessary. Once all streams have been
* played, response message is built and sent.
* @param[in] msg Request message.
* @return none
*/
static void ui_handle_as_stream_end(message_t * msg)
{
rsp_message_t *resp;
uint16_t resp_id;
audio_stream_mgr_evt_msg *evt = (audio_stream_mgr_evt_msg *) msg;
/* Need to filter MSG_ID_AS_STREAM_XX messages, as the UI SVC is not */
/* the only one listening to them. */
if ((evt->sHandle != tone_stream) && (evt->sHandle != sps_stream))
return;
pr_debug(LOG_MODULE_UI_SVC,
"Audio stream 0x%08x ended - reason %d",
evt->sHandle,
evt->sHandle->reason);
if (tone_stream) {
as_stream_destroy(tone_stream);
tone_stream = NULL;
}
/* Check if more data to play. */
if (sps_stream) {
/* Play done. */
as_stream_destroy(sps_stream);
sps_stream = NULL;
sps_id_stream_pending = 0;
} else if (sps_id_stream_pending) {
/* Play speech sequence. */
ui_sps_play_init(sps_id_stream_pending, as_stream_priv);
}
if (!tone_stream && !sps_stream) {
/* Request completed. */
if (ui_audio_req->id == MSG_ID_UI_LPAL_REQ)
resp_id = MSG_ID_UI_LPAL_RSP;
else
resp_id = MSG_ID_UI_ASR_RSP;
resp = cfw_alloc_rsp_msg(ui_audio_req, resp_id, sizeof(*resp));
if (resp == NULL) force_panic();
resp->status = evt->sHandle->reason;
cfw_send_message(resp);
cfw_msg_free(ui_audio_req);
ui_audio_req = NULL;
}
}
static void ble_service_message_handler(struct cfw_message *msg, void *param)
{
bool free_msg = true;
struct _ble_service_cb *p_cb = param;
uint16_t msg_id = CFW_MESSAGE_ID(msg);
if (p_cb->ble_state < BLE_ST_ENABLED &&
msg_id != MSG_ID_BLE_ENABLE_REQ) {
ble_is_not_enabled_rsp(msg, -ENODEV);
goto out;
}
switch (msg_id) {
case MSG_ID_BLE_ENABLE_REQ: {
struct ble_enable_req *req =
container_of(msg, struct ble_enable_req, header);
if (p_cb->ble_state) {
if (req->enable) {
handle_ble_enable(req, p_cb);
free_msg = false;
} else
handle_ble_disable(req, p_cb);
} else {
pr_debug(LOG_MODULE_BLE, "ble_hdl_msg: core service not opened!");
/* core service is not yet up */
struct ble_enable_rsp *resp = (void *)cfw_alloc_rsp_msg(msg,
MSG_ID_BLE_ENABLE_RSP, sizeof(*resp));
resp->status = -EINPROGRESS;
resp->enable = 0;
cfw_send_message(resp);
}
}
break;
#ifdef CONFIG_TCMD_BLE_DEBUG
case MSG_ID_BLE_DBG_REQ:
handle_msg_id_ble_dbg(msg);
break;
#endif
default:
pr_warning(LOG_MODULE_BLE, "unsupported %d", msg_id);
break;
}
out:
if (free_msg)
cfw_msg_free(msg);
}
static void cfw_message_handler(struct cfw_message *msg, void *param)
{
DRIVER_API_RC ret = DRV_RC_FAIL;
static uint16_t adc_value;
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_GPIO_SERVICE_CONFIGURE_RSP:
case MSG_ID_GPIO_SERVICE_SET_STATE_RSP:
break;
case MSG_ID_ADC_SERVICE_SUBSCRIBE_RSP:
pr_debug(LOG_MODULE_MAIN, "ADC subscribe Response");
adc_svc_client =
((adc_service_subscribe_rsp_msg_t *)msg)->
adc_sub_conn_handle;
ret = ((adc_service_subscribe_rsp_msg_t *)msg)->status;
if (DRV_RC_OK != ret) {
pr_error(LOG_MODULE_MAIN, "ADC subscribe fails %d", ret);
panic(-1);
}
break;
case MSG_ID_ADC_SERVICE_GET_VAL_EVT:
ret = ((adc_service_get_evt_msg_t *)msg)->status;
if (DRV_RC_OK == ret) {
adc_value =
((adc_service_get_evt_msg_t *)msg)->adc_value;
pr_debug(LOG_MODULE_MAIN, "adc_value %d", adc_value);
if (adc_value < LOWER_LIMIT)
blink_freq = LED_BLINK_ONE_SEC;
else if (adc_value > HIGHER_LIMIT)
blink_freq = LED_BLINK_500_MS;
else
blink_freq = LED_BLINK_TWO_SEC;
} else {
pr_error(LOG_MODULE_MAIN, "ADC get value fails %d",
ret);
}
break;
default:
pr_info(LOG_MODULE_MAIN, "Discarded message: %x",
CFW_MESSAGE_ID(msg));
}
cfw_msg_free(msg);
}
/**
* \fn void gpio_tst_handle_msg(struct cfw_message * msg, void * data)
*
* \brief Callback function for gpio service test
*/
void gpio_tst_handle_msg(struct cfw_message * msg, void * data)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_OPEN_SERVICE_RSP:
*((cfw_service_conn_t **)(msg->priv)) = (cfw_service_conn_t *)((cfw_open_conn_rsp_msg_t*)msg)->service_conn;
cu_print("TST_GPIO open\n");
break;
case MSG_ID_GPIO_CONFIGURE_RSP:
cu_print("TST_GPIO %s state=%d\n", msg->priv, ((gpio_configure_rsp_msg_t*)msg)->rsp_header.status);
tst_gpio_configure = 1;
break;
case MSG_ID_GPIO_SET_RSP:
tst_gpio_set_state = 1;
cu_print("TST_GPIO %s: state=%d\n", msg->priv, ((gpio_set_rsp_msg_t*)msg)->rsp_header.status);
break;
case MSG_ID_GPIO_GET_RSP:
tst_gpio_get_state = 1;
tst_gpio_get_value = ((gpio_get_rsp_msg_t*)msg)->state;
cu_print("TST_GPIO %s: state=%d, pin=0x%x\n", msg->priv,
((gpio_set_rsp_msg_t*)msg)->rsp_header.status,
((gpio_get_rsp_msg_t*)msg)->state);
break;
case MSG_ID_GPIO_LISTEN_RSP:
tst_gpio_listen = 1;
cu_print("TST_GPIO %s: state=%d, pin=%d\n", msg->priv,((gpio_listen_rsp_msg_t*)msg)->rsp_header.status,
((gpio_listen_rsp_msg_t*)msg)->index);
break;
case MSG_ID_GPIO_UNLISTEN_RSP:
tst_gpio_unlisten = 1;
cu_print("TST_GPIO %s: state=%d, pin=%d\n", msg->priv,((gpio_unlisten_rsp_msg_t*)msg)->rsp_header.status,
((gpio_listen_rsp_msg_t*)msg)->index);
break;
case MSG_ID_GPIO_EVT:
tst_gpio_event = 1;
cu_print("TST_GPIO EVT %s: state=%d, pin=%d\n", msg->priv,((gpio_listen_evt_msg_t*)msg)->pin_state,
((gpio_listen_evt_msg_t*)msg)->index);
break;
default:
cu_print("default cfw handler\n");
break;
}
cfw_msg_free(msg);
}
static void srv_client_handle_msg(struct cfw_message * msg, void * data)
{
cfw_dump_message(msg);
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_OPEN_SERVICE_RSP:
{
cfw_open_conn_rsp_msg_t *resp = (cfw_open_conn_rsp_msg_t *)msg;
printf("server_main:%s(): MSG_ID_CFW_OPEN_SERVICE_RSP::port_id: %d, cpu_id: %d, "
"service_conn: 0x%p, priv 0x%p\n", __func__,
resp->port, resp->cpu_id, resp->service_conn,
msg->priv);
break;
}
case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP:
printf("server_main::%s(): MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP, priv:"
" 0x%p\n",
__func__, msg->priv);
break;
case MSG_ID_CFW_SVC_AVAIL_EVT: {
cfw_svc_available_evt_msg_t * evt =
(cfw_svc_available_evt_msg_t *)msg;
if ((evt->service_id == BLE_CORE_SERVICE_ID) ||
(0 != cfw_service_registered(
BLE_CORE_SERVICE_ID))) {
_server_cb.ble_svc_started = 1;
printf("\n%s(): BLE_CORE_SERVICE_ID registered!\n", __func__);
#ifdef CONFIG_BLE_CORE_TEST
extern void test_ble_service_init(void);
test_ble_service_init();
#endif
}
break;
}
default:
pr_info(LOG_MODULE_MAIN, "server_main::%s(): Unhandled Msg: 0x%x",
__func__, CFW_MESSAGE_ID(msg));
break;
}
cfw_msg_free(msg);
}
/**@brief Function to handle requests, responses and events
* @param[in] msg Event message.
*/
static void bs_handle_message(struct cfw_message *msg, void *param)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_BATTERY_SERVICE_GET_BATTERY_INFO_REQ:
handle_battery_service_get_info(msg);
break;
case MSG_ID_BATTERY_SERVICE_SET_LOW_LEVEL_ALARM_REQ:
case MSG_ID_BATTERY_SERVICE_SET_CRITICAL_LEVEL_ALARM_REQ:
handle_bs_set_level_alarm(msg, CFW_MESSAGE_ID(msg));
break;
case MSG_ID_BATTERY_SERVICE_SET_MEASURE_INTERVAL_REQ:
handle_battery_set_measure_interval(msg);
break;
default:
pr_error(LOG_MODULE_BS, "Unexpected message id: %x",
CFW_MESSAGE_ID(
msg));
break;
}
cfw_msg_free(msg);
}
/**@brief Function to broadcast to other clients ASR events coming
* from the Audio service.
*
* @details Broadcast message is built and passed to the framework which
* in turn sends it to all clients consumers of the event.
* @param[in] msg Event message.
* @return none
*/
void ui_broadcast_svc_asr_event(message_t * msg)
{
message_t *broadcast_msg;
broadcast_msg = cfw_alloc_evt_msg(ui_svc,
MSG_ID_UI_ASR_EVT,
sizeof(ui_asr_evt_t));
if (broadcast_msg == NULL) force_panic();
((ui_asr_evt_t *) broadcast_msg)->ui_asr_event_id =
((ui_asr_evt_t *) msg)->ui_asr_event_id;
pr_debug(LOG_MODULE_UI_SVC,
"Audio: broadcast ASR EVT:0x%x from src:%d",
((ui_asr_evt_t *) msg)->ui_asr_event_id,
msg->src);
cfw_send_event(broadcast_msg);
/* Message cloned by the framework. Can be deleted now. */
cfw_msg_free(broadcast_msg);
}
static void ble_app_msg_handler(struct cfw_message *msg, void *param)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_BLE_ENABLE_RSP:
handle_msg_id_ble_enable_rsp(msg);
break;
case MSG_ID_PROP_SERVICE_ADD_RSP:
break;
case MSG_ID_PROP_SERVICE_READ_RSP:
handle_ble_property_read_rsp(msg);
break;
case MSG_ID_PROP_SERVICE_WRITE_RSP:
break;
#ifdef CONFIG_BLE_APP_USE_BAT
case MSG_ID_BATTERY_SERVICE_LEVEL_UPDATED_EVT: {
battery_service_listen_evt_rsp_msg_t *evt = container_of(
msg, battery_service_listen_evt_rsp_msg_t, header);
if (_ble_app_cb.flags & BLE_APP_ENABLED)
ble_bas_update(
evt->battery_service_evt_content_rsp_msg.
bat_soc);
break;
}
case MSG_ID_BATTERY_SERVICE_GET_BATTERY_INFO_RSP: {
struct battery_service_info_request_rsp_msg *batt_msg =
container_of(
msg,
struct battery_service_info_request_rsp_msg,
header);
if (_ble_app_cb.flags & BLE_APP_ENABLED)
ble_bas_update(batt_msg->battery_soc.bat_soc);
break;
}
#endif
default:
pr_debug(LOG_MODULE_BLE, "Unhandled BLE app message");
}
cfw_msg_free(msg);
}
static void handle_message(struct cfw_message * msg, void * param)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_LL_ERASE_BLOCK_REQ:
handle_erase_block(msg);
break;
case MSG_ID_LL_READ_PARTITION_REQ:
handle_read_partition(msg);
break;
case MSG_ID_LL_WRITE_PARTITION_REQ:
handle_write_partition(msg);
break;
#ifdef CONFIG_SERVICES_QUARK_SE_STORAGE_CIRCULAR
case MSG_ID_LL_CIR_STOR_INIT_REQ:
handle_cir_stor_init(msg);
break;
case MSG_ID_LL_PUSH_REQ:
handle_push(msg);
break;
case MSG_ID_LL_POP_REQ:
handle_pop(msg);
break;
case MSG_ID_LL_PEEK_REQ:
handle_peek(msg);
break;
case MSG_ID_LL_CLEAR_REQ:
handle_clear(msg);
break;
#endif
default:
cfw_print_default_handle_error_msg(LOG_MODULE_MAIN, CFW_MESSAGE_ID(msg));
break;
}
cfw_msg_free(msg);
}
/**@brief Function to handle messages from framework.
*
* @details In this function are handled messages of
* communications with the Audio service.
* @param[in] msg Message from framework.
* @param[in] param Additional data. NULL if not used.
* @return none.
*/
void ui_audio_svc_handle_message(message_t * msg, void *param)
{
int client_events[4];
cfw_open_conn_rsp_msg_t *cnf = NULL;
audio_stream_mgr_evt_msg *evt = NULL;
pr_debug(LOG_MODULE_UI_SVC,
"Audio: received msg: %d src: %d dst: %d",
msg->id,
msg->src,
msg->dst);
/* Dump message content. */
cfw_dump_message(msg);
ui_port = msg->dst;
switch (msg->id) {
case MSG_ID_CFW_OPEN_SERVICE_RSP:{
cnf = (cfw_open_conn_rsp_msg_t *) msg;
if (cnf == NULL) force_panic();
audio_client_cfw_hdl = cnf->service_conn;
if (audio_client_cfw_hdl == NULL) force_panic();
client_events[0] = MSG_ID_AS_LPAL_EVT;
client_events[1] = MSG_ID_AS_ASR_EVT;
client_events[2] = MSG_ID_AS_STREAM_STOPPED_EVT;
client_events[3] = MSG_ID_AS_STREAM_TERMINATED_EVT;
/* Events registration. */
cfw_register_events(audio_client_cfw_hdl,
client_events, 4, msg->priv);
pr_info(LOG_MODULE_UI_SVC,
"Audio: Audio service id %lu opened",
UI_SVC_ID);
}
break;
case MSG_ID_CFW_CLOSE_SERVICEi_RSP:
pr_info(LOG_MODULE_UI_SVC,
"Audio: Audio service has been closed");
break;
case MSG_ID_CFW_REGISTER_EVT_RSP:
pr_debug(LOG_MODULE_UI_SVC,
"Audio: Events registered for Audio service");
break;
case MSG_ID_AS_LPAL_EVT:
ui_broadcast_svc_lpal_event(msg);
break;
case MSG_ID_AS_ASR_EVT:
ui_broadcast_svc_asr_event(msg);
break;
case MSG_ID_AS_STREAM_STOPPED_EVT:
/* Need to filter MSG_ID_AS_STREAM_XX messages, as the UI SVC is */
/* not the only one listening to them. */
/* If not tone or speech sequence initialized, msg is ignored. */
evt = (audio_stream_mgr_evt_msg *)msg;
if ((evt->sHandle == tone_stream) || (evt->sHandle == sps_stream)) {
pr_debug(LOG_MODULE_UI_SVC,
"Audio: stream 0x%08x stopped, reason %d",
evt->sHandle,
evt->sHandle->reason);
if (evt->sHandle->reason == AUDIO_STREAM_STATE_INIT_SUCCESS) {
if (tone_stream)
ui_tone_play_start();
else if (sps_stream)
ui_sps_play_start();
}
}
break;
case MSG_ID_AS_STREAM_TERMINATED_EVT:
ui_handle_as_stream_end(msg);
break;
default:
break;
}
cfw_msg_free(msg);
}
void sensor_core_svc_rsp_handle(struct cfw_message *p_msg, void *p_param)
{
switch (CFW_MESSAGE_ID(p_msg)) {
case MSG_ID_CFW_OPEN_SERVICE_RSP:
{
cfw_open_conn_rsp_msg_t *cnf = (cfw_open_conn_rsp_msg_t *)p_msg;
p_sc_service_conn = (cfw_service_conn_t *)cnf->service_conn;
if (NULL == p_sc_service_conn) {
SS_PRINT_ERR("Opening Score_svc failed");
return;
}
SS_PRINT_LOG("Opening Score_svc successful");
if (core_connected_cb) {
core_connected_cb(core_connected_cb_data);
}
} break;
case MSG_ID_CFW_REGISTER_EVT_RSP:
{
SS_PRINT_LOG("Register evt!!");
} break;
case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP:
break;
case MSG_ID_CFW_SVC_AVAIL_EVT:
{
uint16_t service_id =
((cfw_svc_available_evt_msg_t *)p_msg)->service_id;
SS_PRINT_LOG("AVAIL_EVT: %d", service_id);
if (ARC_SC_SVC_ID == service_id) {
cfw_open_service_conn(p_client, ARC_SC_SVC_ID, NULL);
} else {
SS_PRINT_LOG("AVAIL_EVT:service_id is error");
}
} break;
case MSG_ID_SENSOR_SERVICE_START_SCANNING_RSP:
{
SS_PRINT_LOG("[%s]Scanning rsp", __func__);
} break;
case MSG_ID_SENSOR_SERVICE_START_SCANNING_EVT:
{
sensor_service_scan_event_t *p_evt =
(sensor_service_scan_event_t *)p_msg;
uint8_t sensor_type = (uint8_t)(((uint32_t)p_evt->handle) >> 8);
uint8_t sensor_id = (uint8_t)(((uint32_t)p_evt->handle) & 0xff);
send_scan_evt_message_to_clients(sensor_type, sensor_id);
SS_PRINT_LOG("[%s]Scanning evt", __func__);
} break;
case MSG_ID_SENSOR_SERVICE_STOP_SCANNING_RSP:
{
SS_PRINT_LOG("[%s]Stop SCANNING RSP", __func__);
} break;
case MSG_ID_SENSOR_SERVICE_PAIR_RSP:
{
SS_PRINT_LOG("[%s]PAIR RSP", __func__);
} break;
case MSG_ID_SENSOR_SERVICE_SUBSCRIBE_DATA_RSP:
{
sensor_service_message_general_rsp_t *p_rsp =
(sensor_service_message_general_rsp_t *)p_msg;
uint8_t sensor_type = (uint8_t)(((uint32_t)p_rsp->handle) >> 8);
uint8_t sensor_id = (uint8_t)(((uint32_t)p_rsp->handle) & 0xff);
SS_PRINT_LOG("SUBSCRIBE_DATA_RSP:type=%d,id=%d,status=%d]", \
sensor_type, sensor_id, \
p_rsp->status);
send_sensor_subscribing_rsp_message_to_clients(sensor_type,
sensor_id,
p_rsp->status);
} break;
case MSG_ID_SENSOR_SERVICE_SUBSCRIBE_DATA_EVT:
{
sensor_service_subscribe_data_event_t *p_evt =
(sensor_service_subscribe_data_event_t *)p_msg;
sensor_service_sensor_data_header_t *p_data_header =
&p_evt->sensor_data_header;
uint8_t sensor_type = (uint8_t)(((uint32_t)p_evt->handle) >> 8);
uint8_t sensor_id = (uint8_t)(((uint32_t)p_evt->handle) & 0xff);
send_sensor_subscribing_evt_message_to_clients(
sensor_type, sensor_id, 0, \
p_data_header->
timestamp, \
(void *)
p_data_header->data, \
p_data_header->
data_length);
} break;
case MSG_ID_SENSOR_SERVICE_UNSUBSCRIBE_DATA_RSP:
{
SS_PRINT_LOG("[%s]UNSUBSCRIBED RSP", __func__);
ss_sensor_unsubscribe_data_rsp_t *p_rsp =
(ss_sensor_unsubscribe_data_rsp_t *)p_msg;
uint8_t sensor_type = GET_SENSOR_TYPE(p_rsp->handle);
uint8_t sensor_id = GET_SENSOR_ID(p_rsp->handle);
send_sensor_unsubscribing_rsp_message_to_clients(sensor_type,
sensor_id,
p_rsp->status);
} break;
case MSG_ID_SENSOR_SERVICE_UNPAIR_RSP:
break;
case MSG_ID_SS_SENSOR_UNLINK_EVT:
break;
default:
SS_PRINT_ERR("[%s]unhandled msg %d", __func__,
CFW_MESSAGE_ID(p_msg));
break;
}
cfw_msg_free(p_msg);
}
void internal_handle_message(struct cfw_message * msg, void * param)
{
int free_msg = 1; /* by default free message */
switch (CFW_MESSAGE_ID(msg))
{
case MSG_ID_CFW_ALLOC_PORT:
{
//TODO: Enable this, currently relies on sync IPC API.
//_port_t * port = cfw_port_alloc(NULL);
//cfw_port_set_handler(port, send_message_ipc, NULL);
break;
}
case MSG_ID_CFW_OPEN_SERVICE:
{
cfw_open_conn_req_msg_t * req = (cfw_open_conn_req_msg_t *) msg;
service_t * svc = cfw_get_service(req->service_id);
if (svc == NULL) {
pr_error(LOG_MODULE_MAIN, "try to open non registered service %d", req->service_id);
cfw_open_conn_rsp_msg_t * resp =
(cfw_open_conn_rsp_msg_t *) cfw_alloc_rsp_msg(msg,
MSG_ID_CFW_OPEN_SERVICE, sizeof(*resp));
resp->rsp_header.status = E_OS_ERR_UNKNOWN;
cfw_send_message(resp);
break;
}
uint8_t svc_cpu_id = port_get_cpu_id(svc->port_id);
if (svc_cpu_id != get_cpu_id()) {
#ifdef INFRA_MULTI_CPU_SUPPORT
pr_debug(LOG_MODULE_MAIN, "forward open service to proxy");
CFW_MESSAGE_DST(msg) = proxies[svc_cpu_id].port_id;
cfw_send_message(msg);
free_msg = 0; /* the lower layers will free it! */
#else
pr_error(LOG_MODULE_MAIN, "incorrect cpu_id settings, single cpu!");
#endif
} else {
conn_handle_t * conn_handle;
conn_handle = (conn_handle_t *) balloc(sizeof(*conn_handle),
NULL );
conn_handle->client_port = CFW_MESSAGE_SRC(msg);
conn_handle->priv_data = NULL;
conn_handle->svc = svc;
conn_handle->client_handle = req->client_handle;
/* For OPEN_SERVICE, conn is not know yet, it is just alloc'ed.
* set it here.*/
req->header.conn = conn_handle;
if (svc->client_connected != NULL &&
svc_cpu_id == get_cpu_id())
svc->client_connected(conn_handle);
cfw_open_conn_rsp_msg_t * resp =
(cfw_open_conn_rsp_msg_t *) cfw_alloc_rsp_msg(msg,
MSG_ID_CFW_OPEN_SERVICE, sizeof(*resp));
resp->port = svc->port_id;
resp->cpu_id = svc_cpu_id;
#ifdef SVC_MANAGER_DEBUG
pr_debug(LOG_MODULE_CFW, "OPEN_SERVICE: %d, svc:%p port:%d", req->service_id,
svc, svc->port_id);
#endif
resp->svc_server_handle = conn_handle;
resp->client_handle = req->client_handle;
cfw_send_message(resp);
}
break;
}
case MSG_ID_CFW_CLOSE_SERVICE:
{
cfw_close_conn_req_msg_t * req = (cfw_close_conn_req_msg_t*) msg;
service_t * svc = cfw_get_service(req->service_id);
if (svc == NULL) {
pr_debug(LOG_MODULE_MAIN, "try close unregistered service %d",
req->service_id);
cfw_close_conn_rsp_msg_t * resp =
(cfw_close_conn_rsp_msg_t *) cfw_alloc_rsp_msg(msg,
MSG_ID_CFW_CLOSE_SERVICE, sizeof(*resp));
resp->rsp_header.status = E_OS_ERR_UNKNOWN;
cfw_send_message(resp);
break;
}
uint8_t svc_cpu_id = port_get_cpu_id(svc->port_id);
if (svc_cpu_id != get_cpu_id()) {
#ifdef INFRA_MULTI_CPU_SUPPORT
CFW_MESSAGE_DST(msg) = proxies[svc_cpu_id].port_id;
cfw_send_message(msg);
free_msg=0;
#else
pr_error(LOG_MODULE_MAIN, "incorrect cpu_id!");
#endif
} else {
cfw_close_conn_rsp_msg_t * resp =
(cfw_close_conn_rsp_msg_t *) cfw_alloc_rsp_msg(msg,
MSG_ID_CFW_CLOSE_SERVICE, sizeof(*resp));
conn_handle_t * conn = (conn_handle_t*) msg->conn;
if (conn != NULL && conn->svc != NULL
&& conn->svc->client_disconnected != NULL )
conn->svc->client_disconnected(conn);
cfw_send_message(resp);
/* Free server-side conn */
bfree(conn);
}
break;
}
case MSG_ID_CFW_REGISTER_EVT:
{
int * params = (int *) &msg[1];
int i;
for (i = 0; i < params[0]; i++) {
_cfw_register_event((conn_handle_t*) msg->conn, params[i + 1]);
}
cfw_register_evt_rsp_msg_t * resp =
(cfw_register_evt_rsp_msg_t *) cfw_alloc_rsp_msg(msg,
MSG_ID_CFW_REGISTER_EVT, (sizeof(*resp)));
conn_handle_t * conn = (conn_handle_t*) msg->conn;
if (conn != NULL && conn->svc != NULL
&& conn->svc->registered_events_changed != NULL )
conn->svc->registered_events_changed(conn);
cfw_send_message(resp);
break;
}
case MSG_ID_CFW_REGISTER_SVC_AVAIL:
{
bool already_avail = true;
cfw_register_svc_avail_req_msg_t * req =
(cfw_register_svc_avail_req_msg_t *) msg;
int flags = interrupt_lock();
if (_find_service(req->service_id) == -1) {
add_service_avail_listener(CFW_MESSAGE_SRC(msg),
req->service_id, msg->priv);
already_avail = false;
}
interrupt_unlock(flags);
cfw_register_svc_avail_rsp_msg_t * resp =
(cfw_register_svc_avail_rsp_msg_t *) cfw_alloc_rsp_msg(msg,
MSG_ID_CFW_REGISTER_SVC_AVAIL, (sizeof(*resp)));
cfw_send_message(resp);
if (already_avail) {
send_service_avail_evt(req->service_id, CFW_MESSAGE_SRC(msg), msg->priv);
}
break;
}
default:
pr_warning(LOG_MODULE_CFW, "%s: unhandled message id: %x", __func__, CFW_MESSAGE_ID(msg));
break;
}
if (free_msg)
cfw_msg_free(msg);
}
static void ble_core_client_handle_message(struct cfw_message *msg, void *param)
{
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_SVC_AVAIL_EVT:
handle_msg_id_cfw_svc_avail_evt((cfw_svc_available_evt_msg_t *)msg, param);
break;
case MSG_ID_CFW_OPEN_SERVICE:
handle_msg_id_cfw_open_svc((cfw_open_conn_rsp_msg_t *)msg, param);
break;
case MSG_ID_BLE_GAP_WR_CONF_RSP:
handle_msg_id_ble_gap_wr_conf_rsp((struct ble_rsp *)msg, param);
break;
case MSG_ID_BLE_GAP_RD_BDA_RSP:
handle_msg_id_ble_gap_rd_bda_rsp((ble_bda_rd_rsp_t *)msg, param);
break;
case MSG_ID_BLE_GAP_SM_CONFIG_RSP:
handle_msg_id_ble_gap_sm_config_rsp((struct ble_rsp *)msg, param);
break;
case MSG_ID_BLE_GAP_WR_ADV_DATA_RSP:
handle_msg_id_ble_gap_wr_adv_data_rsp((struct ble_rsp *)msg, param);
break;
case MSG_ID_BLE_GAP_ENABLE_ADV_RSP:
handle_msg_id_ble_gap_enable_adv_rsp((struct ble_rsp *)msg, param);
break;
case MSG_ID_BLE_GAP_DISABLE_ADV_RSP:
handle_msg_id_ble_gap_disable_adv_rsp((struct ble_rsp *)msg, param);
break;
case MSG_ID_BLE_GATTS_ADD_SERVICE_RSP:
handle_msg_id_gatts_add_service_rsp((struct ble_gatts_add_svc_rsp *)msg, param);
break;
case MSG_ID_BLE_GATTS_ADD_CHARACTERISTIC_RSP:
handle_msg_id_gatts_add_characteristic_rsp((struct ble_gatts_add_char_rsp *)msg, param);
break;
case MSG_ID_BLE_GATTS_ADD_DESCRIPTOR_RSP:
handle_msg_id_gatts_add_desc_rsp((struct ble_gatts_add_desc_rsp *)msg, param);
break;
case MSG_ID_BLE_GATTS_SET_ATTRIBUTE_VALUE_RSP:
handle_msg_id_ble_gatts_set_attribute_value_rsp((struct ble_gatts_set_attr_rsp_msg *)msg, param);
break;
case MSG_ID_BLE_GATTS_SEND_NOTIF_RSP:
case MSG_ID_BLE_GATTS_SEND_IND_RSP:
handle_msg_id_ble_gatts_send_notif_ind_rsp((ble_gatts_rsp_t *)msg, param);
break;
case MSG_ID_BLE_GAP_CONNECT_EVT:
handle_msg_id_ble_gap_connect_evt_msg((struct ble_gap_event *)msg, param);
break;
case MSG_ID_BLE_GAP_DISCONNECT_EVT:
handle_msg_id_ble_gap_disconnect_evt_msg((struct ble_gap_event *)msg, param);
break;
case MSG_ID_BLE_GAP_TO_EVT:
handle_msg_id_ble_gap_timeout_evt_msg((struct ble_gap_event *)msg, param);
break;
case MSG_ID_BLE_GAP_RSSI_EVT:
handle_msg_id_ble_gap_rssi_evt_msg((struct ble_gap_event *)msg, param);
break;
case MSG_ID_BLE_GATTS_WRITE_EVT:
handle_msg_id_ble_gatts_write_evt_msg((struct ble_gatts_evt_msg *)msg, param);
break;
case MSG_ID_BLE_GAP_DISCONNECT_RSP:
handle_msg_id_ble_gap_disconnect_rsp((struct ble_rsp *)msg, param);
break;
case MSG_ID_BLE_GAP_SET_RSSI_REPORT_RSP:
handle_msg_id_ble_gap_set_rssi_report_rsp((struct ble_rsp *)msg, param);
break;
case MSG_ID_BLE_GAP_DTM_INIT_RSP:
handle_msg_id_ble_gap_dtm_init_rsp((struct ble_generic_msg *)msg, param);
break;
}
cfw_msg_free(msg);
}
void test_handle_message(struct cfw_message * msg, void * param)
{
cfw_log("%s:%s for param: %s conn:%p id:%d\n", __FILE__, __func__,
(char*) param, msg->conn, CFW_MESSAGE_ID(msg));
//cfw_dump_message(msg);
switch (CFW_MESSAGE_ID(msg)) {
case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP:
break;
case MSG_ID_CFW_SVC_AVAIL_EVT: {
int svc_id = ((cfw_svc_available_evt_msg_t *)msg)->service_id;
if (svc_id == SOC_GPIO_SERVICE_ID) {
cfw_open_service_conn(client, SOC_GPIO_SERVICE_ID, "Conn1");
}
break;
}
case MSG_ID_CFW_OPEN_SERVICE_RSP: {
cfw_log("%s:%s for conn: %s\n", __FILE__, __func__,
(char*) CFW_MESSAGE_PRIV(msg));
cfw_open_conn_rsp_msg_t * cnf = (cfw_open_conn_rsp_msg_t*) msg;
gpio_service_conn = cnf->service_conn;
gpio_configure(gpio_service_conn, 26, 1, NULL);
break;
}
case MSG_ID_GPIO_CONFIGURE_RSP:
gpio_set_state(gpio_service_conn, 26, 1, NULL);
break;
case MSG_ID_GPIO_SET_RSP: {
int val;
void * next;
if (!((int) CFW_MESSAGE_PRIV(msg))) {
val = 0;
next = (void*) 1;
} else {
val = 1;
next = (void*) 0;
}
printf("Got response: %d %d \n", val, (int) next);
if (count ++ > 100) {
cfw_close_service_conn(gpio_service_conn, NULL);
} else {
gpio_set_state(gpio_service_conn, 26, val, next);
}
}
break;
case MSG_ID_CFW_CLOSE_SERVICE_RSP: {
cfw_close_conn_rsp_msg_t * resp = (cfw_close_conn_rsp_msg_t*) msg;
cfw_log("%s: res: %d\n", __func__, resp->rsp_header.status);
exit(0);
}
break;
default: {
cfw_log("%s: Unhandled message: %d\n", __func__, CFW_MESSAGE_ID(msg));
break;
}
}
cfw_msg_free(msg);
}
