drm/vmwgfx: Use preprocessor macro for FIFO allocation

Whenever FIFO allocation fails an error message is printed to dmesg.
Since this is common operation a lot of similar messages are scattered
everywhere. Use preprocessor macro to remove this cluttering.

Signed-off-by: Deepak Rawat <drawat@vmware.com>
Reviewed-by: Thomas Hellstrom <thellstrom@vmware.com>

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_binding.c b/drivers/gpu/drm/vmwgfx/vmwgfx_binding.c
index ef1469c4e91fb00dd6cddba719ebdd1198be954e..66e14e38d5e87980408f39219addb190e5637baf 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_binding.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_binding.c
@@ -499,12 +499,9 @@ static int vmw_binding_scrub_shader(struct vmw_ctx_bindinfo *bi, bool rebind)
                SVGA3dCmdSetShader body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for shader "
-                         "unbinding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_SET_SHADER;
        cmd->header.size = sizeof(cmd->body);
@@ -534,12 +531,9 @@ static int vmw_binding_scrub_render_target(struct vmw_ctx_bindinfo *bi,
                SVGA3dCmdSetRenderTarget body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for render target "
-                         "unbinding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_SETRENDERTARGET;
        cmd->header.size = sizeof(cmd->body);
@@ -576,12 +570,9 @@ static int vmw_binding_scrub_texture(struct vmw_ctx_bindinfo *bi,
                } body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for texture "
-                         "unbinding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_SETTEXTURESTATE;
        cmd->header.size = sizeof(cmd->body);
@@ -610,12 +601,10 @@ static int vmw_binding_scrub_dx_shader(struct vmw_ctx_bindinfo *bi, bool rebind)
                SVGA3dCmdDXSetShader body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), bi->ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for DX shader "
-                         "unbinding.\n");
+       cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), bi->ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
+
        cmd->header.id = SVGA_3D_CMD_DX_SET_SHADER;
        cmd->header.size = sizeof(cmd->body);
        cmd->body.type = binding->shader_slot + SVGA3D_SHADERTYPE_MIN;
@@ -641,12 +630,9 @@ static int vmw_binding_scrub_cb(struct vmw_ctx_bindinfo *bi, bool rebind)
                SVGA3dCmdDXSetSingleConstantBuffer body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), bi->ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for DX shader "
-                         "unbinding.\n");
+       cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), bi->ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_SET_SINGLE_CONSTANT_BUFFER;
        cmd->header.size = sizeof(cmd->body);
@@ -768,12 +754,9 @@ static int vmw_emit_set_sr(struct vmw_ctx_binding_state *cbs,
 
        view_id_size = cbs->bind_cmd_count*sizeof(uint32);
        cmd_size = sizeof(*cmd) + view_id_size;
-       cmd = vmw_fifo_reserve_dx(ctx->dev_priv, cmd_size, ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for DX shader"
-                         " resource binding.\n");
+       cmd = VMW_FIFO_RESERVE_DX(ctx->dev_priv, cmd_size, ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_SET_SHADER_RESOURCES;
        cmd->header.size = sizeof(cmd->body) + view_id_size;
@@ -807,12 +790,9 @@ static int vmw_emit_set_rt(struct vmw_ctx_binding_state *cbs)
        vmw_collect_view_ids(cbs, loc, SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS);
        view_id_size = cbs->bind_cmd_count*sizeof(uint32);
        cmd_size = sizeof(*cmd) + view_id_size;
-       cmd = vmw_fifo_reserve_dx(ctx->dev_priv, cmd_size, ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for DX render-target"
-                         " binding.\n");
+       cmd = VMW_FIFO_RESERVE_DX(ctx->dev_priv, cmd_size, ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_SET_RENDERTARGETS;
        cmd->header.size = sizeof(cmd->body) + view_id_size;
@@ -894,12 +874,9 @@ static int vmw_emit_set_so(struct vmw_ctx_binding_state *cbs)
 
        so_target_size = cbs->bind_cmd_count*sizeof(SVGA3dSoTarget);
        cmd_size = sizeof(*cmd) + so_target_size;
-       cmd = vmw_fifo_reserve_dx(ctx->dev_priv, cmd_size, ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for DX SO target"
-                         " binding.\n");
+       cmd = VMW_FIFO_RESERVE_DX(ctx->dev_priv, cmd_size, ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_SET_SOTARGETS;
        cmd->header.size = sizeof(cmd->body) + so_target_size;
@@ -1011,12 +988,9 @@ static int vmw_emit_set_vb(struct vmw_ctx_binding_state *cbs)
 
        set_vb_size = cbs->bind_cmd_count*sizeof(SVGA3dVertexBuffer);
        cmd_size = sizeof(*cmd) + set_vb_size;
-       cmd = vmw_fifo_reserve_dx(ctx->dev_priv, cmd_size, ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for DX vertex buffer"
-                         " binding.\n");
+       cmd = VMW_FIFO_RESERVE_DX(ctx->dev_priv, cmd_size, ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_SET_VERTEX_BUFFERS;
        cmd->header.size = sizeof(cmd->body) + set_vb_size;
@@ -1167,12 +1141,10 @@ static int vmw_binding_scrub_ib(struct vmw_ctx_bindinfo *bi, bool rebind)
                SVGA3dCmdDXSetIndexBuffer body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), bi->ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for DX index buffer "
-                         "binding.\n");
+       cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), bi->ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
+
        cmd->header.id = SVGA_3D_CMD_DX_SET_INDEX_BUFFER;
        cmd->header.size = sizeof(cmd->body);
        if (rebind) {

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_context.c b/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
index 39e96bb86329810f9cf7683ba943c4874b07eb89..63f111068a4409d2657047868017455bb06eaec5 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
@@ -156,12 +156,9 @@ static void vmw_hw_context_destroy(struct vmw_resource *res)
        }
 
        vmw_execbuf_release_pinned_bo(dev_priv);
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for surface "
-                         "destruction.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return;
-       }
 
        cmd->header.id = SVGA_3D_CMD_CONTEXT_DESTROY;
        cmd->header.size = sizeof(cmd->body);
@@ -259,9 +256,8 @@ static int vmw_context_init(struct vmw_private *dev_priv,
                return -ENOMEM;
        }
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
        if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Fifo reserve failed.\n");
                vmw_resource_unreference(&res);
                return -ENOMEM;
        }
