Merge pull request #3104 from OpenNuvoton/nuvoton

[NuMaker] Support CAN and fix PWM CLK error

Author: sg-

targets/TARGET_NUVOTON/TARGET_M451/TARGET_NUMAKER_PFM_M453/PeripheralNames.h

@@ -110,6 +110,10 @@ typedef enum {
     DMA_0 = (int) NU_MODNAME(PDMA_BASE, 0)
 } DMAName;
 
+typedef enum {
+    CAN_0 = (int) NU_MODNAME(CAN0_BASE, 0)
+} CANName;
+
 #ifdef __cplusplus
 }
 #endif

targets/TARGET_NUVOTON/TARGET_M451/TARGET_NUMAKER_PFM_M453/PeripheralPins.c

@@ -359,3 +359,19 @@ const PinMap PinMap_SPI_SSEL[] = {
 
     {NC,    NC,    0}
 };
+
+const PinMap PinMap_CAN_TD[] = {
+    {PC_0, CAN_0, SYS_GPC_MFPL_PC0MFP_CAN0_TXD},
+    {PA_1, CAN_0, SYS_GPA_MFPL_PA1MFP_CAN0_TXD},
+    {PA_12, CAN_0, SYS_GPA_MFPH_PA12MFP_CAN0_TXD},
+	
+    {NC,    NC,     0}
+};
+    
+const PinMap PinMap_CAN_RD[] = { 
+    {PC_1, CAN_0, SYS_GPC_MFPL_PC1MFP_CAN0_RXD},
+    {PA_0, CAN_0, SYS_GPA_MFPL_PA0MFP_CAN0_RXD},
+    {PA_13, CAN_0, SYS_GPA_MFPH_PA13MFP_CAN0_RXD},
+	
+    {NC,    NC,    0}
+};

targets/TARGET_NUVOTON/TARGET_M451/TARGET_NUMAKER_PFM_M453/PeripheralPins.h

@@ -65,6 +65,11 @@ extern const PinMap PinMap_SD_DAT1[];
 extern const PinMap PinMap_SD_DAT2[];
 extern const PinMap PinMap_SD_DAT3[];
 
+//*** CAN ***
+
+extern PinMap const PinMap_CAN_TD[];
+extern PinMap const PinMap_CAN_RD[];
+
 #ifdef __cplusplus
 }
 #endif

targets/TARGET_NUVOTON/TARGET_M451/TARGET_NUMAKER_PFM_M453/device.h

@@ -38,8 +38,6 @@
 #define DEVICE_SPI_ASYNCH       1
 #define DEVICE_SPISLAVE         1
 
-#define DEVICE_CAN              0
-
 #define DEVICE_RTC              1
 
 #define DEVICE_ETHERNET         0

targets/TARGET_NUVOTON/TARGET_M451/TARGET_NUMAKER_PFM_M453/objects.h

@@ -123,6 +123,10 @@ struct sleep_s {
     int powerdown;
 };
 
+struct can_s {
+    CANName can;
+    char index; 
+};
 #ifdef __cplusplus
 }
 #endif

targets/TARGET_NUVOTON/TARGET_M451/can_api.c

