drx_driver.c

用于DRX3973或DRX39系列的芯片的控制

      drxDriverCoreVersionText    /**< version as text string */
   };

   static DRXVersionList_t drxDriverCoreVersionList = {
      &drxDriverCoreVersion,
      NULL
   };

   pDRXVersionList_t demodVersionList = NULL;
   DRXStatus_t returnStatus = DRX_STS_ERROR;

   /* Check arguments */
   if ( versionList == NULL )
   {
      return ( DRX_STS_INVALID_ARG );
   }

   /* Get version info list from demod */
   returnStatus = (*(demod->myDemodFunct->ctrlFunc))(
                           demod,
                           DRX_CTRL_VERSION,
                           (void *) &demodVersionList );

   /* Always fill in the information of the driver SW . */
   drxDriverCoreVersion.moduleType  = DRX_MODULE_DRIVERCORE;
   drxDriverCoreVersion.moduleName  = drxDriverCoreModuleName;
   drxDriverCoreVersion.vMajor      = VERSION_MAJOR;
   drxDriverCoreVersion.vMinor      = VERSION_MINOR;
   drxDriverCoreVersion.vPatch      = VERSION_PATCH;
   drxDriverCoreVersion.vString     =
         DRX_VERSIONSTRING( VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH );

   drxDriverCoreVersionList.version = &drxDriverCoreVersion;
   drxDriverCoreVersionList.next    = NULL;

   if (( returnStatus == DRX_STS_OK ) && ( demodVersionList != NULL ))
   {
      /* Append versioninfo from driver to versioninfo from demod  */
      /* Return version info in "bottom-up" order. This way, multiple
         devices can be handled without using malloc. */
      pDRXVersionList_t currentListElement = demodVersionList;
      while ( currentListElement->next != NULL )
      {
         currentListElement = currentListElement->next;
      }
      currentListElement->next = &drxDriverCoreVersionList;

      *versionList = demodVersionList;
   }
   else
   {
      /* Just return versioninfo from driver */
      *versionList = &drxDriverCoreVersionList;
   }

   return (DRX_STS_OK);
}

/*============================================================================*/
/*============================================================================*/
/*== Driver helper functions =================================================*/
/*============================================================================*/
/*============================================================================*/

/**
* \fn u32_t CountInList(pDRXDemodInstance_t demod,pDRXDemodInstance_t listOfDemods [])
* \brief Count occurences of demod pointer in listOfDemods
* \param demod A pointer to a demodulator instance.
* \param listOfDemods Pointer to a linked list of pointers to demods.
* \return Number of occurences.
*/
static u32_t
CountInList( pDRXDemodInstance_t demod,
             pDRXDemodInstance_t listOfDemods [] )
{
   u32_t result = 0;

   if ( ( demod != NULL ) || ( listOfDemods != NULL ) )
   {
      u32_t i = 0;
      while (listOfDemods[i] != NULL)
      {
         if (listOfDemods[i] == demod)
         {
            result++;
         }
         i++;
      }
   }

   return (result);
}

/*============================================================================*/

/**
* \fn Bool_t AllInstancesUnique( pDRXDemodInstance_t listOfDemods [] )
* \brief Check if all pointers in listOfDemods are unique.
* \param listOfDemods Pointer to a linked list of pointers to demods.
* \return TRUE if all pointers are unique, FALSE otherwise.
*/
static Bool_t
AllInstancesUnique( pDRXDemodInstance_t listOfDemods [] )
{
   Bool_t result = FALSE;

   if ( listOfDemods != NULL )
   {
      pDRXDemodInstance_t *demod=listOfDemods;

      while ( (*demod) != NULL )
      {
         if ( CountInList( (*demod), listOfDemods ) > 1 )
         {
            break;
         }
         demod++;
      }

      if ( (*demod) == NULL )
      {
         /* No demod occures more then once */
         result = TRUE;
      }
   }

   return (result);
}

/*============================================================================*/
/*============================================================================*/
/*== Exported functions ======================================================*/
/*============================================================================*/
/*============================================================================*/



