[feat][examples] add some samples

examples/bflb_block_pool/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.15)
+
+include(proj.conf)
+
+find_package(bouffalo_sdk REQUIRED HINTS $ENV{BL_SDK_BASE})
+
+sdk_add_include_directories(.)
+
+sdk_set_main_file(main.c)
+
+project(bflb_block_pool)

examples/bflb_block_pool/FreeRTOSConfig.h

@@ -0,0 +1,127 @@
+/*
+ * FreeRTOS Kernel V10.2.1
+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://www.FreeRTOS.org
+ * http://aws.amazon.com/freertos
+ *
+ * 1 tab == 4 spaces!
+ */
+
+#ifndef FREERTOS_CONFIG_H
+#define FREERTOS_CONFIG_H
+
+/*-----------------------------------------------------------
+ * Application specific definitions.
+ *
+ * These definitions should be adjusted for your particular hardware and
+ * application requirements.
+ *
+ * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
+ * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
+ *
+ * See http://www.freertos.org/a00110.html.
+ *----------------------------------------------------------*/
+#include "stdio.h"
+
+#ifdef BL702
+#define configMTIME_BASE_ADDRESS    (0x02000000UL + 0xBFF8UL)
+#define configMTIMECMP_BASE_ADDRESS (0x02000000UL + 0x4000UL)
+#else
+#define configMTIME_BASE_ADDRESS    (0xE0000000UL + 0xBFF8UL)
+#define configMTIMECMP_BASE_ADDRESS (0xE0000000UL + 0x4000UL)
+#endif
+
+// #define configSUPPORT_STATIC_ALLOCATION         1
+#define configUSE_PREEMPTION                    1
+#define configUSE_IDLE_HOOK                     0
+#define configUSE_TICK_HOOK                     0
+#define configCPU_CLOCK_HZ                      ((uint32_t)(1 * 1000 * 1000))
+#define configTICK_RATE_HZ                      ((TickType_t)1000)
+#define configMAX_PRIORITIES                    (7)
+#define configMINIMAL_STACK_SIZE                ((unsigned short)128) /* Only needs to be this high as some demo tasks also use this constant.  In production only the idle task would use this. */
+#define configTOTAL_HEAP_SIZE                   ((size_t)12 * 1024)
+#define configMAX_TASK_NAME_LEN                 (16)
+#define configUSE_TRACE_FACILITY                1
+#define configUSE_STATS_FORMATTING_FUNCTIONS    1
+#define configUSE_16_BIT_TICKS                  0
+#define configIDLE_SHOULD_YIELD                 0
+#define configUSE_MUTEXES                       1
+#define configQUEUE_REGISTRY_SIZE               8
+#define configCHECK_FOR_STACK_OVERFLOW          2
+#define configUSE_RECURSIVE_MUTEXES             1
+#define configUSE_MALLOC_FAILED_HOOK            1
+#define configUSE_APPLICATION_TASK_TAG          0
+#define configUSE_COUNTING_SEMAPHORES           1
+#define configGENERATE_RUN_TIME_STATS           0
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1
+#define configUSE_TICKLESS_IDLE                 0
+
+/* Co-routine definitions. */
+#define configUSE_CO_ROUTINES           0
+#define configMAX_CO_ROUTINE_PRIORITIES (2)
+
+/* Software timer definitions. */
+#define configUSE_TIMERS             1
+#define configTIMER_TASK_PRIORITY    (configMAX_PRIORITIES - 1)
+#define configTIMER_QUEUE_LENGTH     4
+#define configTIMER_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE)
+
+/* Task priorities.  Allow these to be overridden. */
+#ifndef uartPRIMARY_PRIORITY
+#define uartPRIMARY_PRIORITY (configMAX_PRIORITIES - 3)
+#endif
+
+/* Set the following definitions to 1 to include the API function, or zero
+to exclude the API function. */
+#define INCLUDE_vTaskPrioritySet         1
+#define INCLUDE_uxTaskPriorityGet        1
+#define INCLUDE_vTaskDelete              1
+#define INCLUDE_vTaskCleanUpResources    1
+#define INCLUDE_vTaskSuspend             1
+#define INCLUDE_vTaskDelayUntil          1
+#define INCLUDE_vTaskDelay               1
+#define INCLUDE_eTaskGetState            1
+#define INCLUDE_xTimerPendFunctionCall   1
+#define INCLUDE_xTaskAbortDelay          1
+#define INCLUDE_xTaskGetHandle           1
+#define INCLUDE_xSemaphoreGetMutexHolder 1
+
+/* Normal assert() semantics without relying on the provision of an assert.h
+header file. */
+void vApplicationMallocFailedHook(void);
+void vAssertCalled(void);
+#define configASSERT(x)                        \
+    if ((x) == 0) {                            \
+        printf("file [%s]\r\n", __FILE__);     \
+        printf("func [%s]\r\n", __FUNCTION__); \
+        printf("line [%d]\r\n", __LINE__);     \
+        printf("%s\r\n", (const char *)(#x));  \
+        vAssertCalled();                       \
+    }
+
+#if (configUSE_TICKLESS_IDLE != 0)
+void vApplicationSleep(uint32_t xExpectedIdleTime);
+#define portSUPPRESS_TICKS_AND_SLEEP(xExpectedIdleTime) vApplicationSleep(xExpectedIdleTime)
+#endif
+
+// #define portUSING_MPU_WRAPPERS
+
+#endif /* FREERTOS_CONFIG_H */

examples/bflb_block_pool/Makefile

@@ -0,0 +1,13 @@
+SDK_DEMO_PATH ?= .
+BL_SDK_BASE ?= $(SDK_DEMO_PATH)/../..
+
+export BL_SDK_BASE
+
+CHIP ?= bl616
+BOARD ?= bl616dk
+CROSS_COMPILE ?= riscv64-unknown-elf-
+
+# add custom cmake definition
+#cmake_definition+=-Dxxx=sss
+
+include $(BL_SDK_BASE)/project.build

examples/bflb_block_pool/main.c

@@ -0,0 +1,158 @@
+#include "bflb_mtimer.h"
+#include <FreeRTOS.h>
+#include "semphr.h"
+#include "log.h"
+#include "bflb_block_pool.h"
+#include "stdlib.h"
+
+extern void board_init(void);
+
+#define BLK_COUNT 16
+#define BLK_SIZE  128
+
+static bflb_block_pool_t block_pool;
+static bflb_block_pool_node_t block_nodes[BLK_COUNT];
+static uint8_t block_pool_memory[BLK_COUNT * BLK_SIZE];
+
+static uint8_t freertos_heap[configTOTAL_HEAP_SIZE];
+
+static HeapRegion_t xHeapRegions[] = {
+    { (uint8_t *)freertos_heap, 0 },
+    { NULL, 0 }, /* Terminates the array. */
+    { NULL, 0 }  /* Terminates the array. */
+};
+
+static TaskHandle_t consumer_handle;
+static TaskHandle_t producer_handle;
+
+QueueHandle_t queue;
+
+static void consumer_task(void *pvParameters)
+{
+    uint8_t time = 200;
+
+    LOG_I("Consumer task enter \r\n");
+    vTaskDelay(1000);
+    LOG_I("Consumer task start \r\n");
+
+    void *block_ptr;
+
+    while (1) {
+        time += 20;
+        if (pdTRUE != xQueueReceive(queue, &block_ptr, portMAX_DELAY)) {
+            LOG_E("queue recv faild\r\n");
+        } else {
+            LOG_I("Consumer recv << %s\r\n", (char *)block_ptr);
+            if (bflb_block_pool_free(&block_pool, block_ptr)) {
+                LOG_E("free block heap faild\r\n");
+            }
+        }
+
+        vTaskDelay(time);
+    }
+
+    vTaskDelete(NULL);
+}
+
+static void producer_task(void *pvParameters)
+{
+    uint8_t time = 100;
+    uint32_t cnt = 0;
+
+    LOG_I("Producer task enter \r\n");
+    vTaskDelay(1000);
+    LOG_I("Producer task start \r\n");
+
+    void *block_ptr;
+    uint32_t free;
+    uint32_t busy;
+
+    while (1) {
+        time = rand() % 64;
+
+        if (bflb_block_pool_alloc_wait(&block_pool, &block_ptr, 100)) {
+            LOG_W("alloc block pool faild\r\n");
+
+            bflb_block_pool_get_info(&block_pool, &busy, &free);
+            LOG_W("free [%4ld] busy [%4ld]\r\n", free, busy);
+        } else {
+            bflb_block_pool_get_info(&block_pool, &busy, &free);
+            LOG_I("free [%4ld] busy [%4ld]\r\n", free, busy);
+
+            cnt++;
+            sprintf((char *)block_ptr, "this is [%ld] info in block [%08lx]\r\n", cnt, (uint32_t)block_ptr);
+            LOG_I("Producer send >> %s\r\n", (char *)block_ptr);
+            if (pdTRUE != xQueueSend(queue, (void *)&block_ptr, 1000)) {
+                LOG_E("queue send faild\r\n");
+            }
+        }
+
+        vTaskDelay(time);
+    }
+
+    vTaskDelete(NULL);
+}
+
+SemaphoreHandle_t sem;
+SemaphoreHandle_t mtx;
+
+static int block_pool_semaphore_get(uint32_t wait)
+{
+    if (pdTRUE != xSemaphoreTake(sem, wait)) {
+        return -1;
+    }
+    return 0;
+}
+static int block_pool_semaphore_put(void)
+{
+    if (pdTRUE != xSemaphoreGive(sem)) {
+        return -1;
+    }
+    return 0;
+}
+static int block_pool_mutex_get(uint32_t wait)
+{
+    if (pdTRUE != xSemaphoreTake(mtx, wait)) {
+        return -1;
+    }
+    return 0;
+}
+static int block_pool_mutex_put(void)
+{
+    if (pdTRUE != xSemaphoreGive(mtx)) {
+        return -1;
+    }
+    return 0;
+}
+
+int main(void)
+{
+    board_init();
+    xHeapRegions[0].xSizeInBytes = configTOTAL_HEAP_SIZE;
+    vPortDefineHeapRegions(xHeapRegions);
+
+    configASSERT((configMAX_PRIORITIES > 4));
+
+    queue = xQueueCreate(BLK_COUNT, sizeof(void *));
+    _ASSERT_PARAM(NULL != queue);
+
+    sem = xSemaphoreCreateCounting(BLK_COUNT, BLK_COUNT);
+    _ASSERT_PARAM(NULL != sem);
+
+    mtx = xSemaphoreCreateMutex();
+    _ASSERT_PARAM(NULL != sem);
+
+    _ASSERT_FUNC(0 == bflb_block_pool_create(&block_pool, block_nodes, block_pool_memory, BLK_COUNT, BLK_SIZE));
+    _ASSERT_FUNC(0 == bflb_block_pool_register_mutex(&block_pool, block_pool_mutex_get, block_pool_mutex_put));
+    _ASSERT_FUNC(0 == bflb_block_pool_register_semaphore(&block_pool, block_pool_semaphore_get, block_pool_semaphore_put));
+
+    LOG_I("[OS] Starting consumer task...\r\n");
+    xTaskCreate(consumer_task, (char *)"consumer_task", 512, NULL, configMAX_PRIORITIES - 2, &consumer_handle);
+    LOG_I("[OS] Starting producer task...\r\n");
+    xTaskCreate(producer_task, (char *)"producer_task", 512, NULL, configMAX_PRIORITIES - 3, &producer_handle);
+
+    vTaskStartScheduler();
+
+    while (1) {
+    }
+}

examples/bflb_block_pool/proj.conf

@@ -0,0 +1,6 @@
+set(CONFIG_VLIBC 1)
+set(CONFIG_BFLOG 1)
+
+set(CONFIG_FREERTOS 1)
+
+set(CONFIG_BFLB_BLOCK_POOL_DEBUG 1)

examples/coremark_v1.01/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.15)
+
+include(proj.conf)
+
+find_package(bouffalo_sdk REQUIRED HINTS $ENV{BL_SDK_BASE})
+
+target_sources(app PRIVATE core_list_join.c
+               core_main.c
+               core_matrix.c
+               core_portme.c
+               core_state.c
+               core_util.c)
+
+sdk_set_main_file(main.c)
+
+sdk_add_compile_definitions(
+    -DITERATIONS=0
+    -DCORE_DEBUG=0
+    -DCOMPILER_REQUIRES_SORT_RETURN=0
+    -DVALIDATION_RUN=0
+    -DPROFILE_RUN=0
+    -DPERFORMANCE_RUN=1
+)
+
+sdk_add_compile_options(
+    # -O3
+    -falign-functions=2
+    # -fno-code-hoisting
+    # -finline-limit=500
+    # -funroll-all-loops
+)
+
+project(coremark)

examples/coremark_v1.01/LICENSE.md

@@ -0,0 +1,44 @@
+# COREMARK® ACCEPTABLE USE AGREEMENT 
+
+This ACCEPTABLE USE AGREEMENT (this “Agreement”) is offered by Embedded Microprocessor Benchmark Consortium, a California nonprofit corporation (“Licensor”), to users of its CoreMark® software (“Licensee”) exclusively on the following terms.
+
+Licensor offers benchmarking software (“Software”) pursuant to an open source license, but carefully controls use of its benchmarks and their associated goodwill. Licensor has registered its trademark in one of the benchmarks available through the Software, COREMARK, Ser. No. 85/487,290; Reg. No. 4,179,307 (the “Trademark”), and promotes the use of a standard metric as a benchmark for assessing the performance of embedded systems. Solely on the terms described herein, Licensee may use and display the Trademark in connection with the generation of data regarding measurement and analysis of computer and embedded system benchmarking via the Software (the “Licensed Use”).
+
+## Article 1 – License Grant.
+1.1.	License. Subject to the terms and conditions of this Agreement, Licensor hereby grants to Licensee, and Licensee hereby accepts from Licensor, a personal, non-exclusive, royalty-free, revocable right and license to use and display the Trademark during the term of this Agreement (the “Term”), solely and exclusively in connection with the Licensed Use. During the Term, Licensee (i) shall not modify or otherwise create derivative works of the Trademark, and (ii) may use the Trademark only to the extent permitted under this License. Neither Licensee nor any affiliate or agent thereof shall otherwise use the Trademark without the prior express written consent of Licensor, which may be withheld in its sole and absolute discretion. All rights not expressly granted to Licensee hereunder shall remain the exclusive property of Licensor.
+
+1.2.	Modifications to the Software.  Licensee shall not use the Trademark in connection with any use of a modified, derivative, or otherwise altered copy of the Software.
+
+1.3.	Licensor’s Use. Nothing in this Agreement shall preclude Licensor or any of its successors or assigns from using or permitting other entities to use the Trademark, whether or not such entity directly or indirectly competes or conflicts with Licensee’s Licensed Use in any manner. 
+
+1.4.	Term and Termination.  This Agreement is perpetual unless terminated by either of the parties.  Licensee may terminate this Agreement for convenience, without cause or liability, for any reason or for no reason whatsoever, upon ten (10) business days written notice. Licensor may terminate this Agreement effective immediately upon notice of breach.  Upon termination, Licensee shall immediately remove all implementations of the Trademark from the Licensed Use, and delete all digitals files and records of all materials related to the Trademark. 
+
+## Article 2 – Ownership.
+2.1.	Ownership. Licensee acknowledges and agrees that Licensor is the owner of all right, title, and interest in and to the Trademark, and all such right, title, and interest shall remain with Licensor. Licensee shall not contest, dispute, challenge, oppose, or seek to cancel Licensor’s right, title, and interest in and to the Trademark. Licensee shall not prosecute any application for registration of the Trademark. Licensee shall display appropriate notices regarding ownership of the Trademark in connection with the Licensed Use.
+
+2.2.	Goodwill. Licensee acknowledges that Licensee shall not acquire any right, title, or interest in the Trademark by virtue of this Agreement other than the license granted hereunder, and disclaims any such right, title, interest, or ownership. All goodwill and reputation generated by Licensee’s use of the Trademark shall inure to the exclusive benefit of Licensor. Licensee shall not by any act or omission use the Trademark in any manner that disparages or reflects adversely on Licensor or its Licensed Use or reputation. Licensee shall not take any action that would interfere with or prejudice Licensor’s ownership or registration of the Trademark, the validity of the Trademark or the validity of the license granted by this Agreement. If Licensor determines and notifies Licensee that any act taken in connection with the Licensed Use (i) is inaccurate, unlawful or offensive to good taste; (ii) fails to provide for proper trademark notices, or (iii) otherwise violates Licensee’s obligations under this Agreement, the license granted under this Agreement shall terminate. 
+
+## Article 3 – Indemnification. 
+3.1.	Indemnification Generally.  Licensee agrees to indemnify, defend, and hold harmless (collectively “indemnify” or “indemnification”) Licensor, including Licensor’s members, managers, officers, and employees (collectively “Related Persons”), from and against, and pay or reimburse Licensor and such Related Persons for, any and all third-party actions, claims, demands, proceedings, investigations, inquiries (collectively, “Claims”), and any and all liabilities, obligations, fines, deficiencies, costs, expenses, royalties, losses, and damages (including reasonable outside counsel fees and expenses) associated with such Claims, to the extent that such Claim arises out of (i) Licensee’s material breach of this Agreement, or (ii) any allegation(s) that Licensee’s actions infringe or violate any third-party intellectual property right, including without limitation, any U.S. copyright, patent, or trademark, or are otherwise found to be tortious or criminal (whether or not such indemnified person is a named party in a legal proceeding).  
+
+3.2.	Notice and Defense of Claims. Licensor shall promptly notify Licensee of any Claim for which indemnification is sought, following actual knowledge of such Claim, provided however that the failure to give such notice shall not relieve Licensee of its obligations hereunder except to the extent that Licensee is materially prejudiced by such failure. In the event that any third-party Claim is brought, Licensee shall have the right and option to undertake and control the defense of such action with counsel of its choice, provided however that (i) Licensor at its own expense may participate and appear on an equal footing with Licensee in the defense of any such Claim, (ii) Licensor may undertake and control such defense in the event of the material failure of Licensee to undertake and control the same; and (iii) the defense of any Claim relating to the intellectual property rights of Licensor or its licensors and any related counterclaims shall be solely controlled by Licensor with counsel of its choice. Licensee shall not consent to judgment or concede or settle or compromise any Claim without the prior written approval of Licensor (whose approval shall not be unreasonably withheld), unless such concession or settlement or compromise includes a full and unconditional release of Licensor and any applicable Related Persons from all liabilities in respect of such Claim.
+
+## Article 4 – Miscellaneous.
+4.1.	Relationship of the Parties. This Agreement does not create a partnership, franchise, joint venture, agency, fiduciary, or employment relationship between the parties. 
+
+4.2.	No Third-Party Beneficiaries. Except for the rights of Related Persons under Article 3 (Indemnification), there are no third-party beneficiaries to this Agreement.
+
+4.3.	Assignment. Licensee’s rights hereunder are non-assignable, and may not be sublicensed. 
+
+4.4.	Equitable Relief. Licensee acknowledges that the remedies available at law for any breach of this Agreement will, by their nature, be inadequate.  Accordingly, Licensor may obtain injunctive relief or other equitable relief to restrain a breach or threatened breach of this Agreement or to specifically enforce this Agreement, without proving that any monetary damages have been sustained, and without the requirement of posting of a bond prior to obtaining such equitable relief.
+
+4.5.	Governing Law. This Agreement will be interpreted, construed, and enforced in all respects in accordance with the laws of the State of California, without reference to its conflict of law principles. 
+
+4.6.	Attorneys’ Fees.  If any legal action, arbitration or other proceeding is brought for the enforcement of this Agreement, or because of an alleged dispute, breach, default, or misrepresentation in connection with any of the provisions of this Agreement, the successful or prevailing party shall be entitled to recover its reasonable attorneys’ fees and other reasonable costs incurred in that action or proceeding, in addition to any other relief to which it may be entitled.
+
+4.7.	Amendment; Waiver.  This Agreement may not be amended, nor may any rights under it be waived, except in writing by Licensor.
+
+4.8.	Severability. If any provision of this Agreement is held by a court of competent jurisdiction to be contrary to law, the provision shall be modified by the court and interpreted so as best to accomplish the objectives of the original provision to the fullest extent 
+permitted by law, and the remaining provisions of this Agreement shall remain in effect.
+
+4.9.	Entire Agreement. This Agreement constitutes the entire agreement between the parties and supersedes all prior and contemporaneous agreements, proposals or representations, written or oral, concerning its subject matter.

examples/coremark_v1.01/Makefile

@@ -0,0 +1,13 @@
+SDK_DEMO_PATH ?= .
+BL_SDK_BASE ?= $(SDK_DEMO_PATH)/../..
+
+export BL_SDK_BASE
+
+CHIP ?= bl616
+BOARD ?= bl616dk
+CROSS_COMPILE ?= riscv64-unknown-elf-
+
+# add custom cmake definition
+#cmake_definition+=-Dxxx=sss
+
+include $(BL_SDK_BASE)/project.build

examples/coremark_v1.01/Makefile_coremark

@@ -0,0 +1,141 @@
+#Author : Shay Gal-On, EEMBC
+#
+#This file is part of  EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 
+#All rights reserved.                            
+#
+#EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the
+#CoreMark License that is distributed with the official EEMBC COREMARK Software release. 
+#If you received this EEMBC CoreMark Software without the accompanying CoreMark License, 
+#you must discontinue use and download the official release from www.coremark.org.  
+#
+#Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, 
+#make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file.
+#
+#EEMBC 
+#4354 Town Center Blvd. Suite 114-200
+#El Dorado Hills, CA, 95762 
+
+
+# Make sure the default target is to simply build and run the benchmark.
+RSTAMP = v1.0
+
+.PHONY: run score
+run: $(OUTFILE) rerun score
+
+score:
+	@echo "Check run1.log and run2.log for results."
+	@echo "See readme.txt for run and reporting rules." 
+	
+ifndef PORT_DIR
+# Ports for a couple of common self hosted platforms
+UNAME=$(shell if [[ `uname 2> /dev/null` ]] ; then uname ; fi)
+ifneq (,$(findstring CYGWIN,$(UNAME)))
+PORT_DIR=cygwin
+endif
+ifneq (,$(findstring Linux,$(UNAME)))
+MACHINE=$(shell uname -m)
+ifneq (,$(findstring 64,$(MACHINE)))
+PORT_DIR=linux64
+else
+PORT_DIR=linux
+endif
+endif
+endif
+ifndef PORT_DIR
+$(error PLEASE define PORT_DIR! (e.g. make PORT_DIR=simple)) 
+endif
+vpath %.c $(PORT_DIR)
+vpath %.h $(PORT_DIR)
+vpath %.mak $(PORT_DIR)
+include $(PORT_DIR)/core_portme.mak
+
+ifndef $(ITERATIONS)
+ITERATIONS=0
+endif
+ifdef REBUILD
+FORCE_REBUILD=force_rebuild
+endif
+
+CFLAGS += -DITERATIONS=$(ITERATIONS)
+
+CORE_FILES = core_list_join core_main core_matrix core_state core_util
+ORIG_SRCS = $(addsuffix .c,$(CORE_FILES))
+SRCS = $(ORIG_SRCS) $(PORT_SRCS)
+OBJS = $(addprefix $(OPATH),$(addsuffix $(OEXT),$(CORE_FILES)) $(PORT_OBJS))
+OUTNAME = coremark$(EXE)
+OUTFILE = $(OPATH)$(OUTNAME)
+LOUTCMD = $(OFLAG) $(OUTFILE) $(LFLAGS_END)
+OUTCMD = $(OUTFLAG) $(OUTFILE) $(LFLAGS_END)
+
+HEADERS = coremark.h 
+CHECK_FILES = $(ORIG_SRCS) $(HEADERS)
+
+$(OPATH):
+	$(MKDIR) $(OPATH)
+
+.PHONY: compile link
+ifdef SEPARATE_COMPILE
+$(OPATH)$(PORT_DIR):
+	$(MKDIR) $(OPATH)$(PORT_DIR)
+
+compile: $(OPATH) $(OPATH)$(PORT_DIR) $(OBJS) $(HEADERS) 
+link: compile 
+	$(LD) $(LFLAGS) $(XLFLAGS) $(OBJS) $(LOUTCMD)
+	
+else
+
+compile: $(OPATH) $(SRCS) $(HEADERS) 
+	$(CC) $(CFLAGS) $(XCFLAGS) $(SRCS) $(OUTCMD)
+link: compile 
+	@echo "Link performed along with compile"
+
+endif
+
+$(OUTFILE): $(SRCS) $(HEADERS) Makefile core_portme.mak $(FORCE_REBUILD)
+	$(MAKE) port_prebuild
+	$(MAKE) link
+	$(MAKE) port_postbuild
+
+.PHONY: rerun
+rerun: 
+	$(MAKE) XCFLAGS="$(XCFLAGS) -DPERFORMANCE_RUN=1" load run1.log
+	$(MAKE) XCFLAGS="$(XCFLAGS) -DVALIDATION_RUN=1" load run2.log
+
+PARAM1=$(PORT_PARAMS) 0x0 0x0 0x66 $(ITERATIONS)
+PARAM2=$(PORT_PARAMS) 0x3415 0x3415 0x66 $(ITERATIONS)
+PARAM3=$(PORT_PARAMS) 8 8 8 $(ITERATIONS)
+
+run1.log-PARAM=$(PARAM1) 7 1 2000
+run2.log-PARAM=$(PARAM2) 7 1 2000 
+run3.log-PARAM=$(PARAM3) 7 1 1200
+
+run1.log run2.log run3.log: load
+	$(MAKE) port_prerun
+	$(RUN) $(OUTFILE) $($(@)-PARAM) > $(OPATH)$@
+	$(MAKE) port_postrun
+	
+.PHONY: gen_pgo_data
+gen_pgo_data: run3.log
+
+.PHONY: load
+load: $(OUTFILE)
+	$(MAKE) port_preload
+	$(LOAD) $(OUTFILE)
+	$(MAKE) port_postload
+
+.PHONY: clean
+clean:
+	rm -f $(OUTFILE) $(OPATH)*.log *.info $(OPATH)index.html $(PORT_CLEAN)
+
+.PHONY: force_rebuild
+force_rebuild:
+	echo "Forcing Rebuild"
+	
+.PHONY: check
+check:
+	md5sum -c coremark.md5 
+
+ifdef ETC
+# Targets related to testing and releasing CoreMark. Not part of the general release!
+include Makefile.internal
+endif	

examples/coremark_v1.01/README_coremark.md

@@ -0,0 +1,393 @@
+
+# Introduction
+
+CoreMark's primary goals are simplicity and providing a method for testing only a processor's core features. For more information about EEMBC's comprehensive embedded benchmark suites, please see www.eembc.org.
+
+# Building and Running
+	
+To build and run the benchmark, type 
+
+`> make`
+
+Full results are available in the files `run1.log` and `run2.log`. CoreMark result can be found in `run1.log`.
+	
+## Cross Compiling
+
+For cross compile platforms please adjust `core_portme.mak`, `core_portme.h` (and possibly `core_portme.c`) according to the specific platform used. When porting to a new platform, it is recommended to copy one of the default port folders  (e.g. `mkdir <platform> && cp linux/* <platform>`), adjust the porting files, and run:
+~~~
+% make PORT_DIR=<platform>
+~~~
+
+## Make Targets
+`run` - Default target, creates `run1.log` and `run2.log`.
+`run1.log` - Run the benchmark with performance parameters, and output to `run1.log`
+`run2.log` - Run the benchmark with validation parameters, and output to `run2.log`
+`run3.log` - Run the benchmark with profile generation parameters, and output to `run3.log`
+`compile` - compile the benchmark executable 
+`link` - link the benchmark executable
+`check` - test MD5 of sources that may not be modified
+`clean` - clean temporary files
+
+### Make flag: `ITERATIONS` 
+By default, the benchmark will run between 10-100 seconds. To override, use `ITERATIONS=N`
+~~~
+% make ITERATIONS=10
+~~~
+Will run the benchmark for 10 iterations. It is recommended to set a specific number of iterations in certain situations e.g.:
+
+* Running with a simulator
+* Measuring power/energy
+* Timing cannot be restarted
+
+Minimum required run time: **Results are only valid for reporting if the benchmark ran for at least 10 secs!**
+
+### Make flag: `XCFLAGS`
+To add compiler flags from the command line, use `XCFLAGS` e.g.:
+
+~~~
+% make XCFLAGS="-g -DMULTITHREAD=4 -DUSE_FORK=1"
+~~~
+
+### Make flag: `CORE_DEBUG`
+
+Define to compile for a debug run if you get incorrect CRC.
+
+~~~
+% make XCFLAGS="-DCORE_DEBUG=1"
+~~~
+
+### Make flag: `REBUILD`
+
+Force a rebuild of the executable.
+
+## Systems Without `make`
+The following files need to be compiled:
+* `core_list_join.c`
+* `core_main.c`
+* `core_matrix.c`
+* `core_state.c`
+* `core_util.c`
+* `PORT_DIR/core_portme.c`
+
+For example:
+~~~
+% gcc -O2 -o coremark.exe core_list_join.c core_main.c core_matrix.c core_state.c core_util.c simple/core_portme.c -DPERFORMANCE_RUN=1 -DITERATIONS=1000
+% ./coremark.exe > run1.log
+~~~
+The above will compile the benchmark for a performance run and 1000 iterations. Output is redirected to `run1.log`.
+
+# Parallel Execution
+Use `XCFLAGS=-DMULTITHREAD=N` where N is number of threads to run in parallel. Several implementations are available to execute in multiple contexts, or you can implement your own in `core_portme.c`.
+
+~~~
+% make XCFLAGS="-DMULTITHREAD=4 -DUSE_PTHREAD"
+~~~
+
+Above will compile the benchmark for execution on 4 cores, using POSIX Threads API.
+
+# Run Parameters for the Benchmark Executable
+CoreMark's executable takes several parameters as follows (but only if `main()` accepts arguments):
+1st - A seed value used for initialization of data.
+2nd - A seed value used for initialization of data.
+3rd - A seed value used for initialization of data.
+4th - Number of iterations (0 for auto : default value)
+5th - Reserved for internal use. 
+6th - Reserved for internal use. 
+7th - For malloc users only, ovreride the size of the input data buffer.
+
+The run target from make will run coremark with 2 different data initialization seeds.
+
+## Alternative parameters: 
+If not using `malloc` or command line arguments are not supported, the buffer size
+for the algorithms must be defined via the compiler define `TOTAL_DATA_SIZE`.
+`TOTAL_DATA_SIZE` must be set to 2000 bytes (default) for standard runs.
+The default for such a target when testing different configurations could be:
+
+~~~
+% make XCFLAGS="-DTOTAL_DATA_SIZE=6000 -DMAIN_HAS_NOARGC=1"
+~~~
+
+# Submitting Results
+
+CoreMark results can be submitted on the web. Open a web browser and go to http://www.coremark.org/benchmark/index.php?pg=benchmark. Select the link to add a new score and follow the instructions.
+
+# Run Rules
+What is and is not allowed.
+
+## Required
+1. The benchmark needs to run for at least 10 seconds.
+2. All validation must succeed for seeds `0,0,0x66` and `0x3415,0x3415,0x66`, buffer size of 2000 bytes total.
+    * If not using command line arguments to main:
+~~~
+	% make XCFLAGS="-DPERFORMANCE_RUN=1" REBUILD=1 run1.log
+	% make XCFLAGS="-DVALIDATION_RUN=1" REBUILD=1 run2.log
+~~~
+3. If using profile guided optimization, profile must be generated using seeds of `8,8,8`, and buffer size of 1200 bytes total.
+~~~
+    % make XCFLAGS="-DTOTAL_DATA_SIZE=1200 -DPROFILE_RUN=1" REBUILD=1 run3.log
+~~~
+4. All source files must be compiled with the same flags.
+5. All data type sizes must match size in bits such that:
+	* `ee_u8` is an 8 bits datatype.
+	* `ee_s16` is a 16 bits datatype.
+	* `ee_u16` is a 16 bits datatype.
+	* `ee_s32` is a 32 bits datatype.
+	* `ee_u32` is a 32 bits datatype.
+
+## Allowed
+
+1. Changing number of iterations
+2. Changing toolchain and build/load/run options
+3. Changing method of acquiring a data memory block
+5. Changing the method of acquiring seed values
+6. Changing implementation `in core_portme.c`
+7. Changing configuration values in `core_portme.h`
+8. Changing `core_portme.mak`
+
+## NOT ALLOWED
+1. Changing of source file other then `core_portme*` (use `make check` to validate)
+
+# Reporting rules
+Use the following syntax to report results on a data sheet:
+
+CoreMark 1.0 : N / C [/ P] [/ M]
+
+N - Number of iterations per second with seeds 0,0,0x66,size=2000)
+
+C - Compiler version and flags
+
+P - Parameters such as data and code allocation specifics
+
+* This parameter *may* be omitted if all data was allocated on the heap in RAM.
+* This parameter *may not* be omitted when reporting CoreMark/MHz
+
+M - Type of parallel execution (if used) and number of contexts
+* This parameter may be omitted if parallel execution was not used.
+
+e.g.:
+
+~~~
+CoreMark 1.0 : 128 / GCC 4.1.2 -O2 -fprofile-use / Heap in TCRAM / FORK:2 
+~~~
+or
+~~~
+CoreMark 1.0 : 1400 / GCC 3.4 -O4 
+~~~
+
+If reporting scaling results, the results must be reported as follows:
+
+CoreMark/MHz 1.0 : N / C / P [/ M]
+
+P - When reporting scaling results, memory parameter must also indicate memory frequency:core frequency ratio.
+1. If the core has cache and cache frequency to core frequency ratio is configurable, that must also be included.
+
+e.g.:
+
+~~~
+CoreMark/MHz 1.0 : 1.47 / GCC 4.1.2 -O2 / DDR3(Heap) 30:1 Memory 1:1 Cache
+~~~
+
+# Log File Format
+The log files have the following format
+
+~~~
+2K performance run parameters for coremark.	(Run type)
+CoreMark Size    	: 666					(Buffer size)
+Total ticks			: 25875					(platform dependent value)
+Total time (secs) 	: 25.875000				(actual time in seconds)
+Iterations/Sec 		: 3864.734300			(Performance value to report)
+Iterations			: 100000				(number of iterations used)
+Compiler version	: GCC3.4.4				(Compiler and version)	
+Compiler flags		: -O2					(Compiler and linker flags)
+Memory location		: Code in flash, data in on chip RAM
+seedcrc				: 0xe9f5				(identifier for the input seeds)
+[0]crclist			: 0xe714				(validation for list part)
+[0]crcmatrix		: 0x1fd7				(validation for matrix part)
+[0]crcstate			: 0x8e3a				(validation for state part)
+[0]crcfinal			: 0x33ff				(iteration dependent output)
+Correct operation validated. See readme.txt for run and reporting rules.  (*Only when run is successful*)
+CoreMark 1.0 : 6508.490622 / GCC3.4.4 -O2 / Heap 						  (*Only on a successful performance run*)
+~~~
+
+# Theory of Operation
+
+This section describes the initial goals of CoreMark and their implementation.
+
+## Small and easy to understand
+
+* X number of source code lines for timed portion of the benchmark.
+* Meaningful names for variables and functions.
+* Comments for each block of code more than 10 lines long.
+
+## Portability
+
+A thin abstraction layer will be provided for I/O and timing in a separate file. All I/O and timing of the benchmark will be done through this layer.
+
+### Code / data size
+
+* Compile with gcc on x86 and make sure all sizes are according to requirements. 
+* If dynamic memory allocation is used, take total memory allocated into account as well. 
+* Avoid recursive functions and keep track of stack usage.
+* Use the same memory block as data site for all algorithms, and initialize the data before each algorithm – while this means that initialization with data happens during the timed portion, it will only happen once during the timed portion and so have negligible effect on the results.
+
+## Controlled output
+
+This may be the most difficult goal. Compilers are constantly improving and getting better at analyzing code. To create work that cannot be computed at compile time and must be computed at run time, we will rely on two assumptions:
+
+* Some system functions (e.g. time, scanf) and parameters cannot be computed at compile time.  In most cases, marking a variable volatile means the compiler is force to read this variable every time it is read. This will be used to introduce a factor into the input that cannot be precomputed at compile time. Since the results are input dependent, that will make sure that computation has to happen at run time.
+
+* Either a system function or I/O (e.g. scanf) or command line parameters or volatile variables will be used before the timed portion to generate data which is not available at compile time. Specific method used is not relevant as long as it can be controlled, and that it cannot be computed or eliminated by the compiler at compile time. E.g. if the clock() functions is a compiler stub, it may not be used. The derived values will be reported on the output so that verification can be done on a different machine. 
+
+* We cannot rely on command line parameters since some embedded systems do not have the capability to provide command line parameters. All 3 methods above will be implemented (time based, scanf and command line parameters) and all 3 are valid if the compiler cannot determine the value at compile time. 
+
+* It is important to note that The actual values that are to be supplied at run time will be standardized. The methodology is not intended to provide random data, but simply to provide controlled data that cannot be precomputed at compile time.
+
+* Printed results must be valid at run time. This will be used to make sure the computation has been executed.
+
+* Some embedded systems do not provide “printf” or other I/O functionality. All I/O will be done through a thin abstraction interface to allow execution on such systems (e.g. allow output via JTAG).
+
+## Key Algorithms
+
+### Linked List
+
+The following linked list structure will be used:
+
+~~~
+typedef struct list_data_s {
+	ee_s16 data16;
+	ee_s16 idx;
+} list_data;
+
+typedef struct list_head_s {
+	struct list_head_s *next;
+	struct list_data_s *info;
+} list_head;
+~~~
+
+While adding a level of indirection accessing the data, this structure is realistic and used in many embedded applications for small to medium lists.
+
+The list itself will be initialized on a block of memory that will be passed in to the initialization function. While in general linked lists use malloc for new nodes, embedded applications sometime control the memory for small data structures such as arrays and lists directly to avoid the overhead of system calls, so this approach is realistic.
+
+The linked list will be initialized such that 1/4 of the list pointers point to sequential areas in memory, and 3.4 of the list pointers are distributed in a non sequential manner. This is done to emulate a linked list that had add/remove happen for a while disrupting the neat order, and then a series of adds that are likely to come from sequential memory locations.
+
+For the benchmark itself:
+- Multiple find operations are going to be performed. These find operations may result in the whole list being traversed. The result of each find will become part of the output chain.
+- The list will be sorted using merge sort based on the data16 value, and then derive CRC of the data16 item in order for part of the list. The CRC will become part of the output chain.
+- The list will be sorted again using merge sort based on the idx value. This sort will guarantee that the list is returned to the primary state before leaving the function, so that multiple iterations of the function will have the same result. CRC of the data16 for part of the list will again be calculated and become part of the output chain.
+
+The actual `data16` in each cell will be pseudo random based on a single 16b input that cannot be determined at compile time. In addition, the part of the list which is used for CRC will also be passed to the function, and determined based on an input that cannot be determined at run time.
+
+### Matrix Multiply
+
+This very simple algorithm forms the basis of many more complex algorithms. The tight inner loop is the focus of many optimizations (compiler as well as hardware based) and is thus relevant for embedded processing. 
+
+The total available data space will be divided to 3 parts:
+1. NxN matrix A.
+2. NxN matrix B.
+3. NxN matrix C.
+
+E.g. for 2K we will have 3 12x12 matrices (assuming data type of 32b 12(len)*12(wid)*4(size)*3(num) =1728 bytes). 
+
+Matrix A will be initialized with small values (upper 3/4 of the bits all zero).
+Matrix B will be initialized with medium values (upper half of the bits all zero).
+Matrix C will be used for the result.
+
+For the benchmark itself:
+- Multiple A by a constant into C, add the upper bits of each of the values in the result matrix. The result will become part of the output chain.
+- Multiple A by column X of B into C, add the upper bits of each of the values in the result matrix. The result will become part of the output chain.
+- Multiple A by B into C, add the upper bits of each of the values in the result matrix. The result will become part of the output chain.
+
+The actual values for A and B must be derived based on input that is not available at compile time.
+
+### State Machine
+
+This part of the code needs to exercise switch and if statements. As such, we will use a small Moore state machine. In particular, this will be a state machine that identifies string input as numbers and divides them according to format.
+
+The state machine will parse the input string until either a “,” separator or end of input is encountered. An invalid number will cause the state machine to return invalid state and a valid number will cause the state machine to return with type of number format (int/float/scientific).
+
+This code will perform a realistic task, be small enough to easily understand, and exercise the required functionality. The other option used in embedded systems is a mealy based state machine, which is driven by a table. The table then determines the number of states and complexity of transitions. This approach, however, tests mainly the load/store and function call mechanisms and less the handling of branches. If analysis of the final results shows that the load/store functionality of the processor is not exercised thoroughly, it may be a good addition to the benchmark (codesize allowing).
+
+For input, the memory block will be initialized with comma separated values of mixed formats, as well as invalid inputs.
+
+For the benchmark itself:
+- Invoke the state machine on all of the input and count final states and state transitions. CRC of all final states and transitions will become part of the output chain.
+- Modify the input at intervals (inject errors) and repeat the state machine operation.
+- Modify the input back to original form.
+
+The actual input must be initialized based on data that cannot be determined at compile time. In addition the intervals for modification of the input and the actual modification must be based on input that cannot be determined at compile time.
+
+# Validation
+
+This release was tested on the following platforms:
+* x86 cygwin and gcc 3.4 (Quad, dual and single core systems)
+* x86 linux (Ubuntu/Fedora) and gcc (4.2/4.1) (Quad and single core systems)
+* MIPS64 BE linux and gcc 3.4 16 cores system
+* MIPS32 BE linux with CodeSourcery compiler 4.2-177 on Malta/Linux with a 1004K 3-core system
+* PPC simulator with gcc 4.2.2 (No OS)
+* PPC 64b BE linux (yellowdog) with gcc 3.4 and 4.1 (Dual core system)
+* BF533 with VDSP50 
+* Renesas R8C/H8 MCU with HEW 4.05
+* NXP LPC1700 armcc v4.0.0.524
+* NEC 78K with IAR v4.61
+* ARM simulator with armcc v4
+
+# Memory Analysis
+
+Valgrind 3.4.0 used and no errors reported.
+	
+# Balance Analysis
+
+Number of instructions executed for each function tested with cachegrind and found balanced with gcc and -O0.
+
+# Statistics
+
+Lines:
+~~~
+Lines  Blank  Cmnts  Source     AESL     
+=====  =====  =====  =====  ==========  =======================================
+  469     66    170    251       627.5  core_list_join.c  (C)
+  330     18     54    268       670.0  core_main.c  (C)
+  256     32     80    146       365.0  core_matrix.c  (C)
+  240     16     51    186       465.0  core_state.c  (C)
+  165     11     20    134       335.0  core_util.c  (C)
+  150     23     36     98       245.0  coremark.h  (C)
+ 1610    166    411   1083      2707.5  ----- Benchmark -----  (6 files)
+  293     15     74    212       530.0  linux/core_portme.c  (C)
+  235     30    104    104       260.0  linux/core_portme.h  (C)
+  528     45    178    316       790.0  ----- Porting -----  (2 files)
+ 
+* For comparison, here are the stats for Dhrystone
+Lines  Blank  Cmnts  Source     AESL     
+=====  =====  =====  =====  ==========  =======================================
+  311     15    242     54       135.0  dhry.h  (C)
+  789    132    119    553      1382.5  dhry_1.c  (C)
+  186     26     68    107       267.5  dhry_2.c  (C)
+ 1286    173    429    714      1785.0  ----- C -----  (3 files)
+~~~
+
+# Credits
+Many thanks to all of the individuals who helped with the development or testing of CoreMark including (Sorted by company name; note that company names may no longer be accurate as this was written in 2009).
+* Alan Anderson, ADI
+* Adhikary Rajiv, ADI
+* Elena Stohr, ARM
+* Ian Rickards, ARM
+* Andrew Pickard, ARM
+* Trent Parker, CAVIUM
+* Shay Gal-On, EEMBC
+* Markus Levy, EEMBC
+* Ron Olson, IBM
+* Eyal Barzilay, MIPS
+* Jens Eltze, NEC
+* Hirohiko Ono, NEC
+* Ulrich Drees, NEC
+* Frank Roscheda, NEC
+* Rob Cosaro, NXP
+* Shumpei Kawasaki, RENESAS
+
+# Legal
+Please refer to LICENSE.md in this reposity for a description of your rights to use this code.
+
+# Copyright
+Copyright © 2009 EEMBC All rights reserved. 
+CoreMark is a trademark of EEMBC and EEMBC is a registered trademark of the Embedded Microprocessor Benchmark Consortium.
+

