Skip to contentSkip to conversation

Add support for the Chamelium

RFC Superseded Lyude 2 participants 9 messages Dec 1, 2016 – Dec 8, 2016 Library code

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

Lyude

author
#0 lore raw

v3 cover Add support for the Chamelium

Latest version of my series for adding Chamelium

Major changes:
- Since I finally figured out why Video capturing wasn't working on my Chamelium, add the rest of the CRC functions and fix some of the existing ones
- Doc fixes

Lyude (5):
igt_aux: Add igt_skip_without_suspend_support()
igt_aux: Add igt_set_autoresume_delay()
igt_kms: Add helpers for watching for sysfs hotplug events
igt_debugfs: Make igt_crc_to_string() work with other CRC types Add support for hotplug testing with the Chamelium

 configure.ac                                       |  13 +
 .../intel-gpu-tools/intel-gpu-tools-docs.xml       |   1 +
 lib/Makefile.am                                    |   4 +-
 lib/Makefile.sources                               |  10 +-
 lib/igt.h                                          |   4 +
 lib/igt_aux.c                                      |  67 ++
 lib/igt_aux.h                                      |   3 +
 lib/igt_chamelium.c                                | 849 +++++++++++++++++++++
 lib/igt_chamelium.h                                |  73 ++
 lib/igt_debugfs.c                                  |  15 +-
 lib/igt_kms.c                                      | 108 +++
 lib/igt_kms.h                                      |   6 +
 scripts/run-tests.sh                               |   4 +-
 tests/Makefile.am                                  |   5 +-
 tests/Makefile.sources                             |   9 +-
 tests/chamelium.c                                  | 407 ++++++++++
 16 files changed, 1566 insertions(+), 12 deletions(-)
 create mode 100644 lib/igt_chamelium.c
 create mode 100644 lib/igt_chamelium.h
 create mode 100644 tests/chamelium.c
Signature · 6 lines
2.9.3

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
author
#1 lore raw

RFC v3 1/5 igt_aux: Add igt_skip_without_suspend_support()

Since all of the chamelium calls are blocking, we need to be able to make suspend/resume tests with it multi-threaded. As such, it's not the best idea to rely on igt_system_suspend_autoresume() for skipping tests on systems without suspend/resume support since we could accidentally leave the thread controlling the chamelium running after the test gets skipped.

---
 lib/igt_aux.c | 21 +++++++++++++++++++++
 lib/igt_aux.h |  2 ++
 2 files changed, 23 insertions(+)
lib/igt_aux.c +21 -0
index b5ae854..ce2f245 100644
@@ -732,6 +732,27 @@ static uint32_t get_supported_suspend_states(int power_dir)
 }
 
 /**
+ * igt_skip_without_suspend_state:
+ * @state: an #igt_suspend_state to check for
+ *
+ * Check whether or not the system supports the given @state, and skip the
+ * current test if it doesn't. Useful for tests we want to skip before
+ * attempting to call #igt_system_suspend_autoresume.
+ */
+void igt_skip_without_suspend_support(enum igt_suspend_state state,
+				      enum igt_suspend_test test)
+{
+	int power_dir;
+
+	igt_require((power_dir = open("/sys/power", O_RDONLY)) >= 0);
+	igt_require(get_supported_suspend_states(power_dir) & (1 << state));
+	igt_require(test == SUSPEND_TEST_NONE ||
+		    faccessat(power_dir, "pm_test", R_OK | W_OK, 0) == 0);
+
+	close(power_dir);
+}
+
+/**
  * igt_system_suspend_autoresume:
  * @state: an #igt_suspend_state, the target suspend state
  * @test: an #igt_suspend_test, test point at which to complete the suspend
lib/igt_aux.h +2 -0
index 177bd1d..41903c2 100644
@@ -181,6 +181,8 @@ enum igt_suspend_test {
 	SUSPEND_TEST_NUM,
 };
 
+void igt_skip_without_suspend_support(enum igt_suspend_state state,
+				      enum igt_suspend_test test);
 void igt_system_suspend_autoresume(enum igt_suspend_state state,
 				   enum igt_suspend_test test);
 
Signature · 6 lines
2.9.3

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
author
#2 lore raw

RFC v3 2/5 igt_aux: Add igt_set_autoresume_delay()

In reply to Lyude

The default autoresume delay is about 5 seconds. It's possible on a system that's not very fast this might not be a long enough time, since an asynchronous hotplug event we scheduled on the chamelium that was intended to happen during suspend could happen before we actually manage to suspend. So, add a function that allows us to increase the autoresume time to ensure this never happens during suspend/resume tests with the chamelium.

Changes since v1:
- Use igt_require, not assert

---
 lib/igt_aux.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_aux.h |  1 +
 2 files changed, 47 insertions(+)
lib/igt_aux.c +46 -0
index ce2f245..babec57 100644
@@ -801,6 +801,52 @@ void igt_system_suspend_autoresume(enum igt_suspend_state state,
 	close(power_dir);
 }
 
+static int original_autoresume_delay;
+
+static void igt_restore_autoresume_delay(int sig)
+{
+	int delay_fd;
+	char delay_str[10];
+
+	igt_require((delay_fd = open("/sys/module/suspend/parameters/pm_test_delay",
+				    O_WRONLY)) >= 0);
+
+	snprintf(delay_str, sizeof(delay_str), "%d", original_autoresume_delay);
+	igt_require(write(delay_fd, delay_str, strlen(delay_str)));
+
+	close(delay_fd);
+}
+
+/**
+ * igt_set_autoresume_delay:
+ * @delay_secs: The delay in seconds before resuming the system
+ *
+ * Sets how long we wait to resume the system after suspending it, using the
+ * suspend.pm_test_delay variable. On exit, the original delay value is
+ * restored.
+ */
+void igt_set_autoresume_delay(int delay_secs)
+{
+	int delay_fd;
+	char delay_str[10];
+
+	igt_skip_on_simulation();
+
+	igt_require((delay_fd = open("/sys/module/suspend/parameters/pm_test_delay",
+				    O_RDWR)) >= 0);
+
+	if (!original_autoresume_delay) {
+		igt_require(read(delay_fd, delay_str, sizeof(delay_str)));
+		original_autoresume_delay = atoi(delay_str);
+		igt_install_exit_handler(igt_restore_autoresume_delay);
+	}
+
+	snprintf(delay_str, sizeof(delay_str), "%d", delay_secs);
+	igt_require(write(delay_fd, delay_str, strlen(delay_str)));
+
+	close(delay_fd);
+}
+
 /**
  * igt_drop_root:
  *
lib/igt_aux.h +1 -0
index 41903c2..2c58abc 100644
@@ -185,6 +185,7 @@ void igt_skip_without_suspend_support(enum igt_suspend_state state,
 				      enum igt_suspend_test test);
 void igt_system_suspend_autoresume(enum igt_suspend_state state,
 				   enum igt_suspend_test test);
+void igt_set_autoresume_delay(int delay_secs);
 
 /* dropping priviledges */
 void igt_drop_root(void);
Signature · 6 lines
2.9.3

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
author
#3 lore raw

RFC v3 3/5 igt_kms: Add helpers for watching for sysfs hotplug events

In reply to Lyude

This adds some basic helpers for connecting to udev and watching for sysfs hotplug events.

Changes since v1:
- Remove unused arg from documentation

---
 lib/igt_kms.c | 108 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_kms.h |   6 ++++
 2 files changed, 114 insertions(+)
lib/igt_kms.c +108 -0
index 989704e..ca37c47 100644
@@ -38,6 +38,10 @@
 #elif HAVE_SYS_KD_H
 #include <sys/kd.h>
 #endif
+#ifdef HAVE_UDEV
+#include <libudev.h>
+#include <poll.h>
+#endif
 #include <errno.h>
 #include <time.h>
 
@@ -2760,6 +2764,110 @@ void igt_reset_connectors(void)
 			      "detect");
 }
 
+#ifdef HAVE_UDEV
+static struct udev_monitor *hotplug_mon;
+
+/**
+ * igt_watch_hotplug:
+ *
+ * Begin monitoring udev for hotplug events.
+ */
+void igt_watch_hotplug(void)
+{
+	struct udev *udev;
+	int ret, flags, fd;
+
+	if (hotplug_mon)
+		igt_cleanup_hotplug();
+
+	udev = udev_new();
+	igt_assert(udev != NULL);
+
+	hotplug_mon = udev_monitor_new_from_netlink(udev, "udev");
+	igt_assert(hotplug_mon != NULL);
+
+	ret = udev_monitor_filter_add_match_subsystem_devtype(hotplug_mon,
+							      "drm",
+							      "drm_minor");
+	igt_assert_eq(ret, 0);
+	ret = udev_monitor_filter_update(hotplug_mon);
+	igt_assert_eq(ret, 0);
+	ret = udev_monitor_enable_receiving(hotplug_mon);
+	igt_assert_eq(ret, 0);
+
+	/* Set the fd for udev as non blocking */
+	fd = udev_monitor_get_fd(hotplug_mon);
+	flags = fcntl(fd, F_GETFL, 0);
+	igt_assert(flags);
+
+	flags |= O_NONBLOCK;
+	igt_assert_neq(fcntl(fd, F_SETFL, flags), -1);
+}
+
+/**
+ * igt_hotplug_detected:
+ * @timeout_secs: How long to wait for a hotplug event to occur.
+ *
+ * Assert that a hotplug event was received since we last checked the monitor.
+ *
+ * Returns: true if a sysfs hotplug event was received, false if we timed out
+ */
+bool igt_hotplug_detected(int timeout_secs)
+{
+	struct udev_device *dev;
+	const char *hotplug_val;
+	struct pollfd fd = {
+		.fd = udev_monitor_get_fd(hotplug_mon),
+		.events = POLLIN
+	};
+	bool hotplug_received = false;
+
+	/* Go through all of the events pending on the udev monitor. Once we
+	 * receive a hotplug, we continue going through the rest of the events
+	 * so that redundant hotplug events don't change the results of future
+	 * checks
+	 */
+	while (!hotplug_received && poll(&fd, 1, timeout_secs * 1000)) {
+		dev = udev_monitor_receive_device(hotplug_mon);
+
+		hotplug_val = udev_device_get_property_value(dev, "HOTPLUG");
+		if (hotplug_val && atoi(hotplug_val) == 1)
+			hotplug_received = true;
+
+		udev_device_unref(dev);
+	}
+
+	return hotplug_received;
+}
+
+/**
+ * igt_flush_hotplugs:
+ *
+ * Get rid of any pending hotplug events
+ */
+void igt_flush_hotplugs(void)
+{
+	struct udev_device *dev;
+
+	while ((dev = udev_monitor_receive_device(hotplug_mon)))
+		udev_device_unref(dev);
+}
+
+/**
+ * igt_cleanup_hotplug:
+ *
+ * Cleanup the resources allocated by #igt_watch_hotplug
+ */
+void igt_cleanup_hotplug(void)
+{
+	struct udev *udev = udev_monitor_get_udev(hotplug_mon);
+
+	udev_monitor_unref(hotplug_mon);
+	hotplug_mon = NULL;
+	udev_unref(udev);
+}
+#endif
+
 /**
  * kmstest_get_vbl_flag:
  * @pipe_id: Pipe to convert to flag representation.
lib/igt_kms.h +6 -0
index 6422adc..95395cd 100644
@@ -479,5 +479,11 @@ uint32_t kmstest_get_vbl_flag(uint32_t pipe_id);
 const unsigned char* igt_kms_get_base_edid(void);
 const unsigned char* igt_kms_get_alt_edid(void);
 
+#ifdef HAVE_UDEV
+void igt_watch_hotplug(void);
+bool igt_hotplug_detected(int timeout_secs);
+void igt_flush_hotplugs(void);
+void igt_cleanup_hotplug(void);
+#endif
 
 #endif /* __IGT_KMS_H__ */
Signature · 6 lines
2.9.3

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
author
#4 lore raw

RFC v3 4/5 igt_debugfs: Make igt_crc_to_string() work with other CRC types

In reply to Lyude

Intel GPUs have CRC values with 5 n_words, but the Chamelium's definitely doesn't. So make igt_crc_to_string() a little smarter so it can handle this.

---
 lib/igt_debugfs.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)
lib/igt_debugfs.c +11 -4
index 9142e3f..4809b73 100644
@@ -290,11 +290,18 @@ void igt_assert_crc_equal(igt_crc_t *a, igt_crc_t *b)
 char *igt_crc_to_string(igt_crc_t *crc)
 {
 	char buf[128];
+	char *p;
+	int i, len;
+
+	for (i = 0, p = buf;
+	     i < crc->n_words;
+	     i++, p += len) {
+		snprintf(p, sizeof(buf) - (p - buf), "%08x %n",
+			 crc->crc[i], &len);
+	}
 
-	igt_assert_eq(crc->n_words, 5);
-
-	sprintf(buf, "%08x %08x %08x %08x %08x", crc->crc[0],
-		crc->crc[1], crc->crc[2], crc->crc[3], crc->crc[4]);
+	/* Strip the trailing space */
+	*strrchr(buf, ' ') = '\0';
 
 	return strdup(buf);
 }
Signature · 6 lines
2.9.3

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
author
#5 lore raw

RFC v3 5/5 Add support for hotplug testing with the Chamelium

In reply to Lyude

For the purpose of testing things such as hotplugging and bad monitors, the ChromeOS team ended up designing a neat little device known as the Chamelium. More information on this can be found here:

https://www.chromium.org/chromium-os/testing/chamelium

This adds support for a couple of things to intel-gpu-tools:
- igt library functions for connecting to udev and monitoring it for hotplug events, loosely based off of the unfinished hotplugging implementation in testdisplay
- Library functions for controlling the chamelium in tests using xmlrpc. A couple of RPC calls were ommitted here, mainly because they didn't seem very useful for our needs (yet)
- A set of basic tests using the chamelium.

Changes since v1:
- Don't try to guess connector mappings, have the user specify them manually using a configuration file
- Open DRM fd using DRIVER_ANY, not DRIVER_INTEL
- Lower the hotplug timeout a little bit, since 30 seconds was leftover from debugging these tests anyway
- Don't try to keep track of the original state of the chamelium ports, and just leave them plugged in after each run. This makes more sense to me, since I'd imagine in automated testing setups using chameliums that all of the extra monitors will probably be provided by the Chamelium to begin with, so keeping them plugged in would make sure tests running afterwards that require >1 monitor don't get skipped.
- Add wait_for_connector() to the chamelium tests. After some more testing, I found that depending on the system some tests would throw false negatives due to us not waiting long enough for the system to detect that we connected something to it. This mainly happened with VGA connectors, since their lack of HPD makes them take significantly longer for the hardware to notice. wait_for_connector() fixes this by continually reprobing the status of the desired connector (without relying on a hpd event happening, since that might never come) until we get what we want, or we time out and fail.
- Use kmstest_get_property() for retrieving EDIDs instead of doing it by hand
- Don't hardcode PIPE_A for bringing up the display, use kmstest to find an appropriate CRTC to use.
Changes since v2:
- Fix incorrect usage of the list helpers when recording new EDIDs
- Add missing documentation
- Make sure documentation actually appears
- Since we finally got video capture working, add CRC functions and fix the ones we couldn't actually test before
- In the exit handler, reset the xmlrpc env so we can properly reset the Chamelium even after an RPC error
- Make sure compiling without Chamelium support still works

---
 configure.ac                                       |  13 +
 .../intel-gpu-tools/intel-gpu-tools-docs.xml       |   1 +
 lib/Makefile.am                                    |   4 +-
 lib/Makefile.sources                               |  10 +-
 lib/igt.h                                          |   4 +
 lib/igt_chamelium.c                                | 849 +++++++++++++++++++++
 lib/igt_chamelium.h                                |  73 ++
 scripts/run-tests.sh                               |   4 +-
 tests/Makefile.am                                  |   5 +-
 tests/Makefile.sources                             |   9 +-
 tests/chamelium.c                                  | 407 ++++++++++
 11 files changed, 1371 insertions(+), 8 deletions(-)
 create mode 100644 lib/igt_chamelium.c
 create mode 100644 lib/igt_chamelium.h
 create mode 100644 tests/chamelium.c
configure.ac +13 -0
index b62b8fc..1920609 100644
@@ -263,6 +263,18 @@ if test "x$with_libunwind" = xyes; then
 			  AC_MSG_ERROR([libunwind not found. Use --without-libunwind to disable libunwind support.]))
 fi
 
