[mirror_ubuntu-bionic-kernel.git] / drivers / ata / ahci_st.c

/*
 * Copyright (C) 2012 STMicroelectronics Limited
 *
 * Authors: Francesco Virlinzi <francesco.virlinzi@st.com>
 *	    Alexandre Torgue <alexandre.torgue@st.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/export.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/of.h>
#include <linux/ahci_platform.h>
#include <linux/libata.h>
#include <linux/reset.h>
#include <linux/io.h>
#include <linux/dma-mapping.h>

#include "ahci.h"

#define DRV_NAME  "st_ahci"

#define ST_AHCI_OOBR			0xbc
#define ST_AHCI_OOBR_WE			BIT(31)
#define ST_AHCI_OOBR_CWMIN_SHIFT	24
#define ST_AHCI_OOBR_CWMAX_SHIFT	16
#define ST_AHCI_OOBR_CIMIN_SHIFT	8
#define ST_AHCI_OOBR_CIMAX_SHIFT	0

struct st_ahci_drv_data {
	struct platform_device *ahci;
	struct reset_control *pwr;
	struct reset_control *sw_rst;
	struct reset_control *pwr_rst;
};

static void st_ahci_configure_oob(void __iomem *mmio)
{
	unsigned long old_val, new_val;

	new_val = (0x02 << ST_AHCI_OOBR_CWMIN_SHIFT) |
		  (0x04 << ST_AHCI_OOBR_CWMAX_SHIFT) |
		  (0x08 << ST_AHCI_OOBR_CIMIN_SHIFT) |
		  (0x0C << ST_AHCI_OOBR_CIMAX_SHIFT);

	old_val = readl(mmio + ST_AHCI_OOBR);
	writel(old_val | ST_AHCI_OOBR_WE, mmio + ST_AHCI_OOBR);
	writel(new_val | ST_AHCI_OOBR_WE, mmio + ST_AHCI_OOBR);
	writel(new_val, mmio + ST_AHCI_OOBR);
}

static int st_ahci_deassert_resets(struct ahci_host_priv *hpriv,
				struct device *dev)
{
	struct st_ahci_drv_data *drv_data = hpriv->plat_data;
	int err;

	if (drv_data->pwr) {
		err = reset_control_deassert(drv_data->pwr);
		if (err) {
			dev_err(dev, "unable to bring out of pwrdwn\n");
			return err;
		}
	}

	if (drv_data->sw_rst) {
		err = reset_control_deassert(drv_data->sw_rst);
		if (err) {
			dev_err(dev, "unable to bring out of sw-rst\n");
			return err;
		}
	}

	if (drv_data->pwr_rst) {
		err = reset_control_deassert(drv_data->pwr_rst);
		if (err) {
			dev_err(dev, "unable to bring out of pwr-rst\n");
			return err;
		}
	}

	return 0;
}

static void st_ahci_host_stop(struct ata_host *host)
{
	struct ahci_host_priv *hpriv = host->private_data;
	struct st_ahci_drv_data *drv_data = hpriv->plat_data;
	struct device *dev = host->dev;
	int err;

	if (drv_data->pwr) {
		err = reset_control_assert(drv_data->pwr);
		if (err)
			dev_err(dev, "unable to pwrdwn\n");
	}

	ahci_platform_disable_resources(hpriv);
}

static int st_ahci_probe_resets(struct ahci_host_priv *hpriv,
				struct device *dev)
{
	struct st_ahci_drv_data *drv_data = hpriv->plat_data;

	drv_data->pwr = devm_reset_control_get(dev, "pwr-dwn");
	if (IS_ERR(drv_data->pwr)) {
		dev_info(dev, "power reset control not defined\n");
		drv_data->pwr = NULL;
	}

	drv_data->sw_rst = devm_reset_control_get(dev, "sw-rst");
	if (IS_ERR(drv_data->sw_rst)) {
		dev_info(dev, "soft reset control not defined\n");
		drv_data->sw_rst = NULL;
	}

	drv_data->pwr_rst = devm_reset_control_get(dev, "pwr-rst");
	if (IS_ERR(drv_data->pwr_rst)) {
		dev_dbg(dev, "power soft reset control not defined\n");
		drv_data->pwr_rst = NULL;
	}

	return st_ahci_deassert_resets(hpriv, dev);
}

static struct ata_port_operations st_ahci_port_ops = {
	.inherits	= &ahci_platform_ops,
	.host_stop	= st_ahci_host_stop,
};

static const struct ata_port_info st_ahci_port_info = {
	.flags          = AHCI_FLAG_COMMON,
	.pio_mask       = ATA_PIO4,
	.udma_mask      = ATA_UDMA6,
	.port_ops       = &st_ahci_port_ops,
};

static struct scsi_host_template ahci_platform_sht = {
	AHCI_SHT(DRV_NAME),
};

static int st_ahci_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct st_ahci_drv_data *drv_data;
	struct ahci_host_priv *hpriv;
	int err;

	drv_data = devm_kzalloc(&pdev->dev, sizeof(*drv_data), GFP_KERNEL);
	if (!drv_data)
		return -ENOMEM;

	hpriv = ahci_platform_get_resources(pdev);
	if (IS_ERR(hpriv))
		return PTR_ERR(hpriv);
	hpriv->plat_data = drv_data;

	err = st_ahci_probe_resets(hpriv, &pdev->dev);
	if (err)
		return err;

	err = ahci_platform_enable_resources(hpriv);
	if (err)
		return err;

	st_ahci_configure_oob(hpriv->mmio);

	of_property_read_u32(dev->of_node,
			     "ports-implemented", &hpriv->force_port_map);

	err = ahci_platform_init_host(pdev, hpriv, &st_ahci_port_info,
				      &ahci_platform_sht);
	if (err) {
		ahci_platform_disable_resources(hpriv);
		return err;
	}

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int st_ahci_suspend(struct device *dev)
{
	struct ata_host *host = dev_get_drvdata(dev);
	struct ahci_host_priv *hpriv = host->private_data;
	struct st_ahci_drv_data *drv_data = hpriv->plat_data;
	int err;

	err = ahci_platform_suspend_host(dev);
	if (err)
		return err;

	if (drv_data->pwr) {
		err = reset_control_assert(drv_data->pwr);
		if (err) {
			dev_err(dev, "unable to pwrdwn");
			return err;
		}
	}

	ahci_platform_disable_resources(hpriv);

	return 0;
}

static int st_ahci_resume(struct device *dev)
{
	struct ata_host *host = dev_get_drvdata(dev);
	struct ahci_host_priv *hpriv = host->private_data;
	int err;

	err = ahci_platform_enable_resources(hpriv);
	if (err)
		return err;

	err = st_ahci_deassert_resets(hpriv, dev);
	if (err) {
		ahci_platform_disable_resources(hpriv);
		return err;
	}

	st_ahci_configure_oob(hpriv->mmio);

	return ahci_platform_resume_host(dev);
}
#endif

static SIMPLE_DEV_PM_OPS(st_ahci_pm_ops, st_ahci_suspend, st_ahci_resume);

static const struct of_device_id st_ahci_match[] = {
	{ .compatible = "st,ahci", },
	{},
};
MODULE_DEVICE_TABLE(of, st_ahci_match);

static struct platform_driver st_ahci_driver = {
	.driver = {
		.name = DRV_NAME,
		.pm = &st_ahci_pm_ops,
		.of_match_table = of_match_ptr(st_ahci_match),
	},
	.probe = st_ahci_probe,
	.remove = ata_platform_remove_one,
};
module_platform_driver(st_ahci_driver);

MODULE_AUTHOR("Alexandre Torgue <alexandre.torgue@st.com>");
MODULE_AUTHOR("Francesco Virlinzi <francesco.virlinzi@st.com>");
MODULE_DESCRIPTION("STMicroelectronics SATA AHCI Driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
76884cb2 LJ	1	/*
	2	* Copyright (C) 2012 STMicroelectronics Limited
	3	*
	4	* Authors: Francesco Virlinzi <francesco.virlinzi@st.com>
	5	* Alexandre Torgue <alexandre.torgue@st.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/init.h>
	13	#include <linux/module.h>
	14	#include <linux/export.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/clk.h>
	17	#include <linux/of.h>
	18	#include <linux/ahci_platform.h>
76884cb2 LJ	19	#include <linux/libata.h>
	20	#include <linux/reset.h>
	21	#include <linux/io.h>
	22	#include <linux/dma-mapping.h>
	23
	24	#include "ahci.h"
	25
018d5ef2 AM	26	#define DRV_NAME "st_ahci"
018d5ef2 AM	27
76884cb2 LJ	28	#define ST_AHCI_OOBR 0xbc
	29	#define ST_AHCI_OOBR_WE BIT(31)
	30	#define ST_AHCI_OOBR_CWMIN_SHIFT 24
	31	#define ST_AHCI_OOBR_CWMAX_SHIFT 16
	32	#define ST_AHCI_OOBR_CIMIN_SHIFT 8
	33	#define ST_AHCI_OOBR_CIMAX_SHIFT 0
	34
	35	struct st_ahci_drv_data {
	36	struct platform_device *ahci;
76884cb2 LJ	37	struct reset_control *pwr;
	38	struct reset_control *sw_rst;
	39	struct reset_control *pwr_rst;
76884cb2 LJ	40	};
	41
	42	static void st_ahci_configure_oob(void __iomem *mmio)
	43	{
	44	unsigned long old_val, new_val;
	45
	46	new_val = (0x02 << ST_AHCI_OOBR_CWMIN_SHIFT) \|
	47	(0x04 << ST_AHCI_OOBR_CWMAX_SHIFT) \|
	48	(0x08 << ST_AHCI_OOBR_CIMIN_SHIFT) \|
	49	(0x0C << ST_AHCI_OOBR_CIMAX_SHIFT);
	50
	51	old_val = readl(mmio + ST_AHCI_OOBR);
	52	writel(old_val \| ST_AHCI_OOBR_WE, mmio + ST_AHCI_OOBR);
	53	writel(new_val \| ST_AHCI_OOBR_WE, mmio + ST_AHCI_OOBR);
	54	writel(new_val, mmio + ST_AHCI_OOBR);
	55	}
	56
e0e2674b PG	57	static int st_ahci_deassert_resets(struct ahci_host_priv *hpriv,
e0e2674b PG	58	struct device *dev)
76884cb2	59	{
e0e2674b	60	struct st_ahci_drv_data *drv_data = hpriv->plat_data;
76884cb2 LJ	61	int err;
	62
	63	if (drv_data->pwr) {
	64	err = reset_control_deassert(drv_data->pwr);
	65	if (err) {
	66	dev_err(dev, "unable to bring out of pwrdwn\n");
	67	return err;
	68	}
	69	}
	70
76884cb2 LJ	71	if (drv_data->sw_rst) {
	72	err = reset_control_deassert(drv_data->sw_rst);
	73	if (err) {
	74	dev_err(dev, "unable to bring out of sw-rst\n");
	75	return err;
	76	}
	77	}
	78
	79	if (drv_data->pwr_rst) {
	80	err = reset_control_deassert(drv_data->pwr_rst);
	81	if (err) {
	82	dev_err(dev, "unable to bring out of pwr-rst\n");
	83	return err;
	84	}
	85	}
	86
	87	return 0;
	88	}
	89
b032378b	90	static void st_ahci_host_stop(struct ata_host *host)
a8237084	91	{
b032378b	92	struct ahci_host_priv *hpriv = host->private_data;
e0e2674b	93	struct st_ahci_drv_data *drv_data = hpriv->plat_data;
b032378b	94	struct device *dev = host->dev;
a8237084 LJ	95	int err;
	96
	97	if (drv_data->pwr) {
	98	err = reset_control_assert(drv_data->pwr);
	99	if (err)
33081b34	100	dev_err(dev, "unable to pwrdwn\n");
a8237084 LJ	101	}
	102
	103	ahci_platform_disable_resources(hpriv);
a8237084 LJ	104	}
a8237084 LJ	105
e0e2674b PG	106	static int st_ahci_probe_resets(struct ahci_host_priv *hpriv,
e0e2674b PG	107	struct device *dev)
76884cb2	108	{
e0e2674b	109	struct st_ahci_drv_data *drv_data = hpriv->plat_data;
76884cb2	110
e0e2674b	111	drv_data->pwr = devm_reset_control_get(dev, "pwr-dwn");
76884cb2	112	if (IS_ERR(drv_data->pwr)) {
e0e2674b	113	dev_info(dev, "power reset control not defined\n");
76884cb2 LJ	114	drv_data->pwr = NULL;
	115	}
	116
e0e2674b	117	drv_data->sw_rst = devm_reset_control_get(dev, "sw-rst");
76884cb2	118	if (IS_ERR(drv_data->sw_rst)) {
e0e2674b	119	dev_info(dev, "soft reset control not defined\n");
76884cb2 LJ	120	drv_data->sw_rst = NULL;
	121	}
	122
e0e2674b	123	drv_data->pwr_rst = devm_reset_control_get(dev, "pwr-rst");
76884cb2	124	if (IS_ERR(drv_data->pwr_rst)) {
e0e2674b	125	dev_dbg(dev, "power soft reset control not defined\n");
76884cb2 LJ	126	drv_data->pwr_rst = NULL;
	127	}
	128
e0e2674b	129	return st_ahci_deassert_resets(hpriv, dev);
76884cb2 LJ	130	}
76884cb2 LJ	131
b032378b BZ	132	static struct ata_port_operations st_ahci_port_ops = {
	133	.inherits = &ahci_platform_ops,
	134	.host_stop = st_ahci_host_stop,
	135	};
	136
76884cb2 LJ	137	static const struct ata_port_info st_ahci_port_info = {
	138	.flags = AHCI_FLAG_COMMON,
	139	.pio_mask = ATA_PIO4,
	140	.udma_mask = ATA_UDMA6,
b032378b	141	.port_ops = &st_ahci_port_ops,
76884cb2 LJ	142	};
76884cb2 LJ	143
018d5ef2 AM	144	static struct scsi_host_template ahci_platform_sht = {
	145	AHCI_SHT(DRV_NAME),
	146	};
	147
76884cb2 LJ	148	static int st_ahci_probe(struct platform_device *pdev)
76884cb2 LJ	149	{
e7190699	150	struct device *dev = &pdev->dev;
76884cb2 LJ	151	struct st_ahci_drv_data *drv_data;
	152	struct ahci_host_priv *hpriv;
	153	int err;
	154
	155	drv_data = devm_kzalloc(&pdev->dev, sizeof(*drv_data), GFP_KERNEL);
	156	if (!drv_data)
	157	return -ENOMEM;
	158
76884cb2 LJ	159	hpriv = ahci_platform_get_resources(pdev);
	160	if (IS_ERR(hpriv))
	161	return PTR_ERR(hpriv);
e0e2674b	162	hpriv->plat_data = drv_data;
76884cb2	163
e0e2674b	164	err = st_ahci_probe_resets(hpriv, &pdev->dev);
76884cb2 LJ	165	if (err)
	166	return err;
	167
	168	err = ahci_platform_enable_resources(hpriv);
	169	if (err)
	170	return err;
	171
e0e2674b	172	st_ahci_configure_oob(hpriv->mmio);
9a1e75e1	173
e7190699 PC	174	of_property_read_u32(dev->of_node,
	175	"ports-implemented", &hpriv->force_port_map);
	176
018d5ef2 AM	177	err = ahci_platform_init_host(pdev, hpriv, &st_ahci_port_info,
018d5ef2 AM	178	&ahci_platform_sht);
76884cb2 LJ	179	if (err) {
	180	ahci_platform_disable_resources(hpriv);
	181	return err;
	182	}
	183
	184	return 0;
	185	}
	186
76884cb2 LJ	187	#ifdef CONFIG_PM_SLEEP
	188	static int st_ahci_suspend(struct device *dev)
	189	{
e0e2674b PG	190	struct ata_host *host = dev_get_drvdata(dev);
	191	struct ahci_host_priv *hpriv = host->private_data;
	192	struct st_ahci_drv_data *drv_data = hpriv->plat_data;
76884cb2 LJ	193	int err;
76884cb2 LJ	194
33081b34 BZ	195	err = ahci_platform_suspend_host(dev);
	196	if (err)
	197	return err;
761a8c27	198
76884cb2 LJ	199	if (drv_data->pwr) {
	200	err = reset_control_assert(drv_data->pwr);
	201	if (err) {
	202	dev_err(dev, "unable to pwrdwn");
	203	return err;
	204	}
	205	}
	206
	207	ahci_platform_disable_resources(hpriv);
	208
	209	return 0;
	210	}
	211
	212	static int st_ahci_resume(struct device *dev)
	213	{
e0e2674b PG	214	struct ata_host *host = dev_get_drvdata(dev);
e0e2674b PG	215	struct ahci_host_priv *hpriv = host->private_data;
76884cb2 LJ	216	int err;
	217
	218	err = ahci_platform_enable_resources(hpriv);
	219	if (err)
	220	return err;
	221
e0e2674b	222	err = st_ahci_deassert_resets(hpriv, dev);
76884cb2 LJ	223	if (err) {
	224	ahci_platform_disable_resources(hpriv);
	225	return err;
	226	}
	227
e0e2674b	228	st_ahci_configure_oob(hpriv->mmio);
9a1e75e1	229
761a8c27	230	return ahci_platform_resume_host(dev);
76884cb2 LJ	231	}
	232	#endif
	233
	234	static SIMPLE_DEV_PM_OPS(st_ahci_pm_ops, st_ahci_suspend, st_ahci_resume);
	235
09de99db	236	static const struct of_device_id st_ahci_match[] = {
76884cb2 LJ	237	{ .compatible = "st,ahci", },
	238	{},
	239	};
	240	MODULE_DEVICE_TABLE(of, st_ahci_match);
	241
	242	static struct platform_driver st_ahci_driver = {
	243	.driver = {
018d5ef2	244	.name = DRV_NAME,
76884cb2 LJ	245	.pm = &st_ahci_pm_ops,
	246	.of_match_table = of_match_ptr(st_ahci_match),
	247	},
	248	.probe = st_ahci_probe,
a8237084	249	.remove = ata_platform_remove_one,
76884cb2 LJ	250	};
	251	module_platform_driver(st_ahci_driver);
	252
	253	MODULE_AUTHOR("Alexandre Torgue <alexandre.torgue@st.com>");
	254	MODULE_AUTHOR("Francesco Virlinzi <francesco.virlinzi@st.com>");
4a2e5123	255	MODULE_DESCRIPTION("STMicroelectronics SATA AHCI Driver");
76884cb2	256	MODULE_LICENSE("GPL v2");