Build with panwrap headers
authorCafe <cafe@not.applicable>
Wed, 2 Aug 2017 02:10:26 +0000 (02:10 +0000)
committerCafe <cafe@not.applicable>
Wed, 2 Aug 2017 02:10:26 +0000 (02:10 +0000)
src/build.sh
src/jobs.h
src/memory.c
src/prototype.c
src/shim.c
src/shim.h
src/synthesise.c
src/trace.c

index 8fada2ea2a519ec28ec38c1ae50ea9abd7bfcec6..25e256dd4aad4989d7911a521420356336a0fd6d 100755 (executable)
@@ -1,3 +1,5 @@
 #!/bin/sh
 arm-linux-gnueabi-gcc prototype.c shim.c memory.c synthesise.c \
+       -Wl,-Bdynamic -lc -ldl \
+       -I../../panloader/include \
        -Wall -Werror -Wextra -Wno-missing-braces -D_FILE_OFFSET_BITS=64
index e8cebcf387ca925923946e2fd4670cea5c1f294e..e66c43dfc94ad7483f6c85846fca6a9fb184872a 100644 (file)
@@ -40,4 +40,51 @@ struct job_descriptor_header {
 
 } __attribute__((packed));
 
+typedef struct mali_jd_replay_payload {
+       /**
+        * Pointer to the first entry in the mali_jd_replay_jc list.  These
+        * will be replayed in @b reverse order (so that extra ones can be added
+        * to the head in future soft jobs without affecting this soft job)
+        */
+       u64 tiler_jc_list;
+
+       /**
+        * Pointer to the fragment job chain.
+        */
+       u64 fragment_jc;
+
+       /**
+        * Pointer to the tiler heap free FBD field to be modified.
+        */
+       u64 tiler_heap_free;
+
+       /**
+        * Hierarchy mask for the replayed fragment jobs. May be zero.
+        */
+       u16 fragment_hierarchy_mask;
+
+       /**
+        * Hierarchy mask for the replayed tiler jobs. May be zero.
+        */
+       u16 tiler_hierarchy_mask;
+
+       /**
+        * Default weight to be used for hierarchy levels not in the original
+        * mask.
+        */
+       u32 hierarchy_default_weight;
+
+       /**
+        * Core requirements for the tiler job chain
+        */
+       mali_jd_core_req tiler_core_req;
+
+       /**
+        * Core requirements for the fragment job chain
+        */
+       mali_jd_core_req fragment_core_req;
+
+       u8 padding[4];
+} mali_jd_replay_payload;
+
 #endif
index 6a9bc48f9df6c141d1c74cd84518ea51d645dda6..fe8ce0e8b4bd173c24f128c3084b9c73a4d48398 100644 (file)
@@ -2,6 +2,7 @@
 
 #include <stdio.h>
 #include <memory.h>
+#include <mali-ioctl.h>
 #include "shim.h"
 
 #define CBMA_PAGES 1024
@@ -11,9 +12,9 @@ uint32_t cbma_top;
 void init_cbma(int fd)
 {
        cbma_bottom = alloc_gpu_pages(fd, CBMA_PAGES,
-                       BASE_MEM_PROT_CPU_RD | BASE_MEM_PROT_CPU_WR |
-                       BASE_MEM_PROT_GPU_RD | BASE_MEM_PROT_GPU_WR |
-                       BASE_MEM_SAME_VA); cbma_top = cbma_bottom;
+                       MALI_MEM_PROT_CPU_RD | MALI_MEM_PROT_CPU_WR |
+                       MALI_MEM_PROT_GPU_RD | MALI_MEM_PROT_GPU_WR |
+                       MALI_MEM_SAME_VA); cbma_top = cbma_bottom;
        memset((void*) cbma_bottom, 0, CBMA_PAGES << PAGE_SHIFT);
 }
 