+# enable support for using the chamelium
+AC_ARG_ENABLE(chamelium,
+	      AS_HELP_STRING([--disable-chamelium],
+			     [Build tests without chamelium support]),
+	      [], [enable_chamelium=yes])
+
+AM_CONDITIONAL(HAVE_CHAMELIUM, [test "x$enable_chamelium" = xyes])
+if test "x$enable_chamelium" = xyes; then
+	AC_DEFINE(HAVE_CHAMELIUM, 1, [chamelium suport])
+	PKG_CHECK_MODULES(XMLRPC, xmlrpc_client)
+fi
+
 # enable debug symbols
 AC_ARG_ENABLE(debug,
 	      AS_HELP_STRING([--disable-debug],
@@ -360,6 +372,7 @@ echo "       Assembler          : ${enable_assembler}"
 echo "       Debugger           : ${enable_debugger}"
 echo "       Overlay            : X: ${enable_overlay_xlib}, Xv: ${enable_overlay_xvlib}"
 echo "       x86-specific tools : ${build_x86}"
+echo "       Chamelium support  : ${enable_chamelium}"
 echo ""
 echo " • API-Documentation      : ${enable_gtk_doc}"
 echo " • Fail on warnings       : ${enable_werror}"
docs/reference/intel-gpu-tools/intel-gpu-tools-docs.xml +1 -0
index 55902ab..f515f33 100644
@@ -33,6 +33,7 @@
     <xi:include href="xml/igt_vc4.xml"/>
     <xi:include href="xml/igt_vgem.xml"/>
     <xi:include href="xml/igt_dummyload.xml"/>
+    <xi:include href="xml/igt_chamelium.xml"/>
   </chapter>
   <xi:include href="xml/igt_test_programs.xml"/>
 
lib/Makefile.am +3 -1
index b7c7020..0136663 100644
@@ -23,7 +23,7 @@ if !HAVE_LIBDRM_INTEL
 endif
 
 AM_CPPFLAGS = -I$(top_srcdir)
-AM_CFLAGS = $(CWARNFLAGS) $(DRM_CFLAGS) $(PCIACCESS_CFLAGS) $(KMOD_CFLAGS) $(LIBUNWIND_CFLAGS) $(DEBUG_CFLAGS) \
+AM_CFLAGS = $(CWARNFLAGS) $(DRM_CFLAGS) $(PCIACCESS_CFLAGS) $(KMOD_CFLAGS) $(LIBUNWIND_CFLAGS) $(DEBUG_CFLAGS) $(XMLRPC_CFLAGS) $(UDEV_CFLAGS) \
 	    -DIGT_SRCDIR=\""$(abs_top_srcdir)/tests"\" \
 	    -DIGT_DATADIR=\""$(pkgdatadir)"\" \
 	    -DIGT_LOG_DOMAIN=\""$(subst _,-,$*)"\" \
@@ -39,5 +39,7 @@ libintel_tools_la_LIBADD = \
 	$(LIBUDEV_LIBS) \
 	$(LIBUNWIND_LIBS) \
 	$(TIMER_LIBS) \
+	$(XMLRPC_LIBS) \
+	$(UDEV_LIBS) \
 	-lm
 
lib/Makefile.sources +8 -2
index 7fc5ec2..7132e32 100644
@@ -78,8 +78,14 @@ lib_source_list =	 	\
 	igt_dummyload.c		\
 	igt_dummyload.h		\
 	uwildmat/uwildmat.h	\
-	uwildmat/uwildmat.c	\
-	$(NULL)
+	uwildmat/uwildmat.c
+
+if HAVE_CHAMELIUM
+lib_source_list += igt_chamelium.h \
+		   igt_chamelium.c
+endif
+
+lib_source_list += $(NULL)
 
 .PHONY: version.h.tmp
 
lib/igt.h +4 -0
index a0028d5..d0ded79 100644
@@ -47,4 +47,8 @@
 #include "media_spin.h"
 #include "rendercopy.h"
 
+#ifdef HAVE_CHAMELIUM
+#include "igt_chamelium.h"
+#endif
+
 #endif /* IGT_H */
lib/igt_chamelium.c new file +849 -0

849 lines not on this page · raw message

lib/igt_chamelium.h new file +73 -0

73 lines not on this page · raw message

scripts/run-tests.sh +2 -2
index 97ba9e5..6539bf9 100755
@@ -122,10 +122,10 @@ if [ ! -x "$PIGLIT" ]; then
 fi
 
 if [ "x$RESUME" != "x" ]; then
-	sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" "$PIGLIT" resume "$RESULTS" $NORETRY
+	sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" CHAMELIUM_HOST="$CHAMELIUM_HOST" "$PIGLIT" resume "$RESULTS" $NORETRY
 else
 	mkdir -p "$RESULTS"
-	sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" "$PIGLIT" run igt -o "$RESULTS" -s $VERBOSE $EXCLUDE $FILTER
+	sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" CHAMELIUM_HOST="$CHAMELIUM_HOST" "$PIGLIT" run igt -o "$RESULTS" -s $VERBOSE $EXCLUDE $FILTER
 fi
 
 if [ "$SUMMARY" == "html" ]; then
tests/Makefile.am +4 -1
index a408126..06a8e6b 100644
@@ -63,7 +63,7 @@ AM_CFLAGS = $(DRM_CFLAGS) $(CWARNFLAGS) -Wno-unused-result $(DEBUG_CFLAGS)\
 	$(LIBUNWIND_CFLAGS) $(WERROR_CFLAGS) \
 	$(NULL)
 
-LDADD = ../lib/libintel_tools.la $(GLIB_LIBS)
+LDADD = ../lib/libintel_tools.la $(GLIB_LIBS) $(XMLRPC_LIBS)
 
 AM_CFLAGS += $(CAIRO_CFLAGS) $(LIBUDEV_CFLAGS) $(GLIB_CFLAGS)
 AM_LDFLAGS = -Wl,--as-needed
@@ -119,5 +119,8 @@ vc4_wait_bo_CFLAGS = $(AM_CFLAGS) $(DRM_VC4_CFLAGS)
 vc4_wait_bo_LDADD = $(LDADD) $(DRM_VC4_LIBS)
 vc4_wait_seqno_CFLAGS = $(AM_CFLAGS) $(DRM_VC4_CFLAGS)
 vc4_wait_seqno_LDADD = $(LDADD) $(DRM_VC4_LIBS)
+
+chamelium_CFLAGS = $(AM_CFLAGS) $(XMLRPC_CFLAGS) $(UDEV_CFLAGS)
+chamelium_LDADD = $(LDADD) $(XMLRPC_LIBS) $(UDEV_LIBS)
 endif
 
tests/Makefile.sources +7 -2
index 57a10c5..5eeae77 100644
@@ -135,8 +135,13 @@ TESTS_progs_M = \
 	prime_vgem \
 	template \
 	vgem_basic \
-	vgem_slow \
-	$(NULL)
+	vgem_slow
+
+if HAVE_CHAMELIUM
+TESTS_progs_M += chamelium
+endif
+
+TESTS_progs_M += $(NULL)
 
 TESTS_progs_XM = \
     gem_concurrent_all \
tests/chamelium.c new file +407 -0

407 lines not on this page · raw message

Signature · 6 lines
2.9.3

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#6 lore raw

Re: [RFC i-g-t v3 5/5] Add support for hotplug testing with the Chamelium

Hi Lyude,

this looks very good. Some minor comments below.

Regards,

Tomeu

Quoted 78 lines · Lyude

For the purpose of testing things such as hotplugging and bad monitors, the ChromeOS team ended up designing a neat little device known as the Chamelium. More information on this can be found here:

https://www.chromium.org/chromium-os/testing/chamelium

This adds support for a couple of things to intel-gpu-tools:
- igt library functions for connecting to udev and monitoring it for hotplug events, loosely based off of the unfinished hotplugging implementation in testdisplay
- Library functions for controlling the chamelium in tests using xmlrpc. A couple of RPC calls were ommitted here, mainly because they didn't seem very useful for our needs (yet)
- A set of basic tests using the chamelium.

Changes since v1:
- Don't try to guess connector mappings, have the user specify them manually using a configuration file
- Open DRM fd using DRIVER_ANY, not DRIVER_INTEL
- Lower the hotplug timeout a little bit, since 30 seconds was leftover from debugging these tests anyway
- Don't try to keep track of the original state of the chamelium ports, and just leave them plugged in after each run. This makes more sense to me, since I'd imagine in automated testing setups using chameliums that all of the extra monitors will probably be provided by the Chamelium to begin with, so keeping them plugged in would make sure tests running afterwards that require >1 monitor don't get skipped.
- Add wait_for_connector() to the chamelium tests. After some more testing, I found that depending on the system some tests would throw false negatives due to us not waiting long enough for the system to detect that we connected something to it. This mainly happened with VGA connectors, since their lack of HPD makes them take significantly longer for the hardware to notice. wait_for_connector() fixes this by continually reprobing the status of the desired connector (without relying on a hpd event happening, since that might never come) until we get what we want, or we time out and fail.
- Use kmstest_get_property() for retrieving EDIDs instead of doing it by hand
- Don't hardcode PIPE_A for bringing up the display, use kmstest to find an appropriate CRTC to use.
Changes since v2:
- Fix incorrect usage of the list helpers when recording new EDIDs
- Add missing documentation
- Make sure documentation actually appears
- Since we finally got video capture working, add CRC functions and fix the ones we couldn't actually test before
- In the exit handler, reset the xmlrpc env so we can properly reset the Chamelium even after an RPC error
- Make sure compiling without Chamelium support still works

---
 configure.ac                                       |  13 +
 .../intel-gpu-tools/intel-gpu-tools-docs.xml       |   1 +
 lib/Makefile.am                                    |   4 +-
 lib/Makefile.sources                               |  10 +-
 lib/igt.h                                          |   4 +
 lib/igt_chamelium.c                                | 849 +++++++++++++++++++++
 lib/igt_chamelium.h                                |  73 ++
 scripts/run-tests.sh                               |   4 +-
 tests/Makefile.am                                  |   5 +-
 tests/Makefile.sources                             |   9 +-
 tests/chamelium.c                                  | 407 ++++++++++
 11 files changed, 1371 insertions(+), 8 deletions(-)
 create mode 100644 lib/igt_chamelium.c
 create mode 100644 lib/igt_chamelium.h
 create mode 100644 tests/chamelium.c
configure.ac +2 -0
index b62b8fc..1920609 100644
@@ -263,6 +263,18 @@ if test "x$with_libunwind" = xyes; then
                          AC_MSG_ERROR([libunwind not found. Use --without-libunwind to disable libunwind support.]))
 fi
 
+# enable support for using the chamelium
+AC_ARG_ENABLE(chamelium,

configure.ac if test "x$with_libunwind" = xyes; then · line 277

Quoted 10 lines
configure.ac +10 -0
+             AS_HELP_STRING([--disable-chamelium],
+                            [Build tests without chamelium support]),
+             [], [enable_chamelium=yes])
+
+AM_CONDITIONAL(HAVE_CHAMELIUM, [test "x$enable_chamelium" = xyes])
+if test "x$enable_chamelium" = xyes; then
+       AC_DEFINE(HAVE_CHAMELIUM, 1, [chamelium suport])
+       PKG_CHECK_MODULES(XMLRPC, xmlrpc_client)
+fi
+

IMO libxmlrpc is a very common dependency and thus adding the possibility of disabling Chamelium support isn't worth the cruft we have to add later. Plus, alternative build configurations tend to break and remain broken as most people hacking on the project won't be using them.

Quoted 37 lines
configure.ac +1 -0
 # enable debug symbols
 AC_ARG_ENABLE(debug,
              AS_HELP_STRING([--disable-debug],
@@ -360,6 +372,7 @@ echo "       Assembler          : ${enable_assembler}"
 echo "       Debugger           : ${enable_debugger}"
 echo "       Overlay            : X: ${enable_overlay_xlib}, Xv: ${enable_overlay_xvlib}"
 echo "       x86-specific tools : ${build_x86}"
+echo "       Chamelium support  : ${enable_chamelium}"
 echo ""
 echo " • API-Documentation      : ${enable_gtk_doc}"
 echo " • Fail on warnings       : ${enable_werror}"
docs/reference/intel-gpu-tools/intel-gpu-tools-docs.xml +1 -0
index 55902ab..f515f33 100644
@@ -33,6 +33,7 @@
     <xi:include href="xml/igt_vc4.xml"/>
     <xi:include href="xml/igt_vgem.xml"/>
     <xi:include href="xml/igt_dummyload.xml"/>
+    <xi:include href="xml/igt_chamelium.xml"/>
   </chapter>
   <xi:include href="xml/igt_test_programs.xml"/>
 
lib/Makefile.am +1 -1
index b7c7020..0136663 100644
@@ -23,7 +23,7 @@ if !HAVE_LIBDRM_INTEL
 endif
 
 AM_CPPFLAGS = -I$(top_srcdir)
-AM_CFLAGS = $(CWARNFLAGS) $(DRM_CFLAGS) $(PCIACCESS_CFLAGS) $(KMOD_CFLAGS) $(LIBUNWIND_CFLAGS) $(DEBUG_CFLAGS) \
+AM_CFLAGS = $(CWARNFLAGS) $(DRM_CFLAGS) $(PCIACCESS_CFLAGS) $(KMOD_CFLAGS) $(LIBUNWIND_CFLAGS) $(DEBUG_CFLAGS) $(XMLRPC_CFLAGS) $(UDEV_CFLAGS) \
            -DIGT_SRCDIR=\""$(abs_top_srcdir)/tests"\" \
            -DIGT_DATADIR=\""$(pkgdatadir)"\" \
            -DIGT_LOG_DOMAIN=\""$(subst _,-,$*)"\" \

lib/Makefile.am libintel_tools_la_LIBADD = \ · line 43

Quoted 5 lines
lib/Makefile.am +2 -0
@@ -39,5 +39,7 @@ libintel_tools_la_LIBADD = \
        $(LIBUDEV_LIBS) \
        $(LIBUNWIND_LIBS) \
        $(TIMER_LIBS) \
+       $(XMLRPC_LIBS) \
+       $(UDEV_LIBS) \

The prefix we passed to PKG_CHECK_MODULES is LIBUDEV.

Quoted 10 lines
lib/Makefile.am +0 -0
        -lm
 
lib/Makefile.sources +0 -0
index 7fc5ec2..7132e32 100644
@@ -78,8 +78,14 @@ lib_source_list =            \
        igt_dummyload.c         \
        igt_dummyload.h         \
        uwildmat/uwildmat.h     \

lib/Makefile.sources lib_source_list = \ · line 88

Quoted 10 lines
lib/Makefile.sources +8 -2
-       uwildmat/uwildmat.c     \
-       $(NULL)
+       uwildmat/uwildmat.c
+
+if HAVE_CHAMELIUM
+lib_source_list += igt_chamelium.h \
+                  igt_chamelium.c
+endif
+
+lib_source_list += $(NULL)

The $(NULL) was there just so the last line in lib_source_list could end with \ and thus adding more files to the end wouldn't have to change more lines than strictly needed.

Quoted 55 lines
lib/Makefile.sources +0 -0
 .PHONY: version.h.tmp
 
lib/igt.h +4 -0
index a0028d5..d0ded79 100644
@@ -47,4 +47,8 @@
 #include "media_spin.h"
 #include "rendercopy.h"
 
+#ifdef HAVE_CHAMELIUM
+#include "igt_chamelium.h"
+#endif
+
 #endif /* IGT_H */
lib/igt_chamelium.c new file +33 -0
new file mode 100644
index 0000000..ee94e4a
@@ -0,0 +1,849 @@
+/*
+ * Copyright © 2016 Red Hat Inc.
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ * Authors:
+ *  Lyude Paul <[email protected]>
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <errno.h>
+#include <xmlrpc-c/base.h>
+#include <xmlrpc-c/client.h>
+#include <glib.h>

lib/igt_chamelium.c line 43

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+
+#include "igt.h"
+
+#define check_rpc() \
+       igt_assert_f(!env.fault_occurred, "Chamelium RPC call failed: %s\n", \
+                    env.fault_string);
+
+/**
+ * SECTION:igt_chamelium
+ * @short_description: Library for encorporating the Chamelium into igt tests

incorporating (though I would personally just say "using")

Quoted 25 lines
lib/igt_chamelium.c new file +25 -0
+ * @title: Chamelium
+ * @include: igt_chamelium.h
+ *
+ * This library contains helpers for using Chameliums in IGT tests. This allows
+ * for tests to simulate more difficult tasks to automate such as display
+ * hotplugging, faulty display behaviors, etc.
+ *
+ * More information on the Chamelium can be found
+ * [on the ChromeOS project page](https://www.chromium.org/chromium-os/testing/chamelium).
+ *
+ * In order to run tests using the Chamelium, a valid configuration file must be
+ * present.  The configuration file is a normal Glib keyfile (similar to Windows
+ * INI) structured like so:
+ *
+ * |[<!-- language="plain" -->
+ *     [Chamelium]
+ *     URL=http://chameleon:9992 # The URL used for connecting to the Chamelium's RPC server
+ *
+ *     # The rest of the sections are used for defining connector mappings.
+ *     # This is required so any tests using the Chamelium know which connector
+ *     # on the test machine should be connected to each Chamelium port.
+ *     #
+ *     # In the event that any of these mappings are specified incorrectly,
+ *     # any hotplugging tests for the incorrect connector mapping will fail.
+ *

lib/igt_chamelium.c line 78

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+ *     [DP-1] # The name of the DRM connector
+ *     ChameliumPortID=1 # The ID of the port on the Chamelium this connector is attached to
+ *
+ *     [HDMI-A-1]
+ *     ChameliumPortID=3
+ * ]|
+ *
+ * By default, this file is expected to exist in ~/.igt_chamelium_rc . The
+ * directory for this can be overriden by setting the environment variable
+ * %CHAMELIUM_CONFIG_PATH.

It would be a pity if in time we need to add configuration parameters for other aspects of IGT and we have to choose between renaming this file, or having two configuration files for the same project. Why not call it just .igt_rc?

Quoted 9 lines
lib/igt_chamelium.c new file +9 -0
+ */
+
+/**
+ * chamelium_ports:
+ *
+ * Contains information on all of the ports that are configured for use with the
+ * Chamelium. This information is initialized when #chamelium_init is called.
+ */
+struct chamelium_port *chamelium_ports;

lib/igt_chamelium.c line 97

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+
+/**
+ * chamelium_port_count:
+ *
+ * How many ports are configured for use by the Chamelium.
+ */
+int chamelium_port_count;
+
+static const char *chamelium_url;
+static xmlrpc_env env;

I think it would be better to follow the same pattern as used in igt_pipe_crc_ calls and explicitly pass a pointer to a igt_pipe_crc_t around, instead of using globals.

Quoted 9 lines
lib/igt_chamelium.c new file +9 -0
+
+struct chamelium_edid {
+       int id;
+       struct igt_list link;
+};
+struct chamelium_edid *allocated_edids;
+
+/**
+ * chamelium_plug:

lib/igt_chamelium.c line 116

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+ * @id: The ID of the port on the chamelium to plug
+ *
+ * Simulate a display connector being plugged into the system using the
+ * chamelium.
+ */
+void chamelium_plug(int id)
+{
+       xmlrpc_value *res;
+
+       igt_debug("Plugging port %d\n", id);

For this and other places below, I think it could be very useful when reading logs from CI if we could have the name of the connector along or instead the chamelium port id.

Quoted 85 lines
lib/igt_chamelium.c new file +85 -0
+       res = xmlrpc_client_call(&env, chamelium_url, "Plug", "(i)", id);
+       check_rpc();
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_unplug:
+ * @id: The ID of the port on the chamelium to unplug
+ *
+ * Simulate a display connector being unplugged from the system using the
+ * chamelium.
+ */
+void chamelium_unplug(int id)
+{
+       xmlrpc_value *res;
+
+       igt_debug("Unplugging port %d\n", id);
+       res = xmlrpc_client_call(&env, chamelium_url, "Unplug", "(i)", id);
+       check_rpc();
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_is_plugged:
+ * @id: The ID of the port on the chamelium to check the status of
+ *
+ * Check whether or not the given port has been plugged into the system using
+ * #chamelium_plug.
+ *
+ * Returns: %true if the connector is set to plugged in, %false otherwise.
+ */
+bool chamelium_is_plugged(int id)
+{
+       xmlrpc_value *res;
+       xmlrpc_bool is_plugged;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "IsPlugged", "(i)", id);
+       check_rpc();
+
+       xmlrpc_read_bool(&env, res, &is_plugged);
+       xmlrpc_DECREF(res);
+
+       return is_plugged;
+}
+
+/**
+ * chamelium_port_wait_video_input_stable:
+ * @id: The ID of the port on the chamelium to check the status of
+ * @timeout_secs: How long to wait for a video signal to appear before timing
+ * out
+ *
+ * Waits for a video signal to appear on the given port. This is useful for
+ * checking whether or not we've setup a monitor correctly.
+ *
+ * Returns: %true if a video signal was detected, %false if we timed out
+ */
+bool chamelium_port_wait_video_input_stable(int id, int timeout_secs)
+{
+       xmlrpc_value *res;
+       xmlrpc_bool is_on;
+
+       igt_debug("Waiting for video input to stabalize on port %d\n", id);
+
+       res = xmlrpc_client_call(&env, chamelium_url, "WaitVideoInputStable",
+                                "(ii)", id, timeout_secs);
+       check_rpc();
+
+       xmlrpc_read_bool(&env, res, &is_on);
+       xmlrpc_DECREF(res);
+
+       return is_on;
+}
+
+/**
+ * chamelium_fire_hpd_pulses:
+ * @id: The ID of the port to fire hotplug pulses on
+ * @width_msec: How long each pulse should last
+ * @count: The number of pulses to send
+ *
+ * A convienence function for sending multiple hotplug pulses to the system.
+ * The pulses start at low (e.g. connector is disconnected), and then alternate
+ * from high (e.g. connector is plugged in) to low. This is the equivalent of
+ * repeatedly calling #chamelium_plug and #chamelium_unplug, waiting

lib/igt_chamelium.c line 211

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+ * @width_msec between each call.
+ *
+ * If @count is even, the last pulse sent will be high, and if it's odd then it
+ * will be low. Resetting the HPD line back to it's previous state, if desired,
+ * is the responsibility of the caller.
+ */
+void chamelium_fire_hpd_pulses(int id, int width_msec, int count)
+{
+       xmlrpc_value *pulse_widths = xmlrpc_array_new(&env),
+                    *width = xmlrpc_int_new(&env, width_msec), *res;

If it's going to be two lines anyway, we may just leave the type specifier in the second one.

Quoted 44 lines
lib/igt_chamelium.c new file +44 -0
+       int i;
+
+       igt_debug("Firing %d HPD pulses with width of %d msec on id %d\n",
+                 count, width_msec, id);
+
+       for (i = 0; i < count; i++)
+               xmlrpc_array_append_item(&env, pulse_widths, width);
+
+       res = xmlrpc_client_call(&env, chamelium_url, "FireMixedHpdPulses",
+                                "(iA)", id, pulse_widths);
+       check_rpc();
+
+       xmlrpc_DECREF(res);
+       xmlrpc_DECREF(width);
+       xmlrpc_DECREF(pulse_widths);
+}
+
+/**
+ * chamelium_fire_mixed_hpd_pulses:
+ * @id: The ID of the port to fire hotplug pulses on
+ * @...: The length of each pulse in milliseconds, terminated with a %0
+ *
+ * Does the same thing as #chamelium_fire_hpd_pulses, but allows the caller to
+ * specify the length of each individual pulse.
+ */
+void chamelium_fire_mixed_hpd_pulses(int id, ...)
+{
+       va_list args;
+       xmlrpc_value *pulse_widths = xmlrpc_array_new(&env), *width, *res;
+       int arg;
+
+       igt_debug("Firing mixed HPD pulses on port %d\n", id);
+
+       va_start(args, id);
+       for (arg = va_arg(args, int); arg; arg = va_arg(args, int)) {
+               width = xmlrpc_int_new(&env, arg);
+               xmlrpc_array_append_item(&env, pulse_widths, width);
+               xmlrpc_DECREF(width);
+       }
+       va_end(args);
+
+       res = xmlrpc_client_call(&env, chamelium_url, "FireMixedHpdPulses",
+                                "(iA)", id, pulse_widths);
+       check_rpc();

lib/igt_chamelium.c line 265

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+       xmlrpc_DECREF(res);
+
+       xmlrpc_DECREF(pulse_widths);
+}
+
+static void async_rpc_handler(const char *server_url, const char *method_name,
+                             xmlrpc_value *param_array, void *user_data,
+                             xmlrpc_env *fault, xmlrpc_value *result)
+{
+       /* We don't care about the responses */

What about reporting any errors?

Quoted 46 lines
lib/igt_chamelium.c new file +46 -0
+}
+
+/**
+ * chamelium_async_hpd_pulse_start:
+ * @id: The ID of the port to fire a hotplug pulse on
+ * @high: Whether to fire a high pulse (e.g. simulate a connect), or a low
+ * pulse (e.g. simulate a disconnect)
+ * @delay_secs: How long to wait before sending the HPD pulse.
+ *
+ * Instructs the chamelium to send an hpd pulse after @delay_secs seconds have
+ * passed, without waiting for the chamelium to finish. This is useful for
+ * testing things such as hpd after a suspend/resume cycle, since we can't tell
+ * the chamelium to send a hotplug at the same time that our system is
+ * suspended.
+ *
+ * It is required that the user eventually call
+ * #chamelium_async_hpd_pulse_finish, to clean up the leftover XML-RPC
+ * responses from the chamelium.
+ */
+void chamelium_async_hpd_pulse_start(int id, bool high, int delay_secs)
+{
+       xmlrpc_value *pulse_widths = xmlrpc_array_new(&env), *width;
+
+       /* TODO: Actually implement something in the chameleon server to allow
+        * for delayed actions such as hotplugs. This would work a bit better
+        * and allow us to test suspend/resume on ports without hpd like VGA
+        */
+
+       igt_debug("Sending HPD pulse (%s) on port %d with %d second delay\n",
+                 high ? "high->low" : "low->high", id, delay_secs);
+
+       /* If we're starting at high, make the first pulse width 0 so we keep
+        * the port connected */
+       if (high) {
+               width = xmlrpc_int_new(&env, 0);
+               xmlrpc_array_append_item(&env, pulse_widths, width);
+               xmlrpc_DECREF(width);
+       }
+
+       width = xmlrpc_int_new(&env, delay_secs * 1000);
+       xmlrpc_array_append_item(&env, pulse_widths, width);
+       xmlrpc_DECREF(width);
+
+       xmlrpc_client_call_asynch(chamelium_url, "FireMixedHpdPulses",
+                                 async_rpc_handler, NULL, "(iA)",
+                                 id, pulse_widths);

lib/igt_chamelium.c line 321

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+       xmlrpc_DECREF(pulse_widths);
+}
+
+/**
+ * chamelium_async_hpd_pulse_finish:
+ *
+ * Waits for any asynchronous RPC started by #chamelium_async_hpd_pulse_start
+ * to complete, and then cleans up any leftover responses from the chamelium.
+ * If all of the RPC calls have already completed, this function returns
+ * immediately.

This makes me wonder if it wouldn't have been better to go with libsoup, as it uses a real event loop that we may need to use in tests for other reasons.

Quoted 19 lines
lib/igt_chamelium.c new file +19 -0
+ */
+void chamelium_async_hpd_pulse_finish(void)
+{
+       xmlrpc_client_event_loop_finish_asynch();
+}
+
+/**
+ * chamelium_new_edid:
+ * @edid: The edid blob to upload to the chamelium
+ *
+ * Uploads and registers a new EDID with the chamelium. The EDID will be
+ * destroyed automatically when #chamelium_deinit is called.
+ *
+ * Returns: The ID of the EDID uploaded to the chamelium.
+ */
+int chamelium_new_edid(const unsigned char *edid)
+{
+       xmlrpc_value *res;
+       struct chamelium_edid *allocated_edid;

lib/igt_chamelium.c line 350

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+       int edid_id;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "CreateEdid",
+                                "(6)", edid, EDID_LENGTH);
+       check_rpc();
+
+       xmlrpc_read_int(&env, res, &edid_id);
+       xmlrpc_DECREF(res);
+
+       allocated_edid = malloc(sizeof(struct chamelium_edid));

Should be zeroed?

lib/igt_chamelium.c line 351

Quoted 1 line
lib/igt_chamelium.c new file +1 -0
+       igt_assert(allocated_edid);

Don't think it makes sense in userspace to check for malloc failures.

Quoted 148 lines
lib/igt_chamelium.c new file +148 -0
+
+       allocated_edid->id = edid_id;
+       igt_list_init(&allocated_edid->link);
+
+       if (allocated_edids) {
+               igt_list_add(&allocated_edids->link, &allocated_edid->link);
+       } else {
+               allocated_edids = allocated_edid;
+       }
+
+       return edid_id;
+}
+
+static void chamelium_destroy_edid(int edid_id)
+{
+       xmlrpc_value *res;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "DestroyEdid",
+                                "(i)", edid_id);
+       check_rpc();
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_port_set_edid:
+ * @id: The ID of the port to set the EDID on
+ * @edid_id: The ID of an EDID on the chamelium created with
+ * #chamelium_new_edid, or 0 to disable the EDID on the port
+ *
+ * Sets a port on the chamelium to use the specified EDID. This does not fire a
+ * hotplug pulse on it's own, and merely changes what EDID the chamelium port
+ * will report to us the next time we probe it. Users will need to reprobe the
+ * connectors themselves if they want to see the EDID reported by the port
+ * change.
+ */
+void chamelium_port_set_edid(int id, int edid_id)
+{
+       xmlrpc_value *res;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "ApplyEdid",
+                                "(ii)", id, edid_id);
+       check_rpc();
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_port_set_ddc_state:
+ * @id: The ID of the port whose DDC bus we want to modify
+ * @enabled: Whether or not to enable the DDC bus
+ *
+ * This disables the DDC bus (e.g. the i2c line on the connector that gives us
+ * an EDID) of the specified port on the chamelium. This is useful for testing
+ * behavior on legacy connectors such as VGA, where the presence of a DDC bus
+ * is not always guaranteed.
+ */
+void chamelium_port_set_ddc_state(int port, bool enabled)
+{
+       xmlrpc_value *res;
+
+       igt_debug("%sabling DDC bus on port %d\n",
+                 enabled ? "En" : "Dis", port);
+
+       res = xmlrpc_client_call(&env, chamelium_url, "SetDdcState",
+                                "(ib)", port, enabled);
+       check_rpc();
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_port_get_ddc_state:
+ * @id: The ID of the port whose DDC bus we want to check the status of
+ *
+ * Check whether or not the DDC bus on the specified chamelium port is enabled
+ * or not.
+ *
+ * Returns: %true if the DDC bus is enabled, %false otherwise.
+ */
+bool chamelium_port_get_ddc_state(int id)
+{
+       xmlrpc_value *res;
+       xmlrpc_bool enabled;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "IsDdcEnabled",
+                                "(i)", id);
+       check_rpc();
+
+       xmlrpc_read_bool(&env, res, &enabled);
+
+       xmlrpc_DECREF(res);
+       return enabled;
+}
+
+/**
+ * chamelium_port_get_resolution:
+ * @id: The ID of the port whose display resolution we want to check
+ * @x: Where to store the horizontal resolution of the port
+ * @y: Where to store the verical resolution of the port
+ *
+ * Check the current reported display resolution of the specified port on the
+ * chamelium. This information is provided by the chamelium itself, not DRM.
+ * Useful for verifying that we really are scanning out at the resolution we
+ * think we are.
+ */
+void chamelium_port_get_resolution(int id, int *x, int *y)
+{
+       xmlrpc_value *res, *res_x, *res_y;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "DetectResolution",
+                                "(i)", id);
+       check_rpc();
+
+       xmlrpc_array_read_item(&env, res, 0, &res_x);
+       xmlrpc_array_read_item(&env, res, 1, &res_y);
+       xmlrpc_read_int(&env, res_x, x);
+       xmlrpc_read_int(&env, res_y, y);
+
+       xmlrpc_DECREF(res_x);
+       xmlrpc_DECREF(res_y);
+       xmlrpc_DECREF(res);
+}
+
+static void crc_from_xml(xmlrpc_value *xml_crc, igt_crc_t *out)
+{
+       xmlrpc_value *res;
+       int i;
+
+       out->n_words = xmlrpc_array_size(&env, xml_crc);
+       for (i = 0; i < out->n_words; i++) {
+               xmlrpc_array_read_item(&env, xml_crc, i, &res);
+               xmlrpc_read_int(&env, res, (int*)&out->crc[i]);
+               xmlrpc_DECREF(res);
+       }
+}
+
+/**
+ * chamelium_get_crc_for_area:
+ * @id: The ID of the port from which we want to retrieve the CRC
+ * @x: The X coordinate on the emulated display to start calculating the CRC
+ * from
+ * @y: The Y coordinate on the emulated display to start calculating the CRC
+ * from
+ * @w: The width of the area to fetch the CRC from, or %0 for the whole display
+ * @h: The height of the area to fetch the CRC from, or %0 for the whole display
+ *
+ * Reads back the pixel CRC for an area on the specified chamelium port. This

lib/igt_chamelium.c line 509

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+ * is the same as using the CRC readback from a GPU, the main difference being
+ * the data is provided by the chamelium and also allows us to specify a region
+ * of the screen to use as opposed to the entire thing.
+ *
+ * Returns: The CRC read back from the chamelium
+ */
+igt_crc_t *chamelium_get_crc_for_area(int id, int x, int y, int w, int h)
+{
+       xmlrpc_value *res;
+       igt_crc_t *ret = malloc(sizeof(igt_crc_t));;

Extra ;. Docs should mention that the caller has to free.

Quoted 150 lines
lib/igt_chamelium.c new file +150 -0
+
+       res = xmlrpc_client_call(&env, chamelium_url, "ComputePixelChecksum",
+                                (w && h) ? "(iiiii)" : "(innnn)",
+                                id, x, y, w, h);
+       check_rpc();
+
+       crc_from_xml(res, ret);
+       xmlrpc_DECREF(res);
+
+       return ret;
+}
+
+/**
+ * chamelium_start_capture:
+ * @id: The ID of the port for which we want to start capturing frames on
+ * @x: The X coordinate to crop the video to
+ * @y: The Y coordinate to crop the video to
+ * @w: The width of the cropped video, or %0 for the whole display
+ * @h: The height of the cropped video, or %0 for the whole display
+ *
+ * Starts capturing video frames on the given Chamelium port. Once the user is
+ * finished capturing frames, they should call #chamelium_stop_capture.
+ *
+ * For capturing a single frame, users can use the one-shot
+ * @chamelium_get_crc_for_area
+ */
+void chamelium_start_capture(int id, int x, int y, int w, int h)
+{
+       xmlrpc_client_call(&env, chamelium_url, "StartCapturingVideo",
+                          (w && h) ? "(iiiii)" : "(innnn)", id, x, y, w, h);
+       check_rpc();
+}
+
+/**
+ * chamelium_stop_capture:
+ * @frame_count: The number of frames to wait to capture, or %0 to stop
+ * immediately
+ *
+ * Finishes capturing video frames on the given Chamelium port. If @frame_count
+ * is specified, this call will block until the given number of frames have been
+ * captured.
+ */
+void chamelium_stop_capture(int frame_count)
+{
+       xmlrpc_client_call(&env, chamelium_url, "StopCapturingVideo",
+                          "(i)", frame_count);
+       check_rpc();
+}
+
+/**
+ * chamelium_read_captured_crcs:
+ * @frame_count: Where to store the number of CRCs we read in
+ *
+ * Reads all of the CRCs that have been captured thus far from the Chamelium.
+ *
+ * Returns: An array of @frame_count length containing all of the CRCs we read
+ */
+igt_crc_t *chamelium_read_captured_crcs(int *frame_count)
+{
+       igt_crc_t *ret;
+       xmlrpc_value *res, *elem;
+       int i;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "GetCapturedChecksums",
+                                "(in)", 0);
+       check_rpc();
+
+       *frame_count = xmlrpc_array_size(&env, res);
+       ret = calloc(sizeof(igt_crc_t), *frame_count);
+
+       for (i = 0; i < *frame_count; i++) {
+               xmlrpc_array_read_item(&env, res, i, &elem);
+
+               crc_from_xml(elem, &ret[i]);
+               ret[i].frame = i;
+
+               xmlrpc_DECREF(elem);
+       }
+
+       xmlrpc_DECREF(res);
+
+       return ret;
+}
+
+/**
+ * chamelium_get_frame_limit:
+ * @id: The ID of the port to get the capture frame limit for
+ * @w: The width of the area to get the capture frame limit for, or %0 for the
+ * whole display
+ * @h: The height of the area to get the capture frame limit for, or %0 for the
+ * whole display
+ *
+ * Gets the max number of frames we can capture with the Chamelium for the given
+ * resolution.
+ *
+ * Returns: The number of the max number of frames we can capture
+ */
+int chamelium_get_frame_limit(int id, int w, int h)
+{
+       xmlrpc_value *res;
+       int ret;
+
+       if (!w && !h)
+               chamelium_port_get_resolution(id, &w, &h);
+
+       res = xmlrpc_client_call(&env, chamelium_url, "GetMaxFrameLimit",
+                                "(iii)", id, w, h);
+       check_rpc();
+
+       xmlrpc_read_int(&env, res, &ret);
+       xmlrpc_DECREF(res);
+
+       return ret;
+}
+
+static unsigned int chamelium_get_port_type(int port)
+{
+       xmlrpc_value *res;
+       const char *port_type_str;
+       unsigned int port_type;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "GetConnectorType",
+                                "(i)", port);
+       check_rpc();
+
+       xmlrpc_read_string(&env, res, &port_type_str);
+       igt_debug("Port %d is of type '%s'\n", port, port_type_str);
+
+       if (strcmp(port_type_str, "DP") == 0)
+               port_type = DRM_MODE_CONNECTOR_DisplayPort;
+       else if (strcmp(port_type_str, "HDMI") == 0)
+               port_type = DRM_MODE_CONNECTOR_HDMIA;
+       else if (strcmp(port_type_str, "VGA") == 0)
+               port_type = DRM_MODE_CONNECTOR_VGA;
+       else
+               port_type = DRM_MODE_CONNECTOR_Unknown;
+
+       free((void*)port_type_str);
+       xmlrpc_DECREF(res);
+
+       return port_type;
+}
+
+static void chamelium_read_port_mappings(int drm_fd, GKeyFile *key_file)
+{
+       drmModeRes *res;
+       drmModeConnector *connector;
+       struct chamelium_port *port;
+       GError *error = NULL;
+       char **group_list;

lib/igt_chamelium.c line 669

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+       char *group;
+       size_t group_list_len;
+       int port_i, i, j;
+
+       group_list = g_key_file_get_groups(key_file, &group_list_len);
+       chamelium_port_count = group_list_len - 1;
+       chamelium_ports = calloc(sizeof(struct chamelium_port),
+                                chamelium_port_count);
+       memset(chamelium_ports, 0,
+              sizeof(struct chamelium_port) * chamelium_port_count);

calloc already zeroes.

Quoted 53 lines
lib/igt_chamelium.c new file +53 -0
+       port_i = 0;
+       res = drmModeGetResources(drm_fd);
+
+       for (i = 0; group_list[i] != NULL; i++) {
+               group = group_list[i];
+
+               if (strcmp(group, "Chamelium") == 0)
+                       continue;
+
+               port = &chamelium_ports[port_i++];
+               port->connector_name = strdup(group);
+               port->id = g_key_file_get_integer(key_file, group,
+                                                 "ChameliumPortID",
+                                                 &error);
+               igt_require_f(port->id,
+                             "Failed to read chamelium port ID for %s: %s\n",
+                             group, error->message);
+
+               port->type = chamelium_get_port_type(port->id);
+               igt_require_f(port->type != DRM_MODE_CONNECTOR_Unknown,
+                             "Unable to retrieve the physical port type from the Chamelium for '%s'\n",
+                             group);
+
+               for (j = 0;
+                    j < res->count_connectors && !port->connector_id;
+                    j++) {
+                       char connector_name[50];
+
+                       connector = drmModeGetConnectorCurrent(
+                           drm_fd, res->connectors[j]);
+
+                       /* We have to generate the connector name on our own */
+                       snprintf(connector_name, 50, "%s-%u",
+                                kmstest_connector_type_str(connector->connector_type),
+                                connector->connector_type_id);
+
+                       if (strcmp(connector_name, group) == 0)
+                               port->connector_id = connector->connector_id;
+
+                       drmModeFreeConnector(connector);
+               }
+               igt_assert_f(port->connector_id,
+                            "No connector found with name '%s'\n", group);
+
+               igt_debug("Port '%s' with physical type '%s' mapped to Chamelium port %d\n",
+                         group, kmstest_connector_type_str(port->type),
+                         port->id);
+       }
+
+       drmModeFreeResources(res);
+       g_strfreev(group_list);
+}
+

