[deliverable/linux.git] / drivers / staging / fsl-mc / bus / mc-io.c

/* Copyright 2013-2016 Freescale Semiconductor Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the above-listed copyright holders nor the
 *       names of any contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 *
 * ALTERNATIVELY, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") as published by the Free Software
 * Foundation, either version 2 of that License or (at your option) any
 * later version.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/io.h>
#include "../include/mc-bus.h"
#include "../include/mc-sys.h"

#include "fsl-mc-private.h"
#include "dpmcp.h"
#include "dpmcp-cmd.h"

static int fsl_mc_io_set_dpmcp(struct fsl_mc_io *mc_io,
			       struct fsl_mc_device *dpmcp_dev)
{
	int error;

	if (WARN_ON(!dpmcp_dev))
		return -EINVAL;

	if (WARN_ON(mc_io->dpmcp_dev))
		return -EINVAL;

	if (WARN_ON(dpmcp_dev->mc_io))
		return -EINVAL;

	error = dpmcp_open(mc_io,
			   0,
			   dpmcp_dev->obj_desc.id,
			   &dpmcp_dev->mc_handle);
	if (error < 0)
		return error;

	mc_io->dpmcp_dev = dpmcp_dev;
	dpmcp_dev->mc_io = mc_io;
	return 0;
}

static void fsl_mc_io_unset_dpmcp(struct fsl_mc_io *mc_io)
{
	int error;
	struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;

	if (WARN_ON(!dpmcp_dev))
		return;

	if (WARN_ON(dpmcp_dev->mc_io != mc_io))
		return;

	error = dpmcp_close(mc_io,
			    0,
			    dpmcp_dev->mc_handle);
	if (error < 0) {
		dev_err(&dpmcp_dev->dev, "dpmcp_close() failed: %d\n",
			error);
	}

	mc_io->dpmcp_dev = NULL;
	dpmcp_dev->mc_io = NULL;
}

/**
 * Creates an MC I/O object
 *
 * @dev: device to be associated with the MC I/O object
 * @mc_portal_phys_addr: physical address of the MC portal to use
 * @mc_portal_size: size in bytes of the MC portal
 * @dpmcp-dev: Pointer to the DPMCP object associated with this MC I/O
 * object or NULL if none.
 * @flags: flags for the new MC I/O object
 * @new_mc_io: Area to return pointer to newly created MC I/O object
 *
 * Returns '0' on Success; Error code otherwise.
 */
int __must_check fsl_create_mc_io(struct device *dev,
				  phys_addr_t mc_portal_phys_addr,
				  u32 mc_portal_size,
				  struct fsl_mc_device *dpmcp_dev,
				  u32 flags, struct fsl_mc_io **new_mc_io)
{
	int error;
	struct fsl_mc_io *mc_io;
	void __iomem *mc_portal_virt_addr;
	struct resource *res;

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

	mc_io->dev = dev;
	mc_io->flags = flags;
	mc_io->portal_phys_addr = mc_portal_phys_addr;
	mc_io->portal_size = mc_portal_size;
	if (flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL)
		spin_lock_init(&mc_io->spinlock);
	else
		mutex_init(&mc_io->mutex);

	res = devm_request_mem_region(dev,
				      mc_portal_phys_addr,
				      mc_portal_size,
				      "mc_portal");
	if (!res) {
		dev_err(dev,
			"devm_request_mem_region failed for MC portal %#llx\n",
			mc_portal_phys_addr);
		return -EBUSY;
	}

	mc_portal_virt_addr = devm_ioremap_nocache(dev,
						   mc_portal_phys_addr,
						   mc_portal_size);
	if (!mc_portal_virt_addr) {
		dev_err(dev,
			"devm_ioremap_nocache failed for MC portal %#llx\n",
			mc_portal_phys_addr);
		return -ENXIO;
	}

	mc_io->portal_virt_addr = mc_portal_virt_addr;
	if (dpmcp_dev) {
		error = fsl_mc_io_set_dpmcp(mc_io, dpmcp_dev);
		if (error < 0)
			goto error_destroy_mc_io;
	}

	*new_mc_io = mc_io;
	return 0;

error_destroy_mc_io:
	fsl_destroy_mc_io(mc_io);
	return error;
}

/**
 * Destroys an MC I/O object
 *
 * @mc_io: MC I/O object to destroy
 */
