unsigned r2, n2, p;
wrpll_compute_rnp(ref->clock, &r2, &n2, &p);
- if (ref->r2 != r2 || ref->n2 != n2 || ref->p != p) {
- printf("Computed value differs for %li Hz:\n"
- " Reference: (%u,%u,%u)\n"
- " Computed: (%u,%u,%u)\n",
- (int64_t)ref->clock * 1000,
- ref->r2, ref->n2, ref->p,
- r2, n2, p);
-
- abort();
- }
+ igt_fail_on_f(ref->r2 != r2 || ref->n2 != n2 || ref->p != p,
+ "Computed value differs for %li Hz:\n"" Reference: (%u,%u,%u)\n"" Computed: (%u,%u,%u)\n", (int64_t)ref->clock * 1000, ref->r2, ref->n2, ref->p, r2, n2, p);
}
return 0;
read_dfs(fname, tmp, l + 1);
if (!inverse) {
- if (strncmp(tmp, s, l) != 0) {
- fprintf(stderr, "contents of %s: '%s' (expected '%s')\n",
- fname, tmp, s);
- igt_fail(1);
- }
+ igt_fail_on_f(strncmp(tmp, s, l) != 0,
+ "contents of %s: '%s' (expected '%s')\n", fname, tmp, s);
} else {
- if (strncmp(tmp, s, l) == 0) {
- fprintf(stderr, "contents of %s: '%s' (expected not '%s'\n",
- fname, tmp, s);
- igt_fail(1);
- }
+ igt_fail_on_f(strncmp(tmp, s, l) == 0,
+ "contents of %s: '%s' (expected not '%s'\n", fname, tmp, s);
}
}
&execbuf));
gem_close(fd, gem_exec[1].handle);
- printf("Found offset %ld for 4k batch\n", (long)gem_exec[0].offset);
+ igt_info("Found offset %ld for 4k batch\n", (long)gem_exec[0].offset);
igt_require(gem_exec[0].offset < BIAS);
memset(gem_reloc, 0, sizeof(gem_reloc));
DRM_IOCTL_I915_GEM_EXECBUFFER2,
&execbuf));
- printf("Batch is now at offset %ld\n", (long)gem_exec[0].offset);
+ igt_info("Batch is now at offset %ld\n", (long)gem_exec[0].offset);
gem_read(fd, gem_exec[0].handle, 0, buf, sizeof(buf));
gem_close(fd, gem_exec[0].handle);
gettimeofday(&end, NULL);
linear[count != 2] = count * loop / elapsed(&start, &end);
- printf("Upload rate for %d linear surfaces: %7.3fMiB/s\n",
- count, linear[count != 2]);
+ igt_info("Upload rate for %d linear surfaces: %7.3fMiB/s\n", count, linear[count != 2]);
for (n = 0; n < count; n++)
gem_set_tiling(fd, handle[n], I915_TILING_X, 1024);
gettimeofday(&end, NULL);
tiled[count != 2] = count * loop / elapsed(&start, &end);
- printf("Upload rate for %d tiled surfaces: %7.3fMiB/s\n",
- count, tiled[count != 2]);
+ igt_info("Upload rate for %d tiled surfaces: %7.3fMiB/s\n", count, tiled[count != 2]);
for (n = 0; n < count; n++) {
munmap(ptr[n], OBJECT_SIZE);
gettimeofday(&end, NULL);
linear[count != 2] = nthreads * loops / elapsed(&start, &end) / (OBJECT_SIZE / 4096);
- printf("%s rate for %d linear surfaces, %d threads: %7.3fMiB/s\n",
- direction_string(mask), count, nthreads, linear[count != 2]);
+ igt_info("%s rate for %d linear surfaces, %d threads: %7.3fMiB/s\n", direction_string(mask), count, nthreads, linear[count != 2]);
for (n = 0; n < count; n++)
gem_set_tiling(fd, handle[n], I915_TILING_X, 1024);
gettimeofday(&end, NULL);
tiled[count != 2] = nthreads * loops / elapsed(&start, &end) / (OBJECT_SIZE / 4096);
- printf("%s rate for %d tiled surfaces, %d threads: %7.3fMiB/s\n",
- direction_string(mask), count, nthreads, tiled[count != 2]);
+ igt_info("%s rate for %d tiled surfaces, %d threads: %7.3fMiB/s\n", direction_string(mask), count, nthreads, tiled[count != 2]);
for (n = 0; n < count; n++) {
munmap(ptr[n], OBJECT_SIZE);
gettimeofday(&end, NULL);
linear[count != 2] = count * loops / elapsed(&start, &end) / (OBJECT_SIZE / 4096);
- printf("Contended upload rate for %d threads: %7.3fMiB/s\n",
- count, linear[count != 2]);
+ igt_info("Contended upload rate for %d threads: %7.3fMiB/s\n", count, linear[count != 2]);
for (n = 0; n < count; n++)
gem_set_tiling(fd, threads[n].handle, I915_TILING_X, 1024);
gettimeofday(&end, NULL);
tiled[count != 2] = count * loops / elapsed(&start, &end) / (OBJECT_SIZE / 4096);
- printf("Contended upload rate for %d threads: %7.3fMiB/s\n",
- count, tiled[count != 2]);
+ igt_info("Contended upload rate for %d threads: %7.3fMiB/s\n", count, tiled[count != 2]);
for (n = 0; n < count; n++) {
gem_close(fd, threads[n].handle);
struct local_drm_i915_reg_read reg_read;
reg_read.offset = 0x2358;
- if (drmIoctl(fd, REG_READ_IOCTL, ®_read)) {
- perror("positive test case failed: ");
- igt_fail(1);
- }
+ igt_fail_on_f(drmIoctl(fd, REG_READ_IOCTL, ®_read),
+ "positive test case failed: ");
return reg_read.val;
}
if (count == 0)
count = 3 * gem_aperture_size(fd) / SIZE / 2;
else if (count < 2) {
- fprintf(stderr, "count must be >= 2\n");
+ igt_warn("count must be >= 2\n");
return 1;
}
if (count == 0)
count = 3 * gem_aperture_size(fd) / SIZE / 2;
else if (count < 2) {
- fprintf(stderr, "count must be >= 2\n");
+ igt_warn("count must be >= 2\n");
return 1;
}
bo_check(data, b, 0xc);
break;
default:
- abort();
+ igt_fail(1);
}
r1_ops->busy_fini(data);
intel_batchbuffer_flush(batch_3d);
} else {
if (!warned) {
- printf("No render copy found for this gen, "
- "test is shallow!\n");
+ igt_info("No render copy found for this gen, ""test is shallow!\n");
warned = 1;
}
igt_assert(dst->bo);
int i;
r = wordexp(s, &wexp, 0);
if (r != 0) {
- printf("can't parse %s\n", s);
+ igt_info("can't parse %s\n", s);
return r;
}
for(i = 0; i < wexp.we_wordc; i++)
- printf("argv[%d] = %s\n", i, wexp.we_wordv[i]);
+ igt_info("argv[%d] = %s\n", i, wexp.we_wordv[i]);
pid = fork();
char path[PATH_MAX];
char full_path[PATH_MAX];
- if (getcwd(path, PATH_MAX) == NULL)
- perror("getcwd");
+ igt_warn_on_f(getcwd(path, PATH_MAX) == NULL, "getcwd");
igt_assert(snprintf(full_path, PATH_MAX, "%s/%s", path, wexp.we_wordv[0]) > 0);
r = execv(full_path, wexp.we_wordv);
- if (r == -1)
- perror("execv failed");
+ igt_warn_on_f(r == -1, "execv failed");
} else {
int waitcount = options.timeout;
r = waitpid(pid, &status, WNOHANG);
if (r == pid) {
if(WIFEXITED(status)) {
- if (WEXITSTATUS(status))
- fprintf(stderr,
- "child returned with %d\n",
- WEXITSTATUS(status));
+ igt_warn_on_f(WEXITSTATUS(status),
+ "child returned with %d\n", WEXITSTATUS(status));
return WEXITSTATUS(status);
}
} else if (r != 0) {
- perror("waitpid");
+ igt_warn("waitpid");
return -errno;
}
r = read(fh, buf, sizeof(buf) - 1);
close(fh);
if (r < 0) {
- perror("read");
+ igt_warn("read");
return -errno;
}
errno = 0;
tmp = strtoul(p, NULL, 0);
if (tmp == ULONG_MAX && errno) {
- perror("strtoul");
+ igt_warn("strtoul");
return -errno;
}
return r;
if (rb != seqno) {
- printf("seqno readback differs rb:0x%x vs w:0x%x\n", rb, seqno);
+ igt_info("seqno readback differs rb:0x%x vs w:0x%x\n", rb, seqno);
return -1;
}
static void print_usage(const char *s)
{
- printf("%s: [OPTION]...\n", s);
- printf(" where options are:\n");
- printf(" -b --background run in background inducing wraps\n");
- printf(" -c --cmd=cmdstring use cmdstring to cross wrap\n");
- printf(" -n --rounds=num run num times across wrap boundary, 0 == forever\n");
- printf(" -t --timeout=sec set timeout to wait for testrun to sec seconds\n");
- printf(" -d --dontwrap don't wrap just run the test\n");
- printf(" -p --prewrap=n set seqno to WRAP - n for each testrun\n");
- printf(" -r --norandom dont randomize prewrap space\n");
- printf(" -i --buffers number of buffers to copy\n");
+ igt_info("%s: [OPTION]...\n", s);
+ igt_info(" where options are:\n");
+ igt_info(" -b --background run in background inducing wraps\n");
+ igt_info(" -c --cmd=cmdstring use cmdstring to cross wrap\n");
+ igt_info(" -n --rounds=num run num times across wrap boundary, 0 == forever\n");
+ igt_info(" -t --timeout=sec set timeout to wait for testrun to sec seconds\n");
+ igt_info(" -d --dontwrap don't wrap just run the test\n");
+ igt_info(" -p --prewrap=n set seqno to WRAP - n for each testrun\n");
+ igt_info(" -r --norandom dont randomize prewrap space\n");
+ igt_info(" -i --buffers number of buffers to copy\n");
igt_fail(-1);
}
switch(c) {
case 'b':
options.background = 1;
- printf("running in background inducing wraps\n");
+ igt_info("running in background inducing wraps\n");
break;
case 'd':
options.dontwrap = 1;
- printf("won't wrap after testruns\n");
+ igt_info("won't wrap after testruns\n");
break;
case 'n':
options.rounds = atoi(optarg);
- printf("running %d rounds\n", options.rounds);
+ igt_info("running %d rounds\n", options.rounds);
break;
case 'c':
strncpy(options.cmd, optarg, sizeof(options.cmd) - 1);
options.cmd[sizeof(options.cmd) - 1] = 0;
- printf("cmd set to %s\n", options.cmd);
+ igt_info("cmd set to %s\n", options.cmd);
break;
case 'i':
options.buffers = atoi(optarg);
- printf("buffers %d\n", options.buffers);
+ igt_info("buffers %d\n", options.buffers);
break;
case 't':
options.timeout = atoi(optarg);
if (options.timeout == 0)
options.timeout = 10;
- printf("setting timeout to %d seconds\n",
- options.timeout);
+ igt_info("setting timeout to %d seconds\n", options.timeout);
break;
case 'r':
options.random = 0;
break;
case 'p':
options.prewrap_space = atoi(optarg);
- printf("prewrap set to %d (0x%x)\n",
- options.prewrap_space, UINT32_MAX -
- options.prewrap_space);
+ igt_info("prewrap set to %d (0x%x)\n", options.prewrap_space, UINT32_MAX - options.prewrap_space);
break;
default:
- printf("unkown command options\n");
+ igt_info("unkown command options\n");
print_usage(argv[0]);
break;
}
}
if (optind < argc) {
- printf("unkown command options\n");
+ igt_info("unkown command options\n");
print_usage(argv[0]);
}
}
+ i*options.tile_size + j;
uint32_t tmp = src[src_ofs];
if (tmp != expect) {
- printf("mismatch at tile %i pos %i, read %i, expected %i, diff %i\n",
- logical_tile_no, i*options.tile_size + j, tmp, expect, (int) tmp - expect);
- if (options.trace_tile >= 0 && options.fail)
- igt_fail(1);
+ igt_info("mismatch at tile %i pos %i, read %i, expected %i, diff %i\n", logical_tile_no, i * options.tile_size + j, tmp, expect, (int)tmp - expect);
+ igt_fail_on(options.trace_tile >= 0 && options.fail);
failed++;
}
/* when not aborting, correct any errors */
dst[dst_ofs] = expect;
}
}
- if (failed && options.fail)
- igt_fail(1);
+ igt_fail_on(failed && options.fail);
if (failed > stats.max_failed_reads)
stats.max_failed_reads = failed;
{
if (fence_storm) {
if (tile == options.trace_tile)
- printf(" using fence storm\n");
+ igt_info(" using fence storm\n");
return;
}
if (copyfunc_seq % 61 == 0
&& options.forced_tiling != I915_TILING_NONE) {
if (tile == options.trace_tile)
- printf(" using fence storm\n");
+ igt_info(" using fence storm\n");
fence_storm = num_fences;
copyfunc = blitter_copyfunc;
} else if (copyfunc_seq % 17 == 0) {
if (tile == options.trace_tile)
- printf(" using cpu\n");
+ igt_info(" using cpu\n");
copyfunc = cpu_copyfunc;
} else if (copyfunc_seq % 19 == 0) {
if (tile == options.trace_tile)
- printf(" using prw\n");
+ igt_info(" using prw\n");
copyfunc = prw_copyfunc;
} else if (copyfunc_seq % 3 == 0 && options.use_render) {
if (tile == options.trace_tile)
- printf(" using render\n");
+ igt_info(" using render\n");
copyfunc = render_copyfunc;
} else if (options.use_blt){
if (tile == options.trace_tile)
- printf(" using blitter\n");
+ igt_info(" using blitter\n");
copyfunc = blitter_copyfunc;
} else if (options.use_render){
if (tile == options.trace_tile)
- printf(" using render\n");
+ igt_info(" using render\n");
copyfunc = render_copyfunc;
} else {
copyfunc = cpu_copyfunc;
buffers[set][i].stride);
if (options.trace_tile != -1 && i == options.trace_tile/options.tiles_per_buf)
- printf("changing buffer %i containing tile %i: tiling %i, stride %i\n", i,
- options.trace_tile,
- buffers[set][i].tiling, buffers[set][i].stride);
+ igt_info("changing buffer %i containing tile %i: tiling %i, stride %i\n", i, options.trace_tile, buffers[set][i].tiling, buffers[set][i].stride);
}
}
tile2xy(dst_buf, dst_tile, &dst_x, &dst_y);
if (options.trace_tile == i)
- printf("copying tile %i from %i (%i, %i) to %i (%i, %i)", i,
- tile_permutation[i], src_buf_idx, src_tile,
- permutation[idx], dst_buf_idx, dst_tile);
+ igt_info("copying tile %i from %i (%i, %i) to %i (%i, %i)", i, tile_permutation[i], src_buf_idx, src_tile, permutation[idx], dst_buf_idx, dst_tile);
if (options.no_hw) {
cpucpy2d(src_buf->data,
switch(c) {
case 'd':
options.no_hw = 1;
- printf("no-hw debug mode\n");
+ igt_info("no-hw debug mode\n");
break;
case 'S':
options.use_signal_helper = 0;
- printf("disabling that pesky nuisance who keeps interrupting us\n");
+ igt_info("disabling that pesky nuisance who keeps interrupting us\n");
break;
case 's':
tmp = atoi(optarg);
if (tmp < options.tile_size*8192)
- printf("scratch buffer size needs to be at least %i\n",
- options.tile_size*8192);
+ igt_info("scratch buffer size needs to be at least %i\n", options.tile_size * 8192);
else if (tmp & (tmp - 1)) {
- printf("scratch buffer size needs to be a power-of-two\n");
+ igt_info("scratch buffer size needs to be a power-of-two\n");
} else {
- printf("fixed scratch buffer size to %u\n", tmp);
+ igt_info("fixed scratch buffer size to %u\n", tmp);
options.scratch_buf_size = tmp;
sanitize_tiles_per_buf();
}
case 'g':
tmp = atoi(optarg);
if (tmp < 0 || tmp > 10)
- printf("gpu busy load needs to be bigger than 0 and smaller than 10\n");
+ igt_info("gpu busy load needs to be bigger than 0 and smaller than 10\n");
else {
- printf("gpu busy load factor set to %i\n", tmp);
+ igt_info("gpu busy load factor set to %i\n", tmp);
gpu_busy_load = options.gpu_busy_load = tmp;
}
break;
case 'c':
options.num_buffers = atoi(optarg);
- printf("buffer count set to %i\n", options.num_buffers);
+ igt_info("buffer count set to %i\n", options.num_buffers);
break;
case 't':
options.trace_tile = atoi(optarg);
- printf("tracing tile %i\n", options.trace_tile);
+ igt_info("tracing tile %i\n", options.trace_tile);
break;
case 'r':
options.use_render = 0;
- printf("disabling render copy\n");
+ igt_info("disabling render copy\n");
break;
case 'b':
options.use_blt = 0;
- printf("disabling blt copy\n");
+ igt_info("disabling blt copy\n");
break;
case 'u':
options.forced_tiling = I915_TILING_NONE;
- printf("disabling tiling\n");
+ igt_info("disabling tiling\n");
break;
case 'x':
if (options.use_cpu_maps) {
- printf("tiling not possible with cpu maps\n");
+ igt_info("tiling not possible with cpu maps\n");
} else {
options.forced_tiling = I915_TILING_X;
- printf("using only X-tiling\n");
+ igt_info("using only X-tiling\n");
}
break;
case 'm':
options.use_cpu_maps = 1;
options.forced_tiling = I915_TILING_NONE;
- printf("disabling tiling\n");
+ igt_info("disabling tiling\n");
break;
case 'o':
options.total_rounds = atoi(optarg);
- printf("total rounds %i\n", options.total_rounds);
+ igt_info("total rounds %i\n", options.total_rounds);
break;
case 'f':
options.fail = 0;
- printf("not failing when detecting errors\n");
+ igt_info("not failing when detecting errors\n");
break;
case 'p':
options.tiles_per_buf = atoi(optarg);
- printf("tiles per buffer %i\n", options.tiles_per_buf);
+ igt_info("tiles per buffer %i\n", options.tiles_per_buf);
break;
case DUCTAPE:
options.ducttape = 0;
- printf("applying duct-tape\n");
+ igt_info("applying duct-tape\n");
break;
case TILESZ:
options.tile_size = atoi(optarg);
sanitize_tiles_per_buf();
- printf("til size %i\n", options.tile_size);
+ igt_info("til size %i\n", options.tile_size);
break;
case CHCK_RENDER:
options.check_render_cpyfn = 1;
- printf("checking render copy function\n");
+ igt_info("checking render copy function\n");
break;
default:
- printf("unkown command options\n");
+ igt_info("unkown command options\n");
break;
}
}
if (optind < argc)
- printf("unkown command options\n");
+ igt_info("unkown command options\n");
/* actually 32767, according to docs, but that kills our nice pot calculations. */
options.max_dimension = 16*1024;
else
options.max_dimension = 8192;
}
- printf("Limiting buffer to %dx%d\n",
- options.max_dimension, options.max_dimension);
+ igt_info("Limiting buffer to %dx%d\n", options.max_dimension, options.max_dimension);
}
static void init(void)
tmp = tmp > 256*(1024*1024) ? 256*(1024*1024) : tmp;
num_buffers = 2 * tmp / options.scratch_buf_size / 3;
num_buffers /= 2;
- printf("using %u buffers\n", num_buffers);
+ igt_info("using %u buffers\n", num_buffers);
} else
num_buffers = options.num_buffers;
ptr = (uint32_t*)((char *)dst.data + dx*4 + (dy+j) * dst.stride);
for (i = 0; i < options.tile_size; i++)
if (ptr[i] != j * options.tile_size + i) {
- printf("render copyfunc mismatch at (%d, %d): found %d, expected %d\n",
- i, j, ptr[i], j*options.tile_size + i);
+ igt_info("render copyfunc mismatch at (%d, %d): found %d, expected %d\n", i, j, ptr[i], j * options.tile_size + i);
}
}
}
fan_out();
for (i = 0; i < options.total_rounds; i++) {
- printf("round %i\n", i);
+ igt_info("round %i\n", i);
if (i % 64 == 63) {
fan_in_and_check();
- printf("everything correct after %i rounds\n", i + 1);
+ igt_info("everything correct after %i rounds\n", i + 1);
}
target_set = (current_set + 1) & 1;
fan_in_and_check();
- fprintf(stdout, "num failed tiles %u, max incoherent bytes %zd\n",
- stats.num_failed, stats.max_failed_reads*sizeof(uint32_t));
+ igt_info("num failed tiles %u, max incoherent bytes %zd\n", stats.num_failed, stats.max_failed_reads * sizeof(uint32_t));
intel_batchbuffer_free(batch);
drm_intel_bufmgr_destroy(bufmgr);
igt_plane_set_fb(primary, &fb[!(i&1)]);
igt_display_commit(display);
- printf(".");
+ igt_info(".");
fflush(stdout);
}
igt_remove_fb(data->drm_fd, &fb[1]);
igt_remove_fb(data->drm_fd, &fb[0]);
- printf("\n");
+ igt_info("\n");
return true;
}
igt_require(file);
ret = fscanf(file, "Sink_Support: %s\n", str);
- if (ret == 0)
- igt_skip("i915_edp_psr_status format not supported by this test case\n");
+ igt_skip_on_f(ret == 0,
+ "i915_edp_psr_status format not supported by this test case\n");
fclose(file);
return strcmp(str, "yes") == 0;
ptr = gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
gem_set_domain(data->drm_fd, handle,
I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
- fprintf(stdout, "Sleeping for 10 sec...\n");
+ igt_info("Sleeping for 10 sec...\n");
sleep(10);
memset(ptr, 0xff, 4);
munmap(ptr, 4096);
ptr = gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
gem_set_domain(data->drm_fd, handle,
I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
- fprintf(stdout, "Sleeping for 10 sec...\n");
+ igt_info("Sleeping for 10 sec...\n");
sleep(10);
fill_blt(data, handle, 0xff);
igt_assert(wait_psr_entry(data, 10));
get_sink_crc(data, ref_crc);
- fprintf(stdout, "Sleeping for 10 sec...\n");
+ igt_info("Sleeping for 10 sec...\n");
sleep(10);
memset(ptr, 0xff, 4);
munmap(ptr, 4096);
ptr = gem_mmap__cpu(data->drm_fd, handle, 4096, PROT_WRITE);
gem_set_domain(data->drm_fd, handle,
I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
- fprintf(stdout, "Sleeping for 10 sec...\n");
+ igt_info("Sleeping for 10 sec...\n");
sleep(10);
fill_blt(data, handle, 0xff);
igt_assert(wait_psr_entry(data, 10));
get_sink_crc(data, ref_crc);
- fprintf(stdout, "Sleeping for 10 sec...\n");
+ igt_info("Sleeping for 10 sec...\n");
sleep(10);
memset(ptr, 0xff, 4);
munmap(ptr, 4096);
drmModeRes *mode_resources = drmModeGetResources(drmfd);
if (!mode_resources) {
- fprintf(stderr, "drmModeGetResources failed: %s\n",
- strerror(errno));
+ igt_warn("drmModeGetResources failed: %s\n", strerror(errno));
return;
}
- printf("Connectors:\n");
- printf("id\tencoder\tstatus\t\ttype\tsize (mm)\tmodes\n");
+ igt_info("Connectors:\n");
+ igt_info("id\tencoder\tstatus\t\ttype\tsize (mm)\tmodes\n");
for (i = 0; i < mode_resources->count_connectors; i++) {
drmModeConnector *connector;
connector = drmModeGetConnector(drmfd, mode_resources->connectors[i]);
if (!connector) {
- fprintf(stderr, "could not get connector %i: %s\n",
- mode_resources->connectors[i], strerror(errno));
+ igt_warn("could not get connector %i: %s\n", mode_resources->connectors[i], strerror(errno));
continue;
}
- printf("%d\t%d\t%s\t%s\t%dx%d\t\t%d\n",
- connector->connector_id,
- connector->encoder_id,
- kmstest_connector_status_str(connector->connection),
- kmstest_connector_type_str(connector->connector_type),
- connector->mmWidth, connector->mmHeight,
- connector->count_modes);
+ igt_info("%d\t%d\t%s\t%s\t%dx%d\t\t%d\n", connector->connector_id, connector->encoder_id, kmstest_connector_status_str(connector->connection), kmstest_connector_type_str(connector->connector_type), connector->mmWidth, connector->mmHeight, connector->count_modes);
if (!connector->count_modes)
continue;
- printf(" modes:\n");
- printf(" name refresh (Hz) hdisp hss hse htot vdisp "
- "vss vse vtot flags type clock\n");
+ igt_info(" modes:\n");
+ igt_info(" name refresh (Hz) hdisp hss hse htot vdisp ""vss vse vtot flags type clock\n");
for (j = 0; j < connector->count_modes; j++){
- fprintf(stdout, "[%d]", j );
+ igt_info("[%d]", j);
kmstest_dump_mode(&connector->modes[j]);
}
drmModeFreeConnector(connector);
}
- printf("\n");
+ igt_info("\n");
drmModeFreeResources(mode_resources);
}
int i;
drmModeRes *mode_resources = drmModeGetResources(drmfd);
- printf("CRTCs:\n");
- printf("id\tfb\tpos\tsize\n");
+ igt_info("CRTCs:\n");
+ igt_info("id\tfb\tpos\tsize\n");
for (i = 0; i < mode_resources->count_crtcs; i++) {
drmModeCrtc *crtc;
crtc = drmModeGetCrtc(drmfd, mode_resources->crtcs[i]);
if (!crtc) {
- fprintf(stderr, "could not get crtc %i: %s\n",
- mode_resources->crtcs[i], strerror(errno));
+ igt_warn("could not get crtc %i: %s\n", mode_resources->crtcs[i], strerror(errno));
continue;
}
- printf("%d\t%d\t(%d,%d)\t(%dx%d)\n",
- crtc->crtc_id,
- crtc->buffer_id,
- crtc->x, crtc->y,
- crtc->width, crtc->height);
+ igt_info("%d\t%d\t(%d,%d)\t(%dx%d)\n", crtc->crtc_id, crtc->buffer_id, crtc->x, crtc->y, crtc->width, crtc->height);
kmstest_dump_mode(&crtc->mode);
drmModeFreeCrtc(crtc);
}
- printf("\n");
+ igt_info("\n");
drmModeFreeResources(mode_resources);
}
sigemptyset(&sa.sa_mask);
- if (sigaction(sigs[0], &sa, NULL) == -1)
- perror("Could not set signal handler");
+ igt_warn_on_f(sigaction(sigs[0], &sa, NULL) == -1,
+ "Could not set signal handler");
}
static void
paint_output_info(c, &fb_info[current_fb]);
paint_color_key(&fb_info[current_fb]);
- fprintf(stdout, "CRTC(%u):[%d]",c->crtc, j);
+ igt_info("CRTC(%u):[%d]", c->crtc, j);
kmstest_dump_mode(&c->mode);
if (drmModeSetCrtc(drm_fd, c->crtc, fb_id, 0, 0,
&c->id, 1, &c->mode)) {
- fprintf(stderr, "failed to set mode (%dx%d@%dHz): %s\n",
- width, height, c->mode.vrefresh,
- strerror(errno));
+ igt_warn("failed to set mode (%dx%d@%dHz): %s\n", width, height, c->mode.vrefresh, strerror(errno));
continue;
}
fb_id = create_stereo_fb(&c->mode, &fb_info);
- if (drmModeSetCrtc(drm_fd, c->crtc, fb_id, 0, 0,
- &c->id, 1, &c->mode)) {
- fprintf(stderr, "failed to set mode (%dx%d@%dHz): %s\n",
- width, height, c->mode.vrefresh,
- strerror(errno));
- }
+ igt_warn_on_f(drmModeSetCrtc(drm_fd, c->crtc, fb_id, 0, 0, &c->id, 1, &c->mode),
+ "failed to set mode (%dx%d@%dHz): %s\n", width, height, c->mode.vrefresh, strerror(errno));
}
static void
if (!(c->mode.flags & DRM_MODE_FLAG_3D_MASK))
continue;
- fprintf(stdout, "CRTC(%u): [%d]", c->crtc, i);
+ igt_info("CRTC(%u): [%d]", c->crtc, i);
kmstest_dump_mode(&c->mode);
do_set_stereo_mode(c);
resources = drmModeGetResources(drm_fd);
if (!resources) {
- fprintf(stderr, "drmModeGetResources failed: %s\n",
- strerror(errno));
+ igt_warn("drmModeGetResources failed: %s\n", strerror(errno));
return 0;
}
static void __attribute__((noreturn)) usage(char *name)
{
- fprintf(stdout, "usage: %s [-hiasdpmtf]\n", name);
- fprintf(stdout, "\t-i\tdump info\n");
- fprintf(stdout, "\t-a\ttest all modes\n");
- fprintf(stdout, "\t-s\t<duration>\tsleep between each mode test\n");
- fprintf(stdout, "\t-d\t<depth>\tbit depth of scanout buffer\n");
-
fprintf(stdout, "\t-p\t<planew,h>,<crtcx,y>,<crtcw,h> test overlay plane\n");
- fprintf(stdout, "\t-m\ttest the preferred mode\n");
- fprintf(stdout, "\t-3\ttest all 3D modes\n");
- fprintf(stdout, "\t-t\tuse a tiled framebuffer\n");
- fprintf(stdout, "\t-j\tdo dpms off, optional arg to select dpms leve (1-3)\n");
- fprintf(stdout, "\t-r\tprint a QR code on the screen whose content is \"pass\" for the automatic test\n");
- fprintf(stdout, "\t-o\t<id of the display>,<number of the mode>\tonly test specified mode on the specified display\n");
- fprintf(stdout, "\t-f\t<clock MHz>,<hdisp>,<hsync-start>,<hsync-end>,<htotal>,\n");
- fprintf(stdout, "\t\t<vdisp>,<vsync-start>,<vsync-end>,<vtotal>\n");
- fprintf(stdout, "\t\ttest force mode\n");
- fprintf(stdout, "\tDefault is to test all modes.\n");
+ igt_info("usage: %s [-hiasdpmtf]\n", name);
+ igt_info("\t-i\tdump info\n");
+ igt_info("\t-a\ttest all modes\n");
+ igt_info("\t-s\t<duration>\tsleep between each mode test\n");
+ igt_info("\t-d\t<depth>\tbit depth of scanout buffer\n");
+
igt_info("\t-p\t<planew,h>,<crtcx,y>,<crtcw,h> test overlay plane\n");
+ igt_info("\t-m\ttest the preferred mode\n");
+ igt_info("\t-3\ttest all 3D modes\n");
+ igt_info("\t-t\tuse a tiled framebuffer\n");
+ igt_info("\t-j\tdo dpms off, optional arg to select dpms leve (1-3)\n");
+ igt_info("\t-r\tprint a QR code on the screen whose content is \"pass\" for the automatic test\n");
+ igt_info("\t-o\t<id of the display>,<number of the mode>\tonly test specified mode on the specified display\n");
+ igt_info("\t-f\t<clock MHz>,<hdisp>,<hsync-start>,<hsync-end>,<htotal>,\n");
+ igt_info("\t\t<vdisp>,<vsync-start>,<vsync-end>,<vtotal>\n");
+ igt_info("\t\ttest force mode\n");
+ igt_info("\tDefault is to test all modes.\n");
exit(0);
}
break;
case 'd':
depth = atoi(optarg);
- fprintf(stdout, "using depth %d\n", depth);
+ igt_info("using depth %d\n", depth);
break;
case 'p':
if (sscanf(optarg, "%d,%d,%d,%d,%d,%d", &plane_width,
if (test_stereo_modes &&
drmSetClientCap(drm_fd, DRM_CLIENT_CAP_STEREO_3D, 1) < 0) {
- fprintf(stderr, "DRM_CLIENT_CAP_STEREO_3D failed\n");
+ igt_warn("DRM_CLIENT_CAP_STEREO_3D failed\n");
goto out_close;
}
mainloop = g_main_loop_new(NULL, FALSE);
if (!mainloop) {
- fprintf(stderr, "failed to create glib mainloop\n");
+ igt_warn("failed to create glib mainloop\n");
ret = -1;
goto out_close;
}
if (!testdisplay_setup_hotplug()) {
- fprintf(stderr, "failed to initialize hotplug support\n");
+ igt_warn("failed to initialize hotplug support\n");
goto out_mainloop;
}
stdinchannel = g_io_channel_unix_new(0);
if (!stdinchannel) {
- fprintf(stderr, "failed to create stdin GIO channel\n");
+ igt_warn("failed to create stdin GIO channel\n");
goto out_hotplug;
}
ret = g_io_add_watch(stdinchannel, G_IO_IN | G_IO_ERR, input_event,
NULL);
if (ret < 0) {
- fprintf(stderr, "failed to add watch on stdin GIO channel\n");
+ igt_warn("failed to add watch on stdin GIO channel\n");
goto out_stdio;
}
#include "config.h"
#endif
+#include "igt_core.h"
+
#if HAVE_UDEV
#include <libudev.h>
static struct udev_monitor *uevent_monitor;
udev = udev_new();
if (!udev) {
- fprintf(stderr, "failed to create udev object\n");
+ igt_warn("failed to create udev object\n");
goto out;
}
uevent_monitor = udev_monitor_new_from_netlink(udev, "udev");
if (!uevent_monitor) {
- fprintf(stderr, "failed to create udev event monitor\n");
+ igt_warn("failed to create udev event monitor\n");
goto out;
}
"drm",
"drm_minor");
if (ret < 0) {
- fprintf(stderr, "failed to filter for drm events\n");
+ igt_warn("failed to filter for drm events\n");
goto out;
}
ret = udev_monitor_enable_receiving(uevent_monitor);
if (ret < 0) {
- fprintf(stderr, "failed to enable udev event reception\n");
+ igt_warn("failed to enable udev event reception\n");
goto out;
}
udevchannel =
g_io_channel_unix_new(udev_monitor_get_fd(uevent_monitor));
if (!udevchannel) {
- fprintf(stderr, "failed to create udev GIO channel\n");
+ igt_warn("failed to create udev GIO channel\n");
goto out;
}
ret = g_io_add_watch(udevchannel, G_IO_IN | G_IO_ERR, hotplug_event,
udev);
if (ret < 0) {
- fprintf(stderr, "failed to add watch on udev GIO channel\n");
+ igt_warn("failed to add watch on udev GIO channel\n");
goto out;
}
#else
gboolean testdisplay_setup_hotplug(void)
{
- fprintf(stderr, "no hotplug support on this platform\n");
+ igt_warn("no hotplug support on this platform\n");
return TRUE;
}
projects / platform / upstream / intel-gpu-tools.git / commitdiff