add amebaz bsp

bsp/amebaz/.config

+#
+# Automatically generated file; DO NOT EDIT.
+# RT-Thread Configuration
+#
+
+#
+# RT-Thread Kernel
+#
+CONFIG_RT_NAME_MAX=8
+CONFIG_RT_ALIGN_SIZE=4
+# CONFIG_RT_THREAD_PRIORITY_8 is not set
+CONFIG_RT_THREAD_PRIORITY_32=y
+# CONFIG_RT_THREAD_PRIORITY_256 is not set
+CONFIG_RT_THREAD_PRIORITY_MAX=32
+CONFIG_RT_TICK_PER_SECOND=1000
+CONFIG_RT_DEBUG=y
+CONFIG_RT_USING_OVERFLOW_CHECK=y
+CONFIG_RT_DEBUG_INIT=0
+CONFIG_RT_DEBUG_THREAD=0
+CONFIG_RT_USING_HOOK=y
+CONFIG_IDLE_THREAD_STACK_SIZE=256
+CONFIG_RT_USING_TIMER_SOFT=y
+CONFIG_RT_TIMER_THREAD_PRIO=4
+CONFIG_RT_TIMER_THREAD_STACK_SIZE=512
+
+#
+# Inter-Thread communication
+#
+CONFIG_RT_USING_SEMAPHORE=y
+CONFIG_RT_USING_MUTEX=y
+CONFIG_RT_USING_EVENT=y
+CONFIG_RT_USING_MAILBOX=y
+CONFIG_RT_USING_MESSAGEQUEUE=y
+# CONFIG_RT_USING_SIGNALS is not set
+
+#
+# Memory Management
+#
+CONFIG_RT_USING_MEMPOOL=y
+# CONFIG_RT_USING_MEMHEAP is not set
+# CONFIG_RT_USING_NOHEAP is not set
+CONFIG_RT_USING_SMALL_MEM=y
+# CONFIG_RT_USING_SLAB is not set
+# CONFIG_RT_USING_MEMTRACE is not set
+CONFIG_RT_USING_HEAP=y
+
+#
+# Kernel Device Object
+#
+CONFIG_RT_USING_DEVICE=y
+# CONFIG_RT_USING_DEVICE_OPS is not set
+# CONFIG_RT_USING_INTERRUPT_INFO is not set
+CONFIG_RT_USING_CONSOLE=y
+CONFIG_RT_CONSOLEBUF_SIZE=128
+CONFIG_RT_CONSOLE_DEVICE_NAME="dbg"
+# CONFIG_RT_USING_MODULE is not set
+
+#
+# RT-Thread Components
+#
+CONFIG_RT_USING_COMPONENTS_INIT=y
+# CONFIG_RT_USING_USER_MAIN is not set
+
+#
+# C++ features
+#
+# CONFIG_RT_USING_CPLUSPLUS is not set
+
+#
+# Command shell
+#
+CONFIG_RT_USING_FINSH=y
+CONFIG_FINSH_THREAD_NAME="tshell"
+CONFIG_FINSH_USING_HISTORY=y
+CONFIG_FINSH_HISTORY_LINES=5
+CONFIG_FINSH_USING_SYMTAB=y
+CONFIG_FINSH_USING_DESCRIPTION=y
+# CONFIG_FINSH_ECHO_DISABLE_DEFAULT is not set
+CONFIG_FINSH_THREAD_PRIORITY=20
+CONFIG_FINSH_THREAD_STACK_SIZE=4096
+CONFIG_FINSH_CMD_SIZE=80
+# CONFIG_FINSH_USING_AUTH is not set
+CONFIG_FINSH_USING_MSH=y
+CONFIG_FINSH_USING_MSH_DEFAULT=y
+# CONFIG_FINSH_USING_MSH_ONLY is not set
+CONFIG_FINSH_ARG_MAX=10
+
+#
+# Device virtual file system
+#
+# CONFIG_RT_USING_DFS is not set
+
+#
+# Device Drivers
+#
+CONFIG_RT_USING_DEVICE_IPC=y
+CONFIG_RT_USING_SERIAL=y
+# CONFIG_RT_USING_CAN is not set
+# CONFIG_RT_USING_HWTIMER is not set
+# CONFIG_RT_USING_CPUTIME is not set
+# CONFIG_RT_USING_I2C is not set
+CONFIG_RT_USING_PIN=y
+# CONFIG_RT_USING_PWM is not set
+# CONFIG_RT_USING_MTD_NOR is not set
+# CONFIG_RT_USING_MTD_NAND is not set
+# CONFIG_RT_USING_RTC is not set
+# CONFIG_RT_USING_SDIO is not set
+# CONFIG_RT_USING_SPI is not set
+# CONFIG_RT_USING_WDT is not set
+CONFIG_RT_USING_WIFI=y
+CONFIG_RT_USING_WLAN_STA=y
+CONFIG_RT_USING_WLAN_AP=y
+CONFIG_WIFI_DEVICE_STA_NAME="w0"
+CONFIG_WIFI_DEVICE_AP_NAME="ap"
+# CONFIG_RT_USING_AUDIO is not set
+
+#
+# Using USB
+#
+# CONFIG_RT_USING_USB_HOST is not set
+# CONFIG_RT_USING_USB_DEVICE is not set
+
+#
+# POSIX layer and C standard library
+#
+CONFIG_RT_USING_LIBC=y
+# CONFIG_RT_USING_PTHREADS is not set
+
+#
+# Network stack
+#
+
+#
+# light weight TCP/IP stack
+#
+CONFIG_RT_USING_LWIP=y
+CONFIG_RT_USING_LWIP141=y
+# CONFIG_RT_USING_LWIP202 is not set
+CONFIG_RT_LWIP_IGMP=y
+CONFIG_RT_LWIP_ICMP=y
+# CONFIG_RT_LWIP_SNMP is not set
+CONFIG_RT_LWIP_DNS=y
+CONFIG_RT_LWIP_DHCP=y
+CONFIG_IP_SOF_BROADCAST=1
+CONFIG_IP_SOF_BROADCAST_RECV=1
+
+#
+# Static IPv4 Address
+#
+CONFIG_RT_LWIP_IPADDR="192.168.1.30"
+CONFIG_RT_LWIP_GWADDR="192.168.1.1"
+CONFIG_RT_LWIP_MSKADDR="255.255.255.0"
+CONFIG_RT_LWIP_UDP=y
+CONFIG_RT_LWIP_TCP=y
+# CONFIG_RT_LWIP_RAW is not set
+# CONFIG_RT_LWIP_PPP is not set
+CONFIG_RT_MEMP_NUM_NETCONN=8
+CONFIG_RT_LWIP_PBUF_NUM=16
+CONFIG_RT_LWIP_RAW_PCB_NUM=4
+CONFIG_RT_LWIP_UDP_PCB_NUM=4
+CONFIG_RT_LWIP_TCP_PCB_NUM=4
+CONFIG_RT_LWIP_TCP_SEG_NUM=40
+CONFIG_RT_LWIP_TCP_SND_BUF=8196
+CONFIG_RT_LWIP_TCP_WND=8196
+CONFIG_RT_LWIP_TCPTHREAD_PRIORITY=10
+CONFIG_RT_LWIP_TCPTHREAD_MBOX_SIZE=8
+CONFIG_RT_LWIP_TCPTHREAD_STACKSIZE=1024
+# CONFIG_LWIP_NO_RX_THREAD is not set
+# CONFIG_LWIP_NO_TX_THREAD is not set
+CONFIG_RT_LWIP_ETHTHREAD_PRIORITY=12
+CONFIG_RT_LWIP_ETHTHREAD_STACKSIZE=1024
+CONFIG_RT_LWIP_ETHTHREAD_MBOX_SIZE=8
+# CONFIG_RT_LWIP_REASSEMBLY_FRAG is not set
+CONFIG_LWIP_NETIF_STATUS_CALLBACK=1
+CONFIG_SO_REUSE=1
+CONFIG_LWIP_SO_RCVTIMEO=1
+CONFIG_LWIP_SO_SNDTIMEO=1
+CONFIG_LWIP_SO_RCVBUF=1
+# CONFIG_RT_LWIP_NETIF_LOOPBACK is not set
+CONFIG_LWIP_NETIF_LOOPBACK=0
+
+#
+# Modbus master and slave stack
+#
+# CONFIG_RT_USING_MODBUS is not set
+# CONFIG_LWIP_USING_DHCPD is not set
+
+#
+# VBUS(Virtual Software BUS)
+#
+# CONFIG_RT_USING_VBUS is not set
+
+#
+# Utilities
+#
+# CONFIG_RT_USING_LOGTRACE is not set
+# CONFIG_RT_USING_RYM is not set
+
+#
+# RT-Thread online packages
+#
+
+#
+# IoT - internet of things
+#
+# CONFIG_PKG_USING_PAHOMQTT is not set
+# CONFIG_PKG_USING_WEBCLIENT is not set
+# CONFIG_PKG_USING_MONGOOSE is not set
+# CONFIG_PKG_USING_WEBTERMINAL is not set
+# CONFIG_PKG_USING_CJSON is not set
+# CONFIG_PKG_USING_JSMN is not set
+# CONFIG_PKG_USING_LJSON is not set
+# CONFIG_PKG_USING_EZXML is not set
+# CONFIG_PKG_USING_NANOPB is not set
+# CONFIG_PKG_USING_GAGENT_CLOUD is not set
+
+#
+# Wi-Fi
+#
+
+#
+# Marvell WiFi
+#
+# CONFIG_PKG_USING_WLANMARVELL is not set
+
+#
+# Wiced WiFi
+#
+# CONFIG_PKG_USING_WLAN_WICED is not set
+# CONFIG_PKG_USING_COAP is not set
+# CONFIG_PKG_USING_NOPOLL is not set
+# CONFIG_PKG_USING_NETUTILS is not set
+# CONFIG_PKG_USING_ONENET is not set
+
+#
+# security packages
+#
+# CONFIG_PKG_USING_MBEDTLS is not set
+# CONFIG_PKG_USING_libsodium is not set
+# CONFIG_PKG_USING_TINYCRYPT is not set
+
+#
+# language packages
+#
+# CONFIG_PKG_USING_JERRYSCRIPT is not set
+# CONFIG_PKG_USING_MICROPYTHON is not set
+
+#
+# multimedia packages
+#
+# CONFIG_PKG_USING_OPENMV is not set
+# CONFIG_PKG_USING_MUPDF is not set
+
+#
+# tools packages
+#
+# CONFIG_PKG_USING_CMBACKTRACE is not set
+# CONFIG_PKG_USING_EASYFLASH is not set
+# CONFIG_PKG_USING_EASYLOGGER is not set
+# CONFIG_PKG_USING_SYSTEMVIEW is not set
+
+#
+# system packages
+#
+# CONFIG_PKG_USING_GUIENGINE is not set
+# CONFIG_PKG_USING_CAIRO is not set
+# CONFIG_PKG_USING_PIXMAN is not set
+# CONFIG_PKG_USING_LWEXT4 is not set
+# CONFIG_PKG_USING_PARTITION is not set
+# CONFIG_PKG_USING_FAL is not set
+# CONFIG_PKG_USING_SQLITE is not set
+# CONFIG_PKG_USING_RTI is not set
+# CONFIG_PKG_USING_LITTLEVGL2RTT is not set
+
+#
+# peripheral libraries and drivers
+#
+# CONFIG_PKG_USING_STM32F4_HAL is not set
+# CONFIG_PKG_USING_STM32F4_DRIVERS is not set
+CONFIG_PKG_USING_REALTEK_AMEBA=y
+CONFIG_PKG_REALTEK_AMEBA_PATH="/packages/peripherals/realtek_ameba"
+CONFIG_PKG_USING_REALTEK_AMEBA_LATEST_VERSION=y
+# CONFIG_PKG_USING_REALTEK_AMEBA_V100 is not set
+CONFIG_PKG_REALTEK_AMEBA_VER="latest"
+# CONFIG_PKG_USING_CC3200_SDK is not set
+
+#
+# miscellaneous packages
+#
+# CONFIG_PKG_USING_FASTLZ is not set
+# CONFIG_PKG_USING_MINILZO is not set
+# CONFIG_PKG_USING_QUICKLZ is not set
+# CONFIG_PKG_USING_MULTIBUTTON is not set
+# CONFIG_PKG_USING_CANFESTIVAL is not set
+# CONFIG_PKG_USING_ZLIB is not set
+# CONFIG_PKG_USING_DSTR is not set
+
+#
+# sample package
+#
+# CONFIG_PKG_USING_SAMPLES is not set
+
+#
+# example package: hello
+#
+# CONFIG_PKG_USING_HELLO is not set
+
+#
+# Env config
+#
+# CONFIG_SYS_AUTO_UPDATE_PKGS is not set
+# CONFIG_SYS_CREATE_MDK_IAR_PROJECT is not set
+# CONFIG_SYS_PKGS_DOWNLOAD_ACCELERATE is not set
+CONFIG_RT_USING_UART0=y

bsp/amebaz/Kconfig