@@ -311,10 +307,8 @@ static int vmw_gb_context_create(struct vmw_resource *res)
                goto out_no_fifo;
        }
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
        if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for context "
-                         "creation.\n");
                ret = -ENOMEM;
                goto out_no_fifo;
        }
@@ -345,12 +339,10 @@ static int vmw_gb_context_bind(struct vmw_resource *res,
 
        BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for context "
-                         "binding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
+
        cmd->header.id = SVGA_3D_CMD_BIND_GB_CONTEXT;
        cmd->header.size = sizeof(cmd->body);
        cmd->body.cid = res->id;
@@ -391,10 +383,8 @@ static int vmw_gb_context_unbind(struct vmw_resource *res,
 
        submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0);
 
-       cmd = vmw_fifo_reserve(dev_priv, submit_size);
+       cmd = VMW_FIFO_RESERVE(dev_priv, submit_size);
        if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for context "
-                         "unbinding.\n");
                mutex_unlock(&dev_priv->binding_mutex);
                return -ENOMEM;
        }
@@ -441,12 +431,9 @@ static int vmw_gb_context_destroy(struct vmw_resource *res)
        if (likely(res->id == -1))
                return 0;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for context "
-                         "destruction.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DESTROY_GB_CONTEXT;
        cmd->header.size = sizeof(cmd->body);
@@ -487,10 +474,8 @@ static int vmw_dx_context_create(struct vmw_resource *res)
                goto out_no_fifo;
        }
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
        if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for context "
-                         "creation.\n");
                ret = -ENOMEM;
                goto out_no_fifo;
        }
@@ -521,12 +506,9 @@ static int vmw_dx_context_bind(struct vmw_resource *res,
 
        BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for context "
-                         "binding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_BIND_CONTEXT;
        cmd->header.size = sizeof(cmd->body);
@@ -615,10 +597,8 @@ static int vmw_dx_context_unbind(struct vmw_resource *res,
 
        submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0);
 
-       cmd = vmw_fifo_reserve(dev_priv, submit_size);
+       cmd = VMW_FIFO_RESERVE(dev_priv, submit_size);
        if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for context "
-                         "unbinding.\n");
                mutex_unlock(&dev_priv->binding_mutex);
                return -ENOMEM;
        }
@@ -665,12 +645,9 @@ static int vmw_dx_context_destroy(struct vmw_resource *res)
        if (likely(res->id == -1))
                return 0;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for context "
-                         "destruction.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_DESTROY_CONTEXT;
        cmd->header.size = sizeof(cmd->body);

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_cotable.c b/drivers/gpu/drm/vmwgfx/vmwgfx_cotable.c
index 44f3f6f107d3c632caeac9e94a7b2f0035b22a97..b4f6e1217c9d309b250d0fefcec57871826ef242 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_cotable.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_cotable.c
@@ -171,12 +171,9 @@ static int vmw_cotable_unscrub(struct vmw_resource *res)
        WARN_ON_ONCE(bo->mem.mem_type != VMW_PL_MOB);
        lockdep_assert_held(&bo->resv->lock.base);
 
