Merge branch 'irq-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

* Cortina Systems Gemini interrupt controller

This interrupt controller is found on the Gemini SoCs.

Required properties:

- compatible: must be "cortina,gemini-interrupt-controller"

- reg: The register bank for the interrupt controller.

- interrupt-controller: Identifies the node as an interrupt controller

- #interrupt-cells: The number of cells to define the interrupts.

  Must be 2 as the controller can specify level or rising edge

  IRQs. The bindings follows the standard binding for controllers

  with two cells specified in

  interrupt-controller/interrupts.txt

Example:

interrupt-controller@48000000 {

	compatible = "cortina,gemini-interrupt-controller";

	reg = <0x48000000 0x1000>;

	interrupt-controller;

	#interrupt-cells = <2>;

};

  devm_request_any_context_irq()

  devm_request_irq()

  devm_request_threaded_irq()

  devm_irq_alloc_descs()

  devm_irq_alloc_desc()

  devm_irq_alloc_desc_at()

  devm_irq_alloc_desc_from()

  devm_irq_alloc_descs_from()

LED

  devm_led_classdev_register()

acpi-$(CONFIG_ACPI_NUMA)	+= numa.o

acpi-$(CONFIG_ACPI_PROCFS_POWER) += cm_sbs.o

acpi-y				+= acpi_lpat.o

acpi-$(CONFIG_ACPI_GENERIC_GSI) += gsi.o

acpi-$(CONFIG_ACPI_GENERIC_GSI) += irq.o

acpi-$(CONFIG_ACPI_WATCHDOG)	+= acpi_watchdog.o

# These are (potentially) separate modules

}

EXPORT_SYMBOL_GPL(acpi_unregister_gsi);

/**

 * acpi_get_irq_source_fwhandle() - Retrieve fwhandle from IRQ resource source.

 * @source: acpi_resource_source to use for the lookup.

 *

 * Description:

 * Retrieve the fwhandle of the device referenced by the given IRQ resource

 * source.

 *

 * Return:

 * The referenced device fwhandle or NULL on failure

 */

static struct fwnode_handle *

acpi_get_irq_source_fwhandle(const struct acpi_resource_source *source)

{

	struct fwnode_handle *result;

	struct acpi_device *device;

	acpi_handle handle;

	acpi_status status;

	if (!source->string_length)

		return acpi_gsi_domain_id;

	status = acpi_get_handle(NULL, source->string_ptr, &handle);

	if (WARN_ON(ACPI_FAILURE(status)))

		return NULL;

	device = acpi_bus_get_acpi_device(handle);

	if (WARN_ON(!device))

		return NULL;

	result = &device->fwnode;

	acpi_bus_put_acpi_device(device);

	return result;

}

/*

 * Context for the resource walk used to lookup IRQ resources.

 * Contains a return code, the lookup index, and references to the flags

 * and fwspec where the result is returned.

 */

struct acpi_irq_parse_one_ctx {

	int rc;

	unsigned int index;

	unsigned long *res_flags;

	struct irq_fwspec *fwspec;

};

/**

 * acpi_irq_parse_one_match - Handle a matching IRQ resource.

 * @fwnode: matching fwnode

 * @hwirq: hardware IRQ number

 * @triggering: triggering attributes of hwirq

 * @polarity: polarity attributes of hwirq

 * @polarity: polarity attributes of hwirq

 * @shareable: shareable attributes of hwirq

 * @ctx: acpi_irq_parse_one_ctx updated by this function

 *

 * Description:

 * Handle a matching IRQ resource by populating the given ctx with

 * the information passed.

 */

static inline void acpi_irq_parse_one_match(struct fwnode_handle *fwnode,

					    u32 hwirq, u8 triggering,

					    u8 polarity, u8 shareable,

					    struct acpi_irq_parse_one_ctx *ctx)

{

	if (!fwnode)

		return;

	ctx->rc = 0;

	*ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable);

	ctx->fwspec->fwnode = fwnode;

	ctx->fwspec->param[0] = hwirq;

	ctx->fwspec->param[1] = acpi_dev_get_irq_type(triggering, polarity);

	ctx->fwspec->param_count = 2;

}

/**

 * acpi_irq_parse_one_cb - Handle the given resource.

 * @ares: resource to handle

 * @context: context for the walk

 *

 * Description:

 * This is called by acpi_walk_resources passing each resource returned by

 * the _CRS method. We only inspect IRQ resources. Since IRQ resources

 * might contain multiple interrupts we check if the index is within this

 * one's interrupt array, otherwise we subtract the current resource IRQ

 * count from the lookup index to prepare for the next resource.

 * Once a match is found we call acpi_irq_parse_one_match to populate

 * the result and end the walk by returning AE_CTRL_TERMINATE.

 *

 * Return:

 * AE_OK if the walk should continue, AE_CTRL_TERMINATE if a matching

 * IRQ resource was found.

 */

