[linux-block.git] / drivers / memory / ti-emif-pm.c

/*
 * TI AM33XX SRAM EMIF Driver
 *
 * Copyright (C) 2016-2017 Texas Instruments Inc.
 *	Dave Gerlach
 *
 * 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.
 *
 * 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.
 */

#include <linux/err.h>
#include <linux/genalloc.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/sram.h>
#include <linux/ti-emif-sram.h>

#include "emif.h"

#define TI_EMIF_SRAM_SYMBOL_OFFSET(sym) ((unsigned long)(sym) - \
					 (unsigned long)&ti_emif_sram)

#define EMIF_POWER_MGMT_WAIT_SELF_REFRESH_8192_CYCLES		0x00a0

struct ti_emif_data {
	phys_addr_t ti_emif_sram_phys;
	phys_addr_t ti_emif_sram_data_phys;
	unsigned long ti_emif_sram_virt;
	unsigned long ti_emif_sram_data_virt;
	struct gen_pool *sram_pool_code;
	struct gen_pool	*sram_pool_data;
	struct ti_emif_pm_data pm_data;
	struct ti_emif_pm_functions pm_functions;
};

static struct ti_emif_data *emif_instance;

static u32 sram_suspend_address(struct ti_emif_data *emif_data,
				unsigned long addr)
{
	return (emif_data->ti_emif_sram_virt +
		TI_EMIF_SRAM_SYMBOL_OFFSET(addr));
}

static phys_addr_t sram_resume_address(struct ti_emif_data *emif_data,
				       unsigned long addr)
{
	return ((unsigned long)emif_data->ti_emif_sram_phys +
		TI_EMIF_SRAM_SYMBOL_OFFSET(addr));
}

static void ti_emif_free_sram(struct ti_emif_data *emif_data)
{
	gen_pool_free(emif_data->sram_pool_code, emif_data->ti_emif_sram_virt,
		      ti_emif_sram_sz);
	gen_pool_free(emif_data->sram_pool_data,
		      emif_data->ti_emif_sram_data_virt,
		      sizeof(struct emif_regs_amx3));
}

static int ti_emif_alloc_sram(struct device *dev,
			      struct ti_emif_data *emif_data)
{
	struct device_node *np = dev->of_node;
	int ret;

	emif_data->sram_pool_code = of_gen_pool_get(np, "sram", 0);
	if (!emif_data->sram_pool_code) {
		dev_err(dev, "Unable to get sram pool for ocmcram code\n");
		return -ENODEV;
	}

	emif_data->ti_emif_sram_virt =
			gen_pool_alloc(emif_data->sram_pool_code,
				       ti_emif_sram_sz);
	if (!emif_data->ti_emif_sram_virt) {
		dev_err(dev, "Unable to allocate code memory from ocmcram\n");
		return -ENOMEM;
	}

	/* Save physical address to calculate resume offset during pm init */
	emif_data->ti_emif_sram_phys =
			gen_pool_virt_to_phys(emif_data->sram_pool_code,
					      emif_data->ti_emif_sram_virt);

	/* Get sram pool for data section and allocate space */
	emif_data->sram_pool_data = of_gen_pool_get(np, "sram", 1);
	if (!emif_data->sram_pool_data) {
		dev_err(dev, "Unable to get sram pool for ocmcram data\n");
		ret = -ENODEV;
		goto err_free_sram_code;
	}

	emif_data->ti_emif_sram_data_virt =
				gen_pool_alloc(emif_data->sram_pool_data,
					       sizeof(struct emif_regs_amx3));
	if (!emif_data->ti_emif_sram_data_virt) {
		dev_err(dev, "Unable to allocate data memory from ocmcram\n");
		ret = -ENOMEM;
		goto err_free_sram_code;
	}

	/* Save physical address to calculate resume offset during pm init */
	emif_data->ti_emif_sram_data_phys =
		gen_pool_virt_to_phys(emif_data->sram_pool_data,
				      emif_data->ti_emif_sram_data_virt);
	/*
	 * These functions are called during suspend path while MMU is
	 * still on so add virtual base to offset for absolute address
	 */
	emif_data->pm_functions.save_context =
		sram_suspend_address(emif_data,
				     (unsigned long)ti_emif_save_context);
	emif_data->pm_functions.enter_sr =
		sram_suspend_address(emif_data,
				     (unsigned long)ti_emif_enter_sr);
	emif_data->pm_functions.abort_sr =
		sram_suspend_address(emif_data,
				     (unsigned long)ti_emif_abort_sr);

