/*
 * 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;
}