/*
 * VFIO PCI I/O Port & MMIO access
 *
 * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
 *     Author: Alex Williamson <alex.williamson@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Derived from original vfio:
 * Copyright 2010 Cisco Systems, Inc.  All rights reserved.
 * Author: Tom Lyon, pugs@cisco.com
 */

#include <linux/fs.h>
#include <linux/pci.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/vgaarb.h>

#include "vfio_pci_private.h"

/*
 * Read or write from an __iomem region (MMIO or I/O port) with an excluded
 * range which is inaccessible.  The excluded range drops writes and fills
 * reads with -1.  This is intended for handling MSI-X vector tables and
 * leftover space for ROM BARs.
 */
static ssize_t do_io_rw(void __iomem *io, char __user *buf,
                        loff_t off, size_t count, size_t x_start,
                        size_t x_end, bool iswrite)
{
        ssize_t done = 0;

        while (count) {
                size_t fillable, filled;

                if (off < x_start)
                        fillable = min(count, (size_t)(x_start - off));
                else if (off >= x_end)
                        fillable = count;
                else
                        fillable = 0;

                if (fillable >= 4 && !(off % 4)) {
                        __le32 val;

                        if (iswrite) {
                                if (copy_from_user(&val, buf, 4))
                                        return -EFAULT;

                                iowrite32(le32_to_cpu(val), io + off);
                        } else {
                                val = cpu_to_le32(ioread32(io + off));

                                if (copy_to_user(buf, &val, 4))
                                        return -EFAULT;
                        }

                        filled = 4;
                } else if (fillable >= 2 && !(off % 2)) {
                        __le16 val;

                        if (iswrite) {
                                if (copy_from_user(&val, buf, 2))
                                        return -EFAULT;

                                iowrite16(le16_to_cpu(val), io + off);
                        } else {
                                val = cpu_to_le16(ioread16(io + off));

                                if (copy_to_user(buf, &val, 2))
                                        return -EFAULT;
                        }

                        filled = 2;
                } else if (fillable) {
                        u8 val;

                        if (iswrite) {
                                if (copy_from_user(&val, buf, 1))
                                        return -EFAULT;

                                iowrite8(val, io + off);
                        } else {
                                val = ioread8(io + off);

                                if (copy_to_user(buf, &val, 1))
                                        return -EFAULT;
                        }

                        filled = 1;
                } else {
                        /* Fill reads with -1, drop writes */
                        filled = min(count, (size_t)(x_end - off));
                        if (!iswrite) {
                                u8 val = 0xFF;
                                size_t i;

                                for (i = 0; i < filled; i++)
                                        if (copy_to_user(buf + i, &val, 1))
                                                return -EFAULT;
                        }
                }

                count -= filled;
                done += filled;
                off += filled;
                buf += filled;
        }

        return done;
}

ssize_t vfio_pci_bar_rw(struct vfio_pci_device *vdev, char __user *buf,
                        size_t count, loff_t *ppos, bool iswrite)
{
        struct pci_dev *pdev = vdev->pdev;
        loff_t pos = *ppos & VFIO_PCI_OFFSET_MASK;
        int bar = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
        size_t x_start = 0, x_end = 0;
        resource_size_t end;
        void __iomem *io;
        ssize_t done;

        if (pci_resource_start(pdev, bar))
                end = pci_resource_len(pdev, bar);
        else if (bar == PCI_ROM_RESOURCE &&
                 pdev->resource[bar].flags & IORESOURCE_ROM_SHADOW)
                end = 0x20000;
        else
                return -EINVAL;

        if (pos >= end)
                return -EINVAL;

        count = min(count, (size_t)(end - pos));

        if (bar == PCI_ROM_RESOURCE) {
                /*
                 * The ROM can fill less space than the BAR, so we start the
                 * excluded range at the end of the actual ROM.  This makes
                 * filling large ROM BARs much faster.
                 */
                io = pci_map_rom(pdev, &x_start);
                if (!io)
                        return -ENOMEM;
                x_end = end;
        } else if (!vdev->barmap[bar]) {
                int ret;

                ret = pci_request_selected_regions(pdev, 1 << bar, "vfio");
                if (ret)
                        return ret;

                io = pci_iomap(pdev, bar, 0);
                if (!io) {
                        pci_release_selected_regions(pdev, 1 << bar);
                        return -ENOMEM;
                }

                vdev->barmap[bar] = io;
        } else
                io = vdev->barmap[bar];

        if (bar == vdev->msix_bar) {
                x_start = vdev->msix_offset;
                x_end = vdev->msix_offset + vdev->msix_size;
        }

        done = do_io_rw(io, buf, pos, count, x_start, x_end, iswrite);

        if (done >= 0)
                *ppos += done;

        if (bar == PCI_ROM_RESOURCE)
                pci_unmap_rom(pdev, io);

        return done;
}

ssize_t vfio_pci_vga_rw(struct vfio_pci_device *vdev, char __user *buf,
                               size_t count, loff_t *ppos, bool iswrite)
{
        int ret;
        loff_t off, pos = *ppos & VFIO_PCI_OFFSET_MASK;
        void __iomem *iomem = NULL;
        unsigned int rsrc;
        bool is_ioport;
        ssize_t done;

        if (!vdev->has_vga)
                return -EINVAL;

        switch (pos) {
        case 0xa0000 ... 0xbffff:
                count = min(count, (size_t)(0xc0000 - pos));
                iomem = ioremap_nocache(0xa0000, 0xbffff - 0xa0000 + 1);
                off = pos - 0xa0000;
                rsrc = VGA_RSRC_LEGACY_MEM;
                is_ioport = false;
                break;
        case 0x3b0 ... 0x3bb:
                count = min(count, (size_t)(0x3bc - pos));
                iomem = ioport_map(0x3b0, 0x3bb - 0x3b0 + 1);
                off = pos - 0x3b0;
                rsrc = VGA_RSRC_LEGACY_IO;
                is_ioport = true;
                break;
        case 0x3c0 ... 0x3df:
                count = min(count, (size_t)(0x3e0 - pos));
                iomem = ioport_map(0x3c0, 0x3df - 0x3c0 + 1);
                off = pos - 0x3c0;
                rsrc = VGA_RSRC_LEGACY_IO;
                is_ioport = true;
                break;
        default:
                return -EINVAL;
        }

        if (!iomem)
                return -ENOMEM;

        ret = vga_get_interruptible(vdev->pdev, rsrc);
        if (ret) {
                is_ioport ? ioport_unmap(iomem) : iounmap(iomem);
                return ret;
        }

        done = do_io_rw(iomem, buf, off, count, 0, 0, iswrite);

        vga_put(vdev->pdev, rsrc);

        is_ioport ? ioport_unmap(iomem) : iounmap(iomem);

        if (done >= 0)
                *ppos += done;

        return done;
}