drivers/gpu/drm/vboxvideo/hgsmi_base.c

   1 // SPDX-License-Identifier: MIT
   2 /* Copyright (C) 2006-2017 Oracle Corporation */
   3
   4 #include <linux/vbox_err.h>
   5 #include "vbox_drv.h"
   6 #include "vboxvideo_guest.h"
   7 #include "vboxvideo_vbe.h"
   8 #include "hgsmi_channels.h"
   9 #include "hgsmi_ch_setup.h"
  10
  11 /**
  12  * hgsmi_report_flags_location - Inform the host of the location of
  13  *                               the host flags in VRAM via an HGSMI cmd.
  14  * Return: 0 or negative errno value.
  15  * @ctx:        The context of the guest heap to use.
  16  * @location:   The offset chosen for the flags within guest VRAM.
  17  */
  18 int hgsmi_report_flags_location(struct gen_pool *ctx, u32 location)
  19 {
  20         struct hgsmi_buffer_location *p;
  21
  22         p = hgsmi_buffer_alloc(ctx, sizeof(*p), HGSMI_CH_HGSMI,
  23                                HGSMI_CC_HOST_FLAGS_LOCATION);
  24         if (!p)
  25                 return -ENOMEM;
  26
  27         p->buf_location = location;
  28         p->buf_len = sizeof(struct hgsmi_host_flags);
  29
  30         hgsmi_buffer_submit(ctx, p);
  31         hgsmi_buffer_free(ctx, p);
  32
  33         return 0;
  34 }
  35
  36 /**
  37  * hgsmi_send_caps_info - Notify the host of HGSMI-related guest capabilities
  38  *                        via an HGSMI command.
  39  * Return: 0 or negative errno value.
  40  * @ctx:        The context of the guest heap to use.
  41  * @caps:       The capabilities to report, see vbva_caps.
  42  */
  43 int hgsmi_send_caps_info(struct gen_pool *ctx, u32 caps)
  44 {
  45         struct vbva_caps *p;
  46
  47         p = hgsmi_buffer_alloc(ctx, sizeof(*p), HGSMI_CH_VBVA, VBVA_INFO_CAPS);
  48         if (!p)
  49                 return -ENOMEM;
  50
  51         p->rc = VERR_NOT_IMPLEMENTED;
  52         p->caps = caps;
  53
  54         hgsmi_buffer_submit(ctx, p);
  55
  56         WARN_ON_ONCE(p->rc < 0);
  57
  58         hgsmi_buffer_free(ctx, p);
  59
  60         return 0;
  61 }
  62
  63 int hgsmi_test_query_conf(struct gen_pool *ctx)
  64 {
  65         u32 value = 0;
  66         int ret;
  67
  68         ret = hgsmi_query_conf(ctx, U32_MAX, &value);
  69         if (ret)
  70                 return ret;
  71
  72         return value == U32_MAX ? 0 : -EIO;
  73 }
  74
  75 /**
  76  * hgsmi_query_conf - Query the host for an HGSMI configuration
  77  *                    parameter via an HGSMI command.
  78  * Return: 0 or negative errno value.
  79  * @ctx:        The context containing the heap used.
  80  * @index:      The index of the parameter to query.
  81  * @value_ret:  Where to store the value of the parameter on success.
  82  */
  83 int hgsmi_query_conf(struct gen_pool *ctx, u32 index, u32 *value_ret)
  84 {
  85         struct vbva_conf32 *p;
  86
  87         p = hgsmi_buffer_alloc(ctx, sizeof(*p), HGSMI_CH_VBVA,
  88                                VBVA_QUERY_CONF32);
  89         if (!p)
  90                 return -ENOMEM;
  91
  92         p->index = index;
  93         p->value = U32_MAX;
  94
  95         hgsmi_buffer_submit(ctx, p);
  96
  97         *value_ret = p->value;
  98
  99         hgsmi_buffer_free(ctx, p);
 100
 101         return 0;
 102 }
 103
 104 /**
 105  * hgsmi_update_pointer_shape - Pass the host a new mouse pointer shape
 106  *                              via an HGSMI command.
 107  * Return: 0 or negative errno value.
 108  * @ctx:        The context containing the heap to be used.
 109  * @flags:      Cursor flags.
 110  * @hot_x:      Horizontal position of the hot spot.
 111  * @hot_y:      Vertical position of the hot spot.
 112  * @width:      Width in pixels of the cursor.
 113  * @height:     Height in pixels of the cursor.
 114  * @pixels:     Pixel data, @see VMMDevReqMousePointer for the format.
 115  * @len:        Size in bytes of the pixel data.
 116  */
 117 int hgsmi_update_pointer_shape(struct gen_pool *ctx, u32 flags,
 118                                u32 hot_x, u32 hot_y, u32 width, u32 height,
 119                                u8 *pixels, u32 len)
 120 {
 121         struct vbva_mouse_pointer_shape *p;
 122         u32 pixel_len = 0;
 123         int rc;
 124
 125         if (flags & VBOX_MOUSE_POINTER_SHAPE) {
 126                 /*
 127                  * Size of the pointer data:
 128                  * sizeof (AND mask) + sizeof (XOR_MASK)
 129                  */
 130                 pixel_len = ((((width + 7) / 8) * height + 3) & ~3) +
 131                          width * 4 * height;
 132                 if (pixel_len > len)
 133                         return -EINVAL;
 134
 135                 /*
 136                  * If shape is supplied, then always create the pointer visible.
 137                  * See comments in 'vboxUpdatePointerShape'
 138                  */
 139                 flags |= VBOX_MOUSE_POINTER_VISIBLE;
 140         }
 141
 142         p = hgsmi_buffer_alloc(ctx, sizeof(*p) + pixel_len, HGSMI_CH_VBVA,
 143                                VBVA_MOUSE_POINTER_SHAPE);
 144         if (!p)
 145                 return -ENOMEM;
 146
 147         p->result = VINF_SUCCESS;
 148         p->flags = flags;
 149         p->hot_X = hot_x;
 150         p->hot_y = hot_y;
 151         p->width = width;
 152         p->height = height;
 153         if (pixel_len)
 154                 memcpy(p->data, pixels, pixel_len);
 155
 156         hgsmi_buffer_submit(ctx, p);
 157
 158         switch (p->result) {
 159         case VINF_SUCCESS:
 160                 rc = 0;
 161                 break;
 162         case VERR_NO_MEMORY:
 163                 rc = -ENOMEM;
 164                 break;
 165         case VERR_NOT_SUPPORTED:
 166                 rc = -EBUSY;
 167                 break;
 168         default:
 169                 rc = -EINVAL;
 170         }
 171
 172         hgsmi_buffer_free(ctx, p);
 173
 174         return rc;
 175 }
 176
 177 /**
 178  * hgsmi_cursor_position - Report the guest cursor position.  The host may
 179  *                         wish to use this information to re-position its
 180  *                         own cursor (though this is currently unlikely).
 181  *                         The current host cursor position is returned.
 182  * Return: 0 or negative errno value.
 183  * @ctx:              The context containing the heap used.
 184  * @report_position:  Are we reporting a position?
 185  * @x:                Guest cursor X position.
 186  * @y:                Guest cursor Y position.
 187  * @x_host:           Host cursor X position is stored here.  Optional.
 188  * @y_host:           Host cursor Y position is stored here.  Optional.
 189  */
 190 int hgsmi_cursor_position(struct gen_pool *ctx, bool report_position,
 191                           u32 x, u32 y, u32 *x_host, u32 *y_host)
 192 {
 193         struct vbva_cursor_position *p;
 194
 195         p = hgsmi_buffer_alloc(ctx, sizeof(*p), HGSMI_CH_VBVA,
 196                                VBVA_CURSOR_POSITION);
 197         if (!p)
 198                 return -ENOMEM;
 199
 200         p->report_position = report_position;
 201         p->x = x;
 202         p->y = y;
 203
 204         hgsmi_buffer_submit(ctx, p);
 205
 206         *x_host = p->x;
 207         *y_host = p->y;
 208
 209         hgsmi_buffer_free(ctx, p);
 210
 211         return 0;
 212 }