examples/coremark_v1.01/core_list_join.c

@@ -0,0 +1,512 @@
+/*
+Author : Shay Gal-On, EEMBC
+
+This file is part of  EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009
+All rights reserved.
+
+EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the
+CoreMark License that is distributed with the official EEMBC COREMARK Software release.
+If you received this EEMBC CoreMark Software without the accompanying CoreMark License,
+you must discontinue use and download the official release from www.coremark.org.
+
+Also, if you are publicly displaying scores generated from the EEMBC CoreMark software,
+make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file.
+
+EEMBC
+4354 Town Center Blvd. Suite 114-200
+El Dorado Hills, CA, 95762
+*/
+
+#include "coremark.h"
+/*
+Topic: Description
+	Benchmark using a linked list.
+
+	Linked list is a common data structure used in many applications.
+
+	For our purposes, this will excercise the memory units of the processor.
+	In particular, usage of the list pointers to find and alter data.
+
+	We are not using Malloc since some platforms do not support this library.
+
+	Instead, the memory block being passed in is used to create a list,
+	and the benchmark takes care not to add more items then can be
+	accomodated by the memory block. The porting layer will make sure
+	that we have a valid memory block.
+
+	All operations are done in place, without using any extra memory.
+
+	The list itself contains list pointers and pointers to data items.
+	Data items contain the following:
+
+	idx - An index that captures the initial order of the list.
+	data - Variable data initialized based on the input parameters. The 16b are divided as follows:
+	o Upper 8b are backup of original data.
+	o Bit 7 indicates if the lower 7 bits are to be used as is or calculated.
+	o Bits 0-2 indicate type of operation to perform to get a 7b value.
+	o Bits 3-6 provide input for the operation.
+
+*/
+
+/* local functions */
+
+list_head *core_list_find(list_head *list, list_data *info);
+list_head *core_list_reverse(list_head *list);
+list_head *core_list_remove(list_head *item);
+list_head *core_list_undo_remove(list_head *item_removed, list_head *item_modified);
+list_head *core_list_insert_new(list_head *insert_point, list_data *info, list_head **memblock, list_data **datablock, list_head *memblock_end, list_data *datablock_end);
+typedef ee_s32 (*list_cmp)(list_data *a, list_data *b, core_results *res);
+list_head *core_list_mergesort(list_head *list, list_cmp cmp, core_results *res);
+
+ee_s16 calc_func(ee_s16 *pdata, core_results *res)
+{
+    ee_s16 data = *pdata;
+    ee_s16 retval;
+    ee_u8 optype = (data >> 7) & 1; /* bit 7 indicates if the function result has been cached */
+    if (optype)                     /* if cached, use cache */
+        return (data & 0x007f);
+    else {                                  /* otherwise calculate and cache the result */
+        ee_s16 flag = data & 0x7;           /* bits 0-2 is type of function to perform */
+        ee_s16 dtype = ((data >> 3) & 0xf); /* bits 3-6 is specific data for the operation */
+        dtype |= dtype << 4;                /* replicate the lower 4 bits to get an 8b value */
+        switch (flag) {
+            case 0:
+                if (dtype < 0x22) /* set min period for bit corruption */
+                    dtype = 0x22;
+                retval = core_bench_state(res->size, res->memblock[3], res->seed1, res->seed2, dtype, res->crc);
+                if (res->crcstate == 0)
+                    res->crcstate = retval;
+                break;
+            case 1:
+                retval = core_bench_matrix(&(res->mat), dtype, res->crc);
+                if (res->crcmatrix == 0)
+                    res->crcmatrix = retval;
+                break;
+            default:
+                retval = data;
+                break;
+        }
+        res->crc = crcu16(retval, res->crc);
+        retval &= 0x007f;
+        *pdata = (data & 0xff00) | 0x0080 | retval; /* cache the result */
+        return retval;
+    }
+}
+/* Function: cmp_complex
+	Compare the data item in a list cell.
+
+	Can be used by mergesort.
+*/
+ee_s32 cmp_complex(list_data *a, list_data *b, core_results *res)
+{
+    ee_s16 val1 = calc_func(&(a->data16), res);
+    ee_s16 val2 = calc_func(&(b->data16), res);
+    return val1 - val2;
+}
+
+/* Function: cmp_idx
+	Compare the idx item in a list cell, and regen the data.
+
+	Can be used by mergesort.
+*/
+ee_s32 cmp_idx(list_data *a, list_data *b, core_results *res)
+{
+    if (res == NULL) {
+        a->data16 = (a->data16 & 0xff00) | (0x00ff & (a->data16 >> 8));
+        b->data16 = (b->data16 & 0xff00) | (0x00ff & (b->data16 >> 8));
+    }
+    return a->idx - b->idx;
+}
+
+void copy_info(list_data *to, list_data *from)
+{
+    to->data16 = from->data16;
+    to->idx = from->idx;
+}
+
+/* Benchmark for linked list:
+	- Try to find multiple data items.
+	- List sort
+	- Operate on data from list (crc)
+	- Single remove/reinsert
+	* At the end of this function, the list is back to original state
+*/
+ee_u16 core_bench_list(core_results *res, ee_s16 finder_idx)
+{
+    ee_u16 retval = 0;
+    ee_u16 found = 0, missed = 0;
+    list_head *list = res->list;
+    ee_s16 find_num = res->seed3;
+    list_head *this_find;
+    list_head *finder, *remover;
+    ee_s16 i;
+    list_data info = { 0 };
+
+    info.idx = finder_idx;
+    /* find <find_num> values in the list, and change the list each time (reverse and cache if value found) */
+    for (i = 0; i < find_num; i++) {
+        info.data16 = (i & 0xff);
+        this_find = core_list_find(list, &info);
+        list = core_list_reverse(list);
+        if (this_find == NULL) {
+            missed++;
+            retval += (list->next->info->data16 >> 8) & 1;
+        } else {
+            found++;
+            if (this_find->info->data16 & 0x1) /* use found value */
+                retval += (this_find->info->data16 >> 9) & 1;
+            /* and cache next item at the head of the list (if any) */
+            if (this_find->next != NULL) {
+                finder = this_find->next;
+                this_find->next = finder->next;
+                finder->next = list->next;
+                list->next = finder;
+            }
+        }
+        if (info.idx >= 0)
+            info.idx++;
+#if CORE_DEBUG
+        ee_printf("List find %d: [%d,%d,%d]\n", i, retval, missed, found);
+#endif
+    }
+    retval += found * 4 - missed;
+    /* sort the list by data content and remove one item*/
+    if (finder_idx > 0)
+        list = core_list_mergesort(list, cmp_complex, res);
+    remover = core_list_remove(list->next);
+    /* CRC data content of list from location of index N forward, and then undo remove */
+    finder = core_list_find(list, &info);
+    if (!finder)
+        finder = list->next;
+    while (finder) {
+        retval = crc16(list->info->data16, retval);
+        finder = finder->next;
+    }
+#if CORE_DEBUG
+    ee_printf("List sort 1: %04x\n", retval);
+#endif
+    remover = core_list_undo_remove(remover, list->next);
+    /* sort the list by index, in effect returning the list to original state */
+    list = core_list_mergesort(list, cmp_idx, NULL);
+    /* CRC data content of list */
+    finder = list->next;
+    while (finder) {
+        retval = crc16(list->info->data16, retval);
+        finder = finder->next;
+    }
+#if CORE_DEBUG
+    ee_printf("List sort 2: %04x\n", retval);
+#endif
+    return retval;
+}
+/* Function: core_list_init
+	Initialize list with data.
+
+	Parameters:
+	blksize - Size of memory to be initialized.
+	memblock - Pointer to memory block.
+	seed - 	Actual values chosen depend on the seed parameter.
+		The seed parameter MUST be supplied from a source that cannot be determined at compile time
+
+	Returns:
+	Pointer to the head of the list.
+
+*/
+list_head *core_list_init(ee_u32 blksize, list_head *memblock, ee_s16 seed)
+{
+    /* calculated pointers for the list */
+    ee_u32 per_item = 16 + sizeof(struct list_data_s);
+    ee_u32 size = (blksize / per_item) - 2; /* to accomodate systems with 64b pointers, and make sure same code is executed, set max list elements */
+    list_head *memblock_end = memblock + size;
+    list_data *datablock = (list_data *)(memblock_end);
+    list_data *datablock_end = datablock + size;
+    /* some useful variables */
+    ee_u32 i;
+    list_head *finder, *list = memblock;
+    list_data info;
+
+    /* create a fake items for the list head and tail */
+    list->next = NULL;
+    list->info = datablock;
+    list->info->idx = 0x0000;
+    list->info->data16 = (ee_s16)0x8080;
+    memblock++;
+    datablock++;
+    info.idx = 0x7fff;
+    info.data16 = (ee_s16)0xffff;
+    core_list_insert_new(list, &info, &memblock, &datablock, memblock_end, datablock_end);
+
+    /* then insert size items */
+    for (i = 0; i < size; i++) {
+        ee_u16 datpat = ((ee_u16)(seed ^ i) & 0xf);
+        ee_u16 dat = (datpat << 3) | (i & 0x7); /* alternate between algorithms */
+        info.data16 = (dat << 8) | dat;         /* fill the data with actual data and upper bits with rebuild value */
+        core_list_insert_new(list, &info, &memblock, &datablock, memblock_end, datablock_end);
+    }
+    /* and now index the list so we know initial seed order of the list */
+    finder = list->next;
+    i = 1;
+    while (finder->next != NULL) {
+        if (i < size / 5) /* first 20% of the list in order */
+            finder->info->idx = i++;
+        else {
+            ee_u16 pat = (ee_u16)(i++ ^ seed);                      /* get a pseudo random number */
+            finder->info->idx = 0x3fff & (((i & 0x07) << 8) | pat); /* make sure the mixed items end up after the ones in sequence */
+        }
+        finder = finder->next;
+    }
+    list = core_list_mergesort(list, cmp_idx, NULL);
+#if CORE_DEBUG
+    ee_printf("Initialized list:\n");
+    finder = list;
+    while (finder) {
+        ee_printf("[%04x,%04x]", finder->info->idx, (ee_u16)finder->info->data16);
+        finder = finder->next;
+    }
+    ee_printf("\n");
+#endif
+    return list;
+}
+
+/* Function: core_list_insert
+	Insert an item to the list
+
+	Parameters:
+	insert_point - where to insert the item.
+	info - data for the cell.
+	memblock - pointer for the list header
+	datablock - pointer for the list data
+	memblock_end - end of region for list headers
+	datablock_end - end of region for list data
+
+	Returns:
+	Pointer to new item.
+*/
+list_head *core_list_insert_new(list_head *insert_point, list_data *info, list_head **memblock, list_data **datablock, list_head *memblock_end, list_data *datablock_end)
+{
+    list_head *newitem;
+
+    if ((*memblock + 1) >= memblock_end)
+        return NULL;
+    if ((*datablock + 1) >= datablock_end)
+        return NULL;
+
+    newitem = *memblock;
+    (*memblock)++;
+    newitem->next = insert_point->next;
+    insert_point->next = newitem;
+
+    newitem->info = *datablock;
+    (*datablock)++;
+    copy_info(newitem->info, info);
+
+    return newitem;
+}
+
+/* Function: core_list_remove
+	Remove an item from the list.
+
+	Operation:
+	For a singly linked list, remove by copying the data from the next item
+	over to the current cell, and unlinking the next item.
+
+	Note:
+	since there is always a fake item at the end of the list, no need to check for NULL.
+
+	Returns:
+	Removed item.
+*/
+list_head *core_list_remove(list_head *item)
+{
+    list_data *tmp;
+    list_head *ret = item->next;
+    /* swap data pointers */
+    tmp = item->info;
+    item->info = ret->info;
+    ret->info = tmp;
+    /* and eliminate item */
+    item->next = item->next->next;
+    ret->next = NULL;
+    return ret;
+}
+
+/* Function: core_list_undo_remove
+	Undo a remove operation.
+
+	Operation:
+	Since we want each iteration of the benchmark to be exactly the same,
+	we need to be able to undo a remove.
+	Link the removed item back into the list, and switch the info items.
+
+	Parameters:
+	item_removed - Return value from the <core_list_remove>
+	item_modified - List item that was modified during <core_list_remove>
+
+	Returns:
+	The item that was linked back to the list.
+
+*/
+list_head *core_list_undo_remove(list_head *item_removed, list_head *item_modified)
+{
+    list_data *tmp;
+    /* swap data pointers */
+    tmp = item_removed->info;
+    item_removed->info = item_modified->info;
+    item_modified->info = tmp;
+    /* and insert item */
+    item_removed->next = item_modified->next;
+    item_modified->next = item_removed;
+    return item_removed;
+}
+
+/* Function: core_list_find
+	Find an item in the list
+
+	Operation:
+	Find an item by idx (if not 0) or specific data value
+
+	Parameters:
+	list - list head
+	info - idx or data to find
+
+	Returns:
+	Found item, or NULL if not found.
+*/
+list_head *core_list_find(list_head *list, list_data *info)
+{
+    if (info->idx >= 0) {
+        while (list && (list->info->idx != info->idx))
+            list = list->next;
+        return list;
+    } else {
+        while (list && ((list->info->data16 & 0xff) != info->data16))
+            list = list->next;
+        return list;
+    }
+}
+/* Function: core_list_reverse
+	Reverse a list
+
+	Operation:
+	Rearrange the pointers so the list is reversed.
+
+	Parameters:
+	list - list head
+	info - idx or data to find
+
+	Returns:
+	Found item, or NULL if not found.
+*/
+
+list_head *core_list_reverse(list_head *list)
+{
+    list_head *next = NULL, *tmp;
+    while (list) {
+        tmp = list->next;
+        list->next = next;
+        next = list;
+        list = tmp;
+    }
+    return next;
+}
+/* Function: core_list_mergesort
+	Sort the list in place without recursion.
+
+	Description:
+	Use mergesort, as for linked list this is a realistic solution.
+	Also, since this is aimed at embedded, care was taken to use iterative rather then recursive algorithm.
+	The sort can either return the list to original order (by idx) ,
+	or use the data item to invoke other other algorithms and change the order of the list.
+
+	Parameters:
+	list - list to be sorted.
+	cmp - cmp function to use
+
+	Returns:
+	New head of the list.
+
+	Note:
+	We have a special header for the list that will always be first,
+	but the algorithm could theoretically modify where the list starts.
+
+ */
+list_head *core_list_mergesort(list_head *list, list_cmp cmp, core_results *res)
+{
+    list_head *p, *q, *e, *tail;
+    ee_s32 insize, nmerges, psize, qsize, i;
+
+    insize = 1;
+
+    while (1) {
+        p = list;
+        list = NULL;
+        tail = NULL;
+
+        nmerges = 0; /* count number of merges we do in this pass */
+
+        while (p) {
+            nmerges++; /* there exists a merge to be done */
+            /* step `insize' places along from p */
+            q = p;
+            psize = 0;
+            for (i = 0; i < insize; i++) {
+                psize++;
+                q = q->next;
+                if (!q)
+                    break;
+            }
+
+            /* if q hasn't fallen off end, we have two lists to merge */
+            qsize = insize;
+
+            /* now we have two lists; merge them */
+            while (psize > 0 || (qsize > 0 && q)) {
+                /* decide whether next element of merge comes from p or q */
+                if (psize == 0) {
+                    /* p is empty; e must come from q. */
+                    e = q;
+                    q = q->next;
+                    qsize--;
+                } else if (qsize == 0 || !q) {
+                    /* q is empty; e must come from p. */
+                    e = p;
+                    p = p->next;
+                    psize--;
+                } else if (cmp(p->info, q->info, res) <= 0) {
+                    /* First element of p is lower (or same); e must come from p. */
+                    e = p;
+                    p = p->next;
+                    psize--;
+                } else {
+                    /* First element of q is lower; e must come from q. */
+                    e = q;
+                    q = q->next;
+                    qsize--;
+                }
+
+                /* add the next element to the merged list */
+                if (tail) {
+                    tail->next = e;
+                } else {
+                    list = e;
+                }
+                tail = e;
+            }
+
+            /* now p has stepped `insize' places along, and q has too */
+            p = q;
+        }
+
+        tail->next = NULL;
+
+        /* If we have done only one merge, we're finished. */
+        if (nmerges <= 1) /* allow for nmerges==0, the empty list case */
+            return list;
+
+        /* Otherwise repeat, merging lists twice the size */
+        insize *= 2;
+    }
+#if COMPILER_REQUIRES_SORT_RETURN
+    return list;
+#endif
+}