index d960e7b3a9e776b3bb4cd60027159306938961de..c04139b0a692d1de736c59fdf0153a1081f03f00 100644 (file)
@@ -24,6 +24,8 @@ int main()
        uint64_t scratchpad = alloc_gpu_pages(fd, 8, 0xC);
        uint64_t heap_free_address = alloc_gpu_heap(fd, 0x8000);        
 
+       printf("Allocated what we need..\n");
+
        // size_t fb_size = 29 * 16 * 45 * 16 * 4 * 2;
        // uint64_t framebuffer = (uint64_t) (uint32_t) galloc(fb_size);
        
@@ -37,6 +39,8 @@ int main()
                0.0, 1.0, 0.0
        };
 
+       printf("Tiling...\n");
+
        uint32_t tiler_jc =
                job_chain_vertex_tiler(fd,
                        vertices, sizeof(vertices), CHAI_TRIANGLE_FAN,
@@ -44,10 +48,14 @@ int main()
                        sample_fragment, sizeof(sample_fragment),
                        heap_free_address, scratchpad);
 
+       printf("Fragging...\n");
+
        uint32_t fragment_jc = job_chain_fragment(fd, framebuffer, heap_free_address, scratchpad);
 
        job_chain_replay(fd, tiler_jc, fragment_jc, heap_free_address, framebuffer);
+       printf("Syncing...\n");
        sync_cbma(fd);
+       printf("Submitting...\n");
        flush_job_queue(fd);
 
        sleep(3);
index 2e280c4f260dbef449b1b65d84f2481e65f29b02..94229c0701d0fbe179b84894192e130cc259b519 100644 (file)
@@ -19,10 +19,12 @@ int ioctl(int fd, int request, ...);
 
 #include "shim.h"
 
