/*
 * Copyright (c) 2013 Linaro Ltd.
 * Copyright (c) 2013 Hisilicon Limited.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/mmc/host.h>
#include <linux/mmc/dw_mmc.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_address.h>

#include "dw_mmc.h"
#include "dw_mmc-pltfm.h"

#define DRIVER_NAME "dwmmc_k3"

enum dw_mci_k3_type {
	DW_MCI_TYPE_HI4511,
};

static struct dw_mci_k3_compatible {
	char				*compatible;
	enum dw_mci_k3_type		type;
} k3_compat[] = {
	{
		.compatible	= "hisilicon,hi4511-dw-mshc",
		.type		= DW_MCI_TYPE_HI4511,
	},
};

struct dw_mci_k3_priv_data {
	enum dw_mci_k3_type	type;
	int			old_timing;
	u32			id;
	u32			gpio_cd;
	u32			clken_reg;
	u32			clken_bit;
	u32			sam_sel_reg;
	u32			sam_sel_bit;
	u32			drv_sel_reg;
	u32			drv_sel_bit;
	u32			div_reg;
	u32			div_bit;
};

static void __iomem *pctrl;
static DEFINE_SPINLOCK(mmc_tuning_lock);
static int k3_tuning_config[][8][6] = {
	/* bus_clk, div, drv_sel, sam_sel_max, sam_sel_min, input_clk */
	{
		{180000000, 6, 6, 13, 13, 25000000},	/* 0: LEGACY 400k */
		{0},					/* 1: MMC_HS */
		{360000000, 6, 4, 2, 0, 50000000  },	/* 2: SD_HS */
		{180000000, 6, 4, 13, 13, 25000000},	/* 3: SDR12 */
		{360000000, 6, 4, 2, 0, 50000000  },	/* 4: SDR25 */
		{720000000, 6, 1, 9, 4, 100000000 },	/* 5: SDR50 */
		{0},					/* 6: SDR104 */
		{360000000, 7, 1, 3, 0, 50000000  },	/* 7: DDR50 */
	}, {
		{26000000, 1, 1, 3, 3, 13000000  },	/* 0: LEGACY 400k */
		{360000000, 6, 3, 3, 1, 50000000 },	/* 1: MMC_HS*/
		{0},					/* 2: SD_HS */
		{0},					/* 3: SDR12 */
		{26000000, 1, 1, 3, 3, 13000000	 },     /* 4: SDR25 */
		{360000000, 6, 3, 3, 1, 50000000 },	/* 5: SDR50 */
		{0},					/* 6: SDR104 */
		{720000000, 6, 4, 8, 4, 100000000},	/* 7: DDR50 */
	},
};

static void dw_mci_k3_set_timing(struct dw_mci_k3_priv_data *priv,
				int idx, int sam, int drv, int div)
{
	unsigned int clken_reg = priv->clken_reg;
	unsigned int clken_bit = priv->clken_bit;
	unsigned int sam_sel_reg = priv->sam_sel_reg;
	unsigned int sam_sel_bit = priv->sam_sel_bit;
	unsigned int drv_sel_reg = priv->drv_sel_reg;
	unsigned int drv_sel_bit = priv->drv_sel_bit;
	unsigned int div_reg = priv->div_reg;
	unsigned int div_bit = priv->div_bit;
	int i = 0;
	unsigned int temp_reg;
	unsigned long flags;

	spin_lock_irqsave(&mmc_tuning_lock, flags);

	/* disable clock */
	temp_reg = readl(pctrl + clken_reg);
	temp_reg &= ~(1<<clken_bit);
	writel(temp_reg, pctrl + clken_reg);

	temp_reg = readl(pctrl + sam_sel_reg);
	if (sam >= 0) {
		/* set sam delay */
		for (i = 0; i < 4; i++) {
			if (sam % 2)
				temp_reg |= 1<<(sam_sel_bit + i);
			else
				temp_reg &= ~(1<<(sam_sel_bit + i));
			sam = sam >> 1;
		}
	}
	writel(temp_reg, pctrl + sam_sel_reg);

	temp_reg = readl(pctrl + drv_sel_reg);
	if (drv >= 0) {
		/* set drv delay */
		for (i = 0; i < 4; i++) {
			if (drv % 2)
				temp_reg |= 1<<(drv_sel_bit + i);
			else
				temp_reg &= ~(1<<(drv_sel_bit + i));
			drv = drv >> 1;
		}
	}
	writel(temp_reg, pctrl + drv_sel_reg);

	temp_reg = readl(pctrl + div_reg);
	if (div >= 0) {
		/* set drv delay */
		for (i = 0; i < 3; i++) {
			if (div % 2)
				temp_reg |= 1<<(div_bit + i);
			else
				temp_reg &= ~(1<<(div_bit + i));
			div = div >> 1;
		}
	}
	writel(temp_reg, pctrl + div_reg);

	/* enable clock */
	temp_reg = readl(pctrl + clken_reg);
	temp_reg |= 1<<clken_bit;
	writel(temp_reg, pctrl + clken_reg);

	spin_unlock_irqrestore(&mmc_tuning_lock, flags);
}

