diff --git a/ext/hal/ti/simplelink/kernel/zephyr/dpl/ClockP_zephyr.c b/ext/hal/ti/simplelink/kernel/zephyr/dpl/ClockP_zephyr.c
new file mode 100644
index 0000000..34f5731
--- /dev/null
+++ b/ext/hal/ti/simplelink/kernel/zephyr/dpl/ClockP_zephyr.c
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2017, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr.h>
+#include <misc/__assert.h>
+#include <kernel/zephyr/dpl/dpl.h>
+#include <ti/drivers/dpl/ClockP.h>
+
+uint32_t ClockP_getSystemTicks()
+{
+	return (uint32_t)_ms_to_ticks(k_uptime_get_32());
+}
+
+void ClockP_usleep(uint32_t usec)
+{
+	k_sleep((s32_t)usec);
+}
diff --git a/ext/hal/ti/simplelink/kernel/zephyr/dpl/HwiP_zephyr.c b/ext/hal/ti/simplelink/kernel/zephyr/dpl/HwiP_zephyr.c
new file mode 100644
index 0000000..201854f
--- /dev/null
+++ b/ext/hal/ti/simplelink/kernel/zephyr/dpl/HwiP_zephyr.c
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2017, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+#include <zephyr.h>
+#include <misc/__assert.h>
+#include <kernel/zephyr/dpl/dpl.h>
+#include <ti/drivers/dpl/HwiP.h>
+
+#include <inc/hw_types.h>
+#include <inc/hw_ints.h>
+#include <driverlib/rom.h>
+#include <driverlib/rom_map.h>
+#include <driverlib/interrupt.h>
+
+/*
+ * IRQ_CONNECT requires we know the ISR signature and argument
+ * at build time; whereas SimpleLink plugs the interrupts
+ * at run time, so we create an ISR shim, and register that.
+ * The callback argument doesn't change after the ISR is registered.
+ */
+struct sl_isr_args
+{
+	HwiP_Fxn cb;
+	uintptr_t arg;
+};
+
+static struct sl_isr_args sl_UDMA_cb = {NULL, 0};
+static struct sl_isr_args sl_UDMAERR_cb = {NULL, 0};
+static struct sl_isr_args sl_NWPIC_cb = {NULL, 0};
+static struct sl_isr_args sl_LSPI_cb = {NULL, 0};
+
+static void sl_isr(void *isr_arg)
+{
+	HwiP_Fxn cb = ((struct sl_isr_args *)isr_arg)->cb;
+	uintptr_t arg =	 ((struct sl_isr_args *)isr_arg)->arg;
+
+	/* Call the SimpleLink ISR Handler: */
+	if (cb) {
+		cb(arg);
+	}
+}
+
+/* Must hardcode the IRQ for IRQ_CONNECT macro.	 Must be <= CONFIG_NUM_IRQs.*/
+#define EXCEPTION_UDMA		46	/* == INT_UDMA	(62) - 16 */
+#define EXCEPTION_UDMAERR	47	/* == INT_UDMAERR (63) - 16 */
+#define EXCEPTION_NWPIC		171	/* == INT_NWPIC (187) - 16 */
+#define EXCEPTION_LSPI		177	/* == INT_LSPI (193) - 16 */
+
+HwiP_Handle HwiP_create(int interruptNum, HwiP_Fxn hwiFxn, HwiP_Params *params)
+{
+	HwiP_Handle handle = 0;
+	uint32_t priority = ~0;
+	uintptr_t arg = 0;
+
+	if (params) {
+		priority = params->priority;
+		arg = params->arg;
+	}
+
+	/*
+	 * SimpleLink only uses the NWPIC, UDMA, UDMAERR and LSPI interrupts:
+	 */
+	__ASSERT(INT_NWPIC == interruptNum || INT_UDMA == interruptNum ||
+		 INT_UDMAERR == interruptNum || INT_LSPI == interruptNum,
+		 "Unexpected interruptNum: %d\r\n",
+		 interruptNum);
+	/*
+	 * Priority expected is either:
+	 *    INT_PRIORITY_LVL_1,
+	 *    or ~0 or 255 (meaning lowest priority)
+	 *    ~0 and 255 are meant to be the same as INT_PRIORITY_LVL_7.
+	 *    For ~0 or 255, we want 7; but Zephyr IRQ_CONNECT adds +1,
+	 *    so we pass 6 for those TI drivers passing prio = ~0.
+	 */
+	__ASSERT((INT_PRIORITY_LVL_1 == priority) ||
+		 (0xff == (priority & 0xff)),
+		 "Expected priority: 0x%x or 0x%x, got: 0x%x\r\n",
+		 INT_PRIORITY_LVL_1, 0xff, (unsigned int)priority);
+
+	switch(interruptNum) {
+	case INT_UDMA:
+		sl_UDMA_cb.cb = hwiFxn;
+		sl_UDMA_cb.arg = arg;
+		IRQ_CONNECT(EXCEPTION_UDMA, 6, sl_isr, &sl_UDMA_cb, 0);
+		break;
+	case INT_UDMAERR:
+		sl_UDMAERR_cb.cb = hwiFxn;
+		sl_UDMAERR_cb.arg = arg;
+		IRQ_CONNECT(EXCEPTION_UDMAERR, 6, sl_isr, &sl_UDMAERR_cb, 0);
+		break;
+	case INT_NWPIC:
+		sl_NWPIC_cb.cb = hwiFxn;
+		sl_NWPIC_cb.arg = arg;
+		IRQ_CONNECT(EXCEPTION_NWPIC, 1, sl_isr, &sl_NWPIC_cb, 0);
+		break;
+	case INT_LSPI:
+		sl_LSPI_cb.cb = hwiFxn;
+		sl_LSPI_cb.arg = arg;
+		IRQ_CONNECT(EXCEPTION_LSPI, 6, sl_isr, &sl_LSPI_cb, 0);
+		break;
+	default:
+		return(handle);
+	}
+	irq_enable(interruptNum - 16);
+
+	return (HwiP_Handle)interruptNum;
+}
+
+/* Can't actually de-register an interrupt in Zephyr, so just disable: */
+void HwiP_delete(HwiP_Handle handle)
+{
+	int interruptNum = (int)handle;
+
+	__ASSERT(INT_NWPIC == interruptNum || INT_UDMA == interruptNum ||
+		 INT_UDMAERR == interruptNum || INT_LSPI == interruptNum,
+		 "Unexpected interruptNum: %d\r\n",
+		 interruptNum);
+
+	irq_disable(interruptNum - 16);
+}
+
+void HwiP_Params_init(HwiP_Params *params)
+{
+	params->arg = 0;
+	params->priority = ~0;
+}
+
+/* Zephyr has no functions for clearing an interrupt, so use driverlib: */
+void HwiP_clearInterrupt(int interruptNum)
+{
+	MAP_IntPendClear((unsigned long)interruptNum);
+}
+
+void HwiP_enableInterrupt(int interruptNum)
+{
+	irq_enable(interruptNum - 16);
+}
+
+void HwiP_disableInterrupt(int interruptNum)
+{
+	irq_disable(interruptNum - 16);
+}
+
+uintptr_t HwiP_disable(void)
+{
+	uintptr_t key;
+
+	key = irq_lock();
+
+	return (key);
+}
+
+void HwiP_restore(uintptr_t key)
+{
+	irq_unlock(key);
+}
diff --git a/ext/hal/ti/simplelink/kernel/zephyr/dpl/MutexP_zephyr.c b/ext/hal/ti/simplelink/kernel/zephyr/dpl/MutexP_zephyr.c
new file mode 100644
index 0000000..0b5a8be7
--- /dev/null
+++ b/ext/hal/ti/simplelink/kernel/zephyr/dpl/MutexP_zephyr.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2017, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr.h>
+#include <misc/__assert.h>
+#include <kernel/zephyr/dpl/dpl.h>
+#include <ti/drivers/dpl/MutexP.h>
+
+/*
+ * Zephyr kernel object pools:
+ *
+ * This bit of code enables the simplelink host driver, which assumes dynamic
+ * allocation of kernel objects (semaphores, mutexes, hwis), to be
+ * more easily ported to Zephyr (which supports static allocation).
+ *
+ * It leverages the Zephyr memory slab, enabling us to define a mutex object
+ * pool for use by the SimpleLink host driver.
+ */
+
+/* Define a Mutex pool: */
+#define DPL_MAX_MUTEXES	 4  /* From simplelink driver code inspection */
+K_MEM_SLAB_DEFINE(mutex_slab, sizeof(struct k_mutex), DPL_MAX_MUTEXES,\
+		  MEM_ALIGN);
+
+static struct k_mutex *dpl_mutex_pool_alloc()
+{
+	struct k_mutex *mutex_ptr = NULL;
+
+	if (k_mem_slab_alloc(&mutex_slab, (void **)&mutex_ptr,
+			     K_NO_WAIT) < 0) {
+		/*
+		 * We assert, as this is a logic error, due to a change in #
+		 * of mutexes needed by the simplelink driver. In that case,
+		 * the mutex pool must be increased programmatically to match.
+		 */
+		 __ASSERT(0, "Increase size of DPL mutex pool");
+	}
+	return mutex_ptr;
+}
+
+static MutexP_Status dpl_mutex_pool_free(struct k_mutex *mutex)
+{
+	k_mem_slab_free(&mutex_slab, (void **)&mutex);
+	return MutexP_OK;
+}
+
+MutexP_Handle MutexP_create(MutexP_Params *params)
+{
+	struct k_mutex *mutex;
+
+	ARG_UNUSED(params);
+
+	mutex = dpl_mutex_pool_alloc();
+	__ASSERT(mutex, "MutexP_create failed\r\n");
+
+	if (mutex) {
+		k_mutex_init(mutex);
+	}
+	return ((MutexP_Handle)mutex);
+}
+
+void MutexP_delete(MutexP_Handle handle)
+{
+	/* No way in Zephyr to "reset" the lock, so just re-init: */
+	k_mutex_init((struct k_mutex *)handle);
+
+	dpl_mutex_pool_free((struct k_mutex *)handle);
+}
+
+uintptr_t MutexP_lock(MutexP_Handle handle)
+{
+	unsigned int key = 0;
+	int retval;
+
+	retval = k_mutex_lock((struct k_mutex *)handle, K_FOREVER);
+	__ASSERT(retval == 0,
+		 "MutexP_lock: retval: %d\r\n", retval);
+
+	return ((uintptr_t)key);
+}
+
+void MutexP_Params_init(MutexP_Params *params)
+{
+	params->callback = NULL;
+}
+
+void MutexP_unlock(MutexP_Handle handle, uintptr_t key)
+{
+	ARG_UNUSED(key);
+
+	k_mutex_unlock((struct k_mutex *)handle);
+}
diff --git a/ext/hal/ti/simplelink/kernel/zephyr/dpl/SemaphoreP_zephyr.c b/ext/hal/ti/simplelink/kernel/zephyr/dpl/SemaphoreP_zephyr.c
new file mode 100644
index 0000000..7d9816b
--- /dev/null
+++ b/ext/hal/ti/simplelink/kernel/zephyr/dpl/SemaphoreP_zephyr.c
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2017, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr.h>
+#include <misc/__assert.h>
+#include <kernel/zephyr/dpl/dpl.h>
+#include <ti/drivers/dpl/SemaphoreP.h>
+
+/*
+ * Zephyr kernel object pools:
+ *
+ * This bit of code enables the simplelink host driver, which assumes dynamic
+ * allocation of kernel objects (semaphores, mutexes, hwis), to be
+ * more easily ported to Zephyr (which supports static allocation).
+ *
+ * It leverages the Zephyr memory slab, enabling us to define a semaphore
+ * object pool for use by the SimpleLink host driver.
+ */
+#define DPL_MAX_SEMAPHORES 14  /* (user.h:MAX_CONCURRENT_ACTIONS+4) = 14 */
+K_MEM_SLAB_DEFINE(sem_slab, sizeof(struct k_sem), DPL_MAX_SEMAPHORES,\
+		  MEM_ALIGN);
+
+static struct k_sem *dpl_sem_pool_alloc()
+{
+	struct k_sem *sem_ptr = NULL;
+
+	if (k_mem_slab_alloc(&sem_slab, (void **)&sem_ptr, K_NO_WAIT) < 0) {
+		/*
+		 * We assert, as this is a logic error, due to a change in #
+		 * of semaphores needed by the simplelink driver. In that case,
+		 * the sem pool must be increased programmatically to match.
+		 */
+		 __ASSERT(0, "Increase size of DPL semaphore pool");
+	}
+	return sem_ptr;
+}
+
+static SemaphoreP_Status dpl_sem_pool_free(struct k_sem *sem)
+{
+	k_mem_slab_free(&sem_slab, (void **)&sem);
+
+	return SemaphoreP_OK;
+}
+
+/* timeout comes in and out as milliSeconds: */
+static int32_t dpl_convert_timeout(uint32_t timeout)
+{
+	int32_t zephyr_timeout;
+
+	switch(timeout) {
+	case SemaphoreP_NO_WAIT:
+		zephyr_timeout = K_NO_WAIT;
+		break;
+	case SemaphoreP_WAIT_FOREVER:
+		zephyr_timeout = K_FOREVER;
+		break;
+	default:
+		zephyr_timeout = timeout;
+	}
+	return zephyr_timeout;
+}
+
+
+SemaphoreP_Handle SemaphoreP_create(unsigned int count,
+				    SemaphoreP_Params *params)
+{
+	unsigned int limit = UINT_MAX;
+	struct k_sem *sem;
+
+	if (params) {
+		limit = (params->mode == SemaphoreP_Mode_BINARY) ?
+			1 : UINT_MAX;
+	}
+
+	sem = dpl_sem_pool_alloc();
+	if (sem) {
+		k_sem_init(sem, 0, limit);
+	}
+
+	return (SemaphoreP_Handle)sem;
+}
+
+SemaphoreP_Handle SemaphoreP_createBinary(unsigned int count)
+{
+	SemaphoreP_Params params;
+
+	SemaphoreP_Params_init(&params);
+	params.mode = SemaphoreP_Mode_BINARY;
+
+	return (SemaphoreP_create(count, &params));
+}
+
+
+void SemaphoreP_delete(SemaphoreP_Handle handle)
+{
+	k_sem_reset((struct k_sem *)handle);
+
+	(void)dpl_sem_pool_free((struct k_sem *)handle);
+}
+
+void SemaphoreP_Params_init(SemaphoreP_Params *params)
+{
+	params->mode = SemaphoreP_Mode_COUNTING;
+	params->callback = NULL;
+}
+
+/*
+ * The SimpleLink driver calls this function with a timeout of 0 to "clear"
+ * the SyncObject, rather than calling dpl_SyncObjClear() directly.
+ * See: <simplelinksdk>/source/ti/drivers/net/wifi/source/driver.h
+ *  #define SL_DRV_SYNC_OBJ_CLEAR(pObj)
+ *	    (void)sl_SyncObjWait(pObj,SL_OS_NO_WAIT);
+ *
+ * So, we claim (via simplelink driver code inspection), that SyncObjWait
+ * will *only* be called with timeout == 0 if the intention is to clear the
+ * semaphore: in that case, we just call k_sem_reset.
+ */
+SemaphoreP_Status SemaphoreP_pend(SemaphoreP_Handle handle, uint32_t timeout)
+{
+	int retval;
+
+	if (0 == timeout) {
+		k_sem_reset((struct k_sem *)handle);
+		retval = SemaphoreP_OK;
+	} else {
+		retval = k_sem_take((struct k_sem *)handle,
+				    dpl_convert_timeout(timeout));
+		__ASSERT_NO_MSG(retval != -EBUSY);
+		retval = (retval >= 0) ? SemaphoreP_OK : SemaphoreP_TIMEOUT;
+	}
+	return retval;
+}
+
+void SemaphoreP_post(SemaphoreP_Handle handle)
+{
+	k_sem_give((struct k_sem *)handle);
+}
diff --git a/ext/hal/ti/simplelink/kernel/zephyr/dpl/dpl.c b/ext/hal/ti/simplelink/kernel/zephyr/dpl/dpl.c
new file mode 100644
index 0000000..b8d210d
--- /dev/null
+++ b/ext/hal/ti/simplelink/kernel/zephyr/dpl/dpl.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2017, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <zephyr.h>
+#include <device.h>
+#include <init.h>
+#include <misc/util.h>
+#include <misc/__assert.h>
+
+#include <inc/hw_types.h>
+#include <inc/hw_ints.h>
+#include <driverlib/rom_map.h>
+#include <driverlib/interrupt.h>
+
+#include <ti/drivers/net/wifi/simplelink.h>
+#include <kernel/zephyr/dpl/dpl.h>
+
+#define	 SPAWN_TASK_STACKSIZE  2048
+/*
+ * Priority must be higher than any thread priority in the system which
+ * might use the SimpleLink host driver, which involves the spawn_task().
+ * Since SimpleLink APIs may be called from any thread, including
+ * cooperative threads, and the _main kernel thread, we must set this
+ * as highest prioirty.
+ */
+#define	 SPAWN_TASK_PRIORITY   K_HIGHEST_THREAD_PRIO
+
+/* Spawn message queue size: Could be 1, but 3 is used by other DPL ports */
+#define SPAWN_QUEUE_SIZE  ( 3 )
+
+/* Stack, for the simplelink spawn task: */
+static K_THREAD_STACK_DEFINE(spawn_task_stack, SPAWN_TASK_STACKSIZE);
+static struct k_thread spawn_task_data;
+
+static void spawn_task(void *unused1, void *unused2, void *unused3);
+
+/*
+ * MessageQ to send message from an ISR or other task to the SimpleLink
+ * "Spawn" task:
+ */
+K_MSGQ_DEFINE(spawn_msgq, sizeof(tSimpleLinkSpawnMsg), SPAWN_QUEUE_SIZE,\
+	      MEM_ALIGN);
+
+/*
+ * SimpleLink does not have an init hook, so we export this function to
+ * be called early during system initialization.
+ */
+static int dpl_zephyr_init(struct device *port)
+{
+	(void)k_thread_create(&spawn_task_data, spawn_task_stack,
+			SPAWN_TASK_STACKSIZE, spawn_task,
+			NULL, NULL, NULL,
+			SPAWN_TASK_PRIORITY, 0, K_NO_WAIT);
+	return 0;
+}
+SYS_INIT(dpl_zephyr_init, POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT);
+
+/* SimpleLink driver code can call this from ISR or task context: */
+_SlReturnVal_t os_Spawn(P_OS_SPAWN_ENTRY pEntry, void *pValue,
+			unsigned long flags)
+{
+	tSimpleLinkSpawnMsg slMsg;
+	_SlReturnVal_t retval;
+
+	slMsg.pEntry = pEntry;
+	slMsg.pValue = pValue;
+
+	if (0 == k_msgq_put(&spawn_msgq, &slMsg, K_NO_WAIT)) {
+		retval = OS_OK;
+	}
+	else {
+		retval = -1;
+		__ASSERT(retval == OS_OK,
+			 "os_Spawn: Failed to k_msgq_put failed\r\n");
+
+	}
+
+	return retval;
+}
+
+void spawn_task(void *unused1, void *unused2, void *unused3)
+{
+	tSimpleLinkSpawnMsg slMsg;
+
+	ARG_UNUSED(unused1);
+	ARG_UNUSED(unused2);
+	ARG_UNUSED(unused3);
+
+	while (1) {
+		k_msgq_get(&spawn_msgq, &slMsg, K_FOREVER);
+		slMsg.pEntry(slMsg.pValue);
+	}
+}
+
+#if CONFIG_ERRNO && !defined(SL_INC_INTERNAL_ERRNO)
+/*
+ * Called by the SimpleLink host driver to set POSIX error codes
+ * for the host OS.
+ */
+int dpl_set_errno(int err)
+{
+	/* Ensure (POSIX) errno is positive.
+	 * __errno() is a Zephyr function returning a pointer to the
+	 * current thread's errno variable.
+	 */
+	*__errno() = (err < 0? -err : err);
+	return -1;
+}
+#endif
diff --git a/ext/hal/ti/simplelink/kernel/zephyr/dpl/dpl.h b/ext/hal/ti/simplelink/kernel/zephyr/dpl/dpl.h
new file mode 100644
index 0000000..3642a74
--- /dev/null
+++ b/ext/hal/ti/simplelink/kernel/zephyr/dpl/dpl.h
@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2017, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#define MEM_ALIGN (sizeof(uint32_t))
+
+extern int *__errno(void);
diff --git a/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/CC3220SF_LAUNCHXL.c b/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/CC3220SF_LAUNCHXL.c
new file mode 100644
index 0000000..43984af
--- /dev/null
+++ b/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/CC3220SF_LAUNCHXL.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2017, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+/* =========================== SPI Driver Fxns ========================= */
+#include <ti/devices/cc32xx/inc/hw_ints.h>
+#include <ti/devices/cc32xx/inc/hw_memmap.h>
+#include <ti/devices/cc32xx/inc/hw_types.h>
+
+#include <ti/devices/cc32xx/driverlib/rom_map.h>
+#include <ti/devices/cc32xx/driverlib/prcm.h>
+#include <ti/devices/cc32xx/driverlib/spi.h>
+#include <ti/devices/cc32xx/driverlib/udma.h>
+
+typedef enum CC3220SF_LAUNCHXL_SPIName {
+    CC3220SF_LAUNCHXL_SPI0 = 0,
+    CC3220SF_LAUNCHXL_SPICOUNT
+} CC3220SF_LAUNCHXL_SPIName;
+
+#include <ti/drivers/SPI.h>
+#include <ti/drivers/spi/SPICC32XXDMA.h>
+
+SPICC32XXDMA_Object spiCC3220SDMAObjects[CC3220SF_LAUNCHXL_SPICOUNT];
+
+__attribute__ ((aligned (32)))
+uint32_t spiCC3220SDMAscratchBuf[CC3220SF_LAUNCHXL_SPICOUNT];
+
+const SPICC32XXDMA_HWAttrsV1 spiCC3220SDMAHWAttrs[CC3220SF_LAUNCHXL_SPICOUNT] = {
+    /* index 0 is reserved for LSPI that links to the NWP */
+    {
+	.baseAddr = LSPI_BASE,
+	.intNum = INT_LSPI,
+	.intPriority = (~0),
+	.spiPRCM = PRCM_LSPI,
+	.csControl = SPI_SW_CTRL_CS,
+	.csPolarity = SPI_CS_ACTIVEHIGH,
+	.pinMode = SPI_4PIN_MODE,
+	.turboMode = SPI_TURBO_OFF,
+	.scratchBufPtr = &spiCC3220SDMAscratchBuf[CC3220SF_LAUNCHXL_SPI0],
+	.defaultTxBufValue = 0,
+	.rxChannelIndex = UDMA_CH12_LSPI_RX,
+	.txChannelIndex = UDMA_CH13_LSPI_TX,
+	.minDmaTransferSize = 100,
+	.mosiPin = SPICC32XXDMA_PIN_NO_CONFIG,
+	.misoPin = SPICC32XXDMA_PIN_NO_CONFIG,
+	.clkPin = SPICC32XXDMA_PIN_NO_CONFIG,
+	.csPin = SPICC32XXDMA_PIN_NO_CONFIG
+    }
+};
+
+const SPI_Config SPI_config[CC3220SF_LAUNCHXL_SPICOUNT] = {
+    {
+	.fxnTablePtr = &SPICC32XXDMA_fxnTable,
+	.object = &spiCC3220SDMAObjects[CC3220SF_LAUNCHXL_SPI0],
+	.hwAttrs = &spiCC3220SDMAHWAttrs[CC3220SF_LAUNCHXL_SPI0]
+    }
+};
+
+const uint_least8_t SPI_count = CC3220SF_LAUNCHXL_SPICOUNT;
+
+/*
+ *  =============================== DMA ===============================
+ */
+#include <ti/drivers/dma/UDMACC32XX.h>
+
+__attribute__ ((aligned (1024)))
+static tDMAControlTable dmaControlTable[64];
+
+/*
+ *  ======== dmaErrorFxn ========
+ *  This is the handler for the uDMA error interrupt.
+ */
+static void dmaErrorFxn(uintptr_t arg)
+{
+    int status = MAP_uDMAErrorStatusGet();
+    MAP_uDMAErrorStatusClear();
+
+    /* Suppress unused variable warning */
+    (void)status;
+
+    while (1);
+}
+
+UDMACC32XX_Object udmaCC3220SObject;
+
+const UDMACC32XX_HWAttrs udmaCC3220SHWAttrs = {
+    .controlBaseAddr = (void *)dmaControlTable,
+    .dmaErrorFxn = (UDMACC32XX_ErrorFxn)dmaErrorFxn,
+    .intNum = INT_UDMAERR,
+    .intPriority = (~0)
+};
+
+const UDMACC32XX_Config UDMACC32XX_config = {
+    .object = &udmaCC3220SObject,
+    .hwAttrs = &udmaCC3220SHWAttrs
+};
+
+
+void CC3220SF_LAUNCHXL_init()
+{
+	MAP_PRCMLPDSWakeupSourceEnable(PRCM_LPDS_HOST_IRQ);
+	SPI_init();
+}
+
+#if defined(__SF_DEBUG__)
+#if defined(__TI_COMPILER_VERSION__)
+#pragma DATA_SECTION(ulDebugHeader, ".dbghdr")
+#elif defined(__IAR_SYSTEMS_ICC__)
+#pragma data_location=".dbghdr"
+#elif defined(__GNUC__)
+__attribute__ ((section (".dbghdr")))
+#endif
+const unsigned long ulDebugHeader[]=
+{
+                0x5AA5A55A,
+                0x000FF800,
+                0xEFA3247D
+};
+#endif
diff --git a/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/CC3220SF_LAUNCHXL.h b/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/CC3220SF_LAUNCHXL.h
new file mode 100644
index 0000000..c39e308
--- /dev/null
+++ b/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/CC3220SF_LAUNCHXL.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2017, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+#ifndef _CC3220SF_LAUNCHXL_H_
+#define _CC3220SF_LAUNCHXL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void CC3220SF_LAUNCHXL_init();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CC3220SF_LAUNCHXL_H_ */
diff --git a/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/user.h b/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/user.h
index 0ffddd5..35b99bf 100644
--- a/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/user.h
+++ b/ext/hal/ti/simplelink/source/ti/drivers/net/wifi/porting/user.h
@@ -956,10 +956,11 @@
     
     \warning                User must implement it's own 'os_Spawn' function.
 */
-//#define SL_PLATFORM_EXTERNAL_SPAWN
+#define SL_PLATFORM_EXTERNAL_SPAWN
 
 #ifdef SL_PLATFORM_EXTERNAL_SPAWN
-#define sl_Spawn(pEntry,pValue,flags)       os_Spawn(pEntry,pValue,flags)        
+extern  _i16 os_Spawn(P_OS_SPAWN_ENTRY pEntry, void *pValue, unsigned long flags);
+#define sl_Spawn(pEntry,pValue,flags)       os_Spawn(pEntry,pValue,flags)
 #endif
 
 /*!