examples/coremark_v1.01/core_main.c

@@ -0,0 +1,372 @@
+/*
+Author : Shay Gal-On, EEMBC
+
+This file is part of  EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009
+All rights reserved.
+
+EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the
+CoreMark License that is distributed with the official EEMBC COREMARK Software release.
+If you received this EEMBC CoreMark Software without the accompanying CoreMark License,
+you must discontinue use and download the official release from www.coremark.org.
+
+Also, if you are publicly displaying scores generated from the EEMBC CoreMark software,
+make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file.
+
+EEMBC
+4354 Town Center Blvd. Suite 114-200
+El Dorado Hills, CA, 95762
+*/
+/* File: core_main.c
+	This file contains the framework to acquire a block of memory, seed initial parameters, tun t he benchmark and report the results.
+*/
+#include "coremark.h"
+
+/* Function: iterate
+	Run the benchmark for a specified number of iterations.
+
+	Operation:
+	For each type of benchmarked algorithm:
+		a - Initialize the data block for the algorithm.
+		b - Execute the algorithm N times.
+
+	Returns:
+	NULL.
+*/
+static ee_u16 list_known_crc[] = { (ee_u16)0xd4b0, (ee_u16)0x3340, (ee_u16)0x6a79, (ee_u16)0xe714, (ee_u16)0xe3c1 };
+static ee_u16 matrix_known_crc[] = { (ee_u16)0xbe52, (ee_u16)0x1199, (ee_u16)0x5608, (ee_u16)0x1fd7, (ee_u16)0x0747 };
+static ee_u16 state_known_crc[] = { (ee_u16)0x5e47, (ee_u16)0x39bf, (ee_u16)0xe5a4, (ee_u16)0x8e3a, (ee_u16)0x8d84 };
+void *iterate(void *pres)
+{
+    ee_u32 i;
+    ee_u16 crc;
+    core_results *res = (core_results *)pres;
+    ee_u32 iterations = res->iterations;
+    res->crc = 0;
+    res->crclist = 0;
+    res->crcmatrix = 0;
+    res->crcstate = 0;
+
+    for (i = 0; i < iterations; i++) {
+        crc = core_bench_list(res, 1);
+        res->crc = crcu16(crc, res->crc);
+        crc = core_bench_list(res, -1);
+        res->crc = crcu16(crc, res->crc);
+        if (i == 0)
+            res->crclist = res->crc;
+    }
+    return NULL;
+}
+
+#if (SEED_METHOD == SEED_ARG)
+ee_s32 get_seed_args(int i, int argc, char *argv[]);
+#define get_seed(x)    (ee_s16) get_seed_args(x, argc, argv)
+#define get_seed_32(x) get_seed_args(x, argc, argv)
+#else /* via function or volatile */
+ee_s32 get_seed_32(int i);
+#define get_seed(x) (ee_s16) get_seed_32(x)
+#endif
+
+#if (MEM_METHOD == MEM_STATIC)
+ee_u8 static_memblk[TOTAL_DATA_SIZE];
+#endif
+char *mem_name[3] = { "Static", "Heap", "Stack" };
+/* Function: main
+	Main entry routine for the benchmark.
+	This function is responsible for the following steps:
+
+	1 - Initialize input seeds from a source that cannot be determined at compile time.
+	2 - Initialize memory block for use.
+	3 - Run and time the benchmark.
+	4 - Report results, testing the validity of the output if the seeds are known.
+
+	Arguments:
+	1 - first seed  : Any value
+	2 - second seed : Must be identical to first for iterations to be identical
+	3 - third seed  : Any value, should be at least an order of magnitude less then the input size, but bigger then 32.
+	4 - Iterations  : Special, if set to 0, iterations will be automatically determined such that the benchmark will run between 10 to 100 secs
+
+*/
+
+#if MAIN_HAS_NOARGC
+MAIN_RETURN_TYPE core_mark(void)
+{
+    int argc = 0;
+    char *argv[1];
+#else
+MAIN_RETURN_TYPE core_mark(int argc, char *argv[])
+{
+#endif
+    ee_u16 i, j = 0, num_algorithms = 0;
+    ee_s16 known_id = -1, total_errors = 0;
+    ee_u16 seedcrc = 0;
+    CORE_TICKS total_time;
+    core_results results[MULTITHREAD];
+#if (MEM_METHOD == MEM_STACK)
+    ee_u8 stack_memblock[TOTAL_DATA_SIZE * MULTITHREAD];
+#endif
+    /* first call any initializations needed */
+    portable_init(&(results[0].port), &argc, argv);
+    /* First some checks to make sure benchmark will run ok */
+    if (sizeof(struct list_head_s) > 128) {
+        ee_printf("list_head structure too big for comparable data!\n");
+        return MAIN_RETURN_VAL;
+    }
+    results[0].seed1 = get_seed(1);
+    results[0].seed2 = get_seed(2);
+    results[0].seed3 = get_seed(3);
+    results[0].iterations = get_seed_32(4);
+#if CORE_DEBUG
+    results[0].iterations = 1;
+#endif
+    results[0].execs = get_seed_32(5);
+    if (results[0].execs == 0) { /* if not supplied, execute all algorithms */
+        results[0].execs = ALL_ALGORITHMS_MASK;
+    }
+    /* put in some default values based on one seed only for easy testing */
+    if ((results[0].seed1 == 0) && (results[0].seed2 == 0) && (results[0].seed3 == 0)) { /* validation run */
+        results[0].seed1 = 0;
+        results[0].seed2 = 0;
+        results[0].seed3 = 0x66;
+    }
+    if ((results[0].seed1 == 1) && (results[0].seed2 == 0) && (results[0].seed3 == 0)) { /* perfromance run */
+        results[0].seed1 = 0x3415;
+        results[0].seed2 = 0x3415;
+        results[0].seed3 = 0x66;
+    }
+#if (MEM_METHOD == MEM_STATIC)
+    results[0].memblock[0] = (void *)static_memblk;
+    results[0].size = TOTAL_DATA_SIZE;
+    results[0].err = 0;
+#if (MULTITHREAD > 1)
+#error "Cannot use a static data area with multiple contexts!"
+#endif
+#elif (MEM_METHOD == MEM_MALLOC)
+    for (i = 0; i < MULTITHREAD; i++) {
+        ee_s32 malloc_override = get_seed(7);
+        if (malloc_override != 0)
+            results[i].size = malloc_override;
+        else
+            results[i].size = TOTAL_DATA_SIZE;
+        results[i].memblock[0] = portable_malloc(results[i].size);
+        results[i].seed1 = results[0].seed1;
+        results[i].seed2 = results[0].seed2;
+        results[i].seed3 = results[0].seed3;
+        results[i].err = 0;
+        results[i].execs = results[0].execs;
+    }
+#elif (MEM_METHOD == MEM_STACK)
+for (i = 0; i < MULTITHREAD; i++) {
+    results[i].memblock[0] = stack_memblock + i * TOTAL_DATA_SIZE;
+    results[i].size = TOTAL_DATA_SIZE;
+    results[i].seed1 = results[0].seed1;
+    results[i].seed2 = results[0].seed2;
+    results[i].seed3 = results[0].seed3;
+    results[i].err = 0;
+    results[i].execs = results[0].execs;
+}
+#else
+#error "Please define a way to initialize a memory block."
+#endif
+    /* Data init */
+    /* Find out how space much we have based on number of algorithms */
+    for (i = 0; i < NUM_ALGORITHMS; i++) {
+        if ((1 << (ee_u32)i) & results[0].execs)
+            num_algorithms++;
+    }
+    for (i = 0; i < MULTITHREAD; i++)
+        results[i].size = results[i].size / num_algorithms;
+    /* Assign pointers */
+    for (i = 0; i < NUM_ALGORITHMS; i++) {
+        ee_u32 ctx;
+        if ((1 << (ee_u32)i) & results[0].execs) {
+            for (ctx = 0; ctx < MULTITHREAD; ctx++)
+                results[ctx].memblock[i + 1] = (char *)(results[ctx].memblock[0]) + results[0].size * j;
+            j++;
+        }
+    }
+    /* call inits */
+    for (i = 0; i < MULTITHREAD; i++) {
+        if (results[i].execs & ID_LIST) {
+            results[i].list = core_list_init(results[0].size, results[i].memblock[1], results[i].seed1);
+        }
+        if (results[i].execs & ID_MATRIX) {
+            core_init_matrix(results[0].size, results[i].memblock[2], (ee_s32)results[i].seed1 | (((ee_s32)results[i].seed2) << 16), &(results[i].mat));
+        }
+        if (results[i].execs & ID_STATE) {
+            core_init_state(results[0].size, results[i].seed1, results[i].memblock[3]);
+        }
+    }
+
+    /* automatically determine number of iterations if not set */
+    if (results[0].iterations == 0) {
+        secs_ret secs_passed = 0;
+        ee_u32 divisor;
+        results[0].iterations = 1;
+        while (secs_passed < (secs_ret)1) {
+            results[0].iterations *= 10;
+            start_time();
+            iterate(&results[0]);
+            stop_time();
+            secs_passed = time_in_secs(get_time());
+        }
+        /* now we know it executes for at least 1 sec, set actual run time at about 10 secs */
+        divisor = (ee_u32)secs_passed;
+        if (divisor == 0) /* some machines cast float to int as 0 since this conversion is not defined by ANSI, but we know at least one second passed */
+            divisor = 1;
+        results[0].iterations *= 1 + 10 / divisor;
+    }
+    /* perform actual benchmark */
+    start_time();
+#if (MULTITHREAD > 1)
+    if (default_num_contexts > MULTITHREAD) {
+        default_num_contexts = MULTITHREAD;
+    }
+    for (i = 0; i < default_num_contexts; i++) {
+        results[i].iterations = results[0].iterations;
+        results[i].execs = results[0].execs;
+        core_start_parallel(&results[i]);
+    }
+    for (i = 0; i < default_num_contexts; i++) {
+        core_stop_parallel(&results[i]);
+    }
+#else
+    iterate(&results[0]);
+#endif
+    stop_time();
+    total_time = get_time();
+    /* get a function of the input to report */
+    seedcrc = crc16(results[0].seed1, seedcrc);
+    seedcrc = crc16(results[0].seed2, seedcrc);
+    seedcrc = crc16(results[0].seed3, seedcrc);
+    seedcrc = crc16(results[0].size, seedcrc);
+
+    switch (seedcrc) { /* test known output for common seeds */
+        case 0x8a02:   /* seed1=0, seed2=0, seed3=0x66, size 2000 per algorithm */
+            known_id = 0;
+            ee_printf("6k performance run parameters for coremark.\n");
+            break;
+        case 0x7b05: /*  seed1=0x3415, seed2=0x3415, seed3=0x66, size 2000 per algorithm */
+            known_id = 1;
+            ee_printf("6k validation run parameters for coremark.\n");
+            break;
+        case 0x4eaf: /* seed1=0x8, seed2=0x8, seed3=0x8, size 400 per algorithm */
+            known_id = 2;
+            ee_printf("Profile generation run parameters for coremark.\n");
+            break;
+        case 0xe9f5: /* seed1=0, seed2=0, seed3=0x66, size 666 per algorithm */
+            known_id = 3;
+            ee_printf("2K performance run parameters for coremark.\n");
+            break;
+        case 0x18f2: /*  seed1=0x3415, seed2=0x3415, seed3=0x66, size 666 per algorithm */
+            known_id = 4;
+            ee_printf("2K validation run parameters for coremark.\n");
+            break;
+        default:
+            total_errors = -1;
+            break;
+    }
+    if (known_id >= 0) {
+        for (i = 0; i < default_num_contexts; i++) {
+            results[i].err = 0;
+            if ((results[i].execs & ID_LIST) &&
+                (results[i].crclist != list_known_crc[known_id])) {
+                ee_printf("[%u]ERROR! list crc 0x%04x - should be 0x%04x\n", i, results[i].crclist, list_known_crc[known_id]);
+                results[i].err++;
+            }
+            if ((results[i].execs & ID_MATRIX) &&
+                (results[i].crcmatrix != matrix_known_crc[known_id])) {
+                ee_printf("[%u]ERROR! matrix crc 0x%04x - should be 0x%04x\n", i, results[i].crcmatrix, matrix_known_crc[known_id]);
+                results[i].err++;
+            }
+            if ((results[i].execs & ID_STATE) &&
+                (results[i].crcstate != state_known_crc[known_id])) {
+                ee_printf("[%u]ERROR! state crc 0x%04x - should be 0x%04x\n", i, results[i].crcstate, state_known_crc[known_id]);
+                results[i].err++;
+            }
+            total_errors += results[i].err;
+        }
+    }
+    total_errors += check_data_types();
+    /* and report results */
+    ee_printf("CoreMark Size    : %lu\n", (long unsigned)results[0].size);
+    ee_printf("Total ticks      : %lu\n", (long unsigned)total_time);
+#if HAS_FLOAT
+    ee_printf("Total time (secs): %f\n", time_in_secs(total_time));
+    if (time_in_secs(total_time) > 0)
+        ee_printf("Iterations/Sec   : %f\n", default_num_contexts * results[0].iterations / time_in_secs(total_time));
+#else
+    ee_printf("Total time (secs): %d\n", time_in_secs(total_time));
+    if (time_in_secs(total_time) > 0)
+        ee_printf("Iterations/Sec   : %d\n", default_num_contexts * results[0].iterations / time_in_secs(total_time));
+#endif
+    if (time_in_secs(total_time) < 10) {
+        ee_printf("ERROR! Must execute for at least 10 secs for a valid result!\n");
+        total_errors++;
+    }
+
+    ee_printf("Iterations       : %lu\n", (long unsigned)default_num_contexts * results[0].iterations);
+    ee_printf("Compiler version : %s\n", COMPILER_VERSION);
+    ee_printf("Compiler flags   : %s\n", COMPILER_FLAGS);
+#if (MULTITHREAD > 1)
+    ee_printf("Parallel %s : %d\n", PARALLEL_METHOD, default_num_contexts);
+#endif
+    ee_printf("Memory location  : %s\n", MEM_LOCATION);
+    /* output for verification */
+    ee_printf("seedcrc          : 0x%04x\n", seedcrc);
+    if (results[0].execs & ID_LIST)
+        for (i = 0; i < default_num_contexts; i++)
+            ee_printf("[%d]crclist       : 0x%04x\n", i, results[i].crclist);
+    if (results[0].execs & ID_MATRIX)
+        for (i = 0; i < default_num_contexts; i++)
+            ee_printf("[%d]crcmatrix     : 0x%04x\n", i, results[i].crcmatrix);
+    if (results[0].execs & ID_STATE)
+        for (i = 0; i < default_num_contexts; i++)
+            ee_printf("[%d]crcstate      : 0x%04x\n", i, results[i].crcstate);
+    for (i = 0; i < default_num_contexts; i++)
+        ee_printf("[%d]crcfinal      : 0x%04x\n", i, results[i].crc);
+    if (total_errors == 0) {
+        ee_printf("Correct operation validated. See readme.txt for run and reporting rules.\n");
+#if HAS_FLOAT
+        if (known_id == 3) {
+            ee_printf("CoreMark 1.0 : %f / %s %s", default_num_contexts * results[0].iterations / time_in_secs(total_time), COMPILER_VERSION, COMPILER_FLAGS);
+#if defined(MEM_LOCATION) && !defined(MEM_LOCATION_UNSPEC)
+            ee_printf(" / %s", MEM_LOCATION);
+#else
+            ee_printf(" / %s", mem_name[MEM_METHOD]);
+#endif
+
+#if (MULTITHREAD > 1)
+            ee_printf(" / %d:%s", default_num_contexts, PARALLEL_METHOD);
+#endif
+            ee_printf("\n");
+        }
+#else
+        if (known_id == 3) {
+            ee_printf("CoreMark 1.0 : %d / %s %s", default_num_contexts * results[0].iterations / time_in_secs(total_time), COMPILER_VERSION, COMPILER_FLAGS);
+#if defined(MEM_LOCATION) && !defined(MEM_LOCATION_UNSPEC)
+            ee_printf(" / %s", MEM_LOCATION);
+#else
+            ee_printf(" / %s", mem_name[MEM_METHOD]);
+#endif
+
+#if (MULTITHREAD > 1)
+            ee_printf(" / %d:%s", default_num_contexts, PARALLEL_METHOD);
+#endif
+            ee_printf("\n");
+        }
+#endif
+    }
+    if (total_errors > 0)
+        ee_printf("Errors detected\n");
+    if (total_errors < 0)
+        ee_printf("Cannot validate operation for these seed values, please compare with results on a known platform.\n");
+
+#if (MEM_METHOD == MEM_MALLOC)
+    for (i = 0; i < MULTITHREAD; i++)
+        portable_free(results[i].memblock[0]);
+#endif
+    /* And last call any target specific code for finalizing */
+    portable_fini(&(results[0].port));
+
+    return MAIN_RETURN_VAL;
+}

examples/coremark_v1.01/core_matrix.c

@@ -0,0 +1,308 @@
+/*
+Author : Shay Gal-On, EEMBC
+
+This file is part of  EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 
+All rights reserved.                            
+
+EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the
+CoreMark License that is distributed with the official EEMBC COREMARK Software release. 
+If you received this EEMBC CoreMark Software without the accompanying CoreMark License, 
+you must discontinue use and download the official release from www.coremark.org.  
+
+Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, 
+make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file.
+
+EEMBC 
+4354 Town Center Blvd. Suite 114-200
+El Dorado Hills, CA, 95762 
+*/ 
+#include "coremark.h"
+/*
+Topic: Description
+	Matrix manipulation benchmark
+	
+	This very simple algorithm forms the basis of many more complex algorithms. 
+	
+	The tight inner loop is the focus of many optimizations (compiler as well as hardware based) 
+	and is thus relevant for embedded processing. 
+	
+	The total available data space will be divided to 3 parts:
+	NxN Matrix A - initialized with small values (upper 3/4 of the bits all zero).
+	NxN Matrix B - initialized with medium values (upper half of the bits all zero).
+	NxN Matrix C - used for the result.
+
+	The actual values for A and B must be derived based on input that is not available at compile time.
+*/
+ee_s16 matrix_test(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B, MATDAT val);
+ee_s16 matrix_sum(ee_u32 N, MATRES *C, MATDAT clipval);
+void matrix_mul_const(ee_u32 N, MATRES *C, MATDAT *A, MATDAT val);
+void matrix_mul_vect(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B);
+void matrix_mul_matrix(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B);
+void matrix_mul_matrix_bitextract(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B);
+void matrix_add_const(ee_u32 N, MATDAT *A, MATDAT val);
+
+#define matrix_test_next(x) (x+1)
+#define matrix_clip(x,y) ((y) ? (x) & 0x0ff : (x) & 0x0ffff)
+#define matrix_big(x) (0xf000 | (x))
+#define bit_extract(x,from,to) (((x)>>(from)) & (~(0xffffffff << (to))))
+
+#if CORE_DEBUG
+void printmat(MATDAT *A, ee_u32 N, char *name) {
+	ee_u32 i,j;
+	ee_printf("Matrix %s [%dx%d]:\n",name,N,N);
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			if (j!=0)
+				ee_printf(",");
+			ee_printf("%d",A[i*N+j]);
+		}
+		ee_printf("\n");
+	}
+}
+void printmatC(MATRES *C, ee_u32 N, char *name) {
+	ee_u32 i,j;
+	ee_printf("Matrix %s [%dx%d]:\n",name,N,N);
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			if (j!=0)
+				ee_printf(",");
+			ee_printf("%d",C[i*N+j]);
+		}
+		ee_printf("\n");
+	}
+}
+#endif
+/* Function: core_bench_matrix
+	Benchmark function
+
+	Iterate <matrix_test> N times, 
+	changing the matrix values slightly by a constant amount each time.
+*/
+ee_u16 core_bench_matrix(mat_params *p, ee_s16 seed, ee_u16 crc) {
+	ee_u32 N=p->N;
+	MATRES *C=p->C;
+	MATDAT *A=p->A;
+	MATDAT *B=p->B;
+	MATDAT val=(MATDAT)seed;
+
+	crc=crc16(matrix_test(N,C,A,B,val),crc);
+
+	return crc;
+}
+
+/* Function: matrix_test
+	Perform matrix manipulation.
+
+	Parameters:
+	N - Dimensions of the matrix.
+	C - memory for result matrix.
+	A - input matrix
+	B - operator matrix (not changed during operations)
+
+	Returns:
+	A CRC value that captures all results calculated in the function.
+	In particular, crc of the value calculated on the result matrix 
+	after each step by <matrix_sum>.
+
+	Operation:
+	
+	1 - Add a constant value to all elements of a matrix.
+	2 - Multiply a matrix by a constant.
+	3 - Multiply a matrix by a vector.
+	4 - Multiply a matrix by a matrix.
+	5 - Add a constant value to all elements of a matrix.
+
+	After the last step, matrix A is back to original contents.
+*/
+ee_s16 matrix_test(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B, MATDAT val) {
+	ee_u16 crc=0;
+	MATDAT clipval=matrix_big(val);
+
+	matrix_add_const(N,A,val); /* make sure data changes  */
+#if CORE_DEBUG
+	printmat(A,N,"matrix_add_const");
+#endif
+	matrix_mul_const(N,C,A,val);
+	crc=crc16(matrix_sum(N,C,clipval),crc);
+#if CORE_DEBUG
+	printmatC(C,N,"matrix_mul_const");
+#endif
+	matrix_mul_vect(N,C,A,B);
+	crc=crc16(matrix_sum(N,C,clipval),crc);
+#if CORE_DEBUG
+	printmatC(C,N,"matrix_mul_vect");
+#endif
+	matrix_mul_matrix(N,C,A,B);
+	crc=crc16(matrix_sum(N,C,clipval),crc);
+#if CORE_DEBUG
+	printmatC(C,N,"matrix_mul_matrix");
+#endif
+	matrix_mul_matrix_bitextract(N,C,A,B);
+	crc=crc16(matrix_sum(N,C,clipval),crc);
+#if CORE_DEBUG
+	printmatC(C,N,"matrix_mul_matrix_bitextract");
+#endif
+	
+	matrix_add_const(N,A,-val); /* return matrix to initial value */
+	return crc;
+}
+
+/* Function : matrix_init
+	Initialize the memory block for matrix benchmarking.
+
+	Parameters:
+	blksize - Size of memory to be initialized.
+	memblk - Pointer to memory block.
+	seed - Actual values chosen depend on the seed parameter.
+	p - pointers to <mat_params> containing initialized matrixes.
+
+	Returns:
+	Matrix dimensions.
+	
+	Note:
+	The seed parameter MUST be supplied from a source that cannot be determined at compile time
+*/
+ee_u32 core_init_matrix(ee_u32 blksize, void *memblk, ee_s32 seed, mat_params *p) {
+	ee_u32 N=0;
+	MATDAT *A;
+	MATDAT *B;
+	ee_s32 order=1;
+	MATDAT val;
+	ee_u32 i=0,j=0;
+	if (seed==0)
+		seed=1;
+	while (j<blksize) {
+		i++;
+		j=i*i*2*4;		
+	}
+	N=i-1;
+	A=(MATDAT *)align_mem(memblk);
+	B=A+N*N;
+
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			seed = ( ( order * seed ) % 65536 );
+			val = (seed + order);
+			val=matrix_clip(val,0);
+			B[i*N+j] = val;
+			val =  (val + order);
+			val=matrix_clip(val,1);
+			A[i*N+j] = val;
+			order++;
+		}
+	}
+
+	p->A=A;
+	p->B=B;
+	p->C=(MATRES *)align_mem(B+N*N);
+	p->N=N;
+#if CORE_DEBUG
+	printmat(A,N,"A");
+	printmat(B,N,"B");
+#endif
+	return N;
+}
+
+/* Function: matrix_sum
+	Calculate a function that depends on the values of elements in the matrix.
+
+	For each element, accumulate into a temporary variable.
+	
+	As long as this value is under the parameter clipval, 
+	add 1 to the result if the element is bigger then the previous.
+	
+	Otherwise, reset the accumulator and add 10 to the result.
+*/
+ee_s16 matrix_sum(ee_u32 N, MATRES *C, MATDAT clipval) {
+	MATRES tmp=0,prev=0,cur=0;
+	ee_s16 ret=0;
+	ee_u32 i,j;
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			cur=C[i*N+j];
+			tmp+=cur;
+			if (tmp>clipval) {
+				ret+=10;
+				tmp=0;
+			} else {
+				ret += (cur>prev) ? 1 : 0;
+			}
+			prev=cur;
+		}
+	}
+	return ret;
+}
+
+/* Function: matrix_mul_const
+	Multiply a matrix by a constant.
+	This could be used as a scaler for instance.
+*/
+void matrix_mul_const(ee_u32 N, MATRES *C, MATDAT *A, MATDAT val) {
+	ee_u32 i,j;
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			C[i*N+j]=(MATRES)A[i*N+j] * (MATRES)val;
+		}
+	}
+}
+
+/* Function: matrix_add_const
+	Add a constant value to all elements of a matrix.
+*/
+void matrix_add_const(ee_u32 N, MATDAT *A, MATDAT val) {
+	ee_u32 i,j;
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			A[i*N+j] += val;
+		}
+	}
+}
+
+/* Function: matrix_mul_vect
+	Multiply a matrix by a vector.
+	This is common in many simple filters (e.g. fir where a vector of coefficients is applied to the matrix.)
+*/
+void matrix_mul_vect(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B) {
+	ee_u32 i,j;
+	for (i=0; i<N; i++) {
+		C[i]=0;
+		for (j=0; j<N; j++) {
+			C[i]+=(MATRES)A[i*N+j] * (MATRES)B[j];
+		}
+	}
+}
+
+/* Function: matrix_mul_matrix
+	Multiply a matrix by a matrix.
+	Basic code is used in many algorithms, mostly with minor changes such as scaling.
+*/
+void matrix_mul_matrix(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B) {
+	ee_u32 i,j,k;
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			C[i*N+j]=0;
+			for(k=0;k<N;k++)
+			{
+				C[i*N+j]+=(MATRES)A[i*N+k] * (MATRES)B[k*N+j];
+			}
+		}
+	}
+}
+
+/* Function: matrix_mul_matrix_bitextract
+	Multiply a matrix by a matrix, and extract some bits from the result.
+	Basic code is used in many algorithms, mostly with minor changes such as scaling.
+*/
+void matrix_mul_matrix_bitextract(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B) {
+	ee_u32 i,j,k;
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			C[i*N+j]=0;
+			for(k=0;k<N;k++)
+			{
+				MATRES tmp=(MATRES)A[i*N+k] * (MATRES)B[k*N+j];
+				C[i*N+j]+=bit_extract(tmp,2,4)*bit_extract(tmp,5,7);
+			}
+		}
+	}
+}

