/* * This file is subject to the terms of the GFX License. If a copy of * the license was not distributed with this file, you can obtain one at: * * http://ugfx.org/license.html */ /** * @file src/gos/raw32.c * @brief GOS Raw (bare metal) support. */ #include "gfx.h" #if GFX_USE_OS_RAW32 #include <string.h> // Prototype for memcpy() #if GOS_RAW_HEAP_SIZE != 0 static void _gosHeapInit(void); #else #define _gosHeapInit() #endif static void _gosThreadsInit(void); /********************************************************* * Initialise *********************************************************/ void _gosInit(void) { // Set up the heap allocator _gosHeapInit(); // Start the scheduler _gosThreadsInit(); } void _gosDeinit(void) { /* ToDo */ } /********************************************************* * For WIn32 emulation - automatically add the tick functions * the user would normally have to provide for bare metal. *********************************************************/ #if defined(WIN32) #undef Red #undef Green #undef Blue #define WIN32_LEAN_AND_MEAN #include <stdio.h> #include <windows.h> systemticks_t gfxSystemTicks(void) { return GetTickCount(); } systemticks_t gfxMillisecondsToTicks(delaytime_t ms) { return ms; } #endif /********************************************************* * Exit everything functions *********************************************************/ void gfxHalt(const char *msg) { #if defined(WIN32) fprintf(stderr, "%s\n", msg); ExitProcess(1); #else volatile uint32_t dummy; (void) msg; while(1) dummy++; #endif } void gfxExit(void) { #if defined(WIN32) ExitProcess(0); #else volatile uint32_t dummy; while(1) dummy++; #endif } /********************************************************* * Head allocation functions *********************************************************/ #if GOS_RAW_HEAP_SIZE == 0 #include <stdlib.h> // Prototype for malloc(), realloc() and free() void *gfxAlloc(size_t sz) { return malloc(sz); } void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz) { (void) oldsz; return realloc(ptr, newsz); } void gfxFree(void *ptr) { free(ptr); } #else // Slot structure - user memory follows typedef struct memslot { struct memslot *next; // The next memslot size_t sz; // Includes the size of this memslot. } memslot; // Free Slot - immediately follows the memslot structure typedef struct freeslot { memslot *nextfree; // The next free slot } freeslot; #define GetSlotSize(sz) ((((sz) + (sizeof(freeslot) - 1)) & ~(sizeof(freeslot) - 1)) + sizeof(memslot)) #define NextFree(pslot) ((freeslot *)Slot2Ptr(pslot))->nextfree #define Ptr2Slot(p) ((memslot *)(p) - 1) #define Slot2Ptr(pslot) ((pslot)+1) static memslot * firstSlot; static memslot * lastSlot; static memslot * freeSlots; static char heap[GOS_RAW_HEAP_SIZE]; static void _gosHeapInit(void) { lastSlot = 0; gfxAddHeapBlock(heap, GOS_RAW_HEAP_SIZE); } void gfxAddHeapBlock(void *ptr, size_t sz) { if (sz < sizeof(memslot)+sizeof(freeslot)) return; if (lastSlot) lastSlot->next = (memslot *)ptr; else firstSlot = lastSlot = freeSlots = (memslot *)ptr; lastSlot->next = 0; lastSlot->sz = sz; NextFree(lastSlot) = 0; } void *gfxAlloc(size_t sz) { register memslot *prev, *p, *new; if (!sz) return 0; sz = GetSlotSize(sz); for (prev = 0, p = freeSlots; p != 0; prev = p, p = NextFree(p)) { // Loop till we have a block big enough if (p->sz < sz) continue; // Can we save some memory by splitting this block? if (p->sz >= sz + sizeof(memslot)+sizeof(freeslot)) { new = (memslot *)((char *)p + sz); new->next = p->next; p->next = new; new->sz = p->sz - sz; p->sz = sz; if (lastSlot == p) lastSlot = new; NextFree(new) = NextFree(p); NextFree(p) = new; } // Remove it from the free list if (prev) NextFree(prev) = NextFree(p); else freeSlots = NextFree(p); // Return the result found return Slot2Ptr(p); } // No slots large enough return 0; } void *gfxRealloc(void *ptr, size_t oldsz, size_t sz) { register memslot *prev, *p, *new; (void) oldsz; if (!ptr) return gfxAlloc(sz); if (!sz) { gfxFree(ptr); return 0; } p = Ptr2Slot(ptr); sz = GetSlotSize(sz); // If the next slot is free (and contiguous) merge it into this one if ((char *)p + p->sz == (char *)p->next) { for (prev = 0, new = freeSlots; new != 0; prev = new, new = NextFree(new)) { if (new == p->next) { p->next = new->next; p->sz += new->sz; if (prev) NextFree(prev) = NextFree(new); else freeSlots = NextFree(new); if (lastSlot == new) lastSlot = p; break; } } } // If this block is large enough we are nearly done if (sz < p->sz) { // Can we save some memory by splitting this block? if (p->sz >= sz + sizeof(memslot)+sizeof(freeslot)) { new = (memslot *)((char *)p + sz); new->next = p->next; p->next = new; new->sz = p->sz - sz; p->sz = sz; if (lastSlot == p) lastSlot = new; NextFree(new) = freeSlots; freeSlots = new; } return Slot2Ptr(p); } // We need to do this the hard way if ((new = gfxAlloc(sz))) return 0; memcpy(new, ptr, p->sz - sizeof(memslot)); gfxFree(ptr); return new; } void gfxFree(void *ptr) { register memslot *prev, *p, *new; if (!ptr) return; p = Ptr2Slot(ptr); // If the next slot is free (and contiguous) merge it into this one if ((char *)p + p->sz == (char *)p->next) { for (prev = 0, new = freeSlots; new != 0; prev = new, new = NextFree(new)) { if (new == p->next) { p->next = new->next; p->sz += new->sz; if (prev) NextFree(prev) = NextFree(new); else freeSlots = NextFree(new); if (lastSlot == new) lastSlot = p; break; } } } // Add it into the free chain NextFree(p) = freeSlots; freeSlots = p; } #endif /********************************************************* * Semaphores and critical region functions *********************************************************/ #if !defined(INTERRUPTS_OFF) || !defined(INTERRUPTS_ON) #define INTERRUPTS_OFF() #define INTERRUPTS_ON() #endif void gfxSystemLock(void) { INTERRUPTS_OFF(); } void gfxSystemUnlock(void) { INTERRUPTS_ON(); } void gfxMutexInit(gfxMutex *pmutex) { pmutex[0] = 0; } void gfxMutexEnter(gfxMutex *pmutex) { INTERRUPTS_OFF(); while (pmutex[0]) { INTERRUPTS_ON(); gfxYield(); INTERRUPTS_OFF(); } pmutex[0] = 1; INTERRUPTS_ON(); } void gfxMutexExit(gfxMutex *pmutex) { pmutex[0] = 0; } void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit) { psem->cnt = val; psem->limit = limit; } bool_t gfxSemWait(gfxSem *psem, delaytime_t ms) { systemticks_t starttm, delay; // Convert our delay to ticks switch (ms) { case TIME_IMMEDIATE: delay = TIME_IMMEDIATE; break; case TIME_INFINITE: delay = TIME_INFINITE; break; default: delay = gfxMillisecondsToTicks(ms); if (!delay) delay = 1; starttm = gfxSystemTicks(); } INTERRUPTS_OFF(); while (psem->cnt <= 0) { INTERRUPTS_ON(); // Check if we have exceeded the defined delay switch (delay) { case TIME_IMMEDIATE: return FALSE; case TIME_INFINITE: break; default: if (gfxSystemTicks() - starttm >= delay) return FALSE; break; } gfxYield(); INTERRUPTS_OFF(); } psem->cnt--;