1
=== added file '.bzrignore'
2
--- .bzrignore	1970-01-01 00:00:00 +0000
3
+++ .bzrignore	2016-06-08 13:28:19 +0000
4
@@ -0,0 +1,3 @@
5
1
.idea
6
2
build
7
3
include/server/mir/version.h
8
0
4
9
=== modified file 'CMakeLists.txt'
10
--- CMakeLists.txt	2016-06-02 05:33:50 +0000
11
+++ CMakeLists.txt	2016-06-08 13:28:19 +0000
12
@@ -163,10 +163,10 @@
13
163
# Default to KMS backend, but build all of them
163
# Default to KMS backend, but build all of them
14
164
set(
164
set(
15
165
  MIR_PLATFORM
165
  MIR_PLATFORM
17
166
  mesa-kms;android;mesa-x11
166
  mesa-kms;android;mesa-x11;eglstream-kms
18
167
  CACHE
167
  CACHE
19
168
  STRING
168
  STRING
21
169
  "a list of graphics backends to build (options are 'mesa-kms', 'android' or 'mesa-x11')"
169
  "a list of graphics backends to build (options are 'mesa-kms', 'android', 'mesa-x11', or 'eglstream-kms')"
22
170
)
170
)
23
171
171
24
172
list(GET MIR_PLATFORM 0 MIR_TEST_PLATFORM)
172
list(GET MIR_PLATFORM 0 MIR_TEST_PLATFORM)
25
@@ -183,6 +183,9 @@
26
183
  if (platform STREQUAL "mesa-x11")
183
  if (platform STREQUAL "mesa-x11")
27
184
     set(MIR_BUILD_PLATFORM_MESA_X11 TRUE)
184
     set(MIR_BUILD_PLATFORM_MESA_X11 TRUE)
28
185
  endif()
185
  endif()
29
186
  if (platform STREQUAL "eglstream-kms")
30
187
     set(MIR_BUILD_PLATFORM_EGLSTREAM_KMS TRUE)
31
188
  endif()
32
186
endforeach(platform)
189
endforeach(platform)
33
187
190
34
188
find_package(EGL REQUIRED)
191
find_package(EGL REQUIRED)
35
@@ -245,6 +248,10 @@
36
245
  pkg_check_modules( DRM REQUIRED libdrm )
248
  pkg_check_modules( DRM REQUIRED libdrm )
