communication/CanIf/CanIf.c

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