+mainmenu "RT-Thread Configuration"
+
+config $BSP_DIR
+    string
+    option env="BSP_ROOT"
+    default "."
+
+config $RTT_DIR
+    string
+    option env="RTT_ROOT"
+    default "../.."
+    
+# you can change the RTT_ROOT default "../.." to your rtthread_root,
+# example : default "F:/git_repositories/rt-thread"
+
+config $PKGS_DIR
+    string
+    option env="PKGS_ROOT"
+    default "packages"
+    
+config $ENV_DIR
+    string
+    option env="ENV_ROOT"
+    default "/"
+
+source "$RTT_DIR/Kconfig"
+source "$PKGS_DIR/Kconfig"
+source "$ENV_DIR/tools/scripts/cmds/Kconfig"
+
+config RT_USING_UART0
+    bool "Using RT_USING_UART0"
+    default y
+
+select PKG_USING_REALTEK_AMEBA
+

bsp/amebaz/SConscript

+# for module compiling
+import os
+Import('RTT_ROOT')
+
+cwd = str(Dir('#'))
+objs = []
+list = os.listdir(cwd)
+
+for d in list:
+    path = os.path.join(cwd, d)
+    if os.path.isfile(os.path.join(path, 'SConscript')):
+        objs = objs + SConscript(os.path.join(d, 'SConscript'))
+
+Return('objs')

bsp/amebaz/SConstruct

+import os
+import sys
+import rtconfig
+
+if os.getenv('RTT_ROOT'):
+    RTT_ROOT = os.getenv('RTT_ROOT')
+else:
+    RTT_ROOT = os.path.normpath(os.getcwd() + '/../..')
+
+sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')]
+try:
+    from building import *
+except:
+    print('Cannot found RT-Thread root directory, please check RTT_ROOT')
+    print(RTT_ROOT)
+    exit(-1)
+
+TARGET = 'rtthread.' + rtconfig.TARGET_EXT
+
+env = Environment(tools = ['mingw'],
+    AS = rtconfig.AS, ASFLAGS = rtconfig.AFLAGS,
+    CC = rtconfig.CC, CCFLAGS = rtconfig.CFLAGS,
+    AR = rtconfig.AR, ARFLAGS = '-rc',
+    LINK = rtconfig.LINK, LINKFLAGS = rtconfig.LFLAGS)
+env.PrependENVPath('PATH', rtconfig.EXEC_PATH)
+
+if rtconfig.PLATFORM == 'iar':
+    env.Replace(CCCOM = ['$CC $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -o $TARGET $SOURCES'])
+    env.Replace(ARFLAGS = [''])
+    env.Replace(LINKCOM = ['$LINK $SOURCES $LINKFLAGS -o $TARGET --map project.map'])
+
+Export('RTT_ROOT')
+Export('rtconfig')
+
+# prepare building environment
+objs = PrepareBuilding(env, RTT_ROOT, has_libcpu=False)
+
+# make a building
+DoBuilding(TARGET, objs)

bsp/amebaz/applications/SConscript

+import rtconfig
+from building import *
+
+cwd     = GetCurrentDir()
+CPPPATH = [cwd, str(Dir('#'))]
+src     = Glob('*.c')
+
+group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH)
+
+Return('group')

bsp/amebaz/applications/main.c

+/*
+ * File      : startup.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, RT-Thread Develop Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2006-08-31     Bernard      first implementation
+ * 2018-03-01     flyingcys    add realtek ameba
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+
+/**
+ * @addtogroup ameba
+ */
+
+/*@{*/
+
+int main(void)
+{
+    rt_kprintf("build time: %s %s\n", __DATE__, __TIME__);
+    rt_kprintf("Hello RT-Thread!\n");
+    
+    return 0;
+}
+
+/*@}*/

bsp/amebaz/bootloader_symbol.icf

+/* Bootloader symbol list */ 
+define exported symbol BOOT_FLASH_RDP_VALID = 0x08000123;  
+define exported symbol BOOT_FLASH_SetStatusReg = 0x080003f5;  
+define exported symbol BOOT_FLASH_Image1 = 0x0800043b;  
+define exported symbol IMAGE1$$Base = 0x10002001;  
+define exported symbol RamStartTable = 0x10002001;  
+define exported symbol RAM_IMG1_VALID_PATTEN = 0x10002019;  
+define exported symbol boot_export_symbol = 0x10002021;  
+define exported symbol BOOT_System_Init1 = 0x10002251;  
+define exported symbol BOOT_System_Init2 = 0x10002263;  
+define exported symbol BOOT_Swd_Off = 0x10002275;  
+define exported symbol boot_ram_end = 0x10002455;  
+define exported symbol IMAGE1$$Limit = 0x10002459;  

bsp/amebaz/drivers/SConscript

+from building import *
+
+cwd = GetCurrentDir()
+list = os.listdir(cwd)
+objs = []
+
+src = Split('''
+	board.c
+	drv_uart.c
+	''')
+
+if GetDepend(['RT_USING_LWIP']):
+	src += Split('''
+		drv_wifi.c
+		''')
+
+CPPPATH = [cwd]
+
+group = DefineGroup('Drivers', src, depend = [''], CPPPATH = CPPPATH)
+
+for d in list:
+    path = os.path.join(cwd, d)
+    if os.path.isfile(os.path.join(path, 'SConscript')):
+        objs = objs + SConscript(os.path.join(d, 'SConscript'))
+objs = objs + group
+Return('objs')

bsp/amebaz/drivers/board.c

+/*
+ * File      : board.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2009 RT-Thread Develop Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2009-01-05     Bernard      first implementation
+ * 2018-03-15     flyingcys    add amebaz
+ */
+#include <stdint.h>
+#include <rthw.h>
+#include <rtthread.h>
+
+#include "board.h"
+#include "drv_uart.h"
+
+#ifdef __ICCARM__
+#pragma section="HEAP"
+#define HEAP_BEGIN         (__segment_end("HEAP"))
+#elif  defined(__GNUC__)
+extern int __rtt_heap_start;
+#define HEAP_BEGIN          (&__rtt_heap_start)
+#else
+#error "not support toolchain!!!"
+#endif
+
+#define HEAP_END           (0x1002FFFF)
+
+#ifdef __GNUC__
+void __wrap_rtl_printf(const char *fmt, ...)
+{
+    va_list args;
+    rt_size_t length;
+    static char rt_log_buf[RT_CONSOLEBUF_SIZE];
+
+    va_start(args, fmt);
+    /* the return value of vsnprintf is the number of bytes that would be
+     * written to buffer had if the size of the buffer been sufficiently
+     * large excluding the terminating null byte. If the output string
+     * would be larger than the rt_log_buf, we have to adjust the output
+     * length. */
+    length = rt_vsnprintf(rt_log_buf, sizeof(rt_log_buf) - 1, fmt, args);
+    if (length > RT_CONSOLEBUF_SIZE - 1)
+        length = RT_CONSOLEBUF_SIZE - 1;    
+    rt_kprintf("%s", rt_log_buf);
+    va_end(args);
+}
+#endif
+
+/**
+ * This is the timer interrupt service routine.
+ *
+ */
+void SysTick_Handler(void)
+{
+    /* enter interrupt */
+    rt_interrupt_enter();
+
+    rt_tick_increase();
+
+    /* leave interrupt */
+    rt_interrupt_leave();
+}
+
+ uint32_t SysTick_Config(uint32_t ticks)
+{
+  if ((ticks - 1) > SysTick_LOAD_RELOAD_Msk)  return (1);      /* Reload value impossible */
+
+  SysTick->LOAD  = ticks - 1;                                  /* set reload register */
+  NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1);  /* set Priority for Systick Interrupt */
+  SysTick->VAL   = 0;                                          /* Load the SysTick Counter Value */
+  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                   SysTick_CTRL_TICKINT_Msk   |
+                   SysTick_CTRL_ENABLE_Msk;                    /* Enable SysTick IRQ and SysTick Timer */
+  return (0);                                                  /* Function successful */
+}
+
+/**
+ * This function will initial board.
+ */
+void rt_hw_board_init(void)
+{
+    extern uint32_t SystemCoreClock;
+    SysTick_Config(SystemCoreClock/RT_TICK_PER_SECOND);
+    
+#ifdef RT_USING_HEAP
+        rt_system_heap_init((void*)HEAP_BEGIN, (void*)HEAP_END);
+#endif
+    
+#ifdef RT_USING_COMPONENTS_INIT
+    rt_components_board_init();
+#endif
+    
+#ifdef RT_USING_CONSOLE
+    rt_hw_uart_init();
+    rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
+#endif
+}
+
+/*@}*/

bsp/amebaz/drivers/board.h

+/*
+ * File      : board.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2009, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2009-09-22     Bernard      add board.h to this bsp
+ * 2018-03-15     flyingcys    add amebaz
+ */
+
+// <<< Use Configuration Wizard in Context Menu >>>
+#ifndef __BOARD_H__
+#define __BOARD_H__
+
+#include "rtl8710b.h"
+
+void rt_hw_board_init(void);
+
+#endif
+
+//*** <<< end of configuration section >>>    ***

bsp/amebaz/drivers/drv_uart.c

+/*
+ * File      : drv_uart.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-05-30     Bernard      the first version
+ * 2018-03-15     flyingcys    add amebaz
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#include "board.h"
+#include "drv_uart.h"
+
+struct device_uart
+{
+    serial_t serial;
+
+    rt_uint32_t irqno;
+};
+
+#ifdef RT_USING_UART0
+static struct rt_serial_device  serial0;
+static struct device_uart       uart0;
+#endif
+
+static rt_err_t  ameba_uart_configure    (struct rt_serial_device *serial, struct serial_configure *cfg);
+static rt_err_t  ameba_uart_control      (struct rt_serial_device *serial, int cmd, void *arg);
+static int       ameba_uart_putc         (struct rt_serial_device *serial, char c);
+static int       ameba_uart_getc         (struct rt_serial_device *serial);
+static rt_size_t ameba_uart_dma_transmit (struct rt_serial_device *serial, rt_uint8_t *buf, rt_size_t size, int direction);
+
+static void ameba_uart_irq(uint32_t id, SerialIrq event);
+
+const struct rt_uart_ops _uart_ops =
+{
+    ameba_uart_configure,
+    ameba_uart_control,
+    ameba_uart_putc,
+    ameba_uart_getc,
+    ameba_uart_dma_transmit
+};
+
+/*
+ * UART interface
+ */
+static rt_err_t ameba_uart_configure (struct rt_serial_device *serial, struct serial_configure *cfg)
+{
+     rt_uint32_t baud_div;
+     struct device_uart * uart;
+
+     RT_ASSERT(serial != RT_NULL);
+     serial->config = *cfg;
+
+     uart = serial->parent.user_data;
+     RT_ASSERT(uart != RT_NULL);
+
+     /* Set databits, stopbits and parity. (8-bit data, 1 stopbit, no parity) */
+     serial_format(&uart->serial, 8, ParityNone, 1);
+
+     /* set baudrate */
+     serial_baud(&uart->serial, 115200);
+
+     return (RT_EOK);
+}
+
+static rt_err_t ameba_uart_control (struct rt_serial_device *serial, int cmd, void *arg)
+{
+    struct device_uart * uart;
+
+    uart = serial->parent.user_data;
+
+    RT_ASSERT(uart != RT_NULL);
+
+    switch (cmd)
+    {
+    case RT_DEVICE_CTRL_CLR_INT:
+        /* Disable the UART Interrupt */
+        serial_irq_set(&uart->serial, RxIrq, 0);
+        serial_irq_handler(&uart->serial, RT_NULL, 0);
+        break;
+
+    case RT_DEVICE_CTRL_SET_INT:
+        /* install interrupt */
+        serial_irq_handler(&uart->serial, ameba_uart_irq, (uint32_t)serial);
+
+        /* Enable the UART Interrupt */
+        serial_irq_set(&uart->serial, RxIrq, 1);
+        break;
+    }
+
+    return (RT_EOK);
+}
+
+static int ameba_uart_putc (struct rt_serial_device *serial, char c)
+{
+    struct device_uart* uart;
+
+    uart = serial->parent.user_data;
+
+    /* FIFO status, contain valid data */
+    /* write data */
+    serial_putc(&uart->serial, c);
+
+    return (1);
+}
+
+static int ameba_uart_getc (struct rt_serial_device *serial)
+{
+    struct device_uart* uart = serial->parent.user_data;
+
+	if(!serial_readable(&uart->serial))
+        return -1;
+
+    /* Receive Data Available */
+    return serial_getc(&uart->serial);
+}
+
+static rt_size_t ameba_uart_dma_transmit (struct rt_serial_device *serial, rt_uint8_t *buf, rt_size_t size, int direction)
+{
+    return (0);
+}
+
+static void ameba_uart_irq(uint32_t id, SerialIrq event)
+{
+    struct rt_serial_device *serial = (struct rt_serial_device *)id;
+	if(event == RxIrq)
+    {
+        rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND);
+	}
+	else if(event == TxIrq)
+    {
+	}
+}
+
+static rt_err_t dbg_configure(struct rt_serial_device *serial, struct serial_configure *cfg);
+static rt_err_t dbg_control(struct rt_serial_device *serial, int cmd, void *arg);
+static int dbg_putc(struct rt_serial_device *serial, char c);
+static int dbg_getc(struct rt_serial_device *serial);
+
+static struct rt_serial_device ameba_dbg_serial;
+const struct rt_uart_ops _ambed_dbg_ops = 
+{
+    dbg_configure,
+    dbg_control,
+    dbg_putc,
+    dbg_getc,
+    RT_NULL,
+};
+
+static rt_err_t dbg_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
+{
+    LOGUART_SetBaud(115200);
+    return RT_EOK;
+}
+
+void dbg_uart_irq_handler(void * data)
+{
+    u32 IrqEn = DiagGetIsrEnReg();
+
+    DiagSetIsrEnReg(0);
+
+    rt_hw_serial_isr(&ameba_dbg_serial, RT_SERIAL_EVENT_RX_IND);
+    
+    DiagSetIsrEnReg(IrqEn);
+}
+
+static rt_err_t dbg_control(struct rt_serial_device *serial, int cmd, void *arg)
+{
+    switch (cmd)
+    {
+    case RT_DEVICE_CTRL_CLR_INT:
+        /* Disable the UART Interrupt */
+        NVIC_DisableIRQ(UART_LOG_IRQ); /* this is rom_code_patch */
+        break;
+
+    case RT_DEVICE_CTRL_SET_INT:
+        /* install interrupt */
+    	DIAG_UartReInit((IRQ_FUN) dbg_uart_irq_handler);
+        /* Enable the UART Interrupt */
+    	NVIC_SetPriority(UART_LOG_IRQ, 10); /* this is rom_code_patch */
+        break;
+    }
+
+    return (RT_EOK);
+}
+
+static int dbg_putc(struct rt_serial_device *serial, char c)
+{
+    DiagPutChar(c);
+
+    return 1;
+};
+
+static int dbg_getc(struct rt_serial_device *serial)
+{
+    int c = -1;
+
+    if(!UART_Readable(UART2_DEV))
+        return -1;
+    
+    c = DiagGetChar(_FALSE);
+
+    return c;
+}
+ 
+/*
+ * UART Initiation
+ */
+int rt_hw_uart_init(void)
+{
+    struct rt_serial_device *serial;
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+
+#ifdef RT_USING_UART0
+    {
+        struct device_uart      *uart;
+        
+        serial  = &serial0;
+        uart    = &uart0;
+                
+        /* Init UART Hardware */
+        serial_init(&uart->serial, UART_TX, UART_RX);
+        
+        serial->ops              = &_uart_ops;
+        serial->config           = config;
+        serial->config.baud_rate = 115200;
+
+        uart->irqno     = UART0_IRQ;
+
+        rt_hw_serial_register(serial,
+                              "uart0",
+                              RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
+                              uart);
+    }
+#endif
+
+    {
+        serial  = &ameba_dbg_serial;
+
+        serial->ops = &_ambed_dbg_ops;
+        serial->config = config;
+        
+        rt_hw_serial_register(serial,
+                              RT_CONSOLE_DEVICE_NAME,
+                              RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
+                              RT_NULL);
+    }
+    return 0;
+}