37
246
endif()
249
endif()
38
247
250
39
251
if (MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
40
252
  pkg_check_modules(EPOXY REQUIRED epoxy)
41
253
endif()
42
254
43
248
set(MIR_ANDROID_INCLUDE_DIRECTORIES) # to be filled by android-input
255
set(MIR_ANDROID_INCLUDE_DIRECTORIES) # to be filled by android-input
44
249
set(MIR_ANDROID_INPUT_COMPILE_FLAGS) # to be filled by android-input
256
set(MIR_ANDROID_INPUT_COMPILE_FLAGS) # to be filled by android-input
45
250
set(MIR_3RD_PARTY_INCLUDE_DIRECTORIES)
257
set(MIR_3RD_PARTY_INCLUDE_DIRECTORIES)
46
251
258
47
=== modified file 'include/client/mir_toolkit/client_types.h'
48
--- include/client/mir_toolkit/client_types.h	2016-05-03 06:55:25 +0000
49
+++ include/client/mir_toolkit/client_types.h	2016-06-08 13:28:19 +0000
50
@@ -200,7 +200,8 @@
51
200
typedef enum MirPlatformType
200
typedef enum MirPlatformType
52
201
{
201
{
53
202
    mir_platform_type_gbm,
202
    mir_platform_type_gbm,
55
203
    mir_platform_type_android
203
    mir_platform_type_android,
56
204
    mir_platform_type_eglstream,
57
204
} MirPlatformType;
205
} MirPlatformType;
58
205
206
59
206
typedef struct MirPlatformPackage
207
typedef struct MirPlatformPackage
60
207
208
61
=== modified file 'src/platforms/CMakeLists.txt'
62
--- src/platforms/CMakeLists.txt	2016-05-03 06:55:25 +0000
63
+++ src/platforms/CMakeLists.txt	2016-06-08 13:28:19 +0000
64
@@ -71,4 +71,8 @@
65
71
  add_subdirectory(android/)
71
  add_subdirectory(android/)
66
72
endif()
72
endif()
67
73
73
69
74
  add_subdirectory(evdev/)
74
if (MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
70
75
  add_subdirectory(eglstream-kms)
71
76
endif()
72
77
73
78
add_subdirectory(evdev/)
74
75
79
75
=== added directory 'src/platforms/eglstream-kms'
76
=== added file 'src/platforms/eglstream-kms/CMakeLists.txt'
77
--- src/platforms/eglstream-kms/CMakeLists.txt	1970-01-01 00:00:00 +0000
78
+++ src/platforms/eglstream-kms/CMakeLists.txt	2016-06-08 13:28:19 +0000
79
@@ -0,0 +1,2 @@
80
1
add_subdirectory(client/)
81
2
add_subdirectory(server/)
82
0
3
83
=== added directory 'src/platforms/eglstream-kms/client'
84
=== added file 'src/platforms/eglstream-kms/client/CMakeLists.txt'
85
--- src/platforms/eglstream-kms/client/CMakeLists.txt	1970-01-01 00:00:00 +0000
86
+++ src/platforms/eglstream-kms/client/CMakeLists.txt	2016-06-08 13:28:19 +0000
87
@@ -0,0 +1,39 @@
88
1
include_directories(${client_common_include_dirs})
89
2
90
3
include_directories(
91
4
    ${DRM_INCLUDE_DIRS}
92
5
    ${EGL_INCLUDE_DIRS}
93
6
)
94
7
95
8
set(symbol_map ${CMAKE_CURRENT_SOURCE_DIR}/symbols.map)
96
9
97
10
add_library(mirclientplatformeglstreamobjects OBJECT
98
11
  client_platform_factory.cpp
99
12
  client_platform.cpp
100
13
  client_buffer_factory.cpp
101
14
  client_buffer.cpp
102
15
)
103
16
104
17
mir_add_library_with_symbols(
105
18
  mirclientplatformeglstream MODULE
106
19
107
20
  ${symbol_map}
108
21
  $<TARGET_OBJECTS:mirclientplatformeglstreamobjects>
109
22
)
110
23
111
24
set_target_properties(
112
25
  mirclientplatformeglstream PROPERTIES
113
26
  OUTPUT_NAME eglstream
114
27
  LIBRARY_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/client-modules
115
28
  PREFIX ""
116
29
  SUFFIX ".so.${MIR_CLIENT_PLATFORM_ABI}"
117
30
  LINK_FLAGS "-Wl,--version-script,${symbol_map}"
118
31
)
119
32
120
33
target_link_libraries(mirclientplatformeglstream
121
34
  mirclient
122
35
  client_platform_common
123
36
  ${DRM_LDFLAGS} ${DRM_LIBRARIES}
124
37
)
125
38
126
39
install(TARGETS mirclientplatformeglstream LIBRARY DESTINATION ${MIR_CLIENT_PLATFORM_PATH})
127
0
40
128
=== added file 'src/platforms/eglstream-kms/client/client_buffer.cpp'
129
--- src/platforms/eglstream-kms/client/client_buffer.cpp	1970-01-01 00:00:00 +0000
130
+++ src/platforms/eglstream-kms/client/client_buffer.cpp	2016-06-08 13:28:19 +0000
131
@@ -0,0 +1,159 @@
132
1
/*
133
2
 * Copyright © 2016 Canonical Ltd.
134
3
 *
135
4
 * This program is free software: you can redistribute it and/or modify it
136
5
 * under the terms of the GNU Lesser General Public License version 3,
137
6
 * as published by the Free Software Foundation.
138
7
 *
139
8
 * This program is distributed in the hope that it will be useful,
140
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
141
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
142
11
 * GNU Lesser General Public License for more details.
143
12
 *
144
13
 * You should have received a copy of the GNU Lesser General Public License
145
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
146
15
 *
147
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
148
17
 */
149
18
150
19
#include "mir_toolkit/mir_client_library.h"
151
20
#include "client_buffer.h"
152
21
153
22
#include <boost/throw_exception.hpp>
154
23
155
24
#include <stdexcept>
156
25
#include <system_error>
157
26
158
27
#include <errno.h>
159
28
#include <sys/mman.h>
160
29
161
30
namespace mcl=mir::client;
162
31
namespace mcle=mir::client::eglstream;
163
32
namespace geom=mir::geometry;
164
33
165
34
namespace
166
35
{
167
36
168
37
struct ShmMemoryRegion : mcl::MemoryRegion
169
38
{
170
39
    ShmMemoryRegion(
171
40
        int buffer_fd,
172
41
        geom::Size const& size_param,
173
42
        geom::Stride stride_param,
174
43
        MirPixelFormat format_param)
175
44
        : size_in_bytes{size_param.height.as_uint32_t() * stride_param.as_uint32_t()}
176
45
    {
177
46
        static off_t const map_offset = 0;
178
47
        width = size_param.width;
179
48
        height = size_param.height;
180
49
        stride = stride_param;
181
50
        format = format_param;
182
51
183
52
        void* map = mmap(
184
53
            nullptr,
185
54
            size_in_bytes,
186
55
            PROT_READ | PROT_WRITE,
187
56
            MAP_SHARED,
188
57
            buffer_fd,
189
58
            map_offset);
190
59
        if (map == MAP_FAILED)
191
60
        {
192
61
            BOOST_THROW_EXCEPTION((
193
62
                std::system_error{errno, std::system_category(), "Failed to mmap buffer"}));
194
63
        }
195
64
196
65
        vaddr = std::shared_ptr<char>(static_cast<char*>(map), [](auto*) noexcept {});
197
66
    }
198
67
199
68
    ~ShmMemoryRegion()
200
69
    {
201
70
        munmap(vaddr.get(), size_in_bytes);
202
71
    }
203
72
204
73
    size_t const size_in_bytes;
205
74
};
206
75
207
76
}
208
77
209
78
mcle::ClientBuffer::ClientBuffer(
210
79
    std::shared_ptr<MirBufferPackage> const& package,
211
80
    geom::Size size, MirPixelFormat pf)
212
81
    : creation_package{package},
213
82
      rect({geom::Point{0, 0}, size}),
214
83
      buffer_pf{pf}
215
84
{
216
85
    if (package->fd_items != 1)
217
86
    {
218
87
        BOOST_THROW_EXCEPTION(std::runtime_error(
219
88
            "Buffer package does not contain the expected number of fd items"));
220
89
    }
221
90
}
222
91
223
92
mcle::ClientBuffer::~ClientBuffer() noexcept
224
93
{
225
94
    // TODO (@raof): Error reporting? It should not be possible for this to fail; if it does,
226
95
    //               something's seriously wrong.
227
96
    close(creation_package->fd[0]);
228
97
}
229
98
230
99
std::shared_ptr<mcl::MemoryRegion> mcle::ClientBuffer::secure_for_cpu_write()
231
100
{
232
101
    int const buffer_fd = creation_package->fd[0];
233
102
234
103
    return std::make_shared<ShmMemoryRegion>(
235
104
        buffer_fd,
236
105
        size(),
237
106
        stride(),
238
107
        pixel_format());
239
108
}
240
109
241
110
geom::Size mcle::ClientBuffer::size() const
242
111
{
243
112
    return rect.size;
244
113
}
245
114
246
115
geom::Stride mcle::ClientBuffer::stride() const
247
116
{
248
117
    return geom::Stride{creation_package->stride};
249
118
}
250
119
251
120
MirPixelFormat mcle::ClientBuffer::pixel_format() const
252
121
{
253
122
    return buffer_pf;
254
123
}
255
124
256
125
std::shared_ptr<MirNativeBuffer> mcle::ClientBuffer::native_buffer_handle() const
257
126
{
258
127
    creation_package->age = age();
259
128
    return creation_package;
260
129
}
261
130
262
131
void mcle::ClientBuffer::update_from(MirBufferPackage const&)
263
132
{
264
133
}
265
134
266
135
void mcle::ClientBuffer::fill_update_msg(MirBufferPackage& package)
267
136
{
268
137
    package.data_items = 0;
269
138
    package.fd_items = 0;
270
139
}
271
140
272
141
MirNativeBuffer* mcle::ClientBuffer::as_mir_native_buffer() const
273
142
{
274
143
    //mesa has a POD native type for now. can return it directly to client API.
275
144
    return native_buffer_handle().get();
276
145
}
277
146
278
147
void mcle::ClientBuffer::set_fence(MirNativeFence*, MirBufferAccess)
279
148
{
280
149
}
281
150
282
151
MirNativeFence* mcle::ClientBuffer::get_fence() const
283
152
{
284
153
    return nullptr;
285
154
}
286
155
287
156
bool mcle::ClientBuffer::wait_fence(MirBufferAccess, std::chrono::nanoseconds)
288
157
{
289
158
    return true;
290
159
}
291
0
160
292
=== added file 'src/platforms/eglstream-kms/client/client_buffer.h'
293
--- src/platforms/eglstream-kms/client/client_buffer.h	1970-01-01 00:00:00 +0000
294
+++ src/platforms/eglstream-kms/client/client_buffer.h	2016-06-08 13:28:19 +0000
295
@@ -0,0 +1,67 @@
296
1
/*
297
2
 * Copyright © 2016 Canonical Ltd.
298
3
 *
299
4
 * This program is free software: you can redistribute it and/or modify it
300
5
 * under the terms of the GNU Lesser General Public License version 3,
301
6
 * as published by the Free Software Foundation.
302
7
 *
303
8
 * This program is distributed in the hope that it will be useful,
304
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
305
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
306
11
 * GNU Lesser General Public License for more details.
307
12
 *
308
13
 * You should have received a copy of the GNU Lesser General Public License
309
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
310
15
 *
311
16
 * Authored by:
312
17
 *   Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
313
18
 */
314
19
315
20
#ifndef MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_H_
316
21
#define MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_H_
317
22
318
23
#include "mir/aging_buffer.h"
319
24
#include "mir_toolkit/mir_client_library.h"
320
25
#include "mir/geometry/rectangle.h"
321
26
322
27
#include <memory>
323
28
324
29
namespace mir
325
30
{
326
31
namespace client
327
32
{
328
33
namespace eglstream
329
34
{
330
35
331
36
class ClientBuffer : public AgingBuffer
332
37
{
333
38
public:
334
39
    ClientBuffer(
335
40
        std::shared_ptr<MirBufferPackage> const& buffer_package,
336
41
        geometry::Size size,
337
42
        MirPixelFormat pf);
338
43
339
44
    ~ClientBuffer() noexcept;
340
45
341
46
    std::shared_ptr<MemoryRegion> secure_for_cpu_write();
342
47
    geometry::Size size() const;
343
48
    geometry::Stride stride() const;
344
49
    MirPixelFormat pixel_format() const;
345
50
    std::shared_ptr<MirNativeBuffer> native_buffer_handle() const;
346
51
    void update_from(MirBufferPackage const&);
347
52
    void fill_update_msg(MirBufferPackage&);
348
53
    MirNativeBuffer* as_mir_native_buffer() const;
349
54
    void set_fence(MirNativeFence*, MirBufferAccess);
350
55
    MirNativeFence* get_fence() const;
351
56
    bool wait_fence(MirBufferAccess, std::chrono::nanoseconds timeout);
352
57
353
58
private:
354
59
    std::shared_ptr<MirBufferPackage> const creation_package;
355
60
    geometry::Rectangle const rect;
356
61
    MirPixelFormat const buffer_pf;
357
62
};
358
63
359
64
}
360
65
}
361
66
}
362
67
#endif /* MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_H_ */
363
0
68
364
=== added file 'src/platforms/eglstream-kms/client/client_buffer_factory.cpp'
365
--- src/platforms/eglstream-kms/client/client_buffer_factory.cpp	1970-01-01 00:00:00 +0000
366
+++ src/platforms/eglstream-kms/client/client_buffer_factory.cpp	2016-06-08 13:28:19 +0000
367
@@ -0,0 +1,36 @@
368
1
/*
369
2
 * Copyright © 2016 Canonical Ltd.
370
3
 *
371
4
 * This program is free software: you can redistribute it and/or modify
372
5
 * it under the terms of the GNU Lesser General Public License version 3 as
373
6
 * published by the Free Software Foundation.
374
7
 *
375
8
 * This program is distributed in the hope that it will be useful,
376
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
377
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
378
11
 * GNU Lesser General Public License for more details.
379
12
 *
380
13
 * You should have received a copy of the GNU Lesser General Public License
381
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
382
15
 *
383
16
 * Authored by:
384
17
 *   Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
385
18
 */
386
19
387
20
#include "client_buffer_factory.h"
388
21
#include "client_buffer.h"
389
22
390
23
namespace mcl=mir::client;
391
24
namespace mcle=mir::client::eglstream;
392
25
393
26
std::shared_ptr<mcl::ClientBuffer>
394
27
mcle::ClientBufferFactory::create_buffer(
395
28
    std::shared_ptr<MirBufferPackage> const& package,
396
29
    geometry::Size /*size*/,
397
30
    MirPixelFormat pf)
398
31
{
399
32
    return std::make_shared<mcle::ClientBuffer>(
400
33
        package,
401
34
        geometry::Size{package->width, package->height},
402
35
        pf);
403
36
}
404
0
37
405
=== added file 'src/platforms/eglstream-kms/client/client_buffer_factory.h'
406
--- src/platforms/eglstream-kms/client/client_buffer_factory.h	1970-01-01 00:00:00 +0000
407
+++ src/platforms/eglstream-kms/client/client_buffer_factory.h	2016-06-08 13:28:19 +0000
408
@@ -0,0 +1,45 @@
409
1
/*
410
2
 * Copyright © 2016 Canonical Ltd.
411
3
 *
412
4
 * This program is free software: you can redistribute it and/or modify
413
5
 * it under the terms of the GNU Lesser General Public License version 3 as
414
6
 * published by the Free Software Foundation.
415
7
 *
416
8
 * This program is distributed in the hope that it will be useful,
417
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
418
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
419
11
 * GNU Lesser General Public License for more details.
420
12
 *
421
13
 * You should have received a copy of the GNU Lesser General Public License
422
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
423
15
 *
424
16
 * Authored by:
425
17
 *   Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
426
18
 */
427
19
428
20
#ifndef MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_FACTORY_H_
429
21
#define MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_FACTORY_H_
430
22
431
23
#include "mir/client_buffer_factory.h"
432
24
433
25
namespace mir
434
26
{
435
27
namespace client
436
28
{
437
29
namespace eglstream
438
30
{
439
31
440
32
class ClientBufferFactory : public client::ClientBufferFactory
441
33
{
442
34
public:
443
35
    ClientBufferFactory() = default;
444
36
445
37
    std::shared_ptr<client::ClientBuffer> create_buffer(
446
38
        std::shared_ptr<MirBufferPackage> const& package,
447
39
        geometry::Size size, MirPixelFormat pf);
448
40
};
449
41
450
42
}
451
43
}
452
44
}
453
45
#endif /* MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_FACTORY_H_ */
454
0
46
455
=== added file 'src/platforms/eglstream-kms/client/client_platform.cpp'
456
--- src/platforms/eglstream-kms/client/client_platform.cpp	1970-01-01 00:00:00 +0000
457
+++ src/platforms/eglstream-kms/client/client_platform.cpp	2016-06-08 13:28:19 +0000
458
@@ -0,0 +1,77 @@
459
1
/*
460
2
 * Copyright © 2016 Canonical Ltd.
461
3
 *
462
4
 * This program is free software: you can redistribute it and/or modify it
463
5
 * under the terms of the GNU Lesser General Public License version 3,
464
6
 * as published by the Free Software Foundation.
465
7
 *
466
8
 * This program is distributed in the hope that it will be useful,
467
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
468
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
469
11
 * GNU Lesser General Public License for more details.
470
12
 *
471
13
 * You should have received a copy of the GNU Lesser General Public License
472
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
473
15
 *
474
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
475
17
 */
476
18
477
19
#include "mir_toolkit/mir_client_library.h"
478
20
#include "client_platform.h"
479
21
#include "client_buffer_factory.h"
480
22
#include "mir/client_buffer_factory.h"
481
23
#include "mir/client_context.h"
482
24
483
25
#include <cstring>
484
26
#include <boost/throw_exception.hpp>
485
27
486
28
namespace mcl=mir::client;
487
29
namespace mcle=mir::client::eglstream;
488
30
namespace geom=mir::geometry;
489
31
490
32
mcle::ClientPlatform::ClientPlatform(ClientContext* const context)
491
33
    : context{context}
492
34
{
493
35
}
494
36
495
37
std::shared_ptr<mcl::ClientBufferFactory> mcle::ClientPlatform::create_buffer_factory()
496
38
{
497
39
    return std::make_shared<mcle::ClientBufferFactory>();
498
40
}
499
41
500
42
std::shared_ptr<void> mcle::ClientPlatform::create_egl_native_window(EGLNativeSurface* /*client_surface*/)
501
43
{
502
44
    return nullptr;
503
45
}
504
46
505
47
std::shared_ptr<EGLNativeDisplayType> mcle::ClientPlatform::create_egl_native_display()
506
48
{
507
49
    return nullptr;
508
50
}
509
51
510
52
MirPlatformType mcle::ClientPlatform::platform_type() const
511
53
{
512
54
    return mir_platform_type_eglstream;
513
55
}
514
56
515
57
void mcle::ClientPlatform::populate(MirPlatformPackage& /*package*/) const
516
58
{
517
59
}
518
60
519
61
MirPlatformMessage* mcle::ClientPlatform::platform_operation(MirPlatformMessage const* /*msg*/)
520
62
{
521
63
    return nullptr;
522
64
}
523
65
524
66
MirNativeBuffer* mcle::ClientPlatform::convert_native_buffer(graphics::NativeBuffer* buf) const
525
67
{
526
68
    // Only buffers we currently support are ShmBuffers, which are type-compatible
527
69
    return buf;
528
70
}
529
71
530
72
531
73
MirPixelFormat mcle::ClientPlatform::get_egl_pixel_format(
532
74
    EGLDisplay /*disp*/, EGLConfig /*conf*/) const
533
75
{
534
76
    BOOST_THROW_EXCEPTION(std::runtime_error{"EGL support unimplemented"});
535
77
}
536
0
78
537
=== added file 'src/platforms/eglstream-kms/client/client_platform.h'
538
--- src/platforms/eglstream-kms/client/client_platform.h	1970-01-01 00:00:00 +0000
539
+++ src/platforms/eglstream-kms/client/client_platform.h	2016-06-08 13:28:19 +0000
540
@@ -0,0 +1,52 @@
541
1
/*
542
2
 * Copyright © 2016 Canonical Ltd.
543
3
 *
544
4
 * This program is free software: you can redistribute it and/or modify it
545
5
 * under the terms of the GNU Lesser General Public License version 3,
546
6
 * as published by the Free Software Foundation.
547
7
 *
548
8
 * This program is distributed in the hope that it will be useful,
549
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
550
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
551
11
 * GNU Lesser General Public License for more details.
552
12
 *
553
13
 * You should have received a copy of the GNU Lesser General Public License
554
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
555
15
 *
556
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
557
17
 */
558
18
#ifndef MIR_CLIENT_EGLSTREAM_CLIENT_PLATFORM_H_
559
19
#define MIR_CLIENT_EGLSTREAM_CLIENT_PLATFORM_H_
560
20
561
21
#include "mir/client_platform.h"
562
22
563
23
namespace mir
564
24
{
565
25
namespace client
566
26
{
567
27
namespace eglstream
568
28
{
569
29
570
30
class ClientPlatform : public client::ClientPlatform
571
31
{
572
32
public:
573
33
    ClientPlatform(ClientContext* const context);
574
34
575
35
    MirPlatformType platform_type() const override;
576
36
    void populate(MirPlatformPackage& package) const override;
577
37
    MirPlatformMessage* platform_operation(MirPlatformMessage const* request) override;
578
38
    std::shared_ptr<ClientBufferFactory> create_buffer_factory() override;
579
39
    std::shared_ptr<void> create_egl_native_window(EGLNativeSurface *surface) override;
580
40
    std::shared_ptr<EGLNativeDisplayType> create_egl_native_display() override;
581
41
    MirNativeBuffer* convert_native_buffer(graphics::NativeBuffer*) const override;
582
42
    MirPixelFormat get_egl_pixel_format(EGLDisplay, EGLConfig) const override;
583
43
584
44
private:
585
45
    ClientContext* const context;
586
46
};
587
47
588
48
}
589
49
}
590
50
}
591
51
592
52
#endif /* MIR_CLIENT_EGLSTREAM_CLIENT_PLATFORM_H_ */
593
0
53
594
=== added file 'src/platforms/eglstream-kms/client/client_platform_factory.cpp'
595
--- src/platforms/eglstream-kms/client/client_platform_factory.cpp	1970-01-01 00:00:00 +0000
596
+++ src/platforms/eglstream-kms/client/client_platform_factory.cpp	2016-06-08 13:28:19 +0000
597
@@ -0,0 +1,59 @@
598
1
/*
599
2
 * Copyright © 2016 Canonical Ltd.
600
3
 *
601
4
 * This program is free software: you can redistribute it and/or modify it
602
5
 * under the terms of the GNU Lesser General Public License version 3,
603
6
 * as published by the Free Software Foundation.
604
7
 *
605
8
 * This program is distributed in the hope that it will be useful,
606
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
607
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
608
11
 * GNU Lesser General Public License for more details.
609
12
 *
610
13
 * You should have received a copy of the GNU Lesser General Public License
611
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
612
15
 *
613
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
614
17
 */
615
18
616
19
#include "mir/client_platform_factory.h"
617
20
#include "client_platform.h"
618
21
#include "mir_toolkit/client_types.h"
619
22
#include "mir/client_context.h"
620
23
#include "mir/egl_native_display_container.h"
621
24
#include "mir/assert_module_entry_point.h"
622
25
#include "mir/module_deleter.h"
623
26
624
27
#include "mir_toolkit/mir_client_library.h"
625
28
626
29
#include <cstring>
627
30
628
31
namespace mcl = mir::client;
629
32
namespace mcle = mcl::eglstream;
630
33
631
34
namespace
632
35
{
633
36
bool is_eglstream_server(mcl::ClientContext* context)
634
37
{
635
38
    MirModuleProperties module_properties;
636
39
637
40
    context->populate_graphics_module(module_properties);
638
41
639
42
    return strncmp(module_properties.name, "mir:eglstream", strlen("mir:eglstream")) == 0;
640
43
}
641
44
}
642
45
643
46
mir::UniqueModulePtr<mcl::ClientPlatform> create_client_platform(mcl::ClientContext* context)
644
47
{
645
48
    mir::assert_entry_point_signature<mcl::CreateClientPlatform>(&create_client_platform);
646
49
647
50
    return mir::make_module_ptr<mcle::ClientPlatform>(context);
648
51
}
649
52
650
53
bool
651
54
is_appropriate_module(mcl::ClientContext* context)
652
55
{
653
56
    mir::assert_entry_point_signature<mcl::ClientPlatformProbe>(&is_appropriate_module);
654
57
655
58
    return is_eglstream_server(context);
656
59
}
657
0
60
658
=== added file 'src/platforms/eglstream-kms/client/symbols.map'
659
--- src/platforms/eglstream-kms/client/symbols.map	1970-01-01 00:00:00 +0000
660
+++ src/platforms/eglstream-kms/client/symbols.map	2016-06-08 13:28:19 +0000
661
@@ -0,0 +1,7 @@
662
1
MIR_CLIENT_PLATFORM_5 {
663
2
  global:
664
3
    create_client_platform;
665
4
    is_appropriate_module;
666
5
  local:
667
6
    *;
668
7
};
669
0
8
670
=== added directory 'src/platforms/eglstream-kms/server'
671
=== added file 'src/platforms/eglstream-kms/server/CMakeLists.txt'
672
--- src/platforms/eglstream-kms/server/CMakeLists.txt	1970-01-01 00:00:00 +0000
673
+++ src/platforms/eglstream-kms/server/CMakeLists.txt	2016-06-08 13:28:19 +0000
674
@@ -0,0 +1,55 @@
675
1
include_directories(
676
2
  ${server_common_include_dirs}
677
3
  ${DRM_INCLUDE_DIRS}
678
4
  ${GBM_INCLUDE_DIRS}
679
5
  ${EGL_INCLUDE_DIRS}
680
6
  ${GLESv2_INCLUDE_DIRS}
681
7
  ${EPOXY_INCLUDE_DIRS}
682
8
)
683
9
684
10
configure_file(
685
11
  ${CMAKE_CURRENT_SOURCE_DIR}/symbols.map.in
686
12
  ${CMAKE_CURRENT_BINARY_DIR}/symbols.map
687
13
)
688
14
set(symbol_map ${CMAKE_CURRENT_BINARY_DIR}/symbols.map)
689
15
690
16
mir_add_library_with_symbols(
691
17
  mirplatformgraphicseglstreamkms MODULE
692
18
693
19
  ${symbol_map}
694
20
  platform_symbols.cpp
695
21
  platform.cpp
696
22
  buffer_allocator.cpp
697
23
  buffer_allocator.h
698
24
  display.cpp
699
25
  display.h
700
26
  kms_display_configuration.h
701
27
  kms_display_configuration.cpp
702
28
  egl_output.h
703
29
  egl_output.cpp
704
30
)
705
31
706
32
target_link_libraries(
707
33
  mirplatformgraphicseglstreamkms
708
34
709
35
  PRIVATE
710
36
  mirplatform
711
37
  server_platform_common
712
38
  kms_utils
713
39
  ${Boost_PROGRAM_OPTIONS_LIBRARY}
714
40
  ${DRM_LDFLAGS} ${DRM_LIBRARIES}
715
41
  ${EGL_LDFLAGS} ${EGL_LIBRARIES}
716
42
  ${GLESv2_LDFLAGS} ${GLESv2_LIBRARIES}
717
43
  ${EPOXY_LDFLAGS} ${EPOXY_LIBRARIES}
718
44
)
719
45
720
46
set_target_properties(
721
47
  mirplatformgraphicseglstreamkms PROPERTIES
722
48
  OUTPUT_NAME graphics-eglstream-kms
723
49
  LIBRARY_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/server-modules
724
50
  PREFIX ""
725
51
  SUFFIX ".so.${MIR_SERVER_GRAPHICS_PLATFORM_ABI}"
726
52
  LINK_FLAGS "-Wl,--exclude-libs=ALL -Wl,--version-script,${symbol_map}"
727
53
)
728
54
729
55
install(TARGETS mirplatformgraphicseglstreamkms LIBRARY DESTINATION ${MIR_SERVER_PLATFORM_PATH})
730
0
56
731
=== added file 'src/platforms/eglstream-kms/server/buffer_allocator.cpp'
732
--- src/platforms/eglstream-kms/server/buffer_allocator.cpp	1970-01-01 00:00:00 +0000
733
+++ src/platforms/eglstream-kms/server/buffer_allocator.cpp	2016-06-08 13:28:19 +0000
734
@@ -0,0 +1,69 @@
735
1
/*
736
2
 * Copyright © 2016 Canonical Ltd.
737
3
 *
738
4
 * This program is free software: you can redistribute it and/or modify it
739
5
 * under the terms of the GNU Lesser General Public License version 3,
740
6
 * as published by the Free Software Foundation.
741
7
 *
742
8
 * This program is distributed in the hope that it will be useful,
743
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
744
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
745
11
 * GNU Lesser General Public License for more details.
746
12
 *
747
13
 * You should have received a copy of the GNU Lesser General Public License
748
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
749
15
 *
750
16
 * Authored by:
751
17
 *   Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
752
18
 */
753
19
754
20
#include "buffer_allocator.h"
755
21
#include "buffer_texture_binder.h"
756
22
#include "anonymous_shm_file.h"
757
23
#include "shm_buffer.h"
758
24
#include "mir/graphics/buffer_properties.h"
759
25
#include <boost/throw_exception.hpp>
760
26
#include <boost/exception/errinfo_errno.hpp>
761
27
762
28
#include <system_error>
763
29
#include <cassert>
764
30
765
31
namespace mg  = mir::graphics;
766
32
namespace mge = mg::eglstream;
767
33
namespace mgc = mg::common;
768
34
namespace geom = mir::geometry;
769
35
770
36
mge::BufferAllocator::BufferAllocator()
771
37
{
772
38
}
773
39
774
40
std::shared_ptr<mg::Buffer> mge::BufferAllocator::alloc_buffer(
775
41
    BufferProperties const& buffer_properties)
776
42
{
777
43
    if (!mgc::ShmBuffer::supports(buffer_properties.format))
778
44
    {
779
45
        BOOST_THROW_EXCEPTION(
780
46
            std::runtime_error(
781
47
                "Trying to create SHM buffer with unsupported pixel format"));
782
48
    }
783
49
784
50
    auto const stride = geom::Stride{
785
51
        MIR_BYTES_PER_PIXEL(buffer_properties.format) *
786
52
        buffer_properties.size.width.as_uint32_t()};
787
53
    size_t const size_in_bytes =
788
54
        stride.as_int() * buffer_properties.size.height.as_int();
789
55
    auto shm_file =
790
56
        std::make_unique<mgc::AnonymousShmFile>(size_in_bytes);
791
57
792
58
    auto const buffer =
793
59
        std::make_shared<mgc::ShmBuffer>(std::move(shm_file), buffer_properties.size,
794
60
                                         buffer_properties.format);
795
61
796
62
    return buffer;
797
63
}
798
64
799
65
std::vector<MirPixelFormat> mge::BufferAllocator::supported_pixel_formats()
800
66
{
801
67
    // Lazy
802
68
    return {mir_pixel_format_argb_8888, mir_pixel_format_xrgb_8888};
803
69
}
804
0
70
805
=== added file 'src/platforms/eglstream-kms/server/buffer_allocator.h'
806
--- src/platforms/eglstream-kms/server/buffer_allocator.h	1970-01-01 00:00:00 +0000
807
+++ src/platforms/eglstream-kms/server/buffer_allocator.h	2016-06-08 13:28:19 +0000
808
@@ -0,0 +1,48 @@
809
1
/*
810
2
 * Copyright © 2016 Canonical Ltd.
811
3
 *
812
4
 * This program is free software: you can redistribute it and/or modify it
813
5
 * under the terms of the GNU Lesser General Public License version 3,
814
6
 * as published by the Free Software Foundation.
815
7
 *
816
8
 * This program is distributed in the hope that it will be useful,
817
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
818
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
819
11
 * GNU Lesser General Public License for more details.
820
12
 *
821
13
 * You should have received a copy of the GNU Lesser General Public License
822
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
823
15
 *
824
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
825
17
 */
826
18
827
19
#ifndef MIR_PLATFORMS_EGLSTREAM_BUFFER_ALLOCATOR_
828
20
#define MIR_PLATFORMS_EGLSTREAM_BUFFER_ALLOCATOR_
829
21
830
22
#include "mir/graphics/graphic_buffer_allocator.h"
831
23
#include "mir/graphics/buffer_id.h"
832
24
833
25
#include <memory>
834
26
835
27
namespace mir
836
28
{
837
29
namespace graphics
838
30
{
839
31
840
32
namespace eglstream
841
33
{
842
34
843
35
class BufferAllocator: public graphics::GraphicBufferAllocator
844
36
{
845
37
public:
846
38
    BufferAllocator();
847
39
848
40
    std::shared_ptr<Buffer> alloc_buffer(graphics::BufferProperties const& buffer_properties) override;
849
41
    std::vector<MirPixelFormat> supported_pixel_formats() override;
850
42
};
851
43
852
44
}
853
45
}
854
46
}
855
47
856
48
#endif // MIR_PLATFORMS_EGLSTREAM_BUFFER_ALLOCATOR_
857
0
49
858
=== added file 'src/platforms/eglstream-kms/server/display.cpp'
859
--- src/platforms/eglstream-kms/server/display.cpp	1970-01-01 00:00:00 +0000
860
+++ src/platforms/eglstream-kms/server/display.cpp	2016-06-08 13:28:19 +0000
861
@@ -0,0 +1,363 @@
862
1
/*
863
2
 * Copyright © 2016 Canonical Ltd.
864
3
 *
865
4
 * This program is free software: you can redistribute it and/or modify it
866
5
 * under the terms of the GNU Lesser General Public License version 3,
867
6
 * as published by the Free Software Foundation.
868
7
 *
869
8
 * This program is distributed in the hope that it will be useful,
870
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
871
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
872
11
 * GNU Lesser General Public License for more details.
873
12
 *
874
13
 * You should have received a copy of the GNU Lesser General Public License
875
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
876
15
 *
877
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
878
17
 */
879
18
880
19
#include <epoxy/egl.h>
881
20
882
21
#include "display.h"
883
22
#include "egl_output.h"
884
23
885
24
#include "kms-utils/drm_mode_resources.h"
886
25
887
26
#include "mir/graphics/display_configuration.h"
888
27
#include "mir/graphics/display_configuration_policy.h"
889
28
#include "mir/graphics/overlapping_output_grouping.h"
890
29
#include "mir/graphics/gl_context.h"
891
30
#include "mir/graphics/gl_config.h"
892
31
#include "mir/graphics/virtual_output.h"
893
32
#include "mir/graphics/egl_error.h"
894
33
#include "mir/graphics/display_buffer.h"
895
34
#include "mir/renderer/gl/render_target.h"
896
35
897
36
#include <drm/drm.h>
898
37
#include <xf86drmMode.h>
899
38
#include <sys/ioctl.h>
900
39
#include <system_error>
901
40
#include <boost/throw_exception.hpp>
902
41
903
42
namespace mg = mir::graphics;
904
43
namespace mge = mir::graphics::eglstream;
905
44
namespace mgk = mir::graphics::kms;
906
45
907
46
namespace
908
47
{
909
48
EGLConfig choose_config(EGLDisplay display, mg::GLConfig const& requested_config)
910
49
{
911
50
    EGLint const config_attr[] = {
912
51
        EGL_SURFACE_TYPE, EGL_STREAM_BIT_KHR,
913
52
        EGL_RED_SIZE, 8,
914
53
        EGL_GREEN_SIZE, 8,
915
54
        EGL_BLUE_SIZE, 8,
916
55
        EGL_ALPHA_SIZE, 0,
917
56
        EGL_DEPTH_SIZE, requested_config.depth_buffer_bits(),
918
57
        EGL_STENCIL_SIZE, requested_config.stencil_buffer_bits(),
919
58
        EGL_RENDERABLE_TYPE, MIR_SERVER_EGL_OPENGL_BIT,
920
59
        EGL_NONE
921
60
    };
922
61
923
62
    EGLint num_egl_configs;
924
63
    EGLConfig egl_config;
925
64
    if (eglChooseConfig(display, config_attr, &egl_config, 1, &num_egl_configs) != EGL_TRUE)
926
65
    {
927
66
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to chose EGL config"));
928
67
    }
929
68
    else if (num_egl_configs != 1)
930
69
    {
931
70
        BOOST_THROW_EXCEPTION(std::runtime_error{"Failed to find compatible EGL config"});
932
71
    }
933
72
934
73
    return egl_config;
935
74
}
936
75
937
76
EGLContext create_context(EGLDisplay display, EGLConfig config)
938
77
{
939
78
    eglBindAPI(MIR_SERVER_EGL_OPENGL_API);
940
79
941
80
    EGLint const context_attr[] = {
942
81
#if MIR_SERVER_EGL_OPENGL_BIT == EGL_OPENGL_ES2_BIT
943
82
        EGL_CONTEXT_CLIENT_VERSION, 2,
944
83
#endif
945
84
        EGL_NONE
946
85
    };
947
86
948
87
    EGLContext context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attr);
949
88
    if (context == EGL_NO_CONTEXT)
950
89
    {
951
90
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGL context"));
952
91
    }
953
92
954
93
    return context;
955
94
}
956
95
957
96
EGLContext create_context(EGLDisplay display, EGLConfig config, EGLContext shared_context)
958
97
{
959
98
    eglBindAPI(MIR_SERVER_EGL_OPENGL_API);
960
99
961
100
    EGLint const context_attr[] = {
962
101
#if MIR_SERVER_EGL_OPENGL_BIT == EGL_OPENGL_ES2_BIT
963
102
        EGL_CONTEXT_CLIENT_VERSION, 2,
964
103
#endif
965
104
        EGL_NONE
966
105
    };
967
106
968
107
    EGLContext context = eglCreateContext(display, config, shared_context, context_attr);
969
108
    if (context == EGL_NO_CONTEXT)
970
109
    {
971
110
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGL context"));
972
111
    }
973
112
974
113
    return context;
975
114
}
976
115
977
116
class DisplayBuffer
978
117
    : public mg::DisplaySyncGroup,
979
118
      public mg::DisplayBuffer,
980
119
      public mg::NativeDisplayBuffer,
981
120
      public mir::renderer::gl::RenderTarget
982
121
{
983
122
public:
984
123
    DisplayBuffer(EGLDisplay dpy, EGLContext ctx, EGLConfig config, mge::kms::EGLOutput const& output)
985
124
        : dpy{dpy},
986
125
          ctx{create_context(dpy, config, ctx)},
987
126
          layer{output.output_layer()},
988
127
          view_area_{output.top_left, output.size()}
989
128
    {
990
129
        EGLint const stream_attribs[] = {
991
130
            EGL_STREAM_FIFO_LENGTH_KHR, 1,
992
131
            EGL_NONE
993
132
        };
994
133
        output_stream = eglCreateStreamKHR(dpy, stream_attribs);
995
134
        if (output_stream == EGL_NO_STREAM_KHR)
996
135
        {
997
136
            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGLStream"));
998
137
        }
999
138
1000
139
        EGLAttrib swap_interval;
1001
140
        if (eglQueryOutputLayerAttribEXT(dpy, layer, EGL_SWAP_INTERVAL_EXT, &swap_interval) != EGL_TRUE)
1002
141
        {
1003
142
            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to query swap interval"));
1004
143
        }
1005
144
1006
145
        if (eglOutputLayerAttribEXT(dpy, layer, EGL_SWAP_INTERVAL_EXT, 1) != EGL_TRUE)
1007
146
        {
1008
147
            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to set swap interval"));
1009
148
        }
1010
149
1011
150
        if (eglStreamConsumerOutputEXT(dpy, output_stream, output.output_layer()) == EGL_FALSE)
1012
151
        {
1013
152
            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to attach EGLStream to output"));
1014
153
        };
1015
154
1016
155
        EGLint const surface_attribs[] = {
1017
156
            EGL_WIDTH, output.size().width.as_int(),
1018
157
            EGL_HEIGHT, output.size().height.as_int(),
1019
158
            EGL_NONE,
1020
159
        };
1021
160
        surface = eglCreateStreamProducerSurfaceKHR(dpy, config, output_stream, surface_attribs);
1022
161
        if (surface == EGL_NO_SURFACE)
1023
162
        {
1024
163
            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create StreamProducerSurface"));
1025
164
        }
1026
165
1027
166
    }
1028
167
1029
168
    /* gl::RenderTarget */
1030
169
    void make_current() override
1031
170
    {
1032
171
        if (eglMakeCurrent(dpy, surface, surface, ctx) != EGL_TRUE)
1033
172
        {
1034
173
            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to make context current"));
1035
174
        }
1036
175
    }
1037
176
1038
177
    void release_current() override
1039
178
    {
1040
179
        if (eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT) != EGL_TRUE)
1041
180
        {
1042
181
            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to release context"));
1043
182
        }
1044
183
    }
1045
184
1046
185
    void swap_buffers() override
1047
186
    {
1048
187
        if (eglSwapBuffers(dpy, surface) != EGL_TRUE)
1049
188
        {
1050
189
            BOOST_THROW_EXCEPTION(mg::egl_error("eglSwapBuffers failed"));
1051
190
        }
1052
191
    }
1053
192
1054
193
    mir::geometry::Rectangle view_area() const override
1055
194
    {
1056
195
        return view_area_;
1057
196
    }
1058
197
1059
198
    bool post_renderables_if_optimizable(const mir::graphics::RenderableList& /*renderlist*/) override
1060
199
    {
1061
200
        return false;
1062
201
    }
1063
202
1064
203
    MirOrientation orientation() const override
1065
204
    {
1066
205
        return mir_orientation_normal;
1067
206
    }
1068
207
1069
208
    MirMirrorMode mirror_mode() const override
1070
209
    {
1071
210
        return mir_mirror_mode_none;
1072
211
    }
1073
212
1074
213
    mir::graphics::NativeDisplayBuffer* native_display_buffer() override
1075
214
    {
1076
215
        return this;
1077
216
    }
1078
217
1079
218
    void for_each_display_buffer(const std::function<void(mir::graphics::DisplayBuffer&)>& f) override
1080
219
    {
1081
220
        f(*this);
1082
221
    }
1083
222
1084
223
    void post() override
1085
224
    {
1086
225
1087
226
    }
1088
227
1089
228
    void bind() override
1090
229
    {
1091
230
    }
1092
231
1093
232
    std::chrono::milliseconds recommended_sleep() const override
1094
233
    {
1095
234
        return std::chrono::milliseconds{0};
1096
235
    }
1097
236
1098
237
private:
1099
238
    EGLDisplay dpy;
1100
239
    EGLContext ctx;
1101
240
    EGLOutputLayerEXT layer;
1102
241
    mir::geometry::Rectangle const view_area_;
1103
242
    EGLStreamKHR output_stream;
1104
243
    EGLSurface surface;
1105
244
};
1106
245
}
1107
246
1108
247
mge::Display::Display(
1109
248
    mir::Fd drm_node,
1110
249
    EGLDisplay display,
1111
250
    std::shared_ptr<DisplayConfigurationPolicy> const& configuration_policy,
1112
251
    GLConfig const& gl_conf)