examples/coremark_v1.01/core_portme.c

@@ -0,0 +1,128 @@
+/*
+	File : core_portme.c
+*/
+/*
+	Author : Shay Gal-On, EEMBC
+	Legal : TODO!
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include "coremark.h"
+
+#include "bflb_mtimer.h"
+
+#if VALIDATION_RUN
+volatile ee_s32 seed1_volatile = 0x3415;
+volatile ee_s32 seed2_volatile = 0x3415;
+volatile ee_s32 seed3_volatile = 0x66;
+#endif
+#if PERFORMANCE_RUN
+volatile ee_s32 seed1_volatile = 0x0;
+volatile ee_s32 seed2_volatile = 0x0;
+volatile ee_s32 seed3_volatile = 0x66;
+#endif
+#if PROFILE_RUN
+volatile ee_s32 seed1_volatile = 0x8;
+volatile ee_s32 seed2_volatile = 0x8;
+volatile ee_s32 seed3_volatile = 0x8;
+#endif
+volatile ee_s32 seed4_volatile = ITERATIONS;
+volatile ee_s32 seed5_volatile = 0;
+/* Porting : Timing functions
+	How to capture time and convert to seconds must be ported to whatever is supported by the platform.
+	e.g. Read value from on board RTC, read value from cpu clock cycles performance counter etc.
+	Sample implementation for standard time.h and windows.h definitions included.
+*/
+/* Define : TIMER_RES_DIVIDER
+	Divider to trade off timer resolution and total time that can be measured.
+
+	Use lower values to increase resolution, but make sure that overflow does not occur.
+	If there are issues with the return value overflowing, increase this value.
+	*/
+#define NSECS_PER_SEC              (1000)
+#define CORETIMETYPE               uint64_t
+#define GETMYTIME(_t)              (*_t = bflb_mtimer_get_time_ms())
+#define MYTIMEDIFF(fin, ini)       ((fin) - (ini))
+#define TIMER_RES_DIVIDER          1
+#define SAMPLE_TIME_IMPLEMENTATION 1
+#define EE_TICKS_PER_SEC           (NSECS_PER_SEC / TIMER_RES_DIVIDER)
+
+/** Define Host specific (POSIX), or target specific global time variables. */
+static CORETIMETYPE start_time_val, stop_time_val;
+
+/* Function : start_time
+	This function will be called right before starting the timed portion of the benchmark.
+
+	Implementation may be capturing a system timer (as implemented in the example code)
+	or zeroing some system parameters - e.g. setting the cpu clocks cycles to 0.
+*/
+void start_time(void)
+{
+    GETMYTIME(&start_time_val);
+}
+/* Function : stop_time
+	This function will be called right after ending the timed portion of the benchmark.
+
+	Implementation may be capturing a system timer (as implemented in the example code)
+	or other system parameters - e.g. reading the current value of cpu cycles counter.
+*/
+void stop_time(void)
+{
+    GETMYTIME(&stop_time_val);
+}
+/* Function : get_time
+	Return an abstract "ticks" number that signifies time on the system.
+
+	Actual value returned may be cpu cycles, milliseconds or any other value,
+	as long as it can be converted to seconds by <time_in_secs>.
+	This methodology is taken to accomodate any hardware or simulated platform.
+	The sample implementation returns millisecs by default,
+	and the resolution is controlled by <TIMER_RES_DIVIDER>
+*/
+CORE_TICKS get_time(void)
+{
+    CORE_TICKS elapsed = (CORE_TICKS)(MYTIMEDIFF(stop_time_val, start_time_val));
+    return elapsed;
+}
+/* Function : time_in_secs
+	Convert the value returned by get_time to seconds.
+
+	The <secs_ret> type is used to accomodate systems with no support for floating point.
+	Default implementation implemented by the EE_TICKS_PER_SEC macro above.
+*/
+secs_ret time_in_secs(CORE_TICKS ticks)
+{
+    secs_ret retval = ((secs_ret)ticks) / (secs_ret)EE_TICKS_PER_SEC;
+    return retval;
+}
+
+ee_u32 default_num_contexts = 1;
+
+/* Function : portable_init
+	Target specific initialization code
+	Test for some common mistakes.
+*/
+void portable_init(core_portable *p, int *argc, char *argv[])
+{
+    ee_printf("Benchmark started, please make sure it runs for at least 10s.\n\n");
+
+    uint32_t i = 0;
+    __asm volatile("add %0, ra, zero"
+                   : "=r"(i));
+    ee_printf("Now PC=%lx\r\n", i);
+
+    if (sizeof(ee_ptr_int) != sizeof(ee_u8 *)) {
+        ee_printf("ERROR! Please define ee_ptr_int to a type that holds a pointer!\n");
+    }
+    if (sizeof(ee_u32) != 4) {
+        ee_printf("ERROR! Please define ee_u32 to a 32b unsigned type!\n");
+    }
+    p->portable_id = 1;
+}
+/* Function : portable_fini
+	Target specific final code
+*/
+void portable_fini(core_portable *p)
+{
+    p->portable_id = 0;
+}

examples/coremark_v1.01/core_portme.h

@@ -0,0 +1,184 @@
+/* File : core_portme.h */
+
+/*
+	Author : Shay Gal-On, EEMBC
+	Legal : TODO!
+*/
+/* Topic : Description
+	This file contains configuration constants required to execute on different platforms
+*/
+#ifndef CORE_PORTME_H
+#define CORE_PORTME_H
+/************************/
+/* Data types and settings */
+/************************/
+/* Configuration : HAS_FLOAT
+	Define to 1 if the platform supports floating point.
+*/
+#ifndef HAS_FLOAT
+#define HAS_FLOAT 0
+#endif
+/* Configuration : HAS_TIME_H
+	Define to 1 if platform has the time.h header file,
+	and implementation of functions thereof.
+*/
+#ifndef HAS_TIME_H
+#define HAS_TIME_H 1
+#endif
+/* Configuration : USE_CLOCK
+	Define to 1 if platform has the time.h header file,
+	and implementation of functions thereof.
+*/
+#ifndef USE_CLOCK
+#define USE_CLOCK 1
+#endif
+/* Configuration : HAS_STDIO
+	Define to 1 if the platform has stdio.h.
+*/
+#ifndef HAS_STDIO
+#define HAS_STDIO 1
+#endif
+/* Configuration : HAS_PRINTF
+	Define to 1 if the platform has stdio.h and implements the printf function.
+*/
+#ifndef HAS_PRINTF
+#define HAS_PRINTF 1
+#endif
+
+/* Configuration : CORE_TICKS
+	Define type of return from the timing functions.
+ */
+#include <time.h>
+typedef clock_t CORE_TICKS;
+
+/* Definitions : COMPILER_VERSION, COMPILER_FLAGS, MEM_LOCATION
+	Initialize these strings per platform
+*/
+#ifndef COMPILER_VERSION
+#ifdef __GNUC__
+#define COMPILER_VERSION "GCC" __VERSION__
+#else
+#define COMPILER_VERSION "Please put compiler version here (e.g. gcc 4.1)"
+#endif
+#endif
+#ifndef COMPILER_FLAGS
+#define COMPILER_FLAGS "-O2" /* "Please put compiler flags here (e.g. -o3)" */
+#endif
+#ifndef MEM_LOCATION
+#define MEM_LOCATION "STACK"
+#endif
+
+/* Data Types :
+	To avoid compiler issues, define the data types that need ot be used for 8b, 16b and 32b in <core_portme.h>.
+
+	*Imprtant* :
+	ee_ptr_int needs to be the data type used to hold pointers, otherwise coremark may fail!!!
+*/
+typedef signed short ee_s16;
+typedef unsigned short ee_u16;
+typedef signed int ee_s32;
+typedef double ee_f32;
+typedef unsigned char ee_u8;
+typedef unsigned int ee_u32;
+typedef ee_u32 ee_ptr_int;
+typedef size_t ee_size_t;
+/* align_mem :
+	This macro is used to align an offset to point to a 32b value. It is used in the Matrix algorithm to initialize the input memory blocks.
+*/
+#define align_mem(x) (void *)(4 + (((ee_ptr_int)(x)-1) & ~3))
+
+/* Configuration : SEED_METHOD
+	Defines method to get seed values that cannot be computed at compile time.
+
+	Valid values :
+	SEED_ARG - from command line.
+	SEED_FUNC - from a system function.
+	SEED_VOLATILE - from volatile variables.
+*/
+#ifndef SEED_METHOD
+#define SEED_METHOD SEED_VOLATILE
+#endif
+
+/* Configuration : MEM_METHOD
+	Defines method to get a block of memry.
+
+	Valid values :
+	MEM_MALLOC - for platforms that implement malloc and have malloc.h.
+	MEM_STATIC - to use a static memory array.
+	MEM_STACK - to allocate the data block on the stack (NYI).
+*/
+#ifndef MEM_METHOD
+#define MEM_METHOD MEM_STACK
+#endif
+
+/* Configuration : MULTITHREAD
+	Define for parallel execution
+
+	Valid values :
+	1 - only one context (default).
+	N>1 - will execute N copies in parallel.
+
+	Note :
+	If this flag is defined to more then 1, an implementation for launching parallel contexts must be defined.
+
+	Two sample implementations are provided. Use <USE_PTHREAD> or <USE_FORK> to enable them.
+
+	It is valid to have a different implementation of <core_start_parallel> and <core_end_parallel> in <core_portme.c>,
+	to fit a particular architecture.
+*/
+#ifndef MULTITHREAD
+#define MULTITHREAD 1
+#define USE_PTHREAD 0
+#define USE_FORK    0
+#define USE_SOCKET  0
+#endif
+
+/* Configuration : MAIN_HAS_NOARGC
+	Needed if platform does not support getting arguments to main.
+
+	Valid values :
+	0 - argc/argv to main is supported
+	1 - argc/argv to main is not supported
+
+	Note :
+	This flag only matters if MULTITHREAD has been defined to a value greater then 1.
+*/
+#ifndef MAIN_HAS_NOARGC
+#define MAIN_HAS_NOARGC 1
+#endif
+
+/* Configuration : MAIN_HAS_NORETURN
+	Needed if platform does not support returning a value from main.
+
+	Valid values :
+	0 - main returns an int, and return value will be 0.
+	1 - platform does not support returning a value from main
+*/
+#ifndef MAIN_HAS_NORETURN
+#define MAIN_HAS_NORETURN 0
+#endif
+
+/* Variable : default_num_contexts
+	Not used for this simple port, must cintain the value 1.
+*/
+extern ee_u32 default_num_contexts;
+
+typedef struct CORE_PORTABLE_S {
+    ee_u8 portable_id;
+} core_portable;
+
+/* target specific init/fini */
+void portable_init(core_portable *p, int *argc, char *argv[]);
+void portable_fini(core_portable *p);
+
+#if !defined(PROFILE_RUN) && !defined(PERFORMANCE_RUN) && !defined(VALIDATION_RUN)
+#if (TOTAL_DATA_SIZE == 1200)
+#define PROFILE_RUN 1
+#elif (TOTAL_DATA_SIZE == 2000)
+#define PERFORMANCE_RUN 1
+#else
+#define VALIDATION_RUN 1
+#endif
+#endif
+
+#endif /* CORE_PORTME_H */

examples/coremark_v1.01/core_state.c

