/*
 * vNPlugDev (PCI Device)
 *
 * Authors:
 *
 * 	Alfredo Cardigliano <cardigliano@ntop.org>
 *
 * This work is licensed under the terms of the GNU GPL version 2. 
 *
 */

#include <sys/mman.h>
#include <sys/types.h>
#include <sys/eventfd.h>

#include "hw.h"
#include "pc.h"
#include "pci.h"
#include "msix.h"
#include "kvm.h"

#include "vnplug.h"
#include "vnplug-dev.h"

//#define VNPLUGDEV_DEBUG

#ifdef VNPLUGDEV_DEBUG
#define VNPLUGDEV_DEBUG_PRINTF(fmt, ...)	do {printf("[vNPlugDev] " fmt, ## __VA_ARGS__); } while (0)
#else
#define VNPLUGDEV_DEBUG_PRINTF(fmt, ...)
#endif

static uint32_t vnplug_device_id_counter = 0;

/* ******************************************************************************************* */

static void vnplug_dev_io_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
{
	VNPLUGDEV_DEBUG_PRINTF("io_writew: unhandled\n");
}

/* ******************************************************************************************* */

/* called when the guest writes to the registers region */
static void vnplug_dev_io_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
{
	struct vNPlugDev *s = opaque;

	addr &= 0xffc;

	VNPLUGDEV_DEBUG_PRINTF("io_writel: registers[" TARGET_FMT_plx "] = %u\n", addr, val);

	if (!((struct vNPlugDevClientInfo *) s->dev_client)->io_writel_handler)
		fprintf(stderr, "[vNPlugDev] io_writel: client handler undefined\n");
	else
		((struct vNPlugDevClientInfo *) s->dev_client)->io_writel_handler((struct vNPlugDevClientInfo *) s->dev_client, addr, val);
}

/* ******************************************************************************************* */

static void vnplug_dev_io_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
{
	VNPLUGDEV_DEBUG_PRINTF("io_writeb: unhandled\n");
}

/* ******************************************************************************************* */

static uint32_t vnplug_dev_io_readw(void *opaque, target_phys_addr_t addr)
{
	VNPLUGDEV_DEBUG_PRINTF("io_readw: unhandled\n");
	return 0;
}

/* ******************************************************************************************* */

/* called when the guest reads from the registers region */
static uint32_t vnplug_dev_io_readl(void *opaque, target_phys_addr_t addr)
{
	struct vNPlugDev *s = opaque;
	uint32_t ret = 0;

	addr &= 0xffc;

	if (addr == VNPLUGDEV_REG_OFF_ID){
		ret = s->dev_id;
		goto return_ret;
	}

	if ( addr >= VNPLUGDEV_REG_OFF_BASE_MM_SIZE && 
	     addr <  VNPLUGDEV_REG_OFF_BASE_MM_SIZE + VNPLUGDEV_MAX_MM_BARS * sizeof(uint32_t) && 
	   !(addr &  0x3)){
		ret = s->mm_dev_size[(addr-VNPLUGDEV_REG_OFF_BASE_MM_SIZE)>>2];
		goto return_ret;
	}

	if (((struct vNPlugDevClientInfo *) s->dev_client)->io_readl_handler){
		ret = ((struct vNPlugDevClientInfo *) s->dev_client)->io_readl_handler((struct vNPlugDevClientInfo *) s->dev_client, addr);
		goto return_ret;
	}

	fprintf(stderr, "[vNPlugDev] io_readl: client handler undefined\n");
	ret = 0;

return_ret:
	VNPLUGDEV_DEBUG_PRINTF("io_readl: registers[" TARGET_FMT_plx "] value=%u\n", addr, ret);
	return ret;
}

/* ******************************************************************************************* */

static uint32_t vnplug_dev_io_readb(void *opaque, target_phys_addr_t addr)
{
	VNPLUGDEV_DEBUG_PRINTF("io_readb: unhandled, returning 0\n");
	return 0;
}

/* ******************************************************************************************* */

static CPUReadMemoryFunc * const vnplug_dev_mmio_read[3] = {
	vnplug_dev_io_readb,
	vnplug_dev_io_readw,
	vnplug_dev_io_readl,
};

static CPUWriteMemoryFunc * const vnplug_dev_mmio_write[3] = {
	vnplug_dev_io_writeb,
	vnplug_dev_io_writew,
	vnplug_dev_io_writel,
};

/* ******************************************************************************************* */

/* to setup irqfds use on=1, to unset them use on=0 */
static int setup_irqfds(struct vNPlugDev *s, int on) {
	int i, err = 0;

	for (i = 0; i < s->vectors; i++)
	/* irqfd support: interrupts are injected when a signal on an eventfd occurs */
	if ( ( err = kvm_set_irqfd(s->dev.msix_irq_entries[i].gsi, s->backend_eventfds[i], on) ) < 0)
			fprintf(stderr, "[vNPlugDev] irqfd warning (err=%d). Not available, or already set?\n", err);
	else {
		VNPLUGDEV_DEBUG_PRINTF("irqfd on=%d for host event %d\n", on, i);
	}

	return err;
}


/* ******************************************************************************************* */

/* to setup ioeventfds use on=1, to unset them use on=0 */
static int setup_ioeventfds(struct vNPlugDev *s, int on) {
	int i, err = 0;

	for (i = 0; i < s->guest_events_n; i++)
	/*  setting ioeventfd support to raise an event when a write on 
	 *  mmio_pci_addr + VNPLUGDEV_REG_OFF_DOORBELL occurs, passing i as the value to match
	 *  (the relative io_writel handler will not be called) */
	if ( (err = kvm_set_ioeventfd_mmio_long(s->guest_eventfds[i], s->mmio_pci_addr + VNPLUGDEV_REG_OFF_DOORBELL, i, on)) < 0)
			fprintf(stderr, "[vNPlugDev] ioeventfd warning (err=%d). Not available, or already set?\n", err);
	else {
		VNPLUGDEV_DEBUG_PRINTF("ioeventfd on=%d for guest event %d\n", on, i);
	}

	return err;
}

/* ******************************************************************************************* */

static void vnplug_dev_reset(DeviceState *d)
{
	//struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev.qdev, d);
	return;
}

/* ******************************************************************************************* */

/* region 2..5 (mmap-ed memory) map handler */
static void vnplug_dev_mm_map(PCIDevice *pci_dev, int region_num, pcibus_t addr, pcibus_t size, int type)
{
	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev, pci_dev);

	// BAR0=registers, BAR1=MSI, BAR2..5=mm
	int index = region_num - VNPLUGDEV_BASE_MM_BAR;

	VNPLUGDEV_DEBUG_PRINTF("registering shared memory %d at guest pci addr=%" FMT_PCIBUS ", guest hw addr=%" PRIu64 ", with size=%" FMT_PCIBUS "\n", index, addr, s->mm_dev_offset[index], size);

	if (index < 0 || index > VNPLUGDEV_MAX_MM_BARS-1) {
		fprintf(stderr, "[vNPlugDev] mm bar index out of range: %d\n", index);
		return;
	}

	s->mm_pci_addr[index] = addr;

	if (s->mm_dev_offset[index] > 0) 
		cpu_register_physical_memory(s->mm_pci_addr[index], s->mm_dev_size[index], s->mm_dev_offset[index]);
}

/* ******************************************************************************************* */

static void vnplug_dev_mmio_map(PCIDevice *pci_dev, int region_num, pcibus_t addr, pcibus_t size, int type)
{
	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev, pci_dev);

	VNPLUGDEV_DEBUG_PRINTF("registering mmio memory\n");

	s->mmio_pci_addr = addr;
	cpu_register_physical_memory(addr + 0, VNPLUGDEV_REG_BAR_SIZE, s->mmio_dev_offset);

	setup_ioeventfds(s, 1);
}

/* ******************************************************************************************* */

static void vnplug_dev_setup_msi(struct vNPlugDev * s) 
{
	int i;

	if (msix_init(&s->dev, s->vectors, 1, 0) == 0) {
		/* MSI region */
		pci_register_bar(&s->dev, 1, msix_bar_size(&s->dev), PCI_BASE_ADDRESS_SPACE_MEMORY, msix_mmio_map);

		VNPLUGDEV_DEBUG_PRINTF("msix initialized (%d vectors)\n", s->vectors);
	} else {
		VNPLUGDEV_DEBUG_PRINTF("msix initialization failed\n");
		exit(1);
	}

	for (i = 0; i < s->vectors; i++) {
		msix_vector_use(&s->dev, i);
	}
}

/* ******************************************************************************************* */

static const VMStateDescription vmstate_vnplug_device = {
	.name = "vnplug-dev",
	.fields = (VMStateField []) {
		VMSTATE_END_OF_LIST()
	}
};

/* ******************************************************************************************* */

static int pci_vnplug_dev_init(PCIDevice *dev)
{
	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev, dev);
	uint8_t *pci_conf;
	int i;
	char ram_block_name[32];

	struct vNPlugDevClientInfo *client = (struct vNPlugDevClientInfo *) s->dev_client;
	if (!client){
		fprintf(stderr, "[vNPlugDev] undefined vNPlug-dev client info\n"); 
		exit(-1);
	}

	s->dev_id = vnplug_device_id_counter++;

	vmstate_register(&dev->qdev, s->dev_id, &vmstate_vnplug_device, s);
	register_device_unmigratable(&dev->qdev, vmstate_vnplug_device.name, s);

	pci_conf = s->dev.config;
	pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_SILICOM);
	pci_conf[0x02] = (PCI_DEVICE_ID_VNPLUG_DEV) & 0xff;
	pci_conf[0x03] = (PCI_DEVICE_ID_VNPLUG_DEV >> 8) & 0xff;
	pci_conf[PCI_COMMAND] = PCI_COMMAND_IO | PCI_COMMAND_MEMORY;
	pci_config_set_class(pci_conf, PCI_CLASS_MEMORY_RAM);
	pci_conf[PCI_HEADER_TYPE] = PCI_HEADER_TYPE_NORMAL;
	pci_config_set_interrupt_pin(pci_conf, 1);

	for (i=0; i<VNPLUGDEV_MAX_MM_BARS; i++){
		s->mm_pci_addr[i] = 0;
		s->mm_dev_offset [i] = 0;
	}
	s->mm_dev_size   [0] = s->mm_dev_size_0;
	s->mm_dev_vma_ptr[0] = s->mm_dev_vma_ptr_0;
	s->mm_dev_size   [1] = s->mm_dev_size_1;
	s->mm_dev_vma_ptr[1] = s->mm_dev_vma_ptr_1;
	s->mm_dev_size   [2] = s->mm_dev_size_2;
	s->mm_dev_vma_ptr[2] = s->mm_dev_vma_ptr_2;
	s->mm_dev_size   [3] = s->mm_dev_size_3;
	s->mm_dev_vma_ptr[3] = s->mm_dev_vma_ptr_3;

	VNPLUGDEV_DEBUG_PRINTF("setting mmio read/write handlers for device %u [ passing opaque (struct vNPlugDev *) = %p ]\n", s->dev_id, s);

	s->mmio_dev_offset = cpu_register_io_memory(vnplug_dev_mmio_read, vnplug_dev_mmio_write, s, DEVICE_NATIVE_ENDIAN);

	/* region for registers */
	pci_register_bar(&s->dev, 0, VNPLUGDEV_REG_BAR_SIZE, PCI_BASE_ADDRESS_SPACE_MEMORY, vnplug_dev_mmio_map);

	/* setup host to guest events via MSI */

	s->vectors = s->backend_events_n;

	VNPLUGDEV_DEBUG_PRINTF("setting up %d MSI-X vectors\n", s->vectors);

	/* msi init & region for msi */
	vnplug_dev_setup_msi(s);
	
	VNPLUGDEV_DEBUG_PRINTF("setting up %d backend eventdfds\n", s->vectors);
	s->backend_eventfds	= qemu_mallocz(s->vectors * sizeof(int));
	for (i=0;i<s->vectors;i++){
		if ((s->backend_eventfds[i] = eventfd(0, 0)) < 0) {
			fprintf(stderr, "[vNPlugDev] failed to create eventfd\n");
			exit(-1);
		}
	}
	
	VNPLUGDEV_DEBUG_PRINTF("setting up the irqfd support\n");
	
	setup_irqfds(s, 1);

	VNPLUGDEV_DEBUG_PRINTF("setting up %d guest eventdfds\n", s->guest_events_n);
	s->guest_eventfds	= qemu_mallocz(s->guest_events_n * sizeof(int));
	for (i=0;i<s->guest_events_n;i++){
		if ((s->guest_eventfds[i] = eventfd(0, 0)) < 0) {
			fprintf(stderr, "[vNPlugDev] failed to create eventfd\n");
		exit(-1);
	}
	}

	for (i=0; i<VNPLUGDEV_MAX_MM_BARS; i++)
		if (s->mm_dev_size[i] && s->mm_dev_vma_ptr[i]){

			/* Checking size (it must be power of two) */
			if ((s->mm_dev_size[i] & (s->mm_dev_size[i] - 1)) != 0){
				fprintf(stderr, "[vNPlugDev] device memory %d size is not power of 2\n", i); 
				exit(-1);
			}

			/* ram block with mmapped memory to share */
			snprintf(ram_block_name, 32, "vnplug-dev-%u.bar%d", s->dev_id, VNPLUGDEV_BASE_MM_BAR+i);
			s->mm_dev_offset[i] = qemu_ram_alloc_from_ptr(&s->dev.qdev, ram_block_name, s->mm_dev_size[i], (void *) s->mm_dev_vma_ptr[i]);

			VNPLUGDEV_DEBUG_PRINTF("ram block %d allocated from ptr %" PRIu64 " and size %u at guest hw addr %" PRIu64 "\n", i, s->mm_dev_vma_ptr[i], s->mm_dev_size[i], s->mm_dev_offset[i]);

			/* region for shared memory */
			pci_register_bar(&s->dev, VNPLUGDEV_BASE_MM_BAR+i, s->mm_dev_size[i], PCI_BASE_ADDRESS_SPACE_MEMORY, vnplug_dev_mm_map);
		}

	if (!s->dev_client || !(client->set_init_data_handler)){
		fprintf(stderr, "[vNPlugDev] client or client handlers undefined\n");
		exit(-1);
	}

	/* setting dev id and eventfds on client */
	client->set_init_data_handler(client, s->dev_id, s->backend_events_n, s->backend_eventfds, s->guest_events_n, s->guest_eventfds);
  
	return 0;
}

