Change license, update Readme and fixed some compability issues

Author: jicheng0622

bsp/imxrt/Libraries/imxrt1021/drivers/drv_cache.c

@@ -1,11 +1,7 @@
 /*
- * File      : drv_cache.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Development Team
+ * Copyright (c) 2006-2018, RT-Thread Development Team
  *
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * SPDX-License-Identifier: Apache-2.0
  *
  * Change Logs:
  * Date           Author       Notes

bsp/imxrt/Libraries/imxrt1021/drivers/drv_codec.c

@@ -1,3 +1,13 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-03-11     JiCheng      Adapt RT1020's IO MAP
+ */
+
 #include <rthw.h>
 #include <rtthread.h>
 #include <rtdevice.h>
@@ -55,21 +65,21 @@ static void _InitPins(void)
 {
     CLOCK_EnableClock(kCLOCK_Iomuxc);
 
-    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_00_LPI2C1_SCL, 1);
-    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_01_LPI2C1_SDA, 1);
+    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_14_LPI2C1_SCL, 1);
+    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_15_LPI2C1_SDA, 1);
 
-    IOMUXC_SetPinConfig( IOMUXC_GPIO_AD_B1_00_LPI2C1_SCL,  0xD8B0u);
-    IOMUXC_SetPinConfig(  IOMUXC_GPIO_AD_B1_01_LPI2C1_SDA, 0xD8B0u);
+    IOMUXC_SetPinConfig( IOMUXC_GPIO_AD_B1_14_LPI2C1_SCL,  0xD8B0u);
+    IOMUXC_SetPinConfig( IOMUXC_GPIO_AD_B1_15_LPI2C1_SDA, 0xD8B0u);
 
-    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_09_SAI1_MCLK, 1U);
-    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_13_SAI1_TX_DATA00, 1U);
-    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_14_SAI1_TX_BCLK, 1U);
-    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_15_SAI1_TX_SYNC, 1U);
+    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_00_SAI1_MCLK, 1U);
+    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_03_SAI1_TX_DATA00, 1U);
+    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_01_SAI1_TX_BCLK, 1U);
+    IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B1_02_SAI1_TX_SYNC, 1U);
 
-    IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B1_09_SAI1_MCLK, 0x10B0u);
-    IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B1_13_SAI1_TX_DATA00,  0x10B0u);
-    IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B1_14_SAI1_TX_BCLK, 0x10B0u);
-    IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B1_15_SAI1_TX_SYNC, 0x10B0u);
+    IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B1_00_SAI1_MCLK, 0x10B0u);
+    IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B1_03_SAI1_TX_DATA00,  0x10B0u);
+    IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B1_01_SAI1_TX_BCLK, 0x10B0u);
+    IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B1_02_SAI1_TX_SYNC, 0x10B0u);
 }
 
 static void BOARD_EnableSaiMclkOutput(bool enable)

bsp/imxrt/Libraries/imxrt1021/drivers/drv_codec.h

@@ -1,3 +1,11 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
 #ifndef __DRV_CODEC_H__
 #define __DRV_CODEC_H__
 

bsp/imxrt/Libraries/imxrt1021/drivers/drv_eth.c

@@ -1,15 +1,12 @@
 /*
- * File      : application.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Development Team
+ * Copyright (c) 2006-2018, RT-Thread Development Team
  *
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * SPDX-License-Identifier: Apache-2.0
  *
  * Change Logs:
  * Date           Author       Notes
  * 2017-06-08     tanek        first implementation
+ * 2019-03-11     JiCheng      Adapt RT1020's IO MAP
  */
 #include <rtthread.h>
 #include "board.h"
@@ -386,13 +383,13 @@ static void _enet_config(void)
     /* Set SMI to get PHY link status. */
     sysClock = CLOCK_GetFreq(kCLOCK_AhbClk);
 
-    dbg_log(DBG_LOG, "deinit\n");
+    LOG_D("deinit\n");
     ENET_Deinit(imxrt_eth_device.enet_base);
-    dbg_log(DBG_LOG, "init\n");
+    LOG_D("init\n");
     ENET_Init(imxrt_eth_device.enet_base, &imxrt_eth_device.enet_handle, &config, &buffConfig, &imxrt_eth_device.dev_addr[0], sysClock);
