/**
 *
 * Name:	skisr.c
 * Project:	Wireless LAN, Bus driver for SDIO interface
 * Version:	$Revision: 1.1 $
 * Date:	$Date: 2007/01/18 09:21:35 $
 * Purpose:	This module handles the interrupts.
 *
 * Copyright (C) 2003-2009, Marvell International Ltd. 
 *
 * This software file (the "File") is distributed by Marvell International 
 * Ltd. under the terms of the GNU General Public License Version 2, June 1991 
 * (the "License").  You may use, redistribute and/or modify this File in 
 * accordance with the terms and conditions of the License, a copy of which 
 * is available by writing to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE 
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about 
 * this warranty disclaimer.
 *
 */

/******************************************************************************
 *
 * History:
 *
 *	$Log: skisr.c,v $
 *	Revision 1.1  2007/01/18 09:21:35  pweber
 *	Put under CVS control
 *	
 *
 ******************************************************************************/

#include "h/skdrv1st.h"
#include "h/skdrv2nd.h"

static void (*gpio_int_callback) (void *) = NULL;
static void *gpio_int_callback_arg = NULL;

int
request_gpio_irq_callback(void (*callback) (void *), void *arg)
{
    if (!gpio_int_callback && !gpio_int_callback_arg) {
        gpio_int_callback = callback;
        gpio_int_callback_arg = arg;
        return 0;
    }
    return -1;
}

EXPORT_SYMBOL(request_gpio_irq_callback);

int
release_gpio_irq_callback(void (*callback) (void *), void *arg)
{
    if ((callback == gpio_int_callback)
        && (arg == gpio_int_callback_arg)) {
        gpio_int_callback = NULL;
        gpio_int_callback_arg = NULL;
        return 0;
    }
    return -1;
}

EXPORT_SYMBOL(release_gpio_irq_callback);

DECLARE_TASKLET(SDIOBus_tasklet, SDIOBus_Dpc, 0);

