Subversion Repositories Kolibri OS

Rev

Rev 2007 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1404 serge 1
 
2
#include 
3
#include "radeon_drm.h"
4
#include "radeon.h"
5
6
 
7
 
8
static struct drm_mm   mm_vram;
9
10
 
1986 serge 11
 
12
 * Initialize an already allocate GEM object of the specified size with
13
 * shmfs backing store.
14
 */
15
int drm_gem_object_init(struct drm_device *dev,
16
            struct drm_gem_object *obj, size_t size)
17
{
18
    BUG_ON((size & (PAGE_SIZE - 1)) != 0);
19
20
 
21
    obj->filp = NULL;
22
23
 
24
    obj->size = size;
25
26
 
27
}
28
29
 
30
 
1404 serge 31
                 struct drm_mm_node **node)
32
{
33
    struct drm_mm_node *vm_node;
34
    int    r;
35
36
 
37
38
 
39
40
 
41
       return r;
42
43
 
44
45
 
46
        r = -ENOMEM;
47
        return r;
48
    }
49
50
 
51
52
 
53
            goto retry_pre_get;
54
    }
55
56
 
57
};
58
59
 
60
 
1986 serge 61
 
1404 serge 62
{
63
    u32 c = 0;
64
65
 
66
    rbo->placement.lpfn = 0;
67
    rbo->placement.placement = rbo->placements;
68
    rbo->placement.busy_placement = rbo->placements;
69
    if (domain & RADEON_GEM_DOMAIN_VRAM)
70
        rbo->placements[c++] = TTM_PL_FLAG_WC | TTM_PL_FLAG_UNCACHED |
71
                    TTM_PL_FLAG_VRAM;
72
    if (domain & RADEON_GEM_DOMAIN_GTT)
73
        rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_TT;
74
    if (domain & RADEON_GEM_DOMAIN_CPU)
75
        rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
76
    if (!c)
77
        rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
78
    rbo->placement.num_placement = c;
79
    rbo->placement.num_busy_placement = c;
80
}
81
82
 
83
 
84
{
85
    int r;
86
87
 
88
        rdev->mc.mc_vram_size >> 20,
89
        (unsigned long long)rdev->mc.aper_size >> 20);
90
    DRM_INFO("RAM width %dbits %cDR\n",
91
            rdev->mc.vram_width, rdev->mc.vram_is_ddr ? 'D' : 'S');
92
93
 
94
               ((rdev->mc.real_vram_size - 0xC00000) >> PAGE_SHIFT));
95
    if (r) {
96
        DRM_ERROR("Failed initializing VRAM heap.\n");
97
        return r;
98
    };
99
100
 
101
    if (r) {
102
        DRM_ERROR("Failed initializing GTT heap.\n");
103
        return r;
104
    }
105
106
 
107
}
108
109
 
110
 
111
{
112
    int r;
113
114
 
115
116
 
117
}
118
119
 
120
{
121
    bo->reserved.counter = 1;
122
}
123
124
 
2997 Serge 125
126
 
1963 serge 127
                unsigned long size, int byte_align, bool kernel, u32 domain,
2997 Serge 128
                struct sg_table *sg, struct radeon_bo **bo_ptr)
129
{
1404 serge 130
	struct radeon_bo *bo;
1986 serge 131
    enum ttm_bo_type type;
1404 serge 132
133
 
134
    struct drm_mm      *mman;
135
    u32                 bo_domain;
136
    int r;
137
138
 
139
140
 
2005 serge 141
142
 
1404 serge 143
        dbgprintf("Illegal buffer object size.\n");
144
        return -EINVAL;
145
    }
146
147
 
148
    {
149
        mman = &mm_vram;
150
        bo_domain = RADEON_GEM_DOMAIN_VRAM;
151
    }
152
    else if(domain & RADEON_GEM_DOMAIN_GTT)
153
    {
154
        mman = &mm_gtt;
155
        bo_domain = RADEON_GEM_DOMAIN_GTT;
156
    }
157
    else return -EINVAL;
158
159
 
160
        type = ttm_bo_type_kernel;
161
    } else {
162
        type = ttm_bo_type_device;
163
    }
164
    *bo_ptr = NULL;
165
    bo = kzalloc(sizeof(struct radeon_bo), GFP_KERNEL);
166
    if (bo == NULL)
167
        return -ENOMEM;
168
169
 
1986 serge 170
    if (unlikely(r)) {
171
		kfree(bo);
172
		return r;
173
	}
174
    bo->rdev = rdev;
1404 serge 175
	bo->gem_base.driver_private = NULL;
1986 serge 176
    bo->surface_reg = -1;
1404 serge 177
    bo->tbo.num_pages = num_pages;
178
    bo->domain = domain;
179
180
 
181
182
 
183
    /* Kernel allocation are uninterruptible */
184
185
 
186
    if (unlikely(r != 0))
187
        return r;
188
189
 
190
191
 
192
}
193
194
 
195
196
 
197
{
198
    int r=0, i;
199
200
 
201
        bo->pin_count++;
202
        if (gpu_addr)
203
            *gpu_addr = radeon_bo_gpu_offset(bo);
204
        return 0;
205
    }
206
207
 
208
209
 
210
    {
211
        bo->tbo.offset += (u64)bo->rdev->mc.vram_start;
1430 serge 212
    }
1404 serge 213
    else if (bo->domain & RADEON_GEM_DOMAIN_GTT)
214
    {
215
        u32_t *pagelist;
216
        bo->kptr  = KernelAlloc( bo->tbo.num_pages << PAGE_SHIFT );
217
        dbgprintf("kernel alloc %x\n", bo->kptr );
218
219
 
220
        dbgprintf("pagelist %x\n", pagelist);
221
        radeon_gart_bind(bo->rdev, bo->tbo.offset,
222
                         bo->tbo.vm_node->size,  pagelist, NULL);
2997 Serge 223
        bo->tbo.offset += (u64)bo->rdev->mc.gtt_start;
1430 serge 224
    }
