| /* Copyright (c) 2015, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| #include <linux/bitops.h> |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/sched.h> |
| #include <linux/irq.h> |
| #include <linux/delay.h> |
| #include <linux/of.h> |
| #include <linux/of_irq.h> |
| #include <linux/slab.h> |
| #include <linux/ratelimit.h> |
| #include <linux/pm_qos.h> |
| #include <soc/qcom/pm.h> |
| #include "wsa881x-irq.h" |
| #include "wsa881x-registers-analog.h" |
| |
| #define BYTE_BIT_MASK(nr) (1UL << ((nr) % BITS_PER_BYTE)) |
| #define BIT_BYTE(nr) ((nr) / BITS_PER_BYTE) |
| |
| |
| #define WSA_MAX_NUM_IRQS 8 |
| |
| #ifndef NO_IRQ |
| #define NO_IRQ (-1) |
| #endif |
| |
| static int virq_to_phyirq( |
| struct wsa_resource *wsa_res, int virq); |
| static int phyirq_to_virq( |
| struct wsa_resource *wsa_res, int irq); |
| static unsigned int wsa_irq_get_upstream_irq( |
| struct wsa_resource *wsa_res); |
| static void wsa_irq_put_upstream_irq( |
| struct wsa_resource *wsa_res); |
| static int wsa_map_irq( |
| struct wsa_resource *wsa_res, int irq); |
| |
| static struct snd_soc_codec *ptr_codec; |
| |
| /** |
| * wsa_set_codec() - to update codec pointer |
| * @codec: codec pointer. |
| * |
| * To update the codec pointer, which is used to read/write |
| * wsa register. |
| * |
| * Return: void. |
| */ |
| void wsa_set_codec(struct snd_soc_codec *codec) |
| { |
| if (codec == NULL) { |
| pr_err("%s: codec pointer is NULL\n", __func__); |
| ptr_codec = NULL; |
| return; |
| } |
| ptr_codec = codec; |
| /* Initialize interrupt mask and level registers */ |
| snd_soc_write(codec, WSA881X_INTR_LEVEL, 0x8F); |
| snd_soc_write(codec, WSA881X_INTR_MASK, 0x8F); |
| } |
| |
| static void wsa_irq_lock(struct irq_data *data) |
| { |
| struct wsa_resource *wsa_res = |
| irq_data_get_irq_chip_data(data); |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res pointer is NULL\n", __func__); |
| return; |
| } |
| mutex_lock(&wsa_res->irq_lock); |
| } |
| |
| static void wsa_irq_sync_unlock(struct irq_data *data) |
| { |
| struct wsa_resource *wsa_res = |
| irq_data_get_irq_chip_data(data); |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res pointer is NULL\n", __func__); |
| return; |
| } |
| if (wsa_res->codec == NULL) { |
| pr_err("%s: codec pointer not registered\n", __func__); |
| if (ptr_codec == NULL) { |
| pr_err("%s: did not receive valid codec pointer\n", |
| __func__); |
| goto unlock; |
| } else { |
| wsa_res->codec = ptr_codec; |
| } |
| } |
| |
| /* |
| * If there's been a change in the mask write it back |
| * to the hardware. |
| */ |
| if (wsa_res->irq_masks_cur != |
| wsa_res->irq_masks_cache) { |
| |
| wsa_res->irq_masks_cache = |
| wsa_res->irq_masks_cur; |
| snd_soc_write(wsa_res->codec, |
| WSA881X_INTR_MASK, |
| wsa_res->irq_masks_cur); |
| } |
| unlock: |
| mutex_unlock(&wsa_res->irq_lock); |
| } |
| |
| static void wsa_irq_enable(struct irq_data *data) |
| { |
| struct wsa_resource *wsa_res = |
| irq_data_get_irq_chip_data(data); |
| int wsa_irq; |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res pointer is NULL\n", __func__); |
| return; |
| } |
| wsa_irq = virq_to_phyirq(wsa_res, data->irq); |
| pr_debug("%s: wsa_irq = %d\n", __func__, wsa_irq); |
| wsa_res->irq_masks_cur &= |
| ~(BYTE_BIT_MASK(wsa_irq)); |
| } |
| |
| static void wsa_irq_disable(struct irq_data *data) |
| { |
| struct wsa_resource *wsa_res = |
| irq_data_get_irq_chip_data(data); |
| int wsa_irq; |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res pointer is NULL\n", __func__); |
| return; |
| } |
| wsa_irq = virq_to_phyirq(wsa_res, data->irq); |
| pr_debug("%s: wsa_irq = %d\n", __func__, wsa_irq); |
| wsa_res->irq_masks_cur |
| |= BYTE_BIT_MASK(wsa_irq); |
| } |
| |
| static void wsa_irq_ack(struct irq_data *data) |
| { |
| int wsa_irq = 0; |
| struct wsa_resource *wsa_res = |
| irq_data_get_irq_chip_data(data); |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return; |
| } |
| wsa_irq = virq_to_phyirq(wsa_res, data->irq); |
| pr_debug("%s: IRQ_ACK called for WCD9XXX IRQ: %d\n", |
| __func__, wsa_irq); |
| } |
| |
| static void wsa_irq_mask(struct irq_data *d) |
| { |
| /* do nothing but required as linux calls irq_mask without NULL check */ |
| } |
| |
| static struct irq_chip wsa_irq_chip = { |
| .name = "wsa", |
| .irq_bus_lock = wsa_irq_lock, |
| .irq_bus_sync_unlock = wsa_irq_sync_unlock, |
| .irq_disable = wsa_irq_disable, |
| .irq_enable = wsa_irq_enable, |
| .irq_mask = wsa_irq_mask, |
| .irq_ack = wsa_irq_ack, |
| }; |
| |
| static irqreturn_t wsa_irq_thread(int irq, void *data) |
| { |
| struct wsa_resource *wsa_res = data; |
| int i; |
| u8 status; |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return IRQ_HANDLED; |
| } |
| if (wsa_res->codec == NULL) { |
| pr_err("%s: codec pointer not registered\n", __func__); |
| if (ptr_codec == NULL) { |
| pr_err("%s: did not receive valid codec pointer\n", |
| __func__); |
| return IRQ_HANDLED; |
| } |
| wsa_res->codec = ptr_codec; |
| } |
| status = snd_soc_read(wsa_res->codec, WSA881X_INTR_STATUS); |
| /* Apply masking */ |
| status &= ~wsa_res->irq_masks_cur; |
| |
| for (i = 0; i < wsa_res->num_irqs; i++) { |
| if (status & BYTE_BIT_MASK(i)) { |
| mutex_lock(&wsa_res->nested_irq_lock); |
| handle_nested_irq(phyirq_to_virq(wsa_res, i)); |
| mutex_unlock(&wsa_res->nested_irq_lock); |
| } |
| } |
| |
| return IRQ_HANDLED; |
| } |
| |
| /** |
| * wsa_free_irq() - to free an interrupt |
| * @irq: interrupt number. |
| * @data: pointer to wsa resource. |
| * |
| * To free already requested interrupt. |
| * |
| * Return: void. |
| */ |
| void wsa_free_irq(int irq, void *data) |
| { |
| struct wsa_resource *wsa_res = data; |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return; |
| } |
| free_irq(phyirq_to_virq(wsa_res, irq), data); |
| } |
| |
| /** |
| * wsa_enable_irq() - to enable an interrupt |
| * @wsa_res: pointer to wsa resource. |
| * @irq: interrupt number. |
| * |
| * This function is to enable an interrupt. |
| * |
| * Return: void. |
| */ |
| void wsa_enable_irq(struct wsa_resource *wsa_res, int irq) |
| { |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return; |
| } |
| enable_irq(phyirq_to_virq(wsa_res, irq)); |
| } |
| |
| /** |
| * wsa_disable_irq() - to disable an interrupt |
| * @wsa_res: pointer to wsa resource. |
| * @irq: interrupt number. |
| * |
| * To disable an interrupt without waiting for executing |
| * handler to complete. |
| * |
| * Return: void. |
| */ |
| void wsa_disable_irq(struct wsa_resource *wsa_res, int irq) |
| { |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return; |
| } |
| disable_irq_nosync(phyirq_to_virq(wsa_res, irq)); |
| } |
| |
| /** |
| * wsa_disable_irq_sync() - to disable an interrupt |
| * @wsa_res: pointer to wsa resource. |
| * @irq: interrupt number. |
| * |
| * To disable an interrupt, wait for executing IRQ |
| * handler to complete. |
| * |
| * Return: void. |
| */ |
| void wsa_disable_irq_sync( |
| struct wsa_resource *wsa_res, int irq) |
| { |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return; |
| } |
| disable_irq(phyirq_to_virq(wsa_res, irq)); |
| } |
| |
| static int wsa_irq_setup_downstream_irq(struct wsa_resource *wsa_res) |
| { |
| int irq, virq, ret; |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return -EINVAL; |
| } |
| pr_debug("%s: enter\n", __func__); |
| |
| for (irq = 0; irq < wsa_res->num_irqs; irq++) { |
| /* Map OF irq */ |
| virq = wsa_map_irq(wsa_res, irq); |
| pr_debug("%s: irq %d -> %d\n", __func__, irq, virq); |
| if (virq == NO_IRQ) { |
| pr_err("%s, No interrupt specifier for irq %d\n", |
| __func__, irq); |
| return NO_IRQ; |
| } |
| |
| ret = irq_set_chip_data(virq, wsa_res); |
| if (ret) { |
| pr_err("%s: Failed to configure irq %d (%d)\n", |
| __func__, irq, ret); |
| return ret; |
| } |
| |
| if (wsa_res->irq_level_high[irq]) |
| irq_set_chip_and_handler(virq, &wsa_irq_chip, |
| handle_level_irq); |
| else |
| irq_set_chip_and_handler(virq, &wsa_irq_chip, |
| handle_edge_irq); |
| |
| irq_set_nested_thread(virq, 1); |
| } |
| |
| pr_debug("%s: leave\n", __func__); |
| |
| return 0; |
| } |
| |
| static int wsa_irq_init(struct wsa_resource *wsa_res) |
| { |
| int i, ret; |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return -EINVAL; |
| } |
| mutex_init(&wsa_res->irq_lock); |
| mutex_init(&wsa_res->nested_irq_lock); |
| |
| wsa_res->irq = wsa_irq_get_upstream_irq(wsa_res); |
| if (!wsa_res->irq) { |
| pr_warn("%s: irq driver is not yet initialized\n", __func__); |
| mutex_destroy(&wsa_res->irq_lock); |
| mutex_destroy(&wsa_res->nested_irq_lock); |
| return -EPROBE_DEFER; |
| } |
| pr_debug("%s: probed irq %d\n", __func__, wsa_res->irq); |
| |
| /* Setup downstream IRQs */ |
| ret = wsa_irq_setup_downstream_irq(wsa_res); |
| if (ret) { |
| pr_err("%s: Failed to setup downstream IRQ\n", __func__); |
| goto fail_irq_init; |
| } |
| |
| /* mask all the interrupts */ |
| for (i = 0; i < wsa_res->num_irqs; i++) { |
| wsa_res->irq_masks_cur |= BYTE_BIT_MASK(i); |
| wsa_res->irq_masks_cache |= BYTE_BIT_MASK(i); |
| } |
| |
| ret = request_threaded_irq(wsa_res->irq, NULL, wsa_irq_thread, |
| IRQF_TRIGGER_HIGH | IRQF_ONESHOT, |
| "wsa", wsa_res); |
| if (ret != 0) { |
| dev_err(wsa_res->dev, "Failed to request IRQ %d: %d\n", |
| wsa_res->irq, ret); |
| } else { |
| ret = enable_irq_wake(wsa_res->irq); |
| if (ret) { |
| dev_err(wsa_res->dev, |
| "Failed to set wake interrupt on IRQ %d: %d\n", |
| wsa_res->irq, ret); |
| free_irq(wsa_res->irq, wsa_res); |
| } |
| } |
| |
| if (ret) |
| goto fail_irq_init; |
| |
| return ret; |
| |
| fail_irq_init: |
| dev_err(wsa_res->dev, |
| "%s: Failed to init wsa irq\n", __func__); |
| wsa_irq_put_upstream_irq(wsa_res); |
| mutex_destroy(&wsa_res->irq_lock); |
| mutex_destroy(&wsa_res->nested_irq_lock); |
| return ret; |
| } |
| |
| /** |
| * wsa_request_irq() - to request/register an interrupt |
| * @wsa_res: pointer to wsa_resource. |
| * @irq: interrupt number. |
| * @handler: interrupt handler function pointer. |
| * @name: interrupt name. |
| * @data: device info. |
| * |
| * Convert physical irq to virtual irq and then |
| * reguest for threaded handler. |
| * |
| * Return: Retuns success/failure. |
| */ |
| int wsa_request_irq(struct wsa_resource *wsa_res, |
| int irq, irq_handler_t handler, |
| const char *name, void *data) |
| { |
| int virq; |
| |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return -EINVAL; |
| } |
| virq = phyirq_to_virq(wsa_res, irq); |
| |
| /* |
| * ARM needs us to explicitly flag the IRQ as valid |
| * and will set them noprobe when we do so. |
| */ |
| #if defined(CONFIG_ARM) || defined(CONFIG_ARM64) |
| set_irq_flags(virq, IRQF_VALID); |
| #else |
| set_irq_noprobe(virq); |
| #endif |
| |
| return request_threaded_irq(virq, NULL, handler, IRQF_TRIGGER_RISING, |
| name, data); |
| } |
| |
| /** |
| * wsa_irq_exit() - to disable/clear interrupt/resources |
| * @wsa_res: pointer to wsa_resource |
| * |
| * Disable and free the interrupts and then release resources. |
| * |
| * Return: void. |
| */ |
| void wsa_irq_exit(struct wsa_resource *wsa_res) |
| { |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return; |
| } |
| dev_dbg(wsa_res->dev, "%s: Cleaning up irq %d\n", __func__, |
| wsa_res->irq); |
| |
| if (wsa_res->irq) { |
| disable_irq_wake(wsa_res->irq); |
| free_irq(wsa_res->irq, wsa_res); |
| /* Release parent's of node */ |
| wsa_irq_put_upstream_irq(wsa_res); |
| } |
| mutex_destroy(&wsa_res->irq_lock); |
| mutex_destroy(&wsa_res->nested_irq_lock); |
| } |
| |
| static int phyirq_to_virq(struct wsa_resource *wsa_res, int offset) |
| { |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return -EINVAL; |
| } |
| return irq_linear_revmap(wsa_res->domain, offset); |
| } |
| |
| static int virq_to_phyirq(struct wsa_resource *wsa_res, int virq) |
| { |
| struct irq_data *irq_data = irq_get_irq_data(virq); |
| |
| if (unlikely(!irq_data)) { |
| pr_err("%s: irq_data is NULL\n", __func__); |
| return -EINVAL; |
| } |
| return irq_data->hwirq; |
| } |
| |
| static unsigned int wsa_irq_get_upstream_irq(struct wsa_resource *wsa_res) |
| { |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return -EINVAL; |
| } |
| return wsa_res->irq; |
| } |
| |
| static void wsa_irq_put_upstream_irq(struct wsa_resource *wsa_res) |
| { |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return; |
| } |
| /* Hold parent's of node */ |
| of_node_put(wsa_res->dev->of_node); |
| } |
| |
| static int wsa_map_irq(struct wsa_resource *wsa_res, int irq) |
| { |
| if (wsa_res == NULL) { |
| pr_err("%s: wsa_res is NULL\n", __func__); |
| return -EINVAL; |
| } |
| return of_irq_to_resource(wsa_res->dev->of_node, irq, NULL); |
| } |
| |
| static int wsa_irq_probe(struct platform_device *pdev) |
| { |
| int irq; |
| struct wsa_resource *wsa_res = NULL; |
| int ret = -EINVAL; |
| |
| irq = platform_get_irq_byname(pdev, "wsa-int"); |
| if (irq < 0) { |
| dev_err(&pdev->dev, "%s: Couldn't find wsa-int node(%d)\n", |
| __func__, irq); |
| return -EINVAL; |
| } |
| pr_debug("%s: node %s\n", __func__, pdev->name); |
| wsa_res = kzalloc(sizeof(*wsa_res), GFP_KERNEL); |
| if (!wsa_res) { |
| pr_err("%s: could not allocate memory\n", __func__); |
| return -ENOMEM; |
| } |
| /* |
| * wsa interrupt controller supports N to N irq mapping with |
| * single cell binding with irq numbers(offsets) only. |
| * Use irq_domain_simple_ops that has irq_domain_simple_map and |
| * irq_domain_xlate_onetwocell. |
| */ |
| wsa_res->dev = &pdev->dev; |
| wsa_res->domain = irq_domain_add_linear(wsa_res->dev->of_node, |
| WSA_MAX_NUM_IRQS, &irq_domain_simple_ops, |
| wsa_res); |
| if (!wsa_res->domain) { |
| dev_err(&pdev->dev, "%s: domain is NULL\n", __func__); |
| ret = -ENOMEM; |
| goto err; |
| } |
| wsa_res->dev = &pdev->dev; |
| |
| dev_dbg(&pdev->dev, "%s: virq = %d\n", __func__, irq); |
| wsa_res->irq = irq; |
| wsa_res->num_irq_regs = 1; |
| wsa_res->num_irqs = WSA_NUM_IRQS; |
| ret = wsa_irq_init(wsa_res); |
| if (ret < 0) { |
| dev_err(&pdev->dev, "%s: failed to do irq init %d\n", |
| __func__, ret); |
| goto err; |
| } |
| |
| return ret; |
| err: |
| kfree(wsa_res); |
| return ret; |
| } |
| |
| static int wsa_irq_remove(struct platform_device *pdev) |
| { |
| struct irq_domain *domain; |
| struct wsa_resource *data; |
| |
| domain = irq_find_host(pdev->dev.of_node); |
| if (unlikely(!domain)) { |
| pr_err("%s: domain is NULL\n", __func__); |
| return -EINVAL; |
| } |
| data = (struct wsa_resource *)domain->host_data; |
| data->irq = 0; |
| |
| return 0; |
| } |
| |
| static const struct of_device_id of_match[] = { |
| { .compatible = "qcom,wsa-irq" }, |
| { } |
| }; |
| |
| static struct platform_driver wsa_irq_driver = { |
| .probe = wsa_irq_probe, |
| .remove = wsa_irq_remove, |
| .driver = { |
| .name = "wsa_intc", |
| .owner = THIS_MODULE, |
| .of_match_table = of_match_ptr(of_match), |
| }, |
| }; |
| |
| static int wsa_irq_drv_init(void) |
| { |
| return platform_driver_register(&wsa_irq_driver); |
| } |
| subsys_initcall(wsa_irq_drv_init); |
| |
| static void wsa_irq_drv_exit(void) |
| { |
| platform_driver_unregister(&wsa_irq_driver); |
| } |
| module_exit(wsa_irq_drv_exit); |
| |
| MODULE_DESCRIPTION("WSA881x IRQ driver"); |
| MODULE_LICENSE("GPL v2"); |