source: svn/trunk/newcon3bcm2_21bu/nexus/build/nfe_driver/b_bare_os.c

/*
 * Copyright (C) 2010-2011 Broadcom 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.
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
#include <linux/version.h>
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
#include <linux/autoconf.h>
#else
#include <generated/autoconf.h>
#endif
#include <linux/kernel.h> /* printk */
#include <linux/slab.h> /* memset and friends */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
#define DECLARE_MUTEX DEFINE_SEMAPHORE
#define init_MUTEX(sem)     sema_init(sem, 1)
#define init_MUTEX_LOCKED(sem)  sema_init(sem, 0)
#endif
#include <linux/wait.h>
#include <linux/delay.h>
#include <linux/signal.h>
#include <linux/semaphore.h>
#include <linux/sched.h>
#include <linux/freezer.h>
#include <linux/hardirq.h>
#include <linux/interrupt.h>
#include <linux/kthread.h>
#include <linux/kmod.h>
#include <asm/atomic.h>
#include <asm/uaccess.h>
#include <asm/brcmstb/brcmapi.h>
#include "b_bare_os.h"
#include "nexus_generic_driver.h"

/* cannot include magnum header files here */

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)
#error linux 2.6.31-3.2 or higher required
#endif

static int print_error(const char *file, int line, const char *test, int rc)
{
    if (rc) {
        printk("!!! BERR_TRACE %s = %d at %s:%d\n", test, rc, file, line);
    }
    return rc;
}

#define BERR_TRACE(rc) (print_error(__FILE__,__LINE__,#rc,rc))
#define BDBG_ERR(PARAMS) do{printk("### ");printk PARAMS;printk("\n");}while(0)
#define BDBG_WRN(PARAMS) do{printk("*** ");printk PARAMS;printk("\n");}while(0)
#define BDBG_MSG(PARAMS) /*do{printk("--- ");printk PARAMS;printk("\n");}while(0)*/
#define BDBG_MSG_IRQ(x)  /*BDBG_MSG(x)*/
#define BDBG_ASSERT(x) do {if (!(x)) {BDBG_ERR(("ASSERT %s failed at %s:%d", #x, __FILE__, __LINE__));b_bare_fail();}} while(0)
#define BERR_SUCCESS 0
#define BERR_OS_ERROR -1
#define BERR_TIMEOUT 1 /* >0 */
#define BSTD_UNUSED(x) ((x)=(x))

/* NUM_L1_REGISTERS can be >= the number of actual L1 regiters */
#define NUM_L1_REGISTERS 4
#define NUM_IRQS (32*NUM_L1_REGISTERS)
/* b_bare_os L1 interrupts are 0-based. linux is 1-based. */
#define LINUX_IRQ(i) (i+1)
#define NEXUS_IRQ(i) (i-1)

struct b_bare_interrupt_entry {
    const char *name;
    void (*handler)(void *,int);
    void *context_ptr;
    int context_int;
    b_bare_os_special_interrupt_handler special_handler;
    bool requested; /* request_irq called. must be defered until first enable. */
    bool enabled; /* externally enabled by caller. must also check IntrMaskStatus if internally disabled for tasklet. */
    bool shared;
};

static struct b_bare_interrupt_state {
    spinlock_t lock;
    bool started;
    bool scheduled;
    struct {
        uint32_t IntrStatus;
        uint32_t IntrMaskStatus;
    } processing[NUM_L1_REGISTERS], pending[NUM_L1_REGISTERS];
    struct b_bare_interrupt_entry table[NUM_IRQS];
    struct work_struct task;
} b_bare_interrupt_state = {
    SPIN_LOCK_UNLOCKED,
};

static void b_bare_enter_critical_section(void);
static void b_bare_leave_critical_section(void);
static void b_bare_fail(void);
static void b_bare_lock_signals(sigset_t *pPrevMask);
static void b_bare_restore_signals(sigset_t *pPrevMask);
static int b_bare_signal_pending(void);
static void b_bare_disconnect_interrupt(unsigned irqNum);

static struct task_struct *g_csOwner;

#define SET_CRITICAL() do { g_csOwner = current; } while (0)
#define CLEAR_CRITICAL() do { g_csOwner = NULL; } while (0)

#define CHECK_CRITICAL() ( g_csOwner == current || in_interrupt() )