	/*
	 * These are called during resume path when MMU is not enabled
	 * so physical address is used instead
	 */
	emif_data->pm_functions.restore_context =
		sram_resume_address(emif_data,
				    (unsigned long)ti_emif_restore_context);
	emif_data->pm_functions.exit_sr =
		sram_resume_address(emif_data,
				    (unsigned long)ti_emif_exit_sr);
	emif_data->pm_functions.run_hw_leveling =
		sram_resume_address(emif_data,
				    (unsigned long)ti_emif_run_hw_leveling);

	emif_data->pm_data.regs_virt =
		(struct emif_regs_amx3 *)emif_data->ti_emif_sram_data_virt;
	emif_data->pm_data.regs_phys = emif_data->ti_emif_sram_data_phys;

	return 0;

err_free_sram_code:
	gen_pool_free(emif_data->sram_pool_code, emif_data->ti_emif_sram_virt,
		      ti_emif_sram_sz);
	return ret;
}

static int ti_emif_push_sram(struct device *dev, struct ti_emif_data *emif_data)
{
	void *copy_addr;
	u32 data_addr;

	copy_addr = sram_exec_copy(emif_data->sram_pool_code,
				   (void *)emif_data->ti_emif_sram_virt,
				   &ti_emif_sram, ti_emif_sram_sz);
	if (!copy_addr) {
		dev_err(dev, "Cannot copy emif code to sram\n");
		return -ENODEV;
	}

	data_addr = sram_suspend_address(emif_data,
					 (unsigned long)&ti_emif_pm_sram_data);
	copy_addr = sram_exec_copy(emif_data->sram_pool_code,
				   (void *)data_addr,
				   &emif_data->pm_data,
				   sizeof(emif_data->pm_data));
	if (!copy_addr) {
		dev_err(dev, "Cannot copy emif data to code sram\n");
		return -ENODEV;
	}

	return 0;
}

/*
 * Due to Usage Note 3.1.2 "DDR3: JEDEC Compliance for Maximum
 * Self-Refresh Command Limit" found in AM335x Silicon Errata
 * (Document SPRZ360F Revised November 2013) we must configure
 * the self refresh delay timer to 0xA (8192 cycles) to avoid
 * generating too many refresh command from the EMIF.
 */
static void ti_emif_configure_sr_delay(struct ti_emif_data *emif_data)
{
	writel(EMIF_POWER_MGMT_WAIT_SELF_REFRESH_8192_CYCLES,
	       (emif_data->pm_data.ti_emif_base_addr_virt +
		EMIF_POWER_MANAGEMENT_CONTROL));

	writel(EMIF_POWER_MGMT_WAIT_SELF_REFRESH_8192_CYCLES,
	       (emif_data->pm_data.ti_emif_base_addr_virt +
		EMIF_POWER_MANAGEMENT_CTRL_SHDW));
}

/**
 * ti_emif_copy_pm_function_table - copy mapping of pm funcs in sram
 * @sram_pool: pointer to struct gen_pool where dst resides
 * @dst: void * to address that table should be copied
 *
 * Returns 0 if success other error code if table is not available
 */
int ti_emif_copy_pm_function_table(struct gen_pool *sram_pool, void *dst)
{
	void *copy_addr;

	if (!emif_instance)
		return -ENODEV;

	copy_addr = sram_exec_copy(sram_pool, dst,
				   &emif_instance->pm_functions,
				   sizeof(emif_instance->pm_functions));
	if (!copy_addr)
		return -ENODEV;

	return 0;
}
EXPORT_SYMBOL_GPL(ti_emif_copy_pm_function_table);

/**
 * ti_emif_get_mem_type - return type for memory type in use
 *
 * Returns memory type value read from EMIF or error code if fails
 */
int ti_emif_get_mem_type(void)
{
	unsigned long temp;

	if (!emif_instance)
		return -ENODEV;

	temp = readl(emif_instance->pm_data.ti_emif_base_addr_virt +
		     EMIF_SDRAM_CONFIG);

	temp = (temp & SDRAM_TYPE_MASK) >> SDRAM_TYPE_SHIFT;
	return temp;
}
EXPORT_SYMBOL_GPL(ti_emif_get_mem_type);

