mftmac.c.bak

motorola jw32 usb 源码

}
*/
/*********************************************************************
 * Function:        BYTE MACStartScan()
 *
 * PreCondition:    MACInit(), MACEnable() are called
 *                  And MACIsPutReady() == TRUE
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        If this is active scan, receive beacon
 *
 * Note:            None
 ********************************************************************/
void MACStartScan()
{
    // Send beacon if this is active scan

   	  bIsScan = TRUE  ;
   		macStartTick = TickGet();
   		//MACReqNetState();
   		//sendFlag=1;
    	PHYSetTRXState(PHY_TRX_RX_ON);
}


/*********************************************************************
 * Function:        BYTE MACIsScanComplete(void)
 *
 * PreCondition:    MACStartScan() is called.
 *
 * Input:           None
 *
 * Output:          TRUE if scan is complete
 *                  FALSE otherwise.
 *
 * Side Effects:    None
 *
 * Overview:        Checks to see a beacon was received and if it is,
 *                  it processes it.
 *
 * Note:            None
 ********************************************************************/
BYTE MACIsScanComplete(void)
{
    BYTE result;
		unsigned int  tdiff;

    result = FALSE;
    if (bIsGetReady)
    {
        if ( macCurrentFrame.frameCtrl.Control.fields.type == MAC_FRAME_NETST||	macCurrentFrame.frameCtrl.Control.fields.type==MAC_FRAME_BEACON)
        {
            	result=MACProcessNetState();
        }
		  MACDiscardRx();
    }
    else
    {
    	tdiff = TickGet();
    	tdiff = TickGetDiff(tdiff, macStartTick)  ;
			if ( tdiff >= MAC_ACTIVE_SCAN_PERIOD )
            result = TRUE;
    }
    if(result) {  	
         PHYSetTRXState(PHY_TRX_TX_ON);
         macRandom += PHYGetRssi();
    }
    return result;
}






/*********************************************************************
 * Function:        void MACDiscardRx(void)
 *
 * PreCondition:    MACIsGetReady() = TRUE
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Fetches remaining data bytes for current received
 *                  frame.
 *
 * Note:            None
 ********************************************************************/
static void MACDiscardRx(void)
{
    // Mark this frame as empty.
    bIsGetReady = FALSE;

    if(RXBuffer[0].head != NULL)
    {
        RXBuffer[0].head = NULL;
    }
}

/*********************************************************************
 * Function:        void MACPutHeader(BYTE flength,BYTE desAddr)
 *
 * PreCondition:    MACIsPutReady() = TRUE
 *
 * Input:           dest        - Destination node info
 *                  frameCON    - Frame control for frame header
 *                                Logical AND of
 *                                "Frame Control flags" as defined
 *                                in zMAC.h
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Constructs and loads frame header as per
 *                  IEEE spec.
 *                  If frame requires ack, it makes an entry into
 *                  DSN queue so that future ack can be matched
 *                  against this frame.
 *
 * Note:            None
 ********************************************************************/
void MACPutHeader(BYTE flength,BYTE desAddr)
{
    // If we are not buffering the packet, clear the TX
    macPacketLen=0;
    //put frame length
    MACPut(flength);
    //put destination address
    MACPut(desAddr);

}
/*********************************************************************
 * Function:      void MACPhyDataReady()
 	Description:    when PHY received data,call this program,tell MAC data
 		              is Ready.
  ********************************************************************/

void MACPhyDataReady(void)
{
	if(bIsEnabled)//if have into send becon time slot,we will discard this receive data
	{
		bPhyGetReady = TRUE;
	}

    //PTD_PTD4^=1;

}

/*********************************************************************
 * Function:        void MACBufferPacket(void)
 *
 * PreCondition:    Transceiver has a packet waiting.
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    New packet is read in and buffered.
 *
 * Overview:        This function will read the packet out of the RF
 *                  chip and buffer it into RAM. If there is no room
 *                  available in RAM then it will discard the packet.
 *
 * Note:            None
 ********************************************************************/
