/*
 * Intel MIC Platform Software Stack (MPSS)
 *
 * Copyright(c) 2013 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, 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.
 *
 * The full GNU General Public License is included in this distribution in
 * the file called "COPYING".
 *
 * Intel MIC Host driver.
 *
 */
#include <linux/pci.h>
#include <linux/interrupt.h>

#include "../common/mic_dev.h"
#include "mic_device.h"

static irqreturn_t mic_thread_fn(int irq, void *dev)
{
        struct mic_device *mdev = dev;
        struct mic_intr_info *intr_info = mdev->intr_info;
        struct mic_irq_info *irq_info = &mdev->irq_info;
        struct mic_intr_cb *intr_cb;
        struct pci_dev *pdev = container_of(mdev->sdev->parent,
                                            struct pci_dev, dev);
        int i;

        spin_lock(&irq_info->mic_thread_lock);
        for (i = intr_info->intr_start_idx[MIC_INTR_DB];
                        i < intr_info->intr_len[MIC_INTR_DB]; i++)
                if (test_and_clear_bit(i, &irq_info->mask)) {
                        list_for_each_entry(intr_cb, &irq_info->cb_list[i],
                                            list)
                                if (intr_cb->thread_fn)
                                        intr_cb->thread_fn(pdev->irq,
                                                         intr_cb->data);
                }
        spin_unlock(&irq_info->mic_thread_lock);
        return IRQ_HANDLED;
}
/**
 * mic_interrupt - Generic interrupt handler for
 * MSI and INTx based interrupts.
 */
static irqreturn_t mic_interrupt(int irq, void *dev)
{
        struct mic_device *mdev = dev;
        struct mic_intr_info *intr_info = mdev->intr_info;
        struct mic_irq_info *irq_info = &mdev->irq_info;
        struct mic_intr_cb *intr_cb;
        struct pci_dev *pdev = container_of(mdev->sdev->parent,
                                            struct pci_dev, dev);
        u32 mask;
        int i;

        mask = mdev->ops->ack_interrupt(mdev);
        if (!mask)
                return IRQ_NONE;

        spin_lock(&irq_info->mic_intr_lock);
        for (i = intr_info->intr_start_idx[MIC_INTR_DB];
                        i < intr_info->intr_len[MIC_INTR_DB]; i++)
                if (mask & BIT(i)) {
                        list_for_each_entry(intr_cb, &irq_info->cb_list[i],
                                            list)
                                if (intr_cb->handler)
                                        intr_cb->handler(pdev->irq,
                                                         intr_cb->data);
                        set_bit(i, &irq_info->mask);
                }
        spin_unlock(&irq_info->mic_intr_lock);
        return IRQ_WAKE_THREAD;
}

/* Return the interrupt offset from the index. Index is 0 based. */
static u16 mic_map_src_to_offset(struct mic_device *mdev,
                int intr_src, enum mic_intr_type type)
{
        if (type >= MIC_NUM_INTR_TYPES)
                return MIC_NUM_OFFSETS;
        if (intr_src >= mdev->intr_info->intr_len[type])
                return MIC_NUM_OFFSETS;

        return mdev->intr_info->intr_start_idx[type] + intr_src;
}

/* Return next available msix_entry. */
static struct msix_entry *mic_get_available_vector(struct mic_device *mdev)
{
        int i;
        struct mic_irq_info *info = &mdev->irq_info;

        for (i = 0; i < info->num_vectors; i++)
                if (!info->mic_msi_map[i])
                        return &info->msix_entries[i];
        return NULL;
}

/**
 * mic_register_intr_callback - Register a callback handler for the
 * given source id.
 *
 * @mdev: pointer to the mic_device instance
 * @idx: The source id to be registered.
 * @handler: The function to be called when the source id receives
 * the interrupt.
 * @thread_fn: thread fn. corresponding to the handler
 * @data: Private data of the requester.
 * Return the callback structure that was registered or an
 * appropriate error on failure.
 */