@@ -0,0 +1,277 @@
+/*
+Author : Shay Gal-On, EEMBC
+
+This file is part of  EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 
+All rights reserved.                            
+
+EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the
+CoreMark License that is distributed with the official EEMBC COREMARK Software release. 
+If you received this EEMBC CoreMark Software without the accompanying CoreMark License, 
+you must discontinue use and download the official release from www.coremark.org.  
+
+Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, 
+make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file.
+
+EEMBC 
+4354 Town Center Blvd. Suite 114-200
+El Dorado Hills, CA, 95762 
+*/ 
+#include "coremark.h"
+/* local functions */
+enum CORE_STATE core_state_transition( ee_u8 **instr , ee_u32 *transition_count);
+
+/*
+Topic: Description
+	Simple state machines like this one are used in many embedded products.
+	
+	For more complex state machines, sometimes a state transition table implementation is used instead, 
+	trading speed of direct coding for ease of maintenance.
+	
+	Since the main goal of using a state machine in CoreMark is to excercise the switch/if behaviour,
+	we are using a small moore machine. 
+	
+	In particular, this machine tests type of string input,
+	trying to determine whether the input is a number or something else.
+	(see core_state.png).
+*/
+
+/* Function: core_bench_state
+	Benchmark function
+
+	Go over the input twice, once direct, and once after introducing some corruption. 
+*/
+ee_u16 core_bench_state(ee_u32 blksize, ee_u8 *memblock, 
+		ee_s16 seed1, ee_s16 seed2, ee_s16 step, ee_u16 crc) 
+{
+	ee_u32 final_counts[NUM_CORE_STATES];
+	ee_u32 track_counts[NUM_CORE_STATES];
+	ee_u8 *p=memblock;
+	ee_u32 i;
+
+
+#if CORE_DEBUG
+	ee_printf("State Bench: %d,%d,%d,%04x\n",seed1,seed2,step,crc);
+#endif
+	for (i=0; i<NUM_CORE_STATES; i++) {
+		final_counts[i]=track_counts[i]=0;
+	}
+	/* run the state machine over the input */
+	while (*p!=0) {
+		enum CORE_STATE fstate=core_state_transition(&p,track_counts);
+		final_counts[fstate]++;
+#if CORE_DEBUG
+	ee_printf("%d,",fstate);
+	}
+	ee_printf("\n");
+#else
+	}
+#endif
+	p=memblock;
+	while (p < (memblock+blksize)) { /* insert some corruption */
+		if (*p!=',')
+			*p^=(ee_u8)seed1;
+		p+=step;
+	}
+	p=memblock;
+	/* run the state machine over the input again */
+	while (*p!=0) {
+		enum CORE_STATE fstate=core_state_transition(&p,track_counts);
+		final_counts[fstate]++;
+#if CORE_DEBUG
+	ee_printf("%d,",fstate);
+	}
+	ee_printf("\n");
+#else
+	}
+#endif
+	p=memblock;
+	while (p < (memblock+blksize)) { /* undo corruption is seed1 and seed2 are equal */
+		if (*p!=',')
+			*p^=(ee_u8)seed2;
+		p+=step;
+	}
+	/* end timing */
+	for (i=0; i<NUM_CORE_STATES; i++) {
+		crc=crcu32(final_counts[i],crc);
+		crc=crcu32(track_counts[i],crc);
+	}
+	return crc;
+}
+
+/* Default initialization patterns */
+static ee_u8 *intpat[4]  ={(ee_u8 *)"5012",(ee_u8 *)"1234",(ee_u8 *)"-874",(ee_u8 *)"+122"};
+static ee_u8 *floatpat[4]={(ee_u8 *)"35.54400",(ee_u8 *)".1234500",(ee_u8 *)"-110.700",(ee_u8 *)"+0.64400"};
+static ee_u8 *scipat[4]  ={(ee_u8 *)"5.500e+3",(ee_u8 *)"-.123e-2",(ee_u8 *)"-87e+832",(ee_u8 *)"+0.6e-12"};
+static ee_u8 *errpat[4]  ={(ee_u8 *)"T0.3e-1F",(ee_u8 *)"-T.T++Tq",(ee_u8 *)"1T3.4e4z",(ee_u8 *)"34.0e-T^"};
+
+/* Function: core_init_state
+	Initialize the input data for the state machine.
+
+	Populate the input with several predetermined strings, interspersed.
+	Actual patterns chosen depend on the seed parameter.
+	
+	Note:
+	The seed parameter MUST be supplied from a source that cannot be determined at compile time
+*/
+void core_init_state(ee_u32 size, ee_s16 seed, ee_u8 *p) {
+	ee_u32 total=0,next=0,i;
+	ee_u8 *buf=0;
+#if CORE_DEBUG
+	ee_u8 *start=p;
+	ee_printf("State: %d,%d\n",size,seed);
+#endif
+	size--;
+	next=0;
+	while ((total+next+1)<size) {
+		if (next>0) {
+			for(i=0;i<next;i++)
+				*(p+total+i)=buf[i];
+			*(p+total+i)=',';
+			total+=next+1;
+		}
+		seed++;
+		switch (seed & 0x7) {
+			case 0: /* int */
+			case 1: /* int */
+			case 2: /* int */
+				buf=intpat[(seed>>3) & 0x3];
+				next=4;
+			break;
+			case 3: /* float */
+			case 4: /* float */
+				buf=floatpat[(seed>>3) & 0x3];
+				next=8;
+			break;
+			case 5: /* scientific */
+			case 6: /* scientific */
+				buf=scipat[(seed>>3) & 0x3];
+				next=8;
+			break;
+			case 7: /* invalid */
+				buf=errpat[(seed>>3) & 0x3];
+				next=8;
+			break;
+			default: /* Never happen, just to make some compilers happy */
+			break;
+		}
+	}
+	size++;
+	while (total<size) { /* fill the rest with 0 */
+		*(p+total)=0;
+		total++;
+	}
+#if CORE_DEBUG
+	ee_printf("State Input: %s\n",start);
+#endif
+}
+
+static ee_u8 ee_isdigit(ee_u8 c) {
+	ee_u8 retval;
+	retval = ((c>='0') & (c<='9')) ? 1 : 0;
+	return retval;
+}
+
+/* Function: core_state_transition
+	Actual state machine.
+
+	The state machine will continue scanning until either:
+	1 - an invalid input is detcted.
+	2 - a valid number has been detected.
+	
+	The input pointer is updated to point to the end of the token, and the end state is returned (either specific format determined or invalid).
+*/
+
+enum CORE_STATE core_state_transition( ee_u8 **instr , ee_u32 *transition_count) {
+	ee_u8 *str=*instr;
+	ee_u8 NEXT_SYMBOL;
+	enum CORE_STATE state=CORE_START;
+	for( ; *str && state != CORE_INVALID; str++ ) {
+		NEXT_SYMBOL = *str;
+		if (NEXT_SYMBOL==',') /* end of this input */ {
+			str++;
+			break;
+		}
+		switch(state) {
+		case CORE_START:
+			if(ee_isdigit(NEXT_SYMBOL)) {
+				state = CORE_INT;
+			}
+			else if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) {
+				state = CORE_S1;
+			}
+			else if( NEXT_SYMBOL == '.' ) {
+				state = CORE_FLOAT;
+			}
+			else {
+				state = CORE_INVALID;
+				transition_count[CORE_INVALID]++;
+			}
+			transition_count[CORE_START]++;
+			break;
+		case CORE_S1:
+			if(ee_isdigit(NEXT_SYMBOL)) {
+				state = CORE_INT;
+				transition_count[CORE_S1]++;
+			}
+			else if( NEXT_SYMBOL == '.' ) {
+				state = CORE_FLOAT;
+				transition_count[CORE_S1]++;
+			}
+			else {
+				state = CORE_INVALID;
+				transition_count[CORE_S1]++;
+			}
+			break;
+		case CORE_INT:
+			if( NEXT_SYMBOL == '.' ) {
+				state = CORE_FLOAT;
+				transition_count[CORE_INT]++;
+			}
+			else if(!ee_isdigit(NEXT_SYMBOL)) {
+				state = CORE_INVALID;
+				transition_count[CORE_INT]++;
+			}
+			break;
+		case CORE_FLOAT:
+			if( NEXT_SYMBOL == 'E' || NEXT_SYMBOL == 'e' ) {
+				state = CORE_S2;
+				transition_count[CORE_FLOAT]++;
+			}
+			else if(!ee_isdigit(NEXT_SYMBOL)) {
+				state = CORE_INVALID;
+				transition_count[CORE_FLOAT]++;
+			}
+			break;
+		case CORE_S2:
+			if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) {
+				state = CORE_EXPONENT;
+				transition_count[CORE_S2]++;
+			}
+			else {
+				state = CORE_INVALID;
+				transition_count[CORE_S2]++;
+			}
+			break;
+		case CORE_EXPONENT:
+			if(ee_isdigit(NEXT_SYMBOL)) {
+				state = CORE_SCIENTIFIC;
+				transition_count[CORE_EXPONENT]++;
+			}
+			else {
+				state = CORE_INVALID;
+				transition_count[CORE_EXPONENT]++;
+			}
+			break;
+		case CORE_SCIENTIFIC:
+			if(!ee_isdigit(NEXT_SYMBOL)) {
+				state = CORE_INVALID;
+				transition_count[CORE_INVALID]++;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+	*instr=str;
+	return state;
+}

examples/coremark_v1.01/core_util.c

@@ -0,0 +1,210 @@
+/*
+Author : Shay Gal-On, EEMBC
+
+This file is part of  EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 
+All rights reserved.                            
+
+EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the
+CoreMark License that is distributed with the official EEMBC COREMARK Software release. 
+If you received this EEMBC CoreMark Software without the accompanying CoreMark License, 
+you must discontinue use and download the official release from www.coremark.org.  
+
+Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, 
+make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file.
+
+EEMBC 
+4354 Town Center Blvd. Suite 114-200
+El Dorado Hills, CA, 95762 
+*/ 
+#include "coremark.h"
+/* Function: get_seed
+	Get a values that cannot be determined at compile time.
+
+	Since different embedded systems and compilers are used, 3 different methods are provided:
+	1 - Using a volatile variable. This method is only valid if the compiler is forced to generate code that
+	reads the value of a volatile variable from memory at run time. 
+	Please note, if using this method, you would need to modify core_portme.c to generate training profile.
+	2 - Command line arguments. This is the preferred method if command line arguments are supported.
+	3 - System function. If none of the first 2 methods is available on the platform,
+	a system function which is not a stub can be used.
+	
+	e.g. read the value on GPIO pins connected to switches, or invoke special simulator functions.
+*/
+#if (SEED_METHOD==SEED_VOLATILE)
+	extern volatile ee_s32 seed1_volatile;
+	extern volatile ee_s32 seed2_volatile;
+	extern volatile ee_s32 seed3_volatile;
+	extern volatile ee_s32 seed4_volatile;
+	extern volatile ee_s32 seed5_volatile;
+	ee_s32 get_seed_32(int i) {
+		ee_s32 retval;
+		switch (i) {
+			case 1:
+				retval=seed1_volatile;
+				break;
+			case 2:
+				retval=seed2_volatile;
+				break;
+			case 3:
+				retval=seed3_volatile;
+				break;
+			case 4:
+				retval=seed4_volatile;
+				break;
+			case 5:
+				retval=seed5_volatile;
+				break;
+			default:
+				retval=0;
+				break;
+		}
+		return retval;
+	}
+#elif (SEED_METHOD==SEED_ARG)
+ee_s32 parseval(char *valstring) {
+	ee_s32 retval=0;
+	ee_s32 neg=1;
+	int hexmode=0;
+	if (*valstring == '-') {
+		neg=-1;
+		valstring++;
+	}
+	if ((valstring[0] == '0') && (valstring[1] == 'x')) {
+		hexmode=1;
+		valstring+=2;
+	}
+		/* first look for digits */
+	if (hexmode) {
+		while (((*valstring >= '0') && (*valstring <= '9')) || ((*valstring >= 'a') && (*valstring <= 'f'))) {
+			ee_s32 digit=*valstring-'0';
+			if (digit>9)
+				digit=10+*valstring-'a';
+			retval*=16;
+			retval+=digit;
+			valstring++;
+		}
+	} else {
+		while ((*valstring >= '0') && (*valstring <= '9')) {
+			ee_s32 digit=*valstring-'0';
+			retval*=10;
+			retval+=digit;
+			valstring++;
+		}
+	}
+	/* now add qualifiers */
+	if (*valstring=='K')
+		retval*=1024;
+	if (*valstring=='M')
+		retval*=1024*1024;
+
+	retval*=neg;
+	return retval;
+}
+
+ee_s32 get_seed_args(int i, int argc, char *argv[]) {
+	if (argc>i)
+		return parseval(argv[i]);
+	return 0;
+}
+
+#elif (SEED_METHOD==SEED_FUNC)
+/* If using OS based function, you must define and implement the functions below in core_portme.h and core_portme.c ! */
+ee_s32 get_seed_32(int i) {
+	ee_s32 retval;
+	switch (i) {
+		case 1:
+			retval=portme_sys1();
+			break;
+		case 2:
+			retval=portme_sys2();
+			break;
+		case 3:
+			retval=portme_sys3();
+			break;
+		case 4:
+			retval=portme_sys4();
+			break;
+		case 5:
+			retval=portme_sys5();
+			break;
+		default:
+			retval=0;
+			break;
+	}
+	return retval;
+}
+#endif
+
+/* Function: crc*
+	Service functions to calculate 16b CRC code.
+
+*/
+ee_u16 crcu8(ee_u8 data, ee_u16 crc )
+{
+	ee_u8 i=0,x16=0,carry=0;
+
+	for (i = 0; i < 8; i++)
+    {
+		x16 = (ee_u8)((data & 1) ^ ((ee_u8)crc & 1));
+		data >>= 1;
+
+		if (x16 == 1)
+		{
+		   crc ^= 0x4002;
+		   carry = 1;
+		}
+		else 
+			carry = 0;
+		crc >>= 1;
+		if (carry)
+		   crc |= 0x8000;
+		else
+		   crc &= 0x7fff;
+    }
+	return crc;
+} 
+ee_u16 crcu16(ee_u16 newval, ee_u16 crc) {
+	crc=crcu8( (ee_u8) (newval)				,crc);
+	crc=crcu8( (ee_u8) ((newval)>>8)	,crc);
+	return crc;
+}
+ee_u16 crcu32(ee_u32 newval, ee_u16 crc) {
+	crc=crc16((ee_s16) newval		,crc);
+	crc=crc16((ee_s16) (newval>>16)	,crc);
+	return crc;
+}
+ee_u16 crc16(ee_s16 newval, ee_u16 crc) {
+	return crcu16((ee_u16)newval, crc);
+}
+
+ee_u8 check_data_types() {
+	ee_u8 retval=0;
+	if (sizeof(ee_u8) != 1) {
+		ee_printf("ERROR: ee_u8 is not an 8b datatype!\n");
+		retval++;
+	}
+	if (sizeof(ee_u16) != 2) {
+		ee_printf("ERROR: ee_u16 is not a 16b datatype!\n");
+		retval++;
+	}
+	if (sizeof(ee_s16) != 2) {
+		ee_printf("ERROR: ee_s16 is not a 16b datatype!\n");
+		retval++;
+	}
+	if (sizeof(ee_s32) != 4) {
+		ee_printf("ERROR: ee_s32 is not a 32b datatype!\n");
+		retval++;
+	}
+	if (sizeof(ee_u32) != 4) {
+		ee_printf("ERROR: ee_u32 is not a 32b datatype!\n");
+		retval++;
+	}
+	if (sizeof(ee_ptr_int) != sizeof(int *)) {
+		ee_printf("ERROR: ee_ptr_int is not a datatype that holds an int pointer!\n");
+		retval++;
+	}
+	if (retval>0) {
+		ee_printf("ERROR: Please modify the datatypes in core_portme.h!\n");
+	}
+	return retval;
+}

examples/coremark_v1.01/coremark.h

@@ -0,0 +1,174 @@
+/*
+Author : Shay Gal-On, EEMBC
+
+This file is part of  EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 
+All rights reserved.                            
+
+EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the
+CoreMark License that is distributed with the official EEMBC COREMARK Software release. 
+If you received this EEMBC CoreMark Software without the accompanying CoreMark License, 
+you must discontinue use and download the official release from www.coremark.org.  
+
+Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, 
+make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file.
+
+EEMBC 
+4354 Town Center Blvd. Suite 114-200
+El Dorado Hills, CA, 95762 
+*/ 
+/* Topic: Description
+	This file contains  declarations of the various benchmark functions.
+*/
+
+/* Configuration: TOTAL_DATA_SIZE
+	Define total size for data algorithms will operate on
+*/
+#ifndef TOTAL_DATA_SIZE 
+#define TOTAL_DATA_SIZE 2*1000
+#endif
+
+#define SEED_ARG 0
+#define SEED_FUNC 1
+#define SEED_VOLATILE 2
+
+#define MEM_STATIC 0
+#define MEM_MALLOC 1
+#define MEM_STACK 2
+
+#include "core_portme.h"
+
+#if HAS_STDIO
+#include <stdio.h>
+#endif
+#if HAS_PRINTF
+#define ee_printf printf
+#endif
+
+/* Actual benchmark execution in iterate */
+void *iterate(void *pres);
+
+/* Typedef: secs_ret
+	For machines that have floating point support, get number of seconds as a double. 
+	Otherwise an unsigned int.
+*/
+#if HAS_FLOAT
+typedef double secs_ret;
+#else
+typedef ee_u32 secs_ret;
+#endif
+
+#if MAIN_HAS_NORETURN
+#define MAIN_RETURN_VAL 
+#define MAIN_RETURN_TYPE void
+#else
+#define MAIN_RETURN_VAL 0
+#define MAIN_RETURN_TYPE int
+#endif 
+
+void start_time(void);
+void stop_time(void);
+CORE_TICKS get_time(void);
+secs_ret time_in_secs(CORE_TICKS ticks);
+
+/* Misc useful functions */
+ee_u16 crcu8(ee_u8 data, ee_u16 crc);
+ee_u16 crc16(ee_s16 newval, ee_u16 crc);
+ee_u16 crcu16(ee_u16 newval, ee_u16 crc);
+ee_u16 crcu32(ee_u32 newval, ee_u16 crc);
+ee_u8 check_data_types();
+void *portable_malloc(ee_size_t size);
+void portable_free(void *p);
+ee_s32 parseval(char *valstring);
+
+/* Algorithm IDS */
+#define ID_LIST 	(1<<0)
+#define ID_MATRIX 	(1<<1)
+#define ID_STATE 	(1<<2)
+#define ALL_ALGORITHMS_MASK (ID_LIST|ID_MATRIX|ID_STATE)
+#define NUM_ALGORITHMS 3
+
+/* list data structures */
+typedef struct list_data_s {
+	ee_s16 data16;
+	ee_s16 idx;
+} list_data;
+
+typedef struct list_head_s {
+	struct list_head_s *next;
+	struct list_data_s *info;
+} list_head;
+
+
+/*matrix benchmark related stuff */
+#define MATDAT_INT 1
+#if MATDAT_INT
+typedef ee_s16 MATDAT;
+typedef ee_s32 MATRES;
+#else
+typedef ee_f16 MATDAT;
+typedef ee_f32 MATRES;
+#endif
+
+typedef struct MAT_PARAMS_S {
+	int N;
+	MATDAT *A;
+	MATDAT *B;
+	MATRES *C;
+} mat_params;
+
+/* state machine related stuff */
+/* List of all the possible states for the FSM */
+typedef enum CORE_STATE {
+	CORE_START=0,
+	CORE_INVALID,
+	CORE_S1,
+	CORE_S2,
+	CORE_INT,
+	CORE_FLOAT,
+	CORE_EXPONENT,
+	CORE_SCIENTIFIC,
+	NUM_CORE_STATES
+} core_state_e ;
+
+		
+/* Helper structure to hold results */
+typedef struct RESULTS_S {
+	/* inputs */
+	ee_s16	seed1;		/* Initializing seed */
+	ee_s16	seed2;		/* Initializing seed */
+	ee_s16	seed3;		/* Initializing seed */
+	void	*memblock[4];	/* Pointer to safe memory location */
+	ee_u32	size;		/* Size of the data */
+	ee_u32 iterations;		/* Number of iterations to execute */
+	ee_u32	execs;		/* Bitmask of operations to execute */
+	struct list_head_s *list;
+	mat_params mat;
+	/* outputs */
+	ee_u16	crc;
+	ee_u16	crclist;
+	ee_u16	crcmatrix;
+	ee_u16	crcstate;
+	ee_s16	err;
+	/* ultithread specific */
+	core_portable port;
+} core_results;
+
+/* Multicore execution handling */
+#if (MULTITHREAD>1)
+ee_u8 core_start_parallel(core_results *res);
+ee_u8 core_stop_parallel(core_results *res);
+#endif
+
+/* list benchmark functions */
+list_head *core_list_init(ee_u32 blksize, list_head *memblock, ee_s16 seed);
+ee_u16 core_bench_list(core_results *res, ee_s16 finder_idx);
+
+/* state benchmark functions */
+void core_init_state(ee_u32 size, ee_s16 seed, ee_u8 *p);
+ee_u16 core_bench_state(ee_u32 blksize, ee_u8 *memblock, 
+		ee_s16 seed1, ee_s16 seed2, ee_s16 step, ee_u16 crc);
+
+/* matrix benchmark functions */
+ee_u32 core_init_matrix(ee_u32 blksize, void *memblk, ee_s32 seed, mat_params *p);
+ee_u16 core_bench_matrix(mat_params *p, ee_s16 seed, ee_u16 crc);
+

examples/coremark_v1.01/main.c

@@ -0,0 +1,15 @@
+#include "bflb_mtimer.h"
+#include "board.h"
+
+extern void core_mark();
+
+int main(void)
+{
+    board_init();
+
+    core_mark();
+
+    while (1) {
+        bflb_mtimer_delay_ms(1000);
+    }
+}

examples/coremark_v1.01/proj.conf

@@ -0,0 +1,2 @@
+set(CONFIG_VLIBC 0)
+set(CONFIG_BFLOG 0)

examples/peripherals/mjpeg/mjpeg_no_camera/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.15)
+
+include(proj.conf)
+
+find_package(bouffalo_sdk REQUIRED HINTS $ENV{BL_SDK_BASE})
+
+target_sources(app PRIVATE jpeg_head.c)
+
+sdk_set_main_file(main.c)
+
+project(mjpeg_no_camera)

examples/peripherals/mjpeg/mjpeg_no_camera/Makefile

@@ -0,0 +1,13 @@
+SDK_DEMO_PATH ?= .
+BL_SDK_BASE ?= $(SDK_DEMO_PATH)/../../../..
+
+export BL_SDK_BASE
+
+CHIP ?= bl616
+BOARD ?= bl616dk
+CROSS_COMPILE ?= riscv64-unknown-elf-
+
+# add custom cmake definition
+#cmake_definition+=-Dxxx=sss
+
+include $(BL_SDK_BASE)/project.build

examples/peripherals/mjpeg/mjpeg_no_camera/jpeg_head.c

@@ -0,0 +1,195 @@
+#include "jpeg_head.h"
+
+static const uint8_t tableQy[] = {
+	16, 11, 12, 14, 12, 10, 16, 14,
+	13, 14, 18, 17, 16, 19, 24, 40,
+	26, 24, 22, 22, 24, 49, 35, 37,
+	29, 40, 58, 51, 61, 60, 57, 51,
+	56, 55, 64, 72, 92, 78, 64, 68,
+	87, 69, 55, 56, 80, 109, 81, 87,
+	95, 98, 103, 104, 103, 62, 77, 113,
+	121, 112, 100, 120, 92, 101, 103, 99
+};
+
+static const uint8_t tableQuv[] = {
+	17, 18, 18, 24, 21, 24, 47, 26,
+	26, 47, 99, 66, 56, 66, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99
+};
+
+static const uint8_t tableHuffman[] = {
+	0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 
+	0x0B, 
+
+	0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00,	0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 
+	0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,	0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 
+	0x06, 0x13, 0x51, 0x61, 0x07, 0x22,	0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 
+	0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24,	0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 
+	0x1A, 0x25, 0x26, 0x27, 0x28, 0x29,	0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 
+	0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,	0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 
+	0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,	0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 
+	0x85, 0x86, 0x87, 0x88, 0x89, 0x8A,	0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 
+	0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,	0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 
+	0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6,	0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 
+	0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3,	0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 
+	0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,	0xFA, 
+
+	0xFF, 0xC4, 0x00, 0x1F, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 
+	0x0B, 
+
+	0xFF, 0xC4, 0x00, 0xB5, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07,	0x05, 0x04, 
+	0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31,	0x06, 0x12, 
+	0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1,	0xB1, 0xC1, 
+	0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1,	0x25, 0xF1, 
+	0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0X2A, 0x35, 0x36, 0x37, 0x38, 0x39,	0x3A, 0x43, 
+	0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,	0x5A, 0x63, 
+	0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,	0x7A, 0x82, 
+	0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,	0x98, 0x99, 
+	0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5,	0xB6, 0xB7, 
+	0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,	0xD4, 0xD5, 
+	0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,	0xF2, 0xF3, 
+	0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA
+};
+
+static void QCalc(const uint8_t *in, uint8_t *out, uint8_t q)
+{
+	float tq, result;
+	int i;
+
+	if (q < 1)
+		tq = 5000.0f;
+	else if (q <= 50)
+		tq = 5000.0f / q;
+	else if (q <= 100)
+		tq = 200.0f - 2.0f * q;
+	else
+		tq = 0.0f;
+	tq = tq / 100.0f;
+
+	for (i = 0; i < 64; i++)
+	{
+		result = in[i] * tq;
+		if (result > 255.0f)
+			out[i] = 255;
+		else if (result < 1.0f)
+			out[i] = 1;
+		else
+			out[i] = (uint8_t)(result + 0.5f);
+	}
+}
+
+uint32_t JpegHeadCreate(uint8_t type, uint8_t q, int width, int height, uint8_t *out)
+{
+	uint32_t index = 0;
+	uint32_t i;
+	/* start of jpeg file */
+	out[index++] = 0xFF;
+	out[index++] = 0xD8;
+
+	/* define quality table */
+	out[index++] = 0xFF;
+	out[index++] = 0xDB;
+	out[index++] = 0x00;
+	out[index++] = 0x43;		//=3+N, N=64
+	out[index++] = 0x00;
+	QCalc(tableQy, out + index, q);		//Y quality table
+	index += 64;
+	out[index++] = 0xFF;
+	out[index++] = 0xDB;
+	out[index++] = 0x00;
+	out[index++] = 0x43;		//=3+N, N=64
+	out[index++] = 0x01;
+	QCalc(tableQuv, out + index, q);	//UV quality table
+	index += 64;
+
+	/* basic information of mjpeg */
+	out[index++] = 0xFF;
+	out[index++] = 0xC0;
+	out[index++] = 0x00;
+	if(type==YUV_MODE_400)
+		out[index++] = 0x0B;	//length:2 + bits:1 + height:2 + width:2 + num:1 + 3 * part=1
+	else
+		out[index++] = 0x11;	//length:2 + bits:1 + height:2 + width:2 + num:1 + 3 * part=3
+	out[index++] = 0x08;
+	out[index++] = (uint8_t)((height >> 8) & 0xFF);
+	out[index++] = (uint8_t)(height & 0xFF);
+	out[index++] = (uint8_t)((width >> 8) & 0xFF);
+	out[index++] = (uint8_t)(width & 0xFF);
+	if (type == YUV_MODE_400)
+	{
+		out[index++] = 0x01;	//number of part
+		out[index++] = 0x01;	//the first part id
+		out[index++] = 0x11;	//[0:3]vertical sample coefficient, [4:7]horizontal sample coefficient
+		out[index++] = 0x00;	//id of quality tab
+	}
+	else if (type == YUV_MODE_420)
+	{
+		out[index++] = 0x03;	//number of part
+		out[index++] = 0x01;	//the first part id
+		out[index++] = 0x22;	//[0:3]vertical sample coefficient, [4:7]horizontal sample coefficient
+		out[index++] = 0x00;	//id of quality tab
+		out[index++] = 0x02;	//the second part id
+		out[index++] = 0x11;	//[0:3]vertical sample coefficient, [4:7]horizontal sample coefficient
+		out[index++] = 0x01;	//id of quality tab
+		out[index++] = 0x03;	//the third part id
+		out[index++] = 0x11;	//[0:3]vertical sample coefficient, [4:7]horizontal sample coefficient
+		out[index++] = 0x01;	//id of quality tab
+	}
+	else if (type == YUV_MODE_422)
+	{
+		out[index++] = 0x03;	//number of part
+		out[index++] = 0x01;	//the first part id
+		out[index++] = 0x21;	//[0:3]vertical sample coefficient, [4:7]horizontal sample coefficient
+		out[index++] = 0x00;	//id of quality tab
+		out[index++] = 0x02;	//the second part id
+		out[index++] = 0x11;	//[0:3]vertical sample coefficient, [4:7]horizontal sample coefficient
+		out[index++] = 0x01;	//id of quality tab
+		out[index++] = 0x03;	//the third part id
+		out[index++] = 0x11;	//[0:3]vertical sample coefficient, [4:7]horizontal sample coefficient
+		out[index++] = 0x01;	//id of quality tab
+	}
+
+	/* define Huffman table */
+	for (i = 0; i < sizeof(tableHuffman); i++)
+	{
+		out[index++] = tableHuffman[i];
+	}
+	
+	/* start of scan*/
+	out[index++] = 0xFF;
+	out[index++] = 0xDA;
+	if (type == YUV_MODE_400)
+	{
+		out[index++] = 0x00;
+		out[index++] = 0x08;	//length
+		out[index++] = 0x01;
+		out[index++] = 0x01;
+		out[index++] = 0x00;
+		out[index++] = 0x02;
+		out[index++] = 0x3F;
+		out[index++] = 0x00;
+	}
+	else
+	{
+		out[index++] = 0x00;
+		out[index++] = 0x0C;	//length
+		out[index++] = 0x03;
+		out[index++] = 0x01;
+		out[index++] = 0x00;
+		out[index++] = 0x02;
+		out[index++] = 0x11;
+		out[index++] = 0x03;
+		out[index++] = 0x11;
+		out[index++] = 0x00;
+		out[index++] = 0x3F;
+		out[index++] = 0x00;
+	}
+	return index;
+}