static void dw_mci_k3_tun(struct dw_mci *host, int id, int index)
{
	struct dw_mci_k3_priv_data *priv = host->priv;
	int ret;

	if (!pctrl)
		return;

	if (priv->old_timing == index)
		return;

	ret = clk_set_rate(host->ciu_clk, k3_tuning_config[id][index][0]);
	if (ret)
		dev_err(host->dev, "clk_set_rate failed\n");

	dw_mci_k3_set_timing(priv, id,
			(k3_tuning_config[id][index][3] +
			k3_tuning_config[id][index][4]) / 2,
			k3_tuning_config[id][index][2],
			k3_tuning_config[id][index][1]);

	host->bus_hz = k3_tuning_config[id][index][5];
	priv->old_timing = index;
}

static void dw_mci_k3_set_ios(struct dw_mci *host, struct mmc_ios *ios)
{
	struct dw_mci_k3_priv_data *priv = host->priv;
	int id = priv->id;

	if (priv->type == DW_MCI_TYPE_HI4511)
		dw_mci_k3_tun(host, id, ios->timing);
}

static int dw_mci_k3_priv_init(struct dw_mci *host)
{
	struct dw_mci_k3_priv_data *priv;
	int i;

	priv = devm_kzalloc(host->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv) {
		dev_err(host->dev, "mem alloc failed for private data\n");
		return -ENOMEM;
	}
	priv->id = of_alias_get_id(host->dev->of_node, "mshc");
	priv->old_timing = -1;
	host->priv = priv;

	for (i = 0; i < ARRAY_SIZE(k3_compat); i++) {
		if (of_device_is_compatible(host->dev->of_node,
					k3_compat[i].compatible))
			priv->type = k3_compat[i].type;
	}

	if (priv->type == DW_MCI_TYPE_HI4511) {
		if (!pctrl) {
			struct device_node *node;

			node = of_find_compatible_node(NULL, NULL,
						"hisilicon,pctrl");
			pctrl = of_iomap(node, 0);
		}
	}

	return 0;
}

static int dw_mci_k3_setup_clock(struct dw_mci *host)
{
	struct dw_mci_k3_priv_data *priv = host->priv;

	if (priv->type == DW_MCI_TYPE_HI4511)
		dw_mci_k3_tun(host, priv->id, MMC_TIMING_LEGACY);

	return 0;
}


static irqreturn_t dw_mci_k3_card_detect(int irq, void *data)
{
	struct dw_mci *host = (struct dw_mci *)data;

	queue_work(host->card_workqueue, &host->card_work);
	return IRQ_HANDLED;
};

static int dw_mci_k3_get_cd(struct dw_mci *host, u32 slot_id)
{
	unsigned int status;
	struct dw_mci_k3_priv_data *priv = host->priv;

	status = !gpio_get_value(priv->gpio_cd);
	return status;
}

static int dw_mci_k3_parse_dt(struct dw_mci *host)
{
	struct dw_mci_k3_priv_data *priv = host->priv;
	struct device_node *np = host->dev->of_node;
	u32 data[2];
	int ret;

	if (priv->type == DW_MCI_TYPE_HI4511) {
		ret = of_property_read_u32_array(np,
				"clken-reg", data, 2);
		if (!ret) {
			priv->clken_reg = data[0];
			priv->clken_bit = data[1];
		}

		ret = of_property_read_u32_array(np,
				"drv-sel-reg", data, 2);
		if (!ret) {
			priv->drv_sel_reg = data[0];
			priv->drv_sel_bit = data[1];
		}

		ret = of_property_read_u32_array(np,
				"sam-sel-reg", data, 2);
		if (!ret) {
			priv->sam_sel_reg = data[0];
			priv->sam_sel_bit = data[1];
		}

		ret = of_property_read_u32_array(np,
				"div-reg", data, 2);
		if (!ret) {
			priv->div_reg = data[0];
			priv->div_bit = data[1];
		}
	}

	return 0;
}

