// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2019 MediaTek Inc.
 */

#define pr_fmt(fmt) "<STEP_COUNTER> " fmt

#include "step_counter.h"

static struct step_c_context *step_c_context_obj;
static struct step_c_init_info *
	step_counter_init_list[MAX_CHOOSE_STEP_C_NUM] = { 0 };

static void step_c_work_func(struct work_struct *work)
{

	struct step_c_context *cxt = NULL;
	uint32_t counter;
	uint32_t counter_floor_c;
	/* hwm_sensor_data sensor_data; */
	int status;
	int64_t nt;
	struct timespec time;
	int err = 0;

	cxt = step_c_context_obj;

	if (cxt->step_c_data.get_data == NULL)
		pr_debug("step_c driver not register data path\n");
	if (cxt->step_c_data.get_data_floor_c == NULL)
		pr_debug("floor_c driver not register data path\n");


	status = 0;
	counter = 0;
	time.tv_sec = time.tv_nsec = 0;
	time = get_monotonic_coarse();
	nt = time.tv_sec * 1000000000LL + time.tv_nsec;

	/* add wake lock to make sure data can be read before system suspend */
	if ((cxt->is_active_data == true) &&
		(cxt->step_c_data.get_data != NULL))
		err = cxt->step_c_data.get_data(&counter, &status);

	if (err) {
		pr_err("get step_c data fails!!\n");
		goto step_c_loop;
	} else {
		{
			cxt->drv_data.counter = counter;
			cxt->drv_data.status = status;
		}
	}

	status = 0;
	counter_floor_c = 0;
	if ((cxt->is_floor_c_active_data == true) &&
		(cxt->step_c_data.get_data_floor_c != NULL))
		err = cxt->step_c_data.get_data_floor_c(&counter_floor_c,
							&status);

	if (err) {
		pr_err("get floor_c data fails!!\n");
		goto step_c_loop;
	} else {
		{
			cxt->drv_data.floor_counter = counter_floor_c;
			cxt->drv_data.floor_c_status = status;
		}
	}

	if (true == cxt->is_first_data_after_enable) {
		cxt->is_first_data_after_enable = false;
		/* filter -1 value */
		if (cxt->drv_data.counter == STEP_C_INVALID_VALUE) {
			pr_debug(" read invalid data\n");
			goto step_c_loop;

		}
	}

	if (true == cxt->is_first_floor_c_data_after_enable) {
		cxt->is_first_floor_c_data_after_enable = false;
		/* filter -1 value */
		if (cxt->drv_data.floor_counter == STEP_C_INVALID_VALUE) {
			pr_debug(" read invalid data\n");
			goto step_c_loop;

		}
	}

	/* report data to input device */
	/*pr_debug("step_c data[%d]\n", cxt->drv_data.counter);*/

	step_c_data_report(cxt->drv_data.counter, cxt->drv_data.status);
	floor_c_data_report(cxt->drv_data.floor_counter,
		cxt->drv_data.floor_c_status);

step_c_loop:
	if (true == cxt->is_polling_run) {
		mod_timer(&cxt->timer,
			jiffies + atomic_read(&cxt->delay) / (1000 / HZ));
	}
}

static void step_c_poll(struct timer_list *t)
{
	struct step_c_context *obj = from_timer(obj, t, timer);

	if (obj != NULL)
		schedule_work(&obj->report);
}

static struct step_c_context *step_c_context_alloc_object(void)
{
	struct step_c_context *obj = kzalloc(sizeof(*obj), GFP_KERNEL);

	pr_debug("%s start\n", __func__);
	if (!obj) {
		pr_err("Alloc step_c object error!\n");
		return NULL;
	}
	atomic_set(&obj->delay, 2000);	/*0.5Hz */
	atomic_set(&obj->wake, 0);
	INIT_WORK(&obj->report, step_c_work_func);
	timer_setup(&obj->timer, step_c_poll, 0);
	obj->timer.expires = jiffies + atomic_read(&obj->delay) / (1000 / HZ);
	obj->is_first_data_after_enable = false;
	obj->is_polling_run = false;
	mutex_init(&obj->step_c_op_mutex);
	obj->is_step_c_batch_enable = false;	/* for batch mode init */
	obj->is_step_d_batch_enable = false;	/* for batch mode init */

