int getbuttonstate() { FILE *in; int ret; #ifdef HAVE_STORM ret = read_bit(60); #elif HAVE_WG302V1 ret = read_bit(13); #elif HAVE_WG302 ret = read_bit(3); #elif HAVE_MI424WR ret = read_bit(10); #elif HAVE_USR8200 ret = read_bit(12); #elif HAVE_CAMBRIA if (isGW2350()) ret = read_bit(4); else ret = read_bit(20); #else if (isCompex()) ret = read_bit(0); if (isGW2369()) ret = read_bit(3); else ret = read_bit(4); #endif #ifdef HAVE_TONZE return ret == 0 ? 0 : 1; #else return ret == 0 ? 1 : 0; #endif }
/*! * \brief Parse PES packet. * \param *bitstr: The bitstream to use. * \param *header: A pointer to a PES header structure. * \param *packet: A pointer to a PES packet structure. * \return 1 if succeed, 0 otherwise. * * From 'ISO/IEC 13818-1' specification: * 2.4.3.6 PES packet. * Table 2-17 – PES packet. * * Parse both MPEG-1 (ISO/IEC 11172-1) and MPEG-2 (ISO/IEC 13818-1) PES packets. */ int parse_pes(Bitstream_t *bitstr, PesHeader_t *header, PesPacket_t *packet) { TRACE_2(MPS, "> parse_pes()"); int retcode = SUCCESS; TRACE_INFO(MPS, "parse_pes() 0x%X @ %lli", header->start_code, bitstream_get_absolute_byte_offset(bitstr)); // "regular" PES packet? if ((header->stream_id != SID_PROGRAM_STREAM_MAP) && (header->stream_id != SID_PADDING) && (header->stream_id != SID_PRIVATE_STREAM_2) && (header->stream_id != SID_ECM_STREAM) && (header->stream_id != SID_EMM_STREAM) && (header->stream_id != SID_PROGRAM_STREAM_DIRECTORY) && (header->stream_id != SID_DSMCC_STREAM) && (header->stream_id != SID_2221E)) { unsigned checkversion = next_bits(bitstr, 2); // Parse MPEG-2 PES header if ((checkversion & 0x02) == 0x02) { packet->mpeg_version = 2; if (read_bits(bitstr, 2) != 2) { TRACE_ERROR(MPS, "wrong 'marker_bits'"); return FAILURE; } packet->PES_scrambling_control = read_bits(bitstr, 2); packet->PES_priority = read_bit(bitstr); packet->data_alignment_indicator = read_bit(bitstr); packet->copyright = read_bit(bitstr); packet->original_or_copy = read_bit(bitstr); packet->PTS_DTS_flag = read_bits(bitstr, 2); packet->ESCR_flag = read_bit(bitstr); packet->ES_rate_flag = read_bit(bitstr); packet->DSM_trick_mode_flag = read_bit(bitstr); packet->additional_copy_info_flag = read_bit(bitstr); packet->PES_CRC_flag = read_bit(bitstr); packet->PES_extension_flag = read_bit(bitstr); packet->PES_header_data_length = read_bits(bitstr, 8); if (packet->PTS_DTS_flag == 2) { if (read_bits(bitstr, 4) != 2) { TRACE_ERROR(MPS, "wrong 'marker_bit'"); return FAILURE; } packet->PTS = read_bits(bitstr, 3) << 30; MARKER_BIT packet->PTS += read_bits(bitstr, 15) << 15; MARKER_BIT packet->PTS += read_bits(bitstr, 15); MARKER_BIT } else if (packet->PTS_DTS_flag == 3)
void read_chunk_regs(void *fptr, int action) { struct user user; struct cp_sparc_window_regs or; int stopped; read_bit(fptr, &user, sizeof(struct user)); read_bit(fptr, &stopped, sizeof(int)); read_bit(fptr, &or, sizeof(struct cp_sparc_window_regs)); /* if (action & ACTION_PRINT) { fprintf(stderr, "(registers): Process was %sstopped\n", stopped?"":"not "); fprintf(stderr, "\teax: 0x%08lx ebx: 0x%08lx ecx: 0x%08lx edx: 0x%08lx\n", user.regs.eax, user.regs.ebx, user.regs.ecx, user.regs.edx); fprintf(stderr, "\tesi: 0x%08lx edi: 0x%08lx ebp: 0x%08lx esp: 0x%08lx\n", user.regs.esi, user.regs.edi, user.regs.ebp, user.regs.esp); fprintf(stderr, "\t ds: 0x%08x es: 0x%08x fs: 0x%08x gs: 0x%08x\n", user.regs.ds, user.regs.es, user.regs.fs, user.regs.gs); fprintf(stderr, "\teip: 0x%08lx eflags: 0x%08lx", user.regs.eip, user.regs.eflags); } */ if (action & ACTION_LOAD) load_chunk_regs(&user, &or, stopped); }
static void pin_write_handler(ble_lbs_t * p_lbs, uint8_t * pin_state) { // Sets motor values for every motor. twi_set_motor(pin_state); // Sets the color for every RGB-LED. uint8_t web_color_data = read_byte(pin_state, 5); set_rgb_color(web_color_data); // Shoots IR-signal. if (read_bit(pin_state, 1, 0)) { ir_shooting(pin_state); playNote(536); nrf_delay_ms(50); playNote(536); } // Turns laser on when game session is active if(read_bit(pin_state, 1, 1)) { nrf_gpio_pin_set(LASER_TRANSISTOR); } else nrf_gpio_pin_clear(LASER_TRANSISTOR); write_car_id(pin_state[19]); unique_car_ID = pin_state[19]; }
/*! * \param *dc The current DecodingContext. * \param *slice structure. * \return *rplm_t initialized data structure. */ static rplm_t *decodeRPLM(DecodingContext_t *dc, slice_t *slice) { TRACE_INFO(SLICE, " > " BLD_GREEN "decodeRPLM()\n" CLR_RESET); // RPLM allocation //////////////////////////////////////////////////////////////////////////// rplm_t *rplm = (rplm_t*)calloc(1, sizeof(rplm_t)); if (rplm == NULL) { TRACE_ERROR(SLICE, "Unable to alloc new RPLM!\n"); } else { // RPLM decoding //////////////////////////////////////////////////////////////////////// if (slice->slice_type % 5 != 2 && slice->slice_type % 5 != 4) { rplm->ref_pic_list_modification_flag_l0 = read_bit(dc->bitstr); if (rplm->ref_pic_list_modification_flag_l0) { do { rplm->modification_of_pic_nums_idc = read_ue(dc->bitstr); if (rplm->modification_of_pic_nums_idc == 0 || rplm->modification_of_pic_nums_idc == 1) { rplm->abs_diff_pic_num_minus1 = read_ue(dc->bitstr); } else if (rplm->modification_of_pic_nums_idc == 2) { rplm->long_term_pic_num = read_ue(dc->bitstr); } } while (rplm->modification_of_pic_nums_idc != 3); } } if (slice->slice_type % 5 == 1) { rplm->ref_pic_list_modification_flag_l1 = read_bit(dc->bitstr); if (rplm->ref_pic_list_modification_flag_l1) { do { rplm->modification_of_pic_nums_idc = read_ue(dc->bitstr); if (rplm->modification_of_pic_nums_idc == 0 || rplm->modification_of_pic_nums_idc == 1) { rplm->abs_diff_pic_num_minus1 = read_ue(dc->bitstr); } else if (rplm->modification_of_pic_nums_idc == 2) { rplm->long_term_pic_num = read_ue(dc->bitstr); } } while (rplm->modification_of_pic_nums_idc != 3); } } } return rplm; }
AM_ERR CMp4Builder::get_pic_order(unsigned char* pBuffer, int size, int nal_unit_type, int* pic_order_cnt_lsb) { AM_U8* pSlice_header = pBuffer; AM_U8 bit_pos = 0; AM_INT first_mb_in_slice; AM_INT slice_type; AM_INT pic_parameter_set_id; AM_INT frame_num; pSlice_header += parse_ue(pSlice_header,&first_mb_in_slice,&bit_pos); pSlice_header += parse_ue(pSlice_header,&slice_type,&bit_pos); switch (slice_type) { case SLICE_P_0: case SLICE_P_1: if (_last_p_num == -1) { _last_p_num = mVideoCnt; } else { if (mH264Info.M == 0) { mH264Info.M = mVideoCnt - _last_p_num; } } break; case SLICE_I_0: case SLICE_I_1: if (_last_i_num == -1) { _last_i_num = mVideoCnt; } else { if (mH264Info.N == 0) { mH264Info.N = mVideoCnt - _last_i_num; } } break; default: break; } pSlice_header += parse_ue(pSlice_header,&pic_parameter_set_id,&bit_pos); pSlice_header += read_bit(pSlice_header,&frame_num,&bit_pos, mSpsInfo.log2_max_frame_num_minus4+4); if (!mSpsInfo.frame_mbs_only_flag) { AM_BOOL field_pic_flag; AM_BOOL bottom_field_flag; pSlice_header += read_bit(pSlice_header, (AM_INT *)&field_pic_flag,&bit_pos); if (field_pic_flag) pSlice_header += read_bit(pSlice_header, (AM_INT *)&bottom_field_flag,&bit_pos); } if (nal_unit_type == NAL_IDR) { AM_INT idr_pic_id; pSlice_header += parse_ue(pSlice_header,&idr_pic_id,&bit_pos); } if( mSpsInfo.pic_order_cnt_type == 0 ) { pSlice_header += read_bit(pSlice_header,pic_order_cnt_lsb,&bit_pos, mSpsInfo.log2_max_pic_order_cnt_lsb_minus4+4); int max_pic_order_cnt_lsb = 1<<(mSpsInfo.log2_max_pic_order_cnt_lsb_minus4+4); if (*pic_order_cnt_lsb > max_pic_order_cnt_lsb/2) { *pic_order_cnt_lsb -= max_pic_order_cnt_lsb; } } return ME_OK; }
/*! * \brief Parse a program stream directory structure. * \param *bitstr The bitstream to use. * \param *packet A program stream directory structure. * \return 1 if succeed, 0 otherwise. * * From 'ISO/IEC 13818-1' specification: * 2.5.5 Program Stream directory * Table 2-36 – Program Stream directory packet */ static int parse_program_stream_directory(Bitstream_t *bitstr, PesHeader_t *header, ProgramStreamDirectory_t *packet) { TRACE_INFO(MPS, BLD_GREEN "parse_program_stream_directory()" CLR_RESET " @ %lli", header->offset_start); int retcode = SUCCESS; packet->number_of_access_units = read_bits(bitstr, 15); MARKER_BIT packet->prev_directory_offset = read_bits(bitstr, 15) << 30; MARKER_BIT packet->prev_directory_offset += read_bits(bitstr, 15) << 15; MARKER_BIT packet->prev_directory_offset += read_bits(bitstr, 15); MARKER_BIT packet->next_directory_offset = read_bits(bitstr, 15) << 30; MARKER_BIT packet->next_directory_offset += read_bits(bitstr, 15) << 15; MARKER_BIT packet->next_directory_offset += read_bits(bitstr, 15); MARKER_BIT for (uint16_t i = 0; i < packet->number_of_access_units; i++) { // TODO stack it? packet->packet_stream_id = read_bits(bitstr, 8); packet->PES_header_position_offset_sign = read_bit(bitstr); packet->PES_header_position_offset = read_bits(bitstr, 14) << 30; MARKER_BIT packet->PES_header_position_offset += read_bits(bitstr, 15) << 15; MARKER_BIT packet->PES_header_position_offset += read_bits(bitstr, 15); MARKER_BIT packet->reference_offset = read_bits(bitstr, 16); MARKER_BIT /*unsigned reserved1 =*/ read_bits(bitstr, 3); packet->PTS = read_bits(bitstr, 3) << 30; MARKER_BIT packet->PTS += read_bits(bitstr, 15) << 15; MARKER_BIT packet->PTS += read_bits(bitstr, 15); MARKER_BIT packet->byes_to_read = read_bits(bitstr, 15) << 15; MARKER_BIT packet->byes_to_read += read_bits(bitstr, 8); MARKER_BIT packet->intra_coded_indicator = read_bit(bitstr); packet->coding_parameters_indicator = read_bits(bitstr, 2); /*unsigned reserved2 =*/ read_bits(bitstr, 4); } return retcode; }
static int read_result(hx711_task* task) { int result; result = -read_bit(task); for(int i=0;i<23;i++) { result <<= 1; result |= read_bit(task); } return result; }
static void rebuild_tree(LHAPM2Decoder *decoder) { switch (decoder->tree_state) { // Initial tree build, from start of stream: case PM2_REBUILD_UNBUILT: read_code_tree(decoder); read_offset_tree(decoder, 5); decoder->tree_state = PM2_REBUILD_BUILD1; decoder->tree_rebuild_remaining = 1024; break; // Tree rebuild after 1KiB of data has been read: case PM2_REBUILD_BUILD1: read_offset_tree(decoder, 6); decoder->tree_state = PM2_REBUILD_BUILD2; decoder->tree_rebuild_remaining = 1024; break; // Tree rebuild after 2KiB of data has been read: case PM2_REBUILD_BUILD2: read_offset_tree(decoder, 7); decoder->tree_state = PM2_REBUILD_BUILD3; decoder->tree_rebuild_remaining = 2048; break; // Tree rebuild after 4KiB of data has been read: case PM2_REBUILD_BUILD3: if (read_bit(&decoder->bit_stream_reader) == 1) { read_code_tree(decoder); } read_offset_tree(decoder, 8); decoder->tree_state = PM2_REBUILD_CONTINUING; decoder->tree_rebuild_remaining = 4096; break; // Tree rebuild after 8KiB of data has been read, // and every 4KiB after that: case PM2_REBUILD_CONTINUING: if (read_bit(&decoder->bit_stream_reader) == 1) { read_code_tree(decoder); read_offset_tree(decoder, 8); } decoder->tree_rebuild_remaining = 4096; break; } }
void compressed_file_reader::get_next() { uint64_t numberBits = 0; while (status_ == 0 && !read_bit()) ++numberBits; current_value_ = 0; for (int64_t bit = numberBits - 1; status_ == 0 && bit >= 0; --bit) { if (read_bit()) current_value_ |= (1 << bit); } current_value_ |= (1 << numberBits); }
static void clock_setup_pulses(hx711_task* task) { int setup_pulses; switch (task->op) { case A128: setup_pulses = 1; break; case A64: setup_pulses = 3; break; case B32: setup_pulses = 2; break; default: setup_pulses = 1; } for (int i=0;i<setup_pulses;i++) { read_bit(task); } }
static size_t lha_pm2_decoder_read(void *data, uint8_t *buf) { LHAPM2Decoder *decoder = data; size_t result; int code; // On first pass through, build initial lookup trees. if (decoder->tree_state == PM2_REBUILD_UNBUILT) { // First bit in stream is discarded? read_bit(&decoder->bit_stream_reader); rebuild_tree(decoder); } result = 0; code = read_from_tree(&decoder->bit_stream_reader, decoder->code_tree); if (code < 0) { return 0; } if (code < 8) { read_single_byte(decoder, (unsigned int) code, buf, &result); } else { copy_from_history(decoder, (unsigned int) code - 8, buf, &result); } return result; }
int BinaryFileReader::read_omega() { int number = 1; while (read_bit() == 1) { number = read_binary(number); } return number; }
int funzip() { PHuftree_node p; unsigned char b,byte; p=&huftree[512]; while (p->num != 256) { b=read_bit(F_SRC); if (b) p=&huftree[p->rchild]; else p=&huftree[p->lchild]; if (p->num < 256) { byte=(unsigned char)(p->num); write_byte(F_DST,&byte); p=&huftree[512]; } } return 0; }
void compucolor_floppy_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) { if (!m_sel && !m_rw) { output_rxd(read_bit()); } }
// write to scratchpad of a SINGLE sensor void writeSP(int brdNo) { int i; int get[8]; ow_reset(); write_byte(0xCC); write_byte(0x4E); write_byte(brdNo); write_byte(0x0); write_byte(0x7F); while(read_bit() == 0); ow_reset(); write_byte(0xCC); write_byte(0x48); uDelay(120); ow_reset(); write_byte(0xCC); uDelay(120); write_byte(0xBE); for (i = 0 ; i < 9 ; i++){ get[i] = read_byte(); } if(get[2] != brdNo || get[3] != 0 || get[4] != 0x7F) { UART_printf("BAD CONFIGURATION?\n"); } }
/*! * \brief Parse a program stream map structure. * \param *bitstr The bitstream to use. * \param *header PES packet header. * \param *packet A program stream map structure. * \return 1 if succeed, 0 otherwise. * * \todo Parse desciptors. * * From 'ISO/IEC 13818-1' specification: * 2.5.4 Program Stream map * Table 2-35 – Program Stream map */ int parse_program_stream_map(Bitstream_t *bitstr, PesHeader_t *header, ProgramStreamMap_t *packet) { TRACE_INFO(MPS, BLD_GREEN "parse_program_stream_map()" CLR_RESET " @ %lli", header->offset_start); int retcode = SUCCESS; int i = 0, N1 = 0, N2 = 0; packet->current_next_indicator = read_bit(bitstr); /*int reserved1 =*/ read_bits(bitstr, 2); packet->program_stream_map_version = read_bits(bitstr, 5); /*int reserved2 =*/ read_bits(bitstr, 7); MARKER_BIT packet->program_stream_map_info_length = read_bits(bitstr, 16); for (i = 0; i < N1; i++) { // descriptor() } packet->elementary_stream_map_length = read_bits(bitstr, 16); for (i = 0; i < N1; i++) { // Stack it? packet->stream_type = read_bits(bitstr, 8); packet->elementary_stream_id = read_bits(bitstr, 8); packet->elementary_stream_info_length = read_bits(bitstr, 16); for (i = 0; i < N2; i++) { // descriptor() } } packet->CRC_32 = read_bits(bitstr, 32); return retcode; }
char *deflate_decompress(char *data, int data_length, int max_size) { char *buf = malloc(max_size * sizeof(char)); int pos = 0; bitstream_t *bitstream = calloc(1, sizeof(bitstream_t)); bitstream->data = data; int final, type; do { final = read_bit(bitstream); type = read_bits(bitstream, 2); if (type == 0) { pos = deflate_process_uncompressed(buf, pos, bitstream); } else if (type == 1 || type == 2) { htree_t *htree_lit, *htree_dist; if (type == 1) { deflate_get_fixed_htrees(&htree_lit, &htree_dist); } else { deflate_parse_htrees(bitstream, &htree_lit, &htree_dist); } pos = deflate_process_huffman(buf, pos, bitstream, htree_lit, htree_dist); /* Free the Huffman trees. */ huffman_free_tree(htree_lit); huffman_free_tree(htree_dist); } else { printf("Error: Invalid deflate block type\n"); } } while (!final);
static int read_code(LHALH1Decoder *decoder, uint16_t *result) { unsigned int node_index; int bit; // Start from the root node, and traverse down until a leaf is // reached. node_index = 0; //printf("<root "); while (!decoder->nodes[node_index].leaf) { bit = read_bit(&decoder->bit_stream_reader); if (bit < 0) { return 0; } //printf("<%i>", bit); // Choose one of the two children depending on the // bit that was read. node_index = decoder->nodes[node_index].child_index - (unsigned int) bit; } *result = decoder->nodes[node_index].child_index; //printf(" -> %i!>\n", *result); increment_for_code(decoder, *result); return 1; }
void read_chunk_tls(void *fptr, int action) { struct user_desc u; int ret; read_bit(fptr, &u, sizeof(struct user_desc)); if (!u.base_addr) return; if (action & ACTION_PRINT) fprintf(stderr, "TLS entry (%d): base_addr = 0x%lx", u.entry_number, u.base_addr); if (!(action & ACTION_LOAD)) return; if (!emulate_tls) { ret = set_thread_area(NULL); if (ret == -1) /* some libcs return the actual errno instead of -1 */ ret = -errno; if (ret == -ENOSYS) { /* We are not a TLS capable system. Turn on TLS emulation voodoo. */ emulate_tls = 1; /* We'll need write access to the code segments to do this. */ extra_prot_flags |= PROT_WRITE; } } if (emulate_tls) tls_base_address = u.base_addr; else syscall_check(set_thread_area(&u), 0, "set_thread_area"); }
static int read_length_value(LHANewDecoder *decoder) { int i, len; len = read_bits(&decoder->bit_stream_reader, 3); if (len < 0) { return -1; } if (len == 7) { // Read more bits to extend the length until we reach a '0'. for (;;) { i = read_bit(&decoder->bit_stream_reader); if (i < 0) { return -1; } else if (i == 0) { break; } ++len; } } return len; }
AM_UINT CMp4Builder::parse_exp_codes(AM_U8* pBuffer, AM_INT* value, AM_U8* bit_pos=0, AM_U8 type=0) { int leadingZeroBits = -1; AM_UINT i=0; AM_U8 j=*bit_pos; for (AM_U8 b = 0; !b; leadingZeroBits ++, j ++) { if(j == 8) { i++; j=0; } if (j == 0) { if ((pBuffer[i] == 0x3) && (*(pBuffer+i-1) == 0) && (*(pBuffer+i-2) == 0)) { i++; } } b = pBuffer[i] >> (7 -j) & 0x1; } AM_INT codeNum = 0; i += read_bit(pBuffer+i, &codeNum, &j, leadingZeroBits); codeNum += (1 << leadingZeroBits) -1; if (type == 0) { //ue(v) *value = codeNum; } else if (type == 1) {//se(v) *value = (codeNum/2+1); if (codeNum %2 == 0) { *value *= -1; } } *bit_pos = j; return i; }
/*! * \brief parse_ebml_element * \note 'bitstr' pointer is not checked for performance reasons. * * https://matroska.org/technical/specs/index.html * https://matroska.org/technical/specs/rfc/index.html */ int parse_ebml_element(Bitstream_t *bitstr, EbmlElement_t *element) { TRACE_3(MKV, "parse_ebml_element()"); int retcode = SUCCESS; if (element == NULL) { TRACE_ERROR(MKV, "Invalid EbmlElement_t structure!"); retcode = FAILURE; } else { // Set element offset element->offset_start = bitstream_get_absolute_byte_offset(bitstr); // Read element ID { uint32_t ebml_leadingZeroBits = 0; uint32_t ebml_size = 0; while (read_bit(bitstr) == 0 && ebml_leadingZeroBits < 4) ebml_leadingZeroBits++; ebml_size = (ebml_leadingZeroBits + 1) * 7; element->eid_size = (ebml_size + ebml_leadingZeroBits + 1) / 8; element->eid = read_bits_64(bitstr, ebml_size) + pow(2, ebml_size); } // Read element size { uint32_t ebml_leadingZeroBits = 0; uint32_t ebml_size = 0; while (read_bit(bitstr) == 0 && ebml_leadingZeroBits < 8) ebml_leadingZeroBits++; ebml_size = (ebml_leadingZeroBits + 1) * 7; element->size_size = (ebml_size + ebml_leadingZeroBits + 1) / 8; element->size = read_bits_64(bitstr, ebml_size); } // Set end offset element->offset_end = element->offset_start + (element->eid_size + element->size_size + element->size); } return retcode; }
static int write_byte(struct i2c *base, int byte) { int i; for (i=7; i>=0; i--) write_bit(base, (byte & (1<<i)) != 0); return read_bit(base) == 0; // ok (1) if NACK is asserted }
static boolean send_byte(byte b, boolean mak) { for (int i=0; i<8; i++) { rwbit(b&0x80); b<<=1; } rwbit(mak); return read_bit(); }
int BinaryFileReader::read_binary(int n) { int number = 1; for (int i = 0; i < n; ++i) { number <<= 1; number |= read_bit(); } return number; }
Node * read_header(FILE * fporig) {//reads the header from the beginning of the .huff file and builds the huffman tree int donecheck = 0; int count; unsigned char readchar; Node * root = NULL; Node * newNode = NULL; Node * head = NULL; while (!donecheck) {//while were not done, keep reading header read_bit(fporig); if (bit) {//found a leaf in the header, read in the 8-bit unsigned char readchar = 0; read_bit(fporig); readchar |= bit; //put in first bit for (count = 0; count < 7; ++count) {//loop 7 times to save the next 7 bits readchar <<= 1; read_bit(fporig); readchar |= bit; } //create a list of nodes where the last two are the lowest in the tree newNode = create_node(readchar); head = add_list(head, newNode); } else {//we are at a non-leaf node if (head == NULL) { fprintf(stderr, "\nERROR! FIRST BIT IN HEADER SHOULD NOT BE 0. WILL SEGFAULT.\n\n"); } if (head -> next == NULL) {//the list has become the tree root = head; donecheck = 1; } else {//have atleast 2 nodes in the list, merge the 2 furthest to the right head = merge_two(head); } } } //done reading the header, root points to our tree, last 0 bits are padding return (root); }
char read_char(FILE* input){ int c = 0; for (int i = 0; i < CHAR_BIT; i++){ int bit = read_bit(input); bit = bit << (CHAR_BIT - i - 1); c |= bit; } return c; }
/** * Transfer bits over SPI bit-bashing bus * * @v bus SPI bus * @v data_out TX data buffer (or NULL) * @v data_in RX data buffer (or NULL) * @v len Length of transfer (in @b bits) * @v endianness Endianness of this data transfer * * This issues @c len clock cycles on the SPI bus, shifting out data * from the @c data_out buffer to the MOSI line and shifting in data * from the MISO line to the @c data_in buffer. If @c data_out is * NULL, then the data sent will be all zeroes. If @c data_in is * NULL, then the incoming data will be discarded. */ static void spi_bit_transfer ( struct spi_bit_basher *spibit, const void *data_out, void *data_in, unsigned int len, int endianness ) { struct spi_bus *bus = &spibit->bus; struct bit_basher *basher = &spibit->basher; unsigned int sclk = ( ( bus->mode & SPI_MODE_CPOL ) ? 1 : 0 ); unsigned int cpha = ( ( bus->mode & SPI_MODE_CPHA ) ? 1 : 0 ); unsigned int bit_offset; unsigned int byte_offset; unsigned int byte_mask; unsigned int bit; unsigned int step; DBGC2 ( spibit, "SPIBIT %p transferring %d bits in mode %#x\n", spibit, len, bus->mode ); for ( step = 0 ; step < ( len * 2 ) ; step++ ) { /* Calculate byte offset and byte mask */ bit_offset = ( ( endianness == SPI_BIT_BIG_ENDIAN ) ? ( len - ( step / 2 ) - 1 ) : ( step / 2 ) ); byte_offset = ( bit_offset / 8 ); byte_mask = ( 1 << ( bit_offset % 8 ) ); /* Shift data in or out */ if ( sclk == cpha ) { const uint8_t *byte; /* Shift data out */ if ( data_out ) { byte = ( data_out + byte_offset ); bit = ( *byte & byte_mask ); DBGCP ( spibit, "SPIBIT %p wrote bit %d\n", spibit, ( bit ? 1 : 0 ) ); } else { bit = 0; } write_bit ( basher, SPI_BIT_MOSI, bit ); } else { uint8_t *byte; /* Shift data in */ bit = read_bit ( basher, SPI_BIT_MISO ); if ( data_in ) { DBGCP ( spibit, "SPIBIT %p read bit %d\n", spibit, ( bit ? 1 : 0 ) ); byte = ( data_in + byte_offset ); *byte &= ~byte_mask; *byte |= ( bit & byte_mask ); } } /* Toggle clock line */ spi_bit_delay(); sclk ^= 1; write_bit ( basher, SPI_BIT_SCLK, sclk ); } }
static int read_byte(struct i2c *base) { int i; u8 byte=0; for (i=7; i>=0; i--) byte = (byte << 1) | read_bit(base); return byte; }