/*

* MCP2210 software IRQ controller

*

* Copyright (c) 2013-2017 Daniel Santos <daniel.santos@pobox.com>

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* 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.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

*/

#include "mcp2210.h"

#include "mcp2210-debug.h"

#ifdef CONFIG_MCP2210_IRQ

#include <linux/irq.h>

static int complete_poll(struct mcp2210_cmd *cmd, void *context);

static void mcp2210_irq_mask(struct irq_data *data) {

struct mcp2210_device *dev = irq_data_get_irq_chip_data(data);

dev->irq_mask |= data->mask;

}

static void mcp2210_irq_unmask(struct irq_data *data) {

struct mcp2210_device *dev = irq_data_get_irq_chip_data(data);

dev->irq_mask &= ~data->mask;

}

static int mcp2210_irq_set_type(struct irq_data *data, unsigned int flow_type) {

struct mcp2210_device *dev = irq_data_get_irq_chip_data(data);

BUG_ON(data->hwirq > 7);

dev->irq_type[data->hwirq] = flow_type;

mcp2210_info("irq type set to 0x%02x", flow_type);

return 0;

}

static struct irq_chip mcp2210_irq_chip = {

.name = "mcp2210",

.irq_mask = mcp2210_irq_mask,

.irq_unmask = mcp2210_irq_unmask,

.irq_set_type = mcp2210_irq_set_type,

};

/******************************************************************************

* probe & remove

*/

int mcp2210_irq_probe(struct mcp2210_device *dev)

{

uint i;

int ret;

mcp2210_info();

mutex_init(&dev->irq_lock);

dev->nr_irqs = 0;

dev->poll_intr = 0;

dev->poll_gpio = 0;

for (i = 0; i < MCP2210_NUM_PINS; ++i) {

const struct mcp2210_pin_config *pin = &dev->config->pins[i];

if (pin->mode == MCP2210_PIN_SPI || !pin->has_irq)

continue;

++dev->nr_irqs;

BUG_ON(dev->irq_revmap[i]);

dev->irq_revmap[i] = pin->irq;

if (pin->mode == MCP2210_PIN_DEDICATED)

dev->poll_intr = 1;

else if (pin->mode == MCP2210_PIN_GPIO) {

dev->poll_gpio = 1;

dev->irq_type[i] = pin->irq_type;

}

}

if (!dev->nr_irqs)

return 0;

ret = irq_alloc_descs(-1, 0, dev->nr_irqs, 0);

if (ret < 0) {

/* CONFIG_SPARSE_IRQ needed? */

mcp2210_err("Failed to allocate %u irq descriptors: %d", dev->nr_irqs, ret);

return ret;

}

dev->irq_base = ret;

for (i = 0; i < dev->nr_irqs; ++i) {

int virq = dev->irq_base + i;

dev->irq_descs[i] = irq_to_desc(virq);

BUG_ON(!dev->irq_descs[i]);

irq_set_chip_data(virq, dev);

irq_set_chip(virq, &mcp2210_irq_chip);

#if defined(CONFIG_ARM) && LINUX_VERSION_CODE < KERNEL_VERSION(4,3,0)

set_irq_flags(virq, 0);

#else

irq_set_noprobe(virq);

#endif

}

#ifdef CONFIG_MCP2210_GPIO

if (dev->poll_gpio) {

ctl_cmd_init(dev, &dev->cmd_poll_gpio,

MCP2210_CMD_GET_PIN_VALUE, 0, NULL, 0, false);

dev->cmd_poll_gpio.head.complete = complete_poll;

mcp2210_add_cmd(&dev->cmd_poll_gpio.head, false);

}

#endif /* CONFIG_MCP2210_GPIO */

if (dev->poll_intr) {

/* read and then reset */

ctl_cmd_init(dev, &dev->cmd_poll_intr,

MCP2210_CMD_GET_INTERRUPTS, 0, NULL, 0, false);

dev->cmd_poll_intr.head.complete = complete_poll;

mcp2210_add_cmd(&dev->cmd_poll_intr.head, false);

}

dev->is_irq_probed = 1;

dev->suppress_poll_warn = 0;

return 0;

}

void mcp2210_irq_disable(struct mcp2210_device *dev)

{

mcp2210_info();

if (dev->is_irq_probed) {

const int virq_end = dev->irq_base + dev->nr_irqs;

int virq;

for (virq = dev->irq_base; virq < virq_end; ++virq) {

irq_set_status_flags(virq, IRQ_NOREQUEST);

irq_set_chip_and_handler(virq, NULL, NULL);

synchronize_irq(virq);

}

}

}

void mcp2210_irq_remove(struct mcp2210_device *dev)