1113
252
    : drm_node{drm_node},
1114
253
      display{display},
1115
254
      config{choose_config(display, gl_conf)},
1116
255
      context{create_context(display, config)},
1117
256
      display_configuration{this->drm_node, display}
1118
257
{
1119
258
    auto ret = drmSetClientCap(drm_node, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
1120
259
    if (ret != 0)
1121
260
    {
1122
261
        BOOST_THROW_EXCEPTION(std::system_error(-ret, std::system_category(), "Request for Universal Planes support failed"));
1123
262
    }
1124
263
1125
264
    ret = drmSetClientCap(drm_node, DRM_CLIENT_CAP_ATOMIC, 1);
1126
265
    if (ret != 0)
1127
266
    {
1128
267
        BOOST_THROW_EXCEPTION(std::system_error(-ret, std::system_category(), "Request for Atomic Modesetting support failed"));
1129
268
    }
1130
269
1131
270
    configuration_policy->apply_to(display_configuration);
1132
271
1133
272
    configure(display_configuration);
1134
273
}
1135
274
1136
275
void mge::Display::for_each_display_sync_group(const std::function<void(DisplaySyncGroup&)>& f)
1137
276
{
1138
277
    for (auto& group : active_sync_groups)
1139
278
    {
1140
279
        f(*group);
1141
280
    }
1142
281
}
1143
282
1144
283
std::unique_ptr<mg::DisplayConfiguration> mge::Display::configuration() const
1145
284
{
1146
285
    return display_configuration.clone();
1147
286
}
1148
287
1149
288
void mge::Display::configure(DisplayConfiguration const& conf)
1150
289
{
1151
290
    auto kms_conf = dynamic_cast<KMSDisplayConfiguration const&>(conf);
1152
291
    active_sync_groups.clear();
1153
292
    kms_conf.for_each_output([this, &conf](kms::EGLOutput const& output)
1154
293
         {
1155
294
             if (output.used)
1156
295
             {
1157
296
                 const_cast<kms::EGLOutput&>(output).configure(output.current_mode_index);
1158
297
                 active_sync_groups.emplace_back(std::make_unique<::DisplayBuffer>(display, context, config, output));
1159
298
             }
1160
299
         });
1161
300
}
1162
301
1163
302
void mge::Display::register_configuration_change_handler(
1164
303
    EventHandlerRegister& /*handlers*/,
1165
304
    DisplayConfigurationChangeHandler const& /*conf_change_handler*/)
1166
305
{
1167
306
}
1168
307
1169
308
void mge::Display::register_pause_resume_handlers(
1170
309
    EventHandlerRegister& /*handlers*/,
1171
310
    DisplayPauseHandler const& /*pause_handler*/,
1172
311
    DisplayResumeHandler const& /*resume_handler*/)
1173
312
{
1174
313
}
1175
314
1176
315
void mge::Display::pause()
1177
316
{
1178
317
1179
318
}
1180
319
1181
320
void mge::Display::resume()
1182
321
{
1183
322
1184
323
}
1185
324
1186
325
std::shared_ptr<mg::Cursor> mge::Display::create_hardware_cursor(
1187
326
    std::shared_ptr<CursorImage> const& /*initial_image*/)
1188
327
{
1189
328
    // TODO: Find the cursor plane, and use it.
1190
329
    return nullptr;
1191
330
}
1192
331
1193
332
std::unique_ptr<mg::GLContext> mge::Display::create_gl_context()
1194
333
{
1195
334
    class GLContext : public mg::GLContext
1196
335
    {
1197
336
    public:
1198
337
        GLContext(EGLDisplay display, EGLContext context)
1199
338
            : display{display},
1200
339
              context{context}
1201
340
        {
1202
341
        }
1203
342
1204
343
        void make_current() const override
1205
344
        {
1206
345
            eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, context);
1207
346
        }
1208
347
1209
348
        void release_current() const override
1210
349
        {
1211
350
            eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
1212
351
        }
1213
352
1214
353
    private:
1215
354
        EGLDisplay display;
1216
355
        EGLContext context;
1217
356
    };
1218
357
    return std::make_unique<GLContext>(display, context);
1219
358
}
1220
359
1221
360
std::unique_ptr<mg::VirtualOutput> mge::Display::create_virtual_output(int /*width*/, int /*height*/)
1222
361
{
1223
362
    return nullptr;
1224
363
}
1225
0
364
1226
=== added file 'src/platforms/eglstream-kms/server/display.h'
1227
--- src/platforms/eglstream-kms/server/display.h	1970-01-01 00:00:00 +0000
1228
+++ src/platforms/eglstream-kms/server/display.h	2016-06-08 13:28:19 +0000
1229
@@ -0,0 +1,82 @@
1230
1
/*
1231
2
 * Copyright © 2016 Canonical Ltd.
1232
3
 *
1233
4
 * This program is free software: you can redistribute it and/or modify it
1234
5
 * under the terms of the GNU Lesser General Public License version 3,
1235
6
 * as published by the Free Software Foundation.
1236
7
 *
1237
8
 * This program is distributed in the hope that it will be useful,
1238
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1239
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1240
11
 * GNU Lesser General Public License for more details.
1241
12
 *
1242
13
 * You should have received a copy of the GNU Lesser General Public License
1243
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1244
15
 *
1245
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
1246
17
 */
