[linux-2.6-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_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);
141
142	emif_data->pm_data.regs_virt =
143	(struct emif_regs_amx3 *)emif_data->ti_emif_sram_data_virt;
144	emif_data->pm_data.regs_phys = emif_data->ti_emif_sram_data_phys;
145
146	return 0;
147
148	err_free_sram_code:
149	gen_pool_free(emif_data->sram_pool_code, emif_data->ti_emif_sram_virt,
150	ti_emif_sram_sz);
151	return ret;
152	}
153
154	static int ti_emif_push_sram(struct device dev, struct ti_emif_data emif_data)
155	{
156	void *copy_addr;
157	u32 data_addr;
158
159	copy_addr = sram_exec_copy(emif_data->sram_pool_code,
160	(void *)emif_data->ti_emif_sram_virt,
161	&ti_emif_sram, ti_emif_sram_sz);
162	if (!copy_addr) {
163	dev_err(dev, "Cannot copy emif code to sram\n");
164	return -ENODEV;
165	}
166
167	data_addr = sram_suspend_address(emif_data,
168	(unsigned long)&ti_emif_pm_sram_data);
169	copy_addr = sram_exec_copy(emif_data->sram_pool_code,
170	(void *)data_addr,
171	&emif_data->pm_data,
172	sizeof(emif_data->pm_data));
173	if (!copy_addr) {
174	dev_err(dev, "Cannot copy emif data to code sram\n");
175	return -ENODEV;
176	}
177
178	return 0;
179	}
180
181	/*
182	* Due to Usage Note 3.1.2 "DDR3: JEDEC Compliance for Maximum
183	* Self-Refresh Command Limit" found in AM335x Silicon Errata
184	* (Document SPRZ360F Revised November 2013) we must configure
185	* the self refresh delay timer to 0xA (8192 cycles) to avoid
186	* generating too many refresh command from the EMIF.
187	*/
188	static void ti_emif_configure_sr_delay(struct ti_emif_data *emif_data)
189	{
190	writel(EMIF_POWER_MGMT_WAIT_SELF_REFRESH_8192_CYCLES,
191	(emif_data->pm_data.ti_emif_base_addr_virt +
192	EMIF_POWER_MANAGEMENT_CONTROL));
193
194	writel(EMIF_POWER_MGMT_WAIT_SELF_REFRESH_8192_CYCLES,
195	(emif_data->pm_data.ti_emif_base_addr_virt +
196	EMIF_POWER_MANAGEMENT_CTRL_SHDW));
197	}
198
199	/**
200	* ti_emif_copy_pm_function_table - copy mapping of pm funcs in sram
201	* @sram_pool: pointer to struct gen_pool where dst resides
202	* @dst: void * to address that table should be copied
203	*
204	* Returns 0 if success other error code if table is not available
205	*/
206	int ti_emif_copy_pm_function_table(struct gen_pool sram_pool, void dst)
207	{
208	void *copy_addr;
209
210	if (!emif_instance)
211	return -ENODEV;
212
213	copy_addr = sram_exec_copy(sram_pool, dst,
214	&emif_instance->pm_functions,
215	sizeof(emif_instance->pm_functions));
216	if (!copy_addr)
217	return -ENODEV;
218
219	return 0;
220	}
221	EXPORT_SYMBOL_GPL(ti_emif_copy_pm_function_table);
222
223	/**
224	* ti_emif_get_mem_type - return type for memory type in use
225	*
226	* Returns memory type value read from EMIF or error code if fails
227	*/
228	int ti_emif_get_mem_type(void)
229	{
230	unsigned long temp;
231
232	if (!emif_instance)
233	return -ENODEV;
234
235	temp = readl(emif_instance->pm_data.ti_emif_base_addr_virt +
236	EMIF_SDRAM_CONFIG);
237
238	temp = (temp & SDRAM_TYPE_MASK) >> SDRAM_TYPE_SHIFT;
239	return temp;
240	}
241	EXPORT_SYMBOL_GPL(ti_emif_get_mem_type);
242
243	static const struct of_device_id ti_emif_of_match[] = {
244	{ .compatible = "ti,emif-am3352", .data =
245	(void *)EMIF_SRAM_AM33_REG_LAYOUT, },
246	{ .compatible = "ti,emif-am4372", .data =
247	(void *)EMIF_SRAM_AM43_REG_LAYOUT, },
248	{},
249	};
250	MODULE_DEVICE_TABLE(of, ti_emif_of_match);
251
38853979 DG	252	#ifdef CONFIG_PM_SLEEP
	253	static int ti_emif_resume(struct device *dev)
	254	{
	255	unsigned long tmp =
	256	__raw_readl((void *)emif_instance->ti_emif_sram_virt);
	257
	258	/*
	259	* Check to see if what we are copying is already present in the
	260	* first byte at the destination, only copy if it is not which
	261	* indicates we have lost context and sram no longer contains
	262	* the PM code
	263	*/
	264	if (tmp != ti_emif_sram)
	265	ti_emif_push_sram(dev, emif_instance);
	266
	267	return 0;
	268	}
	269
	270	static int ti_emif_suspend(struct device *dev)
	271	{
	272	/*
	273	* The contents will be present in DDR hence no need to
	274	* explicitly save
	275	*/
	276	return 0;
	277	}
	278	#endif /* CONFIG_PM_SLEEP */
	279
