[linux-2.6-block.git] / drivers / gpu / drm / vmwgfx / vmwgfx_dmabuf.c

/**************************************************************************
 *
 * Copyright © 2011 VMware, Inc., Palo Alto, CA., USA
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 **************************************************************************/

#include <drm/ttm/ttm_placement.h>

#include <drm/drmP.h>
#include "vmwgfx_drv.h"


/**
 * vmw_dmabuf_to_placement - Validate a buffer to placement.
 *
 * @dev_priv:  Driver private.
 * @buf:  DMA buffer to move.
 * @pin:  Pin buffer if true.
 * @interruptible:  Use interruptible wait.
 *
 * May only be called by the current master since it assumes that the
 * master lock is the current master's lock.
 * This function takes the master's lock in write mode.
 * Flushes and unpins the query bo to avoid failures.
 *
 * Returns
 *  -ERESTARTSYS if interrupted by a signal.
 */
int vmw_dmabuf_to_placement(struct vmw_private *dev_priv,
			    struct vmw_dma_buffer *buf,
			    struct ttm_placement *placement,
			    bool interruptible)
{
	struct vmw_master *vmaster = dev_priv->active_master;
	struct ttm_buffer_object *bo = &buf->base;
	int ret;

	ret = ttm_write_lock(&vmaster->lock, interruptible);
	if (unlikely(ret != 0))
		return ret;

	vmw_execbuf_release_pinned_bo(dev_priv, false, 0);

	ret = ttm_bo_reserve(bo, interruptible, false, false, 0);
	if (unlikely(ret != 0))
		goto err;

	ret = ttm_bo_validate(bo, placement, interruptible, false, false);

	ttm_bo_unreserve(bo);

err:
	ttm_write_unlock(&vmaster->lock);
	return ret;
}

/**
 * vmw_dmabuf_to_vram_or_gmr - Move a buffer to vram or gmr.
 *
 * May only be called by the current master since it assumes that the
 * master lock is the current master's lock.
 * This function takes the master's lock in write mode.
 * Flushes and unpins the query bo if @pin == true to avoid failures.
 *
 * @dev_priv:  Driver private.
 * @buf:  DMA buffer to move.
 * @pin:  Pin buffer if true.
 * @interruptible:  Use interruptible wait.
 *
 * Returns
 * -ERESTARTSYS if interrupted by a signal.
 */
int vmw_dmabuf_to_vram_or_gmr(struct vmw_private *dev_priv,
			      struct vmw_dma_buffer *buf,
			      bool pin, bool interruptible)
{
	struct vmw_master *vmaster = dev_priv->active_master;
	struct ttm_buffer_object *bo = &buf->base;
	struct ttm_placement *placement;
	int ret;

	ret = ttm_write_lock(&vmaster->lock, interruptible);
	if (unlikely(ret != 0))
		return ret;

	if (pin)
		vmw_execbuf_release_pinned_bo(dev_priv, false, 0);

	ret = ttm_bo_reserve(bo, interruptible, false, false, 0);
	if (unlikely(ret != 0))
		goto err;

	/**
	 * Put BO in VRAM if there is space, otherwise as a GMR.
	 * If there is no space in VRAM and GMR ids are all used up,
	 * start evicting GMRs to make room. If the DMA buffer can't be
	 * used as a GMR, this will return -ENOMEM.
	 */

	if (pin)
		placement = &vmw_vram_gmr_ne_placement;
	else
		placement = &vmw_vram_gmr_placement;

	ret = ttm_bo_validate(bo, placement, interruptible, false, false);
	if (likely(ret == 0) || ret == -ERESTARTSYS)
		goto err_unreserve;


	/**
	 * If that failed, try VRAM again, this time evicting
	 * previous contents.
	 */

	if (pin)
		placement = &vmw_vram_ne_placement;
	else
		placement = &vmw_vram_placement;

	ret = ttm_bo_validate(bo, placement, interruptible, false, false);

err_unreserve:
	ttm_bo_unreserve(bo);
err:
	ttm_write_unlock(&vmaster->lock);
	return ret;
}

/**
 * vmw_dmabuf_to_vram - Move a buffer to vram.
 *
 * May only be called by the current master since it assumes that the
 * master lock is the current master's lock.
 * This function takes the master's lock in write mode.
 *
 * @dev_priv:  Driver private.
 * @buf:  DMA buffer to move.
 * @pin:  Pin buffer in vram if true.
 * @interruptible:  Use interruptible wait.
 *
 * Returns
 * -ERESTARTSYS if interrupted by a signal.
 */
