Sync from master (75a3f3dd3a930eab1dc58fa0258a9d1605a0ac11)

13 files changed, 284 insertions, 389 deletions

diff --git a/components/drivers/include/drivers/audio.h b/components/drivers/include/drivers/audio.h
index 7d2cb36728..86057e7626 100644
--- a/components/drivers/include/drivers/audio.h
+++ b/components/drivers/include/drivers/audio.h
@@ -5,52 +5,30 @@
  *
  * Change Logs:
  * Date           Author       Notes
- * 2017-05-09     Urey      first version
+ * 2017-05-09     Urey         first version
+ * 2019-07-09     Zero-Free    improve device ops interface and data flows
+ *
  */
 
 #ifndef __AUDIO_H__
 #define __AUDIO_H__
 
+#include "audio_pipe.h"
+
 /* AUDIO command */
 #define _AUDIO_CTL(a) (0x10 + a)
 
 #define AUDIO_CTL_GETCAPS                   _AUDIO_CTL(1)
 #define AUDIO_CTL_CONFIGURE                 _AUDIO_CTL(2)
-#define AUDIO_CTL_SHUTDOWN                  _AUDIO_CTL(3)
-#define AUDIO_CTL_START                     _AUDIO_CTL(4)
-#define AUDIO_CTL_STOP                      _AUDIO_CTL(5)
-#define AUDIO_CTL_PAUSE                     _AUDIO_CTL(6)
-#define AUDIO_CTL_RESUME                    _AUDIO_CTL(7)
-#define AUDIO_CTL_GETBUFFERINFO             _AUDIO_CTL(8)
-#define AUDIO_CTL_ALLOCBUFFER               _AUDIO_CTL(9)
-#define AUDIO_CTL_FREEBUFFER                _AUDIO_CTL(10)
-#define AUDIO_CTL_HWRESET                   _AUDIO_CTL(11)
-
+#define AUDIO_CTL_START                     _AUDIO_CTL(3)
+#define AUDIO_CTL_STOP                      _AUDIO_CTL(4)
+#define AUDIO_CTL_GETBUFFERINFO             _AUDIO_CTL(5)
 
 /* Audio Device Types */
 #define AUDIO_TYPE_QUERY                    0x00
 #define AUDIO_TYPE_INPUT                    0x01
 #define AUDIO_TYPE_OUTPUT                   0x02
 #define AUDIO_TYPE_MIXER                    0x04
-#define AUDIO_TYPE_SELECTOR                 0x08
-#define AUDIO_TYPE_EFFECT                   0x10
-
-/* Audio Format Types */
-#define AUDIO_FMT_PCM_U8                    0x0001
-#define AUDIO_FMT_PCM_S8                    0x0002
-
-#define AUDIO_FMT_PCM_U16_LE                0x0010
-#define AUDIO_FMT_PCM_S16_BE                0x0020
-#define AUDIO_FMT_PCM_S16_LE                0x0040
-#define AUDIO_FMT_PCM_U16_BE                0x0080
-#define AUDIO_FMT_PCM_U24_LE                0x0100
-#define AUDIO_FMT_PCM_S24_BE                0x0200
-#define AUDIO_FMT_PCM_S24_LE                0x0400
-#define AUDIO_FMT_PCM_U24_BE                0x0800
-#define AUDIO_FMT_PCM_U32_LE                0x1000
-#define AUDIO_FMT_PCM_S32_BE                0x2000
-#define AUDIO_FMT_PCM_S32_LE                0x4000
-#define AUDIO_FMT_PCM_U32_BE                0x8000
 
 /* Supported Sampling Rates */
 #define AUDIO_SAMP_RATE_8K                  0x0001
@@ -76,13 +54,11 @@
 #define AUDIO_BIT_RATE_172K                 0x40
 #define AUDIO_BIT_RATE_192K                 0x80
 
-
-
 /* Support Dsp(input/output) Units controls */
 #define AUDIO_DSP_PARAM                     0           /* get/set all params */
-#define AUDIO_DSP_SAMPLERATE                1                       /*  采样频率                    */
-#define AUDIO_DSP_FMT                       2
-#define AUDIO_DSP_CHANNELS                  3
+#define AUDIO_DSP_SAMPLERATE                1           /* samplerate */
+#define AUDIO_DSP_CHANNELS                  2           /* channels */
+#define AUDIO_DSP_SAMPLEBITS                3           /* sample bits width */
 
 /* Supported Mixer Units controls */
 #define AUDIO_MIXER_QUERY                   0x0000
@@ -95,15 +71,13 @@
 #define AUDIO_MIXER_LINE                    0x0040
 #define AUDIO_MIXER_DIGITAL                 0x0080
 #define AUDIO_MIXER_MIC                     0x0100
+#define AUDIO_MIXER_VITURAL                 0x0200
+#define AUDIO_MIXER_EXTEND                  0x8000    /* extend mixer command */
 
-#define AUDIO_MIXER_EXTEND                  0x8000    //extend mixer command
+#define AUDIO_VOLUME_MAX                    (100)
+#define AUDIO_VOLUME_MIN                    (0)
 
 #define CFG_AUDIO_REPLAY_QUEUE_COUNT        4