@@ -0,0 +1,303 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2015-2016 Nuvoton
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+ #include "can_api.h"
+ #include "m451_gpio.h"
+ #include "m451_can.h"
+ 
+ #if DEVICE_CAN
+ #include <string.h>
+ #include "cmsis.h"
+ #include "pinmap.h"
+ #include "PeripheralPins.h"
+ #include "nu_modutil.h"
+ #include "nu_miscutil.h"
+ #include "nu_bitutil.h"
+ #include "critical.h"
+ 
+ #define NU_CAN_DEBUG    0
+ #define CAN_NUM         1
+ 
+ static uint32_t can_irq_ids[CAN_NUM] = {0};
+ static can_irq_handler can0_irq_handler;
+
+ 
+ static const struct nu_modinit_s can_modinit_tab[] = {
+    {CAN_0, CAN0_MODULE, 0, 0, CAN0_RST, CAN0_IRQn, NULL},
+    
+    {NC, 0, 0, 0, 0, (IRQn_Type) 0, NULL}
+};
+
+ 
+ void can_init(can_t *obj, PinName rd, PinName td)
+ {
+    uint32_t can_td = (CANName)pinmap_peripheral(td, PinMap_CAN_TD);
+    uint32_t can_rd = (CANName)pinmap_peripheral(rd, PinMap_CAN_RD);
+    obj->can = (CANName)pinmap_merge(can_td, can_rd);
+    MBED_ASSERT((int)obj->can != NC);
+    
+    const struct nu_modinit_s *modinit = get_modinit(obj->can, can_modinit_tab);
+    MBED_ASSERT(modinit != NULL);
+    MBED_ASSERT(modinit->modname == obj->can);
+    
+    // Reset this module
+    SYS_ResetModule(modinit->rsetidx);
+    
+    // Enable IP clock
+    CLK_EnableModuleClock(modinit->clkidx);
+     
+    obj->index = 0;
+    
+    pinmap_pinout(td, PinMap_CAN_TD);
+    pinmap_pinout(rd, PinMap_CAN_RD);
+    
+    /* For M453 mbed Board Transmitter Setting (RS Pin) */
+    GPIO_SetMode(PA, BIT0| BIT1, GPIO_MODE_OUTPUT);    
+    PA0 = 0x00;
+    PA1 = 0x00;   
+
+    CAN_Open((CAN_T *)obj->can, 500000, CAN_NORMAL_MODE);
+    
+    can_filter(obj, 0, 0, CANStandard, 0);
+ }
+ 
+ 
+void can_free(can_t *obj)
+{
+
+    const struct nu_modinit_s *modinit = get_modinit(obj->can, can_modinit_tab);
+    
+    MBED_ASSERT(modinit != NULL);
+    MBED_ASSERT(modinit->modname == obj->can);
+    
+    // Reset this module
+    SYS_ResetModule(modinit->rsetidx);
+    
+    CLK_DisableModuleClock(modinit->clkidx);
+}
+
+int can_frequency(can_t *obj, int hz)
+{
+    CAN_SetBaudRate((CAN_T *)obj->can, hz);
+    
+    return CAN_GetCANBitRate((CAN_T *)obj->can);
+}
+
+static void can_irq(CANName name, int id) 
+{
+    
+    CAN_T *can = (CAN_T *)NU_MODBASE(name);
+    uint32_t u8IIDRstatus;
+
+    u8IIDRstatus = can->IIDR;
+
+    if(u8IIDRstatus == 0x00008000) {      /* Check Status Interrupt Flag (Error status Int and Status change Int) */
+        /**************************/
+        /* Status Change interrupt*/
+        /**************************/
+        if(can->STATUS & CAN_STATUS_RXOK_Msk) {
+            can->STATUS &= ~CAN_STATUS_RXOK_Msk;   /* Clear Rx Ok status*/
+            can0_irq_handler(can_irq_ids[id], IRQ_RX);
+        }
+
+        if(can->STATUS & CAN_STATUS_TXOK_Msk) {
+            can->STATUS &= ~CAN_STATUS_TXOK_Msk;    /* Clear Tx Ok status*/
+            can0_irq_handler(can_irq_ids[id], IRQ_TX);
+        }
+
+        /**************************/
+        /* Error Status interrupt */
+        /**************************/
+        if(can->STATUS & CAN_STATUS_EWARN_Msk) {
+            can0_irq_handler(can_irq_ids[id], IRQ_ERROR);
+        }
+
+        if(can->STATUS & CAN_STATUS_BOFF_Msk) {
+            can0_irq_handler(can_irq_ids[id], IRQ_BUS);
+        }
+    } else if (u8IIDRstatus!=0) {
+
+        can0_irq_handler(can_irq_ids[id], IRQ_OVERRUN);
+        
+        CAN_CLR_INT_PENDING_BIT(can, ((can->IIDR) -1));      /* Clear Interrupt Pending */
+
+    } else if(can->WU_STATUS == 1) {
+
+        can->WU_STATUS = 0;                       /* Write '0' to clear */
+        can0_irq_handler(can_irq_ids[id], IRQ_WAKEUP);
+    }
+}
+
+void CAN0_IRQHandler(void)
+{
+    can_irq(CAN_0, 0);
+}
+
+void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+{
+    can0_irq_handler = handler;
+    can_irq_ids[obj->index] = id; 
+}
+
+void can_irq_free(can_t *obj)
+{
+    CAN_DisableInt((CAN_T *)obj->can, (CAN_CON_IE_Msk|CAN_CON_SIE_Msk|CAN_CON_EIE_Msk));
+    
+    can_irq_ids[obj->index] = 0;
+    
+    NVIC_DisableIRQ(CAN0_IRQn);    
+}
+
+void can_irq_set(can_t *obj, CanIrqType irq, uint32_t enable)
+{
+    
+    CAN_EnterInitMode((CAN_T*)obj->can, ((enable != 0 )? CAN_CON_IE_Msk :0) );
+    
+    
+    switch (irq)
+    {
+        case IRQ_ERROR:
+        case IRQ_BUS:
+        case IRQ_PASSIVE:
+            ((CAN_T *)(obj->can))->CON = (((CAN_T *)(obj->can))->CON) |CAN_CON_EIE_Msk;
+            ((CAN_T *)(obj->can))->CON = (((CAN_T *)(obj->can))->CON) |CAN_CON_SIE_Msk;
+            break;
+        
+        case IRQ_RX:
+        case IRQ_TX:
+        case IRQ_OVERRUN:
+        case IRQ_WAKEUP:
+            ((CAN_T *)(obj->can))->CON = (((CAN_T *)(obj->can))->CON) |CAN_CON_SIE_Msk;
+            break;
+        
+        default:
+            break;
+    
+    }
+
+    CAN_LeaveInitMode((CAN_T*)obj->can);
+    
+    NVIC_SetVector(CAN0_IRQn, (uint32_t)&CAN0_IRQHandler);
+    NVIC_EnableIRQ(CAN0_IRQn);
+    
+}
+
+int can_write(can_t *obj, CAN_Message msg, int cc)
+{
+    STR_CANMSG_T CMsg;
+    
+    CMsg.IdType = (uint32_t)msg.format;
+    CMsg.FrameType = (uint32_t)!msg.type;
+    CMsg.Id = msg.id;
+    CMsg.DLC = msg.len;
+    memcpy((void *)&CMsg.Data[0],(const void *)&msg.data[0], (unsigned int)8);
+
+    return CAN_Transmit((CAN_T *)(obj->can), cc, &CMsg);
+}
+
+int can_read(can_t *obj, CAN_Message *msg, int handle)
+{
+    STR_CANMSG_T CMsg;
+
+    if(!CAN_Receive((CAN_T *)(obj->can), handle, &CMsg))
+    return 0;
+        
+    msg->format = (CANFormat)CMsg.IdType;
+    msg->type = (CANType)!CMsg.FrameType;
+    msg->id = CMsg.Id;
+    msg->len = CMsg.DLC;
+    memcpy(&msg->data[0], &CMsg.Data[0], 8);
+    
+    return 1;
+}
+
+int can_mode(can_t *obj, CanMode mode)
+{
+    int success = 0;
+    switch (mode)
+    {
+        case MODE_RESET:
+            CAN_LeaveTestMode((CAN_T*)obj->can);
+            success = 1;
+            break;
+        
+        case MODE_NORMAL:
+            CAN_EnterTestMode((CAN_T*)(obj->can), CAN_TEST_BASIC_Msk);
+            success = 1;
+            break;
+        
+        case MODE_SILENT:
+            CAN_EnterTestMode((CAN_T*)(obj->can), CAN_TEST_SILENT_Msk);
+            success = 1;
+            break;
+        
+        case MODE_TEST_LOCAL:
+        case MODE_TEST_GLOBAL:
+            CAN_EnterTestMode((CAN_T*)(obj->can), CAN_TEST_LBACK_Msk);
+            success = 1;
+            break;
+        
+        case MODE_TEST_SILENT:
+            CAN_EnterTestMode((CAN_T*)(obj->can), CAN_TEST_SILENT_Msk | CAN_TEST_LBACK_Msk);
+            success = 1;
+            break;
+        
+        default:
+            success = 0;
+            break;
+        
+    }
+    
+    
+    return success;
+}
+
+int can_filter(can_t *obj, uint32_t id, uint32_t mask, CANFormat format, int32_t handle)
+{
+    return CAN_SetRxMsg((CAN_T *)(obj->can), handle , (uint32_t)format, id);
+}
+
+
+void can_reset(can_t *obj)
+{
+    const struct nu_modinit_s *modinit = get_modinit(obj->can, can_modinit_tab);
+    
+    MBED_ASSERT(modinit != NULL);
+    MBED_ASSERT(modinit->modname == obj->can);
+    
+    // Reset this module
+    SYS_ResetModule(modinit->rsetidx);
+    
+}
+
+unsigned char can_rderror(can_t *obj)
+{
+    CAN_T *can = (CAN_T *)(obj->can); 
+    return ((can->ERR>>8)&0xFF);
+}
+
+unsigned char can_tderror(can_t *obj)
+{
+    CAN_T *can = (CAN_T *)(obj->can);
+    return ((can->ERR)&0xFF);
+}
+
+void can_monitor(can_t *obj, int silent)
+{
+    CAN_EnterTestMode((CAN_T *)(obj->can), CAN_TEST_SILENT_Msk);
+}
+ 
+#endif // DEVICE_CAN