1247
18
1248
19
#ifndef MIR_PLATFORMS_EGLSTREAM_KMS_DISPLAY_H_
1249
20
#define MIR_PLATFORMS_EGLSTREAM_KMS_DISPLAY_H_
1250
21
1251
22
#include "mir/graphics/display.h"
1252
23
#include "kms_display_configuration.h"
1253
24
#include "mir/fd.h"
1254
25
1255
26
namespace mir
1256
27
{
1257
28
namespace graphics
1258
29
{
1259
30
class DisplayConfigurationPolicy;
1260
31
class GLConfig;
1261
32
1262
33
namespace eglstream
1263
34
{
1264
35
1265
36
class Display : public mir::graphics::Display
1266
37
{
1267
38
public:
1268
39
    Display(
1269
40
        mir::Fd drm_node,
1270
41
        EGLDisplay display,
1271
42
        std::shared_ptr<DisplayConfigurationPolicy> const& configuration_policy,
1272
43
        GLConfig const& gl_conf);
1273
44
1274
45
    void for_each_display_sync_group(const std::function<void(DisplaySyncGroup&)>& f) override;
1275
46
1276
47
    std::unique_ptr<DisplayConfiguration> configuration() const override;
1277
48
1278
49
    void configure(DisplayConfiguration const& conf) override;
1279
50
1280
51
    void register_configuration_change_handler(EventHandlerRegister& handlers,
1281
52
        DisplayConfigurationChangeHandler const& conf_change_handler) override;
1282
53
1283
54
    void register_pause_resume_handlers(EventHandlerRegister& handlers,
1284
55
        DisplayPauseHandler const& pause_handler, DisplayResumeHandler const& resume_handler) override;
1285
56
1286
57
    void pause() override;
1287
58
1288
59
    void resume() override;
1289
60
1290
61
    std::shared_ptr<Cursor> create_hardware_cursor(std::shared_ptr<CursorImage> const& initial_image) override;
1291
62
1292
63
    std::unique_ptr<GLContext> create_gl_context() override;
1293
64
1294
65
    std::unique_ptr<VirtualOutput> create_virtual_output(int width, int height) override;
1295
66
1296
67
private:
1297
68
    mir::Fd const drm_node;
1298
69
    EGLDisplay display;
1299
70
    EGLConfig config;
1300
71
    EGLContext context;
1301
72
    KMSDisplayConfiguration display_configuration;
1302
73
    std::vector<std::unique_ptr<DisplaySyncGroup>> active_sync_groups;
1303
74
    std::shared_ptr<DisplayConfigurationPolicy> const configuration_policy;
1304
75
};
1305
76
1306
77
}
1307
78
}
1308
79
1309
80
}
1310
81
1311
82
#endif  // MIR_PLATFORMS_EGLSTREAM_KMS_DISPLAY_H_
1312
0
83
1313
=== added file 'src/platforms/eglstream-kms/server/egl_output.cpp'
1314
--- src/platforms/eglstream-kms/server/egl_output.cpp	1970-01-01 00:00:00 +0000
1315
+++ src/platforms/eglstream-kms/server/egl_output.cpp	2016-06-08 13:28:19 +0000
1316
@@ -0,0 +1,359 @@
1317
1
/*
1318
2
 * Copyright © 2016 Canonical Ltd.
1319
3
 *
1320
4
 * This program is free software: you can redistribute it and/or modify it
1321
5
 * under the terms of the GNU Lesser General Public License version 3,
1322
6
 * as published by the Free Software Foundation.
1323
7
 *
1324
8
 * This program is distributed in the hope that it will be useful,
1325
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1326
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1327
11
 * GNU Lesser General Public License for more details.
1328
12
 *
1329
13
 * You should have received a copy of the GNU Lesser General Public License
1330
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1331
15
 *
1332
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
1333
17
 */
1334
18
1335
19
#include <epoxy/egl.h>
1336
20
1337
21
#include "egl_output.h"
1338
22
#include "mir/graphics/egl_error.h"
1339
23
#include "kms-utils/kms_connector.h"
1340
24
1341
25
#include <cstring>
1342
26
#include <drm/drm.h>
1343
27
#include <sys/ioctl.h>
1344
28
#include <vector>
1345
29
#include <boost/throw_exception.hpp>
1346
30
#include <unordered_map>
1347
31
#include <tuple>
1348
32
#include <sys/mman.h>
1349
33
1350
34
namespace mg = mir::graphics;
1351
35
namespace mge = mg::eglstream;
1352
36
namespace mgek = mge::kms;
1353
37
namespace mgk = mg::kms;
1354
38
namespace geom = mir::geometry;
1355
39
1356
40
namespace
1357
41
{
1358
42
namespace
1359
43
{
1360
44
class DumbFb
1361
45
{
1362
46
public:
1363
47
    DumbFb(int drm_fd, uint32_t width, uint32_t height)
1364
48
        : drm_fd{drm_fd}
1365
49
    {
1366
50
        struct drm_mode_create_dumb params = {};
1367
51
1368
52
        params.bpp = 32;
1369
53
        params.height = height;
1370
54
        params.width = width;
1371
55
1372
56
        if (ioctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &params) != 0)
1373
57
        {
1374
58
            BOOST_THROW_EXCEPTION((std::system_error{errno, std::system_category(), "Failed to create dumb buffer"}));
1375
59
        }
1376
60
1377
61
        gem_handle = params.handle;
1378
62
        pitch_ = params.pitch;
1379
63
1380
64
        auto ret = drmModeAddFB(drm_fd, width, height, 24, 32, params.pitch, params.handle, &fb_id);
1381
65
        if (ret)
1382
66
        {
1383
67
            BOOST_THROW_EXCEPTION((std::system_error{-ret, std::system_category(), "Failed to attach dumb buffer to FB"}));
1384
68
        }
1385
69
1386
70
        struct drm_mode_map_dumb map_request = {};
1387
71
1388
72
        map_request.handle = gem_handle;
1389
73
1390
74
        ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map_request);
1391
75
        if (ret)
1392
76
        {
1393
77
            BOOST_THROW_EXCEPTION((std::system_error{-ret, std::system_category(), "Failed to map dumb buffer"}));
1394
78
        }
1395
79
1396
80
        auto map = mmap(0, params.size, PROT_READ | PROT_WRITE, MAP_SHARED, drm_fd, map_request.offset);
1397
81
        if (map == MAP_FAILED)
1398
82
        {
1399
83
            BOOST_THROW_EXCEPTION((std::system_error{errno, std::system_category(), "Failed to mmap() buffer"}));
1400
84
        }
1401
85
    }
1402
86
    ~DumbFb() noexcept(false)
1403
87
    {
1404
88
        struct drm_mode_destroy_dumb params = { gem_handle };
1405
89
1406
90
        if (ioctl(drm_fd, DRM_IOCTL_MODE_DESTROY_DUMB, &params) != 0)
1407
91
        {
1408
92
            if (!std::uncaught_exception())
1409
93
            {
1410
94
                BOOST_THROW_EXCEPTION((std::system_error{errno, std::system_category(), "Failed to destroy dumb buffer"}));
1411
95
            }
1412
96
        }
1413
97
    }
1414
98
1415
99
    uint32_t handle() const
1416
100
    {
1417
101
        return gem_handle;
1418
102
    }
1419
103
1420
104
    uint32_t pitch() const
1421
105
    {
1422
106
        return pitch_;
1423
107
    }
1424
108
1425
109
    uint32_t id() const
1426
110
    {
1427
111
        return fb_id;
1428
112
    }
1429
113
1430
114
private:
1431
115
    int const drm_fd;
1432
116
    uint32_t fb_id;
1433
117
    uint32_t gem_handle;
1434
118
    uint32_t pitch_;
1435
119
};
1436
120
1437
121
}
1438
122
1439
123
uint32_t kms_id_from_port(EGLDisplay dpy, EGLOutputPortEXT port)
1440
124
{
1441
125
    EGLAttrib kms_connector_id;
1442
126
    if (eglQueryOutputPortAttribEXT(dpy, port, EGL_DRM_CONNECTOR_EXT, &kms_connector_id) != EGL_TRUE)
1443
127
    {
1444
128
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to get EGLOutputPort → KMS connector ID mapping"));
1445
129
    }
1446
130
    return static_cast<uint32_t>(kms_connector_id);
1447
131
}
1448
132
1449
133
void refresh_connector(int drm_fd, mgk::DRMModeConnectorUPtr& connector)
1450
134
{
1451
135
    connector = mgk::get_connector(drm_fd, connector->connector_id);
1452
136
}
1453
137
}
1454
138
1455
139
mgek::EGLOutput::EGLOutput(
1456
140
    int drm_fd,
1457
141
    EGLDisplay dpy,
1458
142
    EGLOutputPortEXT connector)
1459
143
    : drm_fd{drm_fd},
1460
144
      display{dpy},
1461
145
      port{connector},
1462
146
      connector{mgk::get_connector(drm_fd, kms_id_from_port(dpy, port))}
1463
147
{
1464
148
1465
149
}
1466
150
1467
151
mgek::EGLOutput::~EGLOutput() noexcept(false)
1468
152
{
1469
153
    auto const uncaught_exception = std::uncaught_exception();
1470
154
    try
1471
155
    {
1472
156
        restore_saved_crtc();
1473
157
    }
1474
158
    catch(...)
1475
159
    {
1476
160
        if (!uncaught_exception)
1477
161
        {
1478
162
            throw;
1479
163
        }
1480
164
    }
1481
165
}
1482
166
1483
167
void mgek::EGLOutput::reset()
1484
168
{
1485
169
    /* Update the connector to ensure we have the latest information */
1486
170
    refresh_connector(drm_fd, connector);
1487
171
1488
172
    // TODO: What if we can't locate the DPMS property?
1489
173
    // TODO: Replace with mgk::ObjectProperties
1490
174
    for (int i = 0; i < connector->count_props; i++)
1491
175
    {
1492
176
        auto prop = drmModeGetProperty(drm_fd, connector->props[i]);
1493
177
        if (prop && (prop->flags & DRM_MODE_PROP_ENUM)) {
1494
178
            if (!strcmp(prop->name, "DPMS"))
1495
179
            {
1496
180
                dpms_enum_id = connector->props[i];
1497
181
                drmModeFreeProperty(prop);
1498
182
                break;
1499
183
            }
1500
184
            drmModeFreeProperty(prop);
1501
185
        }
1502
186
    }
1503
187
}
1504
188
1505
189
geom::Size mgek::EGLOutput::size() const
1506
190
{
1507
191
    drmModeModeInfo const& mode = connector->modes[mode_index];
1508
192
    return {mode.hdisplay, mode.vdisplay};
1509
193
}
1510
194
1511
195
int mgek::EGLOutput::max_refresh_rate() const
1512
196
{
1513
197
    // TODO: In future when DRM exposes FreeSync/Adaptive Sync/G-Sync info
1514
198
    //       this value may be calculated differently.
1515
199
    drmModeModeInfo const& current_mode = connector->modes[mode_index];
1516
200
    return current_mode.vrefresh;
1517
201
}
1518
202
1519
203
void mgek::EGLOutput::configure(size_t kms_mode_index)
1520
204
{
1521
205
    mode_index = kms_mode_index;
1522
206
    auto const width = connector->modes[kms_mode_index].hdisplay;
1523
207
    auto const height = connector->modes[kms_mode_index].vdisplay;
1524
208
1525
209
    std::unique_ptr<drmModeAtomicReq, void(*)(drmModeAtomicReqPtr)>
1526
210
        request{drmModeAtomicAlloc(), &drmModeAtomicFree};
1527
211
1528
212
    mgk::DRMModeCrtcUPtr crtc;
1529
213
    mgk::DRMModePlaneUPtr plane;
1530
214
1531
215
    std::tie(crtc, plane) = mgk::find_crtc_with_primary_plane(drm_fd, connector);
1532
216
    auto const crtc_id = crtc->crtc_id;
1533
217
1534
218
    uint32_t mode_id{0};
1535
219
    auto ret = drmModeCreatePropertyBlob(
1536
220
        drm_fd,
1537
221
        &connector->modes[kms_mode_index],
1538
222
        sizeof(connector->modes[kms_mode_index]),
1539
223
        &mode_id);
1540
224
1541
225
    if (ret != 0)
1542
226
    {
1543
227
        BOOST_THROW_EXCEPTION(
1544
228
            std::system_error(-ret, std::system_category(), "Failed to create DRM Mode property blob"));
1545
229
    }
1546
230
1547
231
    DumbFb dummy{drm_fd, width, height};
1548
232
1549
233
    mgk::ObjectProperties crtc_props{drm_fd, crtc_id, DRM_MODE_OBJECT_CRTC};
1550
234
1551
235
    /* Activate the CRTC and set the mode */
1552
236
    drmModeAtomicAddProperty(request.get(), crtc_id, crtc_props.id_for("MODE_ID"), mode_id);
1553
237
    drmModeAtomicAddProperty(request.get(), crtc_id, crtc_props.id_for("ACTIVE"), 1);
1554
238
1555
239
    /* Set CRTC for the output */
1556
240
    auto const connector_id = connector->connector_id;
1557
241
    mgk::ObjectProperties connector_props{drm_fd, connector_id, DRM_MODE_OBJECT_CONNECTOR};
1558
242
    drmModeAtomicAddProperty(request.get(), connector_id, connector_props.id_for("CRTC_ID"), crtc_id);
1559
243
1560
244
    /* Set up the output plane... */
1561
245
    auto const plane_id = plane->plane_id;
1562
246
    mgk::ObjectProperties plane_props{drm_fd, plane_id, DRM_MODE_OBJECT_PLANE};
1563
247
1564
248
    /* Source viewport. Coordinates are 16.16 fixed point format */
1565
249
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("SRC_X"), 0);
1566
250
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("SRC_Y"), 0);
1567
251
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("SRC_W"), width << 16);
1568
252
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("SRC_H"), height << 16);
1569
253
1570
254
    /* Destination viewport. Coordinates are *not* 16.16 */
