/*
* A simple program to test the System Timer driver
******************************************************************************
*/
int main (int argc, char* argv[])
{
/* */
unsigned int read_value ;
const char *files[] = {"/dev/CS", "/dev/CLO", "/dev/CHI", "/dev/C0", "/dev/C1", "/dev/C2", "/dev/C3"} ;
const unsigned int file_count = sizeof (files) / sizeof (char*) ;
/* */
if (argv[1] == NULL)
{
print_syntax () ;
exit (1) ;
}
if (strcmp(argv[1], "all") == 0)
{
for (int index = 0 ; index < file_count ; index++)
for (int repeat = 1 ; repeat <= 1 ; repeat++)
read_from_device (files[index], &read_value) ;
} // if
/* */
else
{
int index = atoi(argv[1]) ;
read_from_device (files[index], &read_value) ;
}
/* Program exists cleanly */
return 0 ;
} //main
//------------------------------------------------
// Runs in every device tomb raider thread,
// executes continuous large-block reads.
//
static void*
run_tomb_raider(void* pv_dev)
{
device* dev = (device*)pv_dev;
uint8_t* buf = act_valloc(g_scfg.large_block_ops_bytes);
if (! buf) {
fprintf(stdout, "ERROR: tomb raider buffer act_valloc()\n");
g_running = false;
return NULL;
}
uint64_t offset = 0;
uint64_t end = dev->n_large_blocks * g_scfg.large_block_ops_bytes;
while (g_running) {
if (g_scfg.tomb_raider_sleep_us != 0) {
usleep(g_scfg.tomb_raider_sleep_us);
}
read_from_device(dev, offset, g_scfg.large_block_ops_bytes, buf);
offset += g_scfg.large_block_ops_bytes;
if (offset == end) {
offset = 0;
}
}
free(buf);
return NULL;
}
//------------------------------------------------
// Do one large block read operation and report.
//
static void read_and_report_large_block(device* p_device) {
uint64_t offset = random_large_block_offset(p_device);
uint64_t start_time = cf_getus();
uint64_t stop_time = read_from_device(p_device, offset,
g_large_block_ops_bytes, p_device->p_large_block_read_buffer);
if (stop_time != -1) {
histogram_insert_data_point(g_p_large_block_read_histogram,
safe_delta_us(start_time, stop_time));
}
}
//------------------------------------------------
// Do one large block read operation and report.
//
static void
read_and_report_large_block(device* dev, uint8_t* buf)
{
uint64_t offset = random_large_block_offset(dev);
uint64_t start_time = get_ns();
uint64_t stop_time = read_from_device(dev, offset,
g_scfg.large_block_ops_bytes, buf);
if (stop_time != -1) {
histogram_insert_data_point(g_large_block_read_hist,
safe_delta_ns(start_time, stop_time));
}
}
//------------------------------------------------
// Do one transaction read operation and report.
//
static void read_and_report(readreq* p_readreq, uint8_t* p_buffer) {
uint64_t raw_start_time = cf_getus();
uint64_t stop_time = read_from_device(p_readreq->p_device,
p_readreq->offset, p_readreq->size, p_buffer);
if (stop_time != -1) {
histogram_insert_data_point(g_p_raw_read_histogram,
safe_delta_us(raw_start_time, stop_time));
histogram_insert_data_point(g_p_read_histogram,
safe_delta_us(p_readreq->start_time, stop_time));
histogram_insert_data_point(
p_readreq->p_device->p_raw_read_histogram,
safe_delta_us(raw_start_time, stop_time));
}
}
//------------------------------------------------
//
//
static void prep_to_sector_div(uint64_t offset, uint32_t division, void* dest, char* message, uint32_t write_size){
if (! read_from_device(g_device, offset, g_device->read_bytes, dest)){
printf("=> ERROR read op. PREP_TO_SECTOR. Offset: %" PRIu64 "\n", offset);
return;
}
else{
int i, sector_div = g_device->read_bytes/g_ref_tab_columns;
memset(dest+(sector_div*division), '\0', sector_div);
if (write_size > 0 && write_size < sector_div){
strncpy(dest+(sector_div*division), message, write_size);
}else if(write_size >= sector_div)
{strncpy(dest+(sector_div*division), message, sector_div - 1);}
}
}
//------------------------------------------------
// Do one transaction read operation and report.
//
static void
read_and_report(trans_req* read_req, uint8_t* buf)
{
uint64_t raw_start_time = get_ns();
uint64_t stop_time = read_from_device(read_req->dev, read_req->offset,
read_req->size, buf);
if (stop_time != -1) {
histogram_insert_data_point(g_raw_read_hist,
safe_delta_ns(raw_start_time, stop_time));
histogram_insert_data_point(g_read_hist,
safe_delta_ns(read_req->start_time, stop_time));
histogram_insert_data_point(read_req->dev->raw_read_hist,
safe_delta_ns(raw_start_time, stop_time));
}
}
//--------------------------------------------------------------------------
main() {
int job, flag = 0;
if ((fd = open_device()) == -1) {
printf("\ncan not open device ...\n");
exit(1);
}
while (1) {
system ("clear");
printf("\n\n << This is an application to use device driver >>\n");
printf("\n\n\n1) read data\n");
printf("2) write data\n");
printf("3) exit\n");
printf("\n\nselect (1-3) : ");
scanf("%d", &job);
switch (job) {
case 1:
read_from_device();
break;
case 2:
write_to_device();
break;
case 3:
flag = 1;
break;
default:
printf("\nwrong number ...\n");
}
if (flag == 1) break;
printf("\n\n\npress ENTER to continue ...\n");
getchar();
getchar();
}
close (fd);
}
//------------------------------------------------
// Read from sub_sectors function for JNA
//
char* readJNA(uint64_t division, uint32_t read_size){
int sector_div = g_device->read_bytes/g_ref_tab_columns;
char* message = cf_valloc(sector_div);
void* p_buffer = cf_valloc(g_device->read_bytes);
if (! p_buffer) {
printf("=> ERROR: read buffer cf_valloc()\n");
return NULL;
}
uint64_t offset = division / g_ref_tab_columns;
offset = (offset % g_device->num_read_offsets) * g_device->min_op_bytes;
if(! is_sector_free(offset/g_device->read_bytes, division % g_ref_tab_columns)){
if (! read_from_device(g_device, offset, g_device->read_bytes, p_buffer)){
printf("=> ERROR read op on offset: %" PRIu64 "\n", offset);
free(p_buffer);
free(message);
return NULL;
}else{
memset(message, '\0', sizeof(message));
if (read_size > 0 && read_size < sector_div){
strncpy(message, p_buffer+(sector_div*(division % g_ref_tab_columns)), read_size);
}else if(read_size >= sector_div){
strncpy(message, p_buffer+(sector_div*(division % g_ref_tab_columns)), sector_div-1);
}
// printf("readSize = %"PRIu32"\n", read_size);
printf("Message = %s\n", message);
}
}else{
printf("=> Sector NOT referenced!\n");
}
free(p_buffer);
free(message);
return message;
}
/*
* A simple program to test the System Timer driver
******************************************************************************
*/
int main (int argc, char* argv[])
{
/* */
unsigned int read_value ;
unsigned int write_value = 0 ;
const char *files[] = {"/dev/CS", "/dev/CLO", "/dev/CHI", "/dev/C0", "/dev/C1", "/dev/C2", "/dev/C3"} ;
//const unsigned int file_count = sizeof (files) / sizeof (char*) ;
/* */
if (argv[1] == NULL)
{
print_syntax () ;
exit (1) ;
}
/* */
piHiPri (100) ;
/* */
unsigned int interval ;
sscanf (argv[1], "%u", &interval) ;
/* */
read_from_device (files[1], &read_value) ;
write_value = (read_value / 10000000 + 1) * 10000000 ;
write_to_device (files[4], &write_value) ;
/* */
sigset_t block_mask, oldmask ;
/* Set up the mask of signals to temporarily block. */
sigemptyset (&block_mask) ;
sigaddset (&block_mask, SIGUSR1) ;
sigaddset (&block_mask, SIGUSR2) ;
/* */
struct sigaction action ;
/* Establish the signal handler. */
action.sa_handler = signal_handler ;
action.sa_mask = block_mask ;
action.sa_flags = 0 ;
/* */
sigaction (SIGUSR1, &action, NULL) ;
sigaction (SIGUSR2, &action, NULL) ;
/* */
sigprocmask (SIG_BLOCK, &block_mask, &oldmask) ;
/* Wait for a signal to arrive. */
while (1)
sigsuspend (&oldmask) ;
/* */
sigprocmask (SIG_UNBLOCK, &block_mask, NULL) ;
/* Program exists cleanly */
return 0 ;
} //main