bsp/amebaz/drivers/drv_uart.h

+/*
+ * File      : drv_uart.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-05-30     Bernard      the first version
+ * 2018-03-15     flyingcys    add amebaz
+ */
+
+#ifndef __DRV_UART_H__
+#define __DRV_UART_H__
+
+#include "ameba_soc.h"
+#include "serial_api.h"
+
+#if defined(CONFIG_PLATFORM_8711B)
+// 8710B
+#define UART_TX PA_23
+#define UART_RX PA_18
+#else
+// 8711AM
+#define UART_TX PA_7
+#define UART_RX PA_6
+//8711AF
+//#define UART_TX PA_4
+//#define UART_RX PA_0
+#endif
+
+int rt_hw_uart_init(void);
+
+#endif /* __DRV_UART_H__ */

bsp/amebaz/drivers/drv_wifi.c

+/*
+ * File      : drv_wifi.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-5-30      Bernard      the first version
+ * 2018-5-30      flyingcys    add amebaz wifi driver
+ */
+
+#include <rtthread.h>
+#include <wlan_dev.h>
+#include <skbuff.h>
+
+#include "amebaz_wlan.h"
+
+//#define ETH_RX_DUMP
+//#define ETH_TX_DUMP
+//#define MINI_DUMP
+
+#define     MAX_ADDR_LEN        6
+
+struct ameba_wifi
+{
+    struct rt_wlan_device parent;
+
+    rt_uint8_t dev_addr[MAX_ADDR_LEN];
+    
+    int idx;
+    int connected;
+};
+
+#ifdef RT_USING_WLAN_STA
+static struct ameba_wifi wifi_sta;
+#endif
+
+#ifdef RT_USING_WLAN_AP
+static struct ameba_wifi wifi_ap;
+#endif
+
+#if defined(ETH_RX_DUMP) ||  defined(ETH_TX_DUMP)
+static void packet_dump(const char *msg, const struct pbuf *p)
+{
+    const struct pbuf *q;
+    rt_uint32_t i, j;
+    rt_uint8_t *ptr;
+
+    rt_kprintf("%s %d byte\n", msg, p->tot_len);
+
+#ifdef MINI_DUMP
+	return;
+#endif
+
+    i = 0;
+    for (q = p; q != RT_NULL; q = q->next)
+    {
+        ptr = q->payload;
+
+        for (j = 0; j < q->len; j++)
+        {
+            if ((i % 8) == 0)
+            {
+                rt_kprintf("  ");
+            }
+            
+            if ((i % 16) == 0)
+            {
+                rt_kprintf("\r\n");
+            }
+            rt_kprintf("%02x ", *ptr);
+
+            i++;
+            ptr++;
+        }
+    }
+
+    rt_kprintf("\n\n");
+}
+#endif /* dump */
+
+#define netifapi_netif_set_link_up(n)      netifapi_netif_common(n, netif_set_link_up, NULL)
+#define netifapi_netif_set_link_down(n)    netifapi_netif_common(n, netif_set_link_down, NULL)
+
+void netif_set_connected(int connected)
+{
+    wifi_sta.connected = connected;
+    if (connected)
+    {
+        netifapi_netif_set_link_up(wifi_sta.parent.parent.netif);
+    }
+    else
+    {
+        netifapi_netif_set_link_down(wifi_sta.parent.parent.netif);
+    }
+} 
+
+void rltk_wlan_set_netif_info(int idx_wlan, void * dev, unsigned char * dev_addr)
+{
+    struct ameba_wifi *wifi;
+    
+    if(idx_wlan == 0)
+         wifi = &wifi_sta;
+    
+    rtw_memcpy(wifi->dev_addr, dev_addr, 6);
+    rt_hw_wifi_init();
+}
+
+void netif_rx(int idx, unsigned int len)
+{
+    struct ameba_wifi *wifi;
+	struct pbuf *p, *q;
+	int sg_len = 0;
+	struct sk_buff *skb = RT_NULL;
+
+    if(idx == 0)
+         wifi = &wifi_sta;
+    
+#if CONFIG_WLAN
+    if(!wifi->connected || !rltk_wlan_running(idx))
+        return;
+#endif
+
+    skb = rltk_wlan_get_recv_skb(idx);
+    if(!skb)
+    {
+        rt_kprintf("netif_rx rltk_wlan_get_recv_skb NULL.\n");
+        return;
+    }
+    
+	p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
+	if (p != RT_NULL)
+	{
+        pbuf_take(p, skb->data, len);
+        skb_pull(skb, len);
+        
+#ifdef ETH_RX_DUMP
+        packet_dump("RX dump", p);
+#endif /* ETH_RX_DUMP */
+
+        if(wifi->parent.parent.netif->input(p, wifi->parent.parent.netif) != ERR_OK)
+        {
+            pbuf_free(p);
+        }
+    }
+    else
+    {
+		rt_kprintf("pbuf_alloc NULL for wifi RX.\n");
+	}
+}
+      
+int netif_is_valid_IP(int idx, unsigned char *ip_dest)
+{
+
+	struct netif * pnetif;
+	struct ip_addr addr = { 0 };
+	u32_t *ip_dest_addr  = (u32_t*)ip_dest;
+
+    if(idx == 0)
+        pnetif = wifi_sta.parent.parent.netif;
+    
+	addr.addr = *ip_dest_addr;
+
+    if(pnetif == RT_NULL)
+        return 0;
+    
+	if(pnetif->ip_addr.addr == 0)
+		return 1;
+	
+	if(ip_addr_ismulticast(&addr) || ip_addr_isbroadcast(&addr,pnetif))
+    {
+		return 1;
+	}
+		
+	if(ip_addr_cmp(&(pnetif->ip_addr), &addr))
+		return 1;
+
+	return 0;
+}
+       
+void netif_post_sleep_processing(void)
+{
+
+}
+
+void netif_pre_sleep_processing(void)
+{
+
+}
+
+unsigned char *rltk_wlan_get_ip(int idx)
+{
+    struct ameba_wifi *wifi;
+
+    if(idx == 0)
+        wifi = &wifi_sta;
+
+    return (unsigned char *)&(wifi->parent.parent.netif->ip_addr);
+}
+
+struct netif *rltk_wlan_get_netif(int idx)
+{
+    struct netif *netif;
+    
+    if(idx == 0)
+        netif = &wifi_sta.parent.parent.netif;
+    else if(idx = 1)
+        netif = &wifi_ap.parent.parent.netif;
+
+    return netif;
+}
+
+
+rt_err_t rt_ameba_wifi_init(rt_device_t dev)
+{
+    return RT_EOK;
+}
+
+rt_err_t rt_ameba_wifi_open(rt_device_t dev, rt_uint16_t oflag)
+{
+    return RT_EOK;
+}
+
+rt_err_t rt_ameba_wifi_close(rt_device_t dev)
+{
+    return RT_EOK;
+}
+
+rt_size_t rt_ameba_wifi_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
+{
+    rt_set_errno(-RT_ENOSYS);
+    return 0;
+}
+
+rt_size_t rt_ameba_wifi_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
+{
+    rt_set_errno(-RT_ENOSYS);
+    return 0;
+}
+
+rt_err_t  rt_ameba_wifi_control(rt_device_t dev, int cmd, void *args)
+{
+    switch(cmd)
+    {
+    case NIOCTL_GADDR:
+    {
+        struct ameba_wifi *wifi = (struct ameba_wifi *)dev;
+        if(args)
+            memcpy(args, wifi->dev_addr, MAX_ADDR_LEN);
+        else
+            return -RT_ERROR;
+    }
+        break;
+
+    case WIFI_INIT:
+    {
+        rt_wlan_mode_t mode = *(rt_wlan_mode_t *)args;
+        rt_kprintf("mode:%d\n", mode);
+    }
+        break;    
+
+    case WIFI_SCAN:
+    {
+        struct rt_wlan_scan_result *dst = RT_NULL;
+        dst = (struct rt_wlan_scan_result *)rt_malloc(sizeof(struct rt_wlan_scan_result));
+        if(dst == RT_NULL)
+        {
+            rt_kprintf("rt_malloc for scan result failed!\n");
+            return -RT_ENOMEM;
+        }
+
+        memset(dst, 0, sizeof(struct rt_wlan_scan_result));
+        if(amebaz_wifi_scan(dst) != RT_EOK)
+        {
+            rt_kprintf("amebaz_wifi_scan failed...\n");
+            return -RT_ERROR;
+        }
+
+        *(struct rt_wlan_scan_result **)args = dst;
+    }
+        break;
+
+    case WIFI_JOIN:
+        
+        break;
+    
+    case WIFI_EASYJOIN:
+    {
+        struct rt_wlan_device *wlan = (struct rt_wlan_device *)dev;
+        if(amebaz_wifi_connect(wlan->info->ssid, (char *)args) != RT_EOK)
+        {
+            rt_kprintf("amebaz_wifi_connect failed...\n");
+            return -RT_ERROR;
+        }
+    }
+        break;
+        
+    case WIFI_SOFTAP:
+    {
+        struct rt_wlan_device *wlan = (struct rt_wlan_device *)dev;
+        if(amebaz_wifi_ap_start(wlan->info->ssid, (char *)args, wlan->info->channel) != RT_EOK)
+        {
+            rt_kprintf("amebaz_wifi_ap_start failed...\n");
+            return -RT_ERROR;
+        }
+    }
+        break;
+        
+    case WIFI_DISCONNECT:
+        if(amebaz_wifi_disconnect() != RT_EOK)
+        {
+            rt_kprintf("amebaz_wifi_disconnect failed...\n");
+            return -RT_ERROR;
+        }
+        break;
+        
+    case WIFI_GET_RSSI:
+    {
+        int *rssi = (int *)args;
+        
+        *rssi = amebaz_wifi_get_rssi();
+    }
+        break;
+        
+    case WIFI_ENTER_POWERSAVE:
+        
+        break;
+        
+    case WIFI_CFG_MONITOR:
+
+        break;
+        
+    case WIFI_SET_CHANNEL:
+    {
+        int channel = *(int *)args;
+        
+        amebaz_wifi_set_channel(channel);
+    }
+        break;
+        
+    case WIFI_GET_CHANNEL:
+    {
+        int *channel = (int *)args;
+
+        channel = amebaz_wifi_get_channel();
+    }
+        break;
+        
+    case WIFI_SET_MONITOR_CALLBACK:
+        
+        break;
+    }
+
+    return RT_EOK;
+}
+
+rt_err_t rt_ameba_wifi_tx(rt_device_t dev, struct pbuf* p)
+{
+    rt_err_t result = RT_EOK;
+    struct ameba_wifi *wifi = (struct ameba_wifi *)dev;
+    int idx;
+    rt_base_t level;
+	struct sk_buff *skb = RT_NULL;
+
+    idx = wifi->idx;
+
+    level = rt_hw_interrupt_disable();
+	if(wifi->connected && rltk_wlan_check_isup(idx))
+		rltk_wlan_tx_inc(idx);
+    else
+    {
+        rt_hw_interrupt_enable(level);
+//		rt_kprintf("is not: connected && rltk_wlan_check_isup(idx)\n");
+
+        result = -RT_ERROR;
+        goto _exit;
+    }
+
+    rt_hw_interrupt_enable(level);
+    
+#ifdef ETH_TX_DUMP
+    packet_dump("TX dump", p);
+#endif /* ETH_TX_DUMP */
+
+    skb = rltk_wlan_alloc_skb(p->tot_len); 
+    if(skb != RT_NULL)
+    {
+		/* copy pbuf to a whole ETH frame */
+		pbuf_copy_partial(p, skb->tail, p->tot_len, 0);
+        skb_put(skb, p->tot_len);
+        
+    	rltk_wlan_send_skb(idx, skb);
+    }
+	else
+	{
+		rt_kprintf("rltk_wlan_alloc_skb NULL for WIFI TX.\n");
+        result = -RT_ENOMEM;
+	}
+
+_exit:  
+    level = rt_hw_interrupt_disable();
+    rltk_wlan_tx_dec(idx);
+    rt_hw_interrupt_enable(level);
+    
+    return result;
+}
+
+int rt_hw_wifi_init(void)
+{
+    rt_kprintf("%s %d\n", __FUNCTION__, __LINE__);
+    
+#ifdef RT_USING_WLAN_STA
+    wifi_sta.parent.parent.parent.init = rt_ameba_wifi_init;
+    wifi_sta.parent.parent.parent.open = rt_ameba_wifi_open;
+    wifi_sta.parent.parent.parent.close = rt_ameba_wifi_close;
+    wifi_sta.parent.parent.parent.read = rt_ameba_wifi_read;
+    wifi_sta.parent.parent.parent.write = rt_ameba_wifi_write;
+    wifi_sta.parent.parent.parent.control = rt_ameba_wifi_control;
+    wifi_sta.parent.parent.parent.user_data = RT_NULL;
+    //
+    wifi_sta.idx = 0;
+    //
+    wifi_sta.parent.parent.eth_rx = RT_NULL;
+    wifi_sta.parent.parent.eth_tx = rt_ameba_wifi_tx;
+
+    /* register wifi device */
+    eth_device_init(&wifi_sta.parent.parent, WIFI_DEVICE_STA_NAME);   
+#endif
+
+#ifdef RT_USING_WLAN_AP
+
+#endif
+    
+    return RT_EOK;
+}
+