static struct mic_intr_cb *mic_register_intr_callback(struct mic_device *mdev,
                        u8 idx, irq_handler_t handler, irq_handler_t thread_fn,
                        void *data)
{
        struct mic_intr_cb *intr_cb;
        unsigned long flags;
        int rc;
        intr_cb = kmalloc(sizeof(*intr_cb), GFP_KERNEL);

        if (!intr_cb)
                return ERR_PTR(-ENOMEM);

        intr_cb->handler = handler;
        intr_cb->thread_fn = thread_fn;
        intr_cb->data = data;
        intr_cb->cb_id = ida_simple_get(&mdev->irq_info.cb_ida,
                0, 0, GFP_KERNEL);
        if (intr_cb->cb_id < 0) {
                rc = intr_cb->cb_id;
                goto ida_fail;
        }

        spin_lock(&mdev->irq_info.mic_thread_lock);
        spin_lock_irqsave(&mdev->irq_info.mic_intr_lock, flags);
        list_add_tail(&intr_cb->list, &mdev->irq_info.cb_list[idx]);
        spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock, flags);
        spin_unlock(&mdev->irq_info.mic_thread_lock);

        return intr_cb;
ida_fail:
        kfree(intr_cb);
        return ERR_PTR(rc);
}

/**
 * mic_unregister_intr_callback - Unregister the callback handler
 * identified by its callback id.
 *
 * @mdev: pointer to the mic_device instance
 * @idx: The callback structure id to be unregistered.
 * Return the source id that was unregistered or MIC_NUM_OFFSETS if no
 * such callback handler was found.
 */
static u8 mic_unregister_intr_callback(struct mic_device *mdev, u32 idx)
{
        struct list_head *pos, *tmp;
        struct mic_intr_cb *intr_cb;
        unsigned long flags;
        int i;

        spin_lock(&mdev->irq_info.mic_thread_lock);
        spin_lock_irqsave(&mdev->irq_info.mic_intr_lock, flags);
        for (i = 0;  i < MIC_NUM_OFFSETS; i++) {
                list_for_each_safe(pos, tmp, &mdev->irq_info.cb_list[i]) {
                        intr_cb = list_entry(pos, struct mic_intr_cb, list);
                        if (intr_cb->cb_id == idx) {
                                list_del(pos);
                                ida_simple_remove(&mdev->irq_info.cb_ida,
                                                  intr_cb->cb_id);
                                kfree(intr_cb);
                                spin_unlock_irqrestore(
                                        &mdev->irq_info.mic_intr_lock, flags);
                                spin_unlock(&mdev->irq_info.mic_thread_lock);
                                return i;
                        }
                }
        }
        spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock, flags);
        spin_unlock(&mdev->irq_info.mic_thread_lock);
        return MIC_NUM_OFFSETS;
}

/**
 * mic_setup_msix - Initializes MSIx interrupts.
 *
 * @mdev: pointer to mic_device instance
 *
 *
 * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
 */
static int mic_setup_msix(struct mic_device *mdev, struct pci_dev *pdev)
{
        int rc, i;
        int entry_size = sizeof(*mdev->irq_info.msix_entries);

        mdev->irq_info.msix_entries = kmalloc_array(MIC_MIN_MSIX,
                                                    entry_size, GFP_KERNEL);
        if (!mdev->irq_info.msix_entries) {
                rc = -ENOMEM;
                goto err_nomem1;
        }

        for (i = 0; i < MIC_MIN_MSIX; i++)
                mdev->irq_info.msix_entries[i].entry = i;

        rc = pci_enable_msix_exact(pdev, mdev->irq_info.msix_entries,
                MIC_MIN_MSIX);
        if (rc) {
                dev_dbg(&pdev->dev, "Error enabling MSIx. rc = %d\n", rc);
                goto err_enable_msix;
        }

        mdev->irq_info.num_vectors = MIC_MIN_MSIX;
        mdev->irq_info.mic_msi_map = kzalloc((sizeof(u32) *
                mdev->irq_info.num_vectors), GFP_KERNEL);

        if (!mdev->irq_info.mic_msi_map) {
                rc = -ENOMEM;
                goto err_nomem2;
        }

        dev_dbg(mdev->sdev->parent,
                "%d MSIx irqs setup\n", mdev->irq_info.num_vectors);
        return 0;
err_nomem2:
        pci_disable_msix(pdev);
err_enable_msix:
        kfree(mdev->irq_info.msix_entries);
err_nomem1:
        mdev->irq_info.num_vectors = 0;
        return rc;
}

/**
 * mic_setup_callbacks - Initialize data structures needed
 * to handle callbacks.
 *
 * @mdev: pointer to mic_device instance
 */
static int mic_setup_callbacks(struct mic_device *mdev)
{
        int i;

        mdev->irq_info.cb_list = kmalloc_array(MIC_NUM_OFFSETS,
                                               sizeof(*mdev->irq_info.cb_list),
                                               GFP_KERNEL);
        if (!mdev->irq_info.cb_list)
                return -ENOMEM;

        for (i = 0; i < MIC_NUM_OFFSETS; i++)
                INIT_LIST_HEAD(&mdev->irq_info.cb_list[i]);
        ida_init(&mdev->irq_info.cb_ida);
        spin_lock_init(&mdev->irq_info.mic_intr_lock);
        spin_lock_init(&mdev->irq_info.mic_thread_lock);
        return 0;
}