#define ASSERT_CRITICAL() do \
{\
    if ( !CHECK_CRITICAL() )\
    {\
        printk("Error, must be in critical section to call %s\n", __FUNCTION__);\
        b_bare_fail();\
    }\
} while (0)

#define ASSERT_NOT_CRITICAL() do \
{\
    if ( CHECK_CRITICAL() )\
    {\
        printk("Error, must not be in critical section to call %s\n", __FUNCTION__);\
        b_bare_fail();\
    }\
} while (0)

static struct tasklet_struct *g_pIsrTasklet;
static struct tasklet_struct *g_pPendingTasklet;
static sigset_t g_blockedSignals;

struct b_bare_os_signal_tag {
    wait_queue_head_t wq;
    atomic_t eventset;
};

struct b_bare_os_lock_tag {
    struct semaphore sem;
};

int b_bare_os_init(void)
{
    struct b_bare_interrupt_state *state = &b_bare_interrupt_state;
    unsigned i;

    memset(&state->table, 0, sizeof(state->table));
    for(i=0;i<NUM_L1_REGISTERS;i++) {
        state->processing[i].IntrMaskStatus = ~0;
        state->processing[i].IntrStatus = 0;
        state->pending[i] = state->processing[i];
    }
    state->scheduled = false;
    state->started = true;
    printk("b_bare_os initialized\n");

    return 0;
}

void b_bare_os_uninit(void)
{
    struct b_bare_interrupt_state *state = &b_bare_interrupt_state;
    unsigned i;

    state->started = false;
    for(i=0;i<NUM_IRQS;i++) {
        if (state->table[i].handler) {
            printk("auto-b_bare_disconnect_interrupt %d\n", LINUX_IRQ(i));
            b_bare_disconnect_interrupt(i);
        }
    }
    printk("b_bare_os uninitialized\n");
}

/* coverity[+kill] */
static void b_bare_fail(void)
{
    volatile int i=0;
    volatile int j=0;
    printk("b_bare_fail: forcing oops\n");
    i = *(int *)i;
    i /= j;
    panic("b_bare_fail: panic...");
}

static void 
b_bare_delay(unsigned microsec)
{
    udelay(microsec);
}

static void 
b_bare_sleep(unsigned millisec)
{
    unsigned long ticks;
    long rc;
    sigset_t mask;
    int retval;

    ticks = (millisec * HZ) / 1000;

    /* Each tick is 1 or 10ms, so we must wait at least that long */
    if (ticks == 0) {
        ticks = 1;
    }

    /* Block all non-terminal signals while sleeping */
    b_bare_lock_signals(&mask);

    for(;;) {
        set_current_state(TASK_INTERRUPTIBLE);
        rc = schedule_timeout(ticks);
        if (rc==0) {
            retval = BERR_SUCCESS;
            break;
        }
        if (b_bare_signal_pending()) {
            retval = BERR_TRACE(BERR_OS_ERROR);
            break;
        }
        ticks = rc; /* keep sleeping */
    }

    /* Restore original signal mask */
    b_bare_restore_signals(&mask);

    return;
}

static b_bare_os_signal 
b_bare_signal_create(void)
{
    b_bare_os_signal event;
    event = kmalloc(sizeof(*event), GFP_KERNEL);
    if (!event)
        return NULL;
    atomic_set(&event->eventset, 0);
    init_waitqueue_head(&event->wq);
    return event;
}

static void 
b_bare_signal_destroy(b_bare_os_signal event)
{
    kfree(event);
}

static void 
b_bare_signal_set(b_bare_os_signal event)
{
    atomic_set(&event->eventset, 1);
    wake_up_interruptible(&event->wq);
}

/**
* This will modify the caller's signal mask to block all signals
* except for the terminal signals listed in BKNI_Init().  This prevents
* user signals from interrupting magnum code, but they will be safely
* dispatched at the next opportunity.
**/
static void b_bare_lock_signals(sigset_t *pPrevMask)
{
    unsigned long flags;
    spinlock_t *pSignalLock;

    /* 2.6 signal lock */
    pSignalLock = &current->sighand->siglock;

    /* Lock the signal structs, should use spin_lock_irq since the same
     * spinlock coule be acqured by the kernel code from within IRQ handler */
    spin_lock_irqsave(pSignalLock, flags);

    /* Save current signals */
    memcpy(pPrevMask, &current->blocked, sizeof(sigset_t));
    /* Set to block all but the terminal signals */
    memcpy(&current->blocked, &g_blockedSignals, sizeof(sigset_t));
    /* Must be called after manipulating blocked signals */
    recalc_sigpending();

    /* Release the lock */
    spin_unlock_irqrestore(pSignalLock, flags);
    return;
}