-    dbg_log(DBG_LOG, "set call back\n");
+    LOG_D("set call back\n");
     ENET_SetCallback(&imxrt_eth_device.enet_handle, _enet_callback, &imxrt_eth_device);
-    dbg_log(DBG_LOG, "active read\n");
+    LOG_D("active read\n");
     ENET_ActiveRead(imxrt_eth_device.enet_base);
 }
 
@@ -436,41 +433,41 @@ static void packet_dump(const char *msg, const struct pbuf *p)
 /* initialize the interface */
 static rt_err_t rt_imxrt_eth_init(rt_device_t dev)
 {
-    dbg_log(DBG_LOG, "rt_imxrt_eth_init...\n");
+    LOG_D("rt_imxrt_eth_init...\n");
     _enet_config();
 
     return RT_EOK;
 }
 
 static rt_err_t rt_imxrt_eth_open(rt_device_t dev, rt_uint16_t oflag)
 {
-    dbg_log(DBG_LOG, "rt_imxrt_eth_open...\n");
+    LOG_D("rt_imxrt_eth_open...\n");
     return RT_EOK;
 }
 
 static rt_err_t rt_imxrt_eth_close(rt_device_t dev)
 {
-    dbg_log(DBG_LOG, "rt_imxrt_eth_close...\n");
+    LOG_D("rt_imxrt_eth_close...\n");
     return RT_EOK;
 }
 
 static rt_size_t rt_imxrt_eth_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
 {
-    dbg_log(DBG_LOG, "rt_imxrt_eth_read...\n");
+    LOG_D("rt_imxrt_eth_read...\n");
     rt_set_errno(-RT_ENOSYS);
     return 0;
 }
 
 static rt_size_t rt_imxrt_eth_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
 {
-    dbg_log(DBG_LOG, "rt_imxrt_eth_write...\n");
+    LOG_D("rt_imxrt_eth_write...\n");
     rt_set_errno(-RT_ENOSYS);
     return 0;
 }
 
 static rt_err_t rt_imxrt_eth_control(rt_device_t dev, int cmd, void *args)
 {
-    dbg_log(DBG_LOG, "rt_imxrt_eth_control...\n");
+    LOG_D("rt_imxrt_eth_control...\n");
     switch (cmd)
     {
     case NIOCTL_GADDR:
@@ -679,7 +676,7 @@ rt_err_t rt_imxrt_eth_tx(rt_device_t dev, struct pbuf *p)
     RT_ASSERT(p != NULL);
     RT_ASSERT(enet_handle != RT_NULL);
 
-    dbg_log(DBG_LOG, "rt_imxrt_eth_tx: %d\n", p->len);
+    LOG_D("rt_imxrt_eth_tx: %d\n", p->len);
 
 #ifdef ETH_TX_DUMP
     packet_dump("send", p);
@@ -733,18 +730,18 @@ struct pbuf *rt_imxrt_eth_rx(rt_device_t dev)
             }
             else
             {
-                dbg_log(DBG_LOG, " A frame read failed\n");
+                LOG_D(" A frame read failed\n");
                 pbuf_free(p);
             }
         }
         else
         {
-            dbg_log(DBG_LOG, " pbuf_alloc faild\n");
+            LOG_D(" pbuf_alloc faild\n");
         }
     }
     else if (status == kStatus_ENET_RxFrameError)
     {
-        dbg_log(DBG_WARNING, "ENET_GetRxFrameSize: kStatus_ENET_RxFrameError\n");
+        LOG_W("ENET_GetRxFrameSize: kStatus_ENET_RxFrameError\n");
         /* Update the received buffer when error happened. */
         /* Get the error information of the received g_frame. */
         ENET_GetRxErrBeforeReadFrame(enet_handle, error_statistic);
@@ -782,20 +779,20 @@ static void phy_monitor_thread_entry(void *parameter)
 
                 if (kPHY_Speed10M == speed)
                 {
-                    dbg_log(DBG_LOG, "10M\n");
+                    LOG_D("10M\n");
                 }
                 else
                 {
-                    dbg_log(DBG_LOG, "100M\n");
+                    LOG_D("100M\n");
                 }
 
                 if (kPHY_HalfDuplex == duplex)
                 {
-                    dbg_log(DBG_LOG, "half dumplex\n");
+                    LOG_D("half dumplex\n");
                 }
                 else
                 {
-                    dbg_log(DBG_LOG, "full dumplex\n");
+                    LOG_D("full dumplex\n");
                 }
 
                 if ((imxrt_eth_device.speed != (enet_mii_speed_t)speed)
@@ -804,19 +801,19 @@ static void phy_monitor_thread_entry(void *parameter)
                     imxrt_eth_device.speed = (enet_mii_speed_t)speed;
                     imxrt_eth_device.duplex = (enet_mii_duplex_t)duplex;
 
-                    dbg_log(DBG_LOG, "link up, and update eth mode.\n");
+                    LOG_D("link up, and update eth mode.\n");
                     rt_imxrt_eth_init((rt_device_t)&imxrt_eth_device);
                 }
                 else
                 {
-                    dbg_log(DBG_LOG, "link up, eth not need re-config.\n");
+                    LOG_D("link up, eth not need re-config.\n");
                 }
-                dbg_log(DBG_LOG, "link up.\n");
+                LOG_D("link up.\n");
                 eth_device_linkchange(&imxrt_eth_device.parent, RT_TRUE);
             }
             else        // link down
             {
-                dbg_log(DBG_LOG, "link down.\n");
+                LOG_D("link down.\n");
                 eth_device_linkchange(&imxrt_eth_device.parent, RT_FALSE);
             }
         }