static const struct of_device_id ti_emif_of_match[] = {
	{ .compatible = "ti,emif-am3352", .data =
					(void *)EMIF_SRAM_AM33_REG_LAYOUT, },
	{ .compatible = "ti,emif-am4372", .data =
					(void *)EMIF_SRAM_AM43_REG_LAYOUT, },
	{},
};
MODULE_DEVICE_TABLE(of, ti_emif_of_match);

#ifdef CONFIG_PM_SLEEP
static int ti_emif_resume(struct device *dev)
{
	unsigned long tmp =
			__raw_readl((void *)emif_instance->ti_emif_sram_virt);

	/*
	 * Check to see if what we are copying is already present in the
	 * first byte at the destination, only copy if it is not which
	 * indicates we have lost context and sram no longer contains
	 * the PM code
	 */
	if (tmp != ti_emif_sram)
		ti_emif_push_sram(dev, emif_instance);

	return 0;
}

static int ti_emif_suspend(struct device *dev)
{
	/*
	 * The contents will be present in DDR hence no need to
	 * explicitly save
	 */
	return 0;
}
#endif /* CONFIG_PM_SLEEP */

static int ti_emif_probe(struct platform_device *pdev)
{
	int ret;
	struct resource *res;
	struct device *dev = &pdev->dev;
	const struct of_device_id *match;
	struct ti_emif_data *emif_data;

	emif_data = devm_kzalloc(dev, sizeof(*emif_data), GFP_KERNEL);
	if (!emif_data)
		return -ENOMEM;

	match = of_match_device(ti_emif_of_match, &pdev->dev);
	if (!match)
		return -ENODEV;

	emif_data->pm_data.ti_emif_sram_config = (unsigned long)match->data;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	emif_data->pm_data.ti_emif_base_addr_virt = devm_ioremap_resource(dev,
									  res);
	if (IS_ERR(emif_data->pm_data.ti_emif_base_addr_virt)) {
		ret = PTR_ERR(emif_data->pm_data.ti_emif_base_addr_virt);
		return ret;
	}

	emif_data->pm_data.ti_emif_base_addr_phys = res->start;

	ti_emif_configure_sr_delay(emif_data);

	ret = ti_emif_alloc_sram(dev, emif_data);
	if (ret)
		return ret;

	ret = ti_emif_push_sram(dev, emif_data);
	if (ret)
		goto fail_free_sram;

	emif_instance = emif_data;

	return 0;

fail_free_sram:
	ti_emif_free_sram(emif_data);

	return ret;
}

static int ti_emif_remove(struct platform_device *pdev)
{
	struct ti_emif_data *emif_data = emif_instance;

	emif_instance = NULL;

	ti_emif_free_sram(emif_data);

	return 0;
}

static const struct dev_pm_ops ti_emif_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(ti_emif_suspend, ti_emif_resume)
};

static struct platform_driver ti_emif_driver = {
	.probe = ti_emif_probe,
	.remove = ti_emif_remove,
	.driver = {
		.name = KBUILD_MODNAME,
		.of_match_table = of_match_ptr(ti_emif_of_match),
		.pm = &ti_emif_pm_ops,
	},
};
module_platform_driver(ti_emif_driver);