-#define CFG_AUDIO_RECORD_PIPE_SIZE          (8 * 1024)
-#define AUDIO_DEVICE_MP_CNT                 (4)
-#define AUDIO_DEVICE_DECODE_MP_BLOCK_SZ     (4352 * 4)
-#define AUDIO_DEVICE_DECODE_MP_SZ           ((AUDIO_DEVICE_DECODE_MP_BLOCK_SZ*2 + 4)*AUDIO_DEVICE_MP_CNT)
-
 
 enum
 {
@@ -115,19 +89,10 @@ enum
 /* the preferred number and size of audio pipeline buffer for the audio device */
 struct rt_audio_buf_info
 {
-  rt_uint32_t buffer_size;          /* Preferred qty of buffers */
-  rt_uint32_t buffer_count;           /* Preferred size of the buffers */
-};
-struct rt_audio_buf_desc
-{
-  rt_uint8_t *data_ptr;
-  rt_size_t data_size;
-};
-
-struct rt_audio_frame
-{
-    const void *data_ptr;
-    rt_size_t   data_size;
+    rt_uint8_t *buffer;
+    rt_uint16_t block_size;
+    rt_uint16_t block_count;
+    rt_uint32_t total_size;
 };
 
 struct rt_audio_device;
@@ -135,73 +100,68 @@ struct rt_audio_caps;
 struct rt_audio_configure;
 struct rt_audio_ops
 {
-    rt_err_t  (*getcaps)        (struct rt_audio_device *audio,struct rt_audio_caps *caps);
-    rt_err_t  (*configure)      (struct rt_audio_device *audio,struct rt_audio_caps *caps);
-
-    rt_err_t    (*init)         (struct rt_audio_device *audio);
-    rt_err_t    (*shutdown)     (struct rt_audio_device *audio);
-    rt_err_t    (*start)        (struct rt_audio_device *audio,int stream);
-    rt_err_t    (*stop)         (struct rt_audio_device *audio,int stream);
-    rt_err_t    (*suspend)      (struct rt_audio_device *audio,int stream);
-    rt_err_t    (*resume)       (struct rt_audio_device *audio,int stream);
-
-    rt_err_t    (*control)      (struct rt_audio_device *audio, int cmd, void *arg);
-    rt_size_t   (*transmit)     (struct rt_audio_device *audio, const void *writeBuf,void *readBuf, rt_size_t size);
-
-    //get page size of codec or private buffer's info
-    void    (*buffer_info)      (struct rt_audio_device *audio,struct rt_audio_buf_info *info );
+    rt_err_t (*getcaps)(struct rt_audio_device *audio, struct rt_audio_caps *caps);
+    rt_err_t (*configure)(struct rt_audio_device *audio, struct rt_audio_caps *caps);
+    rt_err_t (*init)(struct rt_audio_device *audio);
+    rt_err_t (*start)(struct rt_audio_device *audio, int stream);
+    rt_err_t (*stop)(struct rt_audio_device *audio, int stream);
+    rt_size_t (*transmit)(struct rt_audio_device *audio, const void *writeBuf, void *readBuf, rt_size_t size);
+    /* get page size of codec or private buffer's info */
+    void (*buffer_info)(struct rt_audio_device *audio, struct rt_audio_buf_info *info);
 };
 
-
 struct rt_audio_configure
 {
-    rt_uint32_t channels;
-
-    rt_uint32_t samplefmt;
     rt_uint32_t samplerate;
-    rt_uint32_t samplefmts;
+    rt_uint16_t channels;
+    rt_uint16_t samplebits;
 };
 
 struct rt_audio_caps
 {
-  int main_type;
-  int sub_type;
+    int main_type;
+    int sub_type;
 
-  union
-  {
-    rt_uint32_t mask;
-    int     value;
-    struct rt_audio_configure config;
-  }udata;
+    union
+    {
+        rt_uint32_t mask;
+        int     value;
+        struct rt_audio_configure config;
+    } udata;
 };
 
 struct rt_audio_replay
 {
-    rt_bool_t activated;
+    struct rt_mempool *mp;
     struct rt_data_queue queue;
+    struct rt_mutex lock;
+    struct rt_completion cmp;
+    struct rt_audio_buf_info buf_info;
+    rt_uint8_t *write_data;
+    rt_uint16_t write_index;
+    rt_uint16_t read_index;
+    rt_uint32_t pos;
+    rt_uint8_t event;
+    rt_bool_t activated;
 };
 
 struct rt_audio_record
 {
+    struct rt_audio_pipe pipe;
     rt_bool_t activated;
 };
 
 struct rt_audio_device
 {
-    struct rt_device            parent;
+    struct rt_device           parent;
     struct rt_audio_ops        *ops;
-
-    struct rt_mempool           mp;
-
     struct rt_audio_replay     *replay;
     struct rt_audio_record     *record;
 };
 
-rt_err_t    rt_audio_register       (struct rt_audio_device *audio, const char *name, rt_uint32_t flag, void *data);
-void        rt_audio_tx_complete    (struct rt_audio_device *audio,rt_uint8_t *pbuf);
-void        rt_audio_rx_done        (struct rt_audio_device *audio,rt_uint8_t *pbuf,rt_size_t len);
-rt_uint32_t rt_audio_format_to_bits (rt_uint32_t format);
-
+rt_err_t    rt_audio_register(struct rt_audio_device *audio, const char *name, rt_uint32_t flag, void *data);
+void        rt_audio_tx_complete(struct rt_audio_device *audio);
+void        rt_audio_rx_done(struct rt_audio_device *audio, rt_uint8_t *pbuf, rt_size_t len);
 
 /* Device Control Commands */
 #define CODEC_CMD_RESET             0
diff --git a/components/drivers/include/drivers/can.h b/components/drivers/include/drivers/can.h
index c61fb19eaa..d4fcc845b4 100644
--- a/components/drivers/include/drivers/can.h
+++ b/components/drivers/include/drivers/can.h
@@ -221,7 +221,7 @@ struct rt_can_msg
     rt_uint32_t rsv : 1;
     rt_uint32_t len : 8;
     rt_uint32_t priv : 8;
-    rt_uint32_t hdr : 8;
+    rt_int32_t hdr : 8;
     rt_uint32_t reserved : 8;
     rt_uint8_t data[8];
 };
