request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,

const char *name, void *dev)

static int __init rtc_init(void)

{

...

rtc_int_handler_ptr = rtc_interrupt;

...

request_irq(RTC_IRQ, rtc_int_handler_ptr, 0, "rtc", NULL)

...

}

static irqreturn_t rtc_interrupt(int irq, void *dev_id)

{

/*

* Can be an alarm interrupt, update complete interrupt,

* or a periodic interrupt. We store the status in the

* low byte and the number of interrupts received since

* the last read in the remainder of rtc_irq_data.

*/

spin_lock(&rtc_lock);

rtc_irq_data += 0x100;

rtc_irq_data &= ~0xff;

if (is_hpet_enabled()) {

/*

* In this case it is HPET RTC interrupt handler

* calling us, with the interrupt information

* passed as arg1, instead of irq.

*/

rtc_irq_data |= (unsigned long)irq & 0xF0;

} else {

rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);

}

if (rtc_status & RTC_TIMER_ON)

mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);

spin_unlock(&rtc_lock);

wake_up_interruptible(&rtc_wait);

kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);

return IRQ_HANDLED;

}

asmlinkage void __exception_irq_entry

asm_do_IRQ(unsigned int irq, struct pt_regs *regs)

{

handle_IRQ(irq, regs);

}

void handle_IRQ(unsigned int irq, struct pt_regs *regs)

{

__handle_domain_irq(NULL, irq, false, regs);

}

int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,

bool lookup, struct pt_regs *regs)

{

struct pt_regs *old_regs = set_irq_regs(regs);

unsigned int irq = hwirq;

int ret = 0;

irq_enter();

#ifdef CONFIG_IRQ_DOMAIN

if (lookup)

irq = irq_find_mapping(domain, hwirq);

#endif

/*

* Some hardware gives randomly wrong interrupts. Rather

* than crashing, do something sensible.

*/

if (unlikely(!irq || irq >= nr_irqs)) {

ack_bad_irq(irq);

ret = -EINVAL;

} else {

generic_handle_irq(irq);

}

irq_exit();

set_irq_regs(old_regs);

return ret;

}

int generic_handle_irq(unsigned int irq)

{

struct irq_desc *desc = irq_to_desc(irq);

if (!desc)

return -EINVAL;

generic_handle_irq_desc(desc);

return 0;

}

EXPORT_SYMBOL_GPL(generic_handle_irq);

static inline void generic_handle_irq_desc(struct irq_desc *desc)

{

desc->handle_irq(desc);

}

struct irq_desc *irq_to_desc(unsigned int irq)

{

return (irq < NR_IRQS) ? irq_desc + irq : NULL;

}

EXPORT_SYMBOL(irq_to_desc);

struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {

[0 ... NR_IRQS-1] = {

.handle_irq = handle_bad_irq,

.depth = 1,

.lock = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),

}

};

struct irq_desc {

struct irq_common_data irq_common_data;

struct irq_data irq_data;

unsigned int __percpu *kstat_irqs;

irq_flow_handler_t handle_irq;

#ifdef CONFIG_IRQ_PREFLOW_FASTEOI

irq_preflow_handler_t preflow_handler;

#endif

struct irqaction *action; /* IRQ action list */

unsigned int status_use_accessors;

unsigned int core_internal_state__do_not_mess_with_it;

unsigned int depth; /* nested irq disables */

unsigned int wake_depth; /* nested wake enables */

unsigned int irq_count; /* For detecting broken IRQs */

unsigned long last_unhandled; /* Aging timer for unhandled count */

unsigned int irqs_unhandled;

atomic_t threads_handled;

int threads_handled_last;

raw_spinlock_t lock;

struct cpumask *percpu_enabled;

const struct cpumask *percpu_affinity;

#ifdef CONFIG_SMP

const struct cpumask *affinity_hint;

struct irq_affinity_notify *affinity_notify;

#ifdef CONFIG_GENERIC_PENDING_IRQ

cpumask_var_t pending_mask;

#endif

#endif

unsigned long threads_oneshot;

atomic_t threads_active;

wait_queue_head_t wait_for_threads;

#ifdef CONFIG_PM_SLEEP

unsigned int nr_actions;

unsigned int no_suspend_depth;

unsigned int cond_suspend_depth;

unsigned int force_resume_depth;

#endif

#ifdef CONFIG_PROC_FS

struct proc_dir_entry *dir;

#endif

#ifdef CONFIG_GENERIC_IRQ_DEBUGFS

struct dentry *debugfs_file;

const char *dev_name;

#endif

#ifdef CONFIG_SPARSE_IRQ

struct rcu_head rcu;

struct kobject kobj;

#endif

struct mutex request_mutex;

int parent_irq;

struct module *owner;

const char *name;

} ____cacheline_internodealigned_in_smp;

