
/***************************************************************************
 * Copyright (c) 2014 Amlogic, Inc. All rights reserved.
 *
 * This source code is subject to the terms and conditions defined in the
 * file 'LICENSE' which is part of this source code package.
 *
 * Description:
 *
***************************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/of.h>
#include "../aml_ci.h"
#include "aml_cimax.h"
#include "aml_cimax_spi.h"
#include "aml_cimax_usb.h"

#define MODUDLE_NAME       "aml_cimax"

MODULE_PARM_DESC(cimax_debug, "enable verbose debug messages");
static int aml_cimax_debug = 1;
module_param_named(cimax_debug, aml_cimax_debug, int, 0644);

//static struct switch_dev slot_state = {
//	.name = "ci_slot",
//};

#define pr_dbg(fmt...)\
	do {\
		if (aml_cimax_debug)\
			pr_info("AML_CIMAX: " fmt);\
	} while (0)
#define pr_error(fmt...) pr_err("AML_CIMAX: " fmt)

static int aml_cimax_slot_reset(struct aml_ci *ci, int slot)
{
	int ret = 0;
	struct aml_cimax *cimax = ci->data;
	pr_dbg("cimax: slot(%d) reset\n", slot);
	if (cimax->ops.slot_reset)
		ret = cimax->ops.slot_reset(cimax, slot);
	return ret;
}

static int aml_cimax_slot_shutdown(struct aml_ci *ci, int slot)
{
	pr_dbg("slot(%d) shutdown\n", slot);
	return 0;
}

static int aml_cimax_slot_ts_enable(struct aml_ci *ci, int slot)
{
	pr_dbg("slot(%d) ts control\n", slot);
	return 0;
}

static int aml_cimax_slot_status(struct aml_ci *ci, int slot, int open)
{
	int ret = 0;
	struct aml_cimax *cimax = ci->data;

	/*pr_dbg("cimax: slot(%d) poll\n", slot);*/
	if (cimax->ops.slot_status)
		ret = cimax->ops.slot_status(cimax, slot);
	return ret;
}

#define DEF_FUNC_WRAPPER3(_pre, _fn, _S, _P1, _P2, _P3) \
static int _pre##_fn(_S s, _P1 p1, _P2 p2, _P3 p3)\
{\
	struct aml_cimax *cimax = s->data;\
	/*pr_dbg("%s\n", #_fn);*/\
	if (cimax->ops._fn)\
		return cimax->ops._fn(cimax, p1, p2, p3);\
	return 0;\
}

/*DEF_FUNC_WRAPPER3(aml_cimax_, read_reg, struct aml_ci*, int, u8*, int)*/
/*DEF_FUNC_WRAPPER3(aml_cimax_, write_reg, struct aml_ci*, int, u8*, int)*/
DEF_FUNC_WRAPPER3(aml_cimax_, read_cis, struct aml_ci*, int, u8*, int)
DEF_FUNC_WRAPPER3(aml_cimax_, read_lpdu, struct aml_ci*, int, u8*, int)
DEF_FUNC_WRAPPER3(aml_cimax_, write_lpdu, struct aml_ci*, int, u8*, int)

static int aml_cimax_write_cor(struct aml_ci *ci, int slot, int addr, u8 *buf)
{
	struct aml_cimax *cimax = ci->data;
	pr_dbg("write_cor\n");
	if (cimax->ops.write_cor)
		return cimax->ops.write_cor(cimax, slot, addr, buf);
	return 0;
}

static int aml_cimax_negotiate(struct aml_ci *ci, int slot, int size)
{
	struct aml_cimax *cimax = ci->data;
	pr_dbg("negotiate\n");
	if (cimax->ops.negotiate)
		return cimax->ops.negotiate(cimax, slot, size);
	return 0;
}

static int aml_cimax_read_cam_status(struct aml_ci *ci, int slot)
{
	struct aml_cimax *cimax = ci->data;
	if (cimax->ops.read_cam_status)
		return cimax->ops.read_cam_status(cimax, slot);
	return 0;
}

static int aml_cimax_cam_reset(struct aml_ci *ci, int slot)
{
	struct aml_cimax *cimax = ci->data;
	if (cimax->ops.cam_reset)
		return cimax->ops.cam_reset(cimax, slot);
	return 0;
}

static int aml_cimax_get_capbility(struct aml_ci *ci, int slot)
{
	return 0;
}

int aml_cimax_camchanged(struct aml_cimax *cimax, int slot, int plugin)
{
	struct aml_ci *ci = cimax->ci;
	if (plugin) {
		dvb_ca_en50221_cimax_camchange_irq(&ci->en50221_cimax,
			slot, DVB_CA_EN50221_CAMCHANGE_INSERTED);
	} else {
		dvb_ca_en50221_cimax_camchange_irq(&ci->en50221_cimax,
			slot, DVB_CA_EN50221_CAMCHANGE_REMOVED);
	}
	return 0;
}