targets/TARGET_NUVOTON/TARGET_M451/device/StdDriver/m451_can.h

@@ -158,7 +158,11 @@ int32_t CAN_SetRxMsg(CAN_T *tCAN, uint32_t u32MsgNum , uint32_t u32IDType, uint3
 int32_t CAN_SetRxMsgAndMsk(CAN_T *tCAN, uint32_t u32MsgNum , uint32_t u32IDType, uint32_t u32ID, uint32_t u32IDMask);
 int32_t CAN_SetTxMsg(CAN_T *tCAN, uint32_t u32MsgNum , STR_CANMSG_T* pCanMsg);
 int32_t CAN_TriggerTxMsg(CAN_T  *tCAN, uint32_t u32MsgNum);
-
+uint32_t CAN_GetCANBitRate(CAN_T  *tCAN);
+void CAN_EnterInitMode(CAN_T *tCAN, uint8_t u8Mask);
+void CAN_LeaveInitMode(CAN_T *tCAN);
+void CAN_EnterTestMode(CAN_T *tCAN, uint8_t u8TestMask);
+void CAN_LeaveTestMode(CAN_T *tCAN);
 
 /*@}*/ /* end of group CAN_EXPORTED_FUNCTIONS */
 

targets/TARGET_NUVOTON/TARGET_NUC472/TARGET_NUMAKER_PFM_NUC472/PeripheralNames.h

@@ -116,10 +116,15 @@ typedef enum {
 } DMAName;
 
 typedef enum {
-    SD_0 = (int) NU_MODNAME(SD_BASE, 0),
-    SD_1 = (int) NU_MODNAME(SD_BASE, 1)
+    SD_0_0 = (int) NU_MODNAME(SD_BASE, 0),
+    SD_0_1 = (int) NU_MODNAME(SD_BASE, 1)
 } SDName;
 
+typedef enum {
+    CAN_0 = (int) NU_MODNAME(CAN0_BASE, 0),
+    CAN_1 = (int) NU_MODNAME(CAN1_BASE, 0)
+} CANName;
+
 #ifdef __cplusplus
 }
 #endif