drivers/gpu/drm/qxl/qxl_draw.c

   1 /*
   2  * Copyright 2011 Red Hat, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 #include "qxl_drv.h"
  24 #include "qxl_object.h"
  25
  26 static int alloc_clips(struct qxl_device *qdev,
  27                        struct qxl_release *release,
  28                        unsigned num_clips,
  29                        struct qxl_bo **clips_bo)
  30 {
  31         int size = sizeof(struct qxl_clip_rects) + sizeof(struct qxl_rect) * num_clips;
  32
  33         return qxl_alloc_bo_reserved(qdev, release, size, clips_bo);
  34 }
  35
  36 /* returns a pointer to the already allocated qxl_rect array inside
  37  * the qxl_clip_rects. This is *not* the same as the memory allocated
  38  * on the device, it is offset to qxl_clip_rects.chunk.data */
  39 static struct qxl_rect *drawable_set_clipping(struct qxl_device *qdev,
  40                                               struct qxl_drawable *drawable,
  41                                               unsigned num_clips,
  42                                               struct qxl_bo *clips_bo)
  43 {
  44         struct qxl_clip_rects *dev_clips;
  45         int ret;
  46
  47         ret = qxl_bo_kmap(clips_bo, (void **)&dev_clips);
  48         if (ret) {
  49                 return NULL;
  50         }
  51         dev_clips->num_rects = num_clips;
  52         dev_clips->chunk.next_chunk = 0;
  53         dev_clips->chunk.prev_chunk = 0;
  54         dev_clips->chunk.data_size = sizeof(struct qxl_rect) * num_clips;
  55         return (struct qxl_rect *)dev_clips->chunk.data;
  56 }
  57
  58 static int
  59 alloc_drawable(struct qxl_device *qdev, struct qxl_release **release)
  60 {
  61         int ret;
  62         ret = qxl_alloc_release_reserved(qdev, sizeof(struct qxl_drawable),
  63                                          QXL_RELEASE_DRAWABLE, release,
  64                                          NULL);
  65         return ret;
  66 }
  67
  68 static void
  69 free_drawable(struct qxl_device *qdev, struct qxl_release *release)
  70 {
  71         qxl_release_free(qdev, release);
  72 }
  73
  74 /* release needs to be reserved at this point */
  75 static int
  76 make_drawable(struct qxl_device *qdev, int surface, uint8_t type,
  77               const struct qxl_rect *rect,
  78               struct qxl_release *release)
  79 {
  80         struct qxl_drawable *drawable;
  81         int i;
  82
  83         drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);
  84         if (!drawable)
  85                 return -ENOMEM;
  86
  87         drawable->type = type;
  88
  89         drawable->surface_id = surface;         /* Only primary for now */
  90         drawable->effect = QXL_EFFECT_OPAQUE;
  91         drawable->self_bitmap = 0;
  92         drawable->self_bitmap_area.top = 0;
  93         drawable->self_bitmap_area.left = 0;
  94         drawable->self_bitmap_area.bottom = 0;
  95         drawable->self_bitmap_area.right = 0;
  96         /* FIXME: add clipping */
  97         drawable->clip.type = SPICE_CLIP_TYPE_NONE;
  98
  99         /*
 100          * surfaces_dest[i] should apparently be filled out with the
 101          * surfaces that we depend on, and surface_rects should be
 102          * filled with the rectangles of those surfaces that we
 103          * are going to use.
 104          */
 105         for (i = 0; i < 3; ++i)
 106                 drawable->surfaces_dest[i] = -1;
 107
 108         if (rect)
 109                 drawable->bbox = *rect;
 110
 111         drawable->mm_time = qdev->rom->mm_clock;
 112         qxl_release_unmap(qdev, release, &drawable->release_info);
 113         return 0;
 114 }
 115
 116 static int alloc_palette_object(struct qxl_device *qdev,
 117                                 struct qxl_release *release,
 118                                 struct qxl_bo **palette_bo)
 119 {
 120         return qxl_alloc_bo_reserved(qdev, release,
 121                                      sizeof(struct qxl_palette) + sizeof(uint32_t) * 2,
 122                                      palette_bo);
 123 }
 124
 125 static int qxl_palette_create_1bit(struct qxl_bo *palette_bo,
 126                                    struct qxl_release *release,
 127                                    const struct qxl_fb_image *qxl_fb_image)
 128 {
 129         const struct fb_image *fb_image = &qxl_fb_image->fb_image;
 130         uint32_t visual = qxl_fb_image->visual;
 131         const uint32_t *pseudo_palette = qxl_fb_image->pseudo_palette;
 132         struct qxl_palette *pal;
 133         int ret;
 134         uint32_t fgcolor, bgcolor;
 135         static uint64_t unique; /* we make no attempt to actually set this
 136                                  * correctly globaly, since that would require
 137                                  * tracking all of our palettes. */
 138         ret = qxl_bo_kmap(palette_bo, (void **)&pal);
 139         pal->num_ents = 2;
 140         pal->unique = unique++;
 141         if (visual == FB_VISUAL_TRUECOLOR || visual == FB_VISUAL_DIRECTCOLOR) {
 142                 /* NB: this is the only used branch currently. */
 143                 fgcolor = pseudo_palette[fb_image->fg_color];
 144                 bgcolor = pseudo_palette[fb_image->bg_color];
 145         } else {
 146                 fgcolor = fb_image->fg_color;
 147                 bgcolor = fb_image->bg_color;
 148         }
 149         pal->ents[0] = bgcolor;
 150         pal->ents[1] = fgcolor;
 151         qxl_bo_kunmap(palette_bo);
 152         return 0;
 153 }
 154
 155 void qxl_draw_opaque_fb(const struct qxl_fb_image *qxl_fb_image,
 156                         int stride /* filled in if 0 */)
 157 {
 158         struct qxl_device *qdev = qxl_fb_image->qdev;
 159         struct qxl_drawable *drawable;
 160         struct qxl_rect rect;
 161         const struct fb_image *fb_image = &qxl_fb_image->fb_image;
 162         int x = fb_image->dx;
 163         int y = fb_image->dy;
 164         int width = fb_image->width;
 165         int height = fb_image->height;
 166         const char *src = fb_image->data;
 167         int depth = fb_image->depth;
 168         struct qxl_release *release;
 169         struct qxl_image *image;
 170         int ret;
 171         struct qxl_drm_image *dimage;
 172         struct qxl_bo *palette_bo = NULL;
 173         if (stride == 0)
 174                 stride = depth * width / 8;
 175
 176         ret = alloc_drawable(qdev, &release);
 177         if (ret)
 178                 return;
 179
 180         ret = qxl_image_alloc_objects(qdev, release,
 181                                       &dimage,
 182                                       height, stride);
 183         if (ret)
 184                 goto out_free_drawable;
 185
 186         if (depth == 1) {
 187                 ret = alloc_palette_object(qdev, release, &palette_bo);
 188                 if (ret)
 189                         goto out_free_image;
 190         }
 191
 192         /* do a reservation run over all the objects we just allocated */
 193         ret = qxl_release_reserve_list(release, true);
 194         if (ret)
 195                 goto out_free_palette;
 196
 197         rect.left = x;
 198         rect.right = x + width;
 199         rect.top = y;
 200         rect.bottom = y + height;
 201
 202         ret = make_drawable(qdev, 0, QXL_DRAW_COPY, &rect, release);
 203         if (ret) {
 204                 qxl_release_backoff_reserve_list(release);
 205                 goto out_free_palette;
 206         }
 207
 208         ret = qxl_image_init(qdev, release, dimage,
 209                              (const uint8_t *)src, 0, 0,
 210                              width, height, depth, stride);
 211         if (ret) {
 212                 qxl_release_backoff_reserve_list(release);
 213                 qxl_release_free(qdev, release);
 214                 return;
 215         }
 216
 217         if (depth == 1) {
 218                 void *ptr;
 219                 ret = qxl_palette_create_1bit(palette_bo, release, qxl_fb_image);
 220
 221                 ptr = qxl_bo_kmap_atomic_page(qdev, dimage->bo, 0);
 222                 image = ptr;
 223                 image->u.bitmap.palette =
 224                         qxl_bo_physical_address(qdev, palette_bo, 0);
 225                 qxl_bo_kunmap_atomic_page(qdev, dimage->bo, ptr);
 226         }
 227
 228         drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);
 229
 230         drawable->u.copy.src_area.top = 0;
 231         drawable->u.copy.src_area.bottom = height;
 232         drawable->u.copy.src_area.left = 0;
 233         drawable->u.copy.src_area.right = width;
 234
 235         drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT;
 236         drawable->u.copy.scale_mode = 0;
 237         drawable->u.copy.mask.flags = 0;
 238         drawable->u.copy.mask.pos.x = 0;
 239         drawable->u.copy.mask.pos.y = 0;
 240         drawable->u.copy.mask.bitmap = 0;
 241
 242         drawable->u.copy.src_bitmap =
 243                 qxl_bo_physical_address(qdev, dimage->bo, 0);
 244         qxl_release_unmap(qdev, release, &drawable->release_info);
 245
 246         qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
 247         qxl_release_fence_buffer_objects(release);
 248
 249 out_free_palette:
 250         if (palette_bo)
 251                 qxl_bo_unref(&palette_bo);
 252 out_free_image:
 253         qxl_image_free_objects(qdev, dimage);
 254 out_free_drawable:
 255         if (ret)
 256                 free_drawable(qdev, release);
 257 }
 258
 259 /* push a draw command using the given clipping rectangles as
 260  * the sources from the shadow framebuffer.
 261  *
 262  * Right now implementing with a single draw and a clip list. Clip
 263  * lists are known to be a problem performance wise, this can be solved
 264  * by treating them differently in the server.
 265  */
 266 void qxl_draw_dirty_fb(struct qxl_device *qdev,
 267                        struct qxl_framebuffer *qxl_fb,
 268                        struct qxl_bo *bo,
 269                        unsigned flags, unsigned color,
 270                        struct drm_clip_rect *clips,
 271                        unsigned num_clips, int inc)
 272 {
 273         /*
 274          * TODO: if flags & DRM_MODE_FB_DIRTY_ANNOTATE_FILL then we should
 275          * send a fill command instead, much cheaper.
 276          *
 277          * See include/drm/drm_mode.h
 278          */
 279         struct drm_clip_rect *clips_ptr;
 280         int i;
 281         int left, right, top, bottom;
 282         int width, height;
 283         struct qxl_drawable *drawable;
 284         struct qxl_rect drawable_rect;
 285         struct qxl_rect *rects;
 286         int stride = qxl_fb->base.pitches[0];
 287         /* depth is not actually interesting, we don't mask with it */
 288         int depth = qxl_fb->base.bits_per_pixel;
 289         uint8_t *surface_base;
 290         struct qxl_release *release;
 291         struct qxl_bo *clips_bo;
 292         struct qxl_drm_image *dimage;
 293         int ret;
 294
 295         ret = alloc_drawable(qdev, &release);
 296         if (ret)
 297                 return;
 298
 299         left = clips->x1;
 300         right = clips->x2;
 301         top = clips->y1;
 302         bottom = clips->y2;
 303
 304         /* skip the first clip rect */
 305         for (i = 1, clips_ptr = clips + inc;
 306              i < num_clips; i++, clips_ptr += inc) {
 307                 left = min_t(int, left, (int)clips_ptr->x1);
 308                 right = max_t(int, right, (int)clips_ptr->x2);
 309                 top = min_t(int, top, (int)clips_ptr->y1);
 310                 bottom = max_t(int, bottom, (int)clips_ptr->y2);
 311         }
 312
 313         width = right - left;
 314         height = bottom - top;
 315
 316         ret = alloc_clips(qdev, release, num_clips, &clips_bo);
 317         if (ret)
 318                 goto out_free_drawable;
 319
 320         ret = qxl_image_alloc_objects(qdev, release,
 321                                       &dimage,
 322                                       height, stride);
 323         if (ret)
 324                 goto out_free_clips;
 325
 326         /* do a reservation run over all the objects we just allocated */
 327         ret = qxl_release_reserve_list(release, true);
 328         if (ret)
 329                 goto out_free_image;
 330
 331         drawable_rect.left = left;
 332         drawable_rect.right = right;
 333         drawable_rect.top = top;
 334         drawable_rect.bottom = bottom;
 335
 336         ret = make_drawable(qdev, 0, QXL_DRAW_COPY, &drawable_rect,
 337                             release);
 338         if (ret)
 339                 goto out_release_backoff;
 340
 341         ret = qxl_bo_kmap(bo, (void **)&surface_base);
 342         if (ret)
 343                 goto out_release_backoff;
 344
 345
 346         ret = qxl_image_init(qdev, release, dimage, surface_base,
 347                              left, top, width, height, depth, stride);
 348         qxl_bo_kunmap(bo);
 349         if (ret)
 350                 goto out_release_backoff;
 351
 352         rects = drawable_set_clipping(qdev, drawable, num_clips, clips_bo);
 353         if (!rects)
 354                 goto out_release_backoff;
 355
 356         drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);
 357
 358         drawable->clip.type = SPICE_CLIP_TYPE_RECTS;
 359         drawable->clip.data = qxl_bo_physical_address(qdev,
 360                                                       clips_bo, 0);
 361
 362         drawable->u.copy.src_area.top = 0;
 363         drawable->u.copy.src_area.bottom = height;
 364         drawable->u.copy.src_area.left = 0;
 365         drawable->u.copy.src_area.right = width;
 366
 367         drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT;
 368         drawable->u.copy.scale_mode = 0;
 369         drawable->u.copy.mask.flags = 0;
 370         drawable->u.copy.mask.pos.x = 0;
 371         drawable->u.copy.mask.pos.y = 0;
 372         drawable->u.copy.mask.bitmap = 0;
 373
 374         drawable->u.copy.src_bitmap = qxl_bo_physical_address(qdev, dimage->bo, 0);
 375         qxl_release_unmap(qdev, release, &drawable->release_info);
 376
 377         clips_ptr = clips;
 378         for (i = 0; i < num_clips; i++, clips_ptr += inc) {
 379                 rects[i].left   = clips_ptr->x1;
 380                 rects[i].right  = clips_ptr->x2;
 381                 rects[i].top    = clips_ptr->y1;
 382                 rects[i].bottom = clips_ptr->y2;
 383         }
 384         qxl_bo_kunmap(clips_bo);
 385
 386         qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
 387         qxl_release_fence_buffer_objects(release);
 388
 389 out_release_backoff:
 390         if (ret)
 391                 qxl_release_backoff_reserve_list(release);
 392 out_free_image:
 393         qxl_image_free_objects(qdev, dimage);
 394 out_free_clips:
 395         qxl_bo_unref(&clips_bo);
 396 out_free_drawable:
 397         /* only free drawable on error */
 398         if (ret)
 399                 free_drawable(qdev, release);
 400
 401 }
 402
 403 void qxl_draw_copyarea(struct qxl_device *qdev,
 404                        u32 width, u32 height,
 405                        u32 sx, u32 sy,
 406                        u32 dx, u32 dy)
 407 {
 408         struct qxl_drawable *drawable;
 409         struct qxl_rect rect;
 410         struct qxl_release *release;
 411         int ret;
 412
 413         ret = alloc_drawable(qdev, &release);
 414         if (ret)
 415                 return;
 416
 417         /* do a reservation run over all the objects we just allocated */
 418         ret = qxl_release_reserve_list(release, true);
 419         if (ret)
 420                 goto out_free_release;
 421
 422         rect.left = dx;
 423         rect.top = dy;
 424         rect.right = dx + width;
 425         rect.bottom = dy + height;
 426         ret = make_drawable(qdev, 0, QXL_COPY_BITS, &rect, release);
 427         if (ret) {
 428                 qxl_release_backoff_reserve_list(release);
 429                 goto out_free_release;
 430         }
 431
 432         drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);
 433         drawable->u.copy_bits.src_pos.x = sx;
 434         drawable->u.copy_bits.src_pos.y = sy;
 435         qxl_release_unmap(qdev, release, &drawable->release_info);
 436
 437         qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
 438         qxl_release_fence_buffer_objects(release);
 439
 440 out_free_release:
 441         if (ret)
 442                 free_drawable(qdev, release);
 443 }
 444
 445 void qxl_draw_fill(struct qxl_draw_fill *qxl_draw_fill_rec)
 446 {
 447         struct qxl_device *qdev = qxl_draw_fill_rec->qdev;
 448         struct qxl_rect rect = qxl_draw_fill_rec->rect;
 449         uint32_t color = qxl_draw_fill_rec->color;
 450         uint16_t rop = qxl_draw_fill_rec->rop;
 451         struct qxl_drawable *drawable;
 452         struct qxl_release *release;
 453         int ret;
 454
 455         ret = alloc_drawable(qdev, &release);
 456         if (ret)
 457                 return;
 458
 459         /* do a reservation run over all the objects we just allocated */
 460         ret = qxl_release_reserve_list(release, true);
 461         if (ret)
 462                 goto out_free_release;
 463
 464         ret = make_drawable(qdev, 0, QXL_DRAW_FILL, &rect, release);
 465         if (ret) {
 466                 qxl_release_backoff_reserve_list(release);
 467                 goto out_free_release;
 468         }
 469
 470         drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);
 471         drawable->u.fill.brush.type = SPICE_BRUSH_TYPE_SOLID;
 472         drawable->u.fill.brush.u.color = color;
 473         drawable->u.fill.rop_descriptor = rop;
 474         drawable->u.fill.mask.flags = 0;
 475         drawable->u.fill.mask.pos.x = 0;
 476         drawable->u.fill.mask.pos.y = 0;
 477         drawable->u.fill.mask.bitmap = 0;
 478
 479         qxl_release_unmap(qdev, release, &drawable->release_info);
 480
 481         qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
 482         qxl_release_fence_buffer_objects(release);
 483
 484 out_free_release:
 485         if (ret)
 486                 free_drawable(qdev, release);
 487 }