	pr_debug("%s end\n", __func__);
	return obj;
}

int step_notify_t(enum STEP_NOTIFY_TYPE type, int64_t time_stamp)
{
	int err = 0;
	struct step_c_context *cxt = NULL;
	struct sensor_event event;

	memset(&event, 0, sizeof(struct sensor_event));

	cxt = step_c_context_obj;
	event.time_stamp = time_stamp;

	if (type == TYPE_STEP_DETECTOR) {
		event.flush_action = DATA_ACTION;
		event.handle = ID_STEP_DETECTOR;
		event.word[0] = 1;
		err = sensor_input_event(step_c_context_obj->mdev.minor,
			&event);

	}
	if (type == TYPE_SIGNIFICANT) {
		pr_debug("fwq TYPE_SIGNIFICANT notify\n");
		/* cxt->step_c_data.get_data_significant(&value); */
		event.flush_action = DATA_ACTION;
		event.handle = ID_SIGNIFICANT_MOTION;
		event.word[0] = 1;
		err = sensor_input_event(step_c_context_obj->mdev.minor,
			&event);
	}

	return err;
}
int step_notify(enum STEP_NOTIFY_TYPE type)
{
	return step_notify_t(type, 0);
}
static int step_d_real_enable(int enable)
{
	int err = 0;
	unsigned int i = 0;
	struct step_c_context *cxt = NULL;

	cxt = step_c_context_obj;
	if (enable == 1) {

		for (i = 0; i < 3; i++) {
			err = cxt->step_c_ctl.enable_step_detect(1);
			if (err == 0)
				break;
			else if (i == 2) {
				pr_err("step_d E(%d)err 3 = %d\n",
					enable, err);
			}
		}

		pr_debug("step_d real enable\n");
	}
	if (enable == 0) {

		err = cxt->step_c_ctl.enable_step_detect(0);
		if (err)
			pr_err("step_d enable(%d) err = %d\n",
				enable, err);
		pr_debug("step_d real disable\n");

	}

	return err;
}

static int significant_real_enable(int enable)
{
	int err = 0;
	unsigned int i = 0;
	struct step_c_context *cxt = NULL;

	cxt = step_c_context_obj;
	if (enable == 1) {

		for (i = 0; i < 3; i++) {
			err = cxt->step_c_ctl.enable_significant(1);
			if (err == 0)
				break;
			else if (i == 2) {
				pr_err("significant E(%d)err 3 = %d\n",
					enable, err);
			}
		}

		pr_debug("enable_significant real enable\n");
	}
	if (enable == 0) {
		err = cxt->step_c_ctl.enable_significant(0);
		if (err)
			pr_err("enable_significantenable(%d) err = %d\n",
				enable, err);
		pr_debug("enable_significant real disable\n");

	}
	return err;
}


static int step_c_real_enable(int enable)
{
	int err = 0;
	unsigned int i = 0;
	struct step_c_context *cxt = NULL;

	cxt = step_c_context_obj;
	if (enable == 1) {
		if (true == cxt->is_active_data ||
			true == cxt->is_active_nodata) {

			for (i = 0; i < 3; i++) {
				err = cxt->step_c_ctl.enable_nodata(1);
				if (err == 0)
					break;
				else if (i == 2) {
					pr_err("step_c E(%d)err 3 =%d\n",
						enable, err);
				}
			}

			pr_debug("step_c real enable\n");
		}
	}
	if (enable == 0) {
		if (false == cxt->is_active_data &&
			false == cxt->is_active_nodata) {
			err = cxt->step_c_ctl.enable_nodata(0);
			if (err)
				pr_err("step_c enable(%d) err = %d\n",
					enable, err);
			pr_debug("step_c real disable\n");
		}

	}

	return err;
}


static int floor_c_real_enable(int enable)
{
	int err = 0;
	unsigned int i = 0;
	struct step_c_context *cxt = NULL;

	cxt = step_c_context_obj;
	if (enable == 1) {
		for (i = 0; i < 3; i++) {
			err = cxt->step_c_ctl.enable_floor_c(1);
			if (err == 0)
				break;
			else if (i == 2)
				pr_err("floor_c enable(%d) err 3 = %d\n",
					enable, err);
		}

		pr_debug("floor_c real enable\n");
	}
	if (enable == 0) {
		err = cxt->step_c_ctl.enable_floor_c(0);
		if (err)
			pr_err("floor_c enable(%d) err = %d\n",
				enable, err);
		pr_debug("floor_c real disable\n");

	}

	return err;
}



