Subversion Repositories Kolibri OS

Rev

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