examples/peripherals/mjpeg/mjpeg_no_camera/jpeg_head.h

@@ -0,0 +1,12 @@
+#ifndef __JPEG_HEAD_H__
+#define __JPEG_HEAD_H__
+
+#include "stdint.h"
+
+#define YUV_MODE_400				1
+#define YUV_MODE_420				2
+#define YUV_MODE_422				3
+
+extern uint32_t JpegHeadCreate(uint8_t type, uint8_t q, int width, int height, uint8_t *out);
+
+#endif /* __JPEG_HEAD_H__ */

examples/peripherals/mjpeg/mjpeg_no_camera/main.c

@@ -0,0 +1,122 @@
+#include "bflb_mtimer.h"
+#include "bflb_mjpeg.h"
+#include "board.h"
+#include "jpeg_head.h"
+#include "test_64x64.h"
+
+static struct bflb_device_s *mjpeg;
+
+#define X 64
+#define Y 64
+
+volatile uint32_t pic_count = 0;
+volatile uint32_t pic_addr[MJPEG_MAX_FRAME_COUNT] = { 0 };
+volatile uint32_t pic_len[MJPEG_MAX_FRAME_COUNT] = { 0 };
+
+uint8_t *pic;
+volatile uint32_t jpeg_len;
+
+void mjpeg_isr(int irq, void *arg)
+{
+    uint32_t intstatus = bflb_mjpeg_get_intstatus(mjpeg);
+    if (intstatus & MJPEG_INTSTS_ONE_FRAME) {
+        jpeg_len = bflb_mjpeg_get_frame_info(mjpeg, &pic);
+        pic_addr[pic_count] = (uint32_t)pic;
+        pic_len[pic_count] = jpeg_len;
+        pic_count++;
+        bflb_mjpeg_pop_one_frame(mjpeg);
+        bflb_mjpeg_int_clear(mjpeg, MJPEG_INTCLR_ONE_FRAME);
+    }
+}
+
+static uint16_t Q_Table_50_Y[64] = {
+    16, 11, 10, 16, 24, 40, 51, 61,
+    12, 12, 14, 19, 26, 58, 60, 55,
+    14, 13, 16, 24, 40, 57, 69, 56,
+    14, 17, 22, 29, 51, 87, 80, 62,
+    18, 22, 37, 56, 68, 109, 103, 77,
+    24, 35, 55, 64, 81, 104, 113, 92,
+    49, 64, 78, 87, 103, 121, 120, 101,
+    72, 92, 95, 98, 112, 100, 103, 99
+};
+
+static uint16_t Q_Table_50_UV[64] = {
+    17, 18, 24, 47, 99, 99, 99, 99,
+    18, 21, 26, 66, 99, 99, 99, 99,
+    24, 26, 56, 99, 99, 99, 99, 99,
+    47, 66, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99
+};
+
+uint8_t jpgHeadBuf[800] = { 0 };
+uint32_t jpgHeadLength;
+
+uint8_t MJPEG_QUALITY = 50;
+
+#define BUFFER_YUV  0xA8000000
+#define SIZE_BUFFER (4 * 1024 * 1024)
+
+void bflb_mjpeg_dump_hex(uint8_t *data, uint32_t len)
+{
+    uint32_t i = 0;
+
+    for (i = 0; i < len; i++) {
+        if (i % 16 == 0) {
+            printf("\r\n");
+        }
+
+        printf("%02x ", data[i]);
+    }
+
+    printf("\r\n");
+}
+
+int main(void)
+{
+    uint16_t tmpTableY[64] = { 0 };
+    uint16_t tmpTableUV[64] = { 0 };
+
+    board_init();
+
+    mjpeg = bflb_device_get_by_name("mjpeg");
+
+    struct bflb_mjpeg_config_s config;
+
+    config.format = MJPEG_FORMAT_YUV422_YUYV;
+    config.resolution_x = X;
+    config.resolution_y = Y;
+    config.input_bufaddr0 = (uint32_t)test_64x64;
+    config.input_bufaddr1 = 0;
+    config.output_bufaddr = (uint32_t)BUFFER_YUV + MJPEG_MAX_FRAME_COUNT * X * Y * 2;
+    config.output_bufsize = SIZE_BUFFER - MJPEG_MAX_FRAME_COUNT * X * Y * 2;
+
+    bflb_mjpeg_init(mjpeg, &config);
+
+    bflb_mjpeg_calculate_quantize_table(MJPEG_QUALITY, Q_Table_50_Y, tmpTableY);
+    bflb_mjpeg_calculate_quantize_table(MJPEG_QUALITY, Q_Table_50_UV, tmpTableUV);
+    bflb_mjpeg_fill_quantize_table(mjpeg, tmpTableY, tmpTableUV);
+    jpgHeadLength = JpegHeadCreate(YUV_MODE_422, MJPEG_QUALITY, X, Y, jpgHeadBuf);
+    bflb_mjpeg_fill_jpeg_header_tail(mjpeg, jpgHeadBuf, jpgHeadLength);
+
+    bflb_mjpeg_tcint_mask(mjpeg, false);
+    bflb_irq_attach(mjpeg->irq_num, mjpeg_isr, NULL);
+    bflb_irq_enable(mjpeg->irq_num);
+
+    bflb_mjpeg_sw_run(mjpeg, MJPEG_MAX_FRAME_COUNT);
+
+    while (pic_count < MJPEG_MAX_FRAME_COUNT) {
+        bflb_mtimer_delay_ms(200);
+    }
+
+    for (uint8_t i = 0; i < MJPEG_MAX_FRAME_COUNT; i++) {
+        printf("jpg addr:%08x ,jpg size:%d\r\n", pic_addr[i], pic_len[i]);
+        bflb_mjpeg_dump_hex((uint8_t *)pic_addr[i], pic_len[i]);
+    }
+
+    while (1) {
+        bflb_mtimer_delay_ms(2000);
+    }
+}

examples/peripherals/mjpeg/mjpeg_no_camera/proj.conf

@@ -0,0 +1 @@
+set(CONFIG_PSRAM 1)

examples/peripherals/usbdev/usbd_audio_v1_mic_speaker_multichan/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.15)
+
+include(proj.conf)
+
+find_package(bouffalo_sdk REQUIRED HINTS $ENV{BL_SDK_BASE})
+
+sdk_add_include_directories(.)
+
+target_sources(app PRIVATE audio_v1_mic_speaker_multichan_template.c)
+sdk_set_main_file(main.c)
+
+project(usbd_audio_v1_mic_speaker_multichan)

examples/peripherals/usbdev/usbd_audio_v1_mic_speaker_multichan/Makefile

@@ -0,0 +1,13 @@
+SDK_DEMO_PATH ?= .
+BL_SDK_BASE ?= $(SDK_DEMO_PATH)/../../../..
+
+export BL_SDK_BASE
+
+CHIP ?= bl616
+BOARD ?= bl616dk
+CROSS_COMPILE ?= riscv64-unknown-elf-
+
+# add custom cmake definition
+#cmake_definition+=-Dxxx=sss
+
+include $(BL_SDK_BASE)/project.build

examples/peripherals/usbdev/usbd_audio_v1_mic_speaker_multichan/audio_v1_mic_speaker_multichan_template.c

@@ -0,0 +1,226 @@
+#include "usbd_core.h"
+#include "usbd_audio.h"
+
+#define USBD_VID           0xffff
+#define USBD_PID           0xffff
+#define USBD_MAX_POWER     100
+#define USBD_LANGID_STRING 1033
+
+#ifdef CONFIG_USB_HS
+#define EP_INTERVAL 0x04
+#else
+#define EP_INTERVAL 0x01
+#endif
+
+#define AUDIO_IN_EP  0x81
+#define AUDIO_OUT_EP 0x02
+
+/* AUDIO Class Config */
+#define AUDIO_FREQ 16000U
+
+#define AUDIO_SAMPLE_FREQ(frq) (uint8_t)(frq), (uint8_t)((frq >> 8)), (uint8_t)((frq >> 16))
+
+/* AudioFreq * DataSize (2 bytes) * NumChannels (Stereo: 2) */
+#define AUDIO_OUT_PACKET ((uint32_t)((AUDIO_FREQ * 2 * 2) / 1000))
+/* 16bit(2 Bytes) 双声道(Mono:2) */
+#define AUDIO_IN_PACKET ((uint32_t)((AUDIO_FREQ * 2 * 2) / 1000))
+
+#define USB_AUDIO_CONFIG_DESC_SIZ (unsigned long)(9 +                                       \
+                                                  AUDIO_AC_DESCRIPTOR_INIT_LEN(2) +         \
+                                                  AUDIO_SIZEOF_AC_INPUT_TERMINAL_DESC +     \
+                                                  AUDIO_SIZEOF_AC_FEATURE_UNIT_DESC(2, 1) + \
+                                                  AUDIO_SIZEOF_AC_OUTPUT_TERMINAL_DESC +    \
+                                                  AUDIO_SIZEOF_AC_INPUT_TERMINAL_DESC +     \
+                                                  AUDIO_SIZEOF_AC_FEATURE_UNIT_DESC(2, 1) + \
+                                                  AUDIO_SIZEOF_AC_OUTPUT_TERMINAL_DESC +    \
+                                                  AUDIO_AS_DESCRIPTOR_INIT_LEN(1) +         \
+                                                  AUDIO_AS_DESCRIPTOR_INIT_LEN(1))
+
+#define AUDIO_AC_SIZ (AUDIO_SIZEOF_AC_HEADER_DESC(2) +          \
+                      AUDIO_SIZEOF_AC_INPUT_TERMINAL_DESC +     \
+                      AUDIO_SIZEOF_AC_FEATURE_UNIT_DESC(2, 1) + \
+                      AUDIO_SIZEOF_AC_OUTPUT_TERMINAL_DESC +    \
+                      AUDIO_SIZEOF_AC_INPUT_TERMINAL_DESC +     \
+                      AUDIO_SIZEOF_AC_FEATURE_UNIT_DESC(2, 1) + \
+                      AUDIO_SIZEOF_AC_OUTPUT_TERMINAL_DESC)
+
+const uint8_t audio_descriptor[] = {
+    USB_DEVICE_DESCRIPTOR_INIT(USB_2_0, 0xef, 0x02, 0x01, USBD_VID, USBD_PID, 0x0001, 0x01),
+    USB_CONFIG_DESCRIPTOR_INIT(USB_AUDIO_CONFIG_DESC_SIZ, 0x03, 0x01, USB_CONFIG_BUS_POWERED, USBD_MAX_POWER),
+    AUDIO_AC_DESCRIPTOR_INIT(0x00, 0x03, AUDIO_AC_SIZ, 0x00, 0x01, 0x02),
+    AUDIO_AC_INPUT_TERMINAL_DESCRIPTOR_INIT(0x01, AUDIO_INTERM_MIC, 0x02, 0x0003),
+    AUDIO_AC_FEATURE_UNIT_DESCRIPTOR_INIT(0x02, 0x01, 0x01, 0x03, 0x00),
+    AUDIO_AC_OUTPUT_TERMINAL_DESCRIPTOR_INIT(0x03, AUDIO_TERMINAL_STREAMING, 0x02),
+    AUDIO_AC_INPUT_TERMINAL_DESCRIPTOR_INIT(0x04, AUDIO_TERMINAL_STREAMING, 0x02, 0x0003),
+    AUDIO_AC_FEATURE_UNIT_DESCRIPTOR_INIT(0x05, 0x04, 0x01, 0x03, 0x00),
+    AUDIO_AC_OUTPUT_TERMINAL_DESCRIPTOR_INIT(0x06, AUDIO_OUTTERM_SPEAKER, 0x05),
+    AUDIO_AS_DESCRIPTOR_INIT(0x01, 0x04, 0x02, AUDIO_OUT_EP, AUDIO_OUT_PACKET, EP_INTERVAL, AUDIO_SAMPLE_FREQ_3B(AUDIO_FREQ)),
+    AUDIO_AS_DESCRIPTOR_INIT(0x02, 0x03, 0x02, AUDIO_IN_EP, AUDIO_IN_PACKET, EP_INTERVAL, AUDIO_SAMPLE_FREQ_3B(AUDIO_FREQ)),
+    ///////////////////////////////////////
+    /// string0 descriptor
+    ///////////////////////////////////////
+    USB_LANGID_INIT(USBD_LANGID_STRING),
+    ///////////////////////////////////////
+    /// string1 descriptor
+    ///////////////////////////////////////
+    0x14,                       /* bLength */
+    USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+    'C', 0x00,                  /* wcChar0 */
+    'h', 0x00,                  /* wcChar1 */
+    'e', 0x00,                  /* wcChar2 */
+    'r', 0x00,                  /* wcChar3 */
+    'r', 0x00,                  /* wcChar4 */
+    'y', 0x00,                  /* wcChar5 */
+    'U', 0x00,                  /* wcChar6 */
+    'S', 0x00,                  /* wcChar7 */
+    'B', 0x00,                  /* wcChar8 */
+    ///////////////////////////////////////
+    /// string2 descriptor
+    ///////////////////////////////////////
+    0x26,                       /* bLength */
+    USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+    'C', 0x00,                  /* wcChar0 */
+    'h', 0x00,                  /* wcChar1 */
+    'e', 0x00,                  /* wcChar2 */
+    'r', 0x00,                  /* wcChar3 */
+    'r', 0x00,                  /* wcChar4 */
+    'y', 0x00,                  /* wcChar5 */
+    'U', 0x00,                  /* wcChar6 */
+    'S', 0x00,                  /* wcChar7 */
+    'B', 0x00,                  /* wcChar8 */
+    ' ', 0x00,                  /* wcChar9 */
+    'U', 0x00,                  /* wcChar10 */
+    'A', 0x00,                  /* wcChar11 */
+    'C', 0x00,                  /* wcChar12 */
+    ' ', 0x00,                  /* wcChar13 */
+    'D', 0x00,                  /* wcChar14 */
+    'E', 0x00,                  /* wcChar15 */
+    'M', 0x00,                  /* wcChar16 */
+    'O', 0x00,                  /* wcChar17 */
+    ///////////////////////////////////////
+    /// string3 descriptor
+    ///////////////////////////////////////
+    0x16,                       /* bLength */
+    USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+    '2', 0x00,                  /* wcChar0 */
+    '0', 0x00,                  /* wcChar1 */
+    '2', 0x00,                  /* wcChar2 */
+    '1', 0x00,                  /* wcChar3 */
+    '0', 0x00,                  /* wcChar4 */
+    '3', 0x00,                  /* wcChar5 */
+    '1', 0x00,                  /* wcChar6 */
+    '0', 0x00,                  /* wcChar7 */
+    '0', 0x00,                  /* wcChar8 */
+    '1', 0x00,                  /* wcChar9 */
+#ifdef CONFIG_USB_HS
+    ///////////////////////////////////////
+    /// device qualifier descriptor
+    ///////////////////////////////////////
+    0x0a,
+    USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER,
+    0x00,
+    0x02,
+    0x00,
+    0x00,
+    0x00,
+    0x40,
+    0x01,
+    0x00,
+#endif
+    0x00
+};
+
+volatile bool tx_flag = 0;
+volatile bool rx_flag = 0;
+
+void usbd_audio_open(uint8_t intf)
+{
+    if (intf == 1) {
+        rx_flag = 1;
+        printf("OPEN1\r\n");
+    } else {
+        tx_flag = 1;
+        printf("OPEN2\r\n");
+    }
+}
+void usbd_audio_close(uint8_t intf)
+{
+    if (intf == 1) {
+        rx_flag = 1;
+        printf("CLOSE1\r\n");
+    } else {
+        tx_flag = 0;
+        printf("CLOSE2\r\n");
+    }
+}
+
+#ifdef CONFIG_USB_HS
+#define AUDIO_OUT_EP_MPS 512
+#else
+#define AUDIO_OUT_EP_MPS 64
+#endif
+
+USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[2048];
+USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t out_buffer[AUDIO_OUT_PACKET];
+
+volatile bool ep_tx_busy_flag = false;
+
+void usbd_configure_done_callback(void)
+{
+    /* setup first out ep read transfer */
+    usbd_ep_start_read(AUDIO_OUT_EP, out_buffer, AUDIO_OUT_PACKET);
+}
+
+void usbd_audio_out_callback(uint8_t ep, uint32_t nbytes)
+{
+    USB_LOG_RAW("actual out len:%d\r\n", nbytes);
+    usbd_ep_start_read(AUDIO_OUT_EP, out_buffer, AUDIO_OUT_PACKET);
+}
+
+void usbd_audio_in_callback(uint8_t ep, uint32_t nbytes)
+{
+    USB_LOG_RAW("actual in len:%d\r\n", nbytes);
+    ep_tx_busy_flag = false;
+}
+
+static struct usbd_endpoint audio_in_ep = {
+    .ep_cb = usbd_audio_in_callback,
+    .ep_addr = AUDIO_IN_EP
+};
+
+static struct usbd_endpoint audio_out_ep = {
+    .ep_cb = usbd_audio_out_callback,
+    .ep_addr = AUDIO_OUT_EP
+};
+
+struct usbd_interface intf0;
+struct usbd_interface intf1;
+struct usbd_interface intf2;
+
+void audio_init()
+{
+    usbd_desc_register(audio_descriptor);
+    usbd_add_interface(usbd_audio_init_intf(&intf0));
+    usbd_add_interface(usbd_audio_init_intf(&intf1));
+    usbd_add_interface(usbd_audio_init_intf(&intf2));
+    usbd_add_endpoint(&audio_in_ep);
+    usbd_add_endpoint(&audio_out_ep);
+
+    usbd_audio_add_entity(0x02, AUDIO_CONTROL_FEATURE_UNIT);
+    usbd_audio_add_entity(0x05, AUDIO_CONTROL_FEATURE_UNIT);
+
+    usbd_initialize();
+}
+
+void audio_test()
+{
+    while (1) {
+        if (tx_flag) {
+           memset(write_buffer, 'a', 2048);
+           ep_tx_busy_flag = true;
+           usbd_ep_start_write(AUDIO_IN_EP, write_buffer, 2048);
+           while (ep_tx_busy_flag) {
+           }
+        }
+    }
+}

examples/peripherals/usbdev/usbd_audio_v1_mic_speaker_multichan/main.c

@@ -0,0 +1,16 @@
+#include "usbh_core.h"
+#include "bflb_mtimer.h"
+#include "board.h"
+
+extern void audio_init(void);
+extern void audio_test(void);
+
+int main(void)
+{
+    board_init();
+
+    audio_init();
+    while (1) {
+        audio_test();
+    }
+}

examples/peripherals/usbdev/usbd_audio_v1_mic_speaker_multichan/proj.conf

@@ -0,0 +1,7 @@
+set(CONFIG_CHERRYUSB 1)
+set(CONFIG_CHERRYUSB_DEVICE 1)
+set(CONFIG_CHERRYUSB_DEVICE_CDC 1)
+set(CONFIG_CHERRYUSB_DEVICE_HID 1)
+set(CONFIG_CHERRYUSB_DEVICE_MSC 1)
+set(CONFIG_CHERRYUSB_DEVICE_AUDIO 1)
+set(CONFIG_CHERRYUSB_DEVICE_VIDEO 1)

examples/peripherals/usbdev/usbd_audio_v1_mic_speaker_multichan/usb_config.h

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2022, sakumisu
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef CHERRYUSB_CONFIG_H
+#define CHERRYUSB_CONFIG_H
+
+/* ================ USB common Configuration ================ */
+
+#define CONFIG_USB_PRINTF(...) printf(__VA_ARGS__)
+
+#define usb_malloc(size) malloc(size)
+#define usb_free(ptr)    free(ptr)
+
+#ifndef CONFIG_USB_DBG_LEVEL
+#define CONFIG_USB_DBG_LEVEL USB_DBG_INFO
+#endif
+
+/* Enable print with color */
+#define CONFIG_USB_PRINTF_COLOR_ENABLE
+
+/* data align size when use dma */
+#ifndef CONFIG_USB_ALIGN_SIZE
+#define CONFIG_USB_ALIGN_SIZE 4
+#endif
+
+/* attribute data into no cache ram */
+#define USB_NOCACHE_RAM_SECTION __attribute__((section(".noncacheable")))
+
+/* ================= USB Device Stack Configuration ================ */
+
+/* Ep0 max transfer buffer, specially for receiving data from ep0 out */
+#define CONFIG_USBDEV_REQUEST_BUFFER_LEN 256
+
+/* Setup packet log for debug */
+// #define CONFIG_USBDEV_SETUP_LOG_PRINT
+
+/* Check if the input descriptor is correct */
+// #define CONFIG_USBDEV_DESC_CHECK
+
+/* Enable test mode */
+// #define CONFIG_USBDEV_TEST_MODE
+
+#ifndef CONFIG_USBDEV_MSC_BLOCK_SIZE
+#define CONFIG_USBDEV_MSC_BLOCK_SIZE 512
+#endif
+
+#ifndef CONFIG_USBDEV_MSC_MANUFACTURER_STRING
+#define CONFIG_USBDEV_MSC_MANUFACTURER_STRING ""
+#endif
+
+#ifndef CONFIG_USBDEV_MSC_PRODUCT_STRING
+#define CONFIG_USBDEV_MSC_PRODUCT_STRING ""
+#endif
+
+#ifndef CONFIG_USBDEV_MSC_VERSION_STRING
+#define CONFIG_USBDEV_MSC_VERSION_STRING "0.01"
+#endif
+
+// #define CONFIG_USBDEV_MSC_THREAD
+
+#ifdef CONFIG_USBDEV_MSC_THREAD
+#ifndef CONFIG_USBDEV_MSC_STACKSIZE
+#define CONFIG_USBDEV_MSC_STACKSIZE 2048
+#endif
+
+#ifndef CONFIG_USBDEV_MSC_PRIO
+#define CONFIG_USBDEV_MSC_PRIO 4
+#endif
+#endif
+
+#ifndef CONFIG_USBDEV_AUDIO_VERSION
+#define CONFIG_USBDEV_AUDIO_VERSION 0x0100
+#endif
+
+#ifndef CONFIG_USBDEV_AUDIO_MAX_CHANNEL
+#define CONFIG_USBDEV_AUDIO_MAX_CHANNEL 8
+#endif
+
+/* ================ USB HOST Stack Configuration ================== */
+
+#define CONFIG_USBHOST_MAX_RHPORTS          1
+#define CONFIG_USBHOST_MAX_EXTHUBS          1
+#define CONFIG_USBHOST_MAX_EHPORTS          4
+#define CONFIG_USBHOST_MAX_INTERFACES       6
+#define CONFIG_USBHOST_MAX_INTF_ALTSETTINGS 8
+#define CONFIG_USBHOST_MAX_ENDPOINTS        4
+
+#define CONFIG_USBHOST_DEV_NAMELEN 16
+
+#ifndef CONFIG_USBHOST_PSC_PRIO
+#define CONFIG_USBHOST_PSC_PRIO 4
+#endif
+#ifndef CONFIG_USBHOST_PSC_STACKSIZE
+#define CONFIG_USBHOST_PSC_STACKSIZE 2048
+#endif
+
+//#define CONFIG_USBHOST_GET_STRING_DESC
+
+/* Ep0 max transfer buffer */
+#define CONFIG_USBHOST_REQUEST_BUFFER_LEN 512
+
+#ifndef CONFIG_USBHOST_CONTROL_TRANSFER_TIMEOUT
+#define CONFIG_USBHOST_CONTROL_TRANSFER_TIMEOUT 500
+#endif
+
+#ifndef CONFIG_USBHOST_MSC_TIMEOUT
+#define CONFIG_USBHOST_MSC_TIMEOUT 5000
+#endif
+
+/* ================ USB Device Port Configuration ================*/
+
+//#define USBD_IRQHandler USBD_IRQHandler
+//#define USB_BASE (0x40080000UL)
+//#define USB_NUM_BIDIR_ENDPOINTS 4
+
+/* ================ USB Host Port Configuration ==================*/
+
+#define CONFIG_USBHOST_PIPE_NUM 10
+
+/* ================ EHCI Configuration ================ */
+
+#define CONFIG_USB_EHCI_HCCR_BASE       (0x20072000)
+#define CONFIG_USB_EHCI_HCOR_BASE       (0x20072000 + 0x10)
+#define CONFIG_USB_EHCI_FRAME_LIST_SIZE 1024
+// #define CONFIG_USB_EHCI_INFO_ENABLE
+#define CONFIG_USB_ECHI_HCOR_RESERVED_DISABLE
+// #define CONFIG_USB_EHCI_CONFIGFLAG
+// #define CONFIG_USB_EHCI_PORT_POWER
+
+#endif

examples/peripherals/usbdev/usbd_cdc_acm/cdc_acm_template.c