static int step_c_enable_data(int enable)
{
	struct step_c_context *cxt = NULL;

	cxt = step_c_context_obj;
	if (cxt->step_c_ctl.open_report_data == NULL) {
		pr_err("no step_c control path\n");
		return -1;
	}

	if (enable == 1) {
		pr_debug("STEP_C enable data\n");
		cxt->is_active_data = true;
		cxt->is_first_data_after_enable = true;
		cxt->step_c_ctl.open_report_data(1);
		if (false == cxt->is_polling_run &&
			cxt->is_step_c_batch_enable == false) {
			if (false == cxt->step_c_ctl.is_report_input_direct) {
				mod_timer(&cxt->timer, jiffies +
					atomic_read(&cxt->delay) / (1000 / HZ));
				cxt->is_polling_run = true;
			}
		}
	}
	if (enable == 0) {
		pr_debug("STEP_C disable\n");
		cxt->is_active_data = false;
		cxt->step_c_ctl.open_report_data(0);
		if (true == cxt->is_polling_run) {
			if (false == cxt->step_c_ctl.is_report_input_direct) {
				cxt->is_polling_run = false;
				del_timer_sync(&cxt->timer);
				cancel_work_sync(&cxt->report);
				cxt->drv_data.counter = STEP_C_INVALID_VALUE;
			}
		}

	}
	step_c_real_enable(enable);
	return 0;
}


static int floor_c_enable_data(int enable)
{
	struct step_c_context *cxt = NULL;

	cxt = step_c_context_obj;

	if (enable == 1) {
		pr_debug("FLOOR_C enable data\n");
		cxt->is_floor_c_active_data = true;
		cxt->is_first_floor_c_data_after_enable = true;
		floor_c_real_enable(1);
		if (false == cxt->is_polling_run &&
			cxt->is_step_c_batch_enable == false) {
			if (false == cxt->step_c_ctl.is_report_input_direct) {
				mod_timer(&cxt->timer, jiffies +
					atomic_read(&cxt->delay) / (1000 / HZ));
				cxt->is_polling_run = true;
			}
		}
	}
	if (enable == 0) {
		pr_debug("FLOOR_C disable\n");
		cxt->is_floor_c_active_data = false;
		floor_c_real_enable(0);
		if (true == cxt->is_polling_run) {
			if (false == cxt->step_c_ctl.is_report_input_direct) {
				cxt->is_polling_run = false;
				del_timer_sync(&cxt->timer);
				cancel_work_sync(&cxt->report);
				cxt->drv_data.floor_counter =
					STEP_C_INVALID_VALUE;
			}
		}

	}
	return 0;
}



int step_c_enable_nodata(int enable)
{
	struct step_c_context *cxt = NULL;

	cxt = step_c_context_obj;
	if (cxt->step_c_ctl.enable_nodata == NULL) {
		pr_err("%s:step_c ctl path is NULL\n", __func__);
		return -1;
	}

	if (enable == 1)
		cxt->is_active_nodata = true;

	if (enable == 0)
		cxt->is_active_nodata = false;
	step_c_real_enable(enable);
	return 0;
}


static ssize_t step_cenablenodata_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	int len = 0;

	pr_debug(" not support now\n");
	return len;
}

static ssize_t step_cenablenodata_store(struct device *dev,
	struct device_attribute *attr, const char *buf, size_t count)
{
	int err = 0;
	struct step_c_context *cxt = NULL;

	pr_debug("step_c_store_enable nodata buf=%s\n", buf);
	mutex_lock(&step_c_context_obj->step_c_op_mutex);
	cxt = step_c_context_obj;
	if (cxt->step_c_ctl.enable_nodata == NULL) {
		pr_debug("step_c_ctl enable nodata NULL\n");
		mutex_unlock(&step_c_context_obj->step_c_op_mutex);
		return count;
	}
	if (!strncmp(buf, "1", 1))
		err = step_c_enable_nodata(1);
	else if (!strncmp(buf, "0", 1))
		err = step_c_enable_nodata(0);
	else
		pr_err(" step_c_store enable nodata cmd error !!\n");
	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
	return err;
}

