mt_mac.c

Zigbee2006入门源代码,包括了Zigbee的入门介绍,和源代码

/*********************************************************************
    Filename:       MT_MAC.c
    Revised:        $Date: 2007-02-26 12:07:41 -0800 (Mon, 26 Feb 2007) $
    Revision:       $Revision: 13608 $

    Description:

        MonitorTest functions for the MAC layer.

    Notes:

    Copyright (c) 2006 by Texas Instruments, Inc.
    All Rights Reserved.  Permission to use, reproduce, copy, prepare
    derivative works, modify, distribute, perform, display or sell this
    software and/or its documentation for any purpose is prohibited
    without the express written consent of Texas Instruments, Inc.
*********************************************************************/
#if defined ( MT_MAC_FUNC )             //MAC commands
/*********************************************************************
 * INCLUDES
 */
#include "ZComDef.h"
#include "OSAL.h"
#include "MTEL.h"
#include "ZMAC.h"
#include "MT_MAC.h"

#if !defined( WIN32 )
  #include "OnBoard.h"
#endif

/* Hal */
#include "hal_uart.h"
#include "SPIMgr.h"

/*********************************************************************
 * MACROS
 */

/* The length in bytes of the pending address fields in the beacon */
#define MT_MAC_PEND_LEN(pendAddrSpec)   ((((pendAddrSpec) & 0x07) * 2) + \
                                        ((((pendAddrSpec) & 0x70) >> 4) * 8))

/* This matches the value used by nwk */
#define MT_MAC_ED_SCAN_MAXCHANNELS      27

/* Maximum size of pending address spec in beacon notify ind */
#define MT_MAC_PEND_LEN_MAX             32

/* Maximum size of the payload SDU in beacon notify ind */
#define MT_MAC_SDU_LEN_MAX              32

/* Maximum length of scan result in bytes */
#define MT_MAC_SCAN_RESULT_LEN_MAX      32

/* Maximum size of beacon payload */
#define MT_MAC_BEACON_PAYLOAD_MAX       16

/*********************************************************************
 * CONSTANTS
 */
#define DEFAULT_NSDU_HANDLE             0x00

/*********************************************************************
 * TYPEDEFS
 */

/*********************************************************************
 * GLOBAL VARIABLES
 */
uint16 _macCallbackSub;

union
{
  ZMacStartReq_t        startReq;
  ZMacScanReq_t         scanReq;
  ZMacDataReq_t         dataReq;
  ZMacAssociateReq_t    assocReq;
  ZMacAssociateRsp_t    assocRsp;
  ZMacDisassociateReq_t disassocReq;
  ZMacOrphanRsp_t       orphanRsp;
  ZMacRxEnableReq_t     rxEnableReq;
  ZMacSyncReq_t         syncReq;
  ZMacPollReq_t         pollReq;
} mtMac;

/*********************************************************************
 * EXTERNAL VARIABLES
 */

/*********************************************************************
 * EXTERNAL FUNCTIONS
 */

/*********************************************************************
 * LOCAL VARIABLES
 */

/*********************************************************************
 * LOCAL FUNCTIONS
 */

/* storage for MAC beacon payload */
static uint8 mtMacBeaconPayload[MT_MAC_BEACON_PAYLOAD_MAX];

/*********************************************************************
 * @fn      MT_MacRevExtCpy
 *
 * @brief
 *
 *   Reverse-copy an extended address.
 *
 * @param   pDst - Pointer to data destination
 * @param   pSrc - Pointer to data source
 *
 * @return  void
 */
static void MT_MacRevExtCpy( uint8 *pDst, uint8 *pSrc )
{
  int8 i;

  for ( i = Z_EXTADDR_LEN - 1; i >= 0; i-- )
  {
    *pDst++ = pSrc[i];
  }
}

/*********************************************************************
 * @fn      MT_MacSpi2Addr
 *
 * @brief
 *
 *   Copy an address from an SPI message to an address struct.  The
 *   addrMode in pAddr must already be set.
 *
 * @param   pDst - Pointer to address struct
 * @param   pSrc - Pointer SPI message byte array
 *
 * @return  void
 *********************************************************************/
static void MT_MacSpi2Addr( zAddrType_t *pDst, uint8 *pSrc )
{
  if ( pDst->addrMode == Addr16Bit )
  {
    pDst->addr.shortAddr = BUILD_UINT16( pSrc[7] , pSrc[6] );
  }
  else if ( pDst->addrMode == Addr64Bit )
  {
    MT_MacRevExtCpy( pDst->addr.extAddr, pSrc );
  }
}

