2 * Copyright © 2019 Google LLC
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:
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
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
21 * DEALINGS IN THE SOFTWARE.
26 #include "tu_private.h"
28 #include "registers/adreno_pm4.xml.h"
31 tu_cs_init(struct tu_cs
*cs
, enum tu_cs_mode mode
, uint32_t initial_size
);
34 tu_cs_init_external(struct tu_cs
*cs
, uint32_t *start
, uint32_t *end
);
37 tu_cs_finish(struct tu_device
*dev
, struct tu_cs
*cs
);
40 tu_cs_begin(struct tu_cs
*cs
);
43 tu_cs_end(struct tu_cs
*cs
);
46 tu_cs_begin_sub_stream(struct tu_device
*dev
,
49 struct tu_cs
*sub_cs
);
52 tu_cs_end_sub_stream(struct tu_cs
*cs
, struct tu_cs
*sub_cs
);
55 tu_cs_reserve_space(struct tu_device
*dev
,
57 uint32_t reserved_size
);
60 tu_cs_reset(struct tu_device
*dev
, struct tu_cs
*cs
);
63 * Discard all entries. This allows \a cs to be reused while keeping the
64 * existing BOs and command packets intact.
67 tu_cs_discard_entries(struct tu_cs
*cs
)
69 assert(cs
->mode
== TU_CS_MODE_GROW
);
74 * Get the size needed for tu_cs_emit_call.
76 static inline uint32_t
77 tu_cs_get_call_size(const struct tu_cs
*cs
)
79 assert(cs
->mode
== TU_CS_MODE_GROW
);
80 /* each CP_INDIRECT_BUFFER needs 4 dwords */
81 return cs
->entry_count
* 4;
85 * Assert that we did not exceed the reserved space.
88 tu_cs_sanity_check(const struct tu_cs
*cs
)
90 assert(cs
->start
<= cs
->cur
);
91 assert(cs
->cur
<= cs
->reserved_end
);
92 assert(cs
->reserved_end
<= cs
->end
);
96 * Emit a uint32_t value into a command stream, without boundary checking.
99 tu_cs_emit(struct tu_cs
*cs
, uint32_t value
)
101 assert(cs
->cur
< cs
->reserved_end
);
107 * Emit an array of uint32_t into a command stream, without boundary checking.
110 tu_cs_emit_array(struct tu_cs
*cs
, const uint32_t *values
, uint32_t length
)
112 assert(cs
->cur
+ length
<= cs
->reserved_end
);
113 memcpy(cs
->cur
, values
, sizeof(uint32_t) * length
);
117 static inline unsigned
118 tu_odd_parity_bit(unsigned val
)
120 /* See: http://graphics.stanford.edu/~seander/bithacks.html#ParityParallel
121 * note that we want odd parity so 0x6996 is inverted.
127 return (~0x6996 >> val
) & 1;
131 * Emit a type-4 command packet header into a command stream.
134 tu_cs_emit_pkt4(struct tu_cs
*cs
, uint16_t regindx
, uint16_t cnt
)
136 tu_cs_emit(cs
, CP_TYPE4_PKT
| cnt
| (tu_odd_parity_bit(cnt
) << 7) |
137 ((regindx
& 0x3ffff) << 8) |
138 ((tu_odd_parity_bit(regindx
) << 27)));
142 * Emit a type-7 command packet header into a command stream.
145 tu_cs_emit_pkt7(struct tu_cs
*cs
, uint8_t opcode
, uint16_t cnt
)
147 tu_cs_emit(cs
, CP_TYPE7_PKT
| cnt
| (tu_odd_parity_bit(cnt
) << 15) |
148 ((opcode
& 0x7f) << 16) |
149 ((tu_odd_parity_bit(opcode
) << 23)));
153 tu_cs_emit_wfi(struct tu_cs
*cs
)
155 tu_cs_emit_pkt7(cs
, CP_WAIT_FOR_IDLE
, 0);
159 tu_cs_emit_qw(struct tu_cs
*cs
, uint64_t value
)
161 tu_cs_emit(cs
, (uint32_t) value
);
162 tu_cs_emit(cs
, (uint32_t) (value
>> 32));
166 tu_cs_emit_write_reg(struct tu_cs
*cs
, uint16_t reg
, uint32_t value
)
168 tu_cs_emit_pkt4(cs
, reg
, 1);
169 tu_cs_emit(cs
, value
);
173 * Emit a CP_INDIRECT_BUFFER command packet.
176 tu_cs_emit_ib(struct tu_cs
*cs
, const struct tu_cs_entry
*entry
)
179 assert(entry
->size
&& entry
->offset
+ entry
->size
<= entry
->bo
->size
);
180 assert(entry
->size
% sizeof(uint32_t) == 0);
181 assert(entry
->offset
% sizeof(uint32_t) == 0);
183 tu_cs_emit_pkt7(cs
, CP_INDIRECT_BUFFER
, 3);
184 tu_cs_emit_qw(cs
, entry
->bo
->iova
+ entry
->offset
);
185 tu_cs_emit(cs
, entry
->size
/ sizeof(uint32_t));
189 * Emit a CP_INDIRECT_BUFFER command packet for each entry in the target
193 tu_cs_emit_call(struct tu_cs
*cs
, const struct tu_cs
*target
)
195 assert(target
->mode
== TU_CS_MODE_GROW
);
196 for (uint32_t i
= 0; i
< target
->entry_count
; i
++)
197 tu_cs_emit_ib(cs
, target
->entries
+ i
);