1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <errno.h> 18 #include <fcntl.h> 19 20 #include <adf/adf.h> 21 #include <gtest/gtest.h> 22 #include <sys/mman.h> 23 #include <sync/sync.h> 24 25 class AdfTest : public testing::Test { 26 public: 27 AdfTest() : intf_id(0), intf(-1), eng_id(0), eng(-1) { } 28 29 virtual void SetUp() { 30 int err = adf_device_open(dev_id, O_RDWR, &dev); 31 ASSERT_GE(err, 0) << "opening ADF device " << dev_id << 32 " failed: " << strerror(-err); 33 34 err = adf_find_simple_post_configuration(&dev, fmt8888, n_fmt8888, 35 &intf_id, &eng_id); 36 ASSERT_GE(err, 0) << "finding ADF configuration failed: " << 37 strerror(-err); 38 39 intf = adf_interface_open(&dev, intf_id, O_RDWR); 40 ASSERT_GE(intf, 0) << "opening ADF interface " << dev_id << "." << 41 intf_id << " failed: " << strerror(-intf); 42 43 eng = adf_overlay_engine_open(&dev, eng_id, O_RDWR); 44 ASSERT_GE(eng, 0) << "opening ADF overlay engine " << dev_id << "." << 45 eng_id << " failed: " << strerror(-eng); 46 } 47 48 virtual void TearDown() { 49 if (eng >= 0) 50 close(eng); 51 if (intf >= 0) 52 close(intf); 53 adf_device_close(&dev); 54 } 55 56 void get8888Format(uint32_t &fmt, char fmt_str[ADF_FORMAT_STR_SIZE]) { 57 adf_overlay_engine_data data; 58 int err = adf_get_overlay_engine_data(eng, &data); 59 ASSERT_GE(err, 0) << "getting ADF overlay engine data failed: " << 60 strerror(-err); 61 62 for (size_t i = 0; i < data.n_supported_formats; i++) { 63 for (size_t j = 0; j < n_fmt8888; j++) { 64 if (data.supported_formats[i] == fmt8888[j]) { 65 fmt = data.supported_formats[i]; 66 adf_format_str(fmt, fmt_str); 67 adf_free_overlay_engine_data(&data); 68 return; 69 } 70 } 71 } 72 73 adf_free_overlay_engine_data(&data); 74 FAIL(); /* this should never happen */ 75 } 76 77 /* various helpers to call ADF and die on failure */ 78 79 void getInterfaceData(adf_interface_data &data) { 80 int err = adf_get_interface_data(intf, &data); 81 ASSERT_GE(err, 0) << "getting ADF interface data failed: " << 82 strerror(-err); 83 } 84 85 void getCurrentMode(uint32_t &w, uint32_t &h) { 86 adf_interface_data data; 87 ASSERT_NO_FATAL_FAILURE(getInterfaceData(data)); 88 w = data.current_mode.hdisplay; 89 h = data.current_mode.vdisplay; 90 adf_free_interface_data(&data); 91 } 92 93 void blank(uint8_t mode) { 94 int err = adf_interface_blank(intf, mode); 95 ASSERT_FALSE(err < 0 && err != -EBUSY) << 96 "unblanking interface failed: " << strerror(-err); 97 } 98 99 void attach() { 100 int err = adf_device_attach(&dev, eng_id, intf_id); 101 ASSERT_FALSE(err < 0 && err != -EALREADY) << 102 "attaching overlay engine " << eng_id << " to interface " << 103 intf_id << " failed: " << strerror(-err); 104 } 105 106 void detach() { 107 int err = adf_device_detach(&dev, eng_id, intf_id); 108 ASSERT_FALSE(err < 0 && err != -EINVAL) << 109 "detaching overlay engine " << eng_id << " from interface " << 110 intf_id << " failed: " << strerror(-err); 111 } 112 113 void readVsyncTimestamp(uint64_t ×tamp) { 114 adf_event *event; 115 int err = adf_read_event(intf, &event); 116 ASSERT_GE(err, 0) << "reading ADF event failed: " << strerror(-err); 117 118 ASSERT_EQ(ADF_EVENT_VSYNC, event->type); 119 ASSERT_EQ(sizeof(adf_vsync_event), event->length); 120 121 adf_vsync_event *vsync_event = 122 reinterpret_cast<adf_vsync_event *>(event); 123 timestamp = vsync_event->timestamp; 124 free(event); 125 } 126 127 void drawCheckerboard(uint32_t &w, uint32_t &h, uint32_t &format, 128 char format_str[ADF_FORMAT_STR_SIZE], int &buf_fd, uint32_t &offset, 129 uint32_t &pitch) { 130 ASSERT_NO_FATAL_FAILURE(getCurrentMode(w, h)); 131 ASSERT_NO_FATAL_FAILURE(get8888Format(format, format_str)); 132 133 buf_fd = adf_interface_simple_buffer_alloc(intf, w, h, format, &offset, 134 &pitch); 135 ASSERT_GE(buf_fd, 0) << "allocating " << w << "x" << h << " " << 136 format_str << " buffer failed: " << strerror(-buf_fd); 137 EXPECT_GE(pitch, w * 4); 138 139 void *mapped = mmap(NULL, pitch * h, PROT_WRITE, MAP_SHARED, buf_fd, 140 offset); 141 ASSERT_NE(mapped, MAP_FAILED) << "mapping " << w << "x" << h << " " << 142 format_str << " buffer failed: " << strerror(-errno); 143 144 uint8_t *buf8 = static_cast<uint8_t *>(mapped); 145 for (uint32_t y = 0; y < h / 2; y++) { 146 uint32_t *scanline = reinterpret_cast<uint32_t *>(buf8 + y * pitch); 147 for (uint32_t x = 0; x < w / 2; x++) 148 scanline[x] = 0xFF0000FF; 149 for (uint32_t x = w / 2; x < w; x++) 150 scanline[x] = 0xFF00FFFF; 151 } 152 for (uint32_t y = h / 2; y < h; y++) { 153 uint32_t *scanline = reinterpret_cast<uint32_t *>(buf8 + y * pitch); 154 for (uint32_t x = 0; x < w / 2; x++) 155 scanline[x] = 0xFFFF00FF; 156 for (uint32_t x = w / 2; x < w; x++) 157 scanline[x] = 0xFFFFFFFF; 158 } 159 160 munmap(mapped, pitch * h); 161 } 162 163 protected: 164 adf_device dev; 165 adf_id_t intf_id; 166 int intf; 167 adf_id_t eng_id; 168 int eng; 169 170 private: 171 const static adf_id_t dev_id; 172 const static __u32 fmt8888[]; 173 const static size_t n_fmt8888; 174 }; 175 176 const adf_id_t AdfTest::dev_id = 0; 177 178 const __u32 AdfTest::fmt8888[] = { 179 DRM_FORMAT_XRGB8888, 180 DRM_FORMAT_XBGR8888, 181 DRM_FORMAT_RGBX8888, 182 DRM_FORMAT_BGRX8888, 183 DRM_FORMAT_ARGB8888, 184 DRM_FORMAT_ABGR8888, 185 DRM_FORMAT_RGBA8888, 186 DRM_FORMAT_BGRA8888 187 }; 188 const size_t AdfTest::n_fmt8888 = sizeof(fmt8888) / sizeof(fmt8888[0]); 189 190 TEST(adf, devices) { 191 adf_id_t *devs = nullptr; 192 ssize_t n_devs = adf_devices(&devs); 193 free(devs); 194 195 ASSERT_GE(n_devs, 0) << "enumerating ADF devices failed: " << 196 strerror(-n_devs); 197 ASSERT_TRUE(devs != NULL); 198 } 199 200 TEST_F(AdfTest, device_data) { 201 adf_device_data data; 202 int err = adf_get_device_data(&dev, &data); 203 ASSERT_GE(err, 0) << "getting ADF device data failed: " << strerror(-err); 204 205 EXPECT_LT(data.n_attachments, ADF_MAX_ATTACHMENTS); 206 EXPECT_GT(data.n_allowed_attachments, 0U); 207 EXPECT_LT(data.n_allowed_attachments, ADF_MAX_ATTACHMENTS); 208 EXPECT_LT(data.custom_data_size, (size_t)ADF_MAX_CUSTOM_DATA_SIZE); 209 adf_free_device_data(&data); 210 } 211 212 TEST_F(AdfTest, interface_data) { 213 adf_interface_data data; 214 ASSERT_NO_FATAL_FAILURE(getInterfaceData(data)); 215 216 EXPECT_LT(data.type, ADF_INTF_TYPE_MAX); 217 EXPECT_LE(data.dpms_state, DRM_MODE_DPMS_OFF); 218 EXPECT_EQ(1, data.hotplug_detect); 219 EXPECT_GT(data.n_available_modes, 0U); 220 EXPECT_LT(data.custom_data_size, (size_t)ADF_MAX_CUSTOM_DATA_SIZE); 221 adf_free_interface_data(&data); 222 } 223 224 TEST_F(AdfTest, overlay_engine_data) { 225 adf_overlay_engine_data data; 226 int err = adf_get_overlay_engine_data(eng, &data); 227 ASSERT_GE(err, 0) << "getting ADF overlay engine failed: " << 228 strerror(-err); 229 230 EXPECT_GT(data.n_supported_formats, 0U); 231 EXPECT_LT(data.n_supported_formats, ADF_MAX_SUPPORTED_FORMATS); 232 EXPECT_LT(data.custom_data_size, (size_t)ADF_MAX_CUSTOM_DATA_SIZE); 233 adf_free_overlay_engine_data(&data); 234 } 235 236 TEST_F(AdfTest, blank) { 237 int err = adf_interface_blank(intf, (uint8_t)-1); 238 EXPECT_EQ(-EINVAL, err) << "setting bogus DPMS mode should have failed"; 239 240 err = adf_interface_blank(eng, DRM_MODE_DPMS_OFF); 241 EXPECT_EQ(-EINVAL, err) << "blanking overlay engine should have failed"; 242 243 ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_OFF)); 244 err = adf_interface_blank(intf, DRM_MODE_DPMS_OFF); 245 EXPECT_EQ(-EBUSY, err) << "blanking interface twice should have failed"; 246 247 ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_ON)); 248 err = adf_interface_blank(intf, DRM_MODE_DPMS_ON); 249 EXPECT_EQ(-EBUSY, err) << "unblanking interface twice should have failed"; 250 251 adf_interface_data data; 252 ASSERT_NO_FATAL_FAILURE(getInterfaceData(data)); 253 EXPECT_EQ(DRM_MODE_DPMS_ON, data.dpms_state); 254 adf_free_interface_data(&data); 255 } 256 257 TEST_F(AdfTest, event) { 258 int err = adf_set_event(intf, ADF_EVENT_TYPE_MAX, true); 259 EXPECT_EQ(-EINVAL, err) << "enabling bogus ADF event should have failed"; 260 261 err = adf_set_event(intf, ADF_EVENT_TYPE_MAX, false); 262 EXPECT_EQ(-EINVAL, err) << "disabling bogus ADF event should have failed"; 263 264 err = adf_set_event(intf, ADF_EVENT_VSYNC, true); 265 ASSERT_GE(err, 0) << "enabling vsync event failed: " << strerror(-err); 266 267 err = adf_set_event(intf, ADF_EVENT_VSYNC, true); 268 EXPECT_EQ(-EALREADY, err) << 269 "enabling vsync event twice should have failed"; 270 271 ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_ON)); 272 273 uint64_t timestamp1, timestamp2; 274 ASSERT_NO_FATAL_FAILURE(readVsyncTimestamp(timestamp1)); 275 ASSERT_NO_FATAL_FAILURE(readVsyncTimestamp(timestamp2)); 276 EXPECT_GT(timestamp2, timestamp1); 277 278 err = adf_set_event(intf, ADF_EVENT_VSYNC, false); 279 EXPECT_GE(err, 0) << "disabling vsync event failed: " << strerror(-err); 280 281 err = adf_set_event(intf, ADF_EVENT_VSYNC, false); 282 EXPECT_EQ(-EALREADY, err) << 283 "disabling vsync event twice should have failed"; 284 } 285 286 TEST_F(AdfTest, attach) { 287 ASSERT_NO_FATAL_FAILURE(attach()); 288 int err = adf_device_attach(&dev, eng_id, intf_id); 289 EXPECT_EQ(-EALREADY, err) << "attaching overlay engine " << eng_id << 290 " to interface " << intf_id << " twice should have failed"; 291 292 ASSERT_NO_FATAL_FAILURE(detach()); 293 err = adf_device_detach(&dev, eng_id, intf_id); 294 EXPECT_EQ(-EINVAL, err) << "detaching overlay engine " << eng_id << 295 " from interface " << intf_id << " twice should have failed"; 296 297 err = adf_device_attach(&dev, eng_id, ADF_MAX_INTERFACES); 298 EXPECT_EQ(-EINVAL, err) << "attaching overlay engine " << eng_id << 299 " to bogus interface should have failed"; 300 301 err = adf_device_detach(&dev, eng_id, ADF_MAX_INTERFACES); 302 EXPECT_EQ(-EINVAL, err) << "detaching overlay engine " << eng_id << 303 " from bogus interface should have failed"; 304 } 305 306 TEST_F(AdfTest, simple_buffer_alloc) { 307 uint32_t w = 0, h = 0; 308 ASSERT_NO_FATAL_FAILURE(getCurrentMode(w, h)); 309 310 uint32_t format; 311 char format_str[ADF_FORMAT_STR_SIZE]; 312 ASSERT_NO_FATAL_FAILURE(get8888Format(format, format_str)); 313 314 uint32_t offset; 315 uint32_t pitch; 316 int buf_fd = adf_interface_simple_buffer_alloc(intf, w, h, format, &offset, 317 &pitch); 318 EXPECT_GE(buf_fd, 0) << "allocating " << w << "x" << h << " " << 319 format_str << " buffer failed: " << strerror(-buf_fd); 320 EXPECT_GE(pitch, w * 4); 321 close(buf_fd); 322 323 buf_fd = adf_interface_simple_buffer_alloc(intf, w, h, 0xDEADBEEF, &offset, 324 &pitch); 325 /* n.b.: ADF only allows simple buffers with built-in RGB formats, 326 so this should fail even if a driver supports custom format 0xDEADBEEF */ 327 EXPECT_EQ(-EINVAL, buf_fd) << 328 "allocating buffer with bogus format should have failed"; 329 } 330 331 TEST_F(AdfTest, simple_buffer) { 332 int buf_fd; 333 uint32_t w, h, format, offset, pitch; 334 char format_str[ADF_FORMAT_STR_SIZE]; 335 ASSERT_NO_FATAL_FAILURE(drawCheckerboard(w, h, format, format_str, 336 buf_fd, offset, pitch)); 337 338 ASSERT_NO_FATAL_FAILURE(attach()); 339 ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_ON)); 340 341 int release_fence = adf_interface_simple_post(intf, eng_id, w, h, format, 342 buf_fd, offset, pitch, -1); 343 close(buf_fd); 344 ASSERT_GE(release_fence, 0) << "posting " << w << "x" << h << " " << 345 format_str << " buffer failed: " << strerror(-release_fence); 346 close(release_fence); 347 } 348 349 TEST_F(AdfTest, simple_buffer_v2) { 350 int buf_fd; 351 uint32_t w, h, format, offset, pitch; 352 char format_str[ADF_FORMAT_STR_SIZE]; 353 ASSERT_NO_FATAL_FAILURE(drawCheckerboard(w, h, format, format_str, 354 buf_fd, offset, pitch)); 355 356 ASSERT_NO_FATAL_FAILURE(attach()); 357 ASSERT_NO_FATAL_FAILURE(blank(DRM_MODE_DPMS_ON)); 358 359 int config_1_release; 360 int err = adf_interface_simple_post_v2(intf, eng_id, w, h, 361 format, buf_fd, offset, pitch, -1, ADF_COMPLETE_FENCE_RELEASE, 362 &config_1_release); 363 if (err == -ENOTTY) { 364 GTEST_LOG_(INFO) << "ADF_SIMPLE_POST_CONFIG_V2 not supported on this kernel"; 365 return; 366 } 367 ASSERT_GE(err, 0) << "posting " << w << "x" << h << " " << 368 format_str << " buffer failed: " << strerror(-err); 369 370 err = sync_wait(config_1_release, 1000); 371 ASSERT_EQ(-1, err) << 372 "waiting for config 1's release fence should not have suceeded"; 373 ASSERT_EQ(ETIME, errno) << 374 "config 1's release fence should have timed out, but failed instead: " << 375 strerror(errno); 376 377 int config_2_present; 378 err = adf_interface_simple_post_v2(intf, eng_id, w, h, 379 format, buf_fd, offset, pitch, -1, ADF_COMPLETE_FENCE_PRESENT, 380 &config_2_present); 381 ASSERT_GE(err, 0) << "posting " << w << "x" << h << " " << 382 format_str << " buffer failed: " << strerror(-err); 383 384 err = sync_wait(config_2_present, 1000); 385 ASSERT_EQ(0, err) << 386 "waiting for config 2's present fence failed: " << strerror(errno); 387 err = sync_wait(config_1_release, 0); 388 ASSERT_EQ(0, err) << 389 "waiting for config 1's release fence failed: " << strerror(errno); 390 close(config_1_release); 391 close(config_2_present); 392 393 int config_3_no_fence; 394 err = adf_interface_simple_post_v2(intf, eng_id, w, h, 395 format, buf_fd, offset, pitch, -1, ADF_COMPLETE_FENCE_NONE, 396 &config_3_no_fence); 397 ASSERT_GE(err, 0) << "posting " << w << "x" << h << " " << 398 format_str << " buffer failed: " << strerror(-err); 399 ASSERT_EQ(-1, config_3_no_fence) << 400 "fence returned even though the fence type was ADF_COMPLETE_FENCE_NONE"; 401 402 close(buf_fd); 403 } 404
