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  * Permission is hereby granted, free of charge, to any person
   8  * obtaining a copy of this software and associated documentation
   9  * files (the "Software"), to deal in the Software without
  10  * restriction, including without limitation the rights to use,
  11  * copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following
  14  * conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be
  17  * included in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  21  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  23  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  26  * OTHER DEALINGS IN THE SOFTWARE.
  27  *
  28  * File : fr.c
  29  * Abstract:
  30  *     FlexRay Communication RPP API implementation file.
  31  *
  32  * References:
  33  *     fr.h
  34  *     RPP API documentation.
  35  */
  36
  37
  38 #include "rpp/rpp.h"
  39
  40 #ifndef FREERTOS_POSIX
  41
  42 #include "stdio.h"
  43 #include "string.h"
  44 #include "drv/drv.h"
  45 #include "drv/spi_def.h"
  46 #include "rpp/mutex.h"
  47
  48 RPP_MUTEX_DEFINE(mutex_fr);
  49
  50 static rpp_fr_state_t rpp_fr_state = RPP_FR_NOT_INITIALIZED;    /**< Stores the actual state of the FlexRay module */
  51
  52 /* AUTOSAR-like API */
  53
  54 int8_t rpp_fr_init_driver(const Fr_ConfigType *config_ptr, uint32_t *error)
  55 {
  56         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED)
  57                 return FAILURE;
  58 #ifndef FREERTOS_POSIX
  59         spi_init();
  60 #endif
  61         if (!RPP_MUTEX_INIT(mutex_fr))
  62                 return FAILURE;
  63         Fr_Init(config_ptr);
  64         rpp_fr_state = RPP_FR_DRV_INITIALIZED;
  65         return SUCCESS;
  66 }
  67
  68 int8_t rpp_fr_init_controller(uint8_t ctrl, uint32_t *error)
  69 {
  70         Std_ReturnType retVal = ERR_PARAM_NO_ERROR;
  71         RPP_MUTEX_LOCK(mutex_fr);
  72         if (rpp_fr_state == RPP_FR_DRV_INITIALIZED ||
  73                 rpp_fr_state == RPP_FR_HALTED ||
  74                 rpp_fr_state == RPP_FR_ABORTED) {
  75                 retVal = Fr_ControllerInit(ctrl);
  76                 if (retVal & E_OK) {
  77                         rpp_fr_state = RPP_FR_CTR_INITIALIZED;
  78                         RPP_MUTEX_UNLOCK(mutex_fr);
  79                         return SUCCESS;
  80                 }
  81                 else {
  82                         *error = retVal;
  83                         RPP_MUTEX_UNLOCK(mutex_fr);
  84                         return FAILURE;
  85                 }
  86         }
  87         RPP_MUTEX_UNLOCK(mutex_fr);
  88         return FAILURE;
  89
  90 }
  91
  92 int8_t rpp_fr_start_communication(uint8_t ctrl, uint32_t *error)
  93 {
  94         Std_ReturnType retVal = ERR_PARAM_NO_ERROR;
  95
  96         RPP_MUTEX_LOCK(mutex_fr);
  97         if (rpp_fr_state == RPP_FR_CTR_INITIALIZED) {
  98                 retVal = Fr_StartCommunication(ctrl);
  99                 if (retVal & E_OK) {
 100                         rpp_fr_state = RPP_FR_RUNNING;
 101                         RPP_MUTEX_UNLOCK(mutex_fr);
 102                         return SUCCESS;
 103
 104                 }
 105                 else {
 106                         *error = retVal;
 107                         RPP_MUTEX_UNLOCK(mutex_fr);
 108                         return FAILURE;
 109                 }
 110         }
 111         RPP_MUTEX_UNLOCK(mutex_fr);
 112         return FAILURE;
 113 }
 114
 115 int8_t rpp_fr_all_slots(uint8_t ctrl)
 116 {
 117         int8_t ret;
 118
 119         RPP_MUTEX_LOCK(mutex_fr);
 120         ret = (rpp_fr_state == RPP_FR_RUNNING && Fr_AllSlots(ctrl) & E_OK);
 121         RPP_MUTEX_UNLOCK(mutex_fr);
 122
 123         return ret ? SUCCESS : FAILURE;
 124 }
 125
 126 int8_t rpp_fr_halt_communication(uint8_t ctrl)
 127 {
 128         RPP_MUTEX_LOCK(mutex_fr);
 129         if (rpp_fr_state == RPP_FR_RUNNING && Fr_HaltCommunication(ctrl) & E_OK) {
 130                 rpp_fr_state = RPP_FR_HALTED;
 131                 RPP_MUTEX_UNLOCK(mutex_fr);
 132                 return SUCCESS;
 133
 134         }
 135         RPP_MUTEX_UNLOCK(mutex_fr);
 136         return FAILURE;
 137 }
 138
 139 int8_t rpp_fr_abort_communication(uint8_t ctrl)
 140 {
 141         RPP_MUTEX_LOCK(mutex_fr);
 142         if (rpp_fr_state == RPP_FR_RUNNING && Fr_AbortCommunication(ctrl) & E_OK) {
 143                 rpp_fr_state = RPP_FR_ABORTED;
 144                 RPP_MUTEX_UNLOCK(mutex_fr);
 145                 return SUCCESS;
 146
 147         }
 148         RPP_MUTEX_UNLOCK(mutex_fr);
 149         return FAILURE;
 150 }
 151
 152 int8_t rpp_fr_send_wup(uint8_t ctrl)
 153 {
 154         RPP_MUTEX_LOCK(mutex_fr);
 155         if (rpp_fr_state == RPP_FR_CTR_INITIALIZED && Fr_SendWUP(ctrl) & E_OK) {
 156                 RPP_MUTEX_UNLOCK(mutex_fr);
 157                 return SUCCESS;
 158         }
 159
 160         RPP_MUTEX_UNLOCK(mutex_fr);
 161         return FAILURE;
 162 }
 163
 164 int8_t rpp_fr_set_wu_channel(uint8_t ctrl, Fr_ChannelType channel)
 165 {
 166         RPP_MUTEX_LOCK(mutex_fr);
 167         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_SetWakeupChannel(ctrl, channel) & E_OK) {
 168                 RPP_MUTEX_UNLOCK(mutex_fr);
 169                 return SUCCESS;
 170         }
 171
 172         RPP_MUTEX_UNLOCK(mutex_fr);
 173         return FAILURE;
 174 }
 175
 176 int8_t rpp_fr_get_poc_status(uint8_t ctrl, Fr_POCStatusType *poc_status_ptr)
 177 {
 178         RPP_MUTEX_LOCK(mutex_fr);
 179         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetPOCStatus(ctrl, poc_status_ptr) & E_OK) {
 180                 RPP_MUTEX_UNLOCK(mutex_fr);
 181                 return SUCCESS;
 182         }
 183
 184         RPP_MUTEX_UNLOCK(mutex_fr);
 185         return FAILURE;
 186 }
 187
 188 int8_t rpp_fr_transmit_lpdu(uint8_t ctrl, uint16_t lpdu_idx, const uint8_t *lsdu, uint8_t lsdu_length)
 189 {
 190         RPP_MUTEX_LOCK(mutex_fr);
 191         if (rpp_fr_state == RPP_FR_RUNNING && Fr_TransmitTxLPdu(ctrl, lpdu_idx, lsdu, lsdu_length) & E_OK) {
 192                 RPP_MUTEX_UNLOCK(mutex_fr);
 193                 return SUCCESS;
 194
 195         }
 196         RPP_MUTEX_UNLOCK(mutex_fr);
 197         return FAILURE;
 198
 199 }
 200
 201 int8_t rpp_fr_cancel_transmit_lpdu(uint8_t ctrl, uint16_t lpdu_idx)
 202 {
 203         RPP_MUTEX_LOCK(mutex_fr);
 204         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CancelTxLPdu(ctrl, lpdu_idx) & E_OK) {
 205                 RPP_MUTEX_UNLOCK(mutex_fr);
 206                 return SUCCESS;
 207         }
 208
 209         RPP_MUTEX_UNLOCK(mutex_fr);
 210         return FAILURE;
 211
 212 }
 213
 214 int8_t rpp_fr_receive_lpdu(uint8_t ctrl, uint16_t lpdu_idx, uint8_t *lsdu, Fr_RxLPduStatusType *lpdu_status, uint8_t *lsdu_length)
 215 {
 216         RPP_MUTEX_LOCK(mutex_fr);
 217         if (rpp_fr_state == RPP_FR_RUNNING && Fr_ReceiveRxLPdu(ctrl, lpdu_idx, lsdu, lpdu_status, lsdu_length) & E_OK) {
 218                 RPP_MUTEX_UNLOCK(mutex_fr);
 219                 return SUCCESS;
 220         }
 221
 222         RPP_MUTEX_UNLOCK(mutex_fr);
 223         return FAILURE;
 224
 225 }
 226
 227 int8_t rpp_fr_check_tx_lpdu_status(uint8_t ctrl, uint16_t lpdu_idx, Fr_TxLPduStatusType *lpdu_status)
 228 {
 229         RPP_MUTEX_LOCK(mutex_fr);
 230         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CheckTxLPduStatus(ctrl, lpdu_idx, lpdu_status) & E_OK) {
 231                 RPP_MUTEX_UNLOCK(mutex_fr);
 232                 return SUCCESS;
 233         }
 234
 235         RPP_MUTEX_UNLOCK(mutex_fr);
 236         return FAILURE;
 237
 238 }
 239
 240 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)
 241 {
 242         RPP_MUTEX_LOCK(mutex_fr);
 243         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) {
 244                 RPP_MUTEX_UNLOCK(mutex_fr);
 245                 return SUCCESS;
 246         }
 247
 248         RPP_MUTEX_UNLOCK(mutex_fr);
 249         return FAILURE;
 250
 251 }
 252
 253 int8_t rpp_fr_disable_lpdu(uint8_t ctrl, uint16_t lpdu_idx)
 254 {
 255         RPP_MUTEX_LOCK(mutex_fr);
 256         if (rpp_fr_state == RPP_FR_RUNNING && Fr_DisableLPdu(ctrl, lpdu_idx) & E_OK) {
 257                 RPP_MUTEX_UNLOCK(mutex_fr);
 258                 return SUCCESS;
 259         }
 260
 261         RPP_MUTEX_UNLOCK(mutex_fr);
 262         return FAILURE;
 263
 264 }
 265
 266 int8_t rpp_fr_get_global_time(uint8_t ctrl, uint8_t *cycle, uint16_t *macroticks)
 267 {
 268         RPP_MUTEX_LOCK(mutex_fr);
 269         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetGlobalTime(ctrl, cycle, macroticks) & E_OK) {
 270                 RPP_MUTEX_UNLOCK(mutex_fr);
 271                 return SUCCESS;
 272         }
 273
 274         RPP_MUTEX_UNLOCK(mutex_fr);
 275         return FAILURE;
 276
 277 }
 278
 279 int8_t rpp_fr_get_network_management_vector(uint8_t ctrl, uint8_t *nm_vector)
 280 {
 281         RPP_MUTEX_LOCK(mutex_fr);
 282         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetNmVector(ctrl, nm_vector) & E_OK) {
 283                 RPP_MUTEX_UNLOCK(mutex_fr);
 284                 return SUCCESS;
 285         }
 286
 287         RPP_MUTEX_UNLOCK(mutex_fr);
 288         return FAILURE;
 289
 290 }
 291
 292 int8_t rpp_fr_get_channel_status(uint8_t ctrl, uint16_t *channel_a_status, uint16_t *channel_b_status)
 293 {
 294         RPP_MUTEX_LOCK(mutex_fr);
 295         if (rpp_fr_state >= RPP_FR_CTR_INITIALIZED && Fr_GetChannelStatus(ctrl, channel_a_status, channel_b_status) & E_OK) {
 296                 RPP_MUTEX_UNLOCK(mutex_fr);
 297                 return SUCCESS;
 298         }
 299
 300         RPP_MUTEX_UNLOCK(mutex_fr);
 301         return FAILURE;
 302
 303 }
 304
 305 int8_t rpp_fr_get_clock_correction(uint8_t ctrl, int16_t *rate_correction, int32_t *offset_correction)
 306 {
 307         RPP_MUTEX_LOCK(mutex_fr);
 308         if (rpp_fr_state >= RPP_FR_RUNNING && Fr_GetClockCorrection(ctrl, rate_correction, offset_correction) & E_OK) {
 309                 RPP_MUTEX_UNLOCK(mutex_fr);
 310                 return SUCCESS;
 311         }
 312
 313         RPP_MUTEX_UNLOCK(mutex_fr);
 314         return FAILURE;
 315
 316 }
 317
 318 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)
 319 {
 320         RPP_MUTEX_LOCK(mutex_fr);
 321         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) {
 322                 RPP_MUTEX_UNLOCK(mutex_fr);
 323                 return SUCCESS;
 324         }
 325
 326         RPP_MUTEX_UNLOCK(mutex_fr);
 327         return FAILURE;
 328
 329 }
 330
 331 int8_t rpp_fr_get_wakeup_rx_status(uint8_t ctrl, uint8_t *status)
 332 {
 333         RPP_MUTEX_LOCK(mutex_fr);
 334         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetWakeupRxStatus(ctrl, status) & E_OK) {
 335                 RPP_MUTEX_UNLOCK(mutex_fr);
 336                 return SUCCESS;
 337         }
 338
 339         RPP_MUTEX_UNLOCK(mutex_fr);
 340         return FAILURE;
 341
 342 }
 343
 344 int8_t rpp_fr_set_timer(uint8_t ctrl, uint8_t timer_idx, uint8_t cycle_set, uint16_t offset_threshold)
 345 {
 346         RPP_MUTEX_LOCK(mutex_fr);
 347         if (rpp_fr_state == RPP_FR_RUNNING && Fr_SetAbsoluteTimer(ctrl, timer_idx, cycle_set, offset_threshold) & E_OK) {
 348                 RPP_MUTEX_UNLOCK(mutex_fr);
 349                 return SUCCESS;
 350         }
 351
 352         RPP_MUTEX_UNLOCK(mutex_fr);
 353         return FAILURE;
 354
 355 }
 356
 357 int8_t rpp_fr_cancel_timer(uint8_t ctrl, uint8_t timer_idx)
 358 {
 359         RPP_MUTEX_LOCK(mutex_fr);
 360         if (rpp_fr_state == RPP_FR_RUNNING && Fr_CancelAbsoluteTimer(ctrl, timer_idx) & E_OK) {
 361                 RPP_MUTEX_UNLOCK(mutex_fr);
 362                 return SUCCESS;
 363         }
 364
 365         RPP_MUTEX_UNLOCK(mutex_fr);
 366         return FAILURE;
 367
 368 }
 369
 370 int8_t rpp_fr_clear_timer_irq(uint8_t ctrl, uint8_t timer_idx)
 371 {
 372         RPP_MUTEX_LOCK(mutex_fr);
 373         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_AckAbsoluteTimerIRQ(ctrl, timer_idx) & E_OK) {
 374                 RPP_MUTEX_UNLOCK(mutex_fr);
 375                 return SUCCESS;
 376         }
 377
 378         RPP_MUTEX_UNLOCK(mutex_fr);
 379         return FAILURE;
 380
 381 }
 382
 383 int8_t rpp_fr_get_timer_irq_status(uint8_t ctrl, uint8_t timer_idx, boolean_t *irq_pending)
 384 {
 385         RPP_MUTEX_LOCK(mutex_fr);
 386         if (rpp_fr_state >= RPP_FR_DRV_INITIALIZED && Fr_GetAbsoluteTimerIRQStatus(ctrl, timer_idx, irq_pending) & E_OK) {
 387                 RPP_MUTEX_UNLOCK(mutex_fr);
 388                 return SUCCESS;
 389         }
 390
 391         RPP_MUTEX_UNLOCK(mutex_fr);
 392         return FAILURE;
 393
 394 }
 395
 396 int8_t rpp_fr_get_driver_version(Std_VersionInfoType *version)
 397 {
 398         Fr_GetVersionInfo(version);
 399         return SUCCESS;
 400 }
 401
 402 int8_t rpp_fr_read_com_ctrl_config(uint8_t ctrl, uint8_t param_idx, uint32_t *param_value)
 403 {
 404         RPP_MUTEX_LOCK(mutex_fr);
 405         if (Fr_ReadCCConfig(ctrl, param_idx, param_value) & E_OK) {
 406                 RPP_MUTEX_UNLOCK(mutex_fr);
 407                 return SUCCESS;
 408         }
 409
 410         RPP_MUTEX_UNLOCK(mutex_fr);
 411         return FAILURE;
 412
 413 }
 414
 415 #endif /* FREERTOS_POSIX */