Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * IRQ subsystem internal functions and variables:
       4                 :            :  *
       5                 :            :  * Do not ever include this file from anything else than
       6                 :            :  * kernel/irq/. Do not even think about using any information outside
       7                 :            :  * of this file for your non core code.
       8                 :            :  */
       9                 :            : #include <linux/irqdesc.h>
      10                 :            : #include <linux/kernel_stat.h>
      11                 :            : #include <linux/pm_runtime.h>
      12                 :            : #include <linux/sched/clock.h>
      13                 :            : 
      14                 :            : #ifdef CONFIG_SPARSE_IRQ
      15                 :            : # define IRQ_BITMAP_BITS        (NR_IRQS + 8196)
      16                 :            : #else
      17                 :            : # define IRQ_BITMAP_BITS        NR_IRQS
      18                 :            : #endif
      19                 :            : 
      20                 :            : #define istate core_internal_state__do_not_mess_with_it
      21                 :            : 
      22                 :            : extern bool noirqdebug;
      23                 :            : 
      24                 :            : extern struct irqaction chained_action;
      25                 :            : 
      26                 :            : /*
      27                 :            :  * Bits used by threaded handlers:
      28                 :            :  * IRQTF_RUNTHREAD - signals that the interrupt handler thread should run
      29                 :            :  * IRQTF_WARNED    - warning "IRQ_WAKE_THREAD w/o thread_fn" has been printed
      30                 :            :  * IRQTF_AFFINITY  - irq thread is requested to adjust affinity
      31                 :            :  * IRQTF_FORCED_THREAD  - irq action is force threaded
      32                 :            :  */
      33                 :            : enum {
      34                 :            :         IRQTF_RUNTHREAD,
      35                 :            :         IRQTF_WARNED,
      36                 :            :         IRQTF_AFFINITY,
      37                 :            :         IRQTF_FORCED_THREAD,
      38                 :            : };
      39                 :            : 
      40                 :            : /*
      41                 :            :  * Bit masks for desc->core_internal_state__do_not_mess_with_it
      42                 :            :  *
      43                 :            :  * IRQS_AUTODETECT              - autodetection in progress
      44                 :            :  * IRQS_SPURIOUS_DISABLED       - was disabled due to spurious interrupt
      45                 :            :  *                                detection
      46                 :            :  * IRQS_POLL_INPROGRESS         - polling in progress
      47                 :            :  * IRQS_ONESHOT                 - irq is not unmasked in primary handler
      48                 :            :  * IRQS_REPLAY                  - irq is replayed
      49                 :            :  * IRQS_WAITING                 - irq is waiting
      50                 :            :  * IRQS_PENDING                 - irq is pending and replayed later
      51                 :            :  * IRQS_SUSPENDED               - irq is suspended
      52                 :            :  * IRQS_NMI                     - irq line is used to deliver NMIs
      53                 :            :  */
      54                 :            : enum {
      55                 :            :         IRQS_AUTODETECT         = 0x00000001,
      56                 :            :         IRQS_SPURIOUS_DISABLED  = 0x00000002,
      57                 :            :         IRQS_POLL_INPROGRESS    = 0x00000008,
      58                 :            :         IRQS_ONESHOT            = 0x00000020,
      59                 :            :         IRQS_REPLAY             = 0x00000040,
      60                 :            :         IRQS_WAITING            = 0x00000080,
      61                 :            :         IRQS_PENDING            = 0x00000200,
      62                 :            :         IRQS_SUSPENDED          = 0x00000800,
      63                 :            :         IRQS_TIMINGS            = 0x00001000,
      64                 :            :         IRQS_NMI                = 0x00002000,
      65                 :            : };
      66                 :            : 
      67                 :            : #include "debug.h"
      68                 :            : #include "settings.h"
      69                 :            : 
      70                 :            : extern int __irq_set_trigger(struct irq_desc *desc, unsigned long flags);
      71                 :            : extern void __disable_irq(struct irq_desc *desc);
      72                 :            : extern void __enable_irq(struct irq_desc *desc);
      73                 :            : 
      74                 :            : #define IRQ_RESEND      true
      75                 :            : #define IRQ_NORESEND    false
      76                 :            : 
      77                 :            : #define IRQ_START_FORCE true
      78                 :            : #define IRQ_START_COND  false
      79                 :            : 
      80                 :            : extern int irq_activate(struct irq_desc *desc);
      81                 :            : extern int irq_activate_and_startup(struct irq_desc *desc, bool resend);
      82                 :            : extern int irq_startup(struct irq_desc *desc, bool resend, bool force);
      83                 :            : 
      84                 :            : extern void irq_shutdown(struct irq_desc *desc);
      85                 :            : extern void irq_shutdown_and_deactivate(struct irq_desc *desc);
      86                 :            : extern void irq_enable(struct irq_desc *desc);
      87                 :            : extern void irq_disable(struct irq_desc *desc);
      88                 :            : extern void irq_percpu_enable(struct irq_desc *desc, unsigned int cpu);
      89                 :            : extern void irq_percpu_disable(struct irq_desc *desc, unsigned int cpu);
      90                 :            : extern void mask_irq(struct irq_desc *desc);
      91                 :            : extern void unmask_irq(struct irq_desc *desc);
      92                 :            : extern void unmask_threaded_irq(struct irq_desc *desc);
      93                 :            : 
      94                 :            : #ifdef CONFIG_SPARSE_IRQ
      95                 :            : static inline void irq_mark_irq(unsigned int irq) { }
      96                 :            : #else
      97                 :            : extern void irq_mark_irq(unsigned int irq);
      98                 :            : #endif
      99                 :            : 
     100                 :            : extern int __irq_get_irqchip_state(struct irq_data *data,
     101                 :            :                                    enum irqchip_irq_state which,
     102                 :            :                                    bool *state);
     103                 :            : 
     104                 :            : extern void init_kstat_irqs(struct irq_desc *desc, int node, int nr);
     105                 :            : 
     106                 :            : irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags);
     107                 :            : irqreturn_t handle_irq_event_percpu(struct irq_desc *desc);
     108                 :            : irqreturn_t handle_irq_event(struct irq_desc *desc);
     109                 :            : 
     110                 :            : /* Resending of interrupts :*/
     111                 :            : void check_irq_resend(struct irq_desc *desc);
     112                 :            : bool irq_wait_for_poll(struct irq_desc *desc);
     113                 :            : void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action);
     114                 :            : 
     115                 :            : #ifdef CONFIG_PROC_FS
     116                 :            : extern void register_irq_proc(unsigned int irq, struct irq_desc *desc);
     117                 :            : extern void unregister_irq_proc(unsigned int irq, struct irq_desc *desc);
     118                 :            : extern void register_handler_proc(unsigned int irq, struct irqaction *action);
     119                 :            : extern void unregister_handler_proc(unsigned int irq, struct irqaction *action);
     120                 :            : #else
     121                 :            : static inline void register_irq_proc(unsigned int irq, struct irq_desc *desc) { }
     122                 :            : static inline void unregister_irq_proc(unsigned int irq, struct irq_desc *desc) { }
     123                 :            : static inline void register_handler_proc(unsigned int irq,
     124                 :            :                                          struct irqaction *action) { }
     125                 :            : static inline void unregister_handler_proc(unsigned int irq,
     126                 :            :                                            struct irqaction *action) { }
     127                 :            : #endif
     128                 :            : 
     129                 :            : extern bool irq_can_set_affinity_usr(unsigned int irq);
     130                 :            : 
     131                 :            : extern void irq_set_thread_affinity(struct irq_desc *desc);
     132                 :            : 
     133                 :            : extern int irq_do_set_affinity(struct irq_data *data,
     134                 :            :                                const struct cpumask *dest, bool force);
     135                 :            : 
     136                 :            : #ifdef CONFIG_SMP
     137                 :            : extern int irq_setup_affinity(struct irq_desc *desc);
     138                 :            : #else
     139                 :            : static inline int irq_setup_affinity(struct irq_desc *desc) { return 0; }
     140                 :            : #endif
     141                 :            : 
     142                 :            : /* Inline functions for support of irq chips on slow busses */
     143                 :            : static inline void chip_bus_lock(struct irq_desc *desc)
     144                 :            : {
     145                 :          3 :         if (unlikely(desc->irq_data.chip->irq_bus_lock))
     146                 :          0 :                 desc->irq_data.chip->irq_bus_lock(&desc->irq_data);
     147                 :            : }
     148                 :            : 
     149                 :            : static inline void chip_bus_sync_unlock(struct irq_desc *desc)
     150                 :            : {
     151                 :          3 :         if (unlikely(desc->irq_data.chip->irq_bus_sync_unlock))
     152                 :          0 :                 desc->irq_data.chip->irq_bus_sync_unlock(&desc->irq_data);
     153                 :            : }
     154                 :            : 
     155                 :            : #define _IRQ_DESC_CHECK         (1 << 0)
     156                 :            : #define _IRQ_DESC_PERCPU        (1 << 1)
     157                 :            : 
     158                 :            : #define IRQ_GET_DESC_CHECK_GLOBAL       (_IRQ_DESC_CHECK)
     159                 :            : #define IRQ_GET_DESC_CHECK_PERCPU       (_IRQ_DESC_CHECK | _IRQ_DESC_PERCPU)
     160                 :            : 
     161                 :            : #define for_each_action_of_desc(desc, act)                      \
     162                 :            :         for (act = desc->action; act; act = act->next)
     163                 :            : 
     164                 :            : struct irq_desc *
     165                 :            : __irq_get_desc_lock(unsigned int irq, unsigned long *flags, bool bus,
     166                 :            :                     unsigned int check);
     167                 :            : void __irq_put_desc_unlock(struct irq_desc *desc, unsigned long flags, bool bus);
     168                 :            : 
     169                 :            : static inline struct irq_desc *
     170                 :            : irq_get_desc_buslock(unsigned int irq, unsigned long *flags, unsigned int check)
     171                 :            : {
     172                 :          3 :         return __irq_get_desc_lock(irq, flags, true, check);
     173                 :            : }
     174                 :            : 
     175                 :            : static inline void
     176                 :            : irq_put_desc_busunlock(struct irq_desc *desc, unsigned long flags)
     177                 :            : {
     178                 :          3 :         __irq_put_desc_unlock(desc, flags, true);
     179                 :            : }
     180                 :            : 
     181                 :            : static inline struct irq_desc *
     182                 :            : irq_get_desc_lock(unsigned int irq, unsigned long *flags, unsigned int check)
     183                 :            : {
     184                 :          3 :         return __irq_get_desc_lock(irq, flags, false, check);
     185                 :            : }
     186                 :            : 
     187                 :            : static inline void
     188                 :            : irq_put_desc_unlock(struct irq_desc *desc, unsigned long flags)
     189                 :            : {
     190                 :          3 :         __irq_put_desc_unlock(desc, flags, false);
     191                 :            : }
     192                 :            : 
     193                 :            : #define __irqd_to_state(d) ACCESS_PRIVATE((d)->common, state_use_accessors)
     194                 :            : 
     195                 :            : static inline unsigned int irqd_get(struct irq_data *d)
     196                 :            : {
     197                 :          0 :         return __irqd_to_state(d);
     198                 :            : }
     199                 :            : 
     200                 :            : /*
     201                 :            :  * Manipulation functions for irq_data.state
     202                 :            :  */
     203                 :            : static inline void irqd_set_move_pending(struct irq_data *d)
     204                 :            : {
     205                 :          0 :         __irqd_to_state(d) |= IRQD_SETAFFINITY_PENDING;
     206                 :            : }
     207                 :            : 
     208                 :            : static inline void irqd_clr_move_pending(struct irq_data *d)
     209                 :            : {
     210                 :            :         __irqd_to_state(d) &= ~IRQD_SETAFFINITY_PENDING;
     211                 :            : }
     212                 :            : 
     213                 :            : static inline void irqd_set_managed_shutdown(struct irq_data *d)
     214                 :            : {
     215                 :          0 :         __irqd_to_state(d) |= IRQD_MANAGED_SHUTDOWN;
     216                 :            : }
     217                 :            : 
     218                 :            : static inline void irqd_clr_managed_shutdown(struct irq_data *d)
     219                 :            : {
     220                 :          0 :         __irqd_to_state(d) &= ~IRQD_MANAGED_SHUTDOWN;
     221                 :            : }
     222                 :            : 
     223                 :            : static inline void irqd_clear(struct irq_data *d, unsigned int mask)
     224                 :            : {
     225                 :          3 :         __irqd_to_state(d) &= ~mask;
     226                 :            : }
     227                 :            : 
     228                 :            : static inline void irqd_set(struct irq_data *d, unsigned int mask)
     229                 :            : {
     230                 :          3 :         __irqd_to_state(d) |= mask;
     231                 :            : }
     232                 :            : 
     233                 :            : static inline bool irqd_has_set(struct irq_data *d, unsigned int mask)
     234                 :            : {
     235                 :          3 :         return __irqd_to_state(d) & mask;
     236                 :            : }
     237                 :            : 
     238                 :            : static inline void irq_state_set_disabled(struct irq_desc *desc)
     239                 :            : {
     240                 :            :         irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
     241                 :            : }
     242                 :            : 
     243                 :            : static inline void irq_state_set_masked(struct irq_desc *desc)
     244                 :            : {
     245                 :            :         irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
     246                 :            : }
     247                 :            : 
     248                 :            : #undef __irqd_to_state
     249                 :            : 
     250                 :            : static inline void __kstat_incr_irqs_this_cpu(struct irq_desc *desc)
     251                 :            : {
     252                 :          3 :         __this_cpu_inc(*desc->kstat_irqs);
     253                 :          3 :         __this_cpu_inc(kstat.irqs_sum);
     254                 :            : }
     255                 :            : 
     256                 :          3 : static inline void kstat_incr_irqs_this_cpu(struct irq_desc *desc)
     257                 :            : {
     258                 :            :         __kstat_incr_irqs_this_cpu(desc);
     259                 :          3 :         desc->tot_count++;
     260                 :          3 : }
     261                 :            : 
     262                 :            : static inline int irq_desc_get_node(struct irq_desc *desc)
     263                 :            : {
     264                 :            :         return irq_common_data_get_node(&desc->irq_common_data);
     265                 :            : }
     266                 :            : 
     267                 :            : static inline int irq_desc_is_chained(struct irq_desc *desc)
     268                 :            : {
     269                 :          0 :         return (desc->action && desc->action == &chained_action);
     270                 :            : }
     271                 :            : 
     272                 :            : #ifdef CONFIG_PM_SLEEP
     273                 :            : bool irq_pm_check_wakeup(struct irq_desc *desc);
     274                 :            : void irq_pm_install_action(struct irq_desc *desc, struct irqaction *action);
     275                 :            : void irq_pm_remove_action(struct irq_desc *desc, struct irqaction *action);
     276                 :            : #else
     277                 :            : static inline bool irq_pm_check_wakeup(struct irq_desc *desc) { return false; }
     278                 :            : static inline void
     279                 :            : irq_pm_install_action(struct irq_desc *desc, struct irqaction *action) { }
     280                 :            : static inline void
     281                 :            : irq_pm_remove_action(struct irq_desc *desc, struct irqaction *action) { }
     282                 :            : #endif
     283                 :            : 
     284                 :            : #ifdef CONFIG_IRQ_TIMINGS
     285                 :            : 
     286                 :            : #define IRQ_TIMINGS_SHIFT       5
     287                 :            : #define IRQ_TIMINGS_SIZE        (1 << IRQ_TIMINGS_SHIFT)
     288                 :            : #define IRQ_TIMINGS_MASK        (IRQ_TIMINGS_SIZE - 1)
     289                 :            : 
     290                 :            : /**
     291                 :            :  * struct irq_timings - irq timings storing structure
     292                 :            :  * @values: a circular buffer of u64 encoded <timestamp,irq> values
     293                 :            :  * @count: the number of elements in the array
     294                 :            :  */
     295                 :            : struct irq_timings {
     296                 :            :         u64     values[IRQ_TIMINGS_SIZE];
     297                 :            :         int     count;
     298                 :            : };
     299                 :            : 
     300                 :            : DECLARE_PER_CPU(struct irq_timings, irq_timings);
     301                 :            : 
     302                 :            : extern void irq_timings_free(int irq);
     303                 :            : extern int irq_timings_alloc(int irq);
     304                 :            : 
     305                 :            : static inline void irq_remove_timings(struct irq_desc *desc)
     306                 :            : {
     307                 :            :         desc->istate &= ~IRQS_TIMINGS;
     308                 :            : 
     309                 :            :         irq_timings_free(irq_desc_get_irq(desc));
     310                 :            : }
     311                 :            : 
     312                 :            : static inline void irq_setup_timings(struct irq_desc *desc, struct irqaction *act)
     313                 :            : {
     314                 :            :         int irq = irq_desc_get_irq(desc);
     315                 :            :         int ret;
     316                 :            : 
     317                 :            :         /*
     318                 :            :          * We don't need the measurement because the idle code already
     319                 :            :          * knows the next expiry event.
     320                 :            :          */
     321                 :            :         if (act->flags & __IRQF_TIMER)
     322                 :            :                 return;
     323                 :            : 
     324                 :            :         /*
     325                 :            :          * In case the timing allocation fails, we just want to warn,
     326                 :            :          * not fail, so letting the system boot anyway.
     327                 :            :          */
     328                 :            :         ret = irq_timings_alloc(irq);
     329                 :            :         if (ret) {
     330                 :            :                 pr_warn("Failed to allocate irq timing stats for irq%d (%d)",
     331                 :            :                         irq, ret);
     332                 :            :                 return;
     333                 :            :         }
     334                 :            : 
     335                 :            :         desc->istate |= IRQS_TIMINGS;
     336                 :            : }
     337                 :            : 
     338                 :            : extern void irq_timings_enable(void);
     339                 :            : extern void irq_timings_disable(void);
     340                 :            : 
     341                 :            : DECLARE_STATIC_KEY_FALSE(irq_timing_enabled);
     342                 :            : 
     343                 :            : /*
     344                 :            :  * The interrupt number and the timestamp are encoded into a single
     345                 :            :  * u64 variable to optimize the size.
     346                 :            :  * 48 bit time stamp and 16 bit IRQ number is way sufficient.
     347                 :            :  *  Who cares an IRQ after 78 hours of idle time?
     348                 :            :  */
     349                 :            : static inline u64 irq_timing_encode(u64 timestamp, int irq)
     350                 :            : {
     351                 :            :         return (timestamp << 16) | irq;
     352                 :            : }
     353                 :            : 
     354                 :            : static inline int irq_timing_decode(u64 value, u64 *timestamp)
     355                 :            : {
     356                 :            :         *timestamp = value >> 16;
     357                 :            :         return value & U16_MAX;
     358                 :            : }
     359                 :            : 
     360                 :            : static __always_inline void irq_timings_push(u64 ts, int irq)
     361                 :            : {
     362                 :            :         struct irq_timings *timings = this_cpu_ptr(&irq_timings);
     363                 :            : 
     364                 :            :         timings->values[timings->count & IRQ_TIMINGS_MASK] =
     365                 :            :                 irq_timing_encode(ts, irq);
     366                 :            : 
     367                 :            :         timings->count++;
     368                 :            : }
     369                 :            : 
     370                 :            : /*
     371                 :            :  * The function record_irq_time is only called in one place in the
     372                 :            :  * interrupts handler. We want this function always inline so the code
     373                 :            :  * inside is embedded in the function and the static key branching
     374                 :            :  * code can act at the higher level. Without the explicit
     375                 :            :  * __always_inline we can end up with a function call and a small
     376                 :            :  * overhead in the hotpath for nothing.
     377                 :            :  */
     378                 :            : static __always_inline void record_irq_time(struct irq_desc *desc)
     379                 :            : {
     380                 :            :         if (!static_branch_likely(&irq_timing_enabled))
     381                 :            :                 return;
     382                 :            : 
     383                 :            :         if (desc->istate & IRQS_TIMINGS)
     384                 :            :                 irq_timings_push(local_clock(), irq_desc_get_irq(desc));
     385                 :            : }
     386                 :            : #else
     387                 :            : static inline void irq_remove_timings(struct irq_desc *desc) {}
     388                 :            : static inline void irq_setup_timings(struct irq_desc *desc,
     389                 :            :                                      struct irqaction *act) {};
     390                 :            : static inline void record_irq_time(struct irq_desc *desc) {}
     391                 :            : #endif /* CONFIG_IRQ_TIMINGS */
     392                 :            : 
     393                 :            : 
     394                 :            : #ifdef CONFIG_GENERIC_IRQ_CHIP
     395                 :            : void irq_init_generic_chip(struct irq_chip_generic *gc, const char *name,
     396                 :            :                            int num_ct, unsigned int irq_base,
     397                 :            :                            void __iomem *reg_base, irq_flow_handler_t handler);
     398                 :            : #else
     399                 :            : static inline void
     400                 :            : irq_init_generic_chip(struct irq_chip_generic *gc, const char *name,
     401                 :            :                       int num_ct, unsigned int irq_base,
     402                 :            :                       void __iomem *reg_base, irq_flow_handler_t handler) { }
     403                 :            : #endif /* CONFIG_GENERIC_IRQ_CHIP */
     404                 :            : 
     405                 :            : #ifdef CONFIG_GENERIC_PENDING_IRQ
     406                 :            : static inline bool irq_can_move_pcntxt(struct irq_data *data)
     407                 :            : {
     408                 :            :         return irqd_can_move_in_process_context(data);
     409                 :            : }
     410                 :            : static inline bool irq_move_pending(struct irq_data *data)
     411                 :            : {
     412                 :            :         return irqd_is_setaffinity_pending(data);
     413                 :            : }
     414                 :            : static inline void
     415                 :            : irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
     416                 :            : {
     417                 :            :         cpumask_copy(desc->pending_mask, mask);
     418                 :            : }
     419                 :            : static inline void
     420                 :            : irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
     421                 :            : {
     422                 :            :         cpumask_copy(mask, desc->pending_mask);
     423                 :            : }
     424                 :            : static inline struct cpumask *irq_desc_get_pending_mask(struct irq_desc *desc)
     425                 :            : {
     426                 :            :         return desc->pending_mask;
     427                 :            : }
     428                 :            : bool irq_fixup_move_pending(struct irq_desc *desc, bool force_clear);
     429                 :            : #else /* CONFIG_GENERIC_PENDING_IRQ */
     430                 :            : static inline bool irq_can_move_pcntxt(struct irq_data *data)
     431                 :            : {
     432                 :            :         return true;
     433                 :            : }
     434                 :            : static inline bool irq_move_pending(struct irq_data *data)
     435                 :            : {
     436                 :            :         return false;
     437                 :            : }
     438                 :            : static inline void
     439                 :            : irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
     440                 :            : {
     441                 :            : }
     442                 :            : static inline void
     443                 :            : irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
     444                 :            : {
     445                 :            : }
     446                 :            : static inline struct cpumask *irq_desc_get_pending_mask(struct irq_desc *desc)
     447                 :            : {
     448                 :            :         return NULL;
     449                 :            : }
     450                 :            : static inline bool irq_fixup_move_pending(struct irq_desc *desc, bool fclear)
     451                 :            : {
     452                 :            :         return false;
     453                 :            : }
     454                 :            : #endif /* !CONFIG_GENERIC_PENDING_IRQ */
     455                 :            : 
     456                 :            : #if !defined(CONFIG_IRQ_DOMAIN) || !defined(CONFIG_IRQ_DOMAIN_HIERARCHY)
     457                 :            : static inline int irq_domain_activate_irq(struct irq_data *data, bool reserve)
     458                 :            : {
     459                 :            :         irqd_set_activated(data);
     460                 :            :         return 0;
     461                 :            : }
     462                 :            : static inline void irq_domain_deactivate_irq(struct irq_data *data)
     463                 :            : {
     464                 :            :         irqd_clr_activated(data);
     465                 :            : }
     466                 :            : #endif
     467                 :            : 
     468                 :            : #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
     469                 :            : #include <linux/debugfs.h>
     470                 :            : 
     471                 :            : void irq_add_debugfs_entry(unsigned int irq, struct irq_desc *desc);
     472                 :            : static inline void irq_remove_debugfs_entry(struct irq_desc *desc)
     473                 :            : {
     474                 :          0 :         debugfs_remove(desc->debugfs_file);
     475                 :          0 :         kfree(desc->dev_name);
     476                 :            : }
     477                 :            : void irq_debugfs_copy_devname(int irq, struct device *dev);
     478                 :            : # ifdef CONFIG_IRQ_DOMAIN
     479                 :            : void irq_domain_debugfs_init(struct dentry *root);
     480                 :            : # else
     481                 :            : static inline void irq_domain_debugfs_init(struct dentry *root)
     482                 :            : {
     483                 :            : }
     484                 :            : # endif
     485                 :            : #else /* CONFIG_GENERIC_IRQ_DEBUGFS */
     486                 :            : static inline void irq_add_debugfs_entry(unsigned int irq, struct irq_desc *d)
     487                 :            : {
     488                 :            : }
     489                 :            : static inline void irq_remove_debugfs_entry(struct irq_desc *d)
     490                 :            : {
     491                 :            : }
     492                 :            : static inline void irq_debugfs_copy_devname(int irq, struct device *dev)
     493                 :            : {
     494                 :            : }
     495                 :            : #endif /* CONFIG_GENERIC_IRQ_DEBUGFS */