rpp/src/rpp/fr.c

   1 /* Copyright (C) 2013, 2015 Czech Technical University in Prague
   2  *
   3  * Authors:
   4  *     - Carlos Jenkins <carlos@jenkins.co.cr>
   5  *     - Michal Horn <hornmich@fel.cvut.cz>
   6  *
   7  * This document contains proprietary information belonging to Czech
   8  * Technical University in Prague. Passing on and copying of this
   9  * document, and communication of its contents is not permitted
  10  * without prior written authorization.
  11  *
  12  * File : fr.c
  13  * Abstract:
  14  *     FlexRay Communication RPP API implementation file.
  15  *
  16  * References:
  17  *     fr.h
  18  *     RPP API documentation.
  19  */
  20
  21
  22 #include "rpp/rpp.h"
  23
  24 #ifndef FREERTOS_POSIX
  25
  26 #include "stdio.h"
  27 #include "string.h"
  28 #include "drv/drv.h"
  29 #include "hal/spi_tms570.h"
  30
  31 static rpp_fr_state_t rpp_fr_state = RPP_FR_NOT_INITIALIZED;    /**< Stores the actual state of the FlexRay module */
  32
  33 /* AUTOSAR-like API */
  34
  35 int8_t rpp_fr_init_driver(const Fr_ConfigType *config_ptr, uint32_t *error)
  36 {
  37         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED)
  38                 return FAILURE;
  39 #ifndef FREERTOS_POSIX
  40         spi_tms570_init();
  41 #endif
  42         Fr_Init(config_ptr);
  43         rpp_fr_state = RPP_FR_DRV_INITIALIZED;
  44         return SUCCESS;
  45 }
  46
  47 int8_t rpp_fr_init_controller(uint8_t ctrl, uint32_t *error)
  48 {
  49         Std_ReturnType retVal = ERR_PARAM_NO_ERROR;
  50
  51         if (rpp_fr_state == RPP_FR_DRV_INITIALIZED ||
  52                 rpp_fr_state == RPP_FR_HALTED ||
  53                 rpp_fr_state == RPP_FR_ABORTED) {
  54                 retVal = Fr_ControllerInit(ctrl);
  55                 if (retVal & E_OK) {
  56                         rpp_fr_state = RPP_FR_CTR_INITIALIZED;
  57                         return SUCCESS;
  58                 }
  59                 else {
  60                         *error = retVal;
  61                         return FAILURE;
  62                 }
  63         }
  64         return FAILURE;
  65 }
  66
  67 int8_t rpp_fr_start_communication(uint8_t ctrl, uint32_t *error)
  68 {
  69         Std_ReturnType retVal = ERR_PARAM_NO_ERROR;
  70
  71         if (rpp_fr_state == RPP_FR_CTR_INITIALIZED) {
  72                 retVal = Fr_StartCommunication(ctrl);
  73                 if (retVal & E_OK) {
  74                         rpp_fr_state = RPP_FR_RUNNING;
  75                         return SUCCESS;
  76                 }
  77                 else {
  78                         *error = retVal;
  79                         return FAILURE;
  80                 }
  81         }
  82         return FAILURE;
  83 }
  84
  85 int8_t rpp_fr_all_slots(uint8_t ctrl)
  86 {
  87         if (rpp_fr_state == RPP_FR_RUNNING && Fr_AllSlots(ctrl) & E_OK)
  88                 return SUCCESS;
  89         return FAILURE;
  90 }
  91
  92 int8_t rpp_fr_halt_communication(uint8_t ctrl)
  93 {
  94         if (rpp_fr_state == RPP_FR_RUNNING && Fr_HaltCommunication(ctrl) & E_OK) {
  95                 rpp_fr_state = RPP_FR_HALTED;
  96                 return SUCCESS;
  97         }
  98         return FAILURE;
  99 }
 100
 101 int8_t rpp_fr_abort_communication(uint8_t ctrl)
 102 {
 103         if (rpp_fr_state == RPP_FR_RUNNING && Fr_AbortCommunication(ctrl) & E_OK) {
 104                 rpp_fr_state = RPP_FR_ABORTED;
 105                 return SUCCESS;
 106         }
 107         return FAILURE;
 108 }
 109
 110 int8_t rpp_fr_send_wup(uint8_t ctrl)
 111 {
 112         if (rpp_fr_state == RPP_FR_CTR_INITIALIZED && Fr_SendWUP(ctrl) & E_OK)
 113                 return SUCCESS;
 114         return FAILURE;
 115 }
 116
 117 int8_t rpp_fr_set_wu_channel(uint8_t ctrl, Fr_ChannelType channel)
 118 {
 119         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_SetWakeupChannel(ctrl, channel) & E_OK)
 120                 return SUCCESS;
 121         return FAILURE;
 122 }
 123
 124 int8_t rpp_fr_get_poc_status(uint8_t ctrl, Fr_POCStatusType *poc_status_ptr)
 125 {
 126         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetPOCStatus(ctrl, poc_status_ptr) & E_OK)
 127                 return SUCCESS;
 128         return FAILURE;
 129 }
 130
 131 int8_t rpp_fr_transmit_lpdu(uint8_t ctrl, uint16_t lpdu_idx, const uint8_t *lsdu, uint8_t lsdu_length)
 132 {
 133         if (rpp_fr_state == RPP_FR_RUNNING && Fr_TransmitTxLPdu(ctrl, lpdu_idx, lsdu, lsdu_length) & E_OK)
 134                 return SUCCESS;
 135         return FAILURE;
 136 }
 137
 138 int8_t rpp_fr_cancel_transmit_lpdu(uint8_t ctrl, uint16_t lpdu_idx)
 139 {
 140         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CancelTxLPdu(ctrl, lpdu_idx) & E_OK)
 141                 return SUCCESS;
 142         return FAILURE;
 143 }
 144
 145 int8_t rpp_fr_receive_lpdu(uint8_t ctrl, uint16_t lpdu_idx, uint8_t *lsdu, Fr_RxLPduStatusType *lpdu_status, uint8_t *lsdu_length)
 146 {
 147         if (rpp_fr_state == RPP_FR_RUNNING && Fr_ReceiveRxLPdu(ctrl, lpdu_idx, lsdu, lpdu_status, lsdu_length) & E_OK)
 148                 return SUCCESS;
 149         return FAILURE;
 150 }
 151
 152 int8_t rpp_fr_check_tx_lpdu_status(uint8_t ctrl, uint16_t lpdu_idx, Fr_TxLPduStatusType *lpdu_status)
 153 {
 154         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CheckTxLPduStatus(ctrl, lpdu_idx, lpdu_status) & E_OK)
 155                 return SUCCESS;
 156         return FAILURE;
 157 }
 158
 159 int8_t rpp_fr_reconfigure_lpdu(uint8_t ctrl, uint16_t lpdu_idx, uint16_t frame_id, Fr_ChannelType channel, uint8_t cycle_set, uint8_t cycle_offset, uint8_t payload, uint16_t header_crc)
 160 {
 161         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_ReconfigLPdu(ctrl, lpdu_idx, frame_id, channel, cycle_set, cycle_offset, payload, header_crc) & E_OK)
 162                 return SUCCESS;
 163         return FAILURE;
 164 }
 165
 166 int8_t rpp_fr_disable_lpdu(uint8_t ctrl, uint16_t lpdu_idx)
 167 {
 168         if (rpp_fr_state == RPP_FR_RUNNING && Fr_DisableLPdu(ctrl, lpdu_idx) & E_OK)
 169                 return SUCCESS;
 170         return FAILURE;
 171 }
 172
 173 int8_t rpp_fr_get_global_time(uint8_t ctrl, uint8_t *cycle, uint16_t *macroticks)
 174 {
 175         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetGlobalTime(ctrl, cycle, macroticks) & E_OK)
 176                 return SUCCESS;
 177         return FAILURE;
 178 }
 179
 180 int8_t rpp_fr_get_network_management_vector(uint8_t ctrl, uint8_t *nm_vector)
 181 {
 182         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetNmVector(ctrl, nm_vector) & E_OK)
 183                 return SUCCESS;
 184         return FAILURE;
 185 }
 186
 187 int8_t rpp_fr_get_channel_status(uint8_t ctrl, uint16_t *channel_a_status, uint16_t *channel_b_status)
 188 {
 189         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetChannelStatus(ctrl, channel_a_status, channel_b_status) & E_OK)
 190                 return SUCCESS;
 191         return FAILURE;
 192 }
 193
 194 int8_t rpp_fr_get_clock_correction(uint8_t ctrl, int16_t *rate_correction, int32_t *offset_correction)
 195 {
 196         if (rpp_fr_state >= RPP_FR_RUNNING && Fr_GetClockCorrection(ctrl, rate_correction, offset_correction) & E_OK)
 197                 return SUCCESS;
 198         return FAILURE;
 199 }
 200
 201 int8_t rpp_fr_get_sync_frame_list(uint8_t ctrl, uint8_t list_size, uint16_t *channel_a_even_list, uint16_t *channel_b_even_list, uint16_t *channel_a_odd_list, uint16_t *channel_b_odd_list)
 202 {
 203         if (rpp_fr_state >= RPP_FR_RUNNING && Fr_GetSyncFrameList(ctrl, list_size, channel_a_even_list, channel_b_even_list, channel_a_odd_list, channel_b_odd_list) & E_OK)
 204                 return SUCCESS;
 205         return FAILURE;
 206 }
 207
 208 int8_t rpp_fr_get_wakeup_rx_status(uint8_t ctrl, uint8_t *status)
 209 {
 210         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetWakeupRxStatus(ctrl, status) & E_OK)
 211                 return SUCCESS;
 212         return FAILURE;
 213 }
 214
 215 int8_t rpp_fr_set_timer(uint8_t ctrl, uint8_t timer_idx, uint8_t cycle_set, uint16_t offset_threshold)
 216 {
 217         if (rpp_fr_state == RPP_FR_RUNNING && Fr_SetAbsoluteTimer(ctrl, timer_idx, cycle_set, offset_threshold) & E_OK)
 218                 return SUCCESS;
 219         return FAILURE;
 220 }
 221
 222 int8_t rpp_fr_cancel_timer(uint8_t ctrl, uint8_t timer_idx)
 223 {
 224         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CancelAbsoluteTimer(ctrl, timer_idx) & E_OK)
 225                 return SUCCESS;
 226         return FAILURE;
 227 }
 228
 229 int8_t rpp_fr_clear_timer_irq(uint8_t ctrl, uint8_t timer_idx)
 230 {
 231         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_AckAbsoluteTimerIRQ(ctrl, timer_idx) & E_OK)
 232                 return SUCCESS;
 233         return FAILURE;
 234 }
 235
 236 int8_t rpp_fr_get_timer_irq_status(uint8_t ctrl, uint8_t timer_idx, boolean_t *irq_pending)
 237 {
 238         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetAbsoluteTimerIRQStatus(ctrl, timer_idx, irq_pending) & E_OK)
 239                 return SUCCESS;
 240         return FAILURE;
 241 }
 242
 243 int8_t rpp_fr_get_driver_version(Std_VersionInfoType *version)
 244 {
 245         Fr_GetVersionInfo(version);
 246         return SUCCESS;
 247 }
 248
 249 int8_t rpp_fr_read_com_ctrl_config(uint8_t ctrl, uint8_t param_idx, uint32_t *param_value)
 250 {
 251         if (Fr_ReadCCConfig(ctrl, param_idx, param_value) & E_OK)
 252                 return SUCCESS;
 253         return FAILURE;
 254 }
 255 #endif /* FREERTOS_POSIX */