-       cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), SVGA3D_INVALID_ID);
-       if (!cmd) {
-               DRM_ERROR("Failed reserving FIFO space for cotable "
-                         "binding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (!cmd)
                return -ENOMEM;
-       }
 
        WARN_ON(vcotbl->ctx->id == SVGA3D_INVALID_ID);
        WARN_ON(bo->mem.mem_type != VMW_PL_MOB);
@@ -262,12 +259,9 @@ int vmw_cotable_scrub(struct vmw_resource *res, bool readback)
        if (readback)
                submit_size += sizeof(*cmd0);
 
-       cmd1 = vmw_fifo_reserve_dx(dev_priv, submit_size, SVGA3D_INVALID_ID);
-       if (!cmd1) {
-               DRM_ERROR("Failed reserving FIFO space for cotable "
-                         "unbinding.\n");
+       cmd1 = VMW_FIFO_RESERVE(dev_priv, submit_size);
+       if (!cmd1)
                return -ENOMEM;
-       }
 
        vcotbl->size_read_back = 0;
        if (readback) {
@@ -351,13 +345,10 @@ static int vmw_cotable_readback(struct vmw_resource *res)
        struct vmw_fence_obj *fence;
 
        if (!vcotbl->scrubbed) {
-               cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd),
-                                         SVGA3D_INVALID_ID);
-               if (!cmd) {
-                       DRM_ERROR("Failed reserving FIFO space for cotable "
-                                 "readback.\n");
+               cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+               if (!cmd)
                        return -ENOMEM;
-               }
+
                cmd->header.id = SVGA_3D_CMD_DX_READBACK_COTABLE;
                cmd->header.size = sizeof(cmd->body);
                cmd->body.cid = vcotbl->ctx->id;

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
index 92367d4ebdf3ccc101d0d499f73bdf0936c4a86c..96983c47fb405fcf9aaa082d759ff8fad8b22bca 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
@@ -813,7 +813,6 @@ extern int vmw_fifo_init(struct vmw_private *dev_priv,
                         struct vmw_fifo_state *fifo);
 extern void vmw_fifo_release(struct vmw_private *dev_priv,
                             struct vmw_fifo_state *fifo);
-extern void *vmw_fifo_reserve(struct vmw_private *dev_priv, uint32_t bytes);
 extern void *
 vmw_fifo_reserve_dx(struct vmw_private *dev_priv, uint32_t bytes, int ctx_id);
 extern void vmw_fifo_commit(struct vmw_private *dev_priv, uint32_t bytes);
@@ -829,6 +828,18 @@ extern int vmw_fifo_emit_dummy_query(struct vmw_private *dev_priv,
 extern int vmw_fifo_flush(struct vmw_private *dev_priv,
                          bool interruptible);
 
+#define VMW_FIFO_RESERVE_DX(__priv, __bytes, __ctx_id)                        \
+({                                                                            \
+       vmw_fifo_reserve_dx(__priv, __bytes, __ctx_id) ? : ({                 \
+               DRM_ERROR("FIFO reserve failed at %s for %u bytes\n",         \
+                         __func__, (unsigned int) __bytes);                  \
+               NULL;                                                         \
+       });                                                                   \
+})
+
+#define VMW_FIFO_RESERVE(__priv, __bytes)                                     \
+       VMW_FIFO_RESERVE_DX(__priv, __bytes, SVGA3D_INVALID_ID)
+
 /**
  * TTM glue - vmwgfx_ttm_glue.c
  */

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
index 0d703f431f1f19f851e67aff71696b2004c70744..6cc9837b10ec1aa51f759bde83420e0546b478bc 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
@@ -720,8 +720,7 @@ static int vmw_rebind_all_dx_query(struct vmw_resource *ctx_res)
        if (!dx_query_mob || dx_query_mob->dx_query_ctx)
                return 0;
 
-       cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), ctx_res->id);
-
+       cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), ctx_res->id);
        if (cmd == NULL)
                return -ENOMEM;
 