MODULE_AUTHOR("Dave Gerlach <d-gerlach@ti.com>");
MODULE_DESCRIPTION("Texas Instruments SRAM EMIF driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
8428e5ad DG	1	/*
	2	* TI AM33XX SRAM EMIF Driver
	3	*
	4	* Copyright (C) 2016-2017 Texas Instruments Inc.
	5	* Dave Gerlach
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* version 2 as published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*/
	16
	17	#include <linux/err.h>
	18	#include <linux/genalloc.h>
	19	#include <linux/io.h>
	20	#include <linux/kernel.h>
	21	#include <linux/module.h>
	22	#include <linux/of.h>
	23	#include <linux/of_platform.h>
	24	#include <linux/platform_device.h>
	25	#include <linux/sram.h>
	26	#include <linux/ti-emif-sram.h>
	27
	28	#include "emif.h"
	29
	30	#define TI_EMIF_SRAM_SYMBOL_OFFSET(sym) ((unsigned long)(sym) - \
	31	(unsigned long)&ti_emif_sram)
	32
	33	#define EMIF_POWER_MGMT_WAIT_SELF_REFRESH_8192_CYCLES 0x00a0
	34
	35	struct ti_emif_data {
	36	phys_addr_t ti_emif_sram_phys;
	37	phys_addr_t ti_emif_sram_data_phys;
	38	unsigned long ti_emif_sram_virt;
	39	unsigned long ti_emif_sram_data_virt;
	40	struct gen_pool *sram_pool_code;
	41	struct gen_pool *sram_pool_data;
	42	struct ti_emif_pm_data pm_data;
	43	struct ti_emif_pm_functions pm_functions;
	44	};
	45
	46	static struct ti_emif_data *emif_instance;
	47
	48	static u32 sram_suspend_address(struct ti_emif_data *emif_data,
	49	unsigned long addr)
	50	{
	51	return (emif_data->ti_emif_sram_virt +
	52	TI_EMIF_SRAM_SYMBOL_OFFSET(addr));
	53	}
	54
	55	static phys_addr_t sram_resume_address(struct ti_emif_data *emif_data,
	56	unsigned long addr)
	57	{
	58	return ((unsigned long)emif_data->ti_emif_sram_phys +
	59	TI_EMIF_SRAM_SYMBOL_OFFSET(addr));
	60	}
	61
	62	static void ti_emif_free_sram(struct ti_emif_data *emif_data)
	63	{
	64	gen_pool_free(emif_data->sram_pool_code, emif_data->ti_emif_sram_virt,
65	ti_emif_sram_sz);
66	gen_pool_free(emif_data->sram_pool_data,
67	emif_data->ti_emif_sram_data_virt,
68	sizeof(struct emif_regs_amx3));
69	}
70
71	static int ti_emif_alloc_sram(struct device *dev,
72	struct ti_emif_data *emif_data)
73	{
74	struct device_node *np = dev->of_node;
75	int ret;
76
77	emif_data->sram_pool_code = of_gen_pool_get(np, "sram", 0);
78	if (!emif_data->sram_pool_code) {
79	dev_err(dev, "Unable to get sram pool for ocmcram code\n");
80	return -ENODEV;
81	}
82
83	emif_data->ti_emif_sram_virt =
84	gen_pool_alloc(emif_data->sram_pool_code,
85	ti_emif_sram_sz);
86	if (!emif_data->ti_emif_sram_virt) {
87	dev_err(dev, "Unable to allocate code memory from ocmcram\n");
88	return -ENOMEM;
89	}
90
91	/* Save physical address to calculate resume offset during pm init */
92	emif_data->ti_emif_sram_phys =
93	gen_pool_virt_to_phys(emif_data->sram_pool_code,
94	emif_data->ti_emif_sram_virt);
95
96	/* Get sram pool for data section and allocate space */
97	emif_data->sram_pool_data = of_gen_pool_get(np, "sram", 1);
98	if (!emif_data->sram_pool_data) {
99	dev_err(dev, "Unable to get sram pool for ocmcram data\n");
100	ret = -ENODEV;
101	goto err_free_sram_code;
102	}
103
104	emif_data->ti_emif_sram_data_virt =
105	gen_pool_alloc(emif_data->sram_pool_data,
106	sizeof(struct emif_regs_amx3));
107	if (!emif_data->ti_emif_sram_data_virt) {
108	dev_err(dev, "Unable to allocate data memory from ocmcram\n");
109	ret = -ENOMEM;
110	goto err_free_sram_code;
111	}
112
113	/* Save physical address to calculate resume offset during pm init */
114	emif_data->ti_emif_sram_data_phys =
115	gen_pool_virt_to_phys(emif_data->sram_pool_data,
116	emif_data->ti_emif_sram_data_virt);
117	/*
118	* These functions are called during suspend path while MMU is
119	* still on so add virtual base to offset for absolute address
120	*/
121	emif_data->pm_functions.save_context =
122	sram_suspend_address(emif_data,
123	(unsigned long)ti_emif_save_context);
124	emif_data->pm_functions.enter_sr =
125	sram_suspend_address(emif_data,
126	(unsigned long)ti_emif_enter_sr);
127	emif_data->pm_functions.abort_sr =
128	sram_suspend_address(emif_data,
129	(unsigned long)ti_emif_abort_sr);
130
131	/*
132	* These are called during resume path when MMU is not enabled
133	* so physical address is used instead
134	*/
135	emif_data->pm_functions.restore_context =
136	sram_resume_address(emif_data,
137	(unsigned long)ti_emif_restore_context);
138	emif_data->pm_functions.exit_sr =
139	sram_resume_address(emif_data,
140	(unsigned long)ti_emif_exit_sr);
6c110561 DG	141	emif_data->pm_functions.run_hw_leveling =
	142	sram_resume_address(emif_data,
	143	(unsigned long)ti_emif_run_hw_leveling);
8428e5ad DG	144
	145	emif_data->pm_data.regs_virt =
	146	(struct emif_regs_amx3 *)emif_data->ti_emif_sram_data_virt;
	147	emif_data->pm_data.regs_phys = emif_data->ti_emif_sram_data_phys;
	148
	149	return 0;
	150
	151	err_free_sram_code:
	152	gen_pool_free(emif_data->sram_pool_code, emif_data->ti_emif_sram_virt,
	153	ti_emif_sram_sz);
	154	return ret;
	155	}
	156
	157	static int ti_emif_push_sram(struct device dev, struct ti_emif_data emif_data)
	158	{
	159	void *copy_addr;
	160	u32 data_addr;
	161
	162	copy_addr = sram_exec_copy(emif_data->sram_pool_code,
	163	(void *)emif_data->ti_emif_sram_virt,
	164	&ti_emif_sram, ti_emif_sram_sz);
	165	if (!copy_addr) {
	166	dev_err(dev, "Cannot copy emif code to sram\n");
	167	return -ENODEV;
	168	}
	169
	170	data_addr = sram_suspend_address(emif_data,
	171	(unsigned long)&ti_emif_pm_sram_data);
	172	copy_addr = sram_exec_copy(emif_data->sram_pool_code,
	173	(void *)data_addr,
	174	&emif_data->pm_data,
	175	sizeof(emif_data->pm_data));
	176	if (!copy_addr) {
	177	dev_err(dev, "Cannot copy emif data to code sram\n");
	178	return -ENODEV;
	179	}
	180
	181	return 0;
	182	}
	183
	184	/*
	185	* Due to Usage Note 3.1.2 "DDR3: JEDEC Compliance for Maximum
	186	* Self-Refresh Command Limit" found in AM335x Silicon Errata
	187	* (Document SPRZ360F Revised November 2013) we must configure
	188	* the self refresh delay timer to 0xA (8192 cycles) to avoid
	189	* generating too many refresh command from the EMIF.
	190	*/
	191	static void ti_emif_configure_sr_delay(struct ti_emif_data *emif_data)
	192	{
	193	writel(EMIF_POWER_MGMT_WAIT_SELF_REFRESH_8192_CYCLES,
	194	(emif_data->pm_data.ti_emif_base_addr_virt +
	195	EMIF_POWER_MANAGEMENT_CONTROL));
	196
	197	writel(EMIF_POWER_MGMT_WAIT_SELF_REFRESH_8192_CYCLES,
	198	(emif_data->pm_data.ti_emif_base_addr_virt +
	199	EMIF_POWER_MANAGEMENT_CTRL_SHDW));
	200	}
	201
	202	/**
	203	* ti_emif_copy_pm_function_table - copy mapping of pm funcs in sram
	204	* @sram_pool: pointer to struct gen_pool where dst resides
	205	* @dst: void * to address that table should be copied
	206	*
	207	* Returns 0 if success other error code if table is not available
208	*/
209	int ti_emif_copy_pm_function_table(struct gen_pool sram_pool, void dst)
210	{
211	void *copy_addr;
212
213	if (!emif_instance)
214	return -ENODEV;
215
216	copy_addr = sram_exec_copy(sram_pool, dst,
217	&emif_instance->pm_functions,
218	sizeof(emif_instance->pm_functions));
219	if (!copy_addr)
220	return -ENODEV;
221
222	return 0;
223	}
224	EXPORT_SYMBOL_GPL(ti_emif_copy_pm_function_table);
225
226	/**
227	* ti_emif_get_mem_type - return type for memory type in use
228	*
229	* Returns memory type value read from EMIF or error code if fails
230	*/
231	int ti_emif_get_mem_type(void)
232	{
233	unsigned long temp;
234
235	if (!emif_instance)
236	return -ENODEV;
237
238	temp = readl(emif_instance->pm_data.ti_emif_base_addr_virt +
239	EMIF_SDRAM_CONFIG);
240
241	temp = (temp & SDRAM_TYPE_MASK) >> SDRAM_TYPE_SHIFT;
242	return temp;
243	}
244	EXPORT_SYMBOL_GPL(ti_emif_get_mem_type);
245
246	static const struct of_device_id ti_emif_of_match[] = {
247	{ .compatible = "ti,emif-am3352", .data =
248	(void *)EMIF_SRAM_AM33_REG_LAYOUT, },
249	{ .compatible = "ti,emif-am4372", .data =
250	(void *)EMIF_SRAM_AM43_REG_LAYOUT, },
251	{},
252	};
253	MODULE_DEVICE_TABLE(of, ti_emif_of_match);
254
38853979 DG	255	#ifdef CONFIG_PM_SLEEP
	256	static int ti_emif_resume(struct device *dev)
	257	{
	258	unsigned long tmp =
	259	__raw_readl((void *)emif_instance->ti_emif_sram_virt);
	260
	261	/*
	262	* Check to see if what we are copying is already present in the
	263	* first byte at the destination, only copy if it is not which
	264	* indicates we have lost context and sram no longer contains
	265	* the PM code
	266	*/
	267	if (tmp != ti_emif_sram)
	268	ti_emif_push_sram(dev, emif_instance);
	269
	270	return 0;
	271	}
	272
	273	static int ti_emif_suspend(struct device *dev)
	274	{
	275	/*
	276	* The contents will be present in DDR hence no need to
	277	* explicitly save
	278	*/
	279	return 0;
	280	}
	281	#endif /* CONFIG_PM_SLEEP */
	282
