#include <palacios/vmm_dev.h>
#include <palacios/vmm_dev_mgr.h>
#include <palacios/vm_guest.h>
#include <palacios/vmm.h>

extern struct vmm_os_hooks *os_hooks;

#ifndef NULL
#define NULL 0
#endif

int dev_mgr_init(struct vmm_dev_mgr *mgr, struct guest_info *vm)
{
  mgr->vm=vm;
  mgr->dev_list=NULL;
  mgr->num_devices=0;
  return 0;
}


int dev_mgr_deinit(struct vmm_dev_mgr *mgr)
{
  int rc;

  while (mgr->dev_list) { 
    rc=dev_mgr_detach_device(mgr->vm,mgr->dev_list);
    if (rc) { 
      // Bad bad bad
    }
  }
  return 0;
}

int dev_mgr_attach_device(struct guest_info *vm, struct vm_device *device)
{
  struct vmm_dev_mgr *mgr= &(vm->dev_mgr);
  
  if (device->io_hooks || device->mem_hooks) { 
    return -1;
  }

  device->next = mgr->dev_list;
  device->prev = 0;
  if (device->next) { 
    device->next->prev = device;
  }
  mgr->dev_list = device;
  
  device->vm=vm;

  return 0;
}

int dev_mgr_detach_device(struct guest_info *vm, struct vm_device *device)
{
  if (device->prev==0) { 
    vm->dev_mgr.dev_list = device->next;
  } else {
    device->prev->next = device->next;
  }
  if (device->next) { 
    device->next->prev=device->prev;
  }
  
  // avoid interrupts here

  device->deinit_device(device);

  device->vm=NULL;
  return 0;
}


#define INSERT_FRONT(listhead,item)         \
  do {                                      \
    if (!(listhead)) {                      \
      (listhead)=(item);                    \
      (item)->prev=NULL;                    \
      (item)->next=NULL;                    \
    }  else {                               \
      (item)->prev=NULL;                    \
      (item)->next=(listhead);              \
      if ((listhead)->next) {               \
  	(listhead)->next->prev=(item);      \
      }                                     \
      (listhead)=(item);                    \
    }                                       \
  } while (0)

#define DELETE(listhead,item)               \
  do {                                      \
    if ((item)->prev) {                     \
      (item)->prev->next=(item)->next;      \
    } else {                                \
      (listhead)=(item)->next;              \
    }                                       \
    if ((item)->next) {                     \
      (item)->next->prev=(item)->prev;      \
    }                                       \
  } while (0)
    

   

int dev_mgr_hook_io(struct guest_info    *vm,
		    struct vm_device   *device,
		    ushort_t            portno,
		    enum access_control control,
		    enum access_type    atype)
{
  struct vm_device_io_hook *hook = os_hooks->malloc(sizeof(struct vm_device_io_hook));
  
  if (!hook) { 
    return -1;
  }

  int (*read)(ushort_t, void *, uint_t, void *) = NULL;
  int (*write)(ushort_t, void *, uint_t, void *) = NULL;

  switch (control) { 
  case DEVICE_EMULATED:
    switch (atype) { 
    case DEVICE_READ:
      read = (int (*)(ushort_t, void *,uint_t, void *))  (device->read_io_port);
      break;
    case DEVICE_WRITE:
      write = (int (*)(ushort_t, void *, uint_t, void *)) (device->write_io_port);
      break;
    case DEVICE_READWRITE:
      read = (int (*)(ushort_t, void *, uint_t, void *)) (device->read_io_port);
      write = (int (*)(ushort_t, void *, uint_t, void *)) (device->write_io_port);
      break;
    }
    break;
  case DEVICE_PASSTHROUGH:
    read=write=NULL;
    break;
  }
    
  hook_io_port(&(vm->io_map), 
	       portno, 
	       read,
	       write,
	       device);

  hook->control=control;
  hook->atype=atype;
  hook->guest_port = portno;
  
  INSERT_FRONT(device->io_hooks,hook);
  
  return 0;
}


int dev_mgr_unhook_io(struct guest_info    *vm,
		      struct vm_device   *device,
		      ushort_t            portno)
{
  struct vm_device_io_hook *hook = device->io_hooks;

  while (hook) { 
    if (hook->guest_port==portno) { 
      DELETE(device->io_hooks,hook);
      break;
    }
  }

  if (!hook) { 
    // Very bad - unhooking something that doesn't exist!
    return -1;
  }

  return unhook_io_port(&(vm->io_map),
			portno);
}



int dev_mgr_hook_mem(struct guest_info    *vm,
		     struct vm_device   *device,
		     void               *guest_physical_address_start,
		     void               *guest_physical_address_end,
		     enum access_control control,
		     enum access_type    atype)
{

  struct vm_device_mem_hook *hook = os_hooks->malloc(sizeof(struct vm_device_mem_hook));
  
  if (!hook) { 
    return -1;
  }

  int (*read)(ushort_t, void *, uint_t, void *) = NULL;
  int (*write)(ushort_t, void *, uint_t, void *) = NULL;

  switch (control) { 
  case DEVICE_EMULATED:
    switch (atype) { 
    case DEVICE_READ:
      read = (int (*)(ushort_t, void *, uint_t, void *))(device->read_mapped_memory);
      break;
    case DEVICE_WRITE:
      write = (int (*)(ushort_t, void *, uint_t, void *))(device->write_mapped_memory);
      break;
    case DEVICE_READWRITE:
      read = (int (*)(ushort_t, void *, uint_t, void *))(device->read_mapped_memory);
      write = (int (*)(ushort_t, void *, uint_t, void *))(device->write_mapped_memory);
      break;
    }
    break;
  case DEVICE_PASSTHROUGH:
    read=write=NULL;
    break;
  }
    

  /* not implemented yet
  hook_memory(vm->mem_map, 
	      guest_physical_address_start, 
	      guest_physical_address_end, 
	      read,
	      write,
	      device);

  */

  return -1;   // remove when hook_memory works

  hook->control=control;
  hook->atype=atype;
  hook->guest_physical_start = guest_physical_address_start;
  hook->guest_physical_end = guest_physical_address_end;

  
  INSERT_FRONT(device->mem_hooks,hook);

  return 0;
  
}


int dev_mgr_unhook_mem(struct guest_info    *vm,
		       struct vm_device   *device,
		       void               *guest_physical_start,
		       void               *guest_physical_end) 
{
  struct vm_device_mem_hook *hook = device->mem_hooks;

  while (hook) { 
    if (hook->guest_physical_start==guest_physical_start &&
	hook->guest_physical_end==guest_physical_end) {
      DELETE(device->mem_hooks,hook);
      break;
    }
  }

  if (!hook) { 
    // Very bad - unhooking something that doesn't exist!
    return -1;
  }


  /* not implemented yet
  return unhook_mem_port(vm->mem_map,
			 guest_physical_start,
		         guest_physical_end) ;

  */
  return -1;
}


int dev_mgr_unhook_device(struct guest_info  *vm,
			  struct vm_device *device)
{
  struct vm_device_io_hook *iohook=device->io_hooks;
  struct vm_device_mem_hook *memhook=device->mem_hooks;

  while (iohook) { 
    if (dev_mgr_unhook_io(vm,device,iohook->guest_port)) { 
      return -1;
    }
  }

  while (memhook) { 
    if (dev_mgr_unhook_mem(vm,device,memhook->guest_physical_start, memhook->guest_physical_end)) {
      return -1;
    }
  }

  return 0;
}