/*
 * \brief  DDE iPXE wrappers to C++ backend
 * \author Sebastian Sumpf
 * \author Josef Soentgen
 * \date   2010-10-21
 */

/*
 * Copyright (C) 2010-2015 Genode Labs GmbH
 *
 * This file is part of the Genode OS framework, which is distributed
 * under the terms of the GNU General Public License version 2.
 */

/*
 * The build system picks up stdarg.h from iPXE instead of the one
 * provided by GCC. This header contains the FILE_LICENCE macro which
 * is defined by iPXE's compiler.h.
 */
#define FILE_LICENCE(x)

/* Genode includes */
#include <base/allocator_avl.h>
#include <base/env.h>
#include <base/printf.h>
#include <base/slab.h>
#include <base/sleep.h>
#include <dataspace/client.h>
#include <io_mem_session/connection.h>
#include <io_port_session/connection.h>
#include <irq_session/connection.h>
#include <os/server.h>
#include <pci_device/client.h>
#include <pci_session/connection.h>
#include <rm_session/connection.h>
#include <timer_session/connection.h>
#include <util/misc_math.h>
/* local includes */
#include <dde_support.h>


//using namespace Genode;


/****************
 ** Migriation **
 ****************/

static Server::Entrypoint *_ep;

extern "C" void dde_init(void *ep)
{
	_ep = (Server::Entrypoint*)ep;
}


/************
 ** printf **
 ************/

extern "C" void dde_vprintf(const char *fmt, va_list va) {
	Genode::vprintf(fmt, va); }


extern "C" void dde_printf(const char *fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	dde_vprintf(fmt, args);
	va_end(args);
}


/***********
 ** Timer **
 ***********/

extern "C" void dde_udelay(unsigned long usecs)
{
	/*
	 * This function is called only once during rdtsc calibration (usecs will be
	 * 10000, see dde.c 'udelay'. We do not use DDE timers here, since Genode's
	 * timer connection is the most precise one around.
	 */
	Timer::Connection timer;
	timer.usleep(usecs);
}


/***************************
 ** locking/synchronizing **
 ***************************/

/**
 * DDE iPXE mutual exclusion lock
 */
static Genode::Lock _ipxe_lock;

extern "C" void dde_lock_enter(void) { _ipxe_lock.lock(); }
extern "C" void dde_lock_leave(void) { _ipxe_lock.unlock(); }


extern "C" void dde_mdelay(unsigned long msecs)
{
	/*
	 * Using one static timer connection here is safe because
	 * this function is only called while initializing the device
	 * and only be the same thread.
	 */
	static Timer::Connection timer;
	timer.msleep(msecs);
}


/******************
 ** PCI handling **
 ******************/

struct Pci_driver
{
	enum {
		PCI_BASE_CLASS_NETWORK = 0x02,
		CLASS_MASK             = 0xff0000,
		CLASS_NETWORK          = PCI_BASE_CLASS_NETWORK << 16
	};

	Pci::Connection        _pci;
	Pci::Device_capability _cap;
	Pci::Device_capability _last_cap;

	struct Region
	{
		Genode::addr_t base;
		Genode::addr_t mapped_base;
	} _region;

	template <typename T>
	Pci::Device::Access_size _access_size(T t)
	{
		switch (sizeof(T)) {
		case 1:
			return Pci::Device::ACCESS_8BIT;
		case 2:
			return Pci::Device::ACCESS_16BIT;
		default:
			return Pci::Device::ACCESS_32BIT;
		}
	}

	void _bus_address(int *bus, int *dev, int *fun)
	{
		Pci::Device_client client(_cap);
		unsigned char b, d, f;
		client.bus_address(&b, &d, &f);

		*bus = b;
		*dev = d;
		*fun = f;
	}


	Pci_driver() { }

	template <typename T>
	void config_read(unsigned int devfn, T *val)
	{
		Pci::Device_client client(_cap);
		*val = client.config_read(devfn, _access_size(*val));
	}

	template <typename T>
	void config_write(unsigned int devfn, T val)
	{
		Pci::Device_client client(_cap);
		client.config_write(devfn, val, _access_size(val));
	}

	int first_device(int *bus, int *dev, int *fun)
	{
		_cap = _pci.first_device(CLASS_NETWORK, CLASS_MASK);
		_bus_address(bus, dev, fun);
		return 0;
	}