void
SDIOBus_Dpc(unsigned long arg)
{
    SK_U32 irq_status, status;
    SK_U16 errorIRQ_status = 0;
    PSD_DEVICE_DATA pDev;

    DBGPRINT(DBG_IRQ, (KERN_DEBUG "SDIOBUS_Dpc startet ....\n"));

    if (arg == 0) {
        DBGPRINT(DBG_ERROR, (KERN_DEBUG "SDIOBUS_Dpc : arg == NULL !\n"));
        return;
    }

    pDev = (PSD_DEVICE_DATA) arg;

    if (pDev == NULL) {
        DBGPRINT(DBG_ERROR, (KERN_DEBUG "SDIOBUS_Dpc : pDev == NULL !\n"));
        return;
    }

    irq_status = pDev->lastIntStatus;

    if ((irq_status & STDHOST_NORMAL_IRQ_ERROR) != 0) {
        MEM_READ_USHORT(pDev, SK_SLOT_0, STDHOST_ERROR_IRQ_STATUS,
                        &errorIRQ_status);
        if ((errorIRQ_status & STDHOST_ERROR_IRQ_GPI_0) != 0) {
            if ((pDev->lastErrorIRQSignalMask & STDHOST_ERROR_IRQ_GPI_0) != 0) {
                // clear irq bit
                MEM_WRITE_USHORT(pDev, SK_SLOT_0, STDHOST_ERROR_IRQ_STATUS,
                                 STDHOST_ERROR_IRQ_GPI_0);
                // Fake a SDIO card interrupt
                irq_status |= STDHOST_NORMAL_IRQ_CARD;
            }
        }
        if ((errorIRQ_status & STDHOST_ERROR_IRQ_GPI_1) != 0) {
            if ((pDev->lastErrorIRQSignalMask & STDHOST_ERROR_IRQ_GPI_1) != 0) {
                printk("GPI-1 interrupt fired (0x%4.04X)\n", errorIRQ_status);
                                /*--- mmoser 3/12/2007 ---*/
                // clear irq bit
                MEM_WRITE_USHORT(pDev, SK_SLOT_0, STDHOST_ERROR_IRQ_STATUS,
                                 STDHOST_ERROR_IRQ_GPI_1);

                SDHost_SetClock(pDev, 1);
                if (gpio_int_callback && gpio_int_callback_arg)
                    gpio_int_callback(gpio_int_callback_arg);
            }
        }
    }

    if ((irq_status & STDHOST_NORMAL_IRQ_CARD_OUT) ==
        STDHOST_NORMAL_IRQ_CARD_OUT) {
        // clear irq bit
        MEM_WRITE_USHORT(pDev, SK_SLOT_0, STDHOST_NORMAL_IRQ_STATUS,
                         STDHOST_NORMAL_IRQ_CARD_OUT);

                /*--- mmoser 14.09.2005 ---*/
        if (pDev->initialized) {
            DBGPRINT(DBG_IRQ | DBG_W528D,
                     (KERN_DEBUG "SDIOBUS_Dpc : NORMAL_IRQ_CARD_OUT\n"));

            /*--- mmoser 10.08.2005 ---*/
            DBGPRINT(DBG_IRQ, (KERN_DEBUG "CARD REMOVED\n"));
            SDIOBus_CardRemoved(pDev);

                        /*--- mmoser 3/31/2006 ---*/
            pDev->SurpriseRemoved = SK_TRUE;
        }
        SDHost_EnableInterrupt(pDev, pDev->lastIRQSignalMask);
        DBGPRINT(DBG_IRQ,
                 (KERN_DEBUG "SDIOBUS_Dpc finished.(line=%d)\n", __LINE__));
        return;
    }
    if ((irq_status & STDHOST_NORMAL_IRQ_CARD_IN) == STDHOST_NORMAL_IRQ_CARD_IN) {
        // clear irq bit
        MEM_WRITE_USHORT(pDev, SK_SLOT_0, STDHOST_NORMAL_IRQ_STATUS,
                         STDHOST_NORMAL_IRQ_CARD_IN);

        DBGPRINT(DBG_IRQ, (KERN_DEBUG "SDIOBUS_Dpc : NORMAL_IRQ_CARD_IN\n"));
        DBGPRINT(DBG_IRQ, (KERN_DEBUG "CARD PLUGGED IN\n"));
        SDIOBus_CardPluggedIn(pDev);
        SDHost_EnableInterrupt(pDev, pDev->lastIRQSignalMask);
        DBGPRINT(DBG_IRQ,
                 (KERN_DEBUG "SDIOBUS_Dpc finished.(line=%d)\n", __LINE__));
        return;
    }

    if ((irq_status & STDHOST_NORMAL_IRQ_CARD) == STDHOST_NORMAL_IRQ_CARD) {
        status = (irq_status << 16);
        if (pDev->number_of_functions > 1) {
            queue_work(pDev->workqueue, &pDev->irq_work);
        } else {
            if (pDev->irq_device_cache[1]->functions[1].int_handler != NULL) {
                pDev->irq_device_cache[1]->functions[1].int_handler(pDev->
                                                                    irq_device_cache
                                                                    [1],
                                                                    pDev->
                                                                    irq_device_cache
                                                                    [1]->
                                                                    pCurrent_Ids,
                                                                    pDev->
                                                                    irq_device_cache
                                                                    [1]->
                                                                    functions
                                                                    [1].
                                                                    context);
            } else {
                DBGPRINT(DBG_IRQ,
                         (KERN_DEBUG "No interrupt handler registered.\n"));
                SDHost_EnableInterrupt(pDev, STDHOST_NORMAL_IRQ_CARD_ALL_ENA);
                DBGPRINT(DBG_IRQ, (KERN_DEBUG "SDIOBUS_Dpc finished.\n"));
                return;
            }
        }
        DBGPRINT(DBG_IRQ,
                 (KERN_DEBUG "SDIOBUS_Dpc finished.(line=%d)\n", __LINE__));
        return;
    }

    if (irq_status & (STDHOST_NORMAL_IRQ_ERROR |
                      STDHOST_NORMAL_IRQ_TRANS_COMPLETE |
                      STDHOST_NORMAL_IRQ_CMD_COMPLETE)) {
        if (((irq_status & STDHOST_NORMAL_IRQ_TRANS_COMPLETE) &&
             (pDev->lastIRQSignalMask & STDHOST_NORMAL_IRQ_TRANS_COMPLETE)) ||
            ((irq_status & STDHOST_NORMAL_IRQ_CMD_COMPLETE) &&
             (pDev->lastIRQSignalMask & STDHOST_NORMAL_IRQ_CMD_COMPLETE)) ||
            ((errorIRQ_status & STDHOST_ERROR_IRQ_GPI_1) &&
             (pDev->lastErrorIRQSignalMask & STDHOST_ERROR_IRQ_GPI_1))

            )
        {
            SDHost_EnableInterrupt(pDev, pDev->lastIRQSignalMask);
        }
        DBGPRINT(DBG_IRQ,
                 (KERN_DEBUG "SDIOBUS_Dpc finished.(line=%d)\n", __LINE__));
        return;
    } else {
        MEM_WRITE_USHORT(pDev, SK_SLOT_0, STDHOST_NORMAL_IRQ_STATUS, 0xFFFF);
        MEM_WRITE_USHORT(pDev, SK_SLOT_0, STDHOST_ERROR_IRQ_STATUS, 0xFFFF);
        DBGPRINT(DBG_ERROR,
                 (KERN_DEBUG "SDIOBus_Dpc(): Unhandled IRQ : 0x%8.08X.\n",
                  irq_status));
    }

    SDHost_EnableInterrupt(pDev, pDev->lastIRQSignalMask);
    DBGPRINT(DBG_IRQ,
             (KERN_DEBUG "SDIOBUS_Dpc finished.(line=%d)\n", __LINE__));
}

