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   if(PduModeRequest == CANIF_SET_OFFLINE)
 461   {
 462     CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;
 463   }
 464   else if(PduModeRequest == CANIF_SET_RX_OFFLINE)
 465   {
 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   }
 475   else if(PduModeRequest == CANIF_SET_RX_ONLINE)
 476   {
 477     if (oldMode == CANIF_GET_OFFLINE)
 478       CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;
 479     else if (oldMode == CANIF_GET_TX_ONLINE)
 480       CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;
 481     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)
 482       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;
 483
 484     // Other oldmodes don't care
 485   }
 486   else if(PduModeRequest == CANIF_SET_TX_OFFLINE)
 487   {
 488     if (oldMode == CANIF_GET_TX_ONLINE)
 489       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;
 490     else if (oldMode == CANIF_GET_ONLINE)
 491       CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;
 492     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)
 493       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE;
 494     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE)
 495       CanIf_Global.channelData[channel].PduMode = CANIF_GET_RX_ONLINE;
 496
 497     // Other oldmodes don't care
 498   }
 499   else if(PduModeRequest == CANIF_SET_TX_ONLINE)
 500   {
 501     if (oldMode == CANIF_GET_OFFLINE)
 502       CanIf_Global.channelData[channel].PduMode = CANIF_GET_TX_ONLINE;
 503     else if (oldMode == CANIF_GET_RX_ONLINE)
 504       CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;
 505     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE)
 506       CanIf_Global.channelData[channel].PduMode = CANIF_GET_TX_ONLINE;
 507     else if (oldMode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE)
 508       CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;
 509
 510     // Other oldmodes don't care
 511   }
 512   else if(PduModeRequest == CANIF_SET_ONLINE)
 513   {
 514     CanIf_Global.channelData[channel].PduMode = CANIF_GET_ONLINE;
 515   }
 516   else if(PduModeRequest == CANIF_SET_TX_OFFLINE_ACTIVE)
 517   {
 518     if (oldMode == CANIF_GET_OFFLINE)
 519       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE;
 520     else if (oldMode == CANIF_GET_RX_ONLINE)
 521       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;
 522     else if (oldMode == CANIF_GET_TX_ONLINE)
 523       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE;
 524     else if (oldMode == CANIF_GET_ONLINE)
 525       CanIf_Global.channelData[channel].PduMode = CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE;
 526
 527     // Other oldmodes don't care
 528   }
 529
 530   return E_OK;
 531 }
 532
 533 //-------------------------------------------------------------------
 534
 535 Std_ReturnType CanIf_GetPduMode(uint8 Controller,
 536     CanIf_ChannelGetModeType *PduModePtr)
 537 {
 538   // We call this a CanIf channel. Hopefully makes it easier to follow.
 539   CanIf_Arc_ChannelIdType channel = Controller;
 540
 541   VALIDATE( CanIf_Global.initRun, CANIF_GETPDUMODE_ID, CANIF_E_UNINIT );
 542   VALIDATE( channel < CANIF_CHANNEL_CNT, CANIF_GETPDUMODE_ID, CANIF_E_PARAM_CONTROLLER );
 543
 544   *PduModePtr = CanIf_Global.channelData[channel].PduMode;
 545
 546   return E_OK;
 547 }
 548
 549 #if ( CANIF_SETDYNAMICTXID_API == STD_ON )
 550 void CanIf_SetDynamicTxId(PduIdType CanTxPduId, Can_IdType CanId)
 551 {
 552   const CanIf_TxPduConfigType *txEntry;
 553   VALIDATE(FALSE, CANIF_SETDYNAMICTX_ID, CANIF_E_NOK_NOSUPPORT);
 554   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_SETDYNAMICTX_ID, CANIF_E_UNINIT );
 555
 556   // Get the controller from L-PDU handle
 557   txEntry = CanIf_FindTxPduEntry(CanTxPduId);
 558
 559   if (txEntry == 0)
 560   {
 561     VALIDATE_NO_RV(FALSE, CANIF_SETDYNAMICTX_ID, CANIF_E_INVALID_TXPDUID);
 562     return;
 563   }
 564
 565   // Check that this is a dymanic PDU
 566   if (txEntry->CanIfCanTxPduType != ARC_PDU_TYPE_DYNAMIC)
 567   {
 568     VALIDATE_NO_RV(FALSE, CANIF_SETDYNAMICTX_ID, CANIF_E_INVALID_TXPDUID);
 569     return;
 570   }
 571
 572   // Check that this is an extended or standard id
 573   if (((CanId & 0x80000000) && (txEntry->CanIfTxPduIdCanIdType == ARC_CAN_ID_TYPE_29)) ||
 574       (((CanId & 0x80000000) == 0) && (txEntry->CanIfTxPduIdCanIdType == ARC_CAN_ID_TYPE_11)))
 575   {
 576     // Update the CanID
 577     //txEntry->CanIfCanTxPduIdCanId = CanId;  // TODO How do we fix this from a const pointer
 578
 579     // NOT SUPPORTED
 580   }
 581   else
 582   {
 583     // Inavlid Canid to configuration
 584     VALIDATE_NO_RV(FALSE, CANIF_SETDYNAMICTX_ID, CANIF_E_PARAM_CANID);
 585   }
 586 }
 587 #endif
 588
 589 #if ( CANIF_TRANSCEIVER_API == STD_ON )
 590 Std_ReturnType CanIf_SetTransceiverMode(uint8 Transceiver,
 591     CanIf_TransceiverModeType TransceiverMode)
 592 {
 593   VALIDATE(FALSE, CANIF_SET_TRANSCEIVERMODE_ID, CANIF_E_NOK_NOSUPPORT);
 594 // Not supported
 595
 596   return E_NOT_OK;
 597 }
 598
 599 Std_ReturnType CanIf_GetTransceiverMode(uint8 Transceiver,
 600     CanIf_TransceiverModeType *TransceiverModePtr)
 601 {
 602   VALIDATE(FALSE, CANIF_GET_TRANSCEIVERMODE_ID, CANIF_E_NOK_NOSUPPORT);
 603   // Not supported
 604
 605   return E_NOT_OK;
 606 }
 607
 608 Std_ReturnType CanIf_GetTrcvWakeupReason(uint8 Transceiver,
 609     CanIf_TrcvWakeupReasonType *TrcvWuReasonPtr)
 610 {
 611   VALIDATE(FALSE, CANIF_GET_TRCVMODEREASON_ID, CANIF_E_NOK_NOSUPPORT);
 612   // Not supported
 613
 614   return E_NOT_OK;
 615 }
 616
 617 Std_ReturnType CanIf_SetTransceiverWakeupMode(uint8 Transceiver,
 618     CanIf_TrcvWakeupModeType *TrcvWakeupMode)
 619 {
 620   VALIDATE(FALSE, CANIF_SET_TRANSCEIVERWAKEMODE_ID, CANIF_E_NOK_NOSUPPORT);
 621   // Not supported
 622
 623   return E_NOT_OK;
 624 }
 625 #endif
 626
 627 #if ( CANIF_WAKEUP_EVENT_API == STD_ON )
 628 Std_ReturnType CanIf_CheckWakeup(EcuM_WakeupSourceType WakeupSource)
 629 {
 630   VALIDATE(FALSE, CANIF_CHECKWAKEUP_ID, CANIF_E_NOK_NOSUPPORT);
 631   // Not supported
 632
 633   return E_NOT_OK;
 634 }
 635
 636 Std_ReturnType CanIf_CheckValidation(EcuM_WakeupSourceType WakeupSource)
 637 {
 638   VALIDATE(FALSE, CANIF_CHECKVALIDATION_ID, CANIF_E_NOK_NOSUPPORT);
 639   // Not supported
 640
 641   return E_NOT_OK;
 642 }
 643 #endif
 644
 645 /*
 646  * Callback interface from driver
 647  */
 648 void CanIf_TxConfirmation(PduIdType canTxPduId)
 649 {
 650   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_TXCONFIRMATION_ID, CANIF_E_UNINIT)
 651   VALIDATE_NO_RV(canTxPduId < CanIf_ConfigPtr->InitConfig->CanIfNumberOfCanTXPduIds, CANIF_TXCONFIRMATION_ID, CANIF_E_PARAM_LPDU);
 652
 653   const CanIf_TxPduConfigType* entry =
 654     &CanIf_ConfigPtr->InitConfig->CanIfTxPduConfigPtr[canTxPduId];
 655
 656   /* Find the CAN id in the TxPduList */
 657   /*
 658   for (uint16 i = 0; i < CanIf_ConfigPtr->InitConfig->CanIfNumberOfCanTXPduIds; i++)
 659   {
 660     if (entry->CanIfTxPduId == canTxPduId)
 661     {
 662     */
 663       if (entry->CanIfUserTxConfirmation != NULL)
 664       {
 665         CanIf_ChannelGetModeType mode;
 666         CanIf_GetPduMode(entry->CanIfCanTxPduHthRef->CanIfCanControllerIdRef, &mode);
 667         if ((mode == CANIF_GET_TX_ONLINE) || (mode == CANIF_GET_ONLINE)
 668             || (mode == CANIF_GET_OFFLINE_ACTIVE) || (mode == CANIF_GET_OFFLINE_ACTIVE_RX_ONLINE) )
 669         {
 670           entry->CanIfUserTxConfirmation(entry->CanIfTxPduId);  /* CANIF053 */
 671         }
 672       }
 673       return;
 674       /*
 675     }
 676
 677     entry++;
 678   }
 679   */
 680   // Did not find the PDU, something is wrong
 681
 682 }
 683
 684 void CanIf_RxIndication(uint8 Hrh, Can_IdType CanId, uint8 CanDlc,
 685               const uint8 *CanSduPtr)
 686 {
 687   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_RXINDICATION_ID, CANIF_E_UNINIT);
 688   VALIDATE_NO_RV(CanSduPtr != NULL, CANIF_RXINDICATION_ID, CANIF_E_PARAM_POINTER);
 689
 690   /* Check PDU mode before continue processing */
 691   CanIf_ChannelGetModeType mode;
 692   CanIf_Arc_ChannelIdType channel = CanIf_Arc_FindHrhChannel(Hrh);
 693   if (channel == -1)  // Invalid HRH
 694   {
 695     return;
 696   }
 697
 698   if (CanIf_GetPduMode(channel, &mode) == E_OK)
 699   {
 700     if (mode == CANIF_GET_OFFLINE || mode == CANIF_GET_TX_ONLINE ||
 701         mode == CANIF_GET_OFFLINE_ACTIVE)
 702     {
 703       // Receiver path is disabled so just drop it
 704       return;
 705     }
 706   }
 707   else
 708   {
 709     return;  // No mode so just return
 710   }
 711
 712   const CanIf_RxPduConfigType *entry = CanIf_ConfigPtr->InitConfig->CanIfRxPduConfigPtr;
 713
 714   /* Find the CAN id in the RxPduList */
 715   for (uint16 i = 0; i < CanIf_ConfigPtr->InitConfig->CanIfNumberOfCanRxPduIds; i++)
 716   {
 717     if (entry->CanIfCanRxPduHrhRef->CanIfHrhIdSymRef == Hrh)
 718     {
 719       // Software filtering
 720       if (entry->CanIfCanRxPduHrhRef->CanIfHrhType == CAN_ARC_HANDLE_TYPE_BASIC)
 721       {
 722         if (entry->CanIfCanRxPduHrhRef->CanIfSoftwareFilterHrh)
 723         {
 724           if (entry->CanIfSoftwareFilterType == CANIF_SOFTFILTER_TYPE_MASK)
 725           {
 726             if ((CanId & entry->CanIfCanRxPduCanIdMask ) ==
 727                 ( entry->CanIfCanRxPduCanId & entry->CanIfCanRxPduCanIdMask))
 728             {
 729               // We found a pdu so call higher layers
 730             }
 731             else
 732             {
 733               entry++;
 734               continue; // Not a supported filter type, so just drop the frame
 735             }
 736           }
 737           else
 738           {
 739             DET_REPORTERROR(MODULE_ID_CAN, 0, CANIF_RXINDICATION_ID, CANIF_E_PARAM_HRH);
 740             continue; // Not a supported filter type, so just drop the frame
 741           }
 742         }
 743       }
 744
 745 #if (CANIF_DLC_CHECK == STD_ON)
 746       if (CanDlc < entry->CanIfCanRxPduDlc)
 747       {
 748         VALIDATE_NO_RV(FALSE, CANIF_RXINDICATION_ID, CANIF_E_PARAM_DLC);
 749         return;
 750       }
 751 #endif
 752
 753       switch (entry->CanIfRxUserType)
 754       {
 755         case CANIF_USER_TYPE_CAN_SPECIAL:
 756         {
 757             ((CanIf_FuncTypeCanSpecial) (entry->CanIfUserRxIndication))(entry->CanIfCanRxPduId,
 758                                           CanSduPtr, CanDlc, CanId);
 759             return;
 760         }
 761         break;
 762
 763         case CANIF_USER_TYPE_CAN_NM:
 764         case CANIF_USER_TYPE_CAN_PDUR:
 765             // Send Can frame to PDU router
 766             PduR_CanIfRxIndication(entry->CanIfCanRxPduId,CanSduPtr);
 767             return;
 768             break;
 769
 770         case CANIF_USER_TYPE_CAN_TP:
 771           // Send Can frame to CAN TP
 772 #if defined(USE_CANTP)
 773             {
 774                     PduInfoType CanTpRxPdu;
 775                     CanTpRxPdu.SduLength = CanDlc;
 776                     CanTpRxPdu.SduDataPtr = (uint8 *)CanSduPtr;
 777                 CanTp_RxIndication(entry->CanIfCanRxPduId, &CanTpRxPdu);
 778             }
 779             return;
 780 #endif
 781             break;
 782       }
 783     }
 784
 785     entry++;
 786   }
 787
 788   // Did not find the PDU, something is wrong
 789   VALIDATE_NO_RV(FALSE, CANIF_RXINDICATION_ID, CANIF_E_PARAM_LPDU);
 790 }
 791
 792 #if ( CANIF_TRANSMIT_CANCELLATION == STD_ON )
 793 void CanIf_CancelTxConfirmation(const Can_PduType *PduInfoPtr)
 794 {
 795   VALIDATE(FALSE, CANIF_CANCELTXCONFIRMATION_ID, CANIF_E_NOK_NOSUPPORT);
 796   VALIDATE_NO_RV(CanIf_Global.initRun, CANIF_CANCELTXCONFIRMATION_ID, CANIF_E_UNINIT);
 797   VALIDATE_NO_RV(PduInfoPtr != NULL, CANIF_RXINDICATION_ID, CANIF_E_PARAM_POINTER);
 798
 799   const CanIf_TxPduConfigType *entry =
 800     CanIf_ConfigPtr->InitConfig->CanIfTxPduConfigPtr;
 801
 802   // Not supported
 803
 804   // Did not find the PDU, something is wrong
 805   VALIDATE_NO_RV(FALSE, CANIF_TXCONFIRMATION_ID, CANIF_E_PARAM_LPDU);
 806 }
 807 #endif
 808
 809 void CanIf_ControllerBusOff(uint8 Controller)
 810 {
 811   // We call this a CanIf channel. Hopefully makes it easier to follow.
 812   CanIf_Arc_ChannelIdType channel = Controller;
 813
 814   VALIDATE_NO_RV( CanIf_Global.initRun, CANIF_CONTROLLER_BUSOFF_ID, CANIF_E_UNINIT );
 815   VALIDATE_NO_RV( Controller < CANIF_CHANNEL_CNT, CANIF_CONTROLLER_BUSOFF_ID, CANIF_E_PARAM_CONTROLLER );
 816
 817   // According to figure 35 in canif spec this should be done in
 818   // Can driver but it is better to do it here
 819   CanIf_SetControllerMode(channel, CANIF_CS_STOPPED);
 820
 821   if (CanIf_ConfigPtr->DispatchConfig->CanIfBusOffNotification != NULL)
 822   {
 823     CanIf_ConfigPtr->DispatchConfig->CanIfBusOffNotification(channel);
 824   }
 825 }
 826
 827 void CanIf_SetWakeupEvent(uint8 Controller)
 828 {
 829   // We call this a CanIf channel. Hopefully makes it easier to follow.
 830   CanIf_Arc_ChannelIdType channel = Controller;
 831
 832   VALIDATE_NO_RV(FALSE, CANIF_SETWAKEUPEVENT_ID, CANIF_E_NOK_NOSUPPORT);
 833   VALIDATE_NO_RV( CanIf_Global.initRun, CANIF_SETWAKEUPEVENT_ID, CANIF_E_UNINIT );
 834   VALIDATE_NO_RV( channel < CANIF_CHANNEL_CNT, CANIF_SETWAKEUPEVENT_ID, CANIF_E_PARAM_CONTROLLER );
 835
 836   // Not supported
 837 }
 838
 839 void CanIf_Arc_Error(uint8 Controller, Can_Arc_ErrorType Error)
 840 {
 841   // We call this a CanIf channel. Hopefully makes it easier to follow.
 842   CanIf_Arc_ChannelIdType channel = Controller;
 843
 844   VALIDATE_NO_RV( CanIf_Global.initRun, CANIF_ARCERROR_ID, CANIF_E_UNINIT );
 845   VALIDATE_NO_RV( channel < CANIF_CHANNEL_CNT, CANIF_ARCERROR_ID, CANIF_E_PARAM_CONTROLLER );
 846
 847   if (CanIf_ConfigPtr->DispatchConfig->CanIfErrorNotificaton != NULL)
 848   {
 849     CanIf_ConfigPtr->DispatchConfig->CanIfErrorNotificaton(Controller, Error);
 850   }
 851 }