1571
255
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_X"), 0);
1572
256
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_Y"), 0);
1573
257
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_W"), width);
1574
258
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_H"), height);
1575
259
1576
260
    /* Set a surface for the plane, and connect to the CRTC */
1577
261
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("FB_ID"), dummy.id());
1578
262
    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_ID"), crtc_id);
1579
263
1580
264
    /* We don't monitor the DRM events (yet), so have no userdata */
1581
265
    ret = drmModeAtomicCommit(drm_fd, request.get(), DRM_MODE_ATOMIC_ALLOW_MODESET, nullptr);
1582
266
1583
267
    if (ret != 0)
1584
268
    {
1585
269
        BOOST_THROW_EXCEPTION(
1586
270
            std::system_error(-ret, std::system_category(), "Failed to commit atomic KMS configuration change"));
1587
271
    }
1588
272
1589
273
    EGLAttrib const crtc_filter[] = {
1590
274
        EGL_DRM_PLANE_EXT, plane_id,
1591
275
        EGL_NONE};
1592
276
    int found_layers{0};
1593
277
    if (eglGetOutputLayersEXT(display, crtc_filter, &layer, 1, &found_layers) != EGL_TRUE)
1594
278
    {
1595
279
        BOOST_THROW_EXCEPTION((mg::egl_error("Failed to find EGLOutputEXT corresponding to DRM CRTC")));
1596
280
    }
1597
281
    if (found_layers != 1)
1598
282
    {
1599
283
        BOOST_THROW_EXCEPTION(std::runtime_error{"Failed to find EGLOutputEXT corresponding to DRM CRTC"});
1600
284
    }
1601
285
1602
286
    using_saved_crtc = false;
1603
287
}
1604
288
1605
289
EGLOutputLayerEXT mgek::EGLOutput::output_layer() const
1606
290
{
1607
291
    return layer;
1608
292
}
1609
293
1610
294
void mgek::EGLOutput::clear_crtc()
1611
295
{
1612
296
    using namespace std::string_literals;
1613
297
    mgk::DRMModeCrtcUPtr crtc;
1614
298
    try
1615
299
    {
1616
300
        crtc = mgk::find_crtc_for_connector(drm_fd, connector);
1617
301
    }
1618
302
    catch (std::runtime_error const&)
1619
303
    {
1620
304
        /*
1621
305
         * In order to actually clear the output, we need to have a crtc
1622
306
         * connected to the output/connector so that we can disconnect
1623
307
         * it. However, not being able to get a crtc is OK, since it means
1624
308
         * that the output cannot be displaying anything anyway.
1625
309
         */
1626
310
        return;
1627
311
    }
1628
312
    auto const crtc_id = crtc->crtc_id;
1629
313
1630
314
    auto result = drmModeSetCrtc(drm_fd, crtc_id,
1631
315
                                 0, 0, 0, nullptr, 0, nullptr);
1632
316
    if (result)
1633
317
    {
1634
318
        BOOST_THROW_EXCEPTION((
1635
319
            std::system_error{
1636
320
                -result,
1637
321
                std::system_category(),
1638
322
                "Couldn't clear output "s + mgk::connector_name(connector)}));
1639
323
    }
1640
324
}
1641
325
1642
326
void mgek::EGLOutput::restore_saved_crtc()
1643
327
{
1644
328
    if (!using_saved_crtc)
1645
329
    {
1646
330
        auto result = drmModeSetCrtc(
1647
331
            drm_fd,
1648
332
            saved_crtc.crtc_id,
1649
333
            saved_crtc.buffer_id,
1650
334
            saved_crtc.x, saved_crtc.y,
1651
335
            &connector->connector_id,
1652
336
            1,
1653
337
            &saved_crtc.mode);
1654
338
1655
339
        if (result != 0)
1656
340
        {
1657
341
            BOOST_THROW_EXCEPTION((std::system_error{-result, std::system_category(), "Failed to set CRTC"}));
1658
342
        }
1659
343
1660
344
        using_saved_crtc = true;
1661
345
    }
1662
346
}
1663
347
1664
348
void mgek::EGLOutput::set_power_mode(MirPowerMode mode)
1665
349
{
1666
350
    auto ret = drmModeConnectorSetProperty(
1667
351
        drm_fd,
1668
352
        connector->connector_id,
1669
353
        dpms_enum_id,
1670
354
        mode);
1671
355
    if (ret)
1672
356
    {
1673
357
        BOOST_THROW_EXCEPTION((std::system_error{-ret, std::system_category(), "Failed to set output power mode"}));
1674
358
    }
1675
359
}
1676
0
360
1677
=== added file 'src/platforms/eglstream-kms/server/egl_output.h'
1678
--- src/platforms/eglstream-kms/server/egl_output.h	1970-01-01 00:00:00 +0000
1679
+++ src/platforms/eglstream-kms/server/egl_output.h	2016-06-08 13:28:19 +0000
1680
@@ -0,0 +1,79 @@
1681
1
/*
1682
2
 * Copyright © 2016 Canonical Ltd.
1683
3
 *
1684
4
 * This program is free software: you can redistribute it and/or modify it
1685
5
 * under the terms of the GNU Lesser General Public License version 3,
1686
6
 * as published by the Free Software Foundation.
1687
7
 *
1688
8
 * This program is distributed in the hope that it will be useful,
1689
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1690
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1691
11
 * GNU Lesser General Public License for more details.
1692
12
 *
1693
13
 * You should have received a copy of the GNU Lesser General Public License
1694
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1695
15
 *
1696
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
1697
17
 */
1698
18
1699
19
#ifndef MIR_GRAPHICS_EGLSTREAM_KMS_OUTPUT_H_
1700
20
#define MIR_GRAPHICS_EGLSTREAM_KMS_OUTPUT_H_
1701
21
1702
22
#include "kms-utils/drm_mode_resources.h"
1703
23
#include "mir/geometry/size.h"
1704
24
#include "mir/geometry/point.h"
1705
25
#include "mir/geometry/displacement.h"
1706
26
#include "mir/graphics/display_configuration.h"
1707
27
#include "mir_toolkit/common.h"
1708
28
1709
29
#include <epoxy/egl.h>
1710
30
1711
31
namespace mir
1712
32
{
1713
33
namespace graphics
1714
34
{
1715
35
namespace eglstream
1716
36
{
1717
37
1718
38
namespace kms
1719
39
{
1720
40
class EGLOutput : public DisplayConfigurationOutput
1721
41
{
1722
42
public:
1723
43
    EGLOutput(int drm_fd, EGLDisplay dpy, EGLOutputPortEXT connector);
1724
44
    ~EGLOutput() noexcept(false);
1725
45
1726
46
    void reset();
1727
47
    void configure(size_t kms_mode_index);
1728
48
    geometry::Size size() const;
1729
49
    int max_refresh_rate() const;
1730
50
1731
51
    EGLOutputLayerEXT output_layer() const;
1732
52
    void clear_crtc();
1733
53
1734
54
    void set_power_mode(MirPowerMode mode);
1735
55
1736
56
private:
1737
57
    void restore_saved_crtc();
1738
58
1739
59
    int const drm_fd;
1740
60
1741
61
    EGLDisplay display;
1742
62
    EGLOutputPortEXT port;
1743
63
    EGLOutputLayerEXT layer;
1744
64
1745
65
    graphics::kms::DRMModeConnectorUPtr connector;
1746
66
1747
67
    size_t mode_index;
1748
68
    drmModeCrtc saved_crtc;
1749
69
    bool using_saved_crtc;
1750
70
1751
71
    int dpms_enum_id;
1752
72
};
1753
73
1754
74
}
1755
75
}
1756
76
}
1757
77
}
1758
78
1759
79
#endif /* MIR_GRAPHICS_EGLSTREAM_KMS_KMS_OUTPUT_H_ */
1760
0
80
1761
=== added file 'src/platforms/eglstream-kms/server/kms_display_configuration.cpp'
1762
--- src/platforms/eglstream-kms/server/kms_display_configuration.cpp	1970-01-01 00:00:00 +0000
1763
+++ src/platforms/eglstream-kms/server/kms_display_configuration.cpp	2016-06-08 13:28:19 +0000
1764
@@ -0,0 +1,331 @@
1765
1
/*
1766
2
 * Copyright © 2016 Canonical Ltd.
1767
3
 *
1768
4
 * This program is free software: you can redistribute it and/or modify it
1769
5
 * under the terms of the GNU Lesser General Public License version 3,
1770
6
 * as published by the Free Software Foundation.
1771
7
 *
1772
8
 * This program is distributed in the hope that it will be useful,
1773
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1774
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1775
11
 * GNU Lesser General Public License for more details.
1776
12
 *
1777
13
 * You should have received a copy of the GNU Lesser General Public License
1778
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
1779
15
 *
1780
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
1781
17
 */
1782
18
1783
19
#include <epoxy/egl.h>
1784
20
1785
21
#include "kms_display_configuration.h"
1786
22
#include "kms-utils/drm_mode_resources.h"
1787
23
#include "mir/graphics/pixel_format_utils.h"
1788
24
#include "mir/graphics/egl_error.h"
1789
25
1790
26
#include <cmath>
1791
27
#include <limits>
1792
28
1793
29
#include <boost/throw_exception.hpp>
1794
30
#include <stdexcept>
1795
31
#include <algorithm>
1796
32
1797
33
namespace mg = mir::graphics;
1798
34
namespace mge = mir::graphics::eglstream;
1799
35
namespace mgk = mir::graphics::kms;
1800
36
1801
37
namespace geom = mir::geometry;
1802
38
1803
39
namespace
1804
40
{
1805
41
1806
42
bool kms_modes_are_equal(drmModeModeInfo const& info1, drmModeModeInfo const& info2)
1807
43
{
1808
44
    return (info1.clock == info2.clock &&
1809
45
            info1.hdisplay == info2.hdisplay &&
1810
46
            info1.hsync_start == info2.hsync_start &&
1811
47
            info1.hsync_end == info2.hsync_end &&
1812
48
            info1.htotal == info2.htotal &&
1813
49
            info1.hskew == info2.hskew &&
1814
50
            info1.vdisplay == info2.vdisplay &&
1815
51
            info1.vsync_start == info2.vsync_start &&
1816
52
            info1.vsync_end == info2.vsync_end &&
1817
53
            info1.vtotal == info2.vtotal);
1818
54
}
1819
55
1820
56
double calculate_vrefresh_hz(drmModeModeInfo const& mode)
1821
57
{
1822
58
    if (mode.htotal == 0 || mode.vtotal == 0)
1823
59
        return 0.0;
1824
60
1825
61
    /* mode.clock is in KHz */
1826
62
    double hz = (mode.clock * 100000LL /
1827
63
                 ((long)mode.htotal * (long)mode.vtotal)
1828
64
                ) / 100.0;
1829
65
1830
66
    // Actually we don't need floating point at all for this...
1831
67
    // TODO: Consider converting our structs to fixed-point ints
1832
68
    return hz;
1833
69
}
1834
70
1835
71
mg::DisplayConfigurationOutputType
1836
72
kms_connector_type_to_output_type(uint32_t connector_type)
1837
73
{
1838
74
    return static_cast<mg::DisplayConfigurationOutputType>(connector_type);
1839
75
}
1840
76
1841
77
std::vector<std::shared_ptr<mge::kms::EGLOutput>> create_outputs(int drm_fd, EGLDisplay display)
1842
78
{
1843
79
    mgk::DRMModeResources resources{drm_fd};
1844
80
1845
81
    std::vector<std::shared_ptr<mge::kms::EGLOutput>> outputs;
1846
82
1847
83
    for (auto const& connector : resources.connectors())
1848
84
    {
1849
85
        EGLOutputPortEXT port;
1850
86
        int num_ports;
1851
87
        EGLAttrib const select_connector[] = {
1852
88
            EGL_DRM_CONNECTOR_EXT, connector->connector_id,
1853
89
            EGL_NONE
1854
90
        };
1855
91
        if (eglGetOutputPortsEXT(display, select_connector, &port, 1, &num_ports) != EGL_TRUE)
1856
92
        {
1857
93
            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to find EGLOutputPort corresponding to DRM connector"));
1858
94
        }
1859
95
        if (num_ports != 1)
1860
96
        {
1861
97
            BOOST_THROW_EXCEPTION(std::runtime_error("Failed to find EGLOutputPort corresponding to DRM connector"));
1862
98
        }
1863
99
        outputs.push_back(std::make_shared<mge::kms::EGLOutput>(drm_fd, display, port));
1864
100
        auto& output = outputs.back();
1865
101
1866
102
        // TODO: This should all be owned by mgek::EGLOutput
1867
103
1868
104
        output->id = mg::DisplayConfigurationOutputId{static_cast<int>(connector->connector_id)};
1869
105
        output->card_id = mg::DisplayConfigurationCardId{0};
1870
106
        output->type = kms_connector_type_to_output_type(connector->connector_type);
1871
107
        output->physical_size_mm = geom::Size{connector->mmWidth, connector->mmHeight};
1872
108
        output->connected = connector->connection == DRM_MODE_CONNECTED;
1873
109
        output->pixel_formats = {
1874
110
            mir_pixel_format_argb_8888,
1875
111
            mir_pixel_format_xrgb_8888
1876
112
        };
1877
113
1878
114
        uint32_t const invalid_mode_index = std::numeric_limits<uint32_t>::max();
1879
115
        output->current_mode_index = invalid_mode_index;
1880
116
        output->preferred_mode_index = invalid_mode_index;
1881
117
1882
118
        /* Get information about the current mode */
1883
119
        mgk::DRMModeCrtcUPtr current_crtc;
1884
120
        if (connector->encoder_id)
1885
121
        {
1886
122
            auto encoder = mgk::get_encoder(drm_fd, connector->encoder_id);
1887
123
            if (encoder->crtc_id)
1888
124
            {
1889
125
                current_crtc = mgk::get_crtc(drm_fd, encoder->crtc_id);
1890
126
            }
1891
127
        }
1892
128
1893
129
         /* Add all the available modes and find the current and preferred one */
1894
130
         for (int m = 0; m < connector->count_modes; m++)
1895
131
         {
1896
132
             drmModeModeInfo &mode_info = connector->modes[m];
1897
133
1898
134
             geom::Size size{mode_info.hdisplay, mode_info.vdisplay};
1899
135
1900
136
             double vrefresh_hz = calculate_vrefresh_hz(mode_info);
1901
137
1902
138
             output->modes.push_back({size, vrefresh_hz});
1903
139
1904
140
             if (current_crtc && kms_modes_are_equal(mode_info, current_crtc->mode))
1905
141
                 output->current_mode_index = m;
1906
142
1907
143
             if ((mode_info.type & DRM_MODE_TYPE_PREFERRED) == DRM_MODE_TYPE_PREFERRED)
1908
144
                 output->preferred_mode_index = m;
1909
145
         }
1910
146
1911
147
1912
148
        output->current_format = mir_pixel_format_xrgb_8888;
1913
149
        output->power_mode = mir_power_mode_on;
1914
150
        output->orientation = mir_orientation_normal;
1915
151
        output->scale = 1.0f;
1916
152
        output->form_factor = mir_form_factor_monitor;
1917
153
        output->used = false;
1918
154
    }
1919
155
1920
156
    return outputs;
1921
157
}
1922
158
1923
159
mg::DisplayConfigurationCard create_card(int drm_fd)
1924
160
{
1925
161
    mgk::DRMModeResources resources{drm_fd};
1926
162
1927
163
    size_t max_outputs = std::min(resources.num_crtcs(), resources.num_connectors());
1928
164
    return {mg::DisplayConfigurationCardId{0}, max_outputs};
1929
165
}
1930
166
1931
167
}
1932
168
1933
169
mge::KMSDisplayConfiguration::KMSDisplayConfiguration(int drm_fd, EGLDisplay dpy)
1934
170
    : drm_fd{drm_fd},