/**
* This will restore the original signal mask saved by b_bare_lock_signals()
**/
static void b_bare_restore_signals(sigset_t *pPrevMask)
{
    unsigned long flags;
    spinlock_t *pSignalLock;

    /* 2.6 signal lock */
    pSignalLock = &current->sighand->siglock;

    /* Lock the signal structs, should use spin_lock_irq since the same
     * spinlock coule be acqured by the kernel code from within IRQ handler */
    spin_lock_irqsave(pSignalLock, flags);

    /* Restore signals */
    memcpy(&current->blocked, pPrevMask, sizeof(sigset_t));
    /* Must be called after manipulating blocked signals */
    recalc_sigpending();

    /* Release the lock */
    spin_unlock_irqrestore(pSignalLock, flags);
}

/**
* This will return 1 if a signal is pending.  Previous implementations
* of this function would dequeue all non-terminal signals to allow the
* caller to continue waiting.  That approach had the drawback of consuming
* any non-terminal signals and preventing the application from using them.
* The new implementation assumes that the caller has called b_bare_lock_signals()
* prior to waiting on an event or timeout and therefore can only be interrupted by
* a terminal signal.  When the original signal mask is restored via b_bare_restore_signals,
* the user signals will be dispatched again.
**/
static int b_bare_signal_pending(void)
{
    while (signal_pending(current)) {
        if ( ! try_to_freeze()) {       /* try to freeze returns 0 when no freeze request */
            return 1;                   /* signal pending (but no freeze request)         */
        }
    }
    return 0;                           /* no signal (or freeze request) pending          */
}

static int 
b_bare_signal_wait(b_bare_os_signal event, unsigned timeoutMsec)
{
    int result = BERR_TIMEOUT;
    sigset_t mask;
    int prev_eventset;

    if ( timeoutMsec )
    {
        ASSERT_NOT_CRITICAL();
    }
    else if ( CHECK_CRITICAL() )
    {
        /* Don't mess with current or wait queues from an ISR */
        prev_eventset = atomic_xchg(&event->eventset, 0); /* this atomically clears 'eventset' and returns current (old) value */
        if ( prev_eventset)
        {
            return BERR_SUCCESS;
        }
        else
        {
            return BERR_TIMEOUT;
        }
    }

    /* This is used to achieve consistency between different OS's. */
    if (timeoutMsec>0 && timeoutMsec<30)
    {
        /* wait at least 30 msec */
        timeoutMsec = 30;
    }

    b_bare_lock_signals(&mask);

    if (b_bare_signal_pending())
        result = BERR_OS_ERROR;
    else
    {
        wait_queue_t wqe;
        unsigned long ticks;

        init_waitqueue_entry(&wqe, current);
        add_wait_queue(&event->wq, &wqe);

        if (timeoutMsec == (unsigned)-1)
            ticks = MAX_SCHEDULE_TIMEOUT;
        else if (timeoutMsec)
            ticks = (timeoutMsec * HZ) / 1000;
        else
            ticks = 0;

        /* Need to repeat the sleep until the entire timeout
        is consumed, or event occurs, or a true fatal signal is detected.
        It's possible to be signalled and yet keep going. */
        for ( ;; )
        {
            /* Be sure to go half asleep before checking condition. */
            /* Otherwise we have a race condition between when we   */
            /* check the condition and when we call schedule().     */
            set_current_state(TASK_INTERRUPTIBLE);

            prev_eventset = atomic_xchg(&event->eventset, 0); /* this atomically clears 'eventset' and returns current (old) value */
            if(prev_eventset) 
            {
                result = BERR_SUCCESS;
                break;
            }
            else if (!ticks)
            {
                result = BERR_TIMEOUT;
                break;
            }
            else
            {
                /* When SetEvent is called, event process on event->wq is woken. */
                ticks = schedule_timeout(ticks);
                if (b_bare_signal_pending())
                {
                    result = BERR_OS_ERROR;
                    break;
                }
            }
        }

        set_current_state(TASK_RUNNING);
        remove_wait_queue(&event->wq, &wqe);
    }

    b_bare_restore_signals(&mask);

    return result;
}

