diff --git a/pkg/tlsf/.gitignore b/pkg/tlsf/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..58a9b88df597ce4e37b5d48a1d5ac9d15a7817ec
--- /dev/null
+++ b/pkg/tlsf/.gitignore
@@ -0,0 +1 @@
+/tlsf-*.zip
diff --git a/pkg/tlsf/Makefile b/pkg/tlsf/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..7ea14d4eaca37a7f9a4033ba0955f4d7f4b6b4f6
--- /dev/null
+++ b/pkg/tlsf/Makefile
@@ -0,0 +1,41 @@
+PKG_NAME = tlsf
+PKG_VERSION = 3.0
+PKG_FILE = tlsf-$(PKG_VERSION).zip
+PKG_URL = http://tlsf.baisoku.org/$(PKG_FILE)
+
+ifeq (, $(UNZIP))
+ ifeq (0, $(shell which unzip 2>&1 > /dev/null ; echo $$?))
+ UNZIP := $(shell which unzip)
+ else
+ ifeq (0, $(shell which 7z 2>&1 > /dev/null ; echo $$?))
+ UNZIP := $(shell which 7z) x
+ else
+ $(error "Neither unzip nor 7z is installed.")
+ endif
+ endif
+endif
+
+.PHONY: all clean patch reset
+
+all: $(BINDIR)$(PKG_NAME).a
+
+$(BINDIR)$(PKG_NAME).a: $(BINDIR)$(PKG_NAME)-src/Makefile
+ $(AD)make -C $(<D)
+
+$(BINDIR)$(PKG_NAME)-src/Makefile: $(CURDIR)/$(PKG_FILE) $(CURDIR)/patch.txt
+ @rm -rf $(@D)
+ @mkdir -p $(@D)
+ $(AD)cd $(@D) && $(UNZIP) $(CURDIR)/$(PKG_FILE)
+ $(AD)cd $(@D) && patch --binary -p0 -N -i $(CURDIR)/patch.txt
+
+$(CURDIR)/$(PKG_FILE):
+ $(AD)wget -nv -c -O $@ $(PKG_URL)
+
+clean::
+ rm -rf $(BINDIR)$(PKG_NAME)-src/
+
+distclean:: clean
+ rm -f $(CURDIR)/$(PKG_FILE)
+
+Makefile.include:
+ @true
diff --git a/pkg/tlsf/Makefile.include b/pkg/tlsf/Makefile.include
new file mode 100644
index 0000000000000000000000000000000000000000..9313f40066dbf6f338f799f9427f5a6ea2969a41
--- /dev/null
+++ b/pkg/tlsf/Makefile.include
@@ -0,0 +1 @@
+INCLUDES += -I$(BINDIR)tlsf-src
diff --git a/pkg/tlsf/patch.txt b/pkg/tlsf/patch.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ad87cc36a38461ec39dacd46f5359a42769f9bfc
--- /dev/null
+++ b/pkg/tlsf/patch.txt
@@ -0,0 +1,636 @@
+diff -NdaU0 tlsf.c tlsf.c
+--- tlsf.c
++++ tlsf.c
+@@ -25,4 +24,0 @@
+-#if defined (TLSF_64BIT)
+- /* All allocation sizes and addresses are aligned to 8 bytes. */
+- ALIGN_SIZE_LOG2 = 3,
+-#else
+@@ -30,3 +26,2 @@
+- ALIGN_SIZE_LOG2 = 2,
+-#endif
+- ALIGN_SIZE = (1 << ALIGN_SIZE_LOG2),
++#define ALIGN_SIZE_LOG2 (2)
++#define ALIGN_SIZE (1 << ALIGN_SIZE_LOG2)
+@@ -45,7 +39,0 @@
+-#if defined (TLSF_64BIT)
+- /*
+- ** TODO: We can increase this to support larger sizes, at the expense
+- ** of more overhead in the TLSF structure.
+- */
+- FL_INDEX_MAX = 32,
+-#else
+@@ -53 +40,0 @@
+-#endif
+@@ -73 +60 @@
+-#define tlsf_assert assert
++#define tlsf_assert(X) do { if (0) { (void) (X); } } while (0)
+@@ -165,0 +153,14 @@
++static control_t control __attribute__ ((aligned(ALIGN_SIZE))) = {
++ .block_null = {
++ .next_free = &control.block_null,
++ .prev_free = &control.block_null,
++ },
++ .fl_bitmap = 0,
++ .sl_bitmap = {0},
++ .blocks = {
++ [0 ... FL_INDEX_COUNT-1] = {
++ [0 ... SL_INDEX_COUNT-1] = &control.block_null
++ }
++ }
++};
++
+@@ -345 +346 @@
+-static block_header_t* search_suitable_block(control_t* control, int* fli, int* sli)
++static block_header_t* search_suitable_block(int* fli, int* sli)
+@@ -354 +355 @@
+- unsigned int sl_map = control->sl_bitmap[fl] & (~0 << sl);
++ unsigned int sl_map = control.sl_bitmap[fl] & (~0 << sl);
+@@ -358 +359 @@
+- const unsigned int fl_map = control->fl_bitmap & (~0 << (fl + 1));
++ const unsigned int fl_map = control.fl_bitmap & (~0 << (fl + 1));
+@@ -367 +368 @@
+- sl_map = control->sl_bitmap[fl];
++ sl_map = control.sl_bitmap[fl];
+@@ -374 +375 @@
+- return control->blocks[fl][sl];
++ return control.blocks[fl][sl];
+@@ -378 +379 @@
+-static void remove_free_block(control_t* control, block_header_t* block, int fl, int sl)
++static void remove_free_block(block_header_t* block, int fl, int sl)
+@@ -388 +389 @@
+- if (control->blocks[fl][sl] == block)
++ if (control.blocks[fl][sl] == block)
+@@ -390 +391 @@
+- control->blocks[fl][sl] = next;
++ control.blocks[fl][sl] = next;
+@@ -393 +394 @@
+- if (next == &control->block_null)
++ if (next == &control.block_null)
+@@ -395 +396 @@
+- control->sl_bitmap[fl] &= ~(1 << sl);
++ control.sl_bitmap[fl] &= ~(1 << sl);
+@@ -398 +399 @@
+- if (!control->sl_bitmap[fl])
++ if (!control.sl_bitmap[fl])
+@@ -400 +401 @@
+- control->fl_bitmap &= ~(1 << fl);
++ control.fl_bitmap &= ~(1 << fl);
+@@ -407 +408 @@
+-static void insert_free_block(control_t* control, block_header_t* block, int fl, int sl)
++static void insert_free_block(block_header_t* block, int fl, int sl)
+@@ -409 +410 @@
+- block_header_t* current = control->blocks[fl][sl];
++ block_header_t* current = control.blocks[fl][sl];
+@@ -413 +414 @@
+- block->prev_free = &control->block_null;
++ block->prev_free = &control.block_null;
+@@ -422,3 +423,3 @@
+- control->blocks[fl][sl] = block;
+- control->fl_bitmap |= (1 << fl);
+- control->sl_bitmap[fl] |= (1 << sl);
++ control.blocks[fl][sl] = block;
++ control.fl_bitmap |= (1 << fl);
++ control.sl_bitmap[fl] |= (1 << sl);
+@@ -428 +429 @@
+-static void block_remove(control_t* control, block_header_t* block)
++static void block_remove(block_header_t* block)
+@@ -432 +433 @@
+- remove_free_block(control, block, fl, sl);
++ remove_free_block(block, fl, sl);
+@@ -436 +437 @@
+-static void block_insert(control_t* control, block_header_t* block)
++static void block_insert(block_header_t* block)
+@@ -440 +441 @@
+- insert_free_block(control, block, fl, sl);
++ insert_free_block(block, fl, sl);
+@@ -481 +482 @@
+-static block_header_t* block_merge_prev(control_t* control, block_header_t* block)
++static block_header_t* block_merge_prev(block_header_t* block)
+@@ -488 +489 @@
+- block_remove(control, prev);
++ block_remove(prev);
+@@ -496 +497 @@
+-static block_header_t* block_merge_next(control_t* control, block_header_t* block)
++static block_header_t* block_merge_next(block_header_t* block)
+@@ -504 +505 @@
+- block_remove(control, next);
++ block_remove(next);
+@@ -512 +513 @@
+-static void block_trim_free(control_t* control, block_header_t* block, size_t size)
++static void block_trim_free(block_header_t* block, size_t size)
+@@ -520 +521 @@
+- block_insert(control, remaining_block);
++ block_insert(remaining_block);
+@@ -525 +526 @@
+-static void block_trim_used(control_t* control, block_header_t* block, size_t size)
++static void block_trim_used(block_header_t* block, size_t size)
+@@ -534,2 +535,2 @@
+- remaining_block = block_merge_next(control, remaining_block);
+- block_insert(control, remaining_block);
++ remaining_block = block_merge_next(remaining_block);
++ block_insert(remaining_block);
+@@ -539 +540 @@
+-static block_header_t* block_trim_free_leading(control_t* control, block_header_t* block, size_t size)
++static block_header_t* block_trim_free_leading(block_header_t* block, size_t size)
+@@ -549 +550 @@
+- block_insert(control, block);
++ block_insert(block);
+@@ -555 +556 @@
+-static block_header_t* block_locate_free(control_t* control, size_t size)
++static block_header_t* block_locate_free(size_t size)
+@@ -563 +564 @@
+- block = search_suitable_block(control, &fl, &sl);
++ block = search_suitable_block(&fl, &sl);
+@@ -569 +570 @@
+- remove_free_block(control, block, fl, sl);
++ remove_free_block(block, fl, sl);
+@@ -575 +576 @@
+-static void* block_prepare_used(control_t* control, block_header_t* block, size_t size)
++static void* block_prepare_used(block_header_t* block, size_t size)
+@@ -580 +581 @@
+- block_trim_free(control, block, size);
++ block_trim_free(block, size);
+@@ -587,184 +588 @@
+-/* Clear structure and point all empty lists at the null block. */
+-static void control_construct(control_t* control)
+-{
+- int i, j;
+-
+- control->block_null.next_free = &control->block_null;
+- control->block_null.prev_free = &control->block_null;
+-
+- control->fl_bitmap = 0;
+- for (i = 0; i < FL_INDEX_COUNT; ++i)
+- {
+- control->sl_bitmap[i] = 0;
+- for (j = 0; j < SL_INDEX_COUNT; ++j)
+- {
+- control->blocks[i][j] = &control->block_null;
+- }
+- }
+-}
+-
+-/*
+-** Debugging utilities.
+-*/
+-
+-typedef struct integrity_t
+-{
+- int prev_status;
+- int status;
+-} integrity_t;
+-
+-#define tlsf_insist(x) { tlsf_assert(x); if (!(x)) { status--; } }
+-
+-static void integrity_walker(void* ptr, size_t size, int used, void* user)
+-{
+- block_header_t* block = block_from_ptr(ptr);
+- integrity_t* integ = tlsf_cast(integrity_t*, user);
+- const int this_prev_status = block_is_prev_free(block) ? 1 : 0;
+- const int this_status = block_is_free(block) ? 1 : 0;
+- const size_t this_block_size = block_size(block);
+-
+- int status = 0;
+- tlsf_insist(integ->prev_status == this_prev_status && "prev status incorrect");
+- tlsf_insist(size == this_block_size && "block size incorrect");
+-
+- integ->prev_status = this_status;
+- integ->status += status;
+-}
+-
+-int tlsf_check(tlsf_t tlsf)
+-{
+- int i, j;
+-
+- control_t* control = tlsf_cast(control_t*, tlsf);
+- int status = 0;
+-
+- /* Check that the free lists and bitmaps are accurate. */
+- for (i = 0; i < FL_INDEX_COUNT; ++i)
+- {
+- for (j = 0; j < SL_INDEX_COUNT; ++j)
+- {
+- const int fl_map = control->fl_bitmap & (1 << i);
+- const int sl_list = control->sl_bitmap[i];
+- const int sl_map = sl_list & (1 << j);
+- const block_header_t* block = control->blocks[i][j];
+-
+- /* Check that first- and second-level lists agree. */
+- if (!fl_map)
+- {
+- tlsf_insist(!sl_map && "second-level map must be null");
+- }
+-
+- if (!sl_map)
+- {
+- tlsf_insist(block == &control->block_null && "block list must be null");
+- continue;
+- }
+-
+- /* Check that there is at least one free block. */
+- tlsf_insist(sl_list && "no free blocks in second-level map");
+- tlsf_insist(block != &control->block_null && "block should not be null");
+-
+- while (block != &control->block_null)
+- {
+- int fli, sli;
+- tlsf_insist(block_is_free(block) && "block should be free");
+- tlsf_insist(!block_is_prev_free(block) && "blocks should have coalesced");
+- tlsf_insist(!block_is_free(block_next(block)) && "blocks should have coalesced");
+- tlsf_insist(block_is_prev_free(block_next(block)) && "block should be free");
+- tlsf_insist(block_size(block) >= block_size_min && "block not minimum size");
+-
+- mapping_insert(block_size(block), &fli, &sli);
+- tlsf_insist(fli == i && sli == j && "block size indexed in wrong list");
+- block = block->next_free;
+- }
+- }
+- }
+-
+- return status;
+-}
+-
+-#undef tlsf_insist
+-
+-static void default_walker(void* ptr, size_t size, int used, void* user)
+-{
+- (void)user;
+- printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, block_from_ptr(ptr));
+-}
+-
+-void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user)
+-{
+- tlsf_walker pool_walker = walker ? walker : default_walker;
+- block_header_t* block =
+- offset_to_block(pool, -(int)block_header_overhead);
+-
+- while (block && !block_is_last(block))
+- {
+- pool_walker(
+- block_to_ptr(block),
+- block_size(block),
+- !block_is_free(block),
+- user);
+- block = block_next(block);
+- }
+-}
+-
+-size_t tlsf_block_size(void* ptr)
+-{
+- size_t size = 0;
+- if (ptr)
+- {
+- const block_header_t* block = block_from_ptr(ptr);
+- size = block_size(block);
+- }
+- return size;
+-}
+-
+-int tlsf_check_pool(pool_t pool)
+-{
+- /* Check that the blocks are physically correct. */
+- integrity_t integ = { 0, 0 };
+- tlsf_walk_pool(pool, integrity_walker, &integ);
+-
+- return integ.status;
+-}
+-
+-/*
+-** Size of the TLSF structures in a given memory block passed to
+-** tlsf_create, equal to the size of a control_t
+-*/
+-size_t tlsf_size()
+-{
+- return sizeof(control_t);
+-}
+-
+-size_t tlsf_align_size()
+-{
+- return ALIGN_SIZE;
+-}
+-
+-size_t tlsf_block_size_min()
+-{
+- return block_size_min;
+-}
+-
+-size_t tlsf_block_size_max()
+-{
+- return block_size_max;
+-}
+-
+-/*
+-** Overhead of the TLSF structures in a given memory block passes to
+-** tlsf_add_pool, equal to the overhead of a free block and the
+-** sentinel block.
+-*/
+-size_t tlsf_pool_overhead()
+-{
+- return 2 * block_header_overhead;
+-}
+-
+-size_t tlsf_alloc_overhead()
+-{
+- return block_header_overhead;
+-}
+-
+-pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
++int tlsf_add_pool(void* mem, size_t bytes)
+@@ -775 +593 @@
+- const size_t pool_overhead = tlsf_pool_overhead();
++ const size_t pool_overhead = 2 * block_header_overhead;
+@@ -787,5 +604,0 @@
+-#if defined (TLSF_64BIT)
+- printf("tlsf_add_pool: Memory size must be between 0x%x and 0x%x00 bytes.\n",
+- (unsigned int)(pool_overhead + block_size_min),
+- (unsigned int)((pool_overhead + block_size_max) / 256));
+-#else
+@@ -795 +607,0 @@
+-#endif
+@@ -808 +620 @@
+- block_insert(tlsf_cast(control_t*, tlsf), block);
++ block_insert(block);
+@@ -816,16 +628 @@
+- return mem;
+-}
+-
+-void tlsf_remove_pool(tlsf_t tlsf, pool_t pool)
+-{
+- control_t* control = tlsf_cast(control_t*, tlsf);
+- block_header_t* block = offset_to_block(pool, -(int)block_header_overhead);
+-
+- int fl = 0, sl = 0;
+-
+- tlsf_assert(block_is_free(block) && "block should be free");
+- tlsf_assert(!block_is_free(block_next(block)) && "next block should not be free");
+- tlsf_assert(block_size(block_next(block)) == 0 && "next block size should be zero");
+-
+- mapping_insert(block_size(block), &fl, &sl);
+- remove_free_block(control, block, fl, sl);
++ return 1;
+@@ -838,68 +635 @@
+-#if _DEBUG
+-int test_ffs_fls()
+-{
+- /* Verify ffs/fls work properly. */
+- int rv = 0;
+- rv += (tlsf_ffs(0) == -1) ? 0 : 0x1;
+- rv += (tlsf_fls(0) == -1) ? 0 : 0x2;
+- rv += (tlsf_ffs(1) == 0) ? 0 : 0x4;
+- rv += (tlsf_fls(1) == 0) ? 0 : 0x8;
+- rv += (tlsf_ffs(0x80000000) == 31) ? 0 : 0x10;
+- rv += (tlsf_ffs(0x80008000) == 15) ? 0 : 0x20;
+- rv += (tlsf_fls(0x80000008) == 31) ? 0 : 0x40;
+- rv += (tlsf_fls(0x7FFFFFFF) == 30) ? 0 : 0x80;
+-
+-#if defined (TLSF_64BIT)
+- rv += (tlsf_fls_sizet(0x80000000) == 31) ? 0 : 0x100;
+- rv += (tlsf_fls_sizet(0x100000000) == 32) ? 0 : 0x200;
+- rv += (tlsf_fls_sizet(0xffffffffffffffff) == 63) ? 0 : 0x400;
+-#endif
+-
+- if (rv)
+- {
+- printf("tlsf_create: %x ffs/fls tests failed!\n", rv);
+- }
+- return rv;
+-}
+-#endif
+-
+-tlsf_t tlsf_create(void* mem)
+-{
+-#if _DEBUG
+- if (test_ffs_fls())
+- {
+- return 0;
+- }
+-#endif
+-
+- if (((tlsfptr_t)mem % ALIGN_SIZE) != 0)
+- {
+- printf("tlsf_create: Memory must be aligned to %u bytes.\n",
+- (unsigned int)ALIGN_SIZE);
+- return 0;
+- }
+-
+- control_construct(tlsf_cast(control_t*, mem));
+-
+- return tlsf_cast(tlsf_t, mem);
+-}
+-
+-tlsf_t tlsf_create_with_pool(void* mem, size_t bytes)
+-{
+- tlsf_t tlsf = tlsf_create(mem);
+- tlsf_add_pool(tlsf, (char*)mem + tlsf_size(), bytes - tlsf_size());
+- return tlsf;
+-}
+-
+-void tlsf_destroy(tlsf_t tlsf)
+-{
+- /* Nothing to do. */
+- (void)tlsf;
+-}
+-
+-pool_t tlsf_get_pool(tlsf_t tlsf)
+-{
+- return tlsf_cast(pool_t, (char*)tlsf + tlsf_size());
+-}
+-
+-void* tlsf_malloc(tlsf_t tlsf, size_t size)
++void* tlsf_malloc(size_t size)
+@@ -907 +636,0 @@
+- control_t* control = tlsf_cast(control_t*, tlsf);
+@@ -909,2 +638,2 @@
+- block_header_t* block = block_locate_free(control, adjust);
+- return block_prepare_used(control, block, adjust);
++ block_header_t* block = block_locate_free(adjust);
++ return block_prepare_used(block, adjust);
+@@ -913 +642 @@
+-void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
++void* tlsf_memalign(size_t align, size_t size)
+@@ -915 +643,0 @@
+- control_t* control = tlsf_cast(control_t*, tlsf);
+@@ -932 +660 @@
+- block_header_t* block = block_locate_free(control, aligned_size);
++ block_header_t* block = block_locate_free(aligned_size);
+@@ -960 +688 @@
+- block = block_trim_free_leading(control, block, gap);
++ block = block_trim_free_leading(block, gap);
+@@ -964 +692 @@
+- return block_prepare_used(control, block, adjust);
++ return block_prepare_used(block, adjust);
+@@ -967 +695 @@
+-void tlsf_free(tlsf_t tlsf, void* ptr)
++void tlsf_free(void* ptr)
+@@ -972 +699,0 @@
+- control_t* control = tlsf_cast(control_t*, tlsf);
+@@ -976,3 +703,3 @@
+- block = block_merge_prev(control, block);
+- block = block_merge_next(control, block);
+- block_insert(control, block);
++ block = block_merge_prev(block);
++ block = block_merge_next(block);
++ block_insert(block);
+@@ -995 +722 @@
+-void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
++void* tlsf_realloc(void* ptr, size_t size)
+@@ -997 +723,0 @@
+- control_t* control = tlsf_cast(control_t*, tlsf);
+@@ -1003 +729 @@
+- tlsf_free(tlsf, ptr);
++ tlsf_free(ptr);
+@@ -1008 +734 @@
+- p = tlsf_malloc(tlsf, size);
++ p = tlsf_malloc(size);
+@@ -1027 +753 @@
+- p = tlsf_malloc(tlsf, size);
++ p = tlsf_malloc(size);
+@@ -1032 +758 @@
+- tlsf_free(tlsf, ptr);
++ tlsf_free(ptr);
+@@ -1040 +766 @@
+- block_merge_next(control, block);
++ block_merge_next(block);
+@@ -1045 +771 @@
+- block_trim_used(control, block, adjust);
++ block_trim_used(block, adjust);
+diff -NdaU0 tlsf.h tlsf.h
+--- tlsf.h
++++ tlsf.h
+@@ -21,15 +20,0 @@
+-#if defined(__cplusplus)
+-extern "C" {
+-#endif
+-
+-/* tlsf_t: a TLSF structure. Can contain 1 to N pools. */
+-/* pool_t: a block of memory that TLSF can manage. */
+-typedef void* tlsf_t;
+-typedef void* pool_t;
+-
+-/* Create/destroy a memory pool. */
+-tlsf_t tlsf_create(void* mem);
+-tlsf_t tlsf_create_with_pool(void* mem, size_t bytes);
+-void tlsf_destroy(tlsf_t tlsf);
+-pool_t tlsf_get_pool(tlsf_t tlsf);
+-
+@@ -37,2 +22 @@
+-pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes);
+-void tlsf_remove_pool(tlsf_t tlsf, pool_t pool);
++int tlsf_add_pool(void* mem, size_t bytes);
+@@ -41,26 +25,4 @@
+-void* tlsf_malloc(tlsf_t tlsf, size_t bytes);
+-void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t bytes);
+-void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size);
+-void tlsf_free(tlsf_t tlsf, void* ptr);
+-
+-/* Returns internal block size, not original request size */
+-size_t tlsf_block_size(void* ptr);
+-
+-/* Overheads/limits of internal structures. */
+-size_t tlsf_size();
+-size_t tlsf_align_size();
+-size_t tlsf_block_size_min();
+-size_t tlsf_block_size_max();
+-size_t tlsf_pool_overhead();
+-size_t tlsf_alloc_overhead();
+-
+-/* Debugging. */
+-typedef void (*tlsf_walker)(void* ptr, size_t size, int used, void* user);
+-void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user);
+-/* Returns nonzero if any internal consistency check fails. */
+-int tlsf_check(tlsf_t tlsf);
+-int tlsf_check_pool(pool_t pool);
+-
+-#if defined(__cplusplus)
+-};
+-#endif
++void* tlsf_malloc(size_t bytes);
++void* tlsf_memalign(size_t align, size_t bytes);
++void* tlsf_realloc(void* ptr, size_t size);
++void tlsf_free(void* ptr);
+diff -NdaU0 Makefile Makefile
+--- Makefile
++++ Makefile
+@@ -0,0 +1,3 @@
++MODULE = tlsf
++
++include $(RIOTBASE)/Makefile.base
+diff -NdaU0 tlsf-malloc.c tlsf-malloc.c
+--- tlsf-malloc.c
++++ tlsf-malloc.c
+@@ -0,0 +1,44 @@
++#include "irq.h"
++#include "tlsf-malloc.h"
++
++#include <string.h>
++
++void *TLSF_MALLOC_NAME(malloc)(size_t bytes)
++{
++ unsigned old_state = disableIRQ();
++ void *result = tlsf_malloc(bytes);
++ restoreIRQ(old_state);
++ return result;
++}
++
++void *TLSF_MALLOC_NAME(calloc)(size_t count, size_t bytes)
++{
++ void *result = tlsf_malloc(count * bytes);
++ if (result) {
++ memset(result, 0, count * bytes);
++ }
++ return result;
++}
++
++void *TLSF_MALLOC_NAME(memalign)(size_t align, size_t bytes)
++{
++ unsigned old_state = disableIRQ();
++ void *result = tlsf_memalign(align, bytes);
++ restoreIRQ(old_state);
++ return result;
++}
++
++void *TLSF_MALLOC_NAME(realloc)(void *ptr, size_t size)
++{
++ unsigned old_state = disableIRQ();
++ void *result = tlsf_realloc(ptr, size);
++ restoreIRQ(old_state);
++ return result;
++}
++
++void TLSF_MALLOC_NAME(free)(void *ptr)
++{
++ unsigned old_state = disableIRQ();
++ tlsf_free(ptr);
++ restoreIRQ(old_state);
++}
+diff -NdaU0 tlsf-malloc.h tlsf-malloc.h
+--- tlsf-malloc.h
++++ tlsf-malloc.h
+@@ -0,0 +1,26 @@
++#ifndef __TLSF_MALLOC_H
++#define __TLSF_MALLOC_H
++
++#include <stdbool.h>
++#include <stddef.h>
++
++#include "tlsf.h"
++
++#ifndef TLSF_MALLOC_PREFIX
++# define TLSF_MALLOC_PREFIX
++#endif
++#define __TLSF_MALLOC_NAME(A, B) A ## B
++#define _TLSF_MALLOC_NAME(A, B) __TLSF_MALLOC_NAME(A, B)
++#define TLSF_MALLOC_NAME(NAME) _TLSF_MALLOC_NAME(TLSF_MALLOC_PREFIX, NAME)
++
++void *TLSF_MALLOC_NAME(malloc)(size_t bytes);
++
++void *TLSF_MALLOC_NAME(calloc)(size_t count, size_t bytes);
++
++void *TLSF_MALLOC_NAME(memalign)(size_t align, size_t bytes);
++
++void *TLSF_MALLOC_NAME(realloc)(void *ptr, size_t size);
++
++void TLSF_MALLOC_NAME(free)(void *ptr);
++
++#endif