1935
171
      card{create_card(drm_fd)},
1936
172
      outputs{create_outputs(drm_fd, dpy)}
1937
173
{
1938
174
    update();
1939
175
}
1940
176
1941
177
mge::KMSDisplayConfiguration::KMSDisplayConfiguration(
1942
178
    KMSDisplayConfiguration const& conf)
1943
179
    : mg::DisplayConfiguration(),
1944
180
      drm_fd{conf.drm_fd},
1945
181
      card(conf.card),
1946
182
      outputs{conf.outputs}
1947
183
{
1948
184
}
1949
185
1950
186
void mge::KMSDisplayConfiguration::for_each_card(
1951
187
    std::function<void(DisplayConfigurationCard const&)> f) const
1952
188
{
1953
189
    f(card);
1954
190
}
1955
191
1956
192
void mge::KMSDisplayConfiguration::for_each_output(
1957
193
    std::function<void(DisplayConfigurationOutput const&)> f) const
1958
194
{
1959
195
    for (auto const& output : outputs)
1960
196
        f(*output);
1961
197
}
1962
198
1963
199
void mge::KMSDisplayConfiguration::for_each_output(
1964
200
    std::function<void(UserDisplayConfigurationOutput&)> f)
1965
201
{
1966
202
    for (auto& output : outputs)
1967
203
    {
1968
204
        UserDisplayConfigurationOutput user(*output);
1969
205
        f(user);
1970
206
    }
1971
207
}
1972
208
1973
209
std::unique_ptr<mg::DisplayConfiguration> mge::KMSDisplayConfiguration::clone() const
1974
210
{
1975
211
    return std::make_unique<KMSDisplayConfiguration>(*this);
1976
212
}
1977
213
1978
214
uint32_t mge::KMSDisplayConfiguration::get_kms_connector_id(
1979
215
    DisplayConfigurationOutputId id) const
1980
216
{
1981
217
    auto iter = find_output_with_id(id);
1982
218
1983
219
    if (iter == outputs.end())
1984
220
    {
1985
221
        BOOST_THROW_EXCEPTION(
1986
222
            std::out_of_range("Failed to find DisplayConfigurationOutput with provided id"));
1987
223
    }
1988
224
1989
225
    return id.as_value();
1990
226
}
1991
227
1992
228
size_t mge::KMSDisplayConfiguration::get_kms_mode_index(
1993
229
    DisplayConfigurationOutputId id,
1994
230
    size_t conf_mode_index) const
1995
231
{
1996
232
    auto iter = find_output_with_id(id);
1997
233
1998
234
    if (iter == outputs.end() || conf_mode_index >= (*iter)->modes.size())
1999
235
    {
2000
236
        BOOST_THROW_EXCEPTION(
2001
237
            std::out_of_range("Failed to find valid mode index for DisplayConfigurationOutput with provided id/mode_index"));
2002
238
    }
2003
239
2004
240
    return conf_mode_index;
2005
241
}
2006
242
void mge::KMSDisplayConfiguration::update()
2007
243
{
2008
244
    mgk::DRMModeResources resources{drm_fd};
2009
245
2010
246
    for (auto const& connector : resources.connectors())
2011
247
    {
2012
248
        update_output(resources, connector, **find_output_with_id(DisplayConfigurationOutputId(connector->connector_id)));
2013
249
    };
2014
250
}
2015
251
2016
252
void mge::KMSDisplayConfiguration::for_each_output(
2017
253
    std::function<void(kms::EGLOutput const&)> const& f) const
2018
254
{
2019
255
    for (auto const& output : outputs)
2020
256
    {
2021
257
        f(*output);
2022
258
    }
2023
259
}
2024
260
2025
261
void mge::KMSDisplayConfiguration::update_output(
2026
262
    mgk::DRMModeResources const& resources,
2027
263
    mgk::DRMModeConnectorUPtr const& connector,
2028
264
    kms::EGLOutput& output)
2029
265
{
2030
266
    output.physical_size_mm = geom::Size{connector->mmWidth, connector->mmHeight};
2031
267
    output.connected = connector->connection == DRM_MODE_CONNECTED;
2032
268
2033
269
    uint32_t const invalid_mode_index = std::numeric_limits<uint32_t>::max();
2034
270
2035
271
    output.modes.clear();
2036
272
    output.current_mode_index = invalid_mode_index;
2037
273
2038
274
    drmModeModeInfo* current_mode_info{nullptr};
2039
275
    mgk::DRMModeCrtcUPtr current_crtc;
2040
276
    if (connector->encoder_id)
2041
277
    {
2042
278
        auto encoder = resources.encoder(connector->encoder_id);
2043
279
        if (encoder->crtc_id)
2044
280
        {
2045
281
            current_crtc = resources.crtc(encoder->crtc_id);
2046
282
            current_mode_info = &current_crtc->mode;
2047
283
        }
2048
284
    }
2049
285
2050
286
    /* Add all the available modes and find the current and preferred one */
2051
287
    for (int m = 0; m < connector->count_modes; m++)
2052
288
    {
2053
289
        drmModeModeInfo& mode_info = connector->modes[m];
2054
290
2055
291
        geom::Size size{mode_info.hdisplay, mode_info.vdisplay};
2056
292
2057
293
        double vrefresh_hz = calculate_vrefresh_hz(mode_info);
2058
294
2059
295
        output.modes.push_back({size, vrefresh_hz});
2060
296
2061
297
        if (current_mode_info && kms_modes_are_equal(mode_info, *current_mode_info))
2062
298
            output.current_mode_index = m;
2063
299
2064
300
        if ((mode_info.type & DRM_MODE_TYPE_PREFERRED) == DRM_MODE_TYPE_PREFERRED)
2065
301
            output.preferred_mode_index = m;
2066
302
    }
2067
303
2068
304
    if (output.modes.empty())
2069
305
    {
2070
306
        output.preferred_mode_index = invalid_mode_index;
2071
307
    }
2072
308
    output.physical_size_mm = geom::Size{connector->mmWidth, connector->mmHeight};
2073
309
}
2074
310
2075
311
std::vector<std::shared_ptr<mge::kms::EGLOutput>>::iterator
2076
312
mge::KMSDisplayConfiguration::find_output_with_id(mg::DisplayConfigurationOutputId id)
2077
313
{
2078
314
    return std::find_if(
2079
315
        outputs.begin(), outputs.end(),
2080
316
        [id](std::shared_ptr<DisplayConfigurationOutput> const& output)
2081
317
        {
2082
318
            return output->id == id;
2083
319
        });
2084
320
}
2085
321
2086
322
std::vector<std::shared_ptr<mge::kms::EGLOutput>>::const_iterator
2087
323
mge::KMSDisplayConfiguration::find_output_with_id(mg::DisplayConfigurationOutputId id) const
2088
324
{
2089
325
    return std::find_if(
2090
326
        outputs.begin(), outputs.end(),
2091
327
        [id](std::shared_ptr<DisplayConfigurationOutput> const& output)
2092
328
        {
2093
329
            return output->id == id;
2094
330
        });
2095
331
}
2096
0
332
2097
=== added file 'src/platforms/eglstream-kms/server/kms_display_configuration.h'
2098
--- src/platforms/eglstream-kms/server/kms_display_configuration.h	1970-01-01 00:00:00 +0000
2099
+++ src/platforms/eglstream-kms/server/kms_display_configuration.h	2016-06-08 13:28:19 +0000
2100
@@ -0,0 +1,70 @@
2101
1
/*
2102
2
 * Copyright © 2016 Canonical Ltd.
2103
3
 *
2104
4
 * This program is free software: you can redistribute it and/or modify it
2105
5
 * under the terms of the GNU Lesser General Public License version 3,
2106
6
 * as published by the Free Software Foundation.
2107
7
 *
2108
8
 * This program is distributed in the hope that it will be useful,
2109
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2110
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2111
11
 * GNU Lesser General Public License for more details.
2112
12
 *
2113
13
 * You should have received a copy of the GNU Lesser General Public License
2114
14
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
2115
15
 *
2116
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2117
17
 */
2118
18
2119
19
#ifndef MIR_PLATFORMS_EGLSTREAM_KMS_KMS_DISPLAY_CONFIGURATION_H_
2120
20
#define MIR_PLATFORMS_EGLSTREAM_KMS_KMS_DISPLAY_CONFIGURATION_H_
2121
21
2122
22
#include "egl_output.h"
2123
23
2124
24
#include "mir/graphics/display_configuration.h"
2125
25
2126
26
2127
27
#include <xf86drmMode.h>
2128
28
2129
29
namespace mir
2130
30
{
2131
31
namespace graphics
2132
32
{
2133
33
namespace eglstream
2134
34
{
2135
35
2136
36
class KMSDisplayConfiguration : public DisplayConfiguration
2137
37
{
2138
38
public:
2139
39
    KMSDisplayConfiguration(int drm_fd, EGLDisplay dpy);
2140
40
    KMSDisplayConfiguration(KMSDisplayConfiguration const& conf);
2141
41
2142
42
    void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const override;
2143
43
    void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const override;
2144
44
    void for_each_output(std::function<void(UserDisplayConfigurationOutput&)> f) override;
2145
45
    std::unique_ptr<DisplayConfiguration> clone() const override;
2146
46
2147
47
    uint32_t get_kms_connector_id(DisplayConfigurationOutputId id) const;
2148
48
    size_t get_kms_mode_index(DisplayConfigurationOutputId id, size_t conf_mode_index) const;
2149
49
    void update();
2150
50
2151
51
    void for_each_output(std::function<void(kms::EGLOutput const&)> const& f) const;
2152
52
2153
53
private:
2154
54
    void update_output(
2155
55
        graphics::kms::DRMModeResources const& resources,
2156
56
        graphics::kms::DRMModeConnectorUPtr const& connector,
2157
57
        kms::EGLOutput& output);
2158
58
    std::vector<std::shared_ptr<kms::EGLOutput>>::iterator find_output_with_id(DisplayConfigurationOutputId id);
2159
59
    std::vector<std::shared_ptr<kms::EGLOutput>>::const_iterator find_output_with_id(DisplayConfigurationOutputId id) const;
2160
60
2161
61
    int drm_fd;
2162
62
    DisplayConfigurationCard const card;
2163
63
    std::vector<std::shared_ptr<kms::EGLOutput>> outputs;
2164
64
};
2165
65
2166
66
}
2167
67
}
2168
68
}
2169
69
2170
70
#endif // MIR_PLATFORMS_EGLSTREAM_KMS_KMS_DISPLAY_CONFIGURATION_H_
2171
0
71
2172
=== added file 'src/platforms/eglstream-kms/server/platform.cpp'
2173
--- src/platforms/eglstream-kms/server/platform.cpp	1970-01-01 00:00:00 +0000
2174
+++ src/platforms/eglstream-kms/server/platform.cpp	2016-06-08 13:28:19 +0000
2175
@@ -0,0 +1,162 @@
2176
1
/*
2177
2
 * Copyright © 2016 Canonical Ltd.
2178
3
 *
2179
4
 * This program is free software: you can redistribute it and/or modify it
2180
5
 * under the terms of the GNU Lesser General Public License version 3,
2181
6
 * as published by the Free Software Foundation.
2182
7
 *
2183
8
 * This program is distributed in the hope that it will be useful,
2184
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2185
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2186
11
 * GNU Lesser General Public License for more details.
2187
12
 *
2188
13
 * You should have received a copy of the GNU Lesser General Public License
2189
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2190
15
 *
2191
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2192
17
 */
2193
18
2194
19
#include <epoxy/egl.h>
2195
20
2196
21
#include "platform.h"
2197
22
#include "buffer_allocator.h"
2198
23
#include "display.h"
2199
24
#include "mir/graphics/platform_ipc_operations.h"
2200
25
#include "mir/graphics/platform_ipc_package.h"
2201
26
#include "mir/graphics/platform_operation_message.h"
2202
27
#include "mir/graphics/buffer_ipc_message.h"
2203
28
2204
29
#include "mir/graphics/egl_error.h"
2205
30
2206
31
#include <boost/throw_exception.hpp>
2207
32
#include <xf86drm.h>
2208
33
#include <fcntl.h>
2209
34
2210
35
namespace mg = mir::graphics;
2211
36
namespace mge = mir::graphics::eglstream;
2212
37
2213
38
namespace
2214
39
{
2215
40
// Our copy of eglext.h doesn't have this?
2216
41
int const EGL_DRM_MASTER_FD_EXT{0x333C};
2217
42
2218
43
char const* drm_node_for_device(EGLDeviceEXT device)
2219
44
{
2220
45
    auto const device_path = eglQueryDeviceStringEXT(device, EGL_DRM_DEVICE_FILE_EXT);
2221
46
    if (!device_path)
2222
47
    {
2223
48
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to determine DRM device node path from EGLDevice"));
2224
49
    }
2225
50
    return device_path;
2226
51
}
2227
52
}
2228
53
2229
54
mge::Platform::Platform(
2230
55
    EGLDeviceEXT device,
2231
56
    std::shared_ptr<EmergencyCleanupRegistry> const& /*emergency_cleanup_registry*/,
2232
57
    std::shared_ptr<DisplayReport> const& /*report*/)
2233
58
    : device{device},
