/*
 * Copyright 2018, Jérôme Duval, jerome.duval@gmail.com.
 * Distributed under the terms of the MIT License.
 */


#include "VirtioBalloonPrivate.h"

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


#define VIRTIO_BALLOON_CONTROLLER_PRETTY_NAME "Virtio Balloon Device"

#define VIRTIO_BALLOON_DRIVER_MODULE_NAME "drivers/misc/virtio_balloon/driver_v1"
#define VIRTIO_BALLOON_DEVICE_MODULE_NAME "drivers/misc/virtio_balloon/device_v1"


extern device_manager_info *gDeviceManager;


//	#pragma mark - Device module interface


static status_t
virtio_balloon_init_device(device_node *node, void **_cookie)
{
	CALLED();

	VirtioBalloonDevice *device =  new(std::nothrow)
		VirtioBalloonDevice(node);
	if (device == NULL)
		return B_NO_MEMORY;
	status_t status = device->InitCheck();
	if (status < B_OK) {
		delete device;
		return status;
	}

	*_cookie = device;
	return B_OK;
}


static void
virtio_balloon_uninit_device(void *cookie)
{
	CALLED();
	VirtioBalloonDevice *device = (VirtioBalloonDevice*)cookie;

	delete device;
}


//	#pragma mark -	Driver module interface


static float
virtio_balloon_supports_device(device_node *parent)
{
	const char *bus;
	uint16 deviceType;

	// make sure parent is really the Virtio bus manager
	if (gDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
		return -1;

	if (strcmp(bus, "virtio"))
		return 0.0;

	// check whether it's really a Virtio Entropy Device
	if (gDeviceManager->get_attr_uint16(parent, VIRTIO_DEVICE_TYPE_ITEM,
			&deviceType, true) != B_OK || deviceType != VIRTIO_DEVICE_ID_BALLOON)
		return 0.0;

	TRACE("Virtio Balloon device found!\n");

	return 0.6f;
}


static status_t
virtio_balloon_register_device(device_node *parent)
{
	CALLED();

	device_attr attrs[] = {
		{ NULL }
	};

	return gDeviceManager->register_node(parent, VIRTIO_BALLOON_DRIVER_MODULE_NAME,
		attrs, NULL, NULL);
}


static status_t
virtio_balloon_init_driver(device_node *node, void **_cookie)
{
	CALLED();
	*_cookie = node;
	return B_OK;
}


static status_t
virtio_balloon_register_child_devices(void *cookie)
{
	CALLED();
	device_node *node = (device_node *)cookie;

	device_attr attrs[] = {
		{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
			{ .string = VIRTIO_BALLOON_CONTROLLER_PRETTY_NAME }},
		{ NULL }
	};

	return gDeviceManager->register_node(node,
		VIRTIO_BALLOON_DEVICE_MODULE_NAME, attrs, NULL, NULL);
}


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

		default:
			return B_ERROR;
	}
}


driver_module_info sVirtioBalloonDeviceInterface = {
	{
		VIRTIO_BALLOON_DEVICE_MODULE_NAME,
		0,
		std_ops
	},
	NULL,	// supported devices
	NULL,	// register node
	virtio_balloon_init_device,
	virtio_balloon_uninit_device,
	NULL,	// register child devices
	NULL,	// rescan
	NULL	// bus_removed
};


driver_module_info sVirtioBalloonDriver = {
	{
		VIRTIO_BALLOON_DRIVER_MODULE_NAME,
		0,
		std_ops
	},
	virtio_balloon_supports_device,
	virtio_balloon_register_device,
	virtio_balloon_init_driver,
	NULL,	// uninit_driver,
	virtio_balloon_register_child_devices,
	NULL,	// rescan
	NULL,	// device_removed
};