/**

* struct irqaction - per interrupt action descriptor

* @handler: interrupt handler function

* @name: name of the device

* @dev_id: cookie to identify the device

* @percpu_dev_id: cookie to identify the device

* @next: pointer to the next irqaction for shared interrupts

* @irq: interrupt number

* @flags: flags (see IRQF_* above)

* @thread_fn: interrupt handler function for threaded interrupts

* @thread: thread pointer for threaded interrupts

* @secondary: pointer to secondary irqaction (force threading)

* @thread_flags: flags related to @thread

* @thread_mask: bitmask for keeping track of @thread activity

* @dir: pointer to the proc/irq/NN/name entry

*/

struct irqaction {

irq_handler_t handler;

void *dev_id;

void __percpu *percpu_dev_id;

struct irqaction *next;

irq_handler_t thread_fn;

struct task_struct *thread;

struct irqaction *secondary;

unsigned int irq;

unsigned int flags;

unsigned long thread_flags;

unsigned long thread_mask;

const char *name;

struct proc_dir_entry *dir;

} ____cacheline_internodealigned_in_smp;

/**

* struct irq_chip - hardware interrupt chip descriptor

*

* @parent_device: pointer to parent device for irqchip

* @name: name for /proc/interrupts

* @irq_startup: start up the interrupt (defaults to ->enable if NULL)

* @irq_shutdown: shut down the interrupt (defaults to ->disable if NULL)

* @irq_enable: enable the interrupt (defaults to chip->unmask if NULL)

* @irq_disable: disable the interrupt

* @irq_ack: start of a new interrupt

* @irq_mask: mask an interrupt source

* @irq_mask_ack: ack and mask an interrupt source

* @irq_unmask: unmask an interrupt source

* @irq_eoi: end of interrupt

* @irq_set_affinity: Set the CPU affinity on SMP machines. If the force

* argument is true, it tells the driver to

* unconditionally apply the affinity setting. Sanity

* checks against the supplied affinity mask are not

* required. This is used for CPU hotplug where the

* target CPU is not yet set in the cpu_online_mask.

* @irq_retrigger: resend an IRQ to the CPU

* @irq_set_type: set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ

* @irq_set_wake: enable/disable power-management wake-on of an IRQ

* @irq_bus_lock: function to lock access to slow bus (i2c) chips

* @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips

* @irq_cpu_online: configure an interrupt source for a secondary CPU

* @irq_cpu_offline: un-configure an interrupt source for a secondary CPU

* @irq_suspend: function called from core code on suspend once per

* chip, when one or more interrupts are installed

* @irq_resume: function called from core code on resume once per chip,

* when one ore more interrupts are installed

* @irq_pm_shutdown: function called from core code on shutdown once per chip

* @irq_calc_mask: Optional function to set irq_data.mask for special cases

* @irq_print_chip: optional to print special chip info in show_interrupts

* @irq_request_resources: optional to request resources before calling

* any other callback related to this irq

* @irq_release_resources: optional to release resources acquired with

* irq_request_resources

* @irq_compose_msi_msg: optional to compose message content for MSI

* @irq_write_msi_msg: optional to write message content for MSI

* @irq_get_irqchip_state: return the internal state of an interrupt

* @irq_set_irqchip_state: set the internal state of a interrupt

* @irq_set_vcpu_affinity: optional to target a vCPU in a virtual machine

* @ipi_send_single: send a single IPI to destination cpus

* @ipi_send_mask: send an IPI to destination cpus in cpumask

* @flags: chip specific flags

*/

struct irq_chip {

struct device *parent_device;

const char *name;

unsigned int (*irq_startup)(struct irq_data *data);

void (*irq_shutdown)(struct irq_data *data);

void (*irq_enable)(struct irq_data *data);

void (*irq_disable)(struct irq_data *data);

void (*irq_ack)(struct irq_data *data);

void (*irq_mask)(struct irq_data *data);

void (*irq_mask_ack)(struct irq_data *data);

void (*irq_unmask)(struct irq_data *data);

void (*irq_eoi)(struct irq_data *data);

int (*irq_set_affinity)(struct irq_data *data, const struct cpumask *dest, bool force);

int (*irq_retrigger)(struct irq_data *data);

int (*irq_set_type)(struct irq_data *data, unsigned int flow_type);

int (*irq_set_wake)(struct irq_data *data, unsigned int on);

void (*irq_bus_lock)(struct irq_data *data);

void (*irq_bus_sync_unlock)(struct irq_data *data);

void (*irq_cpu_online)(struct irq_data *data);

void (*irq_cpu_offline)(struct irq_data *data);

void (*irq_suspend)(struct irq_data *data);

void (*irq_resume)(struct irq_data *data);

void (*irq_pm_shutdown)(struct irq_data *data);

void (*irq_calc_mask)(struct irq_data *data);

void (*irq_print_chip)(struct irq_data *data, struct seq_file *p);

int (*irq_request_resources)(struct irq_data *data);

void (*irq_release_resources)(struct irq_data *data);

void (*irq_compose_msi_msg)(struct irq_data *data, struct msi_msg *msg);

void (*irq_write_msi_msg)(struct irq_data *data, struct msi_msg *msg);

int (*irq_get_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool *state);

int (*irq_set_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool state);

int (*irq_set_vcpu_affinity)(struct irq_data *data, void *vcpu_info);

void (*ipi_send_single)(struct irq_data *data, unsigned int cpu);

void (*ipi_send_mask)(struct irq_data *data, const struct cpumask *dest);

unsigned long flags;

};

