1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
|
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#include <linux/list_sort.h>
#include "linux/sde_rsc.h"
#include "dsi/dsi_display.h"
#include "dp/dp_display.h"
#include "sde_kms.h"
#include "sde_vm_common.h"
#include "sde_crtc.h"
struct hh_notify_vmid_desc *sde_vm_populate_vmid(hh_vmid_t vmid)
{
struct hh_notify_vmid_desc *vmid_desc;
vmid_desc = kzalloc(offsetof(struct hh_notify_vmid_desc,
vmid_entries[1]), GFP_KERNEL);
if (!vmid_desc)
return ERR_PTR(ENOMEM);
vmid_desc->n_vmid_entries = 1;
vmid_desc->vmid_entries[0].vmid = vmid;
return vmid_desc;
}
struct hh_acl_desc *sde_vm_populate_acl(enum hh_vm_names vm_name)
{
struct hh_acl_desc *acl_desc;
hh_vmid_t vmid;
hh_rm_get_vmid(vm_name, &vmid);
acl_desc = kzalloc(offsetof(struct hh_acl_desc, acl_entries[1]),
GFP_KERNEL);
if (!acl_desc)
return ERR_PTR(ENOMEM);
acl_desc->n_acl_entries = 1;
acl_desc->acl_entries[0].vmid = vmid;
acl_desc->acl_entries[0].perms = HH_RM_ACL_R | HH_RM_ACL_W;
return acl_desc;
}
int __mem_sort_cmp(void *priv, struct list_head *a, struct list_head *b)
{
struct msm_io_mem_entry *left =
container_of(a, struct msm_io_mem_entry, list);
struct msm_io_mem_entry *right =
container_of(b, struct msm_io_mem_entry, list);
return (left->base - right->base);
}
bool __merge_on_overlap(struct msm_io_mem_entry *res,
const struct msm_io_mem_entry *left,
const struct msm_io_mem_entry *right)
{
phys_addr_t l_s = left->base;
phys_addr_t l_e = left->base + left->size;
phys_addr_t r_s = right->base;
phys_addr_t r_e = right->base + right->size;
memset(res, 0, sizeof(*res));
if (r_s <= l_e) {
res->base = min(l_s, r_s);
res->size = max(l_e, r_e) - res->base;
return true;
}
return false;
}
void _sde_vm_sort_and_align(struct list_head *mem)
{
struct msm_io_mem_entry *entry, *tmp, *prev = NULL;
struct msm_io_mem_entry merged_entry;
list_for_each_entry(entry, mem, list) {
entry->base = ALIGN_DOWN(entry->base, PAGE_SIZE);
entry->size = ALIGN(entry->size, PAGE_SIZE);
}
list_sort(NULL, mem, __mem_sort_cmp);
list_for_each_entry_safe(entry, tmp, mem, list) {
if (prev && __merge_on_overlap(&merged_entry, prev, entry)) {
prev->base = merged_entry.base;
prev->size = merged_entry.size;
list_del(&entry->list);
entry = prev;
}
prev = entry;
}
list_for_each_entry(entry, mem, list)
SDE_DEBUG("base: 0x%x - size: 0x%x\n",
entry->base, entry->size);
}
struct hh_sgl_desc *sde_vm_populate_sgl(struct msm_io_res *io_res)
{
struct hh_sgl_desc *sgl_desc;
struct msm_io_mem_entry *mem;
u32 i = 0, num_mem_entry = 0;
_sde_vm_sort_and_align(&io_res->mem);
list_for_each_entry(mem, &io_res->mem, list)
num_mem_entry++;
sgl_desc = kzalloc(offsetof(struct hh_sgl_desc,
sgl_entries[num_mem_entry]), GFP_KERNEL);
if (!sgl_desc)
return ERR_PTR(ENOMEM);
sgl_desc->n_sgl_entries = num_mem_entry;
list_for_each_entry(mem, &io_res->mem, list) {
sgl_desc->sgl_entries[i].ipa_base = mem->base;
sgl_desc->sgl_entries[i].size = mem->size;
i++;
}
msm_dss_clean_io_mem(&io_res->mem);
return sgl_desc;
}
struct sde_vm_irq_desc *sde_vm_populate_irq(struct msm_io_res *io_res)
{
struct msm_io_irq_entry *irq;
u32 i = 0, num_irq = 0;
struct sde_vm_irq_desc *irq_desc;
list_for_each_entry(irq, &io_res->irq, list)
num_irq++;
irq_desc = kzalloc(sizeof(*irq_desc), GFP_KERNEL);
if (!irq_desc)
return ERR_PTR(ENOMEM);
irq_desc->irq_entries = kcalloc(num_irq,
sizeof(struct sde_vm_irq_entry),
GFP_KERNEL);
if (!irq_desc->irq_entries) {
sde_vm_free_irq(irq_desc);
return ERR_PTR(ENOMEM);
}
list_for_each_entry(irq, &io_res->irq, list) {
struct sde_vm_irq_entry *entry = &irq_desc->irq_entries[i];
entry->irq = irq->irq_num;
entry->label = irq->label;
i++;
}
irq_desc->n_irq = num_irq;
msm_dss_clean_io_irq(&io_res->irq);
return irq_desc;
}
void sde_vm_free_irq(struct sde_vm_irq_desc *irq_desc)
{
if (irq_desc && irq_desc->irq_entries)
kfree(irq_desc->irq_entries);
kfree(irq_desc);
}
int sde_vm_get_resources(struct sde_kms *sde_kms, struct msm_io_res *io_res)
{
struct msm_drm_private *priv = sde_kms->dev->dev_private;
struct msm_vm_client_entry *entry;
int rc = 0;
rc = sde_kms_get_io_resources(sde_kms, io_res);
if (rc)
goto fail_get_res;
list_for_each_entry(entry, &priv->vm_client_list, list) {
if (!entry->ops.vm_get_io_resources)
continue;
rc = entry->ops.vm_get_io_resources(io_res, entry->data);
if (rc) {
SDE_ERROR("get_io_resources failed for device: %d\n",
entry->dev->id);
goto fail_get_res;
}
}
return rc;
fail_get_res:
msm_dss_clean_io_mem(&io_res->mem);
msm_dss_clean_io_irq(&io_res->irq);
return rc;
}
void sde_vm_free_resources(struct msm_io_res *io_res)
{
msm_dss_clean_io_mem(&io_res->mem);
msm_dss_clean_io_irq(&io_res->irq);
}
int sde_vm_post_acquire(struct sde_kms *kms)
{
struct msm_drm_private *priv = kms->dev->dev_private;
struct msm_vm_client_entry *entry;
int rc = 0;
list_for_each_entry(entry, &priv->vm_client_list, list) {
if (!entry->ops.vm_post_hw_acquire)
continue;
rc = entry->ops.vm_post_hw_acquire(entry->data);
if (rc) {
SDE_ERROR("post_acquire failed for device: %d\n",
entry->dev->id);
goto post_acquire_rollback;
}
}
return rc;
post_acquire_rollback:
list_for_each_entry_continue_reverse(entry, &priv->vm_client_list,
list) {
if (!entry->ops.vm_pre_hw_release)
continue;
rc = entry->ops.vm_pre_hw_release(entry->data);
if (rc) {
SDE_ERROR(
"post_acquire failed during rollback for device: %d\n",
entry->dev->id);
break;
}
}
return rc;
}
int sde_vm_pre_release(struct sde_kms *kms)
{
struct msm_drm_private *priv = kms->dev->dev_private;
struct msm_vm_client_entry *entry;
int rc = 0;
list_for_each_entry(entry, &priv->vm_client_list, list) {
if (!entry->ops.vm_pre_hw_release)
continue;
rc = entry->ops.vm_pre_hw_release(entry->data);
if (rc) {
SDE_ERROR("pre_release failed for device: %d\n",
entry->dev->id);
goto pre_release_rollback;
}
}
return rc;
pre_release_rollback:
list_for_each_entry_continue_reverse(entry, &priv->vm_client_list,
list) {
if (!entry->ops.vm_post_hw_acquire)
continue;
rc = entry->ops.vm_post_hw_acquire(entry->data);
if (rc) {
SDE_ERROR(
"post_acquire failed during rollback for device: %d\n",
entry->dev->id);
break;
}
}
return rc;
}
int sde_vm_request_valid(struct sde_kms *sde_kms,
enum sde_crtc_vm_req old_state,
enum sde_crtc_vm_req new_state)
{
struct sde_vm_ops *vm_ops;
int rc = 0;
vm_ops = &sde_kms->vm->vm_ops;
switch (new_state) {
case VM_REQ_RELEASE:
case VM_REQ_NONE:
if ((old_state == VM_REQ_RELEASE) ||
!vm_ops->vm_owns_hw(sde_kms))
rc = -EINVAL;
break;
case VM_REQ_ACQUIRE:
if (old_state != VM_REQ_RELEASE) {
rc = -EINVAL;
} else if (!vm_ops->vm_owns_hw(sde_kms)) {
if (vm_ops->vm_acquire)
rc = vm_ops->vm_acquire(sde_kms);
else
rc = -EINVAL;
}
break;
default:
SDE_ERROR("invalid vm request\n");
rc = -EINVAL;
};
SDE_DEBUG("old req: %d new req: %d owns_hw: %d, rc: %d\n",
old_state, new_state,
vm_ops->vm_owns_hw(sde_kms), rc);
SDE_EVT32(old_state, new_state, vm_ops->vm_owns_hw(sde_kms), rc);
return rc;
}
|