static spinlock_t g_criticalSection = SPIN_LOCK_UNLOCKED;
static DECLARE_MUTEX(g_csMutex);

static void b_bare_enter_critical_section(void)
{
    ASSERT_NOT_CRITICAL();
    if ( g_pIsrTasklet )
    {
        down(&g_csMutex);
        tasklet_disable(g_pIsrTasklet);
    }
    else
    {
        spin_lock_bh(&g_criticalSection);
    }
    SET_CRITICAL();
}

static void b_bare_leave_critical_section(void)
{
    struct tasklet_struct *pIsrTasklet;

    ASSERT_CRITICAL();
    CLEAR_CRITICAL();

    /* Store tasklet and replace with any possible changes */
    pIsrTasklet = g_pIsrTasklet;
    g_pIsrTasklet = g_pPendingTasklet;

    /* Re-enable interrupts in the same way they were disabled */
    if ( pIsrTasklet )
    {
        tasklet_enable(pIsrTasklet);
        up(&g_csMutex);
    }
    else
    {
        spin_unlock_bh(&g_criticalSection);
    }
}

static b_bare_os_lock 
b_bare_lock_create(void)
{
    b_bare_os_lock lock;
    lock = kmalloc(sizeof(*lock), GFP_KERNEL);
    if (!lock) {
        return NULL;
    }
    init_MUTEX(&(lock)->sem);
    return lock;
}

static void 
b_bare_lock_destroy(b_bare_os_lock lock)
{
    kfree(lock);
}

static struct b_bare_os_lock_tag isr_lock_impl;

b_bare_os_lock b_bare_get_interrupt_lock(void)
{
    return &isr_lock_impl;
}

static int 
b_bare_lock_acquire(b_bare_os_lock lock)
{
    if (lock == &isr_lock_impl) {
        b_bare_enter_critical_section();
    }
    else {
        down(&lock->sem);
    }
    return BERR_SUCCESS;
}

static int 
b_bare_lock_try_acquire(b_bare_os_lock lock)
{
    if (lock == &isr_lock_impl) {
        return BERR_OS_ERROR;
    }
    else if (down_trylock(&lock->sem)) {
        return BERR_TIMEOUT;
    }
    else {
        return BERR_SUCCESS;
    }
}

static void 
b_bare_lock_release(b_bare_os_lock lock)
{
    if (lock == &isr_lock_impl) {
        b_bare_leave_critical_section();
    }
    else {
        up(&lock->sem);
    }
}

static void NEXUS_Platform_P_Isr(unsigned long data);
DECLARE_TASKLET(NEXUS_Platform_P_IsrTasklet, NEXUS_Platform_P_Isr, 0);

