Merge pull request #23 from RT-Thread/master

pr

.gitattributes

@@ -1,3 +1,8 @@
+*.c linguist-language=C
+*.C linguist-language=C
+*.h linguist-language=C
+*.H linguist-language=C
+
 * text=auto
 
 *.S text

bsp/allwinner_tina/libcpu/interrupt.c

@@ -1,7 +1,7 @@
 /*
  * File      : interrupt.c
  * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2017, RT-Thread Development Team
+ * COPYRIGHT (C) 2017-2021, RT-Thread Development Team
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -20,6 +20,7 @@
  * Change Logs:
  * Date           Author       Notes
  * 2018-02-08     RT-Thread    the first version
+ * 2020-03-02     Howard Su    Use structure to access registers
  */
 
 #include <rthw.h>
@@ -38,9 +39,6 @@ static void rt_hw_interrupt_handler(int vector, void *param)
     rt_kprintf("Unhandled interrupt %d occured!!!\n", vector);
 }
 
-#define readl(addr)           (*(volatile unsigned int *)(addr))
-#define writel(value,addr)    (*(volatile unsigned int *)(addr) = (value))
-
 /**
  * This function will initialize hardware interrupt
  */
@@ -63,20 +61,20 @@ void rt_hw_interrupt_init(void)
     /* set base_addr reg */
     INTC->base_addr_reg = 0x00000000;
     /* clear enable */
-    INTC->en_reg0 = 0x00000000;
-    INTC->en_reg1 = 0x00000000;
+    INTC->en_reg[0] = 0x00000000;
+    INTC->en_reg[1] = 0x00000000;
     /* mask interrupt */
-    INTC->mask_reg0 = 0xFFFFFFFF;
-    INTC->mask_reg1 = 0xFFFFFFFF;
+    INTC->mask_reg[0] = 0xFFFFFFFF;
+    INTC->mask_reg[1] = 0xFFFFFFFF;
     /* clear pending */
-    INTC->pend_reg0 = 0x00000000;
-    INTC->pend_reg1 = 0x00000000;
+    INTC->pend_reg[0] = 0x00000000;
+    INTC->pend_reg[1] = 0x00000000;
     /* set priority */
-    INTC->resp_reg0 = 0x00000000;
-    INTC->resp_reg1 = 0x00000000;
+    INTC->resp_reg[0] = 0x00000000;
+    INTC->resp_reg[1] = 0x00000000;
     /* close fiq interrupt */
-    INTC->ff_reg0 = 0x00000000;
-    INTC->ff_reg1 = 0x00000000;
+    INTC->ff_reg[0] = 0x00000000;
+    INTC->ff_reg[1] = 0x00000000;
 }
 
 /**
@@ -85,20 +83,16 @@ void rt_hw_interrupt_init(void)
  */
 void rt_hw_interrupt_mask(int vector)
 {
-    rt_uint32_t mask_addr, data;
-
+    int index;
     if ((vector < 0) || (vector > INTERRUPTS_MAX))
     {
         return;
     }
 
-    mask_addr = (rt_uint32_t)(&INTC->mask_reg0);
-    mask_addr += vector & 0xE0 ? sizeof(rt_uint32_t *) : 0;
+    index = (vector & 0xE0) != 0;
+    vector = (vector & 0x1F);
 
-    vector &= 0x1F;
-    data = readl(mask_addr);
-    data |= 0x1 << vector;
-    writel(data, mask_addr);
+    INTC->mask_reg[index] |= 1 << vector;
 }
 
 /**
@@ -108,20 +102,16 @@ void rt_hw_interrupt_mask(int vector)
  */
 void rt_hw_interrupt_umask(int vector)
 {
-    rt_uint32_t mask_addr, data;
-
+    int index;
     if ((vector < 0) || (vector > INTERRUPTS_MAX))
     {
         return;
     }
 
-    mask_addr = (rt_uint32_t)(&INTC->mask_reg0);
-    mask_addr += vector & 0xE0 ? sizeof(rt_uint32_t *) : 0;
+    index = (vector & 0xE0) != 0;
+    vector = (vector & 0x1F);
 
-    vector &= 0x1F;
-    data = readl(mask_addr);
-    data &= ~(0x1 << vector);
-    writel(data, mask_addr);
+    INTC->mask_reg[index] &= ~(1 << vector);
 }
 
 /**
@@ -136,7 +126,7 @@ rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler,
         void *param, const char *name)
 {
     rt_isr_handler_t old_handler = RT_NULL;
-    rt_uint32_t pend_addr, en_addr, data;
+    int index;
 
     if ((vector < 0) || (vector > INTERRUPTS_MAX))
     {
@@ -151,19 +141,11 @@ rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler,
     isr_table[vector].handler = handler;
     isr_table[vector].param = param;
 
-    pend_addr = (rt_uint32_t)(&INTC->pend_reg0);
-    en_addr = (rt_uint32_t)(&INTC->en_reg0);
-    pend_addr += vector & 0xE0 ? sizeof(rt_uint32_t *) : 0;
-    en_addr += vector & 0xE0 ? sizeof(rt_uint32_t *) : 0;
+    index = (vector & 0xE0) != 0;
+    vector = (vector & 0x1F);
 
-    vector &= 0x1F;
-    data = readl(pend_addr);
-    data &= ~(0x1 << vector);
-    writel(data, pend_addr);
-
-    data = readl(en_addr);
-    data |= 0x1 << vector;
-    writel(data, en_addr);
+    INTC->pend_reg[index] &= ~(0x1 << vector);
+    INTC->en_reg[index] |= 0x1 << vector;
 
     return old_handler;
 }
@@ -173,7 +155,7 @@ void rt_interrupt_dispatch(rt_uint32_t fiq_irq)
     void *param;
     int vector;
     rt_isr_handler_t isr_func;
-    rt_uint32_t pend_addr, data;
+    int index;
 
     vector = INTC->vector_reg - INTC->base_addr_reg;
     vector = vector >> 2;
@@ -184,13 +166,11 @@ void rt_interrupt_dispatch(rt_uint32_t fiq_irq)
     /* jump to fun */
     isr_func(vector, param);
     /* clear pend bit */
