text: /*
   * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
   * Copyright (c) 2015 Matt Borgerson
   *
   * All rights reserved. 
   * 
   * Redistribution and use in source and binary forms, with or without modification, 
   * are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   *    this list of conditions and the following disclaimer.
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   * 3. The name of the author may not be used to endorse or promote products
   *    derived from this software without specific prior written permission. 
   *
   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
   * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
   * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
   * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
   * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
   * OF SUCH DAMAGE.
   *
   * This file is part of the lwIP TCP/IP stack.
   * 
   * Author: Adam Dunkels <adam@sics.se>
   * Xbox Support: Matt Borgerson
   *
   */
  #include "lwip/debug.h"
  #include "lwip/sys.h"
  #include "lwip/opt.h"
  #include "lwip/stats.h"
  #include <hal/xbox.h>
  
  #if !NO_SYS
  #include "xboxkrnl/xboxkrnl.h"
  #include <stdlib.h>
  
  static struct sys_sem *sys_sem_new_internal(u8_t count);
  static void sys_sem_free_internal(struct sys_sem *sem);
  
  static struct sys_thread *threads = NULL;
  
  struct sys_mbox_msg {
    struct sys_mbox_msg *next;
    void *msg;
  };
  
  #define SYS_MBOX_SIZE 128
  
  struct sys_mbox {
    int first, last;
    void *msgs[SYS_MBOX_SIZE];
    struct sys_sem *not_empty;
    struct sys_sem *not_full;
    struct sys_sem *mutex;
    int wait_send;
  };
  
  struct sys_sem {
    unsigned int c;
    HANDLE handle;
  };
  
  struct sys_thread {
    struct sys_thread *next;
    int handle;
  };
  #endif /* !NO_SYS */
  
  #if LWIP_DEBUG
  unsigned char debug_flags;
  #endif
  
  int errno;
  
  u32_t
  sys_now(void)
  {
    return KeTickCount;
  }
  
  void
  sys_init(void)
  {
  }
  
  #if 0
  u32_t
  sys_jiffies(void)
  {
    struct timespec ts;
  
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec * 1000000000L + ts.tv_nsec;
  }
  #endif
  
  #if !NO_SYS
  
  sys_thread_t
  sys_thread_new(const char *name, lwip_thread_fn function, void *arg, int stacksize, int prio)
  {
    struct sys_thread *st = NULL;
    LWIP_UNUSED_ARG(name);
    LWIP_UNUSED_ARG(stacksize);
    LWIP_UNUSED_ARG(prio);
  
    st = (struct sys_thread *)malloc(sizeof(struct sys_thread));
  
    if (NULL == st) {
      abort();
    }
  
    st->handle = XCreateThread((void *)function, arg, NULL);
    
    return st;
  }
  
  err_t
  sys_mbox_new(struct sys_mbox **mb, int size)
  {
    struct sys_mbox *mbox;
    LWIP_UNUSED_ARG(size);
  
    mbox = (struct sys_mbox *)malloc(sizeof(struct sys_mbox));
    if (mbox == NULL) {
      return ERR_MEM;
    }
    mbox->first = mbox->last = 0;
    mbox->not_empty = sys_sem_new_internal(0);
    mbox->not_full = sys_sem_new_internal(0);
    mbox->mutex = sys_sem_new_internal(1);
    mbox->wait_send = 0;
  
    SYS_STATS_INC_USED(mbox);
    *mb = mbox;
    return ERR_OK;
  }
  
  void
  sys_mbox_free(struct sys_mbox **mb)
  {
    if ((mb != NULL) && (*mb != SYS_MBOX_NULL)) {
      struct sys_mbox *mbox = *mb;
      SYS_STATS_DEC(mbox.used);
      sys_arch_sem_wait(&mbox->mutex, 0);
      
      sys_sem_free_internal(mbox->not_empty);
      sys_sem_free_internal(mbox->not_full);
      sys_sem_free_internal(mbox->mutex);
      mbox->not_empty = mbox->not_full = mbox->mutex = NULL;
      /*  LWIP_DEBUGF("sys_mbox_free: mbox 0x%lx\n", mbox); */
      free(mbox);
    }
  }
  
  err_t
  sys_mbox_trypost(struct sys_mbox **mb, void *msg)
  {
    u8_t first;
    struct sys_mbox *mbox;
    LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
    mbox = *mb;
  
    sys_arch_sem_wait(&mbox->mutex, 0);
  
    LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_trypost: mbox %p msg %p\n",
                            (void *)mbox, (void *)msg));
  
    if ((mbox->last + 1) >= (mbox->first + SYS_MBOX_SIZE)) {
      sys_sem_signal(&mbox->mutex);
      return ERR_MEM;
    }
  
    mbox->msgs[mbox->last % SYS_MBOX_SIZE] = msg;
  
    if (mbox->last == mbox->first) {
      first = 1;
    } else {
      first = 0;
    }
  
    mbox->last++;
  
    if (first) {
      sys_sem_signal(&mbox->not_empty);
    }
  
    sys_sem_signal(&mbox->mutex);
  
    return ERR_OK;
  }
  
  void
  sys_mbox_post(struct sys_mbox **mb, void *msg)
  {
    u8_t first;
    struct sys_mbox *mbox;
    LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
    mbox = *mb;
  
    sys_arch_sem_wait(&mbox->mutex, 0);
  
    LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_post: mbox %p msg %p\n", (void *)mbox, (void *)msg));
  
    while ((mbox->last + 1) >= (mbox->first + SYS_MBOX_SIZE)) {
      mbox->wait_send++;
      sys_sem_signal(&mbox->mutex);
      sys_arch_sem_wait(&mbox->not_full, 0);
      sys_arch_sem_wait(&mbox->mutex, 0);
      mbox->wait_send--;
    }
  
    mbox->msgs[mbox->last % SYS_MBOX_SIZE] = msg;
  
    if (mbox->last == mbox->first) {
      first = 1;
    } else {
      first = 0;
    }
  
    mbox->last++;
  
    if (first) {
      sys_sem_signal(&mbox->not_empty);
    }
  
    sys_sem_signal(&mbox->mutex);
  }
  
  u32_t
  sys_arch_mbox_tryfetch(struct sys_mbox **mb, void **msg)
  {
    struct sys_mbox *mbox;
    LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
    mbox = *mb;
  
    sys_arch_sem_wait(&mbox->mutex, 0);
  
    if (mbox->first == mbox->last) {
      sys_sem_signal(&mbox->mutex);
      return SYS_MBOX_EMPTY;
    }
  
    if (msg != NULL) {
      LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_tryfetch: mbox %p msg %p\n", (void *)mbox, *msg));
      *msg = mbox->msgs[mbox->first % SYS_MBOX_SIZE];
    }
    else{
      LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_tryfetch: mbox %p, null msg\n", (void *)mbox));
    }
  
    mbox->first++;
  
    if (mbox->wait_send) {
      sys_sem_signal(&mbox->not_full);
    }
  
    sys_sem_signal(&mbox->mutex);
  
    return 0;
  }
  
  u32_t
  sys_arch_mbox_fetch(struct sys_mbox **mb, void **msg, u32_t timeout)
  {
    u32_t time_needed = 0;
    struct sys_mbox *mbox;
    LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
    mbox = *mb;
  
    /* The mutex lock is quick so we don't bother with the timeout
       stuff here. */
    sys_arch_sem_wait(&mbox->mutex, 0);
  
    while (mbox->first == mbox->last) {
      sys_sem_signal(&mbox->mutex);
  
      /* We block while waiting for a mail to arrive in the mailbox. We
         must be prepared to timeout. */
      if (timeout != 0) {
        time_needed = sys_arch_sem_wait(&mbox->not_empty, timeout);
  
        if (time_needed == SYS_ARCH_TIMEOUT) {
          return SYS_ARCH_TIMEOUT;
        }
      } else {
        sys_arch_sem_wait(&mbox->not_empty, 0);
      }
  
      sys_arch_sem_wait(&mbox->mutex, 0);
    }
  
    if (msg != NULL) {
      LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_fetch: mbox %p msg %p\n", (void *)mbox, *msg));
      *msg = mbox->msgs[mbox->first % SYS_MBOX_SIZE];
    }
    else{
      LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_fetch: mbox %p, null msg\n", (void *)mbox));
    }
  
    mbox->first++;
  
    if (mbox->wait_send) {
      sys_sem_signal(&mbox->not_full);
    }
  
    sys_sem_signal(&mbox->mutex);
  
    return time_needed;
  }
  
  static struct sys_sem *
  sys_sem_new_internal(u8_t count)
  {
    struct sys_sem *sem;
  
    sem = (struct sys_sem *)malloc(sizeof(struct sys_sem));
    if (sem != NULL) {
      sem->c = count;
      NtCreateSemaphore(&(sem->handle), NULL, 1, 1);
    }
    return sem;
  }
  
  err_t
  sys_sem_new(struct sys_sem **sem, u8_t count)
  {
    SYS_STATS_INC_USED(sem);
    *sem = sys_sem_new_internal(count);
    if (*sem == NULL) {
      return ERR_MEM;
    }
    return ERR_OK;
  }
  
  u32_t
  sys_arch_sem_wait(struct sys_sem **s, u32_t timeout)
  {
    u32_t start, time_needed = 0;
    struct sys_sem *sem;
    LWIP_ASSERT("invalid sem", (s != NULL) && (*s != NULL));
    sem = *s;
    int done;
  
    start = sys_now();
  
    for (done=0; !done; )
    {
      NtWaitForSingleObject(sem->handle, FALSE, NULL);
  
      if (sem->c > 0)
      {
        sem->c -= 1;
        done = 1;
      }
  
      NtReleaseSemaphore(sem->handle, 1, NULL);
  
      if (timeout > 0)
      {
        time_needed = sys_now()-start;
        if (time_needed >= timeout) return SYS_ARCH_TIMEOUT;
      }
    }
  
    return (u32_t)time_needed;
  }
  
  void
  sys_sem_signal(struct sys_sem **s)
  {
    struct sys_sem *sem;
    LWIP_ASSERT("invalid sem", (s != NULL) && (*s != NULL));
    sem = *s;
  
    NtWaitForSingleObject(sem->handle, FALSE, NULL);
    sem->c++;
  
    if (sem->c > 1) {
      sem->c = 1;
    }
  
    NtReleaseSemaphore(sem->handle, 1, NULL);
  }
  
  static void
  sys_sem_free_internal(struct sys_sem *sem)
  {
    NTSTATUS status = NtClose((void*)sem->handle);
    if (!NT_SUCCESS(status)) {
        abort();
    }
    free(sem);
  }
  
  void
  sys_sem_free(struct sys_sem **sem)
  {
    if ((sem != NULL) && (*sem != SYS_SEM_NULL)) {
      SYS_STATS_DEC(sem.used);
      sys_sem_free_internal(*sem);
    }
  }
  
  #endif /* !NO_SYS */
  