int main(int argc, char **argv)
{
int ret;
int i, j, k, toread;
FILE *fp_ev;
int fp;
char *trigger_name, *dev_dir_name, *buf_dir_name;
char *data;
size_t read_size;
struct iio_event_data dat;
int dev_num, trig_num;
char *buffer_access, *buffer_event;
const char *iio_dir = "/sys/bus/iio/devices/";
int scan_size;
float gain = 1;
/* Find out which iio device is the accelerometer. */
dev_num = find_type_by_name(device_name, "device");
if (dev_num < 0) {
printf("Failed to find the %s\n", device_name);
ret = -ENODEV;
goto error_ret;
}
printf("iio device number being used is %d\n", dev_num);
asprintf(&dev_dir_name, "%sdevice%d", iio_dir, dev_num);
/*
* Build the trigger name.
* In this case we want the lis3l02dq's data ready trigger
* for this lis3l02dq. The naming is lis3l02dq_dev[n], where
* n matches the device number found above.
*/
ret = asprintf(&trigger_name, "%s%d", trigger_name_base, dev_num);
if (ret < 0) {
ret = -ENOMEM;
goto error_free_dev_dir_name;
}
/*
* Find the trigger by name.
* This is techically unecessary here as we only need to
* refer to the trigger by name and that name is already
* known.
*/
trig_num = find_type_by_name(trigger_name, "trigger");
if (trig_num < 0) {
printf("Failed to find the %s\n", trigger_name);
ret = -ENODEV;
goto error_free_triggername;
}
printf("iio trigger number being used is %d\n", trig_num);
/*
* Read in the scale value - in a more generic case, first
* check for accel_scale, then the indivual channel scales
*/
ret = read_sysfs_float("accel_scale", dev_dir_name, &gain);
if (ret)
goto error_free_triggername;;
/*
* Construct the directory name for the associated buffer.
* As we know that the lis3l02dq has only one buffer this may
* be built rather than found.
*/
ret = asprintf(&buf_dir_name, "%sdevice%d:buffer0", iio_dir, dev_num);
if (ret < 0) {
ret = -ENOMEM;
goto error_free_triggername;
}
/* Set the device trigger to be the data rdy trigger found above */
ret = write_sysfs_string_and_verify("trigger/current_trigger",
dev_dir_name,
trigger_name);
if (ret < 0) {
printf("Failed to write current_trigger file\n");
goto error_free_buf_dir_name;
}
/* Setup ring buffer parameters */
ret = write_sysfs_int("length", buf_dir_name, buf_len);
if (ret < 0)
goto error_free_buf_dir_name;
/* Enable the buffer */
ret = write_sysfs_int("ring_enable", buf_dir_name, 1);
if (ret < 0)
goto error_free_buf_dir_name;
data = malloc(size_from_scanmode(num_vals, scan_ts)*buf_len);
if (!data) {
ret = -ENOMEM;
goto error_free_buf_dir_name;
}
ret = asprintf(&buffer_access,
"/dev/device%d:buffer0:access0",
dev_num);
if (ret < 0) {
ret = -ENOMEM;
goto error_free_data;
}
ret = asprintf(&buffer_event, "/dev/device%d:buffer0:event0", dev_num);
if (ret < 0) {
ret = -ENOMEM;
goto error_free_data;
}
/* Attempt to open non blocking the access dev */
fp = open(buffer_access, O_RDONLY | O_NONBLOCK);
if (fp == -1) { /*If it isn't there make the node */
printf("Failed to open %s\n", buffer_access);
ret = -errno;
goto error_free_buffer_event;
}
/* Attempt to open the event access dev (blocking this time) */
fp_ev = fopen(buffer_event, "rb");
if (fp_ev == NULL) {
printf("Failed to open %s\n", buffer_event);
ret = -errno;
goto error_close_buffer_access;
}
/* Wait for events 10 times */
for (j = 0; j < num_loops; j++) {
read_size = fread(&dat, 1, sizeof(struct iio_event_data),
fp_ev);
switch (dat.id) {
case IIO_EVENT_CODE_RING_100_FULL:
toread = buf_len;
break;
case IIO_EVENT_CODE_RING_75_FULL:
toread = buf_len*3/4;
break;
case IIO_EVENT_CODE_RING_50_FULL:
toread = buf_len/2;
break;
default:
printf("Unexpecteded event code\n");
continue;
}
read_size = read(fp,
data,
toread*size_from_scanmode(num_vals, scan_ts));
if (read_size == -EAGAIN) {
printf("nothing available\n");
continue;
}
scan_size = size_from_scanmode(num_vals, scan_ts);
for (i = 0; i < read_size/scan_size; i++) {
for (k = 0; k < num_vals; k++) {
__s16 val = *(__s16 *)(&data[i*scan_size
+ (k)*2]);
printf("%05f ", (float)val*gain);
}
printf(" %lld\n",
*(__s64 *)(&data[(i + 1)
*size_from_scanmode(num_vals,
scan_ts)
- sizeof(__s64)]));
}
}
/* Stop the ring buffer */
ret = write_sysfs_int("ring_enable", buf_dir_name, 0);
if (ret < 0)
goto error_close_buffer_event;
/* Disconnect from the trigger - just write a dummy name.*/
write_sysfs_string("trigger/current_trigger",
dev_dir_name, "NULL");
error_close_buffer_event:
fclose(fp_ev);
error_close_buffer_access:
close(fp);
error_free_data:
free(data);
error_free_buffer_access:
free(buffer_access);
error_free_buffer_event:
free(buffer_event);
error_free_buf_dir_name:
free(buf_dir_name);
error_free_triggername:
free(trigger_name);
error_free_dev_dir_name:
free(dev_dir_name);
error_ret:
return ret;
}
void __log_csv(const char *test_name, int size, int iteration_max,
int fd, struct tm *tm, const char *dbgfs_entry,
const char *sys_pfx, const char *postfix)
{
char buf[CSV_MAX_LINE];
extern int errno;
int error, fd_dev, len;
float request_avg, latency_avg, latency_gb_avg, throughput_avg;
int request_min, request_max, request_jitter;
int latency_min, latency_max, latency_jitter;
int throughput_min, throughput_max, throughput_jitter;
unsigned int i;
char rx_buf[SYSFS_MAX_INT];
fd_dev = open(dbgfs_entry, O_RDONLY);
if (fd_dev < 0) {
fprintf(stderr, "unable to open specified device %s\n",
dbgfs_entry);
return;
}
/* gather data set */
error = read_sysfs_int(sys_pfx, postfix, "error");
request_min = read_sysfs_int(sys_pfx, postfix, "requests_per_second_min");
request_max = read_sysfs_int(sys_pfx, postfix, "requests_per_second_max");
request_avg = read_sysfs_float(sys_pfx, postfix, "requests_per_second_avg");
latency_min = read_sysfs_int(sys_pfx, postfix, "latency_min");
latency_max = read_sysfs_int(sys_pfx, postfix, "latency_max");
latency_avg = read_sysfs_float(sys_pfx, postfix, "latency_avg");
throughput_min = read_sysfs_int(sys_pfx, postfix, "throughput_min");
throughput_max = read_sysfs_int(sys_pfx, postfix, "throughput_max");
throughput_avg = read_sysfs_float(sys_pfx, postfix, "throughput_avg");
/* derive jitter */
request_jitter = request_max - request_min;
latency_jitter = latency_max - latency_min;
throughput_jitter = throughput_max - throughput_min;
/* append calculated metrics to file */
memset(buf, 0x00, sizeof(buf));
len = snprintf(buf, sizeof(buf), "%u-%u-%u %u:%u:%u,",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
len += snprintf(&buf[len], sizeof(buf) - len,
"%s,%s,%u,%u,%u,%u,%u,%f,%u,%u,%u,%f,%u,%u,%u,%f,%u",
test_name, sys_pfx, size, iteration_max, error,
request_min, request_max, request_avg, request_jitter,
latency_min, latency_max, latency_avg, latency_jitter,
throughput_min, throughput_max, throughput_avg,
throughput_jitter);
write(fd, buf, len);
/* print basic metrics to stdout - requested feature add */
printf("\n%s\n", buf);
/* Write raw latency times to CSV */
for (i = 0; i < iteration_max; i++) {
memset(&rx_buf, 0x00, sizeof(rx_buf));
len = read(fd_dev, rx_buf, sizeof(rx_buf));
if (len < 0) {
fprintf(stderr, "error reading %s %s\n",
dbgfs_entry, strerror(errno));
break;
}
lseek(fd_dev, SEEK_SET, 0);
len = snprintf(buf, sizeof(buf), ",%s", rx_buf);
if (write(fd, buf, len) != len) {
log_csv_error(0, errno);
break;
}
}
if (write(fd, "\n", 1) < 1)
log_csv_error(1, errno);
/* skip printing large set to stdout just close open handles */
close(fd_dev);
}
static int get_results(struct loopback_test *t)
{
struct loopback_device *d;
struct loopback_results *r;
int i;
for (i = 0; i < t->device_count; i++) {
if (!device_enabled(t, i))
continue;
d = &t->devices[i];
r = &d->results;
r->error = read_sysfs_int(d->sysfs_entry, "error");
r->request_min = read_sysfs_int(d->sysfs_entry, "requests_per_second_min");
r->request_max = read_sysfs_int(d->sysfs_entry, "requests_per_second_max");
r->request_avg = read_sysfs_float(d->sysfs_entry, "requests_per_second_avg");
r->latency_min = read_sysfs_int(d->sysfs_entry, "latency_min");
r->latency_max = read_sysfs_int(d->sysfs_entry, "latency_max");
r->latency_avg = read_sysfs_float(d->sysfs_entry, "latency_avg");
r->throughput_min = read_sysfs_int(d->sysfs_entry, "throughput_min");
r->throughput_max = read_sysfs_int(d->sysfs_entry, "throughput_max");
r->throughput_avg = read_sysfs_float(d->sysfs_entry, "throughput_avg");
r->apbridge_unipro_latency_min =
read_sysfs_int(d->sysfs_entry, "apbridge_unipro_latency_min");
r->apbridge_unipro_latency_max =
read_sysfs_int(d->sysfs_entry, "apbridge_unipro_latency_max");
r->apbridge_unipro_latency_avg =
read_sysfs_float(d->sysfs_entry, "apbridge_unipro_latency_avg");
r->gbphy_firmware_latency_min =
read_sysfs_int(d->sysfs_entry, "gbphy_firmware_latency_min");
r->gbphy_firmware_latency_max =
read_sysfs_int(d->sysfs_entry, "gbphy_firmware_latency_max");
r->gbphy_firmware_latency_avg =
read_sysfs_float(d->sysfs_entry, "gbphy_firmware_latency_avg");
r->request_jitter = r->request_max - r->request_min;
r->latency_jitter = r->latency_max - r->latency_min;
r->throughput_jitter = r->throughput_max - r->throughput_min;
r->apbridge_unipro_latency_jitter =
r->apbridge_unipro_latency_max - r->apbridge_unipro_latency_min;
r->gbphy_firmware_latency_jitter =
r->gbphy_firmware_latency_max - r->gbphy_firmware_latency_min;
}
/*calculate the aggregate results of all enabled devices */
if (t->aggregate_output) {
r = &t->aggregate_results;
r->request_min = get_request_min_aggregate(t);
r->request_max = get_request_max_aggregate(t);
r->request_avg = get_request_avg_aggregate(t);
r->latency_min = get_latency_min_aggregate(t);
r->latency_max = get_latency_max_aggregate(t);
r->latency_avg = get_latency_avg_aggregate(t);
r->throughput_min = get_throughput_min_aggregate(t);
r->throughput_max = get_throughput_max_aggregate(t);
r->throughput_avg = get_throughput_avg_aggregate(t);
r->apbridge_unipro_latency_min =
get_apbridge_unipro_latency_min_aggregate(t);
r->apbridge_unipro_latency_max =
get_apbridge_unipro_latency_max_aggregate(t);
r->apbridge_unipro_latency_avg =
get_apbridge_unipro_latency_avg_aggregate(t);
r->gbphy_firmware_latency_min =
get_gbphy_firmware_latency_min_aggregate(t);
r->gbphy_firmware_latency_max =
get_gbphy_firmware_latency_max_aggregate(t);
r->gbphy_firmware_latency_avg =
get_gbphy_firmware_latency_avg_aggregate(t);
r->request_jitter = r->request_max - r->request_min;
r->latency_jitter = r->latency_max - r->latency_min;
r->throughput_jitter = r->throughput_max - r->throughput_min;
r->apbridge_unipro_latency_jitter =
r->apbridge_unipro_latency_max - r->apbridge_unipro_latency_min;
r->gbphy_firmware_latency_jitter =
r->gbphy_firmware_latency_max - r->gbphy_firmware_latency_min;
}
return 0;
}