8428e5ad DG	280	static int ti_emif_probe(struct platform_device *pdev)
	281	{
	282	int ret;
	283	struct resource *res;
	284	struct device *dev = &pdev->dev;
	285	const struct of_device_id *match;
	286	struct ti_emif_data *emif_data;
	287
	288	emif_data = devm_kzalloc(dev, sizeof(*emif_data), GFP_KERNEL);
	289	if (!emif_data)
	290	return -ENOMEM;
	291
	292	match = of_match_device(ti_emif_of_match, &pdev->dev);
	293	if (!match)
	294	return -ENODEV;
	295
	296	emif_data->pm_data.ti_emif_sram_config = (unsigned long)match->data;
	297
	298	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	299	emif_data->pm_data.ti_emif_base_addr_virt = devm_ioremap_resource(dev,
	300	res);
	301	if (IS_ERR(emif_data->pm_data.ti_emif_base_addr_virt)) {
8428e5ad DG	302	ret = PTR_ERR(emif_data->pm_data.ti_emif_base_addr_virt);
	303	return ret;
	304	}
	305
	306	emif_data->pm_data.ti_emif_base_addr_phys = res->start;
	307
	308	ti_emif_configure_sr_delay(emif_data);
	309
	310	ret = ti_emif_alloc_sram(dev, emif_data);
	311	if (ret)
	312	return ret;
	313
	314	ret = ti_emif_push_sram(dev, emif_data);
	315	if (ret)
	316	goto fail_free_sram;
	317
	318	emif_instance = emif_data;
	319
	320	return 0;
	321
	322	fail_free_sram:
	323	ti_emif_free_sram(emif_data);
	324
	325	return ret;
	326	}
	327
	328	static int ti_emif_remove(struct platform_device *pdev)
	329	{
8428e5ad DG	330	struct ti_emif_data *emif_data = emif_instance;
	331
	332	emif_instance = NULL;
	333
	334	ti_emif_free_sram(emif_data);
	335
	336	return 0;
	337	}
	338
38853979 DG	339	static const struct dev_pm_ops ti_emif_pm_ops = {
	340	SET_SYSTEM_SLEEP_PM_OPS(ti_emif_suspend, ti_emif_resume)
	341	};
	342
8428e5ad DG	343	static struct platform_driver ti_emif_driver = {
	344	.probe = ti_emif_probe,
	345	.remove = ti_emif_remove,
	346	.driver = {
	347	.name = KBUILD_MODNAME,
	348	.of_match_table = of_match_ptr(ti_emif_of_match),
38853979	349	.pm = &ti_emif_pm_ops,
8428e5ad DG	350	},
	351	};
	352	module_platform_driver(ti_emif_driver);
	353
	354	MODULE_AUTHOR("Dave Gerlach <d-gerlach@ti.com>");
	355	MODULE_DESCRIPTION("Texas Instruments SRAM EMIF driver");
	356	MODULE_LICENSE("GPL v2");