History

Merge tag 'drm-vc4-next-2015-12-11' of http://github.com/anholt/linux into drm-next

This pull request brings in 3D acceleration support for the VC4 GPU. While there is still performance work to be done (particularly surrounding RCL generation), the CL submit ABI should be settled and done now. * tag 'drm-vc4-next-2015-12-11' of http://github.com/anholt/linux: drm/vc4: Add an interface for capturing the GPU state after a hang. drm/vc4: Add support for async pageflips. drm/vc4: Add support for drawing 3D frames. drm/vc4: Bind and initialize the V3D engine. drm/vc4: Fix a typo in a V3D debug register. drm/vc4: Add an API for creating GPU shaders in GEM BOs. drm/vc4: Add create and map BO ioctls. drm/vc4: Add a BO cache. drm: Create a driver hook for allocating GEM object structs.

Dave Airlie committed 10 years ago

Commit 21de54b2 parents 870a171 214613623 files · +5577 −21Browse files

Showing the changes to include/uapi (2 of 23 files). Show all

Unified · Split

2 files
  1. include/uapi/drm/Kbuild +1 −0
  2. include/uapi/drm/vc4_drm.h +279 −0
include/uapi/drm/Kbuild+1−0
@@ -18,4 +18,5 @@ header-y += tegra_drm.h · 17 unmodified lines
18header-y += via_drm.h18header-y += via_drm.h
19header-y += vmwgfx_drm.h19header-y += vmwgfx_drm.h
20header-y += msm_drm.h20header-y += msm_drm.h
21header-y += vc4_drm.h
21header-y += virtgpu_drm.h22header-y += virtgpu_drm.h
include/uapi/drm/vc4_drm.h+279−0
@@ -0,0 +1,279 @@
1/*
2 * Copyright © 2014-2015 Broadcom
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24#ifndef _UAPI_VC4_DRM_H_
25#define _UAPI_VC4_DRM_H_
26
27#include "drm.h"
28
29#define DRM_VC4_SUBMIT_CL 0x00
30#define DRM_VC4_WAIT_SEQNO 0x01
31#define DRM_VC4_WAIT_BO 0x02
32#define DRM_VC4_CREATE_BO 0x03
33#define DRM_VC4_MMAP_BO 0x04
34#define DRM_VC4_CREATE_SHADER_BO 0x05
35#define DRM_VC4_GET_HANG_STATE 0x06
36
37#define DRM_IOCTL_VC4_SUBMIT_CL DRM_IOWR(DRM_COMMAND_BASE + DRM_VC4_SUBMIT_CL, struct drm_vc4_submit_cl)
38#define DRM_IOCTL_VC4_WAIT_SEQNO DRM_IOWR(DRM_COMMAND_BASE + DRM_VC4_WAIT_SEQNO, struct drm_vc4_wait_seqno)
39#define DRM_IOCTL_VC4_WAIT_BO DRM_IOWR(DRM_COMMAND_BASE + DRM_VC4_WAIT_BO, struct drm_vc4_wait_bo)
40#define DRM_IOCTL_VC4_CREATE_BO DRM_IOWR(DRM_COMMAND_BASE + DRM_VC4_CREATE_BO, struct drm_vc4_create_bo)
41#define DRM_IOCTL_VC4_MMAP_BO DRM_IOWR(DRM_COMMAND_BASE + DRM_VC4_MMAP_BO, struct drm_vc4_mmap_bo)
42#define DRM_IOCTL_VC4_CREATE_SHADER_BO DRM_IOWR(DRM_COMMAND_BASE + DRM_VC4_CREATE_SHADER_BO, struct drm_vc4_create_shader_bo)
43#define DRM_IOCTL_VC4_GET_HANG_STATE DRM_IOWR(DRM_COMMAND_BASE + DRM_VC4_GET_HANG_STATE, struct drm_vc4_get_hang_state)
44
45struct drm_vc4_submit_rcl_surface {
46 __u32 hindex; /* Handle index, or ~0 if not present. */
47 __u32 offset; /* Offset to start of buffer. */
48 /*
49 * Bits for either render config (color_write) or load/store packet.
50 * Bits should all be 0 for MSAA load/stores.
51 */
52 __u16 bits;
53
54#define VC4_SUBMIT_RCL_SURFACE_READ_IS_FULL_RES (1 << 0)
55 __u16 flags;
56};
57
58/**
59 * struct drm_vc4_submit_cl - ioctl argument for submitting commands to the 3D
60 * engine.
61 *
62 * Drivers typically use GPU BOs to store batchbuffers / command lists and
63 * their associated state. However, because the VC4 lacks an MMU, we have to
64 * do validation of memory accesses by the GPU commands. If we were to store
65 * our commands in BOs, we'd need to do uncached readback from them to do the
66 * validation process, which is too expensive. Instead, userspace accumulates
67 * commands and associated state in plain memory, then the kernel copies the
68 * data to its own address space, and then validates and stores it in a GPU
69 * BO.
70 */
71struct drm_vc4_submit_cl {
72 /* Pointer to the binner command list.
73 *
74 * This is the first set of commands executed, which runs the
75 * coordinate shader to determine where primitives land on the screen,
76 * then writes out the state updates and draw calls necessary per tile
77 * to the tile allocation BO.
78 */
79 __u64 bin_cl;
80
81 /* Pointer to the shader records.
82 *
83 * Shader records are the structures read by the hardware that contain
84 * pointers to uniforms, shaders, and vertex attributes. The
85 * reference to the shader record has enough information to determine
86 * how many pointers are necessary (fixed number for shaders/uniforms,
87 * and an attribute count), so those BO indices into bo_handles are
88 * just stored as __u32s before each shader record passed in.
89 */
90 __u64 shader_rec;
91
92 /* Pointer to uniform data and texture handles for the textures
93 * referenced by the shader.
94 *
95 * For each shader state record, there is a set of uniform data in the
96 * order referenced by the record (FS, VS, then CS). Each set of
97 * uniform data has a __u32 index into bo_handles per texture
98 * sample operation, in the order the QPU_W_TMUn_S writes appear in
99 * the program. Following the texture BO handle indices is the actual
100 * uniform data.
101 *
102 * The individual uniform state blocks don't have sizes passed in,
103 * because the kernel has to determine the sizes anyway during shader
104 * code validation.
105 */
106 __u64 uniforms;
107 __u64 bo_handles;
108
109 /* Size in bytes of the binner command list. */
110 __u32 bin_cl_size;
111 /* Size in bytes of the set of shader records. */
112 __u32 shader_rec_size;
113 /* Number of shader records.
114 *
115 * This could just be computed from the contents of shader_records and
116 * the address bits of references to them from the bin CL, but it
117 * keeps the kernel from having to resize some allocations it makes.
118 */
119 __u32 shader_rec_count;
120 /* Size in bytes of the uniform state. */
121 __u32 uniforms_size;
122
123 /* Number of BO handles passed in (size is that times 4). */
124 __u32 bo_handle_count;
125
126 /* RCL setup: */
127 __u16 width;
128 __u16 height;
129 __u8 min_x_tile;
130 __u8 min_y_tile;
131 __u8 max_x_tile;
132 __u8 max_y_tile;
133 struct drm_vc4_submit_rcl_surface color_read;
134 struct drm_vc4_submit_rcl_surface color_write;
135 struct drm_vc4_submit_rcl_surface zs_read;
136 struct drm_vc4_submit_rcl_surface zs_write;
137 struct drm_vc4_submit_rcl_surface msaa_color_write;
138 struct drm_vc4_submit_rcl_surface msaa_zs_write;
139 __u32 clear_color[2];
140 __u32 clear_z;
141 __u8 clear_s;
142
143 __u32 pad:24;
144
145#define VC4_SUBMIT_CL_USE_CLEAR_COLOR (1 << 0)
146 __u32 flags;
147
148 /* Returned value of the seqno of this render job (for the
149 * wait ioctl).
150 */
151 __u64 seqno;
152};
153
154/**
155 * struct drm_vc4_wait_seqno - ioctl argument for waiting for
156 * DRM_VC4_SUBMIT_CL completion using its returned seqno.
157 *
158 * timeout_ns is the timeout in nanoseconds, where "0" means "don't
159 * block, just return the status."
160 */
161struct drm_vc4_wait_seqno {
162 __u64 seqno;
163 __u64 timeout_ns;
164};
165
166/**
167 * struct drm_vc4_wait_bo - ioctl argument for waiting for
168 * completion of the last DRM_VC4_SUBMIT_CL on a BO.
169 *
170 * This is useful for cases where multiple processes might be
171 * rendering to a BO and you want to wait for all rendering to be
172 * completed.
173 */
174struct drm_vc4_wait_bo {
175 __u32 handle;
176 __u32 pad;
177 __u64 timeout_ns;
178};
179
180/**
181 * struct drm_vc4_create_bo - ioctl argument for creating VC4 BOs.
182 *
183 * There are currently no values for the flags argument, but it may be
184 * used in a future extension.
185 */
186struct drm_vc4_create_bo {
187 __u32 size;
188 __u32 flags;
189 /** Returned GEM handle for the BO. */
190 __u32 handle;
191 __u32 pad;
192};
193
194/**
195 * struct drm_vc4_mmap_bo - ioctl argument for mapping VC4 BOs.
196 *
197 * This doesn't actually perform an mmap. Instead, it returns the
198 * offset you need to use in an mmap on the DRM device node. This
199 * means that tools like valgrind end up knowing about the mapped
200 * memory.
201 *
202 * There are currently no values for the flags argument, but it may be
203 * used in a future extension.
204 */
205struct drm_vc4_mmap_bo {
206 /** Handle for the object being mapped. */
207 __u32 handle;
208 __u32 flags;
209 /** offset into the drm node to use for subsequent mmap call. */
210 __u64 offset;
211};
212
213/**
214 * struct drm_vc4_create_shader_bo - ioctl argument for creating VC4
215 * shader BOs.
216 *
217 * Since allowing a shader to be overwritten while it's also being
218 * executed from would allow privlege escalation, shaders must be
219 * created using this ioctl, and they can't be mmapped later.
220 */
221struct drm_vc4_create_shader_bo {
222 /* Size of the data argument. */
223 __u32 size;
224 /* Flags, currently must be 0. */
225 __u32 flags;
226
227 /* Pointer to the data. */
228 __u64 data;
229
230 /** Returned GEM handle for the BO. */
231 __u32 handle;
232 /* Pad, must be 0. */
233 __u32 pad;
234};
235
236struct drm_vc4_get_hang_state_bo {
237 __u32 handle;
238 __u32 paddr;
239 __u32 size;
240 __u32 pad;
241};
242
243/**
244 * struct drm_vc4_hang_state - ioctl argument for collecting state
245 * from a GPU hang for analysis.
246*/
247struct drm_vc4_get_hang_state {
248 /** Pointer to array of struct drm_vc4_get_hang_state_bo. */
249 __u64 bo;
250 /**
251 * On input, the size of the bo array. Output is the number
252 * of bos to be returned.
253 */
254 __u32 bo_count;
255
256 __u32 start_bin, start_render;
257
258 __u32 ct0ca, ct0ea;
259 __u32 ct1ca, ct1ea;
260 __u32 ct0cs, ct1cs;
261 __u32 ct0ra0, ct1ra0;
262
263 __u32 bpca, bpcs;
264 __u32 bpoa, bpos;
265
266 __u32 vpmbase;
267
268 __u32 dbge;
269 __u32 fdbgo;
270 __u32 fdbgb;
271 __u32 fdbgr;
272 __u32 fdbgs;
273 __u32 errstat;
274
275 /* Pad that we may save more registers into in the future. */
276 __u32 pad[16];
277};
278
279#endif /* _UAPI_VC4_DRM_H_ */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t