int vmw_dmabuf_to_vram(struct vmw_private *dev_priv,
		       struct vmw_dma_buffer *buf,
		       bool pin, bool interruptible)
{
	struct ttm_placement *placement;

	if (pin)
		placement = &vmw_vram_ne_placement;
	else
		placement = &vmw_vram_placement;

	return vmw_dmabuf_to_placement(dev_priv, buf,
				       placement,
				       interruptible);
}

/**
 * vmw_dmabuf_to_start_of_vram - Move a buffer to start of vram.
 *
 * May only be called by the current master since it assumes that the
 * master lock is the current master's lock.
 * This function takes the master's lock in write mode.
 * Flushes and unpins the query bo if @pin == true to avoid failures.
 *
 * @dev_priv:  Driver private.
 * @buf:  DMA buffer to move.
 * @pin:  Pin buffer in vram if true.
 * @interruptible:  Use interruptible wait.
 *
 * Returns
 * -ERESTARTSYS if interrupted by a signal.
 */
int vmw_dmabuf_to_start_of_vram(struct vmw_private *dev_priv,
				struct vmw_dma_buffer *buf,
				bool pin, bool interruptible)
{
	struct vmw_master *vmaster = dev_priv->active_master;
	struct ttm_buffer_object *bo = &buf->base;
	struct ttm_placement placement;
	int ret = 0;

	if (pin)
		placement = vmw_vram_ne_placement;
	else
		placement = vmw_vram_placement;
	placement.lpfn = bo->num_pages;

	ret = ttm_write_lock(&vmaster->lock, interruptible);
	if (unlikely(ret != 0))
		return ret;

	if (pin)
		vmw_execbuf_release_pinned_bo(dev_priv, false, 0);

	ret = ttm_bo_reserve(bo, interruptible, false, false, 0);
	if (unlikely(ret != 0))
		goto err_unlock;

	/* Is this buffer already in vram but not at the start of it? */
	if (bo->mem.mem_type == TTM_PL_VRAM &&
	    bo->mem.start < bo->num_pages &&
	    bo->mem.start > 0)
		(void) ttm_bo_validate(bo, &vmw_sys_placement, false,
				       false, false);

	ret = ttm_bo_validate(bo, &placement, interruptible, false, false);

	/* For some reason we didn't up at the start of vram */
	WARN_ON(ret == 0 && bo->offset != 0);

	ttm_bo_unreserve(bo);
err_unlock:
	ttm_write_unlock(&vmaster->lock);

	return ret;
}


/**
 * vmw_dmabuf_upin - Unpin the buffer given buffer, does not move the buffer.
 *
 * May only be called by the current master since it assumes that the
 * master lock is the current master's lock.
 * This function takes the master's lock in write mode.
 *
 * @dev_priv:  Driver private.
 * @buf:  DMA buffer to unpin.
 * @interruptible:  Use interruptible wait.
 *
 * Returns
 * -ERESTARTSYS if interrupted by a signal.
 */
int vmw_dmabuf_unpin(struct vmw_private *dev_priv,
		     struct vmw_dma_buffer *buf,
		     bool interruptible)
{
	/*
	 * We could in theory early out if the buffer is
	 * unpinned but we need to lock and reserve the buffer
	 * anyways so we don't gain much by that.
	 */
	return vmw_dmabuf_to_placement(dev_priv, buf,
				       &vmw_evictable_placement,
				       interruptible);
}


/**
 * vmw_bo_get_guest_ptr - Get the guest ptr representing the current placement
 * of a buffer.
 *
 * @bo: Pointer to a struct ttm_buffer_object. Must be pinned or reserved.
 * @ptr: SVGAGuestPtr returning the result.
 */
void vmw_bo_get_guest_ptr(const struct ttm_buffer_object *bo,
			  SVGAGuestPtr *ptr)
{
	if (bo->mem.mem_type == TTM_PL_VRAM) {
		ptr->gmrId = SVGA_GMR_FRAMEBUFFER;
		ptr->offset = bo->offset;
	} else {
		ptr->gmrId = bo->mem.start;
		ptr->offset = 0;
	}
}


/**
 * vmw_bo_pin - Pin or unpin a buffer object without moving it.
 *
 * @bo: The buffer object. Must be reserved, and present either in VRAM
 * or GMR memory.
 * @pin: Whether to pin or unpin.
 *
 */
