canpie_hal.c.svn-base

canpie 一个can bus的协议栈 - CAN interface for embedded control - CAN interface for PC (without local

_TvCpStatus CpCoreCanStatistic(_TsCpPort * ptsPortV, _TsCpStats * ptsStatV)
{
   _U08              ubReturnT;
   _FnCanStats       pfnHalT;          // function of HAL
   

   //----------------------------------------------------------------
   // check logic port number
   //
   if(ptsPortV == 0L) return(CpErr_CHANNEL);   
   if( (ptsPortV->slLogIf) >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);
   
   //----------------------------------------------------------------
   // test if handler is installed on the requested channel
   //
   pfnHalT = atsCpHalS[ptsPortV->slLogIf].pfnCanStats;
   if(pfnHalT == 0L)
   {
      PK_DBG(2, "NULL pointer on channel %d", ptsPortV->slLogIf);
      return(CpErr_NOT_SUPPORTED);
   }


   //----------------------------------------------------------------
   // call the handler 
   //
   ubReturnT = (* pfnHalT )(ptsPortV, ptsStatV);         
   return(ubReturnT);
}


//----------------------------------------------------------------------------//
// CpCoreDriverInit()                                                         //
// Initialize the CAN driver                                                  //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreDriverInit(_U08 ubLogIfV, _TsCpPort * ptsPortV)
{
   _U08           ubReturnT;
   _U08           ubPhyIfT;   // physical CAN interface (for driver)
   _FnDriverInit  pfnHalT;    // function of HAL
   
   
   //----------------------------------------------------------------
   // test the logical CAN interface number
   //
   if( ubLogIfV >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);


   //----------------------------------------------------------------
   // test if handler is installed on the requested channel
   //
   pfnHalT = atsCpHalS[ubLogIfV].pfnDriverInit;
   if(pfnHalT == 0L)
   {
      PK_DBG(eDBG_FUNC, "No driver function on can%d", ubLogIfV);
      return(CpErr_NOT_SUPPORTED);
   }


   //----------------------------------------------------------------
   // convert the logical interface number to the physical interface
   // number and call the function of the driver
   //
   ubPhyIfT = ptsPortV->slPhyIf;
   ubReturnT = (* pfnHalT )(ubPhyIfT, ptsPortV);

   return(ubReturnT);
}


//----------------------------------------------------------------------------//
// CpCoreDriverRelease()                                                      //
// release the CAN driver                                                     //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreDriverRelease(_TsCpPort * ptsPortV)
{
   _U08              ubReturnT;
   _FnDriverRelease  pfnHalT;          // function of HAL
   

   //----------------------------------------------------------------
   // check logic port number
   //
   if(ptsPortV == 0L) return(CpErr_CHANNEL);   
   if( (ptsPortV->slLogIf) >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);
   
   //----------------------------------------------------------------
   // test if handler is installed on the requested channel
   //
   pfnHalT = atsCpHalS[ptsPortV->slLogIf].pfnDriverRelease;
   if(pfnHalT == 0L)
   {
      PK_DBG(2, "NULL pointer on channel %d", ptsPortV->slLogIf);
      return(CpErr_NOT_SUPPORTED);
   }


   //----------------------------------------------------------------
   // call the handler 
   //
   ubReturnT = (* pfnHalT )(ptsPortV);         
   return(ubReturnT);
}



//----------------------------------------------------------------------------//
// CpCoreHDI()                                                                //
// Fill Hardware Description Interface (HDI) structure                        //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreHDI(_U08 ubChannelV, CpStruct_HDI * pHdiV)
{
   //--- test the channel number ------------------------------------

   if( (ubChannelV + 1) > CP_CHANNEL_MAX) return (CpErr_CHANNEL);

   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpCoreFilterAll()                                                          //
// Enable / Disable filter for all messages                                   //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreFilterAll(_U08 ubChannelV, _BIT btEnableV)
{
   //--- test the channel number ------------------------------------
   if( (ubChannelV + 1) > CP_CHANNEL_MAX) return (CpErr_CHANNEL);


   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpCoreFilterMsg()                                                          //
// Enable / Disable filter for a single messages                              //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreFilterMsg(_U08 ubChannelV, _U16 uwIdV, _BIT btEnableV)
{
   //--- test the channel number ------------------------------------
   if( ubChannelV >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);


   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpCoreMsgReceive()                                                         //
// Read CAN message from controller                                           //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreMsgRead( _TsCpPort * ptsPortV, _TsCpCanMsg * ptsCanMsgV, 
                           _U16 * puwMsgCntV)
{
   _U08              ubReturnT;
   _FnMsgRead        pfnHalT;          // function of HAL
   

   //----------------------------------------------------------------
   // check logic port number
   //
   if(ptsPortV == 0L) return(CpErr_CHANNEL);   
   if( (ptsPortV->slLogIf) >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);
   
   //----------------------------------------------------------------
   // test if handler is installed on the requested channel
   //
   pfnHalT = atsCpHalS[ptsPortV->slLogIf].pfnMsgRead;
   if(pfnHalT == 0L)
   {
      PK_DBG(eDBG_FUNC, "No driver function on can%d", ptsPortV->slLogIf);
      return(CpErr_NOT_SUPPORTED);
   }


   //----------------------------------------------------------------
   // call the handler 
   //
   ubReturnT = (* pfnHalT )(ptsPortV, ptsCanMsgV, puwMsgCntV);         
   return(ubReturnT);
}


//----------------------------------------------------------------------------//
// CpCoreMsgWrite()                                                           //
// Write CAN message to controller                                            //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreMsgWrite(_TsCpPort * ptsPortV, _TsCpCanMsg * ptsCanMsgV,
                           _U16 * puwMsgCntV)
{
   _U08              ubReturnT;
   int               slMsgCntReqT;     // number of messages to send
   int               slFifoCopyT;      // number of messages copied to FIFO
   _FnMsgWrite       pfnHalT;          // function of HAL
   

   //----------------------------------------------------------------
   // check logic port number
   //
   if(ptsPortV == 0L) return(CpErr_CHANNEL);   
   if( (ptsPortV->slLogIf) >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);
   
   //----------------------------------------------------------------
   // test if handler is installed on the requested channel
   //
   pfnHalT = atsCpHalS[ptsPortV->slLogIf].pfnMsgWrite;
   if(pfnHalT == 0L)
   {
      PK_DBG(eDBG_FUNC, "No driver function on can%d", ptsPortV->slLogIf);
      return(CpErr_NOT_SUPPORTED);
   }

   //----------------------------------------------------------------
   // push the messages into the transmit queue, a positiv
   // return value denotes the number of messages that could
   // be placed into the transmit FIFO. In general, the value
   // should be the same then the request. A negative return
   // value denotes an error.
   //
   slMsgCntReqT = (int) (*puwMsgCntV);
   if(slMsgCntReqT < 1)
   {
      //---------------------------------------------------
      // there is nothing to send, so just quit here
      //
      return(CpErr_OK);   
   }
   slFifoCopyT = can_queue_trm_push(ptsPortV, ptsCanMsgV, slMsgCntReqT);

   can_print_frame(ptsCanMsgV, szMsgDbgS);
   PK_DBG(eDBG_FUNC, "%s", szMsgDbgS);
   
   //----------------------------------------------------------------
   // test for error return codes
   //
   if(slFifoCopyT < 0)
   {
      if(slFifoCopyT == -ENODEV) return(CpErr_CHANNEL);
      if(slFifoCopyT == -EINVAL) return(CpErr_FIFO_PARM);
      
      return(CpErr_GENERIC);
   }

      
   //----------------------------------------------------------------
   // test if requested size is equal to response size
   //
   if(slFifoCopyT != slMsgCntReqT)
   {
      ubReturnT = CpErr_FIFO_FULL;
   }
   else
   {
      ubReturnT = CpErr_OK;
   }
   
   
   //----------------------------------------------------------------
   // call the handler 
   //
   (* pfnHalT )(ptsPortV, ptsCanMsgV, puwMsgCntV);         
   return(ubReturnT);
}



//----------------------------------------------------------------------------//
// CpCoreRegRead()                                                            //
// Read one byte from specified CAN controller register                       //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreRegRead(_U08 ubChannelV, _U16 uwRegAdrV, _U08 * pubValueV)
{
   //--- check if channel is valid ----------------------------------
   if (ubChannelV >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);


   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpCoreRegWrite()                                                           //
// Write one byte to specified CAN controller register                        //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreRegWrite(_U08 ubChannelV, _U16 uwRegAdrV, _U08 ubValueV)
{
   //--- check if channel is valid ----------------------------------
   if (ubChannelV >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);


   return (CpErr_OK);
}



//============================================================================//
// functions for queue management                                             //
//                                                                            //
//============================================================================//


//----------------------------------------------------------------------------//
// can_queue_create()                                                         //
// create a new Tx & Rx queue on logic CAN interface with index 'slLogIfV'    //
//----------------------------------------------------------------------------//
_TsCpPort * can_queue_create(int slLogIfV, 
                             int slRcvFifoSizeV, int slTrmFifoSizeV)
{
   _TsCpMsgQueue *   ptsQueueT;           // pointer to CAN message queue
   int               slQueueCntT;         // counter for queue
   int               slQueueIdT = -1;     // selected queue ID
   
      
   
   PK_DBG(eDBG_PORT, "Create queue on log. CAN-I/F %d", slLogIfV);

   //----------------------------------------------------------------
   // check if the logical interface number is in range
   //   
   if( (slLogIfV > CP_CHANNEL_MAX - 1) || (slLogIfV < 0) )
   {
      return(0L);
   }

         
   //-------------------------------------------------------------------
   // check the FIFO size first and make sure that it is not above
   // 65535 entries
   //
   if( (slRcvFifoSizeV < CP_QUEUE_MSG_MIN) || 
       (slRcvFifoSizeV > CP_QUEUE_MSG_MAX)   )
   {
      slRcvFifoSizeV = CP_QUEUE_MSG_DEF;
   }

   if( (slTrmFifoSizeV < CP_QUEUE_MSG_MIN) || 
       (slTrmFifoSizeV > CP_QUEUE_MSG_MAX)   )
   {
      slTrmFifoSizeV = CP_QUEUE_MSG_DEF;
   }
   
   //----------------------------------------------------------------
   // check if there is a free entry in the queue array for the
   // selected logic CAN interface
   //
   for(slQueueCntT = 0; slQueueCntT < CP_QUEUE_MAX; slQueueCntT++)
   {
      ptsQueueT = &(atsCpHalS[slLogIfV].atsMsgQueue[slQueueCntT]);
      PK_DBG(2, "slQueue = %d", ptsQueueT->tsCanPort.slQueue);
      
      if(ptsQueueT->tsCanPort.slQueue == -1)
      {
         //------------------------------------------------
         // this queue is not assigned, store the queue
         // number and quit the loop
         //
         slQueueIdT = slQueueCntT;
         PK_DBG(2, "found free queue, ID= %d", slQueueIdT);
         break;
      }
   }