Merge branch 'master' of https://github.com/RT-Thread/rt-thread into nuvoton

# Conflicts:
#	bsp/nuvoton/nk-980iot/.config
#	bsp/nuvoton/nk-n9h30/.config
#	bsp/nuvoton/nk-rtu980/.config
#	bsp/nuvoton/numaker-iot-m487/.config
#	bsp/nuvoton/numaker-m2354/.config
#	bsp/nuvoton/numaker-pfm-m487/.config

11 files changed, 45 insertions, 45 deletions

diff --git a/components/drivers/audio/audio.c b/components/drivers/audio/audio.c
index f9d42aeb5c..edef7d0eeb 100644
--- a/components/drivers/audio/audio.c
+++ b/components/drivers/audio/audio.c
@@ -52,14 +52,14 @@ static rt_err_t _audio_send_replay_frame(struct rt_audio_device *audio)
             rt_completion_done(&audio->replay->cmp);
 
         /* send zero frames */
-        memset(&buf_info->buffer[audio->replay->pos], 0, dst_size);
+        rt_memset(&buf_info->buffer[audio->replay->pos], 0, dst_size);
 
         audio->replay->pos += dst_size;
         audio->replay->pos %= buf_info->total_size;
     }
     else
     {
-        memset(&buf_info->buffer[audio->replay->pos], 0, dst_size);
+        rt_memset(&buf_info->buffer[audio->replay->pos], 0, dst_size);
 
         /* copy data from memory pool to hardware device fifo */
         while (index < dst_size)
@@ -77,7 +77,7 @@ static rt_err_t _audio_send_replay_frame(struct rt_audio_device *audio)
             }
 
             remain_bytes = MIN((dst_size - index), (src_size - audio->replay->read_index));