1404 serge 225
    else
226
    {
227
        DRM_ERROR("Unknown placement %x\n", bo->domain);
228
        bo->tbo.offset = -1;
229
        r = -1;
230
    };
231
232
 
233
        DRM_ERROR("radeon: failed to pin object.\n");
234
    }
235
236
 
237
        bo->pin_count = 1;
238
        if (gpu_addr != NULL)
239
            *gpu_addr = radeon_bo_gpu_offset(bo);
240
    }
241
242
 
243
        dev_err(bo->rdev->dev, "%p pin failed\n", bo);
244
    return r;
245
};
246
247
 
248
{
249
    int r = 0;
250
251
 
252
        dev_warn(bo->rdev->dev, "%p unpin not necessary\n", bo);
253
        return 0;
254
    }
255
    bo->pin_count--;
256
    if (bo->pin_count)
257
        return 0;
258
259
 
260
    {
261
        drm_mm_put_block(bo->tbo.vm_node);
262
        bo->tbo.vm_node = NULL;
263
    };
264
265
 
266
}
267
268
 
269
{
270
    bool is_iomem;
271
272
 
273
        if (ptr) {
274
            *ptr = bo->kptr;
275
        }
276
        return 0;
277
    }
278
279
 
280
    {
281
        bo->cpu_addr = bo->rdev->mc.aper_base +
282
                       (bo->tbo.vm_node->start << PAGE_SHIFT);
283
        bo->kptr = (void*)MapIoMem(bo->cpu_addr,
284
                        bo->tbo.vm_node->size << 12, PG_SW);
285
    }
286
    else
287
    {
288
        return -1;
289
    }
290
291
 
292
        *ptr = bo->kptr;
293
    }
294
295
 
296
}
297
298
 
2007 serge 299
{
300
    bool is_iomem;
301
302
 
303
        if (ptr) {
304
            *ptr = bo->uptr;
305
        }
306
        return 0;
307
    }
308
309
 
310
    {
311
        return -1;
312
    }
313
    else
314
    {
315
        bo->uptr = UserAlloc(bo->tbo.num_pages << PAGE_SHIFT);
316
        if(bo->uptr)
317
        {
318
            u32_t *src, *dst;
319
            int count;
320
            src =  &((u32_t*)page_tabs)[(u32_t)bo->kptr >> 12];
321
            dst =  &((u32_t*)page_tabs)[(u32_t)bo->uptr >> 12];
322
            count = bo->tbo.num_pages;
323
324
 
325
            {
326
              *dst++ = (0xFFFFF000 & *src++) | 0x207 ; // map as shared page
327
            };
328
        }
329
        else
330
            return -1;
331
    }
332
333
 
334
        *ptr = bo->uptr;
335
    }
336
337
 
338
}
339
340
 
1404 serge 341
{
342
    if (bo->kptr == NULL)
343
        return;
344
345
 
346
    {
347
        FreeKernelSpace(bo->kptr);
348
    }
349
350
 
351
352
 
353
354
 
355
{
356
    struct ttm_buffer_object *tbo;
357
358
 
359
        return;
360
361
 
362
}
363
364
 
365
 
366
                uint32_t *tiling_flags,
367
                uint32_t *pitch)
368
{
369
//    BUG_ON(!atomic_read(&bo->tbo.reserved));
370
    if (tiling_flags)
371
        *tiling_flags = bo->tiling_flags;
372
    if (pitch)
373
        *pitch = bo->pitch;
374
}
375
376
 
377
 
378
 * Allocate a GEM object of the specified size with shmfs backing store
379
 */
380
struct drm_gem_object *
381
drm_gem_object_alloc(struct drm_device *dev, size_t size)
382
{
383
    struct drm_gem_object *obj;
384
385
 
386
387
 
388
389
 
390
    obj->size = size;
391
    return obj;
392
}
393
394
 
395
 
396
            unsigned long size, bool kernel, u32 domain,
397
            struct radeon_bo **bo_ptr)
398
{
399
    enum ttm_bo_type    type;
400
401
 
402
    struct drm_mm       *mman;
403
    struct drm_mm_node  *vm_node;
404
405
 
406
    u32     bo_domain;
407
    int     r;
408
409
 
410
411
 
412
        dbgprintf("Illegal buffer object size.\n");
413
        return -EINVAL;
414
    }
415
416
 
417
        RADEON_GEM_DOMAIN_VRAM )
418
    {
419
        return -EINVAL;
420
    };
421
422
 
423
        type = ttm_bo_type_kernel;
424
    } else {
425
        type = ttm_bo_type_device;
426
    }
427
    *bo_ptr = NULL;
428
    bo = kzalloc(sizeof(struct radeon_bo), GFP_KERNEL);
429
    if (bo == NULL)
430
        return -ENOMEM;
431
432
 
433
//    bo->gobj = gobj;
1963 serge 434
    bo->surface_reg = -1;
1404 serge 435
    bo->tbo.num_pages = num_pages;
436
    bo->domain = domain;
437
438
 
439
440
 
441
    /* Kernel allocation are uninterruptible */
442
443
 
444
445
 
446
    vm_node->start = 0;
447
    vm_node->mm = NULL;
448
449
 
450
    bo->tbo.offset  = bo->tbo.vm_node->start << PAGE_SHIFT;
451
    bo->tbo.offset += (u64)bo->rdev->mc.vram_start;
1430 serge 452
    bo->kptr        = (void*)0xFE000000;
1404 serge 453
    bo->pin_count   = 1;
454
455
 
456
457
 
458
}
459