-    pend_addr = (rt_uint32_t)(&INTC->pend_reg0);
-    pend_addr += vector & 0xE0 ? sizeof(rt_uint32_t *) : 0;
 
-    vector &= 0x1F;
-    data = readl(pend_addr);
-    data &= ~(0x1 << vector);
-    writel(data, pend_addr);
+    index = (vector & 0xE0) != 0;
+    vector = (vector & 0x1F);
+
+    INTC->pend_reg[index] &= ~(0x1 << vector);
 
 #ifdef RT_USING_INTERRUPT_INFO
     isr_table[vector].counter ++;

bsp/allwinner_tina/libcpu/interrupt.h

@@ -1,7 +1,7 @@
 /*
  * File      : interrupt.h
  * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2017, RT-Thread Development Team
+ * COPYRIGHT (C) 2017-2021, RT-Thread Development Team
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -20,6 +20,7 @@
  * Change Logs:
  * Date           Author       Notes
  * 2018-02-08     RT-Thread    the first version
+ * 2020-03-2      Howard Su    Define same regsiters as an array
  */
 #ifndef __INTERRUPT_H__
 #define __INTERRUPT_H__
@@ -74,34 +75,21 @@ struct tina_intc
     volatile rt_uint32_t base_addr_reg;    /* 0x04 */
     volatile rt_uint32_t reserved0;
     volatile rt_uint32_t nmi_ctrl_reg;     /* 0x0C */
-    volatile rt_uint32_t pend_reg0;        /* 0x10 */
-    volatile rt_uint32_t pend_reg1;        /* 0x14 */
+    volatile rt_uint32_t pend_reg[2];        /* 0x10, 0x14 */
     volatile rt_uint32_t reserved1[2];
-    volatile rt_uint32_t en_reg0;          /* 0x20 */
-    volatile rt_uint32_t en_reg1;          /* 0x24 */
+    volatile rt_uint32_t en_reg[2];          /* 0x20, 0x24 */
     volatile rt_uint32_t reserved2[2];
-    volatile rt_uint32_t mask_reg0;        /* 0x30 */
-    volatile rt_uint32_t mask_reg1;        /* 0x34 */
+    volatile rt_uint32_t mask_reg[2];        /* 0x30, 0x34 */
     volatile rt_uint32_t reserved3[2];
-    volatile rt_uint32_t resp_reg0;        /* 0x40 */
-    volatile rt_uint32_t resp_reg1;        /* 0x44 */
+    volatile rt_uint32_t resp_reg[2];        /* 0x40, 0x44 */
     volatile rt_uint32_t reserved4[2];
-    volatile rt_uint32_t ff_reg0;          /* 0x50 */
-    volatile rt_uint32_t ff_reg1;          /* 0x54 */
+    volatile rt_uint32_t ff_reg[2];          /* 0x50, 0x54 */
     volatile rt_uint32_t reserved5[2];
-    volatile rt_uint32_t prio_reg0;        /* 0x60 */
-    volatile rt_uint32_t prio_reg1;        /* 0x64 */
-    volatile rt_uint32_t prio_reg2;        /* 0x68 */
-    volatile rt_uint32_t prio_reg3;        /* 0x6C */
+    volatile rt_uint32_t prio_reg[4];        /* 0x60 - 0x6c */
 } ;
 
 typedef struct tina_intc *tina_intc_t;
 
 #define INTC ((tina_intc_t)INTC_BASE_ADDR)
 
-void rt_hw_interrupt_init(void);
-void rt_hw_interrupt_mask(int vector);
-void rt_hw_interrupt_umask(int vector);
-rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler, void *param, const char *name);
-
 #endif /* __INTERRUPT_H__ */

bsp/fh8620/libraries/driverlib/fh_mmc.c

@@ -194,7 +194,6 @@ int MMC_SetCardWidth(struct fh_mmc_obj *mmc_obj, int width)
     default:
         rt_kprintf("ERROR: %s, card width %d is not supported\n", __func__, width);
         return -RT_ERROR;
-        break;
     }
     return 0;
 }

bsp/nrf5x/nrf52832/.gitignore

