Exemple #1
0
static int adie_svc_rpc_cb_func(struct msm_rpc_client *client,
                                void *buffer, int in_size)
{
    int rc = 0;
    struct rpc_request_hdr *req;

    req = (struct rpc_request_hdr *)buffer;

    MM_DBG("procedure received to rpc cb %d\n",
           be32_to_cpu(req->procedure));
    switch (be32_to_cpu(req->procedure)) {
    case ADIE_SVC_CLIENT_STATUS_FUNC_PTR_TYPE_PROC:
        rc = adie_svc_process_cb(client, buffer, in_size);
        break;
    default:
        MM_ERR("%s: procedure not supported %d\n", __func__,
               be32_to_cpu(req->procedure));
        msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
                                     RPC_ACCEPTSTAT_PROC_UNAVAIL);
        rc = msm_rpc_send_accepted_reply(client, 0);
        if (rc)
            MM_ERR("%s: sending reply failed: %d\n", __func__, rc);
        break;
    }
    return rc;
}
static int hs_cb_func(struct msm_rpc_client *client, void *buffer, int in_size)
{
	int rc = -1;

	struct rpc_request_hdr *hdr = buffer;

	hdr->type = be32_to_cpu(hdr->type);
	hdr->xid = be32_to_cpu(hdr->xid);
	hdr->rpc_vers = be32_to_cpu(hdr->rpc_vers);
	hdr->prog = be32_to_cpu(hdr->prog);
	hdr->vers = be32_to_cpu(hdr->vers);
	hdr->procedure = be32_to_cpu(hdr->procedure);

	process_hs_rpc_request(hdr->procedure,
			    (void *) (hdr + 1));

	msm_rpc_start_accepted_reply(client, hdr->xid,
				     RPC_ACCEPTSTAT_SUCCESS);
	rc = msm_rpc_send_accepted_reply(client, 0);
	if (rc) {
		pr_err("%s: sending reply failed: %d\n", __func__, rc);
		return rc;
	}

	return 0;
}
Exemple #3
0
static int pcm_interface_process_callback_routine(struct msm_rpc_client *client,
	void *buffer, int in_size)
{
	struct rpc_request_hdr *req;
	struct audio *audio = &the_audio;
	int rc = 0;

	req = (struct rpc_request_hdr *)buffer;

	MM_DBG("proc id = 0x%8x xid = 0x%8x size = 0x%8x\n",
		be32_to_cpu(req->procedure), be32_to_cpu(req->xid), in_size);
	switch (be32_to_cpu(req->procedure)) {
	/* Procedure which called every 20ms for PCM samples request*/
	case SND_VOC_PCM_CLIENT_INPUT_FN_TYPE_PROC:
		process_callback(audio, buffer, in_size);
		break;
	default:
		MM_ERR("Not supported proceudure 0x%8x\n",
			be32_to_cpu(req->procedure));
		/* Not supported RPC Procedure, send nagative code */
		msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
				RPC_ACCEPTSTAT_PROC_UNAVAIL);
		msm_rpc_send_accepted_reply(client, 0);
	}
	return rc;
}
static int vbus_notification_cb(struct msm_rpc_client *client,
				void *buffer, int in_size)
{
	struct vbus_sn_notification_args *args;
	struct rpc_request_hdr *req = buffer;
	int rc;
	uint32_t accept_status;
	void (*cb_func)(int);
	uint32_t cb_id;
	int vbus;

	args = (struct vbus_sn_notification_args *) (req + 1);
	cb_id = be32_to_cpu(args->cb_id);
	vbus = be32_to_cpu(args->vbus);

	cb_func = msm_rpc_get_cb_func(client, cb_id);
	if (cb_func) {
		cb_func(!vbus);
		accept_status = RPC_ACCEPTSTAT_SUCCESS;
	} else
		accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;

	msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
				     accept_status);
	rc = msm_rpc_send_accepted_reply(client, 0);
	if (rc)
		pr_err("%s: send accepted reply failed: %d\n", __func__, rc);

	return rc;
}
static int ping_mdm_cb_func(struct msm_rpc_client *client,
			    void *buffer, int in_size)
{
	int rc = 0;
	struct rpc_request_hdr *req;

	req = (struct rpc_request_hdr *)buffer;

	switch (be32_to_cpu(req->procedure)) {
	case PING_MDM_CB_PROC:
		rc = ping_mdm_register_cb(client, buffer, in_size);
		break;
	case PING_MDM_DATA_CB_PROC:
		rc = ping_mdm_data_cb(client, buffer, in_size);
		break;
	default:
		pr_err("%s: procedure not supported %d\n", __func__,
		       be32_to_cpu(req->procedure));
		msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
					     RPC_ACCEPTSTAT_PROC_UNAVAIL);
		rc = msm_rpc_send_accepted_reply(client, 0);
		if (rc)
			pr_err("%s: sending reply failed: %d\n", __func__, rc);
		break;
	}
	return rc;
}
static int ping_mdm_register_cb(struct msm_rpc_client *client,
				 void *buffer, int in_size)
{
	int rc;
	uint32_t accept_status;
	struct rpc_request_hdr *req;
	struct ping_mdm_register_cb_arg arg, *buf_ptr;
	void *cb_func;

	req = (struct rpc_request_hdr *)buffer;
	buf_ptr = (struct ping_mdm_register_cb_arg *)(req + 1);

	arg.cb_id = be32_to_cpu(buf_ptr->cb_id);
	arg.val = be32_to_cpu(buf_ptr->val);

	cb_func = msm_rpc_get_cb_func(client, arg.cb_id);
	if (cb_func) {
		rc = ((int (*)(struct ping_mdm_register_cb_arg *, void *))
		      cb_func)(&arg, NULL);
		if (rc)
			accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
		else
			accept_status = RPC_ACCEPTSTAT_SUCCESS;
	} else
		accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;

	msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
				     accept_status);
	rc = msm_rpc_send_accepted_reply(client, 0);
	if (rc)
		pr_err("%s: send accepted reply failed: %d\n", __func__, rc);

	return rc;
}
Exemple #7
0
static int msm_lightsensor_cb_func(struct msm_rpc_client *client,
			    void *buffer, int in_size)
{
	int rc = 0;
	struct rpc_request_hdr *req;
	u32 procedure;
	u32 accept_status;

	req = (struct rpc_request_hdr *)buffer;
	procedure = be32_to_cpu(req->procedure);

	switch (procedure) {
	case LIGHTSENSOR_CB_TYPE_PROC:
		accept_status = RPC_ACCEPTSTAT_SUCCESS;
		break;

	default:
		accept_status = RPC_ACCEPTSTAT_PROC_UNAVAIL;
		pr_err("%s: ERROR. procedure (%d) not supported\n",
		       __func__, procedure);
		break;
	}

	msm_rpc_start_accepted_reply(light_client,
			be32_to_cpu(req->xid), accept_status);

	rc = msm_rpc_send_accepted_reply(light_client, 0);
	if (rc)
		pr_err("%s: FAIL: sending reply. rc=%d\n", __func__, rc);

	/*if (accept_status == RPC_ACCEPTSTAT_SUCCESS)
		msm_batt_update_psy_status();*/

	return rc;
}
Exemple #8
0
/* Server will Callback this function and reply procedure code for checking it*/
static int batt_cb_func(struct msm_rpc_client *client, void *buffer, int in_size)
{
	int ret = 0;
	struct rpc_request_hdr *req;
	req = (struct rpc_request_hdr *)buffer;

	switch (be32_to_cpu(req->procedure)) {
	case CHARGER_NOTIFY_CB_PROC:
		schedule_work(&battery_data->work);
		pr_info("[BATT] batt_cb_func start +++++++++++ \n");
		msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
						RPC_ACCEPTSTAT_SUCCESS);
		pr_info("[BATT] msm_rpc_send_accepted_reply start \n");
		ret = msm_rpc_send_accepted_reply(client, 0);
		pr_info("[BATT] msm_rpc_send_accepted_reply done \n");
		if (ret)
			pr_err("[BATT] msm_rpc_send_accepted_reply error \n");
		break;
	default:
		pr_err("[BATT] %s: procedure not supported %d\n", __func__,
						be32_to_cpu(req->procedure));
		break;
	}
	pr_info("[BATT] batt_cb_func finish ---------\n");
	return ret;
}
static int msmrtc_cb_func(struct msm_rpc_client *client, void *buffer, int size)
{
	int rc = -1;
	struct rpc_request_hdr *recv = buffer;

	recv->xid = be32_to_cpu(recv->xid);
	recv->type = be32_to_cpu(recv->type);
	recv->rpc_vers = be32_to_cpu(recv->rpc_vers);
	recv->prog = be32_to_cpu(recv->prog);
	recv->vers = be32_to_cpu(recv->vers);
	recv->procedure = be32_to_cpu(recv->procedure);

	if (recv->procedure == RTC_EVENT_CB_PROC)
		process_cb_request((void *) (recv + 1));

	msm_rpc_start_accepted_reply(client, recv->xid,
				RPC_ACCEPTSTAT_SUCCESS);

	rc = msm_rpc_send_accepted_reply(client, 0);
	if (rc) {
		pr_debug("%s: sending reply failed: %d\n", __func__, rc);
		return rc;
	}

	return 0;
}
static int ping_mdm_data_cb(struct msm_rpc_client *client,
			     void *buffer, int in_size)
{
	struct rpc_request_hdr *req;
	int rc, i;
	void *buf, *cb_func, *reply;
	uint32_t size, accept_status;
	struct ping_mdm_register_data_cb_cb_arg arg;
	struct ping_mdm_register_data_cb_cb_ret ret;

	req = (struct rpc_request_hdr *)buffer;
	buf = (void *)(req + 1);

	arg.cb_id = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);

	size = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);
	if (size) {
		arg.data = kmalloc((size * sizeof(*arg.data)), GFP_KERNEL);
		if (arg.data)
			for (i = 0; i < size; i++)
				arg.data[i] =
				  be32_to_cpu(*((uint32_t *)buf + i));
	}
	buf += sizeof(uint32_t) * size;

	arg.size = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);

	arg.sum = be32_to_cpu(*(uint32_t *)buf);

	cb_func = msm_rpc_get_cb_func(client, arg.cb_id);
	if (cb_func) {
		rc = ((int (*)
		       (struct ping_mdm_register_data_cb_cb_arg *,
			struct ping_mdm_register_data_cb_cb_ret *))
		      cb_func)(&arg, &ret);
		if (rc)
			accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
		else
			accept_status = RPC_ACCEPTSTAT_SUCCESS;
	} else
		accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;

	reply = msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
					     accept_status);

	size = 0;
	if (accept_status == RPC_ACCEPTSTAT_SUCCESS) {
		*(uint32_t *)reply = cpu_to_be32(ret.result);
		size = sizeof(uint32_t);
	}
	rc = msm_rpc_send_accepted_reply(client, size);
	if (rc)
		pr_err("%s: send accepted reply failed: %d\n", __func__, rc);

	return rc;
}
static int msm_fsusb_cb_func(struct msm_rpc_client *client,
			    void *buffer, int in_size)
{
	struct rpc_request_hdr *req;
	int rc;

	req = buffer;

	msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
				     RPC_ACCEPTSTAT_SUCCESS);
	rc = msm_rpc_send_accepted_reply(client, 0);
	if (rc) {
		pr_err("%s: sending reply failed: %d\n", __func__, rc);
		return rc;
	}

	switch (be32_to_cpu(req->procedure)) {
	case PM_APP_OTG_INIT_DONE_CB_PROC: {
		pr_debug("pm_app_otg_init_done callback received");
		msm_fsusb_request_session();
		break;
	}
	case PM_APP_OTG_HOST_INIT_CB_PROC: {
		pr_debug("pm_app_otg_host_init_cb_proc callback received");
		host_ops->request(host_ops->handle, REQUEST_START);
		break;
	}
	case PM_APP_OTG_REMOTE_DEV_LOST_CB_PROC: {
		pr_debug("pm_app_otg_remote_dev_lost_cb_proc"
				" callback received");
		msm_fsusb_acquire_bus();
		host_ops->request(host_ops->handle, REQUEST_STOP);
		break;
	}
	case PM_APP_OTG_REMOTE_DEV_RESUMED_CB_PROC: {
		pr_debug("pm_app_otg_remote_dev_resumed_cb_proc"
				"callback received");
		host_ops->request(host_ops->handle, REQUEST_RESUME);
		break;
	}
	case PM_APP_OTG_ERROR_NOTIFY_CB_PROC: {
		pr_err("pm_app_otg_error_notify_cb_proc callback received");
		break;
	}
	default:
		pr_err("%s: unknown callback(proc = %d) received\n",
					__func__, req->procedure);
	}
	return 0;
}
static int pm_app_usb_cb_func(struct msm_rpc_client *client,
				void *buffer, int in_size)
{
	int rc;
	struct rpc_request_hdr *req = buffer;

	switch (be32_to_cpu(req->procedure)) {
	case VBUS_SESS_VALID_CB_PROC:
		rc = vbus_notification_cb(client, buffer, in_size);
		break;
	default:
		pr_err("%s: procedure not supported %d\n", __func__,
		       be32_to_cpu(req->procedure));
		msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
					     RPC_ACCEPTSTAT_PROC_UNAVAIL);
		rc = msm_rpc_send_accepted_reply(client, 0);
		if (rc)
			pr_err("%s: sending reply failed: %d\n", __func__, rc);
		break;
	}
	return rc;
}
Exemple #13
0
static int adie_svc_process_cb(struct msm_rpc_client *client,
                               void *buffer, int in_size)
{
    int rc, id;
    uint32_t accept_status;
    struct rpc_request_hdr *req;
    struct adie_svc_client_register_cb_cb_args arg, *buf_ptr;

    req = (struct rpc_request_hdr *)buffer;
    for (id = 0; id < ADIE_SVC_MAX_CLIENTS; id++) {
        if (adie_client[id].rpc_client == client)
            break;
    }
    if (id == ADIE_SVC_MAX_CLIENTS) {
        MM_ERR("RPC reply with invalid rpc client\n");
        accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
        goto err;
    }

    buf_ptr = (struct adie_svc_client_register_cb_cb_args *)(req + 1);
    arg.cb_id		= be32_to_cpu(buf_ptr->cb_id);
    arg.size		= be32_to_cpu(buf_ptr->size);
    arg.client_id		= be32_to_cpu(buf_ptr->client_id);
    arg.adie_block		= be32_to_cpu(buf_ptr->adie_block);
    arg.status		= be32_to_cpu(buf_ptr->status);
    arg.client_operation	= be32_to_cpu(buf_ptr->client_operation);

    if (arg.cb_id != adie_client[id].cb_id) {
        MM_ERR("RPC reply with invalid invalid cb_id\n");
        accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
        goto err;
    }

    mutex_lock(&adie_client[id].lock);
    switch (arg.client_operation) {
    case ADIE_SVC_REGISTER_CLIENT:
        MM_DBG("ADIE_SVC_REGISTER_CLIENT callback\n");
        adie_client[id].client_id = arg.client_id;
        break;
    case ADIE_SVC_DEREGISTER_CLIENT:
        MM_DBG("ADIE_SVC_DEREGISTER_CLIENT callback\n");
        break;
    case ADIE_SVC_CONFIG_ADIE_BLOCK:
        MM_DBG("ADIE_SVC_CONFIG_ADIE_BLOCK callback\n");
        if (adie_client[id].client_id != arg.client_id) {
            mutex_unlock(&adie_client[id].lock);
            accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
            goto err;
        }
        break;
    default:
        accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
        goto err;
    }

    adie_client[id].status = arg.status;
    adie_client[id].adie_svc_cb_done = 1;
    mutex_unlock(&adie_client[id].lock);
    wake_up(&adie_client[id].wq);
    accept_status = RPC_ACCEPTSTAT_SUCCESS;

err:
    msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
                                 accept_status);
    rc = msm_rpc_send_accepted_reply(client, 0);
    if (rc)
        MM_ERR("%s: send accepted reply failed: %d\n", __func__, rc);

    return rc;
}
Exemple #14
0
static void process_callback(struct audio *audio,
	void *buffer, int in_size)
{
	uint32_t accept_status = RPC_ACCEPTSTAT_SUCCESS;
	struct rpc_request_hdr *req;
	struct snd_voice_pcm_interface_ipclnt_fn_type_args arg, *buf_ptr;
	struct snd_voice_pcm_interface_ipclnt_fn_type_reply *reply;
	struct buffer *frame;
	uint32_t status;
	uint32_t pcm_data_len;

	req = (struct rpc_request_hdr *)buffer;
	buf_ptr = (struct snd_voice_pcm_interface_ipclnt_fn_type_args *)\
				(req + 1);
	arg.callback_id = be32_to_cpu(buf_ptr->callback_id);
	arg.pcm_data_ptr_not_null = be32_to_cpu(buf_ptr->pcm_data_ptr_not_null);
	arg.pcm_data_max_length = be32_to_cpu(buf_ptr->pcm_data_max_length);

	MM_DBG("callback_id = 0x%8x pcm_data_ptr_not_null = 0x%8x"\
		"pcm_data_max_length = 0x%8x\n", arg.callback_id,\
		arg.pcm_data_ptr_not_null, arg.pcm_data_max_length);
	/* Flag interface as running */
	if (!audio->running)
		audio->running = 1;
	if (!arg.pcm_data_ptr_not_null) {
		accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
		msm_rpc_start_accepted_reply(audio->client,
			be32_to_cpu(req->xid), accept_status);
		msm_rpc_send_accepted_reply(audio->client, 0);
		return;
	}
	reply = (struct snd_voice_pcm_interface_ipclnt_fn_type_reply *)
		msm_rpc_start_accepted_reply(audio->client,
			be32_to_cpu(req->xid), accept_status);
	frame = audio->out + audio->out_tail;
	/* If Data available, send data */
	if (frame->used) {
		int i;
		unsigned short *src = frame->data;
		atomic_add(frame->used, &audio->out_bytes);
		status = VOICE_PCM_DATA_STATUS_AVAILABLE;
		pcm_data_len = MAX_VOC_FRAME_SIZE;
		xdr_send_int32(&audio->client->cb_xdr, &status);
		xdr_send_int32(&audio->client->cb_xdr, &pcm_data_len);
		/* Expected cb_xdr buffer size is more than PCM buffer size */
		for (i = 0; i < MAX_VOC_FRAME_SIZE; i++, ++src)
			xdr_send_int16(&audio->client->cb_xdr, src);
		frame->used = 0;
		audio->out_tail = ((++audio->out_tail) % MAX_VOC_FRAMES);
		wake_up(&audio->wait);
	} else {
		status = VOICE_PCM_DATA_STATUS_UNAVAILABLE;
		pcm_data_len = 0;
		xdr_send_int32(&audio->client->cb_xdr, &status);
		xdr_send_int32(&audio->client->cb_xdr, &pcm_data_len);
		wake_up(&audio->wait);
		/* Flag all buffer completed */
		if (audio->stopped) {
			audio->buffer_finished = 1;
			wake_up(&audio->stop_wait);
		}
	}
	MM_DBG("Provided PCM data = 0x%8x\n", reply->status);
	msm_rpc_send_accepted_reply(audio->client, 0);
	return;
}
static int oem_rapi_client_cb(struct msm_rpc_client *client,
			      void *buffer, int in_size)
{
	struct rpc_request_hdr *req;
	void *buf, *cb_func, *reply;
	uint32_t cb_id, accept_status, size;
	int rc;

	struct oem_rapi_client_streaming_func_cb_arg arg;
	struct oem_rapi_client_streaming_func_cb_ret ret;

	arg.input = NULL;
	ret.out_len = NULL;
	ret.output = NULL;

	req = (struct rpc_request_hdr *)buffer;
	buf = (void *)(req + 1);

	/* cb_id */
	cb_id = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);

	/* enum */
	arg.event = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);

	/* handle */
	arg.handle = (void *)be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);

	/* in_len */
	arg.in_len = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);

	/* input */
	size = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);
	if (size) {
		arg.input = kmalloc(size, GFP_KERNEL);
		if (arg.input)
			memcpy(arg.input, buf, size);
		else {
			accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
			goto oem_rapi_send_ack;
		}
	}
	buf += size;
	if (size & 0x3)
		buf += 4 - (size & 0x3);

	/* out_len */
	arg.out_len_valid = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);
	if (arg.out_len_valid) {
		ret.out_len = kmalloc(sizeof(*ret.out_len), GFP_KERNEL);
		if (!ret.out_len) {
			accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
			goto oem_rapi_send_ack;
		}
	}

	/* out */
	arg.output_valid = be32_to_cpu(*(uint32_t *)buf);
	buf += sizeof(uint32_t);
	if (arg.output_valid) {
		arg.output_size = be32_to_cpu(*(uint32_t *)buf);
		buf += sizeof(uint32_t);
		ret.output = kmalloc(arg.output_size, GFP_KERNEL);
		if (!ret.output) {
			accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
			goto oem_rapi_send_ack;
		}
	}

	cb_func = msm_rpc_get_cb_func(client, cb_id);
	if (cb_func) {
		rc = ((int (*)(struct oem_rapi_client_streaming_func_cb_arg *,
			       struct oem_rapi_client_streaming_func_cb_ret *))
		      cb_func)(&arg, &ret);
		if (rc)
			accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
		else
			accept_status = RPC_ACCEPTSTAT_SUCCESS;
	} else
		accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;

 oem_rapi_send_ack:
	reply = msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
					     accept_status);

	size = 0;
	if (accept_status == RPC_ACCEPTSTAT_SUCCESS) {
		*(uint32_t *)reply = cpu_to_be32((uint32_t)(ret.out_len != 0));
		reply += sizeof(uint32_t);
		size += sizeof(uint32_t);

		if (ret.out_len) {
			*(uint32_t *)reply = cpu_to_be32(*ret.out_len);
			reply += sizeof(uint32_t);
			size += sizeof(uint32_t);
		}

		if (ret.output && ret.out_len) {
			*(uint32_t *)reply =
				cpu_to_be32((uint32_t)(*ret.out_len));
			reply += sizeof(uint32_t);
			size += sizeof(uint32_t);

			memcpy(reply, ret.output, *ret.out_len);
			reply += *ret.out_len;
			size += *ret.out_len;
			if (*ret.out_len & 0x3) {
				memset(reply, 0, 4 - (*ret.out_len & 0x3));
				reply += 4 - (*ret.out_len & 0x3);
				size += 4 - (*ret.out_len & 0x3);
			}
		} else {
			*(uint32_t *)reply = cpu_to_be32(0);
			reply += sizeof(uint32_t);
			size += sizeof(uint32_t);
		}
	}
	rc = msm_rpc_send_accepted_reply(client, size);
	if (rc)
		pr_err("%s: sending reply failed: %d\n", __func__, rc);

	kfree(arg.input);
	kfree(ret.out_len);
	kfree(ret.output);

	return 0;
}