haiku.git

/*
 * Copyright 2012, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Ithamar R. Adema <ithamar@upgrade-android.com>
 */


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

#include <drivers/device_manager.h>
#include <drivers/KernelExport.h>
#include <drivers/Drivers.h>
#include <kernel/OS.h>


//#define TRACE_NORFLASH
#ifdef TRACE_NORFLASH
#define TRACE(x...)	dprintf("nor: " x)
#else
#define TRACE(x...)
#endif


#define NORFLASH_DEVICE_MODULE_NAME	"drivers/disk/norflash/device_v1"
#define NORFLASH_DRIVER_MODULE_NAME	"drivers/disk/norflash/driver_v1"


#define NORFLASH_ADDR	0x00000000
#define SIZE_IN_BLOCKS	256

/* Hide the start of NOR since U-Boot lives there */
#define HIDDEN_BLOCKS	2

struct nor_driver_info {
	device_node *node;
	size_t blocksize;
	size_t totalsize;

	area_id id;
	uint8 *mapped;
};


static device_manager_info *sDeviceManager;


static status_t
nor_init_device(void *_info, void **_cookie)
{
	TRACE("init_device\n");
	nor_driver_info *info = (nor_driver_info*)_info;

	info->mapped = NULL;
	info->blocksize = 128 * 1024;
	info->totalsize = (SIZE_IN_BLOCKS - HIDDEN_BLOCKS) * info->blocksize;

	info->id = map_physical_memory("NORFlash", NORFLASH_ADDR, info->totalsize, B_ANY_KERNEL_ADDRESS, B_READ_AREA, (void **)&info->mapped);
	if (info->id < 0)
		return info->id;

	info->mapped += HIDDEN_BLOCKS * info->blocksize;


	*_cookie = info;
	return B_OK;
}


static void
nor_uninit_device(void *_cookie)
{
	TRACE("uninit_device\n");
	nor_driver_info *info = (nor_driver_info*)_cookie;
	if (info)
		delete_area(info->id);	
}


static status_t
nor_open(void *deviceCookie, const char *path, int openMode,
	void **_cookie)
{
	TRACE("open(%s)\n", path);
	*_cookie = deviceCookie;
	return B_OK;
}


static status_t
nor_close(void *_cookie)
{
	TRACE("close()\n");
	return B_OK;
}


static status_t
nor_free(void *_cookie)
{
	TRACE("free()\n");
	return B_OK;
}


static status_t
nor_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
{
	nor_driver_info *info = (nor_driver_info*)cookie;
	TRACE("ioctl(%ld,%lu)\n", op, length);

	switch (op) {
		case B_GET_GEOMETRY:
		{
			device_geometry *deviceGeometry = (device_geometry*)buffer;
			deviceGeometry->removable = false;
			deviceGeometry->bytes_per_sector = info->blocksize;
			deviceGeometry->sectors_per_track = info->totalsize / info->blocksize;
			deviceGeometry->cylinder_count = 1;
			deviceGeometry->head_count = 1;
			deviceGeometry->device_type = B_DISK;
			deviceGeometry->removable = false;
			deviceGeometry->read_only = true;
			deviceGeometry->write_once = false;
			return B_OK;
		}
		break;

		case B_GET_DEVICE_NAME:
			strlcpy((char*)buffer, "NORFlash", length);
			break;
	}

	return B_ERROR;
}


static status_t
nor_read(void *_cookie, off_t position, void *data, size_t *numbytes)
{
	nor_driver_info *info = (nor_driver_info*)_cookie;
	TRACE("read(%lld,%lu)\n", position, *numbytes);

	position += HIDDEN_BLOCKS * info->blocksize;

	if (position + *numbytes > info->totalsize)
		*numbytes = info->totalsize - (position + *numbytes);

	memcpy(data, info->mapped + position, *numbytes);

	return B_OK;
}


static status_t
nor_write(void *_cookie, off_t position, const void *data, size_t *numbytes)
{
	TRACE("write(%lld,%lu)\n", position, *numbytes);
	*numbytes = 0;
	return B_ERROR;
}


static float
nor_supports_device(device_node *parent)
{
	const char *bus;
	TRACE("supports_device\n");

	if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
		return B_ERROR;

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

	return 1.0;
}


static status_t
nor_register_device(device_node *node)
{
	TRACE("register_device\n");
	// ready to register
	device_attr attrs[] = {
		{ NULL }
	};

	return sDeviceManager->register_node(node, NORFLASH_DRIVER_MODULE_NAME,
		attrs, NULL, NULL);
}


static status_t
nor_init_driver(device_node *node, void **cookie)
{
	TRACE("init_driver\n");

	nor_driver_info *info = (nor_driver_info*)malloc(sizeof(nor_driver_info));
	if (info == NULL)
		return B_NO_MEMORY;

	memset(info, 0, sizeof(*info));

	info->node = node;

	*cookie = info;
	return B_OK;
}


static void
nor_uninit_driver(void *_cookie)
{
	TRACE("uninit_driver\n");
	nor_driver_info *info = (nor_driver_info*)_cookie;
	free(info);
}


static status_t
nor_register_child_devices(void *_cookie)
{
	TRACE("register_child_devices\n");
	nor_driver_info *info = (nor_driver_info*)_cookie;
	status_t status;

	status = sDeviceManager->publish_device(info->node, "disk/nor/0/raw",
		NORFLASH_DEVICE_MODULE_NAME);

	return status;
}


struct device_module_info sNORFlashDiskDevice = {
	{
		NORFLASH_DEVICE_MODULE_NAME,
		0,
		NULL
	},

	nor_init_device,
	nor_uninit_device,
	NULL, //nor_remove,

	nor_open,
	nor_close,
	nor_free,
	nor_read,
	nor_write,
	NULL,	// nor_io,
	nor_ioctl,

	NULL,	// select
	NULL,	// deselect
};



struct driver_module_info sNORFlashDiskDriver = {
	{
		NORFLASH_DRIVER_MODULE_NAME,
		0,
		NULL
	},

	nor_supports_device,
	nor_register_device,
	nor_init_driver,
	nor_uninit_driver,
	nor_register_child_devices,
	NULL,	// rescan
	NULL,	// removed
};


module_dependency module_dependencies[] = {
	{ B_DEVICE_MANAGER_MODULE_NAME, (module_info**)&sDeviceManager },
	{ }
};


module_info *modules[] = {
	(module_info*)&sNORFlashDiskDriver,
	(module_info*)&sNORFlashDiskDevice,
	NULL
};