@@ -150,6 +150,11 @@ struct usbd_interface intf1;
 /* function ------------------------------------------------------------------*/
 void cdc_acm_init(void)
 {
+    const uint8_t data[10] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
+
+    memcpy(&write_buffer[0], data, 10);
+    memset(&write_buffer[10], 'a', 2038);
+
     usbd_desc_register(cdc_descriptor);
     usbd_add_interface(usbd_cdc_acm_init_intf(&intf0));
     usbd_add_interface(usbd_cdc_acm_init_intf(&intf1));
@@ -171,11 +176,7 @@ void usbd_cdc_acm_set_dtr(uint8_t intf, bool dtr)
 
 void cdc_acm_data_send_with_dtr_test(void)
 {
-    const uint8_t data[10] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
-
     if (dtr_enable) {
-        memcpy(&write_buffer[0], data, 10);
-        memset(&write_buffer[10], 'a', 2038);
         ep_tx_busy_flag = true;
         usbd_ep_start_write(CDC_IN_EP, write_buffer, 2048);
         while (ep_tx_busy_flag) {

examples/peripherals/usbdev/usbd_msc_ram/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.15)
+
+include(proj.conf)
+
+find_package(bouffalo_sdk REQUIRED HINTS $ENV{BL_SDK_BASE})
+
+sdk_add_include_directories(.)
+
+target_sources(app PRIVATE msc_ram_template.c)
+sdk_set_main_file(main.c)
+
+project(usbd_msc_ram)

examples/peripherals/usbdev/usbd_msc_ram/Makefile

@@ -0,0 +1,13 @@
+SDK_DEMO_PATH ?= .
+BL_SDK_BASE ?= $(SDK_DEMO_PATH)/../../../..
+
+export BL_SDK_BASE
+
+CHIP ?= bl616
+BOARD ?= bl616dk
+CROSS_COMPILE ?= riscv64-unknown-elf-
+
+# add custom cmake definition
+#cmake_definition+=-Dxxx=sss
+
+include $(BL_SDK_BASE)/project.build

examples/peripherals/usbdev/usbd_msc_ram/main.c

@@ -0,0 +1,14 @@
+#include "usbh_core.h"
+#include "bflb_mtimer.h"
+#include "board.h"
+
+extern void msc_ram_init(void);
+
+int main(void)
+{
+    board_init();
+
+    msc_ram_init();
+    while (1) {
+    }
+}

examples/peripherals/usbdev/usbd_msc_ram/msc_ram_template.c

@@ -0,0 +1,134 @@
+#include "usbd_core.h"
+#include "usbd_msc.h"
+
+#define MSC_IN_EP  0x81
+#define MSC_OUT_EP 0x02
+
+#define USBD_VID           0xFFFF
+#define USBD_PID           0xFFFF
+#define USBD_MAX_POWER     100
+#define USBD_LANGID_STRING 1033
+
+#define USB_CONFIG_SIZE (9 + MSC_DESCRIPTOR_LEN)
+
+const uint8_t msc_ram_descriptor[] = {
+    USB_DEVICE_DESCRIPTOR_INIT(USB_2_0, 0x00, 0x00, 0x00, USBD_VID, USBD_PID, 0x0200, 0x01),
+    USB_CONFIG_DESCRIPTOR_INIT(USB_CONFIG_SIZE, 0x01, 0x01, USB_CONFIG_BUS_POWERED, USBD_MAX_POWER),
+    MSC_DESCRIPTOR_INIT(0x00, MSC_OUT_EP, MSC_IN_EP, 0x02),
+    ///////////////////////////////////////
+    /// string0 descriptor
+    ///////////////////////////////////////
+    USB_LANGID_INIT(USBD_LANGID_STRING),
+    ///////////////////////////////////////
+    /// string1 descriptor
+    ///////////////////////////////////////
+    0x14,                       /* bLength */
+    USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+    'C', 0x00,                  /* wcChar0 */
+    'h', 0x00,                  /* wcChar1 */
+    'e', 0x00,                  /* wcChar2 */
+    'r', 0x00,                  /* wcChar3 */
+    'r', 0x00,                  /* wcChar4 */
+    'y', 0x00,                  /* wcChar5 */
+    'U', 0x00,                  /* wcChar6 */
+    'S', 0x00,                  /* wcChar7 */
+    'B', 0x00,                  /* wcChar8 */
+    ///////////////////////////////////////
+    /// string2 descriptor
+    ///////////////////////////////////////
+    0x26,                       /* bLength */
+    USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+    'C', 0x00,                  /* wcChar0 */
+    'h', 0x00,                  /* wcChar1 */
+    'e', 0x00,                  /* wcChar2 */
+    'r', 0x00,                  /* wcChar3 */
+    'r', 0x00,                  /* wcChar4 */
+    'y', 0x00,                  /* wcChar5 */
+    'U', 0x00,                  /* wcChar6 */
+    'S', 0x00,                  /* wcChar7 */
+    'B', 0x00,                  /* wcChar8 */
+    ' ', 0x00,                  /* wcChar9 */
+    'M', 0x00,                  /* wcChar10 */
+    'S', 0x00,                  /* wcChar11 */
+    'C', 0x00,                  /* wcChar12 */
+    ' ', 0x00,                  /* wcChar13 */
+    'D', 0x00,                  /* wcChar14 */
+    'E', 0x00,                  /* wcChar15 */
+    'M', 0x00,                  /* wcChar16 */
+    'O', 0x00,                  /* wcChar17 */
+    ///////////////////////////////////////
+    /// string3 descriptor
+    ///////////////////////////////////////
+    0x16,                       /* bLength */
+    USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+    '2', 0x00,                  /* wcChar0 */
+    '0', 0x00,                  /* wcChar1 */
+    '2', 0x00,                  /* wcChar2 */
+    '2', 0x00,                  /* wcChar3 */
+    '1', 0x00,                  /* wcChar4 */
+    '2', 0x00,                  /* wcChar5 */
+    '3', 0x00,                  /* wcChar6 */
+    '4', 0x00,                  /* wcChar7 */
+    '5', 0x00,                  /* wcChar8 */
+    '6', 0x00,                  /* wcChar9 */
+#ifdef CONFIG_USB_HS
+    ///////////////////////////////////////
+    /// device qualifier descriptor
+    ///////////////////////////////////////
+    0x0a,
+    USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER,
+    0x00,
+    0x02,
+    0x00,
+    0x00,
+    0x00,
+    0x40,
+    0x01,
+    0x00,
+#endif
+    0x00
+};
+
+void usbd_configure_done_callback(void)
+{
+    /* do nothing */
+}
+
+#define BLOCK_SIZE  512
+#define BLOCK_COUNT 10
+
+typedef struct
+{
+    uint8_t BlockSpace[BLOCK_SIZE];
+} BLOCK_TYPE;
+
+BLOCK_TYPE mass_block[BLOCK_COUNT];
+
+void usbd_msc_get_cap(uint8_t lun, uint32_t *block_num, uint16_t *block_size)
+{
+    *block_num = 1000; //Pretend having so many buffer,not has actually.
+    *block_size = BLOCK_SIZE;
+}
+int usbd_msc_sector_read(uint32_t sector, uint8_t *buffer, uint32_t length)
+{
+    if (sector < 10)
+        memcpy(buffer, mass_block[sector].BlockSpace, length);
+    return 0;
+}
+
+int usbd_msc_sector_write(uint32_t sector, uint8_t *buffer, uint32_t length)
+{
+    if (sector < 10)
+        memcpy(mass_block[sector].BlockSpace, buffer, length);
+    return 0;
+}
+
+struct usbd_interface intf0;
+
+void msc_ram_init(void)
+{
+    usbd_desc_register(msc_ram_descriptor);
+    usbd_add_interface(usbd_msc_init_intf(&intf0, MSC_OUT_EP, MSC_IN_EP));
+
+    usbd_initialize();
+}

examples/peripherals/usbdev/usbd_msc_ram/proj.conf

@@ -0,0 +1,7 @@
+set(CONFIG_CHERRYUSB 1)
+set(CONFIG_CHERRYUSB_DEVICE 1)
+set(CONFIG_CHERRYUSB_DEVICE_CDC 1)
+set(CONFIG_CHERRYUSB_DEVICE_HID 1)
+set(CONFIG_CHERRYUSB_DEVICE_MSC 1)
+set(CONFIG_CHERRYUSB_DEVICE_AUDIO 1)
+set(CONFIG_CHERRYUSB_DEVICE_VIDEO 1)

examples/peripherals/usbdev/usbd_msc_ram/usb_config.h

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2022, sakumisu
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef CHERRYUSB_CONFIG_H
+#define CHERRYUSB_CONFIG_H
+
+/* ================ USB common Configuration ================ */
+
+#define CONFIG_USB_PRINTF(...) printf(__VA_ARGS__)
+
+#define usb_malloc(size) malloc(size)
+#define usb_free(ptr)    free(ptr)
+
+#ifndef CONFIG_USB_DBG_LEVEL
+#define CONFIG_USB_DBG_LEVEL USB_DBG_INFO
+#endif
+
+/* Enable print with color */
+#define CONFIG_USB_PRINTF_COLOR_ENABLE
+
+/* data align size when use dma */
+#ifndef CONFIG_USB_ALIGN_SIZE
+#define CONFIG_USB_ALIGN_SIZE 4
+#endif
+
+/* attribute data into no cache ram */
+#define USB_NOCACHE_RAM_SECTION __attribute__((section(".noncacheable")))
+
+/* ================= USB Device Stack Configuration ================ */
+
+/* Ep0 max transfer buffer, specially for receiving data from ep0 out */
+#define CONFIG_USBDEV_REQUEST_BUFFER_LEN 256
+
+/* Setup packet log for debug */
+// #define CONFIG_USBDEV_SETUP_LOG_PRINT
+
+/* Check if the input descriptor is correct */
+// #define CONFIG_USBDEV_DESC_CHECK
+
+/* Enable test mode */
+// #define CONFIG_USBDEV_TEST_MODE
+
+#ifndef CONFIG_USBDEV_MSC_BLOCK_SIZE
+#define CONFIG_USBDEV_MSC_BLOCK_SIZE 512
+#endif
+
+#ifndef CONFIG_USBDEV_MSC_MANUFACTURER_STRING
+#define CONFIG_USBDEV_MSC_MANUFACTURER_STRING ""
+#endif
+
+#ifndef CONFIG_USBDEV_MSC_PRODUCT_STRING
+#define CONFIG_USBDEV_MSC_PRODUCT_STRING ""
+#endif
+
+#ifndef CONFIG_USBDEV_MSC_VERSION_STRING
+#define CONFIG_USBDEV_MSC_VERSION_STRING "0.01"
+#endif
+
+// #define CONFIG_USBDEV_MSC_THREAD
+
+#ifdef CONFIG_USBDEV_MSC_THREAD
+#ifndef CONFIG_USBDEV_MSC_STACKSIZE
+#define CONFIG_USBDEV_MSC_STACKSIZE 2048
+#endif
+
+#ifndef CONFIG_USBDEV_MSC_PRIO
+#define CONFIG_USBDEV_MSC_PRIO 4
+#endif
+#endif
+
+#ifndef CONFIG_USBDEV_AUDIO_VERSION
+#define CONFIG_USBDEV_AUDIO_VERSION 0x0100
+#endif
+
+#ifndef CONFIG_USBDEV_AUDIO_MAX_CHANNEL
+#define CONFIG_USBDEV_AUDIO_MAX_CHANNEL 8
+#endif
+
+/* ================ USB HOST Stack Configuration ================== */
+
+#define CONFIG_USBHOST_MAX_RHPORTS          1
+#define CONFIG_USBHOST_MAX_EXTHUBS          1
+#define CONFIG_USBHOST_MAX_EHPORTS          4
+#define CONFIG_USBHOST_MAX_INTERFACES       6
+#define CONFIG_USBHOST_MAX_INTF_ALTSETTINGS 8
+#define CONFIG_USBHOST_MAX_ENDPOINTS        4
+
+#define CONFIG_USBHOST_DEV_NAMELEN 16
+
+#ifndef CONFIG_USBHOST_PSC_PRIO
+#define CONFIG_USBHOST_PSC_PRIO 4
+#endif
+#ifndef CONFIG_USBHOST_PSC_STACKSIZE
+#define CONFIG_USBHOST_PSC_STACKSIZE 2048
+#endif
+
+//#define CONFIG_USBHOST_GET_STRING_DESC
+
+/* Ep0 max transfer buffer */
+#define CONFIG_USBHOST_REQUEST_BUFFER_LEN 512
+
+#ifndef CONFIG_USBHOST_CONTROL_TRANSFER_TIMEOUT
+#define CONFIG_USBHOST_CONTROL_TRANSFER_TIMEOUT 500
+#endif
+
+#ifndef CONFIG_USBHOST_MSC_TIMEOUT
+#define CONFIG_USBHOST_MSC_TIMEOUT 5000
+#endif
+
+/* ================ USB Device Port Configuration ================*/
+
+//#define USBD_IRQHandler USBD_IRQHandler
+//#define USB_BASE (0x40080000UL)
+//#define USB_NUM_BIDIR_ENDPOINTS 4
+
+/* ================ USB Host Port Configuration ==================*/
+
+#define CONFIG_USBHOST_PIPE_NUM 10
+
+/* ================ EHCI Configuration ================ */
+
+#define CONFIG_USB_EHCI_HCCR_BASE       (0x20072000)
+#define CONFIG_USB_EHCI_HCOR_BASE       (0x20072000 + 0x10)
+#define CONFIG_USB_EHCI_FRAME_LIST_SIZE 1024
+// #define CONFIG_USB_EHCI_INFO_ENABLE
+#define CONFIG_USB_ECHI_HCOR_RESERVED_DISABLE
+// #define CONFIG_USB_EHCI_CONFIGFLAG
+// #define CONFIG_USB_EHCI_PORT_POWER
+
+#endif

examples/printf/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.15)
+
+include(proj.conf)
+
+find_package(bouffalo_sdk REQUIRED HINTS $ENV{BL_SDK_BASE})
+
+sdk_set_main_file(main.c)
+
+project(printf)

examples/printf/Makefile

@@ -0,0 +1,13 @@
+SDK_DEMO_PATH ?= .
+BL_SDK_BASE ?= $(SDK_DEMO_PATH)/../..
+
+export BL_SDK_BASE
+
+CHIP ?= bl616
+BOARD ?= bl616dk
+CROSS_COMPILE ?= riscv64-unknown-elf-
+
+# add custom cmake definition
+#cmake_definition+=-Dxxx=sss
+
+include $(BL_SDK_BASE)/project.build

examples/printf/main.c

@@ -0,0 +1,634 @@
+#include "bflb_mtimer.h"
+#include "board.h"
+#include "log.h"
+
+#include <limits.h>
+#include <float.h>
+#include <math.h>
+
+#define PRINT_CHECK(_expected, format, ...)   \
+    do {                                      \
+        printf(_expected "\r\n");             \
+        printf(format "\r\n", ##__VA_ARGS__); \
+    } while (0)
+
+typedef void (*testfunc_t)(void);
+
+#define DEFCASE(_name) static void test_##_name(void)
+#define TEST(_name)    test_##_name
+
+DEFCASE(space_flag)
+{
+    PRINT_CHECK(" 42", "% d", 42);
+    PRINT_CHECK("-42", "% d", -42);
+    PRINT_CHECK("   42", "% 5d", 42);
+    PRINT_CHECK("  -42", "% 5d", -42);
+    PRINT_CHECK("             42", "% 15d", 42);
+    PRINT_CHECK("            -42", "% 15d", -42);
+    PRINT_CHECK("        -42.987", "% 15.3f", -42.987);
+    PRINT_CHECK("         42.987", "% 15.3f", 42.987);
+    PRINT_CHECK(" 1024", "% d", 1024);
+    PRINT_CHECK("-1024", "% d", -1024);
+    PRINT_CHECK(" 1024", "% i", 1024);
+    PRINT_CHECK("-1024", "% i", -1024);
+}
+
+DEFCASE(plus_flag)
+{
+    PRINT_CHECK("+42", "%+d", 42);
+    PRINT_CHECK("-42", "%+d", -42);
+    PRINT_CHECK("  +42", "%+5d", 42);
+    PRINT_CHECK("  -42", "%+5d", -42);
+    PRINT_CHECK("            +42", "%+15d", 42);
+    PRINT_CHECK("            -42", "%+15d", -42);
+    PRINT_CHECK("+1024", "%+d", 1024);
+    PRINT_CHECK("-1024", "%+d", -1024);
+    PRINT_CHECK("+1024", "%+i", 1024);
+    PRINT_CHECK("-1024", "%+i", -1024);
+    PRINT_CHECK("+", "%+0.d", 0);
+}
+
+DEFCASE(zero_flag)
+{
+    PRINT_CHECK("42", "%0d", 42);
+    PRINT_CHECK("42", "%0ld", 42L);
+    PRINT_CHECK("-42", "%0d", -42);
+    PRINT_CHECK("00042", "%05d", 42);
+    PRINT_CHECK("-0042", "%05d", -42);
+    PRINT_CHECK("000000000000042", "%015d", 42);
+    PRINT_CHECK("-00000000000042", "%015d", -42);
+    PRINT_CHECK("000000000042.12", "%015.2f", 42.1234);
+    PRINT_CHECK("00000000042.988", "%015.3f", 42.9876);
+    PRINT_CHECK("-00000042.98760", "%015.5f", -42.9876);
+}
+
+DEFCASE(minus_flag)
+{
+    PRINT_CHECK("42", "%-d", 42);
+    PRINT_CHECK("-42", "%-d", -42);
+    PRINT_CHECK("42   ", "%-5d", 42);
+    PRINT_CHECK("-42  ", "%-5d", -42);
+    PRINT_CHECK("42             ", "%-15d", 42);
+    PRINT_CHECK("-42            ", "%-15d", -42);
+}
+
+DEFCASE(sharp_flag)
+{
+    PRINT_CHECK("0", "%#o", 0);
+    PRINT_CHECK("0", "%#0o", 0);
+    PRINT_CHECK("0", "%#.0o", 0);
+    PRINT_CHECK("0", "%#.1o", 0);
+    PRINT_CHECK("  0", "%#3o", 0);
+    PRINT_CHECK("000", "%#.3o", 0);
+    PRINT_CHECK("01", "%#o", 1);
+    PRINT_CHECK("01", "%#0o", 1);
+    PRINT_CHECK("01", "%#.0o", 1);
+    PRINT_CHECK("01", "%#.1o", 1);
+    PRINT_CHECK(" 01", "%#3o", 1);
+    PRINT_CHECK("0001", "%#.4o", 1);
+    PRINT_CHECK("0x1001", "%#04x", 0x1001);
+    PRINT_CHECK("01001", "%#04o", 01001);
+    PRINT_CHECK("", "%#.0x", 0);
+    PRINT_CHECK("0x0000614e", "%#.8x", 0x614e);
+}
+
+DEFCASE(sharp_flag_with_long_long)
+{
+    PRINT_CHECK("0", "%#llo", (long long)0);
+    PRINT_CHECK("0", "%#0llo", (long long)0);
+    PRINT_CHECK("0", "%#.0llo", (long long)0);
+    PRINT_CHECK("0", "%#.1llo", (long long)0);
+    PRINT_CHECK("   0", "%#4llo", (long long)0);
+    PRINT_CHECK("0000", "%#.4llo", (long long)0);
+    PRINT_CHECK("01", "%#llo", (long long)1);
+    PRINT_CHECK("01", "%#0llo", (long long)1);
+    PRINT_CHECK("01", "%#.0llo", (long long)1);
+    PRINT_CHECK("01", "%#.1llo", (long long)1);
+    PRINT_CHECK("  01", "%#4llo", (long long)1);
+    PRINT_CHECK("0001", "%#.4llo", (long long)1);
+    PRINT_CHECK("0x1001", "%#04llx", (long long)0x1001);
+    PRINT_CHECK("01001", "%#04llo", (long long)01001);
+    PRINT_CHECK("", "%#.0llx", (long long)0);
+    PRINT_CHECK("0x0000614e", "%#.8llx", (long long)0x614e);
+}
+
+DEFCASE(specifier)
+{
+    PRINT_CHECK("Hello World", "Hello World");
+    PRINT_CHECK("Hello World", "%s", "Hello World");
+    PRINT_CHECK("(null)", "%s", (const char *)NULL);
+    PRINT_CHECK("1024", "%d", 1024);
+#if INT_MAX >= 2147483647LL
+    PRINT_CHECK("2147483647", "%d", 2147483647);
+    PRINT_CHECK("4294966272", "%u", 4294966272U);
+    PRINT_CHECK("37777777001", "%o", 4294966785U);
+    PRINT_CHECK("1234abcd", "%x", 305441741);
+    PRINT_CHECK("edcb5433", "%x", 3989525555U);
+    PRINT_CHECK("1234ABCD", "%X", 305441741);
+    PRINT_CHECK("EDCB5433", "%X", 3989525555U);
+#endif
+    PRINT_CHECK("-1024", "%d", -1024);
+    PRINT_CHECK("1024", "%i", 1024);
+    PRINT_CHECK("-1024", "%i", -1024);
+    PRINT_CHECK("1024", "%u", 1024);
+    PRINT_CHECK("777", "%o", 511);
+    PRINT_CHECK("%%", "%%");
+}
+
+DEFCASE(width)
+{
+    PRINT_CHECK("Hello World", "%1s", "Hello World");
+    PRINT_CHECK("1024", "%1d", 1024);
+    PRINT_CHECK("-1024", "%1d", -1024);
+    PRINT_CHECK("1024", "%1i", 1024);
+    PRINT_CHECK("-1024", "%1i", -1024);
+    PRINT_CHECK("1024", "%1u", 1024);
+    PRINT_CHECK("4294966272", "%1u", 4294966272U);
+    PRINT_CHECK("777", "%1o", 511);
+    PRINT_CHECK("37777777001", "%1o", 4294966785U);
+    PRINT_CHECK("1234abcd", "%1x", 305441741);
+    PRINT_CHECK("edcb5433", "%1x", 3989525555U);
+    PRINT_CHECK("1234ABCD", "%1X", 305441741);
+    PRINT_CHECK("EDCB5433", "%1X", 3989525555U);
+    PRINT_CHECK("x", "%1c", 'x');
+}
+
+DEFCASE(width_20)
+{
+    PRINT_CHECK("               Hello", "%20s", "Hello");
+    PRINT_CHECK("                1024", "%20d", 1024);
+    PRINT_CHECK("               -1024", "%20d", -1024);
+    PRINT_CHECK("                1024", "%20i", 1024);
+    PRINT_CHECK("               -1024", "%20i", -1024);
+    PRINT_CHECK("                   0", "%20i", 0);
+    PRINT_CHECK("                1024", "%20u", 1024);
+    PRINT_CHECK("          4294966272", "%20u", 4294966272U);
+    PRINT_CHECK("                 777", "%20o", 511);
+    PRINT_CHECK("         37777777001", "%20o", 4294966785U);
+    PRINT_CHECK("            1234abcd", "%20x", 305441741);
+    PRINT_CHECK("            edcb5433", "%20x", 3989525555U);
+    PRINT_CHECK("            1234ABCD", "%20X", 305441741);
+    PRINT_CHECK("            EDCB5433", "%20X", 3989525555U);
+    PRINT_CHECK("                   0", "%20X", 0);
+    PRINT_CHECK("                   0", "%20X", 0U);
+    PRINT_CHECK("                   0", "%20llX", 0ULL);
+    PRINT_CHECK("                   x", "%20c", 'x');
+}
+
+DEFCASE(width_asterisk_20)
+{
+    PRINT_CHECK("               Hello", "%*s", 20, "Hello");
+    PRINT_CHECK("                1024", "%*d", 20, 1024);
+    PRINT_CHECK("               -1024", "%*d", 20, -1024);
+    PRINT_CHECK("                1024", "%*i", 20, 1024);
+    PRINT_CHECK("               -1024", "%*i", 20, -1024);
+    PRINT_CHECK("                1024", "%*u", 20, 1024);
+    PRINT_CHECK("          4294966272", "%*u", 20, 4294966272U);
+    PRINT_CHECK("                 777", "%*o", 20, 511);
+    PRINT_CHECK("         37777777001", "%*o", 20, 4294966785U);
+    PRINT_CHECK("            1234abcd", "%*x", 20, 305441741);
+    PRINT_CHECK("            edcb5433", "%*x", 20, 3989525555U);
+    PRINT_CHECK("            1234ABCD", "%*X", 20, 305441741);
+    PRINT_CHECK("            EDCB5433", "%*X", 20, 3989525555U);
+    PRINT_CHECK("                   x", "%*c", 20, 'x');
+}
+
+DEFCASE(width_minus_20)
+{
+    PRINT_CHECK("Hello               ", "%-20s", "Hello");
+    PRINT_CHECK("1024                ", "%-20d", 1024);
+    PRINT_CHECK("-1024               ", "%-20d", -1024);
+    PRINT_CHECK("1024                ", "%-20i", 1024);
+    PRINT_CHECK("-1024               ", "%-20i", -1024);
+    PRINT_CHECK("1024                ", "%-20u", 1024);
+    PRINT_CHECK("1024.1234           ", "%-20.4f", 1024.1234);
+    PRINT_CHECK("4294966272          ", "%-20u", 4294966272U);
+    PRINT_CHECK("777                 ", "%-20o", 511);
+    PRINT_CHECK("37777777001         ", "%-20o", 4294966785U);
+    PRINT_CHECK("1234abcd            ", "%-20x", 305441741);
+    PRINT_CHECK("edcb5433            ", "%-20x", 3989525555U);
+    PRINT_CHECK("1234ABCD            ", "%-20X", 305441741);
+    PRINT_CHECK("EDCB5433            ", "%-20X", 3989525555U);
+    PRINT_CHECK("x                   ", "%-20c", 'x');
+    PRINT_CHECK("|    9| |9 | |    9|", "|%5d| |%-2d| |%5d|", 9, 9, 9);
+    PRINT_CHECK("|   10| |10| |   10|", "|%5d| |%-2d| |%5d|", 10, 10, 10);
+    PRINT_CHECK("|    9| |9           | |    9|", "|%5d| |%-12d| |%5d|", 9, 9, 9);
+    PRINT_CHECK("|   10| |10          | |   10|", "|%5d| |%-12d| |%5d|", 10, 10, 10);
+}
+
+DEFCASE(padding_20)
+{
+    PRINT_CHECK("00000000000000001024", "%020d", 1024);
+    PRINT_CHECK("-0000000000000001024", "%020d", -1024);
+    PRINT_CHECK("00000000000000001024", "%020i", 1024);
+    PRINT_CHECK("-0000000000000001024", "%020i", -1024);
+    PRINT_CHECK("00000000000000001024", "%020u", 1024);
+    PRINT_CHECK("00000000004294966272", "%020u", 4294966272U);
+    PRINT_CHECK("00000000000000000777", "%020o", 511);
+    PRINT_CHECK("00000000037777777001", "%020o", 4294966785U);
+    PRINT_CHECK("0000000000001234abcd", "%020x", 305441741);
+    PRINT_CHECK("000000000000edcb5433", "%020x", 3989525555U);
+    PRINT_CHECK("0000000000001234ABCD", "%020X", 305441741);
+    PRINT_CHECK("000000000000EDCB5433", "%020X", 3989525555U);
+}
+
+DEFCASE(padding_dot_20)
+{
+    PRINT_CHECK("00000000000000001024", "%.20d", 1024);
+    PRINT_CHECK("-00000000000000001024", "%.20d", -1024);
+    PRINT_CHECK("00000000000000001024", "%.20i", 1024);
+    PRINT_CHECK("-00000000000000001024", "%.20i", -1024);
+    PRINT_CHECK("00000000000000001024", "%.20u", 1024);
+    PRINT_CHECK("00000000004294966272", "%.20u", 4294966272U);
+    PRINT_CHECK("00000000000000000777", "%.20o", 511);
+    PRINT_CHECK("00000000037777777001", "%.20o", 4294966785U);
+    PRINT_CHECK("0000000000001234abcd", "%.20x", 305441741);
+    PRINT_CHECK("000000000000edcb5433", "%.20x", 3989525555U);
+    PRINT_CHECK("0000000000001234ABCD", "%.20X", 305441741);
+    PRINT_CHECK("000000000000EDCB5433", "%.20X", 3989525555U);
+}
+
+DEFCASE(padding_sharp_020)
+{
+    PRINT_CHECK("00000000000000000777", "%#020o", 511);
+    PRINT_CHECK("00000000037777777001", "%#020o", 4294966785U);
+    PRINT_CHECK("0x00000000001234abcd", "%#020x", 305441741);
+    PRINT_CHECK("0x0000000000edcb5433", "%#020x", 3989525555U);
+    PRINT_CHECK("0X00000000001234ABCD", "%#020X", 305441741);
+    PRINT_CHECK("0X0000000000EDCB5433", "%#020X", 3989525555U);
+}
+
+DEFCASE(padding_sharp_20)
+{
+    PRINT_CHECK("                0777", "%#20o", 511);
+    PRINT_CHECK("        037777777001", "%#20o", 4294966785U);
+    PRINT_CHECK("          0x1234abcd", "%#20x", 305441741);
+    PRINT_CHECK("          0xedcb5433", "%#20x", 3989525555U);
+    PRINT_CHECK("          0X1234ABCD", "%#20X", 305441741);
+    PRINT_CHECK("          0XEDCB5433", "%#20X", 3989525555U);
+}
+
+DEFCASE(padding_20_point_5)
+{
+    PRINT_CHECK("               01024", "%20.5d", 1024);
+    PRINT_CHECK("              -01024", "%20.5d", -1024);
+    PRINT_CHECK("               01024", "%20.5i", 1024);
+    PRINT_CHECK("              -01024", "%20.5i", -1024);
+    PRINT_CHECK("               01024", "%20.5u", 1024);
+    PRINT_CHECK("          4294966272", "%20.5u", 4294966272U);
+    PRINT_CHECK("               00777", "%20.5o", 511);
+    PRINT_CHECK("         37777777001", "%20.5o", 4294966785U);
+    PRINT_CHECK("            1234abcd", "%20.5x", 305441741);
+    PRINT_CHECK("          00edcb5433", "%20.10x", 3989525555U);
+    PRINT_CHECK("            1234ABCD", "%20.5X", 305441741);
+    PRINT_CHECK("          00EDCB5433", "%20.10X", 3989525555U);
+}
+
+DEFCASE(padding_negative_numbers)
+{
+    // space padding
+    PRINT_CHECK("-5", "% 1d", -5);
+    PRINT_CHECK("-5", "% 2d", -5);
+    PRINT_CHECK(" -5", "% 3d", -5);
+    PRINT_CHECK("  -5", "% 4d", -5);
+
+    // zero padding
+    PRINT_CHECK("-5", "%01d", -5);
+    PRINT_CHECK("-5", "%02d", -5);
+    PRINT_CHECK("-05", "%03d", -5);
+    PRINT_CHECK("-005", "%04d", -5);
+}
+
+DEFCASE(float_padding_negative_numbers)
+{
+    // space padding
+    PRINT_CHECK("-5.0", "% 3.1f", -5.);
+    PRINT_CHECK("-5.0", "% 4.1f", -5.);
+    PRINT_CHECK(" -5.0", "% 5.1f", -5.);
+
+    PRINT_CHECK("    -5", "% 6.1g", -5.);
+    PRINT_CHECK("-5.0e+00", "% 6.1e", -5.);
+    PRINT_CHECK("  -5.0e+00", "% 10.1e", -5.);
+
+    // zero padding
+    PRINT_CHECK("-5.0", "%03.1f", -5.);
+    PRINT_CHECK("-5.0", "%04.1f", -5.);
+    PRINT_CHECK("-05.0", "%05.1f", -5.);
+
+    // zero padding no decimal point
+    PRINT_CHECK("-5", "%01.0f", -5.);
+    PRINT_CHECK("-5", "%02.0f", -5.);
+    PRINT_CHECK("-05", "%03.0f", -5.);
+
+    PRINT_CHECK("-005.0e+00", "%010.1e", -5.);
+    PRINT_CHECK("-05E+00", "%07.0E", -5.);
+    PRINT_CHECK("-05", "%03.0g", -5.);
+}
+
+DEFCASE(length)
+{
+    PRINT_CHECK("", "%.0s", "Hello World");
+    PRINT_CHECK("                    ", "%20.0s", "Hello World");
+    PRINT_CHECK("", "%.s", "Hello World");
+    PRINT_CHECK("                    ", "%20.s", "Hello World");
+    PRINT_CHECK("                1024", "%20.0d", 1024);
+    PRINT_CHECK("               -1024", "%20.0d", -1024);
+    PRINT_CHECK("                    ", "%20.d", 0);
+    PRINT_CHECK("                1024", "%20.0i", 1024);
+    PRINT_CHECK("               -1024", "%20.i", -1024);
+    PRINT_CHECK("                    ", "%20.i", 0);
+    PRINT_CHECK("                1024", "%20.u", 1024);
+    PRINT_CHECK("          4294966272", "%20.0u", 4294966272U);
+    PRINT_CHECK("                    ", "%20.u", 0U);
+    PRINT_CHECK("                 777", "%20.o", 511);
+    PRINT_CHECK("         37777777001", "%20.0o", 4294966785U);
+    PRINT_CHECK("                    ", "%20.o", 0U);
+    PRINT_CHECK("            1234abcd", "%20.x", 305441741);
+    PRINT_CHECK("                                          1234abcd", "%50.x", 305441741);
+    PRINT_CHECK("                                          1234abcd     12345", "%50.x%10.u", 305441741, 12345);
+    PRINT_CHECK("            edcb5433", "%20.0x", 3989525555U);
+    PRINT_CHECK("                    ", "%20.x", 0U);
+    PRINT_CHECK("            1234ABCD", "%20.X", 305441741);
+    PRINT_CHECK("            EDCB5433", "%20.0X", 3989525555U);
+    PRINT_CHECK("                    ", "%20.X", 0U);
+}
+
+DEFCASE(infinity_and_not_a_number_values)
+{
+    // test special-case floats using math.h macros
+    PRINT_CHECK("     nan", "%8f", (double)NAN);
+    PRINT_CHECK("     inf", "%8f", (double)INFINITY);
+    PRINT_CHECK("-inf    ", "%-8f", (double)-INFINITY);
+    PRINT_CHECK("     nan", "%8e", (double)NAN);
+    PRINT_CHECK("     inf", "%8e", (double)INFINITY);
+    PRINT_CHECK("-inf    ", "%-8e", (double)-INFINITY);
+}
+
+DEFCASE(floating_point_specifiers_with_31_to_32_bit_integer_values)
+{
+    PRINT_CHECK("2147483647", "%.10f", 2147483647.0); // 2^31 - 1
+    PRINT_CHECK("2147483648", "%.10f", 2147483648.0); // 2^31
+    PRINT_CHECK("4294967295", "%.10f", 4294967295.0); // 2^32 - 1
+    PRINT_CHECK("4294967296", "%.10f", 4294967296.0); // 2^32
+
+    // PRINT_CHECK("2.1474836470e+09", "%.10f", 2147483647.0); // 2^31 - 1
+    // PRINT_CHECK("2.1474836480e+09", "%.10f", 2147483648.0); // 2^31
+    // PRINT_CHECK("4.2949672950e+09", "%.10f", 4294967295.0); // 2^32 - 1
+    // PRINT_CHECK("4.2949672960e+09", "%.10f", 4294967296.0); // 2^32
+
+    PRINT_CHECK("2147483647", "%.10g", 2147483647.0); // 2^31 - 1
+    PRINT_CHECK("2147483648", "%.10g", 2147483648.0); // 2^31
+    PRINT_CHECK("4294967295", "%.10g", 4294967295.0); // 2^32 - 1
+    PRINT_CHECK("4294967296", "%.10g", 4294967296.0); // 2^32
+}
+
+DEFCASE(tiny_floating_point_values)
+{
+    PRINT_CHECK("1e-23", "%.0e", 1.380651569e-23);
+    PRINT_CHECK("1.4e-23", "%.1e", 1.380651569e-23);
+    PRINT_CHECK("1.38e-23", "%.2e", 1.380651569e-23);
+    PRINT_CHECK("1.381e-23", "%.3e", 1.380651569e-23);
+    PRINT_CHECK("1.3807e-23", "%.4e", 1.380651569e-23);
+    PRINT_CHECK("1.38065e-23", "%.5e", 1.380651569e-23);
+    PRINT_CHECK("1.380652e-23", "%.6e", 1.380651569e-23);
+    PRINT_CHECK("1.3806516e-23", "%.7e", 1.380651569e-23);
+    PRINT_CHECK("1.38065157e-23", "%.8e", 1.380651569e-23);
+    PRINT_CHECK("1.380651569e-23", "%.9e", 1.380651569e-23);
+    PRINT_CHECK("1.3806515690e-23", "%.10e", 1.380651569e-23);
+    PRINT_CHECK("1.38065156900e-23", "%.11e", 1.380651569e-23);
+    // These go beyond our precision abilities; enable them, and they will likely fail.
+    PRINT_CHECK("1.380651569000e-23", "%.12e", 1.380651569e-23);
+    PRINT_CHECK("1.3806515690000e-23", "%.13e", 1.380651569e-23);
+    PRINT_CHECK("1.38065156900000e-23", "%.14e", 1.380651569e-23);
+    PRINT_CHECK("1.380651569000000e-23", "%.15e", 1.380651569e-23);
+    PRINT_CHECK("1.3806515690000000e-23", "%.16e", 1.380651569e-23);
+}
+
+DEFCASE(floating_point_specifiers_precision_and_flags)
+{
+    PRINT_CHECK("3.1415", "%.4f", 3.1415354);
+    PRINT_CHECK("30343.142", "%.3f", 30343.1415354);
+    PRINT_CHECK("34", "%.0f", 34.1415354);
+    PRINT_CHECK("1", "%.0f", 1.3);
+    PRINT_CHECK("2", "%.0f", 1.55);
+    PRINT_CHECK("1.6", "%.1f", 1.64);
+    PRINT_CHECK("42.90", "%.2f", 42.8952);
+    PRINT_CHECK("42.895200000", "%.9f", 42.8952);
+    PRINT_CHECK("42.8952230000", "%.10f", 42.895223);
+    PRINT_CHECK("42.895223123457", "%.12f", 42.89522312345678);
+    PRINT_CHECK("42477.371093750000000", "%020.15f", 42477.37109375);
+    PRINT_CHECK("42.895223876543", "%.12f", 42.89522387654321);
+    PRINT_CHECK(" 42.90", "%6.2f", 42.8952);
+    PRINT_CHECK("+42.90", "%+6.2f", 42.8952);
+    PRINT_CHECK("+42.9", "%+5.1f", 42.9252);
+    PRINT_CHECK("42.500000", "%f", 42.5);
+    PRINT_CHECK("42.5", "%.1f", 42.5);
+    PRINT_CHECK("42167.000000", "%f", 42167.0);
+    PRINT_CHECK("-12345.987654321", "%.9f", -12345.987654321);
+    PRINT_CHECK("4.0", "%.1f", 3.999);
+    PRINT_CHECK("4", "%.0f", 3.5);
+    PRINT_CHECK("4", "%.0f", 4.5);
+    PRINT_CHECK("3", "%.0f", 3.49);
+    PRINT_CHECK("3.5", "%.1f", 3.49);
+    PRINT_CHECK("a0.5  ", "a%-5.1f", 0.5);
+    PRINT_CHECK("a0.5  end", "a%-5.1fend", 0.5);
+
+    PRINT_CHECK("0.5", "%.4g", 0.5);
+    PRINT_CHECK("1", "%.4g", 1.0);
+    PRINT_CHECK("12345.7", "%G", 12345.678);
+    PRINT_CHECK("12345.68", "%.7G", 12345.678);
+    PRINT_CHECK("1.2346E+08", "%.5G", 123456789.);
+    PRINT_CHECK("12345", "%.6G", 12345.);
+    PRINT_CHECK("  +1.235e+08", "%+12.4g", 123456789.);
+    PRINT_CHECK("0.0012", "%.2G", 0.001234);
+    PRINT_CHECK(" +0.001234", "%+10.4G", 0.001234);
+    PRINT_CHECK("+001.234e-05", "%+012.4g", 0.00001234);
+    // Note: The following two values are _barely_ normal; make their mantissa 1.1 and they lose their normality.
+    PRINT_CHECK("-1.23e-308", "%.3g", -1.2345e-308);
+    PRINT_CHECK("+1.230E+308", "%+.3E", 1.23e+308);
+    PRINT_CHECK("1.000e+01", "%.3e", 9.9996);
+    PRINT_CHECK("0", "%g", 0.);
+    PRINT_CHECK("-0", "%g", -0.);
+    PRINT_CHECK("+0", "%+g", 0.);
+    PRINT_CHECK("-0", "%+g", -0.);
+    PRINT_CHECK("-4e+04", "%.1g", -40661.5);
+    PRINT_CHECK("-4.e+04", "%#.1g", -40661.5);
+    PRINT_CHECK("100.", "%#.3g", 99.998580932617187500);
+    // Note: The following value is _barely_ normal; make the mantissa 1.1 and it loses its normality.
+    PRINT_CHECK("1.2345678901e-308", "%.10e", 1.2345678901e-308);
+    // Rounding-focused checks
+    PRINT_CHECK("4.895512e+04", "%e", 48955.125);
+    PRINT_CHECK("9.2524e+04", "%.4e", 92523.5);
+    PRINT_CHECK("-8.380923438e+04", "%.9e", -83809.234375);
+}
+
+DEFCASE(integer_types)
+{
+    PRINT_CHECK("0", "%i", 0);
+    PRINT_CHECK("1234", "%i", 1234);
+    PRINT_CHECK("32767", "%i", 32767);
+    PRINT_CHECK("-32767", "%i", -32767);
+    PRINT_CHECK("30", "%li", 30L);
+    PRINT_CHECK("-2147483647", "%li", -2147483647L);
+    PRINT_CHECK("2147483647", "%li", 2147483647L);
+
+    PRINT_CHECK("30", "%lli", 30LL);
+    PRINT_CHECK("-9223372036854775807", "%lli", -9223372036854775807LL);
+    PRINT_CHECK("9223372036854775807", "%lli", 9223372036854775807LL);
+
+    PRINT_CHECK("100000", "%lu", 100000L);
+    PRINT_CHECK("4294967295", "%lu", 0xFFFFFFFFL);
+
+    PRINT_CHECK("281474976710656", "%llu", 281474976710656LLU);
+    PRINT_CHECK("18446744073709551615", "%llu", 18446744073709551615LLU);
+
+    PRINT_CHECK("2147483647", "%zu", (size_t)2147483647UL);
+    PRINT_CHECK("2147483647", "%zd", (size_t)2147483647UL);
+    PRINT_CHECK("-2147483647", "%zi", (ssize_t)-2147483647L);
+    PRINT_CHECK("165140", "%o", 60000);
+    PRINT_CHECK("57060516", "%lo", 12345678L);
+    PRINT_CHECK("12345678", "%lx", 0x12345678L);
+
+    PRINT_CHECK("1234567891234567", "%llx", 0x1234567891234567LLU);
+
+    PRINT_CHECK("abcdefab", "%lx", 0xabcdefabL);
+    PRINT_CHECK("ABCDEFAB", "%lX", 0xabcdefabL);
+    PRINT_CHECK("v", "%c", 'v');
+    PRINT_CHECK("wv", "%cv", 'w');
+    PRINT_CHECK("A Test", "%s", "A Test");
+    PRINT_CHECK("255", "%hhu", (unsigned char)0xFFU);
+    PRINT_CHECK("4660", "%hu", (unsigned short)0x1234u);
+    PRINT_CHECK("Test100 65535", "%s%hhi %hu", "Test", (char)100, (unsigned short)0xFFFF);
+    PRINT_CHECK("a", "%tx", 10 - 0);
+    PRINT_CHECK("-2147483647", "%ji", (intmax_t)-2147483647L);
+}
+
+DEFCASE(pointer)
+{
+    if (sizeof(void *) == 4U) {
+        PRINT_CHECK("0x00001234", "%p", (void *)0x1234U);
+        PRINT_CHECK("0x12345678", "%p", (void *)0x12345678U);
+        PRINT_CHECK("0x12345678-0x7edcba98", "%p-%p", (void *)0x12345678U, (void *)0x7EDCBA98U);
+    } else {
+        PRINT_CHECK("0x0000000000001234", "%p", (void *)0x1234U);
+        PRINT_CHECK("0x0000000012345678", "%p", (void *)0x12345678U);
+        PRINT_CHECK("0x0000000012345678-0x000000007edcba98", "%p-%p", (void *)0x12345678U, (void *)0x7EDCBA98U);
+    }
+
+    if (sizeof(uintptr_t) == sizeof(uint64_t)) {
+        PRINT_CHECK("0x00000000ffffffff", "%p", (void *)(uintptr_t)0xFFFFFFFFU);
+    } else {
+        PRINT_CHECK("0xffffffff", "%p", (void *)(uintptr_t)0xFFFFFFFFU);
+    }
+
+    PRINT_CHECK("(nil)", "%p", (const void *)NULL);
+}
+
+DEFCASE(string_length)
+{
+    PRINT_CHECK("This", "%.4s", "This is a test");
+    PRINT_CHECK("test", "%.4s", "test");
+    PRINT_CHECK("123", "%.7s", "123");
+    PRINT_CHECK("", "%.7s", "");
+    PRINT_CHECK("1234ab", "%.4s%.2s", "123456", "abcdef");
+    PRINT_CHECK("123", "%.*s", 3, "123456");
+    PRINT_CHECK("(null)", "%.*s", 3, (const char *)NULL);
+}
+
+DEFCASE(misc)
+{
+    PRINT_CHECK("53000atest-20 bit", "%u%u%ctest%d %s", 5, 3000, 'a', -20, "bit");
+
+    PRINT_CHECK("0.33", "%.*f", 2, 0.33333333);
+    PRINT_CHECK("1", "%.*d", -1, 1);
+    PRINT_CHECK("foo", "%.3s", "foobar");
+    PRINT_CHECK(" ", "% .0d", 0);
+    PRINT_CHECK("     00004", "%10.5d", 4);
+    PRINT_CHECK("hi x", "%*sx", -3, "hi");
+    PRINT_CHECK("00123               ", "%-20.5i", 123);
+    PRINT_CHECK("-67224.546875000000000000", "%.18f", -67224.546875);
+
+    PRINT_CHECK("0.33", "%.*g", 2, 0.33333333);
+    PRINT_CHECK("3.33e-01", "%.*e", 2, 0.33333333);
+    PRINT_CHECK("0.000000e+00", "%e", 0.0);
+    PRINT_CHECK("-0.000000e+00", "%e", -0.0);
+}
+
+DEFCASE(long_long_4)
+{
+    PRINT_CHECK("30 30 30 30", "%lli %lli %lli %lli", 30LL, 30LL, 30LL, 30LL);
+    PRINT_CHECK("30 30 30 30", "%lld %lld %lld %lld", 30LL, 30LL, 30LL, 30LL);
+    PRINT_CHECK("-9223372036854775807 -9223372036854775807 -9223372036854775807 -9223372036854775807", "%lld %lld %lld %lld", -9223372036854775807LL, -9223372036854775807LL, -9223372036854775807LL, -9223372036854775807LL);
+    PRINT_CHECK("9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807", "%lld %lld %lld %lld", 9223372036854775807LL, 9223372036854775807LL, 9223372036854775807LL, 9223372036854775807LL);
+    PRINT_CHECK("-9223372036854775807 -9223372036854775807 -9223372036854775807 -9223372036854775807", "%lli %lli %lli %lli", -9223372036854775807LL, -9223372036854775807LL, -9223372036854775807LL, -9223372036854775807LL);
+    PRINT_CHECK("9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807", "%lli %lli %lli %lli", 9223372036854775807LL, 9223372036854775807LL, 9223372036854775807LL, 9223372036854775807LL);
+    PRINT_CHECK("281474976710656 281474976710656 281474976710656 281474976710656", "%llu %llu %llu %llu", 281474976710656LLU, 281474976710656LLU, 281474976710656LLU, 281474976710656LLU);
+    PRINT_CHECK("18446744073709551615 18446744073709551615 18446744073709551615 18446744073709551615", "%llu %llu %llu %llu", 18446744073709551615LLU, 18446744073709551615LLU, 18446744073709551615LLU, 18446744073709551615LLU);
+    PRINT_CHECK("1234567891234567 1234567891234567 1234567891234567 1234567891234567", "%llx %llx %llx %llx", 0x1234567891234567LLU, 0x1234567891234567LLU, 0x1234567891234567LLU, 0x1234567891234567LLU);
+}
+
+DEFCASE(buffer_long_long_4)
+{
+    long long buffer[4] = { 30LL, 30LL, 30LL, 30LL };
+    long long lbuffer[4] = { 9223372036854775807LL, 9223372036854775807LL, 9223372036854775807LL, 9223372036854775807LL };
+    unsigned long long ubuffer[4] = { 281474976710656LLU, 281474976710656LLU, 281474976710656LLU, 281474976710656LLU };
+    unsigned long long u2buffer[4] = { 18446744073709551615LLU, 18446744073709551615LLU, 18446744073709551615LLU, 18446744073709551615LLU };
+    unsigned long long xbuffer[4] = { 0x1234567891234567LLU, 0x1234567891234567LLU, 0x1234567891234567LLU, 0x1234567891234567LLU };
+
+    PRINT_CHECK("30 30 30 30", "%lli %lli %lli %lli", buffer[0], buffer[1], buffer[2], buffer[3]);
+    PRINT_CHECK("30 30 30 30", "%lld %lld %lld %lld", buffer[0], buffer[1], buffer[2], buffer[3]);
+    PRINT_CHECK("-9223372036854775807 -9223372036854775807 -9223372036854775807 -9223372036854775807", "%lld %lld %lld %lld", -lbuffer[0], -lbuffer[1], -lbuffer[2], -lbuffer[3]);
+    PRINT_CHECK("9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807", "%lld %lld %lld %lld", lbuffer[0], lbuffer[1], lbuffer[2], lbuffer[3]);
+    PRINT_CHECK("-9223372036854775807 -9223372036854775807 -9223372036854775807 -9223372036854775807", "%lli %lli %lli %lli", -lbuffer[0], -lbuffer[1], -lbuffer[2], -lbuffer[3]);
+    PRINT_CHECK("9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807", "%lli %lli %lli %lli", lbuffer[1], lbuffer[2], lbuffer[3]);
+    PRINT_CHECK("281474976710656 281474976710656 281474976710656 281474976710656", "%llu %llu %llu %llu", ubuffer[0], ubuffer[1], ubuffer[2], ubuffer[3]);
+    PRINT_CHECK("18446744073709551615 18446744073709551615 18446744073709551615 18446744073709551615", "%llu %llu %llu %llu", u2buffer[0], u2buffer[1], u2buffer[2], u2buffer[3]);
+    PRINT_CHECK("1234567891234567 1234567891234567 1234567891234567 1234567891234567", "%llx %llx %llx %llx", xbuffer[0], xbuffer[1], xbuffer[2], xbuffer[3]);
+}
+
+static testfunc_t tests[] = {
+    test_space_flag,
+    test_plus_flag,
+    test_zero_flag,
+    test_minus_flag,
+    test_sharp_flag,
+    test_sharp_flag_with_long_long,
+    test_specifier,
+    test_width,
+    test_width_20,
+    test_width_asterisk_20,
+    test_width_minus_20,
+    test_padding_20,
+    test_padding_dot_20,
+    test_padding_sharp_020,
+    test_padding_sharp_20,
+    test_padding_20_point_5,
+    test_padding_negative_numbers,
+    test_float_padding_negative_numbers,
+    test_length,
+    test_infinity_and_not_a_number_values,
+    test_floating_point_specifiers_with_31_to_32_bit_integer_values,
+    test_tiny_floating_point_values,
+    test_floating_point_specifiers_precision_and_flags,
+    test_integer_types,
+    test_pointer,
+    test_string_length,
+    test_misc,
+    test_long_long_4,
+    test_buffer_long_long_4
+};
+
+int main(void)
+{
+    board_init();
+
+    for (int i = 0; i < sizeof(tests) / sizeof(testfunc_t); i++) {
+        printf("\r\ntest %d begin >>>>>>>>>>>\r\n", i);
+        tests[i]();
+        printf("test %d end >>>>>>>>>>>>>\r\n", i);
+    }
+
+    while (1) {
+        bflb_mtimer_delay_ms(1000);
+    }
+}

examples/printf/proj.conf

@@ -0,0 +1,5 @@
+set(CONFIG_VLIBC 0)
+
+set(CONFIG_VSNPRINTF_FLOAT 1)
+set(CONFIG_VSNPRINTF_FLOAT_EX 1)
+set(CONFIG_VSNPRINTF_LONG_LONG 1)