genirq: Remove compat code (0c6f8a8b) · Commits · e / devices / android_kernel_sony_msm8994

include/linux/irq.h

+0 −117

Original line number	Original line	Diff line number	Diff line
	@@ -92,18 +92,6 @@ enum {
	IRQ_NO_BALANCING = (1 << 13),		IRQ_NO_BALANCING = (1 << 13),
	IRQ_MOVE_PCNTXT = (1 << 14),		IRQ_MOVE_PCNTXT = (1 << 14),
	IRQ_NESTED_THREAD = (1 << 15),		IRQ_NESTED_THREAD = (1 << 15),

	#ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
	IRQ_INPROGRESS = (1 << 16),
	IRQ_REPLAY = (1 << 17),
	IRQ_WAITING = (1 << 18),
	IRQ_DISABLED = (1 << 19),
	IRQ_PENDING = (1 << 20),
	IRQ_MASKED = (1 << 21),
	IRQ_MOVE_PENDING = (1 << 22),
	IRQ_AFFINITY_SET = (1 << 23),
	IRQ_WAKEUP = (1 << 24),
	#endif
	};		};

	#define IRQF_MODIFY_MASK \		#define IRQF_MODIFY_MASK \
	@@ -321,28 +309,6 @@ static inline void irqd_clr_chained_irq_inprogress(struct irq_data *d)
	*/		*/
	struct irq_chip {		struct irq_chip {
	const char *name;		const char *name;
	#ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
	unsigned int (*startup)(unsigned int irq);
	void (*shutdown)(unsigned int irq);
	void (*enable)(unsigned int irq);
	void (*disable)(unsigned int irq);

	void (*ack)(unsigned int irq);
	void (*mask)(unsigned int irq);
	void (*mask_ack)(unsigned int irq);
	void (*unmask)(unsigned int irq);
	void (*eoi)(unsigned int irq);

	void (*end)(unsigned int irq);
	int (*set_affinity)(unsigned int irq,
	const struct cpumask *dest);
	int (*retrigger)(unsigned int irq);
	int (*set_type)(unsigned int irq, unsigned int flow_type);
	int (*set_wake)(unsigned int irq, unsigned int on);

	void (*bus_lock)(unsigned int irq);
	void (*bus_sync_unlock)(unsigned int irq);
	#endif
	unsigned int (irq_startup)(struct irq_data data);		unsigned int (irq_startup)(struct irq_data data);
	void (irq_shutdown)(struct irq_data data);		void (irq_shutdown)(struct irq_data data);
	void (irq_enable)(struct irq_data data);		void (irq_enable)(struct irq_data data);
	@@ -589,89 +555,6 @@ static inline struct msi_desc irq_data_get_msi(struct irq_data d)
	return d->msi_desc;		return d->msi_desc;
	}		}

	#ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
	/* Please do not use: Use the replacement functions instead */
	static inline int set_irq_chip(unsigned int irq, struct irq_chip *chip)
	{
	return irq_set_chip(irq, chip);
	}
	static inline int set_irq_data(unsigned int irq, void *data)
	{
	return irq_set_handler_data(irq, data);
	}
	static inline int set_irq_chip_data(unsigned int irq, void *data)
	{
	return irq_set_chip_data(irq, data);
	}
	static inline int set_irq_type(unsigned int irq, unsigned int type)
	{
	return irq_set_irq_type(irq, type);
	}
	static inline int set_irq_msi(unsigned int irq, struct msi_desc *entry)
	{
	return irq_set_msi_desc(irq, entry);
	}
	static inline struct irq_chip *get_irq_chip(unsigned int irq)
	{
	return irq_get_chip(irq);
	}
	static inline void *get_irq_chip_data(unsigned int irq)
	{
	return irq_get_chip_data(irq);
	}
	static inline void *get_irq_data(unsigned int irq)
	{
	return irq_get_handler_data(irq);
	}
	static inline void irq_data_get_irq_data(struct irq_data d)
	{
	return irq_data_get_irq_handler_data(d);
	}
	static inline struct msi_desc *get_irq_msi(unsigned int irq)
	{
	return irq_get_msi_desc(irq);
	}
	static inline void set_irq_noprobe(unsigned int irq)
	{
	irq_set_noprobe(irq);
	}
	static inline void set_irq_probe(unsigned int irq)
	{
	irq_set_probe(irq);
	}
	static inline void set_irq_nested_thread(unsigned int irq, int nest)
	{
	irq_set_nested_thread(irq, nest);
	}
	static inline void
	set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
	irq_flow_handler_t handle, const char *name)
	{
	irq_set_chip_and_handler_name(irq, chip, handle, name);
	}
	static inline void
	set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
	irq_flow_handler_t handle)
	{
	irq_set_chip_and_handler(irq, chip, handle);
	}
	static inline void
	__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
	const char *name)
	{
	__irq_set_handler(irq, handle, is_chained, name);
	}
	static inline void set_irq_handler(unsigned int irq, irq_flow_handler_t handle)
	{
	irq_set_handler(irq, handle);
	}
	static inline void
	set_irq_chained_handler(unsigned int irq, irq_flow_handler_t handle)
	{
	irq_set_chained_handler(irq, handle);
	}
	#endif

	int irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node);		int irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node);
	void irq_free_descs(unsigned int irq, unsigned int cnt);		void irq_free_descs(unsigned int irq, unsigned int cnt);
	int irq_reserve_irqs(unsigned int from, unsigned int cnt);		int irq_reserve_irqs(unsigned int from, unsigned int cnt);

