static s32 cad_rpc_get_remote_handle(void)
{
s32 err = CAD_RES_SUCCESS;
struct cad_rpc_config_info info;
mutex_lock(&cad_rpc_data_type.resource_mutex);
if (!cad_rpc_data_type.initialized) {
pr_err("RPC data is not initialized\n");
mutex_unlock(&cad_rpc_data_type.resource_mutex);
return CAD_RES_FAILURE;
}
/* already exist the handle */
if (cad_rpc_data_type.remote_handle) {
mutex_unlock(&cad_rpc_data_type.resource_mutex);
return CAD_RES_SUCCESS;
}
/* get device handle */
/* <peter> N-way SMD dependent.*/
err = daldevice_attach(DALDEVICEID_AUDIO_QDSP,
"DAL_AQ_AUD",
1/*DALRPC_DEST_QDSP*/,
&(cad_rpc_data_type.remote_handle));
if (err) {
pr_err("RPC call to Q6 attach failed\n");
mutex_unlock(&cad_rpc_data_type.resource_mutex);
return err;
}
D("Attached for session %d!\n", session_id);
/* get physical addresss of the buffer */
memset(&info, 0, sizeof(struct cad_rpc_config_info));
info.domain_id = cad_rpc_data_type.processor_id;
info.cb_evt = dalrpc_alloc_cb(cad_rpc_data_type.
remote_handle,
&remote_cb_function, &cad_rpc_data_type);
D("Try to configure the remote session %d!\n", session_id);
/* initlize the rpc call */
err = dalrpc_fcn_5(ADSP_RPC_INIT,
cad_rpc_data_type.remote_handle,
(void *)&info,
sizeof(struct cad_rpc_config_info));
D("Configured remote session %d!\n", session_id);
mutex_unlock(&cad_rpc_data_type.resource_mutex);
return err;
}
static int __init voice_init(void)
{
int rc, i;
struct voice_data *v = &voice;
MM_INFO("\n"); /* Macro prints the file name and function */
mutex_init(&voice.voc_lock);
mutex_init(&voice.vol_lock);
v->handle = NULL;
v->cb_handle = NULL;
/* set default value */
v->default_mute_val = 1; /* default is mute */
v->default_vol_val = 0;
v->default_sample_val = 8000;
for (i = 0; i < VOC_RX_VOL_ARRAY_NUM; i++) {
v->max_rx_vol[i] = 0;
v->min_rx_vol[i] = 0;
}
v->network = NETWORK_GSM;
/* initialize dev_rx and dev_tx */
memset(&v->dev_tx, 0, sizeof(struct device_data));
memset(&v->dev_rx, 0, sizeof(struct device_data));
v->dev_rx.volume = v->default_vol_val;
v->dev_tx.mute = v->default_mute_val;
v->dev_state = DEV_INIT;
v->voc_state = VOICE_INIT;
atomic_set(&v->rel_start_flag, 0);
atomic_set(&v->acq_start_flag, 0);
v->dev_event = 0;
v->voc_event = 0;
init_completion(&voice.complete);
init_waitqueue_head(&v->dev_wait);
init_waitqueue_head(&v->voc_wait);
/* get device handle */
rc = daldevice_attach(VOICE_DALRPC_DEVICEID,
VOICE_DALRPC_PORT_NAME,
VOICE_DALRPC_CPU,
&v->handle);
if (rc) {
MM_ERR("Voc DALRPC call to Modem attach failed\n");
goto done;
}
/* Allocate the callback handle */
v->cb_handle = dalrpc_alloc_cb(v->handle, remote_cb_function, v);
if (v->cb_handle == NULL) {
MM_ERR("Allocate Callback failure\n");
goto err;
}
/* setup the callback */
rc = voice_cmd_init(v);
if (rc)
goto err1;
v->device_events = AUDDEV_EVT_DEV_CHG_VOICE |
AUDDEV_EVT_DEV_RDY |
AUDDEV_EVT_REL_PENDING |
AUDDEV_EVT_START_VOICE |
AUDDEV_EVT_END_VOICE |
AUDDEV_EVT_DEVICE_VOL_MUTE_CHG |
AUDDEV_EVT_FREQ_CHG;
MM_DBG(" to register call back \n");
/* register callback to auddev */
auddev_register_evt_listner(v->device_events, AUDDEV_CLNT_VOC,
0, voice_auddev_cb_function, v);
/* create and start thread */
v->task = kthread_run(voice_thread, v, "voice");
if (IS_ERR(v->task)) {
rc = PTR_ERR(v->task);
v->task = NULL;
} else
goto done;
err1:
dalrpc_dealloc_cb(v->handle, v->cb_handle);
err:
daldevice_detach(v->handle);
v->handle = NULL;
done:
return rc;
}
static int remotetest_exec(int dest, u64 *val)
{
void *dev_handle;
void *event_handles[3];
void *cb_handle;
int ret;
u64 errmask = 0;
uint32_t ouint;
uint32_t oalen;
/* */
ret = daldevice_attach(REMOTE_UNITTEST_DEVICEID, NULL,
dest, &dev_handle);
if (ret) {
printk(KERN_INFO "%s: failed to attach (%d)\n", __func__, ret);
*val = 0xffffffff;
return 0;
}
/* */
ret = remote_unittest_0(dev_handle, REMOTE_UNITTEST_INARG_1);
if (ret)
rpc_error(0);
/* */
ret = remote_unittest_1(dev_handle, REMOTE_UNITTEST_INARG_1,
REMOTE_UNITTEST_INARG_2);
if (ret)
rpc_error(1);
/* */
ouint = 0;
ret = remote_unittest_2(dev_handle, REMOTE_UNITTEST_INARG_1, &ouint);
if (ret)
rpc_error(2);
else if (ouint != REMOTE_UNITTEST_OUTARG_1)
verify_error(2, "ouint");
/* */
ret = remote_unittest_3(dev_handle, REMOTE_UNITTEST_INARG_1,
REMOTE_UNITTEST_INARG_2,
REMOTE_UNITTEST_INARG_3);
if (ret)
rpc_error(3);
/* */
ouint = 0;
ret = remote_unittest_4(dev_handle, REMOTE_UNITTEST_INARG_1,
REMOTE_UNITTEST_INARG_2, &ouint);
if (ret)
rpc_error(4);
else if (ouint != REMOTE_UNITTEST_OUTARG_1)
verify_error(4, "ouint");
/* */
init_data(&in_data);
ret = remote_unittest_5(dev_handle, &in_data, sizeof(in_data));
if (ret)
rpc_error(5);
/* */
init_data(&in_data);
ret = remote_unittest_6(dev_handle, REMOTE_UNITTEST_INARG_1,
&in_data.test, sizeof(in_data.test));
if (ret)
rpc_error(6);
/* */
init_data(&in_data);
memset(&out_data, 0, sizeof(out_data));
ret = remote_unittest_7(dev_handle, &in_data, sizeof(in_data),
&out_data.test, sizeof(out_data.test),
&oalen);
if (ret)
rpc_error(7);
else if (oalen != sizeof(out_data.test))
verify_error(7, "oalen");
else if (verify_uint32_buffer(out_data.test))
verify_error(7, "obuf");
/* */
init_bytebuf(in_bytebuf);
memset(&out_data, 0, sizeof(out_data));
ret = remote_unittest_8(dev_handle, in_bytebuf, sizeof(in_bytebuf),
&out_data, sizeof(out_data));
if (ret)
rpc_error(8);
else if (verify_data(&out_data))
verify_error(8, "obuf");
/* */
memset(&out_bytebuf, 0, sizeof(out_bytebuf));
ret = remote_unittest_9(dev_handle, out_bytebuf, sizeof(out_bytebuf));
if (ret)
rpc_error(9);
else if (verify_bytebuf(out_bytebuf))
verify_error(9, "obuf");
/* */
init_bytebuf(in_bytebuf);
memset(&out_bytebuf, 0, sizeof(out_bytebuf));
ret = remote_unittest_10(dev_handle, REMOTE_UNITTEST_INARG_1,
in_bytebuf, sizeof(in_bytebuf),
out_bytebuf, sizeof(out_bytebuf), &oalen);
if (ret)
rpc_error(10);
else if (oalen != sizeof(out_bytebuf))
verify_error(10, "oalen");
else if (verify_bytebuf(out_bytebuf))
verify_error(10, "obuf");
/* */
memset(&out_bytebuf, 0, sizeof(out_bytebuf));
ret = remote_unittest_11(dev_handle, REMOTE_UNITTEST_INARG_1,
out_bytebuf, sizeof(out_bytebuf));
if (ret)
rpc_error(11);
else if (verify_bytebuf(out_bytebuf))
verify_error(11, "obuf");
/* */
memset(&out_bytebuf, 0, sizeof(out_bytebuf));
ret = remote_unittest_12(dev_handle, REMOTE_UNITTEST_INARG_1,
out_bytebuf, sizeof(out_bytebuf), &oalen);
if (ret)
rpc_error(12);
else if (oalen != sizeof(out_bytebuf))
verify_error(12, "oalen");
else if (verify_bytebuf(out_bytebuf))
verify_error(12, "obuf");
/* */
init_data(&in_data);
memset(&out_data, 0, sizeof(out_data));
ret = remote_unittest_13(dev_handle, in_data.test, sizeof(in_data.test),
&in_data, sizeof(in_data),
&out_data, sizeof(out_data));
if (ret)
rpc_error(13);
else if (verify_data(&out_data))
verify_error(13, "obuf");
/* */
init_data(&in_data);
memset(out_bytebuf, 0, sizeof(out_bytebuf));
memset(out_bytebuf2, 0, sizeof(out_bytebuf2));
ret = remote_unittest_14(dev_handle,
in_data.test, sizeof(in_data.test),
out_bytebuf, sizeof(out_bytebuf),
out_bytebuf2, sizeof(out_bytebuf2), &oalen);
if (ret)
rpc_error(14);
else if (verify_bytebuf(out_bytebuf))
verify_error(14, "obuf");
else if (oalen != sizeof(out_bytebuf2))
verify_error(14, "oalen");
else if (verify_bytebuf(out_bytebuf2))
verify_error(14, "obuf2");
/* */
init_data(&in_data);
memset(out_bytebuf, 0, sizeof(out_bytebuf));
memset(&out_data, 0, sizeof(out_data));
ret = remote_unittest_15(dev_handle,
in_data.test, sizeof(in_data.test),
&in_data, sizeof(in_data),
&out_data, sizeof(out_data), &oalen,
out_bytebuf, sizeof(out_bytebuf));
if (ret)
rpc_error(15);
else if (oalen != sizeof(out_data))
verify_error(15, "oalen");
else if (verify_bytebuf(out_bytebuf))
verify_error(15, "obuf");
else if (verify_data(&out_data))
verify_error(15, "obuf2");
/* */
event_handles[0] = dalrpc_alloc_event(dev_handle);
event_handles[1] = dalrpc_alloc_event(dev_handle);
event_handles[2] = dalrpc_alloc_event(dev_handle);
cb_handle = dalrpc_alloc_cb(dev_handle, test_cb, &out_data);
in_data.regular_event = (uint32_t)event_handles[2];
in_data.payload_event = (uint32_t)cb_handle;
ret = remote_unittest_eventcfg(dev_handle, &in_data, sizeof(in_data));
if (ret) {
errmask |= (1 << 16);
printk(KERN_INFO "%s: failed to configure asynch (%d)\n",
__func__, ret);
}
/* */
ret = remote_unittest_eventtrig(dev_handle,
REMOTE_UNITTEST_REGULAR_EVENT);
if (ret) {
errmask |= (1 << 17);
printk(KERN_INFO "%s: failed to trigger event (%d)\n",
__func__, ret);
}
ret = dalrpc_event_wait(event_handles[2], 1000);
if (ret) {
errmask |= (1 << 18);
printk(KERN_INFO "%s: failed to receive event (%d)\n",
__func__, ret);
}
/* */
ret = remote_unittest_eventtrig(dev_handle,
REMOTE_UNITTEST_REGULAR_EVENT);
if (ret) {
errmask |= (1 << 19);
printk(KERN_INFO "%s: failed to trigger event (%d)\n",
__func__, ret);
}
ret = dalrpc_event_wait_multiple(3, event_handles, 1000);
if (ret != 2) {
errmask |= (1 << 20);
printk(KERN_INFO "%s: failed to receive event (%d)\n",
__func__, ret);
}
/* */
ret = remote_unittest_eventtrig(dev_handle,
REMOTE_UNITTEST_CALLBACK_EVENT);
if (ret) {
errmask |= (1 << 21);
printk(KERN_INFO "%s: failed to trigger callback (%d)\n",
__func__, ret);
} else
while (block_until_cb)
;
dalrpc_dealloc_cb(dev_handle, cb_handle);
dalrpc_dealloc_event(dev_handle, event_handles[0]);
dalrpc_dealloc_event(dev_handle, event_handles[1]);
dalrpc_dealloc_event(dev_handle, event_handles[2]);
/* */
ret = daldevice_detach(dev_handle);
if (ret) {
errmask |= (1 << 22);
printk(KERN_INFO "%s: failed to detach (%d)\n", __func__, ret);
}
printk(KERN_INFO "%s: remote_unittest complete\n", __func__);
*val = errmask;
return 0;
}
