include/linux/fsl/mc.h

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