int32_t libfat_searchdir(struct libfat_filesystem *fs, int32_t dirclust,
const void *name, struct libfat_direntry *direntry)
{
struct fat_dirent *dep;
int nent;
libfat_sector_t s = libfat_clustertosector(fs, dirclust);
while ( 1 ) {
if ( s == 0 )
return -2; /* Not found */
else if ( s == (libfat_sector_t)-1 )
return -1; /* Error */
dep = libfat_get_sector(fs, s);
if ( !dep )
return -1; /* Read error */
for ( nent = 0 ; nent < LIBFAT_SECTOR_SIZE ;
nent += sizeof(struct fat_dirent) ) {
if ( !memcmp(dep->name, name, 11) ) {
if ( direntry ) {
memcpy(direntry->entry, dep, sizeof (*dep));
direntry->sector = s;
direntry->offset = nent;
}
if ( read32(&dep->size) == 0 )
return 0; /* An empty file has no clusters */
else
return read16(&dep->clustlo) + (read16(&dep->clusthi) << 16);
}
if ( dep->name[0] == 0 )
return -2; /* Hit high water mark */
dep++;
}
s = libfat_nextsector(fs, s);
}
}
static void oki_play_sample(int sample_no)
{
UINT16 table_start = (sample_no & 0x80) ? read16(SAMPLE_TABLE_1) : read16(SAMPLE_TABLE_0);
UINT8 byte1 = read8(table_start + 2 * (sample_no & 0x7f) + 0);
UINT8 byte2 = read8(table_start + 2 * (sample_no & 0x7f) + 1);
int chip = (byte1 & 0x80) >> 7;
running_device *okidevice = (chip) ? NMK004_state.oki2device : NMK004_state.oki1device;
if ((byte1 & 0x7f) == 0)
{
// stop all channels
okim6295_w(okidevice, 0, 0x78 );
}
else
{
int sample = byte1 & 0x7f;
int ch = byte2 & 0x03;
int force = (byte2 & 0x80) >> 7;
if (!force && (NMK004_state.oki_playing & (1 << (ch + 4*chip))))
return;
NMK004_state.oki_playing |= 1 << (ch + 4*chip);
// stop channel
okim6295_w(okidevice, 0, (0x08 << ch) );
if (sample != 0)
{
UINT8 *rom = memory_region(NMK004_state.machine, (chip == 0) ? "oki1" : "oki2");
int bank = (byte2 & 0x0c) >> 2;
int vol = (byte2 & 0x70) >> 4;
if (bank != 3)
memcpy(rom + 0x20000,rom + 0x40000 + bank * 0x20000,0x20000);
okim6295_w(okidevice, 0, 0x80 | sample );
okim6295_w(okidevice, 0, (0x10 << ch) | vol );
}
}
uint16_t read16(uint8_t address) {
uint8_t err, pec;
uint16_t ret = 0;
i2c_start_wait(MLX90614_I2CADDR << 1);
err = i2c_write(address); // send register address to read from
if (err > 0) {
return 0;
}
err = i2c_start((MLX90614_I2CADDR << 1) + I2C_READ);
if (err > 0) {
return 0;
}
ret = i2c_read_ack();
ret |= i2c_read_ack() << 8;
pec = i2c_read_nack();
i2c_stop();
uint8_t commArray[5] = {MLX90614_I2CADDR << 1,
address,
(MLX90614_I2CADDR << 1) + I2C_READ,
ret & 0xFF,
(ret >> 8) & 0xFF
};
uint8_t crc = crc8_ccitt(commArray, 5);
if (pec != crc) { // PEC error
return 0;
}
return ret;
}
int32_t readTemp(uint8_t reg) {
uint16_t reading = read16(reg);
if (reading == 0) {
return -1;
}
int32_t temp = ((int32_t) reading) * 100;
temp /= 50;
temp -= 27315;
return temp;
}
void
test_writesame16_unmap_until_end(void)
{
int i, ret;
unsigned int j;
unsigned char *buf = alloca(256 * block_size);
CHECK_FOR_DATALOSS;
CHECK_FOR_THIN_PROVISIONING;
CHECK_FOR_LBPWS;
CHECK_FOR_SBC;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test WRITESAME16 of 1-256 blocks at the end of the LUN by setting number-of-blocks==0");
for (i = 1; i <= 256; i++) {
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
ret = write16(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
ret = writesame16(iscsic, tgt_lun, num_blocks - i,
0, i,
0, 1, 0, 0, NULL);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
return;
}
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
logging(LOG_VERBOSE, "LBPRZ is set. Read the unmapped "
"blocks back and verify they are all zero");
logging(LOG_VERBOSE, "Read %d blocks and verify they "
"are now zero", i);
ret = read16(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
for (j = 0; j < block_size * i; j++) {
if (buf[j] != 0) {
CU_ASSERT_EQUAL(buf[j], 0);
}
}
} else {
logging(LOG_VERBOSE, "LBPRZ is clear. Skip the read "
"and verify zero test");
}
}
}
/* to be called from 'bspstart.c' */
void bsp_hw_init (void)
{
uint16_t temp16;
#ifdef STANDALONE_EVB
/* STANDALONE_EVB: sets up PFC */
/* no STANDALONE_EVB: accepts defaults, adds RESET */
/* FIXME: replace 'magic numbers' */
write16(0x5000, PFC_PACRH); /* Pin function controller - WRHH, WRHL */
write16(0x1550, PFC_PACRL1); /* Pin fun. controller - WRH,WRL,RD,CS1 */
write16(0x0000, PFC_PBCR1); /* Pin function controller - default */
write16(0x2005, PFC_PBCR2); /* Pin fcn. controller - A18,A17,A16 */
write16(0xFFFF, PFC_PCCR); /* Pin function controller - A15-A0 */
write16(0x5555, PFC_PDCRH1); /* Pin function controller - D31-D24 */
write16(0x5555, PFC_PDCRH2); /* Pin function controller - D23-D16 */
write16(0xFFFF, PFC_PDCRL); /* Pin function controller - D15-D0 */
write16(0x0000, PFC_IFCR); /* Pin function controller - default */
write16(0x0000, PFC_PACRL2); /* default disconnects all I/O pins;*/
/* [re-connected by DEVICE_open()] */
#endif
/* default hardware setup for SH7045F EVB */
/* PFC: General I/O except pin 13 (reset): */
temp16 = read16(PFC_PECR1);
temp16 |= 0x0800;
write16(temp16, PFC_PECR1);
/* All I/O lines bits 7-0: */
write16(0x00, PFC_PECR2);
/* P5 (LED) out, all other pins in: */
temp16 = read16(PFC_PEIOR);
temp16 |= 0x0020;
write16(temp16, PFC_PEIOR);
}
void PX4Flow::update()
{
//send 0x0 to PX4FLOW module and receive back 22 Bytes data
Wire.beginTransmission(PX4FLOW_ADDRESS);
Wire.write(0x0);
Wire.endTransmission();
// request 22 bytes from the module
Wire.requestFrom(PX4FLOW_ADDRESS, 22);
// wait for all data to be available
// TODO we could manage a timeout in order not to block
// the loop when no component is connected
while(Wire.available() < 22);
frame.frame_count = read16();
frame.pixel_flow_x_sum = read16();
frame.pixel_flow_y_sum = read16();
frame.flow_comp_m_x = read16();
frame.flow_comp_m_y = read16();
frame.qual = read16();
frame.gyro_x_rate = read16();
frame.gyro_y_rate = read16();
frame.gyro_z_rate = read16();
frame.gyro_range = read8();
frame.sonar_timestamp = read8();
frame.ground_distance = read16();
// if too many bytes are available, we drain in order to be synched
// on next read
if(Wire.available()) {
#if PX4FLOW_DEBUG == true
{
Serial.println("ERROR [PX4Flow] : Too many bytes available.");
}
#endif
while(Wire.available()) {Wire.read();}
}
}
void
test_read16_0blocks(void)
{
int ret;
CHECK_FOR_SBC;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test READ16 0-blocks at LBA==0");
ret = read16(sd, NULL, 0, 0, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] READ16 is not implemented on this target and it does not claim SBC-3 support.");
CU_PASS("READ16 is not implemented and no SBC-3 support claimed.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test READ16 0-blocks one block past end-of-LUN");
ret = read16(sd, NULL, num_blocks + 1, 0,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test READ16 0-blocks at LBA==2^63");
ret = read16(sd, NULL, 0x8000000000000000ULL, 0,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test READ16 0-blocks at LBA==-1");
ret = read16(sd, NULL, -1, 0, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
/**
\fn readHeader
\brief read one track
*/
uint8_t amvHeader::readTrack(int nb)
{
uint32_t tail,sz;
AVIStreamHeader stream;
if(read32()!=MKFCC('s','t','r','h'))
{
printf("[AMV]Wrong header (strh)\n");
return 0;
}
// First is strh
sz=read32();
printf("\t\t[AMV] strh size : %u,sizeof :%u\n",sz,sizeof(AVIStreamHeader));
fseeko(_fd,sz,SEEK_CUR);
// The strf
if(read32()!=MKFCC('s','t','r','f'))
{
printf("[AMV]Wrong header (strf)\n");
return 0;
}
sz=read32();
uint32_t pos=ftell(_fd);
printf("\t\t[AMV] strf size : %u,sizeof :%u\n",sz,sizeof(AVIStreamHeader));
if(nb==1) // Second track=Audio
{
read16(); // Tag
wavHeader. channels =read16();
wavHeader. frequency =read32();
wavHeader. byterate =read32();
wavHeader. blockalign=read16();
wavHeader. encoding =WAV_AMV_ADPCM;
wavHeader. bitspersample=16;
}
fseeko(_fd,sz+pos,SEEK_SET);
return 1;
}
void
test_read16_simple(void)
{
int i, ret;
CHECK_FOR_SBC;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test READ16 of 1-256 blocks at the start of the LUN");
for (i = 1; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = read16(sd, 0, i * block_size,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] READ16 is not implemented on this target and it does not claim SBC-3 support.");
CU_PASS("READ16 is not implemented and no SBC-3 support claimed.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
}
logging(LOG_VERBOSE, "Test READ16 of 1-256 blocks at the end of the LUN");
for (i = 1; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = read16(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
}
static uint32_t reg_script_read_mmio(struct reg_script_context *ctx)
{
const struct reg_script *step = reg_script_get_step(ctx);
switch (step->size) {
case REG_SCRIPT_SIZE_8:
return read8((u8 *)step->reg);
case REG_SCRIPT_SIZE_16:
return read16((u16 *)step->reg);
case REG_SCRIPT_SIZE_32:
return read32((u32 *)step->reg);
}
return 0;
}
/*
* Clock_isr
*
* Clock interrupt handling routine.
*/
static rtems_isr Clock_isr(rtems_vector_number vector)
{
uint16_t tcr;
/* reset the timer underflow flag */
tcr = read16(SH7750_TCR0);
write16(tcr & ~SH7750_TCR_UNF, SH7750_TCR0);
/* Increment the clock interrupt counter */
Clock_driver_ticks++ ;
/* Invoke rtems clock service routine */
rtems_clock_tick();
}
attribute_info* read_attribute(FILE* stream){
attribute_info* a = malloc(sizeof(attribute_info));
memcheck(a);
a->name_index = read16(stream);
a->attribute_length = read32(stream);
assert(a->attribute_length > 0);
a->info = malloc(a->attribute_length + 1);
memcheck(a->info);
a->info[a->attribute_length] = 0;
for(int i = 0; i < a->attribute_length; i++){
a->info[i] = read8(stream);
}
return a;
}
static u32
read_2338 (u32 edx)
{
u32 ret;
write32 (DEFAULT_RCBA + 0x2330, edx);
write16 (DEFAULT_RCBA + 0x2338, (read16 (DEFAULT_RCBA + 0x2338)
& 0x1ff) | 0x600);
wait_2338 ();
ret = read32 (DEFAULT_RCBA + 0x2334);
wait_2338 ();
read8 (DEFAULT_RCBA + 0x2338);
return ret;
}
s32 sys_spu_thread_read_ls(u32 id, u32 address, vm::ptr<u64> value, u32 type)
{
sys_spu.Log("sys_spu_thread_read_ls(id=0x%x, address=0x%x, value=*0x%x, type=%d)", id, address, value, type);
LV2_LOCK;
const auto thread = Emu.GetIdManager().get<SPUThread>(id);
if (!thread)
{
return CELL_ESRCH;
}
if (address >= 0x40000 || address + type > 0x40000 || address % type) // check range and alignment
{
return CELL_EINVAL;
}
const auto group = thread->tg.lock();
if (!group)
{
throw EXCEPTION("Invalid SPU thread group");
}
if ((group->state < SPU_THREAD_GROUP_STATUS_WAITING) || (group->state > SPU_THREAD_GROUP_STATUS_RUNNING))
{
return CELL_ESTAT;
}
switch (type)
{
case 1:
*value = thread->read8(address);
break;
case 2:
*value = thread->read16(address);
break;
case 4:
*value = thread->read32(address);
break;
case 8:
*value = thread->read64(address);
break;
default:
return CELL_EINVAL;
}
return CELL_OK;
}
static u32
read_iobp(u32 address)
{
u32 ret;
write32(DEFAULT_RCBA + IOBPIRI, address);
write16(DEFAULT_RCBA + IOBPS, (read16(DEFAULT_RCBA + IOBPS)
& 0x1ff) | 0x600);
wait_iobp();
ret = read32(DEFAULT_RCBA + IOBPD);
wait_iobp();
read8(DEFAULT_RCBA + IOBPS); // call wait_iobp() instead here?
return ret;
}
static
int read_tag(uint8_t* arr, int pos, int swapBytes, void* dest)
{
// Format should be 5 over here (rational)
uint32_t format = read16(arr, pos + 2, swapBytes);
// Components should be 1
uint32_t components = read32(arr, pos + 4, swapBytes);
// Points to the value
uint32_t offset;
// sanity
if (components != 1) return 0;
if (format == 3)
offset = pos + 8;
else
offset = read32(arr, pos + 8, swapBytes);
switch (format) {
case 5: // Rational
{
double num = read32(arr, offset, swapBytes);
double den = read32(arr, offset + 4, swapBytes);
*(double *) dest = num / den;
}
break;
case 3: // uint 16
*(int*) dest = read16(arr, offset, swapBytes);
break;
default: return 0;
}
return 1;
}
bool PX4Flow::update_integral()
{
//send 0x16 to PX4FLOW module and receive back 25 Bytes data
Wire.beginTransmission(PX4FLOW_ADDRESS);
Wire.write(0x16);
Wire.endTransmission();
// request 25 bytes from the module
Wire.requestFrom(PX4FLOW_ADDRESS, 26);
// wait for all data to be available
// TODO we could manage a timeout in order not to block
// the loop when no component is connected
if (!wait(26)) {
return false;
}
// read the data
iframe.frame_count_since_last_readout = read16();
iframe.pixel_flow_x_integral = read16();
iframe.pixel_flow_y_integral = read16();
iframe.gyro_x_rate_integral = read16();
iframe.gyro_y_rate_integral = read16();
iframe.gyro_z_rate_integral = read16();
iframe.integration_timespan = read32();
iframe.sonar_timestamp = read32();
iframe.ground_distance = read16();
iframe.gyro_temperature = read16();
iframe.quality = read8();
// This is due to the lack of structure packing
// in the PX4Flow code.
read8();
// if too many bytes are available, we drain in order to be synched
// on next read
if(Wire.available()) {
#if PX4FLOW_DEBUG == true
{
Serial.println("ERROR [PX4Flow] : Too many bytes available.");
}
#endif
while(Wire.available()) {Wire.read();}
}
return true;
}
/*
* Initialization of serial port
*/
void sh_sci_init(int minor)
{
uint16_t temp16;
/*
* set PFC registers to enable I/O pins
*/
if ((minor == 0)) {
temp16 = read16(PFC_PACRL2); /* disable SCK0, DMA, IRQ */
temp16 &= ~(PA2MD1 | PA2MD0);
temp16 |= (PA_TXD0 | PA_RXD0); /* enable pins for Tx0, Rx0 */
write16(temp16, PFC_PACRL2);
} else if (minor == 1) {
temp16 = read16(PFC_PACRL2); /* disable SCK1, DMA, IRQ */
temp16 &= ~(PA5MD1 | PA5MD0);
temp16 |= (PA_TXD1 | PA_RXD1); /* enable pins for Tx1, Rx1 */
write16(temp16, PFC_PACRL2);
}
/*
* Non-default hardware setup occurs in sh_sci_first_open
*/
}
int read_relocation_bitmask()
{
uint32_t first;
uint32_t lower;
uint32_t upper;
first = read_byte();
if ((first & 0x80) != 0x80)
return first;
if ((first & 0xC0) != 0xC0)
return ((first & 0x7F) << 8) + read_byte();
if ((first & 0xE0) != 0xE0) {
upper = ((first & 0xFF3F) << 8) + read_byte();
lower = read16();
} else {
upper = read16();
lower = read16();
}
uint32_t ret = lower + (upper << 16);
return ret;
}
/**
* \brief Conversion of unsigned int
*/
const char *Translator::toUnsigned(uint16_t *length, uint8_t *data_record, uint16_t offset, const ipfix_element_t * element, struct json_conf * config)
{
if(*length == BYTE1) {
// 1 byte
if(element->en == 0 && element->id == 6 && config->tcpFlags) {
// Formated TCP flags
return formatFlags8(read8(data_record + offset));
} else if (element->en == 0 && element->id == 4 && !config->protocol) {
// Formated protocol identification (TCP, UDP, ICMP,...)
return (formatProtocol(read8(data_record + offset)));
} else {
// Other elements
snprintf(buffer, BUFF_SIZE, "%" PRIu8, read8(data_record + offset));
}
} else if(*length == BYTE2) {
// 2 bytes
if (element->en == 0 && element->id == 6 && config->tcpFlags) {
// Formated TCP flags
return formatFlags16(read16(data_record + offset));
} else {
// Other elements
snprintf(buffer, BUFF_SIZE, "%" PRIu16, ntohs(read16(data_record + offset)));
}
} else if(*length == BYTE4) {
// 4 bytes
snprintf(buffer, BUFF_SIZE, "%" PRIu32, ntohl(read32(data_record + offset)));
} else if(*length == BYTE8) {
// 8 bytes
snprintf(buffer, BUFF_SIZE, "%" PRIu64, be64toh(read64(data_record + offset)));
} else {
// Other sizes
snprintf(buffer, BUFF_SIZE, "%s", "\"unknown\"");
}
return buffer;
}
void
test_mandatory_sbc(void)
{
int ret;
//unsigned char buf[4096];
//struct unmap_list list[1];
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test support for all mandatory opcodes on SBC devices");
CHECK_FOR_SBC;
logging(LOG_VERBOSE, "Test INQUIRY.");
ret = inquiry(sd, NULL, 0, 0, 255,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test READCAPACITY10.");
ret = readcapacity10(sd, NULL, 0, 0,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (sbc3_support) {
logging(LOG_VERBOSE, "Test READCAPACITY16. The device claims SBC-3 support.");
ret = readcapacity16(sd, NULL, 15,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
logging(LOG_VERBOSE, "Test READ10.");
ret = read10(sd, NULL, 0, block_size, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (sbc3_support) {
logging(LOG_VERBOSE, "Test READ16. the device claims SBC-3 support.");
ret = read16(sd, 0, block_size, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
logging(LOG_VERBOSE, "Test TESTUNITREADY.");
ret = testunitready(sd,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
static void analyze_ufsr(void)
{
uint16_t ufsr = read16(UFSR);
if (!ufsr)
return;
explain_register("UFSR", "Usage Fault Status Register", ufsr, NULL);
explain_bit(ufsr, 9, "DIVBYZERO", "Fault because of a divide by zero");
explain_bit(ufsr, 8, "UNALIGNED", "Fault because of an unaligned memory "
"access");
explain_bit(ufsr, 3, "NOCP", "Fault because CPU does not support "
"Coprocessor instructions");
explain_bit(ufsr, 2, "INVPC", "Invalid PC load by EXC_RETURN (from "
"interrupt return)");
}
uint16_t Adafruit_VCNL4010::readProximity() {
uint8_t i = read8(VCNL4010_INTSTAT);
i &= ~0x80;
write8(VCNL4010_INTSTAT, i);
write8(VCNL4010_COMMAND, VCNL4010_MEASUREPROXIMITY);
while (1) {
//Serial.println(read8(VCNL4010_INTSTAT), HEX);
uint8_t result = read8(VCNL4010_COMMAND);
//Serial.print("Ready = 0x"); Serial.println(result, HEX);
if (result & VCNL4010_PROXIMITYREADY) {
return read16(VCNL4010_PROXIMITYDATA);
}
delay(1);
}
}
SisRC
SISLangRecord::fillFrom(uint8_t* buf, int* base, off_t len)
{
if (*base + 2 > len)
return SIS_TRUNCATED;
m_lang = read16(buf + *base);
if (m_lang > 33) // Thai, last language
return SIS_CORRUPTED;
if (logLevel >= 2)
printf(_("Got language %d (%s)\n"), m_lang, langTable[m_lang].m_name);
if (logLevel >= 1)
printf(_("%d .. %d (%d bytes): Language record for %s\n"),
*base, *base + 2, 2, langTable[m_lang].m_name);
*base += 2;
return SIS_OK;
}
static int
init_sections(struct edit_file *efile)
{
uint16_t e_shnum;
uint32_t e_shoff;
int i;
struct edit_section *current_section, *prev_section;
e_shnum = read16(offsetof(Elf32_Ehdr, e_shnum) + efile->mmap,
efile->endianness);
e_shoff = read32(offsetof(Elf32_Ehdr, e_shoff) + efile->mmap,
efile->endianness);
efile->first_section = NULL;
/* NB start with i=1 because section 0 always exists and is defined to be of type NULL */
for (i=1; i < e_shnum; i++) {
char *section_offset;;
current_section = malloc(sizeof(struct edit_section));
current_section -> next = NULL;
section_offset = efile->mmap + e_shoff + (sizeof(Elf32_Shdr) * i);
strcpy(current_section->name, ".");
strcat(current_section->name, efile->ditname);
strcat(current_section->name, read_section_name(efile, i));
current_section->type = read32(offsetof(Elf32_Shdr, sh_type) + section_offset,
efile->endianness);
current_section->addr = read32(offsetof(Elf32_Shdr, sh_addr) + section_offset,
efile->endianness);
current_section->orig_offset = read32(offsetof(Elf32_Shdr, sh_offset) + section_offset,
efile->endianness);
current_section->size = read32(offsetof(Elf32_Shdr, sh_size) + section_offset,
efile->endianness);
current_section->addralign = read32(offsetof(Elf32_Shdr, sh_addralign) + section_offset,
efile->endianness);
current_section->entsize = read32(offsetof(Elf32_Shdr, sh_entsize) + section_offset,
efile->endianness);
current_section->flags = read32(offsetof(Elf32_Shdr, sh_flags) + section_offset,
efile->endianness);
if (i==1) {
efile->first_section = current_section;
} else {
prev_section->next = current_section;
}
prev_section = current_section;
}
}
void
VirtualComponent::loadFromBuffer(uint8_t **buffer)
{
uint8_t *old = *buffer;
debug(3, " Loading internal state (%d bytes) ...\n", VirtualComponent::stateSize());
// Load internal state of sub components
if (subComponents != NULL)
for (unsigned i = 0; subComponents[i] != NULL; i++)
subComponents[i]->loadFromBuffer(buffer);
// Load own internal state
void *data; size_t size; int flags;
for (unsigned i = 0; snapshotItems != NULL && snapshotItems[i].data != NULL; i++) {
data = snapshotItems[i].data;
flags = snapshotItems[i].flags & 0x0F;
size = snapshotItems[i].size;
if (flags == 0) { // Auto detect size
switch (snapshotItems[i].size) {
case 1: *(uint8_t *)data = read8(buffer); break;
case 2: *(uint16_t *)data = read16(buffer); break;
case 4: *(uint32_t *)data = read32(buffer); break;
case 8: *(uint64_t *)data = read64(buffer); break;
default: readBlock(buffer, (uint8_t *)data, size);
}
} else { // Format is specified manually
switch (flags) {
case BYTE_FORMAT: readBlock(buffer, (uint8_t *)data, size); break;
case WORD_FORMAT: readBlock16(buffer, (uint16_t *)data, size); break;
case DOUBLE_WORD_FORMAT: readBlock32(buffer, (uint32_t *)data, size); break;
case QUAD_WORD_FORMAT: readBlock64(buffer, (uint64_t *)data, size); break;
default: assert(0);
}
}
}
if (*buffer - old != VirtualComponent::stateSize()) {
panic("loadFromBuffer: Snapshot size is wrong.");
assert(false);
}
}
float FOXFIRE_Si1132::readIR()
{
float lx = 0;
for (int i = 0; i < 5; i++) {
lx += read16(0x24);
delay(20);
}
lx = lx/5;
// adc offset
if (lx > 256)
lx -= 256;
else
lx = 0;
return lx;
}
static void usb_init2(struct device *dev)
{
u8 byte;
u16 word;
u32 dword;
u32 usb2_bar0;
/* dword = pci_read_config32(dev, 0xf8); */
/* dword |= 40; */
/* pci_write_config32(dev, 0xf8, dword); */
usb2_bar0 = pci_read_config32(dev, 0x10) & ~0xFF;
printk(BIOS_INFO, "usb2_bar0=0x%x\n", usb2_bar0);
/* RPR5.4 Enables the USB PHY auto calibration resister to match 45ohm resistance */
dword = 0x00020F00;
write32(usb2_bar0 + 0xC0, dword);
/* RPR5.5 Sets In/OUT FIFO threshold for best performance */
dword = 0x00200040;
write32(usb2_bar0 + 0xA4, dword);
/* RPR5.9 Disable the EHCI Dynamic Power Saving feature */
word = read16(usb2_bar0 + 0xBC);
word &= ~(1 << 12);
write16(usb2_bar0 + 0xBC, word);
/* RPR5.10 Disable EHCI MSI support */
byte = pci_read_config8(dev, 0x50);
byte |= (1 << 6);
pci_write_config8(dev, 0x50, byte);
/* RPR5.13 Disable C3 time enhancement feature */
dword = pci_read_config32(dev, 0x50);
dword &= ~(1 << 28);
pci_write_config32(dev, 0x50, dword);
/* EHCI Erratum (adapted from Linux) */
dword = pci_read_config32(dev, 0x53);
dword |= (1 << 3);
pci_write_config32(dev, 0x53, dword);
/* RPR5.14 Disable USB PHY PLL Reset signal to come from ACPI */
byte = pci_read_config8(dev, 0x54);
byte &= ~(1 << 0);
pci_write_config8(dev, 0x54, byte);
}
uint16_t VCNL4010::readAmbient(void) {
uint8_t i = read8(VCNL4010_INTSTAT);
i &= ~0x40;
write8(VCNL4010_INTSTAT, i);
write8(VCNL4010_COMMAND, VCNL4010_MEASUREAMBIENT);
while (1) {
//Serial.println(read8(VCNL4010_INTSTAT), HEX);
uint8_t result = read8(VCNL4010_COMMAND);
//Serial.print("Ready = 0x"); Serial.println(result, HEX);
if (result & VCNL4010_AMBIENTREADY) {
return read16(VCNL4010_AMBIENTDATA);
}
delay(1);
}
}
static char* websocket_payload_size(int sd, char* ptr, const struct frame_header* header, size_t* size){
*size = header->plen1;
if ( header->plen1 == 126 ){
uint16_t tmp;
ptr = read16(sd, ptr, &tmp);
*size = tmp;
}
if ( header->plen1 == 127 ){
uint64_t tmp;
ptr = read64(sd, ptr, &tmp);
*size = tmp;
}
return ptr;
}
