void
RrepHeader::Serialize (Buffer::Iterator i) const
{
i.WriteU8 (m_flags);
i.WriteU8 (m_prefixSize);
i.WriteU8 (m_hopCount);
WriteTo (i, m_dst);
i.WriteHtonU32 (m_dstSeqNo);
WriteTo (i, m_origin);
i.WriteHtonU32 (m_lifeTime);
}
void
RreqHeader::Serialize (Buffer::Iterator i) const
{
i.WriteU8 (m_flags);
i.WriteU8 (m_reserved);
i.WriteU8 (m_hopCount);
i.WriteHtonU32 (m_requestID);
WriteTo (i, m_dst);
i.WriteHtonU32 (m_dstSeqNo);
WriteTo (i, m_origin);
i.WriteHtonU32 (m_originSeqNo);
}
int32 CFile::WriteTo(const void* pBuf, int32 nBufLen, const char* sFileName)
{
CFileName oFileName;
if(oFileName.Parse(sFileName))
return WriteTo(pBuf, nBufLen, oFileName);
return 0;
}
bool
GRecord::AppendGRecordToFile(Path path)
{
TextWriter writer(path, true);
if (!writer.IsOpen())
return false;
WriteTo(writer);
return true;
}
bool
GRecord::AppendGRecordToFile(const TCHAR *filename)
{
TextWriter writer(filename, true);
if (!writer.IsOpen())
return false;
WriteTo(writer);
return true;
}
void
IePerr::SerializeInformationField (Buffer::Iterator i) const
{
i.WriteU8 (0);
i.WriteU8 (m_addressUnits.size ());
for (unsigned int j = 0; j < m_addressUnits.size (); j++)
{
WriteTo (i, m_addressUnits[j].destination);
i.WriteHtolsbU32 (m_addressUnits[j].seqnum);
}
}
void
RerrHeader::Serialize (Buffer::Iterator i ) const
{
i.WriteU8 (m_flag);
i.WriteU8 (m_reserved);
i.WriteU8 (GetDestCount ());
std::map<Ipv4Address, uint32_t>::const_iterator j;
for (j = m_unreachableDstSeqNo.begin (); j != m_unreachableDstSeqNo.end (); ++j)
{
WriteTo (i, (*j).first);
i.WriteHtonU32 ((*j).second);
}
}
void CEeprom::EepromCommand(uint8_t * Command)
{
time_t curtime_time;
struct tm curtime;
if (g_System->m_SaveUsing == SaveChip_Auto)
{
g_System->m_SaveUsing = SaveChip_Eeprom_4K;
}
switch (Command[2])
{
case 0: // check
if (g_System->m_SaveUsing != SaveChip_Eeprom_4K && g_System->m_SaveUsing != SaveChip_Eeprom_16K)
{
Command[1] |= 0x80;
break;
}
if (Command[1] != 3)
{
Command[1] |= 0x40;
if ((Command[1] & 3) > 0)
{
Command[3] = 0x00;
}
if ((Command[1] & 3) > 1)
{
Command[4] = (g_System->m_SaveUsing == SaveChip_Eeprom_4K) ? 0x80 : 0xC0;
}
if ((Command[1] & 3) > 2)
{
Command[5] = 0x00;
}
}
else
{
Command[3] = 0x00;
Command[4] = g_System->m_SaveUsing == SaveChip_Eeprom_4K ? 0x80 : 0xC0;
Command[5] = 0x00;
}
break;
case 4: // Read from Eeprom
if (Command[0] != 2 && bHaveDebugger())
{
g_Notify->DisplayError("What am I meant to do with this Eeprom Command");
}
if (Command[1] != 8 && bHaveDebugger())
{
g_Notify->DisplayError("What am I meant to do with this Eeprom Command");
}
ReadFrom(&Command[4], Command[3]);
break;
case 5: //Write to Eeprom
if (Command[0] != 10 && bHaveDebugger())
{
g_Notify->DisplayError("What am I meant to do with this Eeprom Command");
}
if (Command[1] != 1 && bHaveDebugger())
{
g_Notify->DisplayError("What am I meant to do with this Eeprom Command");
}
WriteTo(&Command[4], Command[3]);
break;
case 6: //RTC Status query
Command[3] = 0x00;
Command[4] = 0x10;
Command[5] = 0x00;
break;
case 7: //Read RTC block
switch (Command[3])
{
case 0: //Block number
Command[4] = 0x00;
Command[5] = 0x02;
Command[12] = 0x00;
break;
case 1:
//read block, Command[2], Unimplemented
break;
case 2: //Set RTC Time
time(&curtime_time);
memcpy(&curtime, localtime(&curtime_time), sizeof(curtime)); // fd's fix
Command[4] = byte2bcd(curtime.tm_sec);
Command[5] = byte2bcd(curtime.tm_min);
Command[6] = 0x80 + byte2bcd(curtime.tm_hour);
Command[7] = byte2bcd(curtime.tm_mday);
Command[8] = byte2bcd(curtime.tm_wday);
Command[9] = byte2bcd(curtime.tm_mon + 1);
Command[10] = byte2bcd(curtime.tm_year);
Command[11] = byte2bcd(curtime.tm_year / 100);
Command[12] = 0x00; // status
break;
}
break;
case 8:
//Write RTC, unimplemented
if (g_Settings->LoadDword(Debugger_ShowPifErrors))
{
g_Notify->DisplayError("Write RTC, unimplemented");
}
break;
default:
if (g_Settings->LoadDword(Debugger_ShowPifErrors))
{
g_Notify->DisplayError(stdstr_f("Unknown EepromCommand %d", Command[2]).c_str());
}
}
}
zx_status_t AmlUart::SerialImplConfig(uint32_t baud_rate, uint32_t flags) {
// Control register is determined completely by this logic, so start with a clean slate.
auto ctrl = Control::Get().FromValue(0);
if ((flags & SERIAL_SET_BAUD_RATE_ONLY) == 0) {
switch (flags & SERIAL_DATA_BITS_MASK) {
case SERIAL_DATA_BITS_5:
ctrl.set_xmit_len(Control::kXmitLength5);
break;
case SERIAL_DATA_BITS_6:
ctrl.set_xmit_len(Control::kXmitLength6);
break;
case SERIAL_DATA_BITS_7:
ctrl.set_xmit_len(Control::kXmitLength7);
break;
case SERIAL_DATA_BITS_8:
ctrl.set_xmit_len(Control::kXmitLength8);
break;
default:
return ZX_ERR_INVALID_ARGS;
}
switch (flags & SERIAL_STOP_BITS_MASK) {
case SERIAL_STOP_BITS_1:
ctrl.set_stop_len(Control::kStopLen1);
break;
case SERIAL_STOP_BITS_2:
ctrl.set_stop_len(Control::kStopLen2);
break;
default:
return ZX_ERR_INVALID_ARGS;
}
switch (flags & SERIAL_PARITY_MASK) {
case SERIAL_PARITY_NONE:
ctrl.set_parity(Control::kParityNone);
break;
case SERIAL_PARITY_EVEN:
ctrl.set_parity(Control::kParityEven);
break;
case SERIAL_PARITY_ODD:
ctrl.set_parity(Control::kParityOdd);
break;
default:
return ZX_ERR_INVALID_ARGS;
}
switch (flags & SERIAL_FLOW_CTRL_MASK) {
case SERIAL_FLOW_CTRL_NONE:
ctrl.set_two_wire(1);
break;
case SERIAL_FLOW_CTRL_CTS_RTS:
// CTS/RTS is on by default
break;
default:
return ZX_ERR_INVALID_ARGS;
}
}
// Configure baud rate based on crystal clock speed.
// See meson_uart_change_speed() in drivers/amlogic/uart/uart/meson_uart.c.
constexpr uint32_t kCrystalClockSpeed = 24000000;
uint32_t baud_bits = (kCrystalClockSpeed / 3) / baud_rate - 1;
if (baud_bits & (~AML_UART_REG5_NEW_BAUD_RATE_MASK)) {
zxlogf(ERROR, "%s: baud rate %u too large\n", __func__, baud_rate);
return ZX_ERR_OUT_OF_RANGE;
}
auto baud = Reg5::Get()
.FromValue(0)
.set_new_baud_rate(baud_bits)
.set_use_xtal_clk(1)
.set_use_new_baud_rate(1);
fbl::AutoLock al(&enable_lock_);
if ((flags & SERIAL_SET_BAUD_RATE_ONLY) == 0) {
// Invert our RTS if we are we are not enabled and configured for flow control.
if (!enabled_ && (ctrl.two_wire() == 0)) {
ctrl.set_inv_rts(1);
}
ctrl.WriteTo(&mmio_);
}
baud.WriteTo(&mmio_);
return ZX_OK;
}
void ResourceEntity::WriteToTest(sci::ostream &byteStream, bool fullWrite, int resourceNumber) const
{
std::map<BlobKey, uint32_t> propertyBag;
WriteTo(byteStream, fullWrite, resourceNumber, propertyBag);
}