void fsl_destroy_mc_io(struct fsl_mc_io *mc_io)
{
	struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;

	if (dpmcp_dev)
		fsl_mc_io_unset_dpmcp(mc_io);

	devm_iounmap(mc_io->dev, mc_io->portal_virt_addr);
	devm_release_mem_region(mc_io->dev,
				mc_io->portal_phys_addr,
				mc_io->portal_size);

	mc_io->portal_virt_addr = NULL;
	devm_kfree(mc_io->dev, mc_io);
}

/**
 * fsl_mc_portal_allocate - Allocates an MC portal
 *
 * @mc_dev: MC device for which the MC portal is to be allocated
 * @mc_io_flags: Flags for the fsl_mc_io object that wraps the allocated
 * MC portal.
 * @new_mc_io: Pointer to area where the pointer to the fsl_mc_io object
 * that wraps the allocated MC portal is to be returned
 *
 * This function allocates an MC portal from the device's parent DPRC,
 * from the corresponding MC bus' pool of MC portals and wraps
 * it in a new fsl_mc_io object. If 'mc_dev' is a DPRC itself, the
 * portal is allocated from its own MC bus.
 */
int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev,
					u16 mc_io_flags,
					struct fsl_mc_io **new_mc_io)
{
	struct fsl_mc_device *mc_bus_dev;
	struct fsl_mc_bus *mc_bus;
	phys_addr_t mc_portal_phys_addr;
	size_t mc_portal_size;
	struct fsl_mc_device *dpmcp_dev;
	int error = -EINVAL;
	struct fsl_mc_resource *resource = NULL;
	struct fsl_mc_io *mc_io = NULL;

	if (mc_dev->flags & FSL_MC_IS_DPRC) {
		mc_bus_dev = mc_dev;
	} else {
		if (WARN_ON(!dev_is_fsl_mc(mc_dev->dev.parent)))
			return error;

		mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
	}

	mc_bus = to_fsl_mc_bus(mc_bus_dev);
	*new_mc_io = NULL;
	error = fsl_mc_resource_allocate(mc_bus, FSL_MC_POOL_DPMCP, &resource);
	if (error < 0)
		return error;

	error = -EINVAL;
	dpmcp_dev = resource->data;
	if (WARN_ON(!dpmcp_dev))
		goto error_cleanup_resource;

	if (dpmcp_dev->obj_desc.ver_major < DPMCP_MIN_VER_MAJOR ||
	    (dpmcp_dev->obj_desc.ver_major == DPMCP_MIN_VER_MAJOR &&
	     dpmcp_dev->obj_desc.ver_minor < DPMCP_MIN_VER_MINOR)) {
		dev_err(&dpmcp_dev->dev,
			"ERROR: Version %d.%d of DPMCP not supported.\n",
			dpmcp_dev->obj_desc.ver_major,
			dpmcp_dev->obj_desc.ver_minor);
		error = -ENOTSUPP;
		goto error_cleanup_resource;
	}

	if (WARN_ON(dpmcp_dev->obj_desc.region_count == 0))
		goto error_cleanup_resource;

	mc_portal_phys_addr = dpmcp_dev->regions[0].start;
	mc_portal_size = dpmcp_dev->regions[0].end -
			 dpmcp_dev->regions[0].start + 1;

	if (WARN_ON(mc_portal_size != mc_bus_dev->mc_io->portal_size))
		goto error_cleanup_resource;

	error = fsl_create_mc_io(&mc_bus_dev->dev,
				 mc_portal_phys_addr,
				 mc_portal_size, dpmcp_dev,
				 mc_io_flags, &mc_io);
	if (error < 0)
		goto error_cleanup_resource;

	*new_mc_io = mc_io;
	return 0;

error_cleanup_resource:
	fsl_mc_resource_free(resource);
	return error;
}
EXPORT_SYMBOL_GPL(fsl_mc_portal_allocate);

/**
 * fsl_mc_portal_free - Returns an MC portal to the pool of free MC portals
 * of a given MC bus
 *
 * @mc_io: Pointer to the fsl_mc_io object that wraps the MC portal to free
 */