void vmw_bo_pin(struct ttm_buffer_object *bo, bool pin)
{
	uint32_t pl_flags;
	struct ttm_placement placement;
	uint32_t old_mem_type = bo->mem.mem_type;
	int ret;

	BUG_ON(!atomic_read(&bo->reserved));
	BUG_ON(old_mem_type != TTM_PL_VRAM &&
	       old_mem_type != VMW_PL_FLAG_GMR);

	pl_flags = TTM_PL_FLAG_VRAM | VMW_PL_FLAG_GMR | TTM_PL_FLAG_CACHED;
	if (pin)
		pl_flags |= TTM_PL_FLAG_NO_EVICT;

	memset(&placement, 0, sizeof(placement));
	placement.num_placement = 1;
	placement.placement = &pl_flags;

	ret = ttm_bo_validate(bo, &placement, false, true, true);

	BUG_ON(ret != 0 || bo->mem.mem_type != old_mem_type);
}
Commit	Line	Data
d991ef03 JB	1	/**************************************************************************
	2	*
	3	* Copyright © 2011 VMware, Inc., Palo Alto, CA., USA
	4	* All Rights Reserved.
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a
	7	* copy of this software and associated documentation files (the
	8	* "Software"), to deal in the Software without restriction, including
	9	* without limitation the rights to use, copy, modify, merge, publish,
	10	* distribute, sub license, and/or sell copies of the Software, and to
	11	* permit persons to whom the Software is furnished to do so, subject to
	12	* the following conditions:
	13	*
	14	* The above copyright notice and this permission notice (including the
	15	* next paragraph) shall be included in all copies or substantial portions
	16	* of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
	21	* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
	22	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	23	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
	24	* USE OR OTHER DEALINGS IN THE SOFTWARE.
	25	*
	26	**************************************************************************/
	27