@@ -0,0 +1,7 @@
+# vscode common config
+.vscode/*
+!.vscode/launch.json
+!.vscode/tasks.json
+
+# OS X icon info
+.DS_Store

bsp/nrf5x/nrf52832/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "cortex-debug",
+            "request": "launch",
+            "servertype": "jlink",
+            "cwd": "${workspaceRoot}",
+            "executable": "rt-thread.elf",
+            "name": "Cortex Debug",
+            "device": "nrf52",
+            "interface": "swd"
+        }
+    ]
+}

bsp/nrf5x/nrf52832/.vscode/tasks.json

@@ -0,0 +1,54 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "config",
+            "type": "shell",
+            "command": "RTT_ROOT=../../.. scons --pyconfig",
+            "problemMatcher": []
+        },
+        {
+            "label": "build",
+            "type": "shell",
+            "command": "scons",
+            "problemMatcher": [],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "clean",
+            "type": "shell",
+            "command": "scons -c",
+            "problemMatcher": []
+        },
+        {
+            "label": "flash",
+            "type": "shell",
+            "command": "nrfjprog -f nrf52 --program rt-thread.hex --sectorerase",
+            "group": "build",
+            "problemMatcher": []
+        },
+        {
+            "label": "flash_softdevice",
+            "type": "shell",
+            "command": "nrfjprog -f nrf52 --program packages/nrf5x_sdk-latest/components/softdevice/s132/hex/s132_nrf52_7.0.1_softdevice.hex --sectorerase",
+            "problemMatcher": []
+        },
+        {
+            "label": "erase",
+            "type": "shell",
+            "command": "nrfjprog -f nrf52 --eraseall",
+            "problemMatcher": []
+        },
+        {
+            "label": "reset",
+            "type": "shell",
+            "command": "nrfjprog -f nrf52 --reset",
+            "problemMatcher": []
+        }
+    ]
+}

bsp/nrf5x/nrf52832/README.md

@@ -2,7 +2,7 @@
 
 ## 简介
 
-该文件夹主要存放所有主芯片为nRF52840的板级支持包。目前默认支持的开发板是官方[PCA10040](https://www.nordicsemi.com/Software-and-tools/Development-Kits/nRF52-DK)
+该文件夹主要存放所有主芯片为nRF52832的板级支持包。目前默认支持的开发板是官方[PCA10040](https://www.nordicsemi.com/Software-and-tools/Development-Kits/nRF52-DK)
 主要内容如下：
 
 - 开发板资源介绍
@@ -61,6 +61,30 @@ PCA10040-nrf52832开发板常用 **板载资源** 如下：
 4. 输入`scons --target=mdk4/mdk5/iar` 命令重新生成工程。
 
 
+### VS Code开发支持
+
+配置步骤：
+
+1. 在命令行设置以下两个环境变量：
+
+    ```bash
+    export RTT_CC=gcc
+    export RTT_EXEC_PATH=<工具链路径/bin>
+    ```
+
+2. 搜索插件`Cortex-debug`并安装。
+3. 安装[nRF Command Line Tools](https://www.nordicsemi.com/Software-and-tools/Development-Tools/nRF-Command-Line-Tools)以支持`nrfjprog`命令。
+4. 在.vscode/settings.json内配置工具链和`JlinkGDBServer`，sample：
+
+    ```json
+    {
+        "cortex-debug.armToolchainPath": "/usr/local/gcc-arm-none-eabi-9-2019-q4-major/bin/",
+        "cortex-debug.armToolchainPrefix": "arm-none-eabi",
+        "cortex-debug.JLinkGDBServerPath": "/Applications/SEGGER/JLink/JLinkGDBServer"
+    }
+    ```
+
+5. 点击`终端`->`运行任务`->`build`编译，点击`终端`->`运行任务`->`flash`烧录，点击左侧`debug`->`run`使用VS Code进行debug。
 
 ## 支持其他开发板
 

bsp/nrf5x/nrf52832/rtconfig.py

@@ -54,7 +54,9 @@ if PLATFORM == 'gcc':
     else:
         CFLAGS += ' -O2'
 
-    POST_ACTION = OBJCPY + ' -O binary $TARGET rtthread.bin\n' + SIZE + ' $TARGET \n'
+    POST_ACTION = OBJCPY + ' -O binary $TARGET rt-thread.bin\n'
+    POST_ACTION += OBJCPY + ' -O ihex $TARGET rt-thread.hex\n'
+    POST_ACTION += SIZE + ' $TARGET \n'
 
 elif PLATFORM == 'armcc':
     # toolchains

components/drivers/Kconfig

@@ -642,6 +642,14 @@ menu "Using USB"
                     string "Udisk mount dir"
                     default "/"
                 endif
+            config RT_USBH_HID
+                bool "Enable HID Drivers"
+                default n
+                if RT_USBH_HID
+                    config RT_USBH_HID_MOUSE
+                    bool "Enable HID mouse protocol"
+                    default n
+                endif
         endif
     config RT_USING_USB_DEVICE
         bool "Using USB device"

components/drivers/include/ipc/workqueue.h

@@ -29,6 +29,7 @@ enum
 struct rt_workqueue
 {
     rt_list_t      work_list;
+    rt_list_t      delayed_list;
     struct rt_work *work_current; /* current work */
 
     struct rt_semaphore sem;
@@ -62,6 +63,7 @@ rt_err_t rt_workqueue_dowork(struct rt_workqueue *queue, struct rt_work *work);
 rt_err_t rt_workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *work, rt_tick_t time);
 rt_err_t rt_workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *work);
 rt_err_t rt_workqueue_cancel_work_sync(struct rt_workqueue *queue, struct rt_work *work);
+rt_err_t rt_workqueue_cancel_all_work(struct rt_workqueue *queue);
 
 #ifdef RT_USING_SYSTEM_WORKQUEUE
 rt_err_t rt_work_submit(struct rt_work *work, rt_tick_t time);

components/drivers/src/workqueue.c

@@ -58,15 +58,17 @@ static void _workqueue_thread_entry(void *parameter)
 
     while (1)
     {
+        level = rt_hw_interrupt_disable();
         if (rt_list_isempty(&(queue->work_list)))
         {
             /* no software timer exist, suspend self. */
             rt_thread_suspend(rt_thread_self());
+            rt_hw_interrupt_enable(level);
             rt_schedule();
+            continue;
         }
 
         /* we have work to do with. */
-        level = rt_hw_interrupt_disable();
         work = rt_list_entry(queue->work_list.next, struct rt_work, list);
         rt_list_remove(&(work->list));
         queue->work_current = work;
@@ -76,175 +78,134 @@ static void _workqueue_thread_entry(void *parameter)
 
         /* do work */
         work->work_func(work, work->work_data);
-        level = rt_hw_interrupt_disable();
         /* clean current work */
         queue->work_current = RT_NULL;
-        rt_hw_interrupt_enable(level);
 
         /* ack work completion */
         _workqueue_work_completion(queue);
     }
 }
 
