0,0 → 1,159 |
|
/* |
* Copyright (c) 2006-2007 by Roland Riegel <feedback@roland-riegel.de> |
* |
* This file is free software; you can redistribute it and/or modify |
* it under the terms of either the GNU General Public License version 2 |
* or the GNU Lesser General Public License version 2.1, both as |
* published by the Free Software Foundation. |
*/ |
|
#include "partition.h" |
#include "partition_config.h" |
#include "sd-reader_config.h" |
|
#include <string.h> |
|
#if USE_DYNAMIC_MEMORY |
#include <stdlib.h> |
#endif |
|
/** |
* \addtogroup partition Partition table support |
* |
* Support for reading partition tables and access to partitions. |
* |
* @{ |
*/ |
/** |
* \file |
* Partition table implementation (license: GPLv2 or LGPLv2.1) |
* |
* \author Roland Riegel |
*/ |
|
/** |
* \addtogroup partition_config Configuration of partition table support |
* Preprocessor defines to configure the partition support. |
*/ |
|
#if !USE_DYNAMIC_MEMORY |
static struct partition_struct partition_handles[PARTITION_COUNT]; |
#endif |
|
/** |
* Opens a partition. |
* |
* Opens a partition by its index number and returns a partition |
* handle which describes the opened partition. |
* |
* \note This function does not support extended partitions. |
* |
* \param[in] device_read A function pointer which is used to read from the disk. |
* \param[in] device_read_interval A function pointer which is used to read in constant intervals from the disk. |
* \param[in] device_write A function pointer which is used to write to the disk. |
* \param[in] device_write_interval A function pointer which is used to write a data stream to disk. |
* \param[in] index The index of the partition which should be opened, range 0 to 3. |
* A negative value is allowed as well. In this case, the partition opened is |
* not checked for existance, begins at offset zero, has a length of zero |
* and is of an unknown type. |
* \returns 0 on failure, a partition descriptor on success. |
* \see partition_close |
*/ |
struct partition_struct* partition_open(device_read_t device_read, device_read_interval_t device_read_interval, device_write_t device_write, device_write_interval_t device_write_interval, int8_t index) |
{ |
struct partition_struct* new_partition = 0; |
uint8_t buffer[0x10]; |
|
if(!device_read || !device_read_interval || index >= 4) |
return 0; |
|
if(index >= 0) |
{ |
/* read specified partition table index */ |
if(!device_read(0x01be + index * 0x10, buffer, sizeof(buffer))) |
return 0; |
|
/* abort on empty partition entry */ |
if(buffer[4] == 0x00) |
return 0; |
} |
|
/* allocate partition descriptor */ |
#if USE_DYNAMIC_MEMORY |
new_partition = malloc(sizeof(*new_partition)); |
if(!new_partition) |
return 0; |
#else |
new_partition = partition_handles; |
uint8_t i; |
for(i = 0; i < PARTITION_COUNT; ++i) |
{ |
if(new_partition->type == PARTITION_TYPE_FREE) |
break; |
|
++new_partition; |
} |
if(i >= PARTITION_COUNT) |
return 0; |
#endif |
|
memset(new_partition, 0, sizeof(*new_partition)); |
|
/* fill partition descriptor */ |
new_partition->device_read = device_read; |
new_partition->device_read_interval = device_read_interval; |
new_partition->device_write = device_write; |
new_partition->device_write_interval = device_write_interval; |
|
if(index >= 0) |
{ |
new_partition->type = buffer[4]; |
new_partition->offset = ((uint32_t) buffer[8]) | |
((uint32_t) buffer[9] << 8) | |
((uint32_t) buffer[10] << 16) | |
((uint32_t) buffer[11] << 24); |
new_partition->length = ((uint32_t) buffer[12]) | |
((uint32_t) buffer[13] << 8) | |
((uint32_t) buffer[14] << 16) | |
((uint32_t) buffer[15] << 24); |
} |
else |
{ |
new_partition->type = 0xff; |
} |
|
return new_partition; |
} |
|
/** |
* Closes a partition. |
* |
* This function destroys a partition descriptor which was |
* previously obtained from a call to partition_open(). |
* When this function returns, the given descriptor will be |
* invalid. |
* |
* \param[in] partition The partition descriptor to destroy. |
* \returns 0 on failure, 1 on success. |
* \see partition_open |
*/ |
uint8_t partition_close(struct partition_struct* partition) |
{ |
if(!partition) |
return 0; |
|
/* destroy partition descriptor */ |
#if USE_DYNAMIC_MEMORY |
free(partition); |
#else |
partition->type = PARTITION_TYPE_FREE; |
#endif |
|
return 1; |
} |
|
/** |
* @} |
*/ |
|