Subversion Repositories Kolibri OS

Rev

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

Rev Author Line No. Line
2340 Serge 1
 
2
#include 
3
#include "i915_drm.h"
4
#include "i915_drv.h"
5
#include "intel_drv.h"
6
#include "bitmap.h"
7
8
 
2342 Serge 9
{
10
    printf("destroy bitmap %d\n", bitmap->handle);
2344 Serge 11
    free_handle(&bm_man, bitmap->handle);
12
    bitmap->handle = 0;
13
    i915_gem_object_unpin(bitmap->obj);
14
    drm_gem_object_unreference(&bitmap->obj->base);
15
    __DestroyObject(bitmap);
2342 Serge 16
};
17
18
 
2340 Serge 19
20
 
21
22
 
23
{
24
    int ret;
25
26
 
27
28
 
29
};
30
31
 
32
 
2344 Serge 33
{
2340 Serge 34
    struct drm_i915_gem_object *obj;
35
36
 
37
    u32         handle;
38
    u32         width, max_width;
2344 Serge 39
    u32         height, max_height;
40
    u32         size,  max_size;
41
    u32         pitch, max_pitch;
42
    void       *uaddr;
2340 Serge 43
44
 
45
46
 
47
    pbitmap->data   = (void*)-1;
2344 Serge 48
2340 Serge 49
 
2344 Serge 50
    height = pbitmap->height;
2342 Serge 51
52
 
2344 Serge 53
    if((width==0)||(height==0)||(width>4096)||(height>4096))
2340 Serge 54
        goto err1;
55
56
 
2344 Serge 57
         (pbitmap->max_width < width)) ||
58
         (pbitmap->max_width > 4096) )
59
        goto err1;
60
61
 
62
         (pbitmap->max_height < width)) ||
63
         (pbitmap->max_height > 4096) )
64
        goto err1;
65
66
 
67
        goto err1;
68
*/
69
70
 
71
    max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;
72
73
 
2340 Serge 74
//    printf("%s %d\n",__FUNCTION__, handle);
2342 Serge 75
2340 Serge 76
 
77
        goto err1;
78
79
 
80
    bitmap->handle = handle;
2342 Serge 81
    bitmap->header.destroy = destroy_bitmap;
82
    bitmap->obj    = NULL;
83
84
 
85
    if( bitmap == NULL)
2340 Serge 86
        goto err1;
87
88
 
89
90
 
91
92
 
93
2344 Serge 94
 
2342 Serge 95
2340 Serge 96
 
97
    if (obj == NULL)
98
        goto err2;
99
100
 
101
    if (ret)
102
        goto err3;
103
104
 
2344 Serge 105
    max_size =  roundup(max_pitch*max_height, PAGE_SIZE);
106
107
 
108
    if( uaddr == NULL)
2340 Serge 109
        goto err4;
110
    else
111
    {
112
        u32_t *src, *dst;
113
        u32 count, max_count;
2344 Serge 114
2340 Serge 115
 
116
117
 
118
        dst =  &((u32_t*)page_tabs)[(u32_t)uaddr >> 12];
119
        count = size/4096;
120
        max_count = max_size/4096 - count;
2344 Serge 121
2340 Serge 122
 
123
        {
124
            *dst++ = (0xFFFFF000 & *src++) | 0x207 ; // map as shared page
125
        };
126
//        while(max_count--)
2344 Serge 127
//            *dst++ = 0;                              // cleanup unused space
128
    }
2340 Serge 129
130
 
131
    bitmap->uaddr  = uaddr;
2344 Serge 132
    bitmap->pitch  = pitch;
133
    bitmap->gaddr  = obj->gtt_offset;
134
135
 
2340 Serge 136
    bitmap->height = height;
137
    bitmap->max_width  = max_width;
2344 Serge 138
    bitmap->max_height = max_height;
139
140
 
2340 Serge 141
    bitmap->header.destroy = destroy_bitmap;
2342 Serge 142
2340 Serge 143
 
144
    pbitmap->data   = uaddr;
145
    pbitmap->pitch  = pitch;
2344 Serge 146
2342 Serge 147
 
148
 
2344 Serge 149
            __FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);
150
151
 
2340 Serge 152
153
 
154
    i915_gem_object_unpin(obj);
2344 Serge 155
err3:
2340 Serge 156
    drm_gem_object_unreference(&obj->base);
2344 Serge 157
err2:
2340 Serge 158
    free_handle(&bm_man, handle);
159
    __DestroyObject(bitmap);
2342 Serge 160
err1:
2340 Serge 161
    return -1;
162
163
 
164
165
 
166
 
2344 Serge 167
 
168
 
2340 Serge 169
{
170
    u32* data;
171
172
 
173
    if(data)
174
    {
175
        int i;
176
177
 
178
            data[i] = ++i;
179
        data[i] = 0;
180
181
 
182
        man->next  = 0;
183
        man->avail = count;
184
        man->count = count;
185
186
 
187
    };
188
    return -ENOMEM;
189
};
190
191
 
192
{
193
    u32 handle = 0;
194
195
 
196
    {
197
        handle = man->next;
198
        man->next = man->table[handle];
199
        man->avail--;
200
        handle++;
201
    }
202
    return handle;
203
};
204
205
 
206
{
207
    int ret = -1;
208
209
 
210
211
 
212
    {
213
        man->table[handle] = man->next;
214
        man->next = handle;
215
        man->avail++;
216
        ret = 0;
217
    };
218
219
 
220
};
221