-static rt_err_t _workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *work)
+static rt_err_t _workqueue_submit_work(struct rt_workqueue *queue,
+        struct rt_work *work, rt_tick_t ticks)
 {
     rt_base_t level;
+    rt_err_t err;
 
     level = rt_hw_interrupt_disable();
-    if (work->flags & RT_WORK_STATE_PENDING)
-    {
-        rt_hw_interrupt_enable(level);
-        return -RT_EBUSY;
-    }
-
-    if (queue->work_current == work)
-    {
-        rt_hw_interrupt_enable(level);
-        return -RT_EBUSY;
-    }
-
-    /* NOTE: the work MUST be initialized firstly */
+    /* remove list */
     rt_list_remove(&(work->list));
-
-    rt_list_insert_after(queue->work_list.prev, &(work->list));
-    work->flags |= RT_WORK_STATE_PENDING;
-
-    /* whether the workqueue is doing work */
-    if (queue->work_current == RT_NULL)
+    work->flags &= ~RT_WORK_STATE_PENDING;
+    /*  */
+    if (ticks == 0)
     {
-        rt_hw_interrupt_enable(level);
-        /* resume work thread */
-        rt_thread_resume(queue->work_thread);
-        rt_schedule();
+        if (queue->work_current != work)
+        {
+            rt_list_insert_after(queue->work_list.prev, &(work->list));
+            work->flags |= RT_WORK_STATE_PENDING;
+            work->workqueue = queue;
+            err = RT_EOK;
+        }
+        else
+        {
+            err = -RT_EBUSY;
+        }
+
+        /* whether the workqueue is doing work */
+        if (queue->work_current == RT_NULL &&
+            ((queue->work_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND))
+        {
+            /* resume work thread */
+            rt_thread_resume(queue->work_thread);
+            rt_hw_interrupt_enable(level);
+            rt_schedule();
+        }
+        else
+        {
+            rt_hw_interrupt_enable(level);
+        }
+        return err;
     }
-    else
+    else if (ticks < RT_TICK_MAX / 2)
     {
+        /* Timer started */
+        if (work->flags & RT_WORK_STATE_SUBMITTING)
+        {
+            rt_timer_stop(&work->timer);
+            rt_timer_control(&work->timer, RT_TIMER_CTRL_SET_TIME, &ticks);
+        }
+        else
+        {
+            rt_timer_init(&(work->timer), "work", _delayed_work_timeout_handler,
+                        work, ticks, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER);
+            work->flags |= RT_WORK_STATE_SUBMITTING;
+        }
+        work->workqueue = queue;
+        /* insert delay work list */
+        rt_list_insert_after(queue->delayed_list.prev, &(work->list));
         rt_hw_interrupt_enable(level);
+        rt_timer_start(&(work->timer));
+        return RT_EOK;
     }
-
-    return RT_EOK;
+    rt_hw_interrupt_enable(level);
+    return -RT_ERROR;
 }
 
 static rt_err_t _workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *work)
 {
     rt_base_t level;
+    rt_err_t err;
 
     level = rt_hw_interrupt_disable();
-    if (queue->work_current == work)
-    {
-        rt_hw_interrupt_enable(level);
-        return -RT_EBUSY;
-    }
     rt_list_remove(&(work->list));
     work->flags &= ~RT_WORK_STATE_PENDING;
-    rt_hw_interrupt_enable(level);
-
-    return RT_EOK;
-}
-
-static rt_err_t _workqueue_cancel_delayed_work(struct rt_work *work)
-{
-    rt_base_t level;
-    int ret = RT_EOK;
-
-    if (!work->workqueue)
-    {
-        ret = -EINVAL;
-        goto __exit;
-    }
-
-    if (work->flags & RT_WORK_STATE_PENDING)
-    {
-        /* Remove from the queue if already submitted */
-        ret = _workqueue_cancel_work(work->workqueue, work);
-        if (ret)
-        {
-            goto __exit;
-        }
-    }
-    else
+    /* Timer started */
+    if (work->flags & RT_WORK_STATE_SUBMITTING)
     {
-        if (work->flags & RT_WORK_STATE_SUBMITTING)
-        {
-            level = rt_hw_interrupt_disable();
-            rt_timer_stop(&(work->timer));
-            rt_timer_detach(&(work->timer));
-            work->flags &= ~RT_WORK_STATE_SUBMITTING;
-            rt_hw_interrupt_enable(level);
-        }
+        rt_timer_stop(&(work->timer));
+        rt_timer_detach(&(work->timer));
+        work->flags &= ~RT_WORK_STATE_SUBMITTING;
     }
-
-    level = rt_hw_interrupt_disable();
-    /* Detach from workqueue */
+    err = queue->work_current != work ? RT_EOK : -RT_EBUSY;
     work->workqueue = RT_NULL;
-    work->flags &= ~(RT_WORK_STATE_PENDING);
     rt_hw_interrupt_enable(level);
-
-__exit:
-    return ret;
+    return err;
 }
 