irqreturn_t
SDIOBus_Isr(int irq, void *dev_id, struct pt_regs *regs)
{
    SK_U32 tmp;
    SK_U16 tmpsig;
    PSD_DEVICE_DATA pDev;

    if (dev_id == NULL) {
        DBGPRINT(DBG_IRQ, (KERN_DEBUG "SDIOBUS_Isr : dev_id == NULL !\n"));
        return IRQ_HANDLED;
    }

    pDev = (PSD_DEVICE_DATA) dev_id;

    if (pDev == NULL) {
        DBGPRINT(DBG_IRQ, (KERN_DEBUG "SDIOBUS_Isr : pDev == NULL !\n"));
        return IRQ_HANDLED;
    }

    MEM_READ_ULONG(pDev, SK_SLOT_0, STDHOST_NORMAL_IRQ_STATUS, &tmp);
    MEM_READ_USHORT(pDev, SK_SLOT_0, STDHOST_ERROR_IRQ_SIGNAL_ENABLE, &tmpsig);

    // Check if interrupt came from our device
    if (((((tmp & STDHOST_NORMAL_IRQ_ERROR) != 0) &&
          ((tmpsig & (STDHOST_ERROR_IRQ_GPI_1 | STDHOST_ERROR_IRQ_GPI_0)) != 0))
         || ((tmp & pDev->currentIRQSignalMask) != 0)) && tmp != 0xFFFFFFFF)
    {
                                                                                                                                                                /*--- mmoser 8/29/2006 ---*/
        if (tmp & STDHOST_NORMAL_IRQ_TRANS_COMPLETE) {
            if (pDev->currentIRQSignalMask & STDHOST_NORMAL_IRQ_TRANS_COMPLETE) {
                // clear irq bit
                MEM_WRITE_USHORT(pDev, SK_SLOT_0, STDHOST_NORMAL_IRQ_STATUS,
                                 STDHOST_NORMAL_IRQ_TRANS_COMPLETE);

                if (!test_and_set_bit(0, &pDev->trans_complete_evt.event)) {
                    wake_up(&pDev->trans_complete_evt.wq);
                }
            }
        }

        if (tmp & STDHOST_NORMAL_IRQ_CMD_COMPLETE) {
            if (pDev->currentIRQSignalMask & STDHOST_NORMAL_IRQ_CMD_COMPLETE) {
                // clear irq bit
                MEM_WRITE_USHORT(pDev, SK_SLOT_0, STDHOST_NORMAL_IRQ_STATUS,
                                 STDHOST_NORMAL_IRQ_CMD_COMPLETE);

                if (!test_and_set_bit(0, &pDev->cmd_complete_evt.event)) {
                    wake_up(&pDev->cmd_complete_evt.wq);
                }
            }
        }

        MEM_READ_USHORT(pDev, SK_SLOT_0, STDHOST_ERROR_IRQ_SIGNAL_ENABLE,
                        &pDev->lastErrorIRQSignalMask);
        pDev->lastIntStatus = tmp;
        DBGPRINT(DBG_IRQ,
                 (KERN_DEBUG "SDIOBUS_Isr (0x%4.04X)\n", pDev->lastIntStatus));
        SDHost_DisableInterrupt(pDev, STDHOST_NORMAL_IRQ_ALL_SIG_ENA);

        SDIOBus_tasklet.data = (unsigned long) pDev;
        tasklet_schedule(&SDIOBus_tasklet);

    } else {
        if (tmp == 0xFFFFFF)
            pDev->SurpriseRemoved = SK_TRUE;
        return IRQ_NONE;
    }
    return IRQ_HANDLED;

}