git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_A53_64-bit_UltraScale_MPSoC/RTOSDemo_A53_bsp/psu_cortexa53_0/libsrc/canps_v3_2/src/xcanps.h

   1 /******************************************************************************
   2 *
   3 * Copyright (C) 2010 - 2015 Xilinx, Inc.  All rights reserved.
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a copy
   6 * of this software and associated documentation files (the "Software"), to deal
   7 * in the Software without restriction, including without limitation the rights
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 * copies of the Software, and to permit persons to whom the Software is
  10 * furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice shall be included in
  13 * all copies or substantial portions of the Software.
  14 *
  15 * Use of the Software is limited solely to applications:
  16 * (a) running on a Xilinx device, or
  17 * (b) that interact with a Xilinx device through a bus or interconnect.
  18 *
  19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  22 * XILINX  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25 * SOFTWARE.
  26 *
  27 * Except as contained in this notice, the name of the Xilinx shall not be used
  28 * in advertising or otherwise to promote the sale, use or other dealings in
  29 * this Software without prior written authorization from Xilinx.
  30 *
  31 ******************************************************************************/
  32 /*****************************************************************************/
  33 /**
  34 *
  35 * @file xcanps.h
  36 * @addtogroup canps_v3_2
  37 * @{
  38 * @details
  39 *
  40 * The Xilinx CAN driver component.  This component supports the Xilinx
  41 * CAN Controller.
  42 *
  43 * The CAN Controller supports the following features:
  44 *       - Confirms to the ISO 11898-1, CAN 2.0A and CAN 2.0B standards.
  45 *       - Supports both Standard (11 bit Identifier) and Extended (29 bit
  46 *         Identifier) frames.
  47 *       - Supports Bit Rates up to 1 Mbps.
  48 *       - Transmit message object FIFO with a user configurable depth of
  49 *         up to 64 message objects.
  50 *       - Transmit prioritization through one TX High Priority Buffer.
  51 *       - Receive message object FIFO with a user configurable depth of
  52 *         up to 64 message objects.
  53 *       - Watermark interrupts for Rx FIFO with configurable Watermark.
  54 *       - Acceptance filtering with 4 acceptance filters.
  55 *       - Sleep mode with automatic wake up.
  56 *       - Loop Back mode for diagnostic applications.
  57 *       - Snoop mode for diagnostic applications.
  58 *       - Maskable Error and Status Interrupts.
  59 *       - Readable Error Counters.
  60 *       - External PHY chip required.
  61 *       - Receive Timestamp.
  62 *
  63 * The device driver supports all the features listed above, if applicable.
  64 *
  65 * <b>Driver Description</b>
  66 *
  67 * The device driver enables higher layer software (e.g., an application) to
  68 * communicate to the CAN. The driver handles transmission and reception of
  69 * CAN frames, as well as configuration of the controller. The driver is simply a
  70 * pass-through mechanism between a protocol stack and the CAN. A single device
  71 * driver can support multiple CANs.
  72 *
  73 * Since the driver is a simple pass-through mechanism between a protocol stack
  74 * and the CAN, no assembly or disassembly of CAN frames is done at the
  75 * driver-level. This assumes that the protocol stack passes a correctly
  76 * formatted CAN frame to the driver for transmission, and that the driver
  77 * does not validate the contents of an incoming frame
  78 *
  79 * <b>Operation Modes</b>
  80 *
  81 * The CAN controller supports the following modes of operation:
  82 *   - <b>Configuration Mode</b>: In this mode the CAN timing parameters and
  83 *        Baud Rate Pre-scalar parameters can be changed. In this mode the CAN
  84 *        controller loses synchronization with the CAN bus and drives a
  85 *        constant recessive bit on the bus line. The Error Counter Register are
  86 *        reset. The CAN controller does not receive or transmit any messages
  87 *        even if there are pending transmit requests from the TX FIFO or the TX
  88 *        High Priority Buffer. The Storage FIFOs and the CAN configuration
  89 *        registers are still accessible.
  90 *   - <b>Normal Mode</b>:In Normal Mode the CAN controller participates in bus
  91 *        communication, by transmitting and receiving messages.
  92 *   - <b>Sleep Mode</b>: In Sleep Mode the CAN Controller does not transmit any
  93 *        messages. However, if any other node transmits a message, then the CAN
  94 *        Controller receives the transmitted message and exits from Sleep Mode.
  95 *        If there are new transmission requests from either the TX FIFO or the
  96 *        TX High Priority Buffer when the CAN Controller is in Sleep Mode, these
  97 *        requests are not serviced, and the CAN Controller continues to remain
  98 *        in Sleep Mode. Interrupts are generated when the CAN controller enters
  99 *       Sleep mode or Wakes up from Sleep mode.
 100 *   - <b>Loop Back Mode</b>: In Loop Back mode, the CAN controller transmits a
 101 *        recessive bit stream on to the CAN Bus. Any message that is transmitted
 102 *        is looped back to the �Rx� line and acknowledged. The CAN controller
 103 *        thus receives any message that it transmits. It does not participate in
 104 *        normal bus communication and does not receive any messages that are
 105 *        transmitted by other CAN nodes. This mode is used for diagnostic
 106 *        purposes.
 107 *   - <b>Snoop Mode</b>: In Snoop mode, the CAN controller transmits a
 108 *        recessive bit stream on to the CAN Bus and does not participate
 109 *        in normal bus communication but receives messages that are transmitted
 110 *        by other CAN nodes. This mode is used for diagnostic purposes.
 111 *
 112 *
 113 * <b>Buffer Alignment</b>
 114 *
 115 * It is important to note that frame buffers passed to the driver must be
 116 * 32-bit aligned.
 117 *
 118 * <b>Receive Address Filtering</b>
 119 *
 120 * The device can be set to accept frames whose Identifiers match any of the
 121 * 4 filters set in the Acceptance Filter Mask/ID registers.
 122 *
 123 * The incoming Identifier is masked with the bits in the Acceptance Filter Mask
 124 * Register. This value is compared with the result of masking the bits in the
 125 * Acceptance Filter ID Register with the Acceptance Filter Mask Register. If
 126 * both these values are equal, the message will be stored in the RX FIFO.
 127 *
 128 * Acceptance Filtering is performed by each of the defined acceptance filters.
 129 * If the incoming identifier passes through any acceptance filter then the
 130 * frame is stored in the RX FIFO.
 131 *
 132 * If the Accpetance Filters are not set up then all the received messages are
 133 * stroed in the RX FIFO.
 134 *
 135 * <b>PHY Communication</b>
 136 *
 137 * This driver does not provide any mechanism for directly programming PHY.
 138 *
 139 * <b>Interrupts</b>
 140 *
 141 * The driver has no dependencies on the interrupt controller. The driver
 142 * provides an interrupt handler. User of this driver needs to provide
 143 * callback functions. An interrupt handler example is available with
 144 * the driver.
 145 *
 146 * <b>Threads</b>
 147 *
 148 * This driver is not thread safe.  Any needs for threads or thread mutual
 149 * exclusion must be satisfied by the layer above this driver.
 150 *
 151 * <b>Device Reset</b>
 152 *
 153 * Bus Off interrupt that can occur in the device requires a device reset.
 154 * The user is responsible for resetting the device and re-configuring it
 155 * based on its needs (the driver does not save the current configuration).
 156 * When integrating into an RTOS, these reset and re-configure obligations are
 157 * taken care of by the OS adapter software if it exists for that RTOS.
 158 *
 159 * <b>Device Configuration</b>
 160 *
 161 * The device can be configured in various ways during the FPGA implementation
 162 * process. Configuration parameters are stored in the xcanps_g.c files.
 163 * A table is defined where each entry contains configuration information
 164 * for a CAN device.  This information includes such things as the base address
 165 * of the memory-mapped device.
 166 *
 167 * <b>Asserts</b>
 168 *
 169 * Asserts are used within all Xilinx drivers to enforce constraints on argument
 170 * values. Asserts can be turned off on a system-wide basis by defining, at
 171 * compile time, the NDEBUG identifier. By default, asserts are turned on and it
 172 * is recommended that users leave asserts on during development.
 173 *
 174 * <b>Building the driver</b>
 175 *
 176 * The XCanPs driver is composed of several source files. This allows the user
 177 * to build and link only those parts of the driver that are necessary.
 178 * <br><br>
 179 *
 180 * <pre>
 181 * MODIFICATION HISTORY:
 182 *
 183 * Ver   Who    Date     Changes
 184 * ----- -----  -------- -----------------------------------------------
 185 * 1.00a xd/sv  01/12/10 First release
 186 * 1.01a bss    12/27/11 Added the APIs XCanPs_SetTxIntrWatermark and
 187 *                       XCanPs_GetTxIntrWatermark.
 188 *                       Updated the Register/bit definitions
 189 *                       Changed XCANPS_RXFWIR_RXFLL_MASK to XCANPS_WIR_FW_MASK
 190 *                       Changed XCANPS_RXWIR_OFFSET to XCANPS_WIR_OFFSET
 191 *                       Added XCANPS_IXR_TXFEMP_MASK for Tx Fifo Empty
 192 *                       Changed XCANPS_IXR_RXFLL_MASK to
 193 *                       XCANPS_IXR_RXFWMFLL_MASK
 194 *                       Changed
 195 *                       XCANPS_TXBUF_ID_OFFSET to XCANPS_TXHPB_ID_OFFSET
 196 *                       XCANPS_TXBUF_DLC_OFFSET to XCANPS_TXHPB_DLC_OFFSET
 197 *                       XCANPS_TXBUF_DW1_OFFSET to XCANPS_TXHPB_DW1_OFFSET
 198 *                       XCANPS_TXBUF_DW2_OFFSET to XCANPS_TXHPB_DW2_OFFSET
 199 * 2.1 adk               23/08/14 Fixed CR:798792 Peripheral test for CANPS IP in
 200 *                       SDK claims a 40kbps baud rate but it's not.
 201 * 3.0 adk     09/12/14  Added support for Zynq Ultrascale Mp.Also code
 202 *                       modified for MISRA-C:2012 compliance.
 203 * 3.1 adk     10/11/15  Fixed CR#911958 Add support for Tx Watermark example.
 204 *                       Data mismatch while sending data less than 8 bytes.
 205 * 3.1 nsk     12/21/15  Updated XCanPs_IntrHandler in xcanps_intr.c to handle
 206 *                       error interrupts correctly. CR#925615
 207 *     ms      03/17/17  Added readme.txt file in examples folder for doxygen
 208 *                       generation.
 209 * </pre>
 210 *
 211 ******************************************************************************/
 212 #ifndef XCANPS_H                        /* prevent circular inclusions */
 213 #define XCANPS_H                        /* by using protection macros */
 214
 215 #ifdef __cplusplus
 216 extern "C" {
 217 #endif
 218
 219 /***************************** Include Files *********************************/
 220
 221 #include "xstatus.h"
 222 #include "xcanps_hw.h"
 223 #include "xil_types.h"
 224
 225 /************************** Constant Definitions *****************************/
 226
 227 /** @name CAN operation modes
 228  *  @{
 229  */
 230 #define XCANPS_MODE_CONFIG      0x00000001U /**< Configuration mode */
 231 #define XCANPS_MODE_NORMAL      0x00000002U /**< Normal mode */
 232 #define XCANPS_MODE_LOOPBACK    0x00000004U /**< Loop Back mode */
 233 #define XCANPS_MODE_SLEEP       0x00000008U /**< Sleep mode */
 234 #define XCANPS_MODE_SNOOP       0x00000010U /**< Snoop mode */
 235 /* @} */
 236
 237 /** @name Callback identifiers used as parameters to XCanPs_SetHandler()
 238  *  @{
 239  */
 240 #define XCANPS_HANDLER_SEND 1U /**< Handler type for frame sending interrupt */
 241 #define XCANPS_HANDLER_RECV 2U /**< Handler type for frame reception interrupt*/
 242 #define XCANPS_HANDLER_ERROR  3U /**< Handler type for error interrupt */
 243 #define XCANPS_HANDLER_EVENT  4U /**< Handler type for all other interrupts */
 244 /* @} */
 245
 246 /**************************** Type Definitions *******************************/
 247
 248 /**
 249  * This typedef contains configuration information for a device.
 250  */
 251 typedef struct {
 252         u16 DeviceId;           /**< Unique ID of device */
 253         u32 BaseAddr;           /**< Register base address */
 254 } XCanPs_Config;
 255
 256 /******************************************************************************/
 257 /**
 258  * Callback type for frame sending and reception interrupts.
 259  *
 260  * @param       CallBackRef is a callback reference passed in by the upper layer
 261  *              when setting the callback functions, and passed back to the
 262  *              upper layer when the callback is invoked.
 263 *******************************************************************************/
 264 typedef void (*XCanPs_SendRecvHandler) (void *CallBackRef);
 265
 266 /******************************************************************************/
 267 /**
 268  * Callback type for error interrupt.
 269  *
 270  * @param       CallBackRef is a callback reference passed in by the upper layer
 271  *              when setting the callback functions, and passed back to the
 272  *              upper layer when the callback is invoked.
 273  * @param       ErrorMask is a bit mask indicating the cause of the error. Its
 274  *              value equals 'OR'ing one or more XCANPS_ESR_* values defined in
 275  *              xcanps_hw.h
 276 *******************************************************************************/
 277 typedef void (*XCanPs_ErrorHandler) (void *CallBackRef, u32 ErrorMask);
 278
 279 /******************************************************************************/
 280 /**
 281  * Callback type for all kinds of interrupts except sending frame interrupt,
 282  * receiving frame interrupt, and error interrupt.
 283  *
 284  * @param       CallBackRef is a callback reference passed in by the upper layer
 285  *              when setting the callback functions, and passed back to the
 286  *              upper layer when the callback is invoked.
 287  * @param       Mask is a bit mask indicating the pending interrupts. Its value
 288  *              equals 'OR'ing one or more XCANPS_IXR_* defined in xcanps_hw.h
 289 *******************************************************************************/
 290 typedef void (*XCanPs_EventHandler) (void *CallBackRef, u32 Mask);
 291
 292 /**
 293  * The XCanPs driver instance data. The user is required to allocate a
 294  * variable of this type for every CAN device in the system. A pointer
 295  * to a variable of this type is then passed to the driver API functions.
 296  */
 297 typedef struct {
 298         XCanPs_Config CanConfig;        /**< Device configuration */
 299         u32 IsReady;                    /**< Device is initialized and ready */
 300
 301         /**
 302          * Callback and callback reference for TXOK interrupt.
 303          */
 304         XCanPs_SendRecvHandler SendHandler;
 305         void *SendRef;
 306
 307         /**
 308          * Callback and callback reference for RXOK/RXNEMP/RXFLL interrupts.
 309          */
 310         XCanPs_SendRecvHandler RecvHandler;
 311         void *RecvRef;
 312
 313         /**
 314          * Callback and callback reference for ERROR interrupt.
 315          */
 316         XCanPs_ErrorHandler ErrorHandler;
 317         void *ErrorRef;
 318
 319         /**
 320          * Callback  and callback reference for RXOFLW/RXUFLW/TXBFLL/TXFLL/
 321          * Wakeup/Sleep/Bus off/ARBLST interrupts.
 322          */
 323         XCanPs_EventHandler EventHandler;
 324         void *EventRef;
 325
 326 } XCanPs;
 327
 328
 329 /***************** Macros (Inline Functions) Definitions *********************/
 330
 331 /****************************************************************************/
 332 /**
 333 *
 334 * This macro checks if the transmission is complete.
 335 *
 336 * @param        InstancePtr is a pointer to the XCanPs instance.
 337 *
 338 * @return
 339 *               - TRUE if the transmission is done.
 340 *               - FALSE if the transmission is not done.
 341 *
 342 * @note         C-Style signature:
 343 *               int XCanPs_IsTxDone(XCanPs *InstancePtr)
 344 *
 345 *******************************************************************************/
 346 #define XCanPs_IsTxDone(InstancePtr) \
 347         (((XCanPs_ReadReg(((InstancePtr)->CanConfig.BaseAddr),          \
 348                 XCANPS_ISR_OFFSET) & XCANPS_IXR_TXOK_MASK) != (u32)0) ? TRUE : FALSE)
 349
 350
 351 /****************************************************************************/
 352 /**
 353 *
 354 * This macro checks if the transmission FIFO is full.
 355 *
 356 * @param        InstancePtr is a pointer to the XCanPs instance.
 357 *
 358 * @return
 359 *               - TRUE if TX FIFO is full.
 360 *               - FALSE if the TX FIFO is NOT full.
 361 *
 362 * @note         C-Style signature:
 363 *               int XCanPs_IsTxFifoFull(XCanPs *InstancePtr)
 364 *
 365 *****************************************************************************/
 366 #define XCanPs_IsTxFifoFull(InstancePtr) \
 367         (((XCanPs_ReadReg(((InstancePtr)->CanConfig.BaseAddr),  \
 368                 XCANPS_SR_OFFSET) & XCANPS_SR_TXFLL_MASK) != (u32)0) ? TRUE : FALSE)
 369
 370
 371 /****************************************************************************/
 372 /**
 373 *
 374 * This macro checks if the Transmission High Priority Buffer is full.
 375 *
 376 * @param        InstancePtr is a pointer to the XCanPs instance.
 377 *
 378 * @return
 379 *               - TRUE if the TX High Priority Buffer is full.
 380 *               - FALSE if the TX High Priority Buffer is NOT full.
 381 *
 382 * @note         C-Style signature:
 383 *               int XCanPs_IsHighPriorityBufFull(XCanPs *InstancePtr)
 384 *
 385 *****************************************************************************/
 386 #define XCanPs_IsHighPriorityBufFull(InstancePtr) \
 387         (((XCanPs_ReadReg(((InstancePtr)->CanConfig.BaseAddr),  \
 388                 XCANPS_SR_OFFSET) & XCANPS_SR_TXBFLL_MASK) != (u32)0) ? TRUE : FALSE)
 389
 390
 391 /****************************************************************************/
 392 /**
 393 *
 394 * This macro checks if the receive FIFO is empty.
 395 *
 396 * @param        InstancePtr is a pointer to the XCanPs instance.
 397 *
 398 * @return
 399 *               - TRUE if RX FIFO is empty.
 400 *               - FALSE if the RX FIFO is NOT empty.
 401 *
 402 * @note         C-Style signature:
 403 *               int XCanPs_IsRxEmpty(XCanPs *InstancePtr)
 404 *
 405 *****************************************************************************/
 406 #define XCanPs_IsRxEmpty(InstancePtr) \
 407         (((XCanPs_ReadReg(((InstancePtr)->CanConfig.BaseAddr),  \
 408                 XCANPS_ISR_OFFSET) & XCANPS_IXR_RXNEMP_MASK) != (u32)0) ? FALSE : TRUE)
 409
 410
 411 /****************************************************************************/
 412 /**
 413 *
 414 * This macro checks if the CAN device is ready for the driver to change
 415 * Acceptance Filter Identifier Registers (AFIR) and Acceptance Filter Mask
 416 * Registers (AFMR).
 417 *
 418 * AFIR and AFMR for a filter are changeable only after the filter is disabled
 419 * and this routine returns FALSE. The filter can be disabled using the
 420 * XCanPs_AcceptFilterDisable function.
 421 *
 422 * Use the XCanPs_Accept_* functions for configuring the acceptance filters.
 423 *
 424 * @param        InstancePtr is a pointer to the XCanPs instance.
 425 *
 426 * @return
 427 *               - TRUE if the device is busy and NOT ready to accept writes to
 428 *               AFIR and AFMR.
 429 *               - FALSE if the device is ready to accept writes to AFIR and
 430 *               AFMR.
 431 *
 432 * @note         C-Style signature:
 433 *               int XCanPs_IsAcceptFilterBusy(XCanPs *InstancePtr)
 434 *
 435 *****************************************************************************/
 436 #define XCanPs_IsAcceptFilterBusy(InstancePtr)          \
 437         (((XCanPs_ReadReg(((InstancePtr)->CanConfig.BaseAddr),  \
 438                 XCANPS_SR_OFFSET) & XCANPS_SR_ACFBSY_MASK) != (u32)0) ? TRUE : FALSE)
 439
 440
 441 /****************************************************************************/
 442 /**
 443 *
 444 * This macro calculates CAN message identifier value given identifier field
 445 * values.
 446 *
 447 * @param        StandardId contains Standard Message ID value.
 448 * @param        SubRemoteTransReq contains Substitute Remote Transmission
 449 *               Request value.
 450 * @param        IdExtension contains Identifier Extension value.
 451 * @param        ExtendedId contains Extended Message ID value.
 452 * @param        RemoteTransReq contains Remote Transmission Request value.
 453 *
 454 * @return       Message Identifier value.
 455 *
 456 * @note         C-Style signature:
 457 *               u32 XCanPs_CreateIdValue(u32 StandardId,
 458 *                                       u32 SubRemoteTransReq,
 459 *                                       u32 IdExtension, u32 ExtendedId,
 460 *                                       u32 RemoteTransReq)
 461 *
 462 *               Read the CAN specification for meaning of each parameter.
 463 *
 464 *****************************************************************************/
 465 #define XCanPs_CreateIdValue(StandardId, SubRemoteTransReq, IdExtension, \
 466                 ExtendedId, RemoteTransReq)                             \
 467  ((((StandardId) << XCANPS_IDR_ID1_SHIFT) & XCANPS_IDR_ID1_MASK) |      \
 468  (((SubRemoteTransReq) << XCANPS_IDR_SRR_SHIFT) & XCANPS_IDR_SRR_MASK)|\
 469  (((IdExtension) << XCANPS_IDR_IDE_SHIFT) & XCANPS_IDR_IDE_MASK) |      \
 470  (((ExtendedId) << XCANPS_IDR_ID2_SHIFT) & XCANPS_IDR_ID2_MASK) |       \
 471  ((RemoteTransReq) & XCANPS_IDR_RTR_MASK))
 472
 473
 474 /****************************************************************************/
 475 /**
 476 *
 477 * This macro calculates value for Data Length Code register given Data
 478 * Length Code value.
 479 *
 480 * @param        DataLengCode indicates Data Length Code value.
 481 *
 482 * @return       Value that can be assigned to Data Length Code register.
 483 *
 484 * @note         C-Style signature:
 485 *               u32 XCanPs_CreateDlcValue(u32 DataLengCode)
 486 *
 487 *               Read the CAN specification for meaning of Data Length Code.
 488 *
 489 *****************************************************************************/
 490 #define XCanPs_CreateDlcValue(DataLengCode) \
 491         (((DataLengCode) << XCANPS_DLCR_DLC_SHIFT) & XCANPS_DLCR_DLC_MASK)
 492
 493
 494 /****************************************************************************/
 495 /**
 496 *
 497 * This macro clears the timestamp in the Timestamp Control Register.
 498 *
 499 * @param        InstancePtr is a pointer to the XCanPs instance.
 500 *
 501 * @return       None.
 502 *
 503 * @note         C-Style signature:
 504 *               void XCanPs_ClearTimestamp(XCanPs *InstancePtr)
 505 *
 506 *****************************************************************************/
 507 #define XCanPs_ClearTimestamp(InstancePtr)                      \
 508         XCanPs_WriteReg((InstancePtr)->CanConfig.BaseAddr,              \
 509                                 XCANPS_TCR_OFFSET, XCANPS_TCR_CTS_MASK)
 510
 511 /************************** Function Prototypes ******************************/
 512
 513 /*
 514  * Functions in xcanps.c
 515  */
 516 s32 XCanPs_CfgInitialize(XCanPs *InstancePtr, XCanPs_Config *ConfigPtr,
 517                                 u32 EffectiveAddr);
 518
 519 void XCanPs_Reset(XCanPs *InstancePtr);
 520 u8 XCanPs_GetMode(XCanPs *InstancePtr);
 521 void XCanPs_EnterMode(XCanPs *InstancePtr, u8 OperationMode);
 522 u32 XCanPs_GetStatus(XCanPs *InstancePtr);
 523 void XCanPs_GetBusErrorCounter(XCanPs *InstancePtr, u8 *RxErrorCount,
 524                                  u8 *TxErrorCount);
 525 u32 XCanPs_GetBusErrorStatus(XCanPs *InstancePtr);
 526 void XCanPs_ClearBusErrorStatus(XCanPs *InstancePtr, u32 Mask);
 527 s32 XCanPs_Send(XCanPs *InstancePtr, u32 *FramePtr);
 528 s32 XCanPs_Recv(XCanPs *InstancePtr, u32 *FramePtr);
 529 s32 XCanPs_SendHighPriority(XCanPs *InstancePtr, u32 *FramePtr);
 530 void XCanPs_AcceptFilterEnable(XCanPs *InstancePtr, u32 FilterIndexes);
 531 void XCanPs_AcceptFilterDisable(XCanPs *InstancePtr, u32 FilterIndexes);
 532 u32 XCanPs_AcceptFilterGetEnabled(XCanPs *InstancePtr);
 533 s32 XCanPs_AcceptFilterSet(XCanPs *InstancePtr, u32 FilterIndex,
 534                          u32 MaskValue, u32 IdValue);
 535 void XCanPs_AcceptFilterGet(XCanPs *InstancePtr, u32 FilterIndex,
 536                           u32 *MaskValue, u32 *IdValue);
 537
 538 s32 XCanPs_SetBaudRatePrescaler(XCanPs *InstancePtr, u8 Prescaler);
 539 u8 XCanPs_GetBaudRatePrescaler(XCanPs *InstancePtr);
 540 s32 XCanPs_SetBitTiming(XCanPs *InstancePtr, u8 SyncJumpWidth,
 541                           u8 TimeSegment2, u8 TimeSegment1);
 542 void XCanPs_GetBitTiming(XCanPs *InstancePtr, u8 *SyncJumpWidth,
 543                            u8 *TimeSegment2, u8 *TimeSegment1);
 544
 545 s32 XCanPs_SetRxIntrWatermark(XCanPs *InstancePtr, u8 Threshold);
 546 u8 XCanPs_GetRxIntrWatermark(XCanPs *InstancePtr);
 547 s32 XCanPs_SetTxIntrWatermark(XCanPs *InstancePtr, u8 Threshold);
 548 u8 XCanPs_GetTxIntrWatermark(XCanPs *InstancePtr);
 549
 550 /*
 551  * Diagnostic functions in xcanps_selftest.c
 552  */
 553 s32 XCanPs_SelfTest(XCanPs *InstancePtr);
 554
 555 /*
 556  * Functions in xcanps_intr.c
 557  */
 558 void XCanPs_IntrEnable(XCanPs *InstancePtr, u32 Mask);
 559 void XCanPs_IntrDisable(XCanPs *InstancePtr, u32 Mask);
 560 u32 XCanPs_IntrGetEnabled(XCanPs *InstancePtr);
 561 u32 XCanPs_IntrGetStatus(XCanPs *InstancePtr);
 562 void XCanPs_IntrClear(XCanPs *InstancePtr, u32 Mask);
 563 void XCanPs_IntrHandler(void *InstancePtr);
 564 s32 XCanPs_SetHandler(XCanPs *InstancePtr, u32 HandlerType,
 565                         void *CallBackFunc, void *CallBackRef);
 566
 567 /*
 568  * Functions in xcanps_sinit.c
 569  */
 570 XCanPs_Config *XCanPs_LookupConfig(u16 DeviceId);
 571
 572 #ifdef __cplusplus
 573 }
 574 #endif
 575
 576 #endif /* end of protection macro */
 577 /** @} */