communication/CanIf/CanIf.c

   1 /* -------------------------------- Arctic Core ------------------------------
   2  * Arctic Core - the open source AUTOSAR platform http://arccore.com
   3  *
   4  * Copyright (C) 2009  ArcCore AB <contact@arccore.com>
   5  *
   6  * This source code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by the
   8  * Free Software Foundation; See <http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  * -------------------------------- Arctic Core ------------------------------*/
  15
  16
  17
  18
  19
  20
  21
  22
  23 #include "Det.h"
  24 #include "CanIf.h"
  25
  26 #include "Can.h"
  27 #include "CanIf_Cbk.h"
  28 #include "string.h"
  29
  30 // Added by Mattias 2008-11-18
  31 #include "debug.h"
  32 #include "PduR.h"
  33
  34 #if defined(USE_CANTP)
  35 #include "CanTp_Cbk.h"
  36 #endif
  37
  38 #if 0
  39 // TODO: Include upper layer functions, See CANIF208 and CANIF233
  40 #include "PduR_CanIf.h"
  41 #include "CanNm.h"
  42 #include "CanTp.h"
  43
  44 #include "PduR_Cbk.h"
  45 #include "CanNm_Cbk.h"
  46 #include "CanTp_Cbk.h"
  47 #endif
  48
  49 #if  ( CANIF_DEV_ERROR_DETECT == STD_ON )
  50 #define VALIDATE(_exp,_api,_err ) \
  51         if( !(_exp) ) { \
  52           Det_ReportError(MODULE_ID_CANIF, 0, _api, _err); \
  53           return E_NOT_OK; \
  54         }
  55
  56 #define VALIDATE_NO_RV(_exp,_api,_err ) \
  57   if( !(_exp) ) { \
  58           Det_ReportError(MODULE_ID_CANIF, 0, _api, _err); \
  59           return; \
  60         }
  61 #undef DET_REPORTERROR
  62 #define DET_REPORTERROR(_x,_y,_z,_q) Det_ReportError(_x, _y, _z, _q)
  63
  64 #else
  65 #define VALIDATE(_exp,_api,_err )
  66 #define VALIDATE_NO_RV(_exp,_api,_err )
  67 #define DET_REPORTERROR(_x,_y,_z,_q)
  68 #endif
  69
  70
  71 // Helper to get the Can Controller refered to by a CanIf Channel
  72 #define ARC_GET_CHANNEL_CONTROLLER(_channel) \
  73         CanIf_ConfigPtr->Arc_ChannelToControllerMap[channel]
  74
  75 /* Global configure */
  76 static const CanIf_ConfigType *CanIf_ConfigPtr;
  77
  78 // Struct of controller private data.
  79 typedef struct
  80 {
  81   CanIf_ControllerModeType  ControllerMode;
  82   CanIf_ChannelGetModeType  PduMode;
  83 } CanIf_ChannelPrivateType;
  84
  85 typedef struct
  86 {
  87   boolean initRun;
  88   CanIf_ChannelPrivateType channelData[CANIF_CHANNEL_CNT];
  89 } CanIf_GlobalType;
  90
  91 static CanIf_Arc_ChannelIdType CanIf_Arc_FindHrhChannel( Can_Arc_HRHType hrh )
  92 {
  93   const CanIf_HrhConfigType *hrhConfig;
  94
  95   hrhConfig = CanIf_ConfigPtr->InitConfig->CanIfHohConfigPtr->CanIfHrhConfig;
  96
  97   hrhConfig--;
  98   do
  99   {
 100     hrhConfig++;
 101     if (hrhConfig->CanIfHrhIdSymRef == hrh)
 102       return hrhConfig->CanIfCanControllerHrhIdRef;
 103   } while(!hrhConfig->CanIf_Arc_EOL);
 104
 105   DET_REPORTERROR(MODULE_ID_CANIF, 0, CANIF_RXINDICATION_ID, CANIF_E_PARAM_HRH);
 106
 107   return -1;
 108 }
 109
 110 // Global config
 111 CanIf_GlobalType CanIf_Global;
 112
 113 void CanIf_Init(const CanIf_ConfigType *ConfigPtr)
 114 {
 115   VALIDATE_NO_RV(ConfigPtr != 0, CANIF_INIT_ID, CANIF_E_PARAM_POINTER); // Only PostBuild case supported
 116
 117   CanIf_ConfigPtr = ConfigPtr;
 118
 119   for (uint16 i = 0; i < CANIF_CHANNEL_CNT; i++)
 120   {
 121     CanIf_Global.channelData[i].ControllerMode = CANIF_CS_STOPPED;
 122     CanIf_Global.channelData[i].PduMode = CANIF_GET_OFFLINE;
 123   }
 124
 125   // NOTE!
 126   // Do NOT initialise the Can Drivers and Tranceivers, see CANIF085
 127
 128   CanIf_Global.initRun = TRUE;
 129 }
 130
 131
 132
 133
 134 //-------------------------------------------------------------------
 135 /*
 136  * Controller :: CanIf_Arc_ChannelIdType (CanIf-specific id to abstract from Can driver/controllers)
 137  * ConfigurationIndex :: CanIf_Arc_ConfigurationIndexType
 138  *   /tojo
 139  */
 140 void CanIf_InitController(uint8 Controller, uint8 ConfigurationIndex)
 141 {
 142   // We call this a CanIf channel. Hopefully makes it easier to follow.
 143   CanIf_Arc_ChannelIdType channel = Controller;
 144
 145   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_INIT_CONTROLLER_ID, CANIF_E_UNINIT );
 146   VALIDATE_NO_RV(channel < CANIF_CHANNEL_CNT, CANIF_INIT_CONTROLLER_ID, CANIF_E_PARAM_CONTROLLER);
 147   VALIDATE_NO_RV(ConfigurationIndex < CANIF_CHANNEL_CONFIGURATION_CNT, CANIF_INIT_CONTROLLER_ID, CANIF_E_PARAM_POINTER);
 148
 149 #if (CANIF_DEV_ERROR_DETECT == STD_ON)
 150   CanIf_ControllerModeType mode;
 151
 152   if (CanIf_GetControllerMode(channel, &mode) == E_OK)
 153   {
 154     VALIDATE_NO_RV((mode != CANIF_CS_UNINIT), CANIF_INIT_CONTROLLER_ID, CANIF_E_PARAM_CONTROLLER_MODE );
 155   }
 156   else
 157   {
 158     VALIDATE_NO_RV(FALSE, CANIF_INIT_CONTROLLER_ID, CANIF_E_PARAM_CONTROLLER_MODE);
 159   }
 160 #endif
 161
 162   if (CanIf_GetControllerMode(channel, &mode) == E_OK)
 163   {
 164     if (mode == CANIF_CS_STARTED)
 165     {
 166       CanIf_SetControllerMode(channel, CANIF_CS_STOPPED); // CANIF092
 167     }
 168     else if (mode != CANIF_CS_STOPPED)
 169     {
 170       VALIDATE_NO_RV(FALSE, CANIF_INIT_CONTROLLER_ID, CANIF_E_PARAM_CONTROLLER_MODE); // CANIF092
 171    }
 172   }
 173
 174   // CANIF293: ..Subsequently the CAN Interface calls the corresponding
 175   //             CAN Driver initialization services.
 176
 177   // CANIF066: The CAN Interface has access to the CAN Driver configuration data. All
 178   // public CAN Driver configuration data are described in [8] Specification of CAN Driver.
 179
 180   // Grab the configuration from the Can Controller
 181   const Can_ControllerConfigType *canConfig;
 182   const CanControllerIdType canControllerId = ARC_GET_CHANNEL_CONTROLLER(channel);
 183
 184   // Validate that the configuration at the index match the right channel
 185   VALIDATE_NO_RV(CanIf_ConfigPtr->ControllerConfig[ConfigurationIndex].CanIfControllerIdRef == channel, CANIF_INIT_CONTROLLER_ID, CANIF_E_PARAM_CONTROLLER);
 186
 187   canConfig = CanIf_ConfigPtr->ControllerConfig[ConfigurationIndex].CanIfInitControllerRef;
 188
 189   // Validate that the CanIfControllerConfig points to configuration for the right Can Controller
 190   VALIDATE_NO_RV(canConfig->CanControllerId == canControllerId, CANIF_INIT_CONTROLLER_ID, CANIF_E_PARAM_CONTROLLER);
 191
 192   Can_InitController(canControllerId, canConfig);
 193
 194   // Set mode to stopped
 195   CanIf_SetControllerMode(channel, CANIF_CS_STOPPED);
 196 }
 197
 198 //-------------------------------------------------------------------
 199
 200 Std_ReturnType CanIf_SetControllerMode(uint8 Controller,
 201     CanIf_ControllerModeType ControllerMode)
 202 {
 203   // We call this a CanIf channel. Hopefully makes it easier to follow.
 204   CanIf_Arc_ChannelIdType channel = Controller;
 205
 206
 207   CanIf_ControllerModeType oldMode;
 208
 209   VALIDATE( CanIf_Global.initRun, CANIF_SET_CONTROLLER_MODE_ID, CANIF_E_UNINIT );
 210   VALIDATE( channel < CANIF_CHANNEL_CNT, CANIF_SET_CONTROLLER_MODE_ID, CANIF_E_PARAM_CONTROLLER );
 211
 212   oldMode = CanIf_Global.channelData[channel].ControllerMode;
 213
 214   if (oldMode == CANIF_CS_UNINIT)
 215   {
 216     VALIDATE(FALSE, CANIF_SET_CONTROLLER_MODE_ID, CANIF_E_UNINIT); // See figure 32, 33
 217     return E_NOT_OK;
 218   }
 219   CanControllerIdType canControllerId = ARC_GET_CHANNEL_CONTROLLER(Controller);
 220   switch (ControllerMode)
 221   {
 222   case CANIF_CS_STARTED:   // Figure 32
 223   {
 224     switch (oldMode)
 225     {
 226       case CANIF_CS_SLEEP:
 227         if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK)
 228           return E_NOT_OK;
 229         CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_STOPPED;
 230         break;
 231       default:
 232         // Just fall through
 233         break;
 234     }
 235
 236     CanIf_SetPduMode(channel, CANIF_SET_ONLINE);
 237     if (Can_SetControllerMode(canControllerId, CAN_T_START) == CAN_NOT_OK)
 238       return E_NOT_OK;
 239     CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_STARTED;
 240   }
 241   break;
 242
 243   case CANIF_CS_SLEEP: // Figure 33
 244   {
 245     switch (oldMode) {
 246       case CANIF_CS_STARTED:
 247         if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK)
 248           return E_NOT_OK;
 249         CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_STOPPED;
 250         break;
 251       default:
 252         // Just fall through for other cases
 253         break;
 254     }
 255
 256     if (Can_SetControllerMode(canControllerId, CAN_T_SLEEP) == CAN_NOT_OK)
 257       return E_NOT_OK;
 258     CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_SLEEP;
 259   }
 260
 261   case CANIF_CS_STOPPED:
 262   {
 263     switch (oldMode)
 264     {
 265       case CANIF_CS_SLEEP:
 266         if (Can_SetControllerMode(canControllerId, CAN_T_WAKEUP) == CAN_NOT_OK)
 267           return E_NOT_OK;
 268         break;
 269       default:
 270         // Just fall through for other cases
 271         break;
 272     }
 273
 274     CanIf_SetPduMode(channel, CANIF_SET_OFFLINE);
 275     if (Can_SetControllerMode(canControllerId, CAN_T_STOP) == CAN_NOT_OK)
 276       return E_NOT_OK;
 277     CanIf_Global.channelData[channel].ControllerMode = CANIF_CS_STOPPED;
 278   }
 279
 280   case CANIF_CS_UNINIT:
 281     // Just fall through
 282     break;
 283   }
 284   return E_OK;
 285 }
 286
 287 //-------------------------------------------------------------------
 288
 289 Std_ReturnType CanIf_GetControllerMode(uint8 Controller,
 290     CanIf_ControllerModeType *ControllerModePtr)
 291 {
 292   // We call this a CanIf channel. Hopefully makes it easier to follow.
 293   CanIf_Arc_ChannelIdType channel = Controller;
 294
 295   VALIDATE(CanIf_Global.initRun, CANIF_GET_CONTROLLER_MODE_ID, CANIF_E_UNINIT );
 296   VALIDATE(channel < CANIF_CHANNEL_CNT, CANIF_GET_CONTROLLER_MODE_ID, CANIF_E_PARAM_CONTROLLER );
 297   VALIDATE(ControllerModePtr != NULL, CANIF_GET_CONTROLLER_MODE_ID, CANIF_E_PARAM_POINTER );
 298
 299   *ControllerModePtr = CanIf_Global.channelData[channel].ControllerMode;
 300
 301   return E_OK;
 302 }
 303
 304 //-------------------------------------------------------------------
 305 /**
 306  * Matches a Tx PDU id agaist the ones that are in the database.
 307  *
 308  * @returns Ptr a TxPdu
 309  */
 310 static const CanIf_TxPduConfigType * CanIf_FindTxPduEntry(PduIdType id)
 311 {
 312         if (id >= CanIf_ConfigPtr->InitConfig->CanIfNumberOfCanTXPduIds) {
 313                 return NULL;
 314         } else {
 315                 return &CanIf_ConfigPtr->InitConfig->CanIfTxPduConfigPtr[id];
 316         }
 317 /*
 318   for (uint16 i = 0; i < CanIf_ConfigPtr->InitConfig->CanIfNumberOfCanTXPduIds; i++)
 319   {
 320     if (entry->CanIfTxPduId == id)
 321     {
 322       return entry;
 323     }
 324     entry++;
 325   }
 326
 327   return 0;
 328   */
 329 }
 330
 331 //-------------------------------------------------------------------
 332
 333 Std_ReturnType CanIf_Transmit(PduIdType CanTxPduId,
 334     const PduInfoType *PduInfoPtr)
 335 {
 336   Can_PduType canPdu;
 337   const CanIf_TxPduConfigType *txEntry;
 338   CanIf_ControllerModeType csMode;
 339   CanIf_ChannelGetModeType pduMode;
 340
 341   VALIDATE(CanIf_Global.initRun, CANIF_TRANSMIT_ID, CANIF_E_UNINIT );
 342   VALIDATE((PduInfoPtr != 0), CANIF_TRANSMIT_ID, CANIF_E_PARAM_POINTER );
 343
 344   // Get the controller from L-PDU handle
 345   txEntry = CanIf_FindTxPduEntry(CanTxPduId);
 346
 347   if (txEntry == 0)
 348   {
 349     VALIDATE(FALSE, CANIF_TRANSMIT_ID, CANIF_E_INVALID_TXPDUID);
 350     return E_NOT_OK;
 351   }
 352
 353   CanIf_Arc_ChannelIdType channel = txEntry->CanIfCanTxPduHthRef->CanIfCanControllerIdRef;
 354
 355   // Get and verify the controller mode
 356   if (CanIf_GetControllerMode(channel, &csMode) == E_NOT_OK)
 357     return E_NOT_OK;
 358
 359   if (csMode != CANIF_CS_STARTED)  // CANIF_161
 360     return E_NOT_OK;
 361
 362   // Get and verify the PDU channel mode control
 363   if (CanIf_GetPduMode(channel, &pduMode) == E_NOT_OK)
 364     return E_NOT_OK;
 365
 366   if ((pduMode != CANIF_GET_TX_ONLINE) && (pduMode != CANIF_GET_ONLINE))
 367     return E_NOT_OK;
 368
 369   canPdu.id = txEntry->CanIfCanTxPduIdCanId;
 370
 371   canPdu.length = PduInfoPtr->SduLength;
 372   canPdu.sdu = PduInfoPtr->SduDataPtr;
 373   canPdu.swPduHandle = CanTxPduId;
 374
 375   Can_ReturnType rVal = Can_Write(txEntry->CanIfCanTxPduHthRef->CanIfHthIdSymRef, &canPdu);
 376
 377   if (rVal == CAN_NOT_OK)
 378     return E_NOT_OK;
 379
 380   if (rVal == CAN_BUSY)  // CANIF 082, CANIF 161
 381   {
 382     // Tx buffering not supported so just return.
 383     return E_NOT_OK;
 384   }
 385
 386   return E_OK;
 387 }
 388
 389 //-------------------------------------------------------------------
 390
 391 #if ( CANIF_READRXPDU_DATA_API == STD_ON )
 392 Std_ReturnType CanIf_ReadRxPduData(PduIdType CanRxPduId,
 393     PduInfoType *PduInfoPtr)
 394 {
 395   VALIDATE(FALSE, CANIF_READTXPDUDATA_ID, CANIF_E_NOK_NOSUPPORT);
 396   VALIDATE(CanIf_Global.initRun == STD_ON, CANIF_READTXPDUDATA_ID, CANIF_E_UNINIT );
 397   VALIDATE(PduInfoPtr != 0, CANIF_READTXPDUDATA_ID, CANIF_E_PARAM_POINTER );
 398
 399   // This function is not supported
 400
 401   return E_NOT_OK;
 402 }
 403 #endif
 404
 405 //-------------------------------------------------------------------
 406
 407 #if ( CANIF_READTXPDU_NOTIFY_STATUS_API == STD_ON )
 408 CanIf_NotifStatusType CanIf_ReadTxNotifStatus(PduIdType CanTxPduId)
 409 {
 410   const CanIf_TxPduConfigType *txEntry;
 411   VALIDATE(FALSE, CANIF_READTXNOTIFSTATUS_ID, CANIF_E_NOK_NOSUPPORT);
 412   VALIDATE(CanIf_Global.initRun, CANIF_READTXNOTIFSTATUS_ID, CANIF_E_UNINIT );
 413
 414   // Get the controller from L-PDU handle
 415   txEntry = CanIf_FindTxPduEntry(CanTxPduId);
 416
 417   if (txEntry == 0)
 418   {
 419     VALIDATE(FALSE, CANIF_READTXNOTIFSTATUS_ID, CANIF_E_INVALID_TXPDUID);
 420     return CANIF_NO_NOTIFICATION;
 421   }
 422
 423   if (txEntry->CanIfReadTxPduNotifyStatus == FALSE)
 424   {
 425     VALIDATE(FALSE, CANIF_READTXNOTIFSTATUS_ID, CANIF_E_INVALID_TXPDUID);
 426     return CANIF_NO_NOTIFICATION;
 427   }
 428
 429   // This function is not supported
 430
 431   return CANIF_NO_NOTIFICATION;
 432 }
 433 #endif
 434
 435 //-------------------------------------------------------------------
 436
 437 #if ( CANIF_READRXPDU_NOTIFY_STATUS_API == STD_ON )
 438 CanIf_NotifStatusType CanIf_ReadRxNotifStatus(PduIdType CanRxPduId)
 439 {
 440   VALIDATE(FALSE, CANIF_READRXNOTIFSTATUS_ID, CANIF_E_NOK_NOSUPPORT);
 441   VALIDATE(CanIf_Global.initRun, CANIF_READRXNOTIFSTATUS_ID, CANIF_E_UNINIT );
 442
 443   return CANIF_NO_NOTIFICATION;
 444 }
 445 #endif
 446
 447 //-------------------------------------------------------------------
 448
 449 Std_ReturnType CanIf_SetPduMode(uint8 Controller,
 450     CanIf_ChannelSetModeType PduModeRequest)
 451 {
 452   // We call this a CanIf channel. Hopefully makes it easier to follow.
 453   CanIf_Arc_ChannelIdType channel = Controller;
 454
 455   VALIDATE( CanIf_Global.initRun, CANIF_SETPDUMODE_ID, CANIF_E_UNINIT );
 456   VALIDATE( channel < CANIF_CHANNEL_CNT, CANIF_SETPDUMODE_ID, CANIF_E_PARAM_CONTROLLER );
 457
 458   CanIf_ChannelGetModeType oldMode = CanIf_Global.channelData[channel].PduMode;
 459
 460   switch(PduModeRequest)
 461   {
 462   case CANIF_SET_OFFLINE:
 463     CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;
 464     break;
 465   case CANIF_SET_RX_OFFLINE:
 466     if (oldMode == CANIF_GET_RX_ONLINE)
 467       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;
 468     else if (oldMode == CANIF_GET_ONLINE)
 469       CanIf_Global.channelData[channel].PduMode = CANIF_GET_TX_ONLINE;
 470     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE)
 471       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE;
 472
 473     // Other oldmodes don't care
 474     break;
 475   case CANIF_SET_RX_ONLINE:
 476     if (oldMode == CANIF_GET_OFFLINE)
 477       CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;
 478     else if (oldMode == CANIF_GET_TX_ONLINE)
 479       CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;
 480     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)
 481       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;
 482
 483     // Other oldmodes don't care
 484     break;
 485   case CANIF_SET_TX_OFFLINE:
 486     if (oldMode == CANIF_GET_TX_ONLINE)
 487       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;
 488     else if (oldMode == CANIF_GET_ONLINE)
 489       CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;
 490     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)
 491       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;
 492     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE)
 493       CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;
 494
 495     // Other oldmodes don't care
 496     break;
 497   case CANIF_SET_TX_ONLINE:
 498     if (oldMode == CANIF_GET_OFFLINE)
 499       CanIf_Global.channelData[channel].PduMode = CANIF_GET_TX_ONLINE;
 500     else if (oldMode == CANIF_GET_RX_ONLINE)
 501       CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;
 502     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)
 503       CanIf_Global.channelData[channel].PduMode = CANIF_GET_TX_ONLINE;
 504     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE)
 505       CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;
 506
 507     // Other oldmodes don't care
 508     break;
 509   case CANIF_SET_ONLINE:
 510     CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;
 511     break;
 512
 513   case CANIF_SET_TX_OFFLINE_ACTIVE:
 514     if (oldMode == CANIF_GET_OFFLINE)
 515       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE;
 516     else if (oldMode == CANIF_GET_RX_ONLINE)
 517       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;
 518     else if (oldMode == CANIF_GET_TX_ONLINE)
 519       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE;
 520     else if (oldMode == CANIF_GET_ONLINE)
 521       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;
 522
 523     // Other oldmodes don't care
 524     break;
 525   }
 526
 527   return E_OK;
 528 }
 529
 530 //-------------------------------------------------------------------
 531
 532 Std_ReturnType CanIf_GetPduMode(uint8 Controller,
 533     CanIf_ChannelGetModeType *PduModePtr)
 534 {
 535   // We call this a CanIf channel. Hopefully makes it easier to follow.
 536   CanIf_Arc_ChannelIdType channel = Controller;
 537
 538   VALIDATE( CanIf_Global.initRun, CANIF_GETPDUMODE_ID, CANIF_E_UNINIT );
 539   VALIDATE( channel < CANIF_CHANNEL_CNT, CANIF_GETPDUMODE_ID, CANIF_E_PARAM_CONTROLLER );
 540
 541   *PduModePtr = CanIf_Global.channelData[channel].PduMode;
 542
 543   return E_OK;
 544 }
 545
 546 #if ( CANIF_SETDYNAMICTXID_API == STD_ON )
 547 void CanIf_SetDynamicTxId(PduIdType CanTxPduId, Can_IdType CanId)
 548 {
 549   const CanIf_TxPduConfigType *txEntry;
 550   VALIDATE(FALSE, CANIF_SETDYNAMICTX_ID, CANIF_E_NOK_NOSUPPORT);
 551   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_SETDYNAMICTX_ID, CANIF_E_UNINIT );
 552
 553   // Get the controller from L-PDU handle
 554   txEntry = CanIf_FindTxPduEntry(CanTxPduId);
 555
 556   if (txEntry == 0)
 557   {
 558     VALIDATE_NO_RV(FALSE, CANIF_SETDYNAMICTX_ID, CANIF_E_INVALID_TXPDUID);
 559     return;
 560   }
 561
 562   // Check that this is a dymanic PDU
 563   if (txEntry->CanIfCanTxPduType != ARC_PDU_TYPE_DYNAMIC)
 564   {
 565     VALIDATE_NO_RV(FALSE, CANIF_SETDYNAMICTX_ID, CANIF_E_INVALID_TXPDUID);
 566     return;
 567   }
 568
 569   // Check that this is an extended or standard id
 570   if (((CanId & 0x80000000) && (txEntry->CanIfTxPduIdCanIdType == ARC_CAN_ID_TYPE_29)) ||
 571       (((CanId & 0x80000000) == 0) && (txEntry->CanIfTxPduIdCanIdType == ARC_CAN_ID_TYPE_11)))
 572   {
 573     // Update the CanID
 574     //txEntry->CanIfCanTxPduIdCanId = CanId;  // TODO How do we fix this from a const pointer
 575
 576     // NOT SUPPORTED
 577   }
 578   else
 579   {
 580     // Inavlid Canid to configuration
 581     VALIDATE_NO_RV(FALSE, CANIF_SETDYNAMICTX_ID, CANIF_E_PARAM_CANID);
 582   }
 583 }
 584 #endif
 585
 586 #if ( CANIF_TRANSCEIVER_API == STD_ON )
 587 Std_ReturnType CanIf_SetTransceiverMode(uint8 Transceiver,
 588     CanIf_TransceiverModeType TransceiverMode)
 589 {
 590   VALIDATE(FALSE, CANIF_SET_TRANSCEIVERMODE_ID, CANIF_E_NOK_NOSUPPORT);
 591 // Not supported
 592
 593   return E_NOT_OK;
 594 }
 595
 596 Std_ReturnType CanIf_GetTransceiverMode(uint8 Transceiver,
 597     CanIf_TransceiverModeType *TransceiverModePtr)
 598 {
 599   VALIDATE(FALSE, CANIF_GET_TRANSCEIVERMODE_ID, CANIF_E_NOK_NOSUPPORT);
 600   // Not supported
 601
 602   return E_NOT_OK;
 603 }
 604
 605 Std_ReturnType CanIf_GetTrcvWakeupReason(uint8 Transceiver,
 606     CanIf_TrcvWakeupReasonType *TrcvWuReasonPtr)
 607 {
 608   VALIDATE(FALSE, CANIF_GET_TRCVMODEREASON_ID, CANIF_E_NOK_NOSUPPORT);
 609   // Not supported
 610
 611   return E_NOT_OK;
 612 }
 613
 614 Std_ReturnType CanIf_SetTransceiverWakeupMode(uint8 Transceiver,
 615     CanIf_TrcvWakeupModeType *TrcvWakeupMode)
 616 {
 617   VALIDATE(FALSE, CANIF_SET_TRANSCEIVERWAKEMODE_ID, CANIF_E_NOK_NOSUPPORT);
 618   // Not supported
 619
 620   return E_NOT_OK;
 621 }
 622 #endif
 623
 624 #if ( CANIF_WAKEUP_EVENT_API == STD_ON )
 625 Std_ReturnType CanIf_CheckWakeup(EcuM_WakeupSourceType WakeupSource)
 626 {
 627   VALIDATE(FALSE, CANIF_CHECKWAKEUP_ID, CANIF_E_NOK_NOSUPPORT);
 628   // Not supported
 629
 630   return E_NOT_OK;
 631 }
 632
 633 Std_ReturnType CanIf_CheckValidation(EcuM_WakeupSourceType WakeupSource)
 634 {
 635   VALIDATE(FALSE, CANIF_CHECKVALIDATION_ID, CANIF_E_NOK_NOSUPPORT);
 636   // Not supported
 637
 638   return E_NOT_OK;
 639 }
 640 #endif
 641
 642 /*
 643  * Callback interface from driver
 644  */
 645 void CanIf_TxConfirmation(PduIdType canTxPduId)
 646 {
 647   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_TXCONFIRMATION_ID, CANIF_E_UNINIT)
 648   VALIDATE_NO_RV(canTxPduId < CanIf_ConfigPtr->InitConfig->CanIfNumberOfCanTXPduIds, CANIF_TXCONFIRMATION_ID, CANIF_E_PARAM_LPDU);
 649
 650   const CanIf_TxPduConfigType* entry =
 651     &CanIf_ConfigPtr->InitConfig->CanIfTxPduConfigPtr[canTxPduId];
 652
 653   /* Find the CAN id in the TxPduList */
 654   /*
 655   for (uint16 i = 0; i < CanIf_ConfigPtr->InitConfig->CanIfNumberOfCanTXPduIds; i++)
 656   {
 657     if (entry->CanIfTxPduId == canTxPduId)
 658     {
 659     */
 660       if (entry->CanIfUserTxConfirmation != NULL)
 661       {
 662         CanIf_ChannelGetModeType mode;
 663         CanIf_GetPduMode(entry->CanIfCanTxPduHthRef->CanIfCanControllerIdRef, &mode);
 664         if ((mode == CANIF_GET_TX_ONLINE) || (mode == CANIF_GET_ONLINE)
 665             || (mode == CANIF_GET_OFFLINE_ACTIVE) || (mode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE) )
 666         {
 667           entry->CanIfUserTxConfirmation(entry->CanIfTxPduId);  /* CANIF053 */
 668         }
 669       }
 670       return;
 671       /*
 672     }
 673
 674     entry++;
 675   }
 676   */
 677   // Did not find the PDU, something is wrong
 678
 679 }
 680
 681 void CanIf_RxIndication(uint8 Hrh, Can_IdType CanId, uint8 CanDlc,
 682               const uint8 *CanSduPtr)
 683 {
 684   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_RXINDICATION_ID, CANIF_E_UNINIT);
 685   VALIDATE_NO_RV(CanSduPtr != NULL, CANIF_RXINDICATION_ID, CANIF_E_PARAM_POINTER);
 686
 687   /* Check PDU mode before continue processing */
 688   CanIf_ChannelGetModeType mode;
 689   CanIf_Arc_ChannelIdType channel = CanIf_Arc_FindHrhChannel(Hrh);
 690   if (channel == -1)  // Invalid HRH
 691   {
 692     return;
 693   }
 694
 695   if (CanIf_GetPduMode(channel, &mode) == E_OK)
 696   {
 697     if (mode == CANIF_GET_OFFLINE || mode == CANIF_GET_TX_ONLINE ||
 698         mode == CANIF_GET_OFFLINE_ACTIVE)
 699     {
 700       // Receiver path is disabled so just drop it
 701       return;
 702     }
 703   }
 704   else
 705   {
 706     return;  // No mode so just return
 707   }
 708
 709   const CanIf_RxPduConfigType *entry = CanIf_ConfigPtr->InitConfig->CanIfRxPduConfigPtr;
 710
 711   /* Find the CAN id in the RxPduList */
 712   for (uint16 i = 0; i < CanIf_ConfigPtr->InitConfig->CanIfNumberOfCanRxPduIds; i++)
 713   {
 714     if (entry->CanIfCanRxPduHrhRef->CanIfHrhIdSymRef == Hrh)
 715     {
 716       // Software filtering
 717       if (entry->CanIfCanRxPduHrhRef->CanIfHrhType == CAN_ARC_HANDLE_TYPE_BASIC)
 718       {
 719         if (entry->CanIfCanRxPduHrhRef->CanIfSoftwareFilterHrh)
 720         {
 721           if (entry->CanIfSoftwareFilterType == CANIF_SOFTFILTER_TYPE_MASK)
 722           {
 723             if ((CanId & entry->CanIfCanRxPduCanIdMask ) ==
 724                 ( entry->CanIfCanRxPduCanId & entry->CanIfCanRxPduCanIdMask))
 725             {
 726               // We found a pdu so call higher layers
 727             }
 728             else
 729             {
 730               entry++;
 731               continue; // Not a supported filter type, so just drop the frame
 732             }
 733           }
 734           else
 735           {
 736             DET_REPORTERROR(MODULE_ID_CAN, 0, CANIF_RXINDICATION_ID, CANIF_E_PARAM_HRH);
 737             continue; // Not a supported filter type, so just drop the frame
 738           }
 739         }
 740       }
 741
 742 #if (CANIF_DLC_CHECK == STD_ON)
 743       if (CanDlc < entry->CanIfCanRxPduDlc)
 744       {
 745         VALIDATE_NO_RV(FALSE, CANIF_RXINDICATION_ID, CANIF_E_PARAM_DLC);
 746         return;
 747       }
 748 #endif
 749
 750       switch (entry->CanIfRxUserType)
 751       {
 752         case CANIF_USER_TYPE_CAN_SPECIAL:
 753         {
 754             ((CanIf_FuncTypeCanSpecial) (entry->CanIfUserRxIndication))(entry->CanIfCanRxPduId,
 755                                           CanSduPtr, CanDlc, CanId);
 756             return;
 757         }
 758         break;
 759
 760         case CANIF_USER_TYPE_CAN_NM:
 761         case CANIF_USER_TYPE_CAN_PDUR:
 762             // Send Can frame to PDU router
 763             PduR_CanIfRxIndication(entry->CanIfCanRxPduId,CanSduPtr);
 764             return;
 765             break;
 766
 767         case CANIF_USER_TYPE_CAN_TP:
 768           // Send Can frame to CAN TP
 769 #if defined(USE_CANTP)
 770             {
 771                     PduInfoType CanTpRxPdu;
 772                     CanTpRxPdu.SduLength = CanDlc;
 773                     CanTpRxPdu.SduDataPtr = (uint8 *)CanSduPtr;
 774                 CanTp_RxIndication(entry->CanIfCanRxPduId, &CanTpRxPdu); /** @req CANTP019 */
 775             }
 776             return;
 777 #endif
 778             break;
 779       }
 780     }
 781
 782     entry++;
 783   }
 784
 785   // Did not find the PDU, something is wrong
 786   VALIDATE_NO_RV(FALSE, CANIF_RXINDICATION_ID, CANIF_E_PARAM_LPDU);
 787 }
 788
 789 #if ( CANIF_TRANSMIT_CANCELLATION == STD_ON )
 790 void CanIf_CancelTxConfirmation(const Can_PduType *PduInfoPtr)
 791 {
 792   VALIDATE(FALSE, CANIF_CANCELTXCONFIRMATION_ID, CANIF_E_NOK_NOSUPPORT);
 793   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_CANCELTXCONFIRMATION_ID, CANIF_E_UNINIT);
 794   VALIDATE_NO_RV(PduInfoPtr != NULL, CANIF_RXINDICATION_ID, CANIF_E_PARAM_POINTER);
 795
 796   const CanIf_TxPduConfigType *entry =
 797     CanIf_ConfigPtr->InitConfig->CanIfTxPduConfigPtr;
 798
 799   // Not supported
 800
 801   // Did not find the PDU, something is wrong
 802   VALIDATE_NO_RV(FALSE, CANIF_TXCONFIRMATION_ID, CANIF_E_PARAM_LPDU);
 803 }
 804 #endif
 805
 806 void CanIf_ControllerBusOff(uint8 Controller)
 807 {
 808   // We call this a CanIf channel. Hopefully makes it easier to follow.
 809   CanIf_Arc_ChannelIdType channel = Controller;
 810
 811   VALIDATE_NO_RV( CanIf_Global.initRun, CANIF_CONTROLLER_BUSOFF_ID, CANIF_E_UNINIT );
 812   VALIDATE_NO_RV( Controller < CANIF_CHANNEL_CNT, CANIF_CONTROLLER_BUSOFF_ID, CANIF_E_PARAM_CONTROLLER );
 813
 814   // According to figure 35 in canif spec this should be done in
 815   // Can driver but it is better to do it here
 816   CanIf_SetControllerMode(channel, CANIF_CS_STOPPED);
 817
 818   if (CanIf_ConfigPtr->DispatchConfig->CanIfBusOffNotification != NULL)
 819   {
 820     CanIf_ConfigPtr->DispatchConfig->CanIfBusOffNotification(channel);
 821   }
 822 }
 823
 824 void CanIf_SetWakeupEvent(uint8 Controller)
 825 {
 826   // We call this a CanIf channel. Hopefully makes it easier to follow.
 827   CanIf_Arc_ChannelIdType channel = Controller;
 828
 829   VALIDATE_NO_RV(FALSE, CANIF_SETWAKEUPEVENT_ID, CANIF_E_NOK_NOSUPPORT);
 830   VALIDATE_NO_RV( CanIf_Global.initRun, CANIF_SETWAKEUPEVENT_ID, CANIF_E_UNINIT );
 831   VALIDATE_NO_RV( channel < CANIF_CHANNEL_CNT, CANIF_SETWAKEUPEVENT_ID, CANIF_E_PARAM_CONTROLLER );
 832
 833   // Not supported
 834 }
 835
 836 void CanIf_Arc_Error(uint8 Controller, Can_Arc_ErrorType Error)
 837 {
 838   // We call this a CanIf channel. Hopefully makes it easier to follow.
 839   CanIf_Arc_ChannelIdType channel = Controller;
 840
 841   VALIDATE_NO_RV( CanIf_Global.initRun, CANIF_ARCERROR_ID, CANIF_E_UNINIT );
 842   VALIDATE_NO_RV( channel < CANIF_CHANNEL_CNT, CANIF_ARCERROR_ID, CANIF_E_PARAM_CONTROLLER );
 843
 844   if (CanIf_ConfigPtr->DispatchConfig->CanIfErrorNotificaton != NULL)
 845   {
 846     CanIf_ConfigPtr->DispatchConfig->CanIfErrorNotificaton(Controller, Error);
 847   }
 848 }