lib/igt_chamelium.c line 732

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+static void chamelium_read_config(int drm_fd)
+{
+       GKeyFile *key_file = g_key_file_new();
+       GError *error = NULL;
+       char *key_file_loc;
+       int rc;
+
+       key_file_loc = getenv("CHAMELIUM_CONFIG_PATH");
+       if (!key_file_loc) {
+               igt_require(key_file_loc = alloca(100));

Why skip the current test if alloca fails? Actually, why checking alloca's result? If we aren't 100% sure that alloca will succeed, we should be using malloc instead.

lib/igt_chamelium.c line 740

Quoted 8 lines
lib/igt_chamelium.c new file +8 -0
+               snprintf(key_file_loc, 100, "%s/.igt_chamelium_rc",
+                        g_get_home_dir());
+       }
+
+       rc = g_key_file_load_from_file(key_file, key_file_loc,
+                                      G_KEY_FILE_NONE, &error);
+       igt_require_f(rc, "Failed to read chamelium configuration file: %s\n",
+                     error->message);

Not sure I agree with the usage of igt_require in this patch. How I envision this to work, is that we require that the functionality to be tested is there, otherwise we skip. But once we have determined that, if there is any problem when testing that functionality, it should cause a failure.

I think it's also better if the test code is able to decide whether to skip or fail.

Quoted 152 lines
lib/igt_chamelium.c new file +108 -0
+       chamelium_url = g_key_file_get_string(key_file, "Chamelium", "URL",
+                                             &error);
+       igt_require_f(chamelium_url,
+                     "Couldn't read chamelium URL from config file: %s\n",
+                     error->message);
+
+       chamelium_read_port_mappings(drm_fd, key_file);
+
+       g_key_file_free(key_file);
+}
+
+/**
+ * chamelium_reset:
+ *
+ * Resets the chamelium's IO board. As well, this also has the effect of
+ * causing all of the chamelium ports to get set to unplugged
+ */
+void chamelium_reset(void)
+{
+       xmlrpc_value *res;
+
+       igt_debug("Resetting the chamelium\n");
+
+       res = xmlrpc_client_call(&env, chamelium_url, "Reset", "()");
+       check_rpc();
+
+       xmlrpc_DECREF(res);
+}
+
+static void chamelium_exit_handler(int sig)
+{
+       xmlrpc_env_clean(&env);
+       xmlrpc_env_init(&env);
+
+       chamelium_deinit();
+}
+
+/**
+ * chamelium_init:
+ * @drm_fd: drm file descriptor
+ *
+ * Sets up a connection with a chamelium, using the URL specified in the
+ * Chamelium configuration. This must be called first before trying to use the
+ * chamelium.
+ *
+ * If we fail to establish a connection with the chamelium, fail to find a
+ * configured connector, etc. we fail the current test.
+ */
+void chamelium_init(int drm_fd)
+{
+       xmlrpc_env_init(&env);
+
+       xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, PACKAGE,
+                           PACKAGE_VERSION, NULL, 0);
+       igt_fail_on_f(env.fault_occurred,
+                     "Failed to init xmlrpc: %s\n",
+                     env.fault_string);
+
+       chamelium_read_config(drm_fd);
+       chamelium_reset();
+
+       igt_install_exit_handler(chamelium_exit_handler);
+}
+
+/**
+ * chamelium_deinit:
+ *
+ * Frees the resources used by a connection to the chamelium that was set up
+ * with #chamelium_init. As well, this function restores the state of the
+ * chamelium like it was before calling #chamelium_init. This function is also
+ * called as an exit handler, so users only need to call manually if they don't
+ * want the chamelium interfering with other tests in the same file.
+ */
+void chamelium_deinit(void)
+{
+       int i;
+       struct chamelium_edid *pos, *tmp;
+
+       if (!chamelium_url)
+               return;
+
+       /* We want to make sure we leave all of the ports plugged in, since
+        * testing setups requiring multiple monitors are probably using the
+        * chamelium to provide said monitors
+        */
+       chamelium_reset();
+       for (i = 0; i < chamelium_port_count; i++)
+               chamelium_plug(chamelium_ports[i].id);
+
+       /* Destroy any EDIDs we created to make sure we don't leak them */
+       igt_list_for_each_safe(pos, tmp, &allocated_edids->link, link) {
+               chamelium_destroy_edid(pos->id);
+               free(pos);
+       }
+
+       xmlrpc_client_cleanup();
+       xmlrpc_env_clean(&env);
+
+       for (i = 0; i < chamelium_port_count; i++)
+               free(chamelium_ports[i].connector_name);
+
+       free(chamelium_ports);
+       allocated_edids = NULL;
+       chamelium_url = NULL;
+       chamelium_ports = NULL;
+       chamelium_port_count = 0;
+}
+
lib/igt_chamelium.h new file +38 -0
new file mode 100644
index 0000000..2f7aadf
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2016 Red Hat Inc.
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ * Authors: Lyude Paul <[email protected]>
+ */
+
+#ifndef IGT_CHAMELIUM_H
+#define IGT_CHAMELIUM_H
+
+#include "config.h"
+#include "igt.h"
+#include <stdbool.h>
+
+/**
+ * chamelium_port:
+ * @type: The DRM connector type of the chamelium port (not the host's)
+ * @id: The ID of the chamelium port
+ * @connector_id: The ID of the DRM connector connected to this port
+ * @connector_name: The name of the DRM connector

lib/igt_chamelium.h line 48

Quoted 10 lines
lib/igt_chamelium.h new file +9 -0
+ */
+struct chamelium_port {
+       unsigned int type;
+       int id;
+       int connector_id;
+       char *connector_name;
+};
 
