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); }