static unsigned long k3_dwmmc_caps[4] = {
	MMC_CAP_4_BIT_DATA | MMC_CAP_SD_HIGHSPEED,
	MMC_CAP_8_BIT_DATA | MMC_CAP_MMC_HIGHSPEED,
	0,
	0,
};

static const struct dw_mci_drv_data k3_drv_data = {
	.caps			= k3_dwmmc_caps,
	.init			= dw_mci_k3_priv_init,
	.set_ios		= dw_mci_k3_set_ios,
	.setup_clock		= dw_mci_k3_setup_clock,
	.parse_dt		= dw_mci_k3_parse_dt,
};

static const struct of_device_id dw_mci_k3_match[] = {
	{ .compatible = "hisilicon,hi4511-dw-mshc",
			.data = &k3_drv_data, },
	{},
};
MODULE_DEVICE_TABLE(of, dw_mci_k3_match);

int dw_mci_k3_probe(struct platform_device *pdev)
{
	const struct dw_mci_drv_data *drv_data;
	const struct of_device_id *match;
	struct dw_mci *host;
	int gpio, err;

	match = of_match_node(dw_mci_k3_match, pdev->dev.of_node);
	drv_data = match->data;

	err = dw_mci_pltfm_register(pdev, drv_data);
	if (err)
		return err;

	host = platform_get_drvdata(pdev);
	if (host->pdata->quirks & DW_MCI_QUIRK_BROKEN_CARD_DETECTION)
		return 0;

	gpio = of_get_named_gpio(pdev->dev.of_node, "cd-gpio", 0);
	if (gpio_is_valid(gpio)) {
		if (devm_gpio_request(host->dev, gpio, "dw-mci-cd")) {
			dev_err(host->dev, "gpio [%d] request failed\n", gpio);
		} else {
			struct dw_mci_k3_priv_data *priv = host->priv;
			priv->gpio_cd = gpio;
			host->pdata->get_cd = dw_mci_k3_get_cd;
			err = devm_request_irq(host->dev, gpio_to_irq(gpio),
				dw_mci_k3_card_detect,
				IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
				DRIVER_NAME, host);
			if (err)
				dev_warn(mmc_dev(host->dev), "request gpio irq error\n");
		}

	} else {
		dev_info(host->dev, "cd gpio not available");
	}
	return 0;
}

static int dw_mci_k3_suspend(struct device *dev)
{
	int ret;
	struct dw_mci *host = dev_get_drvdata(dev);

	ret = dw_mci_suspend(host);
	if (ret)
		return ret;

	return 0;
}

static int dw_mci_k3_resume(struct device *dev)
{
	int ret;
	struct dw_mci *host = dev_get_drvdata(dev);
	struct dw_mci_k3_priv_data *priv = host->priv;

	if (priv->type == DW_MCI_TYPE_HI4511) {
		int id = priv->id;

		priv->old_timing = -1;
		dw_mci_k3_tun(host, id, MMC_TIMING_LEGACY);
	}

	ret = dw_mci_resume(host);
	if (ret)
		return ret;

	return 0;
}

SIMPLE_DEV_PM_OPS(dw_mci_k3_pmops, dw_mci_k3_suspend, dw_mci_k3_resume);

static struct platform_driver dw_mci_k3_pltfm_driver = {
	.probe		= dw_mci_k3_probe,
	.remove		= dw_mci_pltfm_remove,
	.driver		= {
		.name		= DRIVER_NAME,
		.of_match_table	= dw_mci_k3_match,
		.pm		= &dw_mci_k3_pmops,
	},
};

module_platform_driver(dw_mci_k3_pltfm_driver);

MODULE_DESCRIPTION("K3 Specific DW-MSHC Driver Extension");
MODULE_LICENSE("GPL v2");