Subversion Repositories Kolibri OS

            *dst++ = *image++;

            *dst++ = *image++;

        for( ; j < 64; j++)

        for( ; j < 64; j++)

            *dst++ = 0;

            *dst++ = 0;

    }

    }

    for(i = 0; i < 64*(64-32); i++)

    for(i = 0; i < 64*(64-32); i++)

	cmd->cmd = cpu_to_le32(SVGA_CMD_DEFINE_ALPHA_CURSOR);

	cmd->cmd = cpu_to_le32(SVGA_CMD_DEFINE_ALPHA_CURSOR);

	cmd->cursor.id = cpu_to_le32(0);

	cmd->cursor.id = cpu_to_le32(0);

	cmd->cursor.width = cpu_to_le32(width);

	cmd->cursor.width = cpu_to_le32(width);

	int ret;

	int ret;

	kmap_offset = 0;

	kmap_offset = 0;

	ret = ttm_bo_reserve(&dmabuf->base, true, false, false, 0);

	ret = ttm_bo_reserve(&dmabuf->base, true, false, false, NULL);

	if (unlikely(ret != 0)) {

	if (unlikely(ret != 0)) {

		DRM_ERROR("reserve failed\n");

		DRM_ERROR("reserve failed\n");

	 * cursor_set function, especially vmw_cursor_update_position looks

	 * cursor_set function, especially vmw_cursor_update_position looks

	 * suspicious. For now take the easy route and reacquire all locks. We

	 * suspicious. For now take the easy route and reacquire all locks. We

	 * can do this since the caller in the drm core doesn't check anything

	 * can do this since the caller in the drm core doesn't check anything

	 * which is protected by any looks.

	 * which is protected by any looks.

	 */

	 */

	drm_modeset_lock_all(dev_priv->dev);

	drm_modeset_lock_all(dev_priv->dev);

	/* A lot of the code assumes this */

	/* A lot of the code assumes this */

	if (handle && (width != 64 || height != 64)) {

	if (handle && (width != 64 || height != 64)) {

				   du->cursor_y + du->hotspot_y);

				   du->cursor_y + du->hotspot_y);

	ret = 0;

	ret = 0;

out:

out:

	mutex_lock(&crtc->mutex);

	drm_modeset_lock(&crtc->mutex, NULL);

	return ret;

	return ret;

	 * cursor_set function, especially vmw_cursor_update_position looks

	 * cursor_set function, especially vmw_cursor_update_position looks

	 * suspicious. For now take the easy route and reacquire all locks. We

	 * suspicious. For now take the easy route and reacquire all locks. We

	 * can do this since the caller in the drm core doesn't check anything

	 * can do this since the caller in the drm core doesn't check anything

	 * which is protected by any looks.

	 * which is protected by any looks.

	 */

	 */

	drm_modeset_lock_all(dev_priv->dev);

	drm_modeset_lock_all(dev_priv->dev);

	vmw_cursor_update_position(dev_priv, shown,

	vmw_cursor_update_position(dev_priv, shown,

				   du->cursor_x + du->hotspot_x,

				   du->cursor_x + du->hotspot_x,

				   du->cursor_y + du->hotspot_y);

				   du->cursor_y + du->hotspot_y);

	drm_modeset_unlock_all(dev_priv->dev);

	drm_modeset_unlock_all(dev_priv->dev);

	mutex_lock(&crtc->mutex);

	drm_modeset_lock(&crtc->mutex, NULL);

	}

	}

	kmap_offset = cmd->dma.guest.ptr.offset >> PAGE_SHIFT;

	kmap_offset = cmd->dma.guest.ptr.offset >> PAGE_SHIFT;

	ret = ttm_bo_reserve(bo, true, false, false, 0);

	ret = ttm_bo_reserve(bo, true, false, false, NULL);

	if (unlikely(ret != 0)) {

	if (unlikely(ret != 0)) {

		DRM_ERROR("reserve failed\n");

		DRM_ERROR("reserve failed\n");

	SVGASignedRect *blits;

	SVGASignedRect *blits;

	num_units = 0;

	num_units = 0;

	list_for_each_entry(crtc, &dev_priv->dev->mode_config.crtc_list,

	list_for_each_entry(crtc, &dev_priv->dev->mode_config.crtc_list,

		if (crtc->fb != &framebuffer->base)

		if (crtc->primary->fb != &framebuffer->base)

			continue;

			continue;

		units[num_units++] = vmw_crtc_to_du(crtc);

		units[num_units++] = vmw_crtc_to_du(crtc);

	}

	}

				  unsigned flags, unsigned color,

				  unsigned flags, unsigned color,

				  struct drm_clip_rect *clips,

				  struct drm_clip_rect *clips,

				  unsigned num_clips)

				  unsigned num_clips)