static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares,

					 void *context)

{

	struct acpi_irq_parse_one_ctx *ctx = context;

	struct acpi_resource_irq *irq;

	struct acpi_resource_extended_irq *eirq;

	struct fwnode_handle *fwnode;

	switch (ares->type) {

	case ACPI_RESOURCE_TYPE_IRQ:

		irq = &ares->data.irq;

		if (ctx->index >= irq->interrupt_count) {

			ctx->index -= irq->interrupt_count;

			return AE_OK;

		}

		fwnode = acpi_gsi_domain_id;

		acpi_irq_parse_one_match(fwnode, irq->interrupts[ctx->index],

					 irq->triggering, irq->polarity,

					 irq->sharable, ctx);

		return AE_CTRL_TERMINATE;

	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:

		eirq = &ares->data.extended_irq;

		if (eirq->producer_consumer == ACPI_PRODUCER)

			return AE_OK;

		if (ctx->index >= eirq->interrupt_count) {

			ctx->index -= eirq->interrupt_count;

			return AE_OK;

		}

		fwnode = acpi_get_irq_source_fwhandle(&eirq->resource_source);

		acpi_irq_parse_one_match(fwnode, eirq->interrupts[ctx->index],

					 eirq->triggering, eirq->polarity,

					 eirq->sharable, ctx);

		return AE_CTRL_TERMINATE;

	}

	return AE_OK;

}

/**

 * acpi_irq_parse_one - Resolve an interrupt for a device

 * @handle: the device whose interrupt is to be resolved

 * @index: index of the interrupt to resolve

 * @fwspec: structure irq_fwspec filled by this function

 * @flags: resource flags filled by this function

 *

 * Description:

 * Resolves an interrupt for a device by walking its CRS resources to find

 * the appropriate ACPI IRQ resource and populating the given struct irq_fwspec

 * and flags.

 *

 * Return:

 * The result stored in ctx.rc by the callback, or the default -EINVAL value

 * if an error occurs.

 */

static int acpi_irq_parse_one(acpi_handle handle, unsigned int index,

			      struct irq_fwspec *fwspec, unsigned long *flags)

{

	struct acpi_irq_parse_one_ctx ctx = { -EINVAL, index, flags, fwspec };

	acpi_walk_resources(handle, METHOD_NAME__CRS, acpi_irq_parse_one_cb, &ctx);

	return ctx.rc;

}

/**

 * acpi_irq_get - Lookup an ACPI IRQ resource and use it to initialize resource.

 * @handle: ACPI device handle

 * @index:  ACPI IRQ resource index to lookup

 * @res:    Linux IRQ resource to initialize

 *

 * Description:

 * Look for the ACPI IRQ resource with the given index and use it to initialize

 * the given Linux IRQ resource.

 *

 * Return:

 * 0 on success

 * -EINVAL if an error occurs

 * -EPROBE_DEFER if the IRQ lookup/conversion failed

 */

int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)

{

	struct irq_fwspec fwspec;

	struct irq_domain *domain;

	unsigned long flags;

	int rc;

	rc = acpi_irq_parse_one(handle, index, &fwspec, &flags);

	if (rc)

		return rc;

	domain = irq_find_matching_fwnode(fwspec.fwnode, DOMAIN_BUS_ANY);

	if (!domain)

		return -EPROBE_DEFER;

	rc = irq_create_fwspec_mapping(&fwspec);

	if (rc <= 0)

		return -EINVAL;

	res->start = rc;

	res->end = rc;

	res->flags = flags;

	return 0;

}

EXPORT_SYMBOL_GPL(acpi_irq_get);

/**

 * acpi_set_irq_model - Setup the GSI irqdomain information

 * @model: the value assigned to acpi_irq_model

acpi_iospace_resource_valid(struct resource *res) { return true; }

#endif

#if IS_ENABLED(CONFIG_ACPI_GENERIC_GSI)

static inline bool is_gsi(struct acpi_resource_extended_irq *ext_irq)

{

	return ext_irq->resource_source.string_length == 0 &&

	       ext_irq->producer_consumer == ACPI_CONSUMER;

}

#else

static inline bool is_gsi(struct acpi_resource_extended_irq *ext_irq)

{

	return true;

}

#endif

static bool acpi_dev_resource_len_valid(u64 start, u64 end, u64 len, bool io)

{

	u64 reslen = end - start + 1;

			acpi_dev_irqresource_disabled(res, 0);

			return false;

		}

		if (is_gsi(ext_irq))

			acpi_dev_get_irqresource(res, ext_irq->interrupts[index],

					 ext_irq->triggering, ext_irq->polarity,

					 ext_irq->sharable, false);

		else

			acpi_dev_irqresource_disabled(res, 0);

		break;

	default:

		res->flags = 0;