-static rt_err_t _workqueue_submit_delayed_work(struct rt_workqueue *queue,
-        struct rt_work *work, rt_tick_t ticks)
+static void _delayed_work_timeout_handler(void *parameter)
 {
+    struct rt_work *work;
+    struct rt_workqueue *queue;
     rt_base_t level;
-    rt_err_t ret = RT_EOK;
 
-    /* Work cannot be active in multiple queues */
-    if (work->workqueue && work->workqueue != queue)
-    {
-        ret = -RT_EINVAL;
-        goto __exit;
-    }
+    work = (struct rt_work *)parameter;
+    queue = work->workqueue;
+    RT_ASSERT(queue != RT_NULL);
 
-    /* Cancel if work has been submitted */
-    if (work->workqueue == queue)
+    level = rt_hw_interrupt_disable();
+    rt_timer_detach(&(work->timer));
+    work->flags &= ~RT_WORK_STATE_SUBMITTING;
+    /* remove delay list */
+    rt_list_remove(&(work->list));
+    /* insert work queue */
+    if (queue->work_current != work)
     {
-        ret = _workqueue_cancel_delayed_work(work);
-        if (ret < 0)
-        {
-            goto __exit;
-        }
+        rt_list_insert_after(queue->work_list.prev, &(work->list));
+        work->flags |= RT_WORK_STATE_PENDING;
     }
-
-    level = rt_hw_interrupt_disable();
-    /* Attach workqueue so the timeout callback can submit it */
-    work->workqueue = queue;
-    rt_hw_interrupt_enable(level);
-
-    if (!ticks)
+    /* whether the workqueue is doing work */
+    if (queue->work_current == RT_NULL &&
+        ((queue->work_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND))
     {
-        /* Submit work if no ticks is 0 */
-        ret = _workqueue_submit_work(work->workqueue, work);
+        /* resume work thread */
+        rt_thread_resume(queue->work_thread);
+        rt_hw_interrupt_enable(level);
+        rt_schedule();
     }
     else
     {
-        level = rt_hw_interrupt_disable();
-        /* Add timeout */
-        work->flags |= RT_WORK_STATE_SUBMITTING;
-        rt_timer_init(&(work->timer), "work", _delayed_work_timeout_handler, work, ticks,
-                      RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER);
         rt_hw_interrupt_enable(level);
-        rt_timer_start(&(work->timer));
     }
-
-__exit:
-    return ret;
-}
-
-static void _delayed_work_timeout_handler(void *parameter)
-{
-    struct rt_work *delayed_work;
-    rt_base_t level;
-
-    delayed_work = (struct rt_work *)parameter;
-    level = rt_hw_interrupt_disable();
-    rt_timer_stop(&(delayed_work->timer));
-    rt_timer_detach(&(delayed_work->timer));
-    delayed_work->flags &= ~RT_WORK_STATE_SUBMITTING;
-    delayed_work->type &= ~RT_WORK_TYPE_DELAYED;
-    rt_hw_interrupt_enable(level);
-    _workqueue_submit_work(delayed_work->workqueue, delayed_work);
 }
 
 struct rt_workqueue *rt_workqueue_create(const char *name, rt_uint16_t stack_size, rt_uint8_t priority)
@@ -256,6 +217,7 @@ struct rt_workqueue *rt_workqueue_create(const char *name, rt_uint16_t stack_siz
     {
         /* initialize work list */
         rt_list_init(&(queue->work_list));
+        rt_list_init(&(queue->delayed_list));
         queue->work_current = RT_NULL;
         rt_sem_init(&(queue->sem), "wqueue", 0, RT_IPC_FLAG_FIFO);
 
@@ -277,7 +239,9 @@ rt_err_t rt_workqueue_destroy(struct rt_workqueue *queue)
 {
     RT_ASSERT(queue != RT_NULL);
 
+    rt_workqueue_cancel_all_work(queue);
     rt_thread_delete(queue->work_thread);
+    rt_sem_detach(&(queue->sem));
     RT_KERNEL_FREE(queue);
 
     return RT_EOK;
@@ -288,7 +252,7 @@ rt_err_t rt_workqueue_dowork(struct rt_workqueue *queue, struct rt_work *work)
     RT_ASSERT(queue != RT_NULL);
     RT_ASSERT(work != RT_NULL);
 
-    return _workqueue_submit_work(queue, work);
+    return _workqueue_submit_work(queue, work, 0);
 }
 
 rt_err_t rt_workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *work, rt_tick_t time)
@@ -296,19 +260,7 @@ rt_err_t rt_workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *wo
     RT_ASSERT(queue != RT_NULL);
     RT_ASSERT(work != RT_NULL);
 
-    if (time > 0)
-    {
-        work->type |= RT_WORK_TYPE_DELAYED;
-    }
-
-    if (work->type & RT_WORK_TYPE_DELAYED)
-    {
-        return _workqueue_submit_delayed_work(queue, work, time);
-    }
-    else
-    {
-        return _workqueue_submit_work(queue, work);
-    }
+    return _workqueue_submit_work(queue, work, time);
 }
 
 rt_err_t rt_workqueue_critical_work(struct rt_workqueue *queue, struct rt_work *work)
@@ -318,51 +270,38 @@ rt_err_t rt_workqueue_critical_work(struct rt_workqueue *queue, struct rt_work *
     RT_ASSERT(work != RT_NULL);
 
     level = rt_hw_interrupt_disable();
-    if (queue->work_current == work)
-    {
-        rt_hw_interrupt_enable(level);
-        return -RT_EBUSY;
-    }
-
     /* NOTE: the work MUST be initialized firstly */
     rt_list_remove(&(work->list));
-
-    rt_list_insert_after(queue->work_list.prev, &(work->list));
-    if (queue->work_current == RT_NULL)
+    rt_list_insert_after(&queue->work_list, &(work->list));
+    /* whether the workqueue is doing work */
+    if (queue->work_current == RT_NULL &&
+        ((queue->work_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND))
     {
-        rt_hw_interrupt_enable(level);
         /* resume work thread */
         rt_thread_resume(queue->work_thread);
+        rt_hw_interrupt_enable(level);
         rt_schedule();
     }
-    else rt_hw_interrupt_enable(level);
+    else
+    {
+        rt_hw_interrupt_enable(level);
+    }
 
     return RT_EOK;
 }
 
 rt_err_t rt_workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *work)
 {
-    RT_ASSERT(queue != RT_NULL);
     RT_ASSERT(work != RT_NULL);
-
-    if (work->type & RT_WORK_TYPE_DELAYED)
-    {
-        return _workqueue_cancel_delayed_work(work);
-    }
-    else
-    {
-        return _workqueue_cancel_work(queue, work);
-    }
+    RT_ASSERT(queue != RT_NULL);
+    return _workqueue_cancel_work(queue, work);
 }
 
 rt_err_t rt_workqueue_cancel_work_sync(struct rt_workqueue *queue, struct rt_work *work)
 {
-    rt_base_t level;
-
     RT_ASSERT(queue != RT_NULL);
     RT_ASSERT(work != RT_NULL);
 
-    level = rt_hw_interrupt_disable();
     if (queue->work_current == work) /* it's current work in the queue */
     {
         /* wait for work completion */
@@ -370,24 +309,30 @@ rt_err_t rt_workqueue_cancel_work_sync(struct rt_workqueue *queue, struct rt_wor
     }
     else
     {
-        rt_list_remove(&(work->list));
+        _workqueue_cancel_work(queue, work);
     }
-    work->flags &= ~RT_WORK_STATE_PENDING;
-    rt_hw_interrupt_enable(level);
 
     return RT_EOK;
 }
 
 rt_err_t rt_workqueue_cancel_all_work(struct rt_workqueue *queue)
 {
-    struct rt_list_node *node, *next;
+    struct rt_work *work;
+
     RT_ASSERT(queue != RT_NULL);
 
+    /* cancel work */
     rt_enter_critical();
-    for (node = queue->work_list.next; node != &(queue->work_list); node = next)
+    while (rt_list_isempty(&queue->work_list) == RT_FALSE)
+    {
+        work = rt_list_first_entry(&queue->work_list, struct rt_work, list);
+        _workqueue_cancel_work(queue, work);
+    }
+    /* cancel delay work */
+    while (rt_list_isempty(&queue->delayed_list) == RT_FALSE)
     {
-        next = node->next;
-        rt_list_remove(node);
+        work = rt_list_first_entry(&queue->delayed_list, struct rt_work, list);
+        _workqueue_cancel_work(queue, work);
     }
     rt_exit_critical();
 
@@ -416,14 +361,14 @@ rt_err_t rt_work_cancel(struct rt_work *work)
 int rt_work_sys_workqueue_init(void)
 {
     if (sys_workq != RT_NULL)
-        return 0;
+        return RT_EOK;
 
     sys_workq = rt_workqueue_create("sys_work", RT_SYSTEM_WORKQUEUE_STACKSIZE,
                                     RT_SYSTEM_WORKQUEUE_PRIORITY);
+    RT_ASSERT(sys_workq != RT_NULL);
 
     return RT_EOK;
 }
-
 INIT_PREV_EXPORT(rt_work_sys_workqueue_init);
 #endif
 #endif

components/drivers/usb/usbhost/class/hid.c

@@ -6,6 +6,7 @@
  * Change Logs:
  * Date           Author       Notes
  * 2011-12-12     Yi Qiu      first version
+ * 2021-02-23     Leslie Lee  update with current usb api
  */
 
 #include <rtthread.h>
@@ -26,7 +27,7 @@ static rt_list_t _protocal_list;
  * 
  * @return the error code, RT_EOK on successfully.
 */
-rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id)
+rt_err_t rt_usbh_hid_set_idle(struct uhintf* intf, int duration, int report_id)
 {
     struct urequest setup;
     struct uinstance* device;    
@@ -40,14 +41,15 @@ rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id)
 
     setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
         USB_REQ_TYPE_INTERFACE;
-    setup.request = USB_REQ_SET_IDLE;
-    setup.index = 0;
-    setup.length = 0;
-    setup.value = (duration << 8 )| report_id;
-
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, 
-        timeout) == 0) return RT_EOK;
-    else return -RT_FALSE;    
+    setup.bRequest = USB_REQ_SET_IDLE;
+    setup.wIndex = 0;
+    setup.wLength = 0;
+    setup.wValue = (duration << 8 )| report_id;
+
+    if (rt_usb_hcd_setup_xfer(device->hcd, device->pipe_ep0_out, &setup, timeout) == 8)
+        return RT_EOK;
+    else
+        return -RT_FALSE;    
 }
 
 /**
@@ -59,7 +61,7 @@ rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id)
  * 
  * @return the error code, RT_EOK on successfully.
 */
-rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type, 
+rt_err_t rt_usbh_hid_get_report(struct uhintf* intf, rt_uint8_t type, 
     rt_uint8_t id, rt_uint8_t *buffer, rt_size_t size)
 {
     struct urequest setup;
@@ -74,14 +76,24 @@ rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type,
 
     setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | 
         USB_REQ_TYPE_INTERFACE;
-    setup.request = USB_REQ_GET_REPORT;
-    setup.index = intf->intf_desc->bInterfaceNumber;
-    setup.length = size;
-    setup.value = (type << 8 ) + id;
-
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size, 
-        timeout) == size) return RT_EOK;
-    else return -RT_FALSE;    
+    setup.bRequest = USB_REQ_GET_REPORT;
+    setup.wIndex = intf->intf_desc->bInterfaceNumber;
+    setup.wLength = size;
+    setup.wValue = (type << 8 ) + id;
+
+    if (rt_usb_hcd_setup_xfer(device->hcd, device->pipe_ep0_out, &setup, timeout) == 8)
+    {
+        if (rt_usb_hcd_pipe_xfer(device->hcd, device->pipe_ep0_in, buffer, size, timeout) == size)
+        {
+            if (rt_usb_hcd_pipe_xfer(device->hcd, device->pipe_ep0_out, RT_NULL, 0, timeout) == 0)
+            {
+                return RT_EOK;
+            }
+        }
+    }
+    else
+        return -RT_FALSE;
+    return -RT_FALSE; 
 }
 
 /**
@@ -93,7 +105,7 @@ rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type,
  * 
  * @return the error code, RT_EOK on successfully.
 */
-rt_err_t rt_usbh_hid_set_report(struct uintf* intf, rt_uint8_t *buffer, rt_size_t size)
+rt_err_t rt_usbh_hid_set_report(struct uhintf* intf, rt_uint8_t *buffer, rt_size_t size)
 {
     struct urequest setup;
     struct uinstance* device;        
@@ -107,14 +119,15 @@ rt_err_t rt_usbh_hid_set_report(struct uintf* intf, rt_uint8_t *buffer, rt_size_
 
     setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
         USB_REQ_TYPE_INTERFACE;
-    setup.request = USB_REQ_SET_REPORT;
-    setup.index = intf->intf_desc->bInterfaceNumber;
-    setup.length = size;
-    setup.value = 0x02 << 8;
-
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size, 
-        timeout) == size) return RT_EOK;
-    else return -RT_FALSE;    
+    setup.bRequest = USB_REQ_SET_REPORT;
+    setup.wIndex = intf->intf_desc->bInterfaceNumber;
+    setup.wLength = size;
+    setup.wValue = 0x02 << 8;
+
+    if (rt_usb_hcd_setup_xfer(device->hcd, device->pipe_ep0_out, &setup, timeout) == 8)
+        return RT_EOK;
+    else
+        return -RT_FALSE;    
 }
 
 /**
@@ -125,7 +138,7 @@ rt_err_t rt_usbh_hid_set_report(struct uintf* intf, rt_uint8_t *buffer, rt_size_
  * 
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_hid_set_protocal(struct uintf* intf, int protocol)
+rt_err_t rt_usbh_hid_set_protocal(struct uhintf* intf, int protocol)
 {
     struct urequest setup;
     struct uinstance* device;
@@ -139,14 +152,15 @@ rt_err_t rt_usbh_hid_set_protocal(struct uintf* intf, int protocol)
 
     setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | 
         USB_REQ_TYPE_INTERFACE;
-    setup.request = USB_REQ_SET_PROTOCOL;
-    setup.index = 0;
-    setup.length = 0;
-    setup.value = protocol;
-
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, 
-        timeout) == 0) return RT_EOK;
-    else return -RT_FALSE;    
+    setup.bRequest = USB_REQ_SET_PROTOCOL;
+    setup.wIndex = 0;
+    setup.wLength = 0;
+    setup.wValue = protocol;
+
+    if (rt_usb_hcd_setup_xfer(device->hcd, device->pipe_ep0_out, &setup, timeout) == 8)
+        return RT_EOK;
+    else
+        return -RT_FALSE;    
 }
 
 /**
@@ -159,7 +173,7 @@ rt_err_t rt_usbh_hid_set_protocal(struct uintf* intf, int protocol)
  * 
  * @return the error code, RT_EOK on successfully.
  */