static int aml_cimax_start(struct aml_cimax *cimax)
{
	int ret = 0;
	if (cimax->ops.start)
		ret = cimax->ops.start(cimax);
	return ret;
}

static int aml_cimax_stop(struct aml_cimax *cimax)
{
	int ret = 0;
	if (cimax->ops.stop)
		ret = cimax->ops.stop(cimax);
	return ret;
}

static int aml_cimax_get_config_from_dts(struct aml_cimax *cimax)
{
	struct device_node *child = NULL;
	struct platform_device *pdev = cimax->pdev;
	struct device_node *np = pdev->dev.of_node;
	unsigned int val;
	int ret = 0;
	pr_dbg("get cimax dts\n");

	child = of_get_child_by_name(np, "cimax");
	if (child == NULL) {
		pr_error("failed to get cimax\n");
		return -1;
	}
	ret = of_property_read_u32(child, "io_type", &val);
	if (ret)
		cimax->io_type = IO_TYPE_SPI;
	else
		cimax->io_type = val;

	return 0;
}

int aml_cimax_init(struct platform_device *pdev, struct aml_ci *ci)
{
	struct aml_cimax *cimax = NULL;
	int ret = 0;

	cimax = kzalloc(sizeof(struct aml_cimax), GFP_KERNEL);
	if (!cimax) {
		pr_error("Out of memory!, exiting ..\n");
		return -ENOMEM;
	}
	cimax->pdev = pdev;
	cimax->ci = ci;

	aml_cimax_get_config_from_dts(cimax);

	if (cimax->io_type == IO_TYPE_SPI) {
		//ret = aml_cimax_spi_init(pdev, cimax);
	}
	else {
		ret = aml_cimax_usb_init(pdev, cimax);
	}

	if (ret != 0) {
		kfree(cimax);
		cimax = NULL;
		return -EIO;
	}

	ret = aml_cimax_start(cimax);
	if (ret != 0)
		return ret;

	ci->data = cimax;

	ci->ci_read_cis = aml_cimax_read_cis;
	ci->ci_write_cor = aml_cimax_write_cor;
	ci->ci_negotiate = aml_cimax_negotiate;
	ci->ci_read_lpdu = aml_cimax_read_lpdu;
	ci->ci_write_lpdu = aml_cimax_write_lpdu;
	ci->ci_read_cam_status = aml_cimax_read_cam_status;
	ci->ci_cam_reset = aml_cimax_cam_reset;
	ci->ci_get_capbility = aml_cimax_get_capbility;
	ci->ci_slot_reset = aml_cimax_slot_reset;
	ci->ci_slot_shutdown = aml_cimax_slot_shutdown;
	ci->ci_slot_ts_enable = aml_cimax_slot_ts_enable;
	ci->ci_poll_slot_status = aml_cimax_slot_status;

	return 0;
}
EXPORT_SYMBOL(aml_cimax_init);

int aml_cimax_exit(struct aml_ci *ci)
{
	struct aml_cimax *cimax = ci->data;

	ci->ci_read_cis         = NULL;
	ci->ci_write_cor        = NULL;
	ci->ci_negotiate        = NULL;
	ci->ci_read_lpdu        = NULL;
	ci->ci_write_lpdu       = NULL;
	ci->ci_read_cam_status  = NULL;
	ci->ci_cam_reset        = NULL;
	ci->ci_get_capbility    = NULL;
	ci->ci_slot_reset       = NULL;
	ci->ci_slot_shutdown    = NULL;
	ci->ci_slot_ts_enable   = NULL;
	ci->ci_poll_slot_status = NULL;

	aml_cimax_stop(cimax);

	if (cimax->io_type == IO_TYPE_SPI) {
        //aml_cimax_spi_exit(cimax);
	}
	else {
		aml_cimax_usb_exit(cimax);
	}
	kfree(cimax);
	ci->data = NULL;

	return 0;
}
EXPORT_SYMBOL(aml_cimax_exit);

int aml_cimax_slot_state_changed(struct aml_cimax *cimax, int slot, int state)
{
	//if (slot == 0)
	//	switch_set_state(&slot_state, state);
	return 0;
}
EXPORT_SYMBOL(aml_cimax_slot_state_changed);
#if 0
static int __init aml_cimax_mod_init(void)
{
	pr_dbg("Amlogic DVB CIMAX Init\n");
	//switch_dev_register(&slot_state);
	//switch_set_state(&slot_state, 0);
	return 0;
}

static void __exit aml_cimax_mod_exit(void)
{
	pr_dbg("Amlogic DVB CIMAX Exit\n");
	//switch_dev_unregister(&slot_state);
}

module_init(aml_cimax_mod_init);
module_exit(aml_cimax_mod_exit);

MODULE_LICENSE("GPL");
#endif