@@ -3468,14 +3467,13 @@ static int vmw_execbuf_submit_fifo(struct vmw_private *dev_priv,
        void *cmd;
 
        if (sw_context->dx_ctx_node)
-               cmd = vmw_fifo_reserve_dx(dev_priv, command_size,
+               cmd = VMW_FIFO_RESERVE_DX(dev_priv, command_size,
                                          sw_context->dx_ctx_node->ctx->id);
        else
-               cmd = vmw_fifo_reserve(dev_priv, command_size);
-       if (!cmd) {
-               VMW_DEBUG_USER("Failed reserving fifo space for commands.\n");
+               cmd = VMW_FIFO_RESERVE(dev_priv, command_size);
+
+       if (!cmd)
                return -ENOMEM;
-       }
 
        vmw_apply_relocations(sw_context);
        memcpy(cmd, kernel_commands, command_size);

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
index d0fd147ef75f2276fcd5c17865d65d94728e682c..ff3586cb68516e47e645a845a684611b09d3fb1a 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
@@ -395,12 +395,8 @@ void *vmw_fifo_reserve_dx(struct vmw_private *dev_priv, uint32_t bytes,
                WARN(1, "Command buffer has not been allocated.\n");
                ret = NULL;
        }
-       if (IS_ERR_OR_NULL(ret)) {
-               DRM_ERROR("Fifo reserve failure of %u bytes.\n",
-                         (unsigned) bytes);
-               dump_stack();
+       if (IS_ERR_OR_NULL(ret))
                return NULL;
-       }
 
        return ret;
 }
@@ -544,7 +540,7 @@ int vmw_fifo_send_fence(struct vmw_private *dev_priv, uint32_t *seqno)
        int ret = 0;
        uint32_t bytes = sizeof(u32) + sizeof(*cmd_fence);
 
-       fm = vmw_fifo_reserve(dev_priv, bytes);
+       fm = VMW_FIFO_RESERVE(dev_priv, bytes);
        if (unlikely(fm == NULL)) {
                *seqno = atomic_read(&dev_priv->marker_seq);
                ret = -ENOMEM;
@@ -603,12 +599,9 @@ static int vmw_fifo_emit_dummy_legacy_query(struct vmw_private *dev_priv,
                SVGA3dCmdWaitForQuery body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Out of fifo space for dummy query.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_WAIT_FOR_QUERY;
        cmd->header.size = sizeof(cmd->body);
@@ -652,12 +645,9 @@ static int vmw_fifo_emit_dummy_gb_query(struct vmw_private *dev_priv,
                SVGA3dCmdWaitForGBQuery body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Out of fifo space for dummy query.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_WAIT_FOR_GB_QUERY;
        cmd->header.size = sizeof(cmd->body);
@@ -699,8 +689,3 @@ int vmw_fifo_emit_dummy_query(struct vmw_private *dev_priv,
 
        return vmw_fifo_emit_dummy_legacy_query(dev_priv, cid);
 }
-
-void *vmw_fifo_reserve(struct vmw_private *dev_priv, uint32_t bytes)
-{
-       return vmw_fifo_reserve_dx(dev_priv, bytes, SVGA3D_INVALID_ID);
-}

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c b/drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c
index 007a0cc7f232219a825f9cad5ff263bee2c936d2..ae7acc6f3ddab2778c0fc44a28c435fd81ea6993 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c
@@ -51,7 +51,7 @@ static int vmw_gmr2_bind(struct vmw_private *dev_priv,
        uint32_t cmd_size = define_size + remap_size;
        uint32_t i;
 
-       cmd_orig = cmd = vmw_fifo_reserve(dev_priv, cmd_size);
+       cmd_orig = cmd = VMW_FIFO_RESERVE(dev_priv, cmd_size);
        if (unlikely(cmd == NULL))
                return -ENOMEM;
 
@@ -110,11 +110,10 @@ static void vmw_gmr2_unbind(struct vmw_private *dev_priv,
        uint32_t define_size = sizeof(define_cmd) + 4;
        uint32_t *cmd;
 
-       cmd = vmw_fifo_reserve(dev_priv, define_size);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("GMR2 unbind failed.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, define_size);
+       if (unlikely(cmd == NULL))
                return;
-       }
+
        define_cmd.gmrId = gmr_id;
        define_cmd.numPages = 0;
 

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index de367e8612af7fd77f77604a03017f1bd15a38c4..b97bc8e5944b68266122d48b21895cd2d450182c 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -64,11 +64,9 @@ static int vmw_cursor_update_image(struct vmw_private *dev_priv,
        if (!image)
                return -EINVAL;
 
-       cmd = vmw_fifo_reserve(dev_priv, cmd_size);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Fifo reserve failed.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, cmd_size);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        memset(cmd, 0, sizeof(*cmd));
 
@@ -2468,13 +2466,11 @@ int vmw_kms_helper_dirty(struct vmw_private *dev_priv,
 
                dirty->unit = unit;
                if (dirty->fifo_reserve_size > 0) {
-                       dirty->cmd = vmw_fifo_reserve(dev_priv,
+                       dirty->cmd = VMW_FIFO_RESERVE(dev_priv,
                                                      dirty->fifo_reserve_size);
-                       if (!dirty->cmd) {
-                               DRM_ERROR("Couldn't reserve fifo space "
-                                         "for dirty blits.\n");
+                       if (!dirty->cmd)
                                return -ENOMEM;
-                       }
+
                        memset(dirty->cmd, 0, dirty->fifo_reserve_size);
                }
                dirty->num_hits = 0;
@@ -2604,12 +2600,9 @@ int vmw_kms_update_proxy(struct vmw_resource *res,
        if (!clips)
                return 0;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd) * num_clips);
-       if (!cmd) {
-               DRM_ERROR("Couldn't reserve fifo space for proxy surface "
-                         "update.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd) * num_clips);
+       if (!cmd)
                return -ENOMEM;
-       }
 
        for (i = 0; i < num_clips; ++i, clips += increment, ++cmd) {
                box = &cmd->body.box;
@@ -2839,7 +2832,7 @@ int vmw_du_helper_plane_update(struct vmw_du_update_plane *update)
                goto out_unref;
 
        reserved_size = update->calc_fifo_size(update, num_hits);
-       cmd_start = vmw_fifo_reserve(update->dev_priv, reserved_size);
+       cmd_start = VMW_FIFO_RESERVE(update->dev_priv, reserved_size);
        if (!cmd_start) {
                ret = -ENOMEM;
                goto out_revert;

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
index 16be515c4c0f3d3ae737de90c408ba8209d72833..25e6343bcf2173dc32a8eae55a71486ae1e13ce4 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
@@ -554,11 +554,9 @@ int vmw_kms_ldu_do_bo_dirty(struct vmw_private *dev_priv,
        } *cmd;
 
        fifo_size = sizeof(*cmd) * num_clips;
-       cmd = vmw_fifo_reserve(dev_priv, fifo_size);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Fifo reserve failed.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, fifo_size);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        memset(cmd, 0, fifo_size);
        for (i = 0; i < num_clips; i++, clips += increment) {

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_mob.c b/drivers/gpu/drm/vmwgfx/vmwgfx_mob.c
index d83cc66e12104d5794a38b33652a6062894e048b..406edc8cef35d52ffb100c47c46ef2d3237d2a43 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_mob.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_mob.c
@@ -146,9 +146,8 @@ static int vmw_setup_otable_base(struct vmw_private *dev_priv,
                mob->pt_level += VMW_MOBFMT_PTDEPTH_1 - SVGA3D_MOBFMT_PTDEPTH_1;
        }
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
        if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for OTable setup.\n");
                ret = -ENOMEM;
                goto out_no_fifo;
        }
@@ -202,12 +201,9 @@ static void vmw_takedown_otable_base(struct vmw_private *dev_priv,
                return;
 
        bo = otable->page_table->pt_bo;
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for OTable "
-                         "takedown.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return;
-       }
 
        memset(cmd, 0, sizeof(*cmd));
        cmd->header.id = SVGA_3D_CMD_SET_OTABLE_BASE;
@@ -614,16 +610,14 @@ void vmw_mob_unbind(struct vmw_private *dev_priv,
                BUG_ON(ret != 0);
        }
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for Memory "
-                         "Object unbinding.\n");
-       } else {
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (cmd) {
                cmd->header.id = SVGA_3D_CMD_DESTROY_GB_MOB;
                cmd->header.size = sizeof(cmd->body);
                cmd->body.mobid = mob->id;
                vmw_fifo_commit(dev_priv, sizeof(*cmd));
        }
+
        if (bo) {
                vmw_bo_fence_single(bo, NULL);
                ttm_bo_unreserve(bo);
@@ -683,12 +677,9 @@ int vmw_mob_bind(struct vmw_private *dev_priv,
 
        vmw_fifo_resource_inc(dev_priv);
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for Memory "
-                         "Object binding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                goto out_no_cmd_space;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DEFINE_GB_MOB64;
        cmd->header.size = sizeof(cmd->body);

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c b/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c
index 9f1b9d289bec57d9377fec288a284b803ae53d85..d5ef8cf802deed673434d10345c7909d25ea6d64 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c
@@ -124,7 +124,7 @@ static int vmw_overlay_send_put(struct vmw_private *dev_priv,
 
        fifo_size = sizeof(*cmds) + sizeof(*flush) + sizeof(*items) * num_items;
 
-       cmds = vmw_fifo_reserve(dev_priv, fifo_size);
+       cmds = VMW_FIFO_RESERVE(dev_priv, fifo_size);
        /* hardware has hung, can't do anything here */
        if (!cmds)
                return -ENOMEM;
@@ -194,7 +194,7 @@ static int vmw_overlay_send_stop(struct vmw_private *dev_priv,
        int ret;
 
        for (;;) {
-               cmds = vmw_fifo_reserve(dev_priv, sizeof(*cmds));
+               cmds = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmds));
                if (cmds)
                        break;
 

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
index c8feeaa8514396c1c2ebf17f216b48b7aedd3433..711f8fd0dd454fcbde3f79643d874cf73c5527ae 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
@@ -730,12 +730,9 @@ int vmw_query_readback_all(struct vmw_buffer_object *dx_query_mob)
        dx_query_ctx = dx_query_mob->dx_query_ctx;
        dev_priv     = dx_query_ctx->dev_priv;
 
-       cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), dx_query_ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for "
-                         "query MOB read back.\n");
+       cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), dx_query_ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id   = SVGA_3D_CMD_DX_READBACK_ALL_QUERY;
        cmd->header.size = sizeof(cmd->body);

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
index 9c2bdb56a6d3e056581c4790670b7beca84c6eac..9a2a3836d89a88419cef8324d7a6f9ff20a7ed20 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
@@ -130,12 +130,9 @@ static int vmw_sou_fifo_create(struct vmw_private *dev_priv,
        BUG_ON(!sou->buffer);
 
        fifo_size = sizeof(*cmd);
-       cmd = vmw_fifo_reserve(dev_priv, fifo_size);
-       /* The hardware has hung, nothing we can do about it here. */
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Fifo reserve failed.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, fifo_size);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        memset(cmd, 0, fifo_size);
        cmd->header.cmdType = SVGA_CMD_DEFINE_SCREEN;
@@ -182,12 +179,9 @@ static int vmw_sou_fifo_destroy(struct vmw_private *dev_priv,
                return 0;
 
        fifo_size = sizeof(*cmd);
-       cmd = vmw_fifo_reserve(dev_priv, fifo_size);
-       /* the hardware has hung, nothing we can do about it here */
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Fifo reserve failed.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, fifo_size);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        memset(cmd, 0, fifo_size);
        cmd->header.cmdType = SVGA_CMD_DESTROY_SCREEN;
@@ -998,11 +992,9 @@ static int do_bo_define_gmrfb(struct vmw_private *dev_priv,
        if (depth == 32)
                depth = 24;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (!cmd) {
-               DRM_ERROR("Out of fifo space for dirty framebuffer command.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (!cmd)
                return -ENOMEM;
-       }
 
        cmd->header = SVGA_CMD_DEFINE_GMRFB;
        cmd->body.format.bitsPerPixel = framebuffer->base.format->cpp[0] * 8;

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c b/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c
index bbc95743a3819786eb3cbe02649c632f31b73a75..d310d21f0d541c4db59571ab182b8cf4c66a2ad7 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c
@@ -218,10 +218,8 @@ static int vmw_gb_shader_create(struct vmw_resource *res)
                goto out_no_fifo;
        }
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
        if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for shader "
-                         "creation.\n");
                ret = -ENOMEM;
                goto out_no_fifo;
        }
@@ -254,12 +252,9 @@ static int vmw_gb_shader_bind(struct vmw_resource *res,
 
        BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for shader "
-                         "binding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER;
        cmd->header.size = sizeof(cmd->body);
@@ -285,12 +280,9 @@ static int vmw_gb_shader_unbind(struct vmw_resource *res,
 
        BUG_ON(res->backup->base.mem.mem_type != VMW_PL_MOB);
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for shader "
-                         "unbinding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER;
        cmd->header.size = sizeof(cmd->body);
@@ -328,10 +320,8 @@ static int vmw_gb_shader_destroy(struct vmw_resource *res)
        mutex_lock(&dev_priv->binding_mutex);
        vmw_binding_res_list_scrub(&res->binding_head);
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
        if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for shader "
-                         "destruction.\n");
                mutex_unlock(&dev_priv->binding_mutex);
                return -ENOMEM;
        }
@@ -400,13 +390,9 @@ static int vmw_dx_shader_unscrub(struct vmw_resource *res)
        if (!list_empty(&shader->cotable_head) || !shader->committed)
                return 0;
 
-       cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd),
-                                 shader->ctx->id);
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for shader "
-                         "scrubbing.\n");
+       cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), shader->ctx->id);
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_BIND_SHADER;
        cmd->header.size = sizeof(cmd->body);
@@ -491,12 +477,9 @@ static int vmw_dx_shader_scrub(struct vmw_resource *res)
                return 0;
 
        WARN_ON_ONCE(!shader->committed);
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Failed reserving FIFO space for shader "
-                         "scrubbing.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id = SVGA_3D_CMD_DX_BIND_SHADER;
        cmd->header.size = sizeof(cmd->body);

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_so.c b/drivers/gpu/drm/vmwgfx/vmwgfx_so.c
index c50002a3db277a59e189f3321d86eb48dcf27751..63807361e16fc1c46ce2e5bedbc286c13224d931 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_so.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_so.c
@@ -170,13 +170,12 @@ static int vmw_view_create(struct vmw_resource *res)
                return 0;
        }
 
-       cmd = vmw_fifo_reserve_dx(res->dev_priv, view->cmd_size,
-                                 view->ctx->id);
+       cmd = VMW_FIFO_RESERVE_DX(res->dev_priv, view->cmd_size, view->ctx->id);
        if (!cmd) {
-               DRM_ERROR("Failed reserving FIFO space for view creation.\n");
                mutex_unlock(&dev_priv->binding_mutex);
                return -ENOMEM;
        }
+
        memcpy(cmd, &view->cmd, view->cmd_size);
        WARN_ON(cmd->body.view_id != view->view_id);
        /* Sid may have changed due to surface eviction. */
@@ -214,12 +213,9 @@ static int vmw_view_destroy(struct vmw_resource *res)
        if (!view->committed || res->id == -1)
                return 0;
 
-       cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), view->ctx->id);
-       if (!cmd) {
-               DRM_ERROR("Failed reserving FIFO space for view "
-                         "destruction.\n");
+       cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), view->ctx->id);
+       if (!cmd)
                return -ENOMEM;
