Subversion Repositories Kolibri OS

Rev

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

  1.  
  2. #include <stdint.h>
  3. #include <drm/drmP.h>
  4. #include <drm.h>
  5. #include <drm_mm.h>
  6. #include "radeon_drm.h"
  7. #include "radeon.h"
  8. #include "radeon_object.h"
  9. #include "display.h"
  10.  
  11. display_t *rdisplay;
  12.  
  13. static cursor_t*  __stdcall select_cursor(cursor_t *cursor);
  14. static void       __stdcall move_cursor(cursor_t *cursor, int x, int y);
  15.  
  16. extern void destroy_cursor(void);
  17.  
  18. void disable_mouse(void)
  19. {};
  20.  
  21. int init_cursor(cursor_t *cursor)
  22. {
  23.     struct radeon_device *rdev;
  24.  
  25.     uint32_t *bits;
  26.     uint32_t *src;
  27.  
  28.     int       i,j;
  29.     int       r;
  30.  
  31.     rdev = (struct radeon_device *)rdisplay->ddev->dev_private;
  32.  
  33.     r = radeon_object_create(rdev, NULL, CURSOR_WIDTH*CURSOR_HEIGHT*4,
  34.                      false,
  35.                      RADEON_GEM_DOMAIN_VRAM,
  36.                      false, &cursor->robj);
  37.  
  38.     if (unlikely(r != 0))
  39.         return r;
  40.  
  41.     radeon_object_pin(cursor->robj, TTM_PL_FLAG_VRAM, NULL);
  42.  
  43.     r = radeon_object_kmap(cursor->robj, &bits);
  44.     if (r) {
  45.          DRM_ERROR("radeon: failed to map cursor (%d).\n", r);
  46.          return r;
  47.     };
  48.  
  49.     src = cursor->data;
  50.  
  51.     for(i = 0; i < 32; i++)
  52.     {
  53.         for(j = 0; j < 32; j++)
  54.             *bits++ = *src++;
  55.         for(j = 32; j < CURSOR_WIDTH; j++)
  56.             *bits++ = 0;
  57.     }
  58.     for(i = 0; i < CURSOR_WIDTH*(CURSOR_HEIGHT-32); i++)
  59.         *bits++ = 0;
  60.  
  61.     radeon_object_kunmap(cursor->robj);
  62.  
  63.     cursor->header.destroy = destroy_cursor;
  64.  
  65.     return 0;
  66. };
  67.  
  68. void fini_cursor(cursor_t *cursor)
  69. {
  70.     list_del(&cursor->list);
  71.     radeon_object_unpin(cursor->robj);
  72.     KernelFree(cursor->data);
  73.     __DestroyObject(cursor);
  74. };
  75.  
  76.  
  77. static void radeon_show_cursor()
  78. {
  79.     struct radeon_device *rdev = (struct radeon_device *)rdisplay->ddev->dev_private;
  80.  
  81.     if (ASIC_IS_AVIVO(rdev)) {
  82.         WREG32(RADEON_MM_INDEX, AVIVO_D1CUR_CONTROL);
  83.         WREG32(RADEON_MM_DATA, AVIVO_D1CURSOR_EN |
  84.                  (AVIVO_D1CURSOR_MODE_24BPP << AVIVO_D1CURSOR_MODE_SHIFT));
  85.     } else {
  86.         WREG32(RADEON_MM_INDEX, RADEON_CRTC_GEN_CNTL);
  87.         WREG32_P(RADEON_MM_DATA, (RADEON_CRTC_CUR_EN |
  88.                       (RADEON_CRTC_CUR_MODE_24BPP << RADEON_CRTC_CUR_MODE_SHIFT)),
  89.              ~(RADEON_CRTC_CUR_EN | RADEON_CRTC_CUR_MODE_MASK));
  90.     }
  91. }
  92.  
  93. cursor_t* __stdcall select_cursor(cursor_t *cursor)
  94. {
  95.     struct radeon_device *rdev;
  96.     cursor_t *old;
  97.     uint32_t  gpu_addr;
  98.  
  99.     rdev = (struct radeon_device *)rdisplay->ddev->dev_private;
  100.  
  101.     old = rdisplay->cursor;
  102.  
  103.     rdisplay->cursor = cursor;
  104.     gpu_addr = cursor->robj->gpu_addr;
  105.  
  106.     if (ASIC_IS_AVIVO(rdev))
  107.         WREG32(AVIVO_D1CUR_SURFACE_ADDRESS,  gpu_addr);
  108.     else {
  109.         WREG32(RADEON_CUR_OFFSET, gpu_addr - rdev->mc.vram_location);
  110.     }
  111.  
  112.     return old;
  113. };
  114.  
  115. static void radeon_lock_cursor(bool lock)
  116. {
  117.     struct radeon_device *rdev;
  118.  
  119.     rdev = (struct radeon_device *)rdisplay->ddev->dev_private;
  120.  
  121.     uint32_t cur_lock;
  122.  
  123.     if (ASIC_IS_AVIVO(rdev)) {
  124.         cur_lock = RREG32(AVIVO_D1CUR_UPDATE);
  125.         if (lock)
  126.             cur_lock |= AVIVO_D1CURSOR_UPDATE_LOCK;
  127.         else
  128.             cur_lock &= ~AVIVO_D1CURSOR_UPDATE_LOCK;
  129.         WREG32(AVIVO_D1CUR_UPDATE, cur_lock);
  130.     } else {
  131.         cur_lock = RREG32(RADEON_CUR_OFFSET);
  132.         if (lock)
  133.             cur_lock |= RADEON_CUR_LOCK;
  134.         else
  135.             cur_lock &= ~RADEON_CUR_LOCK;
  136.         WREG32(RADEON_CUR_OFFSET, cur_lock);
  137.     }
  138. }
  139.  
  140.  
  141. void __stdcall move_cursor(cursor_t *cursor, int x, int y)
  142. {
  143.     struct radeon_device *rdev;
  144.     rdev = (struct radeon_device *)rdisplay->ddev->dev_private;
  145.  
  146.     int hot_x = cursor->hot_x;
  147.     int hot_y = cursor->hot_y;
  148.  
  149.     radeon_lock_cursor(true);
  150.     if (ASIC_IS_AVIVO(rdev))
  151.     {
  152.         int w = 32;
  153.         int i = 0;
  154.  
  155.         WREG32(AVIVO_D1CUR_POSITION, (x << 16) | y);
  156.         WREG32(AVIVO_D1CUR_HOT_SPOT, (hot_x << 16) | hot_y);
  157.         WREG32(AVIVO_D1CUR_SIZE, ((w - 1) << 16) | 31);
  158.     } else {
  159.         uint32_t  gpu_addr;
  160.  
  161.         WREG32(RADEON_CUR_HORZ_VERT_OFF,
  162.                (RADEON_CUR_LOCK | (hot_x << 16) | hot_y ));
  163.         WREG32(RADEON_CUR_HORZ_VERT_POSN,
  164.                (RADEON_CUR_LOCK | (x << 16) | y));
  165.  
  166.         gpu_addr = cursor->robj->gpu_addr;
  167.  
  168.         /* offset is from DISP(2)_BASE_ADDRESS */
  169.         WREG32(RADEON_CUR_OFFSET,
  170.          (gpu_addr - rdev->mc.vram_location + (hot_y * 256)));
  171.     }
  172.     radeon_lock_cursor(false);
  173. }
  174.  
  175. void __stdcall restore_cursor(int x, int y)
  176. {
  177. };
  178.  
  179.  
  180. bool init_display(struct radeon_device *rdev, mode_t *usermode)
  181. {
  182.     struct drm_device   *dev;
  183.  
  184.     cursor_t            *cursor;
  185.     bool                 retval = true;
  186.     u32_t                ifl;
  187.  
  188.     ENTER();
  189.  
  190.     rdisplay = GetDisplay();
  191.  
  192.     dev = rdisplay->ddev = rdev->ddev;
  193.  
  194.     ifl = safe_cli();
  195.     {
  196.         list_for_each_entry(cursor, &rdisplay->cursors, list)
  197.         {
  198.             init_cursor(cursor);
  199.         };
  200.  
  201.         rdisplay->restore_cursor(0,0);
  202.         rdisplay->init_cursor    = init_cursor;
  203.         rdisplay->select_cursor  = select_cursor;
  204.         rdisplay->show_cursor    = NULL;
  205.         rdisplay->move_cursor    = move_cursor;
  206.         rdisplay->restore_cursor = restore_cursor;
  207.         rdisplay->disable_mouse  = disable_mouse;
  208.  
  209.         select_cursor(rdisplay->cursor);
  210.         radeon_show_cursor();
  211.     };
  212.     safe_sti(ifl);
  213.  
  214.     LEAVE();
  215.  
  216.     return retval;
  217. };
  218.  
  219.  
  220.  
  221.