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