/*
|
* Copyright (C) 2006-2017 Oracle Corporation
|
*
|
* 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, sublicense,
|
* 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 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 NONINFRINGEMENT. IN NO EVENT SHALL
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 "vbox_drv.h"
|
#include "vbox_err.h"
|
#include "vboxvideo_guest.h"
|
#include "hgsmi_channels.h"
|
|
/*
|
* There is a hardware ring buffer in the graphics device video RAM, formerly
|
* in the VBox VMMDev PCI memory space.
|
* All graphics commands go there serialized by vbva_buffer_begin_update.
|
* and vbva_buffer_end_update.
|
*
|
* free_offset is writing position. data_offset is reading position.
|
* free_offset == data_offset means buffer is empty.
|
* There must be always gap between data_offset and free_offset when data
|
* are in the buffer.
|
* Guest only changes free_offset, host changes data_offset.
|
*/
|
|
static u32 vbva_buffer_available(const struct vbva_buffer *vbva)
|
{
|
s32 diff = vbva->data_offset - vbva->free_offset;
|
|
return diff > 0 ? diff : vbva->data_len + diff;
|
}
|
|
static void vbva_buffer_place_data_at(struct vbva_buf_ctx *vbva_ctx,
|
const void *p, u32 len, u32 offset)
|
{
|
struct vbva_buffer *vbva = vbva_ctx->vbva;
|
u32 bytes_till_boundary = vbva->data_len - offset;
|
u8 *dst = &vbva->data[offset];
|
s32 diff = len - bytes_till_boundary;
|
|
if (diff <= 0) {
|
/* Chunk will not cross buffer boundary. */
|
memcpy(dst, p, len);
|
} else {
|
/* Chunk crosses buffer boundary. */
|
memcpy(dst, p, bytes_till_boundary);
|
memcpy(&vbva->data[0], (u8 *)p + bytes_till_boundary, diff);
|
}
|
}
|
|
static void vbva_buffer_flush(struct gen_pool *ctx)
|
{
|
struct vbva_flush *p;
|
|
p = hgsmi_buffer_alloc(ctx, sizeof(*p), HGSMI_CH_VBVA, VBVA_FLUSH);
|
if (!p)
|
return;
|
|
p->reserved = 0;
|
|
hgsmi_buffer_submit(ctx, p);
|
hgsmi_buffer_free(ctx, p);
|
}
|
|
bool vbva_write(struct vbva_buf_ctx *vbva_ctx, struct gen_pool *ctx,
|
const void *p, u32 len)
|
{
|
struct vbva_record *record;
|
struct vbva_buffer *vbva;
|
u32 available;
|
|
vbva = vbva_ctx->vbva;
|
record = vbva_ctx->record;
|
|
if (!vbva || vbva_ctx->buffer_overflow ||
|
!record || !(record->len_and_flags & VBVA_F_RECORD_PARTIAL))
|
return false;
|
|
available = vbva_buffer_available(vbva);
|
|
while (len > 0) {
|
u32 chunk = len;
|
|
if (chunk >= available) {
|
vbva_buffer_flush(ctx);
|
available = vbva_buffer_available(vbva);
|
}
|
|
if (chunk >= available) {
|
if (WARN_ON(available <= vbva->partial_write_tresh)) {
|
vbva_ctx->buffer_overflow = true;
|
return false;
|
}
|
chunk = available - vbva->partial_write_tresh;
|
}
|
|
vbva_buffer_place_data_at(vbva_ctx, p, chunk,
|
vbva->free_offset);
|
|
vbva->free_offset = (vbva->free_offset + chunk) %
|
vbva->data_len;
|
record->len_and_flags += chunk;
|
available -= chunk;
|
len -= chunk;
|
p += chunk;
|
}
|
|
return true;
|
}
|
|
static bool vbva_inform_host(struct vbva_buf_ctx *vbva_ctx,
|
struct gen_pool *ctx, s32 screen, bool enable)
|
{
|
struct vbva_enable_ex *p;
|
bool ret;
|
|
p = hgsmi_buffer_alloc(ctx, sizeof(*p), HGSMI_CH_VBVA, VBVA_ENABLE);
|
if (!p)
|
return false;
|
|
p->base.flags = enable ? VBVA_F_ENABLE : VBVA_F_DISABLE;
|
p->base.offset = vbva_ctx->buffer_offset;
|
p->base.result = VERR_NOT_SUPPORTED;
|
if (screen >= 0) {
|
p->base.flags |= VBVA_F_EXTENDED | VBVA_F_ABSOFFSET;
|
p->screen_id = screen;
|
}
|
|
hgsmi_buffer_submit(ctx, p);
|
|
if (enable)
|
ret = RT_SUCCESS(p->base.result);
|
else
|
ret = true;
|
|
hgsmi_buffer_free(ctx, p);
|
|
return ret;
|
}
|
|
bool vbva_enable(struct vbva_buf_ctx *vbva_ctx, struct gen_pool *ctx,
|
struct vbva_buffer *vbva, s32 screen)
|
{
|
bool ret = false;
|
|
memset(vbva, 0, sizeof(*vbva));
|
vbva->partial_write_tresh = 256;
|
vbva->data_len = vbva_ctx->buffer_length - sizeof(struct vbva_buffer);
|
vbva_ctx->vbva = vbva;
|
|
ret = vbva_inform_host(vbva_ctx, ctx, screen, true);
|
if (!ret)
|
vbva_disable(vbva_ctx, ctx, screen);
|
|
return ret;
|
}
|
|
void vbva_disable(struct vbva_buf_ctx *vbva_ctx, struct gen_pool *ctx,
|
s32 screen)
|
{
|
vbva_ctx->buffer_overflow = false;
|
vbva_ctx->record = NULL;
|
vbva_ctx->vbva = NULL;
|
|
vbva_inform_host(vbva_ctx, ctx, screen, false);
|
}
|
|
bool vbva_buffer_begin_update(struct vbva_buf_ctx *vbva_ctx,
|
struct gen_pool *ctx)
|
{
|
struct vbva_record *record;
|
u32 next;
|
|
if (!vbva_ctx->vbva ||
|
!(vbva_ctx->vbva->host_flags.host_events & VBVA_F_MODE_ENABLED))
|
return false;
|
|
WARN_ON(vbva_ctx->buffer_overflow || vbva_ctx->record);
|
|
next = (vbva_ctx->vbva->record_free_index + 1) % VBVA_MAX_RECORDS;
|
|
/* Flush if all slots in the records queue are used */
|
if (next == vbva_ctx->vbva->record_first_index)
|
vbva_buffer_flush(ctx);
|
|
/* If even after flush there is no place then fail the request */
|
if (next == vbva_ctx->vbva->record_first_index)
|
return false;
|
|
record = &vbva_ctx->vbva->records[vbva_ctx->vbva->record_free_index];
|
record->len_and_flags = VBVA_F_RECORD_PARTIAL;
|
vbva_ctx->vbva->record_free_index = next;
|
/* Remember which record we are using. */
|
vbva_ctx->record = record;
|
|
return true;
|
}
|
|
void vbva_buffer_end_update(struct vbva_buf_ctx *vbva_ctx)
|
{
|
struct vbva_record *record = vbva_ctx->record;
|
|
WARN_ON(!vbva_ctx->vbva || !record ||
|
!(record->len_and_flags & VBVA_F_RECORD_PARTIAL));
|
|
/* Mark the record completed. */
|
record->len_and_flags &= ~VBVA_F_RECORD_PARTIAL;
|
|
vbva_ctx->buffer_overflow = false;
|
vbva_ctx->record = NULL;
|
}
|
|
void vbva_setup_buffer_context(struct vbva_buf_ctx *vbva_ctx,
|
u32 buffer_offset, u32 buffer_length)
|
{
|
vbva_ctx->buffer_offset = buffer_offset;
|
vbva_ctx->buffer_length = buffer_length;
|
}
|