{

mcp2210_info();

if (dev->is_irq_probed) {

const int virq_end = dev->irq_base + dev->nr_irqs;

int virq;

for (virq = dev->irq_base; virq < virq_end; ++virq) {

irq_free_desc(virq);

dev->irq_descs[virq] = NULL;

}

dev->is_irq_probed = 0;

}

}

/******************************************************************************

* polling and virtual IRQ trigger functions

*/

void mcp2210_irq_do_gpio(struct mcp2210_device *dev, u16 old_val, u16 new_val)

{

uint i;

for (i = 0; i < MCP2210_NUM_PINS; ++i) {

struct mcp2210_pin_config *pin = &dev->config->pins[i];

int old_pin_val;

int new_pin_val;

int edge_mask, level_mask;

struct irq_desc *desc;

if (!pin->has_irq || pin->mode != MCP2210_PIN_GPIO)

continue;

old_pin_val = old_val & (1 << i);

new_pin_val = new_val & (1 << i);

level_mask = new_pin_val ? IRQ_TYPE_LEVEL_HIGH

: IRQ_TYPE_LEVEL_LOW;

desc = dev->irq_descs[pin->irq];

if (new_pin_val > old_val)

edge_mask = IRQ_TYPE_EDGE_RISING;

else if (new_pin_val < old_val)

edge_mask = IRQ_TYPE_EDGE_FALLING;

else

edge_mask = 0;

if (pin->irq_type & edge_mask) {

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)

handle_simple_irq(desc);

#else

handle_simple_irq(dev->irq_base + pin->irq, desc);

#endif

}

if (pin->irq_type & level_mask) {

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)

handle_level_irq(desc);

#else

handle_level_irq(dev->irq_base + pin->irq, desc);

#endif

}

}

}

void _mcp2210_irq_do_intr_counter(struct mcp2210_device *dev, u16 count)

{

struct mcp2210_pin_config *pin = &dev->config->pins[6];

struct irq_desc *desc = dev->irq_descs[pin->irq];

if (dev->s.chip_settings.pin_mode[6] != MCP2210_PIN_DEDICATED)

return;

/* We're discarding count and just letting handlers know that at least

* one interrupt occured. Should this have a mechanism to report the

* interrupt once for each count? */

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)

handle_simple_irq(desc);

#else

handle_simple_irq(dev->irq_base + pin->irq, desc);

#endif

}

static void warn_poll_past_due(struct mcp2210_device *dev, unsigned long now,

long how_late)

{

mcp2210_warn("Next poll is past due by %ums.\n",

jiffies_to_msecs(how_late));

if (!poll_delay_warn_secs)

return;

/* If result ends up zero then it'll just repeat once */

dev->suppress_poll_warn = now + msecs_to_jiffies(1000

* poll_delay_warn_secs);

mcp2210_warn("...suppressing for %u seconds.\n", poll_delay_warn_secs);

}

static int complete_poll(struct mcp2210_cmd *cmd_head, void *context)

{

struct mcp2210_device *dev = cmd_head->dev;

struct mcp2210_cmd_ctl *cmd = (void*)cmd_head;

unsigned long now = jiffies;

int enabled;

unsigned long interval;

unsigned long interval_j;

unsigned long next;

long next_diff;

mcp2210_debug();

if (dev->dead)

return -EINPROGRESS;

if (cmd->req.cmd == MCP2210_CMD_GET_PIN_VALUE) {

enabled = dev->poll_gpio;

interval = dev->config->poll_gpio_usecs;

dev->last_poll_gpio = now;

} else {

enabled = dev->poll_intr;

interval = dev->config->poll_intr_usecs;

dev->last_poll_intr = now;

}

if (dev->suppress_poll_warn && jiffdiff(dev->suppress_poll_warn, now) <= 0)

dev->suppress_poll_warn = 0;

if (!enabled)

return -EINPROGRESS;

interval_j = usecs_to_jiffies(interval);

next = dev->eps[EP_OUT].submit_time + interval_j;

next_diff = jiffdiff(next, now);

cmd->head.delayed = 1;

if (next_diff < 0) {

next = now + interval_j;

if (!dev->suppress_poll_warn)

warn_poll_past_due(dev, now, -next_diff);

}

cmd->head.delay_until = next;

#if 0

mcp2210_debug("interval_j: %lu, submit_time: %lu, next: %lu, jiffies: %lu",

interval_j, dev->eps[EP_OUT].submit_time, next, jiffies);

#endif

cmd->head.state = MCP2210_STATE_NEW;

mcp2210_add_cmd(cmd_head, false);

return -EINPROGRESS; /* tell process_commands not to free us */

}

#endif /* CONFIG_MCP2210_IRQ */