@@ -252,7 +252,7 @@ struct rt_can_rx_fifo
 
 #define RT_CAN_EVENT_RX_IND         0x01    /* Rx indication */
 #define RT_CAN_EVENT_TX_DONE        0x02    /* Tx complete   */
-#define RT_CAN_EVENT_TX_FAIL        0x03    /* Tx complete   */
+#define RT_CAN_EVENT_TX_FAIL        0x03    /* Tx fail   */
 #define RT_CAN_EVENT_RX_TIMEOUT     0x05    /* Rx timeout    */
 #define RT_CAN_EVENT_RXOF_IND       0x06    /* Rx overflow */
 
@@ -278,7 +278,7 @@ struct rt_can_ops
     int (*recvmsg)(struct rt_can_device *can, void *buf, rt_uint32_t boxno);
 };
 
-rt_err_t rt_hw_can_register(struct rt_can_device *can,
+rt_err_t rt_hw_can_register(struct rt_can_device    *can,
                             const char              *name,
                             const struct rt_can_ops *ops,
                             void                    *data);
diff --git a/components/drivers/include/drivers/crypto.h b/components/drivers/include/drivers/crypto.h
new file mode 100644
index 0000000000..5341d9ee48
--- /dev/null
+++ b/components/drivers/include/drivers/crypto.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-05-17     tyx          the first version
+ */
+
+#ifndef __CRYPTO_H__
+#define __CRYPTO_H__
+
+#include <rtthread.h>
+#include <hwcrypto.h>
+#include <hw_symmetric.h>
+#include <hw_rng.h>
+#include <hw_hash.h>
+#include <hw_crc.h>
+#include <hw_gcm.h>
+#include <hw_bignum.h>
+
+#endif
diff --git a/components/drivers/include/drivers/i2c.h b/components/drivers/include/drivers/i2c.h
index e2a9e7d0b8..17d57288cd 100644
--- a/components/drivers/include/drivers/i2c.h
+++ b/components/drivers/include/drivers/i2c.h
@@ -60,11 +60,12 @@ struct rt_i2c_bus_device
     void *priv;
 };
 
-#ifdef RT_I2C_DEBUG
-#define i2c_dbg(fmt, ...)   rt_kprintf(fmt, ##__VA_ARGS__)
-#else
-#define i2c_dbg(fmt, ...)
-#endif
+struct rt_i2c_client
+{
+    struct rt_device               parent;
+    struct rt_i2c_bus_device       *bus;
+    rt_uint16_t                    client_addr;
+};
 
 rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
                                     const char               *bus_name);