+extern int chamelium_port_count;
+extern struct chamelium_port *chamelium_ports;

Not sure it's a good idea to expose all this to tests. Afterwards could be a lot of work to update tests if we decide to do changes.

Quoted 31 lines
lib/igt_chamelium.h new file +24 -0
+void chamelium_init(int drm_fd);
+void chamelium_deinit(void);
+void chamelium_reset(void);
+
+void chamelium_plug(int id);
+void chamelium_unplug(int id);
+bool chamelium_is_plugged(int id);
+bool chamelium_port_wait_video_input_stable(int id, int timeout_secs);
+void chamelium_fire_mixed_hpd_pulses(int id, ...);
+void chamelium_fire_hpd_pulses(int id, int width_msec, int count);
+void chamelium_async_hpd_pulse_start(int id, bool high, int delay_secs);
+void chamelium_async_hpd_pulse_finish(void);
+int chamelium_new_edid(const unsigned char *edid);
+void chamelium_port_set_edid(int id, int edid_id);
+bool chamelium_port_get_ddc_state(int id);
+void chamelium_port_set_ddc_state(int id, bool enabled);
+void chamelium_port_get_resolution(int id, int *x, int *y);
+igt_crc_t *chamelium_get_crc_for_area(int id, int x, int y, int w, int h);
+void chamelium_start_capture(int id, int x, int y, int w, int h);
+void chamelium_stop_capture(int frame_count);
+igt_crc_t *chamelium_read_captured_crcs(int *frame_count);
+int chamelium_get_frame_limit(int id, int w, int h);
+
+#endif /* IGT_CHAMELIUM_H */
scripts/run-tests.sh +0 -0
index 97ba9e5..6539bf9 100755
@@ -122,10 +122,10 @@ if [ ! -x "$PIGLIT" ]; then
 fi
 

scripts/run-tests.sh if [ ! -x "$PIGLIT" ]; then · line 131

Quoted 10 lines
scripts/run-tests.sh +2 -2
 if [ "x$RESUME" != "x" ]; then
-       sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" "$PIGLIT" resume "$RESULTS" $NORETRY
+       sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" CHAMELIUM_HOST="$CHAMELIUM_HOST" "$PIGLIT" resume "$RESULTS" $NORETRY
 else
        mkdir -p "$RESULTS"
-       sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" "$PIGLIT" run igt -o "$RESULTS" -s $VERBOSE $EXCLUDE $FILTER
+       sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" CHAMELIUM_HOST="$CHAMELIUM_HOST" "$PIGLIT" run igt -o "$RESULTS" -s $VERBOSE $EXCLUDE $FILTER
 fi
 
 if [ "$SUMMARY" == "html" ]; then

Guess this isn't needed any more?

Quoted 14 lines
tests/Makefile.am +1 -1
index a408126..06a8e6b 100644
@@ -63,7 +63,7 @@ AM_CFLAGS = $(DRM_CFLAGS) $(CWARNFLAGS) -Wno-unused-result $(DEBUG_CFLAGS)\
        $(LIBUNWIND_CFLAGS) $(WERROR_CFLAGS) \
        $(NULL)
 
-LDADD = ../lib/libintel_tools.la $(GLIB_LIBS)
+LDADD = ../lib/libintel_tools.la $(GLIB_LIBS) $(XMLRPC_LIBS)
 
 AM_CFLAGS += $(CAIRO_CFLAGS) $(LIBUDEV_CFLAGS) $(GLIB_CFLAGS)
 AM_LDFLAGS = -Wl,--as-needed

tests/Makefile.am vc4_wait_bo_CFLAGS = $(AM_CFLAGS) $(DRM_VC4_CFLAGS) · line 124

Quoted 6 lines
tests/Makefile.am +3 -0
@@ -119,5 +119,8 @@ vc4_wait_bo_CFLAGS = $(AM_CFLAGS) $(DRM_VC4_CFLAGS)
 vc4_wait_bo_LDADD = $(LDADD) $(DRM_VC4_LIBS)
 vc4_wait_seqno_CFLAGS = $(AM_CFLAGS) $(DRM_VC4_CFLAGS)
 vc4_wait_seqno_LDADD = $(LDADD) $(DRM_VC4_LIBS)
+
+chamelium_CFLAGS = $(AM_CFLAGS) $(XMLRPC_CFLAGS) $(UDEV_CFLAGS)
+chamelium_LDADD = $(LDADD) $(XMLRPC_LIBS) $(UDEV_LIBS)

Same as before (the package prefix is LIBUDEV).

Quoted 9 lines
tests/Makefile.am +0 -0
 endif
 
tests/Makefile.sources +0 -0
index 57a10c5..5eeae77 100644
@@ -135,8 +135,13 @@ TESTS_progs_M = \
        prime_vgem \
        template \

tests/Makefile.sources TESTS_progs_M = \ · line 144

Quoted 10 lines
tests/Makefile.sources +7 -2
        vgem_basic \
-       vgem_slow \
-       $(NULL)
+       vgem_slow
+
+if HAVE_CHAMELIUM
+TESTS_progs_M += chamelium
+endif
+
+TESTS_progs_M += $(NULL)

Same as before.

Quoted 115 lines
tests/Makefile.sources +0 -0
 TESTS_progs_XM = \
     gem_concurrent_all \
tests/chamelium.c new file +107 -0
new file mode 100644
index 0000000..e0f645a
@@ -0,0 +1,407 @@
+/*
+ * Copyright © 2016 Red Hat Inc.
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ * Authors:
+ *    Lyude Paul <[email protected]>
+ */
+
+#include "config.h"
+#include "igt.h"
+
+#include <fcntl.h>
+#include <string.h>
+
+typedef struct {
+       int drm_fd;
+} data_t;
+
+#define HOTPLUG_TIMEOUT 20 /* seconds */
+
+static void
+require_connector_present(data_t *data, unsigned int type)
+{
+       int i;
+       bool found = false;
+
+       for (i = 0; i < chamelium_port_count && !found; i++) {
+               if (chamelium_ports[i].type == type)
+                       found = true;
+       }
+
+       igt_require_f(found, "No port of type %s was found\n",
+                     kmstest_connector_type_str(type));
+}
+
+static drmModeConnection
+reprobe_connector(data_t *data, struct chamelium_port *port)
+{
+       drmModeConnector *connector;
+       drmModeConnection status;
+
+       igt_debug("Reprobing %s...\n", port->connector_name);
+       connector = drmModeGetConnector(data->drm_fd, port->connector_id);
+       igt_assert(connector);
+       status = connector->connection;
+
+       drmModeFreeConnector(connector);
+       return status;
+}
+
+static void
+wait_for_connector(data_t *data, struct chamelium_port *port,
+                  drmModeConnection status)
+{
+       bool finished = false;
+
+       igt_debug("Waiting for %s to %sconnect...\n", port->connector_name,
+                 status == DRM_MODE_DISCONNECTED ? "dis" : "");
+
+       /*
+        * Rely on simple reprobing so we don't fail tests that don't require
+        * that hpd events work in the event that hpd doesn't work on the system
+        */
+       igt_until_timeout(HOTPLUG_TIMEOUT) {
+               if (reprobe_connector(data, port) == status) {
+                       finished = true;
+                       return;
+               }
+
+               sleep(1);
+       }
+
+       igt_assert(finished);
+}
+
+static void
+reset_state(data_t *data, struct chamelium_port *port)
+{
+       igt_reset_connectors();
+       chamelium_reset();
+       wait_for_connector(data, port, DRM_MODE_DISCONNECTED);
+}
+
+static void
+test_basic_hotplug(data_t *data, struct chamelium_port *port)
+{
+       int i;
+
+       reset_state(data, port);

tests/chamelium.c line 117

Quoted 10 lines
tests/chamelium.c new file +10 -0
+
+       igt_watch_hotplug();
+
+       for (i = 0; i < 15; i++) {
+               igt_flush_hotplugs();
+
+               /* Check if we get a sysfs hotplug event */
+               chamelium_plug(port->id);
+               igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+               igt_assert(reprobe_connector(data, port) == DRM_MODE_CONNECTED);

Better use igt_assert_eq in case we get DRM_MODE_UNKNOWNCONNECTION?

tests/chamelium.c line 125

Quoted 8 lines
tests/chamelium.c new file +8 -0
+
+               igt_flush_hotplugs();
+
+               /* Now check if we get a hotplug from disconnection */
+               chamelium_unplug(port->id);
+               igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+               igt_assert(reprobe_connector(data, port) ==
+                          DRM_MODE_DISCONNECTED);

Ditto.

tests/chamelium.c line 128

Quoted 2 lines
tests/chamelium.c new file +2 -0
+               /* Sleep so we don't accidentally cause an hpd storm */
+               sleep(1);

Wouldn't such a long sleep unnecessarily slow test runs down?

Quoted 14 lines
tests/chamelium.c new file +14 -0
+       }
+}
+
+static void
+test_edid_read(data_t *data, struct chamelium_port *port,
+              int edid_id, const unsigned char *edid)
+{
+       drmModePropertyBlobPtr edid_blob = NULL;
+       uint64_t edid_blob_id;
+
+       reset_state(data, port);
+
+       chamelium_port_set_edid(port->id, edid_id);
+       chamelium_plug(port->id);

tests/chamelium.c line 152

Quoted 10 lines
tests/chamelium.c new file +10 -0
+       wait_for_connector(data, port, DRM_MODE_CONNECTED);
+
+       igt_assert(kmstest_get_property(data->drm_fd, port->connector_id,
+                                       DRM_MODE_OBJECT_CONNECTOR, "EDID", NULL,
+                                       &edid_blob_id, NULL));
+       igt_assert(edid_blob = drmModeGetPropertyBlob(data->drm_fd,
+                                                     edid_blob_id));
+
+       /* Compare the EDID from the connector to what we expect */
+       igt_assert(memcmp(edid, edid_blob->data, EDID_LENGTH) == 0);

Would be cool if we had a igt_assert_mem_eq or such that would print the unexpected and expected values to the log (properly capped, of course).

tests/chamelium.c line 162

Quoted 9 lines
tests/chamelium.c new file +9 -0
+       drmModeFreePropertyBlob(edid_blob);
+}
+
+static void
+test_suspend_resume_hpd(data_t *data, struct chamelium_port *port,
+                       enum igt_suspend_state state,
+                       enum igt_suspend_test test)
+{
+       int delay = 7;

Would be better to have this and the 15 below as constants so it's easier to see what knobs are there at a glance?

Quoted 23 lines
tests/chamelium.c new file +23 -0
+       igt_skip_without_suspend_support(state, test);
+       reset_state(data, port);
+       igt_watch_hotplug();
+
+       igt_set_autoresume_delay(15);
+
+       /* Make sure we notice new connectors after resuming */
+       chamelium_async_hpd_pulse_start(port->id, false, delay);
+       igt_system_suspend_autoresume(state, test);
+       chamelium_async_hpd_pulse_finish();
+
+       igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+       igt_assert(reprobe_connector(data, port) == DRM_MODE_CONNECTED);
+
+       igt_flush_hotplugs();
+
+       /* Now make sure we notice disconnected connectors after resuming */
+       chamelium_async_hpd_pulse_start(port->id, true, delay);
+       igt_system_suspend_autoresume(state, test);
+       chamelium_async_hpd_pulse_finish();
+
+       igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+       igt_assert(reprobe_connector(data, port) == DRM_MODE_DISCONNECTED);

tests/chamelium.c line 196

Quoted 10 lines
tests/chamelium.c new file +10 -0
+}
+
+static void
+test_suspend_resume_edid_change(data_t *data, struct chamelium_port *port,
+                               enum igt_suspend_state state,
+                               enum igt_suspend_test test,
+                               int edid_id,
+                               int alt_edid_id)
+{
+       igt_skip_without_suspend_support(state, test);

Maybe igt_require_suspend?

Quoted 37 lines
tests/chamelium.c new file +37 -0
+       reset_state(data, port);
+       igt_watch_hotplug();
+
+       /* First plug in the port */
+       chamelium_port_set_edid(port->id, edid_id);
+       chamelium_plug(port->id);
+       wait_for_connector(data, port, DRM_MODE_CONNECTED);
+
+       igt_flush_hotplugs();
+
+       /*
+        * Change the edid before we suspend. On resume, the machine should
+        * notice the EDID change and fire a hotplug event.
+        */
+       chamelium_port_set_edid(port->id, alt_edid_id);
+
+       igt_system_suspend_autoresume(state, test);
+       igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+}
+
+static void
+test_display(data_t *data, struct chamelium_port *port)
+{
+       igt_display_t display;
+       igt_output_t *output;
+       igt_plane_t *primary;
+       struct igt_fb fb;
+       drmModeRes *res;
+       drmModeModeInfo *mode;
+       drmModeConnector *connector;
+       uint32_t crtc_id;
+       int fb_id;
+
+       reset_state(data, port);
+
+       chamelium_plug(port->id);
+       wait_for_connector(data, port, DRM_MODE_CONNECTED);

tests/chamelium.c line 243

Quoted 10 lines
tests/chamelium.c new file +10 -0
+       igt_assert(res = drmModeGetResources(data->drm_fd));
+       kmstest_unset_all_crtcs(data->drm_fd, res);
+
+       igt_display_init(&display, data->drm_fd);
+
+       /* Find the output struct for this connector */
+       for_each_connected_output(&display, output) {
+               if (output->config.connector->connector_id ==
+                   port->connector_id)
+                       break;

Are we that sure that we'll always find such an output? Could be quite disconcerting if that stopped being true, even if by a bug.

Quoted 19 lines
tests/chamelium.c new file +19 -0
+       }
+
+       connector = drmModeGetConnectorCurrent(data->drm_fd,
+                                              port->connector_id);
+
+       /* Find a spare CRTC to use for the display */
+       crtc_id = kmstest_find_crtc_for_connector(data->drm_fd, res, connector,
+                                                 0);
+
+       /* Setup the display */
+       igt_output_set_pipe(output, kmstest_get_pipe_from_crtc_id(data->drm_fd,
+                                                                 crtc_id));
+       mode = igt_output_get_mode(output);
+       primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY);
+       igt_assert(primary);
+
+       fb_id = igt_create_pattern_fb(data->drm_fd,
+                                     mode->hdisplay,
+                                     mode->vdisplay,

tests/chamelium.c line 272

Quoted 10 lines
tests/chamelium.c new file +10 -0
+                                     DRM_FORMAT_XRGB8888,
+                                     LOCAL_DRM_FORMAT_MOD_NONE,
+                                     &fb);
+       igt_assert(fb_id > 0);
+       igt_plane_set_fb(primary, &fb);
+
+       igt_display_commit(&display);
+
+       igt_assert(chamelium_port_wait_video_input_stable(port->id,
+                                                         HOTPLUG_TIMEOUT));

