1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Freescale Management Complex (MC) bus public interface
4  *
5  * Copyright (C) 2014-2016 Freescale Semiconductor, Inc.
6  * Copyright 2019-2020 NXP
7  * Author: German Rivera <German.Rivera@freescale.com>
8  *
9  */
10 #ifndef _FSL_MC_H_
11 #define _FSL_MC_H_
12 
13 #include <linux/device.h>
14 #include <linux/mod_devicetable.h>
15 #include <linux/interrupt.h>
16 #include <uapi/linux/fsl_mc.h>
17 
18 #define FSL_MC_VENDOR_FREESCALE	0x1957
19 
20 struct irq_domain;
21 struct msi_domain_info;
22 
23 struct fsl_mc_device;
24 struct fsl_mc_io;
25 
26 /**
27  * struct fsl_mc_driver - MC object device driver object
28  * @driver: Generic device driver
29  * @match_id_table: table of supported device matching Ids
30  * @probe: Function called when a device is added
31  * @remove: Function called when a device is removed
32  * @shutdown: Function called at shutdown time to quiesce the device
33  * @suspend: Function called when a device is stopped
34  * @resume: Function called when a device is resumed
35  * @driver_managed_dma: Device driver doesn't use kernel DMA API for DMA.
36  *		For most device drivers, no need to care about this flag
37  *		as long as all DMAs are handled through the kernel DMA API.
38  *		For some special ones, for example VFIO drivers, they know
39  *		how to manage the DMA themselves and set this flag so that
40  *		the IOMMU layer will allow them to setup and manage their
41  *		own I/O address space.
42  *
43  * Generic DPAA device driver object for device drivers that are registered
44  * with a DPRC bus. This structure is to be embedded in each device-specific
45  * driver structure.
46  */
47 struct fsl_mc_driver {
48 	struct device_driver driver;
49 	const struct fsl_mc_device_id *match_id_table;
50 	int (*probe)(struct fsl_mc_device *dev);
51 	void (*remove)(struct fsl_mc_device *dev);
52 	void (*shutdown)(struct fsl_mc_device *dev);
53 	int (*suspend)(struct fsl_mc_device *dev, pm_message_t state);
54 	int (*resume)(struct fsl_mc_device *dev);
55 	bool driver_managed_dma;
56 };
57 
58 #define to_fsl_mc_driver(_drv) \
59 	container_of(_drv, struct fsl_mc_driver, driver)
60 
61 /**
62  * enum fsl_mc_pool_type - Types of allocatable MC bus resources
63  *
64  * Entries in these enum are used as indices in the array of resource
65  * pools of an fsl_mc_bus object.
66  */
67 enum fsl_mc_pool_type {
68 	FSL_MC_POOL_DPMCP = 0x0,    /* corresponds to "dpmcp" in the MC */
69 	FSL_MC_POOL_DPBP,	    /* corresponds to "dpbp" in the MC */
70 	FSL_MC_POOL_DPCON,	    /* corresponds to "dpcon" in the MC */
71 	FSL_MC_POOL_IRQ,
72 
73 	/*
74 	 * NOTE: New resource pool types must be added before this entry
75 	 */
76 	FSL_MC_NUM_POOL_TYPES
77 };
78 
79 /**
80  * struct fsl_mc_resource - MC generic resource
81  * @type: type of resource
82  * @id: unique MC resource Id within the resources of the same type
83  * @data: pointer to resource-specific data if the resource is currently
84  * allocated, or NULL if the resource is not currently allocated.
85  * @parent_pool: pointer to the parent resource pool from which this
86  * resource is allocated from.
87  * @node: Node in the free list of the corresponding resource pool
88  *
89  * NOTE: This structure is to be embedded as a field of specific
90  * MC resource structures.
91  */
92 struct fsl_mc_resource {
93 	enum fsl_mc_pool_type type;
94 	s32 id;
95 	void *data;
96 	struct fsl_mc_resource_pool *parent_pool;
97 	struct list_head node;
98 };
99 
100 /**
101  * struct fsl_mc_device_irq - MC object device message-based interrupt
102  * @virq: Linux virtual interrupt number
103  * @mc_dev: MC object device that owns this interrupt
104  * @dev_irq_index: device-relative IRQ index
105  * @resource: MC generic resource associated with the interrupt
106  */
107 struct fsl_mc_device_irq {
108 	unsigned int virq;
109 	struct fsl_mc_device *mc_dev;
110 	u8 dev_irq_index;
111 	struct fsl_mc_resource resource;
112 };
113 
114 #define to_fsl_mc_irq(_mc_resource) \
115 	container_of(_mc_resource, struct fsl_mc_device_irq, resource)
116 
117 /* Opened state - Indicates that an object is open by at least one owner */
118 #define FSL_MC_OBJ_STATE_OPEN		0x00000001
119 /* Plugged state - Indicates that the object is plugged */
120 #define FSL_MC_OBJ_STATE_PLUGGED	0x00000002
121 
122 /**
123  * Shareability flag - Object flag indicating no memory shareability.
124  * the object generates memory accesses that are non coherent with other
125  * masters;
126  * user is responsible for proper memory handling through IOMMU configuration.
127  */
128 #define FSL_MC_OBJ_FLAG_NO_MEM_SHAREABILITY	0x0001
129 
130 /**
131  * struct fsl_mc_obj_desc - Object descriptor
132  * @type: Type of object: NULL terminated string
133  * @id: ID of logical object resource
134  * @vendor: Object vendor identifier
135  * @ver_major: Major version number
136  * @ver_minor:  Minor version number
137  * @irq_count: Number of interrupts supported by the object
138  * @region_count: Number of mappable regions supported by the object
139  * @state: Object state: combination of FSL_MC_OBJ_STATE_ states
140  * @label: Object label: NULL terminated string
141  * @flags: Object's flags
142  */
143 struct fsl_mc_obj_desc {
144 	char type[16];
145 	int id;
146 	u16 vendor;
147 	u16 ver_major;
148 	u16 ver_minor;
149 	u8 irq_count;
150 	u8 region_count;
151 	u32 state;
152 	char label[16];
153 	u16 flags;
154 };
155 
156 /**
157  * Bit masks for a MC object device (struct fsl_mc_device) flags
158  */
159 #define FSL_MC_IS_DPRC	0x0001
160 
161 /* Region flags */
162 /* Indicates that region can be mapped as cacheable */
163 #define FSL_MC_REGION_CACHEABLE	0x00000001
164 
165 /* Indicates that region can be mapped as shareable */
166 #define FSL_MC_REGION_SHAREABLE	0x00000002
167 
168 /**
169  * struct fsl_mc_device - MC object device object
170  * @dev: Linux driver model device object
171  * @dma_mask: Default DMA mask
172  * @flags: MC object device flags
173  * @icid: Isolation context ID for the device
174  * @mc_handle: MC handle for the corresponding MC object opened
175  * @mc_io: Pointer to MC IO object assigned to this device or
176  * NULL if none.
177  * @obj_desc: MC description of the DPAA device
178  * @regions: pointer to array of MMIO region entries
179  * @irqs: pointer to array of pointers to interrupts allocated to this device
180  * @resource: generic resource associated with this MC object device, if any.
181  * @driver_override: driver name to force a match; do not set directly,
182  *                   because core frees it; use driver_set_override() to
183  *                   set or clear it.
184  *
185  * Generic device object for MC object devices that are "attached" to a
186  * MC bus.
187  *
188  * NOTES:
189  * - For a non-DPRC object its icid is the same as its parent DPRC's icid.
190  * - The SMMU notifier callback gets invoked after device_add() has been
191  *   called for an MC object device, but before the device-specific probe
192  *   callback gets called.
193  * - DP_OBJ_DPRC objects are the only MC objects that have built-in MC
194  *   portals. For all other MC objects, their device drivers are responsible for
195  *   allocating MC portals for them by calling fsl_mc_portal_allocate().
196  * - Some types of MC objects (e.g., DP_OBJ_DPBP, DP_OBJ_DPCON) are
197  *   treated as resources that can be allocated/deallocated from the
198  *   corresponding resource pool in the object's parent DPRC, using the
199  *   fsl_mc_object_allocate()/fsl_mc_object_free() functions. These MC objects
200  *   are known as "allocatable" objects. For them, the corresponding
201  *   fsl_mc_device's 'resource' points to the associated resource object.
202  *   For MC objects that are not allocatable (e.g., DP_OBJ_DPRC, DP_OBJ_DPNI),
203  *   'resource' is NULL.
204  */
205 struct fsl_mc_device {
206 	struct device dev;
207 	u64 dma_mask;
208 	u16 flags;
209 	u32 icid;
210 	u16 mc_handle;
211 	struct fsl_mc_io *mc_io;
212 	struct fsl_mc_obj_desc obj_desc;
213 	struct resource *regions;
214 	struct fsl_mc_device_irq **irqs;
215 	struct fsl_mc_resource *resource;
216 	struct device_link *consumer_link;
217 	const char *driver_override;
218 };
219 
220 #define to_fsl_mc_device(_dev) \
221 	container_of(_dev, struct fsl_mc_device, dev)
222 
223 struct mc_cmd_header {
224 	u8 src_id;
225 	u8 flags_hw;
226 	u8 status;
227 	u8 flags_sw;
228 	__le16 token;
229 	__le16 cmd_id;
230 };
231 
232 enum mc_cmd_status {
233 	MC_CMD_STATUS_OK = 0x0, /* Completed successfully */
234 	MC_CMD_STATUS_READY = 0x1, /* Ready to be processed */
235 	MC_CMD_STATUS_AUTH_ERR = 0x3, /* Authentication error */
236 	MC_CMD_STATUS_NO_PRIVILEGE = 0x4, /* No privilege */
237 	MC_CMD_STATUS_DMA_ERR = 0x5, /* DMA or I/O error */
238 	MC_CMD_STATUS_CONFIG_ERR = 0x6, /* Configuration error */
239 	MC_CMD_STATUS_TIMEOUT = 0x7, /* Operation timed out */
240 	MC_CMD_STATUS_NO_RESOURCE = 0x8, /* No resources */
241 	MC_CMD_STATUS_NO_MEMORY = 0x9, /* No memory available */
242 	MC_CMD_STATUS_BUSY = 0xA, /* Device is busy */
243 	MC_CMD_STATUS_UNSUPPORTED_OP = 0xB, /* Unsupported operation */
244 	MC_CMD_STATUS_INVALID_STATE = 0xC /* Invalid state */
245 };
246 
247 /*
248  * MC command flags
249  */
250 
251 /* High priority flag */
252 #define MC_CMD_FLAG_PRI		0x80
253 /* Command completion flag */
254 #define MC_CMD_FLAG_INTR_DIS	0x01
255 
mc_encode_cmd_header(u16 cmd_id,u32 cmd_flags,u16 token)256 static inline __le64 mc_encode_cmd_header(u16 cmd_id,
257 					  u32 cmd_flags,
258 					  u16 token)
259 {
260 	__le64 header = 0;
261 	struct mc_cmd_header *hdr = (struct mc_cmd_header *)&header;
262 
263 	hdr->cmd_id = cpu_to_le16(cmd_id);
264 	hdr->token  = cpu_to_le16(token);
265 	hdr->status = MC_CMD_STATUS_READY;
266 	if (cmd_flags & MC_CMD_FLAG_PRI)
267 		hdr->flags_hw = MC_CMD_FLAG_PRI;
268 	if (cmd_flags & MC_CMD_FLAG_INTR_DIS)
269 		hdr->flags_sw = MC_CMD_FLAG_INTR_DIS;
270 
271 	return header;
272 }
273 
mc_cmd_hdr_read_token(struct fsl_mc_command * cmd)274 static inline u16 mc_cmd_hdr_read_token(struct fsl_mc_command *cmd)
275 {
276 	struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header;
277 	u16 token = le16_to_cpu(hdr->token);
278 
279 	return token;
280 }
281 
282 struct mc_rsp_create {
283 	__le32 object_id;
284 };
285 
286 struct mc_rsp_api_ver {
287 	__le16 major_ver;
288 	__le16 minor_ver;
289 };
290 
mc_cmd_read_object_id(struct fsl_mc_command * cmd)291 static inline u32 mc_cmd_read_object_id(struct fsl_mc_command *cmd)
292 {
293 	struct mc_rsp_create *rsp_params;
294 
295 	rsp_params = (struct mc_rsp_create *)cmd->params;
296 	return le32_to_cpu(rsp_params->object_id);
297 }
298 
mc_cmd_read_api_version(struct fsl_mc_command * cmd,u16 * major_ver,u16 * minor_ver)299 static inline void mc_cmd_read_api_version(struct fsl_mc_command *cmd,
300 					   u16 *major_ver,
301 					   u16 *minor_ver)
302 {
303 	struct mc_rsp_api_ver *rsp_params;
304 
305 	rsp_params = (struct mc_rsp_api_ver *)cmd->params;
306 	*major_ver = le16_to_cpu(rsp_params->major_ver);
307 	*minor_ver = le16_to_cpu(rsp_params->minor_ver);
308 }
309 
310 /**
311  * Bit masks for a MC I/O object (struct fsl_mc_io) flags
312  */
313 #define FSL_MC_IO_ATOMIC_CONTEXT_PORTAL	0x0001
314 
315 /**
316  * struct fsl_mc_io - MC I/O object to be passed-in to mc_send_command()
317  * @dev: device associated with this Mc I/O object
318  * @flags: flags for mc_send_command()
319  * @portal_size: MC command portal size in bytes
320  * @portal_phys_addr: MC command portal physical address
321  * @portal_virt_addr: MC command portal virtual address
322  * @dpmcp_dev: pointer to the DPMCP device associated with the MC portal.
323  *
324  * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not
325  * set:
326  * @mutex: Mutex to serialize mc_send_command() calls that use the same MC
327  * portal, if the fsl_mc_io object was created with the
328  * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag off. mc_send_command() calls for this
329  * fsl_mc_io object must be made only from non-atomic context.
330  *
331  * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is
332  * set:
333  * @spinlock: Spinlock to serialize mc_send_command() calls that use the same MC
334  * portal, if the fsl_mc_io object was created with the
335  * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag on. mc_send_command() calls for this
336  * fsl_mc_io object can be made from atomic or non-atomic context.
337  */
338 struct fsl_mc_io {
339 	struct device *dev;
340 	u16 flags;
341 	u32 portal_size;
342 	phys_addr_t portal_phys_addr;
343 	void __iomem *portal_virt_addr;
344 	struct fsl_mc_device *dpmcp_dev;
345 	union {
346 		/*
347 		 * This field is only meaningful if the
348 		 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not set
349 		 */
350 		struct mutex mutex; /* serializes mc_send_command() */
351 
352 		/*
353 		 * This field is only meaningful if the
354 		 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is set
355 		 */
356 		raw_spinlock_t spinlock; /* serializes mc_send_command() */
357 	};
358 };
359 
360 int mc_send_command(struct fsl_mc_io *mc_io, struct fsl_mc_command *cmd);
361 
362 #ifdef CONFIG_FSL_MC_BUS
363 #define dev_is_fsl_mc(_dev) ((_dev)->bus == &fsl_mc_bus_type)
364 #else
365 /* If fsl-mc bus is not present device cannot belong to fsl-mc bus */
366 #define dev_is_fsl_mc(_dev) (0)
367 #endif
368 
369 /* Macro to check if a device is a container device */
370 #define fsl_mc_is_cont_dev(_dev) (to_fsl_mc_device(_dev)->flags & \
371 	FSL_MC_IS_DPRC)
372 
373 /* Macro to get the container device of a MC device */
374 #define fsl_mc_cont_dev(_dev) (fsl_mc_is_cont_dev(_dev) ? \
375 	(_dev) : (_dev)->parent)
376 
377 /*
378  * module_fsl_mc_driver() - Helper macro for drivers that don't do
379  * anything special in module init/exit.  This eliminates a lot of
380  * boilerplate.  Each module may only use this macro once, and
381  * calling it replaces module_init() and module_exit()
382  */
383 #define module_fsl_mc_driver(__fsl_mc_driver) \
384 	module_driver(__fsl_mc_driver, fsl_mc_driver_register, \
385 		      fsl_mc_driver_unregister)
386 
387 /*
388  * Macro to avoid include chaining to get THIS_MODULE
389  */
390 #define fsl_mc_driver_register(drv) \
391 	__fsl_mc_driver_register(drv, THIS_MODULE)
392 
393 int __must_check __fsl_mc_driver_register(struct fsl_mc_driver *fsl_mc_driver,
394 					  struct module *owner);
395 
396 void fsl_mc_driver_unregister(struct fsl_mc_driver *driver);
397 
398 /**
399  * struct fsl_mc_version
400  * @major: Major version number: incremented on API compatibility changes
401  * @minor: Minor version number: incremented on API additions (that are
402  *		backward compatible); reset when major version is incremented
403  * @revision: Internal revision number: incremented on implementation changes
404  *		and/or bug fixes that have no impact on API
405  */
406 struct fsl_mc_version {
407 	u32 major;
408 	u32 minor;
409 	u32 revision;
410 };
411 
412 struct fsl_mc_version *fsl_mc_get_version(void);
413 
414 int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev,
415 					u16 mc_io_flags,
416 					struct fsl_mc_io **new_mc_io);
417 
418 void fsl_mc_portal_free(struct fsl_mc_io *mc_io);
419 
420 int fsl_mc_portal_reset(struct fsl_mc_io *mc_io);
421 
422 int __must_check fsl_mc_object_allocate(struct fsl_mc_device *mc_dev,
423 					enum fsl_mc_pool_type pool_type,
424 					struct fsl_mc_device **new_mc_adev);
425 
426 void fsl_mc_object_free(struct fsl_mc_device *mc_adev);
427 
428 struct irq_domain *fsl_mc_msi_create_irq_domain(struct fwnode_handle *fwnode,
429 						struct msi_domain_info *info,
430 						struct irq_domain *parent);
431 
432 int __must_check fsl_mc_allocate_irqs(struct fsl_mc_device *mc_dev);
433 
434 void fsl_mc_free_irqs(struct fsl_mc_device *mc_dev);
435 
436 struct fsl_mc_device *fsl_mc_get_endpoint(struct fsl_mc_device *mc_dev,
437 					  u16 if_id);
438 
439 extern struct bus_type fsl_mc_bus_type;
440 
441 extern struct device_type fsl_mc_bus_dprc_type;
442 extern struct device_type fsl_mc_bus_dpni_type;
443 extern struct device_type fsl_mc_bus_dpio_type;
444 extern struct device_type fsl_mc_bus_dpsw_type;
445 extern struct device_type fsl_mc_bus_dpbp_type;
446 extern struct device_type fsl_mc_bus_dpcon_type;
447 extern struct device_type fsl_mc_bus_dpmcp_type;
448 extern struct device_type fsl_mc_bus_dpmac_type;
449 extern struct device_type fsl_mc_bus_dprtc_type;
450 extern struct device_type fsl_mc_bus_dpseci_type;
451 extern struct device_type fsl_mc_bus_dpdmux_type;
452 extern struct device_type fsl_mc_bus_dpdcei_type;
453 extern struct device_type fsl_mc_bus_dpaiop_type;
454 extern struct device_type fsl_mc_bus_dpci_type;
455 extern struct device_type fsl_mc_bus_dpdmai_type;
456 
is_fsl_mc_bus_dprc(const struct fsl_mc_device * mc_dev)457 static inline bool is_fsl_mc_bus_dprc(const struct fsl_mc_device *mc_dev)
458 {
459 	return mc_dev->dev.type == &fsl_mc_bus_dprc_type;
460 }
461 
is_fsl_mc_bus_dpni(const struct fsl_mc_device * mc_dev)462 static inline bool is_fsl_mc_bus_dpni(const struct fsl_mc_device *mc_dev)
463 {
464 	return mc_dev->dev.type == &fsl_mc_bus_dpni_type;
465 }
466 
is_fsl_mc_bus_dpio(const struct fsl_mc_device * mc_dev)467 static inline bool is_fsl_mc_bus_dpio(const struct fsl_mc_device *mc_dev)
468 {
469 	return mc_dev->dev.type == &fsl_mc_bus_dpio_type;
470 }
471 
is_fsl_mc_bus_dpsw(const struct fsl_mc_device * mc_dev)472 static inline bool is_fsl_mc_bus_dpsw(const struct fsl_mc_device *mc_dev)
473 {
474 	return mc_dev->dev.type == &fsl_mc_bus_dpsw_type;
475 }
476 
is_fsl_mc_bus_dpdmux(const struct fsl_mc_device * mc_dev)477 static inline bool is_fsl_mc_bus_dpdmux(const struct fsl_mc_device *mc_dev)
478 {
479 	return mc_dev->dev.type == &fsl_mc_bus_dpdmux_type;
480 }
481 
is_fsl_mc_bus_dpbp(const struct fsl_mc_device * mc_dev)482 static inline bool is_fsl_mc_bus_dpbp(const struct fsl_mc_device *mc_dev)
483 {
484 	return mc_dev->dev.type == &fsl_mc_bus_dpbp_type;
485 }
486 
is_fsl_mc_bus_dpcon(const struct fsl_mc_device * mc_dev)487 static inline bool is_fsl_mc_bus_dpcon(const struct fsl_mc_device *mc_dev)
488 {
489 	return mc_dev->dev.type == &fsl_mc_bus_dpcon_type;
490 }
491 
is_fsl_mc_bus_dpmcp(const struct fsl_mc_device * mc_dev)492 static inline bool is_fsl_mc_bus_dpmcp(const struct fsl_mc_device *mc_dev)
493 {
494 	return mc_dev->dev.type == &fsl_mc_bus_dpmcp_type;
495 }
496 
is_fsl_mc_bus_dpmac(const struct fsl_mc_device * mc_dev)497 static inline bool is_fsl_mc_bus_dpmac(const struct fsl_mc_device *mc_dev)
498 {
499 	return mc_dev->dev.type == &fsl_mc_bus_dpmac_type;
500 }
501 
is_fsl_mc_bus_dprtc(const struct fsl_mc_device * mc_dev)502 static inline bool is_fsl_mc_bus_dprtc(const struct fsl_mc_device *mc_dev)
503 {
504 	return mc_dev->dev.type == &fsl_mc_bus_dprtc_type;
505 }
506 
is_fsl_mc_bus_dpseci(const struct fsl_mc_device * mc_dev)507 static inline bool is_fsl_mc_bus_dpseci(const struct fsl_mc_device *mc_dev)
508 {
509 	return mc_dev->dev.type == &fsl_mc_bus_dpseci_type;
510 }
511 
is_fsl_mc_bus_dpdcei(const struct fsl_mc_device * mc_dev)512 static inline bool is_fsl_mc_bus_dpdcei(const struct fsl_mc_device *mc_dev)
513 {
514 	return mc_dev->dev.type == &fsl_mc_bus_dpdcei_type;
515 }
516 
is_fsl_mc_bus_dpaiop(const struct fsl_mc_device * mc_dev)517 static inline bool is_fsl_mc_bus_dpaiop(const struct fsl_mc_device *mc_dev)
518 {
519 	return mc_dev->dev.type == &fsl_mc_bus_dpaiop_type;
520 }
521 
is_fsl_mc_bus_dpci(const struct fsl_mc_device * mc_dev)522 static inline bool is_fsl_mc_bus_dpci(const struct fsl_mc_device *mc_dev)
523 {
524 	return mc_dev->dev.type == &fsl_mc_bus_dpci_type;
525 }
526 
is_fsl_mc_bus_dpdmai(const struct fsl_mc_device * mc_dev)527 static inline bool is_fsl_mc_bus_dpdmai(const struct fsl_mc_device *mc_dev)
528 {
529 	return mc_dev->dev.type == &fsl_mc_bus_dpdmai_type;
530 }
531 
532 #define DPRC_RESET_OPTION_NON_RECURSIVE                0x00000001
533 int dprc_reset_container(struct fsl_mc_io *mc_io,
534 			 u32 cmd_flags,
535 			 u16 token,
536 			 int child_container_id,
537 			 u32 options);
538 
539 int dprc_scan_container(struct fsl_mc_device *mc_bus_dev,
540 			bool alloc_interrupts);
541 
542 void dprc_remove_devices(struct fsl_mc_device *mc_bus_dev,
543 			 struct fsl_mc_obj_desc *obj_desc_array,
544 			 int num_child_objects_in_mc);
545 
546 int dprc_cleanup(struct fsl_mc_device *mc_dev);
547 
548 int dprc_setup(struct fsl_mc_device *mc_dev);
549 
550 /**
551  * Maximum number of total IRQs that can be pre-allocated for an MC bus'
552  * IRQ pool
553  */
554 #define FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS	256
555 
556 int fsl_mc_populate_irq_pool(struct fsl_mc_device *mc_bus_dev,
557 			     unsigned int irq_count);
558 
559 void fsl_mc_cleanup_irq_pool(struct fsl_mc_device *mc_bus_dev);
560 
561 /*
562  * Data Path Buffer Pool (DPBP) API
563  * Contains initialization APIs and runtime control APIs for DPBP
564  */
565 
566 int dpbp_open(struct fsl_mc_io *mc_io,
567 	      u32 cmd_flags,
568 	      int dpbp_id,
569 	      u16 *token);
570 
571 int dpbp_close(struct fsl_mc_io *mc_io,
572 	       u32 cmd_flags,
573 	       u16 token);
574 
575 int dpbp_enable(struct fsl_mc_io *mc_io,
576 		u32 cmd_flags,
577 		u16 token);
578 
579 int dpbp_disable(struct fsl_mc_io *mc_io,
580 		 u32 cmd_flags,
581 		 u16 token);
582 
583 int dpbp_reset(struct fsl_mc_io *mc_io,
584 	       u32 cmd_flags,
585 	       u16 token);
586 
587 /**
588  * struct dpbp_attr - Structure representing DPBP attributes
589  * @id:		DPBP object ID
590  * @bpid:	Hardware buffer pool ID; should be used as an argument in
591  *		acquire/release operations on buffers
592  */
593 struct dpbp_attr {
594 	int id;
595 	u16 bpid;
596 };
597 
598 int dpbp_get_attributes(struct fsl_mc_io *mc_io,
599 			u32 cmd_flags,
600 			u16 token,
601 			struct dpbp_attr *attr);
602 
603 /* Data Path Concentrator (DPCON) API
604  * Contains initialization APIs and runtime control APIs for DPCON
605  */
606 
607 /**
608  * Use it to disable notifications; see dpcon_set_notification()
609  */
610 #define DPCON_INVALID_DPIO_ID		(int)(-1)
611 
612 int dpcon_open(struct fsl_mc_io *mc_io,
613 	       u32 cmd_flags,
614 	       int dpcon_id,
615 	       u16 *token);
616 
617 int dpcon_close(struct fsl_mc_io *mc_io,
618 		u32 cmd_flags,
619 		u16 token);
620 
621 int dpcon_enable(struct fsl_mc_io *mc_io,
622 		 u32 cmd_flags,
623 		 u16 token);
624 
625 int dpcon_disable(struct fsl_mc_io *mc_io,
626 		  u32 cmd_flags,
627 		  u16 token);
628 
629 int dpcon_reset(struct fsl_mc_io *mc_io,
630 		u32 cmd_flags,
631 		u16 token);
632 
633 int fsl_mc_obj_open(struct fsl_mc_io *mc_io,
634 		    u32 cmd_flags,
635 		    int obj_id,
636 		    char *obj_type,
637 		    u16 *token);
638 
639 int fsl_mc_obj_close(struct fsl_mc_io *mc_io,
640 		     u32 cmd_flags,
641 		     u16 token);
642 
643 int fsl_mc_obj_reset(struct fsl_mc_io *mc_io,
644 		     u32 cmd_flags,
645 		     u16 token);
646 
647 /**
648  * struct dpcon_attr - Structure representing DPCON attributes
649  * @id: DPCON object ID
650  * @qbman_ch_id: Channel ID to be used by dequeue operation
651  * @num_priorities: Number of priorities for the DPCON channel (1-8)
652  */
653 struct dpcon_attr {
654 	int id;
655 	u16 qbman_ch_id;
656 	u8 num_priorities;
657 };
658 
659 int dpcon_get_attributes(struct fsl_mc_io *mc_io,
660 			 u32 cmd_flags,
661 			 u16 token,
662 			 struct dpcon_attr *attr);
663 
664 /**
665  * struct dpcon_notification_cfg - Structure representing notification params
666  * @dpio_id:	DPIO object ID; must be configured with a notification channel;
667  *	to disable notifications set it to 'DPCON_INVALID_DPIO_ID';
668  * @priority:	Priority selection within the DPIO channel; valid values
669  *		are 0-7, depending on the number of priorities in that channel
670  * @user_ctx:	User context value provided with each CDAN message
671  */
672 struct dpcon_notification_cfg {
673 	int dpio_id;
674 	u8 priority;
675 	u64 user_ctx;
676 };
677 
678 int dpcon_set_notification(struct fsl_mc_io *mc_io,
679 			   u32 cmd_flags,
680 			   u16 token,
681 			   struct dpcon_notification_cfg *cfg);
682 
683 #endif /* _FSL_MC_H_ */
684