Sync from master v4.0.2 .

armink · armink · commit a383385a3c0a · 2019-12-20T16:03:33.000+08:00
diff --git a/components/dfs/src/dfs_file.c b/components/dfs/src/dfs_file.c
@@ -369,8 +369,7 @@ int dfs_file_stat(const char *path, struct stat *buf)
 
     if ((fs = dfs_filesystem_lookup(fullpath)) == NULL)
     {
-        LOG_E(
-                "can't find mounted filesystem on this path:%s", fullpath);
+        LOG_E("can't find mounted filesystem on this path:%s", fullpath);
         rt_free(fullpath);
 
         return -ENOENT;
@@ -399,8 +398,7 @@ int dfs_file_stat(const char *path, struct stat *buf)
         if (fs->ops->stat == NULL)
         {
             rt_free(fullpath);
-            LOG_E(
-                    "the filesystem didn't implement this function");
+            LOG_E("the filesystem didn't implement this function");
 
             return -ENOSYS;
         }
@@ -565,7 +563,7 @@ void ls(const char *pathname)
                     }
                     else
                     {
-                        rt_kprintf("%-25lu\n", stat.st_size);
+                        rt_kprintf("%-25lu\n", (unsigned long)stat.st_size);
                     }
                 }
                 else
diff --git a/components/drivers/spi/spi_flash_sfud.c b/components/drivers/spi/spi_flash_sfud.c
@@ -156,11 +156,11 @@ static sfud_err spi_write_read(const sfud_spi *spi, const uint8_t *write_buf, si
     if(rtt_dev->rt_spi_device->bus->mode & RT_SPI_BUS_MODE_QSPI) {
         qspi_dev = (struct rt_qspi_device *) (rtt_dev->rt_spi_device);
         if (write_size && read_size) {
-            if (rt_qspi_send_then_recv(qspi_dev, write_buf, write_size, read_buf, read_size) == 0) {
+            if (rt_qspi_send_then_recv(qspi_dev, write_buf, write_size, read_buf, read_size) <= 0) {
                 result = SFUD_ERR_TIMEOUT;
             }
         } else if (write_size) {
-            if (rt_qspi_send(qspi_dev, write_buf, write_size) == 0) {
+            if (rt_qspi_send(qspi_dev, write_buf, write_size) <= 0) {
                 result = SFUD_ERR_TIMEOUT;
             }
         }
@@ -173,11 +173,11 @@ static sfud_err spi_write_read(const sfud_spi *spi, const uint8_t *write_buf, si
                 result = SFUD_ERR_TIMEOUT;
             }
         } else if (write_size) {
-            if (rt_spi_send(rtt_dev->rt_spi_device, write_buf, write_size) == 0) {
+            if (rt_spi_send(rtt_dev->rt_spi_device, write_buf, write_size) <= 0) {
                 result = SFUD_ERR_TIMEOUT;
             }
         } else {
-            if (rt_spi_recv(rtt_dev->rt_spi_device, read_buf, read_size) == 0) {
+            if (rt_spi_recv(rtt_dev->rt_spi_device, read_buf, read_size) <= 0) {
                 result = SFUD_ERR_TIMEOUT;
             }
         }
@@ -322,7 +322,7 @@ sfud_err sfud_spi_port_init(sfud_flash *flash) {
 }
 
 #ifdef RT_USING_DEVICE_OPS
-const static struct rt_device_ops flash_device_ops = 
+const static struct rt_device_ops flash_device_ops =
 {
     RT_NULL,
     RT_NULL,
@@ -734,6 +734,7 @@ static void sf(uint8_t argc, char **argv) {
                     for (i = 0; i < size; i += write_size) {
                         result = sfud_write(sfud_dev, addr + i, write_size, write_data);
                         if (result != SFUD_SUCCESS) {
+                            rt_kprintf("Writing %s failed, already wr for %lu bytes, write %d each time\n", sfud_dev->name, i, write_size);
                             break;
                         }
                     }
@@ -761,6 +762,7 @@ static void sf(uint8_t argc, char **argv) {
                         }
 
                         if (result != SFUD_SUCCESS) {
+                            rt_kprintf("Read %s failed, already rd for %lu bytes, read %d each time\n", sfud_dev->name, i, read_size);
                             break;
                         }
                     }
diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c
@@ -19,6 +19,7 @@
 
 static int pipe_fops_open(struct dfs_fd *fd)
 {
+    int rc = 0;
     rt_device_t device;
     rt_pipe_t *pipe;
 
@@ -31,6 +32,11 @@ static int pipe_fops_open(struct dfs_fd *fd)
     if (device->ref_count == 0)
     {
         pipe->fifo = rt_ringbuffer_create(pipe->bufsz);
+        if (pipe->fifo == RT_NULL)
+        {
+            rc = -RT_ENOMEM;
+            goto __exit;
+        }
     }
 
     switch (fd->flags & O_ACCMODE)
@@ -48,9 +54,10 @@ static int pipe_fops_open(struct dfs_fd *fd)
     }
     device->ref_count ++;
 
+__exit:
     rt_mutex_release(&(pipe->lock));
 
-    return 0;
+    return rc;
 }
 
 static int pipe_fops_close(struct dfs_fd *fd)
@@ -90,7 +97,8 @@ static int pipe_fops_close(struct dfs_fd *fd)
 
     if (device->ref_count == 1)
     {
-        rt_ringbuffer_destroy(pipe->fifo);
+        if (pipe->fifo != RT_NULL)
+            rt_ringbuffer_destroy(pipe->fifo);
         pipe->fifo = RT_NULL;
     }
     device->ref_count --;
diff --git a/components/drivers/src/ringblk_buf.c b/components/drivers/src/ringblk_buf.c
@@ -95,9 +95,9 @@ void rt_rbb_destroy(rt_rbb_t rbb)
 {
     RT_ASSERT(rbb);
 
-    rt_free(rbb);
     rt_free(rbb->buf);
     rt_free(rbb->blk_set);
+    rt_free(rbb);
 
 }
 RTM_EXPORT(rt_rbb_destroy);
diff --git a/components/libc/compilers/minilibc/signal.h b/components/libc/compilers/minilibc/signal.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-09-12     Bernard      The first version
+ */
+
+#ifndef SIGNAL_H__
+#define SIGNAL_H__
+
+#include <libc/libc_signal.h>
+
+#define SIG_DFL ((_sig_func_ptr)0)  /* Default action */
+#define SIG_IGN ((_sig_func_ptr)1)  /* Ignore action */
+#define SIG_ERR ((_sig_func_ptr)-1) /* Error return */
+
+#endif
diff --git a/components/utilities/Kconfig b/components/utilities/Kconfig
@@ -2,12 +2,16 @@ menu "Utilities"
 
 config RT_USING_RYM
     bool "Enable Ymodem"
-    depends on RT_USING_DFS = y
     default n
 
     if RT_USING_RYM
-        config YMODEM_DISABLE_CRC_TABLE
-        bool "Disable CRC Table"
+        config YMODEM_USING_CRC_TABLE
+        bool "Enable CRC Table in Ymodem"
+        default n
+
+        config YMODEM_USING_FILE_TRANSFER
+        bool "Enable file transfer feature"
+        select RT_USING_DFS
         default n
     endif
 
diff --git a/components/utilities/ymodem/SConscript b/components/utilities/ymodem/SConscript
@@ -1,8 +1,15 @@
 from building import *
 
 cwd     = GetCurrentDir()
-src     = Glob('*.c')
+src     = Split('''
+ymodem.c
+''')
+ 
 CPPPATH = [cwd]
+
+if GetDepend('RT_USING_DFS') and GetDepend('YMODEM_USING_FILE_TRANSFER'):
+    src += ['ry_sy.c']
+
 group   = DefineGroup('Utilities', src, depend = ['RT_USING_RYM'], CPPPATH = CPPPATH)
 
 Return('group')
diff --git a/components/utilities/ymodem/ry_sy.c b/components/utilities/ymodem/ry_sy.c
@@ -11,8 +11,9 @@
 #include <rtthread.h>
 #include <ymodem.h>
 #include <dfs_posix.h>
+
+#include <stdio.h>
 #include <stdlib.h>
-#include <board.h>
 #include <string.h>
 
 struct custom_ctx
diff --git a/components/utilities/ymodem/ymodem.c b/components/utilities/ymodem/ymodem.c
@@ -13,7 +13,7 @@
 #include <rthw.h>
 #include "ymodem.h"
 
-#ifndef YMODEM_DISABLE_CRC_TABLE
+#ifdef YMODEM_USING_CRC_TABLE 
 static const rt_uint16_t ccitt_table[256] =
 {
     0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
diff --git a/include/libc/libc_signal.h b/include/libc/libc_signal.h
@@ -63,13 +63,14 @@ typedef struct siginfo siginfo_t;
 #define SI_MESGQ    0x05    /* Signal generated by arrival of a 
                                message on an empty message queue. */
 
-#ifdef RT_USING_NEWLIB
-#include <sys/signal.h>
+#if !defined(RT_USING_NEWLIB)
+typedef void (*_sig_func_ptr)(int);
+typedef unsigned long sigset_t;
 #endif
 
-#if defined(__CC_ARM) || defined(__CLANG_ARM)
 #include <signal.h>
-typedef unsigned long sigset_t;
+
+#if defined(__CC_ARM) || defined(__CLANG_ARM)
 
 #define SIGHUP       1
 /* #define SIGINT       2 */
@@ -105,8 +106,6 @@ typedef unsigned long sigset_t;
 #define SIG_BLOCK   1   /* set of signals to block */
 #define SIG_UNBLOCK 2   /* set of signals to, well, unblock */
 
-typedef void (*_sig_func_ptr)(int);
-
 struct sigaction
 {
     _sig_func_ptr sa_handler;
@@ -124,8 +123,6 @@ int sigprocmask (int how, const sigset_t *set, sigset_t *oset);
 int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
 
 #elif defined(__IAR_SYSTEMS_ICC__)
-#include <signal.h>
-typedef unsigned long sigset_t;
 
 #define SIGHUP       1
 #define SIGINT       2
@@ -161,8 +158,6 @@ typedef unsigned long sigset_t;
 #define SIG_BLOCK   1   /* set of signals to block */
 #define SIG_UNBLOCK 2   /* set of signals to, well, unblock */
 
-typedef void (*_sig_func_ptr)(int);
-
 struct sigaction
 {
     _sig_func_ptr sa_handler;
diff --git a/include/rtthread.h b/include/rtthread.h
@@ -137,6 +137,7 @@ rt_err_t rt_thread_delete(rt_thread_t thread);
 
 rt_err_t rt_thread_yield(void);
 rt_err_t rt_thread_delay(rt_tick_t tick);
+rt_err_t rt_thread_delay_until(rt_tick_t *tick, rt_tick_t inc_tick);
 rt_err_t rt_thread_mdelay(rt_int32_t ms);
 rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg);
 rt_err_t rt_thread_suspend(rt_thread_t thread);
diff --git a/src/thread.c b/src/thread.c
@@ -534,6 +534,63 @@ rt_err_t rt_thread_delay(rt_tick_t tick)
 }
 RTM_EXPORT(rt_thread_delay);
 
+/**
+ * This function will let current thread delay until (*tick + inc_tick).
+ *
+ * @param tick the tick of last wakeup.
+ * @param inc_tick the increment tick
+ *
+ * @return RT_EOK
+ */
+rt_err_t rt_thread_delay_until(rt_tick_t *tick, rt_tick_t inc_tick)
+{
+    register rt_base_t level;
+    struct rt_thread *thread;
+
+    RT_ASSERT(tick != RT_NULL);
+
+    /* set to current thread */
+    thread = rt_thread_self();
+    RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
+
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
+
+    if (rt_tick_get() - *tick < inc_tick)
+    {
+        *tick = rt_tick_get() - *tick + inc_tick;
+
+        /* suspend thread */
+        rt_thread_suspend(thread);
+
+        /* reset the timeout of thread timer and start it */
+        rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, tick);
+        rt_timer_start(&(thread->thread_timer));
+
+        /* enable interrupt */
+        rt_hw_interrupt_enable(level);
+
+        rt_schedule();
+
+        /* clear error number of this thread to RT_EOK */
+        if (thread->error == -RT_ETIMEOUT)
+        {
+            thread->error = RT_EOK;
+        }
+    }
+    else
+    {
+        rt_hw_interrupt_enable(level);
+    }
+
+    /* get the wakeup tick */
+    *tick = rt_tick_get();
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_thread_delay_until);
+
 /**
  * This function will let current thread delay for some milliseconds.
  *
diff --git a/tools/pymenuconfig.py b/tools/pymenuconfig.py

Original file line number	Diff line number	Diff line change
`@@ -369,8 +369,7 @@ int dfs_file_stat(const char path, struct stat buf)`
`369`	`369`
`370`	`370`	`if ((fs = dfs_filesystem_lookup(fullpath)) == NULL)`
`371`	`371`	`{`
`372`		`- LOG_E(`
`373`		`- "can't find mounted filesystem on this path:%s", fullpath);`
	`372`	`+ LOG_E("can't find mounted filesystem on this path:%s", fullpath);`
`374`	`373`	`rt_free(fullpath);`
`375`	`374`
`376`	`375`	`return -ENOENT;`
`@@ -399,8 +398,7 @@ int dfs_file_stat(const char path, struct stat buf)`
`399`	`398`	`if (fs->ops->stat == NULL)`
`400`	`399`	`{`
`401`	`400`	`rt_free(fullpath);`
`402`		`- LOG_E(`
`403`		`- "the filesystem didn't implement this function");`
	`401`	`+ LOG_E("the filesystem didn't implement this function");`
`404`	`402`
`405`	`403`	`return -ENOSYS;`
`406`	`404`	`}`
`@@ -565,7 +563,7 @@ void ls(const char *pathname)`
`565`	`563`	`}`
`566`	`564`	`else`
`567`	`565`	`{`
`568`		`- rt_kprintf("%-25lu\n", stat.st_size);`
	`566`	`+ rt_kprintf("%-25lu\n", (unsigned long)stat.st_size);`
`569`	`567`	`}`
`570`	`568`	`}`
`571`	`569`	`else`
Original file line number	Diff line number	Diff line change
`@@ -156,11 +156,11 @@ static sfud_err spi_write_read(const sfud_spi spi, const uint8_t write_buf, si`
`156`	`156`	`if(rtt_dev->rt_spi_device->bus->mode & RT_SPI_BUS_MODE_QSPI) {`
`157`	`157`	`qspi_dev = (struct rt_qspi_device *) (rtt_dev->rt_spi_device);`
`158`	`158`	`if (write_size && read_size) {`
`159`		`- if (rt_qspi_send_then_recv(qspi_dev, write_buf, write_size, read_buf, read_size) == 0) {`
	`159`	`+ if (rt_qspi_send_then_recv(qspi_dev, write_buf, write_size, read_buf, read_size) <= 0) {`
`160`	`160`	`result = SFUD_ERR_TIMEOUT;`
`161`	`161`	`}`
`162`	`162`	`} else if (write_size) {`
`163`		`- if (rt_qspi_send(qspi_dev, write_buf, write_size) == 0) {`
	`163`	`+ if (rt_qspi_send(qspi_dev, write_buf, write_size) <= 0) {`
`164`	`164`	`result = SFUD_ERR_TIMEOUT;`
`165`	`165`	`}`
`166`	`166`	`}`
`@@ -173,11 +173,11 @@ static sfud_err spi_write_read(const sfud_spi spi, const uint8_t write_buf, si`
`173`	`173`	`result = SFUD_ERR_TIMEOUT;`
`174`	`174`	`}`
`175`	`175`	`} else if (write_size) {`
`176`		`- if (rt_spi_send(rtt_dev->rt_spi_device, write_buf, write_size) == 0) {`
	`176`	`+ if (rt_spi_send(rtt_dev->rt_spi_device, write_buf, write_size) <= 0) {`
`177`	`177`	`result = SFUD_ERR_TIMEOUT;`
`178`	`178`	`}`
`179`	`179`	`} else {`
`180`		`- if (rt_spi_recv(rtt_dev->rt_spi_device, read_buf, read_size) == 0) {`
	`180`	`+ if (rt_spi_recv(rtt_dev->rt_spi_device, read_buf, read_size) <= 0) {`
`181`	`181`	`result = SFUD_ERR_TIMEOUT;`
`182`	`182`	`}`
`183`	`183`	`}`
`@@ -322,7 +322,7 @@ sfud_err sfud_spi_port_init(sfud_flash *flash) {`
`322`	`322`	`}`
`323`	`323`
`324`	`324`	`#ifdef RT_USING_DEVICE_OPS`
`325`		`-const static struct rt_device_ops flash_device_ops =`
	`325`	`+const static struct rt_device_ops flash_device_ops =`
`326`	`326`	`{`
`327`	`327`	`RT_NULL,`
`328`	`328`	`RT_NULL,`
`@@ -734,6 +734,7 @@ static void sf(uint8_t argc, char **argv) {`
`734`	`734`	`for (i = 0; i < size; i += write_size) {`
`735`	`735`	`result = sfud_write(sfud_dev, addr + i, write_size, write_data);`
`736`	`736`	`if (result != SFUD_SUCCESS) {`
	`737`	`+ rt_kprintf("Writing %s failed, already wr for %lu bytes, write %d each time\n", sfud_dev->name, i, write_size);`
`737`	`738`	`break;`
`738`	`739`	`}`
`739`	`740`	`}`
`@@ -761,6 +762,7 @@ static void sf(uint8_t argc, char **argv) {`
`761`	`762`	`}`
`762`	`763`
`763`	`764`	`if (result != SFUD_SUCCESS) {`
	`765`	`+ rt_kprintf("Read %s failed, already rd for %lu bytes, read %d each time\n", sfud_dev->name, i, read_size);`
`764`	`766`	`break;`
`765`	`767`	`}`
`766`	`768`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@`
`19`	`19`
`20`	`20`	`static int pipe_fops_open(struct dfs_fd *fd)`
`21`	`21`	`{`
	`22`	`+ int rc = 0;`
`22`	`23`	`rt_device_t device;`
`23`	`24`	`rt_pipe_t *pipe;`
`24`	`25`
`@@ -31,6 +32,11 @@ static int pipe_fops_open(struct dfs_fd *fd)`
`31`	`32`	`if (device->ref_count == 0)`
`32`	`33`	`{`
`33`	`34`	`pipe->fifo = rt_ringbuffer_create(pipe->bufsz);`
	`35`	`+ if (pipe->fifo == RT_NULL)`
	`36`	`+ {`
	`37`	`+ rc = -RT_ENOMEM;`
	`38`	`+ goto __exit;`
	`39`	`+ }`
`34`	`40`	`}`
`35`	`41`
`36`	`42`	`switch (fd->flags & O_ACCMODE)`
`@@ -48,9 +54,10 @@ static int pipe_fops_open(struct dfs_fd *fd)`
`48`	`54`	`}`
`49`	`55`	`device->ref_count ++;`
`50`	`56`
	`57`	`+__exit:`
`51`	`58`	`rt_mutex_release(&(pipe->lock));`
`52`	`59`
`53`		`- return 0;`
	`60`	`+ return rc;`
`54`	`61`	`}`
`55`	`62`
`56`	`63`	`static int pipe_fops_close(struct dfs_fd *fd)`
`@@ -90,7 +97,8 @@ static int pipe_fops_close(struct dfs_fd *fd)`
`90`	`97`
`91`	`98`	`if (device->ref_count == 1)`
`92`	`99`	`{`
`93`		`- rt_ringbuffer_destroy(pipe->fifo);`
	`100`	`+ if (pipe->fifo != RT_NULL)`
	`101`	`+ rt_ringbuffer_destroy(pipe->fifo);`
`94`	`102`	`pipe->fifo = RT_NULL;`
`95`	`103`	`}`
`96`	`104`	`device->ref_count --;`
Original file line number	Diff line number	Diff line change
`@@ -95,9 +95,9 @@ void rt_rbb_destroy(rt_rbb_t rbb)`
`95`	`95`	`{`
`96`	`96`	`RT_ASSERT(rbb);`
`97`	`97`
`98`		`- rt_free(rbb);`
`99`	`98`	`rt_free(rbb->buf);`
`100`	`99`	`rt_free(rbb->blk_set);`
	`100`	`+ rt_free(rbb);`
`101`	`101`
`102`	`102`	`}`
`103`	`103`	`RTM_EXPORT(rt_rbb_destroy);`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`	`#include <rthw.h>`
`14`	`14`	`#include "ymodem.h"`
`15`	`15`
`16`		`-#ifndef YMODEM_DISABLE_CRC_TABLE`
	`16`	`+#ifdef YMODEM_USING_CRC_TABLE`
`17`	`17`	`static const rt_uint16_t ccitt_table[256] =`
`18`	`18`	`{`
`19`	`19`	`0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,`