/*********************************************************************
 * @fn      MT_MacSpi2Sec
 *
 * @brief
 *
 *   Copy Security information from SPI message to a Sec structure
 *
 * @param   pSec - Pointer to security struct
 * @param   pSrc - Pointer SPI message byte array
 *
 * @return  void
 *********************************************************************/
static void MT_MacSpi2Sec( ZMacSec_t *pSec, uint8 *pSrc )
{
  /* Right now, set everything to zero */
  osal_memset (pSec, 0, sizeof (ZMacSec_t));
}

/*********************************************************************
 * @fn      MT_MacAddr2Spi
 *
 * @brief
 *
 *   Copy an address from an address struct to an SPI message.
 *
 * @param   pDst - Pointer SPI message byte array
 * @param   pSrc - Pointer to address struct
 *
 * @return  void
 *********************************************************************/
static void MT_MacAddr2Spi( uint8 *pDst, zAddrType_t *pSrc )
{
  if ( pSrc->addrMode == Addr16Bit )
  {
    *pDst++ = 0; *pDst++ = 0; *pDst++ = 0;
    *pDst++ = 0; *pDst++ = 0; *pDst++ = 0;
    *pDst++ = HI_UINT16( pSrc->addr.shortAddr );
    *pDst = LO_UINT16( pSrc->addr.shortAddr );
  }
  else if ( pSrc->addrMode == Addr64Bit )
  {
    MT_MacRevExtCpy( pDst, pSrc->addr.extAddr );
  }
}


/*********************************************************************
 * @fn      MT_MacMsgAllocate
 *
 * @brief
 *
 *   Allocate an MT MAC SPI message buffer.
 *
 * @param   cmd - SPI command id
 * @param   len - length of SPI command parameters
 *
 * @return  pointer to allocated message
 *********************************************************************/
static mtOSALSerialData_t *MT_MacMsgAllocate( uint16 cmd, uint8 len )
{
  mtOSALSerialData_t  *msgPtr;
  byte                *msg;

  msgPtr = (mtOSALSerialData_t *) osal_msg_allocate( len +
                                                     sizeof(mtOSALSerialData_t) +
                                                     SPI_0DATA_MSG_LEN );
  if ( msgPtr )
  {
    msgPtr->hdr.event = CB_FUNC;
    msg = msgPtr->msg = (uint8 *) ( msgPtr + 1 );
    *msg++ = SOP_VALUE;
    *msg++ = HI_UINT16( cmd );
    *msg++ = LO_UINT16( cmd );
    *msg   = len;
  }
  return msgPtr;
}

/*********************************************************************
 * @fn      MT_MacCommandProcessing
 *
 * @brief
 *
 *   Process all the MAC commands that are issued by test tool
 *
 * @param   cmd_id - Command ID
 * @param   len    - Length of received SPI pData message
 * @param   pData  - pointer to received SPI pData message
 *
 * @return  void
 */
