/* Realtek RTL8169 Family Driver
 * Copyright (C) 2004 Marcus Overhagen <marcus@overhagen.de>. All rights reserved.
 *
 * Permission to use, copy, modify and distribute this software and its 
 * documentation for any purpose and without fee is hereby granted, provided
 * that the above copyright notice appear in all copies, and that both the
 * copyright notice and this permission notice appear in supporting documentation.
 *
 * Marcus Overhagen makes no representations about the suitability of this software
 * for any purpose. It is provided "as is" without express or implied warranty.
 *
 * MARCUS OVERHAGEN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL MARCUS
 * OVERHAGEN BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
 * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#include <Errors.h>
#include <OS.h>
#include <string.h>

#include "debug.h"
#include "fwdebug.h"
#include "timer.h"

#define MAX_TIMERS 8


struct timer_info
{
        timer_id                id;
        timer_function  func;
        void *                  cookie;
        bigtime_t               next_event;
        bigtime_t               interval;
        bool                    periodic;
};


static struct timer_info        sTimerData[MAX_TIMERS];
static int                                      sTimerCount;
static timer_id                         sTimerNextId;
static thread_id                        sTimerThread;
static sem_id                           sTimerSem;
static spinlock                         sTimerSpinlock;


static int32
timer_thread(void *cookie)
{
        status_t status = 0;

        do {
                bigtime_t timeout;
                bigtime_t now;
                cpu_status cpu;
                timer_function func;
                void * cookie;
                int i;
                int index;

                cpu = disable_interrupts();
                acquire_spinlock(&sTimerSpinlock);

                now = system_time();
                cookie = 0;
                func = 0;
                                
                // find timer with smallest event time
                index = -1;
                timeout = B_INFINITE_TIMEOUT;
                for (i = 0; i < sTimerCount; i++) {
                        if (sTimerData[i].next_event < timeout) {
                                timeout = sTimerData[i].next_event;
                                index = i;
                        }
                }
                
                if (timeout < now) {
                        // timer is ready for execution, load func and cookie
                        ASSERT(index >= 0 && index < sTimerCount);
                        func = sTimerData[index].func;
                        cookie = sTimerData[index].cookie;
                        if (sTimerData[index].periodic) {
                                // periodic timer is ready, update the entry
                                sTimerData[index].next_event += sTimerData[index].interval;
                        } else {
                                // single shot timer is ready, delete the entry
                                if (index != (sTimerCount - 1) && sTimerCount != 1) {
                                        memcpy(&sTimerData[index], &sTimerData[sTimerCount - 1], sizeof(struct timer_info));
                                }
                                sTimerCount--;
                        }
                }

                release_spinlock(&sTimerSpinlock);
                restore_interrupts(cpu);
                
                // execute timer hook
                if (timeout < now) {
                        ASSERT(func);
                        func(cookie);
                        continue;
                }

                status = acquire_sem_etc(sTimerSem, 1, B_ABSOLUTE_TIMEOUT, timeout);
        } while (status != B_BAD_SEM_ID);

        return 0;
}


timer_id
create_timer(timer_function func, void *cookie, bigtime_t interval, uint32 flags)
{
        cpu_status cpu;
        timer_id id;
        
        if (func == 0)
                return -1;
        
        // Attention: flags are not real flags, as B_PERIODIC_TIMER is 3

        cpu = disable_interrupts();
        acquire_spinlock(&sTimerSpinlock);
        
        if (sTimerCount < MAX_TIMERS) {
                id = sTimerNextId;
                sTimerData[sTimerCount].id = id;
                sTimerData[sTimerCount].func = func;
                sTimerData[sTimerCount].cookie = cookie;
                sTimerData[sTimerCount].next_event = (flags == B_ONE_SHOT_ABSOLUTE_TIMER) ? interval : system_time() + interval;
                sTimerData[sTimerCount].interval = interval;
                sTimerData[sTimerCount].periodic = flags == B_PERIODIC_TIMER;
                sTimerNextId++;
                sTimerCount++;
        } else {
                id = -1;
        }
        
        release_spinlock(&sTimerSpinlock);
        restore_interrupts(cpu);
        
        if (id != -1)
                release_sem_etc(sTimerSem, 1, B_DO_NOT_RESCHEDULE);

        return id;
}


status_t
delete_timer(timer_id id)
{
        cpu_status cpu;
        bool deleted;
        int i;

        deleted = false;
        
        cpu = disable_interrupts();
        acquire_spinlock(&sTimerSpinlock);
        
        for (i = 0; i < sTimerCount; i++) {
                if (sTimerData[i].id == id) {
                        if (i != (sTimerCount - 1) && sTimerCount != 1) {
                                memcpy(&sTimerData[i], &sTimerData[sTimerCount - 1], sizeof(struct timer_info));
                        }
                        sTimerCount--;
                        deleted = true;
                        break;
                }
        }
        
        release_spinlock(&sTimerSpinlock);
        restore_interrupts(cpu);

        if (!deleted)
                return B_ERROR;
                
        release_sem_etc(sTimerSem, 1, B_DO_NOT_RESCHEDULE);
        return B_OK;
}


status_t
initialize_timer(void)
{
        sTimerCount = 0;
        sTimerNextId = 1;
        B_INITIALIZE_SPINLOCK(&sTimerSpinlock);
        
        sTimerThread = spawn_kernel_thread(timer_thread, "firewire timer", 80, 0);
        sTimerSem = create_sem(0, "firewire timer");
        set_sem_owner(sTimerSem, B_SYSTEM_TEAM);
        
        if (sTimerSem < 0 || sTimerThread < 0) {
                delete_sem(sTimerSem);
                kill_thread(sTimerThread);
                return B_ERROR;
        }
        
        resume_thread(sTimerThread);
        return B_OK;
}


status_t
terminate_timer(void)
{
        status_t thread_return_value;

        delete_sem(sTimerSem);
        return wait_for_thread(sTimerThread, &thread_return_value);     
}