	int next_device(int *bus, int *dev, int *fun)
	{
		_last_cap = _cap;

		_cap = _pci.next_device(_cap, CLASS_NETWORK, CLASS_MASK);
		_bus_address(bus, dev, fun);

		if (_last_cap.valid())
			_pci.release_device(_last_cap);

		return 0;
	}

	Genode::addr_t alloc_dma_memory(Genode::size_t size)
	{
		try {
			using namespace Genode;

			/* trigger that the device gets assigned to this driver */
			for (unsigned i = 0; i < 2; i++) {
				try {
					_pci.config_extended(_cap);
					break;
				} catch (Pci::Device::Quota_exceeded) {
					Genode::env()->parent()->upgrade(_pci.cap(), "ram_quota=4096");
				}
			}

			/* transfer quota to pci driver, otherwise it will give us a exception */
			char buf[32];
			Genode::snprintf(buf, sizeof(buf), "ram_quota=%zd", size);
			Genode::env()->parent()->upgrade(_pci.cap(), buf);

			Ram_dataspace_capability ram_cap = _pci.alloc_dma_buffer(size);

			_region.mapped_base = (Genode::addr_t)env()->rm_session()->attach(ram_cap);
			_region.base = Dataspace_client(ram_cap).phys_addr();

			return _region.mapped_base;
		} catch (...) { return 0; }
	}

	Genode::addr_t virt_to_phys(Genode::addr_t virt) {
		return virt - _region.mapped_base + _region.base; }
};


static Pci_driver& pci_drv()
{
	static Pci_driver _pci_drv;
	return _pci_drv;
}


extern "C" int dde_pci_first_device(int *bus, int *dev, int *fun) {
	return pci_drv().first_device(bus, dev, fun); }


extern "C" int dde_pci_next_device(int *bus, int *dev, int *fun) {
	return pci_drv().next_device(bus, dev, fun); }


extern "C" void dde_pci_readb(int pos, dde_uint8_t *val) {
	pci_drv().config_read(pos, val); }


extern "C" void dde_pci_readw(int pos, dde_uint16_t *val) {
	pci_drv().config_read(pos, val); }


extern "C" void dde_pci_readl(int pos, dde_uint32_t *val) {
	pci_drv().config_read(pos, val); }


extern "C" void dde_pci_writeb(int pos, dde_uint8_t val) {
	pci_drv().config_write(pos, val); }


extern "C" void dde_pci_writew(int pos, dde_uint16_t val) {
	pci_drv().config_write(pos, val); }


extern "C" void dde_pci_writel(int pos, dde_uint32_t val) {
	pci_drv().config_write(pos, val); }


/************************
 ** Interrupt handling **
 ************************/

struct Irq_handler
{
	Server::Entrypoint                     &ep;
	Genode::Irq_session_client              irq;
	Genode::Signal_rpc_member<Irq_handler>  dispatcher;

	typedef void (*irq_handler)(void*);

	irq_handler  handler;
	void        *priv;

	void handle(unsigned)
	{
		handler(priv);
		irq.ack_irq();
	}

	Irq_handler(Server::Entrypoint &ep, Genode::Irq_session_capability cap,
	            irq_handler handler, void *priv)
	:
		ep(ep), irq(cap), dispatcher(ep, *this, &Irq_handler::handle),
		handler(handler), priv(priv)
	{
		irq.sigh(dispatcher);

		/* intial ack so that we will receive IRQ signals */
		irq.ack_irq();
	}
};

static Irq_handler *_irq_handler;

extern "C" int dde_interrupt_attach(void(*handler)(void *), void *priv)
{
	if (_irq_handler) {
		PERR("Irq_handler already registered");
		Genode::sleep_forever();
	}

	try {
		Pci::Device_client device(pci_drv()._cap);
		_irq_handler = new (Genode::env()->heap())
			Irq_handler(*_ep, device.irq(0), handler, priv);
	} catch (...) { return -1; }

	return 0;
}




/***************************************************
 ** Support for aligned and DMA memory allocation **
 ***************************************************/

enum { BACKING_STORE_SIZE = 1024 * 1024 };


static Genode::Allocator_avl& allocator()
{
	static Genode::Allocator_avl _avl(Genode::env()->heap());
	return _avl;
}


extern "C" int dde_dma_mem_init()
{
	try {
		Genode::addr_t base = pci_drv().alloc_dma_memory(BACKING_STORE_SIZE);
		/* add to allocator */
		allocator().add_range(base, BACKING_STORE_SIZE);
	} catch (...) { return false; }

	return true;
}