8428e5ad DG	283	static int ti_emif_probe(struct platform_device *pdev)
	284	{
	285	int ret;
	286	struct resource *res;
	287	struct device *dev = &pdev->dev;
	288	const struct of_device_id *match;
	289	struct ti_emif_data *emif_data;
	290
	291	emif_data = devm_kzalloc(dev, sizeof(*emif_data), GFP_KERNEL);
	292	if (!emif_data)
	293	return -ENOMEM;
	294
	295	match = of_match_device(ti_emif_of_match, &pdev->dev);
	296	if (!match)
	297	return -ENODEV;
	298
	299	emif_data->pm_data.ti_emif_sram_config = (unsigned long)match->data;
	300
	301	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	302	emif_data->pm_data.ti_emif_base_addr_virt = devm_ioremap_resource(dev,
	303	res);
	304	if (IS_ERR(emif_data->pm_data.ti_emif_base_addr_virt)) {
8428e5ad DG	305	ret = PTR_ERR(emif_data->pm_data.ti_emif_base_addr_virt);
	306	return ret;
	307	}
	308
	309	emif_data->pm_data.ti_emif_base_addr_phys = res->start;
	310
	311	ti_emif_configure_sr_delay(emif_data);
	312
	313	ret = ti_emif_alloc_sram(dev, emif_data);
	314	if (ret)
	315	return ret;
	316
	317	ret = ti_emif_push_sram(dev, emif_data);
	318	if (ret)
	319	goto fail_free_sram;
	320
	321	emif_instance = emif_data;
	322
	323	return 0;
	324
	325	fail_free_sram:
	326	ti_emif_free_sram(emif_data);
	327
	328	return ret;
	329	}
	330
	331	static int ti_emif_remove(struct platform_device *pdev)
	332	{
8428e5ad DG	333	struct ti_emif_data *emif_data = emif_instance;
	334
	335	emif_instance = NULL;
	336
	337	ti_emif_free_sram(emif_data);
	338
	339	return 0;
	340	}
	341
38853979 DG	342	static const struct dev_pm_ops ti_emif_pm_ops = {
	343	SET_SYSTEM_SLEEP_PM_OPS(ti_emif_suspend, ti_emif_resume)
	344	};
	345
8428e5ad DG	346	static struct platform_driver ti_emif_driver = {
	347	.probe = ti_emif_probe,
	348	.remove = ti_emif_remove,
	349	.driver = {
	350	.name = KBUILD_MODNAME,
	351	.of_match_table = of_match_ptr(ti_emif_of_match),
38853979	352	.pm = &ti_emif_pm_ops,
8428e5ad DG	353	},
	354	};
	355	module_platform_driver(ti_emif_driver);
	356
	357	MODULE_AUTHOR("Dave Gerlach <d-gerlach@ti.com>");
	358	MODULE_DESCRIPTION("Texas Instruments SRAM EMIF driver");
	359	MODULE_LICENSE("GPL v2");