/* ISR handler, calls L1 interrupt handler */
static void __attribute__((no_instrument_function))
NEXUS_Platform_P_Isr(unsigned long data)
{
    struct b_bare_interrupt_state *state = &b_bare_interrupt_state;
    unsigned long flags;

    BSTD_UNUSED(data);

    if(!state->started) {
        goto done;
    }

    /* Loop until all is cleared */
    for(;;) {
        uint32_t re_enable[NUM_L1_REGISTERS];
        uint32_t status;
        unsigned bit;
        unsigned i;

        /* Mask interrupts only to read current status */
        spin_lock_irqsave(&state->lock, flags);

        for(status=0,i=0;i<NUM_L1_REGISTERS;i++) {
            /* swap pending and current interrupt, then clear pending  and reenable interrupts */
            status |= state->pending[i].IntrStatus;
            /* coverity[use] */
            state->processing[i].IntrStatus = state->pending[i].IntrStatus;
            /* mask interrupts */
            state->processing[i].IntrStatus &= ~state->processing[i].IntrMaskStatus;

            /* Delay reenabling interrupts until after they have been serviced */
            /* disable_irq nests, so if the interrupt handler disables the interrupt */
            /* again, this is still safe. */
            re_enable[i] = state->processing[i].IntrStatus & state->pending[i].IntrStatus;

            /* clear list of delayed interrupts */
            state->pending[i].IntrStatus = 0;
        }

        /* Restore interrupts */
        spin_unlock_irqrestore(&state->lock, flags);

        if(status==0) {
            goto done;
        }


        /* then call L1 handlers inside critical section (KNI serializes with tasklet_disable so we do nothing here) */
        for(bit=0; bit<NUM_IRQS ; bit+=32) {

            status = state->processing[bit/32].IntrStatus;

            if(!status) {
                continue;
            }
            for(i=0;i<32;i++) {
                if(status & (1<<i)) {
                    state->table[i+bit].handler(state->table[i+bit].context_ptr, state->table[i+bit].context_int);
                }
            }
        }

        /* Now, restore any disabled interrupts (masking not required) */
        for(bit=0; bit<NUM_IRQS ; bit+=32) {
            status = re_enable[bit/32];
            if (!status)  {
                continue;
            }
            for(i=0;i<32;i++)
            {
                /* only enable interrupts which are not masked by the software */
                if (status & (1<<i))
                {
                    BDBG_MSG_IRQ(("BH enable[irq] %d", LINUX_IRQ(i+bit)));
                    if (!state->table[i+bit].special_handler)
                    {
                        enable_irq(LINUX_IRQ(i+bit));
                    }
                }
            }
        }
    }


done:
   /* Complete - indicate we're ready to run again */
   /* final unlock */
    /* Serialize with the TH so it will reschedule this tasklet if needed */
    spin_lock_irqsave(&state->lock, flags);
    state->scheduled = false;
    spin_unlock_irqrestore(&state->lock, flags);
    return;
}

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
static irqreturn_t __attribute__((no_instrument_function))
NEXUS_Platform_P_LinuxIsr(int linux_irq, void *dev_id)
#else
static irqreturn_t __attribute__((no_instrument_function))
NEXUS_Platform_P_LinuxIsr(int linux_irq, void *dev_id, struct pt_regs *regs)
#endif
{
    struct b_bare_interrupt_entry *entry = dev_id;
    unsigned irq = NEXUS_IRQ(linux_irq);
    struct b_bare_interrupt_state *state = &b_bare_interrupt_state;
    unsigned i;
    unsigned long flags;

    if (irq >= NUM_IRQS) {
        goto error;
    }

    /* Make sure we're serialized with the tasklet across multiple CPUs */
    spin_lock_irqsave(&state->lock, flags);

    /* disable irq */
    BDBG_MSG_IRQ(("TH disable[irq] %d", linux_irq));
    if ( !entry->special_handler) {
        disable_irq_nosync(linux_irq);
    } else {
        entry->special_handler(irq);
    }

    for(i=0;i<NUM_L1_REGISTERS;i++,irq-=32) {
        if(irq<32) {
            state->pending[i].IntrStatus |= 1<<irq;
            break;
        }
    }

    if (state->started && !state->scheduled)
    {
        /* queue task only once per activation */
        state->scheduled = true;

        /* This needs to run as a high-priority tasklet, which will immediately follow */
        tasklet_hi_schedule(&NEXUS_Platform_P_IsrTasklet);
    }

    spin_unlock_irqrestore(&state->lock, flags);

    return IRQ_HANDLED;
    
error:
    BDBG_WRN(("unknown irq %d", linux_irq));
    disable_irq_nosync(linux_irq);
    return IRQ_HANDLED;
}

static int b_bare_connect_interrupt(const char *name, unsigned irqNum, 
    void (*handler)(void *,int), void *context_ptr, int context_int, 
    bool shared, b_bare_os_special_interrupt_handler special_handler)
{
    struct b_bare_interrupt_state *state = &b_bare_interrupt_state;
    struct b_bare_interrupt_entry *entry;
    unsigned long flags;

    if (irqNum>=NUM_IRQS || handler==NULL || !state->started) {
        return BERR_TRACE(-1);
    }
    entry = &state->table[irqNum];
    if (entry->handler) {
        /* can't overwrite old handler, b_bare_disconnect_interrupt shall be called first */
        return BERR_TRACE(-1);
    }
    
    spin_lock_irqsave(&state->lock, flags);
    entry->name = name;
    entry->handler = handler;
    entry->context_ptr = context_ptr;
    entry->context_int = context_int;
    entry->special_handler = special_handler;
    entry->shared = shared;
    BDBG_ASSERT(!entry->enabled);
    BDBG_ASSERT(!entry->requested);
    /* request_irq deferred to first enable. */
    spin_unlock_irqrestore(&state->lock, flags);
    
    return 0;
}