diff --git a/components/drivers/include/drivers/mtd.h b/components/drivers/include/drivers/mtd.h
deleted file mode 100644
index fb7ea4389d..0000000000
--- a/components/drivers/include/drivers/mtd.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author        Notes
-   2018-09-10     heyuanjie87   first version
-
- */
-
-#ifndef __MTD_H__
-#define __MTD_H__
-
-#include <rtthread.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#define MTD_TYPE_NOR    1
-#define MTD_TYPE_NAND   2
-
- /**
-  * MTD operation modes
-  *
-  * @MTD_OPM_PLACE_OOB:	OOB data are placed at the given offset (default)
-  * @MTD_OPM_AUTO_OOB:	OOB data are automatically placed at the free areas
-  * @MTD_OPM_RAW:	    data are transferred as-is, with no error correction;
-  */
-enum mtd_opm
-{
-    MTD_OPM_PLACE_OOB = 0,
-    MTD_OPM_AUTO_OOB = 1,
-    MTD_OPM_RAW = 2,
-};
-
-#ifndef loff_t
-typedef long loff_t;
-#endif
-
-struct mtd_oob_region
-{
-    uint8_t offset;
-    uint8_t length;
-};
-
-typedef struct mtd_info
-{
-    struct rt_device parent;
-
-    const struct mtd_ops *ops;
-
-    uint16_t oob_size;
-    uint16_t sector_size;   /* Minimal writable flash unit size */
-    uint32_t block_size:28; /* Erase size for the device */
-    uint32_t type:4;
-
-    size_t size;    /* Total size of the MTD */
-    loff_t offset;  /* At which this MTD starts, from the beginning of the MEMORY */
-    struct mtd_info *master;
-
-    void *priv;
-}rt_mtd_t;
-
-struct mtd_io_desc
-{
-    uint8_t mode;      /* operation mode(enum mtd_opm) */
-    uint8_t ooblen;    /* number of oob bytes to write/read */
-    uint8_t oobretlen; /* number of oob bytes written/read */
-    uint8_t ooboffs;   /* offset in the oob area  */
-    uint8_t *oobbuf;
-
-    size_t  datlen;    /* number of data bytes to write/read */
-    size_t  datretlen; /* number of data bytes written/read */
-    uint8_t *datbuf;   /* if NULL only oob are read/written */
-};
-
-struct mtd_ops
-{
-    int(*erase)(rt_mtd_t *mtd, loff_t addr, size_t len);    /* return 0 if success */
-    int(*read) (rt_mtd_t *mtd, loff_t from, struct mtd_io_desc *ops); /* return 0 if success */
-    int(*write) (rt_mtd_t *mtd, loff_t to, struct mtd_io_desc *ops);  /* return 0 if success */
-    int(*isbad) (rt_mtd_t *mtd, uint32_t block);    /* return 1 if bad, 0 not bad */
-    int(*markbad) (rt_mtd_t *mtd, uint32_t block);  /* return 0 if success */
-};
-
-struct mtd_part
-{
-    const char *name;           /* name of the MTD partion */
-    loff_t offset;              /* start addr of partion */
-    size_t size;                /* size of partion */
-};
-
-int rt_mtd_erase(rt_mtd_t *mtd, loff_t addr, size_t size);
-int rt_mtd_block_erase(rt_mtd_t *mtd, uint32_t block);
-int rt_mtd_read_oob(rt_mtd_t *mtd, loff_t from, struct mtd_io_desc *desc);
-int rt_mtd_write_oob(rt_mtd_t *mtd, loff_t to, struct mtd_io_desc *desc);
-int rt_mtd_read(rt_mtd_t *mtd, loff_t from, uint8_t *buf, size_t len);
-int rt_mtd_write(rt_mtd_t *mtd, loff_t to, const uint8_t *buf, size_t len);
-int rt_mtd_block_markbad(rt_mtd_t *mtd, uint32_t block);
-int rt_mtd_block_isbad(rt_mtd_t *mtd, uint32_t block);
-
-rt_mtd_t* rt_mtd_get(const char *name);
-int rt_mtd_register(rt_mtd_t *master, const struct mtd_part *parts, int np);
-
-#endif
diff --git a/components/drivers/include/drivers/mtd_nand.h b/components/drivers/include/drivers/mtd_nand.h
index 8afed000dd..f7675aede6 100644
--- a/components/drivers/include/drivers/mtd_nand.h
+++ b/components/drivers/include/drivers/mtd_nand.h
@@ -21,13 +21,13 @@
 struct rt_mtd_nand_driver_ops;
 #define RT_MTD_NAND_DEVICE(device)  ((struct rt_mtd_nand_device*)(device))
 
