?? chip.c
字號:
return CHIPERR_INVALID_HANDLE;
return hChip->Error;
}
/*****************************************************
**FUNCTION :: CreateMask
**ACTION :: Create a mask according to its number of bits and position
**PARAMS IN :: field ==> Id of the field
**PARAMS OUT:: NONE
**RETURN :: mask of the field
*****************************************************/
unsigned char CreateMask(char NbBits, char Pos)
{
int i;
unsigned char mask=0;
/* Create mask */
for (i = 0; i < NbBits; i++)
{
mask <<= 1 ;
mask += 1 ;
}
mask = mask << Pos;
return mask;
}
/*****************************************************
**FUNCTION :: ChipAddField
**ACTION :: Add a field to the field map
**PARAMS IN :: hChip ==> Handle to the chip
** RegId ==> Id of the register which contains the field
** FieldId ==> Id of the field
** Name ==> Name of the field
** Pos ==> Position (number of left shifts from LSB position) in the register
** NbBits ==> Size (in bits) of the field
** Type ==> SIGNED or UNSIGNED
**PARAMS OUT:: NONE
**RETURN :: Error
*****************************************************/
STCHIP_Error_t ChipAddField(STCHIP_Handle_t hChip,U16 RegId, U32 FieldId,char * Name, char Pos, char NbBits, STCHIP_FieldType_t Type)
{
STCHIP_Field_t *pField;
if(hChip != NULL)
{
if(RegId < hChip->NbRegs)
{
if(FieldId < hChip->NbFields)
{
pField=&hChip->pFieldMap[FieldId];
strcpy(pField->Name,Name);
pField->Reg = RegId;
pField->Pos = Pos;
pField->Bits = NbBits;
pField->Type = Type;
if(NbBits)
pField->Mask = CreateMask(NbBits,Pos);
else
hChip->Error = CHIPERR_INVALID_FIELD_SIZE;
}
else
hChip->Error = CHIPERR_INVALID_FIELD_ID;
}
else
hChip->Error = CHIPERR_INVALID_REG_ID;
}
else
return CHIPERR_INVALID_HANDLE;
return hChip->Error;
}
/*****************************************************
**FUNCTION :: ChipSetOneRegister
**ACTION :: Set the value of one register
**PARAMS IN :: hChip ==> Handle to the chip
** reg_id ==> Id of the register
** Data ==> Data to store in the register
**PARAMS OUT:: NONE
**RETURN :: Error
*****************************************************/
STCHIP_Error_t ChipSetOneRegister(STCHIP_Handle_t hChip,U16 RegId, unsigned char Data)
{
// unsigned char data[2];
if(hChip)
{
if(RegId < hChip->NbRegs)
{
if(hChip->pRegMap[RegId].Access != STCHIP_ACCESS_R)
{
hChip->pRegMap[RegId].Value = Data;
if(hChip->ChipMode != STCHIP_MODE_NOSUBADR)
ChipSetRegisters(hChip,RegId,1);
else
ChipSetRegisters(hChip,hChip->WrStart,hChip->WrSize);
}
}
else
hChip->Error = CHIPERR_INVALID_REG_ID;
}
else
return CHIPERR_INVALID_HANDLE;
return hChip->Error;
}
/*****************************************************
**FUNCTION :: ChipGetOneRegister
**ACTION :: Get the value of one register
**PARAMS IN :: hChip ==> Handle to the chip
** reg_id ==> Id of the register
**PARAMS OUT:: NONE
**RETURN :: Register's value
*****************************************************/
int ChipGetOneRegister(STCHIP_Handle_t hChip, U16 RegId)
{
unsigned char data = 0xFF;
if(hChip)
{
if(hChip->ChipMode != STCHIP_MODE_NOSUBADR)
{
if(ChipGetRegisters(hChip,RegId,1) == CHIPERR_NO_ERROR)
data = hChip->pRegMap[RegId].Value;
}
else
{
if(ChipGetRegisters(hChip,hChip->RdStart,hChip->RdSize) == CHIPERR_NO_ERROR)
data = hChip->pRegMap[RegId].Value;
}
}
return data;
}
/*****************************************************
**FUNCTION :: ChipSetRegisters
**ACTION :: Set values of consecutive's registers (values are taken in RegMap)
**PARAMS IN :: hChip ==> Handle to the chip
** FirstReg ==> Id of the first register
** NbRegs ==> Number of register to write
**PARAMS OUT:: NONE
**RETURN :: Error
*****************************************************/
STCHIP_Error_t ChipSetRegisters(STCHIP_Handle_t hChip,int FirstReg, int NbRegs)
{
unsigned char data[22],nbdata = 0;
// char Tstat,Dstat;
int i;
#ifndef NO_GUI
Tstat=TraceGetState();
Dstat=ApplGetState();
#endif
if(hChip)
{
if(!hChip->Error)
{
if(NbRegs < 20)
{
if((FirstReg >= 0) && ((FirstReg + NbRegs - 1) < hChip->NbRegs))
{
switch(hChip->ChipMode)
{
case STCHIP_MODE_SUBADR_16:
data[nbdata++]=MSB(hChip->pRegMap[FirstReg].Addr); /* 16 bits sub addresses */
case STCHIP_MODE_SUBADR_8:
case STCHIP_MODE_NOSUBADR_RD:
data[nbdata++]=LSB(hChip->pRegMap[FirstReg].Addr); /* 8 bits sub addresses */
case STCHIP_MODE_NOSUBADR:
for(i=0;i<NbRegs;i++)
data[nbdata++]=hChip->pRegMap[FirstReg+i].Value; /* fill data buffer */
break;
}
#ifndef NO_GUI
if(Tstat&&Dstat)
TraceWriteFile(TRACE_OUT,hChip->I2cAddr,hChip->pRegMap[FirstReg].Addr,&data[1],NbRegs);
#endif
#ifndef NO_I2C
#ifndef NO_GUI
if(!(Tstat&&TraceGetMode()&&Dstat))
{
if(WaitForSingleObject(ChipMutex,2000) == WAIT_OBJECT_0) /* Wait for other I2C access termination */
{
#endif
if(hChip->Repeater && hChip->RepeaterHost && hChip->RepeaterHost->RepeaterFn)
hChip->RepeaterHost->RepeaterFn(hChip->RepeaterHost,TRUE); /* Set repeater ON */
if(I2cReadWrite(I2C_WRITE,hChip->I2cAddr,data,nbdata) != I2C_OK) /* write data buffer */
hChip->Error = CHIPERR_I2C_NO_ACK;
if(hChip->Repeater && hChip->RepeaterHost && hChip->RepeaterHost->RepeaterFn)
hChip->RepeaterHost->RepeaterFn(hChip->RepeaterHost,FALSE); /* Set repeater OFF */
#ifndef NO_GUI
ReleaseMutex(ChipMutex); /* Allow other I2C access */
}
}
#endif
#endif
}
else
hChip->Error = CHIPERR_INVALID_REG_ID;
}
else
hChip->Error = CHIPERR_I2C_BURST;
}
}
else
return CHIPERR_INVALID_HANDLE;
return hChip->Error;
}
/*****************************************************
**FUNCTION :: ChipGetRegisters
**ACTION :: Get values of consecutive's registers (values are writen in RegMap)
**PARAMS IN :: hChip ==> Handle to the chip
** FirstReg ==> Id of the first register
** NbRegs ==> Number of register to read
**PARAMS OUT:: NONE
**RETURN :: Error
*****************************************************/
STCHIP_Error_t ChipGetRegisters(STCHIP_Handle_t hChip, int FirstReg, int NbRegs)
{
unsigned char data[22],nbdata =0;
// char Tstat,Tmode,Dstat;
int i;
#ifndef NO_GUI
Tstat=TraceGetState();
Tmode=TraceGetMode();
Dstat=ApplGetState();
#endif
if(hChip)
{
if(!hChip->Error)
{
if((hChip->ChipMode == STCHIP_MODE_NOSUBADR) || (hChip->ChipMode == STCHIP_MODE_NOSUBADR_RD))
{
/* no subadress mode only */
FirstReg = hChip->RdStart;
NbRegs = hChip->RdSize;
}
if(NbRegs < 20)
{
if((FirstReg >= 0) && ((FirstReg + NbRegs - 1) < hChip->NbRegs))
{
#ifndef NO_I2C
#ifndef NO_GUI
if(!(Tstat&&Tmode&&Dstat))
{
if(WaitForSingleObject(ChipMutex,2000) == WAIT_OBJECT_0) /* Wait for other I2C access termination */
{
#endif
switch(hChip->ChipMode)
{
case STCHIP_MODE_SUBADR_16:
data[nbdata++]=MSB(hChip->pRegMap[FirstReg].Addr); /* for 16 bits sub addresses */
case STCHIP_MODE_SUBADR_8:
data[nbdata++]=LSB(hChip->pRegMap[FirstReg].Addr); /* for 8 bits sub addresses */
if(hChip->Repeater && hChip->RepeaterHost && hChip->RepeaterHost->RepeaterFn)
hChip->RepeaterHost->RepeaterFn(hChip->RepeaterHost,TRUE); /* Set repeater ON */
if(I2cReadWrite(I2C_WRITE,hChip->I2cAddr,data,nbdata) != I2C_OK) /* Write sub address */
hChip->Error = CHIPERR_I2C_NO_ACK;
if(hChip->Repeater && hChip->RepeaterHost && hChip->RepeaterHost->RepeaterFn)
hChip->RepeaterHost->RepeaterFn(hChip->RepeaterHost,FALSE); /* Set repeater OFF */
case STCHIP_MODE_NOSUBADR:
case STCHIP_MODE_NOSUBADR_RD:
if(hChip->Repeater && hChip->RepeaterHost && hChip->RepeaterHost->RepeaterFn)
hChip->RepeaterHost->RepeaterFn(hChip->RepeaterHost,TRUE); /* Set repeater ON */
if(I2cReadWrite(I2C_READ,hChip->I2cAddr,data,NbRegs) != I2C_OK) /* Read data buffer */
hChip->Error = CHIPERR_I2C_NO_ACK;
if(hChip->Repeater && hChip->RepeaterHost && hChip->RepeaterHost->RepeaterFn)
hChip->RepeaterHost->RepeaterFn(hChip->RepeaterHost,FALSE); /* Set repeater OFF */
break;
}
#ifndef NO_GUI
ReleaseMutex(ChipMutex); /* Allow other I2C access */
}
}
#endif
#ifndef NO_GUI
if((Tstat == TRACE_ON) && (Dstat == APPL_STANDBY))
{
/* Trace ON and Driver RUNNING */
if(Tmode == TRACE_PLAY)
/* Playback mode */
TraceReadFile(TRACE_IN,hChip->I2cAddr,hChip->pRegMap[FirstReg].Addr,data,NbRegs);
else
/* Record mode */
TraceWriteFile(TRACE_IN,hChip->I2cAddr,hChip->pRegMap[FirstReg].Addr,data,NbRegs);
}
#endif
/* Update RegMap structure */
for(i=0;i<NbRegs;i++)
if(!hChip->Error)
hChip->pRegMap[FirstReg+i].Value = data[i];
else
hChip->pRegMap[FirstReg+i].Value = 0xFF;
#endif
}
else
hChip->Error = CHIPERR_INVALID_REG_ID;
}
else
hChip->Error = CHIPERR_I2C_BURST;
}
}
else
return CHIPERR_INVALID_HANDLE;
return hChip->Error;
}
/*****************************************************
**FUNCTION :: ChipGetRegDefault
**ACTION :: Return the default value of the register
**PARAMS IN :: hChip ==> Handle of the chip
** RegId ==> Id of the register
**PARAMS OUT:: NONE
**RETURN :: default value
*****************************************************/
char ChipGetRegDefault(STCHIP_Handle_t hChip,U16 RegId)
{
char defval = 0;
if(hChip != NULL)
{
if(RegId < hChip->NbRegs)
defval = hChip->pRegMap[RegId].Default;
else
hChip->Error = CHIPERR_INVALID_REG_ID;
}
return defval;
}
/*****************************************************
**FUNCTION :: ChipSetRegDefault
**ACTION :: Set the default value of the register
**PARAMS IN :: hChip ==> Handle of the chip
** RegId ==> Id of the register
** Default ==> Default value
**PARAMS OUT:: NONE
**RETURN :: Error
*****************************************************/
STCHIP_Error_t ChipSetRegDefault(STCHIP_Handle_t hChip,U16 RegId,U8 Default)
{
if(hChip != NULL)
{
if(RegId < hChip->NbRegs)
hChip->pRegMap[RegId].Default = Default;
else
hChip->Error = CHIPERR_INVALID_REG_ID;
}
else
return CHIPERR_INVALID_HANDLE;
return hChip->Error;
}
/*****************************************************
**FUNCTION :: ChipUpdateDefaultValues
**ACTION :: Get default values in all the registers
**PARAMS IN :: hChip ==> Handle of the chip
**PARAMS OUT:: NONE
**RETURN :: Error
*****************************************************/
STCHIP_Error_t ChipUpdateDefaultValues(STCHIP_Handle_t hChip)
{
int reg = 0;
if(hChip != NULL)
{
while((!hChip->Error) && (reg < hChip->NbRegs))
{
hChip->pRegMap[reg].Default = ChipGetOneRegister(hChip,reg);
reg++;
}
}
else
return CHIPERR_INVALID_HANDLE;
return hChip->Error;
}
/*****************************************************
**FUNCTION :: ChipApplyDefaultValues
**ACTION :: Write default values in all the registers
**PARAMS IN :: hChip ==> Handle of the chip
**PARAMS OUT:: NONE
**RETURN :: Error
*****************************************************/
STCHIP_Error_t ChipApplyDefaultValues(STCHIP_Handle_t hChip)
{
int reg = 0;
if(hChip != NULL)
{
if(hChip->ChipMode != STCHIP_MODE_NOSUBADR)
{
while((!hChip->Error) && (reg < hChip->NbRegs))
{
ChipSetOneRegister(hChip,reg,hChip->pRegMap[reg].Default);
reg++;
}
}
else
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -