611 lines
14 KiB
C
611 lines
14 KiB
C
|
/* 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");
|