@@ -858,20 +855,20 @@ static int rt_hw_imxrt_eth_init(void)
     imxrt_eth_device.parent.eth_rx     = rt_imxrt_eth_rx;
     imxrt_eth_device.parent.eth_tx     = rt_imxrt_eth_tx;
 
-    dbg_log(DBG_LOG, "sem init: tx_wait\r\n");
+    LOG_D("sem init: tx_wait\r\n");
     /* init tx semaphore */
     rt_sem_init(&imxrt_eth_device.tx_wait, "tx_wait", 0, RT_IPC_FLAG_FIFO);
 
     /* register eth device */
-    dbg_log(DBG_LOG, "eth_device_init start\r\n");
+    LOG_D("eth_device_init start\r\n");
     state = eth_device_init(&(imxrt_eth_device.parent), "e0");
     if (RT_EOK == state)
     {
-        dbg_log(DBG_LOG, "eth_device_init success\r\n");
+        LOG_D("eth_device_init success\r\n");
     }
     else
     {
-        dbg_log(DBG_LOG, "eth_device_init faild: %d\r\n", state);
+        LOG_D("eth_device_init faild: %d\r\n", state);
     }
 
     eth_device_linkchange(&imxrt_eth_device.parent, RT_FALSE);

bsp/imxrt/Libraries/imxrt1021/drivers/drv_flexspi_nor.c

@@ -6,6 +6,7 @@
  * Change Logs:
  * Date           Author       Notes
  * 2018-07-05     ZYH    the first version
+ * 2019-03-11     JiCheng    Remove section"itcm", use scatter file to allocate drv_flexspi.o to itcm
  */
 #include <rtthread.h>
 #define PRINTF rt_kprintf

bsp/imxrt/Libraries/imxrt1021/drivers/drv_hwtimer.c

@@ -1,25 +1,12 @@
 /*
-* File      : drv_hwtimer.c
-* This file is part of RT-Thread RTOS
-* COPYRIGHT (C) 2017, 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
-*  the Free Software Foundation; either version 2 of the License, or
-*  (at your option) any later version.
-*
-*  This program is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License along
-*  with this program; if not, write to the Free Software Foundation, Inc.,
-*  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
 * Change Logs:
 * Date           Author       Notes
 * 2018-04-17     WangBing     the first version.
+* 2019-03-11     JiCheng      Change API name from rt1052 to rt1021
 */
 
 #include <rtthread.h>
@@ -47,7 +34,7 @@ static void NVIC_Configuration(void)
     EnableIRQ(GPT1_IRQn);
 }
 
