/****************************************************************************** ** FUNCTION DEFINITIONS *******************************************************************************/ int main(void) { /* This function will enable clocks for the DMTimer2 instance */ DMTimer2ModuleClkConfig(); /* Initialize the UART console */ ConsoleUtilsInit(); /* Select the console type based on compile time check */ ConsoleUtilsSetType(CONSOLE_UART); /* Enable IRQ in CPSR */ IntMasterIRQEnable(); /* Register DMTimer2 interrupts on to AINTC */ DMTimerAintcConfigure(); /* Perform the necessary configurations for DMTimer */ DMTimerSetUp(); /* Enable the DMTimer interrupts */ DMTimerIntEnable(SOC_DMTIMER_2_REGS, DMTIMER_INT_OVF_EN_FLAG); ConsoleUtilsPrintf("Tencounter: "); /* Start the DMTimer */ DMTimerEnable(SOC_DMTIMER_2_REGS); while(cntValue) { if(flagIsr == 1) { ConsoleUtilsPrintf("\b%d",(cntValue - 1)); cntValue--; flagIsr = 0; } } /* Stop the DMTimer */ DMTimerDisable(SOC_DMTIMER_2_REGS); PRINT_STATUS(S_PASS); /* Halt the program */ while(1); }
int main() { device<port_a, 0> sensor_0; device<port_a, 1> sensor_1; device<port_b, 0> relay_0; device<port_b, 1> relay_1; std::cout << "Everything's off" << std::endl; PRINT_STATUS(sensor_0); PRINT_STATUS(sensor_1); PRINT_STATUS(relay_0); PRINT_STATUS(relay_1); std::cout << "Turn on sensor 0" << std::endl; sensor_0 = 1; PRINT_STATUS(sensor_0); PRINT_STATUS(sensor_1); std::cout << "Turn on sensor 1" << std::endl; sensor_1 = 1; PRINT_STATUS(sensor_0); PRINT_STATUS(sensor_1); std::cout << "Turn on relay 0" << std::endl; relay_0 = 1; PRINT_STATUS(relay_0); PRINT_STATUS(relay_1); std::cout << "Turn on relay 1" << std::endl; relay_1 = 1; PRINT_STATUS(relay_0); PRINT_STATUS(relay_1); return 0; }
static void validate_file(const char *path, int number, uint64_t *ptr_ok, uint64_t *ptr_corrupted, uint64_t *ptr_changed, uint64_t *ptr_overwritten, uint64_t *ptr_size, int *ptr_read_all, struct timeval *ptr_dt, int progress) { char *full_fn; const char *filename; const int num_int64 = SECTOR_SIZE >> 3; uint64_t sector[num_int64]; FILE *f; int fd; size_t sectors_read; uint64_t expected_offset; int final_errno; struct timeval t1, t2; /* Progress time. */ struct timeval pt1 = { .tv_sec = -1000, .tv_usec = 0 }; *ptr_ok = *ptr_corrupted = *ptr_changed = *ptr_overwritten = 0; full_fn = full_fn_from_number(&filename, path, number); assert(full_fn); printf("Validating file %s ... %s", filename, progress ? BLANK : ""); fflush(stdout); #ifdef __CYGWIN__ /* We don't need write access, but some kernels require that * the file descriptor passed to fdatasync(2) to be writable. */ f = fopen(full_fn, "rb+"); #else f = fopen(full_fn, "rb"); #endif if (!f) err(errno, "Can't open file %s", full_fn); fd = fileno(f); assert(fd >= 0); /* If the kernel follows our advice, f3read won't ever read from cache * even when testing small memory cards without a remount, and * we should have a better reading-speed measurement. */ assert(!fdatasync(fd)); assert(!posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED)); /* Obtain initial time. */ assert(!gettimeofday(&t1, NULL)); /* Help the kernel to help us. */ assert(!posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL)); sectors_read = fread(sector, SECTOR_SIZE, 1, f); final_errno = errno; expected_offset = (uint64_t)number * GIGABYTES; while (sectors_read > 0) { uint64_t rn; int error_count, i; assert(sectors_read == 1); rn = sector[0]; error_count = 0; for (i = 1; error_count <= TOLERANCE && i < num_int64; i++) { rn = random_number(rn); if (rn != sector[i]) error_count++; } if (expected_offset == sector[0]) { if (error_count == 0) (*ptr_ok)++; else if (error_count <= TOLERANCE) (*ptr_changed)++; else (*ptr_corrupted)++; } else if (error_count <= TOLERANCE) (*ptr_overwritten)++; else (*ptr_corrupted)++; sectors_read = fread(sector, SECTOR_SIZE, 1, f); final_errno = errno; expected_offset += SECTOR_SIZE; if (progress) { struct timeval pt2; assert(!gettimeofday(&pt2, NULL)); /* Avoid often printouts. */ if (delay_ms(&pt1, &pt2) >= 200) { PRINT_STATUS(CLEAR); fflush(stdout); pt1 = pt2; } } } assert(!gettimeofday(&t2, NULL)); update_dt(ptr_dt, &t1, &t2); *ptr_read_all = feof(f); *ptr_size = ftell(f); PRINT_STATUS(progress ? CLEAR : ""); if (!*ptr_read_all) { assert(ferror(f)); printf(" - NOT fully read due to \"%s\"", strerror(final_errno)); } printf("\n"); fclose(f); free(full_fn); } static void report(const char *prefix, uint64_t i) { double f = (double) (i * SECTOR_SIZE); const char *unit = adjust_unit(&f); printf("%s %.2f %s (%" PRIu64 " sectors)\n", prefix, f, unit, i); }
int main( int i_argc, char **ppsz_argv ) { char *client_socket_tmpl = "dvblastctl.clientsock.XXXXXX"; char *psz_srv_socket = NULL; int i; char *p_cmd, *p_arg1 = NULL, *p_arg2 = NULL; ssize_t i_size; struct sockaddr_un sun_client, sun_server; uint8_t p_buffer[COMM_BUFFER_SIZE]; uint8_t *p_data = p_buffer + COMM_HEADER_SIZE; uint16_t i_pid = 0; struct dvblastctl_option opt = { 0, 0, 0 }; for ( ; ; ) { int c; static const struct option long_options[] = { {"remote-socket", required_argument, NULL, 'r'}, {"print", required_argument, NULL, 'x'}, {"help", no_argument, NULL, 'h'}, {0, 0, 0, 0} }; if ( (c = getopt_long(i_argc, ppsz_argv, "r:x:h", long_options, NULL)) == -1 ) break; switch ( c ) { case 'r': psz_srv_socket = optarg; break; case 'x': if ( !strcmp(optarg, "text") ) i_print_type = PRINT_TEXT; else if ( !strcmp(optarg, "xml") ) i_print_type = PRINT_XML; else msg_Warn( NULL, "unrecognized print type %s", optarg ); /* Make stdout line-buffered */ setvbuf(stdout, NULL, _IOLBF, 0); break; case 'h': default: usage(); } } /* Validate commands */ #define usage_error(msg, ...) \ do { \ msg_Err( NULL, msg, ##__VA_ARGS__ ); \ usage(); \ } while(0) p_cmd = ppsz_argv[optind]; p_arg1 = ppsz_argv[optind + 1]; p_arg2 = ppsz_argv[optind + 2]; if ( !psz_srv_socket ) usage_error( "Remote socket is not set.\n" ); if ( !p_cmd ) usage_error( "Command is not set.\n" ); i = 0; do { if ( streq(ppsz_argv[optind], options[i].opt) ) { opt = options[i]; break; } } while ( options[++i].opt ); if ( !opt.opt ) usage_error( "Unknown command: %s\n", p_cmd ); if ( opt.nparams == 1 && !p_arg1 ) usage_error( "%s option needs parameter.\n", opt.opt ); if ( opt.nparams == 2 && (!p_arg1 || !p_arg2) ) usage_error( "%s option needs two parameters.\n", opt.opt ); #undef usage_error /* Create client socket name */ char *tmpdir = getenv("TMPDIR"); snprintf( psz_client_socket, PATH_MAX - 1, "%s/%s", tmpdir ? tmpdir : "/tmp", client_socket_tmpl ); psz_client_socket[PATH_MAX - 1] = '\0'; int tmp_fd = mkstemp(psz_client_socket); if ( tmp_fd > -1 ) { close(tmp_fd); unlink(psz_client_socket); } else { return_error( "Cannot build UNIX socket %s (%s)", psz_client_socket, strerror(errno) ); } if ( (i_fd = socket( AF_UNIX, SOCK_DGRAM, 0 )) < 0 ) return_error( "Cannot create UNIX socket (%s)", strerror(errno) ); i = COMM_MAX_MSG_CHUNK; setsockopt( i_fd, SOL_SOCKET, SO_RCVBUF, &i, sizeof(i) ); memset( &sun_client, 0, sizeof(sun_client) ); sun_client.sun_family = AF_UNIX; strncpy( sun_client.sun_path, psz_client_socket, sizeof(sun_client.sun_path) ); sun_client.sun_path[sizeof(sun_client.sun_path) - 1] = '\0'; if ( bind( i_fd, (struct sockaddr *)&sun_client, SUN_LEN(&sun_client) ) < 0 ) return_error( "Cannot bind (%s)", strerror(errno) ); memset( &sun_server, 0, sizeof(sun_server) ); sun_server.sun_family = AF_UNIX; strncpy( sun_server.sun_path, psz_srv_socket, sizeof(sun_server.sun_path) ); sun_server.sun_path[sizeof(sun_server.sun_path) - 1] = '\0'; p_buffer[0] = COMM_HEADER_MAGIC; p_buffer[1] = opt.cmd; memset( p_buffer + 2, 0, COMM_HEADER_SIZE - 2 ); i_size = COMM_HEADER_SIZE; /* Handle commands that send parameters */ switch ( opt.cmd ) { case CMD_INVALID: case CMD_RELOAD: case CMD_SHUTDOWN: case CMD_FRONTEND_STATUS: case CMD_MMI_STATUS: case CMD_GET_PAT: case CMD_GET_CAT: case CMD_GET_NIT: case CMD_GET_SDT: case CMD_GET_PIDS: /* These commands need no special handling because they have no parameters */ break; case CMD_GET_PMT: { uint16_t i_sid = atoi(p_arg1); i_size = COMM_HEADER_SIZE + 2; p_data[0] = (uint8_t)((i_sid >> 8) & 0xff); p_data[1] = (uint8_t)(i_sid & 0xff); break; } case CMD_GET_PID: { i_pid = (uint16_t)atoi(p_arg1); i_size = COMM_HEADER_SIZE + 2; p_data[0] = (uint8_t)((i_pid >> 8) & 0xff); p_data[1] = (uint8_t)(i_pid & 0xff); break; } case CMD_MMI_SEND_TEXT: { struct cmd_mmi_send *p_cmd = (struct cmd_mmi_send *)p_data; p_cmd->i_slot = atoi(p_arg1); en50221_mmi_object_t object; object.i_object_type = EN50221_MMI_ANSW; if ( !p_arg2 || p_arg2[0] == '\0' ) { object.u.answ.b_ok = 0; object.u.answ.psz_answ = ""; } else { object.u.answ.b_ok = 1; object.u.answ.psz_answ = p_arg2; } i_size = COMM_BUFFER_SIZE - COMM_HEADER_SIZE - ((void *)&p_cmd->object - (void *)p_cmd); if ( en50221_SerializeMMIObject( (uint8_t *)&p_cmd->object, &i_size, &object ) == -1 ) return_error( "Comm buffer is too small" ); i_size += COMM_HEADER_SIZE + ((void *)&p_cmd->object - (void *)p_cmd); break; } case CMD_MMI_SEND_CHOICE: { struct cmd_mmi_send *p_cmd = (struct cmd_mmi_send *)p_data; p_cmd->i_slot = atoi(p_arg1); i_size = COMM_HEADER_SIZE + sizeof(struct cmd_mmi_send); p_cmd->object.i_object_type = EN50221_MMI_MENU_ANSW; p_cmd->object.u.menu_answ.i_choice = atoi(p_arg2); break; } case CMD_MMI_SLOT_STATUS: case CMD_MMI_OPEN: case CMD_MMI_CLOSE: case CMD_MMI_RECV: { p_data[0] = atoi(p_arg1); i_size = COMM_HEADER_SIZE + 1; break; } default: /* This should not happen */ return_error( "Unhandled option (%d)", opt.cmd ); } /* Send command and receive answer */ if ( sendto( i_fd, p_buffer, i_size, 0, (struct sockaddr *)&sun_server, SUN_LEN(&sun_server) ) < 0 ) return_error( "Cannot send comm socket (%s)", strerror(errno) ); uint32_t i_packet_size = 0, i_received = 0; do { i_size = recv( i_fd, p_buffer + i_received, COMM_MAX_MSG_CHUNK, 0 ); if ( i_size == -1 ) break; if ( !i_packet_size ) { uint32_t *p_packet_size = (uint32_t *)&p_buffer[4]; i_packet_size = *p_packet_size; if ( i_packet_size > COMM_BUFFER_SIZE ) { i_size = -1; break; } } i_received += i_size; } while ( i_received < i_packet_size ); clean_client_socket(); if ( i_size < COMM_HEADER_SIZE ) return_error( "Cannot recv from comm socket, size:%zd (%s)", i_size, strerror(errno) ); /* Process answer */ if ( p_buffer[0] != COMM_HEADER_MAGIC ) return_error( "Wrong protocol version 0x%x", p_buffer[0] ); now = mdate(); ctl_cmd_answer_t c_answer = p_buffer[1]; switch ( c_answer ) { case RET_OK: break; case RET_MMI_WAIT: exit(252); break; case RET_ERR: return_error( "Request failed" ); break; case RET_HUH: return_error( "Internal error" ); break; case RET_NODATA: return_error( "No data" ); break; case RET_PAT: case RET_CAT: case RET_NIT: case RET_SDT: { uint8_t *p_flat_data = p_buffer + COMM_HEADER_SIZE; unsigned int i_flat_data_size = i_size - COMM_HEADER_SIZE; uint8_t **pp_sections = psi_unpack_sections( p_flat_data, i_flat_data_size ); switch( c_answer ) { case RET_PAT: pat_table_print( pp_sections, psi_print, NULL, i_print_type ); break; case RET_CAT: cat_table_print( pp_sections, psi_print, NULL, i_print_type ); break; case RET_NIT: nit_table_print( pp_sections, psi_print, NULL, psi_iconv, NULL, i_print_type ); break; case RET_SDT: sdt_table_print( pp_sections, psi_print, NULL, psi_iconv, NULL, i_print_type ); break; default: break; /* Can't happen */ } psi_table_free( pp_sections ); free( pp_sections ); break; } case RET_PMT: { pmt_print( p_data, psi_print, NULL, psi_iconv, NULL, i_print_type ); break; } case RET_PID: { print_pids_header(); print_pid( i_pid, (ts_pid_info_t *)p_data ); print_pids_footer(); break; } case RET_PIDS: { print_pids( p_data ); break; } case RET_FRONTEND_STATUS: { int ret = 1; struct ret_frontend_status *p_ret = (struct ret_frontend_status *)&p_buffer[COMM_HEADER_SIZE]; if ( i_size != COMM_HEADER_SIZE + sizeof(struct ret_frontend_status) ) return_error( "Bad frontend status" ); if ( i_print_type == PRINT_XML ) printf("<FRONTEND>\n"); #define PRINT_TYPE( x ) \ do { \ if ( i_print_type == PRINT_XML ) \ printf( " <TYPE type=\"%s\"/>\n", STRINGIFY(x) ); \ else \ printf( "type: %s\n", STRINGIFY(x) ); \ } while(0) switch ( p_ret->info.type ) { case FE_QPSK: PRINT_TYPE(QPSK); break; case FE_QAM : PRINT_TYPE(QAM); break; case FE_OFDM: PRINT_TYPE(OFDM); break; case FE_ATSC: PRINT_TYPE(ATSC); break; default : PRINT_TYPE(UNKNOWN); break; } #undef PRINT_TYPE #define PRINT_INFO( x ) \ do { \ if ( i_print_type == PRINT_XML ) \ printf( " <SETTING %s=\"%u\"/>\n", STRINGIFY(x), p_ret->info.x ); \ else \ printf( "%s: %u\n", STRINGIFY(x), p_ret->info.x ); \ } while(0) PRINT_INFO( frequency_min ); PRINT_INFO( frequency_max ); PRINT_INFO( frequency_stepsize ); PRINT_INFO( frequency_tolerance ); PRINT_INFO( symbol_rate_min ); PRINT_INFO( symbol_rate_max ); PRINT_INFO( symbol_rate_tolerance ); PRINT_INFO( notifier_delay ); #undef PRINT_INFO if ( i_print_type == PRINT_TEXT ) printf("\ncapability list:\n"); #define PRINT_CAPS( x ) \ do { \ if ( p_ret->info.caps & (FE_##x) ) { \ if ( i_print_type == PRINT_XML ) { \ printf( " <CAPABILITY %s=\"1\"/>\n", STRINGIFY(x) ); \ } else { \ printf( "%s\n", STRINGIFY(x) ); \ } \ } \ } while(0) PRINT_CAPS( IS_STUPID ); PRINT_CAPS( CAN_INVERSION_AUTO ); PRINT_CAPS( CAN_FEC_1_2 ); PRINT_CAPS( CAN_FEC_2_3 ); PRINT_CAPS( CAN_FEC_3_4 ); PRINT_CAPS( CAN_FEC_4_5 ); PRINT_CAPS( CAN_FEC_5_6 ); PRINT_CAPS( CAN_FEC_6_7 ); PRINT_CAPS( CAN_FEC_7_8 ); PRINT_CAPS( CAN_FEC_8_9 ); PRINT_CAPS( CAN_FEC_AUTO ); PRINT_CAPS( CAN_QPSK ); PRINT_CAPS( CAN_QAM_16 ); PRINT_CAPS( CAN_QAM_32 ); PRINT_CAPS( CAN_QAM_64 ); PRINT_CAPS( CAN_QAM_128 ); PRINT_CAPS( CAN_QAM_256 ); PRINT_CAPS( CAN_QAM_AUTO ); PRINT_CAPS( CAN_TRANSMISSION_MODE_AUTO ); PRINT_CAPS( CAN_BANDWIDTH_AUTO ); PRINT_CAPS( CAN_GUARD_INTERVAL_AUTO ); PRINT_CAPS( CAN_HIERARCHY_AUTO ); PRINT_CAPS( CAN_MUTE_TS ); #define DVBAPI_VERSION ((DVB_API_VERSION)*100+(DVB_API_VERSION_MINOR)) #if DVBAPI_VERSION >= 301 PRINT_CAPS( CAN_8VSB ); PRINT_CAPS( CAN_16VSB ); PRINT_CAPS( NEEDS_BENDING ); PRINT_CAPS( CAN_RECOVER ); #endif #if DVBAPI_VERSION >= 500 PRINT_CAPS( HAS_EXTENDED_CAPS ); #endif #if DVBAPI_VERSION >= 501 PRINT_CAPS( CAN_2G_MODULATION ); #endif #undef PRINT_CAPS if ( i_print_type == PRINT_TEXT ) printf("\nstatus:\n"); #define PRINT_STATUS( x ) \ do { \ if ( p_ret->i_status & (FE_##x) ) { \ if ( i_print_type == PRINT_XML ) { \ printf( " <STATUS status=\"%s\"/>\n", STRINGIFY(x) ); \ } else { \ printf( "%s\n", STRINGIFY(x) ); \ } \ } \ } while(0) PRINT_STATUS( HAS_SIGNAL ); PRINT_STATUS( HAS_CARRIER ); PRINT_STATUS( HAS_VITERBI ); PRINT_STATUS( HAS_SYNC ); PRINT_STATUS( HAS_LOCK ); PRINT_STATUS( REINIT ); #undef PRINT_STATUS if ( p_ret->i_status & FE_HAS_LOCK ) { if ( i_print_type == PRINT_XML ) { printf(" <VALUE bit_error_rate=\"%d\"/>\n", p_ret->i_ber); printf(" <VALUE signal_strength=\"%d\"/>\n", p_ret->i_strength); printf(" <VALUE SNR=\"%d\"/>\n", p_ret->i_snr); } else { printf("\nBit error rate: %d\n", p_ret->i_ber); printf("Signal strength: %d\n", p_ret->i_strength); printf("SNR: %d\n", p_ret->i_snr); } ret = 0; } if ( i_print_type == PRINT_XML ) printf("</FRONTEND>\n" ); exit(ret); break; } case RET_MMI_STATUS: { struct ret_mmi_status *p_ret = (struct ret_mmi_status *)&p_buffer[COMM_HEADER_SIZE]; if ( i_size != COMM_HEADER_SIZE + sizeof(struct ret_mmi_status) ) return_error( "Bad MMI status" ); printf("CA interface with %d %s, type:\n", p_ret->caps.slot_num, p_ret->caps.slot_num == 1 ? "slot" : "slots"); #define PRINT_CAPS( x, s ) \ if ( p_ret->caps.slot_type & (CA_##x) ) \ printf(s "\n"); PRINT_CAPS( CI, "CI high level interface" ); PRINT_CAPS( CI_LINK, "CI link layer level interface" ); PRINT_CAPS( CI_PHYS, "CI physical layer level interface (not supported)" ); PRINT_CAPS( DESCR, "built-in descrambler" ); PRINT_CAPS( SC, "simple smartcard interface" ); #undef PRINT_CAPS printf("\n%d available %s\n", p_ret->caps.descr_num, p_ret->caps.descr_num == 1 ? "descrambler (key)" : "descramblers (keys)"); #define PRINT_DESC( x ) \ if ( p_ret->caps.descr_type & (CA_##x) ) \ printf( STRINGIFY(x) "\n" ); PRINT_DESC( ECD ); PRINT_DESC( NDS ); PRINT_DESC( DSS ); #undef PRINT_DESC exit( p_ret->caps.slot_num ); break; } case RET_MMI_SLOT_STATUS: { struct ret_mmi_slot_status *p_ret = (struct ret_mmi_slot_status *)&p_buffer[COMM_HEADER_SIZE]; if ( i_size < COMM_HEADER_SIZE + sizeof(struct ret_mmi_slot_status) ) return_error( "Bad MMI slot status" ); printf("CA slot #%u: ", p_ret->sinfo.num); #define PRINT_TYPE( x, s ) \ if ( p_ret->sinfo.type & (CA_##x) ) \ printf(s); PRINT_TYPE( CI, "high level, " ); PRINT_TYPE( CI_LINK, "link layer level, " ); PRINT_TYPE( CI_PHYS, "physical layer level, " ); #undef PRINT_TYPE if ( p_ret->sinfo.flags & CA_CI_MODULE_READY ) { printf("module present and ready\n"); exit(0); } if ( p_ret->sinfo.flags & CA_CI_MODULE_PRESENT ) printf("module present, not ready\n"); else printf("module not present\n"); exit(1); break; } case RET_MMI_RECV: { struct ret_mmi_recv *p_ret = (struct ret_mmi_recv *)&p_buffer[COMM_HEADER_SIZE]; if ( i_size < COMM_HEADER_SIZE + sizeof(struct ret_mmi_recv) ) return_error( "Bad MMI recv" ); en50221_UnserializeMMIObject( &p_ret->object, i_size - COMM_HEADER_SIZE - ((void *)&p_ret->object - (void *)p_ret) ); switch ( p_ret->object.i_object_type ) { case EN50221_MMI_ENQ: printf("%s\n", p_ret->object.u.enq.psz_text); printf("(empty to cancel)\n"); exit(p_ret->object.u.enq.b_blind ? 253 : 254); break; case EN50221_MMI_MENU: printf("%s\n", p_ret->object.u.menu.psz_title); printf("%s\n", p_ret->object.u.menu.psz_subtitle); printf("0 - Cancel\n"); for ( i = 0; i < p_ret->object.u.menu.i_choices; i++ ) printf("%d - %s\n", i + 1, p_ret->object.u.menu.ppsz_choices[i]); printf("%s\n", p_ret->object.u.menu.psz_bottom); exit(p_ret->object.u.menu.i_choices); break; case EN50221_MMI_LIST: printf("%s\n", p_ret->object.u.menu.psz_title); printf("%s\n", p_ret->object.u.menu.psz_subtitle); for ( i = 0; i < p_ret->object.u.menu.i_choices; i++ ) printf("%s\n", p_ret->object.u.menu.ppsz_choices[i]); printf("%s\n", p_ret->object.u.menu.psz_bottom); printf("(0 to cancel)\n"); exit(0); break; default: return_error( "Unknown MMI object" ); break; } exit(255); break; } default: return_error( "Unknown command answer: %u", c_answer ); } return 0; }
/* ** Main function. */ int main(void) { unsigned int numByteChunks = 0; unsigned char *pBuffer = NULL; unsigned int remainBytes = 0; /* Configure and enable the MMU. */ MMUConfigAndEnable(); /* Enable all levels of Cache. */ CacheEnable(CACHE_ALL); /* Configuring the system clocks for EDMA. */ EDMAModuleClkConfig(); /* Configuring the system clocks for UART0 instance. */ UART0ModuleClkConfig(); /* Performing Pin Multiplexing for UART0 instance. */ UARTPinMuxSetup(0); /* Enabling IRQ in CPSR of ARM processor. */ IntMasterIRQEnable(); /* Initializing the ARM Interrupt Controller. */ IntAINTCInit(); /* Initializing the EDMA. */ EDMA3Initialize(); /* Initializing the UART0 instance for use. */ UARTInitialize(); /* Select the console type based on compile time check */ ConsoleUtilsSetType(CONSOLE_UART); /* ** Configuring the EDMA. */ /* Request DMA Channel and TCC for UART Transmit*/ EDMA3RequestChannel(SOC_EDMA30CC_0_REGS, EDMA3_CHANNEL_TYPE_DMA, EDMA3_UART_TX_CHA_NUM, EDMA3_UART_TX_CHA_NUM, EVT_QUEUE_NUM); /* Registering Callback Function for TX*/ cb_Fxn[EDMA3_UART_TX_CHA_NUM] = &callback; /* Request DMA Channel and TCC for UART Receive */ EDMA3RequestChannel(SOC_EDMA30CC_0_REGS, EDMA3_CHANNEL_TYPE_DMA, EDMA3_UART_RX_CHA_NUM, EDMA3_UART_RX_CHA_NUM, EVT_QUEUE_NUM); /* Registering Callback Function for RX*/ cb_Fxn[EDMA3_UART_RX_CHA_NUM] = &callback; /******************** Transmission of a string **************************/ numByteChunks = (sizeof(welcome) - 1) / txBytesPerEvent; remainBytes = (sizeof(welcome) - 1) % txBytesPerEvent; /* Configuring EDMA PaRAM sets to transmit data. */ UARTTxEDMAPaRAMSetConfig(welcome, numByteChunks * txBytesPerEvent, EDMA3_UART_TX_CHA_NUM, EDMA3CC_OPT(DUMMY_CH_NUM), EDMA3_UART_TX_CHA_NUM); /* Configuring the PaRAM set for Dummy Transfer. */ TxDummyPaRAMConfEnable(); /* Enable EDMA Transfer */ EDMA3EnableTransfer(SOC_EDMA30CC_0_REGS, EDMA3_UART_TX_CHA_NUM, EDMA3_TRIG_MODE_EVENT); /* Wait for return from callback */ while(0 == clBackFlag); clBackFlag = 0; /* Remaining bytes are transferred through polling method. */ if(0 != remainBytes) { pBuffer = welcome + (sizeof(welcome) - 1) - remainBytes; UARTPuts((char*)pBuffer, remainBytes); } /******************** Transmission of a string **************************/ numByteChunks = (sizeof(intent) - 1) / txBytesPerEvent; remainBytes = (sizeof(intent) - 1) % txBytesPerEvent; /* Enabling DMA Mode 1. */ UARTDMAEnable(UART_INSTANCE_BASE_ADD, UART_DMA_MODE_1_ENABLE); /* Configuring EDMA PaRAM sets to transmit data. */ UARTTxEDMAPaRAMSetConfig(intent, numByteChunks * txBytesPerEvent, EDMA3_UART_TX_CHA_NUM, EDMA3CC_OPT(DUMMY_CH_NUM), EDMA3_UART_TX_CHA_NUM); /* Configuring the PaRAM set for Dummy Transfer. */ TxDummyPaRAMConfEnable(); /* Enable EDMA Transfer */ EDMA3EnableTransfer(SOC_EDMA30CC_0_REGS, EDMA3_UART_TX_CHA_NUM, EDMA3_TRIG_MODE_EVENT); /* Wait for return from callback */ while(0 == clBackFlag); clBackFlag = 0; /* Remaining bytes are transferred through polling method. */ if(0 != remainBytes) { pBuffer = intent + (sizeof(intent) - 1) - remainBytes; UARTPuts((char*)pBuffer, remainBytes); } /******************** Transmission of a string **************************/ numByteChunks = (sizeof(enter) - 1) / txBytesPerEvent; remainBytes = (sizeof(enter) - 1) % txBytesPerEvent; /* Enabling DMA Mode 1. */ UARTDMAEnable(UART_INSTANCE_BASE_ADD, UART_DMA_MODE_1_ENABLE); /* Configuring EDMA PaRAM sets to transmit data. */ UARTTxEDMAPaRAMSetConfig(enter, numByteChunks * txBytesPerEvent, EDMA3_UART_TX_CHA_NUM, EDMA3CC_OPT(DUMMY_CH_NUM), EDMA3_UART_TX_CHA_NUM); /* Configuring the PaRAM set for Dummy Transfer. */ TxDummyPaRAMConfEnable(); /* Enable EDMA Transfer */ EDMA3EnableTransfer(SOC_EDMA30CC_0_REGS, EDMA3_UART_TX_CHA_NUM, EDMA3_TRIG_MODE_EVENT); /* Wait for return from callback */ while(0 == clBackFlag); clBackFlag = 0; /* Remaining bytes are transferred through polling method. */ if(0 != remainBytes) { pBuffer = enter + (sizeof(enter) - 1) - remainBytes; UARTPuts((char*)pBuffer, remainBytes); } /********************* Receiving Data from User *************************/ /* Enabling DMA Mode 1. */ UARTDMAEnable(UART_INSTANCE_BASE_ADD, UART_DMA_MODE_1_ENABLE); /* Configuring the PaRAM set for reception. */ UARTRxEDMAPaRAMSetConfig(rxBuffer, NUM_RX_BYTES, EDMA3_UART_RX_CHA_NUM, 0xFFFF, EDMA3_UART_RX_CHA_NUM); /* Enable EDMA Transfer */ EDMA3EnableTransfer(SOC_EDMA30CC_0_REGS, EDMA3_UART_RX_CHA_NUM, EDMA3_TRIG_MODE_EVENT); /* Wait for return from callback */ while(0 == clBackFlag); clBackFlag = 0; /******************* Echoing received bytes *****************************/ numByteChunks = (NUM_RX_BYTES) / txBytesPerEvent; remainBytes = (NUM_RX_BYTES) % txBytesPerEvent; /* Enabling DMA Mode 1. */ UARTDMAEnable(UART_INSTANCE_BASE_ADD, UART_DMA_MODE_1_ENABLE); /* Configuring EDMA PaRAM sets to transmit data. */ UARTTxEDMAPaRAMSetConfig(rxBuffer, numByteChunks * txBytesPerEvent, EDMA3_UART_TX_CHA_NUM, EDMA3CC_OPT(DUMMY_CH_NUM), EDMA3_UART_TX_CHA_NUM); /* Configuring the PaRAM set for Dummy Transfer. */ TxDummyPaRAMConfEnable(); /* Enable EDMA Transfer */ EDMA3EnableTransfer(SOC_EDMA30CC_0_REGS, EDMA3_UART_TX_CHA_NUM, EDMA3_TRIG_MODE_EVENT); /* Wait for return from callback */ while(0 == clBackFlag); clBackFlag = 0; /* Remaining bytes are transferred through polling method. */ if(0 != remainBytes) { pBuffer = rxBuffer + NUM_RX_BYTES - remainBytes; UARTPuts((char*)pBuffer, remainBytes); } /******************* Freeing of allocated channels **********************/ /* Free EDMA3 Channels for TX and RX */ EDMA3FreeChannel(SOC_EDMA30CC_0_REGS, EDMA3_CHANNEL_TYPE_DMA, EDMA3_UART_TX_CHA_NUM, EDMA3_TRIG_MODE_EVENT, EDMA3_UART_TX_CHA_NUM, EVT_QUEUE_NUM); EDMA3FreeChannel(SOC_EDMA30CC_0_REGS, EDMA3_CHANNEL_TYPE_DMA, EDMA3_UART_RX_CHA_NUM, EDMA3_TRIG_MODE_EVENT, EDMA3_UART_RX_CHA_NUM, EVT_QUEUE_NUM); /* Support for Automation Testing. */ PRINT_STATUS(S_PASS); while(1); }
int main(int argc, char * const argv[]) { int ch; int fdr, fdw; off_t t, d, start, len; size_t i, j; int error, state; u_char *buf; u_int sectorsize; off_t stripesize; time_t t1, t2; struct stat sb; u_int n, snapshot = 60; while ((ch = getopt(argc, argv, "b:r:w:s:")) != -1) { switch (ch) { case 'b': bigsize = strtoul(optarg, NULL, 0); break; case 'r': rworklist = strdup(optarg); if (rworklist == NULL) err(1, "Cannot allocate enough memory"); break; case 's': snapshot = strtoul(optarg, NULL, 0); break; case 'w': wworklist = strdup(optarg); if (wworklist == NULL) err(1, "Cannot allocate enough memory"); break; default: usage(); /* NOTREACHED */ } } argc -= optind; argv += optind; if (argc < 1 || argc > 2) usage(); fdr = open(argv[0], O_RDONLY); if (fdr < 0) err(1, "Cannot open read descriptor %s", argv[0]); error = fstat(fdr, &sb); if (error < 0) err(1, "fstat failed"); if (S_ISBLK(sb.st_mode) || S_ISCHR(sb.st_mode)) { error = ioctl(fdr, DIOCGSECTORSIZE, §orsize); if (error < 0) err(1, "DIOCGSECTORSIZE failed"); error = ioctl(fdr, DIOCGSTRIPESIZE, &stripesize); if (error == 0 && stripesize > sectorsize) sectorsize = stripesize; minsize = sectorsize; bigsize = rounddown(bigsize, sectorsize); error = ioctl(fdr, DIOCGMEDIASIZE, &t); if (error < 0) err(1, "DIOCGMEDIASIZE failed"); } else { t = sb.st_size; } if (bigsize < minsize) bigsize = minsize; for (ch = 0; (bigsize >> ch) > minsize; ch++) continue; medsize = bigsize >> (ch / 2); medsize = rounddown(medsize, minsize); fprintf(stderr, "Bigsize = %zu, medsize = %zu, minsize = %zu\n", bigsize, medsize, minsize); buf = malloc(bigsize); if (buf == NULL) err(1, "Cannot allocate %zu bytes buffer", bigsize); if (argc > 1) { fdw = open(argv[1], O_WRONLY | O_CREAT, DEFFILEMODE); if (fdw < 0) err(1, "Cannot open write descriptor %s", argv[1]); if (ftruncate(fdw, t) < 0) err(1, "Cannot truncate output %s to %jd bytes", argv[1], (intmax_t)t); } else fdw = -1; if (rworklist != NULL) { d = read_worklist(t); } else { new_lump(0, t, 0); d = 0; } if (wworklist != NULL) signal(SIGINT, sighandler); t1 = 0; start = len = i = state = 0; PRINT_HEADER; n = 0; for (;;) { lp = TAILQ_FIRST(&lumps); if (lp == NULL) break; while (lp->len > 0 && !aborting) { /* These are only copied for printing stats */ start = lp->start; len = lp->len; state = lp->state; i = MIN(lp->len, (off_t)bigsize); if (lp->state == 1) i = MIN(lp->len, (off_t)medsize); if (lp->state > 1) i = MIN(lp->len, (off_t)minsize); time(&t2); if (t1 != t2 || lp->len < (off_t)bigsize) { PRINT_STATUS(start, i, len, state, d, t); t1 = t2; if (++n == snapshot) { save_worklist(); n = 0; } } if (i == 0) { errx(1, "BOGUS i %10jd", (intmax_t)i); } fflush(stdout); j = pread(fdr, buf, i, lp->start); if (j == i) { d += i; if (fdw >= 0) j = pwrite(fdw, buf, i, lp->start); else j = i; if (j != i) printf("\nWrite error at %jd/%zu\n", lp->start, i); lp->start += i; lp->len -= i; continue; } printf("\n%jd %zu failed (%s)\n", lp->start, i, strerror(errno)); if (errno == EINVAL) { printf("read() size too big? Try with -b 131072"); aborting = 1; } if (errno == ENXIO) aborting = 1; new_lump(lp->start, i, lp->state + 1); lp->start += i; lp->len -= i; } if (aborting) { save_worklist(); return (0); } TAILQ_REMOVE(&lumps, lp, list); free(lp); } PRINT_STATUS(start, i, len, state, d, t); save_worklist(); printf("\nCompleted\n"); return (0); }
int main() { door_sensor door_sensor; window_sensor window_sensor; alarm alarm; spotlight spotlight; std::cout << "Everything's off" << std::endl; PRINT_STATUS(door_sensor); PRINT_STATUS(window_sensor); PRINT_STATUS(alarm); PRINT_STATUS(spotlight); std::cout << "Turn on door sensor" << std::endl; door_sensor = 1; PRINT_STATUS(door_sensor); PRINT_STATUS(window_sensor); std::cout << "Turn on window sensor" << std::endl; window_sensor = 1; PRINT_STATUS(door_sensor); PRINT_STATUS(window_sensor); std::cout << "Turn on alarm" << std::endl; alarm = 1; PRINT_STATUS(alarm); PRINT_STATUS(spotlight); std::cout << "Turn on spotlight" << std::endl; spotlight = 1; PRINT_STATUS(alarm); PRINT_STATUS(spotlight); return 0; }