static int msm_fsusb_acquire_bus(void)
{
uint32_t data = PM_APP_OTG_ACQUIRE_BUS;
return msm_rpc_client_req(client,
PM_APP_OTG_ACQUIRE_BUS,
msm_fsusb_rpc_arg, &data,
NULL, NULL, -1);
}
static int ping_mdm_register(
struct msm_rpc_client *client,
struct ping_mdm_register_arg *arg,
struct ping_mdm_register_ret *ret)
{
return msm_rpc_client_req(client,
PING_MDM_REGISTER_PROC,
ping_mdm_register_arg, arg,
ping_mdm_register_ret, ret, -1);
}
int msm_fsusb_set_remote_wakeup(void)
{
uint32_t data = PM_APP_OTG_SET_WAKEUP;
return msm_rpc_client_req(client,
PM_APP_OTG_SET_WAKEUP,
msm_fsusb_rpc_arg, &data,
NULL, NULL, -1);
}
static int __init hs_rpc_cb_init(void)
{
int rc = 0, i, num_vers;
num_vers = ARRAY_SIZE(rpc_vers);
for (i = 0; i < num_vers; i++) {
rpc_client = msm_rpc_register_client("hs",
HS_RPC_PROG, rpc_vers[i], 0, hs_cb_func);
if (IS_ERR(rpc_client))
pr_debug("%s: RPC Client version %d failed, fallback\n",
__func__, rpc_vers[i]);
else
break;
}
if (IS_ERR(rpc_client)) {
pr_err("%s: Incompatible RPC version error %ld\n",
__func__, PTR_ERR(rpc_client));
return PTR_ERR(rpc_client);
}
rc = msm_rpc_client_req(rpc_client, HS_SUBSCRIBE_SRVC_PROC,
hs_rpc_register_subs_arg, NULL,
hs_rpc_register_subs_res, NULL, -1);
if (rc) {
pr_err("%s: RPC client request failed for subscribe services\n",
__func__);
goto err_client_req;
}
rc = msm_rpc_client_req(rpc_client, HS_PROCESS_CMD_PROC,
hs_rpc_pwr_cmd_arg, NULL,
hs_rpc_pwr_cmd_res, NULL, -1);
if (rc)
pr_err("%s: RPC client request failed for pwr key"
" delay cmd, using normal mode\n", __func__);
return 0;
err_client_req:
msm_rpc_unregister_client(rpc_client);
return rc;
}
static int ping_mdm_unregister_data_cb(
struct msm_rpc_client *client,
struct ping_mdm_unregister_data_cb_arg *arg,
struct ping_mdm_unregister_data_cb_ret *ret)
{
return msm_rpc_client_req(client,
PING_MDM_UNREGISTER_DATA_CB_PROC,
ping_mdm_data_cb_unregister_arg, arg,
ping_mdm_data_cb_register_ret, ret, -1);
}
static void led_rpc_set_status(struct msm_rpc_client *client,
enum tricolor_led_status status)
{
int rc;
rc = msm_rpc_client_req(client, LED_CMD_PROC,
led_send_cmd_arg, &status, led_rpc_res, NULL, -1);
if (rc)
pr_err("%s: RPC client request for led failed", __func__);
}
int oem_rapi_client_streaming_function(
struct msm_rpc_client *client,
struct oem_rapi_client_streaming_func_arg *arg,
struct oem_rapi_client_streaming_func_ret *ret)
{
return msm_rpc_client_req(client,
OEM_RAPI_STREAMING_FUNCTION_PROC,
oem_rapi_client_streaming_function_arg, arg,
oem_rapi_client_streaming_function_ret,
ret, -1);
}
/* Returns: 0 on succes and
* -1 on failure
*/
int adie_svc_put(int id)
{
int rc = 0;
struct adie_svc_client_deregister_cb_args arg;
if (id < 0 || id >= ADIE_SVC_MAX_CLIENTS)
return -1;
mutex_lock(&adie_client[id].lock);
if (adie_client[id].client_id == -1 ||
adie_client[id].rpc_client == NULL) {
mutex_unlock(&adie_client[id].lock);
return -1;
}
arg.client_id = adie_client[id].client_id;
adie_client[id].adie_svc_cb_done = 0;
mutex_unlock(&adie_client[id].lock);
rc = msm_rpc_client_req(adie_client[id].rpc_client,
SND_ADIE_SVC_CLIENT_DEREGISTER_PROC,
adie_svc_client_deregister_arg, &arg,
NULL, NULL, -1);
if (!rc) {
rc = wait_event_interruptible(adie_client[id].wq,
adie_client[id].adie_svc_cb_done);
if (unlikely(rc < 0)) {
if (rc == -ERESTARTSYS)
MM_ERR("wait_event_interruptible "
"returned -ERESTARTSYS\n");
else
MM_ERR("wait_event_interruptible "
"returned error\n");
rc = -1;
goto err;
}
MM_DBG("Status received from CB function\n");
mutex_lock(&adie_client[id].lock);
if (adie_client[id].status == ADIE_SVC_STATUS_FAILURE) {
rc = -1;
} else {
msm_rpc_unregister_client(adie_client[id].rpc_client);
adie_client[id].rpc_client = NULL;
adie_client[id].client_id = -1;
adie_client[id].cb_id = MSM_RPC_CLIENT_NULL_CB_ID;
adie_client[id].adie_svc_cb_done = 0;
}
mutex_unlock(&adie_client[id].lock);
} else {
MM_ERR("Failed to send deregister client request\n");
rc = -1;
}
err:
return rc;
}
/* Returns: 0 on success
* 2 already in use
* -1 on failure
*/
int adie_svc_config_adie_block(int id,
enum adie_block_enum_type adie_block_type, bool enable)
{
int rc = 0;
struct adie_svc_config_adie_block_cb_args arg;
if (id < 0 || id >= ADIE_SVC_MAX_CLIENTS)
return -1;
mutex_lock(&adie_client[id].lock);
if (adie_client[id].client_id == -1 ||
adie_client[id].rpc_client == NULL) {
mutex_unlock(&adie_client[id].lock);
return -1;
}
arg.client_id = adie_client[id].client_id;
arg.adie_block = adie_block_type;
arg.config = (enum adie_config_enum_type)enable;
adie_client[id].adie_svc_cb_done = 0;
mutex_unlock(&adie_client[id].lock);
rc = msm_rpc_client_req(adie_client[id].rpc_client,
SND_ADIE_SVC_CONFIG_ADIE_BLOCK_PROC,
adie_svc_config_adie_block_arg, &arg,
NULL, NULL, -1);
if (!rc) {
rc = wait_event_interruptible(adie_client[id].wq,
adie_client[id].adie_svc_cb_done);
if (unlikely(rc < 0)) {
if (rc == -ERESTARTSYS)
MM_ERR("wait_event_interruptible "
"returned -ERESTARTSYS\n");
else
MM_ERR("wait_event_interruptible "
"returned error\n");
rc = -1;
goto err;
}
MM_DBG("Status received from CB function\n");
mutex_lock(&adie_client[id].lock);
if (adie_client[id].status == ADIE_SVC_STATUS_FAILURE)
rc = -1;
else
rc = adie_client[id].status;
mutex_unlock(&adie_client[id].lock);
} else {
MM_ERR("Failed to send adie block config request\n");
rc = -1;
}
err:
return rc;
}
int msm_pm_app_register_vbus_sn(void (*callback)(int online))
{
uint32_t cb_id = msm_rpc_add_cb_func(client, (void *)callback);
/* In case of NULL callback funtion, cb_id would be -1 */
if ((int) cb_id < -1)
return cb_id;
return msm_rpc_client_req(client,
rpc_ids.reg_for_vbus_valid,
vbus_sess_valid_arg_cb,
&cb_id, NULL, NULL, -1);
}
/*Use RPC set rtc alarm time to ARM9*/
int
msmrtc_remote_rtc_set_alarm(struct timespec *tm)
{
int rc;
printk("Rtc-msm alarm time is %ld\n",tm->tv_sec);
rc = msm_rpc_client_req(huawei_alarm_client,TIMEREMOTE_PROCEEDURE_SET_ALARM,
msmrtcalarm_tod_proc_args,&tm->tv_sec,
NULL,NULL,-1);
if (rc) {
printk("%s: rtc time (TOD) could not be set\n", __func__);
return rc;
}
return 0;
}
void report_headset_status(bool connected)
{
int rc = -1;
enum hs_src_state status;
if (connected == true)
status = HS_SRC_STATE_HI;
else
status = HS_SRC_STATE_LO;
rc = msm_rpc_client_req(rpc_client, HS_REPORT_EVNT_PROC,
hs_rpc_report_event_arg, &status,
hs_rpc_report_event_res, NULL, -1);
if (rc)
pr_err("%s: couldn't send rpc client request\n", __func__);
}
int msm_pm_app_rpc_init(void (*callback)(int online))
{
uint32_t cb_id, rc;
if (!machine_is_qsd8x50_ffa() && !machine_is_qsd8x50a_ffa()
&& !machine_is_msm7x27_ffa())
return -ENOTSUPP;
client = msm_rpc_register_client("pmapp_usb",
PMAPP_RPC_PROG,
PMAPP_RPC_VER_2_1, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client)) {
rpc_pmapp_init_rpc_ids(PMAPP_RPC_VER_2_1);
goto done;
}
client = msm_rpc_register_client("pmapp_usb",
PMAPP_RPC_PROG,
PMAPP_RPC_VER_1_2, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client)) {
rpc_pmapp_init_rpc_ids(PMAPP_RPC_VER_1_2);
goto done;
}
client = msm_rpc_register_client("pmapp_usb",
PMAPP_RPC_PROG,
PMAPP_RPC_VER_1_1, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client))
rpc_pmapp_init_rpc_ids(PMAPP_RPC_VER_1_1);
else
return PTR_ERR(client);
done:
cb_id = msm_rpc_add_cb_func(client, (void *)callback);
/* In case of NULL callback funtion, cb_id would be -1 */
if ((int) cb_id < -1)
return cb_id;
rc = msm_rpc_client_req(client,
rpc_ids.reg_for_vbus_valid,
vbus_sess_valid_arg_cb,
&cb_id, NULL, NULL, -1);
return rc;
}
u32 ear_get_adc(void)
{
int rc;
struct msm_ear_get_adc_ret_data rep;
rc = msm_rpc_client_req(ear_client,
EAR_READ_PROC,
NULL, NULL,
msm_ear_get_adc_ret_func, &rep,
msecs_to_jiffies(EAR_RPC_TIMEOUT));
if (rc < 0) {
pr_err("%s: FAIL: mpp4 get adc. rc=%d\n", __func__, rc);
return 0;
}
return rep.ear_adc;
}
u32 msm_pm_vbatt_read_mv(struct msm_rpc_client *clnt)
{
int rc = 0;
struct msm_pm_vbatt_read_mv_ret ret;
rc = msm_rpc_client_req(clnt,
BATTERY_READ_MV_PROC,
NULL,
NULL,
msm_pm_vbatt_read_mv_ret_func,
&ret,
msecs_to_jiffies(BATT_RPC_TIMEOUT));
if (0 > rc) {
pr_err("%s: FAIL: vbatt get volt. rc=%d\n", __func__, rc);
return 0;
}
return ret.batt_voltage;
}
static int
msmrtc_timeremote_read_time_secure(struct device *dev, struct rtc_time *tm)
{
int rc;
struct rtc_tod_args rtc_args;
rtc_args.proc = TIMEREMOTE_PROCEEDURE_GET_SECURE_JULIAN;
rtc_args.tm = tm;
rc = msm_rpc_client_req(rpc_client,
TIMEREMOTE_PROCEEDURE_GET_SECURE_JULIAN, msmrtc_tod_proc_args,
&rtc_args, msmrtc_tod_proc_result, &rtc_args, -1);
if (rc) {
pr_err("%s: Error retrieving secure rtc time\n", __func__);
return rc;
}
return 0;
}
/* DTS2011052803245 wangjiongfeng 20110531 end >*/
static int
msmrtc_timeremote_read_time(struct device *dev, struct rtc_time *tm)
{
int rc;
struct rtc_tod_args rtc_args;
struct msm_rtc *rtc_pdata = dev_get_drvdata(dev);
rtc_args.proc = TIMEREMOTE_PROCEEDURE_GET_JULIAN;
rtc_args.tm = tm;
rc = msm_rpc_client_req(rtc_pdata->rpc_client,
TIMEREMOTE_PROCEEDURE_GET_JULIAN,
msmrtc_tod_proc_args, &rtc_args,
msmrtc_tod_proc_result, &rtc_args, -1);
if (rc) {
dev_err(dev, "%s: Error retrieving rtc (TOD) time\n", __func__);
return rc;
}
return 0;
}
/* RPC call-back function for set flag */
static int hw_rpc_set_dev_flag( void )
{
int rc;
hw_dev_dct_flag_t req;
req = get_hw_dev_flag();
rc = msm_rpc_client_req(hw_dev_rpc_client,
HW_DEV_SET_FLAG_PROC,
hw_dev_set_flag_arg_func, &req,
NULL, NULL,
msecs_to_jiffies(HW_DEV_RPC_TIMEOUT));
if (rc < 0)
{
pr_err("%s: FAIL: i2c dev set flag. rc=%d\n", __func__, rc);
return rc;
}
return 0;
}
static int
msmrtc_timeremote_read_time_secure(struct device *dev, struct rtc_time *tm)
{
int rc;
struct rtc_tod_args rtc_args;
rtc_args.proc = TIMEREMOTE_PROCEEDURE_GET_SECURE_JULIAN;
rtc_args.tm = tm;
rc = msm_rpc_client_req(rpc_client,
TIMEREMOTE_PROCEEDURE_GET_SECURE_JULIAN, msmrtc_tod_proc_args,
&rtc_args, msmrtc_tod_proc_result, &rtc_args, -1);
if (rc) {
pr_err("%s: Error retrieving secure rtc time\n", __func__);
return rc;
}
if (tm->tm_year < 80) {
int rc;
tm->tm_year = 80;
tm->tm_mon = 0;
tm->tm_mday = 1;
tm->tm_hour = 0;
tm->tm_min = 0;
tm->tm_sec = 0;
tm->tm_wday = 2;
rc = msmrtc_timeremote_set_time_secure(dev, tm);
if (rc < 0) {
pr_err("%s: Failed to set default "
"secure time and date.\n", __func__);
return rc;
}
}
return 0;
}
static int
msmrtc_timeremote_set_time(struct device *dev, struct rtc_time *tm)
{
int rc;
struct rtc_tod_args rtc_args;
struct msm_rtc *rtc_pdata = dev_get_drvdata(dev);
struct pid * pid_struct = NULL;
pid_t pid = 0;
struct task_struct *task = NULL;
if (tm->tm_year < 1900)
tm->tm_year += 1900;
if (tm->tm_year < 1970)
return -EINVAL;
pid = sys_getpid();
pid_struct = find_get_pid(pid);
if ( pid_struct ) {
task = pid_task( pid_struct, PIDTYPE_PID);
}
dev_dbg(dev, "%s: %.2u/%.2u/%.4u %.2u:%.2u:%.2u (%.2u) pid:%d %s\n",
__func__, tm->tm_mon, tm->tm_mday, tm->tm_year,
tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday, (int)pid, (task?task->comm:"(null)"));
WARN_ON(1);
rtc_args.proc = TIMEREMOTE_PROCEEDURE_SET_JULIAN;
rtc_args.tm = tm;
rc = msm_rpc_client_req(rtc_pdata->rpc_client,
TIMEREMOTE_PROCEEDURE_SET_JULIAN,
msmrtc_tod_proc_args, &rtc_args,
NULL, NULL, -1);
if (rc) {
dev_err(dev, "%s: rtc time (TOD) could not be set\n", __func__);
return rc;
}
return 0;
}
int msm_pm_vbatt_modify_client(struct msm_rpc_client *clnt,
s32 handle,
u32 desired_batt_voltage,
u32 voltage_direction,
u32 batt_cb_id,
u32 cb_data)
{
int rc = 0;
struct msm_pm_vbatt_modify_client_arg arg;
struct msm_pm_vbatt_modify_client_ret ret;
arg.handle = handle;
arg.vbatt_voltage = desired_batt_voltage;
arg.voltage_direction = voltage_direction;
arg.cb_id = batt_cb_id;
arg.cb_data = cb_data;
rc = msm_rpc_client_req(clnt,
BATTERY_MODIFY_CLIENT_PROC,
msm_pm_vbatt_modify_client_arg_func,
&arg,
msm_pm_vbatt_modify_client_ret_func,
&ret,
msecs_to_jiffies(BATT_RPC_TIMEOUT));
if (0 > rc) {
pr_err("%s: ERROR. failed to modify Vbatt client\n",
__func__);
return rc;
}
if (BATTERY_MODIFICATION_SUCCESSFUL != ret.result) {
pr_err("%s: ERROR. modify client failed. result = %u\n",
__func__, ret.result);
return -EIO;
}
return rc;
}
static int __init hs_rpc_cb_init(void)
{
int rc = 0;
rpc_client = msm_rpc_register_client("hs",
HS_RPC_PROG, HS_RPC_VERS, 0, hs_cb_func);
if (IS_ERR(rpc_client)) {
pr_err("%s: couldn't open rpc client err %ld\n", __func__,
PTR_ERR(rpc_client));
return PTR_ERR(rpc_client);
}
rc = msm_rpc_client_req(rpc_client, HS_SUBSCRIBE_SRVC_PROC,
hs_rpc_register_subs_arg, NULL,
hs_rpc_register_subs_res, NULL, -1);
if (rc) {
pr_err("%s: couldn't send rpc client request\n", __func__);
msm_rpc_unregister_client(rpc_client);
}
return rc;
}
int
#else
static int
#endif
/* } Div2-SW2-BSP-FBX-BATT */
msmrtc_timeremote_read_time(struct device *dev, struct rtc_time *tm)
{
int rc;
struct rtc_tod_args rtc_args;
rtc_args.proc = TIMEREMOTE_PROCEEDURE_GET_JULIAN;
rtc_args.tm = tm;
rc = msm_rpc_client_req(rpc_client, TIMEREMOTE_PROCEEDURE_GET_JULIAN,
msmrtc_tod_proc_args, &rtc_args,
msmrtc_tod_proc_result, &rtc_args, -1);
if (rc) {
pr_err("%s: Error retrieving rtc (TOD) time\n", __func__);
return rc;
}
return 0;
}
int msm_pm_vbatt_enable_disable_filter(struct msm_rpc_client *clnt,
s32 handle,
s32 enable,
u32 filter)
{
int rc = 0;
struct msm_pm_vbatt_enable_disable_filter_arg arg;
struct msm_pm_vbatt_enable_disable_filter_ret ret;
arg.handle = handle;
arg.enable_or_disable_filter = enable;
arg.filter = filter;
rc = msm_rpc_client_req(clnt,
BATTERY_ENABLE_DISABLE_FILTER_PROC,
msm_pm_vbatt_enable_disable_filter_arg_func,
&arg,
msm_pm_vbatt_enable_disable_filter_ret_func,
&ret,
msecs_to_jiffies(BATT_RPC_TIMEOUT));
if (0 > rc) {
pr_err("%s: FAIL: enable vbatt filter. rc=%d\n",
__func__, rc);
return rc;
}
if (BATTERY_DEREGISTRATION_SUCCESSFUL != ret.result) {
pr_err("%s: FAIL: enable vbatt filter: result=%d\n",
__func__, ret.result);
return -EIO;
}
pr_debug("%s: enable vbatt filter: OK\n", __func__);
return rc;
}
static int msmrtc_timeremote_alarm_set(struct device *dev,uint32_t alarmtime)
{
int rc;
struct rtc_alarm_args rtc_args;
struct msm_rtc *rtc_pdata = dev_get_drvdata(dev);
#if 0
unsigned long now = get_seconds();
if (now > alarmtime) {
pr_err("%s: Attempt to set alarm in the past\n", __func__);
return -EINVAL;
}
#endif
rtc_args.proc = TIMEREMOTE_PROCEEDURE_ALARM_SET_PROC;
rtc_args.alarm_time = alarmtime;
rc = msm_rpc_client_req(rtc_pdata->rpc_client, TIMEREMOTE_PROCEEDURE_ALARM_SET_PROC,
msmrtc_alarm_proc_args, &rtc_args, NULL, NULL, -1);
if (rc) {
pr_err("%s: RTC alarm (TOD) could not be set\n", __func__);
return rc;
}
return 0;
}
/* must be called with audio->lock held */
static int audio_enable(struct audio *audio)
{
int rc;
struct snd_voice_pcm_interface_ipclnt_reg_args arg;
struct snd_voice_pcm_interface_ipclnt_reg_status result;
/* voice_pcm_interface_type */
arg.interface = VOICE_PCM_INTERFACE_TX_INPUT;
/* Should be non-zero, unique */
arg.callback_id = START_CALLBACK_ID;
/* Start Voice PCM interface */
rc = msm_rpc_client_req(audio->client,
SND_VOC_REGISTER_PCM_INPUT_CLIENT_PROC,
snd_voice_pcm_interface_ipclnt_reg_args, &arg,
snd_voice_pcm_interface_ipclnt_reg_status,
&result, -1);
MM_DBG("input client registration status rc 0x%8x result 0x%8x\n",
rc, result.status);
/* If error in server side */
if (rc == 0)
if (result.status != SUCCESS)
rc = -ENODEV;
return rc;
}
static int oem_rapi_client_null(struct msm_rpc_client *client,
void *arg, void *ret)
{
return msm_rpc_client_req(client, OEM_RAPI_NULL_PROC,
NULL, NULL, NULL, NULL, -1);
}
static int __devinit tricolor_led_probe(struct platform_device *pdev)
{
const struct led_platform_data *pdata = pdev->dev.platform_data;
struct msm_rpc_client *rpc_client;
struct led_info *curr_led;
struct tricolor_led_data *led, *tmp_led;
int rc, i, j;
if (!pdata) {
dev_err(&pdev->dev, "platform data not supplied\n");
return -EINVAL;
}
/* initialize rpc client */
rpc_client = msm_rpc_register_client("led", LED_RPC_PROG,
LED_RPC_VER, 0, led_cb_func);
rc = IS_ERR(rpc_client);
if (rc) {
dev_err(&pdev->dev, "failed to initialize rpc_client\n");
return -EINVAL;
}
/* subscribe */
rc = msm_rpc_client_req(rpc_client, LED_SUBSCRIBE_PROC,
led_rpc_register_subs_arg, NULL,
led_rpc_res, NULL, -1);
if (rc) {
pr_err("%s: RPC client request failed for subscribe services\n",
__func__);
goto fail_mem_alloc;
}
led = devm_kzalloc(&pdev->dev, pdata->num_leds * sizeof(*led),
GFP_KERNEL);
if (!led) {
dev_err(&pdev->dev, "failed to alloc memory\n");
rc = -ENOMEM;
goto fail_mem_alloc;
}
for (i = 0; i < pdata->num_leds; i++) {
curr_led = &pdata->leds[i];
tmp_led = &led[i];
tmp_led->cdev.name = curr_led->name;
tmp_led->cdev.default_trigger = curr_led->default_trigger;
tmp_led->cdev.brightness_set = tricolor_led_set;
tmp_led->cdev.brightness_get = tricolor_led_get;
tmp_led->cdev.brightness = LED_OFF;
tmp_led->cdev.max_brightness = LED_FULL;
tmp_led->color = curr_led->flags;
tmp_led->rpc_client = rpc_client;
tmp_led->blink_status = false;
mutex_init(&tmp_led->lock);
rc = led_classdev_register(&pdev->dev, &tmp_led->cdev);
if (rc) {
dev_err(&pdev->dev, "failed to register led %s(%d)\n",
tmp_led->cdev.name, rc);
goto fail_led_reg;
}
/* Add blink attributes */
rc = device_create_file(tmp_led->cdev.dev, &dev_attr_blink);
if (rc) {
dev_err(&pdev->dev, "failed to create blink attr\n");
goto fail_blink_attr;
}
dev_set_drvdata(tmp_led->cdev.dev, tmp_led);
}
platform_set_drvdata(pdev, led);
return 0;
fail_blink_attr:
j = i;
while (j)
device_remove_file(led[--j].cdev.dev, &dev_attr_blink);
i++;
fail_led_reg:
while (i) {
led_classdev_unregister(&led[--i].cdev);
mutex_destroy(&led[i].lock);
}
fail_mem_alloc:
msm_rpc_unregister_client(rpc_client);
return rc;
}
/* Returns : client id on success
* and -1 on failure
*/
int adie_svc_get(void)
{
int id, rc = 0;
struct adie_svc_client_register_cb_args arg;
mutex_lock(&adie_client_lock);
for (id = 0; id < ADIE_SVC_MAX_CLIENTS; id++) {
if (adie_client[id].client_id == -1 &&
adie_client[id].rpc_client == NULL)
break;
}
if (id == ADIE_SVC_MAX_CLIENTS) {
mutex_unlock(&adie_client_lock);
return -1;
}
mutex_lock(&adie_client[id].lock);
adie_client[id].rpc_client = msm_rpc_register_client("adie_client",
ADIE_SVC_PROG,
ADIE_SVC_VERS, 1,
adie_svc_rpc_cb_func);
if (IS_ERR(adie_client[id].rpc_client)) {
MM_ERR("Failed to register RPC client\n");
adie_client[id].rpc_client = NULL;
mutex_unlock(&adie_client[id].lock);
mutex_unlock(&adie_client_lock);
return -1;
}
mutex_unlock(&adie_client_lock);
adie_client[id].adie_svc_cb_done = 0;
arg.cb_id = id;
adie_client[id].cb_id = arg.cb_id;
mutex_unlock(&adie_client[id].lock);
rc = msm_rpc_client_req(adie_client[id].rpc_client,
SND_ADIE_SVC_CLIENT_REGISTER_PROC,
adie_svc_client_register_arg, &arg,
NULL, NULL, -1);
if (!rc) {
rc = wait_event_interruptible(adie_client[id].wq,
adie_client[id].adie_svc_cb_done);
mutex_lock(&adie_client[id].lock);
if (unlikely(rc < 0)) {
if (rc == -ERESTARTSYS)
MM_ERR("wait_event_interruptible "
"returned -ERESTARTSYS\n");
else
MM_ERR("wait_event_interruptible "
"returned error\n");
rc = -1;
goto err;
}
MM_DBG("Status %d received from CB function, id %d rc %d\n",
adie_client[id].status, adie_client[id].client_id, rc);
rc = id;
if (adie_client[id].status == ADIE_SVC_STATUS_FAILURE) {
MM_ERR("Received failed status for register request\n");
rc = -1;
} else
goto done;
} else {
MM_ERR("Failed to send register client request\n");
rc = -1;
mutex_lock(&adie_client[id].lock);
}
err:
msm_rpc_unregister_client(adie_client[id].rpc_client);
adie_client[id].rpc_client = NULL;
adie_client[id].client_id = -1;
adie_client[id].cb_id = MSM_RPC_CLIENT_NULL_CB_ID;
adie_client[id].adie_svc_cb_done = 0;
done:
mutex_unlock(&adie_client[id].lock);
return rc;
}
static int ping_mdm_null(struct msm_rpc_client *client,
void *arg, void *ret)
{
return msm_rpc_client_req(client, PING_MDM_NULL_PROC,
NULL, NULL, NULL, NULL, -1);
}
