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 "drv/spi_def.h"
  30 #include "rpp/mutex.h"
  31
  32 RPP_MUTEX_DEFINE(mutex_fr);
  33
  34 static rpp_fr_state_t rpp_fr_state = RPP_FR_NOT_INITIALIZED;    /**< Stores the actual state of the FlexRay module */
  35
  36 /* AUTOSAR-like API */
  37
  38 int8_t rpp_fr_init_driver(const Fr_ConfigType *config_ptr, uint32_t *error)
  39 {
  40         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED)
  41                 return FAILURE;
  42 #ifndef FREERTOS_POSIX
  43         spi_tms570_init(spi_ifcs, ARRAY_SIZE(spi_ifcs));
  44 #endif
  45         if (!RPP_MUTEX_INIT(mutex_fr))
  46                 return FAILURE;
  47         Fr_Init(config_ptr);
  48         rpp_fr_state = RPP_FR_DRV_INITIALIZED;
  49         return SUCCESS;
  50 }
  51
  52 int8_t rpp_fr_init_controller(uint8_t ctrl, uint32_t *error)
  53 {
  54         Std_ReturnType retVal = ERR_PARAM_NO_ERROR;
  55         RPP_MUTEX_LOCK(mutex_fr);
  56         if (rpp_fr_state == RPP_FR_DRV_INITIALIZED ||
  57                 rpp_fr_state == RPP_FR_HALTED ||
  58                 rpp_fr_state == RPP_FR_ABORTED) {
  59                 retVal = Fr_ControllerInit(ctrl);
  60                 if (retVal & E_OK) {
  61                         rpp_fr_state = RPP_FR_CTR_INITIALIZED;
  62                         RPP_MUTEX_UNLOCK(mutex_fr);
  63                         return SUCCESS;
  64                 }
  65                 else {
  66                         *error = retVal;
  67                         RPP_MUTEX_UNLOCK(mutex_fr);
  68                         return FAILURE;
  69                 }
  70         }
  71         RPP_MUTEX_UNLOCK(mutex_fr);
  72         return FAILURE;
  73
  74 }
  75
  76 int8_t rpp_fr_start_communication(uint8_t ctrl, uint32_t *error)
  77 {
  78         Std_ReturnType retVal = ERR_PARAM_NO_ERROR;
  79
  80         RPP_MUTEX_LOCK(mutex_fr);
  81         if (rpp_fr_state == RPP_FR_CTR_INITIALIZED) {
  82                 retVal = Fr_StartCommunication(ctrl);
  83                 if (retVal & E_OK) {
  84                         rpp_fr_state = RPP_FR_RUNNING;
  85                         RPP_MUTEX_UNLOCK(mutex_fr);
  86                         return SUCCESS;
  87
  88                 }
  89                 else {
  90                         *error = retVal;
  91                         RPP_MUTEX_UNLOCK(mutex_fr);
  92                         return FAILURE;
  93                 }
  94         }
  95         RPP_MUTEX_UNLOCK(mutex_fr);
  96         return FAILURE;
  97 }
  98
  99 int8_t rpp_fr_all_slots(uint8_t ctrl)
 100 {
 101         int8_t ret;
 102
 103         RPP_MUTEX_LOCK(mutex_fr);
 104         ret = (rpp_fr_state == RPP_FR_RUNNING && Fr_AllSlots(ctrl) & E_OK);
 105         RPP_MUTEX_UNLOCK(mutex_fr);
 106
 107         return ret ? SUCCESS : FAILURE;
 108 }
 109
 110 int8_t rpp_fr_halt_communication(uint8_t ctrl)
 111 {
 112         RPP_MUTEX_LOCK(mutex_fr);
 113         if (rpp_fr_state == RPP_FR_RUNNING && Fr_HaltCommunication(ctrl) & E_OK) {
 114                 rpp_fr_state = RPP_FR_HALTED;
 115                 RPP_MUTEX_UNLOCK(mutex_fr);
 116                 return SUCCESS;
 117
 118         }
 119         RPP_MUTEX_UNLOCK(mutex_fr);
 120         return FAILURE;
 121 }
 122
 123 int8_t rpp_fr_abort_communication(uint8_t ctrl)
 124 {
 125         RPP_MUTEX_LOCK(mutex_fr);
 126         if (rpp_fr_state == RPP_FR_RUNNING && Fr_AbortCommunication(ctrl) & E_OK) {
 127                 rpp_fr_state = RPP_FR_ABORTED;
 128                 RPP_MUTEX_UNLOCK(mutex_fr);
 129                 return SUCCESS;
 130
 131         }
 132         RPP_MUTEX_UNLOCK(mutex_fr);
 133         return FAILURE;
 134 }
 135
 136 int8_t rpp_fr_send_wup(uint8_t ctrl)
 137 {
 138         RPP_MUTEX_LOCK(mutex_fr);
 139         if (rpp_fr_state == RPP_FR_CTR_INITIALIZED && Fr_SendWUP(ctrl) & E_OK) {
 140                 RPP_MUTEX_UNLOCK(mutex_fr);
 141                 return SUCCESS;
 142         }
 143
 144         RPP_MUTEX_UNLOCK(mutex_fr);
 145         return FAILURE;
 146 }
 147
 148 int8_t rpp_fr_set_wu_channel(uint8_t ctrl, Fr_ChannelType channel)
 149 {
 150         RPP_MUTEX_LOCK(mutex_fr);
 151         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_SetWakeupChannel(ctrl, channel) & E_OK) {
 152                 RPP_MUTEX_UNLOCK(mutex_fr);
 153                 return SUCCESS;
 154         }
 155
 156         RPP_MUTEX_UNLOCK(mutex_fr);
 157         return FAILURE;
 158 }
 159
 160 int8_t rpp_fr_get_poc_status(uint8_t ctrl, Fr_POCStatusType *poc_status_ptr)
 161 {
 162         RPP_MUTEX_LOCK(mutex_fr);
 163         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetPOCStatus(ctrl, poc_status_ptr) & E_OK) {
 164                 RPP_MUTEX_UNLOCK(mutex_fr);
 165                 return SUCCESS;
 166         }
 167
 168         RPP_MUTEX_UNLOCK(mutex_fr);
 169         return FAILURE;
 170 }
 171
 172 int8_t rpp_fr_transmit_lpdu(uint8_t ctrl, uint16_t lpdu_idx, const uint8_t *lsdu, uint8_t lsdu_length)
 173 {
 174         RPP_MUTEX_LOCK(mutex_fr);
 175         if (rpp_fr_state == RPP_FR_RUNNING && Fr_TransmitTxLPdu(ctrl, lpdu_idx, lsdu, lsdu_length) & E_OK) {
 176                 RPP_MUTEX_UNLOCK(mutex_fr);
 177                 return SUCCESS;
 178
 179         }
 180         RPP_MUTEX_UNLOCK(mutex_fr);
 181         return FAILURE;
 182
 183 }
 184
 185 int8_t rpp_fr_cancel_transmit_lpdu(uint8_t ctrl, uint16_t lpdu_idx)
 186 {
 187         RPP_MUTEX_LOCK(mutex_fr);
 188         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CancelTxLPdu(ctrl, lpdu_idx) & E_OK) {
 189                 RPP_MUTEX_UNLOCK(mutex_fr);
 190                 return SUCCESS;
 191         }
 192
 193         RPP_MUTEX_UNLOCK(mutex_fr);
 194         return FAILURE;
 195
 196 }
 197
 198 int8_t rpp_fr_receive_lpdu(uint8_t ctrl, uint16_t lpdu_idx, uint8_t *lsdu, Fr_RxLPduStatusType *lpdu_status, uint8_t *lsdu_length)
 199 {
 200         RPP_MUTEX_LOCK(mutex_fr);
 201         if (rpp_fr_state == RPP_FR_RUNNING && Fr_ReceiveRxLPdu(ctrl, lpdu_idx, lsdu, lpdu_status, lsdu_length) & E_OK) {
 202                 RPP_MUTEX_UNLOCK(mutex_fr);
 203                 return SUCCESS;
 204         }
 205
 206         RPP_MUTEX_UNLOCK(mutex_fr);
 207         return FAILURE;
 208
 209 }
 210
 211 int8_t rpp_fr_check_tx_lpdu_status(uint8_t ctrl, uint16_t lpdu_idx, Fr_TxLPduStatusType *lpdu_status)
 212 {
 213         RPP_MUTEX_LOCK(mutex_fr);
 214         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CheckTxLPduStatus(ctrl, lpdu_idx, lpdu_status) & E_OK) {
 215                 RPP_MUTEX_UNLOCK(mutex_fr);
 216                 return SUCCESS;
 217         }
 218
 219         RPP_MUTEX_UNLOCK(mutex_fr);
 220         return FAILURE;
 221
 222 }
 223
 224 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)
 225 {
 226         RPP_MUTEX_LOCK(mutex_fr);
 227         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) {
 228                 RPP_MUTEX_UNLOCK(mutex_fr);
 229                 return SUCCESS;
 230         }
 231
 232         RPP_MUTEX_UNLOCK(mutex_fr);
 233         return FAILURE;
 234
 235 }
 236
 237 int8_t rpp_fr_disable_lpdu(uint8_t ctrl, uint16_t lpdu_idx)
 238 {
 239         RPP_MUTEX_LOCK(mutex_fr);
 240         if (rpp_fr_state == RPP_FR_RUNNING && Fr_DisableLPdu(ctrl, lpdu_idx) & E_OK) {
 241                 RPP_MUTEX_UNLOCK(mutex_fr);
 242                 return SUCCESS;
 243         }
 244
 245         RPP_MUTEX_UNLOCK(mutex_fr);
 246         return FAILURE;
 247
 248 }
 249
 250 int8_t rpp_fr_get_global_time(uint8_t ctrl, uint8_t *cycle, uint16_t *macroticks)
 251 {
 252         RPP_MUTEX_LOCK(mutex_fr);
 253         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetGlobalTime(ctrl, cycle, macroticks) & E_OK) {
 254                 RPP_MUTEX_UNLOCK(mutex_fr);
 255                 return SUCCESS;
 256         }
 257
 258         RPP_MUTEX_UNLOCK(mutex_fr);
 259         return FAILURE;
 260
 261 }
 262
 263 int8_t rpp_fr_get_network_management_vector(uint8_t ctrl, uint8_t *nm_vector)
 264 {
 265         RPP_MUTEX_LOCK(mutex_fr);
 266         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetNmVector(ctrl, nm_vector) & E_OK) {
 267                 RPP_MUTEX_UNLOCK(mutex_fr);
 268                 return SUCCESS;
 269         }
 270
 271         RPP_MUTEX_UNLOCK(mutex_fr);
 272         return FAILURE;
 273
 274 }
 275
 276 int8_t rpp_fr_get_channel_status(uint8_t ctrl, uint16_t *channel_a_status, uint16_t *channel_b_status)
 277 {
 278         RPP_MUTEX_LOCK(mutex_fr);
 279         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetChannelStatus(ctrl, channel_a_status, channel_b_status) & E_OK) {
 280                 RPP_MUTEX_UNLOCK(mutex_fr);
 281                 return SUCCESS;
 282         }
 283
 284         RPP_MUTEX_UNLOCK(mutex_fr);
 285         return FAILURE;
 286
 287 }
 288
 289 int8_t rpp_fr_get_clock_correction(uint8_t ctrl, int16_t *rate_correction, int32_t *offset_correction)
 290 {
 291         RPP_MUTEX_LOCK(mutex_fr);
 292         if (rpp_fr_state >= RPP_FR_RUNNING && Fr_GetClockCorrection(ctrl, rate_correction, offset_correction) & E_OK) {
 293                 RPP_MUTEX_UNLOCK(mutex_fr);
 294                 return SUCCESS;
 295         }
 296
 297         RPP_MUTEX_UNLOCK(mutex_fr);
 298         return FAILURE;
 299
 300 }
 301
 302 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)
 303 {
 304         RPP_MUTEX_LOCK(mutex_fr);
 305         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) {
 306                 RPP_MUTEX_UNLOCK(mutex_fr);
 307                 return SUCCESS;
 308         }
 309
 310         RPP_MUTEX_UNLOCK(mutex_fr);
 311         return FAILURE;
 312
 313 }
 314
 315 int8_t rpp_fr_get_wakeup_rx_status(uint8_t ctrl, uint8_t *status)
 316 {
 317         RPP_MUTEX_LOCK(mutex_fr);
 318         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetWakeupRxStatus(ctrl, status) & E_OK) {
 319                 RPP_MUTEX_UNLOCK(mutex_fr);
 320                 return SUCCESS;
 321         }
 322
 323         RPP_MUTEX_UNLOCK(mutex_fr);
 324         return FAILURE;
 325
 326 }
 327
 328 int8_t rpp_fr_set_timer(uint8_t ctrl, uint8_t timer_idx, uint8_t cycle_set, uint16_t offset_threshold)
 329 {
 330         RPP_MUTEX_LOCK(mutex_fr);
 331         if (rpp_fr_state == RPP_FR_RUNNING && Fr_SetAbsoluteTimer(ctrl, timer_idx, cycle_set, offset_threshold) & E_OK) {
 332                 RPP_MUTEX_UNLOCK(mutex_fr);
 333                 return SUCCESS;
 334         }
 335
 336         RPP_MUTEX_UNLOCK(mutex_fr);
 337         return FAILURE;
 338
 339 }
 340
 341 int8_t rpp_fr_cancel_timer(uint8_t ctrl, uint8_t timer_idx)
 342 {
 343         RPP_MUTEX_LOCK(mutex_fr);
 344         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CancelAbsoluteTimer(ctrl, timer_idx) & E_OK) {
 345                 RPP_MUTEX_UNLOCK(mutex_fr);
 346                 return SUCCESS;
 347         }
 348
 349         RPP_MUTEX_UNLOCK(mutex_fr);
 350         return FAILURE;
 351
 352 }
 353
 354 int8_t rpp_fr_clear_timer_irq(uint8_t ctrl, uint8_t timer_idx)
 355 {
 356         RPP_MUTEX_LOCK(mutex_fr);
 357         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_AckAbsoluteTimerIRQ(ctrl, timer_idx) & E_OK) {
 358                 RPP_MUTEX_UNLOCK(mutex_fr);
 359                 return SUCCESS;
 360         }
 361
 362         RPP_MUTEX_UNLOCK(mutex_fr);
 363         return FAILURE;
 364
 365 }
 366
 367 int8_t rpp_fr_get_timer_irq_status(uint8_t ctrl, uint8_t timer_idx, boolean_t *irq_pending)
 368 {
 369         RPP_MUTEX_LOCK(mutex_fr);
 370         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetAbsoluteTimerIRQStatus(ctrl, timer_idx, irq_pending) & E_OK) {
 371                 RPP_MUTEX_UNLOCK(mutex_fr);
 372                 return SUCCESS;
 373         }
 374
 375         RPP_MUTEX_UNLOCK(mutex_fr);
 376         return FAILURE;
 377
 378 }
 379
 380 int8_t rpp_fr_get_driver_version(Std_VersionInfoType *version)
 381 {
 382         Fr_GetVersionInfo(version);
 383         return SUCCESS;
 384 }
 385
 386 int8_t rpp_fr_read_com_ctrl_config(uint8_t ctrl, uint8_t param_idx, uint32_t *param_value)
 387 {
 388         RPP_MUTEX_LOCK(mutex_fr);
 389         if (Fr_ReadCCConfig(ctrl, param_idx, param_value) & E_OK) {
 390                 RPP_MUTEX_UNLOCK(mutex_fr);
 391                 return SUCCESS;
 392         }
 393
 394         RPP_MUTEX_UNLOCK(mutex_fr);
 395         return FAILURE;
 396
 397 }
 398
 399 #endif /* FREERTOS_POSIX */