/**
 * mic_release_callbacks - Uninitialize data structures needed
 * to handle callbacks.
 *
 * @mdev: pointer to mic_device instance
 */
static void mic_release_callbacks(struct mic_device *mdev)
{
        unsigned long flags;
        struct list_head *pos, *tmp;
        struct mic_intr_cb *intr_cb;
        int i;

        spin_lock(&mdev->irq_info.mic_thread_lock);
        spin_lock_irqsave(&mdev->irq_info.mic_intr_lock, flags);
        for (i = 0; i < MIC_NUM_OFFSETS; i++) {

                if (list_empty(&mdev->irq_info.cb_list[i]))
                        break;

                list_for_each_safe(pos, tmp, &mdev->irq_info.cb_list[i]) {
                        intr_cb = list_entry(pos, struct mic_intr_cb, list);
                        list_del(pos);
                        ida_simple_remove(&mdev->irq_info.cb_ida,
                                          intr_cb->cb_id);
                        kfree(intr_cb);
                }
        }
        spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock, flags);
        spin_unlock(&mdev->irq_info.mic_thread_lock);
        ida_destroy(&mdev->irq_info.cb_ida);
        kfree(mdev->irq_info.cb_list);
}

/**
 * mic_setup_msi - Initializes MSI interrupts.
 *
 * @mdev: pointer to mic_device instance
 * @pdev: PCI device structure
 *
 * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
 */
static int mic_setup_msi(struct mic_device *mdev, struct pci_dev *pdev)
{
        int rc;

        rc = pci_enable_msi(pdev);
        if (rc) {
                dev_dbg(&pdev->dev, "Error enabling MSI. rc = %d\n", rc);
                return rc;
        }

        mdev->irq_info.num_vectors = 1;
        mdev->irq_info.mic_msi_map = kzalloc((sizeof(u32) *
                mdev->irq_info.num_vectors), GFP_KERNEL);

        if (!mdev->irq_info.mic_msi_map) {
                rc = -ENOMEM;
                goto err_nomem1;
        }

        rc = mic_setup_callbacks(mdev);
        if (rc) {
                dev_err(&pdev->dev, "Error setting up callbacks\n");
                goto err_nomem2;
        }

        rc = request_threaded_irq(pdev->irq, mic_interrupt, mic_thread_fn,
                                  0, "mic-msi", mdev);
        if (rc) {
                dev_err(&pdev->dev, "Error allocating MSI interrupt\n");
                goto err_irq_req_fail;
        }

        dev_dbg(&pdev->dev, "%d MSI irqs setup\n", mdev->irq_info.num_vectors);
        return 0;
err_irq_req_fail:
        mic_release_callbacks(mdev);
err_nomem2:
        kfree(mdev->irq_info.mic_msi_map);
err_nomem1:
        pci_disable_msi(pdev);
        mdev->irq_info.num_vectors = 0;
        return rc;
}

/**
 * mic_setup_intx - Initializes legacy interrupts.
 *
 * @mdev: pointer to mic_device instance
 * @pdev: PCI device structure
 *
 * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
 */
static int mic_setup_intx(struct mic_device *mdev, struct pci_dev *pdev)
{
        int rc;

        pci_msi_off(pdev);

        /* Enable intx */
        pci_intx(pdev, 1);
        rc = mic_setup_callbacks(mdev);
        if (rc) {
                dev_err(&pdev->dev, "Error setting up callbacks\n");
                goto err_nomem;
        }

        rc = request_threaded_irq(pdev->irq, mic_interrupt, mic_thread_fn,
                                  IRQF_SHARED, "mic-intx", mdev);
        if (rc)
                goto err;

        dev_dbg(&pdev->dev, "intx irq setup\n");
        return 0;
err:
        mic_release_callbacks(mdev);
err_nomem:
        return rc;
}

/**
 * mic_next_db - Retrieve the next doorbell interrupt source id.
 * The id is picked sequentially from the available pool of
 * doorlbell ids.
 *
 * @mdev: pointer to the mic_device instance.
 *
 * Returns the next doorbell interrupt source.
 */
