/* * Copyright 2010 Intel Corporation * Jesse Barnes * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ /* * This program is intended for testing of display functionality. It should * allow for testing of * - hotplug * - mode setting * - clone & twin modes * - panel fitting * - test patterns & pixel generators * Additional programs can test the detected outputs against VBT provided * device lists (both docked & undocked). * * TODO: * - pixel generator in transcoder * - test pattern reg in pipe * - test patterns on outputs (e.g. TV) * - handle hotplug (leaks crtcs, can't handle clones) * - allow mode force * - expose output specific controls * - e.g. DDC-CI brightness * - HDMI controls * - panel brightness * - DP commands (e.g. poweroff) * - verify outputs against VBT/physical connectors */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include "ioctl_wrappers.h" #include "drmtest.h" #include "testdisplay.h" #include "igt_kms.h" #include #include drmModeRes *resources; int drm_fd, modes; int test_all_modes = 0, test_preferred_mode = 0, force_mode = 0, test_plane, test_stereo_modes, enable_tiling; int sleep_between_modes = 5; int do_dpms = 0; /* This aliases to DPMS_ON */ uint32_t depth = 24, stride, bpp; int qr_code = 0; int specified_mode_num = -1, specified_disp_id = -1; drmModeModeInfo force_timing; int crtc_x, crtc_y, crtc_w, crtc_h, width, height; unsigned int plane_fb_id; unsigned int plane_crtc_id; unsigned int plane_id; int plane_width, plane_height; static const uint32_t SPRITE_COLOR_KEY = 0x00aaaaaa; /* * Mode setting with the kernel interfaces is a bit of a chore. * First you have to find the connector in question and make sure the * requested mode is available. * Then you need to find the encoder attached to that connector so you * can bind it with a free crtc. */ struct connector { uint32_t id; int mode_valid; drmModeModeInfo mode; drmModeEncoder *encoder; drmModeConnector *connector; int crtc; int crtc_idx; int pipe; }; static void dump_connectors_fd(int drmfd) { int i, j; drmModeRes *mode_resources = drmModeGetResources(drmfd); if (!mode_resources) { fprintf(stderr, "drmModeGetResources failed: %s\n", strerror(errno)); return; } printf("Connectors:\n"); printf("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)); 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); if (!connector->count_modes) continue; printf(" modes:\n"); printf(" 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 ); kmstest_dump_mode(&connector->modes[j]); } drmModeFreeConnector(connector); } printf("\n"); drmModeFreeResources(mode_resources); } static void dump_crtcs_fd(int drmfd) { int i; drmModeRes *mode_resources = drmModeGetResources(drmfd); printf("CRTCs:\n"); printf("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)); 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); kmstest_dump_mode(&crtc->mode); drmModeFreeCrtc(crtc); } printf("\n"); drmModeFreeResources(mode_resources); } static void dump_info(void) { dump_connectors_fd(drm_fd); dump_crtcs_fd(drm_fd); } static void connector_find_preferred_mode(uint32_t connector_id, unsigned long crtc_idx_mask, int mode_num, struct connector *c) { struct kmstest_connector_config config; if (kmstest_get_connector_config(drm_fd, connector_id, crtc_idx_mask, &config) < 0) { c->mode_valid = 0; return; } c->connector = config.connector; c->encoder = config.encoder; c->crtc = config.crtc->crtc_id; c->crtc_idx = config.crtc_idx; c->pipe = config.pipe; if (mode_num != -1) { igt_assert(mode_num < config.connector->count_modes); c->mode = config.connector->modes[mode_num]; } else { c->mode = config.default_mode; } c->mode_valid = 1; } static void paint_color_key(struct kmstest_fb *fb_info) { int i, j; uint32_t *fb_ptr; fb_ptr = gem_mmap(drm_fd, fb_info->gem_handle, fb_info->size, PROT_READ | PROT_WRITE); igt_assert(fb_ptr); for (i = crtc_y; i < crtc_y + crtc_h; i++) for (j = crtc_x; j < crtc_x + crtc_w; j++) { uint32_t offset; offset = (i * fb_info->stride / 4) + j; fb_ptr[offset] = SPRITE_COLOR_KEY; } munmap(fb_ptr, fb_info->size); } static void paint_image(cairo_t *cr, const char *file) { int img_x, img_y, img_w, img_h, img_w_o, img_h_o; double img_w_scale, img_h_scale; cairo_surface_t *image; img_y = height * (0.10 ); img_h = height * 0.08 * 4; img_w = img_h; img_x = (width / 2) - (img_w / 2); image = cairo_image_surface_create_from_png(file); img_w_o = cairo_image_surface_get_width(image); img_h_o = cairo_image_surface_get_height(image); cairo_translate(cr, img_x, img_y); img_w_scale = (double)img_w / (double)img_w_o; img_h_scale = (double)img_h / (double)img_h_o; cairo_scale(cr, img_w_scale, img_h_scale); cairo_set_source_surface(cr, image, 0, 0); cairo_scale(cr, 1, 1); cairo_paint(cr); cairo_surface_destroy(image); } static void paint_output_info(struct connector *c, struct kmstest_fb *fb) { cairo_t *cr = kmstest_get_cairo_ctx(drm_fd, fb); int l_width = fb->width; int l_height = fb->height; double str_width; double x, y, top_y; double max_width; int i; kmstest_paint_test_pattern(cr, l_width, l_height); cairo_select_font_face(cr, "Helvetica", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_move_to(cr, l_width / 2, l_height / 2); /* Print connector and mode name */ cairo_set_font_size(cr, 48); kmstest_cairo_printf_line(cr, align_hcenter, 10, "%s", kmstest_connector_type_str(c->connector->connector_type)); cairo_set_font_size(cr, 36); str_width = kmstest_cairo_printf_line(cr, align_hcenter, 10, "%s @ %dHz on %s encoder", c->mode.name, c->mode.vrefresh, kmstest_encoder_type_str(c->encoder->encoder_type)); cairo_rel_move_to(cr, -str_width / 2, 0); /* List available modes */ cairo_set_font_size(cr, 18); str_width = kmstest_cairo_printf_line(cr, align_left, 10, "Available modes:"); cairo_rel_move_to(cr, str_width, 0); cairo_get_current_point(cr, &x, &top_y); max_width = 0; for (i = 0; i < c->connector->count_modes; i++) { cairo_get_current_point(cr, &x, &y); if (y >= l_height) { x += max_width + 10; max_width = 0; cairo_move_to(cr, x, top_y); } str_width = kmstest_cairo_printf_line(cr, align_right, 10, "%s @ %dHz", c->connector->modes[i].name, c->connector->modes[i].vrefresh); if (str_width > max_width) max_width = str_width; } if (qr_code) paint_image(cr, IGT_DATADIR"/pass.png"); igt_assert(!cairo_status(cr)); } static void sighandler(int signo) { return; } static void set_single(void) { int sigs[] = { SIGUSR1 }; struct sigaction sa; sa.sa_handler = sighandler; sigemptyset(&sa.sa_mask); if (sigaction(sigs[0], &sa, NULL) == -1) perror("Could not set signal handler"); } static void set_connector_dpms(drmModeConnector *connector, int mode) { int i, dpms = 0; bool found_it = false; for (i = 0; i < connector->count_props; i++) { struct drm_mode_get_property prop; prop.prop_id = connector->props[i]; prop.count_values = 0; prop.count_enum_blobs = 0; if (drmIoctl(drm_fd, DRM_IOCTL_MODE_GETPROPERTY, &prop)) continue; if (strcmp(prop.name, "DPMS")) continue; dpms = prop.prop_id; found_it = true; break; } igt_assert_f(found_it, "DPMS property not found on %d\n", connector->connector_id); igt_assert(drmModeConnectorSetProperty(drm_fd, connector->connector_id, dpms, mode) == 0); } static void set_mode(struct connector *c) { unsigned int fb_id = 0; struct kmstest_fb fb_info[2] = { }; int j, test_mode_num, current_fb = 0, old_fb = -1; test_mode_num = 1; if (force_mode){ memcpy( &c->mode, &force_timing, sizeof(force_timing)); c->mode.vrefresh =(force_timing.clock*1e3)/(force_timing.htotal*force_timing.vtotal); c->mode_valid = 1; sprintf(c->mode.name, "%dx%d", force_timing.hdisplay, force_timing.vdisplay); } else if (test_all_modes) test_mode_num = c->connector->count_modes; for (j = 0; j < test_mode_num; j++) { if (test_all_modes) c->mode = c->connector->modes[j]; /* set_mode() only tests 2D modes */ if (c->mode.flags & DRM_MODE_FLAG_3D_MASK) continue; if (!c->mode_valid) continue; width = c->mode.hdisplay; height = c->mode.vdisplay; fb_id = kmstest_create_fb(drm_fd, width, height, bpp_depth_to_drm_format(bpp, depth), enable_tiling, &fb_info[current_fb]); paint_output_info(c, &fb_info[current_fb]); paint_color_key(&fb_info[current_fb]); fprintf(stdout, "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)); continue; } if (old_fb != -1) kmstest_remove_fb(drm_fd, &fb_info[old_fb]); old_fb = current_fb; current_fb = 1 - current_fb; if (sleep_between_modes && test_all_modes && !qr_code) sleep(sleep_between_modes); if (do_dpms) { set_connector_dpms(c->connector, do_dpms); sleep(sleep_between_modes); set_connector_dpms(c->connector, DRM_MODE_DPMS_ON); } if (qr_code){ set_single(); pause(); } } if (test_all_modes) kmstest_remove_fb(drm_fd, &fb_info[old_fb]); drmModeFreeEncoder(c->encoder); drmModeFreeConnector(c->connector); } struct box { int x, y, width, height; }; struct stereo_fb_layout { int fb_width, fb_height; struct box left, right; }; static void box_init(struct box *box, int x, int y, int bwidth, int bheight) { box->x = x; box->y = y; box->width = bwidth; box->height = bheight; } static void stereo_fb_layout_from_mode(struct stereo_fb_layout *layout, drmModeModeInfo *mode) { unsigned int format = mode->flags & DRM_MODE_FLAG_3D_MASK; const int hdisplay = mode->hdisplay, vdisplay = mode->vdisplay; int middle; switch (format) { case DRM_MODE_FLAG_3D_TOP_AND_BOTTOM: layout->fb_width = hdisplay; layout->fb_height = vdisplay; middle = vdisplay / 2; box_init(&layout->left, 0, 0, hdisplay, middle); box_init(&layout->right, 0, middle, hdisplay, vdisplay - middle); break; case DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF: layout->fb_width = hdisplay; layout->fb_height = vdisplay; middle = hdisplay / 2; box_init(&layout->left, 0, 0, middle, vdisplay); box_init(&layout->right, middle, 0, hdisplay - middle, vdisplay); break; case DRM_MODE_FLAG_3D_FRAME_PACKING: { int vactive_space = mode->vtotal - vdisplay; layout->fb_width = hdisplay; layout->fb_height = 2 * vdisplay + vactive_space; box_init(&layout->left, 0, 0, hdisplay, vdisplay); box_init(&layout->right, 0, vdisplay + vactive_space, hdisplay, vdisplay); break; } default: igt_assert(0); } } static const char *stereo_mode_str(drmModeModeInfo *mode) { unsigned int layout = mode->flags & DRM_MODE_FLAG_3D_MASK; switch (layout) { case DRM_MODE_FLAG_3D_TOP_AND_BOTTOM: return "TB"; case DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF: return "SbSH"; case DRM_MODE_FLAG_3D_FRAME_PACKING: return "FP"; default: igt_assert(0); } } static uint32_t create_stereo_fb(drmModeModeInfo *mode, struct kmstest_fb *fb) { struct stereo_fb_layout layout; cairo_t *cr; uint32_t fb_id; stereo_fb_layout_from_mode(&layout, mode); fb_id = kmstest_create_fb(drm_fd, layout.fb_width, layout.fb_height, bpp_depth_to_drm_format(bpp, depth), enable_tiling, fb); cr = kmstest_get_cairo_ctx(drm_fd, fb); kmstest_paint_image(cr, IGT_DATADIR"/1080p-left.png", layout.left.x, layout.left.y, layout.left.width, layout.left.height); kmstest_paint_image(cr, IGT_DATADIR"/1080p-right.png", layout.right.x, layout.right.y, layout.right.width, layout.right.height); cairo_destroy(cr); { char buffer[64]; snprintf(buffer, sizeof(buffer), "%dx%d@%dHz-%s.png", mode->hdisplay, mode->vdisplay, mode->vrefresh, stereo_mode_str(mode)); kmstest_write_fb(drm_fd, fb, buffer); } return fb_id; } static void do_set_stereo_mode(struct connector *c) { uint32_t fb_id; struct kmstest_fb fb_info; 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)); } } static void set_stereo_mode(struct connector *c) { int i, n; if (specified_mode_num != -1) n = 1; else n = c->connector->count_modes; for (i = 0; i < n; i++) { if (specified_mode_num == -1) c->mode = c->connector->modes[i]; if (!c->mode_valid) continue; if (!(c->mode.flags & DRM_MODE_FLAG_3D_MASK)) continue; fprintf(stdout, "CRTC(%u): [%d]", c->crtc, i); kmstest_dump_mode(&c->mode); do_set_stereo_mode(c); if (qr_code) { set_single(); pause(); } else if (sleep_between_modes) sleep(sleep_between_modes); if (do_dpms) { set_connector_dpms(c->connector, DRM_MODE_DPMS_OFF); sleep(sleep_between_modes); set_connector_dpms(c->connector, DRM_MODE_DPMS_ON); } } drmModeFreeEncoder(c->encoder); drmModeFreeConnector(c->connector); } /* * Re-probe outputs and light up as many as possible. * * On Intel, we have two CRTCs that we can drive independently with * different timings and scanout buffers. * * Each connector has a corresponding encoder, except in the SDVO case * where an encoder may have multiple connectors. */ int update_display(void) { struct connector *connectors; int c; resources = drmModeGetResources(drm_fd); if (!resources) { fprintf(stderr, "drmModeGetResources failed: %s\n", strerror(errno)); return 0; } connectors = calloc(resources->count_connectors, sizeof(struct connector)); if (!connectors) return 0; if (test_preferred_mode || test_all_modes || force_mode || specified_disp_id != -1) { unsigned long crtc_idx_mask = -1UL; /* Find any connected displays */ for (c = 0; c < resources->count_connectors; c++) { struct connector *connector = &connectors[c]; connector->id = resources->connectors[c]; if (specified_disp_id != -1 && connector->id != specified_disp_id) continue; connector_find_preferred_mode(connector->id, crtc_idx_mask, specified_mode_num, connector); if (!connector->mode_valid) continue; set_mode(connector); if (test_preferred_mode || force_mode || specified_mode_num != -1) crtc_idx_mask &= ~(1 << connector->crtc_idx); } } if (test_stereo_modes) { for (c = 0; c < resources->count_connectors; c++) { struct connector *connector = &connectors[c]; connector->id = resources->connectors[c]; if (specified_disp_id != -1 && connector->id != specified_disp_id) continue; connector_find_preferred_mode(connector->id, -1UL, specified_mode_num, connector); if (!connector->mode_valid) continue; set_stereo_mode(connector); } } free(connectors); drmModeFreeResources(resources); return 1; } static char optstr[] = "3hiaf:s:d:p:mrto:j:"; static void __attribute__((noreturn)) usage(char *name) { fprintf(stderr, "usage: %s [-hiasdpmtf]\n", name); fprintf(stderr, "\t-i\tdump info\n"); fprintf(stderr, "\t-a\ttest all modes\n"); fprintf(stderr, "\t-s\t\tsleep between each mode test\n"); fprintf(stderr, "\t-d\t\tbit depth of scanout buffer\n"); fprintf(stderr, "\t-p\t,, test overlay plane\n"); fprintf(stderr, "\t-m\ttest the preferred mode\n"); fprintf(stderr, "\t-3\ttest all 3D modes\n"); fprintf(stderr, "\t-t\tuse a tiled framebuffer\n"); fprintf(stderr, "\t-j\tdo dpms off, optional arg to select dpms leve (1-3)\n"); fprintf(stderr, "\t-r\tprint a QR code on the screen whose content is \"pass\" for the automatic test\n"); fprintf(stderr, "\t-o\t,\tonly test specified mode on the specified display\n"); fprintf(stderr, "\t-f\t,,,,,\n"); fprintf(stderr, "\t\t,,,\n"); fprintf(stderr, "\t\ttest force mode\n"); fprintf(stderr, "\tDefault is to test all modes.\n"); exit(0); } #define dump_resource(res) if (res) dump_##res() static gboolean input_event(GIOChannel *source, GIOCondition condition, gpointer data) { gchar buf[2]; gsize count; count = read(g_io_channel_unix_get_fd(source), buf, sizeof(buf)); if (buf[0] == 'q' && (count == 1 || buf[1] == '\n')) { exit(0); } return TRUE; } static void enter_exec_path( char **argv ) { char *exec_path = NULL; char *pos = NULL; short len_path = 0; int ret; len_path = strlen( argv[0] ); exec_path = (char*) malloc(len_path); memcpy(exec_path, argv[0], len_path); pos = strrchr(exec_path, '/'); if (pos != NULL) *(pos+1) = '\0'; ret = chdir(exec_path); igt_assert(ret == 0); free(exec_path); } int main(int argc, char **argv) { int c; int ret = 0; GIOChannel *stdinchannel; GMainLoop *mainloop; float force_clock; bool opt_dump_info = false; igt_skip_on_simulation(); enter_exec_path( argv ); while ((c = getopt(argc, argv, optstr)) != -1) { switch (c) { case '3': test_stereo_modes = 1; break; case 'i': opt_dump_info = true; break; case 'a': test_all_modes = 1; break; case 'f': force_mode = 1; if(sscanf(optarg,"%f,%hu,%hu,%hu,%hu,%hu,%hu,%hu,%hu", &force_clock,&force_timing.hdisplay, &force_timing.hsync_start,&force_timing.hsync_end,&force_timing.htotal, &force_timing.vdisplay, &force_timing.vsync_start, &force_timing.vsync_end, &force_timing.vtotal)!= 9) usage(argv[0]); force_timing.clock = force_clock*1000; break; case 's': sleep_between_modes = atoi(optarg); break; case 'j': do_dpms = atoi(optarg); if (do_dpms == 0) do_dpms = DRM_MODE_DPMS_OFF; break; case 'd': depth = atoi(optarg); fprintf(stderr, "using depth %d\n", depth); break; case 'p': if (sscanf(optarg, "%d,%d,%d,%d,%d,%d", &plane_width, &plane_height, &crtc_x, &crtc_y, &crtc_w, &crtc_h) != 6) usage(argv[0]); test_plane = 1; break; case 'm': test_preferred_mode = 1; break; case 't': enable_tiling = 1; break; case 'r': qr_code = 1; break; case 'o': sscanf(optarg, "%d,%d", &specified_disp_id, &specified_mode_num); break; default: /* fall through */ case 'h': usage(argv[0]); break; } } if (depth <= 8) bpp = 8; else if (depth <= 16) bpp = 16; else if (depth <= 32) bpp = 32; if (!test_all_modes && !force_mode && !test_preferred_mode && specified_mode_num == -1 && !test_stereo_modes) test_all_modes = 1; drm_fd = drm_open_any(); if (test_stereo_modes && drmSetClientCap(drm_fd, DRM_CLIENT_CAP_STEREO_3D, 1) < 0) { fprintf(stderr, "DRM_CLIENT_CAP_STEREO_3D failed\n"); goto out_close; } if (opt_dump_info) { dump_info(); goto out_close; } igt_set_vt_graphics_mode(); mainloop = g_main_loop_new(NULL, FALSE); if (!mainloop) { fprintf(stderr, "failed to create glib mainloop\n"); ret = -1; goto out_close; } if (!testdisplay_setup_hotplug()) { fprintf(stderr, "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"); 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"); goto out_stdio; } ret = 0; if (!update_display()) { ret = 1; goto out_stdio; } if (test_all_modes) goto out_stdio; g_main_loop_run(mainloop); out_stdio: g_io_channel_shutdown(stdinchannel, TRUE, NULL); out_hotplug: testdisplay_cleanup_hotplug(); out_mainloop: g_main_loop_unref(mainloop); out_close: close(drm_fd); return ret; }