drivers/gpu/drm/vboxvideo/vbva_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 "hgsmi_channels.h"
   8
   9 /*
  10  * There is a hardware ring buffer in the graphics device video RAM, formerly
  11  * in the VBox VMMDev PCI memory space.
  12  * All graphics commands go there serialized by vbva_buffer_begin_update.
  13  * and vbva_buffer_end_update.
  14  *
  15  * free_offset is writing position. data_offset is reading position.
  16  * free_offset == data_offset means buffer is empty.
  17  * There must be always gap between data_offset and free_offset when data
  18  * are in the buffer.
  19  * Guest only changes free_offset, host changes data_offset.
  20  */
  21
  22 static u32 vbva_buffer_available(const struct vbva_buffer *vbva)
  23 {
  24         s32 diff = vbva->data_offset - vbva->free_offset;
  25
  26         return diff > 0 ? diff : vbva->data_len + diff;
  27 }
  28
  29 static void vbva_buffer_place_data_at(struct vbva_buf_ctx *vbva_ctx,
  30                                       const void *p, u32 len, u32 offset)
  31 {
  32         struct vbva_buffer *vbva = vbva_ctx->vbva;
  33         u32 bytes_till_boundary = vbva->data_len - offset;
  34         u8 *dst = &vbva->data[offset];
  35         s32 diff = len - bytes_till_boundary;
  36
  37         if (diff <= 0) {
  38                 /* Chunk will not cross buffer boundary. */
  39                 memcpy(dst, p, len);
  40         } else {
  41                 /* Chunk crosses buffer boundary. */
  42                 memcpy(dst, p, bytes_till_boundary);
  43                 memcpy(&vbva->data[0], (u8 *)p + bytes_till_boundary, diff);
  44         }
  45 }
  46
  47 static void vbva_buffer_flush(struct gen_pool *ctx)
  48 {
  49         struct vbva_flush *p;
  50
  51         p = hgsmi_buffer_alloc(ctx, sizeof(*p), HGSMI_CH_VBVA, VBVA_FLUSH);
  52         if (!p)
  53                 return;
  54
  55         p->reserved = 0;
  56
  57         hgsmi_buffer_submit(ctx, p);
  58         hgsmi_buffer_free(ctx, p);
  59 }
  60
  61 bool vbva_write(struct vbva_buf_ctx *vbva_ctx, struct gen_pool *ctx,
  62                 const void *p, u32 len)
  63 {
  64         struct vbva_record *record;
  65         struct vbva_buffer *vbva;
  66         u32 available;
  67
  68         vbva = vbva_ctx->vbva;
  69         record = vbva_ctx->record;
  70
  71         if (!vbva || vbva_ctx->buffer_overflow ||
  72             !record || !(record->len_and_flags & VBVA_F_RECORD_PARTIAL))
  73                 return false;
  74
  75         available = vbva_buffer_available(vbva);
  76
  77         while (len > 0) {
  78                 u32 chunk = len;
  79
  80                 if (chunk >= available) {
  81                         vbva_buffer_flush(ctx);
  82                         available = vbva_buffer_available(vbva);
  83                 }
  84
  85                 if (chunk >= available) {
  86                         if (WARN_ON(available <= vbva->partial_write_tresh)) {
  87                                 vbva_ctx->buffer_overflow = true;
  88                                 return false;
  89                         }
  90                         chunk = available - vbva->partial_write_tresh;
  91                 }
  92
  93                 vbva_buffer_place_data_at(vbva_ctx, p, chunk,
  94                                           vbva->free_offset);
  95
  96                 vbva->free_offset = (vbva->free_offset + chunk) %
  97                                     vbva->data_len;
  98                 record->len_and_flags += chunk;
  99                 available -= chunk;
 100                 len -= chunk;
 101                 p += chunk;
 102         }
 103
 104         return true;
 105 }
 106
 107 static bool vbva_inform_host(struct vbva_buf_ctx *vbva_ctx,
 108                              struct gen_pool *ctx, s32 screen, bool enable)
 109 {
 110         struct vbva_enable_ex *p;
 111         bool ret;
 112
 113         p = hgsmi_buffer_alloc(ctx, sizeof(*p), HGSMI_CH_VBVA, VBVA_ENABLE);
 114         if (!p)
 115                 return false;
 116
 117         p->base.flags = enable ? VBVA_F_ENABLE : VBVA_F_DISABLE;
 118         p->base.offset = vbva_ctx->buffer_offset;
 119         p->base.result = VERR_NOT_SUPPORTED;
 120         if (screen >= 0) {
 121                 p->base.flags |= VBVA_F_EXTENDED | VBVA_F_ABSOFFSET;
 122                 p->screen_id = screen;
 123         }
 124
 125         hgsmi_buffer_submit(ctx, p);
 126
 127         if (enable)
 128                 ret = p->base.result >= 0;
 129         else
 130                 ret = true;
 131
 132         hgsmi_buffer_free(ctx, p);
 133
 134         return ret;
 135 }
 136
 137 bool vbva_enable(struct vbva_buf_ctx *vbva_ctx, struct gen_pool *ctx,
 138                  struct vbva_buffer *vbva, s32 screen)
 139 {
 140         bool ret = false;
 141
 142         memset(vbva, 0, sizeof(*vbva));
 143         vbva->partial_write_tresh = 256;
 144         vbva->data_len = vbva_ctx->buffer_length - sizeof(struct vbva_buffer);
 145         vbva_ctx->vbva = vbva;
 146
 147         ret = vbva_inform_host(vbva_ctx, ctx, screen, true);
 148         if (!ret)
 149                 vbva_disable(vbva_ctx, ctx, screen);
 150
 151         return ret;
 152 }
 153
 154 void vbva_disable(struct vbva_buf_ctx *vbva_ctx, struct gen_pool *ctx,
 155                   s32 screen)
 156 {
 157         vbva_ctx->buffer_overflow = false;
 158         vbva_ctx->record = NULL;
 159         vbva_ctx->vbva = NULL;
 160
 161         vbva_inform_host(vbva_ctx, ctx, screen, false);
 162 }
 163
 164 bool vbva_buffer_begin_update(struct vbva_buf_ctx *vbva_ctx,
 165                               struct gen_pool *ctx)
 166 {
 167         struct vbva_record *record;
 168         u32 next;
 169
 170         if (!vbva_ctx->vbva ||
 171             !(vbva_ctx->vbva->host_flags.host_events & VBVA_F_MODE_ENABLED))
 172                 return false;
 173
 174         WARN_ON(vbva_ctx->buffer_overflow || vbva_ctx->record);
 175
 176         next = (vbva_ctx->vbva->record_free_index + 1) % VBVA_MAX_RECORDS;
 177
 178         /* Flush if all slots in the records queue are used */
 179         if (next == vbva_ctx->vbva->record_first_index)
 180                 vbva_buffer_flush(ctx);
 181
 182         /* If even after flush there is no place then fail the request */
 183         if (next == vbva_ctx->vbva->record_first_index)
 184                 return false;
 185
 186         record = &vbva_ctx->vbva->records[vbva_ctx->vbva->record_free_index];
 187         record->len_and_flags = VBVA_F_RECORD_PARTIAL;
 188         vbva_ctx->vbva->record_free_index = next;
 189         /* Remember which record we are using. */
 190         vbva_ctx->record = record;
 191
 192         return true;
 193 }
 194
 195 void vbva_buffer_end_update(struct vbva_buf_ctx *vbva_ctx)
 196 {
 197         struct vbva_record *record = vbva_ctx->record;
 198
 199         WARN_ON(!vbva_ctx->vbva || !record ||
 200                 !(record->len_and_flags & VBVA_F_RECORD_PARTIAL));
 201
 202         /* Mark the record completed. */
 203         record->len_and_flags &= ~VBVA_F_RECORD_PARTIAL;
 204
 205         vbva_ctx->buffer_overflow = false;
 206         vbva_ctx->record = NULL;
 207 }
 208
 209 void vbva_setup_buffer_context(struct vbva_buf_ctx *vbva_ctx,
 210                                u32 buffer_offset, u32 buffer_length)
 211 {
 212         vbva_ctx->buffer_offset = buffer_offset;
 213         vbva_ctx->buffer_length = buffer_length;
 214 }