static int callCompute_Linux() { Mx_Compute *compute = NULL; int drmFd = 0; struct omap_device *dev = NULL; struct omap_bo *compute_bo = NULL; struct omap_bo *inBuf_bo = NULL; struct omap_bo *outBuf_bo = NULL; uint32_t * inBufPtr = NULL; uint32_t * outBufPtr = NULL; int status = 0; int size; uint32_t val; int i; int32_t ret; /* On Linux, use omapdrm driver to get a Tiler buffer for shared memory */ drmFd = drmOpen("omapdrm", NULL); if (drmFd < 0) { fprintf(stderr, "could not open omapdrm device: %d: %s\n", errno, strerror(errno)); return 1; } dev = omap_device_new(drmFd); if (!dev) { fprintf(stderr, "could not get device from fd\n"); goto leave; } /* allocate a compute structure in shared memory and get a pointer */ compute_bo = omap_bo_new(dev, sizeof(Mx_Compute), OMAP_BO_CACHED); if (compute_bo) { compute = (Mx_Compute *)omap_bo_map(compute_bo); } else { fprintf(stderr, "failed to allocate omap_bo\n"); } if (compute == NULL) { fprintf(stderr, "failed to map omap_bo to user space\n"); goto leave; } /* initialize compute structure */ compute->coef = 0x80400000; compute->key = 0xABA0; compute->size = 0x1000; compute->inBuf = NULL; compute->outBuf = NULL; /* allocate an input buffer in shared memory */ size = compute->size * sizeof(uint32_t); inBuf_bo = omap_bo_new(dev, size, OMAP_BO_CACHED); if (inBuf_bo) { inBufPtr = (uint32_t *)omap_bo_map(inBuf_bo); } else { fprintf(stderr, "failed to allocate inBuf_bo\n"); } if (inBufPtr == NULL) { printf("mmrpc_test: Error: inBufPtr == NULL\n"); status = -1; goto leave; } /* fill input buffer with seed value */ for (i = 0; i < compute->size; i++) { inBufPtr[i] = 0x2010; } /* allocate an output buffer in shared memory */ outBuf_bo = omap_bo_new(dev, size, OMAP_BO_CACHED); if (outBuf_bo) { outBufPtr = (uint32_t *)omap_bo_map(outBuf_bo); } else { fprintf(stderr, "failed to allocate outBuf_bo handle\n"); } if (outBufPtr == NULL) { printf("mmrpc_test: Error: outBufPtr == NULL\n"); status = -1; goto leave; } /* clear output buffer */ for (i = 0; i < compute->size; i++) { outBufPtr[i] = 0; } compute->inBuf = (uint32_t *)inBufPtr; compute->outBuf = (uint32_t *)outBufPtr; /* print some debug info */ printf("mmrpc_test: calling Mx_compute(0x%x)\n", (unsigned int)compute); printf("mmrpc_test: compute->coef=0x%x\n", compute->coef); printf("mmrpc_test: compute->key=0x%x\n", compute->key); printf("mmrpc_test: compute->size=0x%x\n", compute->size); printf("mmrpc_test: compute->inBuf=0x%x\n", (unsigned int)compute->inBuf); printf("mmrpc_test: compute->outBuf=0x%x\n", (unsigned int)compute->outBuf); /* process the buffer */ ret = Mx_compute_Linux(compute, omap_bo_dmabuf(compute_bo), omap_bo_dmabuf(inBuf_bo), omap_bo_dmabuf(outBuf_bo)); if (ret < 0) { status = -1; printf("mmrpc_test: Error: Mx_Compute() failed\n"); goto leave; } printf("mmrpc_test: after Mx_compute(0x%x)\n", (unsigned int)compute); printf("mmrpc_test: compute->coef=0x%x\n", compute->coef); printf("mmrpc_test: compute->key=0x%x\n", compute->key); printf("mmrpc_test: compute->size=0x%x\n", compute->size); printf("mmrpc_test: compute->inBuf=0x%x\n", (unsigned int)compute->inBuf); printf("mmrpc_test: compute->outBuf=0x%x\n", (unsigned int)compute->outBuf); printf("mmrpc_test: compute->inBuf[0]=0x%x\n", (unsigned int)compute->inBuf[0]); printf("mmrpc_test: compute->outBuf[0]=0x%x\n", (unsigned int)compute->outBuf[0]); /* check the output buffer */ for (i = 0; i < compute->size; i++) { val = outBufPtr[i] | compute->coef; if (outBufPtr[i] != val) { status = -1; printf("mmrpc_test: Error: incorrect outBuf\n"); break; } } leave: if (outBuf_bo) { omap_bo_del(outBuf_bo); } if (inBuf_bo) { omap_bo_del(inBuf_bo); } if (compute_bo) { omap_bo_del(compute_bo); } if (dev) { omap_device_del(dev); } if (drmFd) { close(drmFd); } return (status); }
/* get buffer info */ static int get_buffer_info(struct omap_bo *bo) { struct drm_omap_gem_info req = { .handle = bo->handle, }; int ret = drmCommandWriteRead(bo->dev->fd, DRM_OMAP_GEM_INFO, &req, sizeof(req)); if (ret) { return ret; } /* really all we need for now is mmap offset */ bo->offset = req.offset; bo->size = req.size; return 0; } /* import a buffer object from DRI2 name */ drm_public struct omap_bo * omap_bo_from_name(struct omap_device *dev, uint32_t name) { struct omap_bo *bo = NULL; struct drm_gem_open req = { .name = name, }; pthread_mutex_lock(&table_lock); if (drmIoctl(dev->fd, DRM_IOCTL_GEM_OPEN, &req)) { goto fail; } bo = lookup_bo(dev, req.handle); if (!bo) { bo = bo_from_handle(dev, req.handle); bo->name = name; } pthread_mutex_unlock(&table_lock); return bo; fail: pthread_mutex_unlock(&table_lock); free(bo); return NULL; } /* import a buffer from dmabuf fd, does not take ownership of the * fd so caller should close() the fd when it is otherwise done * with it (even if it is still using the 'struct omap_bo *') */ drm_public struct omap_bo * omap_bo_from_dmabuf(struct omap_device *dev, int fd) { struct omap_bo *bo = NULL; struct drm_prime_handle req = { .fd = fd, }; int ret; pthread_mutex_lock(&table_lock); ret = drmIoctl(dev->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &req); if (ret) { goto fail; } bo = lookup_bo(dev, req.handle); if (!bo) { bo = bo_from_handle(dev, req.handle); } pthread_mutex_unlock(&table_lock); return bo; fail: pthread_mutex_unlock(&table_lock); free(bo); return NULL; } /* destroy a buffer object */ drm_public void omap_bo_del(struct omap_bo *bo) { if (!bo) { return; } if (!atomic_dec_and_test(&bo->refcnt)) return; if (bo->map) { munmap(bo->map, bo->size); } if (bo->fd >= 0) { close(bo->fd); } if (bo->handle) { struct drm_gem_close req = { .handle = bo->handle, }; pthread_mutex_lock(&table_lock); drmHashDelete(bo->dev->handle_table, bo->handle); drmIoctl(bo->dev->fd, DRM_IOCTL_GEM_CLOSE, &req); pthread_mutex_unlock(&table_lock); } omap_device_del(bo->dev); free(bo); } /* get the global flink/DRI2 buffer name */ drm_public int omap_bo_get_name(struct omap_bo *bo, uint32_t *name) { if (!bo->name) { struct drm_gem_flink req = { .handle = bo->handle, }; int ret; ret = drmIoctl(bo->dev->fd, DRM_IOCTL_GEM_FLINK, &req); if (ret) { return ret; } bo->name = req.name; } *name = bo->name; return 0; } drm_public uint32_t omap_bo_handle(struct omap_bo *bo) { return bo->handle; } /* caller owns the dmabuf fd that is returned and is responsible * to close() it when done */ drm_public int omap_bo_dmabuf(struct omap_bo *bo) { if (bo->fd < 0) { struct drm_prime_handle req = { .handle = bo->handle, .flags = DRM_CLOEXEC, }; int ret; ret = drmIoctl(bo->dev->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &req); if (ret) { return ret; } bo->fd = req.fd; } return dup(bo->fd); } drm_public uint32_t omap_bo_size(struct omap_bo *bo) { if (!bo->size) { get_buffer_info(bo); } return bo->size; } drm_public void *omap_bo_map(struct omap_bo *bo) { if (!bo->map) { if (!bo->offset) { get_buffer_info(bo); } bo->map = mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED, bo->dev->fd, bo->offset); if (bo->map == MAP_FAILED) { bo->map = NULL; } } return bo->map; } drm_public int omap_bo_cpu_prep(struct omap_bo *bo, enum omap_gem_op op) { struct drm_omap_gem_cpu_prep req = { .handle = bo->handle, .op = op, }; return drmCommandWrite(bo->dev->fd, DRM_OMAP_GEM_CPU_PREP, &req, sizeof(req)); } drm_public int omap_bo_cpu_fini(struct omap_bo *bo, enum omap_gem_op op) { struct drm_omap_gem_cpu_fini req = { .handle = bo->handle, .op = op, .nregions = 0, }; return drmCommandWrite(bo->dev->fd, DRM_OMAP_GEM_CPU_FINI, &req, sizeof(req)); }