asmlinkage __visible void __init start_kernel(void)

{

char *command_line;

char *after_dashes;

.....

early_irq_init();

init_IRQ();

.....

}

void __init init_IRQ(void)

{

int ret;

if (IS_ENABLED(CONFIG_OF) && !machine_desc->init_irq)

irqchip_init();

else

machine_desc->init_irq();

if (IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_CACHE_L2X0) &&

(machine_desc->l2c_aux_mask || machine_desc->l2c_aux_val)) {

if (!outer_cache.write_sec)

outer_cache.write_sec = machine_desc->l2c_write_sec;

ret = l2x0_of_init(machine_desc->l2c_aux_val,

machine_desc->l2c_aux_mask);

if (ret && ret != -ENODEV)

pr_err("L2C: failed to init: %d\n", ret);

}

uniphier_cache_init();

}

int __init s5p_init_irq_eint(void)

{

int irq;

for (irq = IRQ_EINT(0); irq <= IRQ_EINT(15); irq++)

irq_set_chip(irq, &s5p_irq_vic_eint);

for (irq = IRQ_EINT(16); irq <= IRQ_EINT(31); irq++) {

irq_set_chip_and_handler(irq, &s5p_irq_eint, handle_level_irq);

set_irq_flags(irq, IRQF_VALID);

}

irq_set_chained_handler(IRQ_EINT16_31, s5p_irq_demux_eint16_31);

return 0;

}

void

irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,

irq_flow_handler_t handle, const char *name);

irq_set_handler(unsigned int irq, irq_flow_handler_t handle)

{

__irq_set_handler(irq, handle, 0, NULL);

}

static inline void

irq_set_chained_handler(unsigned int irq, irq_flow_handler_t handle)

{

__irq_set_handler(irq, handle, 1, NULL);

}

void

irq_set_chained_handler_and_data(unsigned int irq, irq_flow_handler_t handle,

void *data);

/*

* Built-in IRQ handlers for various IRQ types,

* callable via desc->handle_irq()

*/

extern void handle_level_irq(struct irq_desc *desc);

extern void handle_fasteoi_irq(struct irq_desc *desc);

extern void handle_edge_irq(struct irq_desc *desc);

extern void handle_edge_eoi_irq(struct irq_desc *desc);

extern void handle_simple_irq(struct irq_desc *desc);

extern void handle_untracked_irq(struct irq_desc *desc);

extern void handle_percpu_irq(struct irq_desc *desc);

extern void handle_percpu_devid_irq(struct irq_desc *desc);

extern void handle_bad_irq(struct irq_desc *desc);

extern void handle_nested_irq(unsigned int irq);

/**

* handle_level_irq - Level type irq handler

* @desc: the interrupt description structure for this irq

*

* Level type interrupts are active as long as the hardware line has

* the active level. This may require to mask the interrupt and unmask

* it after the associated handler has acknowledged the device, so the

* interrupt line is back to inactive.

*/

void handle_level_irq(struct irq_desc *desc)

{

raw_spin_lock(&desc->lock);

mask_ack_irq(desc);

if (!irq_may_run(desc))

goto out_unlock;

desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);

/*

* If its disabled or no action available

* keep it masked and get out of here

*/

if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {

desc->istate |= IRQS_PENDING;

goto out_unlock;

}

kstat_incr_irqs_this_cpu(desc);

handle_irq_event(desc);

cond_unmask_irq(desc);

out_unlock:

raw_spin_unlock(&desc->lock);

}

irqreturn_t handle_irq_event(struct irq_desc *desc)

{

irqreturn_t ret;

desc->istate &= ~IRQS_PENDING;

irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);

raw_spin_unlock(&desc->lock);

ret = handle_irq_event_percpu(desc);

raw_spin_lock(&desc->lock);

irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);

return ret;

}