760285e7	28	#include <drm/ttm/ttm_placement.h>
d991ef03	29
760285e7	30	#include <drm/drmP.h>
d991ef03 JB	31	#include "vmwgfx_drv.h"
	32
	33
	34	/**
b37a6b9a	35	* vmw_dmabuf_to_placement - Validate a buffer to placement.
d991ef03	36	*
b37a6b9a TH	37	* @dev_priv: Driver private.
	38	* @buf: DMA buffer to move.
	39	* @pin: Pin buffer if true.
	40	* @interruptible: Use interruptible wait.
	41	*
	42	* May only be called by the current master since it assumes that the
	43	* master lock is the current master's lock.
	44	* This function takes the master's lock in write mode.
e2fa3a76	45	* Flushes and unpins the query bo to avoid failures.
d991ef03 JB	46	*
	47	* Returns
	48	* -ERESTARTSYS if interrupted by a signal.
	49	*/
	50	int vmw_dmabuf_to_placement(struct vmw_private *dev_priv,
	51	struct vmw_dma_buffer *buf,
	52	struct ttm_placement *placement,
	53	bool interruptible)
	54	{
	55	struct vmw_master *vmaster = dev_priv->active_master;
	56	struct ttm_buffer_object *bo = &buf->base;
	57	int ret;
	58
	59	ret = ttm_write_lock(&vmaster->lock, interruptible);
	60	if (unlikely(ret != 0))
	61	return ret;
	62
e2fa3a76 TH	63	vmw_execbuf_release_pinned_bo(dev_priv, false, 0);
e2fa3a76 TH	64
d991ef03 JB	65	ret = ttm_bo_reserve(bo, interruptible, false, false, 0);
	66	if (unlikely(ret != 0))
	67	goto err;
	68
	69	ret = ttm_bo_validate(bo, placement, interruptible, false, false);
	70
	71	ttm_bo_unreserve(bo);
	72
	73	err:
	74	ttm_write_unlock(&vmaster->lock);
	75	return ret;
	76	}
	77
	78	/**
b37a6b9a	79	* vmw_dmabuf_to_vram_or_gmr - Move a buffer to vram or gmr.
d991ef03	80	*
b37a6b9a TH	81	* May only be called by the current master since it assumes that the
	82	* master lock is the current master's lock.
	83	* This function takes the master's lock in write mode.
e2fa3a76	84	* Flushes and unpins the query bo if @pin == true to avoid failures.
d991ef03 JB	85	*
	86	* @dev_priv: Driver private.
	87	* @buf: DMA buffer to move.
	88	* @pin: Pin buffer if true.
	89	* @interruptible: Use interruptible wait.
	90	*
	91	* Returns
	92	* -ERESTARTSYS if interrupted by a signal.
	93	*/
	94	int vmw_dmabuf_to_vram_or_gmr(struct vmw_private *dev_priv,
	95	struct vmw_dma_buffer *buf,
	96	bool pin, bool interruptible)
	97	{
	98	struct vmw_master *vmaster = dev_priv->active_master;
	99	struct ttm_buffer_object *bo = &buf->base;
	100	struct ttm_placement *placement;
	101	int ret;
	102
	103	ret = ttm_write_lock(&vmaster->lock, interruptible);
	104	if (unlikely(ret != 0))
	105	return ret;
	106
e2fa3a76 TH	107	if (pin)
	108	vmw_execbuf_release_pinned_bo(dev_priv, false, 0);
	109
d991ef03 JB	110	ret = ttm_bo_reserve(bo, interruptible, false, false, 0);
	111	if (unlikely(ret != 0))
	112	goto err;
	113
	114	/**
	115	* Put BO in VRAM if there is space, otherwise as a GMR.
	116	* If there is no space in VRAM and GMR ids are all used up,
	117	* start evicting GMRs to make room. If the DMA buffer can't be
	118	* used as a GMR, this will return -ENOMEM.
	119	*/
	120
	121	if (pin)
	122	placement = &vmw_vram_gmr_ne_placement;
	123	else
	124	placement = &vmw_vram_gmr_placement;
	125
	126	ret = ttm_bo_validate(bo, placement, interruptible, false, false);
	127	if (likely(ret == 0) \|\| ret == -ERESTARTSYS)
	128	goto err_unreserve;
	129
	130
	131	/**
	132	* If that failed, try VRAM again, this time evicting
	133	* previous contents.
	134	*/
	135
	136	if (pin)
	137	placement = &vmw_vram_ne_placement;
	138	else
	139	placement = &vmw_vram_placement;
	140
	141	ret = ttm_bo_validate(bo, placement, interruptible, false, false);
	142
	143	err_unreserve:
	144	ttm_bo_unreserve(bo);
	145	err:
	146	ttm_write_unlock(&vmaster->lock);
	147	return ret;
	148	}
	149
	150	/**
b37a6b9a	151	* vmw_dmabuf_to_vram - Move a buffer to vram.
d991ef03	152	*
b37a6b9a TH	153	* May only be called by the current master since it assumes that the
	154	* master lock is the current master's lock.
	155	* This function takes the master's lock in write mode.
d991ef03 JB	156	*
	157	* @dev_priv: Driver private.
	158	* @buf: DMA buffer to move.
	159	* @pin: Pin buffer in vram if true.
	160	* @interruptible: Use interruptible wait.
	161	*
	162	* Returns
	163	* -ERESTARTSYS if interrupted by a signal.
	164	*/
	165	int vmw_dmabuf_to_vram(struct vmw_private *dev_priv,
	166	struct vmw_dma_buffer *buf,
	167	bool pin, bool interruptible)
	168	{
	169	struct ttm_placement *placement;
	170
	171	if (pin)
	172	placement = &vmw_vram_ne_placement;
	173	else
	174	placement = &vmw_vram_placement;
	175
	176	return vmw_dmabuf_to_placement(dev_priv, buf,
	177	placement,
	178	interruptible);
	179	}
	180
	181	/**
b37a6b9a	182	* vmw_dmabuf_to_start_of_vram - Move a buffer to start of vram.
d991ef03	183	*
b37a6b9a TH	184	* May only be called by the current master since it assumes that the
	185	* master lock is the current master's lock.
	186	* This function takes the master's lock in write mode.
e2fa3a76	187	* Flushes and unpins the query bo if @pin == true to avoid failures.
d991ef03 JB	188	*
	189	* @dev_priv: Driver private.
	190	* @buf: DMA buffer to move.
	191	* @pin: Pin buffer in vram if true.
	192	* @interruptible: Use interruptible wait.
	193	*
	194	* Returns
	195	* -ERESTARTSYS if interrupted by a signal.
	196	*/
	197	int vmw_dmabuf_to_start_of_vram(struct vmw_private *dev_priv,
	198	struct vmw_dma_buffer *buf,
	199	bool pin, bool interruptible)
	200	{
	201	struct vmw_master *vmaster = dev_priv->active_master;
	202	struct ttm_buffer_object *bo = &buf->base;
	203	struct ttm_placement placement;
	204	int ret = 0;
	205
	206	if (pin)
	207	placement = vmw_vram_ne_placement;
	208	else
	209	placement = vmw_vram_placement;
	210	placement.lpfn = bo->num_pages;
	211
	212	ret = ttm_write_lock(&vmaster->lock, interruptible);
	213	if (unlikely(ret != 0))
	214	return ret;
	215
e2fa3a76 TH	216	if (pin)
	217	vmw_execbuf_release_pinned_bo(dev_priv, false, 0);
	218
d991ef03 JB	219	ret = ttm_bo_reserve(bo, interruptible, false, false, 0);
	220	if (unlikely(ret != 0))
	221	goto err_unlock;
	222
	223	/* Is this buffer already in vram but not at the start of it? */
	224	if (bo->mem.mem_type == TTM_PL_VRAM &&
	225	bo->mem.start < bo->num_pages &&
	226	bo->mem.start > 0)
	227	(void) ttm_bo_validate(bo, &vmw_sys_placement, false,
	228	false, false);
	229
	230	ret = ttm_bo_validate(bo, &placement, interruptible, false, false);
	231
	232	/* For some reason we didn't up at the start of vram */
	233	WARN_ON(ret == 0 && bo->offset != 0);
	234
	235	ttm_bo_unreserve(bo);
	236	err_unlock:
	237	ttm_write_unlock(&vmaster->lock);
	238
	239	return ret;
	240	}
	241
