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/device-id/fsl_mc.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_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 */ 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 * 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 */ 202 struct 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 219 struct 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 228 enum 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 252 static 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 270 static 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 278 struct mc_rsp_create { 279 __le32 object_id; 280 }; 281 282 struct mc_rsp_api_ver { 283 __le16 major_ver; 284 __le16 minor_ver; 285 }; 286 287 static 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 295 static 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 */ 334 struct 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 __counted_by_ptr(portal_size); 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 356 int 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 u32 fsl_mc_get_msi_id(struct device *dev); 361 #else 362 /* If fsl-mc bus is not present device cannot belong to fsl-mc bus */ 363 #define dev_is_fsl_mc(_dev) (0) 364 #define fsl_mc_get_msi_id(_dev) (0) 365 #endif 366 367 /* Macro to check if a device is a container device */ 368 #define fsl_mc_is_cont_dev(_dev) (to_fsl_mc_device(_dev)->flags & \ 369 FSL_MC_IS_DPRC) 370 371 /* Macro to get the container device of a MC device */ 372 #define fsl_mc_cont_dev(_dev) (fsl_mc_is_cont_dev(_dev) ? \ 373 (_dev) : (_dev)->parent) 374 375 /* 376 * module_fsl_mc_driver() - Helper macro for drivers that don't do 377 * anything special in module init/exit. This eliminates a lot of 378 * boilerplate. Each module may only use this macro once, and 379 * calling it replaces module_init() and module_exit() 380 */ 381 #define module_fsl_mc_driver(__fsl_mc_driver) \ 382 module_driver(__fsl_mc_driver, fsl_mc_driver_register, \ 383 fsl_mc_driver_unregister) 384 385 /* 386 * Macro to avoid include chaining to get THIS_MODULE 387 */ 388 #define fsl_mc_driver_register(drv) \ 389 __fsl_mc_driver_register(drv, THIS_MODULE) 390 391 int __must_check __fsl_mc_driver_register(struct fsl_mc_driver *fsl_mc_driver, 392 struct module *owner); 393 394 void fsl_mc_driver_unregister(struct fsl_mc_driver *driver); 395 396 /** 397 * struct fsl_mc_version 398 * @major: Major version number: incremented on API compatibility changes 399 * @minor: Minor version number: incremented on API additions (that are 400 * backward compatible); reset when major version is incremented 401 * @revision: Internal revision number: incremented on implementation changes 402 * and/or bug fixes that have no impact on API 403 */ 404 struct fsl_mc_version { 405 u32 major; 406 u32 minor; 407 u32 revision; 408 }; 409 410 struct fsl_mc_version *fsl_mc_get_version(void); 411 412 int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev, 413 u16 mc_io_flags, 414 struct fsl_mc_io **new_mc_io); 415 416 void fsl_mc_portal_free(struct fsl_mc_io *mc_io); 417 418 int __must_check fsl_mc_object_allocate(struct fsl_mc_device *mc_dev, 419 enum fsl_mc_pool_type pool_type, 420 struct fsl_mc_device **new_mc_adev); 421 422 void fsl_mc_object_free(struct fsl_mc_device *mc_adev); 423 424 int __must_check fsl_mc_allocate_irqs(struct fsl_mc_device *mc_dev); 425 426 void fsl_mc_free_irqs(struct fsl_mc_device *mc_dev); 427 428 struct fsl_mc_device *fsl_mc_get_endpoint(struct fsl_mc_device *mc_dev, 429 u16 if_id); 430 431 extern const struct bus_type fsl_mc_bus_type; 432 433 extern const struct device_type fsl_mc_bus_dprc_type; 434 extern const struct device_type fsl_mc_bus_dpni_type; 435 extern const struct device_type fsl_mc_bus_dpio_type; 436 extern const struct device_type fsl_mc_bus_dpsw_type; 437 extern const struct device_type fsl_mc_bus_dpbp_type; 438 extern const struct device_type fsl_mc_bus_dpcon_type; 439 extern const struct device_type fsl_mc_bus_dpmcp_type; 440 extern const struct device_type fsl_mc_bus_dpmac_type; 441 extern const struct device_type fsl_mc_bus_dprtc_type; 442 extern const struct device_type fsl_mc_bus_dpseci_type; 443 extern const struct device_type fsl_mc_bus_dpdmux_type; 444 extern const struct device_type fsl_mc_bus_dpdcei_type; 445 extern const struct device_type fsl_mc_bus_dpaiop_type; 446 extern const struct device_type fsl_mc_bus_dpci_type; 447 extern const struct device_type fsl_mc_bus_dpdmai_type; 448 449 static inline bool is_fsl_mc_bus_dprc(const struct fsl_mc_device *mc_dev) 450 { 451 return mc_dev->dev.type == &fsl_mc_bus_dprc_type; 452 } 453 454 static inline bool is_fsl_mc_bus_dpni(const struct fsl_mc_device *mc_dev) 455 { 456 return mc_dev->dev.type == &fsl_mc_bus_dpni_type; 457 } 458 459 static inline bool is_fsl_mc_bus_dpio(const struct fsl_mc_device *mc_dev) 460 { 461 return mc_dev->dev.type == &fsl_mc_bus_dpio_type; 462 } 463 464 static inline bool is_fsl_mc_bus_dpsw(const struct fsl_mc_device *mc_dev) 465 { 466 return mc_dev->dev.type == &fsl_mc_bus_dpsw_type; 467 } 468 469 static inline bool is_fsl_mc_bus_dpdmux(const struct fsl_mc_device *mc_dev) 470 { 471 return mc_dev->dev.type == &fsl_mc_bus_dpdmux_type; 472 } 473 474 static inline bool is_fsl_mc_bus_dpbp(const struct fsl_mc_device *mc_dev) 475 { 476 return mc_dev->dev.type == &fsl_mc_bus_dpbp_type; 477 } 478 479 static inline bool is_fsl_mc_bus_dpcon(const struct fsl_mc_device *mc_dev) 480 { 481 return mc_dev->dev.type == &fsl_mc_bus_dpcon_type; 482 } 483 484 static inline bool is_fsl_mc_bus_dpmcp(const struct fsl_mc_device *mc_dev) 485 { 486 return mc_dev->dev.type == &fsl_mc_bus_dpmcp_type; 487 } 488 489 static inline bool is_fsl_mc_bus_dpmac(const struct fsl_mc_device *mc_dev) 490 { 491 return mc_dev->dev.type == &fsl_mc_bus_dpmac_type; 492 } 493 494 static inline bool is_fsl_mc_bus_dprtc(const struct fsl_mc_device *mc_dev) 495 { 496 return mc_dev->dev.type == &fsl_mc_bus_dprtc_type; 497 } 498 499 static inline bool is_fsl_mc_bus_dpseci(const struct fsl_mc_device *mc_dev) 500 { 501 return mc_dev->dev.type == &fsl_mc_bus_dpseci_type; 502 } 503 504 static inline bool is_fsl_mc_bus_dpdcei(const struct fsl_mc_device *mc_dev) 505 { 506 return mc_dev->dev.type == &fsl_mc_bus_dpdcei_type; 507 } 508 509 static inline bool is_fsl_mc_bus_dpaiop(const struct fsl_mc_device *mc_dev) 510 { 511 return mc_dev->dev.type == &fsl_mc_bus_dpaiop_type; 512 } 513 514 static inline bool is_fsl_mc_bus_dpci(const struct fsl_mc_device *mc_dev) 515 { 516 return mc_dev->dev.type == &fsl_mc_bus_dpci_type; 517 } 518 519 static inline bool is_fsl_mc_bus_dpdmai(const struct fsl_mc_device *mc_dev) 520 { 521 return mc_dev->dev.type == &fsl_mc_bus_dpdmai_type; 522 } 523 524 #define DPRC_RESET_OPTION_NON_RECURSIVE 0x00000001 525 int dprc_reset_container(struct fsl_mc_io *mc_io, 526 u32 cmd_flags, 527 u16 token, 528 int child_container_id, 529 u32 options); 530 531 int dprc_scan_container(struct fsl_mc_device *mc_bus_dev, 532 bool alloc_interrupts); 533 534 void dprc_remove_devices(struct fsl_mc_device *mc_bus_dev, 535 struct fsl_mc_obj_desc *obj_desc_array, 536 int num_child_objects_in_mc); 537 538 int dprc_cleanup(struct fsl_mc_device *mc_dev); 539 540 int dprc_setup(struct fsl_mc_device *mc_dev); 541 542 /** 543 * Maximum number of total IRQs that can be pre-allocated for an MC bus' 544 * IRQ pool 545 */ 546 #define FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS 256 547 548 int fsl_mc_populate_irq_pool(struct fsl_mc_device *mc_bus_dev, 549 unsigned int irq_count); 550 551 void fsl_mc_cleanup_irq_pool(struct fsl_mc_device *mc_bus_dev); 552 553 /* 554 * Data Path Buffer Pool (DPBP) API 555 * Contains initialization APIs and runtime control APIs for DPBP 556 */ 557 558 int dpbp_open(struct fsl_mc_io *mc_io, 559 u32 cmd_flags, 560 int dpbp_id, 561 u16 *token); 562 563 int dpbp_close(struct fsl_mc_io *mc_io, 564 u32 cmd_flags, 565 u16 token); 566 567 int dpbp_enable(struct fsl_mc_io *mc_io, 568 u32 cmd_flags, 569 u16 token); 570 571 int dpbp_disable(struct fsl_mc_io *mc_io, 572 u32 cmd_flags, 573 u16 token); 574 575 int dpbp_reset(struct fsl_mc_io *mc_io, 576 u32 cmd_flags, 577 u16 token); 578 579 /** 580 * struct dpbp_attr - Structure representing DPBP attributes 581 * @id: DPBP object ID 582 * @bpid: Hardware buffer pool ID; should be used as an argument in 583 * acquire/release operations on buffers 584 */ 585 struct dpbp_attr { 586 int id; 587 u16 bpid; 588 }; 589 590 int dpbp_get_attributes(struct fsl_mc_io *mc_io, 591 u32 cmd_flags, 592 u16 token, 593 struct dpbp_attr *attr); 594 595 /* Data Path Concentrator (DPCON) API 596 * Contains initialization APIs and runtime control APIs for DPCON 597 */ 598 599 /** 600 * Use it to disable notifications; see dpcon_set_notification() 601 */ 602 #define DPCON_INVALID_DPIO_ID (int)(-1) 603 604 int dpcon_open(struct fsl_mc_io *mc_io, 605 u32 cmd_flags, 606 int dpcon_id, 607 u16 *token); 608 609 int dpcon_close(struct fsl_mc_io *mc_io, 610 u32 cmd_flags, 611 u16 token); 612 613 int dpcon_enable(struct fsl_mc_io *mc_io, 614 u32 cmd_flags, 615 u16 token); 616 617 int dpcon_disable(struct fsl_mc_io *mc_io, 618 u32 cmd_flags, 619 u16 token); 620 621 int dpcon_reset(struct fsl_mc_io *mc_io, 622 u32 cmd_flags, 623 u16 token); 624 625 int fsl_mc_obj_open(struct fsl_mc_io *mc_io, 626 u32 cmd_flags, 627 int obj_id, 628 char *obj_type, 629 u16 *token); 630 631 int fsl_mc_obj_close(struct fsl_mc_io *mc_io, 632 u32 cmd_flags, 633 u16 token); 634 635 int fsl_mc_obj_reset(struct fsl_mc_io *mc_io, 636 u32 cmd_flags, 637 u16 token); 638 639 /** 640 * struct dpcon_attr - Structure representing DPCON attributes 641 * @id: DPCON object ID 642 * @qbman_ch_id: Channel ID to be used by dequeue operation 643 * @num_priorities: Number of priorities for the DPCON channel (1-8) 644 */ 645 struct dpcon_attr { 646 int id; 647 u16 qbman_ch_id; 648 u8 num_priorities; 649 }; 650 651 int dpcon_get_attributes(struct fsl_mc_io *mc_io, 652 u32 cmd_flags, 653 u16 token, 654 struct dpcon_attr *attr); 655 656 /** 657 * struct dpcon_notification_cfg - Structure representing notification params 658 * @dpio_id: DPIO object ID; must be configured with a notification channel; 659 * to disable notifications set it to 'DPCON_INVALID_DPIO_ID'; 660 * @priority: Priority selection within the DPIO channel; valid values 661 * are 0-7, depending on the number of priorities in that channel 662 * @user_ctx: User context value provided with each CDAN message 663 */ 664 struct dpcon_notification_cfg { 665 int dpio_id; 666 u8 priority; 667 u64 user_ctx; 668 }; 669 670 int dpcon_set_notification(struct fsl_mc_io *mc_io, 671 u32 cmd_flags, 672 u16 token, 673 struct dpcon_notification_cfg *cfg); 674 675 #endif /* _FSL_MC_H_ */ 676