-#define RT_MTD_EOK          0   /* NO error */
-#define RT_MTD_EECC         1   /* ECC error */
-#define RT_MTD_EBUSY        2   /* hardware busy */
-#define RT_MTD_EIO          3   /* generic IO issue */
-#define RT_MTD_ENOMEM       4   /* out of memory */
-#define RT_MTD_ESRC         5   /* source issue */
-#define RT_MTD_EECC_CORRECT 6   /* ECC error but correct */
+#define RT_MTD_EOK          0     /* NO error */
+#define RT_MTD_EECC         101   /* ECC error */
+#define RT_MTD_EBUSY        102   /* hardware busy */
+#define RT_MTD_EIO          103   /* generic IO issue */
+#define RT_MTD_ENOMEM       104   /* out of memory */
+#define RT_MTD_ESRC         105   /* source issue */
+#define RT_MTD_EECC_CORRECT 106   /* ECC error but correct */
 
 struct rt_mtd_nand_device
 {
@@ -41,77 +41,97 @@ struct rt_mtd_nand_device
     rt_uint32_t pages_per_block;    /* The number of page a block */
     rt_uint16_t block_total;
 
+    /* Only be touched by driver */
     rt_uint32_t block_start;        /* The start of available block*/
     rt_uint32_t block_end;          /* The end of available block */
 
     /* operations interface */
-    const struct rt_mtd_nand_driver_ops* ops;
+    const struct rt_mtd_nand_driver_ops *ops;
 };
 
 struct rt_mtd_nand_driver_ops
 {
-    rt_err_t (*read_id) (struct rt_mtd_nand_device* device);
+    rt_err_t (*read_id)(struct rt_mtd_nand_device *device);
 
-    rt_err_t (*read_page)(struct rt_mtd_nand_device* device,
+    rt_err_t (*read_page)(struct rt_mtd_nand_device *device,
                           rt_off_t page,
-                          rt_uint8_t* data, rt_uint32_t data_len,
-                          rt_uint8_t * spare, rt_uint32_t spare_len);
+                          rt_uint8_t *data, rt_uint32_t data_len,
+                          rt_uint8_t *spare, rt_uint32_t spare_len);
 
-    rt_err_t (*write_page)(struct rt_mtd_nand_device * device,
+    rt_err_t (*write_page)(struct rt_mtd_nand_device *device,
                            rt_off_t page,
-                           const rt_uint8_t * data, rt_uint32_t data_len,
-                           const rt_uint8_t * spare, rt_uint32_t spare_len);
-    rt_err_t (*move_page) (struct rt_mtd_nand_device *device, rt_off_t src_page, rt_off_t dst_page);
+                           const rt_uint8_t *data, rt_uint32_t data_len,
+                           const rt_uint8_t *spare, rt_uint32_t spare_len);
+    rt_err_t (*move_page)(struct rt_mtd_nand_device *device, rt_off_t src_page, rt_off_t dst_page);
 
-    rt_err_t (*erase_block)(struct rt_mtd_nand_device* device, rt_uint32_t block);
-    rt_err_t (*check_block)(struct rt_mtd_nand_device* device, rt_uint32_t block);
-    rt_err_t (*mark_badblock)(struct rt_mtd_nand_device* device, rt_uint32_t block);
+    rt_err_t (*erase_block)(struct rt_mtd_nand_device *device, rt_uint32_t block);
+    rt_err_t (*check_block)(struct rt_mtd_nand_device *device, rt_uint32_t block);
+    rt_err_t (*mark_badblock)(struct rt_mtd_nand_device *device, rt_uint32_t block);
 };
 
-rt_err_t rt_mtd_nand_register_device(const char* name, struct rt_mtd_nand_device* device);
+rt_err_t rt_mtd_nand_register_device(const char *name, struct rt_mtd_nand_device *device);
 
-rt_inline rt_uint32_t rt_mtd_nand_read_id(struct rt_mtd_nand_device* device)
+rt_inline rt_uint32_t rt_mtd_nand_read_id(struct rt_mtd_nand_device *device)
 {
+    RT_ASSERT(device->ops->read_id);
     return device->ops->read_id(device);
 }
 
 rt_inline rt_err_t rt_mtd_nand_read(
-    struct rt_mtd_nand_device* device,
+    struct rt_mtd_nand_device *device,
     rt_off_t page,
-    rt_uint8_t* data, rt_uint32_t data_len,
-    rt_uint8_t * spare, rt_uint32_t spare_len)
+    rt_uint8_t *data, rt_uint32_t data_len,
+    rt_uint8_t *spare, rt_uint32_t spare_len)
 {
+    RT_ASSERT(device->ops->read_page);
     return device->ops->read_page(device, page, data, data_len, spare, spare_len);
 }
 
 rt_inline rt_err_t rt_mtd_nand_write(
-    struct rt_mtd_nand_device* device,
+    struct rt_mtd_nand_device *device,
     rt_off_t page,
-    const rt_uint8_t* data, rt_uint32_t data_len,
-    const rt_uint8_t * spare, rt_uint32_t spare_len)
+    const rt_uint8_t *data, rt_uint32_t data_len,
+    const rt_uint8_t *spare, rt_uint32_t spare_len)
 {
+    RT_ASSERT(device->ops->write_page);
     return device->ops->write_page(device, page, data, data_len, spare, spare_len);
 }
 
-rt_inline rt_err_t rt_mtd_nand_move_page(struct rt_mtd_nand_device* device,
-                                         rt_off_t src_page, rt_off_t dst_page)
+rt_inline rt_err_t rt_mtd_nand_move_page(struct rt_mtd_nand_device *device,
+        rt_off_t src_page, rt_off_t dst_page)
 {
+    RT_ASSERT(device->ops->move_page);
     return device->ops->move_page(device, src_page, dst_page);
 }
 
-rt_inline rt_err_t rt_mtd_nand_erase_block(struct rt_mtd_nand_device* device, rt_uint32_t block)
+rt_inline rt_err_t rt_mtd_nand_erase_block(struct rt_mtd_nand_device *device, rt_uint32_t block)
 {
+    RT_ASSERT(device->ops->erase_block);
     return device->ops->erase_block(device, block);
 }
 
-rt_inline rt_err_t rt_mtd_nand_check_block(struct rt_mtd_nand_device* device, rt_uint32_t block)
+rt_inline rt_err_t rt_mtd_nand_check_block(struct rt_mtd_nand_device *device, rt_uint32_t block)
 {
-    return device->ops->check_block(device, block);
+    if (device->ops->check_block)
+    {
+        return device->ops->check_block(device, block);
+    }
+    else
+    {
+        return -RT_ENOSYS;
+    }
 }
 
