M7350/kernel/arch/arm/mach-msm/ping_mdm_rpc_client.c

815 lines
19 KiB
C
Raw Normal View History

2024-09-09 08:52:07 +00:00
/* Copyright (c) 2009-2011, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
/*
* SMD RPC PING MODEM Driver
*/
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/kfifo.h>
#include <linux/export.h>
#include <mach/msm_rpcrouter.h>
#define PING_TEST_BASE 0x31
#define PTIOC_NULL_TEST _IO(PING_TEST_BASE, 1)
#define PTIOC_REG_TEST _IO(PING_TEST_BASE, 2)
#define PTIOC_DATA_REG_TEST _IO(PING_TEST_BASE, 3)
#define PTIOC_DATA_CB_REG_TEST _IO(PING_TEST_BASE, 4)
#define PING_MDM_PROG 0x30000081
#define PING_MDM_VERS 0x00010001
#define PING_MDM_CB_PROG 0x31000081
#define PING_MDM_CB_VERS 0x00010001
#define PING_MDM_NULL_PROC 0
#define PING_MDM_RPC_GLUE_CODE_INFO_REMOTE_PROC 1
#define PING_MDM_REGISTER_PROC 2
#define PING_MDM_UNREGISTER_PROC 3
#define PING_MDM_REGISTER_DATA_PROC 4
#define PING_MDM_UNREGISTER_DATA_CB_PROC 5
#define PING_MDM_REGISTER_DATA_CB_PROC 6
#define PING_MDM_DATA_CB_PROC 1
#define PING_MDM_CB_PROC 2
#define PING_MAX_RETRY 5
static struct msm_rpc_client *rpc_client;
static uint32_t open_count;
static DEFINE_MUTEX(ping_mdm_lock);
struct ping_mdm_register_cb_arg {
uint32_t cb_id;
int val;
};
struct ping_mdm_register_data_cb_cb_arg {
uint32_t cb_id;
uint32_t *data;
uint32_t size;
uint32_t sum;
};
struct ping_mdm_register_data_cb_cb_ret {
uint32_t result;
};
static struct dentry *dent;
static uint32_t test_res;
static int reg_cb_num, reg_cb_num_req;
static int data_cb_num, data_cb_num_req;
static int reg_done_flag, data_cb_done_flag;
static DECLARE_WAIT_QUEUE_HEAD(reg_test_wait);
static DECLARE_WAIT_QUEUE_HEAD(data_cb_test_wait);
enum {
PING_MODEM_NOT_IN_RESET = 0,
PING_MODEM_IN_RESET,
PING_LEAVING_RESET,
PING_MODEM_REGISTER_CB
};
static int fifo_event;
static DEFINE_MUTEX(event_fifo_lock);
static DEFINE_KFIFO(event_fifo, int, sizeof(int)*16);
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 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 ping_mdm_cb_func(struct msm_rpc_client *client,
struct rpc_request_hdr *req,
struct msm_rpc_xdr *xdr)
{
int rc = 0;
switch (req->procedure) {
case PING_MDM_CB_PROC:
rc = ping_mdm_register_cb(client, xdr);
break;
case PING_MDM_DATA_CB_PROC:
rc = ping_mdm_data_cb(client, xdr);
break;
default:
pr_err("%s: procedure not supported %d\n",
__func__, req->procedure);
xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_PROC_UNAVAIL);
rc = xdr_send_msg(xdr);
if (rc)
pr_err("%s: sending reply failed: %d\n", __func__, rc);
break;
}
return rc;
}
struct ping_mdm_unregister_data_cb_arg {
int (*cb_func)(
struct ping_mdm_register_data_cb_cb_arg *arg,
struct ping_mdm_register_data_cb_cb_ret *ret);
};
struct ping_mdm_register_data_cb_arg {
int (*cb_func)(
struct ping_mdm_register_data_cb_cb_arg *arg,
struct ping_mdm_register_data_cb_cb_ret *ret);
uint32_t num;
uint32_t size;
uint32_t interval_ms;
uint32_t num_tasks;
};
struct ping_mdm_register_data_cb_ret {
uint32_t result;
};
struct ping_mdm_unregister_data_cb_ret {
uint32_t result;
};
static int ping_mdm_data_cb_register_arg(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct ping_mdm_register_data_cb_arg *arg = data;
int cb_id;
cb_id = msm_rpc_add_cb_func(client, (void *)arg->cb_func);
if ((cb_id < 0) && (cb_id != MSM_RPC_CLIENT_NULL_CB_ID))
return cb_id;
xdr_send_uint32(xdr, &cb_id); /* cb_id */
xdr_send_uint32(xdr, &arg->num); /* num */
xdr_send_uint32(xdr, &arg->size); /* size */
xdr_send_uint32(xdr, &arg->interval_ms); /* interval_ms */
xdr_send_uint32(xdr, &arg->num_tasks); /* num_tasks */
return 0;
}
static int ping_mdm_data_cb_unregister_arg(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct ping_mdm_unregister_data_cb_arg *arg = data;
int cb_id;
cb_id = msm_rpc_add_cb_func(client, (void *)arg->cb_func);
if ((cb_id < 0) && (cb_id != MSM_RPC_CLIENT_NULL_CB_ID))
return cb_id;
xdr_send_uint32(xdr, &cb_id); /* cb_id */
return 0;
}
static int ping_mdm_data_cb_register_ret(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct ping_mdm_register_data_cb_ret *ret = data;
xdr_recv_uint32(xdr, &ret->result); /* result */
return 0;
}
static int ping_mdm_register_data_cb(
struct msm_rpc_client *client,
struct ping_mdm_register_data_cb_arg *arg,
struct ping_mdm_register_data_cb_ret *ret)
{
return msm_rpc_client_req2(client,
PING_MDM_REGISTER_DATA_CB_PROC,
ping_mdm_data_cb_register_arg, arg,
ping_mdm_data_cb_register_ret, ret, -1);
}
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_req2(client,
PING_MDM_UNREGISTER_DATA_CB_PROC,
ping_mdm_data_cb_unregister_arg, arg,
ping_mdm_data_cb_register_ret, ret, -1);
}
struct ping_mdm_data_arg {
uint32_t *data;
uint32_t size;
};
struct ping_mdm_data_ret {
uint32_t result;
};
static int ping_mdm_data_register_arg(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct ping_mdm_data_arg *arg = data;
/* data */
xdr_send_array(xdr, (void **)&arg->data, &arg->size, 64,
sizeof(uint32_t), (void *)xdr_send_uint32);
xdr_send_uint32(xdr, &arg->size); /* size */
return 0;
}
static int ping_mdm_data_register_ret(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct ping_mdm_data_ret *ret = data;
xdr_recv_uint32(xdr, &ret->result); /* result */
return 0;
}
static int ping_mdm_data_register(
struct msm_rpc_client *client,
struct ping_mdm_data_arg *arg,
struct ping_mdm_data_ret *ret)
{
return msm_rpc_client_req2(client,
PING_MDM_REGISTER_DATA_PROC,
ping_mdm_data_register_arg, arg,
ping_mdm_data_register_ret, ret, -1);
}
struct ping_mdm_register_arg {
int (*cb_func)(struct ping_mdm_register_cb_arg *, void *);
int num;
};
struct ping_mdm_unregister_arg {
int (*cb_func)(struct ping_mdm_register_cb_arg *, void *);
};
struct ping_mdm_register_ret {
uint32_t result;
};
struct ping_mdm_unregister_ret {
uint32_t result;
};
static int ping_mdm_register_arg(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct ping_mdm_register_arg *arg = data;
int cb_id;
cb_id = msm_rpc_add_cb_func(client, (void *)arg->cb_func);
if ((cb_id < 0) && (cb_id != MSM_RPC_CLIENT_NULL_CB_ID))
return cb_id;
xdr_send_uint32(xdr, &cb_id); /* cb_id */
xdr_send_uint32(xdr, &arg->num); /* num */
return 0;
}
static int ping_mdm_unregister_arg(struct msm_rpc_client *client,
struct msm_rpc_xdr *xdr, void *data)
{
struct ping_mdm_unregister_arg *arg = data;
int cb_id;
cb_id = msm_rpc_add_cb_func(client, (void *)arg->cb_func);
if ((cb_id < 0) && (cb_id != MSM_RPC_CLIENT_NULL_CB_ID))
return cb_id;
xdr_send_uint32(xdr, &cb_id); /* cb_id */
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;
}
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_req2(client,
PING_MDM_REGISTER_PROC,
ping_mdm_register_arg, arg,
ping_mdm_register_ret, ret, -1);
}
static int ping_mdm_unregister(
struct msm_rpc_client *client,
struct ping_mdm_unregister_arg *arg,
struct ping_mdm_unregister_ret *ret)
{
return msm_rpc_client_req2(client,
PING_MDM_UNREGISTER_PROC,
ping_mdm_unregister_arg, arg,
ping_mdm_register_ret, ret, -1);
}
static int ping_mdm_null(struct msm_rpc_client *client,
void *arg, void *ret)
{
return msm_rpc_client_req2(client, PING_MDM_NULL_PROC,
NULL, NULL, NULL, NULL, -1);
}
static int ping_mdm_close(void)
{
mutex_lock(&ping_mdm_lock);
if (--open_count == 0) {
msm_rpc_unregister_client(rpc_client);
pr_info("%s: disconnected from remote ping server\n",
__func__);
}
mutex_unlock(&ping_mdm_lock);
return 0;
}
static void handle_restart_teardown(struct msm_rpc_client *client)
{
int event = PING_MODEM_IN_RESET;
pr_info("%s: modem in reset\n", __func__);
mutex_lock(&event_fifo_lock);
kfifo_in(&event_fifo, &event, sizeof(event));
fifo_event = 1;
mutex_unlock(&event_fifo_lock);
wake_up(&data_cb_test_wait);
}
static void handle_restart_setup(struct msm_rpc_client *client)
{
int event = PING_LEAVING_RESET;
pr_info("%s: modem leaving reset\n", __func__);
mutex_lock(&event_fifo_lock);
kfifo_in(&event_fifo, &event, sizeof(event));
fifo_event = 1;
mutex_unlock(&event_fifo_lock);
wake_up(&data_cb_test_wait);
}
static struct msm_rpc_client *ping_mdm_init(void)
{
mutex_lock(&ping_mdm_lock);
if (open_count == 0) {
rpc_client = msm_rpc_register_client2("pingdef",
PING_MDM_PROG,
PING_MDM_VERS, 1,
ping_mdm_cb_func);
if (!IS_ERR(rpc_client)) {
open_count++;
msm_rpc_register_reset_callbacks(rpc_client,
handle_restart_teardown,
handle_restart_setup);
}
}
mutex_unlock(&ping_mdm_lock);
return rpc_client;
}
static int ping_mdm_data_register_test(void)
{
int i, rc = 0;
uint32_t my_data[64];
uint32_t my_sum = 0;
struct ping_mdm_data_arg data_arg;
struct ping_mdm_data_ret data_ret;
for (i = 0; i < 64; i++) {
my_data[i] = (42 + i);
my_sum ^= (42 + i);
}
data_arg.data = my_data;
data_arg.size = 64;
rc = ping_mdm_data_register(rpc_client, &data_arg, &data_ret);
if (rc)
return rc;
if (my_sum != data_ret.result) {
pr_err("%s: sum mismatch %d %d\n",
__func__, my_sum, data_ret.result);
rc = -1;
}
return rc;
}
static int ping_mdm_test_register_data_cb(
struct ping_mdm_register_data_cb_cb_arg *arg,
struct ping_mdm_register_data_cb_cb_ret *ret)
{
uint32_t i, sum = 0;
data_cb_num++;
pr_info("%s: received cb_id %d, size = %d, sum = %u, num = %u of %u\n",
__func__, arg->cb_id, arg->size, arg->sum, data_cb_num,
data_cb_num_req);
if (arg->data)
for (i = 0; i < arg->size; i++)
sum ^= arg->data[i];
if (sum != arg->sum)
pr_err("%s: sum mismatch %u %u\n", __func__, sum, arg->sum);
if (data_cb_num == data_cb_num_req) {
data_cb_done_flag = 1;
wake_up(&data_cb_test_wait);
}
ret->result = 1;
return 0;
}
static int ping_mdm_data_cb_register(
struct ping_mdm_register_data_cb_ret *reg_ret)
{
int rc;
struct ping_mdm_register_data_cb_arg reg_arg;
reg_arg.cb_func = ping_mdm_test_register_data_cb;
reg_arg.num = data_cb_num_req - data_cb_num;
reg_arg.size = 64;
reg_arg.interval_ms = 10;
reg_arg.num_tasks = 1;
pr_info("%s: registering callback\n", __func__);
rc = ping_mdm_register_data_cb(rpc_client, &reg_arg, reg_ret);
if (rc)
pr_err("%s: failed to register callback %d\n", __func__, rc);
return rc;
}
static void retry_timer_cb(unsigned long data)
{
int event = (int)data;
pr_info("%s: retry timer triggered\n", __func__);
mutex_lock(&event_fifo_lock);
kfifo_in(&event_fifo, &event, sizeof(event));
fifo_event = 1;
mutex_unlock(&event_fifo_lock);
wake_up(&data_cb_test_wait);
}
static int ping_mdm_data_cb_register_test(void)
{
int rc;
int event;
int retry_count = 0;
struct ping_mdm_register_data_cb_ret reg_ret;
struct ping_mdm_unregister_data_cb_arg unreg_arg;
struct ping_mdm_unregister_data_cb_ret unreg_ret;
struct timer_list retry_timer;
mutex_init(&event_fifo_lock);
init_timer(&retry_timer);
data_cb_done_flag = 0;
data_cb_num = 0;
if (!data_cb_num_req)
data_cb_num_req = 10;
rc = ping_mdm_data_cb_register(&reg_ret);
if (rc)
return rc;
pr_info("%s: data_cb_register result: 0x%x\n",
__func__, reg_ret.result);
while (!data_cb_done_flag) {
wait_event(data_cb_test_wait, data_cb_done_flag || fifo_event);
fifo_event = 0;
for (;;) {
mutex_lock(&event_fifo_lock);
if (kfifo_is_empty(&event_fifo)) {
mutex_unlock(&event_fifo_lock);
break;
}
rc = kfifo_out(&event_fifo, &event, sizeof(event));
mutex_unlock(&event_fifo_lock);
BUG_ON(rc != sizeof(event));
pr_info("%s: processing event data_cb_done_flag=%d,event=%d\n",
__func__, data_cb_done_flag, event);
if (event == PING_MODEM_IN_RESET) {
pr_info("%s: modem entering reset\n", __func__);
retry_count = 0;
} else if (event == PING_LEAVING_RESET) {
pr_info("%s: modem exiting reset - "
"re-registering cb\n", __func__);
rc = ping_mdm_data_cb_register(&reg_ret);
if (rc) {
retry_count++;
if (retry_count < PING_MAX_RETRY) {
pr_info("%s: retry %d failed\n",
__func__, retry_count);
retry_timer.expires = jiffies +
msecs_to_jiffies(1000);
retry_timer.data =
PING_LEAVING_RESET;
retry_timer.function =
retry_timer_cb;
add_timer(&retry_timer);
} else {
pr_err("%s: max retries exceeded, aborting\n",
__func__);
return -ENETRESET;
}
} else
pr_info("%s: data_cb_register result: 0x%x\n",
__func__, reg_ret.result);
}
}
}
while (del_timer(&retry_timer))
;
unreg_arg.cb_func = ping_mdm_test_register_data_cb;
rc = ping_mdm_unregister_data_cb(rpc_client, &unreg_arg, &unreg_ret);
if (rc)
return rc;
pr_info("%s: data_cb_unregister result: 0x%x\n",
__func__, unreg_ret.result);
pr_info("%s: Test completed\n", __func__);
return 0;
}
static int ping_mdm_test_register_cb(
struct ping_mdm_register_cb_arg *arg, void *ret)
{
pr_info("%s: received cb_id %d, val = %d\n",
__func__, arg->cb_id, arg->val);
reg_cb_num++;
if (reg_cb_num == reg_cb_num_req) {
reg_done_flag = 1;
wake_up(&reg_test_wait);
}
return 0;
}
static int ping_mdm_register_test(void)
{
int rc = 0;
struct ping_mdm_register_arg reg_arg;
struct ping_mdm_unregister_arg unreg_arg;
struct ping_mdm_register_ret reg_ret;
struct ping_mdm_unregister_ret unreg_ret;
reg_cb_num = 0;
reg_cb_num_req = 10;
reg_done_flag = 0;
reg_arg.num = 10;
reg_arg.cb_func = ping_mdm_test_register_cb;
rc = ping_mdm_register(rpc_client, &reg_arg, &reg_ret);
if (rc)
return rc;
pr_info("%s: register result: 0x%x\n",
__func__, reg_ret.result);
wait_event(reg_test_wait, reg_done_flag);
unreg_arg.cb_func = ping_mdm_test_register_cb;
rc = ping_mdm_unregister(rpc_client, &unreg_arg, &unreg_ret);
if (rc)
return rc;
pr_info("%s: unregister result: 0x%x\n",
__func__, unreg_ret.result);
return 0;
}
static int ping_mdm_null_test(void)
{
return ping_mdm_null(rpc_client, NULL, NULL);
}
static int ping_test_release(struct inode *ip, struct file *fp)
{
return ping_mdm_close();
}
static int ping_test_open(struct inode *ip, struct file *fp)
{
struct msm_rpc_client *client;
client = ping_mdm_init();
if (IS_ERR(client)) {
pr_err("%s: couldn't open ping client\n", __func__);
return PTR_ERR(client);
} else
pr_info("%s: connected to remote ping server\n",
__func__);
return 0;
}
static ssize_t ping_test_read(struct file *fp, char __user *buf,
size_t count, loff_t *pos)
{
char _buf[16];
snprintf(_buf, sizeof(_buf), "%i\n", test_res);
return simple_read_from_buffer(buf, count, pos, _buf, strlen(_buf));
}
static ssize_t ping_test_write(struct file *fp, const char __user *buf,
size_t count, loff_t *pos)
{
unsigned char cmd[64];
int len;
if (count < 1)
return 0;
len = count > 63 ? 63 : count;
if (copy_from_user(cmd, buf, len))
return -EFAULT;
cmd[len] = 0;
/* lazy */
if (cmd[len-1] == '\n') {
cmd[len-1] = 0;
len--;
}
if (!strncmp(cmd, "null_test", 64))
test_res = ping_mdm_null_test();
else if (!strncmp(cmd, "reg_test", 64))
test_res = ping_mdm_register_test();
else if (!strncmp(cmd, "data_reg_test", 64))
test_res = ping_mdm_data_register_test();
else if (!strncmp(cmd, "data_cb_reg_test", 64))
test_res = ping_mdm_data_cb_register_test();
else if (!strncmp(cmd, "count=", 6)) {
long tmp;
if (strict_strtol(cmd + 6, 0, &tmp) == 0) {
data_cb_num_req = tmp;
pr_info("Set repetition count to %d\n",
data_cb_num_req);
} else {
data_cb_num_req = 10;
pr_err("invalid number %s, defaulting to %d\n",
cmd + 6, data_cb_num_req);
}
}
else
test_res = -EINVAL;
return count;
}
static const struct file_operations debug_ops = {
.owner = THIS_MODULE,
.open = ping_test_open,
.read = ping_test_read,
.write = ping_test_write,
.release = ping_test_release,
};
static void __exit ping_test_exit(void)
{
debugfs_remove(dent);
}
static int __init ping_test_init(void)
{
dent = debugfs_create_file("ping_mdm", 0444, 0, NULL, &debug_ops);
test_res = 0;
open_count = 0;
return 0;
}
module_init(ping_test_init);
module_exit(ping_test_exit);
MODULE_DESCRIPTION("PING TEST Driver");
MODULE_LICENSE("GPL v2");