}
req.cfgs[i] = FIELD_PREP(AIE2_MSG_CFG_CU_PDI_ADDR,
- abo->mem.dev_addr >> shift);
+ amdxdna_gem_dev_addr(abo) >> shift);
req.cfgs[i] |= FIELD_PREP(AIE2_MSG_CFG_CU_FUNC, cu->cu_func);
XDNA_DBG(xdna, "CU %d full addr 0x%llx, cfg 0x%x", i,
- abo->mem.dev_addr, req.cfgs[i]);
+ amdxdna_gem_dev_addr(abo), req.cfgs[i]);
drm_gem_object_put(gobj);
}
req.num_cus = hwctx->cus->num_cus;
struct mailbox_channel *chann = hwctx->priv->mbox_chann;
struct amdxdna_client *client = hwctx->client;
struct amdxdna_gem_obj *cmd_abo = job->cmd_bo;
+ void *cmd_buf = amdxdna_gem_vmap(cmdbuf_abo);
struct amdxdna_dev *xdna = client->xdna;
struct amdxdna_cmd_chain *payload;
struct xdna_mailbox_msg msg;
u32 op;
u32 i;
+ if (!cmd_buf)
+ return -ENOMEM;
+
op = amdxdna_cmd_get_op(cmd_abo);
payload = amdxdna_cmd_get_payload(cmd_abo, &payload_len);
if (op != ERT_CMD_CHAIN) {
u32 boh = (u32)(payload->data[i]);
struct amdxdna_gem_obj *abo;
- abo = amdxdna_gem_get_obj(client, boh, AMDXDNA_BO_CMD);
+ abo = amdxdna_gem_get_obj(client, boh, AMDXDNA_BO_SHARE);
if (!abo) {
XDNA_ERR(xdna, "Failed to find cmd BO %d", boh);
return -ENOENT;
}
size = cmdbuf_abo->mem.size - offset;
- ret = aie2_cmdlist_fill_slot(cmdbuf_abo->mem.kva + offset,
- abo, &size, &op);
+ ret = aie2_cmdlist_fill_slot(cmd_buf + offset, abo, &size, &op);
amdxdna_gem_put_obj(abo);
if (ret)
return ret;
XDNA_DBG(xdna, "Total %d commands:", ccnt);
print_hex_dump_debug("cmdbufs: ", DUMP_PREFIX_OFFSET, 16, 4,
- cmdbuf_abo->mem.kva, offset, false);
+ cmd_buf, offset, false);
msg.opcode = EXEC_MSG_OPS(xdna)->get_chain_msg_op(op);
if (msg.opcode == MSG_OP_MAX_OPCODE)
return -EOPNOTSUPP;
/* The offset is the accumulated total size of the cmd buffer */
- EXEC_MSG_OPS(xdna)->init_chain_req(&req, cmdbuf_abo->mem.dev_addr,
+ EXEC_MSG_OPS(xdna)->init_chain_req(&req, amdxdna_gem_dev_addr(cmdbuf_abo),
offset, ccnt);
- drm_clflush_virt_range(cmdbuf_abo->mem.kva, offset);
+ drm_clflush_virt_range(cmd_buf, offset);
msg.handle = job;
msg.notify_cb = notify_cb;
struct mailbox_channel *chann = hwctx->priv->mbox_chann;
struct amdxdna_dev *xdna = hwctx->client->xdna;
struct amdxdna_gem_obj *cmd_abo = job->cmd_bo;
+ void *cmd_buf = amdxdna_gem_vmap(cmdbuf_abo);
struct xdna_mailbox_msg msg;
union exec_chain_req req;
u32 op = ERT_INVALID_CMD;
size_t size;
int ret;
+ if (!cmd_buf)
+ return -ENOMEM;
+
size = cmdbuf_abo->mem.size;
- ret = aie2_cmdlist_fill_slot(cmdbuf_abo->mem.kva, cmd_abo, &size, &op);
+ ret = aie2_cmdlist_fill_slot(cmd_buf, cmd_abo, &size, &op);
if (ret)
return ret;
- print_hex_dump_debug("cmdbuf: ", DUMP_PREFIX_OFFSET, 16, 4,
- cmdbuf_abo->mem.kva, size, false);
+ print_hex_dump_debug("cmdbuf: ", DUMP_PREFIX_OFFSET, 16, 4, cmd_buf, size, false);
msg.opcode = EXEC_MSG_OPS(xdna)->get_chain_msg_op(op);
if (msg.opcode == MSG_OP_MAX_OPCODE)
return -EOPNOTSUPP;
- EXEC_MSG_OPS(xdna)->init_chain_req(&req, cmdbuf_abo->mem.dev_addr,
- size, 1);
- drm_clflush_virt_range(cmdbuf_abo->mem.kva, size);
+ EXEC_MSG_OPS(xdna)->init_chain_req(&req, amdxdna_gem_dev_addr(cmdbuf_abo), size, 1);
+ drm_clflush_virt_range(cmd_buf, size);
msg.handle = job;
msg.notify_cb = notify_cb;
struct amdxdna_dev *xdna = client->xdna;
struct amdxdna_mem *mem = &abo->mem;
struct amdxdna_gem_obj *heap;
- u64 offset;
u32 align;
int ret;
goto unlock_out;
}
- if (heap->mem.userptr == AMDXDNA_INVALID_ADDR) {
+ if (amdxdna_gem_uva(heap) == AMDXDNA_INVALID_ADDR) {
XDNA_ERR(xdna, "Invalid dev heap userptr");
ret = -EINVAL;
goto unlock_out;
goto unlock_out;
}
- mem->dev_addr = abo->mm_node.start;
- offset = mem->dev_addr - heap->mem.dev_addr;
- mem->userptr = heap->mem.userptr + offset;
- mem->kva = heap->mem.kva + offset;
-
drm_gem_object_get(to_gobj(heap));
unlock_out:
return ret;
}
-static void
-amdxdna_gem_destroy_obj(struct amdxdna_gem_obj *abo)
-{
- mutex_destroy(&abo->lock);
- kfree(abo);
-}
-
static void
amdxdna_gem_heap_free(struct amdxdna_gem_obj *abo)
{
mutex_unlock(&abo->client->mm_lock);
}
+static struct amdxdna_gem_obj *
+amdxdna_gem_create_obj(struct drm_device *dev, size_t size)
+{
+ struct amdxdna_gem_obj *abo;
+
+ abo = kzalloc_obj(*abo);
+ if (!abo)
+ return ERR_PTR(-ENOMEM);
+
+ abo->pinned = false;
+ abo->assigned_hwctx = AMDXDNA_INVALID_CTX_HANDLE;
+ mutex_init(&abo->lock);
+
+ abo->mem.dma_addr = AMDXDNA_INVALID_ADDR;
+ abo->mem.uva = AMDXDNA_INVALID_ADDR;
+ abo->mem.size = size;
+ INIT_LIST_HEAD(&abo->mem.umap_list);
+
+ return abo;
+}
+
+static void
+amdxdna_gem_destroy_obj(struct amdxdna_gem_obj *abo)
+{
+ mutex_destroy(&abo->lock);
+ kfree(abo);
+}
+
+/*
+ * Obtains a kernel virtual address on the BO (usually of small size).
+ * The mapping is established on the first call and stays valid until
+ * amdxdna_gem_vunmap() is called.
+ */
+void *amdxdna_gem_vmap(struct amdxdna_gem_obj *abo)
+{
+ struct iosys_map map = IOSYS_MAP_INIT_VADDR(NULL);
+ int ret;
+
+ if (abo->mem.kva)
+ return abo->mem.kva;
+
+ /* The first call to get the kva, taking slow path. */
+ guard(mutex)(&abo->lock);
+
+ if (!abo->mem.kva) {
+ ret = drm_gem_vmap(to_gobj(abo), &map);
+ if (ret)
+ XDNA_ERR(abo->client->xdna, "Vmap bo failed, ret %d", ret);
+ else
+ abo->mem.kva = map.vaddr;
+ }
+ return abo->mem.kva;
+}
+
+/*
+ * Free mapping established through amdxdna_gem_vmap()
+ */
+static void amdxdna_gem_vunmap(struct amdxdna_gem_obj *abo)
+{
+ guard(mutex)(&abo->lock);
+
+ if (abo->mem.kva) {
+ struct iosys_map map = IOSYS_MAP_INIT_VADDR(abo->mem.kva);
+
+ drm_gem_vunmap(to_gobj(abo), &map);
+ abo->mem.kva = NULL;
+ }
+}
+
+/*
+ * Obtain the user virtual address for accessing the BO.
+ * It can be used for device to access the BO when PASID is enabled.
+ */
+u64 amdxdna_gem_uva(struct amdxdna_gem_obj *abo)
+{
+ if (abo->type == AMDXDNA_BO_DEV) {
+ struct amdxdna_gem_obj *heap = abo->client->dev_heap;
+ u64 off = amdxdna_dev_bo_offset(abo);
+
+ if (amdxdna_gem_uva(heap) != AMDXDNA_INVALID_ADDR)
+ return amdxdna_gem_uva(heap) + off;
+ return AMDXDNA_INVALID_ADDR;
+ }
+
+ return abo->mem.uva;
+}
+
+/*
+ * Obtain the address for device to access the BO.
+ */
+u64 amdxdna_gem_dev_addr(struct amdxdna_gem_obj *abo)
+{
+ if (abo->type == AMDXDNA_BO_DEV_HEAP)
+ return abo->client->xdna->dev_info->dev_mem_base;
+ if (abo->type == AMDXDNA_BO_DEV)
+ return abo->mm_node.start;
+ return amdxdna_obj_dma_addr(abo);
+}
+
static bool amdxdna_hmm_invalidate(struct mmu_interval_notifier *mni,
const struct mmu_notifier_range *range,
unsigned long cur_seq)
static void amdxdna_umap_release(struct kref *ref)
{
struct amdxdna_umap *mapp = container_of(ref, struct amdxdna_umap, refcnt);
+ struct amdxdna_gem_obj *abo = mapp->abo;
struct vm_area_struct *vma = mapp->vma;
struct amdxdna_dev *xdna;
mmu_interval_notifier_remove(&mapp->notifier);
- if (is_import_bo(mapp->abo) && vma->vm_file && vma->vm_file->f_mapping)
+ if (is_import_bo(abo) && vma->vm_file && vma->vm_file->f_mapping)
mapping_clear_unevictable(vma->vm_file->f_mapping);
xdna = to_xdna_dev(to_gobj(mapp->abo)->dev);
down_write(&xdna->notifier_lock);
list_del(&mapp->node);
+ if (list_empty(&abo->mem.umap_list))
+ abo->mem.uva = AMDXDNA_INVALID_ADDR;
up_write(&xdna->notifier_lock);
kvfree(mapp->range.hmm_pfns);
mapp->abo = abo;
kref_init(&mapp->refcnt);
- if (abo->mem.userptr == AMDXDNA_INVALID_ADDR)
- abo->mem.userptr = addr;
INIT_WORK(&mapp->hmm_unreg_work, amdxdna_hmm_unreg_work);
if (is_import_bo(abo) && vma->vm_file && vma->vm_file->f_mapping)
mapping_set_unevictable(vma->vm_file->f_mapping);
down_write(&xdna->notifier_lock);
+ if (list_empty(&abo->mem.umap_list))
+ abo->mem.uva = addr;
list_add_tail(&mapp->node, &abo->mem.umap_list);
up_write(&xdna->notifier_lock);
struct amdxdna_dev *xdna = to_xdna_dev(gobj->dev);
struct amdxdna_gem_obj *abo = to_xdna_obj(gobj);
- XDNA_DBG(xdna, "BO type %d xdna_addr 0x%llx", abo->type, abo->mem.dev_addr);
+ XDNA_DBG(xdna, "BO type %d xdna_addr 0x%llx", abo->type, amdxdna_gem_dev_addr(abo));
if (abo->pinned)
amdxdna_gem_unpin(abo);
+ amdxdna_gem_vunmap(abo);
amdxdna_gem_heap_free(abo);
drm_gem_object_release(gobj);
amdxdna_gem_destroy_obj(abo);
.vunmap = drm_gem_dmabuf_vunmap,
};
-static int amdxdna_gem_obj_vmap(struct amdxdna_gem_obj *abo, void **vaddr)
-{
- struct iosys_map map = IOSYS_MAP_INIT_VADDR(NULL);
- int ret;
-
- if (is_import_bo(abo))
- ret = dma_buf_vmap_unlocked(abo->dma_buf, &map);
- else
- ret = drm_gem_vmap(to_gobj(abo), &map);
-
- *vaddr = map.vaddr;
- return ret;
-}
-
-static void amdxdna_gem_obj_vunmap(struct amdxdna_gem_obj *abo)
-{
- struct iosys_map map;
-
- if (!abo->mem.kva)
- return;
-
- iosys_map_set_vaddr(&map, abo->mem.kva);
-
- if (is_import_bo(abo))
- dma_buf_vunmap_unlocked(abo->dma_buf, &map);
- else
- drm_gem_vunmap(to_gobj(abo), &map);
-}
-
static struct dma_buf *amdxdna_gem_prime_export(struct drm_gem_object *gobj, int flags)
{
struct amdxdna_gem_obj *abo = to_xdna_obj(gobj);
struct amdxdna_dev *xdna = to_xdna_dev(gobj->dev);
struct amdxdna_gem_obj *abo = to_xdna_obj(gobj);
- XDNA_DBG(xdna, "BO type %d xdna_addr 0x%llx", abo->type, abo->mem.dev_addr);
+ XDNA_DBG(xdna, "BO type %d xdna_addr 0x%llx", abo->type, amdxdna_gem_dev_addr(abo));
amdxdna_hmm_unregister(abo, NULL);
flush_workqueue(xdna->notifier_wq);
if (abo->type == AMDXDNA_BO_DEV_HEAP)
drm_mm_takedown(&abo->mm);
- amdxdna_gem_obj_vunmap(abo);
+ if (amdxdna_iova_on(xdna))
+ amdxdna_iommu_unmap_bo(xdna, abo);
+
+ amdxdna_gem_vunmap(abo);
mutex_destroy(&abo->lock);
- if (is_import_bo(abo)) {
+ if (is_import_bo(abo))
amdxdna_imported_obj_free(abo);
- return;
- }
-
- drm_gem_shmem_free(&abo->base);
+ else
+ drm_gem_shmem_free(&abo->base);
}
static int amdxdna_gem_obj_open(struct drm_gem_object *gobj, struct drm_file *filp)
int ret;
guard(mutex)(&abo->lock);
- if (abo->ref) {
- abo->ref++;
- return 0;
- }
+ if (!abo->client)
+ abo->client = filp->driver_priv;
if (amdxdna_iova_on(xdna)) {
ret = amdxdna_iommu_map_bo(xdna, abo);
if (ret)
return ret;
}
- abo->ref++;
return 0;
}
-static void amdxdna_gem_obj_close(struct drm_gem_object *gobj, struct drm_file *filp)
+static int amdxdna_gem_dev_obj_vmap(struct drm_gem_object *obj, struct iosys_map *map)
{
- struct amdxdna_dev *xdna = to_xdna_dev(gobj->dev);
- struct amdxdna_gem_obj *abo = to_xdna_obj(gobj);
+ struct amdxdna_gem_obj *abo = to_xdna_obj(obj);
+ void *base = amdxdna_gem_vmap(abo->client->dev_heap);
+ u64 offset = amdxdna_dev_bo_offset(abo);
- guard(mutex)(&abo->lock);
- abo->ref--;
- if (abo->ref)
- return;
-
- if (amdxdna_iova_on(xdna))
- amdxdna_iommu_unmap_bo(xdna, abo);
+ if (!base)
+ return -ENOMEM;
+ iosys_map_set_vaddr(map, base + offset);
+ return 0;
}
static const struct drm_gem_object_funcs amdxdna_gem_dev_obj_funcs = {
.free = amdxdna_gem_dev_obj_free,
+ .vmap = amdxdna_gem_dev_obj_vmap,
};
static const struct drm_gem_object_funcs amdxdna_gem_shmem_funcs = {
.free = amdxdna_gem_obj_free,
.open = amdxdna_gem_obj_open,
- .close = amdxdna_gem_obj_close,
.print_info = drm_gem_shmem_object_print_info,
.pin = drm_gem_shmem_object_pin,
.unpin = drm_gem_shmem_object_unpin,
.export = amdxdna_gem_prime_export,
};
-static struct amdxdna_gem_obj *
-amdxdna_gem_create_obj(struct drm_device *dev, size_t size)
-{
- struct amdxdna_gem_obj *abo;
-
- abo = kzalloc_obj(*abo);
- if (!abo)
- return ERR_PTR(-ENOMEM);
-
- abo->pinned = false;
- abo->assigned_hwctx = AMDXDNA_INVALID_CTX_HANDLE;
- mutex_init(&abo->lock);
-
- abo->mem.userptr = AMDXDNA_INVALID_ADDR;
- abo->mem.dev_addr = AMDXDNA_INVALID_ADDR;
- abo->mem.dma_addr = AMDXDNA_INVALID_ADDR;
- abo->mem.size = size;
- INIT_LIST_HEAD(&abo->mem.umap_list);
-
- return abo;
-}
-
/* For drm_driver->gem_create_object callback */
struct drm_gem_object *
-amdxdna_gem_create_object_cb(struct drm_device *dev, size_t size)
+amdxdna_gem_create_shmem_object_cb(struct drm_device *dev, size_t size)
{
struct amdxdna_gem_obj *abo;
}
static struct amdxdna_gem_obj *
-amdxdna_gem_create_shmem_object(struct drm_device *dev, size_t size)
+amdxdna_gem_create_shmem_object(struct drm_device *dev, struct amdxdna_drm_create_bo *args)
{
+ size_t size = args->size;
struct drm_gem_shmem_object *shmem = drm_gem_shmem_create(dev, size);
if (IS_ERR(shmem))
amdxdna_gem_create_ubuf_object(struct drm_device *dev, struct amdxdna_drm_create_bo *args)
{
struct amdxdna_dev *xdna = to_xdna_dev(dev);
- enum amdxdna_ubuf_flag flags = 0;
struct amdxdna_drm_va_tbl va_tbl;
struct drm_gem_object *gobj;
struct dma_buf *dma_buf;
}
if (va_tbl.num_entries) {
- if (args->type == AMDXDNA_BO_CMD)
- flags |= AMDXDNA_UBUF_FLAG_MAP_DMA;
-
- dma_buf = amdxdna_get_ubuf(dev, flags, va_tbl.num_entries,
+ dma_buf = amdxdna_get_ubuf(dev, va_tbl.num_entries,
u64_to_user_ptr(args->vaddr + sizeof(va_tbl)));
} else {
dma_buf = dma_buf_get(va_tbl.dmabuf_fd);
return to_xdna_obj(gobj);
}
-static struct amdxdna_gem_obj *
-amdxdna_gem_create_object(struct drm_device *dev,
- struct amdxdna_drm_create_bo *args)
-{
- size_t aligned_sz = PAGE_ALIGN(args->size);
-
- if (args->vaddr)
- return amdxdna_gem_create_ubuf_object(dev, args);
-
- return amdxdna_gem_create_shmem_object(dev, aligned_sz);
-}
-
struct drm_gem_object *
amdxdna_gem_prime_import(struct drm_device *dev, struct dma_buf *dma_buf)
{
abo = to_xdna_obj(gobj);
abo->attach = attach;
abo->dma_buf = dma_buf;
- abo->type = AMDXDNA_BO_SHMEM;
+ abo->type = AMDXDNA_BO_SHARE;
+ gobj->resv = dma_buf->resv;
return gobj;
}
static struct amdxdna_gem_obj *
-amdxdna_drm_alloc_shmem(struct drm_device *dev,
- struct amdxdna_drm_create_bo *args,
- struct drm_file *filp)
+amdxdna_drm_create_share_bo(struct drm_device *dev,
+ struct amdxdna_drm_create_bo *args, struct drm_file *filp)
{
- struct amdxdna_client *client = filp->driver_priv;
struct amdxdna_gem_obj *abo;
- abo = amdxdna_gem_create_object(dev, args);
+ if (args->vaddr)
+ abo = amdxdna_gem_create_ubuf_object(dev, args);
+ else
+ abo = amdxdna_gem_create_shmem_object(dev, args);
if (IS_ERR(abo))
return ERR_CAST(abo);
- abo->client = client;
- abo->type = AMDXDNA_BO_SHMEM;
+ if (args->type == AMDXDNA_BO_DEV_HEAP)
+ abo->type = AMDXDNA_BO_DEV_HEAP;
+ else
+ abo->type = AMDXDNA_BO_SHARE;
return abo;
}
static struct amdxdna_gem_obj *
-amdxdna_drm_create_dev_heap(struct drm_device *dev,
- struct amdxdna_drm_create_bo *args,
- struct drm_file *filp)
+amdxdna_drm_create_dev_heap_bo(struct drm_device *dev,
+ struct amdxdna_drm_create_bo *args, struct drm_file *filp)
{
struct amdxdna_client *client = filp->driver_priv;
struct amdxdna_dev *xdna = to_xdna_dev(dev);
struct amdxdna_gem_obj *abo;
int ret;
- if (args->size > xdna->dev_info->dev_mem_size) {
- XDNA_DBG(xdna, "Invalid dev heap size 0x%llx, limit 0x%lx",
+ WARN_ON(!is_power_of_2(xdna->dev_info->dev_mem_size));
+ XDNA_DBG(xdna, "Requested dev heap size 0x%llx", args->size);
+ if (!args->size || !IS_ALIGNED(args->size, xdna->dev_info->dev_mem_size)) {
+ XDNA_ERR(xdna, "The dev heap size 0x%llx is not multiple of 0x%lx",
args->size, xdna->dev_info->dev_mem_size);
return ERR_PTR(-EINVAL);
}
+ /* HEAP BO is a special case of SHARE BO. */
+ abo = amdxdna_drm_create_share_bo(dev, args, filp);
+ if (IS_ERR(abo))
+ return ERR_CAST(abo);
+
+ /* Set up heap for this client. */
mutex_lock(&client->mm_lock);
+
if (client->dev_heap) {
XDNA_DBG(client->xdna, "dev heap is already created");
ret = -EBUSY;
goto mm_unlock;
}
-
- abo = amdxdna_gem_create_object(dev, args);
- if (IS_ERR(abo)) {
- ret = PTR_ERR(abo);
- goto mm_unlock;
- }
-
- abo->type = AMDXDNA_BO_DEV_HEAP;
- abo->client = client;
- abo->mem.dev_addr = client->xdna->dev_info->dev_mem_base;
- drm_mm_init(&abo->mm, abo->mem.dev_addr, abo->mem.size);
-
- ret = amdxdna_gem_obj_vmap(abo, &abo->mem.kva);
- if (ret) {
- XDNA_ERR(xdna, "Vmap heap bo failed, ret %d", ret);
- goto release_obj;
- }
-
client->dev_heap = abo;
drm_gem_object_get(to_gobj(abo));
+
+ drm_mm_init(&abo->mm, xdna->dev_info->dev_mem_base, abo->mem.size);
+
mutex_unlock(&client->mm_lock);
return abo;
-release_obj:
- drm_gem_object_put(to_gobj(abo));
mm_unlock:
mutex_unlock(&client->mm_lock);
+ drm_gem_object_put(to_gobj(abo));
return ERR_PTR(ret);
}
struct amdxdna_gem_obj *
-amdxdna_drm_alloc_dev_bo(struct drm_device *dev,
- struct amdxdna_drm_create_bo *args,
- struct drm_file *filp)
+amdxdna_drm_create_dev_bo(struct drm_device *dev,
+ struct amdxdna_drm_create_bo *args, struct drm_file *filp)
{
+ size_t aligned_sz = PAGE_ALIGN(args->size);
struct amdxdna_client *client = filp->driver_priv;
struct amdxdna_dev *xdna = to_xdna_dev(dev);
- size_t aligned_sz = PAGE_ALIGN(args->size);
struct amdxdna_gem_obj *abo;
+ struct drm_gem_object *gobj;
int ret;
- abo = amdxdna_gem_create_obj(&xdna->ddev, aligned_sz);
+ if (!aligned_sz) {
+ XDNA_ERR(xdna, "Invalid BO size 0x%llx", args->size);
+ return ERR_PTR(-EINVAL);
+ }
+
+ abo = amdxdna_gem_create_obj(dev, aligned_sz);
if (IS_ERR(abo))
return abo;
-
- to_gobj(abo)->funcs = &amdxdna_gem_dev_obj_funcs;
+ gobj = to_gobj(abo);
+ gobj->funcs = &amdxdna_gem_dev_obj_funcs;
abo->type = AMDXDNA_BO_DEV;
abo->client = client;
amdxdna_gem_destroy_obj(abo);
return ERR_PTR(ret);
}
-
- drm_gem_private_object_init(&xdna->ddev, to_gobj(abo), aligned_sz);
-
- return abo;
-}
-
-static struct amdxdna_gem_obj *
-amdxdna_drm_create_cmd_bo(struct drm_device *dev,
- struct amdxdna_drm_create_bo *args,
- struct drm_file *filp)
-{
- struct amdxdna_dev *xdna = to_xdna_dev(dev);
- struct amdxdna_gem_obj *abo;
-
- if (args->size < sizeof(struct amdxdna_cmd)) {
- XDNA_DBG(xdna, "Command BO size 0x%llx too small", args->size);
- return ERR_PTR(-EINVAL);
- }
-
- abo = amdxdna_gem_create_object(dev, args);
- if (IS_ERR(abo))
- return ERR_CAST(abo);
-
- abo->type = AMDXDNA_BO_CMD;
- abo->client = filp->driver_priv;
+ drm_gem_private_object_init(dev, gobj, aligned_sz);
return abo;
}
XDNA_DBG(xdna, "BO arg type %d vaddr 0x%llx size 0x%llx flags 0x%llx",
args->type, args->vaddr, args->size, args->flags);
switch (args->type) {
- case AMDXDNA_BO_SHMEM:
- abo = amdxdna_drm_alloc_shmem(dev, args, filp);
+ case AMDXDNA_BO_CMD:
+ fallthrough;
+ case AMDXDNA_BO_SHARE:
+ abo = amdxdna_drm_create_share_bo(dev, args, filp);
break;
case AMDXDNA_BO_DEV_HEAP:
- abo = amdxdna_drm_create_dev_heap(dev, args, filp);
+ abo = amdxdna_drm_create_dev_heap_bo(dev, args, filp);
break;
case AMDXDNA_BO_DEV:
- abo = amdxdna_drm_alloc_dev_bo(dev, args, filp);
- break;
- case AMDXDNA_BO_CMD:
- abo = amdxdna_drm_create_cmd_bo(dev, args, filp);
+ abo = amdxdna_drm_create_dev_bo(dev, args, filp);
break;
default:
return -EINVAL;
}
XDNA_DBG(xdna, "BO hdl %d type %d userptr 0x%llx xdna_addr 0x%llx size 0x%lx",
- args->handle, args->type, abo->mem.userptr,
- abo->mem.dev_addr, abo->mem.size);
+ args->handle, args->type, amdxdna_gem_uva(abo),
+ amdxdna_gem_dev_addr(abo), abo->mem.size);
put_obj:
/* Dereference object reference. Handle holds it now. */
drm_gem_object_put(to_gobj(abo));
struct amdxdna_gem_obj *amdxdna_gem_get_obj(struct amdxdna_client *client,
u32 bo_hdl, u8 bo_type)
{
- struct amdxdna_dev *xdna = client->xdna;
struct amdxdna_gem_obj *abo;
struct drm_gem_object *gobj;
- int ret;
gobj = drm_gem_object_lookup(client->filp, bo_hdl);
if (!gobj) {
- XDNA_DBG(xdna, "Can not find bo %d", bo_hdl);
+ XDNA_DBG(client->xdna, "Can not find bo %d", bo_hdl);
return NULL;
}
abo = to_xdna_obj(gobj);
- if (bo_type != AMDXDNA_BO_INVALID && abo->type != bo_type)
- goto put_obj;
-
- if (bo_type != AMDXDNA_BO_CMD || abo->mem.kva)
+ if (bo_type == AMDXDNA_BO_INVALID || abo->type == bo_type)
return abo;
- if (abo->mem.size > SZ_32K) {
- XDNA_ERR(xdna, "Cmd bo is too big %ld", abo->mem.size);
- goto put_obj;
- }
-
- ret = amdxdna_gem_obj_vmap(abo, &abo->mem.kva);
- if (ret) {
- XDNA_ERR(xdna, "Vmap cmd bo failed, ret %d", ret);
- goto put_obj;
- }
-
- return abo;
-
-put_obj:
drm_gem_object_put(gobj);
return NULL;
}
}
abo = to_xdna_obj(gobj);
- args->vaddr = abo->mem.userptr;
- if (abo->mem.dev_addr != AMDXDNA_INVALID_ADDR)
- args->xdna_addr = abo->mem.dev_addr;
- else
- args->xdna_addr = abo->mem.dma_addr;
+ args->vaddr = amdxdna_gem_uva(abo);
+ args->xdna_addr = amdxdna_gem_dev_addr(abo);
if (abo->type != AMDXDNA_BO_DEV)
args->map_offset = drm_vma_node_offset_addr(&gobj->vma_node);
if (is_import_bo(abo))
drm_clflush_sg(abo->base.sgt);
- else if (abo->mem.kva)
- drm_clflush_virt_range(abo->mem.kva + args->offset, args->size);
+ else if (amdxdna_gem_vmap(abo))
+ drm_clflush_virt_range(amdxdna_gem_vmap(abo) + args->offset, args->size);
else if (abo->base.pages)
drm_clflush_pages(abo->base.pages, gobj->size >> PAGE_SHIFT);
else
projects / thirdparty / linux.git / commitdiff
