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 "mgag200_drv.h"
32
33static inline struct mga_device *
34mgag200_bdev(struct ttm_bo_device *bd)
35{
36 return container_of(bd, struct mga_device, ttm.bdev);
37}
38
39static void mgag200_bo_ttm_destroy(struct ttm_buffer_object *tbo)
40{
41 struct mgag200_bo *bo;
42
43 bo = container_of(tbo, struct mgag200_bo, bo);
44
45 drm_gem_object_release(&bo->gem);
46 kfree(bo);
47}
48
49static bool mgag200_ttm_bo_is_mgag200_bo(struct ttm_buffer_object *bo)
50{
51 if (bo->destroy == &mgag200_bo_ttm_destroy)
52 return true;
53 return false;
54}
55
56static int
57mgag200_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
82mgag200_bo_evict_flags(struct ttm_buffer_object *bo, struct ttm_placement *pl)
83{
84 struct mgag200_bo *mgabo = mgag200_bo(bo);
85
86 if (!mgag200_ttm_bo_is_mgag200_bo(bo))
87 return;
88
89 mgag200_ttm_placement(mgabo, TTM_PL_FLAG_SYSTEM);
90 *pl = mgabo->placement;
91}
92
93static int mgag200_bo_verify_access(struct ttm_buffer_object *bo, struct file *filp)
94{
95 struct mgag200_bo *mgabo = mgag200_bo(bo);
96
97 return drm_vma_node_verify_access(&mgabo->gem.vma_node,
98 filp->private_data);
99}
100
101static int mgag200_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 mga_device *mdev = mgag200_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(mdev->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 mgag200_ttm_io_mem_free(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
131{
132}
133
134static void mgag200_ttm_backend_destroy(struct ttm_tt *tt)
135{
136 ttm_tt_fini(tt);
137 kfree(tt);
138}
139
140static struct ttm_backend_func mgag200_tt_backend_func = {
141 .destroy = &mgag200_ttm_backend_destroy,
142};
143
144
145static struct ttm_tt *mgag200_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 = &mgag200_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 mgag200_bo_driver = {
162 .ttm_tt_create = mgag200_ttm_tt_create,
163 .init_mem_type = mgag200_bo_init_mem_type,
164 .eviction_valuable = ttm_bo_eviction_valuable,
165 .evict_flags = mgag200_bo_evict_flags,
166 .move = NULL,
167 .verify_access = mgag200_bo_verify_access,
168 .io_mem_reserve = &mgag200_ttm_io_mem_reserve,
169 .io_mem_free = &mgag200_ttm_io_mem_free,
170};
171
172int mgag200_mm_init(struct mga_device *mdev)
173{
174 int ret;
175 struct drm_device *dev = mdev->dev;
176 struct ttm_bo_device *bdev = &mdev->ttm.bdev;
177
178 ret = ttm_bo_device_init(&mdev->ttm.bdev,
179 &mgag200_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, mdev->mc.vram_size >> PAGE_SHIFT);
189 if (ret) {
190 DRM_ERROR("Failed ttm VRAM init: %d\n", ret);
191 return ret;
192 }
193
194 arch_io_reserve_memtype_wc(pci_resource_start(dev->pdev, 0),
195 pci_resource_len(dev->pdev, 0));
196
197 mdev->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 mgag200_mm_fini(struct mga_device *mdev)
204{
205 struct drm_device *dev = mdev->dev;
206
207 ttm_bo_device_release(&mdev->ttm.bdev);
208
209 arch_io_free_memtype_wc(pci_resource_start(dev->pdev, 0),
210 pci_resource_len(dev->pdev, 0));
211 arch_phys_wc_del(mdev->fb_mtrr);
212 mdev->fb_mtrr = 0;
213}
214
215void mgag200_ttm_placement(struct mgag200_bo *bo, int domain)
216{
217 u32 c = 0;
218 unsigned i;
219
220 bo->placement.placement = bo->placements;
221 bo->placement.busy_placement = bo->placements;
222 if (domain & TTM_PL_FLAG_VRAM)
223 bo->placements[c++].flags = TTM_PL_FLAG_WC | TTM_PL_FLAG_UNCACHED | TTM_PL_FLAG_VRAM;
224 if (domain & TTM_PL_FLAG_SYSTEM)
225 bo->placements[c++].flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
226 if (!c)
227 bo->placements[c++].flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
228 bo->placement.num_placement = c;
229 bo->placement.num_busy_placement = c;
230 for (i = 0; i < c; ++i) {
231 bo->placements[i].fpfn = 0;
232 bo->placements[i].lpfn = 0;
233 }
234}
235
236int mgag200_bo_create(struct drm_device *dev, int size, int align,
237 uint32_t flags, struct mgag200_bo **pmgabo)
238{
239 struct mga_device *mdev = dev->dev_private;
240 struct mgag200_bo *mgabo;
241 size_t acc_size;
242 int ret;
243
244 mgabo = kzalloc(sizeof(struct mgag200_bo), GFP_KERNEL);
245 if (!mgabo)
246 return -ENOMEM;
247
248 ret = drm_gem_object_init(dev, &mgabo->gem, size);
249 if (ret) {
250 kfree(mgabo);
251 return ret;
252 }
253
254 mgabo->bo.bdev = &mdev->ttm.bdev;
255
256 mgag200_ttm_placement(mgabo, TTM_PL_FLAG_VRAM | TTM_PL_FLAG_SYSTEM);
257
258 acc_size = ttm_bo_dma_acc_size(&mdev->ttm.bdev, size,
259 sizeof(struct mgag200_bo));
260
261 ret = ttm_bo_init(&mdev->ttm.bdev, &mgabo->bo, size,
262 ttm_bo_type_device, &mgabo->placement,
263 align >> PAGE_SHIFT, false, acc_size,
264 NULL, NULL, mgag200_bo_ttm_destroy);
265 if (ret)
266 return ret;
267
268 *pmgabo = mgabo;
269 return 0;
270}
271
272static inline u64 mgag200_bo_gpu_offset(struct mgag200_bo *bo)
273{
274 return bo->bo.offset;
275}
276
277int mgag200_bo_pin(struct mgag200_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 = mgag200_bo_gpu_offset(bo);
286 return 0;
287 }
288
289 mgag200_ttm_placement(bo, pl_flag);
290 for (i = 0; i < bo->placement.num_placement; i++)
291 bo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT;
292 ret = ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
293 if (ret)
294 return ret;
295
296 bo->pin_count = 1;
297 if (gpu_addr)
298 *gpu_addr = mgag200_bo_gpu_offset(bo);
299 return 0;
300}
301
302int mgag200_bo_unpin(struct mgag200_bo *bo)
303{
304 struct ttm_operation_ctx ctx = { false, false };
305 int i;
306 if (!bo->pin_count) {
307 DRM_ERROR("unpin bad %p\n", bo);
308 return 0;
309 }
310 bo->pin_count--;
311 if (bo->pin_count)
312 return 0;
313
314 for (i = 0; i < bo->placement.num_placement ; i++)
315 bo->placements[i].flags &= ~TTM_PL_FLAG_NO_EVICT;
316 return ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
317}
318
319int mgag200_bo_push_sysram(struct mgag200_bo *bo)
320{
321 struct ttm_operation_ctx ctx = { false, false };
322 int i, ret;
323 if (!bo->pin_count) {
324 DRM_ERROR("unpin bad %p\n", bo);
325 return 0;
326 }
327 bo->pin_count--;
328 if (bo->pin_count)
329 return 0;
330
331 if (bo->kmap.virtual)
332 ttm_bo_kunmap(&bo->kmap);
333
334 mgag200_ttm_placement(bo, TTM_PL_FLAG_SYSTEM);
335 for (i = 0; i < bo->placement.num_placement ; i++)
336 bo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT;
337
338 ret = ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
339 if (ret) {
340 DRM_ERROR("pushing to VRAM failed\n");
341 return ret;
342 }
343 return 0;
344}
345
346int mgag200_mmap(struct file *filp, struct vm_area_struct *vma)
347{
348 struct drm_file *file_priv;
349 struct mga_device *mdev;
350
351 if (unlikely(vma->vm_pgoff < DRM_FILE_PAGE_OFFSET))
352 return -EINVAL;
353
354 file_priv = filp->private_data;
355 mdev = file_priv->minor->dev->dev_private;
356 return ttm_bo_mmap(filp, vma, &mdev->ttm.bdev);
357}
358