static ssize_t step_cactive_store(struct device *dev,
	struct device_attribute *attr, const char *buf, size_t count)
{
	struct step_c_context *cxt = NULL;
	int res = 0;
	int handle = 0;
	int en = 0;

	pr_debug("%s buf=%s\n", __func__, buf);
	mutex_lock(&step_c_context_obj->step_c_op_mutex);

	cxt = step_c_context_obj;
	if (cxt->step_c_ctl.open_report_data == NULL) {
		pr_debug("step_c_ctl enable NULL\n");
		mutex_unlock(&step_c_context_obj->step_c_op_mutex);
		return count;
	}
	res = sscanf(buf, "%d,%d", &handle, &en);
	if (res != 2)
		pr_debug("%s param error: res = %d\n", __func__, res);
	pr_debug("%s handle=%d ,en=%d\n", __func__, handle, en);
	switch (handle) {
	case ID_STEP_COUNTER:
		if (en == 1)
			res = step_c_enable_data(1);
		else if (en == 0)
			res = step_c_enable_data(0);
		else
			pr_err("%s error !!\n", __func__);
		break;
	case ID_STEP_DETECTOR:
		if (en == 1)
			res = step_d_real_enable(1);
		else if (en == 0)
			res = step_d_real_enable(0);
		else
			pr_err(" step_d_real_enable error !!\n");
		break;
	case ID_SIGNIFICANT_MOTION:
		if (en == 1)
			res = significant_real_enable(1);
		else if (en == 0)
			res = significant_real_enable(0);
		else
			pr_err(" significant_real_enable error !!\n");
		break;
	case ID_FLOOR_COUNTER:
		if (en == 1)
			res = floor_c_enable_data(1);
		else if (en == 0)
			res = floor_c_enable_data(0);
		else
			pr_err(" fc_real_enable error !!\n");
		break;

	}
	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
	pr_debug("%s done\n", __func__);
	return res;
}

/*----------------------------------------------------------------------------*/
static ssize_t step_cactive_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct step_c_context *cxt = NULL;
	int div;

	cxt = step_c_context_obj;
	div = cxt->step_c_data.vender_div;
	pr_debug("step_c vender_div value: %d\n", div);
	return snprintf(buf, PAGE_SIZE, "%d\n", div);
}

static ssize_t step_cdelay_store(struct device *dev,
	struct device_attribute *attr, const char *buf, size_t count)
{
	int delay = 0, err = 0;
	int mdelay = 0;
	struct step_c_context *cxt = NULL;

	mutex_lock(&step_c_context_obj->step_c_op_mutex);
	cxt = step_c_context_obj;
	if (cxt->step_c_ctl.step_c_set_delay == NULL) {
		pr_debug("step_c_ctl step_c_set_delay NULL\n");
		mutex_unlock(&step_c_context_obj->step_c_op_mutex);
		return -1;
	}

	if (kstrtoint(buf, 10, &delay) != 0) {
		pr_err("invalid format!!\n");
		mutex_unlock(&step_c_context_obj->step_c_op_mutex);
		return -1;
	}

	if (false == cxt->step_c_ctl.is_report_input_direct) {
		mdelay = (int)delay / 1000 / 1000;
		atomic_set(&step_c_context_obj->delay, mdelay);
	}
	err = cxt->step_c_ctl.step_c_set_delay(delay);
	pr_debug(" step_c_delay %d ns\n", delay);
	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
	return err;

}

static ssize_t step_cdelay_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	int len = 0;

	pr_debug(" not support now\n");
	return len;
}


static ssize_t step_cbatch_store(struct device *dev,
	struct device_attribute *attr, const char *buf, size_t count)
{
	struct step_c_context *cxt = NULL;
	int handle = 0, flag = 0, res = 0;
	int64_t samplingPeriodNs = 0, maxBatchReportLatencyNs = 0;