If we have all this already, wouldn't make sense to also test that the CRC functions work as expected?

Quoted 56 lines
tests/chamelium.c new file +56 -0
+       drmModeFreeResources(res);
+       drmModeFreeConnector(connector);
+       igt_display_fini(&display);
+}
+
+static void
+test_hpd_without_ddc(data_t *data, struct chamelium_port *port)
+{
+       reset_state(data, port);
+       igt_watch_hotplug();
+
+       /* Disable the DDC on the connector and make sure we still get a
+        * hotplug
+        */
+       chamelium_port_set_ddc_state(port->id, false);
+       chamelium_plug(port->id);
+
+       igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+       igt_assert(reprobe_connector(data, port) == DRM_MODE_CONNECTED);
+}
+
+#define for_each_port(p, port)                  \
+       for (p = 0, port = &chamelium_ports[p]; \
+            p < chamelium_port_count;          \
+            p++, port = &chamelium_ports[p])   \
+
+#define connector_subtest(name__, type__) \
+       igt_subtest(name__)               \
+               for_each_port(p, port)    \
+                       if (port->type == DRM_MODE_CONNECTOR_ ## type__)
+
+#define define_common_connector_tests(type_str__, type__)                     \
+       connector_subtest(type_str__ "-hpd", type__)                          \
+               test_basic_hotplug(&data, port);                              \
+                                                                              \
+       connector_subtest(type_str__ "-edid-read", type__) {                  \
+               test_edid_read(&data, port, edid_id,                          \
+                              igt_kms_get_base_edid());                      \
+               test_edid_read(&data, port, alt_edid_id,                      \
+                              igt_kms_get_alt_edid());                       \
+       }                                                                     \
+                                                                              \
+       connector_subtest(type_str__ "-hpd-after-suspend", type__)            \
+               test_suspend_resume_hpd(&data, port,                          \
+                                       SUSPEND_STATE_MEM,                    \
+                                       SUSPEND_TEST_NONE);                   \
+                                                                              \
+       connector_subtest(type_str__ "-hpd-after-hibernate", type__)          \
+               test_suspend_resume_hpd(&data, port,                          \
+                                       SUSPEND_STATE_DISK,                   \
+                                       SUSPEND_TEST_DEVICES);                \
+                                                                              \
+       connector_subtest(type_str__ "-edid-change-during-suspend", type__)   \
+               test_suspend_resume_edid_change(&data, port,                  \
+                                               SUSPEND_STATE_MEM,            \
+                                               SUSPEND_TEST_NONE,            \

tests/chamelium.c line 339

Quoted 10 lines
tests/chamelium.c new file +10 -0
+                                               edid_id, alt_edid_id);        \
+                                                                              \
+       connector_subtest(type_str__ "-edid-change-during-hibernate", type__) \
+               test_suspend_resume_edid_change(&data, port,                  \
+                                               SUSPEND_STATE_DISK,           \
+                                               SUSPEND_TEST_DEVICES,         \
+                                               edid_id, alt_edid_id);        \
+                                                                              \
+       connector_subtest(type_str__ "-display", type__)                      \
+               test_display(&data, port);

Not sure about the others, but I think I would prefer if this was C code.

Quoted 68 lines
tests/chamelium.c new file +67 -1
+static data_t data;
+
+igt_main
+{
+       struct chamelium_port *port;
+       int edid_id, alt_edid_id, p;
+
+       igt_fixture {
+               igt_skip_on_simulation();
+
+               data.drm_fd = drm_open_driver_master(DRIVER_ANY);
+
+               chamelium_init(data.drm_fd);
+
+               edid_id = chamelium_new_edid(igt_kms_get_base_edid());
+               alt_edid_id = chamelium_new_edid(igt_kms_get_alt_edid());
+
+               /* So fbcon doesn't try to reprobe things itself */
+               kmstest_set_vt_graphics_mode();
+       }
+
+       igt_subtest_group {
+               igt_fixture {
+                       require_connector_present(
+                           &data, DRM_MODE_CONNECTOR_DisplayPort);
+               }
+
+               define_common_connector_tests("dp", DisplayPort);
+       }
+
+       igt_subtest_group {
+               igt_fixture {
+                       require_connector_present(
+                           &data, DRM_MODE_CONNECTOR_HDMIA);
+               }
+
+               define_common_connector_tests("hdmi", HDMIA);
+       }
+
+       igt_subtest_group {
+               igt_fixture {
+                       require_connector_present(
+                           &data, DRM_MODE_CONNECTOR_VGA);
+               }
+
+               connector_subtest("vga-hpd", VGA)
+                       test_basic_hotplug(&data, port);
+
+               connector_subtest("vga-edid-read", VGA) {
+                       test_edid_read(&data, port, edid_id,
+                                      igt_kms_get_base_edid());
+                       test_edid_read(&data, port, alt_edid_id,
+                                      igt_kms_get_alt_edid());
+               }
+
+               /* FIXME: Right now there isn't a way to do any sort of delayed
+                * psuedo-hotplug with VGA, so testing detection after a
+                * suspend/resume cycle isn't possible yet
+                */
+
+               connector_subtest("vga-hpd-without-ddc", VGA)
+                       test_hpd_without_ddc(&data, port);
+
+               connector_subtest("vga-display", VGA)
+                       test_display(&data, port);
+       }
+}
--
Quoted 2 lines

2.9.3

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

author
#7 lore raw

Re: [RFC i-g-t v3 5/5] Add support for hotplug testing with the Chamelium

Quoted 340 lines · Tomeu Vizoso

Hi Lyude,

this looks very good. Some minor comments below.

Regards,

Tomeu

Quoted 106 lines · Lyude

For the purpose of testing things such as hotplugging and bad monitors,
the ChromeOS team ended up designing a neat little device known as the
Chamelium. More information on this can be found here:

        https://www.chromium.org/chromium-os/testing/chamelium

This adds support for a couple of things to intel-gpu-tools:
 - igt library functions for connecting to udev and monitoring it for
   hotplug events, loosely based off of the unfinished hotplugging implementation in testdisplay
 - Library functions for controlling the chamelium in tests using xmlrpc. A couple of RPC calls were ommitted here, mainly because they
   didn't seem very useful for our needs (yet)
 - A set of basic tests using the chamelium.

Changes since v1:
- Don't try to guess connector mappings, have the user specify them manually using a configuration file
- Open DRM fd using DRIVER_ANY, not DRIVER_INTEL
- Lower the hotplug timeout a little bit, since 30 seconds was leftover
  from debugging these tests anyway
- Don't try to keep track of the original state of the chamelium ports,
  and just leave them plugged in after each run. This makes more sense
  to me, since I'd imagine in automated testing setups using chameliums
  that all of the extra monitors will probably be provided by the Chamelium to begin with, so keeping them plugged in would make sure
  tests running afterwards that require >1 monitor don't get skipped.
- Add wait_for_connector() to the chamelium tests. After some more testing, I found that depending on the system some tests would throw
  false negatives due to us not waiting long enough for the system to
  detect that we connected something to it. This mainly happened with
  VGA connectors, since their lack of HPD makes them take significantly
  longer for the hardware to notice. wait_for_connector() fixes this by
  continually reprobing the status of the desired connector (without
  relying on a hpd event happening, since that might never come) until
  we get what we want, or we time out and fail.
- Use kmstest_get_property() for retrieving EDIDs instead of doing it by
  hand
- Don't hardcode PIPE_A for bringing up the display, use kmstest to find
  an appropriate CRTC to use.
Changes since v2:
- Fix incorrect usage of the list helpers when recording new EDIDs
- Add missing documentation
- Make sure documentation actually appears
- Since we finally got video capture working, add CRC functions and fix
  the ones we couldn't actually test before
- In the exit handler, reset the xmlrpc env so we can properly reset the
  Chamelium even after an RPC error
- Make sure compiling without Chamelium support still works
---
 configure.ac                                       |  13 + .../intel-gpu-tools/intel-gpu-tools-docs.xml       |   1 + lib/Makefile.am                                    |   4 +- lib/Makefile.sources                               |  10 +- lib/igt.h                                          |   4 + lib/igt_chamelium.c                                | 849
+++++++++++++++++++++
 lib/igt_chamelium.h                                |  73 ++ scripts/run-tests.sh                               |   4 +- tests/Makefile.am                                  |   5 +- tests/Makefile.sources                             |   9 +- tests/chamelium.c                                  | 407
++++++++++

 11 files changed, 1371 insertions(+), 8 deletions(-)

 create mode 100644 lib/igt_chamelium.c
 create mode 100644 lib/igt_chamelium.h
 create mode 100644 tests/chamelium.c

configure.ac +0 -0
index b62b8fc..1920609 100644
@@ -263,6 +263,18 @@ if test "x$with_libunwind" = xyes; then

                          AC_MSG_ERROR([libunwind not found. Use -- without-libunwind to disable libunwind support.]))
 fi

configure.ac +4 -0
+# enable support for using the chamelium
+AC_ARG_ENABLE(chamelium,
+             AS_HELP_STRING([--disable-chamelium],
+                            [Build tests without chamelium

support]),
+             [], [enable_chamelium=yes])

configure.ac if test "x$with_libunwind" = xyes; then · line 277

Quoted 7 lines
configure.ac +7 -0
+
+AM_CONDITIONAL(HAVE_CHAMELIUM, [test "x$enable_chamelium" = xyes])
+if test "x$enable_chamelium" = xyes; then
+       AC_DEFINE(HAVE_CHAMELIUM, 1, [chamelium suport])
+       PKG_CHECK_MODULES(XMLRPC, xmlrpc_client)
+fi
+

IMO libxmlrpc is a very common dependency and thus adding the possibility of disabling Chamelium support isn't worth the cruft we have to add later. Plus, alternative build configurations tend to break and remain broken as most people hacking on the project won't be
using them.

