arch/arm/mach-msm/ping_apps_server.c - fp2-dev/kernel/msm - Gitiles

 /* Copyright (c) 2010, 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.
  *
  */

 /*
  * PING APPS SERVER Driver
  */

 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/kthread.h>
 #include <linux/workqueue.h>
 #include <mach/msm_rpcrouter.h>

 /* ping server definitions */

 #define PING_APPS_PROG 0x30000082
 #define PING_APPS_VERS 0x00010001

 #define PING_APPS_NULL  0
 #define PING_APPS_DATA  4
 #define PING_APPS_REG   2
 #define PING_APPS_UNREG 3
 #define PING_APPS_DATA_CB_REG    6
 #define PING_APPS_DATA_CB_UNREG  5

 #define PING_APPS_REG_CB  2
 #define PING_APPS_DATA_CB 1

 static LIST_HEAD(cb_entry_list);
 static DEFINE_MUTEX(cb_entry_list_lock);

 static struct task_struct *server_thread;

 struct ping_apps_register_arg {
 	uint32_t cb_id;
 	int32_t num;
 };

 struct ping_apps_unregister_arg {
 	uint32_t cb_id;
 };

 struct ping_apps_register_cb_arg {
 	uint32_t cb_id;
 	int32_t num;
 };

 struct ping_apps_register_ret {
 	uint32_t result;
 };

 struct ping_apps_unregister_ret {
 	uint32_t result;
 };

 struct ping_apps_data_cb_reg_arg {
 	uint32_t cb_id;
 	uint32_t num;
 	uint32_t size;
 	uint32_t interval_ms;
 	uint32_t num_tasks;
 };

 struct ping_apps_data_cb_unreg_arg {
 	uint32_t cb_id;
 };

 struct ping_apps_data_cb_arg {
 	uint32_t cb_id;
 	uint32_t *data;
 	uint32_t size;
 	uint32_t sum;
 };

 struct ping_apps_data_cb_reg_ret {
 	uint32_t result;
 };

 struct ping_apps_data_cb_unreg_ret {
 	uint32_t result;
 };

 struct ping_apps_data_cb_ret {
 	uint32_t result;
 };

 struct ping_apps_data_arg {
 	uint32_t *data;
 	uint32_t size;
 };

 struct ping_apps_data_ret {
 	uint32_t result;
 };

 struct ping_apps_data_cb_info {
 	void *cb_func;
 	uint32_t size;
 	uint32_t num_tasks;
 };

 struct ping_apps_cb_entry {
 	struct list_head list;

 	struct msm_rpc_client_info clnt_info;
 	void *cb_info;
 	uint32_t cb_id;
 	int32_t num;
 	uint32_t interval_ms;
 	uint32_t time_to_next_cb;
 	void (*cb_func)(struct ping_apps_cb_entry *);
 };

 static int handle_rpc_call(struct msm_rpc_server *server,
 			   struct rpc_request_hdr *req,
 			   struct msm_rpc_xdr *xdr);

 static int ping_apps_data_cb(struct msm_rpc_server *server,
 			     struct msm_rpc_client_info *clnt_info,
 			     struct ping_apps_data_cb_arg *arg,
 			     struct ping_apps_data_cb_ret *ret);

 static int ping_apps_register_cb(struct msm_rpc_server *server,
 				 struct msm_rpc_client_info *clnt_info,
 				 struct ping_apps_register_cb_arg *arg,
 				 void *ret);

 static struct msm_rpc_server rpc_server = {
 	.prog = PING_APPS_PROG,
 	.vers = PING_APPS_VERS,
 	.rpc_call2 = handle_rpc_call,
 };

 static void handle_ping_apps_data_cb(struct ping_apps_cb_entry *cb_entry)
 {
 	struct ping_apps_data_cb_arg arg;
 	struct ping_apps_data_cb_ret ret;
 	uint32_t my_sum = 0;
 	uint32_t *my_data;
 	int i;

 	if (cb_entry->num > 0) {
 		cb_entry->num--;
 		arg.cb_id = cb_entry->cb_id;
 		arg.size = ((struct ping_apps_data_cb_info *)
 			    (cb_entry->cb_info))->size;

 		my_data = kmalloc((arg.size * sizeof(uint32_t)), GFP_KERNEL);
 		if (!my_data)
 			return;

 		for (i = 0; i < arg.size; i++) {
 			my_data[i] = (42 + i);
 			my_sum ^= (42 + i);
 		}
 		arg.data = my_data;
 		arg.sum = my_sum;

 		((int (*)(struct msm_rpc_server *,
 			  struct msm_rpc_client_info *,
 			  struct ping_apps_data_cb_arg *,
 			  struct ping_apps_data_cb_ret *))
 		 ((struct ping_apps_data_cb_info *)
 		  (cb_entry->cb_info))->cb_func)(&rpc_server,
 					     &cb_entry->clnt_info,
 					     &arg, &ret);
 		pr_info("%s: cb_id = %d, ret = %d\n",
 			__func__, arg.cb_id, ret.result);
 		kfree(my_data);
 	}
 }

 static void handle_ping_apps_register_cb(struct ping_apps_cb_entry *cb_entry)
 {
 	struct ping_apps_register_cb_arg arg;

 	if (cb_entry->num > 0) {
 		cb_entry->num--;
 		arg.cb_id = cb_entry->cb_id;
 		arg.num = cb_entry->num;

 		pr_info("%s: cb_id = %d, num = %d\n",
 			__func__, arg.cb_id, arg.num);
 		((int (*)(struct msm_rpc_server *,
 			  struct msm_rpc_client_info *,
 			  struct ping_apps_register_cb_arg *,
 			  void *))cb_entry->cb_info)(&rpc_server,
 						     &cb_entry->clnt_info,
 						     &arg, NULL);
 	}

 }

 static int ping_apps_cb_process_thread(void *data)
 {
 	struct ping_apps_cb_entry *cb_entry;
 	uint32_t sleep_time;
 	uint32_t time_slept = 0;

 	pr_info("%s: thread started\n", __func__);
 	for (;;) {
 		sleep_time = 1000;
 		mutex_lock(&cb_entry_list_lock);
 		list_for_each_entry(cb_entry, &cb_entry_list, list) {
 			if (cb_entry->time_to_next_cb <= time_slept) {
 				cb_entry->cb_func(cb_entry);
 				cb_entry->time_to_next_cb =
 					cb_entry->interval_ms;
 			} else
 				cb_entry->time_to_next_cb -= time_slept;

 			if (cb_entry->time_to_next_cb < sleep_time)
 				sleep_time = cb_entry->time_to_next_cb;
 		}
 		mutex_unlock(&cb_entry_list_lock);

 		msleep(sleep_time);
 		time_slept = sleep_time;
 	}

 	do_exit(0);
 }

 static int ping_apps_data_register(struct ping_apps_data_arg *arg,
 				   struct ping_apps_data_ret *ret)
 {
 	int i;

 	ret->result = 0;
 	for (i = 0; i < arg->size; i++)
 		ret->result ^= arg->data[i];

 	return 0;
 }

 static int ping_apps_data_cb_reg(struct ping_apps_data_cb_reg_arg *arg,
 				 struct ping_apps_data_cb_reg_ret *ret)
 {
 	struct ping_apps_cb_entry *cb_entry;
 	struct ping_apps_data_cb_info *cb_info;

 	cb_entry = kmalloc(sizeof(*cb_entry), GFP_KERNEL);
 	if (!cb_entry)
 		return -ENOMEM;

 	cb_entry->cb_info = kmalloc(sizeof(struct ping_apps_data_cb_info),
 				    GFP_KERNEL);
 	if (!cb_entry->cb_info) {
 		kfree(cb_entry);
 		return -ENOMEM;
 	}
 	cb_info = (struct ping_apps_data_cb_info *)cb_entry->cb_info;

 	INIT_LIST_HEAD(&cb_entry->list);
 	cb_entry->cb_func = handle_ping_apps_data_cb;
 	cb_entry->cb_id = arg->cb_id;
 	cb_entry->num = arg->num;
 	cb_entry->interval_ms = arg->interval_ms;
 	cb_entry->time_to_next_cb = arg->interval_ms;
 	cb_info->cb_func = ping_apps_data_cb;
 	cb_info->size = arg->size;
 	cb_info->num_tasks = arg->num_tasks;

 	mutex_lock(&cb_entry_list_lock);
 	list_add_tail(&cb_entry->list, &cb_entry_list);
 	mutex_unlock(&cb_entry_list_lock);

 	msm_rpc_server_get_requesting_client(&cb_entry->clnt_info);

 	if (IS_ERR(server_thread))
 		server_thread = kthread_run(ping_apps_cb_process_thread,
 					    NULL, "kpingrpccbprocessd");
 	if (IS_ERR(server_thread)) {
 		kfree(cb_entry);
 		return PTR_ERR(server_thread);
 	}

 	ret->result = 1;
 	return 0;
 }

 static int ping_apps_data_cb_unreg(struct ping_apps_data_cb_unreg_arg *arg,
 				   struct ping_apps_data_cb_unreg_ret *ret)
 {
 	struct ping_apps_cb_entry *cb_entry, *tmp_cb_entry;

 	mutex_lock(&cb_entry_list_lock);
 	list_for_each_entry_safe(cb_entry, tmp_cb_entry,
 				 &cb_entry_list, list) {
 		if (cb_entry->cb_id == arg->cb_id) {
 			list_del(&cb_entry->list);
 			kfree(cb_entry->cb_info);
 			kfree(cb_entry);
 			break;
 		}
 	}
 	mutex_unlock(&cb_entry_list_lock);

 	ret->result = 1;
 	return 0;
 }

 static int ping_apps_register(struct ping_apps_register_arg *arg,
 			      struct ping_apps_register_ret *ret)
 {
 	struct ping_apps_cb_entry *cb_entry;

 	cb_entry = kmalloc(sizeof(*cb_entry), GFP_KERNEL);
 	if (!cb_entry)
 		return -ENOMEM;

 	INIT_LIST_HEAD(&cb_entry->list);
 	cb_entry->cb_func = handle_ping_apps_register_cb;
 	cb_entry->cb_info = ping_apps_register_cb;
 	cb_entry->cb_id = arg->cb_id;
 	cb_entry->num = arg->num;
 	cb_entry->interval_ms = 100;
 	cb_entry->time_to_next_cb = 100;

 	mutex_lock(&cb_entry_list_lock);
 	list_add_tail(&cb_entry->list, &cb_entry_list);
 	mutex_unlock(&cb_entry_list_lock);

 	msm_rpc_server_get_requesting_client(&cb_entry->clnt_info);

 	if (IS_ERR(server_thread))
 		server_thread = kthread_run(ping_apps_cb_process_thread,
 					    NULL, "kpingrpccbprocessd");
 	if (IS_ERR(server_thread)) {
 		kfree(cb_entry);
 		return PTR_ERR(server_thread);
 	}

 	ret->result = 1;
 	return 0;
 }

 static int ping_apps_unregister(struct ping_apps_unregister_arg *arg,
 				struct ping_apps_unregister_ret *ret)
 {
 	struct ping_apps_cb_entry *cb_entry, *tmp_cb_entry;

 	mutex_lock(&cb_entry_list_lock);
 	list_for_each_entry_safe(cb_entry, tmp_cb_entry,
 				 &cb_entry_list, list) {
 		if (cb_entry->cb_id == arg->cb_id) {
 			list_del(&cb_entry->list);
 			kfree(cb_entry);
 			break;
 		}
 	}
 	mutex_unlock(&cb_entry_list_lock);

 	ret->result = 1;
 	return 0;
 }

 static int ping_apps_data_cb_arg_func(struct msm_rpc_server *server,
 				      struct msm_rpc_xdr *xdr, void *data)
 {
 	struct ping_apps_data_cb_arg *arg = data;

 	xdr_send_uint32(xdr, &arg->cb_id);
 	xdr_send_array(xdr, (void **)&arg->data, &arg->size, 64,
 		       sizeof(uint32_t), (void *)xdr_send_uint32);
 	xdr_send_uint32(xdr, &arg->size);
 	xdr_send_uint32(xdr, &arg->sum);

 	return 0;
 }

 static int ping_apps_data_cb_ret_func(struct msm_rpc_server *server,
 				      struct msm_rpc_xdr *xdr, void *data)
 {
 	struct ping_apps_data_cb_ret *ret = data;

 	xdr_recv_uint32(xdr, &ret->result);

 	return 0;
 }

 static int ping_apps_data_cb(struct msm_rpc_server *server,
 			     struct msm_rpc_client_info *clnt_info,
 			     struct ping_apps_data_cb_arg *arg,
 			     struct ping_apps_data_cb_ret *ret)
 {
 	return msm_rpc_server_cb_req2(server, clnt_info,
 				      PING_APPS_DATA_CB,
 				      ping_apps_data_cb_arg_func, arg,
 				      ping_apps_data_cb_ret_func, ret, -1);
 }

 static int ping_apps_register_cb_arg(struct msm_rpc_server *server,
 				     struct msm_rpc_xdr *xdr, void *data)
 {
 	struct ping_apps_register_cb_arg *arg = data;

 	xdr_send_uint32(xdr, &arg->cb_id);
 	xdr_send_int32(xdr, &arg->num);

 	return 0;
 }

 static int ping_apps_register_cb(struct msm_rpc_server *server,
 				struct msm_rpc_client_info *clnt_info,
 				struct ping_apps_register_cb_arg *arg,
 				void *ret)
 {
 	return msm_rpc_server_cb_req2(server, clnt_info,
 				      PING_APPS_REG_CB,
 				      ping_apps_register_cb_arg,
 				      arg, NULL, NULL, -1);
 }

 static int handle_ping_apps_data_register(struct msm_rpc_server *server,
 					  struct rpc_request_hdr *req,
 					  struct msm_rpc_xdr *xdr)
 {
 	uint32_t rc;
 	struct ping_apps_data_arg arg;
 	struct ping_apps_data_ret ret;

 	pr_info("%s: request received\n", __func__);

 	xdr_recv_array(xdr, (void **)&arg.data, &arg.size, 64,
 		       sizeof(uint32_t), (void *)xdr_recv_uint32);
 	xdr_recv_uint32(xdr, &arg.size);

 	rc = ping_apps_data_register(&arg, &ret);
 	if (rc < 0)
 		goto free_and_return;

 	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
 	xdr_send_uint32(xdr, &ret.result);
 	rc = xdr_send_msg(xdr);
 	if (rc < 0)
 		pr_info("%s: sending reply failed\n", __func__);
 	else
 		rc = 1;

  free_and_return:
 	kfree(arg.data);
 	return rc;
 }

 static int handle_ping_apps_data_cb_reg(struct msm_rpc_server *server,
 					struct rpc_request_hdr *req,
 					struct msm_rpc_xdr *xdr)
 {
 	uint32_t rc;
 	struct ping_apps_data_cb_reg_arg arg;
 	struct ping_apps_data_cb_reg_ret ret;

 	pr_info("%s: request received\n", __func__);

 	xdr_recv_uint32(xdr, &arg.cb_id);
 	xdr_recv_uint32(xdr, &arg.num);
 	xdr_recv_uint32(xdr, &arg.size);
 	xdr_recv_uint32(xdr, &arg.interval_ms);
 	xdr_recv_uint32(xdr, &arg.num_tasks);

 	rc = ping_apps_data_cb_reg(&arg, &ret);
 	if (rc < 0)
 		return rc;

 	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
 	xdr_send_uint32(xdr, &ret.result);
 	rc = xdr_send_msg(xdr);
 	if (rc < 0)
 		pr_info("%s: sending reply failed\n", __func__);
 	else
 		rc = 1;

 	return rc;
 }

 static int handle_ping_apps_data_cb_unreg(struct msm_rpc_server *server,
 					  struct rpc_request_hdr *req,
 					  struct msm_rpc_xdr *xdr)
 {
 	uint32_t rc;
 	struct ping_apps_data_cb_unreg_arg arg;
 	struct ping_apps_data_cb_unreg_ret ret;

 	pr_info("%s: request received\n", __func__);

 	xdr_recv_uint32(xdr, &arg.cb_id);

 	rc = ping_apps_data_cb_unreg(&arg, &ret);
 	if (rc < 0)
 		return rc;

 	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
 	xdr_send_uint32(xdr, &ret.result);
 	rc = xdr_send_msg(xdr);
 	if (rc < 0)
 		pr_info("%s: sending reply failed\n", __func__);
 	else
 		rc = 1;

 	return rc;
 }

 static int handle_ping_apps_register(struct msm_rpc_server *server,
 				     struct rpc_request_hdr *req,
 				     struct msm_rpc_xdr *xdr)
 {
 	uint32_t rc;
 	struct ping_apps_register_arg arg;
 	struct ping_apps_register_ret ret;

 	pr_info("%s: request received\n", __func__);

 	xdr_recv_uint32(xdr, &arg.cb_id);
 	xdr_recv_int32(xdr, &arg.num);

 	rc = ping_apps_register(&arg, &ret);
 	if (rc < 0)
 		return rc;

 	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
 	xdr_send_uint32(xdr, &ret.result);
 	rc = xdr_send_msg(xdr);
 	if (rc < 0)
 		pr_info("%s: sending reply failed\n", __func__);
 	else
 		rc = 1;

 	return rc;
 }

 static int handle_ping_apps_unregister(struct msm_rpc_server *server,
 				       struct rpc_request_hdr *req,
 				       struct msm_rpc_xdr *xdr)
 {
 	uint32_t rc;
 	struct ping_apps_unregister_arg arg;
 	struct ping_apps_unregister_ret ret;

 	pr_info("%s: request received\n", __func__);

 	xdr_recv_uint32(xdr, &arg.cb_id);

 	rc = ping_apps_unregister(&arg, &ret);
 	if (rc < 0)
 		return rc;

 	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
 	xdr_send_uint32(xdr, &ret.result);
 	rc = xdr_send_msg(xdr);
 	if (rc < 0)
 		pr_info("%s: sending reply failed\n", __func__);
 	else
 		rc = 1;

 	return rc;
 }

 static int handle_rpc_call(struct msm_rpc_server *server,
 			   struct rpc_request_hdr *req,
 			   struct msm_rpc_xdr *xdr)
 {
 	switch (req->procedure) {
 	case PING_APPS_NULL:
 		pr_info("%s: null procedure request received\n", __func__);
 		return 0;
 	case PING_APPS_DATA:
 		return handle_ping_apps_data_register(server, req, xdr);
 	case PING_APPS_REG:
 		return handle_ping_apps_register(server, req, xdr);
 	case PING_APPS_UNREG:
 		return handle_ping_apps_unregister(server, req, xdr);
 	case PING_APPS_DATA_CB_REG:
 		return handle_ping_apps_data_cb_reg(server, req, xdr);
 	case PING_APPS_DATA_CB_UNREG:
 		return handle_ping_apps_data_cb_unreg(server, req, xdr);
 	default:
 		return -ENODEV;
 	}
 }

 static int __init ping_apps_server_init(void)
 {
 	INIT_LIST_HEAD(&cb_entry_list);
 	server_thread = ERR_PTR(-1);
 	return msm_rpc_create_server2(&rpc_server);
 }

 module_init(ping_apps_server_init);

 MODULE_DESCRIPTION("PING APPS SERVER Driver");
 MODULE_LICENSE("GPL v2");
	/* Copyright (c) 2010, 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.
	*
	*/

	/*
	* PING APPS SERVER Driver
	*/

	#include <linux/slab.h>
	#include <linux/module.h>
	#include <linux/kernel.h>
	#include <linux/delay.h>
	#include <linux/err.h>
	#include <linux/kthread.h>
	#include <linux/workqueue.h>
	#include <mach/msm_rpcrouter.h>

	/* ping server definitions */

	#define PING_APPS_PROG 0x30000082
	#define PING_APPS_VERS 0x00010001

	#define PING_APPS_NULL 0
	#define PING_APPS_DATA 4
	#define PING_APPS_REG 2
	#define PING_APPS_UNREG 3
	#define PING_APPS_DATA_CB_REG 6
	#define PING_APPS_DATA_CB_UNREG 5

	#define PING_APPS_REG_CB 2
	#define PING_APPS_DATA_CB 1

	static LIST_HEAD(cb_entry_list);
	static DEFINE_MUTEX(cb_entry_list_lock);

	static struct task_struct *server_thread;

	struct ping_apps_register_arg {
	uint32_t cb_id;
	int32_t num;
	};

	struct ping_apps_unregister_arg {
	uint32_t cb_id;
	};

	struct ping_apps_register_cb_arg {
	uint32_t cb_id;
	int32_t num;
	};

	struct ping_apps_register_ret {
	uint32_t result;
	};

	struct ping_apps_unregister_ret {
	uint32_t result;
	};

	struct ping_apps_data_cb_reg_arg {
	uint32_t cb_id;
	uint32_t num;
	uint32_t size;
	uint32_t interval_ms;
	uint32_t num_tasks;
	};

	struct ping_apps_data_cb_unreg_arg {
	uint32_t cb_id;
	};

	struct ping_apps_data_cb_arg {
	uint32_t cb_id;
	uint32_t *data;
	uint32_t size;
	uint32_t sum;
	};

	struct ping_apps_data_cb_reg_ret {
	uint32_t result;
	};

	struct ping_apps_data_cb_unreg_ret {
	uint32_t result;
	};

	struct ping_apps_data_cb_ret {
	uint32_t result;
	};

	struct ping_apps_data_arg {
	uint32_t *data;
	uint32_t size;
	};

	struct ping_apps_data_ret {
	uint32_t result;
	};

	struct ping_apps_data_cb_info {
	void *cb_func;
	uint32_t size;
	uint32_t num_tasks;
	};

	struct ping_apps_cb_entry {
	struct list_head list;

	struct msm_rpc_client_info clnt_info;
	void *cb_info;
	uint32_t cb_id;
	int32_t num;
	uint32_t interval_ms;
	uint32_t time_to_next_cb;
	void (cb_func)(struct ping_apps_cb_entry );
	};

	static int handle_rpc_call(struct msm_rpc_server *server,
	struct rpc_request_hdr *req,
	struct msm_rpc_xdr *xdr);

	static int ping_apps_data_cb(struct msm_rpc_server *server,
	struct msm_rpc_client_info *clnt_info,
	struct ping_apps_data_cb_arg *arg,
	struct ping_apps_data_cb_ret *ret);

	static int ping_apps_register_cb(struct msm_rpc_server *server,
	struct msm_rpc_client_info *clnt_info,
	struct ping_apps_register_cb_arg *arg,
	void *ret);

	static struct msm_rpc_server rpc_server = {
	.prog = PING_APPS_PROG,
	.vers = PING_APPS_VERS,
	.rpc_call2 = handle_rpc_call,
	};

	static void handle_ping_apps_data_cb(struct ping_apps_cb_entry *cb_entry)
	{
	struct ping_apps_data_cb_arg arg;
	struct ping_apps_data_cb_ret ret;
	uint32_t my_sum = 0;
	uint32_t *my_data;
	int i;

	if (cb_entry->num > 0) {
	cb_entry->num--;
	arg.cb_id = cb_entry->cb_id;
	arg.size = ((struct ping_apps_data_cb_info *)
	(cb_entry->cb_info))->size;

	my_data = kmalloc((arg.size * sizeof(uint32_t)), GFP_KERNEL);
	if (!my_data)
	return;

	for (i = 0; i < arg.size; i++) {
	my_data[i] = (42 + i);
	my_sum ^= (42 + i);
	}
	arg.data = my_data;
	arg.sum = my_sum;

	((int ()(struct msm_rpc_server ,
	struct msm_rpc_client_info *,
	struct ping_apps_data_cb_arg *,
	struct ping_apps_data_cb_ret *))
	((struct ping_apps_data_cb_info *)
	(cb_entry->cb_info))->cb_func)(&rpc_server,
	&cb_entry->clnt_info,
	&arg, &ret);
	pr_info("%s: cb_id = %d, ret = %d\n",
	__func__, arg.cb_id, ret.result);
	kfree(my_data);
	}
	}

	static void handle_ping_apps_register_cb(struct ping_apps_cb_entry *cb_entry)
	{
	struct ping_apps_register_cb_arg arg;

	if (cb_entry->num > 0) {
	cb_entry->num--;
	arg.cb_id = cb_entry->cb_id;
	arg.num = cb_entry->num;

	pr_info("%s: cb_id = %d, num = %d\n",
	__func__, arg.cb_id, arg.num);
	((int ()(struct msm_rpc_server ,
	struct msm_rpc_client_info *,
	struct ping_apps_register_cb_arg *,
	void *))cb_entry->cb_info)(&rpc_server,
	&cb_entry->clnt_info,
	&arg, NULL);
	}

	}

	static int ping_apps_cb_process_thread(void *data)
	{
	struct ping_apps_cb_entry *cb_entry;
	uint32_t sleep_time;
	uint32_t time_slept = 0;

	pr_info("%s: thread started\n", __func__);
	for (;;) {
	sleep_time = 1000;
	mutex_lock(&cb_entry_list_lock);
	list_for_each_entry(cb_entry, &cb_entry_list, list) {
	if (cb_entry->time_to_next_cb <= time_slept) {
	cb_entry->cb_func(cb_entry);
	cb_entry->time_to_next_cb =
	cb_entry->interval_ms;
	} else
	cb_entry->time_to_next_cb -= time_slept;

	if (cb_entry->time_to_next_cb < sleep_time)
	sleep_time = cb_entry->time_to_next_cb;
	}
	mutex_unlock(&cb_entry_list_lock);

	msleep(sleep_time);
	time_slept = sleep_time;
	}

	do_exit(0);
	}

	static int ping_apps_data_register(struct ping_apps_data_arg *arg,
	struct ping_apps_data_ret *ret)
	{
	int i;

	ret->result = 0;
	for (i = 0; i < arg->size; i++)
	ret->result ^= arg->data[i];

	return 0;
	}

	static int ping_apps_data_cb_reg(struct ping_apps_data_cb_reg_arg *arg,
	struct ping_apps_data_cb_reg_ret *ret)
	{
	struct ping_apps_cb_entry *cb_entry;
	struct ping_apps_data_cb_info *cb_info;

	cb_entry = kmalloc(sizeof(*cb_entry), GFP_KERNEL);
	if (!cb_entry)
	return -ENOMEM;

	cb_entry->cb_info = kmalloc(sizeof(struct ping_apps_data_cb_info),
	GFP_KERNEL);
	if (!cb_entry->cb_info) {
	kfree(cb_entry);
	return -ENOMEM;
	}
	cb_info = (struct ping_apps_data_cb_info *)cb_entry->cb_info;

	INIT_LIST_HEAD(&cb_entry->list);
	cb_entry->cb_func = handle_ping_apps_data_cb;
	cb_entry->cb_id = arg->cb_id;
	cb_entry->num = arg->num;
	cb_entry->interval_ms = arg->interval_ms;
	cb_entry->time_to_next_cb = arg->interval_ms;
	cb_info->cb_func = ping_apps_data_cb;
	cb_info->size = arg->size;
	cb_info->num_tasks = arg->num_tasks;

	mutex_lock(&cb_entry_list_lock);
	list_add_tail(&cb_entry->list, &cb_entry_list);
	mutex_unlock(&cb_entry_list_lock);

	msm_rpc_server_get_requesting_client(&cb_entry->clnt_info);

	if (IS_ERR(server_thread))
	server_thread = kthread_run(ping_apps_cb_process_thread,
	NULL, "kpingrpccbprocessd");
	if (IS_ERR(server_thread)) {
	kfree(cb_entry);
	return PTR_ERR(server_thread);
	}

	ret->result = 1;
	return 0;
	}

	static int ping_apps_data_cb_unreg(struct ping_apps_data_cb_unreg_arg *arg,
	struct ping_apps_data_cb_unreg_ret *ret)
	{
	struct ping_apps_cb_entry cb_entry, tmp_cb_entry;

	mutex_lock(&cb_entry_list_lock);
	list_for_each_entry_safe(cb_entry, tmp_cb_entry,
	&cb_entry_list, list) {
	if (cb_entry->cb_id == arg->cb_id) {
	list_del(&cb_entry->list);
	kfree(cb_entry->cb_info);
	kfree(cb_entry);
	break;
	}
	}
	mutex_unlock(&cb_entry_list_lock);

	ret->result = 1;
	return 0;
	}

	static int ping_apps_register(struct ping_apps_register_arg *arg,
	struct ping_apps_register_ret *ret)
	{
	struct ping_apps_cb_entry *cb_entry;

	cb_entry = kmalloc(sizeof(*cb_entry), GFP_KERNEL);
	if (!cb_entry)
	return -ENOMEM;

	INIT_LIST_HEAD(&cb_entry->list);
	cb_entry->cb_func = handle_ping_apps_register_cb;
	cb_entry->cb_info = ping_apps_register_cb;
	cb_entry->cb_id = arg->cb_id;
	cb_entry->num = arg->num;
	cb_entry->interval_ms = 100;
	cb_entry->time_to_next_cb = 100;

	mutex_lock(&cb_entry_list_lock);
	list_add_tail(&cb_entry->list, &cb_entry_list);
	mutex_unlock(&cb_entry_list_lock);

	msm_rpc_server_get_requesting_client(&cb_entry->clnt_info);

	if (IS_ERR(server_thread))
	server_thread = kthread_run(ping_apps_cb_process_thread,
	NULL, "kpingrpccbprocessd");
	if (IS_ERR(server_thread)) {
	kfree(cb_entry);
	return PTR_ERR(server_thread);
	}

	ret->result = 1;
	return 0;
	}

	static int ping_apps_unregister(struct ping_apps_unregister_arg *arg,
	struct ping_apps_unregister_ret *ret)
	{
	struct ping_apps_cb_entry cb_entry, tmp_cb_entry;

	mutex_lock(&cb_entry_list_lock);
	list_for_each_entry_safe(cb_entry, tmp_cb_entry,
	&cb_entry_list, list) {
	if (cb_entry->cb_id == arg->cb_id) {
	list_del(&cb_entry->list);
	kfree(cb_entry);
	break;
	}
	}
	mutex_unlock(&cb_entry_list_lock);

	ret->result = 1;
	return 0;
	}

	static int ping_apps_data_cb_arg_func(struct msm_rpc_server *server,
	struct msm_rpc_xdr xdr, void data)
	{
	struct ping_apps_data_cb_arg *arg = data;

	xdr_send_uint32(xdr, &arg->cb_id);
	xdr_send_array(xdr, (void **)&arg->data, &arg->size, 64,
	sizeof(uint32_t), (void *)xdr_send_uint32);
	xdr_send_uint32(xdr, &arg->size);
	xdr_send_uint32(xdr, &arg->sum);

	return 0;
	}

	static int ping_apps_data_cb_ret_func(struct msm_rpc_server *server,
	struct msm_rpc_xdr xdr, void data)
	{
	struct ping_apps_data_cb_ret *ret = data;

	xdr_recv_uint32(xdr, &ret->result);

	return 0;
	}

	static int ping_apps_data_cb(struct msm_rpc_server *server,
	struct msm_rpc_client_info *clnt_info,
	struct ping_apps_data_cb_arg *arg,
	struct ping_apps_data_cb_ret *ret)
	{
	return msm_rpc_server_cb_req2(server, clnt_info,
	PING_APPS_DATA_CB,
	ping_apps_data_cb_arg_func, arg,
	ping_apps_data_cb_ret_func, ret, -1);
	}

	static int ping_apps_register_cb_arg(struct msm_rpc_server *server,
	struct msm_rpc_xdr xdr, void data)
	{
	struct ping_apps_register_cb_arg *arg = data;

	xdr_send_uint32(xdr, &arg->cb_id);
	xdr_send_int32(xdr, &arg->num);

	return 0;
	}

	static int ping_apps_register_cb(struct msm_rpc_server *server,
	struct msm_rpc_client_info *clnt_info,
	struct ping_apps_register_cb_arg *arg,
	void *ret)
	{
	return msm_rpc_server_cb_req2(server, clnt_info,
	PING_APPS_REG_CB,
	ping_apps_register_cb_arg,
	arg, NULL, NULL, -1);
	}

	static int handle_ping_apps_data_register(struct msm_rpc_server *server,
	struct rpc_request_hdr *req,
	struct msm_rpc_xdr *xdr)
	{
	uint32_t rc;
	struct ping_apps_data_arg arg;
	struct ping_apps_data_ret ret;

	pr_info("%s: request received\n", __func__);

	xdr_recv_array(xdr, (void **)&arg.data, &arg.size, 64,
	sizeof(uint32_t), (void *)xdr_recv_uint32);
	xdr_recv_uint32(xdr, &arg.size);

	rc = ping_apps_data_register(&arg, &ret);
	if (rc < 0)
	goto free_and_return;

	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
	xdr_send_uint32(xdr, &ret.result);
	rc = xdr_send_msg(xdr);
	if (rc < 0)
	pr_info("%s: sending reply failed\n", __func__);
	else
	rc = 1;

	free_and_return:
	kfree(arg.data);
	return rc;
	}

	static int handle_ping_apps_data_cb_reg(struct msm_rpc_server *server,
	struct rpc_request_hdr *req,
	struct msm_rpc_xdr *xdr)
	{
	uint32_t rc;
	struct ping_apps_data_cb_reg_arg arg;
	struct ping_apps_data_cb_reg_ret ret;

	pr_info("%s: request received\n", __func__);

	xdr_recv_uint32(xdr, &arg.cb_id);
	xdr_recv_uint32(xdr, &arg.num);
	xdr_recv_uint32(xdr, &arg.size);
	xdr_recv_uint32(xdr, &arg.interval_ms);
	xdr_recv_uint32(xdr, &arg.num_tasks);

	rc = ping_apps_data_cb_reg(&arg, &ret);
	if (rc < 0)
	return rc;

	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
	xdr_send_uint32(xdr, &ret.result);
	rc = xdr_send_msg(xdr);
	if (rc < 0)
	pr_info("%s: sending reply failed\n", __func__);
	else
	rc = 1;

	return rc;
	}

	static int handle_ping_apps_data_cb_unreg(struct msm_rpc_server *server,
	struct rpc_request_hdr *req,
	struct msm_rpc_xdr *xdr)
	{
	uint32_t rc;
	struct ping_apps_data_cb_unreg_arg arg;
	struct ping_apps_data_cb_unreg_ret ret;

	pr_info("%s: request received\n", __func__);

	xdr_recv_uint32(xdr, &arg.cb_id);

	rc = ping_apps_data_cb_unreg(&arg, &ret);
	if (rc < 0)
	return rc;

	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
	xdr_send_uint32(xdr, &ret.result);
	rc = xdr_send_msg(xdr);
	if (rc < 0)
	pr_info("%s: sending reply failed\n", __func__);
	else
	rc = 1;

	return rc;
	}

	static int handle_ping_apps_register(struct msm_rpc_server *server,
	struct rpc_request_hdr *req,
	struct msm_rpc_xdr *xdr)
	{
	uint32_t rc;
	struct ping_apps_register_arg arg;
	struct ping_apps_register_ret ret;

	pr_info("%s: request received\n", __func__);

	xdr_recv_uint32(xdr, &arg.cb_id);
	xdr_recv_int32(xdr, &arg.num);

	rc = ping_apps_register(&arg, &ret);
	if (rc < 0)
	return rc;

	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
	xdr_send_uint32(xdr, &ret.result);
	rc = xdr_send_msg(xdr);
	if (rc < 0)
	pr_info("%s: sending reply failed\n", __func__);
	else
	rc = 1;

	return rc;
	}

	static int handle_ping_apps_unregister(struct msm_rpc_server *server,
	struct rpc_request_hdr *req,
	struct msm_rpc_xdr *xdr)
	{
	uint32_t rc;
	struct ping_apps_unregister_arg arg;
	struct ping_apps_unregister_ret ret;

	pr_info("%s: request received\n", __func__);

	xdr_recv_uint32(xdr, &arg.cb_id);

	rc = ping_apps_unregister(&arg, &ret);
	if (rc < 0)
	return rc;

	xdr_start_accepted_reply(xdr, RPC_ACCEPTSTAT_SUCCESS);
	xdr_send_uint32(xdr, &ret.result);
	rc = xdr_send_msg(xdr);
	if (rc < 0)
	pr_info("%s: sending reply failed\n", __func__);
	else
	rc = 1;

	return rc;
	}

	static int handle_rpc_call(struct msm_rpc_server *server,
	struct rpc_request_hdr *req,
	struct msm_rpc_xdr *xdr)
	{
	switch (req->procedure) {
	case PING_APPS_NULL:
	pr_info("%s: null procedure request received\n", __func__);
	return 0;
	case PING_APPS_DATA:
	return handle_ping_apps_data_register(server, req, xdr);
	case PING_APPS_REG:
	return handle_ping_apps_register(server, req, xdr);
	case PING_APPS_UNREG:
	return handle_ping_apps_unregister(server, req, xdr);
	case PING_APPS_DATA_CB_REG:
	return handle_ping_apps_data_cb_reg(server, req, xdr);
	case PING_APPS_DATA_CB_UNREG:
	return handle_ping_apps_data_cb_unreg(server, req, xdr);
	default:
	return -ENODEV;
	}
	}

	static int __init ping_apps_server_init(void)
	{
	INIT_LIST_HEAD(&cb_entry_list);
	server_thread = ERR_PTR(-1);
	return msm_rpc_create_server2(&rpc_server);
	}

	module_init(ping_apps_server_init);

	MODULE_DESCRIPTION("PING APPS SERVER Driver");
	MODULE_LICENSE("GPL v2");