	res = sscanf(buf, "%d,%d,%lld,%lld",
		&handle, &flag, &samplingPeriodNs, &maxBatchReportLatencyNs);
	if (res != 4)
		pr_err("%s param error: err =%d\n", __func__, res);
	pr_debug("handle %d, flag:%d PeriodNs:%lld, LatencyNs: %lld\n",
		handle, flag, samplingPeriodNs, maxBatchReportLatencyNs);
	mutex_lock(&step_c_context_obj->step_c_op_mutex);
	cxt = step_c_context_obj;
	if (handle == ID_STEP_COUNTER) {
		if (!cxt->step_c_ctl.is_counter_support_batch)
			maxBatchReportLatencyNs = 0;
		if (cxt->step_c_ctl.step_c_batch != NULL)
			res = cxt->step_c_ctl.step_c_batch(flag,
				samplingPeriodNs, maxBatchReportLatencyNs);
		else
			pr_err("SUPPORT STEP COUNTER COM BATCH\n");
		if (res < 0)
			pr_err("step counter enable batch err %d\n",
				res);
	} else if (handle == ID_STEP_DETECTOR) {
		if (!cxt->step_c_ctl.is_detector_support_batch)
			maxBatchReportLatencyNs = 0;
		if (cxt->step_c_ctl.step_d_batch != NULL)
			res = cxt->step_c_ctl.step_d_batch(flag,
				samplingPeriodNs, maxBatchReportLatencyNs);
		else
			pr_err("NOT SUPPORT STEP DETECTOR COM BATCH\n");
		if (res < 0)
			pr_err("step detector enable batch err %d\n",
				res);
	} else if (handle == ID_SIGNIFICANT_MOTION) {
		if (!cxt->step_c_ctl.is_smd_support_batch)
			maxBatchReportLatencyNs = 0;

		if (cxt->step_c_ctl.smd_batch != NULL)
			res = cxt->step_c_ctl.smd_batch(flag,
			samplingPeriodNs, maxBatchReportLatencyNs);
		else
			pr_err("STEP SMD OLD NOT SUPPORT COM BATCH\n");
		if (res < 0)
			pr_err("step smd enable batch err %d\n", res);
	} else if (handle == ID_FLOOR_COUNTER) {
		if (!cxt->step_c_ctl.is_floor_c_support_batch)
			maxBatchReportLatencyNs = 0;

		if (cxt->step_c_ctl.floor_c_batch != NULL)
			res = cxt->step_c_ctl.floor_c_batch(flag,
				samplingPeriodNs, maxBatchReportLatencyNs);
		else
			pr_err("NOT SUPPORT FLOOR COUNT COM BATCH\n");
		if (res < 0)
			pr_err("floor count enable batch err %d\n", res);
	}
	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
	pr_debug("%s done: %d\n", __func__, cxt->is_step_c_batch_enable);
	return res;
}

static ssize_t step_cbatch_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
}

static ssize_t step_cflush_store(struct device *dev,
	struct device_attribute *attr,
				  const char *buf, size_t count)
{
	struct step_c_context *cxt = NULL;
	int handle = 0, err = 0;

	err = kstrtoint(buf, 10, &handle);
	if (err != 0)
		pr_err("%s param error: err = %d\n", __func__, err);

	pr_debug("%s param: handle %d\n", __func__, handle);

	mutex_lock(&step_c_context_obj->step_c_op_mutex);
	cxt = step_c_context_obj;
	if (handle == ID_STEP_COUNTER) {
		if (cxt->step_c_ctl.step_c_flush != NULL)
			err = cxt->step_c_ctl.step_c_flush();
		else
			pr_err("NOT SUPPORT STEP COUNTER COM FLUSH\n");
		if (err < 0)
			pr_err("step counter enable flush err %d\n",
				err);
	} else if (handle == ID_STEP_DETECTOR) {
		if (cxt->step_c_ctl.step_d_flush != NULL)
			err = cxt->step_c_ctl.step_d_flush();
		else
			pr_err("NOT SUPPORT STEP DETECTOR COM FLUSH\n");
		if (err < 0)
			pr_err("step detector enable flush err %d\n",
				err);
	} else if (handle == ID_SIGNIFICANT_MOTION) {
		if (cxt->step_c_ctl.smd_flush != NULL)
			err = cxt->step_c_ctl.smd_flush();
		else
			pr_err("NOT SUPPORT SMD COMMON VERSION FLUSH\n");
		if (err < 0)
			pr_err("smd enable flush err %d\n", err);
	} else if (handle == ID_FLOOR_COUNTER) {
		if (cxt->step_c_ctl.floor_c_flush != NULL)
			err = cxt->step_c_ctl.floor_c_flush();
		else
			pr_err("NOT SUPPORT FLOOR COUNTER COM FLUSH\n");
		if (err < 0)
			pr_err("floor counter enable flush err %d\n",
				err);

	}
	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
	return err;
}