-rt_err_t rt_usbh_hid_get_report_descriptor(struct uintf* intf, 
+rt_err_t rt_usbh_hid_get_report_descriptor(struct uhintf* intf, 
     rt_uint8_t *buffer, rt_size_t size)
 {
     struct urequest setup;
@@ -174,14 +188,24 @@ rt_err_t rt_usbh_hid_get_report_descriptor(struct uintf* intf,
 
     setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_STANDARD| 
         USB_REQ_TYPE_INTERFACE;
-    setup.request = USB_REQ_GET_DESCRIPTOR;
-    setup.index = 0;
-    setup.length = size;
-    setup.value = USB_DESC_TYPE_REPORT << 8;
-
-    if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size, 
-        timeout) == size) return RT_EOK;
-    else return -RT_FALSE;
+    setup.bRequest = USB_REQ_GET_DESCRIPTOR;
+    setup.wIndex = 0;
+    setup.wLength = size;
+    setup.wValue = USB_DESC_TYPE_REPORT << 8;
+
+    if (rt_usb_hcd_setup_xfer(device->hcd, device->pipe_ep0_out, &setup, timeout) == 8)
+    {
+        if (rt_usb_hcd_pipe_xfer(device->hcd, device->pipe_ep0_in, buffer, size, timeout) == size)
+        {
+            if (rt_usb_hcd_pipe_xfer(device->hcd, device->pipe_ep0_out, RT_NULL, 0, timeout) == 0)
+            {
+                return RT_EOK;
+            }
+        }
+    }
+    else
+        return -RT_FALSE;
+    return -RT_FALSE;
 }
 
 /**
@@ -220,16 +244,16 @@ static void rt_usbh_hid_callback(void* context)
     RT_ASSERT(context != RT_NULL);
     
     pipe = (upipe_t)context;
-    hid = (struct uhid*)pipe->intf->user_data;
+    hid = (struct uhid*)((struct uhintf*)pipe->inst)->user_data;
 
     /* invoke protocal callback function */
     hid->protocal->callback((void*)hid);
 
     /* parameter check */
-     RT_ASSERT(pipe->intf->device->hcd != RT_NULL);
+     RT_ASSERT(((struct uhintf*)pipe->inst)->device->hcd != RT_NULL);
 
-    rt_usb_hcd_int_xfer(pipe->intf->device->hcd, pipe, hid->buffer, 
-        pipe->ep.wMaxPacketSize, timeout);
+    rt_usb_hcd_pipe_xfer(((struct uhintf*)pipe->inst)->device->hcd, pipe, 
+        hid->buffer, pipe->ep.wMaxPacketSize, timeout);
 }
 
 /**
@@ -268,9 +292,7 @@ static rt_err_t rt_usbh_hid_enable(void* arg)
     int i = 0, pro_id;
     uprotocal_t protocal;    
     struct uhid* hid;
-    struct uintf* intf = (struct uintf*)arg;
-    int timeout = USB_TIMEOUT_BASIC;
-    upipe_t pipe;
+    struct uhintf* intf = (struct uhintf*)arg;
     
     /* parameter check */
     if(intf == RT_NULL)
@@ -319,19 +341,13 @@ static rt_err_t rt_usbh_hid_enable(void* arg)
         if(!(ep_desc->bEndpointAddress & USB_DIR_IN)) continue;
 
         ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &hid->pipe_in, 
-            intf, ep_desc, rt_usbh_hid_callback);        
+            intf, ep_desc);
         if(ret != RT_EOK) return ret;
     }
 
     /* initialize hid protocal */
-    hid->protocal->init((void*)intf);    
-    pipe = hid->pipe_in;
+    hid->protocal->init((void*)intf);
 
-    /* parameter check */
-     RT_ASSERT(pipe->intf->device->hcd != RT_NULL);
-    
-    rt_usb_hcd_int_xfer(pipe->intf->device->hcd, hid->pipe_in, 
-        hid->buffer, hid->pipe_in->ep.wMaxPacketSize, timeout);
     return RT_EOK;
 }
 
@@ -346,7 +362,7 @@ static rt_err_t rt_usbh_hid_enable(void* arg)
 static rt_err_t rt_usbh_hid_disable(void* arg)
 {
     struct uhid* hid;
-    struct uintf* intf = (struct uintf*)arg;
+    struct uhintf* intf = (struct uhintf*)arg;
 
     RT_ASSERT(intf != RT_NULL);
 
@@ -364,9 +380,6 @@ static rt_err_t rt_usbh_hid_disable(void* arg)
         /* free the hid instance */    
         rt_free(hid);
     }
-    
-    /* free the instance */
-    rt_free(intf);
 
     return RT_EOK;
 }

components/drivers/usb/usbhost/class/hid.h

@@ -31,11 +31,11 @@ typedef struct uhid uhid_t;
 #define USB_HID_KEYBOARD        1    
 #define USB_HID_MOUSE            2
 
-rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id);
-rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type, rt_uint8_t id, rt_uint8_t *buffer, rt_size_t size);
-rt_err_t rt_usbh_hid_set_report(struct uintf* intf, rt_uint8_t *buffer, rt_size_t size);
-rt_err_t rt_usbh_hid_set_protocal(struct uintf* intf, int protocol);
-rt_err_t rt_usbh_hid_get_report_descriptor(struct uintf* intf, rt_uint8_t *buffer, rt_size_t size);
+rt_err_t rt_usbh_hid_set_idle(struct uhintf* intf, int duration, int report_id);
+rt_err_t rt_usbh_hid_get_report(struct uhintf* intf, rt_uint8_t type, rt_uint8_t id, rt_uint8_t *buffer, rt_size_t size);
+rt_err_t rt_usbh_hid_set_report(struct uhintf* intf, rt_uint8_t *buffer, rt_size_t size);
+rt_err_t rt_usbh_hid_set_protocal(struct uhintf* intf, int protocol);
+rt_err_t rt_usbh_hid_get_report_descriptor(struct uhintf* intf, rt_uint8_t *buffer, rt_size_t size);
 rt_err_t rt_usbh_hid_protocal_register(uprotocal_t protocal);
 