Quoted 43 lines
 # enable debug symbols
 AC_ARG_ENABLE(debug,
              AS_HELP_STRING([--disable-debug],
configure.ac +0 -0
@@ -360,6 +372,7 @@ echo "       Assembler          :

${enable_assembler}"
 echo "       Debugger           : ${enable_debugger}" echo "       Overlay            : X: ${enable_overlay_xlib}, Xv:
${enable_overlay_xvlib}"
 echo "       x86-specific tools : ${build_x86}"
+echo "       Chamelium support  : ${enable_chamelium}" echo ""
 echo " • API-Documentation      : ${enable_gtk_doc}" echo " • Fail on warnings       : ${enable_werror}"

(quoted diff) +0 -0

docs.xml b/docs/reference/intel-gpu-tools/intel-gpu-tools-docs.xml index 55902ab..f515f33 100644

docs/reference/intel-gpu-tools/intel-gpu-tools-docs.xml +0 -0
@@ -33,6 +33,7 @@

     <xi:include href="xml/igt_vc4.xml"/> <xi:include href="xml/igt_vgem.xml"/> <xi:include href="xml/igt_dummyload.xml"/> +    <xi:include href="xml/igt_chamelium.xml"/> </chapter>
   <xi:include href="xml/igt_test_programs.xml"/>

lib/Makefile.am +0 -0
index b7c7020..0136663 100644
@@ -23,7 +23,7 @@ if !HAVE_LIBDRM_INTEL

 endif

 AM_CPPFLAGS = -I$(top_srcdir)
-AM_CFLAGS = $(CWARNFLAGS) $(DRM_CFLAGS) $(PCIACCESS_CFLAGS) $(KMOD_CFLAGS) $(LIBUNWIND_CFLAGS) $(DEBUG_CFLAGS) \
+AM_CFLAGS = $(CWARNFLAGS) $(DRM_CFLAGS) $(PCIACCESS_CFLAGS) $(KMOD_CFLAGS) $(LIBUNWIND_CFLAGS) $(DEBUG_CFLAGS) $(XMLRPC_CFLAGS) $(UDEV_CFLAGS) \
            -DIGT_SRCDIR=\""$(abs_top_srcdir)/tests"\" \
            -DIGT_DATADIR=\""$(pkgdatadir)"\" \
            -DIGT_LOG_DOMAIN=\""$(subst _,-,$*)"\" \

lib/Makefile.am libintel_tools_la_LIBADD = \ · line 43

Quoted 5 lines
lib/Makefile.am +2 -0
@@ -39,5 +39,7 @@ libintel_tools_la_LIBADD = \
         $(LIBUDEV_LIBS) \
         $(LIBUNWIND_LIBS) \
         $(TIMER_LIBS) \
+       $(XMLRPC_LIBS) \
+       $(UDEV_LIBS) \

The prefix we passed to PKG_CHECK_MODULES is LIBUDEV.

Quoted 10 lines

        -lm

lib/Makefile.sources +0 -0
index 7fc5ec2..7132e32 100644
@@ -78,8 +78,14 @@ lib_source_list =            \
         igt_dummyload.c         \
         igt_dummyload.h         \
         uwildmat/uwildmat.h     \

lib/Makefile.sources lib_source_list =            \ · line 88

Quoted 10 lines
lib/Makefile.sources +8 -2
-       uwildmat/uwildmat.c     \
-       $(NULL)
+       uwildmat/uwildmat.c
+
+if HAVE_CHAMELIUM
+lib_source_list += igt_chamelium.h \
+                  igt_chamelium.c
+endif
+
+lib_source_list += $(NULL)

The $(NULL) was there just so the last line in lib_source_list could end with \ and thus adding more files to the end wouldn't have to change more lines than strictly needed.

Quoted 80 lines

 .PHONY: version.h.tmp

lib/igt.h +4 -0
index a0028d5..d0ded79 100644
@@ -47,4 +47,8 @@
  #include "media_spin.h"
  #include "rendercopy.h"
 
+#ifdef HAVE_CHAMELIUM
+#include "igt_chamelium.h"
+#endif
+
  #endif /* IGT_H */
lib/igt_chamelium.c new file +4 -0
new file mode 100644
index 0000000..ee94e4a
@@ -0,0 +1,849 @@
+/*
+ * Copyright © 2016 Red Hat Inc.
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ * Authors:
+ *  Lyude Paul <[email protected]>
+ */

lib/igt_chamelium.c new file +13 -0
+
+#include "config.h"
+
+#include <string.h>
+#include <errno.h>
+#include <xmlrpc-c/base.h>
+#include <xmlrpc-c/client.h>
+#include <glib.h>
+
+#include "igt.h"
+
+#define check_rpc() \
+       igt_assert_f(!env.fault_occurred, "Chamelium RPC call

failed: %s\n", \
+                    env.fault_string);

lib/igt_chamelium.c new file +4 -0
+
+/**
+ * SECTION:igt_chamelium
+ * @short_description: Library for encorporating the Chamelium
Quoted 1 line

into igt tests

incorporating (though I would personally just say "using")

Quoted 41 lines

+ * @title: Chamelium
+ * @include: igt_chamelium.h
+ *
+ * This library contains helpers for using Chameliums in IGT tests. This allows
+ * for tests to simulate more difficult tasks to automate such as display
+ * hotplugging, faulty display behaviors, etc.
+ *
+ * More information on the Chamelium can be found
+ * [on the ChromeOS project page](https://www.chromium.org/chromiu m-os/testing/chamelium).
+ *
+ * In order to run tests using the Chamelium, a valid configuration file must be
+ * present.  The configuration file is a normal Glib keyfile (similar to Windows
+ * INI) structured like so:
+ *
+ * |[<!-- language="plain" -->
+ *     [Chamelium]
+ *     URL=http://chameleon:9992 # The URL used for connecting to the Chamelium's RPC server
+ *
+ *     # The rest of the sections are used for defining connector mappings.
+ *     # This is required so any tests using the Chamelium know which connector
+ *     # on the test machine should be connected to each Chamelium port.
+ *     #
+ *     # In the event that any of these mappings are specified incorrectly,
+ *     # any hotplugging tests for the incorrect connector mapping will fail.
+ *
+ *     [DP-1] # The name of the DRM connector
+ *     ChameliumPortID=1 # The ID of the port on the Chamelium this connector is attached to
+ *
+ *     [HDMI-A-1]

Quoted 8 lines

+ *     ChameliumPortID=3
+ * ]|
+ *
+ * By default, this file is expected to exist in ~/.igt_chamelium_rc . The
+ * directory for this can be overriden by setting the environment variable
+ * %CHAMELIUM_CONFIG_PATH.

Quoted 4 lines

It would be a pity if in time we need to add configuration parameters for other aspects of IGT and we have to choose between renaming this file, or having two configuration files for the same project. Why not call it just .igt_rc?

Nice catch. While I'm at it I'll add a patch to expose a function or two to get a global GKeyFile that's shared across tests that need configurations. As well I'll make sure connector groups are prefixed with something such as "Chamelium:" since we'll be sharing things.

Quoted 230 lines
Quoted 12 lines

+ */

lib/igt_chamelium.c new file +5 -0
+
+/**
+ * chamelium_ports:
+ *
+ * Contains information on all of the ports that are configured

for use with the
+ * Chamelium. This information is initialized when #chamelium_init is called.
+ */

lib/igt_chamelium.c new file +1 -0
+struct chamelium_port *chamelium_ports;

lib/igt_chamelium.c line 97

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+
+/**
+ * chamelium_port_count:
+ *
+ * How many ports are configured for use by the Chamelium.
+ */
+int chamelium_port_count;
+
+static const char *chamelium_url;
+static xmlrpc_env env;

I think it would be better to follow the same pattern as used in igt_pipe_crc_ calls and explicitly pass a pointer to a igt_pipe_crc_t around, instead of using globals.

Quoted 15 lines
lib/igt_chamelium.c new file +12 -0
+
+struct chamelium_edid {
+       int id;
+       struct igt_list link;
+};
+struct chamelium_edid *allocated_edids;
+
+/**
+ * chamelium_plug:
+ * @id: The ID of the port on the chamelium to plug
+ *
+ * Simulate a display connector being plugged into the system

using the
+ * chamelium.
+ */

lib/igt_chamelium.c line 116

Quoted 5 lines
lib/igt_chamelium.c new file +5 -0
+void chamelium_plug(int id)
+{
+       xmlrpc_value *res;
+
+       igt_debug("Plugging port %d\n", id);

For this and other places below, I think it could be very useful when reading logs from CI if we could have the name of the connector along or instead the chamelium port id.

Quoted 113 lines

+       res = xmlrpc_client_call(&env, chamelium_url, "Plug", "(i)", id);
+       check_rpc();

lib/igt_chamelium.c new file +9 -0
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_unplug:
+ * @id: The ID of the port on the chamelium to unplug
+ *
+ * Simulate a display connector being unplugged from the system

using the
+ * chamelium.
+ */

lib/igt_chamelium.c new file +6 -0
+void chamelium_unplug(int id)
+{
+       xmlrpc_value *res;
+
+       igt_debug("Unplugging port %d\n", id);
+       res = xmlrpc_client_call(&env, chamelium_url, "Unplug",

"(i)", id);
+       check_rpc();

lib/igt_chamelium.c new file +9 -0
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_is_plugged:
+ * @id: The ID of the port on the chamelium to check the status of
+ *
+ * Check whether or not the given port has been plugged into the

system using
+ * #chamelium_plug.
+ *
+ * Returns: %true if the connector is set to plugged in, %false otherwise.
+ */

lib/igt_chamelium.c new file +6 -0
+bool chamelium_is_plugged(int id)
+{
+       xmlrpc_value *res;
+       xmlrpc_bool is_plugged;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "IsPlugged",

"(i)", id);
+       check_rpc();

lib/igt_chamelium.c new file +11 -0
+
+       xmlrpc_read_bool(&env, res, &is_plugged);
+       xmlrpc_DECREF(res);
+
+       return is_plugged;
+}
+
+/**
+ * chamelium_port_wait_video_input_stable:
+ * @id: The ID of the port on the chamelium to check the status of
+ * @timeout_secs: How long to wait for a video signal to appear

before timing
+ * out
+ *
+ * Waits for a video signal to appear on the given port. This is useful for
+ * checking whether or not we've setup a monitor correctly.
+ *
+ * Returns: %true if a video signal was detected, %false if we timed out
+ */
+bool chamelium_port_wait_video_input_stable(int id, int timeout_secs)

lib/igt_chamelium.c new file +5 -0
+{
+       xmlrpc_value *res;
+       xmlrpc_bool is_on;
+
+       igt_debug("Waiting for video input to stabalize on port

%d\n", id);
+
+       res = xmlrpc_client_call(&env, chamelium_url, "WaitVideoInputStable",
+                                "(ii)", id, timeout_secs); +       check_rpc();

lib/igt_chamelium.c new file +14 -0
+
+       xmlrpc_read_bool(&env, res, &is_on);
+       xmlrpc_DECREF(res);
+
+       return is_on;
+}
+
+/**
+ * chamelium_fire_hpd_pulses:
+ * @id: The ID of the port to fire hotplug pulses on
+ * @width_msec: How long each pulse should last
+ * @count: The number of pulses to send
+ *
+ * A convienence function for sending multiple hotplug pulses to

the system.
+ * The pulses start at low (e.g. connector is disconnected), and then alternate
+ * from high (e.g. connector is plugged in) to low. This is the equivalent of
+ * repeatedly calling #chamelium_plug and #chamelium_unplug, waiting
+ * @width_msec between each call.
+ *
+ * If @count is even, the last pulse sent will be high, and if it's odd then it
+ * will be low. Resetting the HPD line back to it's previous state, if desired,
+ * is the responsibility of the caller.
+ */

lib/igt_chamelium.c new file +4 -0
+void chamelium_fire_hpd_pulses(int id, int width_msec, int count)
+{
+       xmlrpc_value *pulse_widths = xmlrpc_array_new(&env),
+                    *width = xmlrpc_int_new(&env, width_msec),
Quoted 1 line

*res;

If it's going to be two lines anyway, we may just leave the type specifier in the second one.

Quoted 60 lines

+       int i;
+
+       igt_debug("Firing %d HPD pulses with width of %d msec on id %d\n",
+                 count, width_msec, id);
+
+       for (i = 0; i < count; i++)
+               xmlrpc_array_append_item(&env, pulse_widths, width);
+
+       res = xmlrpc_client_call(&env, chamelium_url, "FireMixedHpdPulses",
+                                "(iA)", id, pulse_widths); +       check_rpc();

lib/igt_chamelium.c new file +10 -0
+
+       xmlrpc_DECREF(res);
+       xmlrpc_DECREF(width);
+       xmlrpc_DECREF(pulse_widths);
+}
+
+/**
+ * chamelium_fire_mixed_hpd_pulses:
+ * @id: The ID of the port to fire hotplug pulses on
+ * @...: The length of each pulse in milliseconds, terminated with

a %0
+ *
+ * Does the same thing as #chamelium_fire_hpd_pulses, but allows the caller to
+ * specify the length of each individual pulse.
+ */

lib/igt_chamelium.c new file +4 -0
+void chamelium_fire_mixed_hpd_pulses(int id, ...)
+{
+       va_list args;
+       xmlrpc_value *pulse_widths = xmlrpc_array_new(&env),

*width, *res;
+       int arg;

lib/igt_chamelium.c new file +5 -0
+
+       igt_debug("Firing mixed HPD pulses on port %d\n", id);
+
+       va_start(args, id);
+       for (arg = va_arg(args, int); arg; arg = va_arg(args, int))

{
+               width = xmlrpc_int_new(&env, arg); +               xmlrpc_array_append_item(&env, pulse_widths, width);
+               xmlrpc_DECREF(width);
+       }
+       va_end(args);
+
+       res = xmlrpc_client_call(&env, chamelium_url, "FireMixedHpdPulses",
+                                "(iA)", id, pulse_widths); +       check_rpc();
+       xmlrpc_DECREF(res);

lib/igt_chamelium.c new file +5 -0
+
+       xmlrpc_DECREF(pulse_widths);
+}
+
+static void async_rpc_handler(const char *server_url, const char

*method_name,

Quoted 8 lines
Quoted 6 lines

+                             xmlrpc_value *param_array, void *user_data,
+                             xmlrpc_env *fault, xmlrpc_value *result)
+{
+       /* We don't care about the responses */

What about reporting any errors?

See below

Quoted 73 lines
Quoted 73 lines
lib/igt_chamelium.c new file +6 -0
+}
+
+/**
+ * chamelium_async_hpd_pulse_start:
+ * @id: The ID of the port to fire a hotplug pulse on
+ * @high: Whether to fire a high pulse (e.g. simulate a connect),

or a low
+ * pulse (e.g. simulate a disconnect)
+ * @delay_secs: How long to wait before sending the HPD pulse.
+ *
+ * Instructs the chamelium to send an hpd pulse after @delay_secs seconds have
+ * passed, without waiting for the chamelium to finish. This is useful for
+ * testing things such as hpd after a suspend/resume cycle, since we can't tell
+ * the chamelium to send a hotplug at the same time that our system is
+ * suspended.
+ *
+ * It is required that the user eventually call
+ * #chamelium_async_hpd_pulse_finish, to clean up the leftover XML-RPC
+ * responses from the chamelium.
+ */
+void chamelium_async_hpd_pulse_start(int id, bool high, int delay_secs)
+{
+       xmlrpc_value *pulse_widths = xmlrpc_array_new(&env), *width;
+
+       /* TODO: Actually implement something in the chameleon server to allow
+        * for delayed actions such as hotplugs. This would work a bit better
+        * and allow us to test suspend/resume on ports without hpd like VGA
+        */
+
+       igt_debug("Sending HPD pulse (%s) on port %d with %d second delay\n",
+                 high ? "high->low" : "low->high", id, delay_secs);
+
+       /* If we're starting at high, make the first pulse width 0 so we keep
+        * the port connected */
+       if (high) {
+               width = xmlrpc_int_new(&env, 0);
+               xmlrpc_array_append_item(&env, pulse_widths, width);
+               xmlrpc_DECREF(width);
+       }

lib/igt_chamelium.c new file +6 -0
+
+       width = xmlrpc_int_new(&env, delay_secs * 1000);
+       xmlrpc_array_append_item(&env, pulse_widths, width);
+       xmlrpc_DECREF(width);
+
+       xmlrpc_client_call_asynch(chamelium_url,

"FireMixedHpdPulses",
+                                 async_rpc_handler, NULL, "(iA)", +                                 id, pulse_widths);
+       xmlrpc_DECREF(pulse_widths);

lib/igt_chamelium.c new file +6 -0
+}
+
+/**
+ * chamelium_async_hpd_pulse_finish:
+ *
+ * Waits for any asynchronous RPC started by

#chamelium_async_hpd_pulse_start
+ * to complete, and then cleans up any leftover responses from the chamelium.

Quoted 8 lines
Quoted 3 lines

+ * If all of the RPC calls have already completed, this function returns
+ * immediately.

This makes me wonder if it wouldn't have been better to go with libsoup, as it uses a real event loop that we may need to use in tests
for other reasons.

Fwiw, I wouldn't worry about this part too much. The only reason we we use async calls here is so that we can use the mixed pulses RPC to get the chamelium to send delayed hotplug events by using the pulse width as the delay. I wouldn't think there would be any situations where the chamelium would fail to send a hotplug, since all that part requires is just asserting the hpd line. It could fail if the IO board stopped responding, but in that case everything else is going to fail too and we won't get the hotplug event we're expecting anyway.

This is just my opinion though, if you can think of some use cases that this could seriously cause some issues I'll be happy to change it.

Quoted 968 lines
Quoted 21 lines

+ */

lib/igt_chamelium.c new file +10 -0
+void chamelium_async_hpd_pulse_finish(void)
+{
+       xmlrpc_client_event_loop_finish_asynch();
+}
+
+/**
+ * chamelium_new_edid:
+ * @edid: The edid blob to upload to the chamelium
+ *
+ * Uploads and registers a new EDID with the chamelium. The EDID

will be
+ * destroyed automatically when #chamelium_deinit is called.
+ *
+ * Returns: The ID of the EDID uploaded to the chamelium.
+ */

lib/igt_chamelium.c new file +4 -0
+int chamelium_new_edid(const unsigned char *edid)
+{
+       xmlrpc_value *res;
+       struct chamelium_edid *allocated_edid;

lib/igt_chamelium.c line 350

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+       int edid_id;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "CreateEdid",
+                                "(6)", edid, EDID_LENGTH);
+       check_rpc();
+
+       xmlrpc_read_int(&env, res, &edid_id);
+       xmlrpc_DECREF(res);
+
+       allocated_edid = malloc(sizeof(struct chamelium_edid));

Should be zeroed?

Quoted 1 line

+       igt_assert(allocated_edid);

Don't think it makes sense in userspace to check for malloc failures.

Quoted 176 lines
lib/igt_chamelium.c new file +6 -0
+
+       allocated_edid->id = edid_id;
+       igt_list_init(&allocated_edid->link);
+
+       if (allocated_edids) {
+               igt_list_add(&allocated_edids->link,

&allocated_edid->link);
+       } else {
+               allocated_edids = allocated_edid; +       }

lib/igt_chamelium.c new file +9 -0
+
+       return edid_id;
+}
+
+static void chamelium_destroy_edid(int edid_id)
+{
+       xmlrpc_value *res;
+
+       res = xmlrpc_client_call(&env, chamelium_url,

"DestroyEdid",
+                                "(i)", edid_id); +       check_rpc();

lib/igt_chamelium.c new file +11 -0
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_port_set_edid:
+ * @id: The ID of the port to set the EDID on
+ * @edid_id: The ID of an EDID on the chamelium created with
+ * #chamelium_new_edid, or 0 to disable the EDID on the port
+ *
+ * Sets a port on the chamelium to use the specified EDID. This

does not fire a
+ * hotplug pulse on it's own, and merely changes what EDID the chamelium port
+ * will report to us the next time we probe it. Users will need to reprobe the
+ * connectors themselves if they want to see the EDID reported by the port
+ * change.
+ */

lib/igt_chamelium.c new file +17 -0
+void chamelium_port_set_edid(int id, int edid_id)
+{
+       xmlrpc_value *res;
+
+       res = xmlrpc_client_call(&env, chamelium_url, "ApplyEdid",
+                                "(ii)", id, edid_id);
+       check_rpc();
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_port_set_ddc_state:
+ * @id: The ID of the port whose DDC bus we want to modify
+ * @enabled: Whether or not to enable the DDC bus
+ *
+ * This disables the DDC bus (e.g. the i2c line on the connector

that gives us
+ * an EDID) of the specified port on the chamelium. This is useful for testing
+ * behavior on legacy connectors such as VGA, where the presence of a DDC bus
+ * is not always guaranteed.
+ */

lib/igt_chamelium.c new file +8 -0
+void chamelium_port_set_ddc_state(int port, bool enabled)
+{
+       xmlrpc_value *res;
+
+       igt_debug("%sabling DDC bus on port %d\n",
+                 enabled ? "En" : "Dis", port);
+
+       res = xmlrpc_client_call(&env, chamelium_url,

"SetDdcState",
+                                "(ib)", port, enabled); +       check_rpc();

lib/igt_chamelium.c new file +7 -0
+
+       xmlrpc_DECREF(res);
+}
+
+/**
+ * chamelium_port_get_ddc_state:
+ * @id: The ID of the port whose DDC bus we want to check the

status of
+ *
+ * Check whether or not the DDC bus on the specified chamelium port is enabled
+ * or not.
+ *
+ * Returns: %true if the DDC bus is enabled, %false otherwise.
+ */

lib/igt_chamelium.c new file +6 -0
+bool chamelium_port_get_ddc_state(int id)
+{
+       xmlrpc_value *res;
+       xmlrpc_bool enabled;
+
+       res = xmlrpc_client_call(&env, chamelium_url,

"IsDdcEnabled",
+                                "(i)", id); +       check_rpc();

lib/igt_chamelium.c new file +10 -0
+
+       xmlrpc_read_bool(&env, res, &enabled);
+
+       xmlrpc_DECREF(res);
+       return enabled;
+}
+
+/**
+ * chamelium_port_get_resolution:
+ * @id: The ID of the port whose display resolution we want to

check
+ * @x: Where to store the horizontal resolution of the port
+ * @y: Where to store the verical resolution of the port
+ *
+ * Check the current reported display resolution of the specified port on the
+ * chamelium. This information is provided by the chamelium itself, not DRM.
+ * Useful for verifying that we really are scanning out at the resolution we
+ * think we are.
+ */

lib/igt_chamelium.c new file +5 -0
+void chamelium_port_get_resolution(int id, int *x, int *y)
+{
+       xmlrpc_value *res, *res_x, *res_y;
+
+       res = xmlrpc_client_call(&env, chamelium_url,

"DetectResolution",
+                                "(i)", id); +       check_rpc();

lib/igt_chamelium.c new file +28 -0
+
+       xmlrpc_array_read_item(&env, res, 0, &res_x);
+       xmlrpc_array_read_item(&env, res, 1, &res_y);
+       xmlrpc_read_int(&env, res_x, x);
+       xmlrpc_read_int(&env, res_y, y);
+
+       xmlrpc_DECREF(res_x);
+       xmlrpc_DECREF(res_y);
+       xmlrpc_DECREF(res);
+}
+
+static void crc_from_xml(xmlrpc_value *xml_crc, igt_crc_t *out)
+{
+       xmlrpc_value *res;
+       int i;
+
+       out->n_words = xmlrpc_array_size(&env, xml_crc);
+       for (i = 0; i < out->n_words; i++) {
+               xmlrpc_array_read_item(&env, xml_crc, i, &res);
+               xmlrpc_read_int(&env, res, (int*)&out->crc[i]);
+               xmlrpc_DECREF(res);
+       }
+}
+
+/**
+ * chamelium_get_crc_for_area:
+ * @id: The ID of the port from which we want to retrieve the CRC
+ * @x: The X coordinate on the emulated display to start

calculating the CRC
+ * from
+ * @y: The Y coordinate on the emulated display to start calculating the CRC
+ * from
+ * @w: The width of the area to fetch the CRC from, or %0 for the whole display
+ * @h: The height of the area to fetch the CRC from, or %0 for the whole display
+ *
+ * Reads back the pixel CRC for an area on the specified chamelium port. This
+ * is the same as using the CRC readback from a GPU, the main difference being
+ * the data is provided by the chamelium and also allows us to specify a region
+ * of the screen to use as opposed to the entire thing.

Quoted 8 lines

+ *
+ * Returns: The CRC read back from the chamelium
+ */
+igt_crc_t *chamelium_get_crc_for_area(int id, int x, int y, int w, int h)
+{
+       xmlrpc_value *res;
+       igt_crc_t *ret = malloc(sizeof(igt_crc_t));;

Extra ;. Docs should mention that the caller has to free.

Quoted 176 lines

+
+       res = xmlrpc_client_call(&env, chamelium_url, "ComputePixelChecksum",
+                                (w && h) ? "(iiiii)" : "(innnn)", +                                id, x, y, w, h);
+       check_rpc();

lib/igt_chamelium.c new file +10 -0
+
+       crc_from_xml(res, ret);
+       xmlrpc_DECREF(res);
+
+       return ret;
+}
+
+/**
+ * chamelium_start_capture:
+ * @id: The ID of the port for which we want to start capturing

frames on
+ * @x: The X coordinate to crop the video to
+ * @y: The Y coordinate to crop the video to
+ * @w: The width of the cropped video, or %0 for the whole display
+ * @h: The height of the cropped video, or %0 for the whole display
+ *
+ * Starts capturing video frames on the given Chamelium port. Once the user is
+ * finished capturing frames, they should call #chamelium_stop_capture.
+ *
+ * For capturing a single frame, users can use the one-shot
+ * @chamelium_get_crc_for_area
+ */

lib/igt_chamelium.c new file +3 -0
+void chamelium_start_capture(int id, int x, int y, int w, int h)
+{
+       xmlrpc_client_call(&env, chamelium_url,

"StartCapturingVideo",
+                          (w && h) ? "(iiiii)" : "(innnn)", id, x, y, w, h);
+       check_rpc();

lib/igt_chamelium.c new file +5 -0
+}
+
+/**
+ * chamelium_stop_capture:
+ * @frame_count: The number of frames to wait to capture, or %0 to

stop
+ * immediately
+ *
+ * Finishes capturing video frames on the given Chamelium port. If @frame_count
+ * is specified, this call will block until the given number of frames have been
+ * captured.
+ */

lib/igt_chamelium.c new file +3 -0
+void chamelium_stop_capture(int frame_count)
+{
+       xmlrpc_client_call(&env, chamelium_url,

"StopCapturingVideo",
+                          "(i)", frame_count); +       check_rpc();

lib/igt_chamelium.c new file +7 -0
+}
+
+/**
+ * chamelium_read_captured_crcs:
+ * @frame_count: Where to store the number of CRCs we read in
+ *
+ * Reads all of the CRCs that have been captured thus far from the

Chamelium.
+ *
+ * Returns: An array of @frame_count length containing all of the CRCs we read
+ */

lib/igt_chamelium.c new file +7 -0
+igt_crc_t *chamelium_read_captured_crcs(int *frame_count)
+{
+       igt_crc_t *ret;
+       xmlrpc_value *res, *elem;
+       int i;
+
+       res = xmlrpc_client_call(&env, chamelium_url,

"GetCapturedChecksums",
+                                "(in)", 0); +       check_rpc();

lib/igt_chamelium.c new file +22 -0
+
+       *frame_count = xmlrpc_array_size(&env, res);
+       ret = calloc(sizeof(igt_crc_t), *frame_count);
+
+       for (i = 0; i < *frame_count; i++) {
+               xmlrpc_array_read_item(&env, res, i, &elem);
+
+               crc_from_xml(elem, &ret[i]);
+               ret[i].frame = i;
+
+               xmlrpc_DECREF(elem);
+       }
+
+       xmlrpc_DECREF(res);
+
+       return ret;
+}
+
+/**
+ * chamelium_get_frame_limit:
+ * @id: The ID of the port to get the capture frame limit for
+ * @w: The width of the area to get the capture frame limit for,

or %0 for the
+ * whole display
+ * @h: The height of the area to get the capture frame limit for, or %0 for the
+ * whole display
+ *
+ * Gets the max number of frames we can capture with the Chamelium for the given
+ * resolution.
+ *
+ * Returns: The number of the max number of frames we can capture
+ */

lib/igt_chamelium.c new file +9 -0
+int chamelium_get_frame_limit(int id, int w, int h)
+{
+       xmlrpc_value *res;
+       int ret;
+
+       if (!w && !h)
+               chamelium_port_get_resolution(id, &w, &h);
+
+       res = xmlrpc_client_call(&env, chamelium_url,

"GetMaxFrameLimit",
+                                "(iii)", id, w, h); +       check_rpc();

lib/igt_chamelium.c new file +14 -0
+
+       xmlrpc_read_int(&env, res, &ret);
+       xmlrpc_DECREF(res);
+
+       return ret;
+}
+
+static unsigned int chamelium_get_port_type(int port)
+{
+       xmlrpc_value *res;
+       const char *port_type_str;
+       unsigned int port_type;
+
+       res = xmlrpc_client_call(&env, chamelium_url,

"GetConnectorType",
+                                "(i)", port); +       check_rpc();
+
+       xmlrpc_read_string(&env, res, &port_type_str); +       igt_debug("Port %d is of type '%s'\n", port, port_type_str);

lib/igt_chamelium.c new file +17 -0
+
+       if (strcmp(port_type_str, "DP") == 0)
+               port_type = DRM_MODE_CONNECTOR_DisplayPort;
+       else if (strcmp(port_type_str, "HDMI") == 0)
+               port_type = DRM_MODE_CONNECTOR_HDMIA;
+       else if (strcmp(port_type_str, "VGA") == 0)
+               port_type = DRM_MODE_CONNECTOR_VGA;
+       else
+               port_type = DRM_MODE_CONNECTOR_Unknown;
+
+       free((void*)port_type_str);
+       xmlrpc_DECREF(res);
+
+       return port_type;
+}
+
+static void chamelium_read_port_mappings(int drm_fd, GKeyFile

*key_file)

lib/igt_chamelium.c new file +11 -0
+{
+       drmModeRes *res;
+       drmModeConnector *connector;
+       struct chamelium_port *port;
+       GError *error = NULL;
+       char **group_list;
+       char *group;
+       size_t group_list_len;
+       int port_i, i, j;
+
+       group_list = g_key_file_get_groups(key_file,
Quoted 7 lines

&group_list_len);
+       chamelium_port_count = group_list_len - 1;
+       chamelium_ports = calloc(sizeof(struct chamelium_port), +                                chamelium_port_count); +       memset(chamelium_ports, 0,
+              sizeof(struct chamelium_port) * chamelium_port_count);

calloc already zeroes.

Quoted 64 lines

+       port_i = 0;
+       res = drmModeGetResources(drm_fd);

lib/igt_chamelium.c new file +11 -0
+
+       for (i = 0; group_list[i] != NULL; i++) {
+               group = group_list[i];
+
+               if (strcmp(group, "Chamelium") == 0)
+                       continue;
+
+               port = &chamelium_ports[port_i++];
+               port->connector_name = strdup(group);
+               port->id = g_key_file_get_integer(key_file, group,
+                                                 "ChameliumPortID"

,
+                                                 &error); +               igt_require_f(port->id,
+                             "Failed to read chamelium port ID for %s: %s\n",
+                             group, error->message);
+
+               port->type = chamelium_get_port_type(port->id); +               igt_require_f(port->type != DRM_MODE_CONNECTOR_Unknown,
+                             "Unable to retrieve the physical port type from the Chamelium for '%s'\n",
+                             group);
+
+               for (j = 0;
+                    j < res->count_connectors && !port-

Quoted 1 line

connector_id;

+                    j++) {
+                       char connector_name[50];

lib/igt_chamelium.c new file +5 -0
+
+                       connector = drmModeGetConnectorCurrent(
+                           drm_fd, res->connectors[j]);
+
+                       /* We have to generate the connector name

on our own */
+                       snprintf(connector_name, 50, "%s-%u", +                                kmstest_connector_type_str(connect or->connector_type),
+                                connector->connector_type_id); +
+                       if (strcmp(connector_name, group) == 0) +                               port->connector_id = connector-

Quoted 1 line

connector_id;

+
+                       drmModeFreeConnector(connector); +               }
+               igt_assert_f(port->connector_id,
+                            "No connector found with name '%s'\n", group);
+
+               igt_debug("Port '%s' with physical type '%s' mapped to Chamelium port %d\n",
+                         group, kmstest_connector_type_str(port-

Quoted 1 line

type),

+                         port->id);
+       }

lib/igt_chamelium.c new file +5 -0
+
+       drmModeFreeResources(res);
+       g_strfreev(group_list);
+}
+

lib/igt_chamelium.c line 732

Quoted 10 lines
lib/igt_chamelium.c new file +10 -0
+static void chamelium_read_config(int drm_fd)
+{
+       GKeyFile *key_file = g_key_file_new();
+       GError *error = NULL;
+       char *key_file_loc;
+       int rc;
+
+       key_file_loc = getenv("CHAMELIUM_CONFIG_PATH");
+       if (!key_file_loc) {
+               igt_require(key_file_loc = alloca(100));

Why skip the current test if alloca fails? Actually, why checking alloca's result? If we aren't 100% sure that alloca will succeed, we should be using malloc instead.

Quoted 9 lines

+               snprintf(key_file_loc, 100, "%s/.igt_chamelium_rc", +                        g_get_home_dir());
+       }
+
+       rc = g_key_file_load_from_file(key_file, key_file_loc, +                                      G_KEY_FILE_NONE, &error); +       igt_require_f(rc, "Failed to read chamelium configuration
file: %s\n",
+                     error->message);

Not sure I agree with the usage of igt_require in this patch. How I envision this to work, is that we require that the functionality to be
tested is there, otherwise we skip. But once we have determined that, if there is any problem when testing that functionality, it should cause a failure.

I think it's also better if the test code is able to decide whether to
skip or fail.

Quoted 185 lines

+       chamelium_url = g_key_file_get_string(key_file, "Chamelium", "URL",
+                                             &error); +       igt_require_f(chamelium_url,
+                     "Couldn't read chamelium URL from config
file: %s\n",
+                     error->message);

lib/igt_chamelium.c new file +10 -0
+
+       chamelium_read_port_mappings(drm_fd, key_file);
+
+       g_key_file_free(key_file);
+}
+
+/**
+ * chamelium_reset:
+ *
+ * Resets the chamelium's IO board. As well, this also has the

effect of
+ * causing all of the chamelium ports to get set to unplugged
+ */

lib/igt_chamelium.c new file +7 -0
+void chamelium_reset(void)
+{
+       xmlrpc_value *res;
+
+       igt_debug("Resetting the chamelium\n");
+
+       res = xmlrpc_client_call(&env, chamelium_url, "Reset",

"()");
+       check_rpc();

lib/igt_chamelium.c new file +17 -0
+
+       xmlrpc_DECREF(res);
+}
+
+static void chamelium_exit_handler(int sig)
+{
+       xmlrpc_env_clean(&env);
+       xmlrpc_env_init(&env);
+
+       chamelium_deinit();
+}
+
+/**
+ * chamelium_init:
+ * @drm_fd: drm file descriptor
+ *
+ * Sets up a connection with a chamelium, using the URL specified

in the
+ * Chamelium configuration. This must be called first before trying to use the
+ * chamelium.
+ *
+ * If we fail to establish a connection with the chamelium, fail to find a
+ * configured connector, etc. we fail the current test.
+ */

lib/igt_chamelium.c new file +20 -0
+void chamelium_init(int drm_fd)
+{
+       xmlrpc_env_init(&env);
+
+       xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, PACKAGE,
+                           PACKAGE_VERSION, NULL, 0);
+       igt_fail_on_f(env.fault_occurred,
+                     "Failed to init xmlrpc: %s\n",
+                     env.fault_string);
+
+       chamelium_read_config(drm_fd);
+       chamelium_reset();
+
+       igt_install_exit_handler(chamelium_exit_handler);
+}
+
+/**
+ * chamelium_deinit:
+ *
+ * Frees the resources used by a connection to the chamelium that

was set up
+ * with #chamelium_init. As well, this function restores the state of the
+ * chamelium like it was before calling #chamelium_init. This function is also
+ * called as an exit handler, so users only need to call manually if they don't
+ * want the chamelium interfering with other tests in the same file.
+ */

lib/igt_chamelium.c new file +9 -0
+void chamelium_deinit(void)
+{
+       int i;
+       struct chamelium_edid *pos, *tmp;
+
+       if (!chamelium_url)
+               return;
+
+       /* We want to make sure we leave all of the ports plugged

in, since
+        * testing setups requiring multiple monitors are probably using the
+        * chamelium to provide said monitors
+        */
+       chamelium_reset();
+       for (i = 0; i < chamelium_port_count; i++)
+               chamelium_plug(chamelium_ports[i].id); +
+       /* Destroy any EDIDs we created to make sure we don't leak them */
+       igt_list_for_each_safe(pos, tmp, &allocated_edids->link, link) {
+               chamelium_destroy_edid(pos->id);
+               free(pos);
+       }

lib/igt_chamelium.c new file +14 -0
+
+       xmlrpc_client_cleanup();
+       xmlrpc_env_clean(&env);
+
+       for (i = 0; i < chamelium_port_count; i++)
+               free(chamelium_ports[i].connector_name);
+
+       free(chamelium_ports);
+       allocated_edids = NULL;
+       chamelium_url = NULL;
+       chamelium_ports = NULL;
+       chamelium_port_count = 0;
+}
+
lib/igt_chamelium.h new file +4 -0
new file mode 100644
index 0000000..2f7aadf
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2016 Red Hat Inc.
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ * Authors: Lyude Paul <[email protected]>
+ */

lib/igt_chamelium.h new file +11 -0
+
+#ifndef IGT_CHAMELIUM_H
+#define IGT_CHAMELIUM_H
+
+#include "config.h"
+#include "igt.h"
+#include <stdbool.h>
+
+/**
+ * chamelium_port:
+ * @type: The DRM connector type of the chamelium port (not the

host's)
+ * @id: The ID of the chamelium port
+ * @connector_id: The ID of the DRM connector connected to this port
+ * @connector_name: The name of the DRM connector
+ */

lib/igt_chamelium.h line 48

Quoted 9 lines
lib/igt_chamelium.h new file +8 -0
+struct chamelium_port {
+       unsigned int type;
+       int id;
+       int connector_id;
+       char *connector_name;
+};
 
+extern int chamelium_port_count;
+extern struct chamelium_port *chamelium_ports;

Not sure it's a good idea to expose all this to tests. Afterwards could be a lot of work to update tests if we decide to do changes.

Quoted 49 lines
lib/igt_chamelium.h new file +8 -0
+void chamelium_init(int drm_fd);
+void chamelium_deinit(void);
+void chamelium_reset(void);
+
+void chamelium_plug(int id);
+void chamelium_unplug(int id);
+bool chamelium_is_plugged(int id);
+bool chamelium_port_wait_video_input_stable(int id, int

timeout_secs);

lib/igt_chamelium.h new file +3 -0
+void chamelium_fire_mixed_hpd_pulses(int id, ...);
+void chamelium_fire_hpd_pulses(int id, int width_msec, int count);
+void chamelium_async_hpd_pulse_start(int id, bool high, int

delay_secs);

lib/igt_chamelium.h new file +7 -0
+void chamelium_async_hpd_pulse_finish(void);
+int chamelium_new_edid(const unsigned char *edid);
+void chamelium_port_set_edid(int id, int edid_id);
+bool chamelium_port_get_ddc_state(int id);
+void chamelium_port_set_ddc_state(int id, bool enabled);
+void chamelium_port_get_resolution(int id, int *x, int *y);
+igt_crc_t *chamelium_get_crc_for_area(int id, int x, int y, int w,

int h);

lib/igt_chamelium.h new file +6 -0
+void chamelium_start_capture(int id, int x, int y, int w, int h);
+void chamelium_stop_capture(int frame_count);
+igt_crc_t *chamelium_read_captured_crcs(int *frame_count);
+int chamelium_get_frame_limit(int id, int w, int h);
+
+#endif /* IGT_CHAMELIUM_H */
scripts/run-tests.sh +0 -0
index 97ba9e5..6539bf9 100755
@@ -122,10 +122,10 @@ if [ ! -x "$PIGLIT" ]; then

 fi

 if [ "x$RESUME" != "x" ]; then
-       sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" "$PIGLIT" resume "$RESULTS" $NORETRY
+       sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" CHAMELIUM_HOST="$CHAMELIUM_HOST" "$PIGLIT" resume "$RESULTS" $NORETRY
 else
        mkdir -p "$RESULTS"
-       sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" "$PIGLIT" run igt -o "$RESULTS" -s $VERBOSE $EXCLUDE $FILTER
+       sudo IGT_TEST_ROOT="$IGT_TEST_ROOT" CHAMELIUM_HOST="$CHAMELIUM_HOST" "$PIGLIT" run igt -o "$RESULTS" -s $VERBOSE $EXCLUDE $FILTER
 fi

Quoted 1 line

 if [ "$SUMMARY" == "html" ]; then

Guess this isn't needed any more?

Quoted 15 lines
tests/Makefile.am +1 -1
index a408126..06a8e6b 100644
@@ -63,7 +63,7 @@ AM_CFLAGS = $(DRM_CFLAGS) $(CWARNFLAGS) -Wno-
 unused-result $(DEBUG_CFLAGS)\
         $(LIBUNWIND_CFLAGS) $(WERROR_CFLAGS) \
         $(NULL)
 
-LDADD = ../lib/libintel_tools.la $(GLIB_LIBS)
+LDADD = ../lib/libintel_tools.la $(GLIB_LIBS) $(XMLRPC_LIBS)
 
  AM_CFLAGS += $(CAIRO_CFLAGS) $(LIBUDEV_CFLAGS) $(GLIB_CFLAGS)

 AM_LDFLAGS = -Wl,--as-needed

tests/Makefile.am vc4_wait_bo_CFLAGS = $(AM_CFLAGS) · line 125

Quoted 7 lines
tests/Makefile.am +3 -0
@@ -119,5 +119,8 @@ vc4_wait_bo_CFLAGS = $(AM_CFLAGS)
 $(DRM_VC4_CFLAGS)
  vc4_wait_bo_LDADD = $(LDADD) $(DRM_VC4_LIBS)
  vc4_wait_seqno_CFLAGS = $(AM_CFLAGS) $(DRM_VC4_CFLAGS)
  vc4_wait_seqno_LDADD = $(LDADD) $(DRM_VC4_LIBS)
+
+chamelium_CFLAGS = $(AM_CFLAGS) $(XMLRPC_CFLAGS) $(UDEV_CFLAGS)
+chamelium_LDADD = $(LDADD) $(XMLRPC_LIBS) $(UDEV_LIBS)

Same as before (the package prefix is LIBUDEV).

Quoted 9 lines

 endif

tests/Makefile.sources +0 -0
index 57a10c5..5eeae77 100644
@@ -135,8 +135,13 @@ TESTS_progs_M = \
         prime_vgem \
         template \

tests/Makefile.sources TESTS_progs_M = \ · line 144

Quoted 10 lines
tests/Makefile.sources +7 -2
         vgem_basic \
-       vgem_slow \
-       $(NULL)
+       vgem_slow
+
+if HAVE_CHAMELIUM
+TESTS_progs_M += chamelium
+endif
+
+TESTS_progs_M += $(NULL)

Same as before.

Quoted 143 lines
tests/Makefile.sources +0 -0
  TESTS_progs_XM = \
      gem_concurrent_all \
tests/chamelium.c new file +4 -0
new file mode 100644
index 0000000..e0f645a
@@ -0,0 +1,407 @@
+/*
+ * Copyright © 2016 Red Hat Inc.
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ * Authors:
+ *    Lyude Paul <[email protected]>
+ */

tests/chamelium.c new file +36 -0
+
+#include "config.h"
+#include "igt.h"
+
+#include <fcntl.h>
+#include <string.h>
+
+typedef struct {
+       int drm_fd;
+} data_t;
+
+#define HOTPLUG_TIMEOUT 20 /* seconds */
+
+static void
+require_connector_present(data_t *data, unsigned int type)
+{
+       int i;
+       bool found = false;
+
+       for (i = 0; i < chamelium_port_count && !found; i++) {
+               if (chamelium_ports[i].type == type)
+                       found = true;
+       }
+
+       igt_require_f(found, "No port of type %s was found\n",
+                     kmstest_connector_type_str(type));
+}
+
+static drmModeConnection
+reprobe_connector(data_t *data, struct chamelium_port *port)
+{
+       drmModeConnector *connector;
+       drmModeConnection status;
+
+       igt_debug("Reprobing %s...\n", port->connector_name);
+       connector = drmModeGetConnector(data->drm_fd, port-
Quoted 1 line

connector_id);

+       igt_assert(connector);
+       status = connector->connection;

tests/chamelium.c new file +12 -0
+
+       drmModeFreeConnector(connector);
+       return status;
+}
+
+static void
+wait_for_connector(data_t *data, struct chamelium_port *port,
+                  drmModeConnection status)
+{
+       bool finished = false;
+
+       igt_debug("Waiting for %s to %sconnect...\n", port-
Quoted 1 line

connector_name,

+                 status == DRM_MODE_DISCONNECTED ? "dis" : ""); +
+       /*
+        * Rely on simple reprobing so we don't fail tests that don't require
+        * that hpd events work in the event that hpd doesn't work on the system
+        */
+       igt_until_timeout(HOTPLUG_TIMEOUT) {
+               if (reprobe_connector(data, port) == status) { +                       finished = true;
+                       return;
+               }

tests/chamelium.c new file +31 -0
+
+               sleep(1);
+       }
+
+       igt_assert(finished);
+}
+
+static void
+reset_state(data_t *data, struct chamelium_port *port)
+{
+       igt_reset_connectors();
+       chamelium_reset();
+       wait_for_connector(data, port, DRM_MODE_DISCONNECTED);
+}
+
+static void
+test_basic_hotplug(data_t *data, struct chamelium_port *port)
+{
+       int i;
+
+       reset_state(data, port);
+
+       igt_watch_hotplug();
+
+       for (i = 0; i < 15; i++) {
+               igt_flush_hotplugs();
+
+               /* Check if we get a sysfs hotplug event */
+               chamelium_plug(port->id);
+               igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+               igt_assert(reprobe_connector(data, port) ==
Quoted 1 line

DRM_MODE_CONNECTED);

Better use igt_assert_eq in case we get DRM_MODE_UNKNOWNCONNECTION?

Quoted 9 lines
tests/chamelium.c new file +4 -0
+
+               igt_flush_hotplugs();
+
+               /* Now check if we get a hotplug from disconnection

*/
+               chamelium_unplug(port->id);
+               igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT)); +               igt_assert(reprobe_connector(data, port) == +                          DRM_MODE_DISCONNECTED);

Ditto.

Quoted 5 lines
Quoted 3 lines

+               /* Sleep so we don't accidentally cause an hpd storm */
+               sleep(1);

Wouldn't such a long sleep unnecessarily slow test runs down?

Yes, but I don't see much of a way around it right now. Eventually I'd like to add something to i915's debugfs to allow disabling HPD storm detection (we'll need this as well if we want to eventually add HPD storm detection tests).

Quoted 30 lines
Quoted 19 lines

+       }

tests/chamelium.c new file +16 -0
+}
+
+static void
+test_edid_read(data_t *data, struct chamelium_port *port,
+              int edid_id, const unsigned char *edid)
+{
+       drmModePropertyBlobPtr edid_blob = NULL;
+       uint64_t edid_blob_id;
+
+       reset_state(data, port);
+
+       chamelium_port_set_edid(port->id, edid_id);
+       chamelium_plug(port->id);
+       wait_for_connector(data, port, DRM_MODE_CONNECTED);
+
+       igt_assert(kmstest_get_property(data->drm_fd, port-
Quoted 1 line

connector_id,

Quoted 10 lines

+                                       DRM_MODE_OBJECT_CONNECTOR, "EDID", NULL,
+                                       &edid_blob_id, NULL)); +       igt_assert(edid_blob = drmModeGetPropertyBlob(data->drm_fd, +                                                     edid_blob_id) );
+
+       /* Compare the EDID from the connector to what we expect */ +       igt_assert(memcmp(edid, edid_blob->data, EDID_LENGTH) == 0);

Quoted 3 lines

Would be cool if we had a igt_assert_mem_eq or such that would print the unexpected and expected values to the log (properly capped, of course).

I like this and this definitely wouldn't be too difficult to add.

Quoted 98 lines

tests/chamelium.c line 162

Quoted 10 lines

+       drmModeFreePropertyBlob(edid_blob);

tests/chamelium.c new file +8 -0
+}
+
+static void
+test_suspend_resume_hpd(data_t *data, struct chamelium_port *port,
+                       enum igt_suspend_state state,
+                       enum igt_suspend_test test)
+{
+       int delay = 7;

Would be better to have this and the 15 below as constants so it's easier to see what knobs are there at a glance?

Quoted 30 lines

+       igt_skip_without_suspend_support(state, test); +       reset_state(data, port);
+       igt_watch_hotplug();

tests/chamelium.c new file +10 -0
+
+       igt_set_autoresume_delay(15);
+
+       /* Make sure we notice new connectors after resuming */
+       chamelium_async_hpd_pulse_start(port->id, false, delay);
+       igt_system_suspend_autoresume(state, test);
+       chamelium_async_hpd_pulse_finish();
+
+       igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+       igt_assert(reprobe_connector(data, port) ==

DRM_MODE_CONNECTED);

tests/chamelium.c new file +4 -0
+
+       igt_flush_hotplugs();
+
+       /* Now make sure we notice disconnected connectors after

resuming */
+       chamelium_async_hpd_pulse_start(port->id, true, delay); +       igt_system_suspend_autoresume(state, test);
+       chamelium_async_hpd_pulse_finish();
+
+       igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT)); +       igt_assert(reprobe_connector(data, port) == DRM_MODE_DISCONNECTED);

tests/chamelium.c new file +4 -0
+}
+
+static void
+test_suspend_resume_edid_change(data_t *data, struct
Quoted 7 lines

chamelium_port *port,
+                               enum igt_suspend_state state, +                               enum igt_suspend_test test, +                               int edid_id,
+                               int alt_edid_id)
+{
+       igt_skip_without_suspend_support(state, test);

Maybe igt_require_suspend?

Quoted 44 lines

+       reset_state(data, port);
+       igt_watch_hotplug();

tests/chamelium.c new file +10 -0
+
+       /* First plug in the port */
+       chamelium_port_set_edid(port->id, edid_id);
+       chamelium_plug(port->id);
+       wait_for_connector(data, port, DRM_MODE_CONNECTED);
+
+       igt_flush_hotplugs();
+
+       /*
+        * Change the edid before we suspend. On resume, the

machine should
+        * notice the EDID change and fire a hotplug event. +        */
+       chamelium_port_set_edid(port->id, alt_edid_id);

tests/chamelium.c new file +28 -0
+
+       igt_system_suspend_autoresume(state, test);
+       igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT));
+}
+
+static void
+test_display(data_t *data, struct chamelium_port *port)
+{
+       igt_display_t display;
+       igt_output_t *output;
+       igt_plane_t *primary;
+       struct igt_fb fb;
+       drmModeRes *res;
+       drmModeModeInfo *mode;
+       drmModeConnector *connector;
+       uint32_t crtc_id;
+       int fb_id;
+
+       reset_state(data, port);
+
+       chamelium_plug(port->id);
+       wait_for_connector(data, port, DRM_MODE_CONNECTED);
+       igt_assert(res = drmModeGetResources(data->drm_fd));
+       kmstest_unset_all_crtcs(data->drm_fd, res);
+
+       igt_display_init(&display, data->drm_fd);
+
+       /* Find the output struct for this connector */
Quoted 8 lines
Quoted 4 lines

+       for_each_connected_output(&display, output) { +               if (output->config.connector->connector_id == +                   port->connector_id)
+                       break;

Are we that sure that we'll always find such an output? Could be quite
disconcerting if that stopped being true, even if by a bug.

Not sure I follow here: that's what the wait_for_connector() call is there for. I'd expect that we could make the assumption we'll find a connector if we've managed to make it that far without failing.

Quoted 30 lines
Quoted 30 lines

+       }

tests/chamelium.c new file +6 -0
+
+       connector = drmModeGetConnectorCurrent(data->drm_fd,
+                                              port->connector_id);
+
+       /* Find a spare CRTC to use for the display */
+       crtc_id = kmstest_find_crtc_for_connector(data->drm_fd,

res, connector,
+                                                 0);
+
+       /* Setup the display */
+       igt_output_set_pipe(output, kmstest_get_pipe_from_crtc_id(data->drm_fd,
+                                                                 c rtc_id));
+       mode = igt_output_get_mode(output);
+       primary = igt_output_get_plane(output, IGT_PLANE_PRIMARY); +       igt_assert(primary);

tests/chamelium.c new file +11 -0
+
+       fb_id = igt_create_pattern_fb(data->drm_fd,
+                                     mode->hdisplay,
+                                     mode->vdisplay,
+                                     DRM_FORMAT_XRGB8888,
+                                     LOCAL_DRM_FORMAT_MOD_NONE,
+                                     &fb);
+       igt_assert(fb_id > 0);
+       igt_plane_set_fb(primary, &fb);
+
+       igt_display_commit(&display);
Quoted 8 lines
Quoted 4 lines

+
+       igt_assert(chamelium_port_wait_video_input_stable(port->id, +                                                         HOTPLUG_T IMEOUT));

If we have all this already, wouldn't make sense to also test that the
CRC functions work as expected?

I did add some debugging code in while writing those functions to make sure all of them worked, but I suppose it would be a good idea to add some as actual tests.

Anyway, I'll get to re-spinning a new version of this series with all of these changes.

Quoted 182 lines
Quoted 96 lines

+       drmModeFreeResources(res);
+       drmModeFreeConnector(connector);
+       igt_display_fini(&display);

tests/chamelium.c new file +9 -0
+}
+
+static void
+test_hpd_without_ddc(data_t *data, struct chamelium_port *port)
+{
+       reset_state(data, port);
+       igt_watch_hotplug();
+
+       /* Disable the DDC on the connector and make sure we still

get a
+        * hotplug
+        */
+       chamelium_port_set_ddc_state(port->id, false); +       chamelium_plug(port->id);
+
+       igt_assert(igt_hotplug_detected(HOTPLUG_TIMEOUT)); +       igt_assert(reprobe_connector(data, port) == DRM_MODE_CONNECTED);

tests/chamelium.c new file +11 -0
+}
+
+#define for_each_port(p, port)                  \
+       for (p = 0, port = &chamelium_ports[p]; \
+            p < chamelium_port_count;          \
+            p++, port = &chamelium_ports[p])   \
+
+#define connector_subtest(name__, type__) \
+       igt_subtest(name__)               \
+               for_each_port(p, port)    \
+                       if (port->type == DRM_MODE_CONNECTOR_ ##

type__)