bsp/amebaz/drivers/drv_wifi.h

+/*
+ * File      : drv_wifi.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-5-30      Bernard      the first version
+ */
+ 
+#ifndef __DRV_WIFI_H__
+#define __DRV_WIFI_H__
+
+int rt_hw_wifi_init(void);
+    
+#endif /* __DRV_WIFI_H__ */
+

bsp/amebaz/drivers/wlan/SConscript

+import rtconfig
+from building import *
+
+cwd     = GetCurrentDir()
+CPPPATH = [cwd, str(Dir('#'))]
+
+src = []
+if GetDepend(['RT_USING_LWIP']):
+	src += Split('''
+		amebaz_wlan.c
+		''')
+
+group = DefineGroup('amebaz_wlan', src, depend = [''], CPPPATH = CPPPATH)
+
+Return('group')

bsp/amebaz/drivers/wlan/amebaz_wlan.c

+/*
+ * File      : amebaz_wlan.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-5-30      Bernard      the first version
+ * 2018-6-12      flyingcys    add amebaz wlan interface
+ */
+#include <rtthread.h>
+#include <netif/ethernetif.h>
+
+#include "wifi_structures.h"
+#include "wifi_constants.h"
+#include <wifi/wifi_util.h>
+#include <wifi/wifi_conf.h>
+
+
+#define     PASSWD_LEN          65
+#define     SCAN_WAIT_TIME      10000
+
+typedef enum
+{
+    WIFI_NONE,
+    WIFI_STATION,
+    WIFI_AP,
+} rt_wlan_mode_t;
+
+struct rt_wlan_info
+{
+    rt_wlan_mode_t mode;   /* wifi mode */
+    rtw_security_t security;
+
+    char *ssid;
+    uint8_t bssid[6];
+
+    /* maximal data rate */
+    uint32_t datarate;
+    /* radio channel */
+    uint16_t channel;
+    /* signal strength */
+    int16_t  rssi;
+};
+
+typedef struct rt_wlan_scan_result
+{
+    char ap_num;
+    struct rt_wlan_info *ap_table;
+} rt_wlan_scan_result_t;
+
+
+static rtw_network_info_t wifi_info = {0};
+static rtw_ap_info_t ap_info = {0};
+static unsigned char wifi_password[65] = {0};
+static unsigned char ap_password[PASSWD_LEN] = {0};
+static rt_sem_t scan_done_sem = RT_NULL;
+static char *scan_buf = RT_NULL;
+static int ApNum = 0;
+
+extern struct netif *rltk_wlan_get_netif(int idx);
+
+static void LwIP_ReleaseIP(uint8_t idx)
+{
+	struct ip_addr ipaddr;
+	struct ip_addr netmask;
+	struct ip_addr gw;
+	struct netif *pnetif = rltk_wlan_get_netif(idx);
+	
+	IP4_ADDR(&ipaddr, 0, 0, 0, 0);
+	IP4_ADDR(&netmask, 255, 255, 255, 0);
+	IP4_ADDR(&gw, 0, 0, 0, 0);
+	
+	netif_set_addr(pnetif, &ipaddr , &netmask, &gw);
+}
+
+static rtw_result_t amebaz_scan_result_handler( rtw_scan_handler_result_t* malloced_scan_result )
+{
+	if (malloced_scan_result->scan_complete != RTW_TRUE) {
+		rtw_scan_result_t* record = &malloced_scan_result->ap_details;
+		record->SSID.val[record->SSID.len] = 0; /* Ensure the SSID is null terminated */
+
+        ++ ApNum;
+        
+		if(malloced_scan_result->user_data)
+			memcpy((void *)((char *)malloced_scan_result->user_data+(ApNum-1)*sizeof(rtw_scan_result_t)), (char *)record, sizeof(rtw_scan_result_t));
+	} 
+    else
+    {
+        rt_kprintf("ap num:%d\n", ApNum);
+
+        if(scan_done_sem)
+        {
+            rt_sem_release(scan_done_sem);
+        }
+    }
+    
+	return RTW_SUCCESS;
+}
+
+
+static int amebaz_wifi_do_scan(void)
+{
+    int ret = RTW_SUCCESS;
+
+    rt_kprintf("wifi scan start...\n");
+
+	scan_buf = malloc(65*sizeof(rtw_scan_result_t));
+	if(scan_buf == NULL){
+		ret = RTW_BUFFER_UNAVAILABLE_TEMPORARY;
+		return -RT_ENOMEM;
+	}
+    
+	memset(scan_buf, 0, 65 * sizeof(rtw_scan_result_t));
+
+    if((ret = wifi_scan_networks(amebaz_scan_result_handler, scan_buf)) != RTW_SUCCESS){
+        rt_kprintf("ERROR: wifi scan failed\n\r");
+
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+int amebaz_wifi_scan(struct rt_wlan_scan_result *dst)
+{
+    rt_uint32_t i;
+    rt_uint32_t j = 0;
+    
+    scan_done_sem = rt_sem_create("scandone", 0, RT_IPC_FLAG_FIFO);
+    if(scan_done_sem == RT_NULL)
+        return -RT_ENOMEM;
+
+    if(amebaz_wifi_do_scan() != RT_EOK)
+    {
+        rt_kprintf("amebaz_wifi_do_scan failed...\n");
+        return -RT_ERROR;
+    }
+
+    if(rt_sem_take(scan_done_sem, rt_tick_from_millisecond(SCAN_WAIT_TIME)) != RT_EOK)
+    {
+        rt_kprintf("scan wait timeout...\n");
+        return -RT_ETIMEOUT;
+    } 
+
+    if(scan_done_sem)
+    {
+        rt_sem_delete(scan_done_sem);
+        scan_done_sem = RT_NULL;
+    }
+
+    rtw_scan_result_t *ptr = (rtw_scan_result_t *)scan_buf;
+    dst->ap_num = ApNum;
+    ApNum = 0;
+
+    dst->ap_table = (struct rt_wlan_info *)rt_malloc(sizeof(struct rt_wlan_info) * dst->ap_num);
+    if(dst->ap_table == RT_NULL)
+    {
+        rt_kprintf("rt_malloc for ap table failed...\n");
+        goto __exit;
+    }
+
+    for(i = 0; i < dst->ap_num; i ++)
+    {
+        dst->ap_table[i].mode = 1;
+        dst->ap_table[i].security = ptr->security;
+        dst->ap_table[i].ssid = (char *)rt_malloc(33);
+        if(dst->ap_table[i].ssid == RT_NULL)
+        {
+			rt_kprintf("rt_malloc for ssid Failed! times:%d,total:%d\n",i,ApNum);
+            j = i;
+            goto __exit;
+        }
+
+        memset(dst->ap_table[i].ssid, 0, 33);
+        memcpy(dst->ap_table[i].ssid, ptr->SSID.val, ptr->SSID.len);
+        memcpy(dst->ap_table[i].bssid, ptr->BSSID.octet, 6);
+        dst->ap_table[i].datarate = 0;
+        dst->ap_table[i].channel = ptr->channel;
+        dst->ap_table[i].rssi = ptr->signal_strength;
+
+        ptr ++;
+    }
+
+    if(scan_buf != RT_NULL)
+    {
+        rt_free(scan_buf);
+        scan_buf = RT_NULL;
+    }
+    
+    return RT_EOK;
+
+__exit:
+    
+    if(scan_buf != RT_NULL)
+    {
+        rt_free(scan_buf);
+        scan_buf = RT_NULL;
+    }
+
+    if(dst->ap_table)
+    {
+        for(i = 0; i < j; i ++)
+            rt_free(dst->ap_table[i].ssid);
+        rt_free(dst->ap_table);
+        dst->ap_table = RT_NULL;
+        dst->ap_num = 0;
+    }
+
+    return -RT_ERROR;
+}
+
+void amebaz_wifi_info_init(void)
+{
+    memset(wifi_info.ssid.val, 0, sizeof(wifi_info.ssid.val));
+    memset(wifi_info.bssid.octet, 0, 6);  
+    memset(wifi_password, 0, sizeof(wifi_password));
+    wifi_info.ssid.len = 0;
+    wifi_info.password = NULL;
+    wifi_info.password_len = 0;
+    wifi_info.key_id = -1;
+    
+    memset(ap_info.ssid.val, 0, sizeof(ap_info.ssid.val));
+    ap_info.ssid.len = 0;
+    ap_info.security_type = RTW_SECURITY_UNKNOWN;
+    ap_info.password = NULL;
+    ap_info.password_len = 0;
+    ap_info.channel = 1;
+}
+
+static int amebaz_wifi_set_sta_info(char *ssid, char *passwd)
+{
+    if(ssid == RT_NULL || strlen(ssid) > 32)
+    {
+        rt_kprintf("Invalid argument...\n");
+        return -RT_EINVAL;
+    }
+
+    strcpy(wifi_info.ssid.val, ssid);
+    wifi_info.ssid.len = strlen(ssid);
+
+    if(passwd != NULL)
+    {
+        if(strlen(passwd) > 64)
+        {
+            rt_kprintf("Invalid argument...\n");
+            return -RT_EINVAL;
+        }
+        strcpy(wifi_password, passwd);
+        wifi_info.password = wifi_password;
+        wifi_info.password_len = strlen(passwd);
+    }
+    else
+        wifi_info.password = RT_NULL;
+
+    return RT_EOK;
+}
+
+static int amebaz_wifi_set_ap_info(char *ssid, char *passwd, int channel)
+{
+    if(ssid == RT_NULL || strlen(ssid) > 32)
+    {
+        rt_kprintf("Invalid argument...\n");
+        return -RT_EINVAL;
+    }
+
+    strcpy(ap_info.ssid.val, ssid);
+    ap_info.ssid.len = strlen(ssid);
+
+    if(passwd != NULL)
+    {
+        if(strlen(passwd) > 64)
+        {
+            rt_kprintf("Invalid argument...\n");
+            return -RT_EINVAL;
+        }
+        strcpy(ap_password, passwd);
+        ap_info.password = ap_password;
+        ap_info.password_len = strlen(passwd);
+    }
+    else
+        ap_info.password = RT_NULL;
+
+    ap_info.channel = channel;
+    return RT_EOK;
+}
+
+static int amebaz_wifi_do_connect(void)
+{
+    int mode, ret;
+    char empty_bssid[6] = {0};
+    char assoc_by_bssid = 0;  
+        
+    rt_kprintf("amebaz wifi do connect start...\n"); 
+    if(memcmp (wifi_info.bssid.octet, empty_bssid, 6))
+    {
+        assoc_by_bssid = 1;
+    }
+    else if(wifi_info.ssid.val[0] == 0)
+    {
+        ret = RTW_BADARG;
+        return -RT_ERROR;
+    }
+    
+    if(wifi_info.password != RT_NULL)
+    {
+        if((wifi_info.key_id >= 0) && (wifi_info.key_id <= 3))
+        {
+            wifi_info.security_type = RTW_SECURITY_WEP_PSK;
+        }
+        else
+        {
+            wifi_info.security_type = RTW_SECURITY_WPA2_AES_PSK;
+        }
+    }
+    else
+    {
+        wifi_info.security_type = RTW_SECURITY_OPEN;
+    }
+    
+    //Check if in AP mode
+    wext_get_mode(WLAN0_NAME, &mode);
+    if(mode == IW_MODE_MASTER)
+    {
+    #if 0
+#if CONFIG_LWIP_LAYER
+        dhcps_deinit();
+#endif
+        wifi_off();
+        vTaskDelay(20);
+        if (wifi_on(RTW_MODE_STA) < 0){
+            printf("\n\rERROR: Wifi on failed!");
+                        ret = RTW_ERROR;
+            goto EXIT;
+        }
+    #endif
+    }
+
+    if(assoc_by_bssid)
+    {
+        rt_kprintf("Joining BSS by BSSID \"MAC_FMT\" ...\n", MAC_ARG(wifi_info.bssid.octet));
+        ret = wifi_connect_bssid(wifi_info.bssid.octet, (char*)wifi_info.ssid.val, wifi_info.security_type, (char*)wifi_info.password, 
+                        ETH_ALEN, wifi_info.ssid.len, wifi_info.password_len, wifi_info.key_id, NULL);     
+    } 
+    else 
+    {
+        rt_kprintf("\n\rJoining BSS by SSID %s...\n\r", (char*)wifi_info.ssid.val);
+        ret = wifi_connect((char*)wifi_info.ssid.val, wifi_info.security_type, 
+                        (char*)wifi_info.password, wifi_info.ssid.len,
+                        wifi_info.password_len, wifi_info.key_id, NULL);
+    }
+    
+    if(ret!= RTW_SUCCESS)
+    {
+        if(ret == RTW_INVALID_KEY)
+            rt_kprintf("ERROR:Invalid Key\n");
+        
+        rt_kprintf("ERROR: Can't connect to AP\n");
+        return -RT_ERROR;
+    }
+
+    rt_kprintf("now start dhcp...\n");
+    netif_set_connected(1);
+    dhcp_start(netif_default);
+    rt_kprintf("dhcp success...\n");
+    
+    return RT_EOK;
+}
+
+int amebaz_wifi_connect(char *ssid, char *passwd)
+{
+    int ret;
+
+    ret = amebaz_wifi_set_sta_info(ssid, passwd);
+    if(ret != RT_EOK)
+    {
+        amebaz_wifi_info_init();
+        return ret;
+    }
+    
+    if(amebaz_wifi_do_connect() != RT_EOK)
+    {
+        amebaz_wifi_info_init();
+        rt_kprintf("amebaz_wifi_do_connect failed...\n");
+        return -RT_ERROR;
+    }
+
+    amebaz_wifi_info_init();
+    
+    return RT_EOK;
+}
+
+static int amebaz_wifi_do_disconnect(void)
+{
+	int timeout = 20;
+	char essid[33];
+	int ret = RTW_SUCCESS;
+
+	if(wext_get_ssid(WLAN0_NAME, (unsigned char *) essid) < 0) 
+    {
+		rt_kprintf("\nWIFI disconnected!\n");
+        return -RT_ERROR;
+	}
+
+	if((ret = wifi_disconnect()) < 0) 
+    {
+        return -RT_ERROR;
+	}
+
+	while(1) 
+    {
+		if(wext_get_ssid(WLAN0_NAME, (unsigned char *) essid) < 0)
+        {
+			rt_kprintf("\nWIFI disconnected!\n");
+			break;
+		}
+
+		if(timeout == 0) 
+        {
+			rt_kprintf("ERROR: Deassoc timeout!\n\r");
+			ret = RTW_TIMEOUT;
+			break;
+		}
+
+		vTaskDelay(10);
+		timeout --;
+	}
+
+	LwIP_ReleaseIP(WLAN0_IDX);
+    
+    if(ret != RTW_SUCCESS)
+        return -RT_ERROR;
+
+    rt_kprintf("amebaz wifi do disconnect success...\n");
+    return RT_EOK;
+}
+
+int amebaz_wifi_disconnect(void)
+{
+    int ret = RT_EOK;
+
+    ret = amebaz_wifi_do_disconnect();
+    if(ret != RT_EOK)
+        rt_kprintf("amebaz_wifi_do_disconnect failed...\n");
+    
+    amebaz_wifi_info_init();
+
+    return ret;
+}
+
+static int amebaz_wifi_do_ap_start(void)
+{
+    struct ip_addr ipaddr;
+    struct ip_addr netmask;
+    struct ip_addr gw;
+    struct netif *pnetif = rltk_wlan_get_netif(1);
+
+    int timeout = 20;
+    int ret = RTW_SUCCESS;
+    
+    if(ap_info.ssid.val[0] == 0){
+        rt_kprintf("ERROR: SSID can't be empty\n\r");
+        return -RT_ERROR;
+    }
+    
+    if(ap_info.password == NULL)
+    {
+        ap_info.security_type = RTW_SECURITY_OPEN;
+    }
+    else
+    {
+        if(ap_info.password_len <= RTW_MAX_PSK_LEN && ap_info.password_len >= RTW_MIN_PSK_LEN)
+        { 
+            ap_info.security_type = RTW_SECURITY_WPA2_AES_PSK;
+        }
+        else
+        {
+            rt_kprintf("ERROR: password length is between 8 to 64 \n");
+            return -RT_ERROR;
+        }
+    }
+    
+//#if CONFIG_LWIP_LAYER
+//    dhcps_deinit();
+//    IP4_ADDR(&ipaddr, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
+//    IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
+//    IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
+//    netif_set_addr(pnetif, &ipaddr, &netmask,&gw);
+//#ifdef CONFIG_DONT_CARE_TP
+//        pnetif->flags |= NETIF_FLAG_IPSWITCH;
+//#endif
+//#endif
+
+    wifi_off();
+    vTaskDelay(20);
+    if (wifi_on(RTW_MODE_AP) < 0)
+    {
+        rt_kprintf("ERROR: Wifi on failed!\n");
+        return -RT_ERROR;
+    }
+    rt_kprintf("Now start AP mode...\n");
+
+    if((ret = wifi_start_ap((char*)ap_info.ssid.val, ap_info.security_type, (char*)ap_info.password, ap_info.ssid.len, ap_info.password_len, ap_info.channel) ) < 0) 
+    {
+        rt_kprintf("ERROR: Operation failed!");
+        return -RT_ERROR;
+    }
+    
+    while(1) 
+    {
+        char essid[33];
+
+        if(wext_get_ssid(WLAN0_NAME, (unsigned char *) essid) > 0) 
+        {
+            if(strcmp((const char *) essid, (const char *)ap_info.ssid.val) == 0) 
+            {
+                rt_kprintf("AP %s started...\n", ap_info.ssid.val);
+                ret = RTW_SUCCESS;
+                break;
+            }
+        }
+
+        if(timeout == 0) 
+        {
+            rt_kprintf("ERROR: Start AP timeout!");
+            ret = RTW_TIMEOUT; 
+            break;
+        }
+
+        vTaskDelay(10);
+        timeout --;
+    }
+
+    if(ret != RTW_SUCCESS)
+        return -RT_ERROR;
+
+//#if CONFIG_LWIP_LAYER
+    //LwIP_UseStaticIP(pnetif);
+//    dhcps_init(pnetif);
+//#endif
+
+    return RT_EOK;
+}
+
+static int amebaz_wifi_do_ap_stop(void)
+{
+    return RT_EOK;
+}
+
+int amebaz_wifi_ap_start(char *ssid, char *passwd, int channel)
+{
+    int ret;
+
+    ret = amebaz_wifi_set_ap_info(ssid, passwd, channel);
+    if(ret != RT_EOK)
+    {
+        amebaz_wifi_info_init();
+        return ret;
+    }
+    
+    if(amebaz_wifi_do_ap_start() != RT_EOK)
+    {
+        amebaz_wifi_info_init();
+        rt_kprintf("amebaz_wifi_ap_start failed...\n");
+        return -RT_ERROR;
+    }
+
+    amebaz_wifi_info_init();
+    return RT_EOK;
+}
+
+int amebaz_wifi_ap_stop(void)
+{
+    int ret;
+
+    if(amebaz_wifi_do_ap_stop() != RT_EOK)
+    {
+        amebaz_wifi_info_init();
+        rt_kprintf("amebaz_wifi_ap_stop failed...\n");
+        return -RT_ERROR;
+    }
+
+    amebaz_wifi_info_init();
+    return RT_EOK;
+}
+
+int amebaz_wifi_get_rssi(void)
+{
+	int rssi = 0;
+    
+	wifi_get_rssi(&rssi);
+    
+    return rssi;
+}
+
+void amebaz_wifi_set_channel(int channel)
+{
+    wifi_set_channel(channel);
+}
+
+int amebaz_wifi_get_channel(void)
+{
+    int channel;
+    
+    wifi_get_channel(&channel);
+    
+    return channel;
+}
+
+int amebaz_wifi_init(rt_wlan_mode_t mode)
+{
+    int ret;
+    rtw_mode_t rtw_mode;
+
+    if(mode == WIFI_STATION)
+        rtw_mode = RTW_MODE_STA;
+    else if(mode == WIFI_AP)
+        rtw_mode = RTW_MODE_AP;
+    
+    if(wifi_on(mode) < 0)
+        return -RT_ERROR;
+    
+    if(wifi_set_autoreconnect(1) < 0)
+        return -RT_ERROR;
+
+    return RT_EOK;
+}
+

bsp/amebaz/drivers/wlan/amebaz_wlan.h

+/*
+ * File      : amebaz_wlan.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-5-30      Bernard      the first version
+ * 2018-6-12      flyingcys    add amebaz wlan interface
+ */
+ 
+#ifndef __AMEBAZ_WLAN_H__
+#define __AMEBAZ_WLAN_H__
+
+int amebaz_wifi_scan();
+
+void amebaz_wifi_info_init(void);
+
+int amebaz_wifi_set_sta_info(char *ssid, char *passwd);
+
+int amebaz_wifi_set_ap_info(char *ssid, char *passwd);
+
+int amebaz_wifi_connect(char *ssid, char *passwd);
+
+int amebaz_wifi_disconnect(void);
+
+int amebaz_wifi_ap_start(char *ssid, char *passwd, int channel);
+
+int amebaz_wifi_ap_stop(void);
+
+int amebaz_wifi_get_rssi(void);
+
+void amebaz_wifi_set_channel(int channel);
+
+int amebaz_wifi_get_channel(void);
+
+int amebaz_wifi_init(rt_wlan_mode_t mode);
+
+#endif /* __AMEBAZ_WLAN_H__ */
+

bsp/amebaz/gen_bin.py

+import re
+import subprocess
+import os
+import platform
+
+tool_pwd=os.path.normpath(os.getcwd()+r'/packages/realtek_ameba/sdk-ameba-v4.0b_without_NDA_GCC_V1.0.0/component/soc/realtek/8711b/misc/iar_utility/common/tools')
+
+def grep_func(file,str):
+	fd=open(file,'r')
+	strtmp=r'^[0-9]{8}\s[a-zA-Z]{1}\s%s$' % str
+	for line in fd.readlines():
+		if re.match(strtmp,line):
+			#print(line)
+			value=re.split(r'[\s+]+',line)
+			fd.close()
+			return value[0]
+	fd.close()
+
+#=====================start=======================
+
+os.system(r'arm-none-eabi-objdump -d rtthread.axf > application.asm')
+os.system(r'arm-none-eabi-size rtthread.axf')
+os.system(r'arm-none-eabi-nm rtthread.axf | sort > application.nmap')
+
+#====================process=====================
+
+addr1=grep_func(r'application.nmap','__ram_image2_text_start__')
+addr2=grep_func(r'application.nmap','__ram_image2_text_end__')
+addr3=grep_func(r'application.nmap','__ram_image2_text_start__')
+addr4=grep_func(r'application.nmap','__ram_image2_text_end__')
+addr5=grep_func(r'application.nmap','__xip_image2_start__')
+addr6=grep_func(r'application.nmap','__xip_image2_start__')
+
+sysstr = platform.system()
+print(sysstr)
+if(sysstr == "Linux"):
+	exec_pick = tool_pwd + r'/pick'
+	exec_checksum = tool_pwd + r'/checksum'
+	os.system('chmod +x ' + exec_pick)
+	os.system('chmod +x ' + exec_checksum)
+	#print(exec_pick)
+elif(sysstr == "Windows"):
+	exec_pick=tool_pwd+r'/pick.exe'
+	exec_checksum = tool_pwd + r'/checksum.exe'
+	#print(exec_pick)
+else:
+	print("not support!!!")
+
+exec_pick_param1=r' 0x%s 0x%s ram_2.r.bin ram_2.bin raw' % (addr1,addr2)
+exec_pick_param2=r' 0x%s 0x%s ram_2.bin ram_2.p.bin' % (addr3,addr4)
+exec_pick_param3=r' 0x%s 0x%s xip_image2.bin xip_image2.p.bin' % (addr5,addr6)
+#print(exec_pick_param1)
+#print(exec_pick_param2)
+#print(exec_pick_param3)
+
+exec_cmd1=exec_pick+exec_pick_param1
+exec_cmd2=exec_pick+exec_pick_param2
+exec_cmd3=exec_pick+exec_pick_param3
+#print(exec_cmd1)
+#print(exec_cmd2)
+#print(exec_cmd3)
+
+os.system(exec_cmd1)
+os.system(exec_cmd2)
+os.system(exec_cmd3)
+
+#================create bin file================
+
+if os.path.exists('image2_all_ota1.bin'):
+	os.remove('image2_all_ota1.bin')
+
+with open('xip_image2.p.bin','rb') as src:
+	with open('image2_all_ota1.bin', 'wb') as dst:
+    		dst.write(src.read())
+
+with open('ram_2.p.bin','rb') as src:
+	with open('image2_all_ota1.bin', 'ab') as dst:
+    		dst.write(src.read())
+
+exec_cmd4 = exec_checksum + ' image2_all_ota1.bin || true'
+os.system(exec_cmd4)
+
+os.remove("ram_2.bin")
+os.remove("ram_2.p.bin")
+os.remove("ram_2.r.bin")
+os.remove("xip_image2.bin")
+os.remove("xip_image2.p.bin")
+os.remove("rdp.bin")
+
+print("Done...")
+
+#=====================end=======================
\ No newline at end of file

bsp/amebaz/image2.icf

+/*###ICF### Section handled by ICF editor, don't touch! ****/
+/*-Editor annotation file-*/
+/* IcfEditorFile="$TOOLKIT_DIR$\config\ide\IcfEditor\cortex_v1_0.xml" */
+/*-Specials-*/
+//define symbol __ICFEDIT_intvec_start__ = 0x00000000;
+/**/
+/**/
+include "rom_symbol_v01_iar.icf";
+/****************************************
+ * Memory Regions                   *
+ ****************************************/
+define symbol __ICFEDIT_region_ROM_start__       	= 0x00000000;
+define symbol __ICFEDIT_region_ROM_end__         	= 0x0007FFFF;
+define symbol __ICFEDIT_region_ROMBSS_RAM_start__       = 0x10000000;
+define symbol __ICFEDIT_region_ROMBSS_RAM_end__        	= 0x10001FFF;
+define symbol __ICFEDIT_region_BOOTLOADER_RAM_start__   = 0x10002000;
+define symbol __ICFEDIT_region_BOOTLOADER_RAM_end__     = 0x10004FFF;
+define symbol __ICFEDIT_region_BD_RAM_start__    	= 0x10005000;
+define symbol __ICFEDIT_region_BD_RAM_end__      	= 0x1002FFFF;
+define symbol __ICFEDIT_region_MSP_RAM_start__    	= 0x1003E000;
+define symbol __ICFEDIT_region_MSP_RAM_end__      	= 0x1003EFFF;
+define symbol __ICFEDIT_region_RDP_RAM_start__    	= 0x1003F000;
+define symbol __ICFEDIT_region_RDP_RAM_end__      	= 0x1003FFEF;
+define symbol __ICFEDIT_region_IMG2_TEMP_start__ 	= 0x10006000;
+define symbol __ICFEDIT_region_IMG2_TEMP_end__   	= 0x1000BFFF;
+define symbol __ICFEDIT_region_XIP_BOOT_start__ 	= 0x08000000+0x20;
+define symbol __ICFEDIT_region_XIP_BOOT_end__   	= 0x08003FFF;
+define symbol __ICFEDIT_region_XIP_OTA1_start__ 	= 0x0800B000+0x20;
+define symbol __ICFEDIT_region_XIP_OTA1_end__   	= 0x080FFFFF;
+/****************************************
+ * Sizes                   *
+ ****************************************/
+/*define symbol __ICFEDIT_size_cstack__   = 0x400;*/
+define symbol __ICFEDIT_size_heap__     = 0x000;
+/**** End of ICF editor section. ###ICF###*/
+define memory mem with size = 4G;
+define region ROM_region   = mem:[from __ICFEDIT_region_ROM_start__   to __ICFEDIT_region_ROM_end__];
+define region ROM_BSS_region   = mem:[from __ICFEDIT_region_ROMBSS_RAM_start__   to __ICFEDIT_region_ROMBSS_RAM_end__];
+define region BOOT_RAM_region   = mem:[from __ICFEDIT_region_BOOTLOADER_RAM_start__   to __ICFEDIT_region_BOOTLOADER_RAM_end__];
+define region BD_RAM_region   = mem:[from __ICFEDIT_region_BD_RAM_start__   to __ICFEDIT_region_BD_RAM_end__];
+define region IMG2_TEMP_region   = mem:[from __ICFEDIT_region_IMG2_TEMP_start__   to __ICFEDIT_region_IMG2_TEMP_end__];
+define region XIP_BOOT_region   = mem:[from __ICFEDIT_region_XIP_BOOT_start__   to __ICFEDIT_region_XIP_BOOT_end__];
+define region XIP_OTA1_region   = mem:[from __ICFEDIT_region_XIP_OTA1_start__   to __ICFEDIT_region_XIP_OTA1_end__];
+define region RDP_RAM_region   = mem:[from __ICFEDIT_region_RDP_RAM_start__   to __ICFEDIT_region_RDP_RAM_end__];
+/*define block CSTACK    with alignment = 8, size = __ICFEDIT_size_cstack__   { };*/
+define block HEAP      with alignment = 8, size = __ICFEDIT_size_heap__     { };
+//initialize by copy { readwrite };
+//initialize by copy with packing = none { section __DLIB_PERTHREAD }; // Required in a multi-threaded application
+//do not initialize  { section * };
+//place at address mem:__ICFEDIT_intvec_start__ { readonly section .vectors_table };
+//
+/****************************************
+ * ROM Section config                   *
+ ****************************************/
+keep { section FSymTab };
+keep { section VSymTab };
+keep { section .rti_fn* };
+keep { section .rom.text };
+keep { section .rom.rodata };
+place at start of ROM_region   { readonly, section .rom.text, section .rom.rodata};
+/****************************************
+ * ROM BSS Section config                *
+ ****************************************/
+keep { section .ram_vector_table1 };
+keep { section .ram_vector_table2 };
+keep { section .ram_vector_table3 };
+keep { section .hal.rom.bss* };
+keep { section .wlan_ram_map* };
+keep { section .libc.ram.bss* };
+keep { section .ssl_ram_map* };
+define block .hal.rom.bss with fixed order{         section .ram_vector_table1, 
+                                                section .ram_vector_table2,
+                                                section .ram_vector_table3,
+                                                section .hal.rom.bss*,
+                                                section .wlan_ram_map*,
+                                                section .libc.ram.bss*,
+                                                section .ssl_ram_map*, 
+                                      };
+define block ROM_BSS with fixed order { block .hal.rom.bss};
+place at start of ROM_BSS_region  { readwrite, 
+                                      block ROM_BSS,
+                                      };
+/****************************************
+ * BOOT RAM Section config                *
+ ****************************************/
+keep { section .image1.entry.data* };
+keep { section .image1.validate.rodata* };
+define block .ram_image1.entry with fixed order{section .image1.entry.data*,
+						section .image1.validate.rodata*,
+						};
+keep { section .boot.ram.text* };
+keep { section .boot.rodata* };
+define block .ram_image1.text with fixed order{section .boot.ram.text*,
+						section .boot.rodata*,
+						};
+keep { section .boot.ram.data* };
+define block .ram_image1.data with fixed order{section .boot.ram.data*,
+						};
+keep { section .boot.ram.bss* };
+define block .ram_image1.bss with fixed order{section .boot.ram.bss*,
+						};
+define block IMAGE1 with fixed order { block .ram_image1.entry, block .ram_image1.text, block .ram_image1.data, block .ram_image1.bss};
+place at start of BOOT_RAM_region   { readwrite, 
+                                    block IMAGE1,
+                                  };
+/****************************************
+ * BD RAM Section config                *
+ ****************************************/
+keep { section .image2.entry.data* };
+keep { section .image2.validate.rodata* };
+define block .ram_image2.entry with fixed order{ section .image2.entry.data*,
+						section .image2.validate.rodata*,
+						};
+define block SHT$$PREINIT_ARRAY { preinit_array };
+define block SHT$$INIT_ARRAY { init_array };
+define block CPP_INIT with fixed order { block SHT$$PREINIT_ARRAY,
+					block SHT$$INIT_ARRAY };
+define block .ram.data with fixed order{ section .data*, 
+					 section DATA, 
+					 section .iar.init_table,
+					 section __DLIB_PERTHREAD,				 	 
+					 block CPP_INIT,
+					 section .mdns.data,
+					 section .mdns.text
+					};
+define block .ram.text with fixed order{ section .image2.ram.text*,
+					}; 
+define block IMAGE2 with fixed order {  block .ram_image2.entry,
+					block .ram.data,  
+					block .ram.text,  
+					};
+define block .ram_image2.bss with fixed order{ section .bss*,
+                                        section COMMON,
+                                      };
+define block .ram_image2.skb.bss with fixed order{ section .bdsram.data* };
+define block .ram_heap.data with fixed order{ section .bfsram.data* };
+place in BD_RAM_region  { readwrite, 
+					block IMAGE2,
+					block .ram_image2.bss,
+					block .ram_image2.skb.bss,
+					block .ram_heap.data,
+					section .heap.stdlib,	
+                    last block HEAP,
+					};
+/****************************************
+ * XIP BOOT Section config                *
+ ****************************************/
+keep { section .flashboot.text* };
+define block .xip_image1.text with fixed order{ section .flashboot.text* };
+define block Bootloader with fixed order { section LOADER };
+place at start of XIP_BOOT_region   {   block Bootloader,
+					readwrite,
+					 block .xip_image1.text };
+/****************************************
+ * XIP OTA1 Section config                *
+ ****************************************/
+keep { section FSymTab };
+keep { section VSymTab };
+keep { section .rti_fn* };
+define block .xip_image2.text with fixed order{ section .img2_custom_signature*,
+						section .text*,
+						section .rodata*,
+						section .debug_trace,
+						section CODE,
+						section Veneer, // object startup.o,
+						section FSymTab,
+						section VSymTab,
+						section .rti_fn*,
+						};
+place at start of  XIP_OTA1_region   {  readwrite, 
+					  block .xip_image2.text };
+/****************************************
+ * RDP Section config                    *
+ ****************************************/
+keep {	section .rdp.ram.text* };
+keep {	section .rdp.ram.data* };
+define block .RDP_RAM with fixed order {
+	section .rdp.ram.text*,
+	section .rdp.ram.data* };
+place at start of  RDP_RAM_region{
+	readwrite, 
+	block .RDP_RAM };
+define exported symbol __ram_start_table_start__= 0x10002000;	// use in rom
+define exported symbol __image1_validate_code__= 0x10002018;	// needed by ram code
+define exported symbol __rom_top_4k_start_= 0x1003F000;	// needed by ram code
+define exported symbol __flash_text_start__= 0x0800b020; // needed by ram code
+define exported symbol boot_export_symbol = 0x10002020;  

bsp/amebaz/project.eww

+<?xml version="1.0" encoding="iso-8859-1"?>
+
+<workspace>
+  <project>
+    <path>$WS_DIR$\project.ewp</path>
+  </project>
+  <batchBuild/>
+</workspace>
+
+

bsp/amebaz/rlx8711B-symbol-v02-img2_xip1.ld

+
+
+ENTRY(Reset_Handler)
+
+INCLUDE "export-rom_symbol_v01.txt"
+
+MEMORY
+{
+	ROM (rx) : 			ORIGIN = 0x00000000, LENGTH = 0x80000	/* ROM: 512k */
+	ROMBSS_RAM (rw)  : 		ORIGIN = 0x10000000, LENGTH = 0x2000	/* ROM BSS RAM: 8K */
+	BOOTLOADER_RAM (rwx)  : 	ORIGIN = 0x10002000, LENGTH = 0x3000	/* BOOT Loader RAM: 12K */
+	BD_RAM (rwx)  : 		ORIGIN = 0x10005000, LENGTH = 0x2B000	/* MAIN RAM: 228 */
+	MSP_RAM (wx)  : 		ORIGIN = 0x1003E000, LENGTH = 0x1000	/* MSP RAM: 4k */
+	RDP_RAM (wx)  : 		ORIGIN = 0x1003F000, LENGTH = 0xFF0	/* RDP RAM: 4k-0x10 */
+
+	XIPBOOT (rx)  :			ORIGIN = 0x08000000+0x20, LENGTH = 0x04000-0x20	/* XIPBOOT: 32k, 32 Bytes resvd for header*/
+	XIPSYS (r) :			ORIGIN = 0x08009000, LENGTH = 0x1000	/* XIPSYS: 4K system data in flash */
+	XIPCAL (r) :			ORIGIN = 0x0800A000, LENGTH = 0x1000	/* XIPCAL: 4K calibration data in flash */
+	XIP1 (rx)  : 			ORIGIN = 0x0800B000+0x20, LENGTH = 0x75000-0x20	/* XIP1: 468k, 32 Bytes resvd for header */
+	XIP2 (rx)  : 			ORIGIN = 0x08080000+0x20, LENGTH = 0x75000-0x20	/* XIP2: 468k, 32 Bytes resvd for header */
+}
+
+
+
+SECTIONS
+{
+	.rom.text : { } > ROM
+	.rom.rodata : { } > ROM
+	.hal.rom.bss : { } > ROMBSS_RAM
+
+	/* image1 entry, this section should in RAM and fixed address for ROM */
+	.ram_image1.entry :
+	{
+		__ram_image1_text_start__ = .;
+		__ram_start_table_start__ = .;
+		KEEP(*(SORT(.image1.entry.data*)))
+		__ram_start_table_end__ = .;
+
+		__image1_validate_code__ = .;
+		KEEP(*(.image1.validate.rodata*))
+		KEEP(*(.image1.export.symb*))
+	} > BOOTLOADER_RAM
+
+	/*  Add . to assign the start address of the section */ 
+	/*  to prevent the change of the start address by ld doing section alignment */  
+	.ram_image1.text . :
+	{
+		/* image1 text */
+		*(.boot.ram.text*)    
+		*(.boot.rodata*)
+	} > BOOTLOADER_RAM
+
+	.ram_image1.data . :
+	{
+		__ram_image1_data_start__ = .;
+		KEEP(*(.boot.ram.data*))
+		__ram_image1_data_end__ = .;
+	
+		__ram_image1_text_end__ = .;
+	} > BOOTLOADER_RAM
+
+	.ram_image1.bss . :
+	{
+		__image1_bss_start__ = .;
+		KEEP(*(.boot.ram.bss*))
+		KEEP(*(.boot.ram.end.bss*))
+		__image1_bss_end__ = .;
+	} > BOOTLOADER_RAM
+
+	.ram_image2.entry :
+	{
+		__ram_image2_text_start__ = .;
+		__image2_entry_func__ = .;
+		KEEP(*(SORT(.image2.entry.data*)))
+
+		__image2_validate_code__ = .;
+		KEEP(*(.image2.validate.rodata*)) 
+
+	} > BD_RAM
+
+	.ram_image2.text :
+	{
+	  KEEP(*(.image2.ram.text*))
+	} > BD_RAM
+
+	.ram_image2.data : 
+	{
+		__data_start__ = .;
+		*(.data*)
+		__data_end__ = .;
+		__ram_image2_text_end__ = .;
+		. = ALIGN(16);	
+	} > BD_RAM
+  
+	.ram_image2.bss :
+	{
+		__bss_start__ = .;
+		*(.bss*)
+		*(COMMON)
+	} > BD_RAM
+
+	.ram_image2.skb.bss :
+	{
+		*(.bdsram.data*)
+		__bss_end__ = .;
+	} > BD_RAM
+
+	.ram_heap.data : 
+	{
+		*(.bfsram.data*)
+		*(.heap.stdlib*)
+		. = ALIGN(4);
+		__rtt_heap_start = .;
+	} > BD_RAM
+
+	.ram_rdp.text : 
+	{
+		__rom_top_4k_start_ = .;
+		__rdp_text_start__ = .;
+		KEEP(*(.rdp.ram.text*))
+		KEEP(*(.rdp.ram.data*))
+		__rdp_text_end__ = .;
+		. = ALIGN(16);
+	
+	} > RDP_RAM
+
+	.xip_image1.text :
+	{
+		__flash_boot_text_start__ = .;
+
+		*(.flashboot.text*)
+
+		__flash_boot_text_end__ = .;
+
+		. = ALIGN(16);
+	} > XIPBOOT
+
+	.xip_image2.text : 
+	{
+		__flash_text_start__ = .;
+
+		*(.img2_custom_signature*)
+
+		*(.text*)    
+		*(.rodata*)
+		*(.debug_trace*)
+
+		__flash_text_end__ = .;
+	
+        /* section information for finsh shell */
+        . = ALIGN(4);
+        __fsymtab_start = .;
+        KEEP(*(FSymTab))
+        __fsymtab_end = .;
+        . = ALIGN(4);
+        __vsymtab_start = .;
+        KEEP(*(VSymTab))
+        __vsymtab_end = .;
+        . = ALIGN(4);
+
+        /* section information for initial. */
+        . = ALIGN(4);
+        __rt_init_start = .;
+        KEEP(*(SORT(.rti_fn*)))
+        __rt_init_end = .;
+        . = ALIGN(4);
+	
+		. = ALIGN (16);
+	} > XIP1
+}
+
+SECTIONS 
+{ 
+	/* Bootloader symbol list */  
+  boot_export_symbol = 0x10002020;  
+} 

bsp/amebaz/rlx8711B-symbol-v02-img2_xip2.ld

+
+
+ENTRY(Reset_Handler)
+
+INCLUDE "export-rom_symbol_v01.txt"
+
+MEMORY
+{
+	ROM (rx) : 			ORIGIN = 0x00000000, LENGTH = 0x80000	/* ROM: 512k */
+	ROMBSS_RAM (rw)  : 		ORIGIN = 0x10000000, LENGTH = 0x2000	/* ROM BSS RAM: 8K */
+	BOOTLOADER_RAM (rwx)  : 	ORIGIN = 0x10002000, LENGTH = 0x3000	/* BOOT Loader RAM: 12K */
+	BD_RAM (rwx)  : 		ORIGIN = 0x10005000, LENGTH = 0x2B000	/* MAIN RAM: 228 */
+	MSP_RAM (wx)  : 		ORIGIN = 0x1003E000, LENGTH = 0x1000	/* MSP RAM: 4k */
+	RDP_RAM (wx)  : 		ORIGIN = 0x1003F000, LENGTH = 0xFF0	/* RDP RAM: 4k-0x10 */
+
+	XIPBOOT (rx)  :			ORIGIN = 0x08000000+0x20, LENGTH = 0x04000-0x20	/* XIPBOOT: 32k, 32 Bytes resvd for header*/
+	XIPSYS (r) :			ORIGIN = 0x08009000, LENGTH = 0x1000	/* XIPSYS: 4K system data in flash */
+	XIPCAL (r) :			ORIGIN = 0x0800A000, LENGTH = 0x1000	/* XIPCAL: 4K calibration data in flash */
+	XIP1 (rx)  : 			ORIGIN = 0x0800B000+0x20, LENGTH = 0x75000-0x20	/* XIP1: 468k, 32 Bytes resvd for header */
+	XIP2 (rx)  : 			ORIGIN = 0x08080000+0x20, LENGTH = 0x75000-0x20	/* XIP2: 468k, 32 Bytes resvd for header */
+}
+
+
+
+SECTIONS
+{
+	.rom.text : { } > ROM
+	.rom.rodata : { } > ROM
+	.hal.rom.bss : { } > ROMBSS_RAM
+
+	/* image1 entry, this section should in RAM and fixed address for ROM */
+	.ram_image1.entry :
+	{
+		__ram_image1_text_start__ = .;
+		__ram_start_table_start__ = .;
+		KEEP(*(SORT(.image1.entry.data*)))
+		__ram_start_table_end__ = .;
+
+		__image1_validate_code__ = .;
+		KEEP(*(.image1.validate.rodata*))
+		KEEP(*(.image1.export.symb*))
+	} > BOOTLOADER_RAM
+
+	/*  Add . to assign the start address of the section */ 
+	/*  to prevent the change of the start address by ld doing section alignment */  
+	.ram_image1.text . :
+	{
+		/* image1 text */
+		*(.boot.ram.text*)    
+		*(.boot.rodata*)
+	} > BOOTLOADER_RAM
+
+	.ram_image1.data . :
+	{
+		__ram_image1_data_start__ = .;
+		KEEP(*(.boot.ram.data*))
+		__ram_image1_data_end__ = .;
+	
+		__ram_image1_text_end__ = .;
+	} > BOOTLOADER_RAM
+
+	.ram_image1.bss . :
+	{
+		__image1_bss_start__ = .;
+		KEEP(*(.boot.ram.bss*))
+		KEEP(*(.boot.ram.end.bss*))
+		__image1_bss_end__ = .;
+	} > BOOTLOADER_RAM
+
+	.ram_image2.entry :
+	{
+		__ram_image2_text_start__ = .;
+		__image2_entry_func__ = .;
+		KEEP(*(SORT(.image2.entry.data*)))
+
+		__image2_validate_code__ = .;
+		KEEP(*(.image2.validate.rodata*)) 
+
+	} > BD_RAM
+
+	.ram_image2.text :
+	{
+	  KEEP(*(.image2.ram.text*))
+	} > BD_RAM
+
+	.ram_image2.data : 
+	{
+		__data_start__ = .;
+		*(.data*)
+		__data_end__ = .;
+		__ram_image2_text_end__ = .;
+		. = ALIGN(16);	
+	} > BD_RAM
+  
+	.ram_image2.bss :
+	{
+		__bss_start__ = .;
+		*(.bss*)
+		*(COMMON)
+	} > BD_RAM
+
+	.ram_image2.skb.bss :
+	{
+		*(.bdsram.data*)
+		__bss_end__ = .;
+	} > BD_RAM
+
+	.ram_heap.data : 
+	{
+		*(.bfsram.data*)
+		*(.heap.stdlib*)
+		. = ALIGN(4);
+		__rtt_heap_start = .;
+	} > BD_RAM
+
+	.ram_rdp.text : 
+	{
+		__rom_top_4k_start_ = .;
+		__rdp_text_start__ = .;
+		KEEP(*(.rdp.ram.text*))
+		KEEP(*(.rdp.ram.data*))
+		__rdp_text_end__ = .;
+		. = ALIGN(16);
+	
+	} > RDP_RAM
+
+	.xip_image1.text :
+	{
+		__flash_boot_text_start__ = .;
+
+		*(.flashboot.text*)
+
+		__flash_boot_text_end__ = .;
+
+		. = ALIGN(16);
+	} > XIPBOOT
+
+	.xip_image2.text : 
+	{
+		__flash_text_start__ = .;
+
+		*(.img2_custom_signature*)
+
+		*(.text*)    
+		*(.rodata*)
+		*(.debug_trace*)
+
+		__flash_text_end__ = .;
+	
+        /* section information for finsh shell */
+        . = ALIGN(4);
+        __fsymtab_start = .;
+        KEEP(*(FSymTab))
+        __fsymtab_end = .;
+        . = ALIGN(4);
+        __vsymtab_start = .;
+        KEEP(*(VSymTab))
+        __vsymtab_end = .;
+        . = ALIGN(4);
+
+        /* section information for initial. */
+        . = ALIGN(4);
+        __rt_init_start = .;
+        KEEP(*(SORT(.rti_fn*)))
+        __rt_init_end = .;
+        . = ALIGN(4);
+		. = ALIGN (16);
+	} > XIP2
+}
+
+SECTIONS 
+{ 
+	/* Bootloader symbol list */  
+  boot_export_symbol = 0x10002020;  
+} 

bsp/amebaz/rtconfig.h

+#ifndef RT_CONFIG_H__
+#define RT_CONFIG_H__
+
+/* Automatically generated file; DO NOT EDIT. */
+/* RT-Thread Configuration */
+
+/* RT-Thread Kernel */
+
+#define RT_NAME_MAX 8
+#define RT_ALIGN_SIZE 4
+#define RT_THREAD_PRIORITY_32
+#define RT_THREAD_PRIORITY_MAX 32
+#define RT_TICK_PER_SECOND 1000
+#define RT_DEBUG
+#define RT_USING_OVERFLOW_CHECK
+#define RT_DEBUG_INIT 0
+#define RT_DEBUG_THREAD 0
+#define RT_USING_HOOK
+#define IDLE_THREAD_STACK_SIZE 256
+#define RT_USING_TIMER_SOFT
+#define RT_TIMER_THREAD_PRIO 4
+#define RT_TIMER_THREAD_STACK_SIZE 512
+
+/* Inter-Thread communication */
+
+#define RT_USING_SEMAPHORE
+#define RT_USING_MUTEX
+#define RT_USING_EVENT
+#define RT_USING_MAILBOX
+#define RT_USING_MESSAGEQUEUE
+
+/* Memory Management */
+
+#define RT_USING_MEMPOOL
+#define RT_USING_SMALL_MEM
+#define RT_USING_HEAP
+
+/* Kernel Device Object */
+
+#define RT_USING_DEVICE
+#define RT_USING_CONSOLE
+#define RT_CONSOLEBUF_SIZE 128
+#define RT_CONSOLE_DEVICE_NAME "dbg"
+
+/* RT-Thread Components */
+
+#define RT_USING_COMPONENTS_INIT
+
+/* C++ features */
+
+
+/* Command shell */
+
+#define RT_USING_FINSH
+#define FINSH_THREAD_NAME "tshell"
+#define FINSH_USING_HISTORY
+#define FINSH_HISTORY_LINES 5
+#define FINSH_USING_SYMTAB
+#define FINSH_USING_DESCRIPTION
+#define FINSH_THREAD_PRIORITY 20
+#define FINSH_THREAD_STACK_SIZE 4096
+#define FINSH_CMD_SIZE 80
+#define FINSH_USING_MSH
+#define FINSH_USING_MSH_DEFAULT
+#define FINSH_ARG_MAX 10
+
+/* Device virtual file system */
+
+
+/* Device Drivers */
+
+#define RT_USING_DEVICE_IPC
+#define RT_USING_SERIAL
+#define RT_USING_PIN
+#define RT_USING_WIFI
+#define RT_USING_WLAN_STA
+#define RT_USING_WLAN_AP
+#define WIFI_DEVICE_STA_NAME "w0"
+#define WIFI_DEVICE_AP_NAME "ap"
+
+/* Using USB */
+
+
+/* POSIX layer and C standard library */
+
+#define RT_USING_LIBC
+
+/* Network stack */
+
+/* light weight TCP/IP stack */
+
+#define RT_USING_LWIP
+#define RT_USING_LWIP141
+#define RT_LWIP_IGMP
+#define RT_LWIP_ICMP
+#define RT_LWIP_DNS
+#define RT_LWIP_DHCP
+#define IP_SOF_BROADCAST 1
+#define IP_SOF_BROADCAST_RECV 1
+
+/* Static IPv4 Address */
+
+#define RT_LWIP_IPADDR "192.168.1.30"
+#define RT_LWIP_GWADDR "192.168.1.1"
+#define RT_LWIP_MSKADDR "255.255.255.0"
+#define RT_LWIP_UDP
+#define RT_LWIP_TCP
+#define RT_MEMP_NUM_NETCONN 8
+#define RT_LWIP_PBUF_NUM 16
+#define RT_LWIP_RAW_PCB_NUM 4
+#define RT_LWIP_UDP_PCB_NUM 4
+#define RT_LWIP_TCP_PCB_NUM 4
+#define RT_LWIP_TCP_SEG_NUM 40
+#define RT_LWIP_TCP_SND_BUF 8196
+#define RT_LWIP_TCP_WND 8196
+#define RT_LWIP_TCPTHREAD_PRIORITY 10
+#define RT_LWIP_TCPTHREAD_MBOX_SIZE 8
+#define RT_LWIP_TCPTHREAD_STACKSIZE 1024
+#define RT_LWIP_ETHTHREAD_PRIORITY 12
+#define RT_LWIP_ETHTHREAD_STACKSIZE 1024
+#define RT_LWIP_ETHTHREAD_MBOX_SIZE 8
+#define LWIP_NETIF_STATUS_CALLBACK 1
+#define SO_REUSE 1
+#define LWIP_SO_RCVTIMEO 1
+#define LWIP_SO_SNDTIMEO 1
+#define LWIP_SO_RCVBUF 1
+#define LWIP_NETIF_LOOPBACK 0
+
+/* Modbus master and slave stack */
+
+
+/* VBUS(Virtual Software BUS) */
+
+
+/* Utilities */
+
+
+/* RT-Thread online packages */
+
+/* IoT - internet of things */
+
+
+/* Wi-Fi */
+
+/* Marvell WiFi */
+
+
+/* Wiced WiFi */
+
+
+/* security packages */
+
+
+/* language packages */
+
+
+/* multimedia packages */
+
+
+/* tools packages */
+
+
+/* system packages */
+
+
+/* peripheral libraries and drivers */
+
+#define PKG_USING_REALTEK_AMEBA
+#define PKG_USING_REALTEK_AMEBA_LATEST_VERSION
+
+/* miscellaneous packages */
+
+
+/* sample package */
+
+
+/* example package: hello */
+
+
+/* Env config */
+
+#define RT_USING_UART0
+
+#endif

bsp/amebaz/rtconfig.py

+import os
+
+# toolchains options
+ARCH='arm'
+CPU='cortex-m4'
+CROSS_TOOL='gcc'
+
+if os.getenv('RTT_CC'):
+    CROSS_TOOL = os.getenv('RTT_CC')
+if os.getenv('RTT_ROOT'):
+    RTT_ROOT = os.getenv('RTT_ROOT')
+
+# cross_tool provides the cross compiler
+# EXEC_PATH is the compiler execute path, for example, CodeSourcery, Keil MDK, IAR
+if  CROSS_TOOL == 'gcc':
+    PLATFORM 	= 'gcc'
+    EXEC_PATH 	= r'/opt/gcc-arm-none-eabi-5_4-2016q3/bin'
+else:
+    print 'Please make sure your toolchains is GNU GCC!'
+    exit(0)
+
+if os.getenv('RTT_EXEC_PATH'):
+	EXEC_PATH = os.getenv('RTT_EXEC_PATH')
+
+BUILD = 'debug'
+
+if PLATFORM == 'gcc':
+    # toolchains
+    PREFIX = 'arm-none-eabi-'
+    CC = PREFIX + 'gcc'
+    AS = PREFIX + 'gcc'
+    AR = PREFIX + 'ar'
+    CXX = PREFIX + 'g++'
+    LINK = PREFIX + 'gcc'
+    TARGET_EXT = 'axf'
+    SIZE = PREFIX + 'size'
+    OBJDUMP = PREFIX + 'objdump'
+    OBJCPY = PREFIX + 'objcopy'
+    NM = PREFIX + 'nm'
+
+    DEVICE = ' -DM3 -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=hard -ffunction-sections -fdata-sections'
+    CFLAGS = DEVICE + ' -g2 -w -O2 -Wno-pointer-sign -fno-common -fmessage-length=0  -ffunction-sections -fdata-sections -fomit-frame-pointer -fno-short-enums -DF_CPU=166000000L -std=gnu99 -fsigned-char'
+    AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp -Wa,-mimplicit-it=thumb '
+    LFLAGS = DEVICE + ' -lm -lgcc -lc' + ' -g --specs=nano.specs -nostartfiles -Wl,-Map=rtthread.map -Os -Wl,--gc-sections -Wl,--cref -Wl,--entry=Reset_Handler -Wl,--no-enum-size-warning -Wl,--no-wchar-size-warning -T./rlx8711B-symbol-v02-img2_xip1.ld'
+    LFLAGS += ' -Wl,-wrap,rtl_printf'
+
+    CPATH = ''
+    LPATH = ''
+
+    if BUILD == 'debug':
+        CFLAGS += ' -O0 -gdwarf-2'
+        AFLAGS += ' -gdwarf-2'
+    else:
+        CFLAGS += ' -O2'
+
+    POST_ACTION =  OBJCPY + ' -j .ram_image2.entry -j .ram_image2.data -j .ram_image2.bss -j .ram_image2.skb.bss -j .ram_heap.data -Obinary rtthread.axf ram_2.r.bin \n' \
+                 + OBJCPY + ' -j .xip_image2.text -Obinary rtthread.axf xip_image2.bin \n' \
+                 + OBJCPY + ' -j .ram_rdp.text -Obinary rtthread.axf rdp.bin \n'
+
+    POST_ACTION += 'python gen_bin.py'
+
+    M_CFLAGS = CFLAGS + ' -mlong-calls  -Dsourcerygxx -O0 -fPIC '
+    M_LFLAGS = DEVICE + ' -Wl,-z,max-page-size=0x4 -shared -fPIC -e main -nostdlib'
+	
+elif PLATFORM == 'armcc':
+    # toolchains
+    CC = 'armcc'
+    AS = 'armasm'
+    AR = 'armar'
+    LINK = 'armlink'
+    TARGET_EXT = 'axf'
+
+    DEVICE = ' --cpu=cortex-m4.fp'
+    CFLAGS = DEVICE + ' --apcs=interwork -DSTM32F429_439xx'
+    AFLAGS = DEVICE
+    LFLAGS = DEVICE + ' --info sizes --info totals --info unused --info veneers --list rtthread-stm32.map --scatter stm32f429_flash.sct'
+
+    CFLAGS += ' -I' + EXEC_PATH + '/ARM/RV31/INC'
+    LFLAGS += ' --libpath ' + EXEC_PATH + '/ARM/RV31/LIB'
+
+    EXEC_PATH += '/arm/bin40/'
+
+    if BUILD == 'debug':
+        CFLAGS += ' -g -O0'
+        AFLAGS += ' -g'
+    else:
+        CFLAGS += ' -O2'
+
+    POST_ACTION = 'fromelf --bin $TARGET --output rtthread.bin \nfromelf -z $TARGET'
+
+elif PLATFORM == 'iar':
+    # toolchains
+    CC = 'iccarm'
+    AS = 'iasmarm'
+    AR = 'iarchive'
+    LINK = 'ilinkarm'
+    TARGET_EXT = 'out'
+
+    DEVICE = ' -D USE_STDPERIPH_DRIVER' + ' -D STM32F10X_HD'
+
+    CFLAGS = DEVICE
+    CFLAGS += ' --diag_suppress Pa050'
+    CFLAGS += ' --no_cse'
+    CFLAGS += ' --no_unroll'
+    CFLAGS += ' --no_inline'
+    CFLAGS += ' --no_code_motion'
+    CFLAGS += ' --no_tbaa'
+    CFLAGS += ' --no_clustering'
+    CFLAGS += ' --no_scheduling'
+    CFLAGS += ' --debug'
+    CFLAGS += ' --endian=little'
+    CFLAGS += ' --cpu=Cortex-M4'
+    CFLAGS += ' -e'
+    CFLAGS += ' --fpu=None'
+    CFLAGS += ' --dlib_config "' + EXEC_PATH + '/arm/INC/c/DLib_Config_Normal.h"'
+    CFLAGS += ' -Ol'
+    CFLAGS += ' --use_c++_inline'
+
+    AFLAGS = ''
+    AFLAGS += ' -s+'
+    AFLAGS += ' -w+'
+    AFLAGS += ' -r'
+    AFLAGS += ' --cpu Cortex-M4'
+    AFLAGS += ' --fpu None'
+
+    LFLAGS = ' --config stm32f429_flash.icf'
+    LFLAGS += ' --redirect _Printf=_PrintfTiny'
+    LFLAGS += ' --redirect _Scanf=_ScanfSmall'
+    LFLAGS += ' --entry __iar_program_start'
+
+    EXEC_PATH = EXEC_PATH + '/arm/bin/'
+    POST_ACTION = ''

bsp/amebaz/tmp.board

+<?xml version="1.0" encoding="iso-8859-1"?> 
+  
+<flash_board> 
+  <pass>    
+    <range>CODE 0x8000000 0x8004fff</range>    
+    <loader>$PROJ_DIR$\packages\realtek_ameba\sdk-ameba-v4.0b_without_NDA_GCC_V1.0.0\component\soc\realtek\8711b\misc\iar_utility\common\flashloader\FlashRTL8195aMP.flash</loader>    
+    <abs_offset>0x00000000</abs_offset>    
+  </pass>    
+  <pass> 
+    <range>CODE 0x800b020 0x807ffff</range> 
+    <loader>$PROJ_DIR$\packages\realtek_ameba\sdk-ameba-v4.0b_without_NDA_GCC_V1.0.0\component\soc\realtek\8711b\misc\iar_utility\common\flashloader\FlashRTL8195aMP.flash</loader>    
+    <abs_offset>0xb020</abs_offset>  
+  </pass> 
+  <pass>    
+    <range>CODE 0x10005000 0x10005A43</range>    
+    <loader>$PROJ_DIR$\packages\realtek_ameba\sdk-ameba-v4.0b_without_NDA_GCC_V1.0.0\component\soc\realtek\8711b\misc\iar_utility\common\flashloader\FlashRTL8195aMP.flash</loader>      
+    <abs_offset>0xb000</abs_offset>    
+    <args>--concat</args>    
+  </pass>    
+  <ignore>CODE 0x10005a44 0x1003dfff</ignore> 
+</flash_board>