-#endif
+#endif

components/drivers/usb/usbhost/class/umouse.c

@@ -126,15 +126,36 @@ static rt_err_t rt_usbh_hid_mouse_callback(void* arg)
     return RT_EOK;
 }
 
+rt_thread_t mouse_thread;
+void mouse_task(void* param)
+{
+    struct uhintf* intf = (struct uhintf*)param;
+    while (1)
+    {
+        if (rt_usb_hcd_pipe_xfer(intf->device->hcd, ((struct uhid*)intf->user_data)->pipe_in,
+            ((struct uhid*)intf->user_data)->buffer, ((struct uhid*)intf->user_data)->pipe_in->ep.wMaxPacketSize,
+            USB_TIMEOUT_BASIC) == 0)
+        {
+            break;
+        }
+
+        rt_usbh_hid_mouse_callback(intf->user_data);
+    }
+}
+
+
 static rt_err_t rt_usbh_hid_mouse_init(void* arg)
 {
-    struct uintf* intf = (struct uintf*)arg;
+    struct uhintf* intf = (struct uhintf*)arg;
 
     RT_ASSERT(intf != RT_NULL);
 
     rt_usbh_hid_set_protocal(intf, 0);
 
-    rt_usbh_hid_set_idle(intf, 10, 0);
+    rt_usbh_hid_set_idle(intf, 0, 0);
+
+    mouse_thread = rt_thread_create("mouse0", mouse_task, intf, 500, 8, 100);
+    rt_thread_startup(mouse_thread);
 
     RT_DEBUG_LOG(RT_DEBUG_USB, ("start usb mouse\n"));
 #ifdef RT_USING_RTGUI

components/net/at/src/at_client.c

@@ -434,20 +434,18 @@ static rt_err_t at_client_getchar(at_client_t client, char *ch, rt_int32_t timeo
 {
     rt_err_t result = RT_EOK;
 
-__retry:
-    result = rt_sem_take(client->rx_notice, rt_tick_from_millisecond(timeout));
-    if (result != RT_EOK)
-    {
-        return result;
-    }
-    if(rt_device_read(client->device, 0, ch, 1) == 1)
-    {
-        return RT_EOK;
-    }
-    else
+    while (rt_device_read(client->device, 0, ch, 1) == 0)
     {
-        goto __retry;
+        result = rt_sem_take(client->rx_notice, rt_tick_from_millisecond(timeout));
+        if (result != RT_EOK)
+        {
+            return result;
+        }
+
+        rt_sem_control(client->rx_notice, RT_IPC_CMD_RESET, RT_NULL);
     }
+
+    return RT_EOK;
 }
 
 /**

components/utilities/ulog/ulog.c

@@ -667,6 +667,9 @@ void ulog_hexdump(const char *tag, rt_size_t width, rt_uint8_t *buf, rt_size_t s
 
     rt_size_t i, j;
     rt_size_t log_len = 0, name_len = rt_strlen(tag);
+#ifdef ULOG_OUTPUT_TIME
+    rt_size_t time_head_len = 0;
+#endif
     char *log_buf = NULL, dump_string[8];
     int fmt_result;
 
@@ -703,6 +706,35 @@ void ulog_hexdump(const char *tag, rt_size_t width, rt_uint8_t *buf, rt_size_t s
         /* package header */
         if (i == 0)
         {
+#ifdef ULOG_OUTPUT_TIME
+            /* add time info */
+#ifdef ULOG_TIME_USING_TIMESTAMP
+            static time_t now;
+            static struct tm *tm, tm_tmp;
+
+            now = time(NULL);
+            tm = gmtime_r(&now, &tm_tmp);
+
+#ifdef RT_USING_SOFT_RTC
+            rt_snprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE - log_len, "%02d-%02d %02d:%02d:%02d.%03d ", tm->tm_mon + 1,
+                tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, rt_tick_get() % 1000);
+#else
+            rt_snprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE - log_len, "%02d-%02d %02d:%02d:%02d ", tm->tm_mon + 1,
+                tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
+#endif /* RT_USING_SOFT_RTC */
+
+#else
+            static rt_size_t tick_len = 0;
+
+            log_buf[log_len] = '[';
+            tick_len = ulog_ultoa(log_buf + log_len + 1, rt_tick_get());
+            log_buf[log_len + 1 + tick_len] = ']';
+            log_buf[log_len + 2 + tick_len] = ' ';
+            log_buf[log_len + 3 + tick_len] = '\0';
+#endif /* ULOG_TIME_USING_TIMESTAMP */
+            time_head_len = rt_strlen(log_buf + log_len);
+            log_len += time_head_len;
+#endif /* ULOG_OUTPUT_TIME */
             log_len += ulog_strcpy(log_len, log_buf + log_len, "D/HEX ");
             log_len += ulog_strcpy(log_len, log_buf + log_len, tag);
             log_len += ulog_strcpy(log_len, log_buf + log_len, ": ");
@@ -710,6 +742,9 @@ void ulog_hexdump(const char *tag, rt_size_t width, rt_uint8_t *buf, rt_size_t s
         else
         {
             log_len = 6 + name_len + 2;
+#ifdef ULOG_OUTPUT_TIME
+            log_len += time_head_len;
+#endif
             rt_memset(log_buf, ' ', log_len);
         }
         fmt_result = rt_snprintf(log_buf + log_len, ULOG_LINE_BUF_SIZE, "%04X-%04X: ", i, i + width - 1);

libcpu/arm/cortex-m33/cpuport.c

@@ -473,17 +473,13 @@ exit
 #elif defined(__CLANG_ARM)
 int __rt_ffs(int value)
 {
-    __asm volatile(
-        "CMP     r0, #0x00            \n"
-        "BEQ     1f                   \n"
+    if (value == 0) return value;
 
+    __asm volatile(
         "RBIT    r0, r0               \n"
         "CLZ     r0, r0               \n"
         "ADDS    r0, r0, #0x01        \n"
 
-        "1:                           \n"
-        "BX      lr                   \n"
-
         : "=r"(value)
         : "r"(value)
     );