/**
* \fn DRXStatus_t DRX_Init(  pDRXDemodInstance_t demods[]  )
* \brief Initialize driver.
* \param demods A non-empty, NULL terminated array of pointers to demodulator instances.
* \return DRXStatus_t Return status.
* \retval DRX_STS_OK Initialization completed.
* \retval DRX_STS_INVALID_ARG The array demods is empty or has invalid content.
*
* Initialize driver. Check if this has already been done, if so abort. Checks
* if each pointer in the demods array is unique, if not abort.
*
*/

DRXStatus_t
DRX_Init(  pDRXDemodInstance_t demods[]  )
{
   if ( drxDriverDemodsInstancesList != NULL )
   {
      /* DRX_Init() was already called. */
      return (DRX_STS_ERROR);
   }

   if ( ( demods == NULL ) ||
        ( demods[0] == NULL ) ||
        ( AllInstancesUnique( demods ) == FALSE ) )
   {
      return (DRX_STS_INVALID_ARG);
   }

   drxDriverDemodsInstancesList = &(demods[0]);

   return DRX_STS_OK;
}

/*============================================================================*/

/**
* \fn DRXStatus_t DRX_Term( void )
* \brief Terminate driver.
* \return DRXStatus_t Return status.
* \retval DRX_STS_OK Terminated driver successful.
* \retval DRX_STS_ERROR Error on closing one or more demodulators.
*
* Close all unclosed demodulators.
*
*/

DRXStatus_t
DRX_Term( void )
{
   pDRXDemodInstance_t *demod = NULL;
   DRXStatus_t closingStatus = DRX_STS_OK;

   if ( drxDriverDemodsInstancesList == NULL )
   {
      /* DRX_Init() not corectly called before calling DRX_Term() */
      return (DRX_STS_ERROR);
   }

   /* Close all demods if necesarry. */
   demod = drxDriverDemodsInstancesList;
   while ( (*demod) != NULL )
   {
      if ( ( (*demod)->myDemodFunct != NULL ) &&
           ( (*demod)->myCommonAttr != NULL ) &&
           ( (*demod)->myI2CDevAddr != NULL ) &&
           ( (*demod)->myCommonAttr->isOpened == TRUE ) )
      {
         if ( DRX_Close( (*demod) ) != DRX_STS_OK )
         {
            closingStatus = DRX_STS_ERROR;
         };
      }
      demod++;
   };

   /* Invalidate driver initialisation. */
   drxDriverDemodsInstancesList = NULL;

   return (closingStatus);
}

/*============================================================================*/

/**
* \fn DRXStatus_t DRX_Open(pDRXDemodInstance_t demod)
* \brief Open a demodulator instance.
* \param demod A pointer to a demodulator instance.
* \return DRXStatus_t Return status.
* \retval DRX_STS_OK Opened demod instance with succes.
* \retval DRX_STS_INVALID_ARG Demod instance has invalid content.
* \retval DRX_STS_ERROR Driver not initialized or unable to initialize demod.
*
*/

DRXStatus_t
DRX_Open(pDRXDemodInstance_t demod)
{
   DRXStatus_t status = DRX_STS_OK;

   if ( drxDriverDemodsInstancesList == NULL )
   {
      return (DRX_STS_ERROR);
   }

   if ( ( demod == NULL ) ||
        ( demod->myDemodFunct == NULL ) ||
        ( demod->myCommonAttr == NULL ) ||
        ( demod->myI2CDevAddr == NULL ) ||
        ( demod->myCommonAttr->isOpened == TRUE ) ||
        ( CountInList( demod, drxDriverDemodsInstancesList) == 0 ) )
   {
      return (DRX_STS_INVALID_ARG);
   }

   status = (*(demod->myDemodFunct->openFunc))( demod );

   if ( status == DRX_STS_OK )
   {
      demod->myCommonAttr->isOpened = TRUE;
   }

   return ( status );
}

/*============================================================================*/

/**
* \fn Status_t DRX_Close( pDRXDemodInstance_t demod)
* \brief Close device.
* \param demod A pointer to a demodulator instance.
* \return DRXStatus_t Return status.
* \retval DRX_STS_OK Closed demod instance with succes.
* \retval DRX_STS_INVALID_ARG Demod instance has invalid content.
* \retval DRX_STS_ERROR Driver not initialized or error during close demod.
*
* Free resources occupied by device instance.
* Put device into sleep mode.
*/

