static int qxl_palette_create_1bit(struct qxl_bo *palette_bo, struct qxl_release *release, const struct qxl_fb_image *qxl_fb_image) { const struct fb_image *fb_image = &qxl_fb_image->fb_image; uint32_t visual = qxl_fb_image->visual; const uint32_t *pseudo_palette = qxl_fb_image->pseudo_palette; struct qxl_palette *pal; int ret; uint32_t fgcolor, bgcolor; static uint64_t unique; /* we make no attempt to actually set this * correctly globaly, since that would require * tracking all of our palettes. */ ret = qxl_bo_kmap(palette_bo, (void **)&pal); pal->num_ents = 2; pal->unique = unique++; if (visual == FB_VISUAL_TRUECOLOR || visual == FB_VISUAL_DIRECTCOLOR) { /* NB: this is the only used branch currently. */ fgcolor = pseudo_palette[fb_image->fg_color]; bgcolor = pseudo_palette[fb_image->bg_color]; } else { fgcolor = fb_image->fg_color; bgcolor = fb_image->bg_color; } pal->ents[0] = bgcolor; pal->ents[1] = fgcolor; qxl_bo_kunmap(palette_bo); return 0; }
static void qxlfb_destroy_pinned_object(struct drm_gem_object *gobj) { struct qxl_bo *qbo = gem_to_qxl_bo(gobj); int ret; ret = qxl_bo_reserve(qbo, false); if (likely(ret == 0)) { qxl_bo_kunmap(qbo); qxl_bo_unpin(qbo); qxl_bo_unreserve(qbo); } drm_gem_object_unreference_unlocked(gobj); }
int qxl_destroy_monitors_object(struct qxl_device *qdev) { int ret; qdev->monitors_config = NULL; qdev->ram_header->monitors_config = 0; qxl_bo_kunmap(qdev->monitors_config_bo); ret = qxl_bo_reserve(qdev->monitors_config_bo, false); if (ret) return ret; qxl_bo_unpin(qdev->monitors_config_bo); qxl_bo_unreserve(qdev->monitors_config_bo); qxl_bo_unref(&qdev->monitors_config_bo); return 0; }
static int qxlfb_create(struct qxl_fbdev *qfbdev, struct drm_fb_helper_surface_size *sizes) { struct qxl_device *qdev = qfbdev->qdev; struct fb_info *info; struct drm_framebuffer *fb = NULL; struct drm_mode_fb_cmd2 mode_cmd; struct drm_gem_object *gobj = NULL; struct qxl_bo *qbo = NULL; int ret; int size; int bpp = sizes->surface_bpp; int depth = sizes->surface_depth; void *shadow; mode_cmd.width = sizes->surface_width; mode_cmd.height = sizes->surface_height; mode_cmd.pitches[0] = ALIGN(mode_cmd.width * ((bpp + 1) / 8), 64); mode_cmd.pixel_format = drm_mode_legacy_fb_format(bpp, depth); ret = qxlfb_create_pinned_object(qfbdev, &mode_cmd, &gobj); if (ret < 0) return ret; qbo = gem_to_qxl_bo(gobj); QXL_INFO(qdev, "%s: %dx%d %d\n", __func__, mode_cmd.width, mode_cmd.height, mode_cmd.pitches[0]); shadow = vmalloc(mode_cmd.pitches[0] * mode_cmd.height); /* TODO: what's the usual response to memory allocation errors? */ BUG_ON(!shadow); QXL_INFO(qdev, "surface0 at gpu offset %lld, mmap_offset %lld (virt %p, shadow %p)\n", qxl_bo_gpu_offset(qbo), qxl_bo_mmap_offset(qbo), qbo->kptr, shadow); size = mode_cmd.pitches[0] * mode_cmd.height; info = drm_fb_helper_alloc_fbi(&qfbdev->helper); if (IS_ERR(info)) { ret = PTR_ERR(info); goto out_unref; } info->par = qfbdev; qxl_framebuffer_init(qdev->ddev, &qfbdev->qfb, &mode_cmd, gobj, &qxlfb_fb_funcs); fb = &qfbdev->qfb.base; /* setup helper with fb data */ qfbdev->helper.fb = fb; qfbdev->shadow = shadow; strcpy(info->fix.id, "qxldrmfb"); drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth); info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT; info->fbops = &qxlfb_ops; /* * TODO: using gobj->size in various places in this function. Not sure * what the difference between the different sizes is. */ info->fix.smem_start = qdev->vram_base; /* TODO - correct? */ info->fix.smem_len = gobj->size; info->screen_base = qfbdev->shadow; info->screen_size = gobj->size; drm_fb_helper_fill_var(info, &qfbdev->helper, sizes->fb_width, sizes->fb_height); /* setup aperture base/size for vesafb takeover */ info->apertures->ranges[0].base = qdev->ddev->mode_config.fb_base; info->apertures->ranges[0].size = qdev->vram_size; info->fix.mmio_start = 0; info->fix.mmio_len = 0; if (info->screen_base == NULL) { ret = -ENOSPC; goto out_destroy_fbi; } info->fbdefio = &qxl_defio; fb_deferred_io_init(info); qdev->fbdev_info = info; qdev->fbdev_qfb = &qfbdev->qfb; DRM_INFO("fb mappable at 0x%lX, size %lu\n", info->fix.smem_start, (unsigned long)info->screen_size); DRM_INFO("fb: depth %d, pitch %d, width %d, height %d\n", fb->depth, fb->pitches[0], fb->width, fb->height); return 0; out_destroy_fbi: drm_fb_helper_release_fbi(&qfbdev->helper); out_unref: if (qbo) { ret = qxl_bo_reserve(qbo, false); if (likely(ret == 0)) { qxl_bo_kunmap(qbo); qxl_bo_unpin(qbo); qxl_bo_unreserve(qbo); } } if (fb && ret) { drm_gem_object_unreference_unlocked(gobj); drm_framebuffer_cleanup(fb); kfree(fb); } drm_gem_object_unreference_unlocked(gobj); return ret; }
static int qxl_crtc_cursor_set2(struct drm_crtc *crtc, struct drm_file *file_priv, uint32_t handle, uint32_t width, uint32_t height, int32_t hot_x, int32_t hot_y) { struct drm_device *dev = crtc->dev; struct qxl_device *qdev = dev->dev_private; struct qxl_crtc *qcrtc = to_qxl_crtc(crtc); struct drm_gem_object *obj; struct qxl_cursor *cursor; struct qxl_cursor_cmd *cmd; struct qxl_bo *cursor_bo, *user_bo; struct qxl_release *release; void *user_ptr; int size = 64*64*4; int ret = 0; if (!handle) return qxl_hide_cursor(qdev); obj = drm_gem_object_lookup(crtc->dev, file_priv, handle); if (!obj) { DRM_ERROR("cannot find cursor object\n"); return -ENOENT; } user_bo = gem_to_qxl_bo(obj); ret = qxl_bo_reserve(user_bo, false); if (ret) goto out_unref; ret = qxl_bo_pin(user_bo, QXL_GEM_DOMAIN_CPU, NULL); qxl_bo_unreserve(user_bo); if (ret) goto out_unref; ret = qxl_bo_kmap(user_bo, &user_ptr); if (ret) goto out_unpin; ret = qxl_alloc_release_reserved(qdev, sizeof(*cmd), QXL_RELEASE_CURSOR_CMD, &release, NULL); if (ret) goto out_kunmap; ret = qxl_alloc_bo_reserved(qdev, release, sizeof(struct qxl_cursor) + size, &cursor_bo); if (ret) goto out_free_release; ret = qxl_release_reserve_list(release, false); if (ret) goto out_free_bo; ret = qxl_bo_kmap(cursor_bo, (void **)&cursor); if (ret) goto out_backoff; cursor->header.unique = 0; cursor->header.type = SPICE_CURSOR_TYPE_ALPHA; cursor->header.width = 64; cursor->header.height = 64; cursor->header.hot_spot_x = hot_x; cursor->header.hot_spot_y = hot_y; cursor->data_size = size; cursor->chunk.next_chunk = 0; cursor->chunk.prev_chunk = 0; cursor->chunk.data_size = size; memcpy(cursor->chunk.data, user_ptr, size); qxl_bo_kunmap(cursor_bo); qxl_bo_kunmap(user_bo); cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release); cmd->type = QXL_CURSOR_SET; cmd->u.set.position.x = qcrtc->cur_x; cmd->u.set.position.y = qcrtc->cur_y; cmd->u.set.shape = qxl_bo_physical_address(qdev, cursor_bo, 0); cmd->u.set.visible = 1; qxl_release_unmap(qdev, release, &cmd->release_info); qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false); qxl_release_fence_buffer_objects(release); /* finish with the userspace bo */ ret = qxl_bo_reserve(user_bo, false); if (!ret) { qxl_bo_unpin(user_bo); qxl_bo_unreserve(user_bo); } drm_gem_object_unreference_unlocked(obj); qxl_bo_unref(&cursor_bo); return ret; out_backoff: qxl_release_backoff_reserve_list(release); out_free_bo: qxl_bo_unref(&cursor_bo); out_free_release: qxl_release_free(qdev, release); out_kunmap: qxl_bo_kunmap(user_bo); out_unpin: qxl_bo_unpin(user_bo); out_unref: drm_gem_object_unreference_unlocked(obj); return ret; }
void qxl_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr) { struct qxl_bo *bo = gem_to_qxl_bo(obj); qxl_bo_kunmap(bo); }
/* push a draw command using the given clipping rectangles as * the sources from the shadow framebuffer. * * Right now implementing with a single draw and a clip list. Clip * lists are known to be a problem performance wise, this can be solved * by treating them differently in the server. */ void qxl_draw_dirty_fb(struct qxl_device *qdev, struct qxl_framebuffer *qxl_fb, struct qxl_bo *bo, unsigned flags, unsigned color, struct drm_clip_rect *clips, unsigned num_clips, int inc) { /* * TODO: if flags & DRM_MODE_FB_DIRTY_ANNOTATE_FILL then we should * send a fill command instead, much cheaper. * * See include/drm/drm_mode.h */ struct drm_clip_rect *clips_ptr; int i; int left, right, top, bottom; int width, height; struct qxl_drawable *drawable; struct qxl_rect drawable_rect; struct qxl_rect *rects; int stride = qxl_fb->base.pitches[0]; /* depth is not actually interesting, we don't mask with it */ int depth = qxl_fb->base.bits_per_pixel; uint8_t *surface_base; struct qxl_release *release; struct qxl_bo *clips_bo; struct qxl_drm_image *dimage; int ret; ret = alloc_drawable(qdev, &release); if (ret) return; left = clips->x1; right = clips->x2; top = clips->y1; bottom = clips->y2; /* skip the first clip rect */ for (i = 1, clips_ptr = clips + inc; i < num_clips; i++, clips_ptr += inc) { left = min_t(int, left, (int)clips_ptr->x1); right = max_t(int, right, (int)clips_ptr->x2); top = min_t(int, top, (int)clips_ptr->y1); bottom = max_t(int, bottom, (int)clips_ptr->y2); } width = right - left; height = bottom - top; ret = alloc_clips(qdev, release, num_clips, &clips_bo); if (ret) goto out_free_drawable; ret = qxl_image_alloc_objects(qdev, release, &dimage, height, stride); if (ret) goto out_free_clips; /* do a reservation run over all the objects we just allocated */ ret = qxl_release_reserve_list(release, true); if (ret) goto out_free_image; drawable_rect.left = left; drawable_rect.right = right; drawable_rect.top = top; drawable_rect.bottom = bottom; ret = make_drawable(qdev, 0, QXL_DRAW_COPY, &drawable_rect, release); if (ret) goto out_release_backoff; ret = qxl_bo_kmap(bo, (void **)&surface_base); if (ret) goto out_release_backoff; ret = qxl_image_init(qdev, release, dimage, surface_base, left, top, width, height, depth, stride); qxl_bo_kunmap(bo); if (ret) goto out_release_backoff; rects = drawable_set_clipping(qdev, drawable, num_clips, clips_bo); if (!rects) goto out_release_backoff; drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); drawable->clip.type = SPICE_CLIP_TYPE_RECTS; drawable->clip.data = qxl_bo_physical_address(qdev, clips_bo, 0); drawable->u.copy.src_area.top = 0; drawable->u.copy.src_area.bottom = height; drawable->u.copy.src_area.left = 0; drawable->u.copy.src_area.right = width; drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT; drawable->u.copy.scale_mode = 0; drawable->u.copy.mask.flags = 0; drawable->u.copy.mask.pos.x = 0; drawable->u.copy.mask.pos.y = 0; drawable->u.copy.mask.bitmap = 0; drawable->u.copy.src_bitmap = qxl_bo_physical_address(qdev, dimage->bo, 0); qxl_release_unmap(qdev, release, &drawable->release_info); clips_ptr = clips; for (i = 0; i < num_clips; i++, clips_ptr += inc) { rects[i].left = clips_ptr->x1; rects[i].right = clips_ptr->x2; rects[i].top = clips_ptr->y1; rects[i].bottom = clips_ptr->y2; } qxl_bo_kunmap(clips_bo); qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); qxl_release_fence_buffer_objects(release); out_release_backoff: if (ret) qxl_release_backoff_reserve_list(release); out_free_image: qxl_image_free_objects(qdev, dimage); out_free_clips: qxl_bo_unref(&clips_bo); out_free_drawable: /* only free drawable on error */ if (ret) free_drawable(qdev, release); }