b37a6b9a	242
d991ef03	243	/**
b37a6b9a	244	* vmw_dmabuf_upin - Unpin the buffer given buffer, does not move the buffer.
d991ef03	245	*
b37a6b9a TH	246	* May only be called by the current master since it assumes that the
	247	* master lock is the current master's lock.
	248	* This function takes the master's lock in write mode.
d991ef03 JB	249	*
	250	* @dev_priv: Driver private.
	251	* @buf: DMA buffer to unpin.
	252	* @interruptible: Use interruptible wait.
	253	*
	254	* Returns
	255	* -ERESTARTSYS if interrupted by a signal.
	256	*/
	257	int vmw_dmabuf_unpin(struct vmw_private *dev_priv,
	258	struct vmw_dma_buffer *buf,
	259	bool interruptible)
	260	{
	261	/*
	262	* We could in theory early out if the buffer is
	263	* unpinned but we need to lock and reserve the buffer
	264	* anyways so we don't gain much by that.
	265	*/
	266	return vmw_dmabuf_to_placement(dev_priv, buf,
	267	&vmw_evictable_placement,
	268	interruptible);
	269	}
	270
b37a6b9a	271
d991ef03	272	/**
b37a6b9a TH	273	* vmw_bo_get_guest_ptr - Get the guest ptr representing the current placement
b37a6b9a TH	274	* of a buffer.
d991ef03	275	*
b37a6b9a TH	276	* @bo: Pointer to a struct ttm_buffer_object. Must be pinned or reserved.
b37a6b9a TH	277	* @ptr: SVGAGuestPtr returning the result.
d991ef03	278	*/
b37a6b9a TH	279	void vmw_bo_get_guest_ptr(const struct ttm_buffer_object *bo,
b37a6b9a TH	280	SVGAGuestPtr *ptr)
d991ef03	281	{
b37a6b9a	282	if (bo->mem.mem_type == TTM_PL_VRAM) {
d991ef03	283	ptr->gmrId = SVGA_GMR_FRAMEBUFFER;
b37a6b9a	284	ptr->offset = bo->offset;
d991ef03	285	} else {
b37a6b9a	286	ptr->gmrId = bo->mem.start;
d991ef03 JB	287	ptr->offset = 0;
	288	}
	289	}
e2fa3a76 TH	290
	291
	292	/**
	293	* vmw_bo_pin - Pin or unpin a buffer object without moving it.
	294	*
	295	* @bo: The buffer object. Must be reserved, and present either in VRAM
	296	* or GMR memory.
	297	* @pin: Whether to pin or unpin.
	298	*
	299	*/
	300	void vmw_bo_pin(struct ttm_buffer_object *bo, bool pin)
	301	{
	302	uint32_t pl_flags;
	303	struct ttm_placement placement;
	304	uint32_t old_mem_type = bo->mem.mem_type;
	305	int ret;
	306
	307	BUG_ON(!atomic_read(&bo->reserved));
	308	BUG_ON(old_mem_type != TTM_PL_VRAM &&
	309	old_mem_type != VMW_PL_FLAG_GMR);
	310
	311	pl_flags = TTM_PL_FLAG_VRAM \| VMW_PL_FLAG_GMR \| TTM_PL_FLAG_CACHED;
	312	if (pin)
	313	pl_flags \|= TTM_PL_FLAG_NO_EVICT;
	314
	315	memset(&placement, 0, sizeof(placement));
	316	placement.num_placement = 1;
	317	placement.placement = &pl_flags;
	318
	319	ret = ttm_bo_validate(bo, &placement, false, true, true);
	320
	321	BUG_ON(ret != 0 \|\| bo->mem.mem_type != old_mem_type);
	322	}