int mic_next_db(struct mic_device *mdev)
{
        int next_db;

        next_db = mdev->irq_info.next_avail_src %
                mdev->intr_info->intr_len[MIC_INTR_DB];
        mdev->irq_info.next_avail_src++;
        return next_db;
}

#define COOKIE_ID_SHIFT 16
#define GET_ENTRY(cookie) ((cookie) & 0xFFFF)
#define GET_OFFSET(cookie) ((cookie) >> COOKIE_ID_SHIFT)
#define MK_COOKIE(x, y) ((x) | (y) << COOKIE_ID_SHIFT)

/**
 * mic_request_threaded_irq - request an irq. mic_mutex needs
 * to be held before calling this function.
 *
 * @mdev: pointer to mic_device instance
 * @handler: The callback function that handles the interrupt.
 * The function needs to call ack_interrupts
 * (mdev->ops->ack_interrupt(mdev)) when handling the interrupts.
 * @thread_fn: thread fn required by request_threaded_irq.
 * @name: The ASCII name of the callee requesting the irq.
 * @data: private data that is returned back when calling the
 * function handler.
 * @intr_src: The source id of the requester. Its the doorbell id
 * for Doorbell interrupts and DMA channel id for DMA interrupts.
 * @type: The type of interrupt. Values defined in mic_intr_type
 *
 * returns: The cookie that is transparent to the caller. Passed
 * back when calling mic_free_irq. An appropriate error code
 * is returned on failure. Caller needs to use IS_ERR(return_val)
 * to check for failure and PTR_ERR(return_val) to obtained the
 * error code.
 *
 */
struct mic_irq *
mic_request_threaded_irq(struct mic_device *mdev,
                         irq_handler_t handler, irq_handler_t thread_fn,
                         const char *name, void *data, int intr_src,
                         enum mic_intr_type type)
{
        u16 offset;
        int rc = 0;
        struct msix_entry *msix = NULL;
        unsigned long cookie = 0;
        u16 entry;
        struct mic_intr_cb *intr_cb;
        struct pci_dev *pdev = container_of(mdev->sdev->parent,
                struct pci_dev, dev);

        offset = mic_map_src_to_offset(mdev, intr_src, type);
        if (offset >= MIC_NUM_OFFSETS) {
                dev_err(mdev->sdev->parent,
                        "Error mapping index %d to a valid source id.\n",
                        intr_src);
                rc = -EINVAL;
                goto err;
        }

        if (mdev->irq_info.num_vectors > 1) {
                msix = mic_get_available_vector(mdev);
                if (!msix) {
                        dev_err(mdev->sdev->parent,
                                "No MSIx vectors available for use.\n");
                        rc = -ENOSPC;
                        goto err;
                }

                rc = request_threaded_irq(msix->vector, handler, thread_fn,
                                          0, name, data);
                if (rc) {
                        dev_dbg(mdev->sdev->parent,
                                "request irq failed rc = %d\n", rc);
                        goto err;
                }
                entry = msix->entry;
                mdev->irq_info.mic_msi_map[entry] |= BIT(offset);
                mdev->intr_ops->program_msi_to_src_map(mdev,
                                entry, offset, true);
                cookie = MK_COOKIE(entry, offset);
                dev_dbg(mdev->sdev->parent, "irq: %d assigned for src: %d\n",
                        msix->vector, intr_src);
        } else {
                intr_cb = mic_register_intr_callback(mdev, offset, handler,
                                                     thread_fn, data);
                if (IS_ERR(intr_cb)) {
                        dev_err(mdev->sdev->parent,
                                "No available callback entries for use\n");
                        rc = PTR_ERR(intr_cb);
                        goto err;
                }

                entry = 0;
                if (pci_dev_msi_enabled(pdev)) {
                        mdev->irq_info.mic_msi_map[entry] |= (1 << offset);
                        mdev->intr_ops->program_msi_to_src_map(mdev,
                                entry, offset, true);
                }
                cookie = MK_COOKIE(entry, intr_cb->cb_id);
                dev_dbg(mdev->sdev->parent, "callback %d registered for src: %d\n",
                        intr_cb->cb_id, intr_src);
        }
        return (struct mic_irq *)cookie;
err:
        return ERR_PTR(rc);
}

/**
 * mic_free_irq - free irq. mic_mutex
 *  needs to be held before calling this function.
 *
 * @mdev: pointer to mic_device instance
 * @cookie: cookie obtained during a successful call to mic_request_threaded_irq
 * @data: private data specified by the calling function during the
 * mic_request_threaded_irq
 *
 * returns: none.
 */