DRXStatus_t
DRX_Close(pDRXDemodInstance_t demod)
{
   DRXStatus_t status = DRX_STS_OK;

   if ( drxDriverDemodsInstancesList == NULL )
   {
      return (DRX_STS_ERROR);
   }

   if ( ( demod == NULL ) ||
        ( demod->myCommonAttr == NULL ) ||
        ( demod->myCommonAttr->isOpened == FALSE ) ||
        ( CountInList( demod, drxDriverDemodsInstancesList) == 0 ) )
   {
      return (DRX_STS_INVALID_ARG);
   }

   status = (*(demod->myDemodFunct->closeFunc))( demod );

   if ( status == DRX_STS_OK )
   {
      demod->myCommonAttr->isOpened = FALSE;
   }

   return ( status );
}

/*============================================================================*/

/**
* \fn Status_t DRX_Ctrl( pDRXDemodInstance_t demod, DRXCtrlIndex_t ctrl, void *ctrlData)
* \brief Control device.
* \param demod A pointer to a demodulator instance.
* \param ctrl Reference to desired control function.
* \param ctrlData Pointer to data structure for control function.
* \return DRXStatus_t Return status.
* \retval DRX_STS_OK Control function completed successful.
* \retval DRX_STS_INVALID_ARG Demod instance or ctrlData has invalid content.
* \retval DRX_STS_ERROR Driver not initialized or error during control demod.
*
* Data needed or returned by the control function is stored in ctrlData.
*
*/

DRXStatus_t
DRX_Ctrl(pDRXDemodInstance_t demod, DRXCtrlIndex_t ctrl, void *ctrlData)
{
   DRXStatus_t status = DRX_STS_ERROR;

   if ( drxDriverDemodsInstancesList == NULL )
   {
      return (DRX_STS_ERROR);
   }

   if ( ( demod == NULL ) ||
        ( CountInList( demod, drxDriverDemodsInstancesList) == 0 ) ||
        ( demod->myCommonAttr == NULL ) ||
        ( ( demod->myCommonAttr->isOpened == FALSE ) &&
          ( ctrl != DRX_CTRL_PROBE_DEVICE ) ) )
   {
      return (DRX_STS_INVALID_ARG);
   }

   /* Fixed control functions */
   switch ( ctrl ) {
      /*======================================================================*/
      case DRX_CTRL_NOP:
         /* No operation */
         return (DRX_STS_OK);
         break;

      /*======================================================================*/
      case DRX_CTRL_VERSION:
         {
            return CtrlVersion( demod, (pDRXVersionList_t *) ctrlData );
         }
         break;

      /*======================================================================*/
      default :
         /* Do nothing */
         break;
   }

   /* Virtual functions */
   /* First try calling function from derived class */
   status = (*(demod->myDemodFunct->ctrlFunc))( demod, ctrl, ctrlData );
   if ( status == DRX_STS_FUNC_NOT_AVAILABLE )
   {
      /* Now try calling a the base class function */
      switch ( ctrl ) {
         /*======================================================================*/
         case DRX_CTRL_LOAD_UCODE:
            {
               return CtrlUCode ( demod,
                                  (pDRXUCodeInfo_t) ctrlData,
                                  UCODE_UPLOAD);
            }
            break;

         /*======================================================================*/
         case DRX_CTRL_VERIFY_UCODE:
            {
               return CtrlUCode ( demod,
                                  (pDRXUCodeInfo_t) ctrlData,
                                  UCODE_VERIFY);
            }
            break;

         /*======================================================================*/
         case DRX_CTRL_SCAN_INIT:
            {
               return CtrlScanInit( demod, (pDRXScanParam_t) ctrlData );
            }
            break;

         /*======================================================================*/
         case DRX_CTRL_SCAN_NEXT:
            {
               return CtrlScanNext( demod, (pu16_t) ctrlData );
            }
            break;

         /*======================================================================*/
         default :
            return (DRX_STS_FUNC_NOT_AVAILABLE);
      }
   } else {
      return (status);
   } /* if ( status == DRX_STS_FUNC_NOT_AVAILABLE ) */

   return (DRX_STS_OK);
}


/*============================================================================*/

/* END OF FILE */