Subversion Repositories Kolibri OS

Rev

Rev 2340 | Rev 2344 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. #include <drmP.h>
  3. #include <drm.h>
  4. #include "i915_drm.h"
  5. #include "i915_drv.h"
  6. #include "intel_drv.h"
  7. #include "bitmap.h"
  8.  
  9. void __attribute__((regparm(1))) destroy_bitmap(bitmap_t *bitmap)
  10. {
  11. /*
  12.  *
  13.  *
  14.  *
  15. */
  16.     __DestroyObject(bitmap);
  17. };
  18.  
  19. extern struct drm_device *main_device;
  20.  
  21. struct hman bm_man;
  22.  
  23. int init_bitmaps()
  24. {
  25.     int ret;
  26.  
  27.     ret = init_hman(&bm_man, 1024);
  28.  
  29.     return ret;
  30. };
  31.  
  32.  
  33. int create_bitmap(struct ubitmap *pbitmap)
  34. {
  35.     struct drm_i915_gem_object *obj;
  36.  
  37.     bitmap_t   *bitmap;
  38.     u32         handle;
  39.     u32         width;
  40.     u32         height;
  41.     u32         size;
  42.     u32         pitch;
  43.     void       *uaddr;
  44.  
  45.     int   ret;
  46.  
  47.     pbitmap->handle = 0;
  48.     pbitmap->data   = NULL;
  49.  
  50.     width = pbitmap->width;
  51.     height = pbitmap->height;
  52.  
  53.     if((width==0)||(height==0)||(width>4096)||(height>4096))
  54.         goto err1;
  55.  
  56.     handle = alloc_handle(&bm_man);
  57. //    printf("%s %d\n",__FUNCTION__, handle);
  58.  
  59.     if(handle == 0)
  60.         goto err1;
  61.  
  62.     bitmap = CreateObject(GetPid(), sizeof(*bitmap));
  63.     bitmap->handle = handle;
  64.     bitmap->header.destroy = destroy_bitmap;
  65.     bitmap->obj    = NULL;
  66.  
  67. //    printf("bitmap %x\n", bitmap);
  68.     if( bitmap == NULL)
  69.         goto err1;
  70.  
  71.     hman_set_data(&bm_man, handle, bitmap);
  72.  
  73.     pitch = ALIGN(width*4,64);
  74.  
  75.     size =  roundup(pitch*height, PAGE_SIZE);
  76. //    printf("pitch %d size %d\n", pitch, size);
  77.  
  78.     obj = i915_gem_alloc_object(main_device, size);
  79.     if (obj == NULL)
  80.         goto err2;
  81.  
  82.     ret = i915_gem_object_pin(obj, 4096, true);
  83.     if (ret)
  84.         goto err3;
  85.  
  86.     uaddr = UserAlloc(size);
  87.     if( uaddr == NULL)
  88.         goto err4;
  89.     else
  90.     {
  91.         u32_t *src, *dst;
  92.         int count;
  93.  
  94. #define page_tabs  0xFDC00000      /* really dirty hack */
  95.  
  96.         src =  (u32_t*)obj->pages;
  97.         dst =  &((u32_t*)page_tabs)[(u32_t)uaddr >> 12];
  98.         count = size/4096;
  99.  
  100.         while(count--)
  101.         {
  102.             *dst++ = (0xFFFFF000 & *src++) | 0x207 ; // map as shared page
  103.         };
  104.     }
  105.  
  106.     bitmap->handle = handle;
  107.     bitmap->width  = width;
  108.     bitmap->height = height;
  109.     bitmap->pitch  = pitch;
  110.     bitmap->gaddr  = obj->gtt_offset;
  111.     bitmap->uaddr  = uaddr;
  112.     bitmap->obj    = obj;
  113.     bitmap->header.destroy = destroy_bitmap;
  114.  
  115.     pbitmap->pitch  = pitch;
  116.     pbitmap->handle = handle;
  117.     pbitmap->data   = uaddr;
  118.  
  119. //    printf("%s handle %d pitch %d gpu %x user %x\n",
  120. //            __FUNCTION__, handle, pitch, obj->gtt_offset, uaddr);
  121.  
  122.     return 0;
  123.  
  124. err4:
  125. //    drm_gem_object_unpin;
  126. err3:
  127. //    drm_gem_object_unreference(&obj->base);
  128. err2:
  129.     free_handle(&bm_man, handle);
  130.     __DestroyObject(bitmap);
  131. err1:
  132.     return -1;
  133.  
  134. };
  135.  
  136.  
  137. int init_hman(struct hman *man, u32 count)
  138. {
  139.     u32* data;
  140.  
  141.     data = malloc(count*sizeof(u32*));
  142.     if(data)
  143.     {
  144.         int i;
  145.  
  146.         for(i=0;i < count-1;)
  147.             data[i] = ++i;
  148.         data[i] = 0;
  149.  
  150.         man->table = data;
  151.         man->next  = 0;
  152.         man->avail = count;
  153.         man->count = count;
  154.  
  155.         return 0;
  156.     };
  157.     return -ENOMEM;
  158. };
  159.  
  160. u32  alloc_handle(struct hman *man)
  161. {
  162.     u32 handle = 0;
  163.  
  164.     if(man->avail)
  165.     {
  166.         handle = man->next;
  167.         man->next = man->table[handle];
  168.         man->avail--;
  169.         handle++;
  170.     }
  171.     return handle;
  172. };
  173.  
  174. int free_handle(struct hman *man, u32 handle)
  175. {
  176.     int ret = -1;
  177.  
  178.     handle--;
  179.  
  180.     if(handle < man->count)
  181.     {
  182.         man->table[handle] = man->next;
  183.         man->next = handle;
  184.         man->avail++;
  185.         ret = 0;
  186.     };
  187.  
  188.     return ret;
  189. };
  190.  
  191.  
  192.