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#include <drm/drmP.h>
29#include <drm/ttm/ttm_page_alloc.h>
30
31#include "ast_drv.h"
32
33static inline struct ast_private *
34ast_bdev(struct ttm_bo_device *bd)
35{
36 return container_of(bd, struct ast_private, ttm.bdev);
37}
38
39static void ast_bo_ttm_destroy(struct ttm_buffer_object *tbo)
40{
41 struct ast_bo *bo;
42
43 bo = container_of(tbo, struct ast_bo, bo);
44
45 drm_gem_object_release(&bo->gem);
46 kfree(bo);
47}
48
49static bool ast_ttm_bo_is_ast_bo(struct ttm_buffer_object *bo)
50{
51 if (bo->destroy == &ast_bo_ttm_destroy)
52 return true;
53 return false;
54}
55
56static int
57ast_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
58 struct ttm_mem_type_manager *man)
59{
60 switch (type) {
61 case TTM_PL_SYSTEM:
62 man->flags = TTM_MEMTYPE_FLAG_MAPPABLE;
63 man->available_caching = TTM_PL_MASK_CACHING;
64 man->default_caching = TTM_PL_FLAG_CACHED;
65 break;
66 case TTM_PL_VRAM:
67 man->func = &ttm_bo_manager_func;
68 man->flags = TTM_MEMTYPE_FLAG_FIXED |
69 TTM_MEMTYPE_FLAG_MAPPABLE;
70 man->available_caching = TTM_PL_FLAG_UNCACHED |
71 TTM_PL_FLAG_WC;
72 man->default_caching = TTM_PL_FLAG_WC;
73 break;
74 default:
75 DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
76 return -EINVAL;
77 }
78 return 0;
79}
80
81static void
82ast_bo_evict_flags(struct ttm_buffer_object *bo, struct ttm_placement *pl)
83{
84 struct ast_bo *astbo = ast_bo(bo);
85
86 if (!ast_ttm_bo_is_ast_bo(bo))
87 return;
88
89 ast_ttm_placement(astbo, TTM_PL_FLAG_SYSTEM);
90 *pl = astbo->placement;
91}
92
93static int ast_bo_verify_access(struct ttm_buffer_object *bo, struct file *filp)
94{
95 struct ast_bo *astbo = ast_bo(bo);
96
97 return drm_vma_node_verify_access(&astbo->gem.vma_node,
98 filp->private_data);
99}
100
101static int ast_ttm_io_mem_reserve(struct ttm_bo_device *bdev,
102 struct ttm_mem_reg *mem)
103{
104 struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type];
105 struct ast_private *ast = ast_bdev(bdev);
106
107 mem->bus.addr = NULL;
108 mem->bus.offset = 0;
109 mem->bus.size = mem->num_pages << PAGE_SHIFT;
110 mem->bus.base = 0;
111 mem->bus.is_iomem = false;
112 if (!(man->flags & TTM_MEMTYPE_FLAG_MAPPABLE))
113 return -EINVAL;
114 switch (mem->mem_type) {
115 case TTM_PL_SYSTEM:
116
117 return 0;
118 case TTM_PL_VRAM:
119 mem->bus.offset = mem->start << PAGE_SHIFT;
120 mem->bus.base = pci_resource_start(ast->dev->pdev, 0);
121 mem->bus.is_iomem = true;
122 break;
123 default:
124 return -EINVAL;
125 break;
126 }
127 return 0;
128}
129
130static void ast_ttm_io_mem_free(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
131{
132}
133
134static void ast_ttm_backend_destroy(struct ttm_tt *tt)
135{
136 ttm_tt_fini(tt);
137 kfree(tt);
138}
139
140static struct ttm_backend_func ast_tt_backend_func = {
141 .destroy = &ast_ttm_backend_destroy,
142};
143
144
145static struct ttm_tt *ast_ttm_tt_create(struct ttm_buffer_object *bo,
146 uint32_t page_flags)
147{
148 struct ttm_tt *tt;
149
150 tt = kzalloc(sizeof(struct ttm_tt), GFP_KERNEL);
151 if (tt == NULL)
152 return NULL;
153 tt->func = &ast_tt_backend_func;
154 if (ttm_tt_init(tt, bo, page_flags)) {
155 kfree(tt);
156 return NULL;
157 }
158 return tt;
159}
160
161struct ttm_bo_driver ast_bo_driver = {
162 .ttm_tt_create = ast_ttm_tt_create,
163 .init_mem_type = ast_bo_init_mem_type,
164 .eviction_valuable = ttm_bo_eviction_valuable,
165 .evict_flags = ast_bo_evict_flags,
166 .move = NULL,
167 .verify_access = ast_bo_verify_access,
168 .io_mem_reserve = &ast_ttm_io_mem_reserve,
169 .io_mem_free = &ast_ttm_io_mem_free,
170};
171
172int ast_mm_init(struct ast_private *ast)
173{
174 int ret;
175 struct drm_device *dev = ast->dev;
176 struct ttm_bo_device *bdev = &ast->ttm.bdev;
177
178 ret = ttm_bo_device_init(&ast->ttm.bdev,
179 &ast_bo_driver,
180 dev->anon_inode->i_mapping,
181 DRM_FILE_PAGE_OFFSET,
182 true);
183 if (ret) {
184 DRM_ERROR("Error initialising bo driver; %d\n", ret);
185 return ret;
186 }
187
188 ret = ttm_bo_init_mm(bdev, TTM_PL_VRAM,
189 ast->vram_size >> PAGE_SHIFT);
190 if (ret) {
191 DRM_ERROR("Failed ttm VRAM init: %d\n", ret);
192 return ret;
193 }
194
195 arch_io_reserve_memtype_wc(pci_resource_start(dev->pdev, 0),
196 pci_resource_len(dev->pdev, 0));
197 ast->fb_mtrr = arch_phys_wc_add(pci_resource_start(dev->pdev, 0),
198 pci_resource_len(dev->pdev, 0));
199
200 return 0;
201}
202
203void ast_mm_fini(struct ast_private *ast)
204{
205 struct drm_device *dev = ast->dev;
206
207 ttm_bo_device_release(&ast->ttm.bdev);
208
209 arch_phys_wc_del(ast->fb_mtrr);
210 arch_io_free_memtype_wc(pci_resource_start(dev->pdev, 0),
211 pci_resource_len(dev->pdev, 0));
212}
213
214void ast_ttm_placement(struct ast_bo *bo, int domain)
215{
216 u32 c = 0;
217 unsigned i;
218
219 bo->placement.placement = bo->placements;
220 bo->placement.busy_placement = bo->placements;
221 if (domain & TTM_PL_FLAG_VRAM)
222 bo->placements[c++].flags = TTM_PL_FLAG_WC | TTM_PL_FLAG_UNCACHED | TTM_PL_FLAG_VRAM;
223 if (domain & TTM_PL_FLAG_SYSTEM)
224 bo->placements[c++].flags = TTM_PL_FLAG_CACHED | TTM_PL_FLAG_SYSTEM;
225 if (!c)
226 bo->placements[c++].flags = TTM_PL_FLAG_CACHED | TTM_PL_FLAG_SYSTEM;
227 bo->placement.num_placement = c;
228 bo->placement.num_busy_placement = c;
229 for (i = 0; i < c; ++i) {
230 bo->placements[i].fpfn = 0;
231 bo->placements[i].lpfn = 0;
232 }
233}
234
235int ast_bo_create(struct drm_device *dev, int size, int align,
236 uint32_t flags, struct ast_bo **pastbo)
237{
238 struct ast_private *ast = dev->dev_private;
239 struct ast_bo *astbo;
240 size_t acc_size;
241 int ret;
242
243 astbo = kzalloc(sizeof(struct ast_bo), GFP_KERNEL);
244 if (!astbo)
245 return -ENOMEM;
246
247 ret = drm_gem_object_init(dev, &astbo->gem, size);
248 if (ret)
249 goto error;
250
251 astbo->bo.bdev = &ast->ttm.bdev;
252
253 ast_ttm_placement(astbo, TTM_PL_FLAG_VRAM | TTM_PL_FLAG_SYSTEM);
254
255 acc_size = ttm_bo_dma_acc_size(&ast->ttm.bdev, size,
256 sizeof(struct ast_bo));
257
258 ret = ttm_bo_init(&ast->ttm.bdev, &astbo->bo, size,
259 ttm_bo_type_device, &astbo->placement,
260 align >> PAGE_SHIFT, false, acc_size,
261 NULL, NULL, ast_bo_ttm_destroy);
262 if (ret)
263 goto error;
264
265 *pastbo = astbo;
266 return 0;
267error:
268 kfree(astbo);
269 return ret;
270}
271
272static inline u64 ast_bo_gpu_offset(struct ast_bo *bo)
273{
274 return bo->bo.offset;
275}
276
277int ast_bo_pin(struct ast_bo *bo, u32 pl_flag, u64 *gpu_addr)
278{
279 struct ttm_operation_ctx ctx = { false, false };
280 int i, ret;
281
282 if (bo->pin_count) {
283 bo->pin_count++;
284 if (gpu_addr)
285 *gpu_addr = ast_bo_gpu_offset(bo);
286 }
287
288 ast_ttm_placement(bo, pl_flag);
289 for (i = 0; i < bo->placement.num_placement; i++)
290 bo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT;
291 ret = ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
292 if (ret)
293 return ret;
294
295 bo->pin_count = 1;
296 if (gpu_addr)
297 *gpu_addr = ast_bo_gpu_offset(bo);
298 return 0;
299}
300
301int ast_bo_unpin(struct ast_bo *bo)
302{
303 struct ttm_operation_ctx ctx = { false, false };
304 int i;
305 if (!bo->pin_count) {
306 DRM_ERROR("unpin bad %p\n", bo);
307 return 0;
308 }
309 bo->pin_count--;
310 if (bo->pin_count)
311 return 0;
312
313 for (i = 0; i < bo->placement.num_placement ; i++)
314 bo->placements[i].flags &= ~TTM_PL_FLAG_NO_EVICT;
315 return ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
316}
317
318int ast_bo_push_sysram(struct ast_bo *bo)
319{
320 struct ttm_operation_ctx ctx = { false, false };
321 int i, ret;
322 if (!bo->pin_count) {
323 DRM_ERROR("unpin bad %p\n", bo);
324 return 0;
325 }
326 bo->pin_count--;
327 if (bo->pin_count)
328 return 0;
329
330 if (bo->kmap.virtual)
331 ttm_bo_kunmap(&bo->kmap);
332
333 ast_ttm_placement(bo, TTM_PL_FLAG_SYSTEM);
334 for (i = 0; i < bo->placement.num_placement ; i++)
335 bo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT;
336
337 ret = ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
338 if (ret) {
339 DRM_ERROR("pushing to VRAM failed\n");
340 return ret;
341 }
342 return 0;
343}
344
345int ast_mmap(struct file *filp, struct vm_area_struct *vma)
346{
347 struct drm_file *file_priv;
348 struct ast_private *ast;
349
350 if (unlikely(vma->vm_pgoff < DRM_FILE_PAGE_OFFSET))
351 return -EINVAL;
352
353 file_priv = filp->private_data;
354 ast = file_priv->minor->dev->dev_private;
355 return ttm_bo_mmap(filp, vma, &ast->ttm.bdev);
356}
357
