system/kernel/lwip/arch/sys_arch.c

   1
   2 #include "arch/cc.h"
   3 #include "ke/panic.h"
   4 #include "ke/debug.h"
   5 #include "lwip/sys.h"
   6
   7 KeSpinlock critlock;
   8
   9 void sys_init(void)
  10 {
  11         keInitSpinlock(&critlock);
  12 }
  13
  14 void LWIP_PLATFORM_ASSERT(char *msg)
  15 {
  16         kePrint("%s\n", msg);
  17         kePanic(0, 42);
  18 }
  19
  20
  21 sys_sem_t sys_sem_new(u8_t count)
  22 {
  23         sys_sem_t sem = malloc(sizeof(KeSpinlock));
  24         keInitSpinlock(sem);
  25         if (count) keLockSpinlock(sem);
  26         return sem;
  27 }
  28 void sys_sem_free(sys_sem_t sem)
  29 {
  30         free(sem);
  31 }
  32 void sys_sem_signal(sys_sem_t sem)
  33 {
  34         keUnlockSpinlock(sem);
  35 }
  36 u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
  37 {
  38         if (!timeout)
  39         {
  40                 uint64_t starttime = keGetTime();
  41                 keLockSpinlock(sem);
  42                 uint64_t needed = keGetTime() - starttime;
  43                 return needed / 1000;
  44         }
  45         else
  46         {
  47                 uint64_t starttime = keGetTime();
  48                 uint64_t currenttime = starttime;
  49                 do
  50                 {
  51                         if (!keTryLockSpinlock(sem))
  52                         {
  53                                 return (currenttime - starttime) / 1000;
  54                         }
  55                         currenttime = keGetTime();
  56                 }
  57                 while (currenttime - starttime < timeout * 1000);
  58                 return SYS_ARCH_TIMEOUT;
  59         }
  60 }
  61
  62 sys_mbox_t sys_mbox_new(int size)
  63 {
  64         struct sys_mbox *mbox = malloc(sizeof(struct sys_mbox));
  65         keInitSpinlock(&mbox->lock);
  66         mbox->firstentry = 0;
  67         return mbox;
  68 }
  69 void sys_mbox_post(sys_mbox_t mbox, void *msg)
  70 {
  71         KeExecLevel oldlevel = keSetExecutionLevel(KE_LEVEL_HIGH);
  72         keLockSpinlock(&mbox->lock);
  73         sys_mbox_entry_t *entry = malloc(sizeof(sys_mbox_entry_t));
  74         entry->data = msg;
  75         entry->next = 0;
  76         if (!mbox->firstentry)
  77         {
  78                 mbox->firstentry = entry;
  79         }
  80         else
  81         {
  82                 sys_mbox_entry_t *prev = mbox->firstentry;
  83                 while (prev->next) prev = prev->next;
  84                 prev->next = entry;
  85         }
  86         keUnlockSpinlock(&mbox->lock);
  87         keSetExecutionLevel(oldlevel);
  88 }
  89 err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg)
  90 {
  91         sys_mbox_post(mbox, msg);
  92         return ERR_OK;
  93 }
  94 u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout)
  95 {
  96         if (!timeout)
  97         {
  98                 uint64_t starttime = keGetTime();
  99                 while (sys_arch_mbox_tryfetch(mbox, msg) != 0);
 100                 uint64_t needed = keGetTime() - starttime;
 101                 return needed / 1000;
 102         }
 103         else
 104         {
 105                 uint64_t starttime = keGetTime();
 106                 uint64_t currenttime = starttime;
 107                 do
 108                 {
 109                         if (sys_arch_mbox_tryfetch(mbox, msg) == 0)
 110                         {
 111                                 return (currenttime - starttime) / 1000;
 112                         }
 113                         asm volatile("int $0x32");
 114                         currenttime = keGetTime();
 115                 }
 116                 while (currenttime - starttime < timeout * 1000);
 117                 return SYS_ARCH_TIMEOUT;
 118         }
 119 }
 120 u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg)
 121 {
 122         KeExecLevel oldlevel = keSetExecutionLevel(KE_LEVEL_HIGH);
 123         keLockSpinlock(&mbox->lock);
 124         u32_t status = SYS_MBOX_EMPTY;
 125         if (mbox->firstentry)
 126         {
 127                 sys_mbox_entry_t *entry = mbox->firstentry;
 128                 mbox->firstentry = entry->next;
 129                 *msg = entry->data;
 130                 free(entry);
 131                 status = 0;
 132         }
 133         keUnlockSpinlock(&mbox->lock);
 134         keSetExecutionLevel(oldlevel);
 135         return status;
 136 }
 137 void sys_mbox_free(sys_mbox_t mbox)
 138 {
 139         KeExecLevel oldlevel = keSetExecutionLevel(KE_LEVEL_HIGH);
 140         keLockSpinlock(&mbox->lock);
 141         if (mbox->firstentry)
 142         {
 143                 kePrint("Trying to free full mailbox.\n");
 144         }
 145         free(mbox);
 146         keSetExecutionLevel(oldlevel);
 147 }
 148
 149 sys_prot_t sys_arch_protect(void)
 150 {
 151         KeExecLevel oldlevel = keSetExecutionLevel(KE_LEVEL_HIGH);
 152         return oldlevel;
 153 }
 154 void sys_arch_unprotect(sys_prot_t p)
 155 {
 156         keSetExecutionLevel(p);
 157 }
 158
 159 static struct sys_timeouts deftimeouts;
 160
 161 static KeSpinlock threadlock;
 162 static sys_thread_t *threads = 0;
 163 static uint32_t threadcount = 0;
 164
 165 sys_thread_t sys_thread_new(char *name, void (*func)(void *arg), void *arg, int stacksize, int prio)
 166 {
 167         kePrint("Creeating thread %s\n", name);
 168         // Create thread struct
 169         sys_thread_t thread = malloc(sizeof(struct sys_thread));
 170         memset(thread, 0, sizeof(struct sys_thread));
 171         thread->name = name;
 172         // Add to list
 173         KeExecLevel oldlevel = keSetExecutionLevel(KE_LEVEL_HIGH);
 174         keLockSpinlock(&threadlock);
 175         threads = realloc(threads, (threadcount + 1) * sizeof(sys_thread_t));
 176         threads[threadcount] = thread;
 177         threadcount++;
 178         keUnlockSpinlock(&threadlock);
 179         keSetExecutionLevel(oldlevel);
 180         // Start thread
 181         keCreateKernelThread((uintptr_t)func, 1, arg);
 182         return thread;
 183 }
 184
 185 struct sys_timeouts *sys_arch_timeouts(void)
 186 {
 187         KeExecLevel oldlevel = keSetExecutionLevel(KE_LEVEL_HIGH);
 188         KeThread *currentthread = keGetCurrentCPU()->currentthread;
 189         keLockSpinlock(&threadlock);
 190         struct sys_timeouts *timeouts = &deftimeouts;
 191         uint32_t i;
 192         for (i = 0; i < threadcount; i++)
 193         {
 194                 if (threads[i]->thread == currentthread)
 195                 {
 196                         timeouts = &threads[i]->timeouts;
 197                 }
 198         }
 199         keUnlockSpinlock(&threadlock);
 200         keSetExecutionLevel(oldlevel);
 201    return timeouts;
 202 }
 203
 204