-#define m_ioctl(fd, data, no) \
-       data.header.id = no; \
-       if(ioctl(fd, _IOC(_IOC_READ | _IOC_WRITE, 0x82, 0, sizeof(data)), &data)) { \
-               printf("Bad ioctl %d (%s)\n", no, strerror(errno)); \
+#include <mali-ioctl.h>
+
+#define m_ioctl(fd, data, ioc) \
+       data.header.id = ((_IOC_TYPE(ioc) & 0xF) << 8) | _IOC_NR(ioc); \
+       if(ioctl(fd, ioc, &data)) { \
+               printf("Bad ioctl %d (%s)\n", ioc, strerror(errno)); \
                exit(1); \
        }
 
@@ -37,17 +39,17 @@ int open_kernel_module()
 
        /* Declare the ABI version (handshake 1/3) */
 
-       struct uku_version_check_args check = {
-               .major = /* BASE_UK_VERSION_MAJOR */ 0x8,
-               .minor = /* BASE_UK_VERSION_MINOR */ 0x0,
+       struct mali_ioctl_get_version check = {
+               .major = /* MALI_UK_VERSION_MAJOR */ 0x8,
+               .minor = /* MALI_UK_VERSION_MINOR */ 0x4,
        };
 
-       m_ioctl(fd, check, UKP_FUNC_ID_CHECK_VERSION);
+       m_ioctl(fd, check, MALI_IOCTL_GET_VERSION);
 
        /* Map the Memmap Tracking Handle (handshake 2/3) */
 
        uint8_t *mtp = mmap(NULL, PAGE_SIZE, PROT_NONE, MAP_SHARED, fd,
-                               BASE_MEM_MAP_TRACKING_HANDLE);
+                               MALI_MEM_MAP_TRACKING_HANDLE);
 
        if(mtp == MAP_FAILED) {
                printf("MP map failed (%s)\n", strerror(errno));
@@ -56,18 +58,18 @@ int open_kernel_module()
 
        /* Declare special flags (handshake 3/3) */
 
-       struct kbase_uk_set_flags flags = {
-               .create_flags = BASE_CONTEXT_CREATE_FLAG_NONE
+       struct mali_ioctl_set_flags flags = {
+               .create_flags = MALI_CONTEXT_CREATE_FLAG_NONE
        };
 
-       m_ioctl(fd, flags, KBASE_FUNC_SET_FLAGS);
+       m_ioctl(fd, flags, MALI_IOCTL_SET_FLAGS);
 
        return fd;
 }
 
 uint64_t alloc_gpu_pages(int fd, int pages, int e_flags)
 {
-       struct kbase_uk_mem_alloc alloc = {
+       struct mali_ioctl_mem_alloc alloc = {
                .va_pages = pages,
                .commit_pages = pages,
                .extent = 0,
@@ -76,13 +78,13 @@ uint64_t alloc_gpu_pages(int fd, int pages, int e_flags)
 
        printf("Allocing %d pages flag %X to %d\n", pages, e_flags, fd);
 
-       m_ioctl(fd, alloc, KBASE_FUNC_MEM_ALLOC);
+       m_ioctl(fd, alloc, MALI_IOCTL_MEM_ALLOC);
 
        // return alloc.gpu_va;
 
        /* Only necessary when we report old versions */
 
-       if(e_flags & BASE_MEM_SAME_VA)  {
+       if(e_flags & MALI_MEM_SAME_VA)  {
                return (uint32_t) mmap(NULL, pages << PAGE_SHIFT, PROT_READ | PROT_WRITE, MAP_SHARED, fd, alloc.gpu_va);
        } else {
                return alloc.gpu_va;
@@ -91,54 +93,50 @@ uint64_t alloc_gpu_pages(int fd, int pages, int e_flags)
 
 uint64_t alloc_gpu_heap(int fd, int pages)
 {
-       struct kbase_uk_mem_alloc alloc = {
+       struct mali_ioctl_mem_alloc alloc = {
                .va_pages = pages,
                .commit_pages = 1,
                .extent = 0x80,
                .flags = 0x26F
        };
 
-       m_ioctl(fd, alloc, KBASE_FUNC_MEM_ALLOC);
+       m_ioctl(fd, alloc, MALI_IOCTL_MEM_ALLOC);
 
        return alloc.gpu_va;
 }
 
 void free_gpu(int fd, uint64_t addr)
 {
-       struct kbase_uk_mem_free gfree = { .gpu_addr = addr };
-       m_ioctl(fd, gfree, KBASE_FUNC_MEM_FREE);
+       struct mali_ioctl_mem_free gfree = { .gpu_addr = addr };
+       m_ioctl(fd, gfree, MALI_IOCTL_MEM_FREE);
 }
 
 void sync_gpu(int fd, uint8_t* cpu, uint64_t gpu, size_t bytes)
 {
-       struct basep_syncset base_sset = {
-               .mem_handle = { .basep = { .handle = gpu & PAGE_MASK } },
-               .user_addr = (u64) (uintptr_t) cpu - (gpu & ~PAGE_MASK),
+       struct mali_ioctl_sync sync = {
+               .handle = gpu & PAGE_MASK,
+               .user_addr = cpu - (gpu & ~PAGE_MASK),
                .size = (gpu & ~PAGE_MASK) + bytes,
-               .type = BASE_SYNCSET_OP_MSYNC
-       };
-
-       struct kbase_uk_sync_now sync = {
-               .sset = { .basep_sset = base_sset}
+               .type = MALI_SYNC_TO_DEVICE
        };
 
-       m_ioctl(fd, sync, KBASE_FUNC_SYNC);
+       m_ioctl(fd, sync, MALI_IOCTL_SYNC);
 }
 
-static void submit_job_internal(int fd, struct base_jd_atom_v2 *atoms, size_t count)
+static void submit_job_internal(int fd, struct mali_jd_atom_v2 *atoms, size_t count)
 {
-       struct kbase_uk_job_submit submit = {
-               .addr = { .value = atoms },
+       struct mali_ioctl_job_submit submit = {
+               .addr = atoms,
                .nr_atoms = count,
-               .stride = sizeof(struct base_jd_atom_v2)
+               .stride = sizeof(struct mali_jd_atom_v2)
        };
        
-       m_ioctl(fd, submit, KBASE_FUNC_JOB_SUBMIT);
+       m_ioctl(fd, submit, MALI_IOCTL_JOB_SUBMIT);
 }
 
 #define ATOM_QUEUE_MAX 16
 
-struct base_jd_atom_v2 atom_queue[ATOM_QUEUE_MAX];
+struct mali_jd_atom_v2 atom_queue[ATOM_QUEUE_MAX];
 int atom_queue_size = 0;
 
 void flush_job_queue(int fd)
@@ -146,10 +144,12 @@ void flush_job_queue(int fd)
        if(atom_queue_size) {
                submit_job_internal(fd, atom_queue, atom_queue_size);
                atom_queue_size = 0;
+       } else {
+               printf("Warning... flushing job queue with no atoms\n");
        }
 }
 
-void submit_job(int fd, struct base_jd_atom_v2 atom)
+void submit_job(int fd, struct mali_jd_atom_v2 atom)
 {
        memcpy(&atom_queue[atom_queue_size++], &atom, sizeof(atom));
 
@@ -177,14 +177,14 @@ uint8_t* mmap_gpu(int fd, uint64_t addr, int page_count)
 
 void stream_create(int fd, char *stream)
 {
-       struct kbase_uk_stream_create s;
+       struct mali_ioctl_stream_create s;
        strcpy(s.name, stream);
-       m_ioctl(fd, s, KBASE_FUNC_STREAM_CREATE);
+       m_ioctl(fd, s, MALI_IOCTL_STREAM_CREATE);
 }
 
 
 void query_gpu_props(int fd)
 {
-       struct kbase_uk_gpuprops v;
-       m_ioctl(fd, v, KBASE_FUNC_GPU_PROPS_REG_DUMP);
+       struct mali_ioctl_gpu_props_reg_dump v;
+       m_ioctl(fd, v, MALI_IOCTL_GPU_PROPS_REG_DUMP);
 }
index 916b8d6187a22d5555aeb2838216920b842e15ca..e9aedfb8f29e235c519a0acb735dd36d4c6b53aa 100644 (file)
@@ -7,6 +7,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <mali-ioctl.h>
 
 typedef int8_t s8;
 typedef int16_t s16;
@@ -25,9 +26,6 @@ typedef uint64_t u64;
 #define PAGE_SIZE      (1 << PAGE_SHIFT)
 #define PAGE_MASK      (~(PAGE_SIZE - 1))
 
-/* Include the shim directly. */
-#include "../../oolong/mali_kbase_uku.h"
-
 /* Include definitions for thin chai wrappers */
 
 int open_kernel_module();
@@ -35,7 +33,7 @@ uint64_t alloc_gpu_pages(int fd, int pages, int e_flags);
 uint64_t alloc_gpu_heap(int fd, int pages);
 void free_gpu(int fd, uint64_t addr);
 void sync_gpu(int fd, uint8_t* cpu, uint64_t gpu, size_t size);
-void submit_job(int fd, struct base_jd_atom_v2 atom);
+void submit_job(int fd, struct mali_jd_atom_v2 atom);
 void flush_job_queue(int fd);
 uint8_t* mmap_gpu(int fd, uint64_t addr, int page_count);
 void stream_create(int fd, char *stream);
index 921f858efff1c9bd44dfb6c75c9cea895538e9f5..87178e79aaa1d4124ecc88003c77604de6a5cfcc 100644 (file)
@@ -14,6 +14,7 @@
  */
 
 #include "synthesise.h"
+#include <mali-ioctl.h>
 
 #include <stdlib.h>
 #include <memory.h>
@@ -26,9 +27,9 @@
 
 int atom_count = 0;
 
-struct base_dependency no_dependency = {
+struct mali_jd_dependency no_dependency = {
        .atom_id = 0,
-       .dependency_type = BASE_JD_DEP_TYPE_INVALID
+       .dependency_type = MALI_JD_DEP_TYPE_INVALID
 };
 
 struct job_descriptor_header* set_value_helper(int fd, uint64_t out)
@@ -124,23 +125,23 @@ uint32_t job_chain_fragment(int fd, uint64_t framebuffer,
        memcpy(packet + sizeof(header), &payload, sizeof(payload));
        sync_gpu(fd, packet, (uint32_t) packet, sizeof(header) + sizeof(payload));
 
-       struct base_dependency depTiler = {
+       struct mali_jd_dependency depTiler = {
                .atom_id = atom_count /* last one */,
-               .dependency_type = BASE_JD_DEP_TYPE_DATA
+               .dependency_type = MALI_JD_DEP_TYPE_DATA
        };
 
        uint64_t* resource = calloc(sizeof(u64), 1);
-       resource[0] = framebuffer | BASE_EXT_RES_ACCESS_EXCLUSIVE;
+       resource[0] = framebuffer | MALI_EXT_RES_ACCESS_EXCLUSIVE;
 
        /* TODO: free resource */
 
-       struct base_jd_atom_v2 job = {
+       struct mali_jd_atom_v2 job = {
                .jc = (uint32_t) packet,
-               .extres_list = resource,
-               .nr_extres = 1,
-               .core_req = BASE_JD_REQ_EXTERNAL_RESOURCES | BASE_JD_REQ_FS,
+               .ext_res_list = (struct mali_external_resource*) resource /* TODO */,
+               .nr_ext_res = 1,
+               .core_req = MALI_JD_REQ_EXTERNAL_RESOURCES | MALI_JD_REQ_FS,
                .atom_number = ++atom_count,
-               .prio = BASE_JD_PRIO_MEDIUM,
+               .prio = MALI_JD_PRIO_MEDIUM,
                .device_nr = 0,
                .pre_dep = { depTiler, no_dependency }
        };
@@ -154,9 +155,9 @@ uint64_t import_shader(int fd, uint8_t *shader, size_t sz, bool fragment)
 {
        int pages = 1 + (sz >> PAGE_SHIFT);
 
-       uint64_t gpu = alloc_gpu_pages(fd, pages, BASE_MEM_PROT_CPU_RD |
-                       BASE_MEM_PROT_CPU_WR | BASE_MEM_PROT_GPU_RD |
-                       BASE_MEM_PROT_GPU_EX);
+       uint64_t gpu = alloc_gpu_pages(fd, pages, MALI_MEM_PROT_CPU_RD |
+                       MALI_MEM_PROT_CPU_WR | MALI_MEM_PROT_GPU_RD |
+                       MALI_MEM_PROT_GPU_EX);
 
        uint8_t *cpu = mmap_gpu(fd, gpu, pages);
 
@@ -366,8 +367,8 @@ uint32_t job_chain_vertex_tiler(int fd,
        uint32_t vertex_fbd = (uint32_t) make_mfbd(true, heap_free_address, scratchpad);
 
        uint32_t zero_buffer = (uint32_t) alloc_gpu_pages(fd, 0x20,
-                       0x3800 | BASE_MEM_PROT_CPU_RD |
-                       BASE_MEM_PROT_CPU_WR | BASE_MEM_PROT_GPU_RD);
+                       0x3800 | MALI_MEM_PROT_CPU_RD |
+                       MALI_MEM_PROT_CPU_WR | MALI_MEM_PROT_GPU_RD);
 
        sync_gpu(fd, (void*) zero_buffer, zero_buffer, 0x20 << PAGE_SHIFT);
 
@@ -396,14 +397,14 @@ uint32_t job_chain_vertex_tiler(int fd,
        vertex->job_dependency_index_2 = set->job_index;
        tiler->job_dependency_index_1 = vertex->job_index;
 
-       struct base_jd_atom_v2 job = {
+       struct mali_jd_atom_v2 job = {
                .jc = (uint32_t) set,
-               .extres_list = NULL,
-               .nr_extres = 0,
-               .core_req = BASE_JD_REQ_CS | BASE_JD_REQ_T
-                       | BASE_JD_REQ_CF | BASE_JD_REQ_COHERENT_GROUP,
+               .ext_res_list = NULL,
+               .nr_ext_res = 0,
+               .core_req = MALI_JD_REQ_CS | MALI_JD_REQ_T
+                       | MALI_JD_REQ_CF | MALI_JD_REQ_COHERENT_GROUP,
                .atom_number = ++atom_count,
-               .prio = BASE_JD_PRIO_MEDIUM,
+               .prio = MALI_JD_PRIO_MEDIUM,
                .device_nr = 0,
                .pre_dep = { no_dependency, no_dependency }
        };
@@ -416,9 +417,9 @@ uint32_t job_chain_vertex_tiler(int fd,
 void job_chain_replay(int fd, uint32_t tiler_jc, uint32_t fragment_jc,
                uint64_t heap_free_address, uint64_t framebuffer)
 {
-       struct base_jd_replay_payload *payload;
+       struct mali_jd_replay_payload *payload;
 
-       payload = (struct base_jd_replay_payload*) galloc(sizeof(*payload));
+       payload = (struct mali_jd_replay_payload*) galloc(sizeof(*payload));
 
        payload->tiler_jc_list = tiler_jc;
        payload->fragment_jc = fragment_jc;
@@ -426,24 +427,24 @@ void job_chain_replay(int fd, uint32_t tiler_jc, uint32_t fragment_jc,
        payload->fragment_hierarchy_mask = 0;
        payload->tiler_hierarchy_mask = 0;
        payload->hierarchy_default_weight = 0x10000;
-       payload->tiler_core_req = BASE_JD_REQ_T | BASE_JD_REQ_COHERENT_GROUP;
-       payload->fragment_core_req = BASE_JD_REQ_FS;
+       payload->tiler_core_req = MALI_JD_REQ_T | MALI_JD_REQ_COHERENT_GROUP;
+       payload->fragment_core_req = MALI_JD_REQ_FS;
 
-       struct base_dependency depFragment = {
+       struct mali_jd_dependency depFragment = {
                .atom_id = atom_count,
-               .dependency_type = BASE_JD_DEP_TYPE_DATA
+               .dependency_type = MALI_JD_DEP_TYPE_DATA
        };
 
        uint64_t* resource = malloc(sizeof(u64) * 1);
-       resource[0] = framebuffer | BASE_EXT_RES_ACCESS_EXCLUSIVE;
+       resource[0] = framebuffer | MALI_EXT_RES_ACCESS_EXCLUSIVE;
 
-       struct base_jd_atom_v2 job = {
+       struct mali_jd_atom_v2 job = {
                .jc = (uint32_t) payload,
-               .extres_list = resource,
-               .nr_extres = 1,
-               .core_req = BASE_JD_REQ_EXTERNAL_RESOURCES | BASE_JD_REQ_SOFT_REPLAY,
+               .ext_res_list = (struct mali_external_resource*)resource,
+               .nr_ext_res = 1,
+               .core_req = MALI_JD_REQ_EXTERNAL_RESOURCES | MALI_JD_REQ_SOFT_REPLAY,
                .atom_number = ++atom_count,
-               .prio = BASE_JD_PRIO_LOW,
+               .prio = MALI_JD_PRIO_LOW,
                .device_nr = 0,
                .pre_dep = { depFragment, no_dependency }
        };
index aea4fd17a515fe8f937d52b99b794f67210d2cbe..e65829aabbf430a6cd8b6bd771b0e2a7bf240682 100644 (file)
@@ -220,7 +220,7 @@ static void chai_trace_vecN(float *p, size_t count)
                panwrap_log("Cannot print vec%d\n", count);
 }
 
-#include "shim.c"
+//#include "shim.c"
 
 static void chai_trace_attribute(uint64_t address)
 {