void mic_free_irq(struct mic_device *mdev,
        struct mic_irq *cookie, void *data)
{
        u32 offset;
        u32 entry;
        u8 src_id;
        unsigned int irq;
        struct pci_dev *pdev = container_of(mdev->sdev->parent,
                struct pci_dev, dev);

        entry = GET_ENTRY((unsigned long)cookie);
        offset = GET_OFFSET((unsigned long)cookie);
        if (mdev->irq_info.num_vectors > 1) {
                if (entry >= mdev->irq_info.num_vectors) {
                        dev_warn(mdev->sdev->parent,
                                 "entry %d should be < num_irq %d\n",
                                entry, mdev->irq_info.num_vectors);
                        return;
                }
                irq = mdev->irq_info.msix_entries[entry].vector;
                free_irq(irq, data);
                mdev->irq_info.mic_msi_map[entry] &= ~(BIT(offset));
                mdev->intr_ops->program_msi_to_src_map(mdev,
                        entry, offset, false);

                dev_dbg(mdev->sdev->parent, "irq: %d freed\n", irq);
        } else {
                irq = pdev->irq;
                src_id = mic_unregister_intr_callback(mdev, offset);
                if (src_id >= MIC_NUM_OFFSETS) {
                        dev_warn(mdev->sdev->parent, "Error unregistering callback\n");
                        return;
                }
                if (pci_dev_msi_enabled(pdev)) {
                        mdev->irq_info.mic_msi_map[entry] &= ~(BIT(src_id));
                        mdev->intr_ops->program_msi_to_src_map(mdev,
                                entry, src_id, false);
                }
                dev_dbg(mdev->sdev->parent, "callback %d unregistered for src: %d\n",
                        offset, src_id);
        }
}

/**
 * mic_setup_interrupts - Initializes interrupts.
 *
 * @mdev: pointer to mic_device instance
 * @pdev: PCI device structure
 *
 * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
 */
int mic_setup_interrupts(struct mic_device *mdev, struct pci_dev *pdev)
{
        int rc;

        rc = mic_setup_msix(mdev, pdev);
        if (!rc)
                goto done;

        rc = mic_setup_msi(mdev, pdev);
        if (!rc)
                goto done;

        rc = mic_setup_intx(mdev, pdev);
        if (rc) {
                dev_err(mdev->sdev->parent, "no usable interrupts\n");
                return rc;
        }
done:
        mdev->intr_ops->enable_interrupts(mdev);
        return 0;
}

/**
 * mic_free_interrupts - Frees interrupts setup by mic_setup_interrupts
 *
 * @mdev: pointer to mic_device instance
 * @pdev: PCI device structure
 *
 * returns none.
 */
void mic_free_interrupts(struct mic_device *mdev, struct pci_dev *pdev)
{
        int i;

        mdev->intr_ops->disable_interrupts(mdev);
        if (mdev->irq_info.num_vectors > 1) {
                for (i = 0; i < mdev->irq_info.num_vectors; i++) {
                        if (mdev->irq_info.mic_msi_map[i])
                                dev_warn(&pdev->dev, "irq %d may still be in use.\n",
                                         mdev->irq_info.msix_entries[i].vector);
                }
                kfree(mdev->irq_info.mic_msi_map);
                kfree(mdev->irq_info.msix_entries);
                pci_disable_msix(pdev);
        } else {
                if (pci_dev_msi_enabled(pdev)) {
                        free_irq(pdev->irq, mdev);
                        kfree(mdev->irq_info.mic_msi_map);
                        pci_disable_msi(pdev);
                } else {
                        free_irq(pdev->irq, mdev);
                }
                mic_release_callbacks(mdev);
        }
}

/**
 * mic_intr_restore - Restore MIC interrupt registers.
 *
 * @mdev: pointer to mic_device instance.
 *
 * Restore the interrupt registers to values previously
 * stored in the SW data structures. mic_mutex needs to
 * be held before calling this function.
 *
 * returns None.
 */
void mic_intr_restore(struct mic_device *mdev)
{
        int entry, offset;
        struct pci_dev *pdev = container_of(mdev->sdev->parent,
                struct pci_dev, dev);

        if (!pci_dev_msi_enabled(pdev))
                return;

        for (entry = 0; entry < mdev->irq_info.num_vectors; entry++) {
                for (offset = 0; offset < MIC_NUM_OFFSETS; offset++) {
                        if (mdev->irq_info.mic_msi_map[entry] & BIT(offset))
                                mdev->intr_ops->program_msi_to_src_map(mdev,
                                        entry, offset, true);
                }
        }
}