Subversion Repositories Kolibri OS

Rev

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