tests/chamelium.c new file +2 -0
+
+#define define_common_connector_tests(type_str__,

type__)                     \
+       connector_subtest(type_str__ "-hpd",
type__)                          \
+               test_basic_hotplug(&data,
port);                              \
+
            \
+       connector_subtest(type_str__ "-edid-read", type__) {                  \
+               test_edid_read(&data, port,
edid_id,                          \
+                              igt_kms_get_base_edid()); \
+               test_edid_read(&data, port,
alt_edid_id,                      \
+                              igt_kms_get_alt_edid()); \
+       }
           \
+
            \
+       connector_subtest(type_str__ "-hpd-after-suspend", type__)            \
+               test_suspend_resume_hpd(&data,
port,                          \
+                                       SUSPEND_STATE_MEM, \
+                                       SUSPEND_TEST_NONE); \
+
            \
+       connector_subtest(type_str__ "-hpd-after-hibernate", type__)          \
+               test_suspend_resume_hpd(&data,
port,                          \
+                                       SUSPEND_STATE_DISK, \
+                                       SUSPEND_TEST_DEVICES); \
+
            \
+       connector_subtest(type_str__ "-edid-change-during-suspend", type__)   \
+               test_suspend_resume_edid_change(&data, port,                  \
+                                               SUSPEND_STATE_MEM, \
+                                               SUSPEND_TEST_NONE, \
+                                               edid_id, alt_edid_id);        \
+
            \
