Lines Matching defs:aub
54 static struct aub_context *aub_context_new(struct aub_file *aub, uint32_t new_id);
55 static void mem_trace_memory_write_header_out(struct aub_file *aub, uint64_t addr,
82 data_out(struct aub_file *aub, const void *data, size_t size)
87 fail_if(fwrite(data, 1, size, aub->file) == 0,
92 dword_out(struct aub_file *aub, uint32_t data)
94 data_out(aub, &data, sizeof(data));
98 write_execlists_header(struct aub_file *aub, const char *name)
105 aub->pci_id, name);
109 dword_out(aub, CMD_MEM_TRACE_VERSION | (dwords - 1));
110 dword_out(aub, AUB_MEM_TRACE_VERSION_FILE_VERSION);
111 dword_out(aub, aub->devinfo.simulator_id << AUB_MEM_TRACE_VERSION_DEVICE_SHIFT);
112 dword_out(aub, 0); /* version */
113 dword_out(aub, 0); /* version */
114 data_out(aub, app_name, app_name_len);
118 write_legacy_header(struct aub_file *aub, const char *name)
124 comment_len = snprintf(comment, sizeof(comment), "PCI-ID=0x%x", aub->pci_id);
129 dword_out(aub, CMD_AUB_HEADER | (dwords - 2));
130 dword_out(aub, (4 << AUB_HEADER_MAJOR_SHIFT) |
136 data_out(aub, app_name, sizeof(app_name));
138 dword_out(aub, 0); /* timestamp */
139 dword_out(aub, 0); /* timestamp */
140 dword_out(aub, comment_len);
141 data_out(aub, comment, comment_dwords * 4);
146 aub_write_header(struct aub_file *aub, const char *app_name)
148 if (aub_use_execlists(aub))
149 write_execlists_header(aub, app_name);
151 write_legacy_header(aub, app_name);
155 aub_file_init(struct aub_file *aub, FILE *file, FILE *debug, uint16_t pci_id, const char *app_name)
157 memset(aub, 0, sizeof(*aub));
159 aub->verbose_log_file = debug;
160 aub->file = file;
161 aub->pci_id = pci_id;
162 fail_if(!intel_get_device_info_from_pci_id(pci_id, &aub->devinfo),
164 aub->addr_bits = aub->devinfo.ver >= 8 ? 48 : 32;
166 aub_write_header(aub, app_name);
168 aub->phys_addrs_allocator = 0;
169 aub->ggtt_addrs_allocator = 0;
170 aub->pml4.phys_addr = aub->phys_addrs_allocator++ << 12;
172 mem_trace_memory_write_header_out(aub, aub->ggtt_addrs_allocator++,
176 dword_out(aub, 1);
177 dword_out(aub, 0);
179 aub->next_context_handle = 1;
180 aub_context_new(aub, 0); /* Default context */
184 aub_file_finish(struct aub_file *aub)
186 aub_ppgtt_table_finish(&aub->pml4, 4);
187 fclose(aub->file);
191 aub_gtt_size(struct aub_file *aub)
193 return NUM_PT_ENTRIES * (aub->addr_bits > 32 ? GFX8_PTE_SIZE : PTE_SIZE);
197 mem_trace_memory_write_header_out(struct aub_file *aub, uint64_t addr,
203 if (aub->verbose_log_file) {
204 fprintf(aub->verbose_log_file,
209 dword_out(aub, CMD_MEM_TRACE_MEMORY_WRITE | (5 + dwords - 1));
210 dword_out(aub, addr & 0xFFFFFFFF); /* addr lo */
211 dword_out(aub, addr >> 32); /* addr hi */
212 dword_out(aub, addr_space); /* gtt */
213 dword_out(aub, len);
217 register_write_out(struct aub_file *aub, uint32_t addr, uint32_t value)
221 if (aub->verbose_log_file) {
222 fprintf(aub->verbose_log_file,
226 dword_out(aub, CMD_MEM_TRACE_REGISTER_WRITE | (5 + dwords - 1));
227 dword_out(aub, addr);
228 dword_out(aub, AUB_MEM_TRACE_REGISTER_SIZE_DWORD |
230 dword_out(aub, 0xFFFFFFFF); /* mask lo */
231 dword_out(aub, 0x00000000); /* mask hi */
232 dword_out(aub, value);
236 populate_ppgtt_table(struct aub_file *aub, struct aub_ppgtt_table *table,
242 if (aub->verbose_log_file) {
243 fprintf(aub->verbose_log_file,
254 (void *)(uintptr_t)(aub->phys_addrs_allocator++ << 12);
255 if (aub->verbose_log_file) {
256 fprintf(aub->verbose_log_file,
264 aub->phys_addrs_allocator++ << 12;
265 if (aub->verbose_log_file) {
266 fprintf(aub->verbose_log_file,
282 mem_trace_memory_write_header_out(aub, write_addr, write_size,
285 data_out(aub, entries + dirty_start, write_size);
290 aub_map_ppgtt(struct aub_file *aub, uint64_t start, uint64_t size)
300 #define L3_table(addr) (aub->pml4.subtables[L4_index(addr)])
304 if (aub->verbose_log_file) {
305 fprintf(aub->verbose_log_file,
310 populate_ppgtt_table(aub, &aub->pml4, L4_index(l4_start), L4_index(l4_end), 4);
319 populate_ppgtt_table(aub, L3_table(l4), l3_start_idx, l3_end_idx, 3);
328 populate_ppgtt_table(aub, L2_table(l3), l2_start_idx, l2_end_idx, 2);
337 populate_ppgtt_table(aub, L1_table(l2), l1_start_idx, l1_end_idx, 1);
344 ppgtt_lookup(struct aub_file *aub, uint64_t ppgtt_addr)
388 aub_map_ggtt(struct aub_file *aub, uint64_t virt_addr, uint64_t size)
394 assert((aub->phys_addrs_allocator + size) < (1ULL << 32));
398 uint64_t phys_addr = aub->phys_addrs_allocator << 12;
399 aub->phys_addrs_allocator += ggtt_ptes;
401 if (aub->verbose_log_file) {
402 fprintf(aub->verbose_log_file,
407 mem_trace_memory_write_header_out(aub,
413 dword_out(aub, 1 + phys_addr + i * 4096);
414 dword_out(aub, 0);
419 aub_write_ggtt(struct aub_file *aub, uint64_t virt_addr, uint64_t size, const void *data)
427 assert(!aub->has_default_setup);
429 aub_map_ggtt(aub, virt_addr, size);
431 /* We write the GGTT buffer through the GGTT aub command rather than the
432 * PHYSICAL aub command. This is because the Gfx9 simulator seems to have 2
440 mem_trace_memory_write_header_out(aub, virt_addr + offset, block_size,
443 data_out(aub, (char *) data + offset, block_size);
446 data_out(aub, null_block, -block_size & 3);
490 alloc_ggtt_address(struct aub_file *aub, uint64_t size)
493 uint64_t addr = aub->ggtt_addrs_allocator << 12;
495 aub->ggtt_addrs_allocator += ggtt_ptes;
496 aub_map_ggtt(aub, addr, size);
502 write_hwsp(struct aub_file *aub,
514 register_write_out(aub, reg, aub->engine_setup[engine_class].hwsp_addr);
518 write_engine_execlist_setup(struct aub_file *aub,
526 get_context_init(&aub->devinfo, NULL, engine_class, NULL, &context_size);
531 uint64_t ggtt_addr = alloc_ggtt_address(aub, total_size);
538 mem_trace_memory_write_header_out(aub, ggtt_addr, RING_SIZE,
542 dword_out(aub, 0);
548 mem_trace_memory_write_header_out(aub, ggtt_addr,
553 dword_out(aub, 0);
559 .pml4_addr = aub->pml4.phys_addr,
562 get_context_init(&aub->devinfo, ¶ms, engine_class, context_data, &context_size);
563 data_out(aub, context_data, context_size);
572 write_execlists_default_setup(struct aub_file *aub)
574 register_write_out(aub, RCSUNIT(GFX_MODE), 0x80008000 /* execlist enable */);
575 register_write_out(aub, VCSUNIT0(GFX_MODE), 0x80008000 /* execlist enable */);
576 register_write_out(aub, BCSUNIT0(GFX_MODE), 0x80008000 /* execlist enable */);
579 static void write_legacy_default_setup(struct aub_file *aub)
584 dword_out(aub, CMD_AUB_TRACE_HEADER_BLOCK |
585 ((aub->addr_bits > 32 ? 6 : 5) - 2));
586 dword_out(aub, AUB_TRACE_MEMTYPE_GTT_ENTRY |
588 dword_out(aub, 0); /* subtype */
589 dword_out(aub, 0); /* offset */
590 dword_out(aub, aub_gtt_size(aub)); /* size */
591 if (aub->addr_bits > 32)
592 dword_out(aub, 0);
594 dword_out(aub, entry + 0x1000 * i);
595 if (aub->addr_bits > 32)
596 dword_out(aub, 0);
605 aub_write_default_setup(struct aub_file *aub)
607 if (aub_use_execlists(aub))
608 write_execlists_default_setup(aub);
610 write_legacy_default_setup(aub);
612 aub->has_default_setup = true;
616 aub_context_new(struct aub_file *aub, uint32_t new_id)
618 assert(aub->num_contexts < MAX_CONTEXT_COUNT);
620 struct aub_context *ctx = &aub->contexts[aub->num_contexts++];
628 aub_write_context_create(struct aub_file *aub, uint32_t *ctx_id)
630 uint32_t new_id = ctx_id ? *ctx_id : aub->next_context_handle;
632 aub_context_new(aub, new_id);
635 aub->next_context_handle++;
641 aub_context_find(struct aub_file *aub, uint32_t id)
643 for (int i = 0; i < aub->num_contexts; i++) {
644 if (aub->contexts[i].id == id)
645 return &aub->contexts[i];
652 aub_write_ensure_context(struct aub_file *aub, uint32_t ctx_id,
655 struct aub_context *ctx = aub_context_find(aub, ctx_id);
660 write_engine_execlist_setup(aub, ctx->id, hw_ctx, engine_class);
666 get_context_descriptor(struct aub_file *aub,
679 aub_write_trace_block(struct aub_file *aub,
690 if (aub_use_execlists(aub)) {
692 mem_trace_memory_write_header_out(aub,
693 ppgtt_lookup(aub, gtt_offset + offset),
698 dword_out(aub, CMD_AUB_TRACE_HEADER_BLOCK |
699 ((aub->addr_bits > 32 ? 6 : 5) - 2));
700 dword_out(aub, AUB_TRACE_MEMTYPE_GTT |
702 dword_out(aub, subtype);
703 dword_out(aub, gtt_offset + offset);
704 dword_out(aub, align_u32(block_size, 4));
705 if (aub->addr_bits > 32)
706 dword_out(aub, (gtt_offset + offset) >> 32);
710 data_out(aub, ((char *) virtual) + offset, block_size);
712 data_out(aub, null_block, block_size);
715 data_out(aub, null_block, -block_size & 3);
720 aub_dump_ring_buffer_execlist(struct aub_file *aub,
725 mem_trace_memory_write_header_out(aub, hw_ctx->ring_addr, 16,
728 dword_out(aub, AUB_MI_BATCH_BUFFER_START | MI_BATCH_NON_SECURE_I965 | (3 - 2));
729 dword_out(aub, batch_offset & 0xFFFFFFFF);
730 dword_out(aub, batch_offset >> 32);
731 dword_out(aub, 0 /* MI_NOOP */);
733 mem_trace_memory_write_header_out(aub, hw_ctx->ring_addr + 8192 + 20, 4,
736 dword_out(aub, 0); /* RING_BUFFER_HEAD */
737 mem_trace_memory_write_header_out(aub, hw_ctx->ring_addr + 8192 + 28, 4,
740 dword_out(aub, 16); /* RING_BUFFER_TAIL */
744 aub_dump_execlist(struct aub_file *aub, const struct engine *cs, uint64_t descriptor)
746 if (aub->devinfo.ver >= 11) {
747 register_write_out(aub, cs->elsq_reg, descriptor & 0xFFFFFFFF);
748 register_write_out(aub, cs->elsq_reg + sizeof(uint32_t), descriptor >> 32);
749 register_write_out(aub, cs->control_reg, 1);
751 register_write_out(aub, cs->elsp_reg, 0);
752 register_write_out(aub, cs->elsp_reg, 0);
753 register_write_out(aub, cs->elsp_reg, descriptor >> 32);
754 register_write_out(aub, cs->elsp_reg, descriptor & 0xFFFFFFFF);
757 dword_out(aub, CMD_MEM_TRACE_REGISTER_POLL | (5 + 1 - 1));
758 dword_out(aub, cs->status_reg);
759 dword_out(aub, AUB_MEM_TRACE_REGISTER_SIZE_DWORD |
761 if (aub->devinfo.ver >= 11) {
762 dword_out(aub, 0x00000001); /* mask lo */
763 dword_out(aub, 0x00000000); /* mask hi */
764 dword_out(aub, 0x00000001);
766 dword_out(aub, 0x00000010); /* mask lo */
767 dword_out(aub, 0x00000000); /* mask hi */
768 dword_out(aub, 0x00000000);
773 aub_dump_ring_buffer_legacy(struct aub_file *aub,
791 aub_mi_bbs_len = aub->addr_bits > 32 ? 3 : 2;
793 aub_write_reloc(&aub->devinfo, &ringbuffer[ring_count + 1], batch_offset);
799 dword_out(aub, CMD_AUB_TRACE_HEADER_BLOCK |
800 ((aub->addr_bits > 32 ? 6 : 5) - 2));
801 dword_out(aub, AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE);
802 dword_out(aub, 0); /* general/surface subtype */
803 dword_out(aub, offset);
804 dword_out(aub, ring_count * 4);
805 if (aub->addr_bits > 32)
806 dword_out(aub, offset >> 32);
808 data_out(aub, ringbuffer, ring_count * 4);
812 aub_write_ensure_hwsp(struct aub_file *aub,
815 uint64_t *hwsp_addr = &aub->engine_setup[engine_class].hwsp_addr;
820 *hwsp_addr = alloc_ggtt_address(aub, 4096);
821 write_hwsp(aub, engine_class);
825 aub_write_exec(struct aub_file *aub, uint32_t ctx_id, uint64_t batch_addr,
830 if (aub_use_execlists(aub)) {
832 aub_write_ensure_context(aub, ctx_id, engine_class);
833 uint64_t descriptor = get_context_descriptor(aub, cs, hw_ctx);
834 aub_write_ensure_hwsp(aub, engine_class);
835 aub_dump_ring_buffer_execlist(aub, hw_ctx, cs, batch_addr);
836 aub_dump_execlist(aub, cs, descriptor);
839 aub_dump_ring_buffer_legacy(aub, batch_addr, offset, engine_class);
841 fflush(aub->file);
845 aub_write_context_execlists(struct aub_file *aub, uint64_t context_addr,
850 aub_dump_execlist(aub, cs, descriptor);