static ssize_t step_cflush_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
}

static ssize_t step_cdevnum_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
}

static int step_counter_remove(struct platform_device *pdev)
{
	pr_debug("%s\n", __func__);
	return 0;
}

static int step_counter_probe(struct platform_device *pdev)
{
	pr_debug("%s\n", __func__);
	return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id step_counter_of_match[] = {
	{.compatible = "mediatek,step_counter",},
	{},
};
#endif

static struct platform_driver step_counter_driver = {
	.probe = step_counter_probe,
	.remove = step_counter_remove,
	.driver = {

		   .name = "step_counter",
#ifdef CONFIG_OF
		   .of_match_table = step_counter_of_match,
#endif
		}
};

static int step_c_real_driver_init(void)
{
	int i = 0;
	int err = 0;

	pr_debug("%s start\n", __func__);
	for (i = 0; i < MAX_CHOOSE_STEP_C_NUM; i++) {
		pr_debug(" i=%d\n", i);
		if (step_counter_init_list[i] != 0) {
			pr_debug(" step_c try to init driver %s\n",
				   step_counter_init_list[i]->name);
			err = step_counter_init_list[i]->init();
			if (err == 0) {
				pr_debug(" step_c real driver %s probe ok\n",
					   step_counter_init_list[i]->name);
				break;
			}
		}
	}

	if (i == MAX_CHOOSE_STEP_C_NUM) {
		pr_debug("%s fail\n", __func__);
		err = -1;
	}
	return err;
}

int step_c_driver_add(struct step_c_init_info *obj)
{
	int err = 0;
	int i = 0;

	pr_debug("%s\n", __func__);

	pr_debug("register step_counter driver for the first time\n");
	if (platform_driver_register(&step_counter_driver))
		pr_err("fail to register gensor driver already exist\n");
	for (i = 0; i < MAX_CHOOSE_STEP_C_NUM; i++) {
		if (step_counter_init_list[i] == NULL) {
			obj->platform_diver_addr = &step_counter_driver;
			step_counter_init_list[i] = obj;
			break;
		}
	}
	if (i >= MAX_CHOOSE_STEP_C_NUM) {
		pr_err("STEP_C driver add err\n");
		err = -1;
	}

	return err;
}

static int step_open(struct inode *inode, struct file *file)
{
	nonseekable_open(inode, file);
	return 0;
}

static ssize_t step_read(struct file *file, char __user *buffer,
			  size_t count, loff_t *ppos)
{
	ssize_t read_cnt = 0;

	read_cnt = sensor_event_read(step_c_context_obj->mdev.minor,
		file, buffer, count, ppos);

	return read_cnt;
}

static unsigned int step_poll(struct file *file, poll_table *wait)
{
	return sensor_event_poll(step_c_context_obj->mdev.minor, file, wait);
}

static const struct file_operations step_fops = {
	.owner = THIS_MODULE,
	.open = step_open,
	.read = step_read,
	.poll = step_poll,
};

static int step_c_misc_init(struct step_c_context *cxt)
{

	int err = 0;
	/* kernel-3.10\include\linux\Miscdevice.h */
	/* use MISC_DYNAMIC_MINOR exceed 64 */
	cxt->mdev.minor = ID_STEP_COUNTER;
	cxt->mdev.name = STEP_C_MISC_DEV_NAME;
	cxt->mdev.fops = &step_fops;
	err = sensor_attr_register(&cxt->mdev);
	if (err)
		pr_err("unable to register step_c misc device!!\n");
	return err;
}

DEVICE_ATTR_RW(step_cenablenodata);
DEVICE_ATTR_RW(step_cactive);
DEVICE_ATTR_RW(step_cdelay);
DEVICE_ATTR_RW(step_cbatch);
DEVICE_ATTR_RW(step_cflush);
DEVICE_ATTR_RO(step_cdevnum);


static struct attribute *step_c_attributes[] = {
	&dev_attr_step_cenablenodata.attr,
	&dev_attr_step_cactive.attr,
	&dev_attr_step_cdelay.attr,
	&dev_attr_step_cbatch.attr,
	&dev_attr_step_cflush.attr,
	&dev_attr_step_cdevnum.attr,
	NULL
};

static struct attribute_group step_c_attribute_group = {
	.attrs = step_c_attributes
};

int step_c_register_data_path(struct step_c_data_path *data)
{
	struct step_c_context *cxt = NULL;

	cxt = step_c_context_obj;
	cxt->step_c_data.get_data = data->get_data;
	cxt->step_c_data.vender_div = data->vender_div;
	cxt->step_c_data.get_data_significant = data->get_data_significant;
	cxt->step_c_data.get_data_step_d = data->get_data_step_d;
	cxt->step_c_data.get_data_floor_c = data->get_data_floor_c;
	pr_debug("step_c register data path vender_div: %d\n",
		cxt->step_c_data.vender_div);
	if (cxt->step_c_data.get_data == NULL
	    || cxt->step_c_data.get_data_significant == NULL
	    || cxt->step_c_data.get_data_step_d == NULL) {
		pr_debug("step_c register data path fail\n");
		return -1;
	}
	return 0;
}

int step_c_register_control_path(struct step_c_control_path *ctl)
{
	struct step_c_context *cxt = NULL;
	int err = 0;

	cxt = step_c_context_obj;
	cxt->step_c_ctl.step_c_set_delay = ctl->step_c_set_delay;
	cxt->step_c_ctl.step_d_set_delay = ctl->step_d_set_delay;
	cxt->step_c_ctl.floor_c_set_delay = ctl->floor_c_set_delay;
	cxt->step_c_ctl.open_report_data = ctl->open_report_data;
	cxt->step_c_ctl.enable_nodata = ctl->enable_nodata;
	cxt->step_c_ctl.step_c_batch = ctl->step_c_batch;
	cxt->step_c_ctl.step_c_flush = ctl->step_c_flush;
	cxt->step_c_ctl.step_d_batch = ctl->step_d_batch;
	cxt->step_c_ctl.step_d_flush = ctl->step_d_flush;
	cxt->step_c_ctl.smd_batch = ctl->smd_batch;
	cxt->step_c_ctl.smd_flush = ctl->smd_flush;
	cxt->step_c_ctl.floor_c_batch = ctl->floor_c_batch;
	cxt->step_c_ctl.floor_c_flush = ctl->floor_c_flush;
	cxt->step_c_ctl.is_counter_support_batch =
		ctl->is_counter_support_batch;
	cxt->step_c_ctl.is_detector_support_batch =
		ctl->is_detector_support_batch;
	cxt->step_c_ctl.is_smd_support_batch = ctl->is_smd_support_batch;
	cxt->step_c_ctl.is_floor_c_support_batch =
		ctl->is_floor_c_support_batch;
	cxt->step_c_ctl.is_report_input_direct = ctl->is_report_input_direct;
	cxt->step_c_ctl.enable_significant = ctl->enable_significant;
	cxt->step_c_ctl.enable_step_detect = ctl->enable_step_detect;
	cxt->step_c_ctl.enable_floor_c = ctl->enable_floor_c;

	if ((cxt->step_c_ctl.step_c_set_delay == NULL)
		|| (cxt->step_c_ctl.open_report_data == NULL)
		|| (cxt->step_c_ctl.enable_nodata == NULL)
		|| (cxt->step_c_ctl.step_d_set_delay == NULL)
		|| (cxt->step_c_ctl.enable_significant == NULL)
		|| (cxt->step_c_ctl.enable_step_detect == NULL)) {
		pr_debug("step_c register control path fail\n");
		return -1;
	}

	/* add misc dev for sensor hal control cmd */
	err = step_c_misc_init(step_c_context_obj);
	if (err) {
		pr_err("unable to register step_c misc device!!\n");
		return -2;
	}
	err = sysfs_create_group(&step_c_context_obj->mdev.this_device->kobj,
				 &step_c_attribute_group);
	if (err < 0) {
		pr_err("unable to create step_c attribute file\n");
		return -3;
	}

	kobject_uevent(&step_c_context_obj->mdev.this_device->kobj, KOBJ_ADD);

	return 0;
}

int step_c_data_report_t(uint32_t new_counter, int status, int64_t time_stamp)
{
	int err = 0;
	struct sensor_event event;
	static uint32_t last_step_counter;

	memset(&event, 0, sizeof(struct sensor_event));
	event.time_stamp = time_stamp;
	if (last_step_counter != new_counter) {
		event.flush_action = DATA_ACTION;
		event.handle = ID_STEP_COUNTER;
		event.word[0] = new_counter;
		err = sensor_input_event(step_c_context_obj->mdev.minor,
			&event);
		if (err >= 0)
			last_step_counter = new_counter;
	}
	return err;
}
int step_c_data_report(uint32_t new_counter, int status)
{
	return step_c_data_report_t(new_counter, status, 0);
}

int floor_c_data_report_t(uint32_t new_counter, int status, int64_t time_stamp)
{
	int err = 0;
	struct sensor_event event;
	static uint32_t last_floor_counter;

	memset(&event, 0, sizeof(struct sensor_event));
	event.time_stamp = time_stamp;
	if (last_floor_counter != new_counter) {
		event.flush_action = DATA_ACTION;
		event.handle = ID_FLOOR_COUNTER;
		event.word[0] = new_counter;
		err = sensor_input_event(step_c_context_obj->mdev.minor,
			&event);
		if (err >= 0)
			last_floor_counter = new_counter;
	}
	return err;
}
int floor_c_data_report(uint32_t new_counter, int status)
{
	return floor_c_data_report_t(new_counter, status, 0);
}
int step_c_flush_report(void)
{
	struct sensor_event event;
	int err = 0;

	memset(&event, 0, sizeof(struct sensor_event));

	event.handle = ID_STEP_COUNTER;
	event.flush_action = FLUSH_ACTION;
	err = sensor_input_event(step_c_context_obj->mdev.minor, &event);
	pr_debug_ratelimited("flush\n");
	return err;
}

int step_d_flush_report(void)
{
	struct sensor_event event;
	int err = 0;

	memset(&event, 0, sizeof(struct sensor_event));

	event.handle = ID_STEP_DETECTOR;
	event.flush_action = FLUSH_ACTION;
	err = sensor_input_event(step_c_context_obj->mdev.minor, &event);
	pr_debug_ratelimited("flush\n");
	return err;
}

int smd_flush_report(void)
{
	return 0;
}

int floor_c_flush_report(void)
{
	struct sensor_event event;
	int err = 0;

	memset(&event, 0, sizeof(struct sensor_event));

	event.handle = ID_FLOOR_COUNTER;
	event.flush_action = FLUSH_ACTION;
	err = sensor_input_event(step_c_context_obj->mdev.minor, &event);
	pr_debug_ratelimited("flush\n");
	return err;
}

static int step_c_probe(void)
{

	int err;

	pr_debug("%s+++!!\n", __func__);

	step_c_context_obj = step_c_context_alloc_object();
	if (!step_c_context_obj) {
		err = -ENOMEM;
		pr_err("unable to allocate devobj!\n");
		goto exit_alloc_data_failed;
	}

	/* init real step_c driver */
	err = step_c_real_driver_init();
	if (err) {
		pr_err("step_c real driver init fail\n");
		goto real_driver_init_fail;
	}

	pr_debug("%s---- OK !!\n", __func__);
	return 0;
real_driver_init_fail:
	kfree(step_c_context_obj);
exit_alloc_data_failed:
	pr_debug("%s---- fail !!!\n", __func__);
	return err;
}

static int step_c_remove(void)
{

	int err = 0;

	pr_debug("%s\n", __func__);
	sysfs_remove_group(&step_c_context_obj->mdev.this_device->kobj,
		&step_c_attribute_group);

	err = sensor_attr_deregister(&step_c_context_obj->mdev);
	if (err)
		pr_err("misc_deregister fail: %d\n", err);
	kfree(step_c_context_obj);
	platform_driver_unregister(&step_counter_driver);

	return 0;
}

static int __init step_c_init(void)
{
	pr_debug("%s\n", __func__);

	if (step_c_probe()) {
		pr_err("failed to register step_c driver\n");
		return -ENODEV;
	}

	return 0;
}

static void __exit step_c_exit(void)
{
	step_c_remove();
	platform_driver_unregister(&step_counter_driver);
}

late_initcall(step_c_init);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("STEP_CMETER device driver");
MODULE_AUTHOR("Mediatek");