2234
59
      display{EGL_NO_DISPLAY},
2235
60
      drm_node{open(drm_node_for_device(device), O_RDWR | O_CLOEXEC)}
2236
61
{
2237
62
    using namespace std::literals;
2238
63
2239
64
    if (drm_node == mir::Fd::invalid)
2240
65
    {
2241
66
        BOOST_THROW_EXCEPTION(std::system_error(
2242
67
            errno,
2243
68
            std::system_category(),
2244
69
            "Failed to open DRM device "s + drm_node_for_device(device)));
2245
70
    }
2246
71
2247
72
    if (drmSetMaster(drm_node))
2248
73
    {
2249
74
        BOOST_THROW_EXCEPTION((std::system_error{errno, std::system_category(), "Failed to acquire DRM master"}));
2250
75
    }
2251
76
2252
77
    int const drm_node_attrib[] = {
2253
78
        EGL_DRM_MASTER_FD_EXT, static_cast<int>(drm_node), EGL_NONE
2254
79
    };
2255
80
    display = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, device, drm_node_attrib);
2256
81
2257
82
    if (display == EGL_NO_DISPLAY)
2258
83
    {
2259
84
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGLDisplay on the EGLDeviceEXT"));
2260
85
    }
2261
86
2262
87
    EGLint major{1};
2263
88
    EGLint minor{4};
2264
89
    if (eglInitialize(display, &major, &minor) != EGL_TRUE)
2265
90
    {
2266
91
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to initialise EGL"));
2267
92
    }
2268
93
    if (major != 1 || minor != 4)
2269
94
    {
2270
95
        BOOST_THROW_EXCEPTION((std::runtime_error{
2271
96
            "Incompatible EGL version"s +
2272
97
            "Wanted 1.4, got " + std::to_string(major) + "." + std::to_string(minor)}));
2273
98
    }
2274
99
}
2275
100
2276
101
mir::UniqueModulePtr<mg::GraphicBufferAllocator> mge::Platform::create_buffer_allocator()
2277
102
{
2278
103
    return mir::make_module_ptr<mge::BufferAllocator>();
2279
104
}
2280
105
2281
106
mir::UniqueModulePtr<mg::Display> mge::Platform::create_display(
2282
107
    std::shared_ptr<DisplayConfigurationPolicy> const& configuration_policy,
2283
108
    std::shared_ptr<GLConfig> const& gl_config)
2284
109
{
2285
110
    return mir::make_module_ptr<mge::Display>(drm_node, display, configuration_policy, *gl_config);
2286
111
}
2287
112
2288
113
mir::UniqueModulePtr<mg::PlatformIpcOperations> mge::Platform::make_ipc_operations() const
2289
114
{
2290
115
    class NoIPCOperations : public mg::PlatformIpcOperations
2291
116
    {
2292
117
2293
118
    public:
2294
119
        void pack_buffer(BufferIpcMessage& packer, Buffer const& buffer, BufferIpcMsgType msg_type) const override
2295
120
        {
2296
121
            if (msg_type == mg::BufferIpcMsgType::full_msg)
2297
122
            {
2298
123
                auto native_handle = buffer.native_buffer_handle();
2299
124
                for(auto i=0; i<native_handle->data_items; i++)
2300
125
                {
2301
126
                    packer.pack_data(native_handle->data[i]);
2302
127
                }
2303
128
                for(auto i=0; i<native_handle->fd_items; i++)
2304
129
                {
2305
130
                    packer.pack_fd(mir::Fd(IntOwnedFd{native_handle->fd[i]}));
2306
131
                }
2307
132
2308
133
                packer.pack_stride(buffer.stride());
2309
134
                packer.pack_flags(native_handle->flags);
2310
135
                packer.pack_size(buffer.size());
2311
136
            }
2312
137
        }
2313
138
2314
139
        void unpack_buffer(BufferIpcMessage& /*message*/, Buffer const& /*buffer*/) const override
2315
140
        {
2316
141
2317
142
        }
2318
143
2319
144
        std::shared_ptr<mg::PlatformIPCPackage> connection_ipc_package() override
2320
145
        {
2321
146
            return std::make_shared<mg::PlatformIPCPackage>(describe_graphics_module());
2322
147
        }
2323
148
2324
149
        PlatformOperationMessage platform_operation(unsigned int const /*opcode*/,
2325
150
            PlatformOperationMessage const& /*message*/) override
2326
151
        {
2327
152
            BOOST_THROW_EXCEPTION(std::runtime_error{"No platform operations implemented"});
2328
153
        }
2329
154
    };
2330
155
2331
156
    return mir::make_module_ptr<NoIPCOperations>();
2332
157
}
2333
158
2334
159
EGLNativeDisplayType mge::Platform::egl_native_display() const
2335
160
{
2336
161
    return display;
2337
162
}
2338
0
163
2339
=== added file 'src/platforms/eglstream-kms/server/platform.h'
2340
--- src/platforms/eglstream-kms/server/platform.h	1970-01-01 00:00:00 +0000
2341
+++ src/platforms/eglstream-kms/server/platform.h	2016-06-08 13:28:19 +0000
2342
@@ -0,0 +1,66 @@
2343
1
/*
2344
2
 * Copyright © 2016 Canonical Ltd.
2345
3
 *
2346
4
 * This program is free software: you can redistribute it and/or modify it
2347
5
 * under the terms of the GNU Lesser General Public License version 3,
2348
6
 * as published by the Free Software Foundation.
2349
7
 *
2350
8
 * This program is distributed in the hope that it will be useful,
2351
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2352
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2353
11
 * GNU Lesser General Public License for more details.
2354
12
 *
2355
13
 * You should have received a copy of the GNU Lesser General Public License
2356
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2357
15
 *
2358
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2359
17
 */
2360
18
2361
19
#ifndef MIR_PLATFORMS_EGLSTREAM_KMS_PLATFORM_H_
2362
20
#define MIR_PLATFORMS_EGLSTREAM_KMS_PLATFORM_H_
2363
21
2364
22
#include "mir/graphics/platform.h"
2365
23
#include "mir/options/option.h"
2366
24
#include "mir/graphics/graphic_buffer_allocator.h"
2367
25
#include "mir/graphics/display.h"
2368
26
#include "mir/graphics/platform_ipc_operations.h"
2369
27
#include "mir/fd.h"
2370
28
2371
29
#include <EGL/egl.h>
2372
30
#include <EGL/eglext.h>
2373
31
2374
32
namespace mir
2375
33
{
2376
34
namespace graphics
2377
35
{
2378
36
namespace eglstream
2379
37
{
2380
38
class Platform : public mir::graphics::Platform
2381
39
{
2382
40
public:
2383
41
    Platform(
2384
42
        EGLDeviceEXT device,
2385
43
        std::shared_ptr<EmergencyCleanupRegistry> const& /*emergency_cleanup_registry*/,
2386
44
        std::shared_ptr<DisplayReport> const& /*report*/);
2387
45
    ~Platform() = default;
2388
46
2389
47
    UniqueModulePtr<GraphicBufferAllocator> create_buffer_allocator() override;
2390
48
2391
49
    UniqueModulePtr<Display> create_display(
2392
50
        std::shared_ptr<DisplayConfigurationPolicy> const& /*initial_conf_policy*/,
2393
51
        std::shared_ptr<GLConfig> const& /*gl_config*/) override;
2394
52
2395
53
    UniqueModulePtr<PlatformIpcOperations> make_ipc_operations() const override;
2396
54
2397
55
    EGLNativeDisplayType egl_native_display() const override;
2398
56
2399
57
private:
2400
58
    EGLDeviceEXT device;
2401
59
    EGLDisplay display;
2402
60
    mir::Fd const drm_node;
2403
61
};
2404
62
}
2405
63
}
2406
64
}
2407
65
2408
66
#endif // MIR_PLATFORMS_EGLSTREAM_KMS_PLATFORM_H_
2409
0
67
2410
=== added file 'src/platforms/eglstream-kms/server/platform_symbols.cpp'
2411
--- src/platforms/eglstream-kms/server/platform_symbols.cpp	1970-01-01 00:00:00 +0000
2412
+++ src/platforms/eglstream-kms/server/platform_symbols.cpp	2016-06-08 13:28:19 +0000
2413
@@ -0,0 +1,189 @@
2414
1
/*
2415
2
 * Copyright © 2016 Canonical Ltd.
2416
3
 *
2417
4
 * This program is free software: you can redistribute it and/or modify it
2418
5
 * under the terms of the GNU Lesser General Public License version 3,
2419
6
 * as published by the Free Software Foundation.
2420
7
 *
2421
8
 * This program is distributed in the hope that it will be useful,
2422
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2423
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2424
11
 * GNU Lesser General Public License for more details.
2425
12
 *
2426
13
 * You should have received a copy of the GNU Lesser General Public License
2427
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2428
15
 *
2429
16
 * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2430
17
 */
2431
18
2432
19
#include <epoxy/egl.h>
2433
20
2434
21
#include "platform.h"
2435
22
#include "mir/graphics/platform.h"
2436
23
#include "mir/options/option.h"
2437
24
#include "mir/module_deleter.h"
2438
25
#include "mir/assert_module_entry_point.h"
2439
26
#include "mir/libname.h"
2440
27
#include "mir/log.h"
2441
28
#include "mir/graphics/egl_error.h"
2442
29
2443
30
#include <boost/throw_exception.hpp>
2444
31
#include <boost/exception/diagnostic_information.hpp>
2445
32
#include <xf86drm.h>
2446
33
#include <sstream>
2447
34
2448
35
#include <fcntl.h>
2449
36
2450
37
namespace mg = mir::graphics;
2451
38
namespace mo = mir::options;
2452
39
namespace mge = mir::graphics::eglstream;
2453
40
2454
41
mir::UniqueModulePtr<mg::Platform> create_host_platform(
2455
42
    std::shared_ptr<mo::Option> const& /*options*/,
2456
43
    std::shared_ptr<mir::EmergencyCleanupRegistry> const& emergency_cleanup_registry,
2457
44
    std::shared_ptr<mg::DisplayReport> const& report)
2458
45
{
2459
46
    mir::assert_entry_point_signature<mg::CreateHostPlatform>(&create_host_platform);
2460
47
2461
48
    int device_count{0};
2462
49
    if (eglQueryDevicesEXT(0, nullptr, &device_count) != EGL_TRUE)
2463
50
    {
2464
51
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to query device count with eglQueryDevicesEXT"));
2465
52
    }
2466
53
2467
54
    auto devices = std::make_unique<EGLDeviceEXT[]>(device_count);
2468
55
    if (eglQueryDevicesEXT(device_count, devices.get(), &device_count) != EGL_TRUE)
2469
56
    {
2470
57
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to get device list with eglQueryDevicesEXT"));
2471
58
    }
2472
59
2473
60
    auto device = std::find_if(devices.get(), devices.get() + device_count,
2474
61
        [](EGLDeviceEXT device)
2475
62
        {
2476
63
            auto device_extensions = eglQueryDeviceStringEXT(device, EGL_EXTENSIONS);
2477
64
            if (device_extensions)
2478
65
            {
2479
66
                return strstr(device_extensions, "EGL_EXT_device_drm") != NULL;
2480
67
            }
2481
68
            return false;
2482
69
        });
2483
70
2484
71
    if (device == (devices.get() + device_count))
2485
72
    {
2486
73
        BOOST_THROW_EXCEPTION(std::runtime_error("Couldn't find EGLDeviceEXT supporting EGL_EXT_device_drm?"));
2487
74
    }
2488
75
2489
76
    return mir::make_module_ptr<mge::Platform>(*device, emergency_cleanup_registry, report);
2490
77
}
2491
78
2492
79
void add_graphics_platform_options(boost::program_options::options_description& /*config*/)
2493
80
{
2494
81
    mir::assert_entry_point_signature<mg::AddPlatformOptions>(&add_graphics_platform_options);
2495
82
}
2496
83
2497
84
mg::PlatformPriority probe_graphics_platform(mo::ProgramOption const& /*options*/)
2498
85
{
2499
86
    mir::assert_entry_point_signature<mg::PlatformProbe>(&probe_graphics_platform);
2500
87
2501
88
    std::vector<char const*> missing_extensions;
2502
89
    for (char const* extension : {
2503
90
        "EGL_EXT_platform_base",
2504
91
        "EGL_EXT_platform_device",
2505
92
        "EGL_EXT_device_base",})
2506
93
    {
2507
94
        if (!epoxy_has_egl_extension(EGL_NO_DISPLAY, extension))
2508
95
        {
2509
96
            missing_extensions.push_back(extension);
2510
97
        }
2511
98
    }
2512
99
2513
100
    if (!missing_extensions.empty())
2514
101
    {
2515
102
        std::stringstream message;
2516
103
        message << "Missing required extension" << (missing_extensions.size() > 1 ? "s:" : ":");
2517
104
        for (auto missing_extension : missing_extensions)
2518
105
        {
2519
106
            message << " " << missing_extension;
2520
107
        }
2521
108
2522
109
        mir::log(
2523
110
            mir::logging::Severity::debug,
2524
111
            "platform-eglstream",
2525
112
            "EGLStream platform is unsupported: %s",
2526
113
            message.str().c_str());
2527
114
        return mg::PlatformPriority::unsupported;
2528
115
    }
2529
116
2530
117
    int device_count{0};
2531
118
    if (eglQueryDevicesEXT(0, nullptr, &device_count) != EGL_TRUE)
2532
119
    {
2533
120
        mir::log(
2534
121
            mir::logging::Severity::informational,
2535
122
            "platform-eglstream",
2536
123
            "Platform claims to support EGL_EXT_device_base, but eglQueryDevicesEXT falied: %s",
2537
124
            mg::egl_category().message(eglGetError()).c_str());
2538
125
        return mg::PlatformPriority::unsupported;
2539
126
    }
2540
127
2541
128
    auto devices = std::make_unique<EGLDeviceEXT[]>(device_count);
2542
129
    if (eglQueryDevicesEXT(device_count, devices.get(), &device_count) != EGL_TRUE)
2543
130
    {
2544
131
        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to get device list with eglQueryDevicesEXT"));
2545
132
    }
2546
133
2547
134
    if (std::none_of(devices.get(), devices.get() + device_count,
2548
135
        [](EGLDeviceEXT device)
2549
136
        {
2550
137
            auto device_extensions = eglQueryDeviceStringEXT(device, EGL_EXTENSIONS);
2551
138
            if (device_extensions)
2552
139
            {
2553
140
                mir::log(
2554
141
                    mir::logging::Severity::debug,
2555
142
                    "platform-eglstream",
2556
143
                    "Found EGLDeviceEXT with device extensions: %s", device_extensions);
2557
144
                return strstr(device_extensions, "EGL_EXT_device_drm") != NULL;
2558
145
            }
2559
146
            else
2560
147
            {
2561
148
                mir::log(
2562
149
                    mir::logging::Severity::debug,
2563
150
                    "platform-eglstream",
2564
151
                    "Found EGLDeviceEXT with no device extensions");
2565
152
                return false;
2566
153
            }
2567
154
        }))
2568
155
    {
2569
156
        mir::log(
2570
157
            mir::logging::Severity::debug,
2571
158
            "platform-eglstream",
2572
159
            "EGLDeviceEXTs found, but none support required EGL_EXT_device_drm extension");
2573
160
        return mg::PlatformPriority::unsupported;
2574
161
    }
2575
162
2576
163
    return mg::PlatformPriority::best;
2577
164
}
2578
165
2579
166
namespace
2580
167
{
2581
168
mir::ModuleProperties const description = {
2582
169
    "mir:eglstream-kms",
2583
170
    MIR_VERSION_MAJOR,
2584
171
    MIR_VERSION_MINOR,
2585
172
    MIR_VERSION_MICRO,
2586
173
    mir::libname()
2587
174
};
2588
175
}
2589
176
2590
177
mir::ModuleProperties const* describe_graphics_module()
2591
178
{
2592
179
    mir::assert_entry_point_signature<mg::DescribeModule>(&describe_graphics_module);
2593
180
    return &description;
2594
181
}
2595
182
2596
183
mir::UniqueModulePtr<mg::Platform> create_guest_platform(
2597
184
    std::shared_ptr<mg::DisplayReport> const&,
2598
185
    std::shared_ptr<mg::NestedContext> const& /*nested_context*/)
