static VOID
WriteEEprom(
struct rtl8190_priv *priv,
UCHAR AddressSize,
USHORT reg,
USHORT data)
{
ULONG ioaddr = priv->pshare->ioaddr;
UCHAR x;
// select EEPROM, mask off ASIC and reset bits, set EECS
x = RTL_R8(CSR_EEPROM_CONTROL_REG);
x &= ~(EEDI | EEDO | EESK | CR9346_EEM0);
x |= CR9346_EEM1 | EECS;
RTL_W8(CSR_EEPROM_CONTROL_REG, x);
ShiftOutBits(priv, EEPROM_EWEN_OPCODE, 5);
/////ShiftOutBits(CSRBaseIoAddress, reg, 4);
ShiftOutBits(priv, 0, 6);
StandBy(priv);
// Erase this particular word. Write the erase opcode and register
// number in that order. The opcode is 3bits in length; reg is 6 bits long.
ShiftOutBits(priv, EEPROM_ERASE_OPCODE, 3);
ShiftOutBits(priv, reg, AddressSize);
if (WaitEEPROMCmdDone(priv) == FALSE)
{
return;
}
StandBy(priv);
// write the new word to the EEPROM
// send the write opcode the EEPORM
ShiftOutBits(priv, EEPROM_WRITE_OPCODE, 3);
// select which word in the EEPROM that we are writing to.
ShiftOutBits(priv, reg, AddressSize);
// write the data to the selected EEPROM word.
ShiftOutBits(priv, data, 16);
if (WaitEEPROMCmdDone(priv) == FALSE)
{
// DbgPrint("D100: Failed EEPROM Write");
return;
}
StandBy(priv);
ShiftOutBits(priv, EEPROM_EWDS_OPCODE, 5);
ShiftOutBits(priv, reg, 4);
EEpromCleanup(priv);
return;
}
BOOLEAN WriteEepromWord(PADAPTER_STRUCT Adapter, UINT16 Reg, UINT16 Data)
{
E1000_WRITE_REG(Eecd, E1000_EECS);
ShiftOutBits(Adapter, EEPROM_EWEN_OPCODE, 5);
ShiftOutBits(Adapter, Reg, 4);
StandBy(Adapter);
ShiftOutBits(Adapter, EEPROM_ERASE_OPCODE, 3);
ShiftOutBits(Adapter, Reg, 6);
if (!WaitEepromCommandDone(Adapter))
return (FALSE);
ShiftOutBits(Adapter, EEPROM_WRITE_OPCODE, 3);
ShiftOutBits(Adapter, Reg, 6);
ShiftOutBits(Adapter, Data, 16);
if (!WaitEepromCommandDone(Adapter))
return (FALSE);
ShiftOutBits(Adapter, EEPROM_EWDS_OPCODE, 5);
ShiftOutBits(Adapter, Reg, 4);
EepromCleanup(Adapter);
return (TRUE);
}
ErrorStatus fnSetAlarmClock(uint8_t h,uint8_t m,uint8_t setting)
{
uint8_t t;
if ((h>=24)||(m>=60))
return ERROR;
rt_kprintf("\n===Enter Alarm Clock Mode===\n");
/* Set Alarm Time */
t = IIC_Read(DS3231_ADDRESS,DS3231_CONTROL) & 0xFC;
if (setting)
{
IIC_Write(DS3231_ADDRESS,DS3231_CONTROL,t | 0x01);
IIC_Write(DS3231_ADDRESS,DS3231_A1_S,0x00);
IIC_Write(DS3231_ADDRESS,DS3231_A1_M,(m%10)|((m/10)<<4));
IIC_Write(DS3231_ADDRESS,DS3231_A1_H,(h%10)|((h/10)<<4));
IIC_Write(DS3231_ADDRESS,DS3231_A1_D,0x80);
}else{
IIC_Write(DS3231_ADDRESS,DS3231_CONTROL,t | 0x02);
IIC_Write(DS3231_ADDRESS,DS3231_A2_M,(m%10)|((m/10)<<4));
IIC_Write(DS3231_ADDRESS,DS3231_A2_H,(h%10)|((h/10)<<4));
IIC_Write(DS3231_ADDRESS,DS3231_A2_D,0x80);
}
/* Clear Alarm Flag */
t = IIC_Read(DS3231_ADDRESS,DS3231_CON_STA);
t &= 0xFC;
IIC_Write(DS3231_ADDRESS,DS3231_CON_STA,t);
rt_event_send(en_event,EVENT_TEMP_CLOCK);
rt_thread_delay_hmsm(0,0,1,0);
rt_event_send(reg_event,REG_ALARM_MSK);
reg_output[REG_ALARM] = REG_Convert(REG_HexToReg(m%10),REG_HexToReg(m/10),REG_HexToReg(h%10),REG_HexToReg(h/10),1,0);
rt_thread_delay_hmsm(0,0,1,0);
reg_output[REG_ALARM] = 0xFFFFFFFF;
rt_thread_delay_hmsm(0,0,0,62);
reg_output[REG_ALARM] = 0xFFFFFFFE;
rt_thread_delay_hmsm(0,0,0,62);
reg_output[REG_ALARM] = 0xFFFFFEBF;
rt_thread_delay_hmsm(0,0,0,62);
reg_output[REG_ALARM] = 0xFFFEBFF7;
rt_thread_delay_hmsm(0,0,0,62);
reg_output[REG_ALARM] = 0xFEBFF7FF;
rt_thread_delay_hmsm(0,0,0,62);
reg_output[REG_ALARM] = 0xBFF7FFFF;
rt_thread_delay_hmsm(0,0,0,62);
reg_output[REG_ALARM] = 0xF7FFFFFF;
rt_thread_delay_hmsm(0,0,0,62);
reg_output[REG_ALARM] = 0xFFFFFFFF;
rt_thread_delay_hmsm(0,0,0,62);
StandBy();
return SUCCESS;
}
STATIC UINT16 WaitEepromCommandDone(PADAPTER_STRUCT Adapter)
{
UINT32 EecdRegValue;
UINT i;
StandBy(Adapter);
for (i = 0; i < 200; i++) {
EecdRegValue = E1000_READ_REG(Eecd);
if (EecdRegValue & E1000_EEDO)
return (TRUE);
DelayInMicroseconds(5);
}
return (FALSE);
}
static USHORT
WaitEEPROMCmdDone(
struct rtl8190_priv *priv)
{
ULONG ioaddr = priv->pshare->ioaddr;
UCHAR x;
USHORT i;
StandBy(priv);
for (i=0; i<200; i++)
{
x = RTL_R8(CSR_EEPROM_CONTROL_REG);
if (x & EEDO)
return (TRUE);
delay_us(CLOCK_RATE);
}
return FALSE;
}
SDR1000::SDR1000(char* name, BOOLEAN rfe, BOOLEAN pa, BOOLEAN usb, uint16 lpt_addr)
{
this->name = name;
this->rfe = rfe;
this->pa = pa;
this->usb = usb;
this->lpt_addr = lpt_addr;
if(usb)
{
sdr1kusb = new Sdr1kUsb();
int ret_val = sdr1kusb->Open(rfe, pa, -1);
if(ret_val != 0)
usb = FALSE;
}
else
{
if(init_count == 0) OpenPortTalk();
init_count++;
}
pio_ic01 = new PIOReg("pio_ic01", this, PIO_IC01, 0xA0);
pio_ic03 = new PIOReg("pio_ic03", this, PIO_IC03, 0x80);
if(rfe)
{
rfe_ic07 = new RFEReg("rfe_ic07", this, RFE_IC07, 0x40);
rfe_ic09 = new RFEReg("rfe_ic09", this, RFE_IC09);
rfe_ic10 = new RFEReg("rfe_ic10", this, RFE_IC10);
rfe_ic11 = new RFEReg("rfe_ic11", this, RFE_IC11);
}
dds = new AD9854("dds", this);
freq_cal_offset = 0.0;
clock_ref_freq = 10.0;
spur_reduction_enabled = false;
spur_reduction_mask = 0xFFFF00000000llu;
StandBy();
}
