1 /* Copyright 2013-2015 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 #ifndef _FSL_DPRC_H 33 #define _FSL_DPRC_H 34 35 /* Data Path Resource Container API 36 * Contains DPRC API for managing and querying DPAA resources 37 */ 38 39 struct fsl_mc_io; 40 41 /** 42 * Set this value as the icid value in dprc_cfg structure when creating a 43 * container, in case the ICID is not selected by the user and should be 44 * allocated by the DPRC from the pool of ICIDs. 45 */ 46 #define DPRC_GET_ICID_FROM_POOL (uint16_t)(~(0)) 47 48 /** 49 * Set this value as the portal_id value in dprc_cfg structure when creating a 50 * container, in case the portal ID is not specifically selected by the 51 * user and should be allocated by the DPRC from the pool of portal ids. 52 */ 53 #define DPRC_GET_PORTAL_ID_FROM_POOL (int)(~(0)) 54 55 /** 56 * dprc_open() - Open DPRC object for use 57 * @mc_io: Pointer to MC portal's I/O object 58 * @container_id: Container ID to open 59 * @token: Returned token of DPRC object 60 * 61 * Return: '0' on Success; Error code otherwise. 62 * 63 * @warning Required before any operation on the object. 64 */ 65 int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token); 66 67 /** 68 * dprc_close() - Close the control session of the object 69 * @mc_io: Pointer to MC portal's I/O object 70 * @token: Token of DPRC object 71 * 72 * After this function is called, no further operations are 73 * allowed on the object without opening a new control session. 74 * 75 * Return: '0' on Success; Error code otherwise. 76 */ 77 int dprc_close(struct fsl_mc_io *mc_io, uint16_t token); 78 79 /** 80 * Container general options 81 * 82 * These options may be selected at container creation by the container creator 83 * and can be retrieved using dprc_get_attributes() 84 */ 85 86 /* Spawn Policy Option allowed - Indicates that the new container is allowed 87 * to spawn and have its own child containers. 88 */ 89 #define DPRC_CFG_OPT_SPAWN_ALLOWED 0x00000001 90 91 /* General Container allocation policy - Indicates that the new container is 92 * allowed to allocate requested resources from its parent container; if not 93 * set, the container is only allowed to use resources in its own pools; Note 94 * that this is a container's global policy, but the parent container may 95 * override it and set specific quota per resource type. 96 */ 97 #define DPRC_CFG_OPT_ALLOC_ALLOWED 0x00000002 98 99 /* Object initialization allowed - software context associated with this 100 * container is allowed to invoke object initialization operations. 101 */ 102 #define DPRC_CFG_OPT_OBJ_CREATE_ALLOWED 0x00000004 103 104 /* Topology change allowed - software context associated with this 105 * container is allowed to invoke topology operations, such as attach/detach 106 * of network objects. 107 */ 108 #define DPRC_CFG_OPT_TOPOLOGY_CHANGES_ALLOWED 0x00000008 109 110 /* IOMMU bypass - indicates whether objects of this container are permitted 111 * to bypass the IOMMU. 112 */ 113 #define DPRC_CFG_OPT_IOMMU_BYPASS 0x00000010 114 115 /* AIOP - Indicates that container belongs to AIOP. */ 116 #define DPRC_CFG_OPT_AIOP 0x00000020 117 118 /** 119 * struct dprc_cfg - Container configuration options 120 * @icid: Container's ICID; if set to 'DPRC_GET_ICID_FROM_POOL', a free 121 * ICID value is allocated by the DPRC 122 * @portal_id: Portal ID; if set to 'DPRC_GET_PORTAL_ID_FROM_POOL', a free 123 * portal ID is allocated by the DPRC 124 * @options: Combination of 'DPRC_CFG_OPT_<X>' options 125 */ 126 struct dprc_cfg { 127 uint16_t icid; 128 int portal_id; 129 uint64_t options; 130 }; 131 132 /** 133 * dprc_create_container() - Create child container 134 * @mc_io: Pointer to MC portal's I/O object 135 * @token: Token of DPRC object 136 * @cfg: Child container configuration 137 * @child_container_id: Returned child container ID 138 * @child_portal_paddr: Returned base physical address of the 139 * child portal 140 * 141 * Return: '0' on Success; Error code otherwise. 142 */ 143 int dprc_create_container(struct fsl_mc_io *mc_io, 144 uint16_t token, 145 struct dprc_cfg *cfg, 146 int *child_container_id, 147 uint64_t *child_portal_paddr); 148 149 /** 150 * dprc_destroy_container() - Destroy child container. 151 * @mc_io: Pointer to MC portal's I/O object 152 * @token: Token of DPRC object 153 * @child_container_id: ID of the container to destroy 154 * 155 * This function terminates the child container, so following this call the 156 * child container ID becomes invalid. 157 * 158 * Notes: 159 * - All resources and objects of the destroyed container are returned to the 160 * parent container or destroyed if were created be the destroyed container. 161 * - This function destroy all the child containers of the specified 162 * container prior to destroying the container itself. 163 * 164 * warning: Only the parent container is allowed to destroy a child policy 165 * Container 0 can't be destroyed 166 * 167 * Return: '0' on Success; Error code otherwise. 168 * 169 */ 170 int dprc_destroy_container(struct fsl_mc_io *mc_io, 171 uint16_t token, 172 int child_container_id); 173 174 /** 175 * dprc_reset_container - Reset child container. 176 * @mc_io: Pointer to MC portal's I/O object 177 * @token: Token of DPRC object 178 * @child_container_id: ID of the container to reset 179 * 180 * In case a software context crashes or becomes non-responsive, the parent 181 * may wish to reset its resources container before the software context is 182 * restarted. 183 * 184 * This routine informs all objects assigned to the child container that the 185 * container is being reset, so they may perform any cleanup operations that are 186 * needed. All objects handles that were owned by the child container shall be 187 * closed. 188 * 189 * Note that such request may be submitted even if the child software context 190 * has not crashed, but the resulting object cleanup operations will not be 191 * aware of that. 192 * 193 * Return: '0' on Success; Error code otherwise. 194 */ 195 int dprc_reset_container(struct fsl_mc_io *mc_io, 196 uint16_t token, 197 int child_container_id); 198 199 /* IRQ */ 200 201 /* Number of dprc's IRQs */ 202 #define DPRC_NUM_OF_IRQS 1 203 204 /* Object irq events */ 205 206 /* IRQ event - Indicates that a new object assigned to the container */ 207 #define DPRC_IRQ_EVENT_OBJ_ADDED 0x00000001 208 /* IRQ event - Indicates that an object was unassigned from the container */ 209 #define DPRC_IRQ_EVENT_OBJ_REMOVED 0x00000002 210 /* IRQ event - Indicates that resources assigned to the container */ 211 #define DPRC_IRQ_EVENT_RES_ADDED 0x00000004 212 /* IRQ event - Indicates that resources unassigned from the container */ 213 #define DPRC_IRQ_EVENT_RES_REMOVED 0x00000008 214 /* IRQ event - Indicates that one of the descendant containers that opened by 215 * this container is destroyed 216 */ 217 #define DPRC_IRQ_EVENT_CONTAINER_DESTROYED 0x00000010 218 219 /* IRQ event - Indicates that on one of the container's opened object is 220 * destroyed 221 */ 222 #define DPRC_IRQ_EVENT_OBJ_DESTROYED 0x00000020 223 224 /* Irq event - Indicates that object is created at the container */ 225 #define DPRC_IRQ_EVENT_OBJ_CREATED 0x00000040 226 227 /** 228 * dprc_set_irq() - Set IRQ information for the DPRC to trigger an interrupt. 229 * @mc_io: Pointer to MC portal's I/O object 230 * @token: Token of DPRC object 231 * @irq_index: Identifies the interrupt index to configure 232 * @irq_addr: Address that must be written to 233 * signal a message-based interrupt 234 * @irq_val: Value to write into irq_addr address 235 * @user_irq_id: Returned a user defined number associated with this IRQ 236 * 237 * Return: '0' on Success; Error code otherwise. 238 */ 239 int dprc_set_irq(struct fsl_mc_io *mc_io, 240 uint16_t token, 241 uint8_t irq_index, 242 uint64_t irq_addr, 243 uint32_t irq_val, 244 int user_irq_id); 245 246 /** 247 * dprc_get_irq() - Get IRQ information from the DPRC. 248 * @mc_io: Pointer to MC portal's I/O object 249 * @token: Token of DPRC object 250 * @irq_index: The interrupt index to configure 251 * @type: Returned interrupt type: 0 represents message interrupt 252 * type (both irq_addr and irq_val are valid) 253 * @irq_addr: Returned address that must be written to 254 * signal the message-based interrupt 255 * @irq_val: Value to write into irq_addr address 256 * @user_irq_id: A user defined number associated with this IRQ 257 * 258 * Return: '0' on Success; Error code otherwise. 259 */ 260 int dprc_get_irq(struct fsl_mc_io *mc_io, 261 uint16_t token, 262 uint8_t irq_index, 263 int *type, 264 uint64_t *irq_addr, 265 uint32_t *irq_val, 266 int *user_irq_id); 267 268 /** 269 * dprc_set_irq_enable() - Set overall interrupt state. 270 * @mc_io: Pointer to MC portal's I/O object 271 * @token: Token of DPRC object 272 * @irq_index: The interrupt index to configure 273 * @en: Interrupt state - enable = 1, disable = 0 274 * 275 * Allows GPP software to control when interrupts are generated. 276 * Each interrupt can have up to 32 causes. The enable/disable control's the 277 * overall interrupt state. if the interrupt is disabled no causes will cause 278 * an interrupt. 279 * 280 * Return: '0' on Success; Error code otherwise. 281 */ 282 int dprc_set_irq_enable(struct fsl_mc_io *mc_io, 283 uint16_t token, 284 uint8_t irq_index, 285 uint8_t en); 286 287 /** 288 * dprc_get_irq_enable() - Get overall interrupt state. 289 * @mc_io: Pointer to MC portal's I/O object 290 * @token: Token of DPRC object 291 * @irq_index: The interrupt index to configure 292 * @en: Returned interrupt state - enable = 1, disable = 0 293 * 294 * Return: '0' on Success; Error code otherwise. 295 */ 296 int dprc_get_irq_enable(struct fsl_mc_io *mc_io, 297 uint16_t token, 298 uint8_t irq_index, 299 uint8_t *en); 300 301 /** 302 * dprc_set_irq_mask() - Set interrupt mask. 303 * @mc_io: Pointer to MC portal's I/O object 304 * @token: Token of DPRC object 305 * @irq_index: The interrupt index to configure 306 * @mask: event mask to trigger interrupt; 307 * each bit: 308 * 0 = ignore event 309 * 1 = consider event for asserting irq 310 * 311 * Every interrupt can have up to 32 causes and the interrupt model supports 312 * masking/unmasking each cause independently 313 * 314 * Return: '0' on Success; Error code otherwise. 315 */ 316 int dprc_set_irq_mask(struct fsl_mc_io *mc_io, 317 uint16_t token, 318 uint8_t irq_index, 319 uint32_t mask); 320 321 /** 322 * dprc_get_irq_mask() - Get interrupt mask. 323 * @mc_io: Pointer to MC portal's I/O object 324 * @token: Token of DPRC object 325 * @irq_index: The interrupt index to configure 326 * @mask: Returned event mask to trigger interrupt 327 * 328 * Every interrupt can have up to 32 causes and the interrupt model supports 329 * masking/unmasking each cause independently 330 * 331 * Return: '0' on Success; Error code otherwise. 332 */ 333 int dprc_get_irq_mask(struct fsl_mc_io *mc_io, 334 uint16_t token, 335 uint8_t irq_index, 336 uint32_t *mask); 337 338 /** 339 * dprc_get_irq_status() - Get the current status of any pending interrupts. 340 * @mc_io: Pointer to MC portal's I/O object 341 * @token: Token of DPRC object 342 * @irq_index: The interrupt index to configure 343 * @status: Returned interrupts status - one bit per cause: 344 * 0 = no interrupt pending 345 * 1 = interrupt pending 346 * 347 * Return: '0' on Success; Error code otherwise. 348 */ 349 int dprc_get_irq_status(struct fsl_mc_io *mc_io, 350 uint16_t token, 351 uint8_t irq_index, 352 uint32_t *status); 353 354 /** 355 * dprc_clear_irq_status() - Clear a pending interrupt's status 356 * @mc_io: Pointer to MC portal's I/O object 357 * @token: Token of DPRC object 358 * @irq_index: The interrupt index to configure 359 * @status: bits to clear (W1C) - one bit per cause: 360 * 0 = don't change 361 * 1 = clear status bit 362 * 363 * Return: '0' on Success; Error code otherwise. 364 */ 365 int dprc_clear_irq_status(struct fsl_mc_io *mc_io, 366 uint16_t token, 367 uint8_t irq_index, 368 uint32_t status); 369 370 /** 371 * struct dprc_attributes - Container attributes 372 * @container_id: Container's ID 373 * @icid: Container's ICID 374 * @portal_id: Container's portal ID 375 * @options: Container's options as set at container's creation 376 * @version: DPRC version 377 */ 378 struct dprc_attributes { 379 int container_id; 380 uint16_t icid; 381 int portal_id; 382 uint64_t options; 383 /** 384 * struct version - DPRC version 385 * @major: DPRC major version 386 * @minor: DPRC minor version 387 */ 388 struct { 389 uint16_t major; 390 uint16_t minor; 391 } version; 392 }; 393 394 /** 395 * dprc_get_attributes() - Obtains container attributes 396 * @mc_io: Pointer to MC portal's I/O object 397 * @token: Token of DPRC object 398 * @attributes Returned container attributes 399 * 400 * Return: '0' on Success; Error code otherwise. 401 */ 402 int dprc_get_attributes(struct fsl_mc_io *mc_io, 403 uint16_t token, 404 struct dprc_attributes *attributes); 405 406 /** 407 * dprc_set_res_quota() - Set allocation policy for a specific resource/object 408 * type in a child container 409 * @mc_io: Pointer to MC portal's I/O object 410 * @token: Token of DPRC object 411 * @child_container_id: ID of the child container 412 * @type: Resource/object type 413 * @quota: Sets the maximum number of resources of the selected type 414 * that the child container is allowed to allocate from its parent; 415 * when quota is set to -1, the policy is the same as container's 416 * general policy. 417 * 418 * Allocation policy determines whether or not a container may allocate 419 * resources from its parent. Each container has a 'global' allocation policy 420 * that is set when the container is created. 421 * 422 * This function sets allocation policy for a specific resource type. 423 * The default policy for all resource types matches the container's 'global' 424 * allocation policy. 425 * 426 * Return: '0' on Success; Error code otherwise. 427 * 428 * @warning Only the parent container is allowed to change a child policy. 429 */ 430 int dprc_set_res_quota(struct fsl_mc_io *mc_io, 431 uint16_t token, 432 int child_container_id, 433 char *type, 434 uint16_t quota); 435 436 /** 437 * dprc_get_res_quota() - Gets the allocation policy of a specific 438 * resource/object type in a child container 439 * @mc_io: Pointer to MC portal's I/O object 440 * @token: Token of DPRC object 441 * @child_container_id; ID of the child container 442 * @type: resource/object type 443 * @quota: Returnes the maximum number of resources of the selected type 444 * that the child container is allowed to allocate from the parent; 445 * when quota is set to -1, the policy is the same as container's 446 * general policy. 447 * 448 * Return: '0' on Success; Error code otherwise. 449 */ 450 int dprc_get_res_quota(struct fsl_mc_io *mc_io, 451 uint16_t token, 452 int child_container_id, 453 char *type, 454 uint16_t *quota); 455 456 /* Resource request options */ 457 458 /* Explicit resource ID request - The requested objects/resources 459 * are explicit and sequential (in case of resources). 460 * The base ID is given at res_req at base_align field 461 */ 462 #define DPRC_RES_REQ_OPT_EXPLICIT 0x00000001 463 464 /* Aligned resources request - Relevant only for resources 465 * request (and not objects). Indicates that resources base ID should be 466 * sequential and aligned to the value given at dprc_res_req base_align field 467 */ 468 #define DPRC_RES_REQ_OPT_ALIGNED 0x00000002 469 470 /* Plugged Flag - Relevant only for object assignment request. 471 * Indicates that after all objects assigned. An interrupt will be invoked at 472 * the relevant GPP. The assigned object will be marked as plugged. 473 * plugged objects can't be assigned from their container 474 */ 475 #define DPRC_RES_REQ_OPT_PLUGGED 0x00000004 476 477 /** 478 * struct dprc_res_req - Resource request descriptor, to be used in assignment 479 * or un-assignment of resources and objects. 480 * @type: Resource/object type: Represent as a NULL terminated string. 481 * This string may received by using dprc_get_pool() to get resource 482 * type and dprc_get_obj() to get object type; 483 * Note: it is not possible to assign/un-assign DPRC objects 484 * @num: Number of resources 485 * @options: Request options: combination of DPRC_RES_REQ_OPT_ options 486 * @id_base_align: In case of explicit assignment (DPRC_RES_REQ_OPT_EXPLICIT 487 * is set at option), this field represents the required base ID 488 * for resource allocation; In case of aligned assignment 489 * (DPRC_RES_REQ_OPT_ALIGNED is set at option), this field 490 * indicates the required alignment for the resource ID(s) - 491 * use 0 if there is no alignment or explicit ID requirements 492 */ 493 struct dprc_res_req { 494 char type[16]; 495 uint32_t num; 496 uint32_t options; 497 int id_base_align; 498 }; 499 500 /** 501 * dprc_assign() - Assigns objects or resource to a child container. 502 * @mc_io: Pointer to MC portal's I/O object 503 * @token: Token of DPRC object 504 * @container_id: ID of the child container 505 * @res_req: Describes the type and amount of resources to 506 * assign to the given container 507 * 508 * Assignment is usually done by a parent (this DPRC) to one of its child 509 * containers. 510 * 511 * According to the DPRC allocation policy, the assigned resources may be taken 512 * (allocated) from the container's ancestors, if not enough resources are 513 * available in the container itself. 514 * 515 * The type of assignment depends on the dprc_res_req options, as follows: 516 * - DPRC_RES_REQ_OPT_EXPLICIT: indicates that assigned resources should have 517 * the explicit base ID specified at the id_base_align field of res_req. 518 * - DPRC_RES_REQ_OPT_ALIGNED: indicates that the assigned resources should be 519 * aligned to the value given at id_base_align field of res_req. 520 * - DPRC_RES_REQ_OPT_PLUGGED: Relevant only for object assignment, 521 * and indicates that the object must be set to the plugged state. 522 * 523 * A container may use this function with its own ID in order to change a 524 * object state to plugged or unplugged. 525 * 526 * If IRQ information has been set in the child DPRC, it will signal an 527 * interrupt following every change in its object assignment. 528 * 529 * Return: '0' on Success; Error code otherwise. 530 */ 531 int dprc_assign(struct fsl_mc_io *mc_io, 532 uint16_t token, 533 int container_id, 534 struct dprc_res_req *res_req); 535 536 /** 537 * dprc_unassign() - Un-assigns objects or resources from a child container 538 * and moves them into this (parent) DPRC. 539 * @mc_io: Pointer to MC portal's I/O object 540 * @token: Token of DPRC object 541 * @child_container_id: ID of the child container 542 * @res_req: Describes the type and amount of resources to un-assign from 543 * the child container 544 * 545 * Un-assignment of objects can succeed only if the object is not in the 546 * plugged or opened state. 547 * 548 * Return: '0' on Success; Error code otherwise. 549 */ 550 int dprc_unassign(struct fsl_mc_io *mc_io, 551 uint16_t token, 552 int child_container_id, 553 struct dprc_res_req *res_req); 554 555 /** 556 * dprc_get_pool_count() - Get the number of dprc's pools 557 * @mc_io: Pointer to MC portal's I/O object 558 * @token: Token of DPRC object 559 * @pool_count: Returned number of resource pools in the dprc 560 * 561 * Return: '0' on Success; Error code otherwise. 562 */ 563 int dprc_get_pool_count(struct fsl_mc_io *mc_io, 564 uint16_t token, 565 int *pool_count); 566 567 /** 568 * dprc_get_pool() - Get the type (string) of a certain dprc's pool 569 * @mc_io: Pointer to MC portal's I/O object 570 * @token: Token of DPRC object 571 * @pool_index; Index of the pool to be queried (< pool_count) 572 * @type: The type of the pool 573 * 574 * The pool types retrieved one by one by incrementing 575 * pool_index up to (not including) the value of pool_count returned 576 * from dprc_get_pool_count(). dprc_get_pool_count() must 577 * be called prior to dprc_get_pool(). 578 * 579 * Return: '0' on Success; Error code otherwise. 580 */ 581 int dprc_get_pool(struct fsl_mc_io *mc_io, 582 uint16_t token, 583 int pool_index, 584 char *type); 585 586 /** 587 * dprc_get_obj_count() - Obtains the number of objects in the DPRC 588 * @mc_io: Pointer to MC portal's I/O object 589 * @token: Token of DPRC object 590 * @obj_count: Number of objects assigned to the DPRC 591 * 592 * Return: '0' on Success; Error code otherwise. 593 */ 594 int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count); 595 596 /* Objects Attributes Flags */ 597 598 /* Opened state - Indicates that an object is open by at least one owner */ 599 #define DPRC_OBJ_STATE_OPEN 0x00000001 600 /* Plugged state - Indicates that the object is plugged */ 601 #define DPRC_OBJ_STATE_PLUGGED 0x00000002 602 603 /** 604 * struct dprc_obj_desc - Object descriptor, returned from dprc_get_obj() 605 * @type: Type of object: NULL terminated string 606 * @id: ID of logical object resource 607 * @vendor: Object vendor identifier 608 * @ver_major: Major version number 609 * @ver_minor: Minor version number 610 * @irq_count: Number of interrupts supported by the object 611 * @region_count: Number of mappable regions supported by the object 612 * @state: Object state: combination of DPRC_OBJ_STATE_ states 613 */ 614 struct dprc_obj_desc { 615 char type[16]; 616 int id; 617 uint16_t vendor; 618 uint16_t ver_major; 619 uint16_t ver_minor; 620 uint8_t irq_count; 621 uint8_t region_count; 622 uint32_t state; 623 }; 624 625 /** 626 * dprc_get_obj() - Get general information on an object 627 * @mc_io: Pointer to MC portal's I/O object 628 * @token: Token of DPRC object 629 * @obj_index: Index of the object to be queried (< obj_count) 630 * @obj_desc: Returns the requested object descriptor 631 * 632 * The object descriptors are retrieved one by one by incrementing 633 * obj_index up to (not including) the value of obj_count returned 634 * from dprc_get_obj_count(). dprc_get_obj_count() must 635 * be called prior to dprc_get_obj(). 636 * 637 * Return: '0' on Success; Error code otherwise. 638 */ 639 int dprc_get_obj(struct fsl_mc_io *mc_io, 640 uint16_t token, 641 int obj_index, 642 struct dprc_obj_desc *obj_desc); 643 644 /** 645 * dprc_get_res_count() - Obtains the number of free resources that are assigned 646 * to this container, by pool type 647 * @mc_io: Pointer to MC portal's I/O object 648 * @token: Token of DPRC object 649 * @type: pool type 650 * @res_count: Returned number of free resources of the given 651 * resource type that are assigned to this DPRC 652 * 653 * Return: '0' on Success; Error code otherwise. 654 */ 655 int dprc_get_res_count(struct fsl_mc_io *mc_io, 656 uint16_t token, 657 char *type, 658 int *res_count); 659 660 /** 661 * enum dprc_iter_status - Iteration status 662 * @DPRC_ITER_STATUS_FIRST: Perform first iteration 663 * @DPRC_ITER_STATUS_MORE: Indicates more/next iteration is needed 664 * @DPRC_ITER_STATUS_LAST: Indicates last iteration 665 */ 666 enum dprc_iter_status { 667 DPRC_ITER_STATUS_FIRST = 0, 668 DPRC_ITER_STATUS_MORE = 1, 669 DPRC_ITER_STATUS_LAST = 2 670 }; 671 672 /** 673 * struct dprc_res_ids_range_desc - Resource ID range descriptor 674 * @base_id: Base resource ID of this range 675 * @last_id: Last resource ID of this range 676 * @iter_status: Iteration status - should be set to DPRC_ITER_STATUS_FIRST at 677 * first iteration; while the returned marker is DPRC_ITER_STATUS_MORE, 678 * additional iterations are needed, until the returned marker is 679 * DPRC_ITER_STATUS_LAST 680 */ 681 struct dprc_res_ids_range_desc { 682 int base_id; 683 int last_id; 684 enum dprc_iter_status iter_status; 685 }; 686 687 /** 688 * dprc_get_res_ids() - Obtains IDs of free resources in the container 689 * @mc_io: Pointer to MC portal's I/O object 690 * @token: Token of DPRC object 691 * @type: pool type 692 * @range_desc: range descriptor 693 * 694 * Return: '0' on Success; Error code otherwise. 695 */ 696 int dprc_get_res_ids(struct fsl_mc_io *mc_io, 697 uint16_t token, 698 char *type, 699 struct dprc_res_ids_range_desc *range_desc); 700 701 /** 702 * dprc_get_portal_paddr() - Get the physical address of MC portals 703 * @mc_io: Pointer to MC portal's I/O object 704 * @token: Token of DPRC object 705 * @portal_id: MC portal ID 706 * @portal_addr: The physical address of the MC portal ID 707 * 708 * Return: '0' on Success; Error code otherwise. 709 */ 710 int dprc_get_portal_paddr(struct fsl_mc_io *mc_io, 711 uint16_t token, 712 int portal_id, 713 uint64_t *portal_addr); 714 715 /** 716 * struct dprc_region_desc - Mappable region descriptor 717 * @base_paddr: Region base physical address 718 * @size: Region size (in bytes) 719 */ 720 struct dprc_region_desc { 721 uint64_t base_paddr; 722 uint32_t size; 723 }; 724 725 /** 726 * dprc_get_obj_region() - Get region information for a specified object. 727 * @mc_io: Pointer to MC portal's I/O object 728 * @token: Token of DPRC object 729 * @obj_type; Object type as returned in dprc_get_obj() 730 * @obj_id: Unique object instance as returned in dprc_get_obj() 731 * @region_index: The specific region to query 732 * @region_desc: Returns the requested region descriptor 733 * 734 * Return: '0' on Success; Error code otherwise. 735 */ 736 int dprc_get_obj_region(struct fsl_mc_io *mc_io, 737 uint16_t token, 738 char *obj_type, 739 int obj_id, 740 uint8_t region_index, 741 struct dprc_region_desc *region_desc); 742 743 /** 744 * struct dprc_endpoint - Endpoint description for link connect/disconnect 745 * operations 746 * @type: Endpoint object type: NULL terminated string 747 * @id: Endpoint object ID 748 * @interface_id: Interface ID; should be set for endpoints with multiple 749 * interfaces ("dpsw", "dpdmux"); for others, always set to 0 750 */ 751 struct dprc_endpoint { 752 char type[16]; 753 int id; 754 int interface_id; 755 }; 756 757 /** 758 * dprc_connect() - Connect two endpoints to create a network link between them 759 * @mc_io: Pointer to MC portal's I/O object 760 * @token: Token of DPRC object 761 * @endpoint1: Endpoint 1 configuration parameters 762 * @endpoint2: Endpoint 2 configuration parameters 763 * 764 * Return: '0' on Success; Error code otherwise. 765 */ 766 int dprc_connect(struct fsl_mc_io *mc_io, 767 uint16_t token, 768 const struct dprc_endpoint *endpoint1, 769 const struct dprc_endpoint *endpoint2); 770 771 /** 772 * dprc_disconnect() - Disconnect one endpoint to remove its network connection 773 * @mc_io: Pointer to MC portal's I/O object 774 * @token: Token of DPRC object 775 * @endpoint: Endpoint configuration parameters 776 * 777 * Return: '0' on Success; Error code otherwise. 778 */ 779 int dprc_disconnect(struct fsl_mc_io *mc_io, 780 uint16_t token, 781 const struct dprc_endpoint *endpoint); 782 783 /** 784 * dprc_get_connection() - Get connected endpoint and link status if connection 785 * exists. 786 * @mc_io Pointer to MC portal's I/O object 787 * @token Token of DPRC object 788 * @endpoint1 Endpoint 1 configuration parameters 789 * @endpoint2 Returned endpoint 2 configuration parameters 790 * @state: Returned link state: 1 - link is up, 0 - link is down 791 * 792 * Return: '0' on Success; -ENAVAIL if connection does not exist. 793 */ 794 int dprc_get_connection(struct fsl_mc_io *mc_io, 795 uint16_t token, 796 const struct dprc_endpoint *endpoint1, 797 struct dprc_endpoint *endpoint2, 798 int *state); 799 800 #endif /* _FSL_DPRC_H */ 801 802