mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/TARGET_KPSDK_CODE/hal/can/fsl_flexcan_hal.c@149:1fb5f62b92bd, 2014-04-03 (annotated)

Committer:
mbed_official
Date:
Thu Apr 03 11:45:06 2014 +0100
Revision:
149:1fb5f62b92bd
Parent:
targets/hal/TARGET_Freescale/TARGET_KSDK_MCUS/TARGET_KSDK_CODE/hal/can/fsl_flexcan_hal.c@146:f64d43ff0c18
Child:
324:406fd2029f23
Synchronized with git revision 220c0bb39ceee40016e1e86350c058963d01ed42



Full URL: https://github.com/mbedmicro/mbed/commit/220c0bb39ceee40016e1e86350c058963d01ed42/

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 146:f64d43ff0c18 1 /*
mbed_official 146:f64d43ff0c18 2 * Copyright (c) 2013 - 2014, Freescale Semiconductor, Inc.
mbed_official 146:f64d43ff0c18 3 * All rights reserved.
mbed_official 146:f64d43ff0c18 4 *
mbed_official 146:f64d43ff0c18 5 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 146:f64d43ff0c18 6 * are permitted provided that the following conditions are met:
mbed_official 146:f64d43ff0c18 7 *
mbed_official 146:f64d43ff0c18 8 * o Redistributions of source code must retain the above copyright notice, this list
mbed_official 146:f64d43ff0c18 9 * of conditions and the following disclaimer.
mbed_official 146:f64d43ff0c18 10 *
mbed_official 146:f64d43ff0c18 11 * o Redistributions in binary form must reproduce the above copyright notice, this
mbed_official 146:f64d43ff0c18 12 * list of conditions and the following disclaimer in the documentation and/or
mbed_official 146:f64d43ff0c18 13 * other materials provided with the distribution.
mbed_official 146:f64d43ff0c18 14 *
mbed_official 146:f64d43ff0c18 15 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
mbed_official 146:f64d43ff0c18 16 * contributors may be used to endorse or promote products derived from this
mbed_official 146:f64d43ff0c18 17 * software without specific prior written permission.
mbed_official 146:f64d43ff0c18 18 *
mbed_official 146:f64d43ff0c18 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
mbed_official 146:f64d43ff0c18 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
mbed_official 146:f64d43ff0c18 21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 146:f64d43ff0c18 22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
mbed_official 146:f64d43ff0c18 23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
mbed_official 146:f64d43ff0c18 24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
mbed_official 146:f64d43ff0c18 25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
mbed_official 146:f64d43ff0c18 26 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
mbed_official 146:f64d43ff0c18 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
mbed_official 146:f64d43ff0c18 28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 146:f64d43ff0c18 29 */
mbed_official 146:f64d43ff0c18 30 #include "fsl_flexcan_hal.h"
mbed_official 146:f64d43ff0c18 31
mbed_official 146:f64d43ff0c18 32 /*******************************************************************************
mbed_official 146:f64d43ff0c18 33 * Definitions
mbed_official 146:f64d43ff0c18 34 ******************************************************************************/
mbed_official 146:f64d43ff0c18 35
mbed_official 146:f64d43ff0c18 36 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_MASK (0x3FFFFFFFU) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 37 /*! format A extended mask.*/
mbed_official 146:f64d43ff0c18 38 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_SHIFT (1U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 39 /*! format A extended shift.*/
mbed_official 146:f64d43ff0c18 40 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_MASK (0x3FF80000U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 41 /*! format A standard mask.*/
mbed_official 146:f64d43ff0c18 42 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_SHIFT (19U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 43 /*! format A standard shift.*/
mbed_official 146:f64d43ff0c18 44 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK (0x3FFFU) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 45 /*! format B extended mask.*/
mbed_official 146:f64d43ff0c18 46 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT1 (16U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 47 /*! format B extended mask.*/
mbed_official 146:f64d43ff0c18 48 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT2 (0U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 49 /*! format B extended mask.*/
mbed_official 146:f64d43ff0c18 50 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK (0x3FF8U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 51 /*! format B standard mask.*/
mbed_official 146:f64d43ff0c18 52 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT1 (19U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 53 /*! format B standard shift1.*/
mbed_official 146:f64d43ff0c18 54 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT2 (3U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 55 /*! format B standard shift2.*/
mbed_official 146:f64d43ff0c18 56 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK (0xFFU) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 57 /*! format C mask.*/
mbed_official 146:f64d43ff0c18 58 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT1 (24U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 59 /*! format C shift1.*/
mbed_official 146:f64d43ff0c18 60 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT2 (16U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 61 /*! format C shift2.*/
mbed_official 146:f64d43ff0c18 62 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT3 (8U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 63 /*! format C shift3.*/
mbed_official 146:f64d43ff0c18 64 #define FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT4 (0U) /*!< FlexCAN RX FIFO ID filter*/
mbed_official 146:f64d43ff0c18 65 /*! format C shift4.*/
mbed_official 146:f64d43ff0c18 66 #define FLEXCAN_ALL_INT (0x0007U) /*!< Masks for wakeup, error, bus off*/
mbed_official 146:f64d43ff0c18 67 /*! interrupts*/
mbed_official 146:f64d43ff0c18 68 #define FLEXCAN_BYTE_DATA_FIELD_MASK (0xFFU) /*!< Masks for byte data field.*/
mbed_official 146:f64d43ff0c18 69
mbed_official 146:f64d43ff0c18 70 /*******************************************************************************
mbed_official 146:f64d43ff0c18 71 * Code
mbed_official 146:f64d43ff0c18 72 ******************************************************************************/
mbed_official 146:f64d43ff0c18 73
mbed_official 146:f64d43ff0c18 74 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 75 *
mbed_official 146:f64d43ff0c18 76 * Function Name : flexcan_hal_enable
mbed_official 146:f64d43ff0c18 77 * Description : Enable FlexCAN module.
mbed_official 146:f64d43ff0c18 78 * This function will enable FlexCAN module clock.
mbed_official 146:f64d43ff0c18 79 *
mbed_official 146:f64d43ff0c18 80 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 81 flexcan_status_t flexcan_hal_enable(uint8_t instance)
mbed_official 146:f64d43ff0c18 82 {
mbed_official 146:f64d43ff0c18 83 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 84
mbed_official 146:f64d43ff0c18 85 /* Check for low power mode*/
mbed_official 146:f64d43ff0c18 86 if(BR_CAN_MCR_LPMACK(instance))
mbed_official 146:f64d43ff0c18 87 {
mbed_official 146:f64d43ff0c18 88 /* Enable clock*/
mbed_official 146:f64d43ff0c18 89 HW_CAN_MCR_CLR(instance, BM_CAN_MCR_MDIS);
mbed_official 146:f64d43ff0c18 90 /* Wait until enabled*/
mbed_official 146:f64d43ff0c18 91 while (BR_CAN_MCR_LPMACK(instance)){}
mbed_official 146:f64d43ff0c18 92 }
mbed_official 146:f64d43ff0c18 93
mbed_official 146:f64d43ff0c18 94 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 95 }
mbed_official 146:f64d43ff0c18 96
mbed_official 146:f64d43ff0c18 97 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 98 *
mbed_official 146:f64d43ff0c18 99 * Function Name : flexcan_hal_disable
mbed_official 146:f64d43ff0c18 100 * Description : Disable FlexCAN module.
mbed_official 146:f64d43ff0c18 101 * This function will disable FlexCAN module clock.
mbed_official 146:f64d43ff0c18 102 *
mbed_official 146:f64d43ff0c18 103 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 104 flexcan_status_t flexcan_hal_disable(uint8_t instance)
mbed_official 146:f64d43ff0c18 105 {
mbed_official 146:f64d43ff0c18 106 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 107
mbed_official 146:f64d43ff0c18 108 /* To access the memory mapped registers*/
mbed_official 146:f64d43ff0c18 109 /* Entre disable mode (hard reset).*/
mbed_official 146:f64d43ff0c18 110 if(BR_CAN_MCR_MDIS(instance) == 0x0)
mbed_official 146:f64d43ff0c18 111 {
mbed_official 146:f64d43ff0c18 112 /* Clock disable (module)*/
mbed_official 146:f64d43ff0c18 113 HW_CAN_MCR_SET(instance, BM_CAN_MCR_MDIS);
mbed_official 146:f64d43ff0c18 114
mbed_official 146:f64d43ff0c18 115 /* Wait until disable mode acknowledged*/
mbed_official 146:f64d43ff0c18 116 while (!(BR_CAN_MCR_LPMACK(instance))){}
mbed_official 146:f64d43ff0c18 117 }
mbed_official 146:f64d43ff0c18 118
mbed_official 146:f64d43ff0c18 119 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 120 }
mbed_official 146:f64d43ff0c18 121
mbed_official 146:f64d43ff0c18 122 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 123 *
mbed_official 146:f64d43ff0c18 124 * Function Name : flexcan_hal_sw_reset
mbed_official 146:f64d43ff0c18 125 * Description : Reset FlexCAN module.
mbed_official 146:f64d43ff0c18 126 * This function will reset FlexCAN module.
mbed_official 146:f64d43ff0c18 127 *
mbed_official 146:f64d43ff0c18 128 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 129 flexcan_status_t flexcan_hal_sw_reset(uint8_t instance)
mbed_official 146:f64d43ff0c18 130 {
mbed_official 146:f64d43ff0c18 131 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 132
mbed_official 146:f64d43ff0c18 133 /* Check for low power mode*/
mbed_official 146:f64d43ff0c18 134 if (BR_CAN_MCR_LPMACK(instance))
mbed_official 146:f64d43ff0c18 135 {
mbed_official 146:f64d43ff0c18 136 /* Enable clock*/
mbed_official 146:f64d43ff0c18 137 HW_CAN_MCR_CLR(instance, BM_CAN_MCR_MDIS);
mbed_official 146:f64d43ff0c18 138 /* Wait until enabled*/
mbed_official 146:f64d43ff0c18 139 while (BR_CAN_MCR_LPMACK(instance)){}
mbed_official 146:f64d43ff0c18 140 }
mbed_official 146:f64d43ff0c18 141
mbed_official 146:f64d43ff0c18 142 /* Reset the FLEXCAN*/
mbed_official 146:f64d43ff0c18 143 HW_CAN_MCR_SET(instance, BM_CAN_MCR_SOFTRST);
mbed_official 146:f64d43ff0c18 144
mbed_official 146:f64d43ff0c18 145 /* Wait for reset cycle to complete*/
mbed_official 146:f64d43ff0c18 146 while (BR_CAN_MCR_SOFTRST(instance)){}
mbed_official 146:f64d43ff0c18 147
mbed_official 146:f64d43ff0c18 148 /* Set Freeze, Halt*/
mbed_official 146:f64d43ff0c18 149 HW_CAN_MCR_SET(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 150
mbed_official 146:f64d43ff0c18 151 /* check for freeze Ack*/
mbed_official 146:f64d43ff0c18 152 while ((!BR_CAN_MCR_FRZACK(instance)) ||
mbed_official 146:f64d43ff0c18 153 (!BR_CAN_MCR_NOTRDY(instance))){}
mbed_official 146:f64d43ff0c18 154
mbed_official 146:f64d43ff0c18 155 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 156 }
mbed_official 146:f64d43ff0c18 157
mbed_official 146:f64d43ff0c18 158 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 159 *
mbed_official 146:f64d43ff0c18 160 * Function Name : flexcan_hal_select_clk
mbed_official 146:f64d43ff0c18 161 * Description : Select FlexCAN clock source.
mbed_official 146:f64d43ff0c18 162 * This function will select either internal bus clock or external clock as
mbed_official 146:f64d43ff0c18 163 * FlexCAN clock source.
mbed_official 146:f64d43ff0c18 164 *
mbed_official 146:f64d43ff0c18 165 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 166 flexcan_status_t flexcan_hal_select_clk(
mbed_official 146:f64d43ff0c18 167 uint8_t instance,
mbed_official 146:f64d43ff0c18 168 flexcan_clk_source_t clk)
mbed_official 146:f64d43ff0c18 169 {
mbed_official 146:f64d43ff0c18 170 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 171
mbed_official 146:f64d43ff0c18 172 if (clk == kFlexCanClkSource_Ipbus)
mbed_official 146:f64d43ff0c18 173 {
mbed_official 146:f64d43ff0c18 174 /* Internal bus clock (fsys/2)*/
mbed_official 146:f64d43ff0c18 175 HW_CAN_CTRL1_SET(instance, BM_CAN_CTRL1_CLKSRC);
mbed_official 146:f64d43ff0c18 176 }
mbed_official 146:f64d43ff0c18 177 else if (clk == kFlexCanClkSource_Osc)
mbed_official 146:f64d43ff0c18 178 {
mbed_official 146:f64d43ff0c18 179 /* External clock*/
mbed_official 146:f64d43ff0c18 180 HW_CAN_CTRL1_CLR(instance, BM_CAN_CTRL1_CLKSRC);
mbed_official 146:f64d43ff0c18 181 }
mbed_official 146:f64d43ff0c18 182 else
mbed_official 146:f64d43ff0c18 183 {
mbed_official 146:f64d43ff0c18 184 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 185 }
mbed_official 146:f64d43ff0c18 186
mbed_official 146:f64d43ff0c18 187 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 188 }
mbed_official 146:f64d43ff0c18 189
mbed_official 146:f64d43ff0c18 190 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 191 *
mbed_official 146:f64d43ff0c18 192 * Function Name : flexcan_hal_init
mbed_official 146:f64d43ff0c18 193 * Description : Initialize FlexCAN module.
mbed_official 146:f64d43ff0c18 194 * This function will reset FlexCAN module, set maximum number of message
mbed_official 146:f64d43ff0c18 195 * buffers, initialize all message buffers as inactive, enable RX FIFO
mbed_official 146:f64d43ff0c18 196 * if needed, mask all mask bits, and disable all MB interrupts.
mbed_official 146:f64d43ff0c18 197 *
mbed_official 146:f64d43ff0c18 198 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 199 flexcan_status_t flexcan_hal_init(uint8_t instance, const flexcan_user_config_t *data)
mbed_official 146:f64d43ff0c18 200 {
mbed_official 146:f64d43ff0c18 201 uint32_t i;
mbed_official 146:f64d43ff0c18 202 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 203 assert(data);
mbed_official 146:f64d43ff0c18 204
mbed_official 146:f64d43ff0c18 205 volatile CAN_Type *flexcan_reg_ptr;
mbed_official 146:f64d43ff0c18 206 flexcan_reg_ptr = ((CAN_Type *)REGS_CAN_BASE(instance));
mbed_official 146:f64d43ff0c18 207 if (NULL == flexcan_reg_ptr)
mbed_official 146:f64d43ff0c18 208 {
mbed_official 146:f64d43ff0c18 209 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 210 }
mbed_official 146:f64d43ff0c18 211
mbed_official 146:f64d43ff0c18 212 /* Reset FLEXCAN, Halt, freeze mode*/
mbed_official 146:f64d43ff0c18 213 if(flexcan_hal_sw_reset(instance))
mbed_official 146:f64d43ff0c18 214 {
mbed_official 146:f64d43ff0c18 215 return (kStatus_FLEXCAN_Fail);
mbed_official 146:f64d43ff0c18 216 }
mbed_official 146:f64d43ff0c18 217
mbed_official 146:f64d43ff0c18 218 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 219 while(!(BR_CAN_MCR_FRZACK(instance))) {}
mbed_official 146:f64d43ff0c18 220
mbed_official 146:f64d43ff0c18 221 /* Set maximum number of message buffers*/
mbed_official 146:f64d43ff0c18 222 BW_CAN_MCR_MAXMB(instance, data->max_num_mb);
mbed_official 146:f64d43ff0c18 223
mbed_official 146:f64d43ff0c18 224 /* Initialize all message buffers as inactive*/
mbed_official 146:f64d43ff0c18 225 for (i = 0; i < data->max_num_mb; i++)
mbed_official 146:f64d43ff0c18 226 {
mbed_official 146:f64d43ff0c18 227 flexcan_reg_ptr->MB[i].CS = 0x0;
mbed_official 146:f64d43ff0c18 228 flexcan_reg_ptr->MB[i].ID = 0x0;
mbed_official 146:f64d43ff0c18 229 flexcan_reg_ptr->MB[i].WORD0 = 0x0;
mbed_official 146:f64d43ff0c18 230 flexcan_reg_ptr->MB[i].WORD1 = 0x0;
mbed_official 146:f64d43ff0c18 231 }
mbed_official 146:f64d43ff0c18 232
mbed_official 146:f64d43ff0c18 233 /* Enable RX FIFO if need*/
mbed_official 146:f64d43ff0c18 234 if (data->is_rx_fifo_needed)
mbed_official 146:f64d43ff0c18 235 {
mbed_official 146:f64d43ff0c18 236 /* Enable RX FIFO*/
mbed_official 146:f64d43ff0c18 237 HW_CAN_MCR_SET(instance, BM_CAN_MCR_RFEN);
mbed_official 146:f64d43ff0c18 238 /* Set the number of the RX FIFO filters needed*/
mbed_official 146:f64d43ff0c18 239 BW_CAN_CTRL2_RFFN(instance, data->num_id_filters);
mbed_official 146:f64d43ff0c18 240 /* RX FIFO global mask*/
mbed_official 146:f64d43ff0c18 241 HW_CAN_RXFGMASK_WR(instance, CAN_ID_EXT(CAN_RXFGMASK_FGM_MASK));
mbed_official 146:f64d43ff0c18 242 for (i = 0; i < data->max_num_mb; i++)
mbed_official 146:f64d43ff0c18 243 {
mbed_official 146:f64d43ff0c18 244 /* RX individual mask*/
mbed_official 146:f64d43ff0c18 245 HW_CAN_RXIMRn_WR(instance, i, CAN_ID_EXT(CAN_RXIMR_MI_MASK));
mbed_official 146:f64d43ff0c18 246 }
mbed_official 146:f64d43ff0c18 247 }
mbed_official 146:f64d43ff0c18 248
mbed_official 146:f64d43ff0c18 249 /* Rx global mask*/
mbed_official 146:f64d43ff0c18 250 HW_CAN_RXMGMASK_WR(instance, CAN_ID_EXT(CAN_RXMGMASK_MG_MASK));
mbed_official 146:f64d43ff0c18 251
mbed_official 146:f64d43ff0c18 252 /* Rx reg 14 mask*/
mbed_official 146:f64d43ff0c18 253 HW_CAN_RX14MASK_WR(instance, CAN_ID_EXT(CAN_RX14MASK_RX14M_MASK));
mbed_official 146:f64d43ff0c18 254
mbed_official 146:f64d43ff0c18 255 /* Rx reg 15 mask*/
mbed_official 146:f64d43ff0c18 256 HW_CAN_RX15MASK_WR(instance, CAN_ID_EXT(CAN_RX15MASK_RX15M_MASK));
mbed_official 146:f64d43ff0c18 257
mbed_official 146:f64d43ff0c18 258 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 259 HW_CAN_MCR_CLR(instance, BM_CAN_MCR_FRZ);
mbed_official 146:f64d43ff0c18 260
mbed_official 146:f64d43ff0c18 261 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 262 while(BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 263
mbed_official 146:f64d43ff0c18 264 /* Disable all MB interrupts*/
mbed_official 146:f64d43ff0c18 265 HW_CAN_IMASK1_WR(instance, 0x0);
mbed_official 146:f64d43ff0c18 266
mbed_official 146:f64d43ff0c18 267 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 268 }
mbed_official 146:f64d43ff0c18 269
mbed_official 146:f64d43ff0c18 270 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 271 *
mbed_official 146:f64d43ff0c18 272 * Function Name : flexcan_hal_set_time_segments
mbed_official 146:f64d43ff0c18 273 * Description : Set FlexCAN time segments.
mbed_official 146:f64d43ff0c18 274 * This function will set all FlexCAN time segments which define the length of
mbed_official 146:f64d43ff0c18 275 * Propagation Segment in the bit time, the length of Phase Buffer Segment 2 in
mbed_official 146:f64d43ff0c18 276 * the bit time, the length of Phase Buffer Segment 1 in the bit time, the ratio
mbed_official 146:f64d43ff0c18 277 * between the PE clock frequency and the Serial Clock (Sclock) frequency, and
mbed_official 146:f64d43ff0c18 278 * the maximum number of time quanta that a bit time can be changed by one
mbed_official 146:f64d43ff0c18 279 * resynchronization. (One time quantum is equal to the Sclock period.)
mbed_official 146:f64d43ff0c18 280 *
mbed_official 146:f64d43ff0c18 281 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 282 void flexcan_hal_set_time_segments(
mbed_official 146:f64d43ff0c18 283 uint8_t instance,
mbed_official 146:f64d43ff0c18 284 flexcan_time_segment_t *time_seg)
mbed_official 146:f64d43ff0c18 285 {
mbed_official 146:f64d43ff0c18 286 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 287
mbed_official 146:f64d43ff0c18 288 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 289 HW_CAN_MCR_SET(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 290
mbed_official 146:f64d43ff0c18 291 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 292 while(!(BR_CAN_MCR_FRZACK(instance))) {}
mbed_official 146:f64d43ff0c18 293
mbed_official 146:f64d43ff0c18 294 /* Set FlexCAN time segments*/
mbed_official 146:f64d43ff0c18 295 HW_CAN_CTRL1_CLR(instance, (CAN_CTRL1_PROPSEG_MASK | CAN_CTRL1_PSEG2_MASK |
mbed_official 146:f64d43ff0c18 296 CAN_CTRL1_PSEG1_MASK | CAN_CTRL1_PRESDIV_MASK) |
mbed_official 146:f64d43ff0c18 297 CAN_CTRL1_RJW_MASK);
mbed_official 146:f64d43ff0c18 298 HW_CAN_CTRL1_SET(instance, (CAN_CTRL1_PROPSEG(time_seg->propseg) |
mbed_official 146:f64d43ff0c18 299 CAN_CTRL1_PSEG2(time_seg->pseg2) |
mbed_official 146:f64d43ff0c18 300 CAN_CTRL1_PSEG1(time_seg->pseg1) |
mbed_official 146:f64d43ff0c18 301 CAN_CTRL1_PRESDIV(time_seg->pre_divider) |
mbed_official 146:f64d43ff0c18 302 CAN_CTRL1_RJW(time_seg->rjw)));
mbed_official 146:f64d43ff0c18 303
mbed_official 146:f64d43ff0c18 304 /* De-assert Freeze mode*/
mbed_official 146:f64d43ff0c18 305 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 306 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 307 while(BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 308 }
mbed_official 146:f64d43ff0c18 309
mbed_official 146:f64d43ff0c18 310 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 311 *
mbed_official 146:f64d43ff0c18 312 * Function Name : flexcan_hal_get_time_segments
mbed_official 146:f64d43ff0c18 313 * Description : Get FlexCAN time segments.
mbed_official 146:f64d43ff0c18 314 * This function will get all FlexCAN time segments defined.
mbed_official 146:f64d43ff0c18 315 *
mbed_official 146:f64d43ff0c18 316 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 317 void flexcan_hal_get_time_segments(
mbed_official 146:f64d43ff0c18 318 uint8_t instance,
mbed_official 146:f64d43ff0c18 319 flexcan_time_segment_t *time_seg)
mbed_official 146:f64d43ff0c18 320 {
mbed_official 146:f64d43ff0c18 321 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 322
mbed_official 146:f64d43ff0c18 323 time_seg->pre_divider = BR_CAN_CTRL1_PRESDIV(instance);
mbed_official 146:f64d43ff0c18 324 time_seg->propseg = BR_CAN_CTRL1_PROPSEG(instance);
mbed_official 146:f64d43ff0c18 325 time_seg->pseg1 = BR_CAN_CTRL1_PSEG1(instance);
mbed_official 146:f64d43ff0c18 326 time_seg->pseg2 = BR_CAN_CTRL1_PSEG2(instance);
mbed_official 146:f64d43ff0c18 327 time_seg->rjw = BR_CAN_CTRL1_RJW(instance);
mbed_official 146:f64d43ff0c18 328 }
mbed_official 146:f64d43ff0c18 329
mbed_official 146:f64d43ff0c18 330 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 331 *
mbed_official 146:f64d43ff0c18 332 * Function Name : flexcan_hal_set_mb_tx
mbed_official 146:f64d43ff0c18 333 * Description : Configure a message buffer for transmission.
mbed_official 146:f64d43ff0c18 334 * This function will first check if RX FIFO is enabled. If RX FIFO is enabled,
mbed_official 146:f64d43ff0c18 335 * the function will make sure if the MB requested is not occupied by RX FIFO
mbed_official 146:f64d43ff0c18 336 * and ID filter table. Then this function will copy user's buffer into the
mbed_official 146:f64d43ff0c18 337 * message buffer data area and configure the message buffer as required for
mbed_official 146:f64d43ff0c18 338 * transmission.
mbed_official 146:f64d43ff0c18 339 *
mbed_official 146:f64d43ff0c18 340 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 341 flexcan_status_t flexcan_hal_set_mb_tx(
mbed_official 146:f64d43ff0c18 342 uint8_t instance,
mbed_official 146:f64d43ff0c18 343 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 344 uint32_t mb_idx,
mbed_official 146:f64d43ff0c18 345 flexcan_mb_code_status_tx_t *cs,
mbed_official 146:f64d43ff0c18 346 uint32_t msg_id,
mbed_official 146:f64d43ff0c18 347 uint8_t *mb_data)
mbed_official 146:f64d43ff0c18 348 {
mbed_official 146:f64d43ff0c18 349 uint32_t i;
mbed_official 146:f64d43ff0c18 350 uint32_t val1, val2 = 1, temp, temp1;
mbed_official 146:f64d43ff0c18 351 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 352 assert(data);
mbed_official 146:f64d43ff0c18 353
mbed_official 146:f64d43ff0c18 354 volatile CAN_Type *flexcan_reg_ptr;
mbed_official 146:f64d43ff0c18 355
mbed_official 146:f64d43ff0c18 356 flexcan_reg_ptr = ((CAN_Type *)REGS_CAN_BASE(instance));
mbed_official 146:f64d43ff0c18 357 if (NULL == flexcan_reg_ptr)
mbed_official 146:f64d43ff0c18 358 {
mbed_official 146:f64d43ff0c18 359 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 360 }
mbed_official 146:f64d43ff0c18 361
mbed_official 146:f64d43ff0c18 362 if (data->num_mb > data->max_num_mb)
mbed_official 146:f64d43ff0c18 363 {
mbed_official 146:f64d43ff0c18 364 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 365 }
mbed_official 146:f64d43ff0c18 366
mbed_official 146:f64d43ff0c18 367 if (mb_idx >= data->max_num_mb)
mbed_official 146:f64d43ff0c18 368 {
mbed_official 146:f64d43ff0c18 369 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 370 }
mbed_official 146:f64d43ff0c18 371
mbed_official 146:f64d43ff0c18 372 /* Check if RX FIFO is enabled*/
mbed_official 146:f64d43ff0c18 373 if (BR_CAN_MCR_RFEN(instance))
mbed_official 146:f64d43ff0c18 374 {
mbed_official 146:f64d43ff0c18 375 /* Get the number of RX FIFO Filters*/
mbed_official 146:f64d43ff0c18 376 val1 = (BR_CAN_CTRL2_RFFN(instance));
mbed_official 146:f64d43ff0c18 377 /* Get the number if MBs occupied by RX FIFO and ID filter table*/
mbed_official 146:f64d43ff0c18 378 /* the Rx FIFO occupies the memory space originally reserved for MB0-5*/
mbed_official 146:f64d43ff0c18 379 /* Every number of RFFN means 8 number of RX FIFO filters*/
mbed_official 146:f64d43ff0c18 380 /* and every 4 number of RX FIFO filters occupied one MB*/
mbed_official 146:f64d43ff0c18 381 val2 = 6 + (val1 + 1) * 8 / 4;
mbed_official 146:f64d43ff0c18 382
mbed_official 146:f64d43ff0c18 383 if (mb_idx <= (val2 - 1))
mbed_official 146:f64d43ff0c18 384 {
mbed_official 146:f64d43ff0c18 385 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 386 }
mbed_official 146:f64d43ff0c18 387 }
mbed_official 146:f64d43ff0c18 388
mbed_official 146:f64d43ff0c18 389 /* Copy user's buffer into the message buffer data area*/
mbed_official 146:f64d43ff0c18 390 if (mb_data != NULL)
mbed_official 146:f64d43ff0c18 391 {
mbed_official 146:f64d43ff0c18 392 flexcan_reg_ptr->MB[mb_idx].WORD0 = 0x0;
mbed_official 146:f64d43ff0c18 393 flexcan_reg_ptr->MB[mb_idx].WORD1 = 0x0;
mbed_official 146:f64d43ff0c18 394
mbed_official 146:f64d43ff0c18 395 for ( i=0 ; i < cs->data_length ; i++ )
mbed_official 146:f64d43ff0c18 396 {
mbed_official 146:f64d43ff0c18 397 temp1 = (*(mb_data + i));
mbed_official 146:f64d43ff0c18 398 if (i < 4)
mbed_official 146:f64d43ff0c18 399 {
mbed_official 146:f64d43ff0c18 400 temp = temp1 << ((3 - i) * 8);
mbed_official 146:f64d43ff0c18 401 flexcan_reg_ptr->MB[mb_idx].WORD0 |= temp;
mbed_official 146:f64d43ff0c18 402 }
mbed_official 146:f64d43ff0c18 403 else
mbed_official 146:f64d43ff0c18 404 {
mbed_official 146:f64d43ff0c18 405 temp = temp1 << ((7 - i) * 8);
mbed_official 146:f64d43ff0c18 406 flexcan_reg_ptr->MB[mb_idx].WORD1 |= temp;
mbed_official 146:f64d43ff0c18 407 }
mbed_official 146:f64d43ff0c18 408 }
mbed_official 146:f64d43ff0c18 409 }
mbed_official 146:f64d43ff0c18 410
mbed_official 146:f64d43ff0c18 411 /* Set the ID according the format structure*/
mbed_official 146:f64d43ff0c18 412 if (cs->msg_id_type == kFlexCanMbId_Ext)
mbed_official 146:f64d43ff0c18 413 {
mbed_official 146:f64d43ff0c18 414 /* ID [28-0]*/
mbed_official 146:f64d43ff0c18 415 flexcan_reg_ptr->MB[mb_idx].ID &= ~(CAN_ID_STD_MASK | CAN_ID_EXT_MASK);
mbed_official 146:f64d43ff0c18 416 flexcan_reg_ptr->MB[mb_idx].ID |= (msg_id & (CAN_ID_STD_MASK | CAN_ID_EXT_MASK));
mbed_official 146:f64d43ff0c18 417
mbed_official 146:f64d43ff0c18 418 /* Set IDE*/
mbed_official 146:f64d43ff0c18 419 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_IDE_MASK;
mbed_official 146:f64d43ff0c18 420
mbed_official 146:f64d43ff0c18 421 /* Clear SRR bit*/
mbed_official 146:f64d43ff0c18 422 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_SRR_MASK;
mbed_official 146:f64d43ff0c18 423
mbed_official 146:f64d43ff0c18 424 /* Set the length of data in bytes*/
mbed_official 146:f64d43ff0c18 425 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_DLC_MASK;
mbed_official 146:f64d43ff0c18 426 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_DLC(cs->data_length);
mbed_official 146:f64d43ff0c18 427
mbed_official 146:f64d43ff0c18 428 /* Set MB CODE*/
mbed_official 146:f64d43ff0c18 429 /* Reset the code*/
mbed_official 146:f64d43ff0c18 430 if (cs->code != kFlexCanTX_NotUsed)
mbed_official 146:f64d43ff0c18 431 {
mbed_official 146:f64d43ff0c18 432 if (cs->code == kFlexCanTX_Remote)
mbed_official 146:f64d43ff0c18 433 {
mbed_official 146:f64d43ff0c18 434 /* Set RTR bit*/
mbed_official 146:f64d43ff0c18 435 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_RTR_MASK;
mbed_official 146:f64d43ff0c18 436 cs->code = kFlexCanTX_Data;
mbed_official 146:f64d43ff0c18 437 }
mbed_official 146:f64d43ff0c18 438
mbed_official 146:f64d43ff0c18 439 /* Reset the code*/
mbed_official 146:f64d43ff0c18 440 flexcan_reg_ptr->MB[mb_idx].CS &= ~(CAN_CS_CODE_MASK);
mbed_official 146:f64d43ff0c18 441
mbed_official 146:f64d43ff0c18 442 /* Activating message buffer*/
mbed_official 146:f64d43ff0c18 443 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_CODE(cs->code);
mbed_official 146:f64d43ff0c18 444 }
mbed_official 146:f64d43ff0c18 445 }
mbed_official 146:f64d43ff0c18 446 else if(cs->msg_id_type == kFlexCanMbId_Std)
mbed_official 146:f64d43ff0c18 447 {
mbed_official 146:f64d43ff0c18 448 /* ID[28-18]*/
mbed_official 146:f64d43ff0c18 449 flexcan_reg_ptr->MB[mb_idx].ID &= ~CAN_ID_STD_MASK;
mbed_official 146:f64d43ff0c18 450 flexcan_reg_ptr->MB[mb_idx].ID |= CAN_ID_STD(msg_id);
mbed_official 146:f64d43ff0c18 451
mbed_official 146:f64d43ff0c18 452 /* make sure IDE and SRR are not set*/
mbed_official 146:f64d43ff0c18 453 flexcan_reg_ptr->MB[mb_idx].CS &= ~(CAN_CS_IDE_MASK | CAN_CS_SRR_MASK);
mbed_official 146:f64d43ff0c18 454
mbed_official 146:f64d43ff0c18 455 /* Set the length of data in bytes*/
mbed_official 146:f64d43ff0c18 456 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_DLC_MASK;
mbed_official 146:f64d43ff0c18 457 flexcan_reg_ptr->MB[mb_idx].CS |= (cs->data_length) << CAN_CS_DLC_SHIFT;
mbed_official 146:f64d43ff0c18 458
mbed_official 146:f64d43ff0c18 459 /* Set MB CODE*/
mbed_official 146:f64d43ff0c18 460 if (cs->code != kFlexCanTX_NotUsed)
mbed_official 146:f64d43ff0c18 461 {
mbed_official 146:f64d43ff0c18 462 if (cs->code == kFlexCanTX_Remote)
mbed_official 146:f64d43ff0c18 463 {
mbed_official 146:f64d43ff0c18 464 /* Set RTR bit*/
mbed_official 146:f64d43ff0c18 465 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_RTR_MASK;
mbed_official 146:f64d43ff0c18 466 cs->code = kFlexCanTX_Data;
mbed_official 146:f64d43ff0c18 467 }
mbed_official 146:f64d43ff0c18 468
mbed_official 146:f64d43ff0c18 469 /* Reset the code*/
mbed_official 146:f64d43ff0c18 470 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_CODE_MASK;
mbed_official 146:f64d43ff0c18 471
mbed_official 146:f64d43ff0c18 472 /* Set the code*/
mbed_official 146:f64d43ff0c18 473 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_CODE(cs->code);
mbed_official 146:f64d43ff0c18 474 }
mbed_official 146:f64d43ff0c18 475 }
mbed_official 146:f64d43ff0c18 476 else
mbed_official 146:f64d43ff0c18 477 {
mbed_official 146:f64d43ff0c18 478 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 479 }
mbed_official 146:f64d43ff0c18 480
mbed_official 146:f64d43ff0c18 481 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 482 }
mbed_official 146:f64d43ff0c18 483
mbed_official 146:f64d43ff0c18 484 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 485 *
mbed_official 146:f64d43ff0c18 486 * Function Name : flexcan_hal_set_mb_rx
mbed_official 146:f64d43ff0c18 487 * Description : Configure a message buffer for receiving.
mbed_official 146:f64d43ff0c18 488 * This function will first check if RX FIFO is enabled. If RX FIFO is enabled,
mbed_official 146:f64d43ff0c18 489 * the function will make sure if the MB requested is not occupied by RX FIFO
mbed_official 146:f64d43ff0c18 490 * and ID filter table. Then this function will configure the message buffer as
mbed_official 146:f64d43ff0c18 491 * required for receiving.
mbed_official 146:f64d43ff0c18 492 *
mbed_official 146:f64d43ff0c18 493 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 494 flexcan_status_t flexcan_hal_set_mb_rx(
mbed_official 146:f64d43ff0c18 495 uint8_t instance,
mbed_official 146:f64d43ff0c18 496 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 497 uint32_t mb_idx,
mbed_official 146:f64d43ff0c18 498 flexcan_mb_code_status_rx_t *cs,
mbed_official 146:f64d43ff0c18 499 uint32_t msg_id)
mbed_official 146:f64d43ff0c18 500 {
mbed_official 146:f64d43ff0c18 501 uint32_t val1, val2 = 1;
mbed_official 146:f64d43ff0c18 502 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 503 assert(data);
mbed_official 146:f64d43ff0c18 504
mbed_official 146:f64d43ff0c18 505 volatile CAN_Type *flexcan_reg_ptr;
mbed_official 146:f64d43ff0c18 506
mbed_official 146:f64d43ff0c18 507 flexcan_reg_ptr = ((CAN_Type *)REGS_CAN_BASE(instance));
mbed_official 146:f64d43ff0c18 508 if (NULL == flexcan_reg_ptr)
mbed_official 146:f64d43ff0c18 509 {
mbed_official 146:f64d43ff0c18 510 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 511 }
mbed_official 146:f64d43ff0c18 512
mbed_official 146:f64d43ff0c18 513 if (data->num_mb > data->max_num_mb)
mbed_official 146:f64d43ff0c18 514 {
mbed_official 146:f64d43ff0c18 515 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 516 }
mbed_official 146:f64d43ff0c18 517
mbed_official 146:f64d43ff0c18 518 if (mb_idx >= data->num_mb)
mbed_official 146:f64d43ff0c18 519 {
mbed_official 146:f64d43ff0c18 520 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 521 }
mbed_official 146:f64d43ff0c18 522
mbed_official 146:f64d43ff0c18 523 /* Check if RX FIFO is enabled*/
mbed_official 146:f64d43ff0c18 524 if (BR_CAN_MCR_RFEN(instance))
mbed_official 146:f64d43ff0c18 525 {
mbed_official 146:f64d43ff0c18 526 /* Get the number of RX FIFO Filters*/
mbed_official 146:f64d43ff0c18 527 val1 = BR_CAN_CTRL2_RFFN(instance);
mbed_official 146:f64d43ff0c18 528 /* Get the number if MBs occupied by RX FIFO and ID filter table*/
mbed_official 146:f64d43ff0c18 529 /* the Rx FIFO occupies the memory space originally reserved for MB0-5*/
mbed_official 146:f64d43ff0c18 530 /* Every number of RFFN means 8 number of RX FIFO filters*/
mbed_official 146:f64d43ff0c18 531 /* and every 4 number of RX FIFO filters occupied one MB*/
mbed_official 146:f64d43ff0c18 532 val2 = 6 + (val1 + 1) * 8 / 4;
mbed_official 146:f64d43ff0c18 533
mbed_official 146:f64d43ff0c18 534 if (mb_idx <= (val2 - 1))
mbed_official 146:f64d43ff0c18 535 {
mbed_official 146:f64d43ff0c18 536 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 537 }
mbed_official 146:f64d43ff0c18 538 }
mbed_official 146:f64d43ff0c18 539
mbed_official 146:f64d43ff0c18 540 /* Set the ID according the format structure*/
mbed_official 146:f64d43ff0c18 541 if (cs->msg_id_type == kFlexCanMbId_Ext)
mbed_official 146:f64d43ff0c18 542 {
mbed_official 146:f64d43ff0c18 543 /* Set IDE*/
mbed_official 146:f64d43ff0c18 544 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_IDE_MASK;
mbed_official 146:f64d43ff0c18 545
mbed_official 146:f64d43ff0c18 546 /* Clear SRR bit*/
mbed_official 146:f64d43ff0c18 547 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_SRR_MASK;
mbed_official 146:f64d43ff0c18 548
mbed_official 146:f64d43ff0c18 549 /* Set the length of data in bytes*/
mbed_official 146:f64d43ff0c18 550 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_DLC_MASK;
mbed_official 146:f64d43ff0c18 551 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_DLC(cs->data_length);
mbed_official 146:f64d43ff0c18 552
mbed_official 146:f64d43ff0c18 553 /* ID [28-0]*/
mbed_official 146:f64d43ff0c18 554 flexcan_reg_ptr->MB[mb_idx].ID &= ~(CAN_ID_STD_MASK | CAN_ID_EXT_MASK);
mbed_official 146:f64d43ff0c18 555 flexcan_reg_ptr->MB[mb_idx].ID |= (msg_id & (CAN_ID_STD_MASK | CAN_ID_EXT_MASK));
mbed_official 146:f64d43ff0c18 556
mbed_official 146:f64d43ff0c18 557 /* Set MB CODE*/
mbed_official 146:f64d43ff0c18 558 if (cs->code != kFlexCanRX_NotUsed)
mbed_official 146:f64d43ff0c18 559 {
mbed_official 146:f64d43ff0c18 560 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_CODE_MASK;
mbed_official 146:f64d43ff0c18 561 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_CODE(cs->code);
mbed_official 146:f64d43ff0c18 562 }
mbed_official 146:f64d43ff0c18 563 }
mbed_official 146:f64d43ff0c18 564 else if(cs->msg_id_type == kFlexCanMbId_Std)
mbed_official 146:f64d43ff0c18 565 {
mbed_official 146:f64d43ff0c18 566 /* Make sure IDE and SRR are not set*/
mbed_official 146:f64d43ff0c18 567 flexcan_reg_ptr->MB[mb_idx].CS &= ~(CAN_CS_IDE_MASK | CAN_CS_SRR_MASK);
mbed_official 146:f64d43ff0c18 568
mbed_official 146:f64d43ff0c18 569 /* Set the length of data in bytes*/
mbed_official 146:f64d43ff0c18 570 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_DLC_MASK;
mbed_official 146:f64d43ff0c18 571 flexcan_reg_ptr->MB[mb_idx].CS |= (cs->data_length) << CAN_CS_DLC_SHIFT;
mbed_official 146:f64d43ff0c18 572
mbed_official 146:f64d43ff0c18 573 /* ID[28-18]*/
mbed_official 146:f64d43ff0c18 574 flexcan_reg_ptr->MB[mb_idx].ID &= ~CAN_ID_STD_MASK;
mbed_official 146:f64d43ff0c18 575 flexcan_reg_ptr->MB[mb_idx].ID |= CAN_ID_STD(msg_id);
mbed_official 146:f64d43ff0c18 576
mbed_official 146:f64d43ff0c18 577 /* Set MB CODE*/
mbed_official 146:f64d43ff0c18 578 if (cs->code != kFlexCanRX_NotUsed)
mbed_official 146:f64d43ff0c18 579 {
mbed_official 146:f64d43ff0c18 580 flexcan_reg_ptr->MB[mb_idx].CS &= ~CAN_CS_CODE_MASK;
mbed_official 146:f64d43ff0c18 581 flexcan_reg_ptr->MB[mb_idx].CS |= CAN_CS_CODE(cs->code);
mbed_official 146:f64d43ff0c18 582 }
mbed_official 146:f64d43ff0c18 583 }
mbed_official 146:f64d43ff0c18 584 else
mbed_official 146:f64d43ff0c18 585 {
mbed_official 146:f64d43ff0c18 586 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 587 }
mbed_official 146:f64d43ff0c18 588
mbed_official 146:f64d43ff0c18 589 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 590 }
mbed_official 146:f64d43ff0c18 591
mbed_official 146:f64d43ff0c18 592 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 593 *
mbed_official 146:f64d43ff0c18 594 * Function Name : flexcan_hal_get_mb
mbed_official 146:f64d43ff0c18 595 * Description : Get a message buffer field values.
mbed_official 146:f64d43ff0c18 596 * This function will first check if RX FIFO is enabled. If RX FIFO is enabled,
mbed_official 146:f64d43ff0c18 597 * the function will make sure if the MB requested is not occupied by RX FIFO
mbed_official 146:f64d43ff0c18 598 * and ID filter table. Then this function will get the message buffer field
mbed_official 146:f64d43ff0c18 599 * values and copy the MB data field into user's buffer.
mbed_official 146:f64d43ff0c18 600 *
mbed_official 146:f64d43ff0c18 601 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 602 flexcan_status_t flexcan_hal_get_mb(
mbed_official 146:f64d43ff0c18 603 uint8_t instance,
mbed_official 146:f64d43ff0c18 604 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 605 uint32_t mb_idx,
mbed_official 146:f64d43ff0c18 606 flexcan_mb_t *mb)
mbed_official 146:f64d43ff0c18 607 {
mbed_official 146:f64d43ff0c18 608 uint32_t i;
mbed_official 146:f64d43ff0c18 609 uint32_t val1, val2 = 1;
mbed_official 146:f64d43ff0c18 610 volatile CAN_Type *flexcan_reg_ptr;
mbed_official 146:f64d43ff0c18 611 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 612 assert(data);
mbed_official 146:f64d43ff0c18 613
mbed_official 146:f64d43ff0c18 614 flexcan_reg_ptr = ((CAN_Type *)REGS_CAN_BASE(instance));
mbed_official 146:f64d43ff0c18 615 if (NULL == flexcan_reg_ptr)
mbed_official 146:f64d43ff0c18 616 {
mbed_official 146:f64d43ff0c18 617 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 618 }
mbed_official 146:f64d43ff0c18 619
mbed_official 146:f64d43ff0c18 620 if (mb_idx >= data->max_num_mb)
mbed_official 146:f64d43ff0c18 621 {
mbed_official 146:f64d43ff0c18 622 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 623 }
mbed_official 146:f64d43ff0c18 624
mbed_official 146:f64d43ff0c18 625 /* Check if RX FIFO is enabled*/
mbed_official 146:f64d43ff0c18 626 if (BR_CAN_MCR_RFEN(instance))
mbed_official 146:f64d43ff0c18 627 {
mbed_official 146:f64d43ff0c18 628 /* Get the number of RX FIFO Filters*/
mbed_official 146:f64d43ff0c18 629 val1 = BR_CAN_CTRL2_RFFN(instance);
mbed_official 146:f64d43ff0c18 630 /* Get the number if MBs occupied by RX FIFO and ID filter table*/
mbed_official 146:f64d43ff0c18 631 /* the Rx FIFO occupies the memory space originally reserved for MB0-5*/
mbed_official 146:f64d43ff0c18 632 /* Every number of RFFN means 8 number of RX FIFO filters*/
mbed_official 146:f64d43ff0c18 633 /* and every 4 number of RX FIFO filters occupied one MB*/
mbed_official 146:f64d43ff0c18 634 val2 = 6 + (val1 + 1) * 8 / 4;
mbed_official 146:f64d43ff0c18 635
mbed_official 146:f64d43ff0c18 636 if (mb_idx <= (val2 - 1))
mbed_official 146:f64d43ff0c18 637 {
mbed_official 146:f64d43ff0c18 638 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 639 }
mbed_official 146:f64d43ff0c18 640 }
mbed_official 146:f64d43ff0c18 641
mbed_official 146:f64d43ff0c18 642 /* Get a MB field values*/
mbed_official 146:f64d43ff0c18 643 mb->cs = flexcan_reg_ptr->MB[mb_idx].CS;
mbed_official 146:f64d43ff0c18 644 if ((mb->cs) & CAN_CS_IDE_MASK)
mbed_official 146:f64d43ff0c18 645 {
mbed_official 146:f64d43ff0c18 646 mb->msg_id = flexcan_reg_ptr->MB[mb_idx].ID;
mbed_official 146:f64d43ff0c18 647 }
mbed_official 146:f64d43ff0c18 648 else
mbed_official 146:f64d43ff0c18 649 {
mbed_official 146:f64d43ff0c18 650 mb->msg_id = (flexcan_reg_ptr->MB[mb_idx].ID) >> CAN_ID_STD_SHIFT;
mbed_official 146:f64d43ff0c18 651 }
mbed_official 146:f64d43ff0c18 652
mbed_official 146:f64d43ff0c18 653 /* Copy MB data field into user's buffer*/
mbed_official 146:f64d43ff0c18 654 for (i=0 ; i < kFlexCanMessageSize ; i++)
mbed_official 146:f64d43ff0c18 655 {
mbed_official 146:f64d43ff0c18 656 if (i < 4)
mbed_official 146:f64d43ff0c18 657 {
mbed_official 146:f64d43ff0c18 658 mb->data[3 - i] = ((flexcan_reg_ptr->MB[mb_idx].WORD0) >> (i * 8)) &
mbed_official 146:f64d43ff0c18 659 FLEXCAN_BYTE_DATA_FIELD_MASK;
mbed_official 146:f64d43ff0c18 660 }
mbed_official 146:f64d43ff0c18 661 else
mbed_official 146:f64d43ff0c18 662 {
mbed_official 146:f64d43ff0c18 663 mb->data[11 - i] = ((flexcan_reg_ptr->MB[mb_idx].WORD1) >> ((i - 4) * 8)) &
mbed_official 146:f64d43ff0c18 664 FLEXCAN_BYTE_DATA_FIELD_MASK;
mbed_official 146:f64d43ff0c18 665 }
mbed_official 146:f64d43ff0c18 666 }
mbed_official 146:f64d43ff0c18 667
mbed_official 146:f64d43ff0c18 668 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 669 }
mbed_official 146:f64d43ff0c18 670
mbed_official 146:f64d43ff0c18 671 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 672 *
mbed_official 146:f64d43ff0c18 673 * Function Name : flexcan_hal_lock_rx_mb
mbed_official 146:f64d43ff0c18 674 * Description : Lock the RX message buffer.
mbed_official 146:f64d43ff0c18 675 * This function will the RX message buffer.
mbed_official 146:f64d43ff0c18 676 *
mbed_official 146:f64d43ff0c18 677 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 678 flexcan_status_t flexcan_hal_lock_rx_mb(
mbed_official 146:f64d43ff0c18 679 uint8_t instance,
mbed_official 146:f64d43ff0c18 680 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 681 uint32_t mb_idx)
mbed_official 146:f64d43ff0c18 682 {
mbed_official 146:f64d43ff0c18 683 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 684 assert(data);
mbed_official 146:f64d43ff0c18 685
mbed_official 146:f64d43ff0c18 686 volatile CAN_Type *flexcan_reg_ptr;
mbed_official 146:f64d43ff0c18 687
mbed_official 146:f64d43ff0c18 688 flexcan_reg_ptr = ((CAN_Type *)REGS_CAN_BASE(instance));
mbed_official 146:f64d43ff0c18 689 if (NULL == flexcan_reg_ptr)
mbed_official 146:f64d43ff0c18 690 {
mbed_official 146:f64d43ff0c18 691 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 692 }
mbed_official 146:f64d43ff0c18 693
mbed_official 146:f64d43ff0c18 694 if (mb_idx >= data->max_num_mb)
mbed_official 146:f64d43ff0c18 695 {
mbed_official 146:f64d43ff0c18 696 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 697 }
mbed_official 146:f64d43ff0c18 698
mbed_official 146:f64d43ff0c18 699 /* Lock the mailbox*/
mbed_official 146:f64d43ff0c18 700 flexcan_reg_ptr->MB[mb_idx].CS;
mbed_official 146:f64d43ff0c18 701
mbed_official 146:f64d43ff0c18 702 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 703 }
mbed_official 146:f64d43ff0c18 704
mbed_official 146:f64d43ff0c18 705 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 706 *
mbed_official 146:f64d43ff0c18 707 * Function Name : flexcan_hal_enable_rx_fifo
mbed_official 146:f64d43ff0c18 708 * Description : Enable Rx FIFO feature.
mbed_official 146:f64d43ff0c18 709 * This function will enable the Rx FIFO feature.
mbed_official 146:f64d43ff0c18 710 *
mbed_official 146:f64d43ff0c18 711 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 712 void flexcan_hal_enable_rx_fifo(uint8_t instance)
mbed_official 146:f64d43ff0c18 713 {
mbed_official 146:f64d43ff0c18 714 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 715
mbed_official 146:f64d43ff0c18 716 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 717 HW_CAN_MCR_SET(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 718
mbed_official 146:f64d43ff0c18 719 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 720 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 721
mbed_official 146:f64d43ff0c18 722 /* Enable RX FIFO*/
mbed_official 146:f64d43ff0c18 723 HW_CAN_MCR_SET(instance, BM_CAN_MCR_RFEN);
mbed_official 146:f64d43ff0c18 724
mbed_official 146:f64d43ff0c18 725 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 726 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 727
mbed_official 146:f64d43ff0c18 728 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 729 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 730 }
mbed_official 146:f64d43ff0c18 731
mbed_official 146:f64d43ff0c18 732 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 733 *
mbed_official 146:f64d43ff0c18 734 * Function Name : flexcan_hal_disable_rx_fifo
mbed_official 146:f64d43ff0c18 735 * Description : Disable Rx FIFO feature.
mbed_official 146:f64d43ff0c18 736 * This function will disable the Rx FIFO feature.
mbed_official 146:f64d43ff0c18 737 *
mbed_official 146:f64d43ff0c18 738 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 739 void flexcan_hal_disable_rx_fifo(uint8_t instance)
mbed_official 146:f64d43ff0c18 740 {
mbed_official 146:f64d43ff0c18 741 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 742
mbed_official 146:f64d43ff0c18 743 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 744 HW_CAN_MCR_SET(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 745
mbed_official 146:f64d43ff0c18 746 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 747 while(!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 748
mbed_official 146:f64d43ff0c18 749 /* Disable RX FIFO*/
mbed_official 146:f64d43ff0c18 750 HW_CAN_MCR_CLR(instance, BM_CAN_MCR_RFEN);
mbed_official 146:f64d43ff0c18 751
mbed_official 146:f64d43ff0c18 752 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 753 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 754
mbed_official 146:f64d43ff0c18 755 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 756 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 757 }
mbed_official 146:f64d43ff0c18 758
mbed_official 146:f64d43ff0c18 759 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 760 *
mbed_official 146:f64d43ff0c18 761 * Function Name : flexcan_hal_set_rx_fifo_filters_number
mbed_official 146:f64d43ff0c18 762 * Description : Set the number of Rx FIFO filters.
mbed_official 146:f64d43ff0c18 763 * This function will define the number of Rx FIFO filters.
mbed_official 146:f64d43ff0c18 764 *
mbed_official 146:f64d43ff0c18 765 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 766 void flexcan_hal_set_rx_fifo_filters_number(
mbed_official 146:f64d43ff0c18 767 uint8_t instance,
mbed_official 146:f64d43ff0c18 768 uint32_t number)
mbed_official 146:f64d43ff0c18 769 {
mbed_official 146:f64d43ff0c18 770 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 771
mbed_official 146:f64d43ff0c18 772 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 773 HW_CAN_MCR_SET(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 774
mbed_official 146:f64d43ff0c18 775 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 776 while(!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 777
mbed_official 146:f64d43ff0c18 778 /* Set the number of RX FIFO ID filters*/
mbed_official 146:f64d43ff0c18 779 BW_CAN_CTRL2_RFFN(instance, number);
mbed_official 146:f64d43ff0c18 780
mbed_official 146:f64d43ff0c18 781 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 782 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 783
mbed_official 146:f64d43ff0c18 784 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 785 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 786 }
mbed_official 146:f64d43ff0c18 787
mbed_official 146:f64d43ff0c18 788 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 789 *
mbed_official 146:f64d43ff0c18 790 * Function Name : flexcan_hal_set_max_mb_number
mbed_official 146:f64d43ff0c18 791 * Description : Set the number of the last Message Buffers.
mbed_official 146:f64d43ff0c18 792 * This function will define the number of the last Message Buffers
mbed_official 146:f64d43ff0c18 793 *
mbed_official 146:f64d43ff0c18 794 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 795 void flexcan_hal_set_max_mb_number(
mbed_official 146:f64d43ff0c18 796 uint8_t instance,
mbed_official 146:f64d43ff0c18 797 const flexcan_user_config_t *data)
mbed_official 146:f64d43ff0c18 798 {
mbed_official 146:f64d43ff0c18 799 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 800 assert(data);
mbed_official 146:f64d43ff0c18 801
mbed_official 146:f64d43ff0c18 802 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 803 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 804
mbed_official 146:f64d43ff0c18 805 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 806 while(!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 807
mbed_official 146:f64d43ff0c18 808 /* Set the maximum number of MBs*/
mbed_official 146:f64d43ff0c18 809 BW_CAN_MCR_MAXMB(instance, data->max_num_mb);
mbed_official 146:f64d43ff0c18 810
mbed_official 146:f64d43ff0c18 811 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 812 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 813
mbed_official 146:f64d43ff0c18 814 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 815 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 816 }
mbed_official 146:f64d43ff0c18 817
mbed_official 146:f64d43ff0c18 818 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 819 *
mbed_official 146:f64d43ff0c18 820 * Function Name : flexcan_hal_set_id_filter_table_elements
mbed_official 146:f64d43ff0c18 821 * Description : Set ID filter table elements.
mbed_official 146:f64d43ff0c18 822 * This function will set up ID filter table elements.
mbed_official 146:f64d43ff0c18 823 *
mbed_official 146:f64d43ff0c18 824 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 825 flexcan_status_t flexcan_hal_set_id_filter_table_elements(
mbed_official 146:f64d43ff0c18 826 uint8_t instance,
mbed_official 146:f64d43ff0c18 827 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 828 flexcan_rx_fifo_id_element_format_t id_format,
mbed_official 146:f64d43ff0c18 829 flexcan_id_table_t *id_filter_table)
mbed_official 146:f64d43ff0c18 830 {
mbed_official 146:f64d43ff0c18 831 uint32_t i, j;
mbed_official 146:f64d43ff0c18 832 uint32_t val1, val2, val;
mbed_official 146:f64d43ff0c18 833 volatile CAN_Type *flexcan_reg_ptr;
mbed_official 146:f64d43ff0c18 834
mbed_official 146:f64d43ff0c18 835 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 836 assert(data);
mbed_official 146:f64d43ff0c18 837
mbed_official 146:f64d43ff0c18 838 flexcan_reg_ptr = ((CAN_Type *)REGS_CAN_BASE(instance));
mbed_official 146:f64d43ff0c18 839 if (NULL == flexcan_reg_ptr)
mbed_official 146:f64d43ff0c18 840 {
mbed_official 146:f64d43ff0c18 841 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 842 }
mbed_official 146:f64d43ff0c18 843
mbed_official 146:f64d43ff0c18 844 switch(id_format)
mbed_official 146:f64d43ff0c18 845 {
mbed_official 146:f64d43ff0c18 846 case (kFlexCanRxFifoIdElementFormat_A):
mbed_official 146:f64d43ff0c18 847 /* One full ID (standard and extended) per ID Filter Table element.*/
mbed_official 146:f64d43ff0c18 848 BW_CAN_MCR_IDAM(instance, kFlexCanRxFifoIdElementFormat_A);
mbed_official 146:f64d43ff0c18 849 if (id_filter_table->is_remote_mb)
mbed_official 146:f64d43ff0c18 850 {
mbed_official 146:f64d43ff0c18 851 val = 1U << 31U;
mbed_official 146:f64d43ff0c18 852 }
mbed_official 146:f64d43ff0c18 853 if (id_filter_table->is_extended_mb)
mbed_official 146:f64d43ff0c18 854 {
mbed_official 146:f64d43ff0c18 855 val |= 1 << 30;
mbed_official 146:f64d43ff0c18 856 j = 0;
mbed_official 146:f64d43ff0c18 857 for (i = 0; i < (data->num_id_filters + 1) * 8; i += 4)
mbed_official 146:f64d43ff0c18 858 {
mbed_official 146:f64d43ff0c18 859 flexcan_reg_ptr->MB[6 + i - j * 3].CS =
mbed_official 146:f64d43ff0c18 860 val + ((*(id_filter_table->id_filter + i)) <<
mbed_official 146:f64d43ff0c18 861 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_SHIFT &
mbed_official 146:f64d43ff0c18 862 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_MASK);
mbed_official 146:f64d43ff0c18 863 flexcan_reg_ptr->MB[6 + i - j * 3].ID =
mbed_official 146:f64d43ff0c18 864 val + ((*(id_filter_table->id_filter + i + 1)) <<
mbed_official 146:f64d43ff0c18 865 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_SHIFT &
mbed_official 146:f64d43ff0c18 866 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_MASK);
mbed_official 146:f64d43ff0c18 867 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 =
mbed_official 146:f64d43ff0c18 868 val + ((*(id_filter_table->id_filter + i + 2)) <<
mbed_official 146:f64d43ff0c18 869 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_SHIFT &
mbed_official 146:f64d43ff0c18 870 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_MASK);
mbed_official 146:f64d43ff0c18 871 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 =
mbed_official 146:f64d43ff0c18 872 val + ((*(id_filter_table->id_filter + i + 3)) <<
mbed_official 146:f64d43ff0c18 873 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_SHIFT &
mbed_official 146:f64d43ff0c18 874 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_EXT_MASK);
mbed_official 146:f64d43ff0c18 875 j++;
mbed_official 146:f64d43ff0c18 876 }
mbed_official 146:f64d43ff0c18 877 }
mbed_official 146:f64d43ff0c18 878 else
mbed_official 146:f64d43ff0c18 879 {
mbed_official 146:f64d43ff0c18 880 j = 0;
mbed_official 146:f64d43ff0c18 881 for (i = 0; i < (data->num_id_filters + 1) * 8; i += 4)
mbed_official 146:f64d43ff0c18 882 {
mbed_official 146:f64d43ff0c18 883 flexcan_reg_ptr->MB[6 + i - j * 3].CS =
mbed_official 146:f64d43ff0c18 884 val + ((*(id_filter_table->id_filter + i)) <<
mbed_official 146:f64d43ff0c18 885 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_SHIFT &
mbed_official 146:f64d43ff0c18 886 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_MASK);
mbed_official 146:f64d43ff0c18 887 flexcan_reg_ptr->MB[6 + i - j * 3].ID =
mbed_official 146:f64d43ff0c18 888 val + ((*(id_filter_table->id_filter + i + 1)) <<
mbed_official 146:f64d43ff0c18 889 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_SHIFT &
mbed_official 146:f64d43ff0c18 890 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_MASK);
mbed_official 146:f64d43ff0c18 891 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 =
mbed_official 146:f64d43ff0c18 892 val + ((*(id_filter_table->id_filter + i + 2)) <<
mbed_official 146:f64d43ff0c18 893 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_SHIFT &
mbed_official 146:f64d43ff0c18 894 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_MASK);
mbed_official 146:f64d43ff0c18 895 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 =
mbed_official 146:f64d43ff0c18 896 val + ((*(id_filter_table->id_filter + i + 3)) <<
mbed_official 146:f64d43ff0c18 897 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_SHIFT &
mbed_official 146:f64d43ff0c18 898 FLEXCAN_RX_FIFO_ID_FILTER_FORMATA_STD_MASK);
mbed_official 146:f64d43ff0c18 899 j++;
mbed_official 146:f64d43ff0c18 900 }
mbed_official 146:f64d43ff0c18 901 }
mbed_official 146:f64d43ff0c18 902 break;
mbed_official 146:f64d43ff0c18 903 case (kFlexCanRxFifoIdElementFormat_B):
mbed_official 146:f64d43ff0c18 904 /* Two full standard IDs or two partial 14-bit (standard and extended) IDs*/
mbed_official 146:f64d43ff0c18 905 /* per ID Filter Table element.*/
mbed_official 146:f64d43ff0c18 906 BW_CAN_MCR_IDAM(instance, kFlexCanRxFifoIdElementFormat_B);
mbed_official 146:f64d43ff0c18 907 if (id_filter_table->is_remote_mb)
mbed_official 146:f64d43ff0c18 908 {
mbed_official 146:f64d43ff0c18 909 val1 = 1U << 31U;
mbed_official 146:f64d43ff0c18 910 val2 = 1 << 15;
mbed_official 146:f64d43ff0c18 911 }
mbed_official 146:f64d43ff0c18 912 if (id_filter_table->is_extended_mb)
mbed_official 146:f64d43ff0c18 913 {
mbed_official 146:f64d43ff0c18 914 val1 |= 1 << 30;
mbed_official 146:f64d43ff0c18 915 val2 |= 1 << 14;
mbed_official 146:f64d43ff0c18 916 j = 0;
mbed_official 146:f64d43ff0c18 917 for (i = 0; i < (data->num_id_filters + 1) * 8; i += 8)
mbed_official 146:f64d43ff0c18 918 {
mbed_official 146:f64d43ff0c18 919 flexcan_reg_ptr->MB[6 + i - j * 3].CS =
mbed_official 146:f64d43ff0c18 920 val1 + ((*(id_filter_table->id_filter + i)) &
mbed_official 146:f64d43ff0c18 921 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK <<
mbed_official 146:f64d43ff0c18 922 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT1);
mbed_official 146:f64d43ff0c18 923 flexcan_reg_ptr->MB[6 + i - j * 3].CS |=
mbed_official 146:f64d43ff0c18 924 val2 + ((*(id_filter_table->id_filter + i + 1)) &
mbed_official 146:f64d43ff0c18 925 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK <<
mbed_official 146:f64d43ff0c18 926 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT2);
mbed_official 146:f64d43ff0c18 927
mbed_official 146:f64d43ff0c18 928 flexcan_reg_ptr->MB[6 + i - j * 3].ID =
mbed_official 146:f64d43ff0c18 929 val1 + ((*(id_filter_table->id_filter + i + 2)) &
mbed_official 146:f64d43ff0c18 930 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK <<
mbed_official 146:f64d43ff0c18 931 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT1);
mbed_official 146:f64d43ff0c18 932 flexcan_reg_ptr->MB[6 + i - j * 3].ID |=
mbed_official 146:f64d43ff0c18 933 val2 + ((*(id_filter_table->id_filter + i + 3)) &
mbed_official 146:f64d43ff0c18 934 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK <<
mbed_official 146:f64d43ff0c18 935 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT2);
mbed_official 146:f64d43ff0c18 936
mbed_official 146:f64d43ff0c18 937 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 =
mbed_official 146:f64d43ff0c18 938 val1 + ((*(id_filter_table->id_filter + i + 4)) &
mbed_official 146:f64d43ff0c18 939 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK <<
mbed_official 146:f64d43ff0c18 940 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT1);
mbed_official 146:f64d43ff0c18 941 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 |=
mbed_official 146:f64d43ff0c18 942 val2 + ((*(id_filter_table->id_filter + i + 5)) &
mbed_official 146:f64d43ff0c18 943 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK <<
mbed_official 146:f64d43ff0c18 944 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT2);
mbed_official 146:f64d43ff0c18 945
mbed_official 146:f64d43ff0c18 946 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 =
mbed_official 146:f64d43ff0c18 947 val1 + ((*(id_filter_table->id_filter + i + 6)) &
mbed_official 146:f64d43ff0c18 948 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK <<
mbed_official 146:f64d43ff0c18 949 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT1);
mbed_official 146:f64d43ff0c18 950 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 |=
mbed_official 146:f64d43ff0c18 951 val2 + ((*(id_filter_table->id_filter + i + 7)) &
mbed_official 146:f64d43ff0c18 952 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_MASK <<
mbed_official 146:f64d43ff0c18 953 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT2);
mbed_official 146:f64d43ff0c18 954 j++;
mbed_official 146:f64d43ff0c18 955 }
mbed_official 146:f64d43ff0c18 956 }
mbed_official 146:f64d43ff0c18 957 else
mbed_official 146:f64d43ff0c18 958 {
mbed_official 146:f64d43ff0c18 959 j = 0;
mbed_official 146:f64d43ff0c18 960 for (i = 0; i < (data->num_id_filters + 1) * 8; i += 8)
mbed_official 146:f64d43ff0c18 961 {
mbed_official 146:f64d43ff0c18 962 flexcan_reg_ptr->MB[6 + i - j * 3].CS =
mbed_official 146:f64d43ff0c18 963 val1 + (((*(id_filter_table->id_filter + i)) &
mbed_official 146:f64d43ff0c18 964 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK) <<
mbed_official 146:f64d43ff0c18 965 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT1);
mbed_official 146:f64d43ff0c18 966 flexcan_reg_ptr->MB[6 + i - j * 3].CS |=
mbed_official 146:f64d43ff0c18 967 val2 + (((*(id_filter_table->id_filter + i + 1)) &
mbed_official 146:f64d43ff0c18 968 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK) <<
mbed_official 146:f64d43ff0c18 969 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT2);
mbed_official 146:f64d43ff0c18 970
mbed_official 146:f64d43ff0c18 971 flexcan_reg_ptr->MB[6 + i - j * 3].ID =
mbed_official 146:f64d43ff0c18 972 val1 + (((*(id_filter_table->id_filter + i + 2)) &
mbed_official 146:f64d43ff0c18 973 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK) <<
mbed_official 146:f64d43ff0c18 974 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT1);
mbed_official 146:f64d43ff0c18 975 flexcan_reg_ptr->MB[6 + i - j * 3].ID |=
mbed_official 146:f64d43ff0c18 976 val2 + (((*(id_filter_table->id_filter + i + 3)) &
mbed_official 146:f64d43ff0c18 977 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK) <<
mbed_official 146:f64d43ff0c18 978 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT2);
mbed_official 146:f64d43ff0c18 979
mbed_official 146:f64d43ff0c18 980 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 =
mbed_official 146:f64d43ff0c18 981 val1 + (((*(id_filter_table->id_filter + i + 4)) &
mbed_official 146:f64d43ff0c18 982 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK) <<
mbed_official 146:f64d43ff0c18 983 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT1);
mbed_official 146:f64d43ff0c18 984 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 |=
mbed_official 146:f64d43ff0c18 985 val2 + (((*(id_filter_table->id_filter + i + 5)) &
mbed_official 146:f64d43ff0c18 986 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK) <<
mbed_official 146:f64d43ff0c18 987 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT2);
mbed_official 146:f64d43ff0c18 988
mbed_official 146:f64d43ff0c18 989 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 =
mbed_official 146:f64d43ff0c18 990 val1 + (((*(id_filter_table->id_filter + i + 6)) &
mbed_official 146:f64d43ff0c18 991 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK) <<
mbed_official 146:f64d43ff0c18 992 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT1);
mbed_official 146:f64d43ff0c18 993 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 |=
mbed_official 146:f64d43ff0c18 994 val2 + (((*(id_filter_table->id_filter + i + 7)) &
mbed_official 146:f64d43ff0c18 995 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_MASK) <<
mbed_official 146:f64d43ff0c18 996 FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_STD_SHIFT2);
mbed_official 146:f64d43ff0c18 997 j++;
mbed_official 146:f64d43ff0c18 998 }
mbed_official 146:f64d43ff0c18 999 }
mbed_official 146:f64d43ff0c18 1000 break;
mbed_official 146:f64d43ff0c18 1001 case (kFlexCanRxFifoIdElementFormat_C):
mbed_official 146:f64d43ff0c18 1002 /* Four partial 8-bit Standard IDs per ID Filter Table element.*/
mbed_official 146:f64d43ff0c18 1003 BW_CAN_MCR_IDAM(instance, kFlexCanRxFifoIdElementFormat_C);
mbed_official 146:f64d43ff0c18 1004 j = 0;
mbed_official 146:f64d43ff0c18 1005 for (i = 0; i < (data->num_id_filters + 1) * 8; i += 16)
mbed_official 146:f64d43ff0c18 1006 {
mbed_official 146:f64d43ff0c18 1007 flexcan_reg_ptr->MB[6 + i - j * 3].CS =
mbed_official 146:f64d43ff0c18 1008 ((*(id_filter_table->id_filter + i)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1009 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT1);
mbed_official 146:f64d43ff0c18 1010 flexcan_reg_ptr->MB[6 + i - j * 3].CS |=
mbed_official 146:f64d43ff0c18 1011 ((*(id_filter_table->id_filter + i + 1)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1012 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT2);
mbed_official 146:f64d43ff0c18 1013 flexcan_reg_ptr->MB[6 + i - j * 3].CS |=
mbed_official 146:f64d43ff0c18 1014 ((*(id_filter_table->id_filter + i + 2)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1015 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT3);
mbed_official 146:f64d43ff0c18 1016 flexcan_reg_ptr->MB[6 + i - j * 3].CS |=
mbed_official 146:f64d43ff0c18 1017 ((*(id_filter_table->id_filter + i + 3)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1018 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT4);
mbed_official 146:f64d43ff0c18 1019
mbed_official 146:f64d43ff0c18 1020 flexcan_reg_ptr->MB[6 + i - j * 3].ID =
mbed_official 146:f64d43ff0c18 1021 ((*(id_filter_table->id_filter + i + 4)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1022 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT1);
mbed_official 146:f64d43ff0c18 1023 flexcan_reg_ptr->MB[6 + i - j * 3].ID |=
mbed_official 146:f64d43ff0c18 1024 ((*(id_filter_table->id_filter + i + 5)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1025 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT2);
mbed_official 146:f64d43ff0c18 1026 flexcan_reg_ptr->MB[6 + i - j * 3].ID |=
mbed_official 146:f64d43ff0c18 1027 ((*(id_filter_table->id_filter + i + 6)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1028 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT3);
mbed_official 146:f64d43ff0c18 1029 flexcan_reg_ptr->MB[6 + i - j * 3].ID |=
mbed_official 146:f64d43ff0c18 1030 ((*(id_filter_table->id_filter + i + 7)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1031 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT4);
mbed_official 146:f64d43ff0c18 1032
mbed_official 146:f64d43ff0c18 1033 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 =
mbed_official 146:f64d43ff0c18 1034 ((*(id_filter_table->id_filter + i + 8)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1035 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT1);
mbed_official 146:f64d43ff0c18 1036 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 |=
mbed_official 146:f64d43ff0c18 1037 ((*(id_filter_table->id_filter + i + 9)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1038 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT2);
mbed_official 146:f64d43ff0c18 1039 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 |=
mbed_official 146:f64d43ff0c18 1040 ((*(id_filter_table->id_filter + i + 10)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1041 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT3);
mbed_official 146:f64d43ff0c18 1042 flexcan_reg_ptr->MB[6 + i - j * 3].WORD0 |=
mbed_official 146:f64d43ff0c18 1043 ((*(id_filter_table->id_filter + i + 11)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1044 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT4);
mbed_official 146:f64d43ff0c18 1045
mbed_official 146:f64d43ff0c18 1046 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 =
mbed_official 146:f64d43ff0c18 1047 ((*(id_filter_table->id_filter + i + 12)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1048 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT1);
mbed_official 146:f64d43ff0c18 1049 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 |=
mbed_official 146:f64d43ff0c18 1050 ((*(id_filter_table->id_filter + i + 13)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1051 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT2);
mbed_official 146:f64d43ff0c18 1052 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 |=
mbed_official 146:f64d43ff0c18 1053 ((*(id_filter_table->id_filter + i + 14)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1054 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT3);
mbed_official 146:f64d43ff0c18 1055 flexcan_reg_ptr->MB[6 + i - j * 3].WORD1 |=
mbed_official 146:f64d43ff0c18 1056 ((*(id_filter_table->id_filter + i + 15)) & FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_MASK <<
mbed_official 146:f64d43ff0c18 1057 FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT4);
mbed_official 146:f64d43ff0c18 1058
mbed_official 146:f64d43ff0c18 1059 j++;
mbed_official 146:f64d43ff0c18 1060 }
mbed_official 146:f64d43ff0c18 1061 break;
mbed_official 146:f64d43ff0c18 1062 case (kFlexCanRxFifoIdElementFormat_D):
mbed_official 146:f64d43ff0c18 1063 /* All frames rejected.*/
mbed_official 146:f64d43ff0c18 1064 BW_CAN_MCR_IDAM(instance, kFlexCanRxFifoIdElementFormat_D);
mbed_official 146:f64d43ff0c18 1065 break;
mbed_official 146:f64d43ff0c18 1066 default:
mbed_official 146:f64d43ff0c18 1067 return kStatus_FLEXCAN_InvalidArgument;
mbed_official 146:f64d43ff0c18 1068 }
mbed_official 146:f64d43ff0c18 1069
mbed_official 146:f64d43ff0c18 1070 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1071 }
mbed_official 146:f64d43ff0c18 1072
mbed_official 146:f64d43ff0c18 1073 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1074 *
mbed_official 146:f64d43ff0c18 1075 * Function Name : flexcan_hal_set_rx_fifo
mbed_official 146:f64d43ff0c18 1076 * Description : Confgure RX FIFO ID filter table elements.
mbed_official 146:f64d43ff0c18 1077 *
mbed_official 146:f64d43ff0c18 1078 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1079 flexcan_status_t flexcan_hal_set_rx_fifo(
mbed_official 146:f64d43ff0c18 1080 uint8_t instance,
mbed_official 146:f64d43ff0c18 1081 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 1082 flexcan_rx_fifo_id_element_format_t id_format,
mbed_official 146:f64d43ff0c18 1083 flexcan_id_table_t *id_filter_table)
mbed_official 146:f64d43ff0c18 1084 {
mbed_official 146:f64d43ff0c18 1085 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1086 assert(data);
mbed_official 146:f64d43ff0c18 1087
mbed_official 146:f64d43ff0c18 1088 if (!data->is_rx_fifo_needed)
mbed_official 146:f64d43ff0c18 1089 {
mbed_official 146:f64d43ff0c18 1090 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 1091 }
mbed_official 146:f64d43ff0c18 1092
mbed_official 146:f64d43ff0c18 1093 if (data->num_mb > data->max_num_mb)
mbed_official 146:f64d43ff0c18 1094 {
mbed_official 146:f64d43ff0c18 1095 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 1096 }
mbed_official 146:f64d43ff0c18 1097
mbed_official 146:f64d43ff0c18 1098 /* Set RX FIFO ID filter table elements*/
mbed_official 146:f64d43ff0c18 1099 return flexcan_hal_set_id_filter_table_elements(instance, data, id_format, id_filter_table);
mbed_official 146:f64d43ff0c18 1100 }
mbed_official 146:f64d43ff0c18 1101
mbed_official 146:f64d43ff0c18 1102 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1103 *
mbed_official 146:f64d43ff0c18 1104 * Function Name : flexcan_hal_enable_mb_interrupt
mbed_official 146:f64d43ff0c18 1105 * Description : Enable the corresponding Message Buffer interrupt.
mbed_official 146:f64d43ff0c18 1106 *
mbed_official 146:f64d43ff0c18 1107 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1108 flexcan_status_t flexcan_hal_enable_mb_interrupt(
mbed_official 146:f64d43ff0c18 1109 uint8_t instance,
mbed_official 146:f64d43ff0c18 1110 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 1111 uint32_t mb_idx)
mbed_official 146:f64d43ff0c18 1112 {
mbed_official 146:f64d43ff0c18 1113 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1114 assert(data);
mbed_official 146:f64d43ff0c18 1115 uint32_t temp;
mbed_official 146:f64d43ff0c18 1116
mbed_official 146:f64d43ff0c18 1117 if ( mb_idx >= data->max_num_mb)
mbed_official 146:f64d43ff0c18 1118 {
mbed_official 146:f64d43ff0c18 1119 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 1120 }
mbed_official 146:f64d43ff0c18 1121
mbed_official 146:f64d43ff0c18 1122 /* Enable the corresponding message buffer Interrupt*/
mbed_official 146:f64d43ff0c18 1123 temp = 0x1 << mb_idx;
mbed_official 146:f64d43ff0c18 1124 HW_CAN_IMASK1_SET(instance, temp);
mbed_official 146:f64d43ff0c18 1125
mbed_official 146:f64d43ff0c18 1126 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1127 }
mbed_official 146:f64d43ff0c18 1128
mbed_official 146:f64d43ff0c18 1129 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1130 *
mbed_official 146:f64d43ff0c18 1131 * Function Name : flexcan_hal_disable_mb_interrupt
mbed_official 146:f64d43ff0c18 1132 * Description : Disable the corresponding Message Buffer interrupt.
mbed_official 146:f64d43ff0c18 1133 *
mbed_official 146:f64d43ff0c18 1134 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1135 flexcan_status_t flexcan_hal_disable_mb_interrupt(
mbed_official 146:f64d43ff0c18 1136 uint8_t instance,
mbed_official 146:f64d43ff0c18 1137 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 1138 uint32_t mb_idx)
mbed_official 146:f64d43ff0c18 1139 {
mbed_official 146:f64d43ff0c18 1140 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1141 assert(data);
mbed_official 146:f64d43ff0c18 1142 uint32_t temp;
mbed_official 146:f64d43ff0c18 1143
mbed_official 146:f64d43ff0c18 1144 if (mb_idx >= data->max_num_mb)
mbed_official 146:f64d43ff0c18 1145 {
mbed_official 146:f64d43ff0c18 1146 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 1147 }
mbed_official 146:f64d43ff0c18 1148
mbed_official 146:f64d43ff0c18 1149 /* Disable the corresponding message buffer Interrupt*/
mbed_official 146:f64d43ff0c18 1150 temp = 0x1 << mb_idx;
mbed_official 146:f64d43ff0c18 1151 HW_CAN_IMASK1_CLR(instance, temp);
mbed_official 146:f64d43ff0c18 1152
mbed_official 146:f64d43ff0c18 1153 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1154 }
mbed_official 146:f64d43ff0c18 1155
mbed_official 146:f64d43ff0c18 1156 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1157 *
mbed_official 146:f64d43ff0c18 1158 * Function Name : flexcan_hal_enable_error_interrupt
mbed_official 146:f64d43ff0c18 1159 * Description : Enable the error interrupts.
mbed_official 146:f64d43ff0c18 1160 * This function will enable Error interrupt.
mbed_official 146:f64d43ff0c18 1161 *
mbed_official 146:f64d43ff0c18 1162 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1163 void flexcan_hal_enable_error_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1164 {
mbed_official 146:f64d43ff0c18 1165 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1166
mbed_official 146:f64d43ff0c18 1167 /* Enable Error interrupt*/
mbed_official 146:f64d43ff0c18 1168 HW_CAN_CTRL1_SET(instance, CAN_CTRL1_ERRMSK_MASK);
mbed_official 146:f64d43ff0c18 1169 }
mbed_official 146:f64d43ff0c18 1170
mbed_official 146:f64d43ff0c18 1171 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1172 *
mbed_official 146:f64d43ff0c18 1173 * Function Name : flexcan_hal_disable_error_interrupt
mbed_official 146:f64d43ff0c18 1174 * Description : Disable the error interrupts.
mbed_official 146:f64d43ff0c18 1175 * This function will disable Error interrupt.
mbed_official 146:f64d43ff0c18 1176 *
mbed_official 146:f64d43ff0c18 1177 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1178 void flexcan_hal_disable_error_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1179 {
mbed_official 146:f64d43ff0c18 1180 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1181
mbed_official 146:f64d43ff0c18 1182 /* Disable Error interrupt*/
mbed_official 146:f64d43ff0c18 1183 HW_CAN_CTRL1_CLR(instance, CAN_CTRL1_ERRMSK_MASK);
mbed_official 146:f64d43ff0c18 1184 }
mbed_official 146:f64d43ff0c18 1185
mbed_official 146:f64d43ff0c18 1186 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1187 *
mbed_official 146:f64d43ff0c18 1188 * Function Name : flexcan_hal_enable_bus_off_interrupt
mbed_official 146:f64d43ff0c18 1189 * Description : Enable the Bus off interrupts.
mbed_official 146:f64d43ff0c18 1190 * This function will enable Bus Off interrupt.
mbed_official 146:f64d43ff0c18 1191 *
mbed_official 146:f64d43ff0c18 1192 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1193 void flexcan_hal_enable_bus_off_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1194 {
mbed_official 146:f64d43ff0c18 1195 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1196
mbed_official 146:f64d43ff0c18 1197 /* Enable Bus Off interrupt*/
mbed_official 146:f64d43ff0c18 1198 HW_CAN_CTRL1_SET(instance, CAN_CTRL1_BOFFMSK_MASK);
mbed_official 146:f64d43ff0c18 1199 }
mbed_official 146:f64d43ff0c18 1200
mbed_official 146:f64d43ff0c18 1201 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1202 *
mbed_official 146:f64d43ff0c18 1203 * Function Name : flexcan_hal_disable_bus_off_interrupt
mbed_official 146:f64d43ff0c18 1204 * Description : Disable the Bus off interrupts.
mbed_official 146:f64d43ff0c18 1205 * This function will disable Bus Off interrupt.
mbed_official 146:f64d43ff0c18 1206 *
mbed_official 146:f64d43ff0c18 1207 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1208 void flexcan_hal_disable_bus_off_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1209 {
mbed_official 146:f64d43ff0c18 1210 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1211
mbed_official 146:f64d43ff0c18 1212 /* Disable Bus Off interrupt*/
mbed_official 146:f64d43ff0c18 1213 HW_CAN_CTRL1_CLR(instance, CAN_CTRL1_BOFFMSK_MASK);
mbed_official 146:f64d43ff0c18 1214 }
mbed_official 146:f64d43ff0c18 1215
mbed_official 146:f64d43ff0c18 1216 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1217 *
mbed_official 146:f64d43ff0c18 1218 * Function Name : flexcan_hal_enable_wakeup_interrupt
mbed_official 146:f64d43ff0c18 1219 * Description : Enable the wakeup interrupts.
mbed_official 146:f64d43ff0c18 1220 * This function will enable Wake up interrupt.
mbed_official 146:f64d43ff0c18 1221 *
mbed_official 146:f64d43ff0c18 1222 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1223 void flexcan_hal_enable_wakeup_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1224 {
mbed_official 146:f64d43ff0c18 1225 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1226
mbed_official 146:f64d43ff0c18 1227 /* Enable Wake Up interrupt*/
mbed_official 146:f64d43ff0c18 1228 BW_CAN_MCR_WAKMSK(instance, 1);
mbed_official 146:f64d43ff0c18 1229 }
mbed_official 146:f64d43ff0c18 1230
mbed_official 146:f64d43ff0c18 1231 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1232 *
mbed_official 146:f64d43ff0c18 1233 * Function Name : flexcan_hal_disable_wakeup_interrupt
mbed_official 146:f64d43ff0c18 1234 * Description : Disable the wakeup interrupts.
mbed_official 146:f64d43ff0c18 1235 * This function will disable Wake up interrupt.
mbed_official 146:f64d43ff0c18 1236 *
mbed_official 146:f64d43ff0c18 1237 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1238 void flexcan_hal_disable_wakeup_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1239 {
mbed_official 146:f64d43ff0c18 1240 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1241
mbed_official 146:f64d43ff0c18 1242 /* Disable Wake Up interrupt*/
mbed_official 146:f64d43ff0c18 1243 BW_CAN_MCR_WAKMSK(instance, 0);
mbed_official 146:f64d43ff0c18 1244 }
mbed_official 146:f64d43ff0c18 1245
mbed_official 146:f64d43ff0c18 1246 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1247 *
mbed_official 146:f64d43ff0c18 1248 * Function Name : flexcan_hal_enable_tx_warning_interrupt
mbed_official 146:f64d43ff0c18 1249 * Description : Enable the TX warning interrupts.
mbed_official 146:f64d43ff0c18 1250 * This function will enable TX warning interrupt.
mbed_official 146:f64d43ff0c18 1251 *
mbed_official 146:f64d43ff0c18 1252 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1253 void flexcan_hal_enable_tx_warning_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1254 {
mbed_official 146:f64d43ff0c18 1255 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1256
mbed_official 146:f64d43ff0c18 1257 /* Enable TX warning interrupt*/
mbed_official 146:f64d43ff0c18 1258 HW_CAN_CTRL1_SET(instance, CAN_CTRL1_TWRNMSK_MASK);
mbed_official 146:f64d43ff0c18 1259 }
mbed_official 146:f64d43ff0c18 1260
mbed_official 146:f64d43ff0c18 1261 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1262 *
mbed_official 146:f64d43ff0c18 1263 * Function Name : flexcan_hal_disable_tx_warning_interrupt
mbed_official 146:f64d43ff0c18 1264 * Description : Disable the TX warning interrupts.
mbed_official 146:f64d43ff0c18 1265 * This function will disable TX warning interrupt.
mbed_official 146:f64d43ff0c18 1266 *
mbed_official 146:f64d43ff0c18 1267 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1268 void flexcan_hal_disable_tx_warning_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1269 {
mbed_official 146:f64d43ff0c18 1270 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1271
mbed_official 146:f64d43ff0c18 1272 /* Disable TX warning interrupt*/
mbed_official 146:f64d43ff0c18 1273 HW_CAN_CTRL1_CLR(instance, CAN_CTRL1_TWRNMSK_MASK);
mbed_official 146:f64d43ff0c18 1274 }
mbed_official 146:f64d43ff0c18 1275
mbed_official 146:f64d43ff0c18 1276 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1277 *
mbed_official 146:f64d43ff0c18 1278 * Function Name : flexcan_hal_enable_rx_warning_interrupt
mbed_official 146:f64d43ff0c18 1279 * Description : Enable the RX warning interrupts.
mbed_official 146:f64d43ff0c18 1280 * This function will enable RX warning interrupt.
mbed_official 146:f64d43ff0c18 1281 *
mbed_official 146:f64d43ff0c18 1282 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1283 void flexcan_hal_enable_rx_warning_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1284 {
mbed_official 146:f64d43ff0c18 1285 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1286
mbed_official 146:f64d43ff0c18 1287 /* Enable RX warning interrupt*/
mbed_official 146:f64d43ff0c18 1288 HW_CAN_CTRL1_SET(instance, CAN_CTRL1_RWRNMSK_MASK);
mbed_official 146:f64d43ff0c18 1289 }
mbed_official 146:f64d43ff0c18 1290
mbed_official 146:f64d43ff0c18 1291 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1292 *
mbed_official 146:f64d43ff0c18 1293 * Function Name : flexcan_hal_disable_rx_warning_interrupt
mbed_official 146:f64d43ff0c18 1294 * Description : Disable the RX warning interrupts.
mbed_official 146:f64d43ff0c18 1295 * This function will disable RX warning interrupt.
mbed_official 146:f64d43ff0c18 1296 *
mbed_official 146:f64d43ff0c18 1297 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1298 void flexcan_hal_disable_rx_warning_interrupt(uint8_t instance)
mbed_official 146:f64d43ff0c18 1299 {
mbed_official 146:f64d43ff0c18 1300 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1301
mbed_official 146:f64d43ff0c18 1302 /* Disable RX warning interrupt*/
mbed_official 146:f64d43ff0c18 1303 HW_CAN_CTRL1_CLR(instance, CAN_CTRL1_RWRNMSK_MASK);
mbed_official 146:f64d43ff0c18 1304 }
mbed_official 146:f64d43ff0c18 1305
mbed_official 146:f64d43ff0c18 1306 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1307 *
mbed_official 146:f64d43ff0c18 1308 * Function Name : flexcan_hal_exit_freeze_mode
mbed_official 146:f64d43ff0c18 1309 * Description : Exit of freeze mode.
mbed_official 146:f64d43ff0c18 1310 *
mbed_official 146:f64d43ff0c18 1311 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1312 void flexcan_hal_exit_freeze_mode(uint8_t instance)
mbed_official 146:f64d43ff0c18 1313 {
mbed_official 146:f64d43ff0c18 1314 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1315 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1316
mbed_official 146:f64d43ff0c18 1317 /* Wait till exit freeze mode*/
mbed_official 146:f64d43ff0c18 1318 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1319 }
mbed_official 146:f64d43ff0c18 1320
mbed_official 146:f64d43ff0c18 1321 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1322 *
mbed_official 146:f64d43ff0c18 1323 * Function Name : flexcan_hal_enter_freeze_mode
mbed_official 146:f64d43ff0c18 1324 * Description : Enter the freeze mode.
mbed_official 146:f64d43ff0c18 1325 *
mbed_official 146:f64d43ff0c18 1326 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1327 void flexcan_hal_enter_freeze_mode(uint8_t instance)
mbed_official 146:f64d43ff0c18 1328 {
mbed_official 146:f64d43ff0c18 1329 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1330 HW_CAN_MCR_SET(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1331
mbed_official 146:f64d43ff0c18 1332 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1333 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1334 }
mbed_official 146:f64d43ff0c18 1335
mbed_official 146:f64d43ff0c18 1336 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1337 *
mbed_official 146:f64d43ff0c18 1338 * Function Name : flexcan_hal_get_mb_int_flag
mbed_official 146:f64d43ff0c18 1339 * Description : Get the corresponding message buffer interrupt flag.
mbed_official 146:f64d43ff0c18 1340 *
mbed_official 146:f64d43ff0c18 1341 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1342 uint8_t flexcan_hal_get_mb_int_flag(
mbed_official 146:f64d43ff0c18 1343 uint8_t instance,
mbed_official 146:f64d43ff0c18 1344 const flexcan_user_config_t *data,
mbed_official 146:f64d43ff0c18 1345 uint32_t mb_idx)
mbed_official 146:f64d43ff0c18 1346 {
mbed_official 146:f64d43ff0c18 1347 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1348 assert(data);
mbed_official 146:f64d43ff0c18 1349 assert(mb_idx < data->max_num_mb);
mbed_official 146:f64d43ff0c18 1350 uint32_t temp;
mbed_official 146:f64d43ff0c18 1351
mbed_official 146:f64d43ff0c18 1352 /* Get the corresponding message buffer interrupt flag*/
mbed_official 146:f64d43ff0c18 1353 temp = 0x1 << mb_idx;
mbed_official 146:f64d43ff0c18 1354 if (HW_CAN_IFLAG1_RD(instance) & temp)
mbed_official 146:f64d43ff0c18 1355 {
mbed_official 146:f64d43ff0c18 1356 return 1;
mbed_official 146:f64d43ff0c18 1357 }
mbed_official 146:f64d43ff0c18 1358 else
mbed_official 146:f64d43ff0c18 1359 {
mbed_official 146:f64d43ff0c18 1360 return 0;
mbed_official 146:f64d43ff0c18 1361 }
mbed_official 146:f64d43ff0c18 1362 }
mbed_official 146:f64d43ff0c18 1363
mbed_official 146:f64d43ff0c18 1364 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1365 *
mbed_official 146:f64d43ff0c18 1366 * Function Name : flexcan_hal_get_err_counter
mbed_official 146:f64d43ff0c18 1367 * Description : Get transmit error counter and receive error counter.
mbed_official 146:f64d43ff0c18 1368 *
mbed_official 146:f64d43ff0c18 1369 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1370 void flexcan_hal_get_err_counter(
mbed_official 146:f64d43ff0c18 1371 uint8_t instance,
mbed_official 146:f64d43ff0c18 1372 flexcan_berr_counter_t *err_cnt)
mbed_official 146:f64d43ff0c18 1373 {
mbed_official 146:f64d43ff0c18 1374 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1375
mbed_official 146:f64d43ff0c18 1376 /* Get transmit error counter and receive error counter*/
mbed_official 146:f64d43ff0c18 1377 err_cnt->rxerr = HW_CAN_ECR(instance).B.RXERRCNT;
mbed_official 146:f64d43ff0c18 1378 err_cnt->txerr = HW_CAN_ECR(instance).B.TXERRCNT;
mbed_official 146:f64d43ff0c18 1379 }
mbed_official 146:f64d43ff0c18 1380
mbed_official 146:f64d43ff0c18 1381 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1382 *
mbed_official 146:f64d43ff0c18 1383 * Function Name : flexcan_hal_clear_err_interrupt_status
mbed_official 146:f64d43ff0c18 1384 * Description : Clear all error interrupt status.
mbed_official 146:f64d43ff0c18 1385 *
mbed_official 146:f64d43ff0c18 1386 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1387 void flexcan_hal_clear_err_interrupt_status(uint8_t instance)
mbed_official 146:f64d43ff0c18 1388 {
mbed_official 146:f64d43ff0c18 1389 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1390
mbed_official 146:f64d43ff0c18 1391 if(HW_CAN_IFLAG1_RD(instance) & FLEXCAN_ALL_INT)
mbed_official 146:f64d43ff0c18 1392 {
mbed_official 146:f64d43ff0c18 1393 HW_CAN_ESR1_SET(instance, FLEXCAN_ALL_INT);
mbed_official 146:f64d43ff0c18 1394 }
mbed_official 146:f64d43ff0c18 1395 }
mbed_official 146:f64d43ff0c18 1396
mbed_official 146:f64d43ff0c18 1397 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1398 *
mbed_official 146:f64d43ff0c18 1399 * Function Name : flexcan_hal_read_fifo
mbed_official 146:f64d43ff0c18 1400 * Description : Read Rx FIFO data.
mbed_official 146:f64d43ff0c18 1401 * This function will copy MB[0] data field into user's buffer.
mbed_official 146:f64d43ff0c18 1402 *
mbed_official 146:f64d43ff0c18 1403 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1404 flexcan_status_t flexcan_hal_read_fifo(
mbed_official 146:f64d43ff0c18 1405 uint8_t instance,
mbed_official 146:f64d43ff0c18 1406 flexcan_mb_t *rx_fifo)
mbed_official 146:f64d43ff0c18 1407 {
mbed_official 146:f64d43ff0c18 1408 uint32_t i;
mbed_official 146:f64d43ff0c18 1409 volatile CAN_Type *flexcan_reg_ptr;
mbed_official 146:f64d43ff0c18 1410 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1411
mbed_official 146:f64d43ff0c18 1412 flexcan_reg_ptr = ((CAN_Type *)REGS_CAN_BASE(instance));
mbed_official 146:f64d43ff0c18 1413 if (NULL == flexcan_reg_ptr)
mbed_official 146:f64d43ff0c18 1414 {
mbed_official 146:f64d43ff0c18 1415 return (kStatus_FLEXCAN_InvalidArgument);
mbed_official 146:f64d43ff0c18 1416 }
mbed_official 146:f64d43ff0c18 1417
mbed_official 146:f64d43ff0c18 1418 rx_fifo->cs = flexcan_reg_ptr->MB[0].CS;
mbed_official 146:f64d43ff0c18 1419
mbed_official 146:f64d43ff0c18 1420 if ((rx_fifo->cs) & CAN_CS_IDE_MASK)
mbed_official 146:f64d43ff0c18 1421 {
mbed_official 146:f64d43ff0c18 1422 rx_fifo->msg_id = flexcan_reg_ptr->MB[0].ID;
mbed_official 146:f64d43ff0c18 1423 }
mbed_official 146:f64d43ff0c18 1424 else
mbed_official 146:f64d43ff0c18 1425 {
mbed_official 146:f64d43ff0c18 1426 rx_fifo->msg_id = (flexcan_reg_ptr->MB[0].ID) >> CAN_ID_STD_SHIFT;
mbed_official 146:f64d43ff0c18 1427 }
mbed_official 146:f64d43ff0c18 1428
mbed_official 146:f64d43ff0c18 1429 /* Copy MB[0] data field into user's buffer*/
mbed_official 146:f64d43ff0c18 1430 for ( i=0 ; i < kFlexCanMessageSize ; i++ )
mbed_official 146:f64d43ff0c18 1431 {
mbed_official 146:f64d43ff0c18 1432 if (i < 4)
mbed_official 146:f64d43ff0c18 1433 {
mbed_official 146:f64d43ff0c18 1434 rx_fifo->data[3 - i] = ((flexcan_reg_ptr->MB[0].WORD0) >> (i * 8)) &
mbed_official 146:f64d43ff0c18 1435 FLEXCAN_BYTE_DATA_FIELD_MASK;
mbed_official 146:f64d43ff0c18 1436 }
mbed_official 146:f64d43ff0c18 1437 else
mbed_official 146:f64d43ff0c18 1438 {
mbed_official 146:f64d43ff0c18 1439 rx_fifo->data[11 - i] = ((flexcan_reg_ptr->MB[0].WORD1) >> ((i - 4) * 8)) &
mbed_official 146:f64d43ff0c18 1440 FLEXCAN_BYTE_DATA_FIELD_MASK;
mbed_official 146:f64d43ff0c18 1441 }
mbed_official 146:f64d43ff0c18 1442 }
mbed_official 146:f64d43ff0c18 1443
mbed_official 146:f64d43ff0c18 1444 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1445 }
mbed_official 146:f64d43ff0c18 1446
mbed_official 146:f64d43ff0c18 1447 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1448 *
mbed_official 146:f64d43ff0c18 1449 * Function Name : flexcan_hal_set_mask_type
mbed_official 146:f64d43ff0c18 1450 * Description : Set RX masking type.
mbed_official 146:f64d43ff0c18 1451 * This function will set RX masking type as RX global mask or RX individual
mbed_official 146:f64d43ff0c18 1452 * mask.
mbed_official 146:f64d43ff0c18 1453 *
mbed_official 146:f64d43ff0c18 1454 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1455 void flexcan_hal_set_mask_type(
mbed_official 146:f64d43ff0c18 1456 uint8_t instance,
mbed_official 146:f64d43ff0c18 1457 flexcan_rx_mask_type_t type)
mbed_official 146:f64d43ff0c18 1458 {
mbed_official 146:f64d43ff0c18 1459 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1460
mbed_official 146:f64d43ff0c18 1461 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1462 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1463
mbed_official 146:f64d43ff0c18 1464 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1465 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1466
mbed_official 146:f64d43ff0c18 1467 /* Set RX masking type (RX global mask or RX individual mask)*/
mbed_official 146:f64d43ff0c18 1468 if (type == kFlexCanRxMask_Global)
mbed_official 146:f64d43ff0c18 1469 {
mbed_official 146:f64d43ff0c18 1470 /* Enable Global RX masking*/
mbed_official 146:f64d43ff0c18 1471 HW_CAN_MCR_CLR(instance, BM_CAN_MCR_IRMQ);
mbed_official 146:f64d43ff0c18 1472 }
mbed_official 146:f64d43ff0c18 1473 else
mbed_official 146:f64d43ff0c18 1474 {
mbed_official 146:f64d43ff0c18 1475 /* Enable Individual Rx Masking and Queue*/
mbed_official 146:f64d43ff0c18 1476 HW_CAN_MCR_SET(instance, BM_CAN_MCR_IRMQ);
mbed_official 146:f64d43ff0c18 1477 }
mbed_official 146:f64d43ff0c18 1478
mbed_official 146:f64d43ff0c18 1479 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1480 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1481
mbed_official 146:f64d43ff0c18 1482 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1483 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1484 }
mbed_official 146:f64d43ff0c18 1485
mbed_official 146:f64d43ff0c18 1486 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1487 *
mbed_official 146:f64d43ff0c18 1488 * Function Name : flexcan_hal_set_rx_fifo_global_std_mask
mbed_official 146:f64d43ff0c18 1489 * Description : Set Rx FIFO global mask as the 11-bit standard mask.
mbed_official 146:f64d43ff0c18 1490 *
mbed_official 146:f64d43ff0c18 1491 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1492 void flexcan_hal_set_rx_fifo_global_std_mask(
mbed_official 146:f64d43ff0c18 1493 uint8_t instance,
mbed_official 146:f64d43ff0c18 1494 uint32_t std_mask)
mbed_official 146:f64d43ff0c18 1495 {
mbed_official 146:f64d43ff0c18 1496 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1497
mbed_official 146:f64d43ff0c18 1498 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1499 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1500
mbed_official 146:f64d43ff0c18 1501 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1502 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1503
mbed_official 146:f64d43ff0c18 1504 /* 11 bit standard mask*/
mbed_official 146:f64d43ff0c18 1505 HW_CAN_RXFGMASK_WR(instance, CAN_ID_STD(std_mask));
mbed_official 146:f64d43ff0c18 1506
mbed_official 146:f64d43ff0c18 1507 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1508 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1509
mbed_official 146:f64d43ff0c18 1510 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1511 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1512 }
mbed_official 146:f64d43ff0c18 1513
mbed_official 146:f64d43ff0c18 1514 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1515 *
mbed_official 146:f64d43ff0c18 1516 * Function Name : flexcan_hal_set_rx_fifo_global_ext_mask
mbed_official 146:f64d43ff0c18 1517 * Description : Set Rx FIFO global mask as the 29-bit extended mask.
mbed_official 146:f64d43ff0c18 1518 *
mbed_official 146:f64d43ff0c18 1519 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1520 void flexcan_hal_set_rx_fifo_global_ext_mask(
mbed_official 146:f64d43ff0c18 1521 uint8_t instance,
mbed_official 146:f64d43ff0c18 1522 uint32_t ext_mask)
mbed_official 146:f64d43ff0c18 1523 {
mbed_official 146:f64d43ff0c18 1524 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1525
mbed_official 146:f64d43ff0c18 1526 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1527 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1528
mbed_official 146:f64d43ff0c18 1529 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1530 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1531
mbed_official 146:f64d43ff0c18 1532 /* 29-bit extended mask*/
mbed_official 146:f64d43ff0c18 1533 HW_CAN_RXFGMASK_WR(instance, CAN_ID_EXT(ext_mask));
mbed_official 146:f64d43ff0c18 1534
mbed_official 146:f64d43ff0c18 1535 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1536 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1537
mbed_official 146:f64d43ff0c18 1538 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1539 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1540 }
mbed_official 146:f64d43ff0c18 1541
mbed_official 146:f64d43ff0c18 1542 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1543 *
mbed_official 146:f64d43ff0c18 1544 * Function Name : flexcan_hal_set_rx_individual_std_mask
mbed_official 146:f64d43ff0c18 1545 * Description : Set Rx individual mask as the 11-bit standard mask.
mbed_official 146:f64d43ff0c18 1546 *
mbed_official 146:f64d43ff0c18 1547 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1548 flexcan_status_t flexcan_hal_set_rx_individual_std_mask(
mbed_official 146:f64d43ff0c18 1549 uint8_t instance,
mbed_official 146:f64d43ff0c18 1550 const flexcan_user_config_t * data,
mbed_official 146:f64d43ff0c18 1551 uint32_t mb_idx,
mbed_official 146:f64d43ff0c18 1552 uint32_t std_mask)
mbed_official 146:f64d43ff0c18 1553 {
mbed_official 146:f64d43ff0c18 1554 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1555 assert(data);
mbed_official 146:f64d43ff0c18 1556
mbed_official 146:f64d43ff0c18 1557 if (mb_idx >= data->max_num_mb)
mbed_official 146:f64d43ff0c18 1558 {
mbed_official 146:f64d43ff0c18 1559 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 1560 }
mbed_official 146:f64d43ff0c18 1561
mbed_official 146:f64d43ff0c18 1562 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1563 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1564
mbed_official 146:f64d43ff0c18 1565 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1566 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1567
mbed_official 146:f64d43ff0c18 1568 /* 11 bit standard mask*/
mbed_official 146:f64d43ff0c18 1569 HW_CAN_RXIMRn_WR(instance, mb_idx, CAN_ID_STD(std_mask));
mbed_official 146:f64d43ff0c18 1570
mbed_official 146:f64d43ff0c18 1571 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1572 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1573
mbed_official 146:f64d43ff0c18 1574 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1575 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1576
mbed_official 146:f64d43ff0c18 1577 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1578 }
mbed_official 146:f64d43ff0c18 1579
mbed_official 146:f64d43ff0c18 1580 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1581 *
mbed_official 146:f64d43ff0c18 1582 * Function Name : flexcan_hal_set_rx_individual_ext_mask
mbed_official 146:f64d43ff0c18 1583 * Description : Set Rx individual mask as the 29-bit extended mask.
mbed_official 146:f64d43ff0c18 1584 *
mbed_official 146:f64d43ff0c18 1585 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1586 flexcan_status_t flexcan_hal_set_rx_individual_ext_mask(
mbed_official 146:f64d43ff0c18 1587 uint8_t instance,
mbed_official 146:f64d43ff0c18 1588 const flexcan_user_config_t * data,
mbed_official 146:f64d43ff0c18 1589 uint32_t mb_idx,
mbed_official 146:f64d43ff0c18 1590 uint32_t ext_mask)
mbed_official 146:f64d43ff0c18 1591 {
mbed_official 146:f64d43ff0c18 1592 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1593 assert(data);
mbed_official 146:f64d43ff0c18 1594
mbed_official 146:f64d43ff0c18 1595 if (mb_idx >= data->max_num_mb)
mbed_official 146:f64d43ff0c18 1596 {
mbed_official 146:f64d43ff0c18 1597 return (kStatus_FLEXCAN_OutOfRange);
mbed_official 146:f64d43ff0c18 1598 }
mbed_official 146:f64d43ff0c18 1599
mbed_official 146:f64d43ff0c18 1600 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1601 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1602
mbed_official 146:f64d43ff0c18 1603 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1604 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1605
mbed_official 146:f64d43ff0c18 1606 /* 29-bit extended mask*/
mbed_official 146:f64d43ff0c18 1607 HW_CAN_RXIMRn_WR(instance, mb_idx, CAN_ID_EXT(ext_mask));
mbed_official 146:f64d43ff0c18 1608
mbed_official 146:f64d43ff0c18 1609 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1610 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1611
mbed_official 146:f64d43ff0c18 1612 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1613 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1614
mbed_official 146:f64d43ff0c18 1615 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1616 }
mbed_official 146:f64d43ff0c18 1617
mbed_official 146:f64d43ff0c18 1618 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1619 *
mbed_official 146:f64d43ff0c18 1620 * Function Name : flexcan_hal_set_rx_mb_global_std_mask
mbed_official 146:f64d43ff0c18 1621 * Description : Set Rx Message Buffer global mask as the 11-bit standard mask.
mbed_official 146:f64d43ff0c18 1622 *
mbed_official 146:f64d43ff0c18 1623 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1624 void flexcan_hal_set_rx_mb_global_std_mask(
mbed_official 146:f64d43ff0c18 1625 uint8_t instance,
mbed_official 146:f64d43ff0c18 1626 uint32_t std_mask)
mbed_official 146:f64d43ff0c18 1627 {
mbed_official 146:f64d43ff0c18 1628 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1629
mbed_official 146:f64d43ff0c18 1630 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1631 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1632
mbed_official 146:f64d43ff0c18 1633 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1634 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1635
mbed_official 146:f64d43ff0c18 1636 /* 11 bit standard mask*/
mbed_official 146:f64d43ff0c18 1637 HW_CAN_RXMGMASK_WR(instance, CAN_ID_STD(std_mask));
mbed_official 146:f64d43ff0c18 1638
mbed_official 146:f64d43ff0c18 1639 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1640 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1641
mbed_official 146:f64d43ff0c18 1642 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1643 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1644 }
mbed_official 146:f64d43ff0c18 1645
mbed_official 146:f64d43ff0c18 1646 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1647 *
mbed_official 146:f64d43ff0c18 1648 * Function Name : flexcan_hal_set_rx_mb_buf14_std_mask
mbed_official 146:f64d43ff0c18 1649 * Description : Set Rx Message Buffer 14 mask as the 11-bit standard mask.
mbed_official 146:f64d43ff0c18 1650 *
mbed_official 146:f64d43ff0c18 1651 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1652 void flexcan_hal_set_rx_mb_buf14_std_mask(
mbed_official 146:f64d43ff0c18 1653 uint8_t instance,
mbed_official 146:f64d43ff0c18 1654 uint32_t std_mask)
mbed_official 146:f64d43ff0c18 1655 {
mbed_official 146:f64d43ff0c18 1656 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1657
mbed_official 146:f64d43ff0c18 1658 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1659 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1660
mbed_official 146:f64d43ff0c18 1661 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1662 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1663
mbed_official 146:f64d43ff0c18 1664 /* 11 bit standard mask*/
mbed_official 146:f64d43ff0c18 1665 HW_CAN_RX14MASK_WR(instance, CAN_ID_STD(std_mask));
mbed_official 146:f64d43ff0c18 1666
mbed_official 146:f64d43ff0c18 1667 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1668 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1669
mbed_official 146:f64d43ff0c18 1670 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1671 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1672 }
mbed_official 146:f64d43ff0c18 1673
mbed_official 146:f64d43ff0c18 1674 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1675 *
mbed_official 146:f64d43ff0c18 1676 * Function Name : flexcan_hal_set_rx_mb_buf15_std_mask
mbed_official 146:f64d43ff0c18 1677 * Description : Set Rx Message Buffer 15 mask as the 11-bit standard mask.
mbed_official 146:f64d43ff0c18 1678 *
mbed_official 146:f64d43ff0c18 1679 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1680 void flexcan_hal_set_rx_mb_buf15_std_mask(
mbed_official 146:f64d43ff0c18 1681 uint8_t instance,
mbed_official 146:f64d43ff0c18 1682 uint32_t std_mask)
mbed_official 146:f64d43ff0c18 1683 {
mbed_official 146:f64d43ff0c18 1684 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1685
mbed_official 146:f64d43ff0c18 1686 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1687 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1688
mbed_official 146:f64d43ff0c18 1689 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1690 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1691
mbed_official 146:f64d43ff0c18 1692 /* 11 bit standard mask*/
mbed_official 146:f64d43ff0c18 1693 HW_CAN_RX15MASK_WR(instance, CAN_ID_STD(std_mask));
mbed_official 146:f64d43ff0c18 1694
mbed_official 146:f64d43ff0c18 1695 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1696 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1697
mbed_official 146:f64d43ff0c18 1698 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1699 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1700 }
mbed_official 146:f64d43ff0c18 1701
mbed_official 146:f64d43ff0c18 1702 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1703 *
mbed_official 146:f64d43ff0c18 1704 * Function Name : flexcan_hal_set_rx_mb_global_ext_mask
mbed_official 146:f64d43ff0c18 1705 * Description : Set Rx Message Buffer global mask as the 29-bit extended mask.
mbed_official 146:f64d43ff0c18 1706 *
mbed_official 146:f64d43ff0c18 1707 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1708 void flexcan_hal_set_rx_mb_global_ext_mask(
mbed_official 146:f64d43ff0c18 1709 uint8_t instance,
mbed_official 146:f64d43ff0c18 1710 uint32_t ext_mask)
mbed_official 146:f64d43ff0c18 1711 {
mbed_official 146:f64d43ff0c18 1712 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1713
mbed_official 146:f64d43ff0c18 1714 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1715 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1716
mbed_official 146:f64d43ff0c18 1717 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1718 while (!(HW_CAN_MCR_RD(instance))){}
mbed_official 146:f64d43ff0c18 1719
mbed_official 146:f64d43ff0c18 1720 /* 29-bit extended mask*/
mbed_official 146:f64d43ff0c18 1721 HW_CAN_RXMGMASK_WR(instance, CAN_ID_EXT(ext_mask));
mbed_official 146:f64d43ff0c18 1722
mbed_official 146:f64d43ff0c18 1723 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1724 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1725
mbed_official 146:f64d43ff0c18 1726 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1727 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1728 }
mbed_official 146:f64d43ff0c18 1729
mbed_official 146:f64d43ff0c18 1730 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1731 *
mbed_official 146:f64d43ff0c18 1732 * Function Name : flexcan_hal_set_rx_mb_buf14_ext_mask
mbed_official 146:f64d43ff0c18 1733 * Description : Set Rx Message Buffer 14 mask as the 29-bit extended mask.
mbed_official 146:f64d43ff0c18 1734 *
mbed_official 146:f64d43ff0c18 1735 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1736 void flexcan_hal_set_rx_mb_buf14_ext_mask(
mbed_official 146:f64d43ff0c18 1737 uint8_t instance,
mbed_official 146:f64d43ff0c18 1738 uint32_t ext_mask)
mbed_official 146:f64d43ff0c18 1739 {
mbed_official 146:f64d43ff0c18 1740 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1741
mbed_official 146:f64d43ff0c18 1742 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1743 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1744
mbed_official 146:f64d43ff0c18 1745 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1746 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1747
mbed_official 146:f64d43ff0c18 1748 /* 29-bit extended mask*/
mbed_official 146:f64d43ff0c18 1749 HW_CAN_RX14MASK_WR(instance, CAN_ID_EXT(ext_mask));
mbed_official 146:f64d43ff0c18 1750
mbed_official 146:f64d43ff0c18 1751 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1752 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1753
mbed_official 146:f64d43ff0c18 1754 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1755 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1756 }
mbed_official 146:f64d43ff0c18 1757
mbed_official 146:f64d43ff0c18 1758 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1759 *
mbed_official 146:f64d43ff0c18 1760 * Function Name : flexcan_hal_set_rx_mb_buf15_ext_mask
mbed_official 146:f64d43ff0c18 1761 * Description : Set Rx Message Buffer 15 mask as the 29-bit extended mask.
mbed_official 146:f64d43ff0c18 1762 *
mbed_official 146:f64d43ff0c18 1763 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1764 void flexcan_hal_set_rx_mb_buf15_ext_mask(
mbed_official 146:f64d43ff0c18 1765 uint8_t instance,
mbed_official 146:f64d43ff0c18 1766 uint32_t ext_mask)
mbed_official 146:f64d43ff0c18 1767 {
mbed_official 146:f64d43ff0c18 1768 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1769
mbed_official 146:f64d43ff0c18 1770 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1771 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1772
mbed_official 146:f64d43ff0c18 1773 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1774 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1775
mbed_official 146:f64d43ff0c18 1776 /* 29-bit extended mask*/
mbed_official 146:f64d43ff0c18 1777 HW_CAN_RX15MASK_WR(instance, CAN_ID_EXT(ext_mask));
mbed_official 146:f64d43ff0c18 1778
mbed_official 146:f64d43ff0c18 1779 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1780 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1781
mbed_official 146:f64d43ff0c18 1782 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1783 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1784 }
mbed_official 146:f64d43ff0c18 1785
mbed_official 146:f64d43ff0c18 1786 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1787 *
mbed_official 146:f64d43ff0c18 1788 * Function Name : flexcan_hal_enable_operation_mode
mbed_official 146:f64d43ff0c18 1789 * Description : Enable a FlexCAN operation mode.
mbed_official 146:f64d43ff0c18 1790 * This function will enable one of the modes listed in flexcan_operation_modes_t.
mbed_official 146:f64d43ff0c18 1791 *
mbed_official 146:f64d43ff0c18 1792 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1793 flexcan_status_t flexcan_hal_enable_operation_mode(
mbed_official 146:f64d43ff0c18 1794 uint8_t instance,
mbed_official 146:f64d43ff0c18 1795 flexcan_operation_modes_t mode)
mbed_official 146:f64d43ff0c18 1796 {
mbed_official 146:f64d43ff0c18 1797 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1798
mbed_official 146:f64d43ff0c18 1799 if (mode == kFlexCanFreezeMode)
mbed_official 146:f64d43ff0c18 1800 {
mbed_official 146:f64d43ff0c18 1801 /* Debug mode, Halt and Freeze*/
mbed_official 146:f64d43ff0c18 1802 HW_CAN_MCR_SET(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1803
mbed_official 146:f64d43ff0c18 1804 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1805 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1806
mbed_official 146:f64d43ff0c18 1807 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1808 }
mbed_official 146:f64d43ff0c18 1809 else if (mode == kFlexCanDisableMode)
mbed_official 146:f64d43ff0c18 1810 {
mbed_official 146:f64d43ff0c18 1811 /* Debug mode, Halt and Freeze*/
mbed_official 146:f64d43ff0c18 1812 HW_CAN_MCR_SET(instance, BM_CAN_MCR_MDIS);
mbed_official 146:f64d43ff0c18 1813 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1814 }
mbed_official 146:f64d43ff0c18 1815
mbed_official 146:f64d43ff0c18 1816 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1817 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1818
mbed_official 146:f64d43ff0c18 1819 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1820 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1821
mbed_official 146:f64d43ff0c18 1822 if (mode == kFlexCanNormalMode)
mbed_official 146:f64d43ff0c18 1823 {
mbed_official 146:f64d43ff0c18 1824 HW_CAN_MCR_CLR(instance, BM_CAN_MCR_SUPV);
mbed_official 146:f64d43ff0c18 1825 }
mbed_official 146:f64d43ff0c18 1826 else if (mode == kFlexCanListenOnlyMode)
mbed_official 146:f64d43ff0c18 1827 {
mbed_official 146:f64d43ff0c18 1828 HW_CAN_CTRL1_SET(instance, BM_CAN_CTRL1_LOM);
mbed_official 146:f64d43ff0c18 1829 }
mbed_official 146:f64d43ff0c18 1830 else if (mode == kFlexCanLoopBackMode)
mbed_official 146:f64d43ff0c18 1831 {
mbed_official 146:f64d43ff0c18 1832 HW_CAN_CTRL1_SET(instance, BM_CAN_CTRL1_LPB);
mbed_official 146:f64d43ff0c18 1833 }
mbed_official 146:f64d43ff0c18 1834 else
mbed_official 146:f64d43ff0c18 1835 {
mbed_official 146:f64d43ff0c18 1836 return kStatus_FLEXCAN_InvalidArgument;
mbed_official 146:f64d43ff0c18 1837 }
mbed_official 146:f64d43ff0c18 1838
mbed_official 146:f64d43ff0c18 1839 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1840 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1841
mbed_official 146:f64d43ff0c18 1842 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1843 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1844
mbed_official 146:f64d43ff0c18 1845 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1846 }
mbed_official 146:f64d43ff0c18 1847
mbed_official 146:f64d43ff0c18 1848 /*FUNCTION**********************************************************************
mbed_official 146:f64d43ff0c18 1849 *
mbed_official 146:f64d43ff0c18 1850 * Function Name : flexcan_hal_disable_operation_mode
mbed_official 146:f64d43ff0c18 1851 * Description : Disable a FlexCAN operation mode.
mbed_official 146:f64d43ff0c18 1852 * This function will disable one of the modes listed in flexcan_operation_modes_t.
mbed_official 146:f64d43ff0c18 1853 *
mbed_official 146:f64d43ff0c18 1854 *END**************************************************************************/
mbed_official 146:f64d43ff0c18 1855 flexcan_status_t flexcan_hal_disable_operation_mode(
mbed_official 146:f64d43ff0c18 1856 uint8_t instance,
mbed_official 146:f64d43ff0c18 1857 flexcan_operation_modes_t mode)
mbed_official 146:f64d43ff0c18 1858 {
mbed_official 146:f64d43ff0c18 1859 assert(instance < HW_CAN_INSTANCE_COUNT);
mbed_official 146:f64d43ff0c18 1860
mbed_official 146:f64d43ff0c18 1861 if (mode == kFlexCanFreezeMode)
mbed_official 146:f64d43ff0c18 1862 {
mbed_official 146:f64d43ff0c18 1863 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1864 HW_CAN_MCR_CLR(instance, BM_CAN_MCR_FRZ);
mbed_official 146:f64d43ff0c18 1865
mbed_official 146:f64d43ff0c18 1866 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1867 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1868
mbed_official 146:f64d43ff0c18 1869 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1870 }
mbed_official 146:f64d43ff0c18 1871 else if (mode == kFlexCanDisableMode)
mbed_official 146:f64d43ff0c18 1872 {
mbed_official 146:f64d43ff0c18 1873 /* Enable module mode*/
mbed_official 146:f64d43ff0c18 1874 HW_CAN_MCR_CLR(instance, BM_CAN_MCR_MDIS);
mbed_official 146:f64d43ff0c18 1875 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1876 }
mbed_official 146:f64d43ff0c18 1877
mbed_official 146:f64d43ff0c18 1878 /* Set Freeze mode*/
mbed_official 146:f64d43ff0c18 1879 HW_CAN_MCR_SET(instance, BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT);
mbed_official 146:f64d43ff0c18 1880
mbed_official 146:f64d43ff0c18 1881 /* Wait for entering the freeze mode*/
mbed_official 146:f64d43ff0c18 1882 while (!(BR_CAN_MCR_FRZACK(instance))){}
mbed_official 146:f64d43ff0c18 1883
mbed_official 146:f64d43ff0c18 1884 if (mode == kFlexCanNormalMode)
mbed_official 146:f64d43ff0c18 1885 {
mbed_official 146:f64d43ff0c18 1886 HW_CAN_MCR_SET(instance, BM_CAN_MCR_SUPV);
mbed_official 146:f64d43ff0c18 1887 }
mbed_official 146:f64d43ff0c18 1888 else if (mode == kFlexCanListenOnlyMode)
mbed_official 146:f64d43ff0c18 1889 {
mbed_official 146:f64d43ff0c18 1890 HW_CAN_CTRL1_CLR(instance, BM_CAN_CTRL1_LOM);
mbed_official 146:f64d43ff0c18 1891 }
mbed_official 146:f64d43ff0c18 1892 else if (mode == kFlexCanLoopBackMode)
mbed_official 146:f64d43ff0c18 1893 {
mbed_official 146:f64d43ff0c18 1894 HW_CAN_CTRL1_CLR(instance, BM_CAN_CTRL1_LPB);
mbed_official 146:f64d43ff0c18 1895 }
mbed_official 146:f64d43ff0c18 1896 else
mbed_official 146:f64d43ff0c18 1897 {
mbed_official 146:f64d43ff0c18 1898 return kStatus_FLEXCAN_InvalidArgument;
mbed_official 146:f64d43ff0c18 1899 }
mbed_official 146:f64d43ff0c18 1900
mbed_official 146:f64d43ff0c18 1901 /* De-assert Freeze Mode*/
mbed_official 146:f64d43ff0c18 1902 HW_CAN_MCR_CLR(instance, (BM_CAN_MCR_FRZ | BM_CAN_MCR_HALT));
mbed_official 146:f64d43ff0c18 1903
mbed_official 146:f64d43ff0c18 1904 /* Wait till exit of freeze mode*/
mbed_official 146:f64d43ff0c18 1905 while (BR_CAN_MCR_FRZACK(instance)){}
mbed_official 146:f64d43ff0c18 1906
mbed_official 146:f64d43ff0c18 1907 return (kStatus_FLEXCAN_Success);
mbed_official 146:f64d43ff0c18 1908 }
mbed_official 146:f64d43ff0c18 1909
mbed_official 146:f64d43ff0c18 1910 /*******************************************************************************
mbed_official 146:f64d43ff0c18 1911 * EOF
mbed_official 146:f64d43ff0c18 1912 ******************************************************************************/
mbed_official 146:f64d43ff0c18 1913