static void MACBufferPacket(void)
{
	  BYTE packetSize=0;
    BYTE packetLQI=0;
  //  if(RXBuffer[0].head == NULL)
    {
        packetSize = PHYDataIndication(FrameRXBuffer,&packetLQI);
       if(packetSize<MAC_FRAME_LENGTH&&packetSize>0)
        {
            //PrintChar(packetSize);
            RXBuffer[0].length = packetSize;
            RXBuffer[0].head 	= FrameRXBuffer;
            RXBuffer[0].databuffer 	= FrameRXBuffer;
            RXBuffer[0].lqi	 	= packetLQI;
          //  PTD_PTD4^=1;
        }
        else
        {
        	RXBuffer[0].head = NULL;
        }
    }
    /* should we indicate to the user that they are out of RX buffers? */
}
/*********************************************************************
 * Function:       void MACPassDeviceData(BYTE deviceid,BYTE *buffer,BYTE length)
 *
 * PreCondition:    app have received device data
 *
 * Input:           buffer:input data buffer.length:input buffer data length,deviceid:which device
 *
 * Output:          no
 *
 * Overview:        This function will save device data in mac buffer untill beacon time.send it out

 * Note:            None
 ********************************************************************/

void MACPassDeviceData(BYTE deviceid,BYTE *buffer,BYTE length)
{
	BYTE i;
	if(length>KbPassLength)
		return;
	DeviceDataLength =length;
	if(deviceid==MAC_DEVICE_KEYBOARD)
	{
		macKbLedState = buffer[0];
	}
	for(i=0;i<length;i++)
	{
		DeviceBuffer[i]=buffer[i];
	}
	/*if(deviceid==MAC_DEVICE_JOYSTICK0)
	{
		macBeaon.Control.bits.devId=(macJkDev[0].devAddress&0x01)+MAC_DEVICE_JOYSTICK0;
	}
	else 	if(deviceid==MAC_DEVICE_JOYSTICK1)
	{
			macBeaon.Control.bits.devId= 	(macJkDev[1].devAddress&0x01)+MAC_DEVICE_JOYSTICK0;
	}
	else*/
		macBeaon.Control.bits.devId= 	deviceid;
	macBeaon.Control.bits.bData= 	1;
}

//input  device job mode.output :devcieId .0 error
BYTE   MACJudgeDeviceId(BYTE bmode)
{
	if(bmode<MAC_MODE_NUMBER)
	{
		return MAC_DEVICE_MOUSE;

	}
	else if((bmode>=JK1MODEID)&&(bmode<(JK1MODEID+MAC_JKMODE_NUMBER)))
	{
		return MAC_DEVICE_JOYSTICK0;
	}
	else if((bmode>=JK2MODEID)&&(bmode<(JK2MODEID+MAC_JKMODE_NUMBER)))
	{
		return MAC_DEVICE_JOYSTICK1;
	}
	return FALSE;
}
/*********************************************************************
 * Function:       BYTE MACSaveAppData(unsigned char *buffer,unsigned char length)
 *
 * PreCondition:    app have received pc data
 *
 * Input:           buffer:input data buffer.length:input buffer data length
 *
 * Output:          if save successful return true,else return false
 *
 * Overview:        This function will save buffer data into keymap flash area.

 * Note:            None
 ********************************************************************/

