canpie_hal.c

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

//****************************************************************************//
// File:          canpie_hal.c                                                //
// Description:   CANpie hardware abstraction layer (HAL)                     //
// Author:        Uwe Koppe                                                   //
// e-mail:        [e-mail]                                      //
//                                                                            //
//============================================================================//
// This program is free software; you can redistribute it and/or modify       //
// it under the terms of the GNU Lesser General Public License as published   //
// by the Free Software Foundation; either version 2.1 of the License, or     //
// (at your option) any later version.                                        //
//============================================================================//
//                                                                            //
// Date        History                                                        //
// ----------  -------------------------------------------------------------- //
// 29.07.2003  Initial version                                                //
//                                                                            //
//****************************************************************************//


//------------------------------------------------------------------------------
// CVS version information:
// $Id: canpie_hal.c,v 1.4 2005/06/23 13:29:54 microcontrol Exp $
//------------------------------------------------------------------------------




/*----------------------------------------------------------------------------*\
** Include files                                                              **
**                                                                            **
\*----------------------------------------------------------------------------*/

#include <asm/uaccess.h>         // memset()

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>

#include <linux/can/canpie_dbg.h>
#include <linux/can/canpie_hal.h>            // Hardware abstraction layer
#include <linux/can/canpie_proc.h>           // interface to /proc filesystem
#include <linux/can/cpcanmsg.h>              // CAN message struct access

#if CP_CONFIG_SOCKET == 1
#include <linux/can/af_can.h>                // socket support
#endif


/*----------------------------------------------------------------------------*\
** Definitions                                                                **
**                                                                            **
\*----------------------------------------------------------------------------*/




/*----------------------------------------------------------------------------*\
** Module information                                                         **
**                                                                            **
\*----------------------------------------------------------------------------*/
MODULE_DESCRIPTION("CANpie kernel driver");
MODULE_AUTHOR("Uwe Koppe <[e-mail]>");
MODULE_LICENSE("GPL");
MODULE_VERSION("1:"CP_MODULE_VERSION);


EXPORT_SYMBOL(can_register_driver);
EXPORT_SYMBOL(can_unregister_driver);

EXPORT_SYMBOL(can_queue_rcv_pop);
EXPORT_SYMBOL(can_queue_rcv_push);
EXPORT_SYMBOL(can_queue_trm_pop);
EXPORT_SYMBOL(can_queue_trm_push);

/*----------------------------------------------------------------------------*\
** Module variables                                                           **
**                                                                            **
\*----------------------------------------------------------------------------*/

static _TsCpHal   atsCpHalS[CP_CHANNEL_MAX];


/*----------------------------------------------------------------------------*\
** Debugging                                                                  **
**                                                                            **
\*----------------------------------------------------------------------------*/
#ifdef  CP_DEBUG
unsigned short    uwCpDebugG = 2;
module_param_named(debug, uwCpDebugG, ushort, 0);
MODULE_PARM_DESC(debug, " Set debug level, 0=quiet .. 5=noisy");

static char szMsgDbgS[64];    // CAN message debugging -> can_debug_frame()
static char *aszBitratesS[] = {  "10 kBit/s",
                                 "20 kBit/s",
                                 "50 kBit/s",
                                 "100 kBit/s",
                                 "125 kBit/s",
                                 "250 kBit/s",
                                 "500 kBit/s",
                                 "800 kBit/s",
                                 "1 MBit/s",
                                 "Used defined, BTR values"
                              };
                                 
static char *aszModeS[] =     {  "STOP",
                                 "ACTIVE",
                                 "SLEEP"
                              };
#endif


#ifdef  CP_DEBUG
static void can_print_frame(_TsCpCanMsg * ptsCanMsgV, char * szBufferV);
#else
#define can_print_frame(A, B)    
#endif



/*----------------------------------------------------------------------------*\
** Functions                                                                  **
**                                                                            **
\*----------------------------------------------------------------------------*/



//----------------------------------------------------------------------------//
// CpCoreBitrate()                                                            //
// Setup baudrate of CAN controller                                           //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreBitrate(_TsCpPort * ptsPortV, _TsCpBitrate * ptsBitrateV)
{
   _U08           ubReturnT;
   _FnBitrate     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].pfnBitrate;
   if(pfnHalT == 0L)
   {
      PK_DBG(eDBG_FUNC, "can%d: No driver function", ptsPortV->slLogIf);
      return(CpErr_NOT_SUPPORTED);
   }

   if(ptsBitrateV->ubBaudSel > CP_BAUD_MAX)
   {
      PK_DBG(  eDBG_FUNC, "can%d: bitrate out of range (ubBaudSel=%d)", 
               ptsPortV->slLogIf, ptsBitrateV->ubBaudSel                );
      return(CpErr_BAUDRATE); 
   }
   
   
   //----------------------------------------------------------------
   // call the handler 
   //
   //    
   PK_DBG(  eDBG_FUNC, "can%d: set bitrate to %s", 
            ptsPortV->slLogIf, aszBitratesS[ptsBitrateV->ubBaudSel]     );
            
   ubReturnT = (* pfnHalT )(ptsPortV, ptsBitrateV);         
   return(ubReturnT);
}


