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


#include "apple.h"

#include <ddm_modules.h>
#include <disk_device_types.h>
#include <KernelExport.h>
#ifdef _BOOT_MODE
#	include <boot/partitions.h>
#else
#	include <DiskDeviceTypes.h>
#endif
#include <util/kernel_cpp.h>

#include <unistd.h>
#include <string.h>


#define TRACE_APPLE 0
#if TRACE_APPLE
#	define TRACE(x) dprintf x
#else
#	define TRACE(x) ;
#endif

#define APPLE_PARTITION_MODULE_NAME "partitioning_systems/apple/v1"

static const char *kApplePartitionTypes[] = {
	"partition_map",	// the partition map itself
	"Driver",			// contains a device driver
	"Driver43",			// the SCSI 4.3 manager
	"MFS",				// Macintosh File System
	"HFS",				// Hierarchical File System (HFS/HFS+)
	"Unix_SVR2",		// UFS
	"PRODOS",
	"Free",				// unused partition
	"Scratch",			// empty partition
	"Driver_ATA",		// the device driver for an ATA device
	"Driver_ATAPI",		// the device driver for an ATAPI device
	"Driver43_CD",		// an SCSI CD-ROM driver suitable for booting
	"FWDriver",			// a FireWire driver for the device
	"Void",				// dummy partition map entry (used to align entries for CD-ROM)
	"Patches",
	NULL
};
#if 0
static const char *kOtherPartitionTypes[] = {
	"Be_BFS",			// Be's BFS (not specified endian)
};
#endif

static status_t
get_next_partition(int fd, apple_driver_descriptor &descriptor, uint32 &cookie,
	apple_partition_map &partition)
{
	uint32 block = cookie;

	// find first partition map if this is the first call,
	// or else, just load the next block
	do {
		ssize_t bytesRead = read_pos(fd, (off_t)block * descriptor.BlockSize(),
					(void *)&partition, sizeof(apple_partition_map));
		if (bytesRead < (ssize_t)sizeof(apple_partition_map))
			return B_ERROR;

		block++;
	} while (cookie == 0 && block < 64 && !partition.HasValidSignature());

	if (!partition.HasValidSignature()) {
		if (cookie)
			return B_ENTRY_NOT_FOUND;

		// we searched for the first partition map entry and failed
		return B_ERROR;
	}

	// the first partition map entry must be of type Apple_partition_map
	if (!cookie && (strncmp(partition.type, "Apple_", 6)
		|| strcmp(partition.type + 6, kApplePartitionTypes[0])))
		return B_ERROR;

	// ToDo: warn about unknown types?

	cookie = block;
	return B_OK;
}


//	#pragma mark -
//	Apple public module interface


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

	return B_ERROR;
}


static float
apple_identify_partition(int fd, partition_data *partition, void **_cookie)
{
	struct apple_driver_descriptor *descriptor;
	uint8 buffer[512];

	if (read_pos(fd, 0, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer))
		return B_ERROR;

	descriptor = (apple_driver_descriptor *)buffer;

	TRACE(("apple: read first chunk (signature = %x)\n", descriptor->signature));

	if (!descriptor->HasValidSignature())
		return B_ERROR;

	TRACE(("apple: valid partition descriptor!\n"));

	// ToDo: Should probably call get_next_partition() once to know if there
	//		are any partitions on this disk

	// copy the relevant part of the first block
	descriptor = new apple_driver_descriptor();
	memcpy(descriptor, buffer, sizeof(apple_driver_descriptor));

	*_cookie = (void *)descriptor;

	// ToDo: reevaluate the priority with ISO-9660 and others in mind
	//		(for CD-ROM only, as far as I can tell)
	return 0.5f;
}


static status_t
apple_scan_partition(int fd, partition_data *partition, void *_cookie)
{
	TRACE(("apple_scan_partition(cookie = %p)\n", _cookie));

	apple_driver_descriptor &descriptor = *(apple_driver_descriptor *)_cookie;

	partition->status = B_PARTITION_VALID;
	partition->flags |= B_PARTITION_PARTITIONING_SYSTEM
						| B_PARTITION_READ_ONLY;
	partition->content_size = descriptor.BlockSize() * descriptor.BlockCount();

	// scan all children

	apple_partition_map partitionMap;
	uint32 index = 0, cookie = 0;
	status_t status;

	while ((status = get_next_partition(fd, descriptor, cookie, partitionMap)) == B_OK) {
		TRACE(("apple: found partition: name = \"%s\", type = \"%s\"\n",
			partitionMap.name, partitionMap.type));

		if (partitionMap.Start(descriptor) + partitionMap.Size(descriptor) > (uint64)partition->size) {
			TRACE(("apple: child partition exceeds existing space (%lld bytes)\n",
				partitionMap.Size(descriptor)));
			continue;
		}

		partition_data *child = create_child_partition(partition->id, index++,
			partition->offset + partitionMap.Start(descriptor),
			partitionMap.Size(descriptor), -1);
		if (child == NULL) {
			TRACE(("apple: Creating child at index %ld failed\n", index - 1));
			return B_ERROR;
		}

		child->block_size = partition->block_size;
	}

	if (status == B_ENTRY_NOT_FOUND)
		return B_OK;

	return status;
}


static void
apple_free_identify_partition_cookie(partition_data *partition, void *_cookie)
{
	delete (apple_driver_descriptor *)_cookie;
}


#ifndef _BOOT_MODE
static partition_module_info sApplePartitionModule = {
#else
partition_module_info gApplePartitionModule = {
#endif
	{
		APPLE_PARTITION_MODULE_NAME,
		0,
		apple_std_ops
	},
	"apple",							// short_name
	APPLE_PARTITION_NAME,				// pretty_name
	0,									// flags

	// scanning
	apple_identify_partition,			// identify_partition
	apple_scan_partition,				// scan_partition
	apple_free_identify_partition_cookie,	// free_identify_partition_cookie
	NULL,
};

#ifndef _BOOT_MODE
partition_module_info *modules[] = {
	&sApplePartitionModule,
	NULL
};
#endif