static int b_bare_enable_interrupt(unsigned irqNum)
{
    struct b_bare_interrupt_state *state = &b_bare_interrupt_state;
    struct b_bare_interrupt_entry *entry;
    unsigned reg = irqNum/32;
    unsigned long flags;

    if (irqNum>=NUM_IRQS || !state->started) {
        return BERR_TRACE(-1);
    }
    entry = &state->table[irqNum];
    if (!entry->handler) {
        return BERR_TRACE(-1);
    }
    
    spin_lock_irqsave(&state->lock, flags);
    state->processing[reg].IntrMaskStatus &= ~(1 << (irqNum%32));
    if (!entry->requested) {
        int irqflags;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
        irqflags = 0; /* later versions of linux always enable interrupts on request_irq */
        if (entry->shared) {
            irqflags |= IRQF_SHARED;
        }
#else
        irqflags = SA_INTERRUPT;
        if (entry->shared) {
            irqflags |= SA_SHIRQ;
        }
#endif    
    
        spin_unlock_irqrestore(&state->lock, flags);
        BDBG_MSG(("connect interrupt %s %d (%d, %p)", entry->name, LINUX_IRQ(irqNum), entry->shared, entry->special_handler));
        if (request_irq(LINUX_IRQ(irqNum), NEXUS_Platform_P_LinuxIsr, irqflags, entry->name, entry)) {
            /* disable */
            spin_lock_irqsave(&state->lock, flags);
            entry->handler = NULL;
            state->processing[reg].IntrMaskStatus |= (1 << (irqNum%32));
            spin_unlock_irqrestore(&state->lock, flags);
            return BERR_TRACE(-1);
        }
        entry->requested = true;
        entry->enabled = true;
        return 0;
    }    
    else if (!entry->enabled) {
        BDBG_MSG(("enable interrupt %d", LINUX_IRQ(irqNum)));
        if (!entry->special_handler) {
            enable_irq(LINUX_IRQ(irqNum));
        }
        entry->enabled = true;
    }
    spin_unlock_irqrestore(&state->lock, flags);
    return 0;
}

static void b_bare_disable_interrupt(unsigned irqNum)
{
    struct b_bare_interrupt_state *state = &b_bare_interrupt_state;
    struct b_bare_interrupt_entry *entry;
    unsigned reg = irqNum/32;
    unsigned long flags;

    if (irqNum>=NUM_IRQS) {
        BERR_TRACE(-1);
        return;
    }
    entry = &state->table[irqNum];
    if (!entry->handler) {
        BERR_TRACE(-1);
        return;
    }
    
    if (entry->enabled) {
        BDBG_ASSERT(entry->requested);
        BDBG_MSG(("disable interrupt %d", LINUX_IRQ(irqNum)));
        spin_lock_irqsave(&state->lock, flags);
        state->processing[reg].IntrMaskStatus |= (1 << (irqNum%32));
        if (!entry->special_handler) {
            /* If the TH has received the interrupt but it has not been processed by the tasklet, don't nest the disable call. */
            if ( 0 == (state->pending[reg].IntrStatus & (1 << (irqNum%32))) )
            {
                disable_irq_nosync(LINUX_IRQ(irqNum));
            }
        }
        entry->enabled = false;
        spin_unlock_irqrestore(&state->lock, flags);
    }
}

static void b_bare_disconnect_interrupt(unsigned irqNum)
{
    int rc;
    struct b_bare_interrupt_state *state = &b_bare_interrupt_state;
    struct b_bare_interrupt_entry *entry;
    unsigned reg = irqNum/32;
    unsigned long flags;

    if(irqNum>=NUM_IRQS) {
        rc = BERR_TRACE(-1);
        return;
    }
    entry = &state->table[irqNum];
    if (!entry->handler) {
        BERR_TRACE(-1);
        return;
    }
    
    spin_lock_irqsave(&state->lock, flags);
    BDBG_MSG(("disconnect interrupt %d", LINUX_IRQ(irqNum)));
    entry->handler = NULL;
    if (entry->enabled) {
        state->processing[reg].IntrMaskStatus |= (1 << (irqNum%32));
        entry->enabled = false;
    }
    if (entry->requested) {
        free_irq(LINUX_IRQ(irqNum), entry);
        entry->requested = false;
    }
    spin_unlock_irqrestore(&state->lock, flags);
}