include/linux/irqdesc.h

+1 −59

Original line number	Original line	Diff line number	Diff line
	@@ -35,32 +35,7 @@ struct timer_rand_state;
	* @name: flow handler name for /proc/interrupts output		* @name: flow handler name for /proc/interrupts output
	*/		*/
	struct irq_desc {		struct irq_desc {

	#ifdef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
	struct irq_data irq_data;
	#else
	/*
	* This union will go away, once we fixed the direct access to
	* irq_desc all over the place. The direct fields are a 1:1
	* overlay of irq_data.
	*/
	union {
	struct irq_data irq_data;		struct irq_data irq_data;
	struct {
	unsigned int irq;
	unsigned int node;
	unsigned int pad_do_not_even_think_about_it;
	struct irq_chip *chip;
	void *handler_data;
	void *chip_data;
	struct msi_desc *msi_desc;
	#ifdef CONFIG_SMP
	cpumask_var_t affinity;
	#endif
	};
	};
	#endif

	struct timer_rand_state *timer_rand_state;		struct timer_rand_state *timer_rand_state;
	unsigned int __percpu *kstat_irqs;		unsigned int __percpu *kstat_irqs;
	irq_flow_handler_t handle_irq;		irq_flow_handler_t handle_irq;
	@@ -68,11 +43,7 @@ struct irq_desc {
	irq_preflow_handler_t preflow_handler;		irq_preflow_handler_t preflow_handler;
	#endif		#endif
	struct irqaction action; / IRQ action list */		struct irqaction action; / IRQ action list */
	#ifdef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
	unsigned int status_use_accessors;		unsigned int status_use_accessors;
	#else
	unsigned int status; /* IRQ status */
	#endif
	unsigned int core_internal_state__do_not_mess_with_it;		unsigned int core_internal_state__do_not_mess_with_it;
	unsigned int depth; /* nested irq disables */		unsigned int depth; /* nested irq disables */
	unsigned int wake_depth; /* nested wake enables */		unsigned int wake_depth; /* nested wake enables */
	@@ -127,27 +98,6 @@ static inline struct msi_desc irq_desc_get_msi_desc(struct irq_desc desc)
	return desc->irq_data.msi_desc;		return desc->irq_data.msi_desc;
	}		}

	#ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
	static inline struct irq_chip get_irq_desc_chip(struct irq_desc desc)
	{
	return irq_desc_get_chip(desc);
	}
	static inline void get_irq_desc_data(struct irq_desc desc)
	{
	return irq_desc_get_handler_data(desc);
	}

	static inline void get_irq_desc_chip_data(struct irq_desc desc)
	{
	return irq_desc_get_chip_data(desc);
	}

	static inline struct msi_desc get_irq_desc_msi(struct irq_desc desc)
	{
	return irq_desc_get_msi_desc(desc);
	}
	#endif

	/*		/*
	* Architectures call this to let the generic IRQ layer		* Architectures call this to let the generic IRQ layer
	* handle an interrupt. If the descriptor is attached to an		* handle an interrupt. If the descriptor is attached to an
	@@ -194,21 +144,13 @@ __irq_set_chip_handler_name_locked(unsigned int irq, struct irq_chip *chip,
	desc->name = name;		desc->name = name;
	}		}

	#ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
	static inline void __set_irq_handler_unlocked(int irq,
	irq_flow_handler_t handler)
	{
	__irq_set_handler_locked(irq, handler);
	}

	static inline int irq_balancing_disabled(unsigned int irq)		static inline int irq_balancing_disabled(unsigned int irq)
	{		{
	struct irq_desc *desc;		struct irq_desc *desc;

	desc = irq_to_desc(irq);		desc = irq_to_desc(irq);
	return desc->status & IRQ_NO_BALANCING_MASK;		return desc->status_use_accessors & IRQ_NO_BALANCING_MASK;
	}		}
	#endif

	static inline void		static inline void
	irq_set_lockdep_class(unsigned int irq, struct lock_class_key *class)		irq_set_lockdep_class(unsigned int irq, struct lock_class_key *class)

kernel/irq/Kconfig

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -10,10 +10,6 @@ menu "IRQ subsystem"
	config GENERIC_HARDIRQS		config GENERIC_HARDIRQS
	def_bool y		def_bool y

	# Select this to disable the deprecated stuff
	config GENERIC_HARDIRQS_NO_DEPRECATED
	bool

	config GENERIC_HARDIRQS_NO_COMPAT		config GENERIC_HARDIRQS_NO_COMPAT
	bool		bool

kernel/irq/autoprobe.c

+1 −3

Original line number	Original line	Diff line number	Diff line
	@@ -70,11 +70,9 @@ unsigned long probe_irq_on(void)
	raw_spin_lock_irq(&desc->lock);		raw_spin_lock_irq(&desc->lock);
	if (!desc->action && irq_settings_can_probe(desc)) {		if (!desc->action && irq_settings_can_probe(desc)) {
	desc->istate \|= IRQS_AUTODETECT \| IRQS_WAITING;		desc->istate \|= IRQS_AUTODETECT \| IRQS_WAITING;
	if (irq_startup(desc)) {		if (irq_startup(desc))
	irq_compat_set_pending(desc);
	desc->istate \|= IRQS_PENDING;		desc->istate \|= IRQS_PENDING;
	}		}
	}
	raw_spin_unlock_irq(&desc->lock);		raw_spin_unlock_irq(&desc->lock);
	}		}

kernel/irq/chip.c

+0 −129

Original line number	Original line	Diff line number	Diff line
	@@ -34,7 +34,6 @@ int irq_set_chip(unsigned int irq, struct irq_chip *chip)
	if (!chip)		if (!chip)
	chip = &no_irq_chip;		chip = &no_irq_chip;

	irq_chip_set_defaults(chip);
	desc->irq_data.chip = chip;		desc->irq_data.chip = chip;
	irq_put_desc_unlock(desc, flags);		irq_put_desc_unlock(desc, flags);
	/*		/*
	@@ -141,25 +140,21 @@ EXPORT_SYMBOL_GPL(irq_get_irq_data);
	static void irq_state_clr_disabled(struct irq_desc *desc)		static void irq_state_clr_disabled(struct irq_desc *desc)
	{		{
	irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);		irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
	irq_compat_clr_disabled(desc);
	}		}

	static void irq_state_set_disabled(struct irq_desc *desc)		static void irq_state_set_disabled(struct irq_desc *desc)
	{		{
	irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);		irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
	irq_compat_set_disabled(desc);
	}		}

	static void irq_state_clr_masked(struct irq_desc *desc)		static void irq_state_clr_masked(struct irq_desc *desc)
	{		{
	irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);		irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
	irq_compat_clr_masked(desc);
	}		}

	static void irq_state_set_masked(struct irq_desc *desc)		static void irq_state_set_masked(struct irq_desc *desc)
	{		{
	irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);		irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
	irq_compat_set_masked(desc);
	}		}

	int irq_startup(struct irq_desc *desc)		int irq_startup(struct irq_desc *desc)
	@@ -209,126 +204,6 @@ void irq_disable(struct irq_desc *desc)
	}		}
	}		}

	#ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
	/* Temporary migration helpers */
	static void compat_irq_mask(struct irq_data *data)
	{
	data->chip->mask(data->irq);
	}

	static void compat_irq_unmask(struct irq_data *data)
	{
	data->chip->unmask(data->irq);
	}

	static void compat_irq_ack(struct irq_data *data)
	{
	data->chip->ack(data->irq);
	}

	static void compat_irq_mask_ack(struct irq_data *data)
	{
	data->chip->mask_ack(data->irq);
	}

	static void compat_irq_eoi(struct irq_data *data)
	{
	data->chip->eoi(data->irq);
	}

	static void compat_irq_enable(struct irq_data *data)
	{
	data->chip->enable(data->irq);
	}

	static void compat_irq_disable(struct irq_data *data)
	{
	data->chip->disable(data->irq);
	}

	static void compat_irq_shutdown(struct irq_data *data)
	{
	data->chip->shutdown(data->irq);
	}

	static unsigned int compat_irq_startup(struct irq_data *data)
	{
	return data->chip->startup(data->irq);
	}

	static int compat_irq_set_affinity(struct irq_data *data,
	const struct cpumask *dest, bool force)
	{
	return data->chip->set_affinity(data->irq, dest);
	}

	static int compat_irq_set_type(struct irq_data *data, unsigned int type)
	{
	return data->chip->set_type(data->irq, type);
	}

	static int compat_irq_set_wake(struct irq_data *data, unsigned int on)
	{
	return data->chip->set_wake(data->irq, on);
	}

	static int compat_irq_retrigger(struct irq_data *data)
	{
	return data->chip->retrigger(data->irq);
	}

	static void compat_bus_lock(struct irq_data *data)
	{
	data->chip->bus_lock(data->irq);
	}

	static void compat_bus_sync_unlock(struct irq_data *data)
	{
	data->chip->bus_sync_unlock(data->irq);
	}
	#endif

	/*
	* Fixup enable/disable function pointers
	*/
	void irq_chip_set_defaults(struct irq_chip *chip)
	{
	#ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
	if (chip->enable)
	chip->irq_enable = compat_irq_enable;
	if (chip->disable)
	chip->irq_disable = compat_irq_disable;
	if (chip->shutdown)
	chip->irq_shutdown = compat_irq_shutdown;
	if (chip->startup)
	chip->irq_startup = compat_irq_startup;
	if (!chip->end)
	chip->end = dummy_irq_chip.end;
	if (chip->bus_lock)
	chip->irq_bus_lock = compat_bus_lock;
	if (chip->bus_sync_unlock)
	chip->irq_bus_sync_unlock = compat_bus_sync_unlock;
	if (chip->mask)
	chip->irq_mask = compat_irq_mask;
	if (chip->unmask)
	chip->irq_unmask = compat_irq_unmask;
	if (chip->ack)
	chip->irq_ack = compat_irq_ack;
	if (chip->mask_ack)
	chip->irq_mask_ack = compat_irq_mask_ack;
	if (chip->eoi)
	chip->irq_eoi = compat_irq_eoi;
	if (chip->set_affinity)
	chip->irq_set_affinity = compat_irq_set_affinity;
	if (chip->set_type)
	chip->irq_set_type = compat_irq_set_type;
	if (chip->set_wake)
	chip->irq_set_wake = compat_irq_set_wake;
	if (chip->retrigger)
	chip->irq_retrigger = compat_irq_retrigger;
	#endif
	}

	static inline void mask_ack_irq(struct irq_desc *desc)		static inline void mask_ack_irq(struct irq_desc *desc)
	{		{
	if (desc->irq_data.chip->irq_mask_ack)		if (desc->irq_data.chip->irq_mask_ack)
	@@ -381,7 +256,6 @@ void handle_nested_irq(unsigned int irq)
	if (unlikely(!action \|\| irqd_irq_disabled(&desc->irq_data)))		if (unlikely(!action \|\| irqd_irq_disabled(&desc->irq_data)))
	goto out_unlock;		goto out_unlock;

	irq_compat_set_progress(desc);
	irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);		irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
	raw_spin_unlock_irq(&desc->lock);		raw_spin_unlock_irq(&desc->lock);

	@@ -391,7 +265,6 @@ void handle_nested_irq(unsigned int irq)

	raw_spin_lock_irq(&desc->lock);		raw_spin_lock_irq(&desc->lock);
	irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);		irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
	irq_compat_clr_progress(desc);

	out_unlock:		out_unlock:
	raw_spin_unlock_irq(&desc->lock);		raw_spin_unlock_irq(&desc->lock);
	@@ -514,7 +387,6 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
	* then mask it and get out of here:		* then mask it and get out of here:
	*/		*/
	if (unlikely(!desc->action \|\| irqd_irq_disabled(&desc->irq_data))) {		if (unlikely(!desc->action \|\| irqd_irq_disabled(&desc->irq_data))) {
	irq_compat_set_pending(desc);
	desc->istate \|= IRQS_PENDING;		desc->istate \|= IRQS_PENDING;
	mask_irq(desc);		mask_irq(desc);
	goto out;		goto out;
	@@ -567,7 +439,6 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
	if (unlikely(irqd_irq_disabled(&desc->irq_data) \|\|		if (unlikely(irqd_irq_disabled(&desc->irq_data) \|\|
	irqd_irq_inprogress(&desc->irq_data) \|\| !desc->action)) {		irqd_irq_inprogress(&desc->irq_data) \|\| !desc->action)) {
	if (!irq_check_poll(desc)) {		if (!irq_check_poll(desc)) {
	irq_compat_set_pending(desc);
	desc->istate \|= IRQS_PENDING;		desc->istate \|= IRQS_PENDING;
	mask_ack_irq(desc);		mask_ack_irq(desc);
	goto out_unlock;		goto out_unlock;