extern "C" void *dde_dma_alloc(dde_size_t size, dde_size_t align,
                                    dde_size_t offset)
{
	void *ptr;
	if (allocator().alloc_aligned(size, &ptr, Genode::log2(align)).is_error()) {
		PERR("memory allocation failed in alloc_memblock (size=%zu, align=%zx,"
		     " offset=%zx)", (Genode::size_t)size, (Genode::size_t)align, (Genode::size_t)offset);
		return 0;
	}
	return ptr;
}


extern "C" void dde_dma_free(void *p, dde_size_t size) {
	allocator().free(p, size); }


extern "C" dde_addr_t dde_dma_get_physaddr(void *virt) {
	return pci_drv().virt_to_phys((Genode::addr_t)virt); }


/**************
 ** I/O port **
 **************/

static Genode::Io_port_session_client *_io_port;

extern "C" void dde_request_io(dde_uint8_t virt_bar_ioport)
{
	using namespace Genode;

	if (_io_port) {
		PERR("Io_port_connection already open");
		sleep_forever();
	}

	Pci::Device_client device(pci_drv()._cap);
	Io_port_session_capability cap = device.io_port(virt_bar_ioport);

	_io_port = new (env()->heap()) Io_port_session_client(cap);
}


extern "C" dde_uint8_t dde_inb(dde_addr_t port) {
	return _io_port->inb(port); }


extern "C" dde_uint16_t dde_inw(dde_addr_t port) {
	return _io_port->inw(port); }


extern "C" dde_uint32_t dde_inl(dde_addr_t port) {
	return _io_port->inl(port); }


extern "C" void dde_outb(dde_addr_t port, dde_uint8_t data) {
	_io_port->outb(port, data); }


extern "C" void dde_outw(dde_addr_t port, dde_uint16_t data) {
	_io_port->outw(port, data); }


extern "C" void dde_outl(dde_addr_t port, dde_uint32_t data) {
	_io_port->outl(port, data); }


/**********************
 ** Slab memory pool **
 **********************/

struct Slab_backend_alloc : public Genode::Allocator,
                            public Genode::Rm_connection
{
	enum {
		VM_SIZE    = 512 * 1024,
		BLOCK_SIZE =  64 * 1024,
		ELEMENTS   = VM_SIZE / BLOCK_SIZE,
	};

	Genode::addr_t                    _base;
	Genode::Ram_dataspace_capability  _ds_cap[ELEMENTS];
	int                               _index;
	Genode::Allocator_avl             _range;
	Genode::Ram_session              &_ram;

	bool _alloc_block()
	{
		using namespace Genode;

		if (_index == ELEMENTS) {
			PERR("Slab-backend exhausted!");
			return false;
		}

		try {
			_ds_cap[_index] = _ram.alloc(BLOCK_SIZE);
			Rm_connection::attach_at(_ds_cap[_index], _index * BLOCK_SIZE, BLOCK_SIZE, 0);
		} catch (...) { return false; }

		/* return base + offset in VM area */
		Genode::addr_t block_base = _base + (_index * BLOCK_SIZE);
		++_index;

		_range.add_range(block_base, BLOCK_SIZE);
		return true;
	}

	Slab_backend_alloc(Genode::Ram_session &ram)
	:
		Rm_connection(0, VM_SIZE),
		_index(0), _range(Genode::env()->heap()), _ram(ram)
	{
		/* reserver attach us, anywere */
		_base = Genode::env()->rm_session()->attach(dataspace());
	}

	Genode::addr_t start() const { return _base; }
	Genode::addr_t end()   const { return _base + VM_SIZE - 1; }

	/*************************
	 ** Allocator interface **
	 *************************/

	bool alloc(Genode::size_t size, void **out_addr)
	{
		bool done = _range.alloc(size, out_addr);

		if (done)
			return done;

		done = _alloc_block();
		if (!done) {
			PERR("Backend allocator exhausted\n");
			return false;
		}

		return _range.alloc(size, out_addr);
	}

	void           free(void *addr, Genode::size_t size) { }
	Genode::size_t overhead(Genode::size_t size) const   { return 0; }
	bool           need_size_for_free() const            { return false; }
};


struct Slab_alloc : public Genode::Slab
{
	/*
	* Each slab block in the slab contains about 8 objects (slab entries)
	* as proposed in the paper by Bonwick and block sizes are multiples of
	* page size.
	*/
	static Genode::size_t _calculate_block_size(Genode::size_t object_size)
	{
		Genode::size_t block_size = 8 * (object_size + sizeof(Genode::Slab_entry))
		                                     + sizeof(Genode::Slab_block);
		return Genode::align_addr(block_size, 12);
	}