-static rt_err_t rt1052_hwtimer_control(rt_hwtimer_t *timer, rt_uint32_t cmd, void *args)
+static rt_err_t rt1021_hwtimer_control(rt_hwtimer_t *timer, rt_uint32_t cmd, void *args)
 {
     rt_err_t err = RT_EOK;
     GPT_Type *hwtimer_dev;
@@ -73,7 +60,7 @@ static rt_err_t rt1052_hwtimer_control(rt_hwtimer_t *timer, rt_uint32_t cmd, voi
     return err;
 }
 
-static rt_uint32_t rt1052_hwtimer_count_get(rt_hwtimer_t *timer)
+static rt_uint32_t rt1021_hwtimer_count_get(rt_hwtimer_t *timer)
 {
     rt_uint32_t CurrentTimer_Count;
     GPT_Type *hwtimer_dev;
@@ -86,7 +73,7 @@ static rt_uint32_t rt1052_hwtimer_count_get(rt_hwtimer_t *timer)
     return CurrentTimer_Count;
 }
 
-static void rt1052_hwtimer_init(rt_hwtimer_t *timer, rt_uint32_t state)
+static void rt1021_hwtimer_init(rt_hwtimer_t *timer, rt_uint32_t state)
 {
     GPT_Type *hwtimer_dev;
     gpt_config_t gptConfig;
@@ -108,7 +95,7 @@ static void rt1052_hwtimer_init(rt_hwtimer_t *timer, rt_uint32_t state)
     }
 }
 
-static rt_err_t rt1052_hwtimer_start(rt_hwtimer_t *timer, rt_uint32_t cnt, rt_hwtimer_mode_t mode)
+static rt_err_t rt1021_hwtimer_start(rt_hwtimer_t *timer, rt_uint32_t cnt, rt_hwtimer_mode_t mode)
 {
     GPT_Type *hwtimer_dev;
     hwtimer_dev = (GPT_Type *)timer->parent.user_data;
@@ -128,7 +115,7 @@ static rt_err_t rt1052_hwtimer_start(rt_hwtimer_t *timer, rt_uint32_t cnt, rt_hw
     return RT_EOK;
 }
 
-static void rt1052_hwtimer_stop(rt_hwtimer_t *timer)
+static void rt1021_hwtimer_stop(rt_hwtimer_t *timer)
 {
     GPT_Type *hwtimer_dev;
     hwtimer_dev = (GPT_Type *)timer->parent.user_data;
@@ -138,16 +125,16 @@ static void rt1052_hwtimer_stop(rt_hwtimer_t *timer)
     GPT_StopTimer(hwtimer_dev);
 }
 
-static const struct rt_hwtimer_ops rt1052_hwtimer_ops =
+static const struct rt_hwtimer_ops rt1021_hwtimer_ops =
 {
-    rt1052_hwtimer_init,
-    rt1052_hwtimer_start,
-    rt1052_hwtimer_stop,
-    rt1052_hwtimer_count_get,
-    rt1052_hwtimer_control,
+    rt1021_hwtimer_init,
+    rt1021_hwtimer_start,
+    rt1021_hwtimer_stop,
+    rt1021_hwtimer_count_get,
+    rt1021_hwtimer_control,
 };
 
-static const struct rt_hwtimer_info rt1052_hwtimer_info =
+static const struct rt_hwtimer_info rt1021_hwtimer_info =
 {
     25000000,           /* the maximum count frequency can be set */
     6103,               /* the minimum count frequency can be set */
@@ -157,12 +144,12 @@ static const struct rt_hwtimer_info rt1052_hwtimer_info =
 
 static rt_hwtimer_t GPT_timer1;
 
-int rt1052_hw_hwtimer_init(void)
+int rt1021_hw_hwtimer_init(void)
 {
     int ret = RT_EOK;
 
-    GPT_timer1.info = &rt1052_hwtimer_info;
-    GPT_timer1.ops  = &rt1052_hwtimer_ops;
+    GPT_timer1.info = &rt1021_hwtimer_info;
+    GPT_timer1.ops  = &rt1021_hwtimer_ops;
 
     rt_device_hwtimer_register(&GPT_timer1, "_timer", GPT1);
 
@@ -184,6 +171,6 @@ void GPT1_IRQHandler(void)
 #endif
 }
 
-INIT_DEVICE_EXPORT(rt1052_hw_hwtimer_init);
+INIT_DEVICE_EXPORT(rt1021_hw_hwtimer_init);
 
 #endif /*RT_USING_HWTIMER*/