BYTE MACSaveAppData(unsigned char *buffer,unsigned char length)
{
    static BYTE newkeyflag = 0;
	static BYTE newTransflag = 0;
	static BYTE btranlength =0;
	static BYTE bErrFlag=0;
    static	BYTE   validCount=0;
    BYTE const* baddress=0;
	BYTE i;
	//if(buffer[0]==0x01)//keyboard pass data
	if(length<3)
	{
	    if(length==2)
		    MACPassDeviceData(MAC_DEVICE_KEYBOARD,buffer+1,length-1);
		else
		     MACPassDeviceData(MAC_DEVICE_KEYBOARD,buffer,length);
		LED_DATA^=1;
		return TRUE;
	}
	else if(buffer[0]==0x06)//download data
	{
	        if(length!=8)
			{
					newkeyflag = 0;
					bErrFlag=1;
				  return FALSE;
			}
				if(newkeyflag==0)  //begin transfer key data
				{
				    macNewKeyMode 	 	= buffer[1];
						macNewKey       	= buffer[2];  //KEY number
						macNewKeyLength  	= buffer[3];  //key map length
						validCount = 0;
						if(macNewKey==0)//transfer first key
						{
							newTransflag = 0;
						}
						if(newTransflag==0)//begin download
				    {
				    		btranlength = 0;				  //clear transfer length
				    		bErrFlag=0;               //clear error flag
				    		downFlash = 0;
				    		downLength = 0;
								if(macNewKeyMode==MAC_NORMAL_MODE)  // first 4byte :store PANDID,CHANNEL
										btranlength=4;
								else if(macNewKeyMode==MAC_WFLASH_MODE) //WRITE FLASH,PANID AND channel
								{
									ReadFlash((byte const *)FLASH_ADDRESS[0],KEYMAPMAXSIZE,Ram_Key);
									for(i=3;i<length;i++)
									{

										macKeyMap[0].keybuffer[btranlength++]=buffer[i];
										validCount++;
										if(buffer[i]==KBDATAEND)
										{
													newkeyflag = 0;
												//	validCount-=2;
													if(validCount!=4)
													{
																bErrFlag=1;
																return FALSE;
													}
													macCurrentChannel= 	macKeyMap[0].keybuffer[2];//channel
													if(macCurrentChannel<FIRSTCHAN)
													{
														macCurrentChannel+=FIRSTCHAN;
													}
													if(macCurrentChannel>=MAXCHAN)
													{
														macCurrentChannel-=MAXCHAN;
														macCurrentChannel&=0x1F;
														macCurrentChannel+=FIRSTCHAN;
													}
													if(macKeyMap[0].keybuffer[1]!=macInfo.devAddress)
													{
																macInfo.devAddress=macKeyMap[0].keybuffer[1];
																macWarncode=0;              //clear all warn information
												  }
												  bchanlost=1;
													//MACSetDeviceAddress(macKeyMap[0].keybuffer[1]);//panid
													//WriteFlash((byte const *)FLASH_ADDRESS[0],KEYMAPMAXSIZE,Ram_Key,NORMAL_WRITE); //
													MACStart();
										}
									}
									return TRUE;
								}
				    }
				    if(bErrFlag)                            //if have error .return
				    	return FALSE;
						newTransflag++;
						//--------------------------------------------------
						// KEY map data
							if(macNewKeyLength>MAC_KEYMAPLEN)//once passs length
							{
							  bErrFlag=1;
								return FALSE;
							}
							if((btranlength+macNewKeyLength)>=MSMAPSIZE)//cannot save it all
							{
								i=MACJudgeDeviceId(macNewKeyMode);
								if((i==MAC_DEVICE_JOYSTICK0)||(i==MAC_DEVICE_JOYSTICK1))
								{
									if(downFlash==0)  //already writed flash once
									{
										downLength = btranlength+1;
										WriteFlash((byte const *)FLASH_BACK,downLength,Ram_Key,NORMAL_WRITE);
										btranlength = 0;
										downFlash = 1;
									}
									else
									{
										 bErrFlag=1;
										return FALSE;
									}
								}
								else
								{
								  bErrFlag=1;
									return FALSE;
								}
							}
							//----------------------------------------------
							// map data is ok.transfer new key map
							newkeyflag        = 1;

						//------------------------------------------------------------
						for(i=3;i<length;i++)
						{

							macKeyMap[0].keybuffer[btranlength++]=buffer[i];
							validCount++;
							if(buffer[i]==KBDATAEND)
							{
								newkeyflag = 0;
								validCount-=2;
								if(validCount!=macNewKeyLength)
								{
											bErrFlag=1;
											return FALSE;

								}
								break;
							}
							 else if(btranlength>MSMAPSIZE)
							 {
							    bErrFlag=1;
								return FALSE;
							 }
						}
					}
					else//continue transfer last times data.no head. all is data
					{
							if(bErrFlag)
									return FALSE;
							for(i=1;i<length;i++)  //save data
							{
								validCount++;
								macKeyMap[0].keybuffer[btranlength++]=buffer[i];
								if(buffer[i]==KBDATAEND)
								{
									newkeyflag = 0;
									validCount-=2;
									if(validCount!=macNewKeyLength)
									{
											bErrFlag=1;
											return FALSE;
									}
									break;
								}
							    else if(btranlength>MSMAPSIZE)
    							 {
    							    bErrFlag=1;
    								return FALSE;
    							 }
							}
					}
					// transfer key map data over.try save it
					if(newkeyflag==0