//----------------------------------------------------------------------------//
// CpCoreBufferGetDlc()                                                   		//
// Get DLC of buffer                                                			   //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreBufferGetDlc(_TsCpPort * ptsPortV, _U08 ubBufferV, _U08 * pubDlcV)
{
   _U08              ubReturnT;
   _FnBufferGetDlc   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].pfnBufferGetDlc;
   if(pfnHalT == 0L)
   {
      PK_DBG(2, "NULL pointer on channel %d", ptsPortV->slLogIf);
      return(CpErr_NOT_SUPPORTED);
   }


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


//----------------------------------------------------------------------------//
// CpCoreBufferInit()                                                        //
// Allocate buffer of FullCAN controller                                      //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreBufferInit(_U08 ubChannelV, _TsCpCanMsg * ptsCanMsgV,
                      _U08 ubDirectionV)
{
   //---	test the channel number ------------------------------------
	if( ubChannelV >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);


   return (CpErr_OK);
}

//----------------------------------------------------------------------------//
// CpCoreBufferRelease()                                                      //
// De-Allocate a FullCAN buffer                                               //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreBufferRelease(_U08 ubChannelV, _U08 ubBufferNumV)
{

   //---	test the channel number ------------------------------------
	if( (ubChannelV + 1) > CP_CHANNEL_MAX) return (CpErr_CHANNEL);

	return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpCoreBufferSetDlc()                                                   		//
// Set DLC of buffer                                                			   //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreBufferSetDlc(	_U08 ubChannelV, _U08 ubBufferV, _U08 ubDlcV)
{
   //--- test the channel number ------------------------------------
   if( ubChannelV >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);



   return (CpErr_OK);
}




//----------------------------------------------------------------------------//
// CpCoreBufferSend()                                                     		//
// Send message of FullCAN buffer                                      			//
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreBufferSend(_U08 ubChannelV, _U08 ubBufferV)
{
   //--- test the channel number ------------------------------------
   if( ubChannelV >= CP_CHANNEL_MAX) return (CpErr_CHANNEL);

   return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpCoreBufferTransmit()                                                     //
// Transmit contents of buffer                                                //

//----------------------------------------------------------------------------//
_TvCpStatus CpCoreBufferTransmit(_U08 ubChannelV, _TsCpCanMsg * ptsCanMsgV)
{
   //--- test the channel number ------------------------------------
   if( (ubChannelV + 1) > CP_CHANNEL_MAX) return (CpErr_CHANNEL);

	return (CpErr_OK);
}


//----------------------------------------------------------------------------//
// CpCoreCanMode()                                                            //
// Set state of CAN controller                                                //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreCanMode(_TsCpPort * ptsPortV, _U08 ubModeV)
{
   _U08              ubReturnT;
   _FnCanMode        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].pfnCanMode;
   if(pfnHalT == 0L)
   {
      PK_DBG(eDBG_FUNC, "can%d: No driver function", ptsPortV->slLogIf);
      return(CpErr_NOT_SUPPORTED);
   }

   if(ubModeV > CP_MODE_SLEEP)
   {
      PK_DBG(  eDBG_FUNC, "can%d: mode out of range (mode=%d)", 
               ptsPortV->slLogIf, ubModeV                         );
      return(CpErr_PARAM); 
   }
   

   //----------------------------------------------------------------
   // call the handler 
   //
   PK_DBG(  eDBG_FUNC, "can%d: set mode to '%s'", 
            ptsPortV->slLogIf, aszModeS[ubModeV]   );
   ubReturnT = (* pfnHalT )(ptsPortV, ubModeV);         
   return(ubReturnT);
}


//----------------------------------------------------------------------------//
// CpCoreCanState()                                                           //
// Retrive state of CAN controller                                            //
//----------------------------------------------------------------------------//
_TvCpStatus CpCoreCanStatus(_TsCpPort * ptsPortV, _U08 * pubStatusV)
{
   _U08              ubReturnT;
   _FnCanStatus      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].pfnCanStatus;
   if(pfnHalT == 0L)
   {
      PK_DBG(2, "NULL pointer on channel %d", ptsPortV->slLogIf);
      return(CpErr_NOT_SUPPORTED);
   }


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


//----------------------------------------------------------------------------//
// CpCoreCanStatistic()                                                       //
//                                                                            //
//----------------------------------------------------------------------------//