/* Copyright (C) 2004 David Decotigny
 
    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    USA. 
 */
 
 
 #include <hwcore/irq.h>
 #include <sos/assert.h>
 
 
 #include "ksynch.h"
 
 
 sos_ret_t sos_ksema_init(struct sos_ksema *sema, const char *name,
                          int initial_value,
                          sos_kwaitq_ordering_t ordering)
 {
   sema->value = initial_value;
   return sos_kwaitq_init(& sema->kwaitq, name, ordering);
 }
 
 
 sos_ret_t sos_ksema_dispose(struct sos_ksema *sema)
 {
   return sos_kwaitq_dispose(& sema->kwaitq);
 }
 
 
 sos_ret_t sos_ksema_down(struct sos_ksema *sema,
                          struct sos_time *timeout)
 {
   sos_ui32_t flags;
   sos_ret_t retval;
 
   sos_disable_IRQs(flags);
   retval = SOS_OK;
 
   sema->value --;
   if (sema->value < 0)
     {
       /* Wait for somebody to wake us */
       retval = sos_kwaitq_wait(& sema->kwaitq, timeout);
 
       /* Something wrong happened (timeout, external wakeup, ...) ? */
       if (SOS_OK != retval)
         {
           /* Yes: pretend we did not ask for the semaphore */
           sema->value ++;
         }
     }
 
   sos_restore_IRQs(flags);
   return retval;
 }
 
 
 sos_ret_t sos_ksema_trydown(struct sos_ksema *sema)
 {
   sos_ui32_t flags;
   sos_ret_t retval;
 
   sos_disable_IRQs(flags);
 
   /* Can we take the semaphore without blocking ? */
   if (sema->value >= 1)
     {
       /* Yes: we take it now */
       sema->value --;      
       retval = SOS_OK;
     }
   else
     {
       /* No: we signal it */
       retval = -SOS_EBUSY;
     }
 
   sos_restore_IRQs(flags);
   return retval;
 }
 
 
 sos_ret_t sos_ksema_up(struct sos_ksema *sema)
 {
   sos_ui32_t flags;
   sos_ret_t retval;
 
   sos_disable_IRQs(flags);
 
   sema->value ++;
   retval = sos_kwaitq_wakeup(& sema->kwaitq, 1, SOS_OK);
 
   sos_restore_IRQs(flags);
   return retval;
 }
 
 
 sos_ret_t sos_kmutex_init(struct sos_kmutex *mutex, const char *name,
                           sos_kwaitq_ordering_t ordering)
 {
   mutex->owner = NULL;
   return sos_kwaitq_init(& mutex->kwaitq, name, ordering);
 }
 
 
 sos_ret_t sos_kmutex_dispose(struct sos_kmutex *mutex)
 {
   return sos_kwaitq_dispose(& mutex->kwaitq);
 }
 
 
 /*
  * Implementation based on ownership transfer (ie no while()
  * loop). The only assumption is that the thread awoken by
  * kmutex_unlock is not suppressed before effectively waking up: in
  * that case the mutex will be forever locked AND unlockable (by
  * nobody other than the owner, but this is not natural since this
  * owner already issued an unlock()...). The same problem happens with
  * the semaphores, but in a less obvious manner.
  */
 sos_ret_t sos_kmutex_lock(struct sos_kmutex *mutex,
                           struct sos_time *timeout)
 {
   __label__ exit_kmutex_lock;
   sos_ui32_t flags;
   sos_ret_t retval;
 
   sos_disable_IRQs(flags);
   retval = SOS_OK;
 
   /* Mutex already owned ? */
   if (NULL != mutex->owner)
     {
       /* Owned by us or by someone else ? */
       if (sos_thread_get_current() == mutex->owner)
         {
           /* Owned by us: do nothing */
           retval = -SOS_EBUSY;
           goto exit_kmutex_lock;
         }
 
       /* Wait for somebody to wake us */
       retval = sos_kwaitq_wait(& mutex->kwaitq, timeout);
 
       /* Something wrong happened ? */
       if (SOS_OK != retval)
         {
           goto exit_kmutex_lock;
         }
     }
 
   /* Ok, the mutex is available to us: take it */
   mutex->owner = sos_thread_get_current();
 
  exit_kmutex_lock:
   sos_restore_IRQs(flags);
   return retval;
 }
 
 
 sos_bool_t sos_kmutex_owned_by_me(struct sos_kmutex const* mutex)
 {
   sos_ui32_t flags;
   sos_bool_t retval;
 
   sos_disable_IRQs(flags);
   retval = (sos_thread_get_current() == mutex->owner);
   sos_restore_IRQs(flags);
 
   return retval;
 }
 
 
 sos_ret_t sos_kmutex_trylock(struct sos_kmutex *mutex)
 {
   sos_ui32_t flags;
   sos_ret_t retval;
 
   sos_disable_IRQs(flags);
 
   /* Mutex available to us ? */
   if (NULL == mutex->owner)
     {
       /* Great ! Take it now */
       mutex->owner = sos_thread_get_current();
 
       retval = SOS_OK;
     }
   else
     {
       /* No: signal it */
       retval = -SOS_EBUSY;
     }
 
   sos_restore_IRQs(flags);
   return retval;
 }
 
 
 sos_ret_t sos_kmutex_unlock(struct sos_kmutex *mutex)
 {
   sos_ui32_t flags;
   sos_ret_t  retval;
 
   sos_disable_IRQs(flags);
 
   if (sos_thread_get_current() != mutex->owner)
     retval = -SOS_EPERM;
 
   else if (sos_kwaitq_is_empty(& mutex->kwaitq))
     {
       /*
        * There is NOT ANY thread waiting => we really mark the mutex
        * as FREE
        */
       mutex->owner = NULL;
       retval = SOS_OK;
     }
   else
     {
       /*
        * There is at least 1 thread waiting => we DO NOT mark the
        * mutex as free !
        * Actually, we should have written:
        *   mutex->owner = thread_that_is_woken_up;
        * But the real Id of the next thread owning the mutex is not
        * that important. What is important here is that mutex->owner
        * IS NOT NULL and does not correspond to any existing thread
        * (address 0x43 is a good candidate because, in SOS, addresses
        * below 4kB are never mapped in order to catch invalid
        * pointers). Otherwise there will be a possibility for the
        * thread woken up here to have the mutex stolen by a thread
        * locking the mutex in the meantime.
        */
 #define MUTEX_STILL_LOCKED ((struct sos_thread*) 0x43)
       mutex->owner = MUTEX_STILL_LOCKED;
 
       /* We wake up ONE thread ONLY */
       retval = sos_kwaitq_wakeup(& mutex->kwaitq, 1, SOS_OK);
     } 
  
   sos_restore_IRQs(flags);
   return retval;
 }