void fsl_mc_portal_free(struct fsl_mc_io *mc_io)
{
	struct fsl_mc_device *dpmcp_dev;
	struct fsl_mc_resource *resource;

	/*
	 * Every mc_io obtained by calling fsl_mc_portal_allocate() is supposed
	 * to have a DPMCP object associated with.
	 */
	dpmcp_dev = mc_io->dpmcp_dev;
	if (WARN_ON(!dpmcp_dev))
		return;

	resource = dpmcp_dev->resource;
	if (WARN_ON(!resource || resource->type != FSL_MC_POOL_DPMCP))
		return;

	if (WARN_ON(resource->data != dpmcp_dev))
		return;

	fsl_destroy_mc_io(mc_io);
	fsl_mc_resource_free(resource);
}
EXPORT_SYMBOL_GPL(fsl_mc_portal_free);

/**
 * fsl_mc_portal_reset - Resets the dpmcp object for a given fsl_mc_io object
 *
 * @mc_io: Pointer to the fsl_mc_io object that wraps the MC portal to free
 */
int fsl_mc_portal_reset(struct fsl_mc_io *mc_io)
{
	int error;
	struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;

	if (WARN_ON(!dpmcp_dev))
		return -EINVAL;

	error = dpmcp_reset(mc_io, 0, dpmcp_dev->mc_handle);
	if (error < 0) {
		dev_err(&dpmcp_dev->dev, "dpmcp_reset() failed: %d\n", error);
		return error;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(fsl_mc_portal_reset);
Commit	Line	Data
7f59f4c7 SY	1	/* Copyright 2013-2016 Freescale Semiconductor Inc.
	2	*
	3	* Redistribution and use in source and binary forms, with or without
	4	* modification, are permitted provided that the following conditions are met:
	5	* * Redistributions of source code must retain the above copyright
	6	* notice, this list of conditions and the following disclaimer.
	7	* * Redistributions in binary form must reproduce the above copyright
	8	* notice, this list of conditions and the following disclaimer in the
	9	* documentation and/or other materials provided with the distribution.
	10	* * Neither the name of the above-listed copyright holders nor the
	11	* names of any contributors may be used to endorse or promote products
	12	* derived from this software without specific prior written permission.
	13	*
	14	*
	15	* ALTERNATIVELY, this software may be distributed under the terms of the
	16	* GNU General Public License ("GPL") as published by the Free Software
	17	* Foundation, either version 2 of that License or (at your option) any
	18	* later version.
	19	*
	20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	21	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	23	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
	24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	27	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	28	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	29	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	30	* POSSIBILITY OF SUCH DAMAGE.
	31	*/
	32
d4e75132	33	#include <linux/io.h>
7f59f4c7 SY	34	#include "../include/mc-bus.h"
7f59f4c7 SY	35	#include "../include/mc-sys.h"
5143ecf6	36
7f59f4c7 SY	37	#include "fsl-mc-private.h"
	38	#include "dpmcp.h"
	39	#include "dpmcp-cmd.h"
	40
	41	static int fsl_mc_io_set_dpmcp(struct fsl_mc_io *mc_io,
	42	struct fsl_mc_device *dpmcp_dev)
	43	{
	44	int error;
	45
	46	if (WARN_ON(!dpmcp_dev))
	47	return -EINVAL;
	48
	49	if (WARN_ON(mc_io->dpmcp_dev))
	50	return -EINVAL;
	51
	52	if (WARN_ON(dpmcp_dev->mc_io))
	53	return -EINVAL;
	54
	55	error = dpmcp_open(mc_io,
	56	0,
	57	dpmcp_dev->obj_desc.id,
	58	&dpmcp_dev->mc_handle);
	59	if (error < 0)
	60	return error;
	61
	62	mc_io->dpmcp_dev = dpmcp_dev;
	63	dpmcp_dev->mc_io = mc_io;
	64	return 0;
	65	}
	66
	67	static void fsl_mc_io_unset_dpmcp(struct fsl_mc_io *mc_io)
	68	{
	69	int error;
	70	struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;
	71
	72	if (WARN_ON(!dpmcp_dev))
	73	return;
	74
	75	if (WARN_ON(dpmcp_dev->mc_io != mc_io))
	76	return;
	77
	78	error = dpmcp_close(mc_io,
	79	0,
	80	dpmcp_dev->mc_handle);
	81	if (error < 0) {
	82	dev_err(&dpmcp_dev->dev, "dpmcp_close() failed: %d\n",
	83	error);
	84	}
	85
	86	mc_io->dpmcp_dev = NULL;
	87	dpmcp_dev->mc_io = NULL;
	88	}
	89
	90	/**
	91	* Creates an MC I/O object
	92	*
	93	* @dev: device to be associated with the MC I/O object
	94	* @mc_portal_phys_addr: physical address of the MC portal to use
	95	* @mc_portal_size: size in bytes of the MC portal
	96	* @dpmcp-dev: Pointer to the DPMCP object associated with this MC I/O
	97	* object or NULL if none.
	98	* @flags: flags for the new MC I/O object
	99	* @new_mc_io: Area to return pointer to newly created MC I/O object
	100	*
101	* Returns '0' on Success; Error code otherwise.
102	*/
103	int __must_check fsl_create_mc_io(struct device *dev,
104	phys_addr_t mc_portal_phys_addr,
105	u32 mc_portal_size,
106	struct fsl_mc_device *dpmcp_dev,
107	u32 flags, struct fsl_mc_io **new_mc_io)
108	{
109	int error;
110	struct fsl_mc_io *mc_io;
111	void __iomem *mc_portal_virt_addr;
112	struct resource *res;
113
114	mc_io = devm_kzalloc(dev, sizeof(*mc_io), GFP_KERNEL);
115	if (!mc_io)
116	return -ENOMEM;
117
118	mc_io->dev = dev;
119	mc_io->flags = flags;
120	mc_io->portal_phys_addr = mc_portal_phys_addr;
121	mc_io->portal_size = mc_portal_size;
122	if (flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL)
123	spin_lock_init(&mc_io->spinlock);
124	else
125	mutex_init(&mc_io->mutex);
126
127	res = devm_request_mem_region(dev,
128	mc_portal_phys_addr,
129	mc_portal_size,
130	"mc_portal");
131	if (!res) {
132	dev_err(dev,
133	"devm_request_mem_region failed for MC portal %#llx\n",
134	mc_portal_phys_addr);
135	return -EBUSY;
136	}
137
138	mc_portal_virt_addr = devm_ioremap_nocache(dev,
139	mc_portal_phys_addr,
140	mc_portal_size);
141	if (!mc_portal_virt_addr) {
142	dev_err(dev,
143	"devm_ioremap_nocache failed for MC portal %#llx\n",
144	mc_portal_phys_addr);
145	return -ENXIO;
146	}
147
148	mc_io->portal_virt_addr = mc_portal_virt_addr;
149	if (dpmcp_dev) {
150	error = fsl_mc_io_set_dpmcp(mc_io, dpmcp_dev);
151	if (error < 0)
152	goto error_destroy_mc_io;
153	}
154
155	*new_mc_io = mc_io;
156	return 0;
157
158	error_destroy_mc_io:
159	fsl_destroy_mc_io(mc_io);
160	return error;
161	}
162
163	/**
164	* Destroys an MC I/O object
165	*
166	* @mc_io: MC I/O object to destroy
167	*/
168	void fsl_destroy_mc_io(struct fsl_mc_io *mc_io)
169	{
170	struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;
171
172	if (dpmcp_dev)
173	fsl_mc_io_unset_dpmcp(mc_io);
174
175	devm_iounmap(mc_io->dev, mc_io->portal_virt_addr);
176	devm_release_mem_region(mc_io->dev,
177	mc_io->portal_phys_addr,
178	mc_io->portal_size);
179
180	mc_io->portal_virt_addr = NULL;
181	devm_kfree(mc_io->dev, mc_io);
182	}
183
184	/**
185	* fsl_mc_portal_allocate - Allocates an MC portal
186	*
187	* @mc_dev: MC device for which the MC portal is to be allocated
188	* @mc_io_flags: Flags for the fsl_mc_io object that wraps the allocated
189	* MC portal.
190	* @new_mc_io: Pointer to area where the pointer to the fsl_mc_io object
191	* that wraps the allocated MC portal is to be returned
192	*
193	* This function allocates an MC portal from the device's parent DPRC,
194	* from the corresponding MC bus' pool of MC portals and wraps
195	* it in a new fsl_mc_io object. If 'mc_dev' is a DPRC itself, the
196	* portal is allocated from its own MC bus.
197	*/
198	int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev,
199	u16 mc_io_flags,
200	struct fsl_mc_io **new_mc_io)
201	{
202	struct fsl_mc_device *mc_bus_dev;
203	struct fsl_mc_bus *mc_bus;
204	phys_addr_t mc_portal_phys_addr;
205	size_t mc_portal_size;
206	struct fsl_mc_device *dpmcp_dev;
207	int error = -EINVAL;
208	struct fsl_mc_resource *resource = NULL;
209	struct fsl_mc_io *mc_io = NULL;
210
211	if (mc_dev->flags & FSL_MC_IS_DPRC) {
212	mc_bus_dev = mc_dev;
213	} else {
214	if (WARN_ON(!dev_is_fsl_mc(mc_dev->dev.parent)))
215	return error;
216
217	mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
218	}
219
220	mc_bus = to_fsl_mc_bus(mc_bus_dev);
221	*new_mc_io = NULL;
222	error = fsl_mc_resource_allocate(mc_bus, FSL_MC_POOL_DPMCP, &resource);
223	if (error < 0)
224	return error;
225
226	error = -EINVAL;
227	dpmcp_dev = resource->data;
228	if (WARN_ON(!dpmcp_dev))
229	goto error_cleanup_resource;
230
231	if (dpmcp_dev->obj_desc.ver_major < DPMCP_MIN_VER_MAJOR \|\|
232	(dpmcp_dev->obj_desc.ver_major == DPMCP_MIN_VER_MAJOR &&
233	dpmcp_dev->obj_desc.ver_minor < DPMCP_MIN_VER_MINOR)) {
234	dev_err(&dpmcp_dev->dev,
235	"ERROR: Version %d.%d of DPMCP not supported.\n",
236	dpmcp_dev->obj_desc.ver_major,
237	dpmcp_dev->obj_desc.ver_minor);
238	error = -ENOTSUPP;
239	goto error_cleanup_resource;
240	}
241
242	if (WARN_ON(dpmcp_dev->obj_desc.region_count == 0))
243	goto error_cleanup_resource;
244
245	mc_portal_phys_addr = dpmcp_dev->regions[0].start;
246	mc_portal_size = dpmcp_dev->regions[0].end -
247	dpmcp_dev->regions[0].start + 1;
248
249	if (WARN_ON(mc_portal_size != mc_bus_dev->mc_io->portal_size))
250	goto error_cleanup_resource;
251
252	error = fsl_create_mc_io(&mc_bus_dev->dev,
253	mc_portal_phys_addr,
254	mc_portal_size, dpmcp_dev,
255	mc_io_flags, &mc_io);
256	if (error < 0)
257	goto error_cleanup_resource;
258
259	*new_mc_io = mc_io;
260	return 0;
261
262	error_cleanup_resource:
263	fsl_mc_resource_free(resource);
264	return error;
265	}
266	EXPORT_SYMBOL_GPL(fsl_mc_portal_allocate);
267
268	/**
269	* fsl_mc_portal_free - Returns an MC portal to the pool of free MC portals
270	* of a given MC bus
271	*
272	* @mc_io: Pointer to the fsl_mc_io object that wraps the MC portal to free
273	*/
274	void fsl_mc_portal_free(struct fsl_mc_io *mc_io)
275	{
276	struct fsl_mc_device *dpmcp_dev;
277	struct fsl_mc_resource *resource;
278
279	/*
280	* Every mc_io obtained by calling fsl_mc_portal_allocate() is supposed
281	* to have a DPMCP object associated with.
282	*/
283	dpmcp_dev = mc_io->dpmcp_dev;
284	if (WARN_ON(!dpmcp_dev))
285	return;
286
287	resource = dpmcp_dev->resource;
288	if (WARN_ON(!resource \|\| resource->type != FSL_MC_POOL_DPMCP))
289	return;
290
291	if (WARN_ON(resource->data != dpmcp_dev))
292	return;
293
294	fsl_destroy_mc_io(mc_io);
295	fsl_mc_resource_free(resource);
296	}
297	EXPORT_SYMBOL_GPL(fsl_mc_portal_free);
298
299	/**
300	* fsl_mc_portal_reset - Resets the dpmcp object for a given fsl_mc_io object
301	*
302	* @mc_io: Pointer to the fsl_mc_io object that wraps the MC portal to free
303	*/
304	int fsl_mc_portal_reset(struct fsl_mc_io *mc_io)
305	{
306	int error;
307	struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;
308
309	if (WARN_ON(!dpmcp_dev))
310	return -EINVAL;
311
312	error = dpmcp_reset(mc_io, 0, dpmcp_dev->mc_handle);
313	if (error < 0) {
314	dev_err(&dpmcp_dev->dev, "dpmcp_reset() failed: %d\n", error);
315	return error;
316	}
317
318	return 0;
319	}
320	EXPORT_SYMBOL_GPL(fsl_mc_portal_reset);