drivers/gpu/drm/mgag200/mgag200_cursor.c

   1 /*
   2  * Copyright 2013 Matrox Graphics
   3  *
   4  * This file is subject to the terms and conditions of the GNU General
   5  * Public License version 2. See the file COPYING in the main
   6  * directory of this archive for more details.
   7  *
   8  * Author: Christopher Harvey <charvey@matrox.com>
   9  */
  10
  11 #include <drm/drmP.h>
  12 #include "mgag200_drv.h"
  13
  14 static bool warn_transparent = true;
  15 static bool warn_palette = true;
  16
  17 /*
  18   Hide the cursor off screen. We can't disable the cursor hardware because it
  19   takes too long to re-activate and causes momentary corruption
  20 */
  21 static void mga_hide_cursor(struct mga_device *mdev)
  22 {
  23         WREG8(MGA_CURPOSXL, 0);
  24         WREG8(MGA_CURPOSXH, 0);
  25         if (mdev->cursor.pixels_1->pin_count)
  26                 mgag200_bo_unpin(mdev->cursor.pixels_1);
  27         if (mdev->cursor.pixels_2->pin_count)
  28                 mgag200_bo_unpin(mdev->cursor.pixels_2);
  29 }
  30
  31 int mga_crtc_cursor_set(struct drm_crtc *crtc,
  32                         struct drm_file *file_priv,
  33                         uint32_t handle,
  34                         uint32_t width,
  35                         uint32_t height)
  36 {
  37         struct drm_device *dev = crtc->dev;
  38         struct mga_device *mdev = (struct mga_device *)dev->dev_private;
  39         struct mgag200_bo *pixels_1 = mdev->cursor.pixels_1;
  40         struct mgag200_bo *pixels_2 = mdev->cursor.pixels_2;
  41         struct mgag200_bo *pixels_current = mdev->cursor.pixels_current;
  42         struct mgag200_bo *pixels_prev = mdev->cursor.pixels_prev;
  43         struct drm_gem_object *obj;
  44         struct mgag200_bo *bo = NULL;
  45         int ret = 0;
  46         unsigned int i, row, col;
  47         uint32_t colour_set[16];
  48         uint32_t *next_space = &colour_set[0];
  49         uint32_t *palette_iter;
  50         uint32_t this_colour;
  51         bool found = false;
  52         int colour_count = 0;
  53         u64 gpu_addr;
  54         u8 reg_index;
  55         u8 this_row[48];
  56
  57         if (!pixels_1 || !pixels_2) {
  58                 WREG8(MGA_CURPOSXL, 0);
  59                 WREG8(MGA_CURPOSXH, 0);
  60                 return -ENOTSUPP; /* Didn't allocate space for cursors */
  61         }
  62
  63         if ((width != 64 || height != 64) && handle) {
  64                 WREG8(MGA_CURPOSXL, 0);
  65                 WREG8(MGA_CURPOSXH, 0);
  66                 return -EINVAL;
  67         }
  68
  69         BUG_ON(pixels_1 != pixels_current && pixels_1 != pixels_prev);
  70         BUG_ON(pixels_2 != pixels_current && pixels_2 != pixels_prev);
  71         BUG_ON(pixels_current == pixels_prev);
  72
  73         if (!handle || !file_priv) {
  74                 mga_hide_cursor(mdev);
  75                 return 0;
  76         }
  77
  78         obj = drm_gem_object_lookup(file_priv, handle);
  79         if (!obj)
  80                 return -ENOENT;
  81
  82         ret = mgag200_bo_reserve(pixels_1, true);
  83         if (ret) {
  84                 WREG8(MGA_CURPOSXL, 0);
  85                 WREG8(MGA_CURPOSXH, 0);
  86                 goto out_unref;
  87         }
  88         ret = mgag200_bo_reserve(pixels_2, true);
  89         if (ret) {
  90                 WREG8(MGA_CURPOSXL, 0);
  91                 WREG8(MGA_CURPOSXH, 0);
  92                 mgag200_bo_unreserve(pixels_1);
  93                 goto out_unreserve1;
  94         }
  95
  96         /* Move cursor buffers into VRAM if they aren't already */
  97         if (!pixels_1->pin_count) {
  98                 ret = mgag200_bo_pin(pixels_1, TTM_PL_FLAG_VRAM,
  99                                      &mdev->cursor.pixels_1_gpu_addr);
 100                 if (ret)
 101                         goto out1;
 102         }
 103         if (!pixels_2->pin_count) {
 104                 ret = mgag200_bo_pin(pixels_2, TTM_PL_FLAG_VRAM,
 105                                      &mdev->cursor.pixels_2_gpu_addr);
 106                 if (ret) {
 107                         mgag200_bo_unpin(pixels_1);
 108                         goto out1;
 109                 }
 110         }
 111
 112         bo = gem_to_mga_bo(obj);
 113         ret = mgag200_bo_reserve(bo, true);
 114         if (ret) {
 115                 dev_err(&dev->pdev->dev, "failed to reserve user bo\n");
 116                 goto out1;
 117         }
 118         if (!bo->kmap.virtual) {
 119                 ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &bo->kmap);
 120                 if (ret) {
 121                         dev_err(&dev->pdev->dev, "failed to kmap user buffer updates\n");
 122                         goto out2;
 123                 }
 124         }
 125
 126         memset(&colour_set[0], 0, sizeof(uint32_t)*16);
 127         /* width*height*4 = 16384 */
 128         for (i = 0; i < 16384; i += 4) {
 129                 this_colour = ioread32(bo->kmap.virtual + i);
 130                 /* No transparency */
 131                 if (this_colour>>24 != 0xff &&
 132                         this_colour>>24 != 0x0) {
 133                         if (warn_transparent) {
 134                                 dev_info(&dev->pdev->dev, "Video card doesn't support cursors with partial transparency.\n");
 135                                 dev_info(&dev->pdev->dev, "Not enabling hardware cursor.\n");
 136                                 warn_transparent = false; /* Only tell the user once. */
 137                         }
 138                         ret = -EINVAL;
 139                         goto out3;
 140                 }
 141                 /* Don't need to store transparent pixels as colours */
 142                 if (this_colour>>24 == 0x0)
 143                         continue;
 144                 found = false;
 145                 for (palette_iter = &colour_set[0]; palette_iter != next_space; palette_iter++) {
 146                         if (*palette_iter == this_colour) {
 147                                 found = true;
 148                                 break;
 149                         }
 150                 }
 151                 if (found)
 152                         continue;
 153                 /* We only support 4bit paletted cursors */
 154                 if (colour_count >= 16) {
 155                         if (warn_palette) {
 156                                 dev_info(&dev->pdev->dev, "Video card only supports cursors with up to 16 colours.\n");
 157                                 dev_info(&dev->pdev->dev, "Not enabling hardware cursor.\n");
 158                                 warn_palette = false; /* Only tell the user once. */
 159                         }
 160                         ret = -EINVAL;
 161                         goto out3;
 162                 }
 163                 *next_space = this_colour;
 164                 next_space++;
 165                 colour_count++;
 166         }
 167
 168         /* Program colours from cursor icon into palette */
 169         for (i = 0; i < colour_count; i++) {
 170                 if (i <= 2)
 171                         reg_index = 0x8 + i*0x4;
 172                 else
 173                         reg_index = 0x60 + i*0x3;
 174                 WREG_DAC(reg_index, colour_set[i] & 0xff);
 175                 WREG_DAC(reg_index+1, colour_set[i]>>8 & 0xff);
 176                 WREG_DAC(reg_index+2, colour_set[i]>>16 & 0xff);
 177                 BUG_ON((colour_set[i]>>24 & 0xff) != 0xff);
 178         }
 179
 180         /* Map up-coming buffer to write colour indices */
 181         if (!pixels_prev->kmap.virtual) {
 182                 ret = ttm_bo_kmap(&pixels_prev->bo, 0,
 183                                   pixels_prev->bo.num_pages,
 184                                   &pixels_prev->kmap);
 185                 if (ret) {
 186                         dev_err(&dev->pdev->dev, "failed to kmap cursor updates\n");
 187                         goto out3;
 188                 }
 189         }
 190
 191         /* now write colour indices into hardware cursor buffer */
 192         for (row = 0; row < 64; row++) {
 193                 memset(&this_row[0], 0, 48);
 194                 for (col = 0; col < 64; col++) {
 195                         this_colour = ioread32(bo->kmap.virtual + 4*(col + 64*row));
 196                         /* write transparent pixels */
 197                         if (this_colour>>24 == 0x0) {
 198                                 this_row[47 - col/8] |= 0x80>>(col%8);
 199                                 continue;
 200                         }
 201
 202                         /* write colour index here */
 203                         for (i = 0; i < colour_count; i++) {
 204                                 if (colour_set[i] == this_colour) {
 205                                         if (col % 2)
 206                                                 this_row[col/2] |= i<<4;
 207                                         else
 208                                                 this_row[col/2] |= i;
 209                                         break;
 210                                 }
 211                         }
 212                 }
 213                 memcpy_toio(pixels_prev->kmap.virtual + row*48, &this_row[0], 48);
 214         }
 215
 216         /* Program gpu address of cursor buffer */
 217         if (pixels_prev == pixels_1)
 218                 gpu_addr = mdev->cursor.pixels_1_gpu_addr;
 219         else
 220                 gpu_addr = mdev->cursor.pixels_2_gpu_addr;
 221         WREG_DAC(MGA1064_CURSOR_BASE_ADR_LOW, (u8)((gpu_addr>>10) & 0xff));
 222         WREG_DAC(MGA1064_CURSOR_BASE_ADR_HI, (u8)((gpu_addr>>18) & 0x3f));
 223
 224         /* Adjust cursor control register to turn on the cursor */
 225         WREG_DAC(MGA1064_CURSOR_CTL, 4); /* 16-colour palletized cursor mode */
 226
 227         /* Now swap internal buffer pointers */
 228         if (mdev->cursor.pixels_1 == mdev->cursor.pixels_prev) {
 229                 mdev->cursor.pixels_prev = mdev->cursor.pixels_2;
 230                 mdev->cursor.pixels_current = mdev->cursor.pixels_1;
 231         } else if (mdev->cursor.pixels_1 == mdev->cursor.pixels_current) {
 232                 mdev->cursor.pixels_prev = mdev->cursor.pixels_1;
 233                 mdev->cursor.pixels_current = mdev->cursor.pixels_2;
 234         } else {
 235                 BUG();
 236         }
 237         ret = 0;
 238
 239         ttm_bo_kunmap(&pixels_prev->kmap);
 240  out3:
 241         ttm_bo_kunmap(&bo->kmap);
 242  out2:
 243         mgag200_bo_unreserve(bo);
 244  out1:
 245         if (ret)
 246                 mga_hide_cursor(mdev);
 247         mgag200_bo_unreserve(pixels_1);
 248 out_unreserve1:
 249         mgag200_bo_unreserve(pixels_2);
 250 out_unref:
 251         drm_gem_object_unreference_unlocked(obj);
 252
 253         return ret;
 254 }
 255
 256 int mga_crtc_cursor_move(struct drm_crtc *crtc, int x, int y)
 257 {
 258         struct mga_device *mdev = (struct mga_device *)crtc->dev->dev_private;
 259         /* Our origin is at (64,64) */
 260         x += 64;
 261         y += 64;
 262
 263         BUG_ON(x <= 0);
 264         BUG_ON(y <= 0);
 265         BUG_ON(x & ~0xffff);
 266         BUG_ON(y & ~0xffff);
 267
 268         WREG8(MGA_CURPOSXL, x & 0xff);
 269         WREG8(MGA_CURPOSXH, (x>>8) & 0xff);
 270
 271         WREG8(MGA_CURPOSYL, y & 0xff);
 272         WREG8(MGA_CURPOSYH, (y>>8) & 0xff);
 273         return 0;
 274 }