Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
20struct irq_domain;
21struct msi_domain_info;
22
23struct fsl_mc_device;
24struct 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 */
47struct 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_const(_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 */
67enum 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 */
92struct 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 */
107struct 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 */
143struct 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 *
182 * Generic device object for MC object devices that are "attached" to a
183 * MC bus.
184 *
185 * NOTES:
186 * - For a non-DPRC object its icid is the same as its parent DPRC's icid.
187 * - The SMMU notifier callback gets invoked after device_add() has been
188 * called for an MC object device, but before the device-specific probe
189 * callback gets called.
190 * - DP_OBJ_DPRC objects are the only MC objects that have built-in MC
191 * portals. For all other MC objects, their device drivers are responsible for
192 * allocating MC portals for them by calling fsl_mc_portal_allocate().
193 * - Some types of MC objects (e.g., DP_OBJ_DPBP, DP_OBJ_DPCON) are
194 * treated as resources that can be allocated/deallocated from the
195 * corresponding resource pool in the object's parent DPRC, using the
196 * fsl_mc_object_allocate()/fsl_mc_object_free() functions. These MC objects
197 * are known as "allocatable" objects. For them, the corresponding
198 * fsl_mc_device's 'resource' points to the associated resource object.
199 * For MC objects that are not allocatable (e.g., DP_OBJ_DPRC, DP_OBJ_DPNI),
200 * 'resource' is NULL.
201 */
202struct fsl_mc_device {
203 struct device dev;
204 u64 dma_mask;
205 u16 flags;
206 u32 icid;
207 u16 mc_handle;
208 struct fsl_mc_io *mc_io;
209 struct fsl_mc_obj_desc obj_desc;
210 struct resource *regions;
211 struct fsl_mc_device_irq **irqs;
212 struct fsl_mc_resource *resource;
213 struct device_link *consumer_link;
214};
215
216#define to_fsl_mc_device(_dev) \
217 container_of(_dev, struct fsl_mc_device, dev)
218
219struct mc_cmd_header {
220 u8 src_id;
221 u8 flags_hw;
222 u8 status;
223 u8 flags_sw;
224 __le16 token;
225 __le16 cmd_id;
226};
227
228enum mc_cmd_status {
229 MC_CMD_STATUS_OK = 0x0, /* Completed successfully */
230 MC_CMD_STATUS_READY = 0x1, /* Ready to be processed */
231 MC_CMD_STATUS_AUTH_ERR = 0x3, /* Authentication error */
232 MC_CMD_STATUS_NO_PRIVILEGE = 0x4, /* No privilege */
233 MC_CMD_STATUS_DMA_ERR = 0x5, /* DMA or I/O error */
234 MC_CMD_STATUS_CONFIG_ERR = 0x6, /* Configuration error */
235 MC_CMD_STATUS_TIMEOUT = 0x7, /* Operation timed out */
236 MC_CMD_STATUS_NO_RESOURCE = 0x8, /* No resources */
237 MC_CMD_STATUS_NO_MEMORY = 0x9, /* No memory available */
238 MC_CMD_STATUS_BUSY = 0xA, /* Device is busy */
239 MC_CMD_STATUS_UNSUPPORTED_OP = 0xB, /* Unsupported operation */
240 MC_CMD_STATUS_INVALID_STATE = 0xC /* Invalid state */
241};
242
243/*
244 * MC command flags
245 */
246
247/* High priority flag */
248#define MC_CMD_FLAG_PRI 0x80
249/* Command completion flag */
250#define MC_CMD_FLAG_INTR_DIS 0x01
251
252static inline __le64 mc_encode_cmd_header(u16 cmd_id,
253 u32 cmd_flags,
254 u16 token)
255{
256 __le64 header = 0;
257 struct mc_cmd_header *hdr = (struct mc_cmd_header *)&header;
258
259 hdr->cmd_id = cpu_to_le16(cmd_id);
260 hdr->token = cpu_to_le16(token);
261 hdr->status = MC_CMD_STATUS_READY;
262 if (cmd_flags & MC_CMD_FLAG_PRI)
263 hdr->flags_hw = MC_CMD_FLAG_PRI;
264 if (cmd_flags & MC_CMD_FLAG_INTR_DIS)
265 hdr->flags_sw = MC_CMD_FLAG_INTR_DIS;
266
267 return header;
268}
269
270static inline u16 mc_cmd_hdr_read_token(struct fsl_mc_command *cmd)
271{
272 struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header;
273 u16 token = le16_to_cpu(hdr->token);
274
275 return token;
276}
277
278struct mc_rsp_create {
279 __le32 object_id;
280};
281
282struct mc_rsp_api_ver {
283 __le16 major_ver;
284 __le16 minor_ver;
285};
286
287static inline u32 mc_cmd_read_object_id(struct fsl_mc_command *cmd)
288{
289 struct mc_rsp_create *rsp_params;
290
291 rsp_params = (struct mc_rsp_create *)cmd->params;
292 return le32_to_cpu(rsp_params->object_id);
293}
294
295static inline void mc_cmd_read_api_version(struct fsl_mc_command *cmd,
296 u16 *major_ver,
297 u16 *minor_ver)
298{
299 struct mc_rsp_api_ver *rsp_params;
300
301 rsp_params = (struct mc_rsp_api_ver *)cmd->params;
302 *major_ver = le16_to_cpu(rsp_params->major_ver);
303 *minor_ver = le16_to_cpu(rsp_params->minor_ver);
304}
305
306/**
307 * Bit masks for a MC I/O object (struct fsl_mc_io) flags
308 */
309#define FSL_MC_IO_ATOMIC_CONTEXT_PORTAL 0x0001
310
311/**
312 * struct fsl_mc_io - MC I/O object to be passed-in to mc_send_command()
313 * @dev: device associated with this Mc I/O object
314 * @flags: flags for mc_send_command()
315 * @portal_size: MC command portal size in bytes
316 * @portal_phys_addr: MC command portal physical address
317 * @portal_virt_addr: MC command portal virtual address
318 * @dpmcp_dev: pointer to the DPMCP device associated with the MC portal.
319 *
320 * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not
321 * set:
322 * @mutex: Mutex to serialize mc_send_command() calls that use the same MC
323 * portal, if the fsl_mc_io object was created with the
324 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag off. mc_send_command() calls for this
325 * fsl_mc_io object must be made only from non-atomic context.
326 *
327 * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is
328 * set:
329 * @spinlock: Spinlock to serialize mc_send_command() calls that use the same MC
330 * portal, if the fsl_mc_io object was created with the
331 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag on. mc_send_command() calls for this
332 * fsl_mc_io object can be made from atomic or non-atomic context.
333 */
334struct fsl_mc_io {
335 struct device *dev;
336 u16 flags;
337 u32 portal_size;
338 phys_addr_t portal_phys_addr;
339 void __iomem *portal_virt_addr;
340 struct fsl_mc_device *dpmcp_dev;
341 union {
342 /*
343 * This field is only meaningful if the
344 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not set
345 */
346 struct mutex mutex; /* serializes mc_send_command() */
347
348 /*
349 * This field is only meaningful if the
350 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is set
351 */
352 raw_spinlock_t spinlock; /* serializes mc_send_command() */
353 };
354};
355
356int mc_send_command(struct fsl_mc_io *mc_io, struct fsl_mc_command *cmd);
357
358#ifdef CONFIG_FSL_MC_BUS
359#define dev_is_fsl_mc(_dev) ((_dev)->bus == &fsl_mc_bus_type)
360#else
361/* If fsl-mc bus is not present device cannot belong to fsl-mc bus */
362#define dev_is_fsl_mc(_dev) (0)
363#endif
364
365/* Macro to check if a device is a container device */
366#define fsl_mc_is_cont_dev(_dev) (to_fsl_mc_device(_dev)->flags & \
367 FSL_MC_IS_DPRC)
368
369/* Macro to get the container device of a MC device */
370#define fsl_mc_cont_dev(_dev) (fsl_mc_is_cont_dev(_dev) ? \
371 (_dev) : (_dev)->parent)
372
373/*
374 * module_fsl_mc_driver() - Helper macro for drivers that don't do
375 * anything special in module init/exit. This eliminates a lot of
376 * boilerplate. Each module may only use this macro once, and
377 * calling it replaces module_init() and module_exit()
378 */
379#define module_fsl_mc_driver(__fsl_mc_driver) \
380 module_driver(__fsl_mc_driver, fsl_mc_driver_register, \
381 fsl_mc_driver_unregister)
382
383/*
384 * Macro to avoid include chaining to get THIS_MODULE
385 */
386#define fsl_mc_driver_register(drv) \
387 __fsl_mc_driver_register(drv, THIS_MODULE)
388
389int __must_check __fsl_mc_driver_register(struct fsl_mc_driver *fsl_mc_driver,
390 struct module *owner);
391
392void fsl_mc_driver_unregister(struct fsl_mc_driver *driver);
393
394/**
395 * struct fsl_mc_version
396 * @major: Major version number: incremented on API compatibility changes
397 * @minor: Minor version number: incremented on API additions (that are
398 * backward compatible); reset when major version is incremented
399 * @revision: Internal revision number: incremented on implementation changes
400 * and/or bug fixes that have no impact on API
401 */
402struct fsl_mc_version {
403 u32 major;
404 u32 minor;
405 u32 revision;
406};
407
408struct fsl_mc_version *fsl_mc_get_version(void);
409
410int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev,
411 u16 mc_io_flags,
412 struct fsl_mc_io **new_mc_io);
413
414void fsl_mc_portal_free(struct fsl_mc_io *mc_io);
415
416int __must_check fsl_mc_object_allocate(struct fsl_mc_device *mc_dev,
417 enum fsl_mc_pool_type pool_type,
418 struct fsl_mc_device **new_mc_adev);
419
420void fsl_mc_object_free(struct fsl_mc_device *mc_adev);
421
422struct irq_domain *fsl_mc_msi_create_irq_domain(struct fwnode_handle *fwnode,
423 struct msi_domain_info *info,
424 struct irq_domain *parent);
425
426int __must_check fsl_mc_allocate_irqs(struct fsl_mc_device *mc_dev);
427
428void fsl_mc_free_irqs(struct fsl_mc_device *mc_dev);
429
430struct fsl_mc_device *fsl_mc_get_endpoint(struct fsl_mc_device *mc_dev,
431 u16 if_id);
432
433extern const struct bus_type fsl_mc_bus_type;
434
435extern const struct device_type fsl_mc_bus_dprc_type;
436extern const struct device_type fsl_mc_bus_dpni_type;
437extern const struct device_type fsl_mc_bus_dpio_type;
438extern const struct device_type fsl_mc_bus_dpsw_type;
439extern const struct device_type fsl_mc_bus_dpbp_type;
440extern const struct device_type fsl_mc_bus_dpcon_type;
441extern const struct device_type fsl_mc_bus_dpmcp_type;
442extern const struct device_type fsl_mc_bus_dpmac_type;
443extern const struct device_type fsl_mc_bus_dprtc_type;
444extern const struct device_type fsl_mc_bus_dpseci_type;
445extern const struct device_type fsl_mc_bus_dpdmux_type;
446extern const struct device_type fsl_mc_bus_dpdcei_type;
447extern const struct device_type fsl_mc_bus_dpaiop_type;
448extern const struct device_type fsl_mc_bus_dpci_type;
449extern const struct device_type fsl_mc_bus_dpdmai_type;
450
451static inline bool is_fsl_mc_bus_dprc(const struct fsl_mc_device *mc_dev)
452{
453 return mc_dev->dev.type == &fsl_mc_bus_dprc_type;
454}
455
456static inline bool is_fsl_mc_bus_dpni(const struct fsl_mc_device *mc_dev)
457{
458 return mc_dev->dev.type == &fsl_mc_bus_dpni_type;
459}
460
461static inline bool is_fsl_mc_bus_dpio(const struct fsl_mc_device *mc_dev)
462{
463 return mc_dev->dev.type == &fsl_mc_bus_dpio_type;
464}
465
466static inline bool is_fsl_mc_bus_dpsw(const struct fsl_mc_device *mc_dev)
467{
468 return mc_dev->dev.type == &fsl_mc_bus_dpsw_type;
469}
470
471static inline bool is_fsl_mc_bus_dpdmux(const struct fsl_mc_device *mc_dev)
472{
473 return mc_dev->dev.type == &fsl_mc_bus_dpdmux_type;
474}
475
476static inline bool is_fsl_mc_bus_dpbp(const struct fsl_mc_device *mc_dev)
477{
478 return mc_dev->dev.type == &fsl_mc_bus_dpbp_type;
479}
480
481static inline bool is_fsl_mc_bus_dpcon(const struct fsl_mc_device *mc_dev)
482{
483 return mc_dev->dev.type == &fsl_mc_bus_dpcon_type;
484}
485
486static inline bool is_fsl_mc_bus_dpmcp(const struct fsl_mc_device *mc_dev)
487{
488 return mc_dev->dev.type == &fsl_mc_bus_dpmcp_type;
489}
490
491static inline bool is_fsl_mc_bus_dpmac(const struct fsl_mc_device *mc_dev)
492{
493 return mc_dev->dev.type == &fsl_mc_bus_dpmac_type;
494}
495
496static inline bool is_fsl_mc_bus_dprtc(const struct fsl_mc_device *mc_dev)
497{
498 return mc_dev->dev.type == &fsl_mc_bus_dprtc_type;
499}
500
501static inline bool is_fsl_mc_bus_dpseci(const struct fsl_mc_device *mc_dev)
502{
503 return mc_dev->dev.type == &fsl_mc_bus_dpseci_type;
504}
505
506static inline bool is_fsl_mc_bus_dpdcei(const struct fsl_mc_device *mc_dev)
507{
508 return mc_dev->dev.type == &fsl_mc_bus_dpdcei_type;
509}
510
511static inline bool is_fsl_mc_bus_dpaiop(const struct fsl_mc_device *mc_dev)
512{
513 return mc_dev->dev.type == &fsl_mc_bus_dpaiop_type;
514}
515
516static inline bool is_fsl_mc_bus_dpci(const struct fsl_mc_device *mc_dev)
517{
518 return mc_dev->dev.type == &fsl_mc_bus_dpci_type;
519}
520
521static inline bool is_fsl_mc_bus_dpdmai(const struct fsl_mc_device *mc_dev)
522{
523 return mc_dev->dev.type == &fsl_mc_bus_dpdmai_type;
524}
525
526#define DPRC_RESET_OPTION_NON_RECURSIVE 0x00000001
527int dprc_reset_container(struct fsl_mc_io *mc_io,
528 u32 cmd_flags,
529 u16 token,
530 int child_container_id,
531 u32 options);
532
533int dprc_scan_container(struct fsl_mc_device *mc_bus_dev,
534 bool alloc_interrupts);
535
536void dprc_remove_devices(struct fsl_mc_device *mc_bus_dev,
537 struct fsl_mc_obj_desc *obj_desc_array,
538 int num_child_objects_in_mc);
539
540int dprc_cleanup(struct fsl_mc_device *mc_dev);
541
542int dprc_setup(struct fsl_mc_device *mc_dev);
543
544/**
545 * Maximum number of total IRQs that can be pre-allocated for an MC bus'
546 * IRQ pool
547 */
548#define FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS 256
549
550int fsl_mc_populate_irq_pool(struct fsl_mc_device *mc_bus_dev,
551 unsigned int irq_count);
552
553void fsl_mc_cleanup_irq_pool(struct fsl_mc_device *mc_bus_dev);
554
555/*
556 * Data Path Buffer Pool (DPBP) API
557 * Contains initialization APIs and runtime control APIs for DPBP
558 */
559
560int dpbp_open(struct fsl_mc_io *mc_io,
561 u32 cmd_flags,
562 int dpbp_id,
563 u16 *token);
564
565int dpbp_close(struct fsl_mc_io *mc_io,
566 u32 cmd_flags,
567 u16 token);
568
569int dpbp_enable(struct fsl_mc_io *mc_io,
570 u32 cmd_flags,
571 u16 token);
572
573int dpbp_disable(struct fsl_mc_io *mc_io,
574 u32 cmd_flags,
575 u16 token);
576
577int dpbp_reset(struct fsl_mc_io *mc_io,
578 u32 cmd_flags,
579 u16 token);
580
581/**
582 * struct dpbp_attr - Structure representing DPBP attributes
583 * @id: DPBP object ID
584 * @bpid: Hardware buffer pool ID; should be used as an argument in
585 * acquire/release operations on buffers
586 */
587struct dpbp_attr {
588 int id;
589 u16 bpid;
590};
591
592int dpbp_get_attributes(struct fsl_mc_io *mc_io,
593 u32 cmd_flags,
594 u16 token,
595 struct dpbp_attr *attr);
596
597/* Data Path Concentrator (DPCON) API
598 * Contains initialization APIs and runtime control APIs for DPCON
599 */
600
601/**
602 * Use it to disable notifications; see dpcon_set_notification()
603 */
604#define DPCON_INVALID_DPIO_ID (int)(-1)
605
606int dpcon_open(struct fsl_mc_io *mc_io,
607 u32 cmd_flags,
608 int dpcon_id,
609 u16 *token);
610
611int dpcon_close(struct fsl_mc_io *mc_io,
612 u32 cmd_flags,
613 u16 token);
614
615int dpcon_enable(struct fsl_mc_io *mc_io,
616 u32 cmd_flags,
617 u16 token);
618
619int dpcon_disable(struct fsl_mc_io *mc_io,
620 u32 cmd_flags,
621 u16 token);
622
623int dpcon_reset(struct fsl_mc_io *mc_io,
624 u32 cmd_flags,
625 u16 token);
626
627int fsl_mc_obj_open(struct fsl_mc_io *mc_io,
628 u32 cmd_flags,
629 int obj_id,
630 char *obj_type,
631 u16 *token);
632
633int fsl_mc_obj_close(struct fsl_mc_io *mc_io,
634 u32 cmd_flags,
635 u16 token);
636
637int fsl_mc_obj_reset(struct fsl_mc_io *mc_io,
638 u32 cmd_flags,
639 u16 token);
640
641/**
642 * struct dpcon_attr - Structure representing DPCON attributes
643 * @id: DPCON object ID
644 * @qbman_ch_id: Channel ID to be used by dequeue operation
645 * @num_priorities: Number of priorities for the DPCON channel (1-8)
646 */
647struct dpcon_attr {
648 int id;
649 u16 qbman_ch_id;
650 u8 num_priorities;
651};
652
653int dpcon_get_attributes(struct fsl_mc_io *mc_io,
654 u32 cmd_flags,
655 u16 token,
656 struct dpcon_attr *attr);
657
658/**
659 * struct dpcon_notification_cfg - Structure representing notification params
660 * @dpio_id: DPIO object ID; must be configured with a notification channel;
661 * to disable notifications set it to 'DPCON_INVALID_DPIO_ID';
662 * @priority: Priority selection within the DPIO channel; valid values
663 * are 0-7, depending on the number of priorities in that channel
664 * @user_ctx: User context value provided with each CDAN message
665 */
666struct dpcon_notification_cfg {
667 int dpio_id;
668 u8 priority;
669 u64 user_ctx;
670};
671
672int dpcon_set_notification(struct fsl_mc_io *mc_io,
673 u32 cmd_flags,
674 u16 token,
675 struct dpcon_notification_cfg *cfg);
676
677#endif /* _FSL_MC_H_ */