-rt_inline rt_err_t rt_mtd_nand_mark_badblock(struct rt_mtd_nand_device* device, rt_uint32_t block)
+rt_inline rt_err_t rt_mtd_nand_mark_badblock(struct rt_mtd_nand_device *device, rt_uint32_t block)
 {
-    return device->ops->mark_badblock(device, block);
+    if (device->ops->mark_badblock)
+    {
+        return device->ops->mark_badblock(device, block);
+    }
+    else
+    {
+        return -RT_ENOSYS;
+    }
 }
 
 #endif /* MTD_NAND_H_ */
diff --git a/components/drivers/include/drivers/mtdnand.h b/components/drivers/include/drivers/mtdnand.h
deleted file mode 100644
index 2e836cb2fb..0000000000
--- a/components/drivers/include/drivers/mtdnand.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author        Notes
-   2018-09-10     heyuanjie87   first version
-
- */
-
-#ifndef _MTDNAND_H_
-#define _MTDNAND_H_
-
-#include "mtd.h"
-
- /* Status bits */
-#define NAND_STATUS_FAIL        0x01
-#define NAND_STATUS_FAIL_N1     0x02
-#define NAND_STATUS_WP          0x80
-
-typedef enum
-{
-    NAND_CMD_PAGE_RD,   /* read data to chip's page buffer,do WaitBusy after this cmd in low driver */
-    NAND_CMD_PAGE_WR0,  /* write data to chip's page buffer */
-    NAND_CMD_PAGE_WR1,  /* do flash programe */
-    NAND_CMD_BLK_ERASE, /* erase block */
-    NAND_CMD_ECC_EN,    /* enable gen HWECC */
-    NAND_CMD_ECC_DIS    /* disable gen HWECC */
-} nand_cmd_t;
-
-typedef enum
-{
-    NAND_ECCM_NONE,
-    NAND_ECCM_HW,
-} nand_eccmode_t;
-
-struct nand_chip;
-struct nand_ops;
-
-/**
-* struct nand_buffers - buffer structure for read/write
-* @ecccalc:    buffer pointer for calculated ECC, size is oobsize.
-* @ecccode:    buffer pointer for ECC read from flash, size is oobsize.
-*
-*/
-struct nand_buffers
-{
-    uint8_t *ecccalc;
-    uint8_t *ecccode;
-};
-
-struct nand_ecc
-{
-    uint8_t mode;    /* nand_eccmode_t */
-    uint8_t bytes;   /* gen ecc bytes per ecc step(usually 3) */
-    uint16_t stepsize:12; /* min 256 */
-    uint16_t _step:4;     /*  */
-
-    /* driver must set the two interface if HWECC */
-    void (*calculate)(struct nand_chip *chip, const uint8_t *dat, uint8_t *ecc_code);
-    /* return max bit flips if can't correct,return -1 ECC is error(0 success) */
-    int(*correct)(struct nand_chip *chip, uint8_t *dat, uint8_t *read_ecc, uint8_t *calc_ecc);
-    /* ignore if NONECC */
-    const struct mtd_oob_region *layout;
-};
-
-typedef struct nand_chip
-{
-    rt_mtd_t parent;
-
-    /* driver must init these */
-    const struct nand_ops *ops;
-    struct nand_ecc ecc;
-    const struct mtd_oob_region *freelayout;
-
-    /* driver do not touch */
-    struct nand_buffers buffers;
-    uint8_t *oob_poi;
-    uint8_t *pagebuf;
-    uint32_t size;
-    uint16_t oobsize;
-    uint8_t pages_pb;
-    uint16_t page_size;
-    int(*read_page)(struct nand_chip *chip, uint8_t *buf, int oob_required, int page);
-    int(*write_page)(struct nand_chip *chip, const uint8_t *buf, int oob_required, int page);
-}rt_nand_t;
-
-struct nand_ops
-{
-    int(*cmdfunc)(rt_nand_t *nand, int cmd, int page, int offset); /* send nand operation cmd, return Status bits(0 success),
-                                                                      if nand is busy please wait in low driver */
-    int(*read_buf)(rt_nand_t *nand, uint8_t *buf, int len);        /* read data from nand chip's page buffer */
-    int(*write_buf)(rt_nand_t *nand, const  uint8_t *buf, int len);/* write data to nand chip's page buffer */
-    int(*isbad)(rt_nand_t *nand, uint32_t blk);   /* if NULL OOB[0] used as bad mark(not 0xff is bad) */
-    int(*markbad)(rt_nand_t *nand, uint32_t blk); /* if NULL OOB[0] used as bad mark(set to 0x00) */
-};
-
-int rt_mtd_nand_init(rt_nand_t *nand, int blk_size, int page_size, int oob_size);
-
-#endif /* MTD_NAND_H_ */
diff --git a/components/drivers/include/drivers/mtdnor.h b/components/drivers/include/drivers/mtdnor.h
deleted file mode 100644
index ccb7466b4b..0000000000
--- a/components/drivers/include/drivers/mtdnor.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author        Notes
-   2018-09-10     heyuanjie87   first version
-
- */
-
-#ifndef __MTDNOR_H__
-#define __MTDNOR_H__
-
-#include <drivers/mtd.h>
-
-struct nor_ops;
-
-typedef struct
-{
-    rt_mtd_t parent;
-
-    const struct nor_ops *ops; /* operations interface */
-}rt_nor_t;
-
-struct nor_ops
-{
-    int (*erase)(rt_nor_t *nor, loff_t addr, size_t len);                     /* return success erased len or error code */
-    int (*read)(rt_nor_t *nor, loff_t addr, uint8_t *buf, size_t len);        /* return success data size or error code */
-    int (*write)(rt_nor_t *nor, loff_t addr, const uint8_t *buf, size_t len); /* return success data size or error code */
-};
-
-int rt_mtd_nor_init(rt_nor_t *nor, int blksize);
-
-#endif
diff --git a/components/drivers/include/drivers/pm.h b/components/drivers/include/drivers/pm.h
index e35b21cd48..dd5875aa1d 100644
--- a/components/drivers/include/drivers/pm.h
+++ b/components/drivers/include/drivers/pm.h
@@ -86,8 +86,8 @@ struct rt_pm;
  */
 struct rt_pm_ops
 {
-    void (*sleep)(struct rt_pm *pm, uint8_t mode);
-    void (*run)(struct rt_pm *pm, uint8_t mode);
+    void (*sleep)(struct rt_pm *pm, rt_uint8_t mode);
+    void (*run)(struct rt_pm *pm, rt_uint8_t mode);
     void (*timer_start)(struct rt_pm *pm, rt_uint32_t timeout);
     void (*timer_stop)(struct rt_pm *pm);
     rt_tick_t (*timer_get_tick)(struct rt_pm *pm);
@@ -95,9 +95,9 @@ struct rt_pm_ops
 
 struct rt_device_pm_ops
 {
-    int (*suspend)(const struct rt_device *device, uint8_t mode);
-    void (*resume)(const struct rt_device *device, uint8_t mode);
-    int (*frequency_change)(const struct rt_device *device, uint8_t mode);
+    int (*suspend)(const struct rt_device *device, rt_uint8_t mode);
+    void (*resume)(const struct rt_device *device, rt_uint8_t mode);
+    int (*frequency_change)(const struct rt_device *device, rt_uint8_t mode);
 };
 
 struct rt_device_pm
@@ -137,22 +137,22 @@ enum
 
 struct rt_pm_notify
 {
-    void (*notify)(uint8_t event, uint8_t mode, void *data);
+    void (*notify)(rt_uint8_t event, rt_uint8_t mode, void *data);
     void *data;
 };
 
-void rt_pm_request(uint8_t sleep_mode);
-void rt_pm_release(uint8_t sleep_mode);
-int rt_pm_run_enter(uint8_t run_mode);
+void rt_pm_request(rt_uint8_t sleep_mode);
+void rt_pm_release(rt_uint8_t sleep_mode);
+int rt_pm_run_enter(rt_uint8_t run_mode);
 
 void rt_pm_device_register(struct rt_device *device, const struct rt_device_pm_ops *ops);
 void rt_pm_device_unregister(struct rt_device *device);
 
-void rt_pm_notify_set(void (*notify)(uint8_t event, uint8_t mode, void *data), void *data);
-void rt_pm_default_set(uint8_t sleep_mode);
+void rt_pm_notify_set(void (*notify)(rt_uint8_t event, rt_uint8_t mode, void *data), void *data);
+void rt_pm_default_set(rt_uint8_t sleep_mode);
 
 void rt_system_pm_init(const struct rt_pm_ops *ops,
-                       uint8_t              timer_mask,
+                       rt_uint8_t              timer_mask,
                        void                 *user_data);
 
 #endif /* __PM_H__ */
diff --git a/components/drivers/include/drivers/pulse_encoder.h b/components/drivers/include/drivers/pulse_encoder.h
new file mode 100644
index 0000000000..0c7df04cd6
--- /dev/null
+++ b/components/drivers/include/drivers/pulse_encoder.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-08-08     balanceTWK   the first version
+ */
+
+#ifndef __PULSE_ENCODER_H__
+#define __PULSE_ENCODER_H__
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* pulse_encoder control command */
+#define PULSE_ENCODER_CMD_GET_TYPE       (128 + 0)    /* get a pulse_encoder type information */
+#define PULSE_ENCODER_CMD_ENABLE         (128 + 1)    /* enable pulse_encoder */
+#define PULSE_ENCODER_CMD_DISABLE        (128 + 2)    /* disable pulse_encoder */
+#define PULSE_ENCODER_CMD_CLEAR_COUNT    (128 + 3)    /* clear pulse_encoder count */
+
+/* pulse_encoder type */
+enum rt_pulse_encoder_type
+{
+    UNKNOWN_PULSE_ENCODER_TYPE = 0x00,    /* Unknown pulse_encoder type */
+    SINGLE_PHASE_PULSE_ENCODER,           /* single phase pulse_encoder */
+    AB_PHASE_PULSE_ENCODER                /* two phase pulse_encoder */
+};
+
+struct rt_pulse_encoder_device;
+
+struct rt_pulse_encoder_ops
+{
+    rt_err_t (*init)(struct rt_pulse_encoder_device *pulse_encoder);
+    rt_int32_t (*get_count)(struct rt_pulse_encoder_device *pulse_encoder);
+    rt_err_t (*clear_count)(struct rt_pulse_encoder_device *pulse_encoder);
+    rt_err_t (*control)(struct rt_pulse_encoder_device *pulse_encoder, rt_uint32_t cmd, void *args);
+};
+
+struct rt_pulse_encoder_device
+{
+    struct rt_device parent;
+    const struct rt_pulse_encoder_ops *ops;
+    enum rt_pulse_encoder_type type;
+};
+
+rt_err_t rt_device_pulse_encoder_register(struct rt_pulse_encoder_device *pulse_encoder, const char *name, void *user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __PULSE_ENCODER_H__ */
diff --git a/components/drivers/include/drivers/rt_inputcapture.h b/components/drivers/include/drivers/rt_inputcapture.h
new file mode 100644
index 0000000000..0cadf6444c
--- /dev/null
+++ b/components/drivers/include/drivers/rt_inputcapture.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-08-13     balanceTWK   first version.
+ */
+
+#ifndef __RT_INPUT_CAPTURE_H__
+#define __RT_INPUT_CAPTURE_H__
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* capture control command */
+#define INPUTCAPTURE_CMD_CLEAR_BUF        (128 + 0)    /* clear capture buf */
+#define INPUTCAPTURE_CMD_SET_WATERMARK    (128 + 1)    /* Set the callback threshold */
+
+struct rt_inputcapture_data
+{
+    rt_uint32_t pulsewidth_us;
+    rt_bool_t   is_high;
+};
+
+struct rt_inputcapture_device
+{
+    struct rt_device                    parent;
+
+    const struct rt_inputcapture_ops    *ops;
+    struct rt_ringbuffer                *ringbuff;
+    rt_size_t                           watermark;
+};
+
+/**
+ * capture operators
+ */
+struct rt_inputcapture_ops
+{
+    rt_err_t (*init)(struct rt_inputcapture_device *inputcapture);
+    rt_err_t (*open)(struct rt_inputcapture_device *inputcapture);
+    rt_err_t (*close)(struct rt_inputcapture_device *inputcapture);
+    rt_err_t (*get_pulsewidth)(struct rt_inputcapture_device *inputcapture, rt_uint32_t *pulsewidth_us);
+};
+
+void rt_hw_capture_isr(struct rt_inputcapture_device *inputcapture, rt_bool_t level);
+
+rt_err_t rt_device_inputcapture_register(struct rt_inputcapture_device *inputcapture,
+                                         const char                    *name,
+                                         void                          *data);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __RT_INPUT_CAPTURE_H__ */
diff --git a/components/drivers/include/ipc/workqueue.h b/components/drivers/include/ipc/workqueue.h
index 354a30c04e..23e256c420 100644
--- a/components/drivers/include/ipc/workqueue.h
+++ b/components/drivers/include/ipc/workqueue.h
@@ -43,13 +43,13 @@ struct rt_work
     void *work_data;
     rt_uint16_t flags;
     rt_uint16_t type;
+    struct rt_timer timer;
+    struct rt_workqueue *workqueue;
 };
 
 struct rt_delayed_work
 {
     struct rt_work work;
-    struct rt_timer timer;
-    struct rt_workqueue *workqueue;
 };
 
 #ifdef RT_USING_HEAP
@@ -74,6 +74,7 @@ rt_inline void rt_work_init(struct rt_work *work, void (*work_func)(struct rt_wo
     rt_list_init(&(work->list));
     work->work_func = work_func;
     work->work_data = work_data;
+    work->workqueue = RT_NULL;
     work->flags = 0;
     work->type = 0;
 }
@@ -81,6 +82,7 @@ rt_inline void rt_work_init(struct rt_work *work, void (*work_func)(struct rt_wo
 void rt_delayed_work_init(struct rt_delayed_work *work, void (*work_func)(struct rt_work *work,
                           void *work_data), void *work_data);
 
+int rt_work_sys_workqueue_init(void);
 #endif
 
 #endif
diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h
index d59b40cc47..623c085430 100644
--- a/components/drivers/include/rtdevice.h
+++ b/components/drivers/include/rtdevice.h
@@ -122,6 +122,18 @@ extern "C" {
 #include "drivers/mtdnand.h"
 #endif
 
+#ifdef RT_USING_HWCRYPTO
+#include "drivers/crypto.h"
+#endif
+
+#ifdef RT_USING_PULSE_ENCODER
+#include "drivers/pulse_encoder.h"
+#endif
+
+#ifdef RT_USING_INPUT_CAPTURE
+#include "drivers/rt_inputcapture.h"
+#endif
+
 #ifdef __cplusplus
 }
 #endif