-            memcpy(&buf_info->buffer[audio->replay->pos],
+            rt_memcpy(&buf_info->buffer[audio->replay->pos],
                    &data[audio->replay->read_index], remain_bytes);
 
             index += remain_bytes;
@@ -229,7 +229,7 @@ static rt_err_t _audio_dev_init(struct rt_device *dev)
 
         if (replay == RT_NULL)
             return -RT_ENOMEM;
-        memset(replay, 0, sizeof(struct rt_audio_replay));
+        rt_memset(replay, 0, sizeof(struct rt_audio_replay));
 
         /* init memory pool for replay */
         replay->mp = rt_mp_create("adu_mp", RT_AUDIO_REPLAY_MP_BLOCK_COUNT, RT_AUDIO_REPLAY_MP_BLOCK_SIZE);
@@ -258,7 +258,7 @@ static rt_err_t _audio_dev_init(struct rt_device *dev)
 
         if (record == RT_NULL)
             return -RT_ENOMEM;
-        memset(record, 0, sizeof(struct rt_audio_record));
+        rt_memset(record, 0, sizeof(struct rt_audio_record));
 
         /* init pipe for record*/
         buffer = rt_malloc(RT_AUDIO_RECORD_PIPE_SIZE);
@@ -393,12 +393,12 @@ static rt_size_t _audio_dev_write(struct rt_device *dev, rt_off_t pos, const voi
         if (audio->replay->write_index % block_size == 0)
         {
             audio->replay->write_data = rt_mp_alloc(audio->replay->mp, RT_WAITING_FOREVER);
-            memset(audio->replay->write_data, 0, block_size);
+            rt_memset(audio->replay->write_data, 0, block_size);
         }
 
         /* copy data to replay memory pool */
         remain_bytes = MIN((block_size - audio->replay->write_index), (size - index));
-        memcpy(&audio->replay->write_data[audio->replay->write_index], &ptr[index], remain_bytes);
+        rt_memcpy(&audio->replay->write_data[audio->replay->write_index], &ptr[index], remain_bytes);
 
         index += remain_bytes;
         audio->replay->write_index += remain_bytes;
diff --git a/components/drivers/misc/rt_drv_pwm.c b/components/drivers/misc/rt_drv_pwm.c
index 42325587ab..c60bf6df1d 100644
--- a/components/drivers/misc/rt_drv_pwm.c
+++ b/components/drivers/misc/rt_drv_pwm.c
@@ -105,7 +105,7 @@ rt_err_t rt_device_pwm_register(struct rt_device_pwm *device, const char *name,
 {
     rt_err_t result = RT_EOK;
 
-    memset(device, 0, sizeof(struct rt_device_pwm));
+    rt_memset(device, 0, sizeof(struct rt_device_pwm));
 
 #ifdef RT_USING_DEVICE_OPS
     device->parent.ops = &pwm_device_ops;
diff --git a/components/drivers/rtc/soft_rtc.c b/components/drivers/rtc/soft_rtc.c
index 255579f35e..02b5cbec53 100644
--- a/components/drivers/rtc/soft_rtc.c
+++ b/components/drivers/rtc/soft_rtc.c
@@ -61,7 +61,7 @@ static rt_err_t soft_rtc_control(rt_device_t dev, int cmd, void *args)
     struct tm time_temp;
 
     RT_ASSERT(dev != RT_NULL);
-    memset(&time_temp, 0, sizeof(struct tm));
+    rt_memset(&time_temp, 0, sizeof(struct tm));
 
     switch (cmd)
     {
diff --git a/components/drivers/serial/serial.c b/components/drivers/serial/serial.c
index 6f7e7d5b2b..da330b5e9c 100644
--- a/components/drivers/serial/serial.c
+++ b/components/drivers/serial/serial.c
@@ -36,7 +36,7 @@
 #define DBG_LVL    DBG_INFO
 #include <rtdbg.h>
 
-#ifdef RT_USING_POSIX_DEVIO
+#ifdef RT_USING_POSIX_STDIO
 #include <dfs_posix.h>
 #include <poll.h>
 #include <sys/ioctl.h>
@@ -203,7 +203,7 @@ const static struct dfs_file_ops _serial_fops =
     RT_NULL, /* getdents */
     serial_fops_poll,
 };
-#endif /* RT_USING_POSIX_DEVIO */
+#endif /* RT_USING_POSIX_STDIO */
 
 /*
  * Serial poll routines
@@ -362,7 +362,7 @@ static void _serial_check_buffer_size(void)
     }
 }
 
-#if defined(RT_USING_POSIX_DEVIO) || defined(RT_SERIAL_USING_DMA)
+#if defined(RT_USING_POSIX_STDIO) || defined(RT_SERIAL_USING_DMA)
 static rt_size_t _serial_fifo_calc_recved_len(struct rt_serial_device *serial)
 {
     struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *) serial->serial_rx;
@@ -385,7 +385,7 @@ static rt_size_t _serial_fifo_calc_recved_len(struct rt_serial_device *serial)
         }
     }
 }
-#endif /* RT_USING_POSIX_DEVIO || RT_SERIAL_USING_DMA */
+#endif /* RT_USING_POSIX_STDIO || RT_SERIAL_USING_DMA */
 
 #ifdef RT_SERIAL_USING_DMA
 /**
@@ -1019,7 +1019,7 @@ static rt_err_t rt_serial_control(struct rt_device *dev,
             }
 
             break;
-#ifdef RT_USING_POSIX_DEVIO
+#ifdef RT_USING_POSIX_STDIO
 #ifdef RT_USING_POSIX_TERMIOS
         case TCGETA:
             {
@@ -1215,7 +1215,7 @@ static rt_err_t rt_serial_control(struct rt_device *dev,
                 *(rt_size_t *)args = recved;
             }
             break;
-#endif /* RT_USING_POSIX_DEVIO */
+#endif /* RT_USING_POSIX_STDIO */
         default :
             /* control device */
             ret = serial->ops->control(serial, cmd, args);
@@ -1270,7 +1270,7 @@ rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
     /* register a character device */
     ret = rt_device_register(device, name, flag);
 
-#ifdef RT_USING_POSIX_DEVIO
+#ifdef RT_USING_POSIX_STDIO
     /* set fops */
     device->fops        = &_serial_fops;
 #endif
diff --git a/components/drivers/serial/serial_v2.c b/components/drivers/serial/serial_v2.c
index c58bbeef1a..16d376eeb9 100644
--- a/components/drivers/serial/serial_v2.c
+++ b/components/drivers/serial/serial_v2.c
@@ -16,7 +16,7 @@
 #define DBG_LVL    DBG_INFO
 #include <rtdbg.h>
 
-#ifdef RT_USING_POSIX_DEVIO
+#ifdef RT_USING_POSIX_STDIO
 #include <dfs_posix.h>
 #include <poll.h>
 #include <sys/ioctl.h>
@@ -179,7 +179,7 @@ const static struct dfs_file_ops _serial_fops =
     RT_NULL, /* getdents */
     serial_fops_poll,
 };
-#endif /* RT_USING_POSIX_DEVIO */
+#endif /* RT_USING_POSIX_STDIO */
 
 static rt_size_t rt_serial_get_linear_buffer(struct rt_ringbuffer       *rb,
                                                     rt_uint8_t         **ptr)
@@ -1135,7 +1135,7 @@ rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
     /* register a character device */
     ret = rt_device_register(device, name, flag);
 
-#ifdef RT_USING_POSIX_DEVIO
+#ifdef RT_USING_POSIX_STDIO
     /* set fops */
     device->fops        = &_serial_fops;
 #endif
diff --git a/components/drivers/spi/enc28j60.c b/components/drivers/spi/enc28j60.c
index f8e5582e10..0a63010a5c 100644
--- a/components/drivers/spi/enc28j60.c
+++ b/components/drivers/spi/enc28j60.c
@@ -778,7 +778,7 @@ rt_err_t enc28j60_attach(const char *spi_device_name)
         rt_spi_configure(spi_device, &cfg);
     } /* config spi */
 
-    memset(&enc28j60_dev, 0, sizeof(enc28j60_dev));
+    rt_memset(&enc28j60_dev, 0, sizeof(enc28j60_dev));
 
     rt_event_init(&tx_event, "eth_tx", RT_IPC_FLAG_FIFO);
     enc28j60_dev.spi_device = spi_device;
diff --git a/components/drivers/spi/sfud/src/sfud.c b/components/drivers/spi/sfud/src/sfud.c
index 4078179262..d28f36d620 100644
--- a/components/drivers/spi/sfud/src/sfud.c
+++ b/components/drivers/spi/sfud/src/sfud.c
@@ -650,7 +650,7 @@ static sfud_err page256_or_1_byte_write(const sfud_flash *flash, uint32_t addr,
         size -= data_size;
         addr += data_size;
 
-        memcpy(&cmd_data[cmd_size], data, data_size);
+        rt_memcpy(&cmd_data[cmd_size], data, data_size);
 
         result = spi->wr(spi, cmd_data, cmd_size + data_size, NULL, 0);
         if (result != SFUD_SUCCESS) {
diff --git a/components/drivers/spi/spi_msd.c b/components/drivers/spi/spi_msd.c
index 875ae3c486..6bd0501694 100644
--- a/components/drivers/spi/spi_msd.c
+++ b/components/drivers/spi/spi_msd.c
@@ -500,7 +500,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
             uint8_t send_buffer[100]; /* 100byte > 74 clock */
 
             /* initial message */
-            memset(send_buffer, DUMMY, sizeof(send_buffer));
+            rt_memset(send_buffer, DUMMY, sizeof(send_buffer));
             message.send_buf = send_buffer;
             message.recv_buf = RT_NULL;
             message.length = sizeof(send_buffer);
@@ -697,7 +697,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                     uint8_t send_buffer[100];
 
                     /* initial message */
-                    memset(send_buffer, DUMMY, sizeof(send_buffer));
+                    rt_memset(send_buffer, DUMMY, sizeof(send_buffer));
                     message.send_buf = send_buffer;
                     message.recv_buf = RT_NULL;
                     message.length = sizeof(send_buffer);
diff --git a/components/drivers/spi/spi_wifi_rw009.c b/components/drivers/spi/spi_wifi_rw009.c
index 84da212077..20dd6d7f93 100644
--- a/components/drivers/spi/spi_wifi_rw009.c
+++ b/components/drivers/spi/spi_wifi_rw009.c
@@ -94,7 +94,7 @@ static void resp_handler(struct rw009_wifi *wifi_device, struct rw009_resp *resp
         WIFI_DEBUG("resp_handler RW009_CMD_INIT\n");
         resp_return = (struct rw009_resp *)rt_malloc(member_offset(struct rw009_resp, resp) + sizeof(rw009_resp_init)); //TODO:
         if(resp_return == RT_NULL) break;
-        memcpy(resp_return, resp, member_offset(struct rw009_resp, resp) + sizeof(rw009_resp_init));
+        rt_memcpy(resp_return, resp, member_offset(struct rw009_resp, resp) + sizeof(rw009_resp_init));
 
         WIFI_DEBUG("sn:%-*.*s\n", sizeof(resp->resp.init.sn), sizeof(resp->resp.init.sn), resp->resp.init.sn);
         WIFI_DEBUG("version:%-*.*s\n", sizeof(resp->resp.init.version), sizeof(resp->resp.init.version), resp->resp.init.version);
@@ -108,7 +108,7 @@ static void resp_handler(struct rw009_wifi *wifi_device, struct rw009_resp *resp
             rw009_ap_info *ap_scan = rt_realloc(wifi_device->ap_scan, sizeof(rw009_ap_info) * (wifi_device->ap_scan_count + 1) );
             if(ap_scan != RT_NULL)
             {
-                memcpy( &ap_scan[wifi_device->ap_scan_count], &resp->resp.ap_info, sizeof(rw009_ap_info) );
+                rt_memcpy( &ap_scan[wifi_device->ap_scan_count], &resp->resp.ap_info, sizeof(rw009_ap_info) );
 
                 //dump
                 if(1)
@@ -142,11 +142,11 @@ static void resp_handler(struct rw009_wifi *wifi_device, struct rw009_resp *resp
         WIFI_DEBUG("resp_handler RW009_CMD_EASY_JOIN\n");
         resp_return = (struct rw009_resp *)rt_malloc(member_offset(struct rw009_resp, resp) + sizeof(rw009_resp_join)); //TODO:
         if(resp_return == RT_NULL) break;
-        memcpy(resp_return, resp, member_offset(struct rw009_resp, resp) + sizeof(rw009_resp_join));
+        rt_memcpy(resp_return, resp, member_offset(struct rw009_resp, resp) + sizeof(rw009_resp_join));
 
         if( resp->result == 0 )
         {
-            memcpy(&wifi_device->ap_info, &resp_return->resp.ap_info, sizeof(rw009_resp_join));
+            rt_memcpy(&wifi_device->ap_info, &resp_return->resp.ap_info, sizeof(rw009_resp_join));
             wifi_device->active = 1;
             eth_device_linkchange(&wifi_device->parent, RT_TRUE);
         }
@@ -284,7 +284,7 @@ static rt_err_t rw009_cmd(struct rw009_wifi *wifi_device, uint32_t cmd, void *ar
     }
 
     if(wifi_cmd->len)
-        memcpy(&wifi_cmd->params, args, wifi_cmd->len);
+        rt_memcpy(&wifi_cmd->params, args, wifi_cmd->len);
 
     data_packet->data_type = data_type_cmd;
     data_packet->data_len = member_offset(struct rw009_cmd, params) + wifi_cmd->len;
@@ -326,7 +326,7 @@ static rt_err_t spi_wifi_transfer(struct rw009_wifi *dev)
     while (spi_wifi_is_busy());
     SPI_DEBUG("sequence start!\n");
 
-    memset(&cmd, 0, sizeof(struct spi_cmd_request));
+    rt_memset(&cmd, 0, sizeof(struct spi_cmd_request));
     cmd.magic1 = CMD_MAGIC1;
     cmd.magic2 = CMD_MAGIC2;
 
@@ -523,7 +523,7 @@ static rt_err_t rw009_wifi_control(rt_device_t dev, int cmd, void *args)
 
     if (cmd == NIOCTL_GADDR)
     {
-        memcpy(args, wifi_device->dev_addr, 6);
+        rt_memcpy(args, wifi_device->dev_addr, 6);
     }
     else
     {
@@ -633,7 +633,7 @@ rt_err_t rt_hw_wifi_init(const char *spi_device_name, wifi_mode_t mode)
     RT_ASSERT( (SPI_MAX_DATA_LEN & 0x03) == 0);
     RT_ASSERT( sizeof(struct rw009_resp) <= SPI_MAX_DATA_LEN);
 
-    memset(&rw009_wifi_device, 0, sizeof(struct rw009_wifi));
+    rt_memset(&rw009_wifi_device, 0, sizeof(struct rw009_wifi));
 
     rw009_wifi_device.rt_spi_device = (struct rt_spi_device *)rt_device_find(spi_device_name);
 
diff --git a/components/drivers/src/ringbuffer.c b/components/drivers/src/ringbuffer.c
index e33f533db0..deb8979930 100644
--- a/components/drivers/src/ringbuffer.c
+++ b/components/drivers/src/ringbuffer.c
@@ -83,17 +83,17 @@ rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
     if (rb->buffer_size - rb->write_index > length)
     {
         /* read_index - write_index = empty space */
-        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
+        rt_memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
         /* this should not cause overflow because there is enough space for
          * length of data in current mirror */
         rb->write_index += length;
         return length;
     }
 
-    memcpy(&rb->buffer_ptr[rb->write_index],
+    rt_memcpy(&rb->buffer_ptr[rb->write_index],
            &ptr[0],
            rb->buffer_size - rb->write_index);
-    memcpy(&rb->buffer_ptr[0],
+    rt_memcpy(&rb->buffer_ptr[0],
            &ptr[rb->buffer_size - rb->write_index],
            length - (rb->buffer_size - rb->write_index));
 
@@ -133,7 +133,7 @@ rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb,
     if (rb->buffer_size - rb->write_index > length)
     {
         /* read_index - write_index = empty space */
-        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
+        rt_memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
         /* this should not cause overflow because there is enough space for
          * length of data in current mirror */
         rb->write_index += length;
@@ -144,10 +144,10 @@ rt_size_t rt_ringbuffer_put_force(struct rt_ringbuffer *rb,
         return length;
     }
 
-    memcpy(&rb->buffer_ptr[rb->write_index],
+    rt_memcpy(&rb->buffer_ptr[rb->write_index],
            &ptr[0],
            rb->buffer_size - rb->write_index);
-    memcpy(&rb->buffer_ptr[0],
+    rt_memcpy(&rb->buffer_ptr[0],
            &ptr[rb->buffer_size - rb->write_index],
            length - (rb->buffer_size - rb->write_index));
 
@@ -197,17 +197,17 @@ rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb,
     if (rb->buffer_size - rb->read_index > length)
     {
         /* copy all of data */
-        memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
+        rt_memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
         /* this should not cause overflow because there is enough space for
          * length of data in current mirror */
         rb->read_index += length;
         return length;
     }
 
-    memcpy(&ptr[0],
+    rt_memcpy(&ptr[0],
            &rb->buffer_ptr[rb->read_index],
            rb->buffer_size - rb->read_index);
-    memcpy(&ptr[rb->buffer_size - rb->read_index],
+    rt_memcpy(&ptr[rb->buffer_size - rb->read_index],
            &rb->buffer_ptr[0],
            length - (rb->buffer_size - rb->read_index));
 
diff --git a/components/drivers/usb/usbdevice/class/rndis.c b/components/drivers/usb/usbdevice/class/rndis.c
index ee25ec1ddf..69ca3f5d69 100644
--- a/components/drivers/usb/usbdevice/class/rndis.c
+++ b/components/drivers/usb/usbdevice/class/rndis.c
@@ -376,7 +376,7 @@ static rndis_query_cmplt_t _create_resp(rt_size_t size)
 static void _copy_resp(rndis_query_cmplt_t resp, const void * buffer)
 {
     char * resp_buffer = (char *)resp + sizeof(struct rndis_query_cmplt);
-    memcpy(resp_buffer, buffer, resp->InformationBufferLength);
+    rt_memcpy(resp_buffer, buffer, resp->InformationBufferLength);
 }
 
 static void _set_resp(rndis_query_cmplt_t resp, rt_uint32_t value)
@@ -897,13 +897,13 @@ static rt_err_t _ep_out_handler(ufunction_t func, rt_size_t size)
             data += sizeof(struct rndis_packet_msg);
             size -= sizeof(struct rndis_packet_msg);
             ((rt_rndis_eth_t)func->user_data)->rx_frist = RT_FALSE;
-            memcpy(&((rt_rndis_eth_t)func->user_data)->rx_buffer[((rt_rndis_eth_t)func->user_data)->rx_offset], data, size);
+            rt_memcpy(&((rt_rndis_eth_t)func->user_data)->rx_buffer[((rt_rndis_eth_t)func->user_data)->rx_offset], data, size);
             ((rt_rndis_eth_t)func->user_data)->rx_offset += size;
         }
     }
     else
     {
-        memcpy(&((rt_rndis_eth_t)func->user_data)->rx_buffer[((rt_rndis_eth_t)func->user_data)->rx_offset], data, size);
+        rt_memcpy(&((rt_rndis_eth_t)func->user_data)->rx_buffer[((rt_rndis_eth_t)func->user_data)->rx_offset], data, size);
         ((rt_rndis_eth_t)func->user_data)->rx_offset += size;
     }
 
@@ -1137,7 +1137,7 @@ struct pbuf *rt_rndis_eth_rx(rt_device_t dev)
             for (q = p; q != RT_NULL; q= q->next)
             {
                 /* Copy the received frame into buffer from memory pointed by the current ETHERNET DMA Rx descriptor */
-                memcpy(q->payload,
+                rt_memcpy(q->payload,
                        (rt_uint8_t *)((device->rx_buffer) + offset),
                        q->len);
                 offset += q->len;
@@ -1191,7 +1191,7 @@ rt_err_t rt_rndis_eth_tx(rt_device_t dev, struct pbuf* p)
     buffer = (char *)&device->tx_buffer + sizeof(struct rndis_packet_msg);
     for (q = p; q != NULL; q = q->next)
     {
-        memcpy(buffer, q->payload, q->len);
+        rt_memcpy(buffer, q->payload, q->len);
         buffer += q->len;
     }