-       }
 
        cmd->header.id = vmw_view_destroy_cmds[view->view_type];
        cmd->header.size = sizeof(cmd->body);

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
index 1a65008a27b2e9d2c730f30bbc30a787f6bfe84c..f803bb5e782ba37c041aeec4d1d6ccfb10c0413f 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
@@ -167,12 +167,9 @@ static int vmw_stdu_define_st(struct vmw_private *dev_priv,
                SVGA3dCmdDefineGBScreenTarget body;
        } *cmd;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Out of FIFO space defining Screen Target\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id   = SVGA_3D_CMD_DEFINE_GB_SCREENTARGET;
        cmd->header.size = sizeof(cmd->body);
@@ -229,12 +226,9 @@ static int vmw_stdu_bind_st(struct vmw_private *dev_priv,
        memset(&image, 0, sizeof(image));
        image.sid = res ? res->id : SVGA3D_INVALID_ID;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Out of FIFO space binding a screen target\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id   = SVGA_3D_CMD_BIND_GB_SCREENTARGET;
        cmd->header.size = sizeof(cmd->body);
@@ -296,12 +290,9 @@ static int vmw_stdu_update_st(struct vmw_private *dev_priv,
                return -EINVAL;
        }
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Out of FIFO space updating a Screen Target\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        vmw_stdu_populate_update(cmd, stdu->base.unit,
                                 0, stdu->display_width,
@@ -335,12 +326,9 @@ static int vmw_stdu_destroy_st(struct vmw_private *dev_priv,
        if (unlikely(!stdu->defined))
                return 0;
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-
-       if (unlikely(cmd == NULL)) {
-               DRM_ERROR("Out of FIFO space, screen target not destroyed\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+       if (unlikely(cmd == NULL))
                return -ENOMEM;
-       }
 
        cmd->header.id   = SVGA_3D_CMD_DESTROY_GB_SCREENTARGET;
        cmd->header.size = sizeof(cmd->body);
@@ -637,12 +625,9 @@ static void vmw_stdu_bo_cpu_commit(struct vmw_kms_dirty *dirty)
 
 
                dev_priv = vmw_priv(stdu->base.crtc.dev);
-               cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
-
-               if (!cmd) {
-                       DRM_ERROR("Cannot reserve FIFO space to update STDU");
+               cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
+               if (!cmd)
                        goto out_cleanup;
-               }
 
                vmw_stdu_populate_update(cmd, stdu->base.unit,
                                         region.x1, region.x2,

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c b/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c
index b550f69578e805b56c2ff10046fa05915f776966..219471903bc175f0375256056305fb0cb1fc32d4 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c
@@ -342,12 +342,9 @@ static void vmw_hw_surface_destroy(struct vmw_resource *res)
 
        if (res->id != -1) {
 
-               cmd = vmw_fifo_reserve(dev_priv, vmw_surface_destroy_size());
-               if (unlikely(!cmd)) {
-                       DRM_ERROR("Failed reserving FIFO space for surface "
-                                 "destruction.\n");
+               cmd = VMW_FIFO_RESERVE(dev_priv, vmw_surface_destroy_size());
+               if (unlikely(!cmd))
                        return;
-               }
 
                vmw_surface_destroy_encode(res->id, cmd);
                vmw_fifo_commit(dev_priv, vmw_surface_destroy_size());
@@ -414,10 +411,8 @@ static int vmw_legacy_srf_create(struct vmw_resource *res)
         */
 
        submit_size = vmw_surface_define_size(srf);
-       cmd = vmw_fifo_reserve(dev_priv, submit_size);
+       cmd = VMW_FIFO_RESERVE(dev_priv, submit_size);
        if (unlikely(!cmd)) {
-               DRM_ERROR("Failed reserving FIFO space for surface "
-                         "creation.\n");
                ret = -ENOMEM;
                goto out_no_fifo;
        }
@@ -468,12 +463,10 @@ static int vmw_legacy_srf_dma(struct vmw_resource *res,
 
        BUG_ON(!val_buf->bo);
        submit_size = vmw_surface_dma_size(srf);
-       cmd = vmw_fifo_reserve(dev_priv, submit_size);
-       if (unlikely(!cmd)) {
-               DRM_ERROR("Failed reserving FIFO space for surface "
-                         "DMA.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, submit_size);
+       if (unlikely(!cmd))
                return -ENOMEM;
-       }
+
        vmw_bo_get_guest_ptr(val_buf->bo, &ptr);
        vmw_surface_dma_encode(srf, cmd, &ptr, bind);
 
@@ -556,12 +549,9 @@ static int vmw_legacy_srf_destroy(struct vmw_resource *res)
         */
 
        submit_size = vmw_surface_destroy_size();
-       cmd = vmw_fifo_reserve(dev_priv, submit_size);
-       if (unlikely(!cmd)) {
-               DRM_ERROR("Failed reserving FIFO space for surface "
-                         "eviction.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, submit_size);
+       if (unlikely(!cmd))
                return -ENOMEM;
-       }
 
        vmw_surface_destroy_encode(res->id, cmd);
        vmw_fifo_commit(dev_priv, submit_size);
@@ -1086,12 +1076,10 @@ static int vmw_gb_surface_create(struct vmw_resource *res)
                submit_len = sizeof(*cmd);
        }
 
-       cmd = vmw_fifo_reserve(dev_priv, submit_len);
+       cmd = VMW_FIFO_RESERVE(dev_priv, submit_len);
        cmd2 = (typeof(cmd2))cmd;
        cmd3 = (typeof(cmd3))cmd;
        if (unlikely(!cmd)) {
-               DRM_ERROR("Failed reserving FIFO space for surface "
-                         "creation.\n");
                ret = -ENOMEM;
                goto out_no_fifo;
        }
@@ -1169,12 +1157,9 @@ static int vmw_gb_surface_bind(struct vmw_resource *res,
 
        submit_size = sizeof(*cmd1) + (res->backup_dirty ? sizeof(*cmd2) : 0);
 
-       cmd1 = vmw_fifo_reserve(dev_priv, submit_size);
-       if (unlikely(!cmd1)) {
-               DRM_ERROR("Failed reserving FIFO space for surface "
-                         "binding.\n");
+       cmd1 = VMW_FIFO_RESERVE(dev_priv, submit_size);
+       if (unlikely(!cmd1))
                return -ENOMEM;
-       }
 
        cmd1->header.id = SVGA_3D_CMD_BIND_GB_SURFACE;
        cmd1->header.size = sizeof(cmd1->body);
@@ -1219,12 +1204,9 @@ static int vmw_gb_surface_unbind(struct vmw_resource *res,
        BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
 
        submit_size = sizeof(*cmd3) + (readback ? sizeof(*cmd1) : sizeof(*cmd2));
-       cmd = vmw_fifo_reserve(dev_priv, submit_size);
-       if (unlikely(!cmd)) {
-               DRM_ERROR("Failed reserving FIFO space for surface "
-                         "unbinding.\n");
+       cmd = VMW_FIFO_RESERVE(dev_priv, submit_size);
+       if (unlikely(!cmd))
                return -ENOMEM;
-       }
 
        if (readback) {
                cmd1 = (void *) cmd;
@@ -1278,10 +1260,8 @@ static int vmw_gb_surface_destroy(struct vmw_resource *res)
        vmw_view_surface_list_destroy(dev_priv, &srf->view_list);
        vmw_binding_res_list_scrub(&res->binding_head);
 
-       cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+       cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
        if (unlikely(!cmd)) {
-               DRM_ERROR("Failed reserving FIFO space for surface "
-                         "destruction.\n");
                mutex_unlock(&dev_priv->binding_mutex);
                return -ENOMEM;
        }