/*
 * Copyright 2004-2008, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Copyright 2002-2003, Thomas Kurschel. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "pci.h"
#include "pci_private.h"


// information about one PCI device
struct pci_device {
	PCIDev*					device;
	device_node*			node;
};


static status_t
pci_device_init_driver(device_node* node, void** _cookie)
{
	uint8 domain;
	uint8 bus, deviceNumber, function;
	if (gDeviceManager->get_attr_uint8(node, B_PCI_DEVICE_DOMAIN, &domain,
			false) != B_OK
		|| gDeviceManager->get_attr_uint8(node, B_PCI_DEVICE_BUS, &bus,
			false) != B_OK
		|| gDeviceManager->get_attr_uint8(node, B_PCI_DEVICE_DEVICE,
			&deviceNumber, false) != B_OK
		|| gDeviceManager->get_attr_uint8(node, B_PCI_DEVICE_FUNCTION,
			&function, false) != B_OK)
		return B_ERROR;

	PCIDev *dev = gPCI->FindDevice(domain, bus, deviceNumber, function);
	if (dev == NULL) {
		panic("device not found!\n");
		return ENODEV;
	}

	pci_device* device = (pci_device*)malloc(sizeof(*device));
	if (device == NULL)
		return B_NO_MEMORY;

	device->device = dev;
	device->node = node;

	*_cookie = device;
	return B_OK;
}


static void
pci_device_uninit_driver(void* cookie)
{
	pci_device* device = (pci_device*)cookie;
	free(device);
}


static status_t
pci_device_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
		case B_MODULE_UNINIT:
			return B_OK;
	}

	return B_BAD_VALUE;
}


pci_device_module_info gPCIDeviceModule = {
	{
		{
			PCI_DEVICE_MODULE_NAME,
			0,
			pci_device_std_ops
		},

		.init_driver = pci_device_init_driver,
		.uninit_driver = pci_device_uninit_driver,
	},

	.read_io_8 = [](pci_device *device, addr_t mappedIOAddress) {
		return pci_read_io_8(mappedIOAddress);
	},
	.write_io_8 = [](pci_device *device, addr_t mappedIOAddress, uint8 value) {
		pci_write_io_8(mappedIOAddress, value);
	},
	.read_io_16 = [](pci_device *device, addr_t mappedIOAddress) {
		return pci_read_io_16(mappedIOAddress);
	},
	.write_io_16 = [](pci_device *device, addr_t mappedIOAddress, uint16 value) {
		pci_write_io_16(mappedIOAddress, value);
	},
	.read_io_32 = [](pci_device *device, addr_t mappedIOAddress) {
		return pci_read_io_32(mappedIOAddress);
	},
	.write_io_32 = [](pci_device *device, addr_t mappedIOAddress, uint32 value) {
		pci_write_io_32(mappedIOAddress, value);
	},
	.ram_address = [](pci_device *device, phys_addr_t physicalAddress) {
		return pci_ram_address(physicalAddress);
	},
	.read_pci_config = [](pci_device *device, uint16 offset, uint8 size) {
		return gPCI->ReadConfig(device->device, offset, size);
	},
	.write_pci_config = [](pci_device *device, uint16 offset, uint8 size, uint32 value) {
		gPCI->WriteConfig(device->device, offset, size, value);
	},
	.find_pci_capability = [](pci_device *device, uint8 capID, uint8 *offset) {
		return gPCI->FindCapability(device->device, capID, offset);
	},
	.get_pci_info = [](pci_device *device, struct pci_info *info) {
		if (info == NULL)
			return;
		*info = device->device->info;
	},
	.find_pci_extended_capability = [](pci_device *device, uint16 capID, uint16 *offset) {
		return gPCI->FindExtendedCapability(device->device, capID, offset);
	},
	.get_powerstate = [](pci_device *device) {
		return gPCI->GetPowerstate(device->device);
	},
	.set_powerstate = [](pci_device *device, uint8 state) {
		gPCI->SetPowerstate(device->device, state);
	},
	.get_msi_count = [](pci_device *device) {
		return gPCI->GetMSICount(device->device);
	},
	.configure_msi = [](pci_device *device, uint32 count, uint32 *startVector) {
		return gPCI->ConfigureMSI(device->device, count, startVector);
	},
	.unconfigure_msi = [](pci_device *device) {
		return gPCI->UnconfigureMSI(device->device);
	},
	.enable_msi = [](pci_device *device) {
		return gPCI->EnableMSI(device->device);
	},
	.disable_msi = [](pci_device *device) {
		return gPCI->DisableMSI(device->device);
	},
	.get_msix_count = [](pci_device *device) {
		return gPCI->GetMSIXCount(device->device);
	},
	.configure_msix = [](pci_device *device, uint32 count, uint32 *startVector) {
		return gPCI->ConfigureMSIX(device->device, count, startVector);
	},
	.enable_msix = [](pci_device *device) {
		return gPCI->EnableMSIX(device->device);
	}
};