static void *
b_bare_mmap(bool cached, unsigned offset, unsigned length)
{
    void *addr;
    
    /* this assumes linux 2.6.31-3.2 or later for full mmap support through kernel's ioremap */
    if (cached)
        addr = ioremap_cachable(offset, length);
    else
        addr = ioremap_nocache(offset, length);
    if (!addr) {
        BDBG_ERR(("ioremap(%#x, %#x, %s) failed", offset, length, cached?"cached":"uncached"));
    }
    return addr;
}

static void 
b_bare_munmap(void *addr, size_t size)
{
    BSTD_UNUSED(size);
    iounmap(addr);
}

static void 
b_bare_atomic_update(unsigned reg, uint32_t mask, uint32_t value)
{
    uint32_t temp;
    unsigned long flags;

    /* this spinlock synchronizes with any kernel use of a set of shared registers */
    spin_lock_irqsave(&brcm_magnum_spinlock, flags);

    /* read/modify/write by calling back into firmware */
    nexus_generic_driver_read_register(reg, &temp);
    temp &= ~mask;
    temp |= value;
    nexus_generic_driver_write_register(reg, temp);

    spin_unlock_irqrestore(&brcm_magnum_spinlock, flags);
}

static void *
b_bare_malloc(size_t size)
{
    return kmalloc(size, GFP_KERNEL);
}

static void 
b_bare_free(void *ptr)
{
    kfree(ptr);
    return;
}

static void 
b_bare_print_debug(bool high_priority, const char *str)
{
    BSTD_UNUSED(high_priority);
    printk("%s", str);
    return;
}

/* units of b_bare_os_tick is milliseconds */
static b_bare_os_tick 
b_bare_current_tick(void)
{
    return jiffies_to_msecs(jiffies);
}

static unsigned 
b_bare_tick_diff(b_bare_os_tick future, b_bare_os_tick past)
{
    return future - past;
}

struct b_bare_os_thread_tag {
    char name[16];
    void (*pThreadFunc)(void *);
    void *pContext;
    b_bare_os_thread_settings settings;
    struct task_struct *task;
};

static int b_bare_thread_start(void *data)
{
    b_bare_os_thread thread = data;
    thread->pThreadFunc(thread->pContext);
    /* do not return until stopped */
    while (1) {
        set_current_state(TASK_INTERRUPTIBLE); /* go half asleep before checking condition */
        if (kthread_should_stop()) break;
        schedule();
    }

    return 0;
}

static b_bare_os_thread 
b_bare_thread_create(const char *pThreadName, void (*callback)(void *), void *pContext, b_bare_os_thread_settings *pSettings)
{
    b_bare_os_thread thread;
    int mrc;

    BDBG_ASSERT(pThreadName);
    BDBG_ASSERT(callback);

    thread = kmalloc(sizeof(*thread), GFP_KERNEL);
    if(!thread) {
        mrc = BERR_TRACE(BERR_OS_ERROR);
        goto err_alloc;
    }
    strncpy(thread->name, pThreadName,sizeof(thread->name)-1);
    thread->name[sizeof(thread->name)-1]='\0';
    thread->pThreadFunc = callback;
    thread->pContext = pContext;
    thread->settings = *pSettings;

    /* in linux kernel stack size is fixed to 2 4K pages */
#define LINUX_KERNEL_STACK_SIZE (8*1024)
    if (thread->settings.stack_size < LINUX_KERNEL_STACK_SIZE) {
        BDBG_WRN(("b_bare_thread_create: %s stack size %u forced to %u",  thread->name, thread->settings.stack_size, LINUX_KERNEL_STACK_SIZE));
    }
    thread->settings.stack_size = LINUX_KERNEL_STACK_SIZE;

    thread->task = kthread_run(b_bare_thread_start, thread, thread->name);
    if (!thread->task) {
        kfree(thread);
        mrc = BERR_TRACE(BERR_OS_ERROR);
        return NULL;
    }

    return thread;

err_alloc:
    return NULL;
}