2599
186
{
2600
187
    mir::assert_entry_point_signature<mg::CreateGuestPlatform>(&create_guest_platform);
2601
188
    return nullptr;
2602
189
}
2603
0
190
2604
=== added file 'src/platforms/eglstream-kms/server/symbols.map.in'
2605
--- src/platforms/eglstream-kms/server/symbols.map.in	1970-01-01 00:00:00 +0000
2606
+++ src/platforms/eglstream-kms/server/symbols.map.in	2016-06-08 13:28:19 +0000
2607
@@ -0,0 +1,10 @@
2608
1
@MIR_SERVER_GRAPHICS_PLATFORM_VERSION@ {
2609
2
  global:
2610
3
    add_graphics_platform_options;
2611
4
    create_host_platform;
2612
5
    create_guest_platform;
2613
6
    probe_graphics_platform;
2614
7
    describe_graphics_module;
2615
8
  local:
2616
9
    *;
2617
10
};
2618
0
11
2619
=== modified file 'src/platforms/mesa/server/kms/platform_symbols.cpp'
2620
--- src/platforms/mesa/server/kms/platform_symbols.cpp	2016-01-29 08:18:22 +0000
2621
+++ src/platforms/mesa/server/kms/platform_symbols.cpp	2016-06-08 13:28:19 +0000
2622
@@ -26,6 +26,7 @@
2623
26
#include "mir/assert_module_entry_point.h"
26
#include "mir/assert_module_entry_point.h"
2624
27
#include "mir/libname.h"
27
#include "mir/libname.h"
2625
28
28
2626
29
#include <EGL/egl.h>
2627
29
#include <fcntl.h>
30
#include <fcntl.h>
2628
30
#include <sys/ioctl.h>
31
#include <sys/ioctl.h>
2629
31
32
2630
@@ -162,6 +163,19 @@
2631
162
    if (drm_devices.begin() == drm_devices.end())
163
    if (drm_devices.begin() == drm_devices.end())
2632
163
        return mg::PlatformPriority::unsupported;
164
        return mg::PlatformPriority::unsupported;
2633
164
165
2634
166
    // We also require GBM EGL platform
2635
167
    auto const* client_extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
2636
168
    if (!client_extensions)
2637
169
    {
2638
170
        // Doesn't support EGL client extensions; Mesa does, so this is unlikely to be mesa.
2639
171
        return mg::PlatformPriority::unsupported;
2640
172
    }
2641
173
    if (strstr(client_extensions, "EGL_MESA_platform_gbm") == nullptr)
2642
174
    {
2643
175
        // No platform_gbm support, so we can't work.
2644
176
        return mg::PlatformPriority::unsupported;
2645
177
    }
2646
178
2647
165
    // Check for master
179
    // Check for master
2648
166
    int tmp_fd = -1;
180
    int tmp_fd = -1;
2649
167
    for (auto& device : drm_devices)
181
    for (auto& device : drm_devices)
2650
168
182
2651
=== modified file 'tests/unit-tests/CMakeLists.txt'
2652
--- tests/unit-tests/CMakeLists.txt	2016-06-02 05:33:50 +0000
2653
+++ tests/unit-tests/CMakeLists.txt	2016-06-08 13:28:19 +0000
2654
@@ -17,6 +17,10 @@
2655
17
  add_definitions(-DMIR_BUILD_PLATFORM_MESA_X11)
17
  add_definitions(-DMIR_BUILD_PLATFORM_MESA_X11)
2656
18
endif()
18
endif()
2657
19
19
2658
20
if (MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
2659
21
  add_definitions(-DMIR_BUILD_PLATFORM_EGLSTREAM_KMS)
2660
22
endif()
2661
23
2662
20
include_directories(
24
include_directories(
2663
21
  ${CMAKE_SOURCE_DIR}
25
  ${CMAKE_SOURCE_DIR}
2664
22
26
2665
23
27
2666
=== modified file 'tests/unit-tests/client/test_probing_client_platform_factory.cpp'
2667
--- tests/unit-tests/client/test_probing_client_platform_factory.cpp	2016-05-27 00:47:04 +0000
2668
+++ tests/unit-tests/client/test_probing_client_platform_factory.cpp	2016-06-08 13:28:19 +0000
2669
@@ -55,6 +55,13 @@
2670
55
    memset(&pkg, 0, sizeof(pkg));
55
    memset(&pkg, 0, sizeof(pkg));
2671
56
}
56
}
2672
57
57
2673
58
#if defined(MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
2674
59
void populate_valid_eglstream_platform_package(MirPlatformPackage& pkg)
2675
60
{
2676
61
    memset(&pkg, 0, sizeof(pkg));
2677
62
}
2678
63
#endif
2679
64
2680
58
class ModuleContext
65
class ModuleContext
2681
59
{
66
{
2682
60
public:
67
public:
2683
@@ -115,6 +122,11 @@
2684
115
        std::make_pair<std::string, ModuleContext>(
122
        std::make_pair<std::string, ModuleContext>(
2685
116
            "android", { "android", "graphics-android", &populate_valid_android_platform_package }));
123
            "android", { "android", "graphics-android", &populate_valid_android_platform_package }));
2686
117
#endif
124
#endif
2687
125
#if defined(MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
2688
126
    modules.emplace(
2689
127
        std::make_pair<std::string, ModuleContext>(
2690
128
            "eglstream-kms", { "eglstream", "graphics-eglstream-kms", &populate_valid_eglstream_platform_package}));
2691
129
#endif
2692
118
    return modules;
130
    return modules;
2693
119
}
131
}
2694
120
132
2695
@@ -289,6 +301,26 @@
2696
289
    EXPECT_EQ(mir_platform_type_gbm, platform->platform_type());
301
    EXPECT_EQ(mir_platform_type_gbm, platform->platform_type());
2697
290
}
302
}
2698
291
303
2699
304
#if defined(MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
2700
305
TEST(ProbingClientPlatformFactory, CreatesEglstreamPlatformOnEglstreamKMS)
2701
306
#else
2702
307
TEST(ProbingClientPlatformFactory, DISABLED_CreatesEglstreamPlatformOnEglstreamKMS)
2703
308
#endif
2704
309
{
2705
310
    using namespace testing;
2706
311
2707
312
    mir::client::ProbingClientPlatformFactory factory(
2708
313
        mir::report::null_shared_library_prober_report(),
2709
314
        all_available_modules(),
2710
315
        {});
2711
316
2712
317
    NiceMock<mtd::MockClientContext> context;
2713
318
    all_available_fixtures().at("eglstream-kms").setup_context(context);
2714
319
2715
320
    auto platform = factory.create_client_platform(&context);
2716
321
    EXPECT_EQ(mir_platform_type_eglstream, platform->platform_type());
2717
322
}
2718
323
2719
292
#ifdef MIR_BUILD_PLATFORM_ANDROID
324
#ifdef MIR_BUILD_PLATFORM_ANDROID
2720
293
TEST(ProbingClientPlatformFactory, CreatesAndroidPlatformWhenAppropriate)
325
TEST(ProbingClientPlatformFactory, CreatesAndroidPlatformWhenAppropriate)
2721
294
#else
326
#else
2722
295
327
2723
=== modified file 'tests/unit-tests/graphics/mesa/kms/test_platform.cpp'
2724
--- tests/unit-tests/graphics/mesa/kms/test_platform.cpp	2016-01-29 08:18:22 +0000
2725
+++ tests/unit-tests/graphics/mesa/kms/test_platform.cpp	2016-06-08 13:28:19 +0000
2726
@@ -40,6 +40,7 @@
2727
40
40
2728
41
#include "mir/test/doubles/mock_drm.h"
41
#include "mir/test/doubles/mock_drm.h"
2729
42
#include "mir/test/doubles/mock_gbm.h"
42
#include "mir/test/doubles/mock_gbm.h"
2730
43
#include "mir/test/doubles/mock_egl.h"
2731
43
#include "mir/test/doubles/fd_matcher.h"
44
#include "mir/test/doubles/fd_matcher.h"
2732
44
45
2733
45
#include <gtest/gtest.h>
46
#include <gtest/gtest.h>
2734
@@ -65,8 +66,11 @@
2735
65
public:
66
public:
2736
66
    void SetUp()
67
    void SetUp()
2737
67
    {
68
    {
2740
68
        ::testing::Mock::VerifyAndClearExpectations(&mock_drm);
69
        using namespace testing;
2741
69
        ::testing::Mock::VerifyAndClearExpectations(&mock_gbm);
70
        Mock::VerifyAndClearExpectations(&mock_drm);
2742
71
        Mock::VerifyAndClearExpectations(&mock_gbm);
2743
72
        ON_CALL(mock_egl, eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS))
2744
73
            .WillByDefault(Return("EGL_AN_extension_string EGL_MESA_platform_gbm"));
2745
70
        fake_devices.add_standard_device("standard-drm-devices");
74
        fake_devices.add_standard_device("standard-drm-devices");
2746
71
    }
75
    }
2747
72
76
2748
@@ -81,6 +85,7 @@
2749
81
85
2750
82
    ::testing::NiceMock<mtd::MockDRM> mock_drm;
86
    ::testing::NiceMock<mtd::MockDRM> mock_drm;
2751
83
    ::testing::NiceMock<mtd::MockGBM> mock_gbm;
87
    ::testing::NiceMock<mtd::MockGBM> mock_gbm;
2752
88
    ::testing::NiceMock<mtd::MockEGL> mock_egl;
2753
84
    mtf::UdevEnvironment fake_devices;
89
    mtf::UdevEnvironment fake_devices;
2754
85
};
90
};
2755
86
}
91
}
2756
@@ -366,3 +371,43 @@
2757
366
    auto probe = platform_lib.load_function<mg::PlatformProbe>(probe_platform);
371
    auto probe = platform_lib.load_function<mg::PlatformProbe>(probe_platform);
2758
367
    EXPECT_EQ(mg::PlatformPriority::best, probe(options));
372
    EXPECT_EQ(mg::PlatformPriority::best, probe(options));
2759
368
}
373
}
2760
374
2761
375
TEST_F(MesaGraphicsPlatform, probe_returns_unsupported_when_egl_client_extensions_not_supported)
2762
376
{
2763
377
    using namespace testing;
2764
378
2765
379
    mtf::UdevEnvironment udev_environment;
2766
380
    boost::program_options::options_description po;
2767
381
    mir::options::ProgramOption options;
2768
382
    const char *argv[] = {"dummy", "--vt"};
2769
383
    options.parse_arguments(po, 2, argv);
2770
384
2771
385
    udev_environment.add_standard_device("standard-drm-devices");
2772
386
2773
387
    ON_CALL(mock_egl, eglQueryString(EGL_NO_DISPLAY, _))
2774
388
        .WillByDefault(Return(nullptr));
2775
389
2776
390
    mir::SharedLibrary platform_lib{mtf::server_platform("graphics-mesa-kms")};
2777
391
    auto probe = platform_lib.load_function<mg::PlatformProbe>(probe_platform);
2778
392
    EXPECT_EQ(mg::PlatformPriority::unsupported, probe(options));
2779
393
}
2780
394
2781
395
TEST_F(MesaGraphicsPlatform, probe_returns_unsupported_when_gbm_platform_not_supported)
2782
396
{
2783
397
    using namespace testing;
2784
398
2785
399
    mtf::UdevEnvironment udev_environment;
2786
400
    boost::program_options::options_description po;
2787
401
    mir::options::ProgramOption options;
2788
402
    const char *argv[] = {"dummy", "--vt"};
2789
403
    options.parse_arguments(po, 2, argv);
2790
404
2791
405
    udev_environment.add_standard_device("standard-drm-devices");
2792
406
2793
407
    ON_CALL(mock_egl, eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS))
2794
408
        .WillByDefault(Return("EGL_KHR_not_really_an_extension EGL_EXT_master_of_the_house"));
2795
409
2796
410
    mir::SharedLibrary platform_lib{mtf::server_platform("graphics-mesa-kms")};
2797
411
    auto probe = platform_lib.load_function<mg::PlatformProbe>(probe_platform);
2798
412
    EXPECT_EQ(mg::PlatformPriority::unsupported, probe(options));
2799
413
}
2800
369
414
2801
=== modified file 'tests/unit-tests/graphics/test_platform_prober.cpp'
2802
--- tests/unit-tests/graphics/test_platform_prober.cpp	2016-05-27 03:32:07 +0000
2803
+++ tests/unit-tests/graphics/test_platform_prober.cpp	2016-06-08 13:28:19 +0000
2804
@@ -27,6 +27,7 @@
2805
27
#ifdef MIR_BUILD_PLATFORM_MESA_KMS
27
#ifdef MIR_BUILD_PLATFORM_MESA_KMS
2806
28
#include "mir/test/doubles/mock_drm.h"
28
#include "mir/test/doubles/mock_drm.h"
2807
29
#include "mir/test/doubles/mock_gbm.h"
29
#include "mir/test/doubles/mock_gbm.h"
2808
30
#include "mir/test/doubles/mock_egl.h"
2809
30
#endif
31
#endif
2810
31
32
2811
32
#ifdef MIR_BUILD_PLATFORM_ANDROID
33
#ifdef MIR_BUILD_PLATFORM_ANDROID
2812
@@ -81,11 +82,18 @@
2813
81
82
2814
82
std::shared_ptr<void> ensure_mesa_probing_succeeds()
83
std::shared_ptr<void> ensure_mesa_probing_succeeds()
2815
83
{
84
{
2821
84
    auto udev = std::make_shared<mtf::UdevEnvironment>();
85
    using namespace testing;
2822
85
86
    struct MockEnvironment {
2823
86
    udev->add_standard_device("standard-drm-devices");
87
        mtf::UdevEnvironment udev;
2824
87
88
        mtd::MockEGL egl;
2825
88
    return udev;
89
    };
2826
90
    auto env = std::make_shared<MockEnvironment>();
2827
91
2828
92
    env->udev.add_standard_device("standard-drm-devices");
2829
93
    ON_CALL(env->egl, eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS))
2830
94
        .WillByDefault(Return("EGL_MESA_platform_gbm"));
2831
95
2832
96
    return env;
2833
89
}
97
}
2834
90
98
2835
91
std::shared_ptr<void> ensure_android_probing_succeeds()
99
std::shared_ptr<void> ensure_android_probing_succeeds()
2836
@@ -236,7 +244,7 @@
2837
236
    auto descriptor = module->load_function<mir::graphics::DescribeModule>(describe_module);
244
    auto descriptor = module->load_function<mir::graphics::DescribeModule>(describe_module);
2838
237
    auto description = descriptor();
245
    auto description = descriptor();
2839
238
246
2841
239
    EXPECT_THAT(description->name, Not(HasSubstr("dummy")));
247
    EXPECT_THAT(description->name, Not(HasSubstr("mir:stub-graphics")));
2842
240
}
248
}
2843
241
#endif
249
#endif
2844
242
250
Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration	2016-06-03	Needs Fixing on 2016-06-09
Alan Griffiths			Abstain on 2016-06-09
Cemil Azizoglu (community)			Needs Fixing on 2016-06-07
Daniel van Vugt		2016-06-03	Pending
Review via email: mp+296389@code.launchpad.net