LCOV - code coverage report
Current view: top level - include/linux - irqdomain.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 10 25 40.0 %
Date: 2022-04-01 14:58:12 Functions: 0 0 -
Branches: 5 30 16.7 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * irq_domain - IRQ translation domains
       4                 :            :  *
       5                 :            :  * Translation infrastructure between hw and linux irq numbers.  This is
       6                 :            :  * helpful for interrupt controllers to implement mapping between hardware
       7                 :            :  * irq numbers and the Linux irq number space.
       8                 :            :  *
       9                 :            :  * irq_domains also have hooks for translating device tree or other
      10                 :            :  * firmware interrupt representations into a hardware irq number that
      11                 :            :  * can be mapped back to a Linux irq number without any extra platform
      12                 :            :  * support code.
      13                 :            :  *
      14                 :            :  * Interrupt controller "domain" data structure. This could be defined as a
      15                 :            :  * irq domain controller. That is, it handles the mapping between hardware
      16                 :            :  * and virtual interrupt numbers for a given interrupt domain. The domain
      17                 :            :  * structure is generally created by the PIC code for a given PIC instance
      18                 :            :  * (though a domain can cover more than one PIC if they have a flat number
      19                 :            :  * model). It's the domain callbacks that are responsible for setting the
      20                 :            :  * irq_chip on a given irq_desc after it's been mapped.
      21                 :            :  *
      22                 :            :  * The host code and data structures use a fwnode_handle pointer to
      23                 :            :  * identify the domain. In some cases, and in order to preserve source
      24                 :            :  * code compatibility, this fwnode pointer is "upgraded" to a DT
      25                 :            :  * device_node. For those firmware infrastructures that do not provide
      26                 :            :  * a unique identifier for an interrupt controller, the irq_domain
      27                 :            :  * code offers a fwnode allocator.
      28                 :            :  */
      29                 :            : 
      30                 :            : #ifndef _LINUX_IRQDOMAIN_H
      31                 :            : #define _LINUX_IRQDOMAIN_H
      32                 :            : 
      33                 :            : #include <linux/types.h>
      34                 :            : #include <linux/irqhandler.h>
      35                 :            : #include <linux/of.h>
      36                 :            : #include <linux/mutex.h>
      37                 :            : #include <linux/radix-tree.h>
      38                 :            : 
      39                 :            : struct device_node;
      40                 :            : struct irq_domain;
      41                 :            : struct of_device_id;
      42                 :            : struct irq_chip;
      43                 :            : struct irq_data;
      44                 :            : struct cpumask;
      45                 :            : struct seq_file;
      46                 :            : struct irq_affinity_desc;
      47                 :            : 
      48                 :            : /* Number of irqs reserved for a legacy isa controller */
      49                 :            : #define NUM_ISA_INTERRUPTS      16
      50                 :            : 
      51                 :            : #define IRQ_DOMAIN_IRQ_SPEC_PARAMS 16
      52                 :            : 
      53                 :            : /**
      54                 :            :  * struct irq_fwspec - generic IRQ specifier structure
      55                 :            :  *
      56                 :            :  * @fwnode:             Pointer to a firmware-specific descriptor
      57                 :            :  * @param_count:        Number of device-specific parameters
      58                 :            :  * @param:              Device-specific parameters
      59                 :            :  *
      60                 :            :  * This structure, directly modeled after of_phandle_args, is used to
      61                 :            :  * pass a device-specific description of an interrupt.
      62                 :            :  */
      63                 :            : struct irq_fwspec {
      64                 :            :         struct fwnode_handle *fwnode;
      65                 :            :         int param_count;
      66                 :            :         u32 param[IRQ_DOMAIN_IRQ_SPEC_PARAMS];
      67                 :            : };
      68                 :            : 
      69                 :            : /*
      70                 :            :  * Should several domains have the same device node, but serve
      71                 :            :  * different purposes (for example one domain is for PCI/MSI, and the
      72                 :            :  * other for wired IRQs), they can be distinguished using a
      73                 :            :  * bus-specific token. Most domains are expected to only carry
      74                 :            :  * DOMAIN_BUS_ANY.
      75                 :            :  */
      76                 :            : enum irq_domain_bus_token {
      77                 :            :         DOMAIN_BUS_ANY          = 0,
      78                 :            :         DOMAIN_BUS_WIRED,
      79                 :            :         DOMAIN_BUS_GENERIC_MSI,
      80                 :            :         DOMAIN_BUS_PCI_MSI,
      81                 :            :         DOMAIN_BUS_PLATFORM_MSI,
      82                 :            :         DOMAIN_BUS_NEXUS,
      83                 :            :         DOMAIN_BUS_IPI,
      84                 :            :         DOMAIN_BUS_FSL_MC_MSI,
      85                 :            :         DOMAIN_BUS_TI_SCI_INTA_MSI,
      86                 :            :         DOMAIN_BUS_WAKEUP,
      87                 :            : };
      88                 :            : 
      89                 :            : /**
      90                 :            :  * struct irq_domain_ops - Methods for irq_domain objects
      91                 :            :  * @match: Match an interrupt controller device node to a host, returns
      92                 :            :  *         1 on a match
      93                 :            :  * @map: Create or update a mapping between a virtual irq number and a hw
      94                 :            :  *       irq number. This is called only once for a given mapping.
      95                 :            :  * @unmap: Dispose of such a mapping
      96                 :            :  * @xlate: Given a device tree node and interrupt specifier, decode
      97                 :            :  *         the hardware irq number and linux irq type value.
      98                 :            :  *
      99                 :            :  * Functions below are provided by the driver and called whenever a new mapping
     100                 :            :  * is created or an old mapping is disposed. The driver can then proceed to
     101                 :            :  * whatever internal data structures management is required. It also needs
     102                 :            :  * to setup the irq_desc when returning from map().
     103                 :            :  */
     104                 :            : struct irq_domain_ops {
     105                 :            :         int (*match)(struct irq_domain *d, struct device_node *node,
     106                 :            :                      enum irq_domain_bus_token bus_token);
     107                 :            :         int (*select)(struct irq_domain *d, struct irq_fwspec *fwspec,
     108                 :            :                       enum irq_domain_bus_token bus_token);
     109                 :            :         int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
     110                 :            :         void (*unmap)(struct irq_domain *d, unsigned int virq);
     111                 :            :         int (*xlate)(struct irq_domain *d, struct device_node *node,
     112                 :            :                      const u32 *intspec, unsigned int intsize,
     113                 :            :                      unsigned long *out_hwirq, unsigned int *out_type);
     114                 :            : #ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
     115                 :            :         /* extended V2 interfaces to support hierarchy irq_domains */
     116                 :            :         int (*alloc)(struct irq_domain *d, unsigned int virq,
     117                 :            :                      unsigned int nr_irqs, void *arg);
     118                 :            :         void (*free)(struct irq_domain *d, unsigned int virq,
     119                 :            :                      unsigned int nr_irqs);
     120                 :            :         int (*activate)(struct irq_domain *d, struct irq_data *irqd, bool reserve);
     121                 :            :         void (*deactivate)(struct irq_domain *d, struct irq_data *irq_data);
     122                 :            :         int (*translate)(struct irq_domain *d, struct irq_fwspec *fwspec,
     123                 :            :                          unsigned long *out_hwirq, unsigned int *out_type);
     124                 :            : #endif
     125                 :            : #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
     126                 :            :         void (*debug_show)(struct seq_file *m, struct irq_domain *d,
     127                 :            :                            struct irq_data *irqd, int ind);
     128                 :            : #endif
     129                 :            : };
     130                 :            : 
     131                 :            : extern struct irq_domain_ops irq_generic_chip_ops;
     132                 :            : 
     133                 :            : struct irq_domain_chip_generic;
     134                 :            : 
     135                 :            : /**
     136                 :            :  * struct irq_domain - Hardware interrupt number translation object
     137                 :            :  * @link: Element in global irq_domain list.
     138                 :            :  * @name: Name of interrupt domain
     139                 :            :  * @ops: pointer to irq_domain methods
     140                 :            :  * @host_data: private data pointer for use by owner.  Not touched by irq_domain
     141                 :            :  *             core code.
     142                 :            :  * @flags: host per irq_domain flags
     143                 :            :  * @mapcount: The number of mapped interrupts
     144                 :            :  *
     145                 :            :  * Optional elements
     146                 :            :  * @fwnode: Pointer to firmware node associated with the irq_domain. Pretty easy
     147                 :            :  *          to swap it for the of_node via the irq_domain_get_of_node accessor
     148                 :            :  * @gc: Pointer to a list of generic chips. There is a helper function for
     149                 :            :  *      setting up one or more generic chips for interrupt controllers
     150                 :            :  *      drivers using the generic chip library which uses this pointer.
     151                 :            :  * @parent: Pointer to parent irq_domain to support hierarchy irq_domains
     152                 :            :  * @debugfs_file: dentry for the domain debugfs file
     153                 :            :  *
     154                 :            :  * Revmap data, used internally by irq_domain
     155                 :            :  * @revmap_direct_max_irq: The largest hwirq that can be set for controllers that
     156                 :            :  *                         support direct mapping
     157                 :            :  * @revmap_size: Size of the linear map table @linear_revmap[]
     158                 :            :  * @revmap_tree: Radix map tree for hwirqs that don't fit in the linear map
     159                 :            :  * @linear_revmap: Linear table of hwirq->virq reverse mappings
     160                 :            :  */
     161                 :            : struct irq_domain {
     162                 :            :         struct list_head link;
     163                 :            :         const char *name;
     164                 :            :         const struct irq_domain_ops *ops;
     165                 :            :         void *host_data;
     166                 :            :         unsigned int flags;
     167                 :            :         unsigned int mapcount;
     168                 :            : 
     169                 :            :         /* Optional data */
     170                 :            :         struct fwnode_handle *fwnode;
     171                 :            :         enum irq_domain_bus_token bus_token;
     172                 :            :         struct irq_domain_chip_generic *gc;
     173                 :            : #ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
     174                 :            :         struct irq_domain *parent;
     175                 :            : #endif
     176                 :            : #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
     177                 :            :         struct dentry           *debugfs_file;
     178                 :            : #endif
     179                 :            : 
     180                 :            :         /* reverse map data. The linear map gets appended to the irq_domain */
     181                 :            :         irq_hw_number_t hwirq_max;
     182                 :            :         unsigned int revmap_direct_max_irq;
     183                 :            :         unsigned int revmap_size;
     184                 :            :         struct radix_tree_root revmap_tree;
     185                 :            :         struct mutex revmap_tree_mutex;
     186                 :            :         unsigned int linear_revmap[];
     187                 :            : };
     188                 :            : 
     189                 :            : /* Irq domain flags */
     190                 :            : enum {
     191                 :            :         /* Irq domain is hierarchical */
     192                 :            :         IRQ_DOMAIN_FLAG_HIERARCHY       = (1 << 0),
     193                 :            : 
     194                 :            :         /* Irq domain name was allocated in __irq_domain_add() */
     195                 :            :         IRQ_DOMAIN_NAME_ALLOCATED       = (1 << 1),
     196                 :            : 
     197                 :            :         /* Irq domain is an IPI domain with virq per cpu */
     198                 :            :         IRQ_DOMAIN_FLAG_IPI_PER_CPU     = (1 << 2),
     199                 :            : 
     200                 :            :         /* Irq domain is an IPI domain with single virq */
     201                 :            :         IRQ_DOMAIN_FLAG_IPI_SINGLE      = (1 << 3),
     202                 :            : 
     203                 :            :         /* Irq domain implements MSIs */
     204                 :            :         IRQ_DOMAIN_FLAG_MSI             = (1 << 4),
     205                 :            : 
     206                 :            :         /* Irq domain implements MSI remapping */
     207                 :            :         IRQ_DOMAIN_FLAG_MSI_REMAP       = (1 << 5),
     208                 :            : 
     209                 :            :         /*
     210                 :            :          * Quirk to handle MSI implementations which do not provide
     211                 :            :          * masking. Currently known to affect x86, but partially
     212                 :            :          * handled in core code.
     213                 :            :          */
     214                 :            :         IRQ_DOMAIN_MSI_NOMASK_QUIRK     = (1 << 6),
     215                 :            : 
     216                 :            :         /*
     217                 :            :          * Flags starting from IRQ_DOMAIN_FLAG_NONCORE are reserved
     218                 :            :          * for implementation specific purposes and ignored by the
     219                 :            :          * core code.
     220                 :            :          */
     221                 :            :         IRQ_DOMAIN_FLAG_NONCORE         = (1 << 16),
     222                 :            : };
     223                 :            : 
     224                 :          0 : static inline struct device_node *irq_domain_get_of_node(struct irq_domain *d)
     225                 :            : {
     226         [ #  # ]:          0 :         return to_of_node(d->fwnode);
     227                 :            : }
     228                 :            : 
     229                 :            : #ifdef CONFIG_IRQ_DOMAIN
     230                 :            : struct fwnode_handle *__irq_domain_alloc_fwnode(unsigned int type, int id,
     231                 :            :                                                 const char *name, phys_addr_t *pa);
     232                 :            : 
     233                 :            : enum {
     234                 :            :         IRQCHIP_FWNODE_REAL,
     235                 :            :         IRQCHIP_FWNODE_NAMED,
     236                 :            :         IRQCHIP_FWNODE_NAMED_ID,
     237                 :            : };
     238                 :            : 
     239                 :            : static inline
     240                 :          6 : struct fwnode_handle *irq_domain_alloc_named_fwnode(const char *name)
     241                 :            : {
     242                 :          6 :         return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_NAMED, 0, name, NULL);
     243                 :            : }
     244                 :            : 
     245                 :            : static inline
     246                 :          6 : struct fwnode_handle *irq_domain_alloc_named_id_fwnode(const char *name, int id)
     247                 :            : {
     248                 :          6 :         return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_NAMED_ID, id, name,
     249                 :            :                                          NULL);
     250                 :            : }
     251                 :            : 
     252                 :            : static inline struct fwnode_handle *irq_domain_alloc_fwnode(phys_addr_t *pa)
     253                 :            : {
     254                 :            :         return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_REAL, 0, NULL, pa);
     255                 :            : }
     256                 :            : 
     257                 :            : void irq_domain_free_fwnode(struct fwnode_handle *fwnode);
     258                 :            : struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
     259                 :            :                                     irq_hw_number_t hwirq_max, int direct_max,
     260                 :            :                                     const struct irq_domain_ops *ops,
     261                 :            :                                     void *host_data);
     262                 :            : struct irq_domain *irq_domain_add_simple(struct device_node *of_node,
     263                 :            :                                          unsigned int size,
     264                 :            :                                          unsigned int first_irq,
     265                 :            :                                          const struct irq_domain_ops *ops,
     266                 :            :                                          void *host_data);
     267                 :            : struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
     268                 :            :                                          unsigned int size,
     269                 :            :                                          unsigned int first_irq,
     270                 :            :                                          irq_hw_number_t first_hwirq,
     271                 :            :                                          const struct irq_domain_ops *ops,
     272                 :            :                                          void *host_data);
     273                 :            : extern struct irq_domain *irq_find_matching_fwspec(struct irq_fwspec *fwspec,
     274                 :            :                                                    enum irq_domain_bus_token bus_token);
     275                 :            : extern bool irq_domain_check_msi_remap(void);
     276                 :            : extern void irq_set_default_host(struct irq_domain *host);
     277                 :            : extern struct irq_domain *irq_get_default_host(void);
     278                 :            : extern int irq_domain_alloc_descs(int virq, unsigned int nr_irqs,
     279                 :            :                                   irq_hw_number_t hwirq, int node,
     280                 :            :                                   const struct irq_affinity_desc *affinity);
     281                 :            : 
     282                 :          0 : static inline struct fwnode_handle *of_node_to_fwnode(struct device_node *node)
     283                 :            : {
     284   [ #  #  #  # ]:          0 :         return node ? &node->fwnode : NULL;
     285                 :            : }
     286                 :            : 
     287                 :            : extern const struct fwnode_operations irqchip_fwnode_ops;
     288                 :            : 
     289                 :         24 : static inline bool is_fwnode_irqchip(struct fwnode_handle *fwnode)
     290                 :            : {
     291   [ -  +  +  -  :         24 :         return fwnode && fwnode->ops == &irqchip_fwnode_ops;
          +  -  -  +  -  
                      + ]
     292                 :            : }
     293                 :            : 
     294                 :            : extern void irq_domain_update_bus_token(struct irq_domain *domain,
     295                 :            :                                         enum irq_domain_bus_token bus_token);
     296                 :            : 
     297                 :            : static inline
     298                 :          0 : struct irq_domain *irq_find_matching_fwnode(struct fwnode_handle *fwnode,
     299                 :            :                                             enum irq_domain_bus_token bus_token)
     300                 :            : {
     301                 :          0 :         struct irq_fwspec fwspec = {
     302                 :            :                 .fwnode = fwnode,
     303                 :            :         };
     304                 :            : 
     305                 :          0 :         return irq_find_matching_fwspec(&fwspec, bus_token);
     306                 :            : }
     307                 :            : 
     308                 :            : static inline struct irq_domain *irq_find_matching_host(struct device_node *node,
     309                 :            :                                                         enum irq_domain_bus_token bus_token)
     310                 :            : {
     311                 :            :         return irq_find_matching_fwnode(of_node_to_fwnode(node), bus_token);
     312                 :            : }
     313                 :            : 
     314                 :            : static inline struct irq_domain *irq_find_host(struct device_node *node)
     315                 :            : {
     316                 :            :         struct irq_domain *d;
     317                 :            : 
     318                 :            :         d = irq_find_matching_host(node, DOMAIN_BUS_WIRED);
     319                 :            :         if (!d)
     320                 :            :                 d = irq_find_matching_host(node, DOMAIN_BUS_ANY);
     321                 :            : 
     322                 :            :         return d;
     323                 :            : }
     324                 :            : 
     325                 :            : /**
     326                 :            :  * irq_domain_add_linear() - Allocate and register a linear revmap irq_domain.
     327                 :            :  * @of_node: pointer to interrupt controller's device tree node.
     328                 :            :  * @size: Number of interrupts in the domain.
     329                 :            :  * @ops: map/unmap domain callbacks
     330                 :            :  * @host_data: Controller private data pointer
     331                 :            :  */
     332                 :            : static inline struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
     333                 :            :                                          unsigned int size,
     334                 :            :                                          const struct irq_domain_ops *ops,
     335                 :            :                                          void *host_data)
     336                 :            : {
     337                 :            :         return __irq_domain_add(of_node_to_fwnode(of_node), size, size, 0, ops, host_data);
     338                 :            : }
     339                 :            : static inline struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
     340                 :            :                                          unsigned int max_irq,
     341                 :            :                                          const struct irq_domain_ops *ops,
     342                 :            :                                          void *host_data)
     343                 :            : {
     344                 :            :         return __irq_domain_add(of_node_to_fwnode(of_node), 0, max_irq, max_irq, ops, host_data);
     345                 :            : }
     346                 :            : static inline struct irq_domain *irq_domain_add_legacy_isa(
     347                 :            :                                 struct device_node *of_node,
     348                 :            :                                 const struct irq_domain_ops *ops,
     349                 :            :                                 void *host_data)
     350                 :            : {
     351                 :            :         return irq_domain_add_legacy(of_node, NUM_ISA_INTERRUPTS, 0, 0, ops,
     352                 :            :                                      host_data);
     353                 :            : }
     354                 :            : static inline struct irq_domain *irq_domain_add_tree(struct device_node *of_node,
     355                 :            :                                          const struct irq_domain_ops *ops,
     356                 :            :                                          void *host_data)
     357                 :            : {
     358                 :            :         return __irq_domain_add(of_node_to_fwnode(of_node), 0, ~0, 0, ops, host_data);
     359                 :            : }
     360                 :            : 
     361                 :          3 : static inline struct irq_domain *irq_domain_create_linear(struct fwnode_handle *fwnode,
     362                 :            :                                          unsigned int size,
     363                 :            :                                          const struct irq_domain_ops *ops,
     364                 :            :                                          void *host_data)
     365                 :            : {
     366                 :          3 :         return __irq_domain_add(fwnode, size, size, 0, ops, host_data);
     367                 :            : }
     368                 :            : 
     369                 :          9 : static inline struct irq_domain *irq_domain_create_tree(struct fwnode_handle *fwnode,
     370                 :            :                                          const struct irq_domain_ops *ops,
     371                 :            :                                          void *host_data)
     372                 :            : {
     373                 :          9 :         return __irq_domain_add(fwnode, 0, ~0, 0, ops, host_data);
     374                 :            : }
     375                 :            : 
     376                 :            : extern void irq_domain_remove(struct irq_domain *host);
     377                 :            : 
     378                 :            : extern int irq_domain_associate(struct irq_domain *domain, unsigned int irq,
     379                 :            :                                         irq_hw_number_t hwirq);
     380                 :            : extern void irq_domain_associate_many(struct irq_domain *domain,
     381                 :            :                                       unsigned int irq_base,
     382                 :            :                                       irq_hw_number_t hwirq_base, int count);
     383                 :            : extern void irq_domain_disassociate(struct irq_domain *domain,
     384                 :            :                                     unsigned int irq);
     385                 :            : 
     386                 :            : extern unsigned int irq_create_mapping(struct irq_domain *host,
     387                 :            :                                        irq_hw_number_t hwirq);
     388                 :            : extern unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec);
     389                 :            : extern void irq_dispose_mapping(unsigned int virq);
     390                 :            : 
     391                 :            : /**
     392                 :            :  * irq_linear_revmap() - Find a linux irq from a hw irq number.
     393                 :            :  * @domain: domain owning this hardware interrupt
     394                 :            :  * @hwirq: hardware irq number in that domain space
     395                 :            :  *
     396                 :            :  * This is a fast path alternative to irq_find_mapping() that can be
     397                 :            :  * called directly by irq controller code to save a handful of
     398                 :            :  * instructions. It is always safe to call, but won't find irqs mapped
     399                 :            :  * using the radix tree.
     400                 :            :  */
     401                 :            : static inline unsigned int irq_linear_revmap(struct irq_domain *domain,
     402                 :            :                                              irq_hw_number_t hwirq)
     403                 :            : {
     404                 :            :         return hwirq < domain->revmap_size ? domain->linear_revmap[hwirq] : 0;
     405                 :            : }
     406                 :            : extern unsigned int irq_find_mapping(struct irq_domain *host,
     407                 :            :                                      irq_hw_number_t hwirq);
     408                 :            : extern unsigned int irq_create_direct_mapping(struct irq_domain *host);
     409                 :            : extern int irq_create_strict_mappings(struct irq_domain *domain,
     410                 :            :                                       unsigned int irq_base,
     411                 :            :                                       irq_hw_number_t hwirq_base, int count);
     412                 :            : 
     413                 :            : static inline int irq_create_identity_mapping(struct irq_domain *host,
     414                 :            :                                               irq_hw_number_t hwirq)
     415                 :            : {
     416                 :            :         return irq_create_strict_mappings(host, hwirq, hwirq, 1);
     417                 :            : }
     418                 :            : 
     419                 :            : extern const struct irq_domain_ops irq_domain_simple_ops;
     420                 :            : 
     421                 :            : /* stock xlate functions */
     422                 :            : int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
     423                 :            :                         const u32 *intspec, unsigned int intsize,
     424                 :            :                         irq_hw_number_t *out_hwirq, unsigned int *out_type);
     425                 :            : int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
     426                 :            :                         const u32 *intspec, unsigned int intsize,
     427                 :            :                         irq_hw_number_t *out_hwirq, unsigned int *out_type);
     428                 :            : int irq_domain_xlate_onetwocell(struct irq_domain *d, struct device_node *ctrlr,
     429                 :            :                         const u32 *intspec, unsigned int intsize,
     430                 :            :                         irq_hw_number_t *out_hwirq, unsigned int *out_type);
     431                 :            : 
     432                 :            : int irq_domain_translate_twocell(struct irq_domain *d,
     433                 :            :                                  struct irq_fwspec *fwspec,
     434                 :            :                                  unsigned long *out_hwirq,
     435                 :            :                                  unsigned int *out_type);
     436                 :            : 
     437                 :            : int irq_domain_translate_onecell(struct irq_domain *d,
     438                 :            :                                  struct irq_fwspec *fwspec,
     439                 :            :                                  unsigned long *out_hwirq,
     440                 :            :                                  unsigned int *out_type);
     441                 :            : 
     442                 :            : /* IPI functions */
     443                 :            : int irq_reserve_ipi(struct irq_domain *domain, const struct cpumask *dest);
     444                 :            : int irq_destroy_ipi(unsigned int irq, const struct cpumask *dest);
     445                 :            : 
     446                 :            : /* V2 interfaces to support hierarchy IRQ domains. */
     447                 :            : extern struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
     448                 :            :                                                 unsigned int virq);
     449                 :            : extern void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
     450                 :            :                                 irq_hw_number_t hwirq, struct irq_chip *chip,
     451                 :            :                                 void *chip_data, irq_flow_handler_t handler,
     452                 :            :                                 void *handler_data, const char *handler_name);
     453                 :            : #ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
     454                 :            : extern struct irq_domain *irq_domain_create_hierarchy(struct irq_domain *parent,
     455                 :            :                         unsigned int flags, unsigned int size,
     456                 :            :                         struct fwnode_handle *fwnode,
     457                 :            :                         const struct irq_domain_ops *ops, void *host_data);
     458                 :            : 
     459                 :            : static inline struct irq_domain *irq_domain_add_hierarchy(struct irq_domain *parent,
     460                 :            :                                             unsigned int flags,
     461                 :            :                                             unsigned int size,
     462                 :            :                                             struct device_node *node,
     463                 :            :                                             const struct irq_domain_ops *ops,
     464                 :            :                                             void *host_data)
     465                 :            : {
     466                 :            :         return irq_domain_create_hierarchy(parent, flags, size,
     467                 :            :                                            of_node_to_fwnode(node),
     468                 :            :                                            ops, host_data);
     469                 :            : }
     470                 :            : 
     471                 :            : extern int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
     472                 :            :                                    unsigned int nr_irqs, int node, void *arg,
     473                 :            :                                    bool realloc,
     474                 :            :                                    const struct irq_affinity_desc *affinity);
     475                 :            : extern void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs);
     476                 :            : extern int irq_domain_activate_irq(struct irq_data *irq_data, bool early);
     477                 :            : extern void irq_domain_deactivate_irq(struct irq_data *irq_data);
     478                 :            : 
     479                 :          0 : static inline int irq_domain_alloc_irqs(struct irq_domain *domain,
     480                 :            :                         unsigned int nr_irqs, int node, void *arg)
     481                 :            : {
     482                 :          0 :         return __irq_domain_alloc_irqs(domain, -1, nr_irqs, node, arg, false,
     483                 :            :                                        NULL);
     484                 :            : }
     485                 :            : 
     486                 :            : extern int irq_domain_alloc_irqs_hierarchy(struct irq_domain *domain,
     487                 :            :                                            unsigned int irq_base,
     488                 :            :                                            unsigned int nr_irqs, void *arg);
     489                 :            : extern int irq_domain_set_hwirq_and_chip(struct irq_domain *domain,
     490                 :            :                                          unsigned int virq,
     491                 :            :                                          irq_hw_number_t hwirq,
     492                 :            :                                          struct irq_chip *chip,
     493                 :            :                                          void *chip_data);
     494                 :            : extern void irq_domain_reset_irq_data(struct irq_data *irq_data);
     495                 :            : extern void irq_domain_free_irqs_common(struct irq_domain *domain,
     496                 :            :                                         unsigned int virq,
     497                 :            :                                         unsigned int nr_irqs);
     498                 :            : extern void irq_domain_free_irqs_top(struct irq_domain *domain,
     499                 :            :                                      unsigned int virq, unsigned int nr_irqs);
     500                 :            : 
     501                 :            : extern int irq_domain_push_irq(struct irq_domain *domain, int virq, void *arg);
     502                 :            : extern int irq_domain_pop_irq(struct irq_domain *domain, int virq);
     503                 :            : 
     504                 :            : extern int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
     505                 :            :                                         unsigned int irq_base,
     506                 :            :                                         unsigned int nr_irqs, void *arg);
     507                 :            : 
     508                 :            : extern void irq_domain_free_irqs_parent(struct irq_domain *domain,
     509                 :            :                                         unsigned int irq_base,
     510                 :            :                                         unsigned int nr_irqs);
     511                 :            : 
     512                 :          0 : static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
     513                 :            : {
     514   [ #  #  #  #  :          0 :         return domain->flags & IRQ_DOMAIN_FLAG_HIERARCHY;
             #  #  #  # ]
     515                 :            : }
     516                 :            : 
     517                 :            : static inline bool irq_domain_is_ipi(struct irq_domain *domain)
     518                 :            : {
     519                 :            :         return domain->flags &
     520                 :            :                 (IRQ_DOMAIN_FLAG_IPI_PER_CPU | IRQ_DOMAIN_FLAG_IPI_SINGLE);
     521                 :            : }
     522                 :            : 
     523                 :            : static inline bool irq_domain_is_ipi_per_cpu(struct irq_domain *domain)
     524                 :            : {
     525                 :            :         return domain->flags & IRQ_DOMAIN_FLAG_IPI_PER_CPU;
     526                 :            : }
     527                 :            : 
     528                 :            : static inline bool irq_domain_is_ipi_single(struct irq_domain *domain)
     529                 :            : {
     530                 :            :         return domain->flags & IRQ_DOMAIN_FLAG_IPI_SINGLE;
     531                 :            : }
     532                 :            : 
     533                 :          0 : static inline bool irq_domain_is_msi(struct irq_domain *domain)
     534                 :            : {
     535         [ #  # ]:          0 :         return domain->flags & IRQ_DOMAIN_FLAG_MSI;
     536                 :            : }
     537                 :            : 
     538                 :          0 : static inline bool irq_domain_is_msi_remap(struct irq_domain *domain)
     539                 :            : {
     540   [ #  #  #  # ]:          0 :         return domain->flags & IRQ_DOMAIN_FLAG_MSI_REMAP;
     541                 :            : }
     542                 :            : 
     543                 :            : extern bool irq_domain_hierarchical_is_msi_remap(struct irq_domain *domain);
     544                 :            : 
     545                 :            : #else   /* CONFIG_IRQ_DOMAIN_HIERARCHY */
     546                 :            : static inline int irq_domain_alloc_irqs(struct irq_domain *domain,
     547                 :            :                         unsigned int nr_irqs, int node, void *arg)
     548                 :            : {
     549                 :            :         return -1;
     550                 :            : }
     551                 :            : 
     552                 :            : static inline void irq_domain_free_irqs(unsigned int virq,
     553                 :            :                                         unsigned int nr_irqs) { }
     554                 :            : 
     555                 :            : static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
     556                 :            : {
     557                 :            :         return false;
     558                 :            : }
     559                 :            : 
     560                 :            : static inline bool irq_domain_is_ipi(struct irq_domain *domain)
     561                 :            : {
     562                 :            :         return false;
     563                 :            : }
     564                 :            : 
     565                 :            : static inline bool irq_domain_is_ipi_per_cpu(struct irq_domain *domain)
     566                 :            : {
     567                 :            :         return false;
     568                 :            : }
     569                 :            : 
     570                 :            : static inline bool irq_domain_is_ipi_single(struct irq_domain *domain)
     571                 :            : {
     572                 :            :         return false;
     573                 :            : }
     574                 :            : 
     575                 :            : static inline bool irq_domain_is_msi(struct irq_domain *domain)
     576                 :            : {
     577                 :            :         return false;
     578                 :            : }
     579                 :            : 
     580                 :            : static inline bool irq_domain_is_msi_remap(struct irq_domain *domain)
     581                 :            : {
     582                 :            :         return false;
     583                 :            : }
     584                 :            : 
     585                 :            : static inline bool
     586                 :            : irq_domain_hierarchical_is_msi_remap(struct irq_domain *domain)
     587                 :            : {
     588                 :            :         return false;
     589                 :            : }
     590                 :            : #endif  /* CONFIG_IRQ_DOMAIN_HIERARCHY */
     591                 :            : 
     592                 :            : #else /* CONFIG_IRQ_DOMAIN */
     593                 :            : static inline void irq_dispose_mapping(unsigned int virq) { }
     594                 :            : static inline struct irq_domain *irq_find_matching_fwnode(
     595                 :            :         struct fwnode_handle *fwnode, enum irq_domain_bus_token bus_token)
     596                 :            : {
     597                 :            :         return NULL;
     598                 :            : }
     599                 :            : static inline bool irq_domain_check_msi_remap(void)
     600                 :            : {
     601                 :            :         return false;
     602                 :            : }
     603                 :            : #endif /* !CONFIG_IRQ_DOMAIN */
     604                 :            : 
     605                 :            : #endif /* _LINUX_IRQDOMAIN_H */

Generated by: LCOV version 1.14