Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
accel/amdxdna: Refactor GEM BO handling and add helper APIs for address retrieval
Refactor amdxdna GEM buffer object (BO) handling to simplify address
management and unify BO type semantics.
Introduce helper APIs to retrieve commonly used BO addresses:
- User virtual address (UVA)
- Kernel virtual address (KVA)
- Device address (IOVA/PA)
These helpers centralize address lookup logic and avoid duplicating
BO-specific handling across submission and execution paths. This also
improves readability and reduces the risk of inconsistent address
handling in future changes.
As part of the refactor:
- Rename SHMEM BO type to SHARE to better reflect its usage.
- Merge CMD BO handling into SHARE, removing special-case logic for
command buffers.
- Consolidate BO type handling paths to reduce code duplication and
simplify maintenance.
No functional change is intended. The refactor prepares the driver for
future enhancements by providing a cleaner abstraction for BO address
management.
Reviewed-by: Mario Limonciello (AMD) <superm1@kernel.org>
Signed-off-by: Max Zhen <max.zhen@amd.com>
Signed-off-by: Lizhi Hou <lizhi.hou@amd.com>
Link: https://patch.msgid.link/20260320210615.1973016-1-lizhi.hou@amd.com
+266
-278
+4
-4
drivers/accel/amdxdna/aie2_ctx.c
+4
-4
drivers/accel/amdxdna/aie2_ctx.c
···
79
79
}
80
80
81
81
ret = aie2_map_host_buf(xdna->dev_handle, hwctx->fw_ctx_id,
82
-
amdxdna_obj_dma_addr(hwctx->client, heap),
82
+
amdxdna_obj_dma_addr(heap),
83
83
heap->mem.size);
84
84
if (ret) {
85
85
XDNA_ERR(xdna, "Map host buf failed, ret %d", ret);
···
659
659
.size = MAX_CHAIN_CMDBUF_SIZE,
660
660
};
661
661
662
-
abo = amdxdna_drm_alloc_dev_bo(&xdna->ddev, &args, client->filp);
662
+
abo = amdxdna_drm_create_dev_bo(&xdna->ddev, &args, client->filp);
663
663
if (IS_ERR(abo)) {
664
664
ret = PTR_ERR(abo);
665
665
goto free_cmd_bufs;
666
666
}
667
667
668
668
XDNA_DBG(xdna, "Command buf %d addr 0x%llx size 0x%lx",
669
-
i, abo->mem.dev_addr, abo->mem.size);
669
+
i, amdxdna_gem_dev_addr(abo), abo->mem.size);
670
670
priv->cmd_buf[i] = abo;
671
671
}
672
672
···
707
707
}
708
708
709
709
ret = aie2_map_host_buf(xdna->dev_handle, hwctx->fw_ctx_id,
710
-
amdxdna_obj_dma_addr(hwctx->client, heap),
710
+
amdxdna_obj_dma_addr(heap),
711
711
heap->mem.size);
712
712
if (ret) {
713
713
XDNA_ERR(xdna, "Map host buffer failed, ret %d", ret);
+19
-14
drivers/accel/amdxdna/aie2_message.c
+19
-14
drivers/accel/amdxdna/aie2_message.c
···
548
548
}
549
549
550
550
req.cfgs[i] = FIELD_PREP(AIE2_MSG_CFG_CU_PDI_ADDR,
551
-
abo->mem.dev_addr >> shift);
551
+
amdxdna_gem_dev_addr(abo) >> shift);
552
552
req.cfgs[i] |= FIELD_PREP(AIE2_MSG_CFG_CU_FUNC, cu->cu_func);
553
553
XDNA_DBG(xdna, "CU %d full addr 0x%llx, cfg 0x%x", i,
554
-
abo->mem.dev_addr, req.cfgs[i]);
554
+
amdxdna_gem_dev_addr(abo), req.cfgs[i]);
555
555
drm_gem_object_put(gobj);
556
556
}
557
557
req.num_cus = hwctx->cus->num_cus;
···
998
998
struct mailbox_channel *chann = hwctx->priv->mbox_chann;
999
999
struct amdxdna_client *client = hwctx->client;
1000
1000
struct amdxdna_gem_obj *cmd_abo = job->cmd_bo;
1001
+
void *cmd_buf = amdxdna_gem_vmap(cmdbuf_abo);
1001
1002
struct amdxdna_dev *xdna = client->xdna;
1002
1003
struct amdxdna_cmd_chain *payload;
1003
1004
struct xdna_mailbox_msg msg;
···
1009
1008
int ret;
1010
1009
u32 op;
1011
1010
u32 i;
1011
+
1012
+
if (!cmd_buf)
1013
+
return -ENOMEM;
1012
1014
1013
1015
op = amdxdna_cmd_get_op(cmd_abo);
1014
1016
payload = amdxdna_cmd_get_payload(cmd_abo, &payload_len);
···
1036
1032
u32 boh = (u32)(payload->data[i]);
1037
1033
struct amdxdna_gem_obj *abo;
1038
1034
1039
-
abo = amdxdna_gem_get_obj(client, boh, AMDXDNA_BO_CMD);
1035
+
abo = amdxdna_gem_get_obj(client, boh, AMDXDNA_BO_SHARE);
1040
1036
if (!abo) {
1041
1037
XDNA_ERR(xdna, "Failed to find cmd BO %d", boh);
1042
1038
return -ENOENT;
1043
1039
}
1044
1040
1045
1041
size = cmdbuf_abo->mem.size - offset;
1046
-
ret = aie2_cmdlist_fill_slot(cmdbuf_abo->mem.kva + offset,
1047
-
abo, &size, &op);
1042
+
ret = aie2_cmdlist_fill_slot(cmd_buf + offset, abo, &size, &op);
1048
1043
amdxdna_gem_put_obj(abo);
1049
1044
if (ret)
1050
1045
return ret;
···
1053
1050
1054
1051
XDNA_DBG(xdna, "Total %d commands:", ccnt);
1055
1052
print_hex_dump_debug("cmdbufs: ", DUMP_PREFIX_OFFSET, 16, 4,
1056
-
cmdbuf_abo->mem.kva, offset, false);
1053
+
cmd_buf, offset, false);
1057
1054
1058
1055
msg.opcode = EXEC_MSG_OPS(xdna)->get_chain_msg_op(op);
1059
1056
if (msg.opcode == MSG_OP_MAX_OPCODE)
1060
1057
return -EOPNOTSUPP;
1061
1058
1062
1059
/* The offset is the accumulated total size of the cmd buffer */
1063
-
EXEC_MSG_OPS(xdna)->init_chain_req(&req, cmdbuf_abo->mem.dev_addr,
1060
+
EXEC_MSG_OPS(xdna)->init_chain_req(&req, amdxdna_gem_dev_addr(cmdbuf_abo),
1064
1061
offset, ccnt);
1065
-
drm_clflush_virt_range(cmdbuf_abo->mem.kva, offset);
1062
+
drm_clflush_virt_range(cmd_buf, offset);
1066
1063
1067
1064
msg.handle = job;
1068
1065
msg.notify_cb = notify_cb;
···
1087
1084
struct mailbox_channel *chann = hwctx->priv->mbox_chann;
1088
1085
struct amdxdna_dev *xdna = hwctx->client->xdna;
1089
1086
struct amdxdna_gem_obj *cmd_abo = job->cmd_bo;
1087
+
void *cmd_buf = amdxdna_gem_vmap(cmdbuf_abo);
1090
1088
struct xdna_mailbox_msg msg;
1091
1089
union exec_chain_req req;
1092
1090
u32 op = ERT_INVALID_CMD;
1093
1091
size_t size;
1094
1092
int ret;
1095
1093
1094
+
if (!cmd_buf)
1095
+
return -ENOMEM;
1096
+
1096
1097
size = cmdbuf_abo->mem.size;
1097
-
ret = aie2_cmdlist_fill_slot(cmdbuf_abo->mem.kva, cmd_abo, &size, &op);
1098
+
ret = aie2_cmdlist_fill_slot(cmd_buf, cmd_abo, &size, &op);
1098
1099
if (ret)
1099
1100
return ret;
1100
1101
1101
-
print_hex_dump_debug("cmdbuf: ", DUMP_PREFIX_OFFSET, 16, 4,
1102
-
cmdbuf_abo->mem.kva, size, false);
1102
+
print_hex_dump_debug("cmdbuf: ", DUMP_PREFIX_OFFSET, 16, 4, cmd_buf, size, false);
1103
1103
1104
1104
msg.opcode = EXEC_MSG_OPS(xdna)->get_chain_msg_op(op);
1105
1105
if (msg.opcode == MSG_OP_MAX_OPCODE)
1106
1106
return -EOPNOTSUPP;
1107
1107
1108
-
EXEC_MSG_OPS(xdna)->init_chain_req(&req, cmdbuf_abo->mem.dev_addr,
1109
-
size, 1);
1110
-
drm_clflush_virt_range(cmdbuf_abo->mem.kva, size);
1108
+
EXEC_MSG_OPS(xdna)->init_chain_req(&req, amdxdna_gem_dev_addr(cmdbuf_abo), size, 1);
1109
+
drm_clflush_virt_range(cmd_buf, size);
1111
1110
1112
1111
msg.handle = job;
1113
1112
msg.notify_cb = notify_cb;
+17
-6
drivers/accel/amdxdna/amdxdna_ctx.c
+17
-6
drivers/accel/amdxdna/amdxdna_ctx.c
···
94
94
95
95
void *amdxdna_cmd_get_payload(struct amdxdna_gem_obj *abo, u32 *size)
96
96
{
97
-
struct amdxdna_cmd *cmd = abo->mem.kva;
97
+
struct amdxdna_cmd *cmd = amdxdna_gem_vmap(abo);
98
98
u32 num_masks, count;
99
+
100
+
if (!cmd)
101
+
return NULL;
99
102
100
103
if (amdxdna_cmd_get_op(abo) == ERT_CMD_CHAIN)
101
104
num_masks = 0;
···
121
118
122
119
u32 amdxdna_cmd_get_cu_idx(struct amdxdna_gem_obj *abo)
123
120
{
124
-
struct amdxdna_cmd *cmd = abo->mem.kva;
121
+
struct amdxdna_cmd *cmd = amdxdna_gem_vmap(abo);
125
122
u32 num_masks, i;
126
123
u32 *cu_mask;
124
+
125
+
if (!cmd)
126
+
return INVALID_CU_IDX;
127
127
128
128
if (amdxdna_cmd_get_op(abo) == ERT_CMD_CHAIN)
129
129
return INVALID_CU_IDX;
···
147
141
void *err_data, size_t size)
148
142
{
149
143
struct amdxdna_client *client = job->hwctx->client;
150
-
struct amdxdna_cmd *cmd = abo->mem.kva;
144
+
struct amdxdna_cmd *cmd = amdxdna_gem_vmap(abo);
151
145
struct amdxdna_cmd_chain *cc = NULL;
146
+
147
+
if (!cmd)
148
+
return -ENOMEM;
152
149
153
150
cmd->header &= ~AMDXDNA_CMD_STATE;
154
151
cmd->header |= FIELD_PREP(AMDXDNA_CMD_STATE, error_state);
···
159
150
if (amdxdna_cmd_get_op(abo) == ERT_CMD_CHAIN) {
160
151
cc = amdxdna_cmd_get_payload(abo, NULL);
161
152
cc->error_index = (cmd_idx < cc->command_count) ? cmd_idx : 0;
162
-
abo = amdxdna_gem_get_obj(client, cc->data[0], AMDXDNA_BO_CMD);
153
+
abo = amdxdna_gem_get_obj(client, cc->data[0], AMDXDNA_BO_SHARE);
163
154
if (!abo)
164
155
return -EINVAL;
165
-
cmd = abo->mem.kva;
156
+
cmd = amdxdna_gem_vmap(abo);
157
+
if (!cmd)
158
+
return -ENOMEM;
166
159
}
167
160
168
161
memset(cmd->data, 0xff, abo->mem.size - sizeof(*cmd));
···
483
472
job->drv_cmd = drv_cmd;
484
473
485
474
if (cmd_bo_hdl != AMDXDNA_INVALID_BO_HANDLE) {
486
-
job->cmd_bo = amdxdna_gem_get_obj(client, cmd_bo_hdl, AMDXDNA_BO_CMD);
475
+
job->cmd_bo = amdxdna_gem_get_obj(client, cmd_bo_hdl, AMDXDNA_BO_SHARE);
487
476
if (!job->cmd_bo) {
488
477
XDNA_ERR(xdna, "Failed to get cmd bo from %d", cmd_bo_hdl);
489
478
ret = -EINVAL;
+12
-3
drivers/accel/amdxdna/amdxdna_ctx.h
+12
-3
drivers/accel/amdxdna/amdxdna_ctx.h
···
158
158
static inline u32
159
159
amdxdna_cmd_get_op(struct amdxdna_gem_obj *abo)
160
160
{
161
-
struct amdxdna_cmd *cmd = abo->mem.kva;
161
+
struct amdxdna_cmd *cmd = amdxdna_gem_vmap(abo);
162
+
163
+
if (!cmd)
164
+
return ERT_INVALID_CMD;
162
165
163
166
return FIELD_GET(AMDXDNA_CMD_OPCODE, cmd->header);
164
167
}
···
169
166
static inline void
170
167
amdxdna_cmd_set_state(struct amdxdna_gem_obj *abo, enum ert_cmd_state s)
171
168
{
172
-
struct amdxdna_cmd *cmd = abo->mem.kva;
169
+
struct amdxdna_cmd *cmd = amdxdna_gem_vmap(abo);
170
+
171
+
if (!cmd)
172
+
return;
173
173
174
174
cmd->header &= ~AMDXDNA_CMD_STATE;
175
175
cmd->header |= FIELD_PREP(AMDXDNA_CMD_STATE, s);
···
181
175
static inline enum ert_cmd_state
182
176
amdxdna_cmd_get_state(struct amdxdna_gem_obj *abo)
183
177
{
184
-
struct amdxdna_cmd *cmd = abo->mem.kva;
178
+
struct amdxdna_cmd *cmd = amdxdna_gem_vmap(abo);
179
+
180
+
if (!cmd)
181
+
return ERT_CMD_STATE_INVALID;
185
182
186
183
return FIELD_GET(AMDXDNA_CMD_STATE, cmd->header);
187
184
}
+187
-213
drivers/accel/amdxdna/amdxdna_gem.c
+187
-213
drivers/accel/amdxdna/amdxdna_gem.c
···
30
30
struct amdxdna_dev *xdna = client->xdna;
31
31
struct amdxdna_mem *mem = &abo->mem;
32
32
struct amdxdna_gem_obj *heap;
33
-
u64 offset;
34
33
u32 align;
35
34
int ret;
36
35
···
41
42
goto unlock_out;
42
43
}
43
44
44
-
if (heap->mem.userptr == AMDXDNA_INVALID_ADDR) {
45
+
if (amdxdna_gem_uva(heap) == AMDXDNA_INVALID_ADDR) {
45
46
XDNA_ERR(xdna, "Invalid dev heap userptr");
46
47
ret = -EINVAL;
47
48
goto unlock_out;
···
63
64
goto unlock_out;
64
65
}
65
66
66
-
mem->dev_addr = abo->mm_node.start;
67
-
offset = mem->dev_addr - heap->mem.dev_addr;
68
-
mem->userptr = heap->mem.userptr + offset;
69
-
mem->kva = heap->mem.kva + offset;
70
-
71
67
drm_gem_object_get(to_gobj(heap));
72
68
73
69
unlock_out:
74
70
mutex_unlock(&client->mm_lock);
75
71
76
72
return ret;
77
-
}
78
-
79
-
static void
80
-
amdxdna_gem_destroy_obj(struct amdxdna_gem_obj *abo)
81
-
{
82
-
mutex_destroy(&abo->lock);
83
-
kfree(abo);
84
73
}
85
74
86
75
static void
···
84
97
drm_gem_object_put(to_gobj(heap));
85
98
86
99
mutex_unlock(&abo->client->mm_lock);
100
+
}
101
+
102
+
static struct amdxdna_gem_obj *
103
+
amdxdna_gem_create_obj(struct drm_device *dev, size_t size)
104
+
{
105
+
struct amdxdna_gem_obj *abo;
106
+
107
+
abo = kzalloc_obj(*abo);
108
+
if (!abo)
109
+
return ERR_PTR(-ENOMEM);
110
+
111
+
abo->pinned = false;
112
+
abo->assigned_hwctx = AMDXDNA_INVALID_CTX_HANDLE;
113
+
mutex_init(&abo->lock);
114
+
115
+
abo->mem.dma_addr = AMDXDNA_INVALID_ADDR;
116
+
abo->mem.uva = AMDXDNA_INVALID_ADDR;
117
+
abo->mem.size = size;
118
+
INIT_LIST_HEAD(&abo->mem.umap_list);
119
+
120
+
return abo;
121
+
}
122
+
123
+
static void
124
+
amdxdna_gem_destroy_obj(struct amdxdna_gem_obj *abo)
125
+
{
126
+
mutex_destroy(&abo->lock);
127
+
kfree(abo);
128
+
}
129
+
130
+
/*
131
+
* Obtains a kernel virtual address on the BO (usually of small size).
132
+
* The mapping is established on the first call and stays valid until
133
+
* amdxdna_gem_vunmap() is called.
134
+
*/
135
+
void *amdxdna_gem_vmap(struct amdxdna_gem_obj *abo)
136
+
{
137
+
struct iosys_map map = IOSYS_MAP_INIT_VADDR(NULL);
138
+
int ret;
139
+
140
+
if (abo->mem.kva)
141
+
return abo->mem.kva;
142
+
143
+
/* The first call to get the kva, taking slow path. */
144
+
guard(mutex)(&abo->lock);
145
+
146
+
if (!abo->mem.kva) {
147
+
ret = drm_gem_vmap(to_gobj(abo), &map);
148
+
if (ret)
149
+
XDNA_ERR(abo->client->xdna, "Vmap bo failed, ret %d", ret);
150
+
else
151
+
abo->mem.kva = map.vaddr;
152
+
}
153
+
return abo->mem.kva;
154
+
}
155
+
156
+
/*
157
+
* Free mapping established through amdxdna_gem_vmap()
158
+
*/
159
+
static void amdxdna_gem_vunmap(struct amdxdna_gem_obj *abo)
160
+
{
161
+
guard(mutex)(&abo->lock);
162
+
163
+
if (abo->mem.kva) {
164
+
struct iosys_map map = IOSYS_MAP_INIT_VADDR(abo->mem.kva);
165
+
166
+
drm_gem_vunmap(to_gobj(abo), &map);
167
+
abo->mem.kva = NULL;
168
+
}
169
+
}
170
+
171
+
/*
172
+
* Obtain the user virtual address for accessing the BO.
173
+
* It can be used for device to access the BO when PASID is enabled.
174
+
*/
175
+
u64 amdxdna_gem_uva(struct amdxdna_gem_obj *abo)
176
+
{
177
+
if (abo->type == AMDXDNA_BO_DEV) {
178
+
struct amdxdna_gem_obj *heap = abo->client->dev_heap;
179
+
u64 off = amdxdna_dev_bo_offset(abo);
180
+
181
+
if (amdxdna_gem_uva(heap) != AMDXDNA_INVALID_ADDR)
182
+
return amdxdna_gem_uva(heap) + off;
183
+
return AMDXDNA_INVALID_ADDR;
184
+
}
185
+
186
+
return abo->mem.uva;
187
+
}
188
+
189
+
/*
190
+
* Obtain the address for device to access the BO.
191
+
*/
192
+
u64 amdxdna_gem_dev_addr(struct amdxdna_gem_obj *abo)
193
+
{
194
+
if (abo->type == AMDXDNA_BO_DEV_HEAP)
195
+
return abo->client->xdna->dev_info->dev_mem_base;
196
+
if (abo->type == AMDXDNA_BO_DEV)
197
+
return abo->mm_node.start;
198
+
return amdxdna_obj_dma_addr(abo);
87
199
}
88
200
89
201
static bool amdxdna_hmm_invalidate(struct mmu_interval_notifier *mni,
···
247
161
static void amdxdna_umap_release(struct kref *ref)
248
162
{
249
163
struct amdxdna_umap *mapp = container_of(ref, struct amdxdna_umap, refcnt);
164
+
struct amdxdna_gem_obj *abo = mapp->abo;
250
165
struct vm_area_struct *vma = mapp->vma;
251
166
struct amdxdna_dev *xdna;
252
167
253
168
mmu_interval_notifier_remove(&mapp->notifier);
254
-
if (is_import_bo(mapp->abo) && vma->vm_file && vma->vm_file->f_mapping)
169
+
if (is_import_bo(abo) && vma->vm_file && vma->vm_file->f_mapping)
255
170
mapping_clear_unevictable(vma->vm_file->f_mapping);
256
171
257
172
xdna = to_xdna_dev(to_gobj(mapp->abo)->dev);
258
173
down_write(&xdna->notifier_lock);
259
174
list_del(&mapp->node);
175
+
if (list_empty(&abo->mem.umap_list))
176
+
abo->mem.uva = AMDXDNA_INVALID_ADDR;
260
177
up_write(&xdna->notifier_lock);
261
178
262
179
kvfree(mapp->range.hmm_pfns);
···
321
232
mapp->abo = abo;
322
233
kref_init(&mapp->refcnt);
323
234
324
-
if (abo->mem.userptr == AMDXDNA_INVALID_ADDR)
325
-
abo->mem.userptr = addr;
326
235
INIT_WORK(&mapp->hmm_unreg_work, amdxdna_hmm_unreg_work);
327
236
if (is_import_bo(abo) && vma->vm_file && vma->vm_file->f_mapping)
328
237
mapping_set_unevictable(vma->vm_file->f_mapping);
329
238
330
239
down_write(&xdna->notifier_lock);
240
+
if (list_empty(&abo->mem.umap_list))
241
+
abo->mem.uva = addr;
331
242
list_add_tail(&mapp->node, &abo->mem.umap_list);
332
243
up_write(&xdna->notifier_lock);
333
244
···
345
256
struct amdxdna_dev *xdna = to_xdna_dev(gobj->dev);
346
257
struct amdxdna_gem_obj *abo = to_xdna_obj(gobj);
347
258
348
-
XDNA_DBG(xdna, "BO type %d xdna_addr 0x%llx", abo->type, abo->mem.dev_addr);
259
+
XDNA_DBG(xdna, "BO type %d xdna_addr 0x%llx", abo->type, amdxdna_gem_dev_addr(abo));
349
260
if (abo->pinned)
350
261
amdxdna_gem_unpin(abo);
351
262
263
+
amdxdna_gem_vunmap(abo);
352
264
amdxdna_gem_heap_free(abo);
353
265
drm_gem_object_release(gobj);
354
266
amdxdna_gem_destroy_obj(abo);
···
480
390
.vunmap = drm_gem_dmabuf_vunmap,
481
391
};
482
392
483
-
static int amdxdna_gem_obj_vmap(struct amdxdna_gem_obj *abo, void **vaddr)
484
-
{
485
-
struct iosys_map map = IOSYS_MAP_INIT_VADDR(NULL);
486
-
int ret;
487
-
488
-
if (is_import_bo(abo))
489
-
ret = dma_buf_vmap_unlocked(abo->dma_buf, &map);
490
-
else
491
-
ret = drm_gem_vmap(to_gobj(abo), &map);
492
-
493
-
*vaddr = map.vaddr;
494
-
return ret;
495
-
}
496
-
497
-
static void amdxdna_gem_obj_vunmap(struct amdxdna_gem_obj *abo)
498
-
{
499
-
struct iosys_map map;
500
-
501
-
if (!abo->mem.kva)
502
-
return;
503
-
504
-
iosys_map_set_vaddr(&map, abo->mem.kva);
505
-
506
-
if (is_import_bo(abo))
507
-
dma_buf_vunmap_unlocked(abo->dma_buf, &map);
508
-
else
509
-
drm_gem_vunmap(to_gobj(abo), &map);
510
-
}
511
-
512
393
static struct dma_buf *amdxdna_gem_prime_export(struct drm_gem_object *gobj, int flags)
513
394
{
514
395
struct amdxdna_gem_obj *abo = to_xdna_obj(gobj);
···
513
452
struct amdxdna_dev *xdna = to_xdna_dev(gobj->dev);
514
453
struct amdxdna_gem_obj *abo = to_xdna_obj(gobj);
515
454
516
-
XDNA_DBG(xdna, "BO type %d xdna_addr 0x%llx", abo->type, abo->mem.dev_addr);
455
+
XDNA_DBG(xdna, "BO type %d xdna_addr 0x%llx", abo->type, amdxdna_gem_dev_addr(abo));
517
456
518
457
amdxdna_hmm_unregister(abo, NULL);
519
458
flush_workqueue(xdna->notifier_wq);
···
524
463
if (abo->type == AMDXDNA_BO_DEV_HEAP)
525
464
drm_mm_takedown(&abo->mm);
526
465
527
-
amdxdna_gem_obj_vunmap(abo);
466
+
if (amdxdna_iova_on(xdna))
467
+
amdxdna_iommu_unmap_bo(xdna, abo);
468
+
469
+
amdxdna_gem_vunmap(abo);
528
470
mutex_destroy(&abo->lock);
529
471
530
-
if (is_import_bo(abo)) {
472
+
if (is_import_bo(abo))
531
473
amdxdna_imported_obj_free(abo);
532
-
return;
533
-
}
534
-
535
-
drm_gem_shmem_free(&abo->base);
474
+
else
475
+
drm_gem_shmem_free(&abo->base);
536
476
}
537
477
538
478
static int amdxdna_gem_obj_open(struct drm_gem_object *gobj, struct drm_file *filp)
···
543
481
int ret;
544
482
545
483
guard(mutex)(&abo->lock);
546
-
if (abo->ref) {
547
-
abo->ref++;
548
-
return 0;
549
-
}
550
484
485
+
if (!abo->client)
486
+
abo->client = filp->driver_priv;
551
487
if (amdxdna_iova_on(xdna)) {
552
488
ret = amdxdna_iommu_map_bo(xdna, abo);
553
489
if (ret)
554
490
return ret;
555
491
}
556
-
abo->ref++;
557
492
558
493
return 0;
559
494
}
560
495
561
-
static void amdxdna_gem_obj_close(struct drm_gem_object *gobj, struct drm_file *filp)
496
+
static int amdxdna_gem_dev_obj_vmap(struct drm_gem_object *obj, struct iosys_map *map)
562
497
{
563
-
struct amdxdna_dev *xdna = to_xdna_dev(gobj->dev);
564
-
struct amdxdna_gem_obj *abo = to_xdna_obj(gobj);
498
+
struct amdxdna_gem_obj *abo = to_xdna_obj(obj);
499
+
void *base = amdxdna_gem_vmap(abo->client->dev_heap);
500
+
u64 offset = amdxdna_dev_bo_offset(abo);
565
501
566
-
guard(mutex)(&abo->lock);
567
-
abo->ref--;
568
-
if (abo->ref)
569
-
return;
570
-
571
-
if (amdxdna_iova_on(xdna))
572
-
amdxdna_iommu_unmap_bo(xdna, abo);
502
+
if (!base)
503
+
return -ENOMEM;
504
+
iosys_map_set_vaddr(map, base + offset);
505
+
return 0;
573
506
}
574
507
575
508
static const struct drm_gem_object_funcs amdxdna_gem_dev_obj_funcs = {
576
509
.free = amdxdna_gem_dev_obj_free,
510
+
.vmap = amdxdna_gem_dev_obj_vmap,
577
511
};
578
512
579
513
static const struct drm_gem_object_funcs amdxdna_gem_shmem_funcs = {
580
514
.free = amdxdna_gem_obj_free,
581
515
.open = amdxdna_gem_obj_open,
582
-
.close = amdxdna_gem_obj_close,
583
516
.print_info = drm_gem_shmem_object_print_info,
584
517
.pin = drm_gem_shmem_object_pin,
585
518
.unpin = drm_gem_shmem_object_unpin,
···
586
529
.export = amdxdna_gem_prime_export,
587
530
};
588
531
589
-
static struct amdxdna_gem_obj *
590
-
amdxdna_gem_create_obj(struct drm_device *dev, size_t size)
591
-
{
592
-
struct amdxdna_gem_obj *abo;
593
-
594
-
abo = kzalloc_obj(*abo);
595
-
if (!abo)
596
-
return ERR_PTR(-ENOMEM);
597
-
598
-
abo->pinned = false;
599
-
abo->assigned_hwctx = AMDXDNA_INVALID_CTX_HANDLE;
600
-
mutex_init(&abo->lock);
601
-
602
-
abo->mem.userptr = AMDXDNA_INVALID_ADDR;
603
-
abo->mem.dev_addr = AMDXDNA_INVALID_ADDR;
604
-
abo->mem.dma_addr = AMDXDNA_INVALID_ADDR;
605
-
abo->mem.size = size;
606
-
INIT_LIST_HEAD(&abo->mem.umap_list);
607
-
608
-
return abo;
609
-
}
610
-
611
532
/* For drm_driver->gem_create_object callback */
612
533
struct drm_gem_object *
613
-
amdxdna_gem_create_object_cb(struct drm_device *dev, size_t size)
534
+
amdxdna_gem_create_shmem_object_cb(struct drm_device *dev, size_t size)
614
535
{
615
536
struct amdxdna_gem_obj *abo;
616
537
···
602
567
}
603
568
604
569
static struct amdxdna_gem_obj *
605
-
amdxdna_gem_create_shmem_object(struct drm_device *dev, size_t size)
570
+
amdxdna_gem_create_shmem_object(struct drm_device *dev, struct amdxdna_drm_create_bo *args)
606
571
{
572
+
size_t size = args->size;
607
573
struct drm_gem_shmem_object *shmem = drm_gem_shmem_create(dev, size);
608
574
609
575
if (IS_ERR(shmem))
···
618
582
amdxdna_gem_create_ubuf_object(struct drm_device *dev, struct amdxdna_drm_create_bo *args)
619
583
{
620
584
struct amdxdna_dev *xdna = to_xdna_dev(dev);
621
-
enum amdxdna_ubuf_flag flags = 0;
622
585
struct amdxdna_drm_va_tbl va_tbl;
623
586
struct drm_gem_object *gobj;
624
587
struct dma_buf *dma_buf;
···
628
593
}
629
594
630
595
if (va_tbl.num_entries) {
631
-
if (args->type == AMDXDNA_BO_CMD)
632
-
flags |= AMDXDNA_UBUF_FLAG_MAP_DMA;
633
-
634
-
dma_buf = amdxdna_get_ubuf(dev, flags, va_tbl.num_entries,
596
+
dma_buf = amdxdna_get_ubuf(dev, va_tbl.num_entries,
635
597
u64_to_user_ptr(args->vaddr + sizeof(va_tbl)));
636
598
} else {
637
599
dma_buf = dma_buf_get(va_tbl.dmabuf_fd);
···
646
614
dma_buf_put(dma_buf);
647
615
648
616
return to_xdna_obj(gobj);
649
-
}
650
-
651
-
static struct amdxdna_gem_obj *
652
-
amdxdna_gem_create_object(struct drm_device *dev,
653
-
struct amdxdna_drm_create_bo *args)
654
-
{
655
-
size_t aligned_sz = PAGE_ALIGN(args->size);
656
-
657
-
if (args->vaddr)
658
-
return amdxdna_gem_create_ubuf_object(dev, args);
659
-
660
-
return amdxdna_gem_create_shmem_object(dev, aligned_sz);
661
617
}
662
618
663
619
struct drm_gem_object *
···
680
660
abo = to_xdna_obj(gobj);
681
661
abo->attach = attach;
682
662
abo->dma_buf = dma_buf;
683
-
abo->type = AMDXDNA_BO_SHMEM;
663
+
abo->type = AMDXDNA_BO_SHARE;
664
+
gobj->resv = dma_buf->resv;
684
665
685
666
return gobj;
686
667
···
696
675
}
697
676
698
677
static struct amdxdna_gem_obj *
699
-
amdxdna_drm_alloc_shmem(struct drm_device *dev,
700
-
struct amdxdna_drm_create_bo *args,
701
-
struct drm_file *filp)
678
+
amdxdna_drm_create_share_bo(struct drm_device *dev,
679
+
struct amdxdna_drm_create_bo *args, struct drm_file *filp)
702
680
{
703
-
struct amdxdna_client *client = filp->driver_priv;
704
681
struct amdxdna_gem_obj *abo;
705
682
706
-
abo = amdxdna_gem_create_object(dev, args);
683
+
if (args->vaddr)
684
+
abo = amdxdna_gem_create_ubuf_object(dev, args);
685
+
else
686
+
abo = amdxdna_gem_create_shmem_object(dev, args);
707
687
if (IS_ERR(abo))
708
688
return ERR_CAST(abo);
709
689
710
-
abo->client = client;
711
-
abo->type = AMDXDNA_BO_SHMEM;
690
+
if (args->type == AMDXDNA_BO_DEV_HEAP)
691
+
abo->type = AMDXDNA_BO_DEV_HEAP;
692
+
else
693
+
abo->type = AMDXDNA_BO_SHARE;
712
694
713
695
return abo;
714
696
}
715
697
716
698
static struct amdxdna_gem_obj *
717
-
amdxdna_drm_create_dev_heap(struct drm_device *dev,
718
-
struct amdxdna_drm_create_bo *args,
719
-
struct drm_file *filp)
699
+
amdxdna_drm_create_dev_heap_bo(struct drm_device *dev,
700
+
struct amdxdna_drm_create_bo *args, struct drm_file *filp)
720
701
{
721
702
struct amdxdna_client *client = filp->driver_priv;
722
703
struct amdxdna_dev *xdna = to_xdna_dev(dev);
723
704
struct amdxdna_gem_obj *abo;
724
705
int ret;
725
706
726
-
if (args->size > xdna->dev_info->dev_mem_size) {
727
-
XDNA_DBG(xdna, "Invalid dev heap size 0x%llx, limit 0x%lx",
707
+
WARN_ON(!is_power_of_2(xdna->dev_info->dev_mem_size));
708
+
XDNA_DBG(xdna, "Requested dev heap size 0x%llx", args->size);
709
+
if (!args->size || !IS_ALIGNED(args->size, xdna->dev_info->dev_mem_size)) {
710
+
XDNA_ERR(xdna, "The dev heap size 0x%llx is not multiple of 0x%lx",
728
711
args->size, xdna->dev_info->dev_mem_size);
729
712
return ERR_PTR(-EINVAL);
730
713
}
731
714
715
+
/* HEAP BO is a special case of SHARE BO. */
716
+
abo = amdxdna_drm_create_share_bo(dev, args, filp);
717
+
if (IS_ERR(abo))
718
+
return ERR_CAST(abo);
719
+
720
+
/* Set up heap for this client. */
732
721
mutex_lock(&client->mm_lock);
722
+
733
723
if (client->dev_heap) {
734
724
XDNA_DBG(client->xdna, "dev heap is already created");
735
725
ret = -EBUSY;
736
726
goto mm_unlock;
737
727
}
738
-
739
-
abo = amdxdna_gem_create_object(dev, args);
740
-
if (IS_ERR(abo)) {
741
-
ret = PTR_ERR(abo);
742
-
goto mm_unlock;
743
-
}
744
-
745
-
abo->type = AMDXDNA_BO_DEV_HEAP;
746
-
abo->client = client;
747
-
abo->mem.dev_addr = client->xdna->dev_info->dev_mem_base;
748
-
drm_mm_init(&abo->mm, abo->mem.dev_addr, abo->mem.size);
749
-
750
-
ret = amdxdna_gem_obj_vmap(abo, &abo->mem.kva);
751
-
if (ret) {
752
-
XDNA_ERR(xdna, "Vmap heap bo failed, ret %d", ret);
753
-
goto release_obj;
754
-
}
755
-
756
728
client->dev_heap = abo;
757
729
drm_gem_object_get(to_gobj(abo));
730
+
731
+
drm_mm_init(&abo->mm, xdna->dev_info->dev_mem_base, abo->mem.size);
732
+
758
733
mutex_unlock(&client->mm_lock);
759
734
760
735
return abo;
761
736
762
-
release_obj:
763
-
drm_gem_object_put(to_gobj(abo));
764
737
mm_unlock:
765
738
mutex_unlock(&client->mm_lock);
739
+
drm_gem_object_put(to_gobj(abo));
766
740
return ERR_PTR(ret);
767
741
}
768
742
769
743
struct amdxdna_gem_obj *
770
-
amdxdna_drm_alloc_dev_bo(struct drm_device *dev,
771
-
struct amdxdna_drm_create_bo *args,
772
-
struct drm_file *filp)
744
+
amdxdna_drm_create_dev_bo(struct drm_device *dev,
745
+
struct amdxdna_drm_create_bo *args, struct drm_file *filp)
773
746
{
747
+
size_t aligned_sz = PAGE_ALIGN(args->size);
774
748
struct amdxdna_client *client = filp->driver_priv;
775
749
struct amdxdna_dev *xdna = to_xdna_dev(dev);
776
-
size_t aligned_sz = PAGE_ALIGN(args->size);
777
750
struct amdxdna_gem_obj *abo;
751
+
struct drm_gem_object *gobj;
778
752
int ret;
779
753
780
-
abo = amdxdna_gem_create_obj(&xdna->ddev, aligned_sz);
754
+
if (!aligned_sz) {
755
+
XDNA_ERR(xdna, "Invalid BO size 0x%llx", args->size);
756
+
return ERR_PTR(-EINVAL);
757
+
}
758
+
759
+
abo = amdxdna_gem_create_obj(dev, aligned_sz);
781
760
if (IS_ERR(abo))
782
761
return abo;
783
-
784
-
to_gobj(abo)->funcs = &amdxdna_gem_dev_obj_funcs;
762
+
gobj = to_gobj(abo);
763
+
gobj->funcs = &amdxdna_gem_dev_obj_funcs;
785
764
abo->type = AMDXDNA_BO_DEV;
786
765
abo->client = client;
787
766
···
791
770
amdxdna_gem_destroy_obj(abo);
792
771
return ERR_PTR(ret);
793
772
}
794
-
795
-
drm_gem_private_object_init(&xdna->ddev, to_gobj(abo), aligned_sz);
796
-
797
-
return abo;
798
-
}
799
-
800
-
static struct amdxdna_gem_obj *
801
-
amdxdna_drm_create_cmd_bo(struct drm_device *dev,
802
-
struct amdxdna_drm_create_bo *args,
803
-
struct drm_file *filp)
804
-
{
805
-
struct amdxdna_dev *xdna = to_xdna_dev(dev);
806
-
struct amdxdna_gem_obj *abo;
807
-
808
-
if (args->size < sizeof(struct amdxdna_cmd)) {
809
-
XDNA_DBG(xdna, "Command BO size 0x%llx too small", args->size);
810
-
return ERR_PTR(-EINVAL);
811
-
}
812
-
813
-
abo = amdxdna_gem_create_object(dev, args);
814
-
if (IS_ERR(abo))
815
-
return ERR_CAST(abo);
816
-
817
-
abo->type = AMDXDNA_BO_CMD;
818
-
abo->client = filp->driver_priv;
773
+
drm_gem_private_object_init(dev, gobj, aligned_sz);
819
774
820
775
return abo;
821
776
}
···
809
812
XDNA_DBG(xdna, "BO arg type %d vaddr 0x%llx size 0x%llx flags 0x%llx",
810
813
args->type, args->vaddr, args->size, args->flags);
811
814
switch (args->type) {
812
-
case AMDXDNA_BO_SHMEM:
813
-
abo = amdxdna_drm_alloc_shmem(dev, args, filp);
815
+
case AMDXDNA_BO_CMD:
816
+
fallthrough;
817
+
case AMDXDNA_BO_SHARE:
818
+
abo = amdxdna_drm_create_share_bo(dev, args, filp);
814
819
break;
815
820
case AMDXDNA_BO_DEV_HEAP:
816
-
abo = amdxdna_drm_create_dev_heap(dev, args, filp);
821
+
abo = amdxdna_drm_create_dev_heap_bo(dev, args, filp);
817
822
break;
818
823
case AMDXDNA_BO_DEV:
819
-
abo = amdxdna_drm_alloc_dev_bo(dev, args, filp);
820
-
break;
821
-
case AMDXDNA_BO_CMD:
822
-
abo = amdxdna_drm_create_cmd_bo(dev, args, filp);
824
+
abo = amdxdna_drm_create_dev_bo(dev, args, filp);
823
825
break;
824
826
default:
825
827
return -EINVAL;
···
834
838
}
835
839
836
840
XDNA_DBG(xdna, "BO hdl %d type %d userptr 0x%llx xdna_addr 0x%llx size 0x%lx",
837
-
args->handle, args->type, abo->mem.userptr,
838
-
abo->mem.dev_addr, abo->mem.size);
841
+
args->handle, args->type, amdxdna_gem_uva(abo),
842
+
amdxdna_gem_dev_addr(abo), abo->mem.size);
839
843
put_obj:
840
844
/* Dereference object reference. Handle holds it now. */
841
845
drm_gem_object_put(to_gobj(abo));
···
886
890
struct amdxdna_gem_obj *amdxdna_gem_get_obj(struct amdxdna_client *client,
887
891
u32 bo_hdl, u8 bo_type)
888
892
{
889
-
struct amdxdna_dev *xdna = client->xdna;
890
893
struct amdxdna_gem_obj *abo;
891
894
struct drm_gem_object *gobj;
892
-
int ret;
893
895
894
896
gobj = drm_gem_object_lookup(client->filp, bo_hdl);
895
897
if (!gobj) {
896
-
XDNA_DBG(xdna, "Can not find bo %d", bo_hdl);
898
+
XDNA_DBG(client->xdna, "Can not find bo %d", bo_hdl);
897
899
return NULL;
898
900
}
899
901
900
902
abo = to_xdna_obj(gobj);
901
-
if (bo_type != AMDXDNA_BO_INVALID && abo->type != bo_type)
902
-
goto put_obj;
903
-
904
-
if (bo_type != AMDXDNA_BO_CMD || abo->mem.kva)
903
+
if (bo_type == AMDXDNA_BO_INVALID || abo->type == bo_type)
905
904
return abo;
906
905
907
-
if (abo->mem.size > SZ_32K) {
908
-
XDNA_ERR(xdna, "Cmd bo is too big %ld", abo->mem.size);
909
-
goto put_obj;
910
-
}
911
-
912
-
ret = amdxdna_gem_obj_vmap(abo, &abo->mem.kva);
913
-
if (ret) {
914
-
XDNA_ERR(xdna, "Vmap cmd bo failed, ret %d", ret);
915
-
goto put_obj;
916
-
}
917
-
918
-
return abo;
919
-
920
-
put_obj:
921
906
drm_gem_object_put(gobj);
922
907
return NULL;
923
908
}
···
921
944
}
922
945
923
946
abo = to_xdna_obj(gobj);
924
-
args->vaddr = abo->mem.userptr;
925
-
if (abo->mem.dev_addr != AMDXDNA_INVALID_ADDR)
926
-
args->xdna_addr = abo->mem.dev_addr;
927
-
else
928
-
args->xdna_addr = abo->mem.dma_addr;
947
+
args->vaddr = amdxdna_gem_uva(abo);
948
+
args->xdna_addr = amdxdna_gem_dev_addr(abo);
929
949
930
950
if (abo->type != AMDXDNA_BO_DEV)
931
951
args->map_offset = drm_vma_node_offset_addr(&gobj->vma_node);
···
967
993
968
994
if (is_import_bo(abo))
969
995
drm_clflush_sg(abo->base.sgt);
970
-
else if (abo->mem.kva)
971
-
drm_clflush_virt_range(abo->mem.kva + args->offset, args->size);
996
+
else if (amdxdna_gem_vmap(abo))
997
+
drm_clflush_virt_range(amdxdna_gem_vmap(abo) + args->offset, args->size);
972
998
else if (abo->base.pages)
973
999
drm_clflush_pages(abo->base.pages, gobj->size >> PAGE_SHIFT);
974
1000
else
+17
-15
drivers/accel/amdxdna/amdxdna_gem.h
+17
-15
drivers/accel/amdxdna/amdxdna_gem.h
···
24
24
};
25
25
26
26
struct amdxdna_mem {
27
-
u64 userptr;
28
27
void *kva;
29
-
u64 dev_addr;
30
28
u64 dma_addr;
31
29
size_t size;
32
-
struct page **pages;
33
-
u32 nr_pages;
34
30
struct list_head umap_list;
35
31
bool map_invalid;
32
+
/*
33
+
* Cache the first mmap uva as PASID addr, which can be accessed by driver
34
+
* without taking notifier_lock.
35
+
*/
36
+
u64 uva;
36
37
};
37
38
38
39
struct amdxdna_gem_obj {
···
41
40
struct amdxdna_client *client;
42
41
u8 type;
43
42
bool pinned;
44
-
struct mutex lock; /* Protects: pinned */
43
+
struct mutex lock; /* Protects: pinned, mem.kva */
45
44
struct amdxdna_mem mem;
46
-
u32 ref;
47
45
48
-
/* Below members is uninitialized when needed */
46
+
/* Below members are initialized when needed */
49
47
struct drm_mm mm; /* For AMDXDNA_BO_DEV_HEAP */
50
48
struct drm_mm_node mm_node; /* For AMDXDNA_BO_DEV */
51
49
u32 assigned_hwctx;
···
67
67
drm_gem_object_put(to_gobj(abo));
68
68
}
69
69
70
+
void *amdxdna_gem_vmap(struct amdxdna_gem_obj *abo);
71
+
u64 amdxdna_gem_uva(struct amdxdna_gem_obj *abo);
72
+
u64 amdxdna_gem_dev_addr(struct amdxdna_gem_obj *abo);
73
+
70
74
static inline u64 amdxdna_dev_bo_offset(struct amdxdna_gem_obj *abo)
71
75
{
72
-
return abo->mem.dev_addr - abo->client->dev_heap->mem.dev_addr;
76
+
return amdxdna_gem_dev_addr(abo) - amdxdna_gem_dev_addr(abo->client->dev_heap);
73
77
}
74
78
75
-
static inline u64 amdxdna_obj_dma_addr(struct amdxdna_client *client,
76
-
struct amdxdna_gem_obj *abo)
79
+
static inline u64 amdxdna_obj_dma_addr(struct amdxdna_gem_obj *abo)
77
80
{
78
-
return amdxdna_pasid_on(client) ? abo->mem.userptr : abo->mem.dma_addr;
81
+
return amdxdna_pasid_on(abo->client) ? amdxdna_gem_uva(abo) : abo->mem.dma_addr;
79
82
}
80
83
81
84
void amdxdna_umap_put(struct amdxdna_umap *mapp);
82
85
83
86
struct drm_gem_object *
84
-
amdxdna_gem_create_object_cb(struct drm_device *dev, size_t size);
87
+
amdxdna_gem_create_shmem_object_cb(struct drm_device *dev, size_t size);
85
88
struct drm_gem_object *
86
89
amdxdna_gem_prime_import(struct drm_device *dev, struct dma_buf *dma_buf);
87
90
struct amdxdna_gem_obj *
88
-
amdxdna_drm_alloc_dev_bo(struct drm_device *dev,
89
-
struct amdxdna_drm_create_bo *args,
90
-
struct drm_file *filp);
91
+
amdxdna_drm_create_dev_bo(struct drm_device *dev,
92
+
struct amdxdna_drm_create_bo *args, struct drm_file *filp);
91
93
92
94
int amdxdna_gem_pin_nolock(struct amdxdna_gem_obj *abo);
93
95
int amdxdna_gem_pin(struct amdxdna_gem_obj *abo);
+1
-1
drivers/accel/amdxdna/amdxdna_pci_drv.c
+1
-1
drivers/accel/amdxdna/amdxdna_pci_drv.c
+4
-13
drivers/accel/amdxdna/amdxdna_ubuf.c
+4
-13
drivers/accel/amdxdna/amdxdna_ubuf.c
···
17
17
struct amdxdna_ubuf_priv {
18
18
struct page **pages;
19
19
u64 nr_pages;
20
-
enum amdxdna_ubuf_flag flags;
21
20
struct mm_struct *mm;
22
21
};
23
22
···
36
37
if (ret)
37
38
goto err_free_sg;
38
39
39
-
if (ubuf->flags & AMDXDNA_UBUF_FLAG_MAP_DMA) {
40
-
ret = dma_map_sgtable(attach->dev, sg, direction, 0);
41
-
if (ret)
42
-
goto err_free_table;
43
-
}
40
+
ret = dma_map_sgtable(attach->dev, sg, direction, 0);
41
+
if (ret)
42
+
goto err_free_table;
44
43
45
44
return sg;
46
45
···
53
56
struct sg_table *sg,
54
57
enum dma_data_direction direction)
55
58
{
56
-
struct amdxdna_ubuf_priv *ubuf = attach->dmabuf->priv;
57
-
58
-
if (ubuf->flags & AMDXDNA_UBUF_FLAG_MAP_DMA)
59
-
dma_unmap_sgtable(attach->dev, sg, direction, 0);
60
-
59
+
dma_unmap_sgtable(attach->dev, sg, direction, 0);
61
60
sg_free_table(sg);
62
61
kfree(sg);
63
62
}
···
126
133
};
127
134
128
135
struct dma_buf *amdxdna_get_ubuf(struct drm_device *dev,
129
-
enum amdxdna_ubuf_flag flags,
130
136
u32 num_entries, void __user *va_entries)
131
137
{
132
138
struct amdxdna_dev *xdna = to_xdna_dev(dev);
···
144
152
if (!ubuf)
145
153
return ERR_PTR(-ENOMEM);
146
154
147
-
ubuf->flags = flags;
148
155
ubuf->mm = current->mm;
149
156
mmgrab(ubuf->mm);
150
157
-5
drivers/accel/amdxdna/amdxdna_ubuf.h
-5
drivers/accel/amdxdna/amdxdna_ubuf.h
···
8
8
#include <drm/drm_device.h>
9
9
#include <linux/dma-buf.h>
10
10
11
-
enum amdxdna_ubuf_flag {
12
-
AMDXDNA_UBUF_FLAG_MAP_DMA = 1,
13
-
};
14
-
15
11
struct dma_buf *amdxdna_get_ubuf(struct drm_device *dev,
16
-
enum amdxdna_ubuf_flag flags,
17
12
u32 num_entries, void __user *va_entries);
18
13
19
14
#endif /* _AMDXDNA_UBUF_H_ */
+5
-4
include/uapi/drm/amdxdna_accel.h
+5
-4
include/uapi/drm/amdxdna_accel.h
···
156
156
157
157
enum amdxdna_bo_type {
158
158
AMDXDNA_BO_INVALID = 0,
159
-
AMDXDNA_BO_SHMEM,
160
-
AMDXDNA_BO_DEV_HEAP,
161
-
AMDXDNA_BO_DEV,
162
-
AMDXDNA_BO_CMD,
159
+
AMDXDNA_BO_SHMEM = 1, /* Be compatible with legacy application code. */
160
+
AMDXDNA_BO_SHARE = 1,
161
+
AMDXDNA_BO_DEV_HEAP = 2,
162
+
AMDXDNA_BO_DEV = 3,
163
+
AMDXDNA_BO_CMD = 4,
163
164
};
164
165
165
166
/**