+       connector_subtest(type_str__ "-edid-change-during- hibernate", type__) \
+               test_suspend_resume_edid_change(&data, port,                  \
+                                               SUSPEND_STATE_DISK, \
+                                               SUSPEND_TEST_DEVICE

Quoted 8 lines

S,         \
+                                               edid_id, alt_edid_id);        \
+
            \
+       connector_subtest(type_str__ "-display", type__)                      \
+               test_display(&data, port);

Not sure about the others, but I think I would prefer if this was C code.

Quoted 74 lines
tests/chamelium.c new file +15 -0
+static data_t data;
+
+igt_main
+{
+       struct chamelium_port *port;
+       int edid_id, alt_edid_id, p;
+
+       igt_fixture {
+               igt_skip_on_simulation();
+
+               data.drm_fd = drm_open_driver_master(DRIVER_ANY);
+
+               chamelium_init(data.drm_fd);
+
+               edid_id =

chamelium_new_edid(igt_kms_get_base_edid()); +               alt_edid_id = chamelium_new_edid(igt_kms_get_alt_edid());

tests/chamelium.c new file +40 -0
+
+               /* So fbcon doesn't try to reprobe things itself */
+               kmstest_set_vt_graphics_mode();
+       }
+
+       igt_subtest_group {
+               igt_fixture {
+                       require_connector_present(
+                           &data, DRM_MODE_CONNECTOR_DisplayPort);
+               }
+
+               define_common_connector_tests("dp", DisplayPort);
+       }
+
+       igt_subtest_group {
+               igt_fixture {
+                       require_connector_present(
+                           &data, DRM_MODE_CONNECTOR_HDMIA);
+               }
+
+               define_common_connector_tests("hdmi", HDMIA);
+       }
+
+       igt_subtest_group {
+               igt_fixture {
+                       require_connector_present(
+                           &data, DRM_MODE_CONNECTOR_VGA);
+               }
+
+               connector_subtest("vga-hpd", VGA)
+                       test_basic_hotplug(&data, port);
+
+               connector_subtest("vga-edid-read", VGA) {
+                       test_edid_read(&data, port, edid_id,
+                                      igt_kms_get_base_edid());
+                       test_edid_read(&data, port, alt_edid_id,
+                                      igt_kms_get_alt_edid());
+               }
+
+               /* FIXME: Right now there isn't a way to do any

sort of delayed
+                * psuedo-hotplug with VGA, so testing detection after a
+                * suspend/resume cycle isn't possible yet +                */

tests/chamelium.c new file +8 -1
+
+               connector_subtest("vga-hpd-without-ddc", VGA)
+                       test_hpd_without_ddc(&data, port);
+
+               connector_subtest("vga-display", VGA)
+                       test_display(&data, port);
+       }
+}
--

2.9.3

Signature · 6 lines
Cheers,
	Lyude
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#8 lore raw

Re: [RFC i-g-t v3 5/5] Add support for hotplug testing with the Chamelium

Quoted 2 lines · Lyude Paul
Quoted 1 line · Tomeu Vizoso

On 1 December 2016 at 02:24, Lyude <[email protected]> wrote:

(big snip)

Quoted 6 lines
Quoted 6 lines
Quoted 5 lines

+ * By default, this file is expected to exist in ~/.igt_chamelium_rc . The
+ * directory for this can be overriden by setting the environment variable
+ * %CHAMELIUM_CONFIG_PATH.

Quoted 8 lines
Quoted 4 lines

It would be a pity if in time we need to add configuration parameters for other aspects of IGT and we have to choose between renaming this file, or having two configuration files for the same project. Why not call it just .igt_rc?

Nice catch. While I'm at it I'll add a patch to expose a function or two to get a global GKeyFile that's shared across tests that need configurations. As well I'll make sure connector groups are prefixed with something such as "Chamelium:" since we'll be sharing things.

Sounds great.

Quoted 25 lines
Quoted 11 lines
Quoted 10 lines

+/**
+ * chamelium_async_hpd_pulse_finish:
+ *
+ * Waits for any asynchronous RPC started by #chamelium_async_hpd_pulse_start
+ * to complete, and then cleans up any leftover responses from the chamelium.
+ * If all of the RPC calls have already completed, this function returns
+ * immediately.

Quoted 4 lines

This makes me wonder if it wouldn't have been better to go with libsoup, as it uses a real event loop that we may need to use in tests
for other reasons.

Fwiw, I wouldn't worry about this part too much. The only reason we we use async calls here is so that we can use the mixed pulses RPC to get the chamelium to send delayed hotplug events by using the pulse width as the delay. I wouldn't think there would be any situations where the chamelium would fail to send a hotplug, since all that part requires is just asserting the hpd line. It could fail if the IO board stopped responding, but in that case everything else is going to fail too and we won't get the hotplug event we're expecting anyway.

Quoted 2 lines

This is just my opinion though, if you can think of some use cases that this could seriously cause some issues I'll be happy to change it.

Fair enough. When this issue came up first, I tried to think of any use cases in which having a proper event loop would be important, but I wasn't able to back then and I still cannot think of anything, so I'm fine with things as they are. Also, as you have the code structured, it would be quite easy to switch to libsoup if needed in the future.

Quoted 9 lines
Quoted 5 lines
Quoted 3 lines

+ /* Sleep so we don't accidentally cause an hpd
storm */
+ sleep(1);

Wouldn't such a long sleep unnecessarily slow test runs down?

Yes, but I don't see much of a way around it right now. Eventually I'd like to add something to i915's debugfs to allow disabling HPD storm detection (we'll need this as well if we want to eventually add HPD storm detection tests).

That's cool, but I was thinking that the sleep duration could be shorter.

Quoted 32 lines
Quoted 24 lines
Quoted 24 lines
tests/chamelium.c new file +24 -0
+
+static void
+test_display(data_t *data, struct chamelium_port *port)
+{
+       igt_display_t display;
+       igt_output_t *output;
+       igt_plane_t *primary;
+       struct igt_fb fb;
+       drmModeRes *res;
+       drmModeModeInfo *mode;
+       drmModeConnector *connector;
+       uint32_t crtc_id;
+       int fb_id;
+
+       reset_state(data, port);
+
+       chamelium_plug(port->id);
+       wait_for_connector(data, port, DRM_MODE_CONNECTED);
+       igt_assert(res = drmModeGetResources(data->drm_fd));
+       kmstest_unset_all_crtcs(data->drm_fd, res);
+
+       igt_display_init(&display, data->drm_fd);
+
+       /* Find the output struct for this connector */
Quoted 8 lines

tests/chamelium.c line 243

Quoted 4 lines
tests/chamelium.c new file +4 -0
+       for_each_connected_output(&display, output) {
+               if (output->config.connector->connector_id ==
+                   port->connector_id)
+                       break;

Are we that sure that we'll always find such an output? Could be quite
disconcerting if that stopped being true, even if by a bug.

Quoted 3 lines

Not sure I follow here: that's what the wait_for_connector() call is there for. I'd expect that we could make the assumption we'll find a connector if we've managed to make it that far without failing.

My concern was rather that, as code evolve, that assumption could become false and the bug would manifest in a disconcerting way. So I would just assert that the connector that we got after the loop is really the one we expected.

Thanks,

Tomeu
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx