/*
 * This file is part of the Palacios Virtual Machine Monitor developed
 * by the V3VEE Project with funding from the United States National 
 * Science Foundation and the Department of Energy.  
 *
 * The V3VEE Project is a joint project between Northwestern University
 * and the University of New Mexico.  You can find out more at 
 * http://www.v3vee.org
 *
 * Copyright (c) 2013, Peter Dinda <pdinda@northwestern.edu> 
 * Copyright (c) 2013, The V3VEE Project <http://www.v3vee.org> 
 * All rights reserved.
 *
 * Author: Peter Dinda <pdinda@northwestern.edu>
 *
 * This is free software.  You are permitted to use,
 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
 */

#include <devices/pci.h>
#include <palacios/vmm.h>
#include <palacios/vmm_types.h>
#include <palacios/vmm_io.h>
#include <palacios/vmm_debug.h>
#include <palacios/vm_guest_mem.h>
#include <palacios/vmm_sprintf.h>
#include <palacios/vmm_paging.h>
#include <interfaces/vmm_graphics_console.h>


#ifndef V3_CONFIG_DEBUG_PARAGRAPH
#undef PrintDebug
#define PrintDebug(fmts, args...)
#endif

/*
  A paravirtualized graphics device is represented in a configuration file as:

  <device class="PARAGRAPH" id="pgraph">
     <bus>pci0</bus>
     <mode>mem|gcons_mem|gcons_direct</mode>
  </device>

   
  The purpose of this device is to project a graphics console
  to the guest as a PCI device with a single BAR.  The BAR maps
  the memory of the frame buffer.

  The mode spec means the following:
     mem = create a backing memory within the device  (dummy device)
     gcons_mem = like mem, but render to graphics console (memcpy)
     gcons_direct = use the graphics console as the memory

  the default mode is mem.

*/


#define VENDOR 0xf00f    
#define DEVICE 0xd00f   

#define MAXX   1024
#define MAXY   1024
#define MAXBPP    4


#define MAX_REGION_SIZE (MAXX*MAXY*MAXBPP)

#define DEFAULT_REGION_ADDR 0x80000000 // Right at 2 GB



struct paragraph_state {
  enum {MEM, GCONS_MEM, GCONS_DIRECT} mode;
  //  v3_lock_t          lock;      // my lock
  struct v3_vm_info *vm;        // my VM
  struct vm_device  *pci_bus;   // my PCI bus
  struct vm_device  *dev;       // me as a registered device
  struct pci_device *pci_dev;   // me as a registered PCI device

  void              *my_paddr;  // me as mapped into the guest (page aligned GPA)
  uint64_t           my_size_pages;   // mapped region in pages

  // If the graphics console is used, these store it and
  // the frame buffer spec it is using
  struct v3_frame_buffer_spec  target_spec;
  v3_graphics_console_t        host_cons;
  void                        *host_fb_vaddr;

  // If the local memory is used, this stores it and its
  // size
  void              *mem_paddr;     // my memory address, paddr
  void              *mem_vaddr;    // my memory address, vaddr
  uint64_t           mem_size;     // my memory size in bytes
};

static uint64_t ceil_pages(uint64_t size)
{
  return (size / PAGE_SIZE) + !!(size % PAGE_SIZE);
}

static uint64_t next_pow2(uint64_t size)
{
  uint64_t test;

  for (test=1; test < size; test<<=1) {}

  return test;
}


static int pci_bar_init(int bar_num, uint32_t * dst, void * private_data) 
{
    struct paragraph_state * state = (struct paragraph_state *)private_data;

    // I am going to show up as a PCI_BAR_MEM32 at my_paddr 
    // and going for my_size_pages pages and not prefetchable


    PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Bar init %d 0x%x\n",bar_num, *dst);

    if (bar_num!=0) {
      PrintError(VM_NONE, VCORE_NONE, "paragraph: Strange - Bar Init for bar %d - ignored\n",bar_num);
      return 0;
    }

    if (state->mode==MEM || state->mode==GCONS_MEM) { 
      PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Adding shadow memory for 0x%p to 0x%p -> 0x%p\n", (void*)(state->my_paddr), (void*)(state->my_paddr+state->my_size_pages*PAGE_SIZE-1), state->mem_paddr);

      if (v3_add_shadow_mem(state->vm, V3_MEM_CORE_ANY,
			    (addr_t)(state->my_paddr), 
			    (addr_t)(state->my_paddr+state->my_size_pages*PAGE_SIZE-1), 
			    (addr_t) (state->mem_paddr))) {
	PrintError(VM_NONE, VCORE_NONE, "paragraph: Cannot add shadow memory for staging\n");
	return -1;
      }
    } else if (state->mode==GCONS_DIRECT) { 
      PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Adding shadow memory for 0x%p to 0x%p -> 0x%p\n", (void*)(state->my_paddr), (void*)(state->my_paddr+state->my_size_pages*PAGE_SIZE-1), (void*)V3_PAddr(state->host_fb_vaddr));
      // Note the physical contiguous assumption here.... 
      if (v3_add_shadow_mem(state->vm, V3_MEM_CORE_ANY,
			    (addr_t)(state->my_paddr), 
			    (addr_t)(state->my_paddr+state->my_size_pages*PAGE_SIZE-1), 
			    (addr_t)(V3_PAddr(state->host_fb_vaddr)))) {
	PrintError(VM_NONE, VCORE_NONE, "paragraph: Cannot add shadow memory for host fb\n");
	return -1;
      }
    }
    
    *dst = PCI_MEM32_BAR_VAL((addr_t)(state->my_paddr), 0);

    PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Bar init done %d is now 0x%x\n",bar_num, *dst);
    
    return 0;
}
	
static int pci_bar_write(int bar_num, uint32_t * src, void * private_data) 
{
    struct paragraph_state * state = (struct paragraph_state *)private_data;
    struct v3_mem_region *old_reg;

    PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Bar write %d 0x%x\n",bar_num, *src);

    if (*src==(uint32_t)0xffffffff) {
      PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Bar write is a size request - complying\n");
      *src = ~(state->my_size_pages*PAGE_SIZE-1);
      PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Returning size mask as %x\n",*src);
      return 0;
    }

    // This whacky cast should be ok - my_paddr will be <2^32 since this is a mem32 bar
    if (*src==(uint32_t)(uint64_t)(state->my_paddr)) { 
      PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Bar write maps to currently mapped address - done.\n");
      return 0;
    } 

    PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Bar write is a remapping\n");

    if (!(old_reg=v3_get_mem_region(state->vm, V3_MEM_CORE_ANY, (addr_t)(state->my_paddr)))) {
      PrintError(VM_NONE,VCORE_NONE, "paragraph: cannot find old region in bar write...\n");
      return -1;
    }

    PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Removing old region at 0x%p\n", (void*)(state->my_paddr));

    v3_delete_mem_region(state->vm, old_reg);

    state->my_paddr = (void*)(*src & ~(state->my_size_pages*PAGE_SIZE - 1));

    *src = PCI_MEM32_BAR_VAL((addr_t)(state->my_paddr), 0);

    PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Moving paragraph to: start=0x%p, size=%llu\n",
	       state->my_paddr, state->my_size_pages*PAGE_SIZE);


    if (state->mode==MEM || state->mode==GCONS_MEM) { 
      PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Adding shadow memory for 0x%p to 0x%p -> 0x%p\n", (void*)(state->my_paddr), (void*)(state->my_paddr+state->my_size_pages*PAGE_SIZE-1), state->mem_paddr);
      if (v3_add_shadow_mem(state->vm, V3_MEM_CORE_ANY,
			    (addr_t)(state->my_paddr),
			    (addr_t)(state->my_paddr+state->my_size_pages*PAGE_SIZE-1),
			    (addr_t) (state->mem_paddr))) {
	PrintError(VM_NONE, VCORE_NONE, "paragraph: Cannot add shadow memory for staging\n");
	return -1;
      }
    } else if (state->mode==GCONS_DIRECT) { 
      // Note the physical contiguous assumption here.... 
      PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Adding shadow memory for 0x%p to 0x%p -> 0x%p\n", (void*)(state->my_paddr), (void*)(state->my_paddr+state->my_size_pages*PAGE_SIZE-1), (void*)V3_PAddr(state->host_fb_vaddr));
      if (v3_add_shadow_mem(state->vm, V3_MEM_CORE_ANY,
			    (addr_t)(state->my_paddr),
			    (addr_t)(state->my_paddr+state->my_size_pages*PAGE_SIZE-1),
			    (addr_t)(V3_PAddr(state->host_fb_vaddr)))) {
	PrintError(VM_NONE, VCORE_NONE, "paragraph: Cannot add shadow memory for host fb\n");
	return -1;
      }
    }

    PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Bar write done %d 0x%x\n",bar_num, *src);

    return 0;
}

      
    


static int register_dev(struct paragraph_state *state)  
{
  int i;
  struct v3_pci_bar bars[6];
  uint64_t target_size;
  
  if (!(state->pci_bus)) { 
    PrintError(state->vm, VCORE_NONE, "paragraph: no pci bus!\n");
    return -1;
  }
  
  memset(bars,0,sizeof(struct v3_pci_bar)*6);

  for (i = 0; i < 6; i++) {
    bars[i].type = PCI_BAR_NONE;
  }

  // I will map my memory as a single MEM32 bar

  switch (state->mode) { 
  case MEM:
  case GCONS_MEM:
    target_size = state->mem_size;
    break;
  case GCONS_DIRECT:
    target_size = state->target_spec.height*state->target_spec.width*state->target_spec.bytes_per_pixel;
    break;
  default:
    PrintError(state->vm, VCORE_NONE, "paragraph: Unknown mode\n");
    return -1;
  }
  
  if (target_size%PAGE_SIZE) { 
    PrintError(VM_NONE, VCORE_NONE, "paragraph: strange, target_size is not an integral number of pages\n");
  }
  
  if (target_size != next_pow2(target_size)) { 
    PrintError(VM_NONE, VCORE_NONE, "paragraph: strange, target_size is not a power of two\n");
  }

  target_size = next_pow2(target_size);

  target_size /= PAGE_SIZE;  // floor(target_size/page_size)

  state->my_paddr = (void*)DEFAULT_REGION_ADDR;
  state->my_size_pages = target_size;

  PrintDebug(VM_NONE, VCORE_NONE, "paragraph: Requesting passthrough bar at %p (%llu pages)\n", state->my_paddr, state->my_size_pages);

  bars[0].type = PCI_BAR_PASSTHROUGH;
  bars[0].private_data = state;
  bars[0].bar_init = pci_bar_init;
  bars[0].bar_write = pci_bar_write;

  state->pci_dev =
    v3_pci_register_device(state->pci_bus, // my bus interace
			   PCI_STD_DEVICE, // I'm a typical device
			   0,              // put me in bus zero
			   -1,             // put me in any slot you want
			   0,              // I am function 0 in that slot
			   "PARAGRAPH",    // My name 
			   bars,           // My bars
			   NULL,           // I don't care about config writes
			   NULL,           // I don't care about config reads
			   NULL,           // I don't care about cmd updates
			   NULL,           // I don't care about rom updates
			   state);         // this is my internal state


  if (!(state->pci_dev)) { 
    PrintError(state->vm, VCORE_NONE, "paragraph: Could not register PCI Device\n");
    return -1;
  }

  // Now lets set up my configuration space
  // to identify as the kind of pci device I am
	
  state->pci_dev->config_header.vendor_id = VENDOR;
  state->pci_dev->config_header.device_id = DEVICE;

  return 0;
}


static int paragraph_free_internal(struct paragraph_state *state)
{
  if (state->host_cons) { 
    v3_graphics_console_close(state->host_cons);
  }

  if (state->mem_paddr) { 
    V3_FreePages(state->mem_paddr,ceil_pages(state->mem_size));
  }

  V3_Free(state);

  return 0;
}

static int paragraph_free(void * private_data) 
{
    struct paragraph_state *state = (struct paragraph_state *)private_data;
    return paragraph_free_internal(state);
}


static int render_callback(v3_graphics_console_t cons,
			   void *priv)
{
  struct paragraph_state *state = (struct paragraph_state *) priv;
  
  PrintDebug(VM_NONE, VCORE_NONE, "paragraph: render due to callback\n");

  switch (state->mode) {
  case MEM:
    PrintError(state->vm, VCORE_NONE, "paragraph: Huh?  render callback when in mem mode?\n");
    return -1;
    break;
  case GCONS_MEM: {
    PrintDebug(state->vm, VCORE_NONE, "paragraph: render callback GCONS_MEM\n");

    void *fb = v3_graphics_console_get_frame_buffer_data_rw(state->host_cons,&(state->target_spec));
    uint64_t target_size = state->target_spec.height*state->target_spec.width*state->target_spec.bytes_per_pixel;
    
    // must be smaller than the memory we have allocated
    target_size = target_size<state->mem_size ? target_size : state->mem_size;
    
    PrintDebug(state->vm, VCORE_NONE, "paragraph: render - copying %llu bytes from our vaddr 0x%p to fb vaddr 0x%p\n", target_size, state->mem_vaddr, fb);

    
    memcpy(fb,state->mem_vaddr,target_size);

    v3_graphics_console_release_frame_buffer_data_rw(state->host_cons);
    
    return 0;
  }					    
    break;
  case GCONS_DIRECT:
    PrintDebug(state->vm, VCORE_NONE, "paragraph: render callback GCONS_DIRECT\n");
    // nothing to do;
    return 0;
    break;
  default:
    PrintError(state->vm, VCORE_NONE, "paragraph: Huh?  render callback when in unknown mode\n");
    return -1;
    break;
  }

  return 0;
}

static int update_callback(v3_graphics_console_t cons,
			   void *priv)
{
  // Yes, Virginia, there is an update clause
  return 1;
}


static struct v3_device_ops dev_ops = {
    .free = paragraph_free,
};