static void 
b_bare_thread_destroy(b_bare_os_thread thread)
{
    kthread_stop(thread->task);
    kfree(thread);
    return;
}

static void 
b_bare_dcache_flush(void *pvAddr, size_t ulNumBytes)
{
    if (ulNumBytes) {
        if((unsigned long)pvAddr >= 0x80000000) {
            dma_cache_wback_inv((unsigned long)pvAddr, ulNumBytes);
        } else {
            BDBG_MSG(("flushing fake address %#lx", (unsigned long)pvAddr));
        }
    }
    return;
}

static struct {
    unsigned count; /* provides short-circuit to full array search */
    struct {
        const char *key,*value;
    } env[64];
} b_bare_env = {
    0
   /* *** */
};

static const char *
b_bare_getenv(const char *name)
{
    unsigned i;
    for(i=0;i<b_bare_env.count;i++) {
        if (b_bare_env.env[i].key && strcmp(b_bare_env.env[i].key, name)==0) {
            return b_bare_env.env[i].value;
        }
    }
    return NULL;
}

static void
b_bare_setenv(const char *name, const char *value)
{
    unsigned i;
    unsigned freeslot = b_bare_env.count;

    for(i=0;i<b_bare_env.count;i++) {
        if (!b_bare_env.env[i].key && freeslot == b_bare_env.count) {
            freeslot = i;
        }

        if (b_bare_env.env[i].key && strcmp(b_bare_env.env[i].key, name)==0) {
            b_bare_env.env[i].value = value;
            if (!value) {
                /* if we're unsetting, free the slot but don't reduce the count */
                b_bare_env.env[i].key = NULL;
            }
            return;
        }
    }
    if (!value) return;

    /* save new key.value pair */
    if (freeslot<sizeof(b_bare_env.env)/sizeof(*b_bare_env.env)) {
        b_bare_env.env[freeslot].key = name;
        b_bare_env.env[freeslot].value = value;
        if (freeslot == b_bare_env.count) {
            b_bare_env.count++;
        }
    }
    else {
        BDBG_WRN(("Unable to store setenv(%s,%s)", name, value));
    }
    return;
}

static int b_bare_copy_from_process(void *dest, const void *src, unsigned size)
{
    return (int)copy_from_user(dest, src, size);
}

static int b_bare_copy_to_process(void *dest, const void *src, unsigned size)
{
    return (int)copy_to_user(dest, src, size);
}

static void b_bare_terminate_process(unsigned id)
{
    int rc;
    char pidstr[16];
    char *argv[] = {"/bin/kill", "-9", pidstr, NULL};
    snprintf(pidstr, 16, "%u", id);
    rc = call_usermodehelper("/bin/kill", argv, NULL, UMH_WAIT_PROC);
    if (rc) BERR_TRACE(rc);
}

b_bare_os_interface b_bare_os = {
    b_bare_malloc,
    b_bare_free,
    b_bare_print_debug,
    b_bare_current_tick,
    b_bare_tick_diff,
    b_bare_mmap,
    b_bare_munmap,
    b_bare_dcache_flush,
    b_bare_delay,
    b_bare_sleep,
    b_bare_lock_create,
    b_bare_lock_acquire,
    b_bare_lock_try_acquire,
    b_bare_lock_release,
    b_bare_lock_destroy,
    b_bare_signal_create,
    b_bare_signal_wait,
    b_bare_signal_set,
    b_bare_signal_destroy,
    b_bare_copy_from_process,
    b_bare_copy_to_process,
    b_bare_thread_create,
    b_bare_thread_destroy,
    b_bare_getenv,
    b_bare_setenv,
    b_bare_terminate_process,
    b_bare_atomic_update,
    b_bare_connect_interrupt,
    b_bare_enable_interrupt,
    b_bare_disable_interrupt,
    b_bare_disconnect_interrupt,
    b_bare_get_interrupt_lock,
        -1
};


/* The following pointer and accessor function are only used on the driver side. */
/* On the firmware side the pointer is located in kni/base/bkni.c and the accessor is located in stubs_rev.S */
/* as this file is not linked with the firmware. */
b_bare_os_interface *pb_bare_os = &b_bare_os;   

b_bare_os_interface *b_get_bare_os(void)
{
        return pb_bare_os;
}