Fix vertex upload regression
[chai.git] / jobs.md
1 This is a job-based architecture. All interesting behaviour (shaders,
2 rendering) is a result of jobs. Each job is sent from the driver across
3 the shim to the GPU. The job is encoded as a special data structure in
4 GPU memory.
5
6 There are two families of jobs, hardware jobs and software jobs.
7 Hardware jobs interact with the GPU directly. Software jobs are used to
8 manipulate the driver. Software jobs set BASE_JD_REQ_SOFT_JOB in the
9 .core_req field of the atom.
10
11 Hardware jobs contain the jc pointer into GPU memory. This points to the
12 job descriptor. All hardware jobs begin with the job descriptor header
13 which is found in the shim headers.
14
15 This header contains a pointer to the next job, forming sequences of
16 hardware jobs.
17
18 The header also denotes the type of job (vertex, fragment, or tiler).
19 After the header there is simple type specific information.
20
21 Set value jobs follow:
22
23         struct tentative_set_value {
24                 uint64_t write_iut; /* Maybe vertices or shader? */
25                 uint64_t unknown1; /* Trace has it set at 3 */
26         }
27
28
29 Fragment jobs follow:
30
31         struct tentative_fragment {
32                 uint32_t min_tile_coord;
33                 uint32_t max_tile_coord;
34                 uint64_t fragment_fbd;
35         };
36
37 Tiles are 16x16 pixels. This can be concluded from max_tile_coord in
38 known render sizes.
39
40 Fragment jobs contain an external resource, the framebuffer (in shared
41 memory / UMM). The framebuffer is in BGRA8888 format.
42
43 Vertex and tiler jobs follow the same structure (pointers are 32-bit to
44 GPU memory):
45
46         struct tentative_vertex_tiler {
47                 uint32_t block1[11];
48                 uint32_t addresses1[4];
49                 tentative_shader *shaderMeta;
50                 vertex_buffer *vb;
51                 uint32_t addresses2[6];
52                 tentative_fbd *fbd;
53                 uint32_t addresses3[1];
54                 uint32_t block2[36];
55         }
56
57 The shader metadata follows a (very indirect) structure:
58
59         struct tentative_shader {
60                 uint64_t shader; /* ORed with 16 bytes of flags */
61                 uint32_t block[unknown];
62         }
63
64 Shader points directly to the compiled instruction stream. For vertex
65 jobs, this is the vertex shader. For tiler jobs, this is the fragment
66 shader.
67
68 The vertex buffer contains metadata about the vertices:
69
70         struct vertex_buffer {
71                 float *vertices;
72                 size_t vertex_size; /* sizeof(*vertices) * components */
73                 size_t buffer_size; /* vertex_size * num_vertices */
74         }