{

{

	struct vmw_private *dev_priv = vmw_priv(framebuffer->dev);

	struct vmw_private *dev_priv = vmw_priv(framebuffer->dev);

	struct vmw_framebuffer_surface *vfbs =

	struct vmw_framebuffer_surface *vfbs =

		vmw_framebuffer_to_vfbs(framebuffer);

		vmw_framebuffer_to_vfbs(framebuffer);

	struct drm_clip_rect norect;

	struct drm_clip_rect norect;

	int ret, inc = 1;

	int ret, inc = 1;

	if (!dev_priv->sou_priv)

	if (!dev_priv->sou_priv)

		return -EINVAL;

		return -EINVAL;

	ret = ttm_read_lock(&vmaster->lock, true);

	ret = ttm_read_lock(&dev_priv->reservation_sem, true);

	if (unlikely(ret != 0)) {

	if (unlikely(ret != 0)) {

		drm_modeset_unlock_all(dev_priv->dev);

		drm_modeset_unlock_all(dev_priv->dev);

	ret = do_surface_dirty_sou(dev_priv, file_priv, &vfbs->base,

	ret = do_surface_dirty_sou(dev_priv, file_priv, &vfbs->base,

				   flags, color,

				   flags, color,

	ttm_read_unlock(&vmaster->lock);

	ttm_read_unlock(&dev_priv->reservation_sem);

		return -ENOMEM;

		return -ENOMEM;

	}

	}

	num_units = 0;

	num_units = 0;

		if (crtc->fb != &framebuffer->base)

		if (crtc->primary->fb != &framebuffer->base)

			continue;

			continue;

		units[num_units++] = vmw_crtc_to_du(crtc);

		units[num_units++] = vmw_crtc_to_du(crtc);

	}

	}

				 unsigned flags, unsigned color,

				 unsigned flags, unsigned color,

				 struct drm_clip_rect *clips,

				 struct drm_clip_rect *clips,

				 unsigned num_clips)

				 unsigned num_clips)

{

{

	struct vmw_private *dev_priv = vmw_priv(framebuffer->dev);

	struct vmw_private *dev_priv = vmw_priv(framebuffer->dev);

	struct vmw_framebuffer_dmabuf *vfbd =

	struct vmw_framebuffer_dmabuf *vfbd =

		vmw_framebuffer_to_vfbd(framebuffer);

		vmw_framebuffer_to_vfbd(framebuffer);

	struct drm_clip_rect norect;

	struct drm_clip_rect norect;

	int ret, increment = 1;

	int ret, increment = 1;

	ret = ttm_read_lock(&vmaster->lock, true);

	ret = ttm_read_lock(&dev_priv->reservation_sem, true);

	if (unlikely(ret != 0)) {

	if (unlikely(ret != 0)) {

		drm_modeset_unlock_all(dev_priv->dev);

		drm_modeset_unlock_all(dev_priv->dev);

		ret = do_dmabuf_dirty_sou(file_priv, dev_priv, &vfbd->base,

		ret = do_dmabuf_dirty_sou(file_priv, dev_priv, &vfbd->base,

					  flags, color,

					  flags, color,

					  clips, num_clips, increment, NULL);

					  clips, num_clips, increment, NULL);

	}

	}

	ttm_read_unlock(&vmaster->lock);

	ttm_read_unlock(&dev_priv->reservation_sem);

	drm_modeset_unlock_all(dev_priv->dev);

	drm_modeset_unlock_all(dev_priv->dev);

	} *cmd;

	} *cmd;

	SVGASignedRect *blits;

	SVGASignedRect *blits;

	num_units = 0;

	num_units = 0;

		if (crtc->fb != &vfb->base)

		if (crtc->primary->fb != &vfb->base)

			continue;

			continue;

		units[num_units++] = vmw_crtc_to_du(crtc);

		units[num_units++] = vmw_crtc_to_du(crtc);

	}

	}

		SVGAFifoCmdBlitScreenToGMRFB body;

		SVGAFifoCmdBlitScreenToGMRFB body;

	} *blits;

	} *blits;

	num_units = 0;

	num_units = 0;

		if (crtc->fb != &vfb->base)

		if (crtc->primary->fb != &vfb->base)

			continue;

			continue;

		units[num_units++] = vmw_crtc_to_du(crtc);

		units[num_units++] = vmw_crtc_to_du(crtc);

	}

	}

int vmw_kms_init(struct vmw_private *dev_priv)

int vmw_kms_init(struct vmw_private *dev_priv)