	Slab_alloc(Genode::size_t object_size, Slab_backend_alloc &allocator)
	: Slab(object_size, _calculate_block_size(object_size), 0, &allocator) { }

	/**
	 * Convenience slabe-entry allocation
	 */
	Genode::addr_t alloc()
	{
		Genode::addr_t result;
		return (Slab::alloc(slab_size(), (void **)&result) ? result : 0);
	}
};

struct Slab
{
	enum {
		SLAB_START_LOG2 = 5,  /* 32 B */
		SLAB_STOP_LOG2  = 10, /* 1 KiB */
		NUM_SLABS = (SLAB_STOP_LOG2 - SLAB_START_LOG2) + 1,
	};

	Slab_backend_alloc &_back_alloc;
	Slab_alloc         *_allocator[NUM_SLABS];
	Genode::addr_t      _start;
	Genode::addr_t      _end;

	Slab(Slab_backend_alloc &alloc)
	: _back_alloc(alloc), _start(alloc.start()), _end(alloc.end())
	{
		for (unsigned i = 0; i < NUM_SLABS; i++)
			_allocator[i] = new (Genode::env()->heap())
				Slab_alloc(1U << (SLAB_START_LOG2 + i), alloc);
	}

	void *alloc(Genode::size_t size)
	{
		using namespace Genode;
		size += sizeof(Genode::addr_t);

		int msb = Genode::log2(size);

		if (size > (1U << msb))
			msb++;

		if (size < (1U << SLAB_START_LOG2))
			msb = SLAB_STOP_LOG2;

		if (msb > SLAB_STOP_LOG2)
			return 0;

		Genode::addr_t addr =  _allocator[msb - SLAB_START_LOG2]->alloc();
		if (!addr)
			return 0;

		*(Genode::addr_t*)addr = msb - SLAB_START_LOG2;
		addr += sizeof(Genode::addr_t);

		return (void*)addr;
	}

	void free(void *p)
	{
		using namespace Genode;
		Genode::addr_t *addr = ((Genode::addr_t *)p)-1;
		unsigned index = *(unsigned*)(addr);
		_allocator[index]->free((void*)(addr));
	}
};


static ::Slab& slab()
{
	static ::Slab_backend_alloc sb(*Genode::env()->ram_session());
	static ::Slab s(sb);
	return s;
}


extern "C" void *dde_slab_alloc(dde_size_t size) {
	return slab().alloc(size); }


extern "C" void dde_slab_free(void *p) {
	slab().free(p); }


/****************
 ** I/O memory **
 ****************/

struct Io_memory
{
	Genode::Io_mem_session_client       _mem;
	Genode::Io_mem_dataspace_capability _mem_ds;

	Genode::addr_t                      _vaddr;

	Io_memory(Genode::addr_t base, Genode::Io_mem_session_capability cap)
	:
		_mem(cap),
		_mem_ds(_mem.dataspace())
	{
		if (!_mem_ds.valid())
			throw Genode::Exception();

		_vaddr = Genode::env()->rm_session()->attach(_mem_ds);
		_vaddr |= base & 0xfff;
	}

	Genode::addr_t vaddr() const { return _vaddr; }
};


static Io_memory *_io_mem;


extern "C" int dde_request_iomem(dde_addr_t start, dde_addr_t *vaddr)
{
	if (_io_mem) {
		PERR("Io_memory already requested");
		Genode::sleep_forever();
	}

	Pci::Device_client device(pci_drv()._cap);
	Genode::Io_mem_session_capability cap;

	Genode::uint8_t virt_iomem_bar = 0;
	for (unsigned i = 0; i < Pci::Device::NUM_RESOURCES; i++) {
		Pci::Device::Resource res = device.resource(i);
		if (res.type() == Pci::Device::Resource::MEMORY) {
			if (res.base() == start) {
				cap = device.io_mem(virt_iomem_bar);
				break;
			}
			virt_iomem_bar ++;
		}
	}
	if (!cap.valid())
		return -1;

	try {
		_io_mem = new (Genode::env()->heap()) Io_memory(start, cap);
	} catch (...) { return -1; }

	*vaddr = _io_mem->vaddr();
	return 0;
}


extern "C" int dde_release_iomem(dde_addr_t start, dde_size_t size)
{
	try {
		destroy(Genode::env()->heap(), _io_mem);
		_io_mem = 0;
		return 0;
	} catch (...) { return -1; }
}