static int paragraph_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) 
{
  struct vm_device         *bus;
  struct paragraph_state  *state;
  char *id;
  char *bus_id;
  char *mode;

  
  if (!(id = v3_cfg_val(cfg,"id"))) {
    PrintError(vm, VCORE_NONE, "paragraph: gnothi seauton!\n");  
    return -1;
  }
  
  if (!(bus_id = v3_cfg_val(cfg,"bus"))) { 
    PrintError(vm, VCORE_NONE, "paragraph: failed because there is no pci bus named\n");
    return -1;
  }
  
  if (!(bus = v3_find_dev(vm,bus_id))) { 
    PrintError(vm, VCORE_NONE, "paragraph: failed because there is no pci bus given\n");
    return -1;
  }
  
  if (!bus) { 
    PrintError(vm, VCORE_NONE, "paragraph: failed because there is no bus named %s\n",bus_id);
    return -1;
  }
 
  state = (struct paragraph_state *) V3_Malloc(sizeof(struct paragraph_state));

  if (!state) {
    PrintError(vm, VCORE_NONE, "paragraph: cannot allocate state\n");
    return -1;
  }

  memset(state, 0, sizeof(struct paragraph_state));

  if (!(mode=v3_cfg_val(cfg,"mode"))) { 
    V3_Print(vm, VCORE_NONE, "paragraph: no mode given, assuming you mean mem\n");
    state->mode=MEM;
  } else {
    if (!strncasecmp(mode,"mem",3)) { 
      state->mode=MEM;
      V3_Print(state->vm, VCORE_NONE, "paragraph: mode set to mem\n");
    } else if (!strncasecmp(mode,"gcons_mem",9)) { 
      state->mode=GCONS_MEM;
      V3_Print(state->vm, VCORE_NONE, "paragraph: mode set to gcons_mem\n");
    } else if (!strncasecmp(mode,"gcons_direct",12)) { 
      state->mode=GCONS_DIRECT;
      V3_Print(state->vm, VCORE_NONE, "paragraph: mode set to gcons_direct\n");
    } else {
      PrintError(state->vm, VCORE_NONE, "paragraph: Unknown mode %s\n",mode);
      paragraph_free_internal(state);
      return -1;
    }
  }
						
  state->vm = vm;
  state->pci_bus = bus;

  if (state->mode==MEM || state->mode==GCONS_MEM) { 
    state->mem_size=MAXX*MAXY*MAXBPP;
    PrintDebug(vm, VCORE_NONE, "paragraph: allocating %llu bytes for local framebuffer\n", state->mem_size);
    state->mem_paddr = V3_AllocPages(ceil_pages(state->mem_size));
    if (!state->mem_paddr) { 
      PrintError(state->vm, VCORE_NONE, "paragraph: Cannot allocate memory for framebuffer\n");
      paragraph_free_internal(state);
      return -1;
    }
    // the following assumes virtual address continuity
    state->mem_vaddr = V3_VAddr(state->mem_paddr);
   
    PrintDebug(vm, VCORE_NONE, "paragraph: staging memory (state->mem) at paddr 0x%p and vaddr 0x%p size=%llu bytes (%llu pages)\n",
	       state->mem_paddr, state->mem_vaddr,
	       state->mem_size, ceil_pages(state->mem_size));
  }
  
  if (state->mode==GCONS_MEM || state->mode==GCONS_DIRECT) { 
    struct v3_frame_buffer_spec req;

    PrintDebug(vm, VCORE_NONE, "paragraph: enabling host frame buffer console (GRAPHICS_CONSOLE)\n");
    memset(&req,0,sizeof(struct v3_frame_buffer_spec));

    req.height=MAXY;
    req.width=MAXX;
    req.bytes_per_pixel=MAXBPP;
    req.bits_per_channel=8;
    req.red_offset=0;
    req.green_offset=1;
    req.blue_offset=2;
    
    state->host_cons = v3_graphics_console_open(vm,&req,&(state->target_spec));
    
    if (!state->host_cons) { 
      PrintError(vm, VCORE_NONE, "paragraph: unable to open host OS's graphics console\n");
      paragraph_free_internal(state);
      return -1;
    }
    
    if (memcmp(&req,&(state->target_spec),sizeof(req))) {
      PrintDebug(vm, VCORE_NONE, "paragraph: warning: target spec differs from requested spec\n");
      PrintDebug(vm, VCORE_NONE, "paragraph: request: %u by %u by %u with %u bpc and r,g,b at %u, %u, %u\n", req.width, req.height, req.bytes_per_pixel, req.bits_per_channel, req.red_offset, req.green_offset, req.blue_offset);
      PrintDebug(vm, VCORE_NONE, "paragraph: response: %u by %u by %u with %u bpc and r,g,b at %u, %u, %u\n", state->target_spec.width, state->target_spec.height, state->target_spec.bytes_per_pixel, state->target_spec.bits_per_channel, state->target_spec.red_offset, state->target_spec.green_offset, state->target_spec.blue_offset);
    }

    if (state->mode==GCONS_DIRECT) { 
      PrintDebug(state->vm, VCORE_NONE, "paragraph: grabbing host console address\n");
      state->host_fb_vaddr = v3_graphics_console_get_frame_buffer_data_rw(state->host_cons,&(state->target_spec));
      if (!state->host_fb_vaddr) { 
	PrintError(state->vm, VCORE_NONE, "paragraph: Unable to acquire host's framebuffer address\n");
	paragraph_free_internal(state);
	return -1;
      }
      v3_graphics_console_release_frame_buffer_data_rw(state->host_cons);
      // we now assume the host FB will not move...
    }

    if (v3_graphics_console_register_render_request(state->host_cons, render_callback, state)!=0) {      PrintError(vm, VCORE_NONE, "paragraph: cannot install render callback\n");
      paragraph_free_internal(state);
      return -1;
    }
    if (v3_graphics_console_register_update_inquire(state->host_cons, update_callback, state)!=0) {
      PrintError(vm, VCORE_NONE, "paragraph: cannot install update inquire callback\n");
      paragraph_free_internal(state);
      return -1;
    }
  }
  
  state->dev = v3_add_device(vm, id, &dev_ops, state);

  if (!(state->dev)) {
    PrintError(state->vm, VCORE_NONE, "paragraph: could not attach device %s\n", id);
    paragraph_free_internal(state);
    return -1;
  }

  if (register_dev(state) !=0 ) { 
    PrintError(state->vm, VCORE_NONE, "paragraph: could not set up device for pci\n");
    paragraph_free_internal(state);
    return -1;
  }

  V3_Print(state->vm, VCORE_NONE, "paragraph: added device id %s\n",id);

  return 0;
}

device_register("PARAGRAPH", paragraph_init)