/* ******************************************************************************************* */

static int pci_vnplug_dev_uninit(PCIDevice *dev)
{
	int i;
	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev, dev);
	struct vNPlugDevClientInfo *client = (struct vNPlugDevClientInfo *) s->dev_client;

	if (client && client->pre_unplug_handler)
		client->pre_unplug_handler(client);

	setup_irqfds(s, 0);

	setup_ioeventfds(s, 0);

	for (i=0; i<VNPLUGDEV_MAX_MM_BARS; i++)
		if (s->mm_dev_size[i] && s->mm_dev_vma_ptr[i]){
			if (s->mm_pci_addr[i]){
				cpu_register_physical_memory(s->mm_pci_addr[i], s->mm_dev_size[i], IO_MEM_UNASSIGNED);
				VNPLUGDEV_DEBUG_PRINTF("vnplug BAR%d unregistered\n", VNPLUGDEV_BASE_MM_BAR+i); 
			}
			if (s->mm_dev_offset[i]){
				qemu_ram_free_from_ptr(s->mm_dev_offset[i]);
				VNPLUGDEV_DEBUG_PRINTF("vnplug BAR%d unmapped\n", VNPLUGDEV_BASE_MM_BAR+i);
			}
		}

	cpu_unregister_io_memory(s->mmio_dev_offset);

	vmstate_unregister(&dev->qdev, &vmstate_vnplug_device, s);

	for (i = 0; i < s->vectors; i++)
		close(s->backend_eventfds[i]);

	for (i = 0; i < s->guest_events_n; i++) {
		close(s->guest_eventfds[i]);
	}

	qemu_free(s->backend_eventfds);
	qemu_free(s->guest_eventfds);

	msix_uninit(dev); 

	if (client && client->post_unplug_handler)
		client->post_unplug_handler(client);
 
	VNPLUGDEV_DEBUG_PRINTF("vnplug device uninitalization done\n");
	
	return 0;
}

/* ******************************************************************************************* */

static PCIDeviceInfo vnplug_dev_info = {
	.qdev.name  = "vnplug-dev",
	.qdev.size  = sizeof(struct vNPlugDev),
	.qdev.reset = vnplug_dev_reset,
	.init	   = pci_vnplug_dev_init,
	.exit	   = pci_vnplug_dev_uninit,
	.qdev.props = (Property[]) {
		DEFINE_PROP_UINT32("backend_events_n", struct vNPlugDev, backend_events_n, 1),
		DEFINE_PROP_UINT32("guest_events_n", struct vNPlugDev, guest_events_n, 1), 
		//generated in pci_vnplug_dev_init: DEFINE_PROP_UINT32("dev_id", struct vNPlugDev, dev_id, 0),

		DEFINE_PROP_UINT32("vma_size", struct vNPlugDev, mm_dev_size_0, 0),
		//ptrs changed to uint64: DEFINE_PROP_PTR("vma_ptr", struct vNPlugDev, mm_dev_vma_ptr),
		DEFINE_PROP_UINT64("vma_ptr",  struct vNPlugDev, mm_dev_vma_ptr_0, 0),

		DEFINE_PROP_UINT32("vma_size_1", struct vNPlugDev, mm_dev_size_1, 0),
		DEFINE_PROP_UINT64("vma_ptr_1",  struct vNPlugDev, mm_dev_vma_ptr_1, 0),

		DEFINE_PROP_UINT32("vma_size_2", struct vNPlugDev, mm_dev_size_2, 0),
		DEFINE_PROP_UINT64("vma_ptr_2",  struct vNPlugDev, mm_dev_vma_ptr_2, 0),

		DEFINE_PROP_UINT32("vma_size_3", struct vNPlugDev, mm_dev_size_3, 0),
		DEFINE_PROP_UINT64("vma_ptr_3",  struct vNPlugDev, mm_dev_vma_ptr_3, 0),

		DEFINE_PROP_UINT64("client_info_ptr", struct vNPlugDev, dev_client, 0),
		DEFINE_PROP_END_OF_LIST(),
	}
};

static void vnplug_dev_register_devices(void)
{
	pci_qdev_register(&vnplug_dev_info);
}

device_init(vnplug_dev_register_devices)