void MT_MacCommandProcessing( uint16 cmd_id , byte len , byte *pData )
{
  byte *msg_ptr;
  ZMacStatus_t ret;
  byte attr;

  ret = ZMacSuccess;

  switch ( cmd_id )
  {
    case SPI_CMD_MAC_INIT:
      ret = ZMacInit();

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_INIT, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_START_REQ:
#ifdef RTR_NWK

      /* StartTime */
      mtMac.startReq.StartTime = BUILD_UINT32 (pData[3], pData[2], pData[1], pData[0]);
      pData += 4;

      /* PanID */
      mtMac.startReq.PANID = BUILD_UINT16( pData[1] , pData[0] );
      pData += 2;

      /* Fill in other fields sequentially incrementing the pointer*/
      mtMac.startReq.LogicalChannel    =  *pData++;
      mtMac.startReq.ChannelPage       =  *pData++;
      mtMac.startReq.BeaconOrder       =  *pData++;
      mtMac.startReq.SuperframeOrder   =  *pData++;
      mtMac.startReq.PANCoordinator    =  *pData++;
      mtMac.startReq.BatteryLifeExt    =  *pData++;
      mtMac.startReq.CoordRealignment  =  *pData++;

      /* Realign Security Information */
      MT_MacSpi2Sec( &mtMac.startReq.RealignSec, pData );
      pData += ZTEST_DEFAULT_SEC_LEN;

      /* Beacon Security Information */
      MT_MacSpi2Sec( &mtMac.startReq.BeaconSec, pData );

      /* Call corresponding ZMAC function */
      ret = ZMacStartReq( &mtMac.startReq );
#else
      ret = ZMacDenied;
#endif

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_START_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_SCAN_REQ:

      /* ScanChannels is the 32-bit channel list */
      mtMac.scanReq.ScanChannels = BUILD_UINT32 (pData[3], pData[2], pData[1], pData[0]);
      pData += 4;

      /* Fill in fields sequentially incrementing the pointer */
      mtMac.scanReq.ScanType = *pData++;

      /* ScanDuration */
      mtMac.scanReq.ScanDuration = *pData++;

      /* Channel Page */
      mtMac.scanReq.ChannelPage = *pData++;

      /* MaxResults */
      mtMac.scanReq.MaxResults = *pData++;

      /* Security Information */
      MT_MacSpi2Sec( &mtMac.scanReq.Sec, pData );

      /* Call corresponding ZMAC function */
      ret =  ZMacScanReq( &mtMac.scanReq );

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_SCAN_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);

      break;

    case SPI_CMD_MAC_DATA_REQ:

      /* Destination address mode */
      mtMac.dataReq.DstAddr.addrMode = *pData++;

      /* Destination address */
      MT_MacSpi2Addr( &mtMac.dataReq.DstAddr, pData);
      pData += Z_EXTADDR_LEN;

      /* Destination Pan ID */
      mtMac.dataReq.DstPANId = BUILD_UINT16( pData[1] , pData[0] );
      pData += 2;

      /* Source address mode */
      mtMac.dataReq.SrcAddrMode = *pData++;

      /* Handle */
      mtMac.dataReq.Handle = *pData++;

      /* TxOptions */
      mtMac.dataReq.TxOptions = *pData++;

      /* Channel */
      mtMac.dataReq.Channel = *pData++;

      /* Power */
      mtMac.dataReq.Power = *pData++;

      /* Security Information */
      MT_MacSpi2Sec( &mtMac.dataReq.Sec, pData );
      pData += ZTEST_DEFAULT_SEC_LEN;

      /* Data length */
      mtMac.dataReq.msduLength = *pData++;

      /* Data - Just pass the pointer to the structure */
      mtMac.dataReq.msdu = pData;

      /* Call corresponding ZMAC function */
      ret = ZMacDataReq( &mtMac.dataReq );

      /* Send response back */
      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_DATA_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_ASSOCIATE_REQ:

      /* Logical Channel */
      mtMac.assocReq.LogicalChannel = *pData++;

      /* Channel Page */
      mtMac.assocReq.ChannelPage = *pData++;

      /* Address Mode */
      mtMac.assocReq.CoordAddress.addrMode = *pData++;

      /* Coordinator Address, address mode must be set at this point */
      MT_MacSpi2Addr( &mtMac.assocReq.CoordAddress, pData );
      pData += Z_EXTADDR_LEN;

      /* Coordinator PanID */
      mtMac.assocReq.CoordPANId = BUILD_UINT16( pData[1] , pData[0] );
      pData += 2;

      /* Capability information */
      mtMac.assocReq.CapabilityInformation = *pData++;

      /* Security Information */
      MT_MacSpi2Sec( &mtMac.assocReq.Sec, pData );

      /* Call corresponding ZMAC function */
      ret = ZMacAssociateReq( &mtMac.assocReq );

      /* Send response back */
      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_ASSOCIATE_REQ, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_ASSOCIATE_RSP:
#ifdef RTR_NWK

      /* Device extended address */
      MT_MacRevExtCpy( mtMac.assocRsp.DeviceAddress, pData );
      pData += Z_EXTADDR_LEN;

      /* Associated short address */
      mtMac.assocRsp.AssocShortAddress = BUILD_UINT16(pData[1],pData[0]);
      pData += 2;

      /* Status */
      mtMac.assocRsp.Status = *pData++;

      /* Security Information */
      MT_MacSpi2Sec( &mtMac.assocRsp.Sec, pData );

      /* Call corresponding ZMAC function */
      ret = ZMacAssociateRsp( &mtMac.assocRsp );
#else
      ret = ZMacDenied;
#endif

      len = SPI_0DATA_MSG_LEN + SPI_RESP_LEN_MAC_DEFAULT;
      MT_SendSPIRespMsg( (byte)ret, SPI_CMD_MAC_ASSOCIATE_RSP, len, SPI_RESP_LEN_MAC_DEFAULT);
      break;

    case SPI_CMD_MAC_DISASSOCIATE_REQ:

      /* Device address mode */
      mtMac.disassocReq.DeviceAddress.addrMode = *pData++;

      /* Device address - Device address mode have to be set to use this function*/
      MT_MacSpi2Addr( &mtMac.disassocReq.DeviceAddress, pData);
      pData += Z_EXTADDR_LEN;

      /* Pan ID */
      mtMac.disassocReq.DevicePanId = BUILD_UINT16( pData[1] , pData[0] );
      pData += 2;

      /* Disassociate reason */
      mtMac.disassocReq.DisassociateReason = *pData++;

      /* TxIndirect */
      mtMac.disassocReq.TxIndirect = *pData++;