static int npa_remote_cb(struct msm_rpc_client *client, struct msm_rpc_xdr *xdr)
{
int err = 0;
int array_length = 0;
unsigned int status = RPC_ACCEPTSTAT_SYSTEM_ERR;
struct npa_remote_cb_data arg;
npa_remote_callback cb_fn = NULL;
xdr_recv_uint32(xdr, &arg.cb_id);
xdr_recv_uint32(xdr, &arg.context);
xdr_recv_uint32(xdr, &arg.type);
xdr_recv_array(xdr, (void **)&arg.buffer, &array_length, INT_MAX,
sizeof(int32_t), (void *)xdr_recv_int32);
xdr_recv_uint32(xdr, &arg.size);
cb_fn = (npa_remote_callback) msm_rpc_get_cb_func(client, arg.cb_id);
if (cb_fn) {
cb_fn((void *)arg.context, arg.type, arg.buffer, arg.size);
status = RPC_ACCEPTSTAT_SUCCESS;
}
xdr_start_accepted_reply(xdr, status);
err = xdr_send_msg(xdr);
if (err) {
pr_err("NPA Remote callback %s: send accepted reply failed: "
"%d\n", __func__, err);
BUG();
}
kfree(arg.buffer);
return 0;
}
static int npa_remote_create_sync_client_ret_fn(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct npa_remote_create_sync_client_ret *ret = data;
xdr_recv_int32(xdr, &ret->result);
xdr_recv_uint32(xdr, &ret->handle_is_valid);
if (ret->handle_is_valid)
xdr_recv_uint32(xdr, &ret->handle);
return 0;
}
static int npa_remote_issue_required_request_ret_fn(
struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct npa_remote_issue_required_request_ret *ret = data;
xdr_recv_int32(xdr, &ret->result);
xdr_recv_uint32(xdr, &ret->new_state_is_valid);
if (ret->new_state_is_valid)
xdr_recv_uint32(xdr, &ret->new_state);
return 0;
}
static int dog_keepalive_cb(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr)
{
int rc;
void *cb_func;
uint32_t accept_status;
struct dog_keepalive_cb_arg arg;
struct dog_keepalive_cb_ret ret;
xdr_recv_uint32(xdr, &arg.cb_id);
cb_func = msm_rpc_get_cb_func(client, arg.cb_id);
if (cb_func) {
rc = ((int (*)
(struct dog_keepalive_cb_arg *,
struct dog_keepalive_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;
xdr_start_accepted_reply(xdr, accept_status);
if (accept_status == RPC_ACCEPTSTAT_SUCCESS)
xdr_send_uint32(xdr, &ret.result);
rc = xdr_send_msg(xdr);
if (rc)
pr_err("%s: send accepted reply failed: %d\n", __func__, rc);
return rc;
}
int xdr_recv_array(struct msm_rpc_xdr *xdr, void **addr, uint32_t *size,
uint32_t maxsize, uint32_t elm_size, void *xdr_op)
{
int i, rc;
void *tmp_addr;
if (!size || !xdr_op)
return -1;
rc = xdr_recv_uint32(xdr, size);
if (rc)
return rc;
if (*size > maxsize)
return -1;
tmp_addr = kmalloc((*size * elm_size), GFP_KERNEL);
if (!tmp_addr)
return -1;
*addr = tmp_addr;
for (i = 0; i < *size; i++) {
rc = ((int (*) (struct msm_rpc_xdr *, void *))xdr_op)
(xdr, tmp_addr);
if (rc) {
kfree(*addr);
*addr = NULL;
return rc;
}
tmp_addr += elm_size;
}
return 0;
}
static int ping_mdm_register_cb(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr)
{
int rc;
uint32_t accept_status;
struct ping_mdm_register_cb_arg arg;
void *cb_func;
xdr_recv_uint32(xdr, &arg.cb_id); /* cb_id */
xdr_recv_int32(xdr, &arg.val); /* 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;
xdr_start_accepted_reply(xdr, accept_status);
rc = xdr_send_msg(xdr);
if (rc)
pr_err("%s: send accepted reply failed: %d\n", __func__, rc);
return rc;
}
static int npa_remote_resource_available_ret_fn(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct npa_remote_resource_available_ret *ret = data;
xdr_recv_uint32(xdr, &ret->result);
return 0;
}
static int ping_mdm_register_ret(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct ping_mdm_register_ret *ret = data;
xdr_recv_uint32(xdr, &ret->result); /* result */
return 0;
}
int xdr_recv_req(struct msm_rpc_xdr *xdr, struct rpc_request_hdr *req)
{
int rc = 0;
if (!req)
return -1;
rc |= xdr_recv_uint32(xdr, &req->xid); /* xid */
rc |= xdr_recv_uint32(xdr, &req->type); /* type */
rc |= xdr_recv_uint32(xdr, &req->rpc_vers); /* rpc_vers */
rc |= xdr_recv_uint32(xdr, &req->prog); /* prog */
rc |= xdr_recv_uint32(xdr, &req->vers); /* vers */
rc |= xdr_recv_uint32(xdr, &req->procedure); /* procedure */
rc |= xdr_recv_uint32(xdr, &req->cred_flavor); /* cred_flavor */
rc |= xdr_recv_uint32(xdr, &req->cred_length); /* cred_length */
rc |= xdr_recv_uint32(xdr, &req->verf_flavor); /* verf_flavor */
rc |= xdr_recv_uint32(xdr, &req->verf_length); /* verf_length */
return rc;
}
static int ping_mdm_data_cb(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr)
{
int rc;
void *cb_func;
uint32_t size, accept_status;
struct ping_mdm_register_data_cb_cb_arg arg;
struct ping_mdm_register_data_cb_cb_ret ret;
xdr_recv_uint32(xdr, &arg.cb_id); /* cb_id */
/* data */
xdr_recv_array(xdr, (void **)(&(arg.data)), &size, 64,
sizeof(uint32_t), (void *)xdr_recv_uint32);
xdr_recv_uint32(xdr, &arg.size); /* size */
xdr_recv_uint32(xdr, &arg.sum); /* sum */
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;
xdr_start_accepted_reply(xdr, accept_status);
if (accept_status == RPC_ACCEPTSTAT_SUCCESS)
xdr_send_uint32(xdr, &ret.result); /* result */
rc = xdr_send_msg(xdr);
if (rc)
pr_err("%s: send accepted reply failed: %d\n", __func__, rc);
kfree(arg.data);
return rc;
}
static int dog_keepalive_register_ret_func(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct dog_keepalive_register_ret *ret = data;
xdr_recv_pointer(xdr, (void **)&(ret->clnt_id), sizeof(uint32_t),
xdr_recv_uint32);
xdr_recv_uint32(xdr, &ret->result);
return 0;
}
static int handle_lg_fw_helper_misc_blk_write(struct msm_rpc_xdr *xdr)
{
int ret;
struct lg_fw_helper_misc_blk_rpc arg;
// get block number
ret = xdr_recv_uint32(xdr, &arg.block_no);
if (ret != 0)
return ret;
// get block data
ret = xdr_recv_array(xdr, (void **)&arg.data, &arg.size, 128,
sizeof(uint32_t), (void *)xdr_recv_uint32);
if (ret != 0)
return ret;
// write block data
print_hex_dump(KERN_INFO, "data: ", DUMP_PREFIX_OFFSET, 16, 1, arg.data, 512, true);
printk(KERN_ERR "[sunny] block num = %d \n", arg.block_no);
ret = lge_emmc_wallpaper_write(arg.block_no, (unsigned char*) arg.data, 512);
ret = xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
if (ret != 0)
goto handle_lg_fw_helper_misc_blk_write_exit;
ret = 0xabcdef12; // for debugging
ret = xdr_send_uint32(xdr, &ret);
if (ret != 0)
goto handle_lg_fw_helper_misc_blk_write_exit;
ret = xdr_send_msg(xdr);
if (ret < 0)
pr_err("%s: sending reply failed\n", __func__);
handle_lg_fw_helper_misc_blk_write_exit:
if (arg.data)
kfree(arg.data);
return 0;
}
int xdr_recv_pointer(struct msm_rpc_xdr *xdr, void **obj,
uint32_t obj_size, void *xdr_op)
{
uint32_t rc, ptr_valid = 0;
rc = xdr_recv_uint32(xdr, &ptr_valid);
if (rc)
return rc;
if (!ptr_valid) {
*obj = NULL;
return 0;
}
*obj = kmalloc(obj_size, GFP_KERNEL);
if (!*obj)
return -1;
rc = ((int (*) (struct msm_rpc_xdr *, void *))xdr_op)(xdr, *obj);
if (rc)
kfree(*obj);
return rc;
}
int xdr_recv_reply(struct msm_rpc_xdr *xdr, struct rpc_reply_hdr *reply)
{
int rc = 0;
if (!reply)
return -1;
rc |= xdr_recv_uint32(xdr, &reply->xid); /* xid */
rc |= xdr_recv_uint32(xdr, &reply->type); /* type */
rc |= xdr_recv_uint32(xdr, &reply->reply_stat); /* reply_stat */
/* acc_hdr */
if (reply->reply_stat == RPCMSG_REPLYSTAT_ACCEPTED) {
rc |= xdr_recv_uint32(xdr, &reply->data.acc_hdr.verf_flavor);
rc |= xdr_recv_uint32(xdr, &reply->data.acc_hdr.verf_length);
rc |= xdr_recv_uint32(xdr, &reply->data.acc_hdr.accept_stat);
}
return rc;
}
/* TODO: check where to allocate memory for return */
static int oem_rapi_client_cb(struct msm_rpc_client *client,
struct rpc_request_hdr *req,
struct msm_rpc_xdr *xdr)
{
uint32_t cb_id, accept_status;
int rc;
void *cb_func;
uint32_t temp;
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;
xdr_recv_uint32(xdr, &cb_id); /* cb_id */
xdr_recv_uint32(xdr, &arg.event); /* enum */
xdr_recv_uint32(xdr, (uint32_t *)(&arg.handle)); /* handle */
xdr_recv_uint32(xdr, &arg.in_len); /* in_len */
xdr_recv_bytes(xdr, (void **)&arg.input, &temp); /* input */
xdr_recv_uint32(xdr, &arg.out_len_valid); /* out_len */
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;
}
}
xdr_recv_uint32(xdr, &arg.output_valid); /* out */
if (arg.output_valid) {
xdr_recv_uint32(xdr, &arg.output_size); /* ouput_size */
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:
xdr_start_accepted_reply(xdr, accept_status);
if (accept_status == RPC_ACCEPTSTAT_SUCCESS) {
uint32_t temp = sizeof(uint32_t);
xdr_send_pointer(xdr, (void **)&(ret.out_len), temp,
xdr_send_uint32);
/* output */
if (ret.output && ret.out_len)
xdr_send_bytes(xdr, (const void **)&ret.output,
ret.out_len);
else {
temp = 0;
xdr_send_uint32(xdr, &temp);
}
}
rc = xdr_send_msg(xdr);
if (rc)
pr_err("%s: sending reply failed: %d\n", __func__, rc);
kfree(arg.input);
kfree(ret.out_len);
kfree(ret.output);
return 0;
}
int xdr_recv_int32(struct msm_rpc_xdr *xdr, int32_t *value)
{
return xdr_recv_uint32(xdr, (uint32_t *)value);
}
