Subversion Repositories Kolibri OS

Rev

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

  1.  
  2. #include <drm/drmP.h>
  3. #include <drm/radeon_drm.h>
  4. #include "radeon.h"
  5. #include "hmm.h"
  6. #include "bitmap.h"
  7.  
  8. //#define DRIVER_CAPS_0   HW_BIT_BLIT
  9.  
  10. #define DRIVER_CAPS_0   0
  11. #define DRIVER_CAPS_1   0
  12.  
  13. struct context *context_map[256];
  14.  
  15. struct hmm bm_mm;
  16.  
  17. extern struct drm_device *main_drm_device;
  18.  
  19.  
  20. void __attribute__((regparm(1))) destroy_bitmap(bitmap_t *bitmap)
  21. {
  22. //    dma_addr_t *pages = bitmap->obj->allocated_pages;
  23.     int i;
  24.  
  25.     free_handle(&bm_mm, bitmap->handle);
  26.     bitmap->handle = 0;
  27. //    bitmap->obj->base.read_domains = I915_GEM_DOMAIN_GTT;
  28. //    bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
  29.  
  30. //    mutex_lock(&main_device->struct_mutex);
  31. //    drm_gem_object_unreference(&bitmap->obj->base);
  32. //    mutex_unlock(&main_device->struct_mutex);
  33.  
  34. //    if(pages != NULL)
  35. //    {
  36. //        for (i = 0; i < bitmap->page_count; i++)
  37. //            FreePage(pages[i]);
  38.  
  39. //        DRM_DEBUG("%s release %d pages\n", __FUNCTION__, bitmap->page_count);
  40.  
  41. //        free(pages);
  42. //    };
  43.     UserFree(bitmap->uaddr);
  44.     __DestroyObject(bitmap);
  45. };
  46.  
  47. #if 0
  48. static int bitmap_get_pages_gtt(struct drm_i915_gem_object *obj)
  49. {
  50.     int page_count;
  51.  
  52.     /* Get the list of pages out of our struct file.  They'll be pinned
  53.      * at this point until we release them.
  54.      */
  55.  
  56.     page_count = obj->base.size / PAGE_SIZE;
  57.     BUG_ON(obj->allocated_pages == NULL);
  58.     BUG_ON(obj->pages.page != NULL);
  59.  
  60.     obj->pages.page = obj->allocated_pages;
  61.     obj->pages.nents = page_count;
  62.  
  63.  
  64. //   if (obj->tiling_mode != I915_TILING_NONE)
  65. //       i915_gem_object_do_bit_17_swizzle(obj);
  66.  
  67.     return 0;
  68. }
  69.  
  70. static void bitmap_put_pages_gtt(struct drm_i915_gem_object *obj)
  71. {
  72.     int ret, i;
  73.  
  74.     BUG_ON(obj->madv == __I915_MADV_PURGED);
  75.  
  76.     ret = i915_gem_object_set_to_cpu_domain(obj, true);
  77.     if (ret) {
  78.         /* In the event of a disaster, abandon all caches and
  79.          * hope for the best.
  80.          */
  81.         WARN_ON(ret != -EIO);
  82.         i915_gem_clflush_object(obj);
  83.         obj->base.read_domains = obj->base.write_domain = I915_GEM_DOMAIN_CPU;
  84.     }
  85.  
  86.     if (obj->madv == I915_MADV_DONTNEED)
  87.         obj->dirty = 0;
  88.  
  89.     obj->dirty = 0;
  90. }
  91.  
  92. static const struct drm_i915_gem_object_ops bitmap_object_ops = {
  93.     .get_pages = bitmap_get_pages_gtt,
  94.     .put_pages = bitmap_put_pages_gtt,
  95. };
  96.  
  97.  
  98.  
  99. struct  io_call_10         /*     SRV_CREATE_SURFACE    */
  100. {
  101.     u32     handle;       // ignored
  102.     void   *data;         // ignored
  103.  
  104.     u32     width;
  105.     u32     height;
  106.     u32     pitch;        // ignored
  107.  
  108.     u32     max_width;
  109.     u32     max_height;
  110.     u32     format;       // reserved mbz
  111. };
  112.  
  113. #endif
  114.  
  115. int create_surface(struct drm_device *dev, struct io_call_10 *pbitmap)
  116. {
  117.     struct radeon_device *rdev = dev->dev_private;
  118.     struct radeon_bo     *obj = NULL;
  119.  
  120.     bitmap_t   *bitmap;
  121.     u32         handle;
  122.     u32         width, max_width;
  123.     u32         height, max_height;
  124.     u32         size,  max_size;
  125.     u32         pitch, max_pitch;
  126.     void       *uaddr;
  127.     dma_addr_t *pages;
  128.     u32         page_count;
  129.  
  130.     int         i;
  131.  
  132.     int   ret;
  133.  
  134.     pbitmap->handle = 0;
  135.     pbitmap->data   = (void*)-1;
  136.  
  137.     width  = pbitmap->width;
  138.     height = pbitmap->height;
  139.  
  140.     if((width == 0)||(height == 0)||(width > 4096)||(height > 4096))
  141.         goto err1;
  142.  
  143.     max_width  = (pbitmap->max_width ==0) ? width  : pbitmap->max_width;
  144.     max_height = (pbitmap->max_height==0) ? height : pbitmap->max_height;
  145.  
  146.     handle = alloc_handle(&bm_mm);
  147. //    printf("%s %d\n",__FUNCTION__, handle);
  148.  
  149.     if(handle == 0)
  150.         goto err1;
  151.  
  152.     bitmap = CreateObject(GetPid(), sizeof(*bitmap));
  153. //    printf("bitmap %x\n", bitmap);
  154.     if( bitmap == NULL)
  155.         goto err2;
  156.  
  157.     bitmap->handle = handle;
  158.     bitmap->header.destroy = destroy_bitmap;
  159.     bitmap->obj    = NULL;
  160.  
  161.     hmm_set_data(&bm_mm, handle, bitmap);
  162.  
  163.     pitch = ALIGN(width*4,64);
  164.     size =  roundup(pitch*height, PAGE_SIZE);
  165.  
  166. //    printf("pitch %d size %d\n", pitch, size);
  167.  
  168.     max_pitch = ALIGN(max_width*4,64);
  169.     max_size =  roundup(max_pitch*max_height, PAGE_SIZE);
  170.  
  171. //    printf("max_pitch %d max_size %d\n", max_pitch, max_size);
  172.  
  173.     ret = radeon_bo_create(rdev, size, PAGE_SIZE, false, RADEON_GEM_DOMAIN_GTT, NULL, &obj);
  174.  
  175.     if (unlikely(ret != 0))
  176.         goto err3;
  177.  
  178.     ret = radeon_bo_reserve(obj, false);
  179.     if (unlikely(ret != 0))
  180.         goto err3;
  181.  
  182.     ret = radeon_bo_pin(obj, RADEON_GEM_DOMAIN_GTT, NULL);
  183.     if (unlikely(ret != 0))
  184.         goto err3;
  185.  
  186.     ret = radeon_bo_user_map(obj, (void**)&uaddr);
  187.     if (unlikely(ret != 0))
  188.         goto err3;
  189.  
  190.     bitmap->page_count = size/PAGE_SIZE;
  191.     bitmap->max_count  =  max_size/PAGE_SIZE;
  192.  
  193.     DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__, page_count);
  194.  
  195.     bitmap->handle = handle;
  196.     bitmap->uaddr  = uaddr;
  197.     bitmap->pitch  = pitch;
  198.     bitmap->gaddr  = radeon_bo_gpu_offset(obj);
  199.  
  200.     bitmap->width  = width;
  201.     bitmap->height = height;
  202.     bitmap->max_width  = max_width;
  203.     bitmap->max_height = max_height;
  204.  
  205.     bitmap->obj    = obj;
  206.     bitmap->header.destroy = destroy_bitmap;
  207.  
  208.     pbitmap->handle = handle;
  209.     pbitmap->data   = uaddr;
  210.     pbitmap->pitch  = pitch;
  211.  
  212.  
  213.     DRM_DEBUG("%s handle: %d pitch: %d gpu_addr: %x user_addr: %x\n",
  214.             __FUNCTION__, handle, pitch, bitmap->gaddr, uaddr);
  215.  
  216.     return 0;
  217.  
  218. err5:
  219. //    mutex_lock(&dev->struct_mutex);
  220. //    drm_gem_object_unreference(&obj->base);
  221. //    mutex_unlock(&dev->struct_mutex);
  222.  
  223. err4:
  224. //    while (i--)
  225. //        FreePage(pages[i]);
  226. //    free(pages);
  227. //    UserFree(uaddr);
  228.  
  229. err3:
  230.     __DestroyObject(bitmap);
  231. err2:
  232.     free_handle(&bm_mm, handle);
  233. err1:
  234.     return -1;
  235. };
  236.  
  237.  
  238. int lock_surface(struct io_call_12 *pbitmap)
  239. {
  240.     int ret;
  241.  
  242.     bitmap_t  *bitmap;
  243.  
  244.     if(unlikely(pbitmap->handle == 0))
  245.         return -1;
  246.  
  247.     bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);
  248.  
  249.     if(unlikely(bitmap==NULL))
  250.         return -1;
  251. /*
  252.     mutex_lock(&main_device->struct_mutex);
  253.     ret = i915_gem_object_set_to_cpu_domain(bitmap->obj, true);
  254.     mutex_unlock(&main_device->struct_mutex);
  255.  
  256.     if(ret != 0 )
  257.     {
  258.         pbitmap->data  = NULL;
  259.         pbitmap->pitch = 0;
  260.  
  261.         dbgprintf("%s fail\n", __FUNCTION__);
  262.         return ret;
  263.     };
  264. */
  265.     pbitmap->data  = bitmap->uaddr;
  266.     pbitmap->pitch = bitmap->pitch;
  267.  
  268.     return 0;
  269. };
  270.  
  271.  
  272. #if 0
  273.  
  274. int resize_surface(struct io_call_14 *pbitmap)
  275. {
  276.     bitmap_t  *bitmap;
  277.     dma_addr_t page, *pages;
  278.     u32        size, page_count;
  279.     u32        width, height;
  280.     u32        pitch;
  281.     int        i;
  282.     int        ret = 0;
  283.  
  284.  
  285.     if(unlikely(pbitmap->handle == 0))
  286.         return -1;
  287.  
  288.     bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);
  289.  
  290.     if(unlikely(bitmap==NULL))
  291.         return -1;
  292.  
  293.     if( pbitmap->new_width > bitmap->max_width ||
  294.         pbitmap->new_height > bitmap->max_height)
  295.         return -1;
  296.  
  297.     width  = pbitmap->new_width;
  298.     height = pbitmap->new_height;
  299.  
  300.     pitch = ALIGN(width*4,64);
  301.     size =  roundup(pitch * height, PAGE_SIZE);
  302.     page_count = size/PAGE_SIZE;
  303.  
  304.     DRM_DEBUG("new width %d height %d pitch %d size %d\n",
  305.             width, height, pitch, size);
  306.  
  307.     if(page_count > bitmap->page_count)
  308.     {
  309.         char *vaddr = bitmap->uaddr + PAGE_SIZE * bitmap->page_count;
  310.  
  311.         pages = bitmap->obj->allocated_pages;
  312.  
  313.         DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",
  314.                 bitmap->page_count, page_count, vaddr);
  315.  
  316.         for(i = bitmap->page_count; i < page_count; i++, vaddr+= PAGE_SIZE)
  317.         {
  318.             page = AllocPage();
  319.             if ( page == 0 )
  320.                 goto err4;
  321.             pages[i] = page;
  322.             MapPage(vaddr, page, 0x207);        //map as shared page
  323.         };
  324.  
  325.         DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__,
  326.                   page_count - bitmap->page_count);
  327.  
  328.         i915_gem_object_unpin(bitmap->obj);
  329.         i915_gem_object_unbind(bitmap->obj);
  330.         bitmap->obj->base.size = size;
  331.         bitmap->obj->pages.nents = page_count;
  332.  
  333.         ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);
  334.         if (ret)
  335.             goto err4;
  336.  
  337.         bitmap->page_count = page_count;
  338.         bitmap->gaddr  = bitmap->obj->gtt_offset;
  339.     }
  340.     else if(page_count < bitmap->page_count)
  341.     {
  342.         char *vaddr = bitmap->uaddr + PAGE_SIZE * page_count;
  343.  
  344.         i915_gem_object_unpin(bitmap->obj);
  345.         i915_gem_object_unbind(bitmap->obj);
  346.  
  347.         pages = bitmap->obj->allocated_pages;
  348.  
  349.         DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",
  350.                 bitmap->page_count, page_count, vaddr);
  351.  
  352.         for(i = page_count; i < bitmap->page_count; i++, vaddr+= PAGE_SIZE)
  353.         {
  354.             MapPage(vaddr, 0, 0);        //unmap
  355.  
  356.             FreePage(pages[i]);
  357.             pages[i] = 0;
  358.         };
  359.  
  360.         DRM_DEBUG("%s release %d pages\n", __FUNCTION__,
  361.                   bitmap->page_count - page_count);
  362.  
  363.         bitmap->obj->base.size = size;
  364.         bitmap->obj->pages.nents = page_count;
  365.  
  366.         ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);
  367.         if (ret)
  368.             goto err3;
  369.  
  370.         bitmap->page_count = page_count;
  371.         bitmap->gaddr  = bitmap->obj->gtt_offset;
  372.     };
  373.  
  374.     bitmap->width  = width;
  375.     bitmap->height = height;
  376.     bitmap->pitch  = pitch;
  377.  
  378.  
  379.     pbitmap->data  = bitmap->uaddr;
  380.     pbitmap->pitch = bitmap->pitch;
  381.  
  382.     return 0;
  383.  
  384. err4:
  385.     while (i-- > bitmap->page_count)
  386.         FreePage(pages[i]);
  387.  
  388. err3:
  389.     return -1;
  390. };
  391. #endif
  392.  
  393.  
  394. int init_bitmaps()
  395. {
  396.     int ret;
  397.  
  398.     ret = init_hmm(&bm_mm, 1024);
  399.  
  400.     return ret;
  401. };
  402.  
  403.  
  404.  
  405. int get_driver_caps(hwcaps_t *caps)
  406. {
  407.     int ret = 0;
  408.  
  409.     ENTER();
  410.     switch(caps->idx)
  411.     {
  412.         case 0:
  413.             caps->opt[0] = DRIVER_CAPS_0;
  414.             caps->opt[1] = DRIVER_CAPS_1;
  415.             break;
  416.  
  417.         case 1:
  418.             caps->cap1.max_tex_width  = 4096;
  419.             caps->cap1.max_tex_height = 4096;
  420.             break;
  421.         default:
  422.             ret = 1;
  423.     };
  424.     caps->idx = 1;
  425.     LEAVE();
  426.     return ret;
  427. }
  428.  
  429.  
  430. void __attribute__((regparm(1))) destroy_context(struct context *context)
  431. {
  432.     struct radeon_device *rdev = main_drm_device->dev_private;
  433.  
  434.     DRM_DEBUG("destroy context %x\n", context);
  435.  
  436.     context_map[context->slot] = NULL;
  437.  
  438.     radeon_ib_free(rdev, &context->ib);
  439.  
  440.     __DestroyObject(context);
  441. };
  442.  
  443.  
  444. #define CURRENT_TASK             (0x80003000)
  445.  
  446. struct context *get_context(struct drm_device *dev)
  447. {
  448.     struct radeon_device *rdev = dev->dev_private;
  449.     struct context *context;
  450.     struct io_call_10 io_10;
  451.     int    slot = *((u8*)CURRENT_TASK);
  452.     int    ret;
  453.  
  454.     context = context_map[slot];
  455.  
  456.     if( context != NULL)
  457.         return context;
  458.  
  459.     context = CreateObject(GetPid(), sizeof(*context));
  460.  
  461.     if( context != NULL)
  462.     {
  463.         ret = radeon_ib_get(rdev, RADEON_RING_TYPE_GFX_INDEX, &context->ib, NULL, 4096);
  464.         if (ret) {
  465.             DRM_ERROR("radeon: failed to get ib (%d).\n", ret);
  466.             goto err;
  467.         };
  468.  
  469.         context->cmd_buffer = context->ib.ptr;
  470.  
  471.         context->header.destroy = destroy_context;
  472.         context->mask  = NULL;
  473.         context->seqno = 0;
  474.         context->slot  = slot;
  475.  
  476.         context_map[slot] = context;
  477.     };
  478.     return context;
  479.  
  480. err:
  481.     __DestroyObject(context);
  482.     return NULL;
  483. };
  484.  
  485.  
  486.