drivers/gpu/drm/qxl/qxl_fb.c

   1 /*
   2  * Copyright © 2013 Red Hat
   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  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *     David Airlie
  25  */
  26 #include <linux/module.h>
  27 #include <linux/fb.h>
  28
  29 #include "drmP.h"
  30 #include "drm/drm.h"
  31 #include "drm/drm_crtc.h"
  32 #include "drm/drm_crtc_helper.h"
  33 #include "qxl_drv.h"
  34
  35 #include "qxl_object.h"
  36 #include "drm_fb_helper.h"
  37
  38 #define QXL_DIRTY_DELAY (HZ / 30)
  39
  40 struct qxl_fbdev {
  41         struct drm_fb_helper helper;
  42         struct qxl_framebuffer  qfb;
  43         struct qxl_device       *qdev;
  44
  45         spinlock_t delayed_ops_lock;
  46         struct list_head delayed_ops;
  47         void *shadow;
  48         int size;
  49
  50         /* dirty memory logging */
  51         struct {
  52                 spinlock_t lock;
  53                 unsigned x1;
  54                 unsigned y1;
  55                 unsigned x2;
  56                 unsigned y2;
  57         } dirty;
  58 };
  59
  60 static void qxl_fb_image_init(struct qxl_fb_image *qxl_fb_image,
  61                               struct qxl_device *qdev, struct fb_info *info,
  62                               const struct fb_image *image)
  63 {
  64         qxl_fb_image->qdev = qdev;
  65         if (info) {
  66                 qxl_fb_image->visual = info->fix.visual;
  67                 if (qxl_fb_image->visual == FB_VISUAL_TRUECOLOR ||
  68                     qxl_fb_image->visual == FB_VISUAL_DIRECTCOLOR)
  69                         memcpy(&qxl_fb_image->pseudo_palette,
  70                                info->pseudo_palette,
  71                                sizeof(qxl_fb_image->pseudo_palette));
  72         } else {
  73                  /* fallback */
  74                 if (image->depth == 1)
  75                         qxl_fb_image->visual = FB_VISUAL_MONO10;
  76                 else
  77                         qxl_fb_image->visual = FB_VISUAL_DIRECTCOLOR;
  78         }
  79         if (image) {
  80                 memcpy(&qxl_fb_image->fb_image, image,
  81                        sizeof(qxl_fb_image->fb_image));
  82         }
  83 }
  84
  85 static void qxl_fb_dirty_flush(struct fb_info *info)
  86 {
  87         struct qxl_fbdev *qfbdev = info->par;
  88         struct qxl_device *qdev = qfbdev->qdev;
  89         struct qxl_fb_image qxl_fb_image;
  90         struct fb_image *image = &qxl_fb_image.fb_image;
  91         unsigned long flags;
  92         u32 x1, x2, y1, y2;
  93
  94         /* TODO: hard coding 32 bpp */
  95         int stride = qfbdev->qfb.base.pitches[0];
  96
  97         spin_lock_irqsave(&qfbdev->dirty.lock, flags);
  98
  99         x1 = qfbdev->dirty.x1;
 100         x2 = qfbdev->dirty.x2;
 101         y1 = qfbdev->dirty.y1;
 102         y2 = qfbdev->dirty.y2;
 103         qfbdev->dirty.x1 = 0;
 104         qfbdev->dirty.x2 = 0;
 105         qfbdev->dirty.y1 = 0;
 106         qfbdev->dirty.y2 = 0;
 107
 108         spin_unlock_irqrestore(&qfbdev->dirty.lock, flags);
 109
 110         /*
 111          * we are using a shadow draw buffer, at qdev->surface0_shadow
 112          */
 113         qxl_io_log(qdev, "dirty x[%d, %d], y[%d, %d]", x1, x2, y1, y2);
 114         image->dx = x1;
 115         image->dy = y1;
 116         image->width = x2 - x1 + 1;
 117         image->height = y2 - y1 + 1;
 118         image->fg_color = 0xffffffff; /* unused, just to avoid uninitialized
 119                                          warnings */
 120         image->bg_color = 0;
 121         image->depth = 32;           /* TODO: take from somewhere? */
 122         image->cmap.start = 0;
 123         image->cmap.len = 0;
 124         image->cmap.red = NULL;
 125         image->cmap.green = NULL;
 126         image->cmap.blue = NULL;
 127         image->cmap.transp = NULL;
 128         image->data = qfbdev->shadow + (x1 * 4) + (stride * y1);
 129
 130         qxl_fb_image_init(&qxl_fb_image, qdev, info, NULL);
 131         qxl_draw_opaque_fb(&qxl_fb_image, stride);
 132 }
 133
 134 static void qxl_dirty_update(struct qxl_fbdev *qfbdev,
 135                              int x, int y, int width, int height)
 136 {
 137         struct qxl_device *qdev = qfbdev->qdev;
 138         unsigned long flags;
 139         int x2, y2;
 140
 141         x2 = x + width - 1;
 142         y2 = y + height - 1;
 143
 144         spin_lock_irqsave(&qfbdev->dirty.lock, flags);
 145
 146         if ((qfbdev->dirty.y2 - qfbdev->dirty.y1) &&
 147             (qfbdev->dirty.x2 - qfbdev->dirty.x1)) {
 148                 if (qfbdev->dirty.y1 < y)
 149                         y = qfbdev->dirty.y1;
 150                 if (qfbdev->dirty.y2 > y2)
 151                         y2 = qfbdev->dirty.y2;
 152                 if (qfbdev->dirty.x1 < x)
 153                         x = qfbdev->dirty.x1;
 154                 if (qfbdev->dirty.x2 > x2)
 155                         x2 = qfbdev->dirty.x2;
 156         }
 157
 158         qfbdev->dirty.x1 = x;
 159         qfbdev->dirty.x2 = x2;
 160         qfbdev->dirty.y1 = y;
 161         qfbdev->dirty.y2 = y2;
 162
 163         spin_unlock_irqrestore(&qfbdev->dirty.lock, flags);
 164
 165         schedule_work(&qdev->fb_work);
 166 }
 167
 168 static void qxl_deferred_io(struct fb_info *info,
 169                             struct list_head *pagelist)
 170 {
 171         struct qxl_fbdev *qfbdev = info->par;
 172         unsigned long start, end, min, max;
 173         struct page *page;
 174         int y1, y2;
 175
 176         min = ULONG_MAX;
 177         max = 0;
 178         list_for_each_entry(page, pagelist, lru) {
 179                 start = page->index << PAGE_SHIFT;
 180                 end = start + PAGE_SIZE - 1;
 181                 min = min(min, start);
 182                 max = max(max, end);
 183         }
 184
 185         if (min < max) {
 186                 y1 = min / info->fix.line_length;
 187                 y2 = (max / info->fix.line_length) + 1;
 188                 qxl_dirty_update(qfbdev, 0, y1, info->var.xres, y2 - y1);
 189         }
 190 };
 191
 192 static struct fb_deferred_io qxl_defio = {
 193         .delay          = QXL_DIRTY_DELAY,
 194         .deferred_io    = qxl_deferred_io,
 195 };
 196
 197 static void qxl_fb_fillrect(struct fb_info *info,
 198                             const struct fb_fillrect *rect)
 199 {
 200         struct qxl_fbdev *qfbdev = info->par;
 201
 202         drm_fb_helper_sys_fillrect(info, rect);
 203         qxl_dirty_update(qfbdev, rect->dx, rect->dy, rect->width,
 204                          rect->height);
 205 }
 206
 207 static void qxl_fb_copyarea(struct fb_info *info,
 208                             const struct fb_copyarea *area)
 209 {
 210         struct qxl_fbdev *qfbdev = info->par;
 211
 212         drm_fb_helper_sys_copyarea(info, area);
 213         qxl_dirty_update(qfbdev, area->dx, area->dy, area->width,
 214                          area->height);
 215 }
 216
 217 static void qxl_fb_imageblit(struct fb_info *info,
 218                              const struct fb_image *image)
 219 {
 220         struct qxl_fbdev *qfbdev = info->par;
 221
 222         drm_fb_helper_sys_imageblit(info, image);
 223         qxl_dirty_update(qfbdev, image->dx, image->dy, image->width,
 224                          image->height);
 225 }
 226
 227 static void qxl_fb_work(struct work_struct *work)
 228 {
 229         struct qxl_device *qdev = container_of(work, struct qxl_device, fb_work);
 230         struct qxl_fbdev *qfbdev = qdev->mode_info.qfbdev;
 231
 232         qxl_fb_dirty_flush(qfbdev->helper.fbdev);
 233 }
 234
 235 int qxl_fb_init(struct qxl_device *qdev)
 236 {
 237         INIT_WORK(&qdev->fb_work, qxl_fb_work);
 238         return 0;
 239 }
 240
 241 static struct fb_ops qxlfb_ops = {
 242         .owner = THIS_MODULE,
 243         .fb_check_var = drm_fb_helper_check_var,
 244         .fb_set_par = drm_fb_helper_set_par, /* TODO: copy vmwgfx */
 245         .fb_fillrect = qxl_fb_fillrect,
 246         .fb_copyarea = qxl_fb_copyarea,
 247         .fb_imageblit = qxl_fb_imageblit,
 248         .fb_pan_display = drm_fb_helper_pan_display,
 249         .fb_blank = drm_fb_helper_blank,
 250         .fb_setcmap = drm_fb_helper_setcmap,
 251         .fb_debug_enter = drm_fb_helper_debug_enter,
 252         .fb_debug_leave = drm_fb_helper_debug_leave,
 253 };
 254
 255 static void qxlfb_destroy_pinned_object(struct drm_gem_object *gobj)
 256 {
 257         struct qxl_bo *qbo = gem_to_qxl_bo(gobj);
 258         int ret;
 259
 260         ret = qxl_bo_reserve(qbo, false);
 261         if (likely(ret == 0)) {
 262                 qxl_bo_kunmap(qbo);
 263                 qxl_bo_unpin(qbo);
 264                 qxl_bo_unreserve(qbo);
 265         }
 266         drm_gem_object_unreference_unlocked(gobj);
 267 }
 268
 269 int qxl_get_handle_for_primary_fb(struct qxl_device *qdev,
 270                                   struct drm_file *file_priv,
 271                                   uint32_t *handle)
 272 {
 273         int r;
 274         struct drm_gem_object *gobj = qdev->fbdev_qfb->obj;
 275
 276         BUG_ON(!gobj);
 277         /* drm_get_handle_create adds a reference - good */
 278         r = drm_gem_handle_create(file_priv, gobj, handle);
 279         if (r)
 280                 return r;
 281         return 0;
 282 }
 283
 284 static int qxlfb_create_pinned_object(struct qxl_fbdev *qfbdev,
 285                                       const struct drm_mode_fb_cmd2 *mode_cmd,
 286                                       struct drm_gem_object **gobj_p)
 287 {
 288         struct qxl_device *qdev = qfbdev->qdev;
 289         struct drm_gem_object *gobj = NULL;
 290         struct qxl_bo *qbo = NULL;
 291         int ret;
 292         int aligned_size, size;
 293         int height = mode_cmd->height;
 294         int bpp;
 295         int depth;
 296
 297         drm_fb_get_bpp_depth(mode_cmd->pixel_format, &bpp, &depth);
 298
 299         size = mode_cmd->pitches[0] * height;
 300         aligned_size = ALIGN(size, PAGE_SIZE);
 301         /* TODO: unallocate and reallocate surface0 for real. Hack to just
 302          * have a large enough surface0 for 1024x768 Xorg 32bpp mode */
 303         ret = qxl_gem_object_create(qdev, aligned_size, 0,
 304                                     QXL_GEM_DOMAIN_SURFACE,
 305                                     false, /* is discardable */
 306                                     false, /* is kernel (false means device) */
 307                                     NULL,
 308                                     &gobj);
 309         if (ret) {
 310                 pr_err("failed to allocate framebuffer (%d)\n",
 311                        aligned_size);
 312                 return -ENOMEM;
 313         }
 314         qbo = gem_to_qxl_bo(gobj);
 315
 316         qbo->surf.width = mode_cmd->width;
 317         qbo->surf.height = mode_cmd->height;
 318         qbo->surf.stride = mode_cmd->pitches[0];
 319         qbo->surf.format = SPICE_SURFACE_FMT_32_xRGB;
 320         ret = qxl_bo_reserve(qbo, false);
 321         if (unlikely(ret != 0))
 322                 goto out_unref;
 323         ret = qxl_bo_pin(qbo, QXL_GEM_DOMAIN_SURFACE, NULL);
 324         if (ret) {
 325                 qxl_bo_unreserve(qbo);
 326                 goto out_unref;
 327         }
 328         ret = qxl_bo_kmap(qbo, NULL);
 329         qxl_bo_unreserve(qbo); /* unreserve, will be mmaped */
 330         if (ret)
 331                 goto out_unref;
 332
 333         *gobj_p = gobj;
 334         return 0;
 335 out_unref:
 336         qxlfb_destroy_pinned_object(gobj);
 337         *gobj_p = NULL;
 338         return ret;
 339 }
 340
 341 static int qxlfb_create(struct qxl_fbdev *qfbdev,
 342                         struct drm_fb_helper_surface_size *sizes)
 343 {
 344         struct qxl_device *qdev = qfbdev->qdev;
 345         struct fb_info *info;
 346         struct drm_framebuffer *fb = NULL;
 347         struct drm_mode_fb_cmd2 mode_cmd;
 348         struct drm_gem_object *gobj = NULL;
 349         struct qxl_bo *qbo = NULL;
 350         int ret;
 351         int size;
 352         int bpp = sizes->surface_bpp;
 353         int depth = sizes->surface_depth;
 354         void *shadow;
 355
 356         mode_cmd.width = sizes->surface_width;
 357         mode_cmd.height = sizes->surface_height;
 358
 359         mode_cmd.pitches[0] = ALIGN(mode_cmd.width * ((bpp + 1) / 8), 64);
 360         mode_cmd.pixel_format = drm_mode_legacy_fb_format(bpp, depth);
 361
 362         ret = qxlfb_create_pinned_object(qfbdev, &mode_cmd, &gobj);
 363         qbo = gem_to_qxl_bo(gobj);
 364         QXL_INFO(qdev, "%s: %dx%d %d\n", __func__, mode_cmd.width,
 365                  mode_cmd.height, mode_cmd.pitches[0]);
 366
 367         shadow = vmalloc(mode_cmd.pitches[0] * mode_cmd.height);
 368         /* TODO: what's the usual response to memory allocation errors? */
 369         BUG_ON(!shadow);
 370         QXL_INFO(qdev,
 371         "surface0 at gpu offset %lld, mmap_offset %lld (virt %p, shadow %p)\n",
 372                  qxl_bo_gpu_offset(qbo),
 373                  qxl_bo_mmap_offset(qbo),
 374                  qbo->kptr,
 375                  shadow);
 376         size = mode_cmd.pitches[0] * mode_cmd.height;
 377
 378         info = drm_fb_helper_alloc_fbi(&qfbdev->helper);
 379         if (IS_ERR(info)) {
 380                 ret = PTR_ERR(info);
 381                 goto out_unref;
 382         }
 383
 384         info->par = qfbdev;
 385
 386         qxl_framebuffer_init(qdev->ddev, &qfbdev->qfb, &mode_cmd, gobj);
 387
 388         fb = &qfbdev->qfb.base;
 389
 390         /* setup helper with fb data */
 391         qfbdev->helper.fb = fb;
 392
 393         qfbdev->shadow = shadow;
 394         strcpy(info->fix.id, "qxldrmfb");
 395
 396         drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
 397
 398         info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT;
 399         info->fbops = &qxlfb_ops;
 400
 401         /*
 402          * TODO: using gobj->size in various places in this function. Not sure
 403          * what the difference between the different sizes is.
 404          */
 405         info->fix.smem_start = qdev->vram_base; /* TODO - correct? */
 406         info->fix.smem_len = gobj->size;
 407         info->screen_base = qfbdev->shadow;
 408         info->screen_size = gobj->size;
 409
 410         drm_fb_helper_fill_var(info, &qfbdev->helper, sizes->fb_width,
 411                                sizes->fb_height);
 412
 413         /* setup aperture base/size for vesafb takeover */
 414         info->apertures->ranges[0].base = qdev->ddev->mode_config.fb_base;
 415         info->apertures->ranges[0].size = qdev->vram_size;
 416
 417         info->fix.mmio_start = 0;
 418         info->fix.mmio_len = 0;
 419
 420         if (info->screen_base == NULL) {
 421                 ret = -ENOSPC;
 422                 goto out_destroy_fbi;
 423         }
 424
 425         info->fbdefio = &qxl_defio;
 426         fb_deferred_io_init(info);
 427
 428         qdev->fbdev_info = info;
 429         qdev->fbdev_qfb = &qfbdev->qfb;
 430         DRM_INFO("fb mappable at 0x%lX, size %lu\n",  info->fix.smem_start, (unsigned long)info->screen_size);
 431         DRM_INFO("fb: depth %d, pitch %d, width %d, height %d\n", fb->depth, fb->pitches[0], fb->width, fb->height);
 432         return 0;
 433
 434 out_destroy_fbi:
 435         drm_fb_helper_release_fbi(&qfbdev->helper);
 436 out_unref:
 437         if (qbo) {
 438                 ret = qxl_bo_reserve(qbo, false);
 439                 if (likely(ret == 0)) {
 440                         qxl_bo_kunmap(qbo);
 441                         qxl_bo_unpin(qbo);
 442                         qxl_bo_unreserve(qbo);
 443                 }
 444         }
 445         if (fb && ret) {
 446                 drm_gem_object_unreference(gobj);
 447                 drm_framebuffer_cleanup(fb);
 448                 kfree(fb);
 449         }
 450         drm_gem_object_unreference(gobj);
 451         return ret;
 452 }
 453
 454 static int qxl_fb_find_or_create_single(
 455                 struct drm_fb_helper *helper,
 456                 struct drm_fb_helper_surface_size *sizes)
 457 {
 458         struct qxl_fbdev *qfbdev =
 459                 container_of(helper, struct qxl_fbdev, helper);
 460         int new_fb = 0;
 461         int ret;
 462
 463         if (!helper->fb) {
 464                 ret = qxlfb_create(qfbdev, sizes);
 465                 if (ret)
 466                         return ret;
 467                 new_fb = 1;
 468         }
 469         return new_fb;
 470 }
 471
 472 static int qxl_fbdev_destroy(struct drm_device *dev, struct qxl_fbdev *qfbdev)
 473 {
 474         struct qxl_framebuffer *qfb = &qfbdev->qfb;
 475
 476         drm_fb_helper_unregister_fbi(&qfbdev->helper);
 477         drm_fb_helper_release_fbi(&qfbdev->helper);
 478
 479         if (qfb->obj) {
 480                 qxlfb_destroy_pinned_object(qfb->obj);
 481                 qfb->obj = NULL;
 482         }
 483         drm_fb_helper_fini(&qfbdev->helper);
 484         vfree(qfbdev->shadow);
 485         drm_framebuffer_cleanup(&qfb->base);
 486
 487         return 0;
 488 }
 489
 490 static const struct drm_fb_helper_funcs qxl_fb_helper_funcs = {
 491         .fb_probe = qxl_fb_find_or_create_single,
 492 };
 493
 494 int qxl_fbdev_init(struct qxl_device *qdev)
 495 {
 496         struct qxl_fbdev *qfbdev;
 497         int bpp_sel = 32; /* TODO: parameter from somewhere? */
 498         int ret;
 499
 500         qfbdev = kzalloc(sizeof(struct qxl_fbdev), GFP_KERNEL);
 501         if (!qfbdev)
 502                 return -ENOMEM;
 503
 504         qfbdev->qdev = qdev;
 505         qdev->mode_info.qfbdev = qfbdev;
 506         spin_lock_init(&qfbdev->delayed_ops_lock);
 507         spin_lock_init(&qfbdev->dirty.lock);
 508         INIT_LIST_HEAD(&qfbdev->delayed_ops);
 509
 510         drm_fb_helper_prepare(qdev->ddev, &qfbdev->helper,
 511                               &qxl_fb_helper_funcs);
 512
 513         ret = drm_fb_helper_init(qdev->ddev, &qfbdev->helper,
 514                                  qxl_num_crtc /* num_crtc - QXL supports just 1 */,
 515                                  QXLFB_CONN_LIMIT);
 516         if (ret)
 517                 goto free;
 518
 519         ret = drm_fb_helper_single_add_all_connectors(&qfbdev->helper);
 520         if (ret)
 521                 goto fini;
 522
 523         ret = drm_fb_helper_initial_config(&qfbdev->helper, bpp_sel);
 524         if (ret)
 525                 goto fini;
 526
 527         return 0;
 528
 529 fini:
 530         drm_fb_helper_fini(&qfbdev->helper);
 531 free:
 532         kfree(qfbdev);
 533         return ret;
 534 }
 535
 536 void qxl_fbdev_fini(struct qxl_device *qdev)
 537 {
 538         if (!qdev->mode_info.qfbdev)
 539                 return;
 540
 541         qxl_fbdev_destroy(qdev->ddev, qdev->mode_info.qfbdev);
 542         kfree(qdev->mode_info.qfbdev);
 543         qdev->mode_info.qfbdev = NULL;
 544 }
 545
 546 void qxl_fbdev_set_suspend(struct qxl_device *qdev, int state)
 547 {
 548         drm_fb_helper_set_suspend(&qdev->mode_info.qfbdev->helper, state);
 549 }
 550
 551 bool qxl_fbdev_qobj_is_fb(struct qxl_device *qdev, struct qxl_bo *qobj)
 552 {
 553         if (qobj == gem_to_qxl_bo(qdev->mode_info.qfbdev->qfb.obj))
 554                 return true;
 555         return false;
 556 }