{

{

	struct drm_device *dev = dev_priv->dev;

	struct drm_device *dev = dev_priv->dev;

	int ret;

	int ret;

	drm_mode_config_init(dev);

	drm_mode_config_init(dev);

	dev->mode_config.funcs = &vmw_kms_funcs;

	dev->mode_config.funcs = &vmw_kms_funcs;

	dev->mode_config.min_width = 1;

	dev->mode_config.min_width = 1;

	dev->mode_config.min_height = 1;

	dev->mode_config.min_height = 1;

	/* assumed largest fb size */

	/* assumed largest fb size */

	dev->mode_config.max_width = 8192;

	dev->mode_config.max_width = 8192;

	dev->mode_config.max_height = 8192;

	dev->mode_config.max_height = 8192;

    LEAVE();

	ret = vmw_kms_init_screen_object_display(dev_priv);

int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,

int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,

				struct drm_file *file_priv)

				struct drm_file *file_priv)

{

{

	struct drm_vmw_cursor_bypass_arg *arg = data;

	struct drm_vmw_cursor_bypass_arg *arg = data;

	struct vmw_display_unit *du;

	struct vmw_display_unit *du;

	struct drm_crtc *crtc;

	struct drm_crtc *crtc;

	int ret = 0;

	int ret = 0;

		mutex_unlock(&dev->mode_config.mutex);

		mutex_unlock(&dev->mode_config.mutex);

		return 0;

		return 0;

	obj = drm_mode_object_find(dev, arg->crtc_id, DRM_MODE_OBJECT_CRTC);

	crtc = drm_crtc_find(dev, arg->crtc_id);

	if (!obj) {

	if (!crtc) {

		ret = -ENOENT;

		ret = -ENOENT;

	}

		goto out;

	}

	crtc = obj_to_crtc(obj);

		     struct drm_framebuffer *fb,

		     struct drm_framebuffer *fb,

		     struct drm_pending_vblank_event *event,

		     struct drm_pending_vblank_event *event,

		     uint32_t page_flip_flags)

		     uint32_t page_flip_flags)

{

{

	struct vmw_private *dev_priv = vmw_priv(crtc->dev);

	struct vmw_private *dev_priv = vmw_priv(crtc->dev);

	struct vmw_framebuffer *vfb = vmw_framebuffer_to_vfb(fb);

	struct vmw_framebuffer *vfb = vmw_framebuffer_to_vfb(fb);

	struct drm_file *file_priv ;

	struct drm_file *file_priv ;

	struct vmw_fence_obj *fence = NULL;

	struct vmw_fence_obj *fence = NULL;

	struct drm_clip_rect clips;

	struct drm_clip_rect clips;

	int ret;

	int ret;

	file_priv = event->base.file_priv;

	file_priv = event->base.file_priv;

	if (!vmw_kms_screen_object_flippable(dev_priv, crtc))

	if (!vmw_kms_screen_object_flippable(dev_priv, crtc))

	crtc->fb = fb;

	crtc->primary->fb = fb;

	/* do a full screen dirty update */

	/* do a full screen dirty update */

		vmw_kms_screen_object_update_implicit_fb(dev_priv, crtc);

		vmw_kms_screen_object_update_implicit_fb(dev_priv, crtc);

	return ret;

	return ret;

out_no_fence:

out_no_fence:

	crtc->fb = old_fb;

	crtc->primary->fb = old_fb;

	return ret;

	return ret;

}

}

	/* Move the prefered mode first, help apps pick the right mode. */

	/* Move the prefered mode first, help apps pick the right mode. */

	if (du->pref_mode)

	if (du->pref_mode)

	drm_mode_connector_list_update(connector);

	drm_mode_connector_list_update(connector, true);

				struct drm_file *file_priv)

				struct drm_file *file_priv)

{

{

	struct vmw_private *dev_priv = vmw_priv(dev);

	struct vmw_private *dev_priv = vmw_priv(dev);

	struct drm_vmw_update_layout_arg *arg =

	struct drm_vmw_update_layout_arg *arg =

		(struct drm_vmw_update_layout_arg *)data;

		(struct drm_vmw_update_layout_arg *)data;

	void __user *user_rects;

	void __user *user_rects;

	struct drm_vmw_rect *rects;

	struct drm_vmw_rect *rects;

	unsigned rects_size;

	unsigned rects_size;

	int ret;

	int ret;

	int i;

	int i;

	struct drm_mode_config *mode_config = &dev->mode_config;

	struct drm_mode_config *mode_config = &dev->mode_config;

	ret = ttm_read_lock(&vmaster->lock, true);

	ret = ttm_read_lock(&dev_priv->reservation_sem, true);

	if (unlikely(ret != 0))

	if (unlikely(ret != 0))

		return ret;

		return ret;

	vmw_du_update_layout(dev_priv, arg->num_outputs, rects);

	vmw_du_update_layout(dev_priv, arg->num_outputs, rects);

out_free:

out_free:

	kfree(rects);

	kfree(rects);

	ttm_read_unlock(&vmaster->lock);

	ttm_read_unlock(&dev_priv->reservation_sem);

	return ret;

	return ret;

}

}