static int
hw_disk_nr_blocks(device_instance *instance,
int n_stack_args,
unsigned32 stack_args[/*n_stack_args*/],
int n_stack_returns,
unsigned32 stack_returns[/*n_stack_returns*/])
{
device *me = device_instance_device(instance);
if ((n_stack_args != 0)
|| (n_stack_returns != 1)) {
device_error(me, "Incorrect number of arguments for block-size method\n");
return -1;
}
else {
unsigned_word nr_blocks;
if (device_find_property(me, "#blocks"))
nr_blocks = device_find_integer_property(me, "#blocks");
else
nr_blocks = -1;
DITRACE(disk, ("#blocks - instance=%ld #blocks=%ld\n",
(unsigned long)device_instance_to_external(instance),
(long int)nr_blocks));
stack_returns[0] = nr_blocks;
return 0;
}
}
static int
hw_disk_block_size(device_instance *instance,
int n_stack_args,
unsigned32 stack_args[/*n_stack_args*/],
int n_stack_returns,
unsigned32 stack_returns[/*n_stack_returns*/])
{
device *me = device_instance_device(instance);
if ((n_stack_args != 0)
|| (n_stack_returns != 1)) {
device_error(me, "Incorrect number of arguments for block-size method\n");
return -1;
}
else {
unsigned_cell block_size;
if (device_find_property(me, "block-size"))
block_size = device_find_integer_property(me, "block-size");
else
block_size = 512;
DITRACE(disk, ("block-size - instance=%ld block-size=%ld\n",
(unsigned long)device_instance_to_external(instance),
(long int)block_size));
stack_returns[0] = block_size;
return 0;
}
}
static int
hw_disk_max_transfer(device_instance *instance,
int n_stack_args,
unsigned32 stack_args[/*n_stack_args*/],
int n_stack_returns,
unsigned32 stack_returns[/*n_stack_returns*/])
{
device *me = device_instance_device(instance);
if ((n_stack_args != 0)
|| (n_stack_returns != 1)) {
device_error(me, "Incorrect number of arguments for max-transfer method\n");
return -1;
}
else {
unsigned_cell max_transfer;
if (device_find_property(me, "max-transfer"))
max_transfer = device_find_integer_property(me, "max-transfer");
else
max_transfer = 512;
DITRACE(disk, ("max-transfer - instance=%ld max-transfer=%ld\n",
(unsigned long)device_instance_to_external(instance),
(long int)max_transfer));
stack_returns[0] = max_transfer;
return 0;
}
}
static int
hw_com_instance_write(device_instance *instance,
const void *buf,
unsigned_word len)
{
device *me = device_instance_device(instance);
hw_com_device *com = device_data(me);
if (com->output.file == NULL)
return sim_io_write_stdout(buf, len);
else {
return fwrite(buf, 1, len, com->output.file);
}
}
static int
hw_com_instance_read(device_instance *instance,
void *buf,
unsigned_word len)
{
device *me = device_instance_device(instance);
hw_com_device *com = device_data(me);
if (com->input.file == NULL)
return sim_io_read_stdin(buf, len);
else {
return fread(buf, 1, len, com->input.file);
}
}
static int
hw_disk_instance_seek(device_instance *instance,
unsigned_word pos_hi,
unsigned_word pos_lo)
{
hw_disk_instance *data = device_instance_data(instance);
if (pos_hi != 0)
device_error(device_instance_device(instance),
"seek - extended addressing unimplemented");
DITRACE(disk, ("seek - instance=%ld pos_hi=%ld pos_lo=%ld\n",
(unsigned long)device_instance_to_external(instance),
(long)pos_hi, (long)pos_lo));
data->pos = pos_lo;
return 0;
}
device_instance *
pk_disklabel_create_instance(device_instance *raw_disk,
const char *args)
{
int partition;
char *filename;
/* parse the arguments */
if (args == NULL) {
partition = 0;
filename = NULL;
}
else {
partition = strtoul((char*)args, &filename, 0);
if (filename == args)
partition = -1; /* not specified */
if (*filename == ',')
filename++;
if (*filename == '\0')
filename = NULL; /* easier */
}
if (partition == 0) {
/* select the raw disk */
return raw_disk;
}
else {
unsigned8 boot_block[512];
/* get the boot block for examination */
if (device_instance_seek(raw_disk, 0, 0) < 0)
device_error(device_instance_device(raw_disk),
"Problem seeking on raw disk");
if (device_instance_read(raw_disk, &boot_block, sizeof(boot_block))
!= sizeof(boot_block))
device_error(device_instance_device(raw_disk), "Problem reading boot block");
if (partition < 0) {
/* select the active partition */
if (block0_is_bpb(boot_block)) {
device_error(device_instance_device(raw_disk), "Unimplemented active BPB");
}
else if (block0_is_fdisk(boot_block)) {
int active = block0_is_fdisk(boot_block);
device_error(device_instance_device(raw_disk), "Unimplemented active FDISK (%d)",
active);
}
else if (is_iso9660(raw_disk)) {
device_error(device_instance_device(raw_disk), "Unimplemented active ISO9660");
}
else if (block0_is_mac_disk(boot_block)) {
device_error(device_instance_device(raw_disk), "Unimplemented active MAC DISK");
}
else {
device_error(device_instance_device(raw_disk), "Unreconized bootblock");
}
}
else {
/* select the specified disk partition */
if (block0_is_bpb(boot_block)) {
device_error(device_instance_device(raw_disk), "Unimplemented BPB");
}
else if (block0_is_fdisk(boot_block)) {
/* return an instance */
ppcboot_partition_t *partition_table = (ppcboot_partition_t*) &boot_block[446];
ppcboot_partition_t *partition_entry;
disklabel *label;
if (partition > 4)
device_error(device_instance_device(raw_disk),
"Only FDISK partitions 1..4 supported");
partition_entry = &partition_table[partition - 1];
label = ZALLOC(disklabel);
label->raw_disk = raw_disk;
label->pos = 0;
label->sector_begin = 512 * sector2uw(partition_entry->sector_begin);
label->sector_length = 512 * sector2uw(partition_entry->sector_length);
PTRACE(disklabel, ("partition %ld, sector-begin %ld, length %ld\n",
(long)partition,
(long)label->sector_begin,
(long)label->sector_length));
if (filename != NULL)
device_error(device_instance_device(raw_disk),
"FDISK file names not yet supported");
return device_create_instance_from(NULL, raw_disk,
label,
NULL, args,
&package_disklabel_callbacks);
}
else if (block0_is_mac_disk(boot_block)) {
device_error(device_instance_device(raw_disk), "Unimplemented MAC DISK");
}
else {
device_error(device_instance_device(raw_disk),
"Unreconized bootblock");
}
}
}
return NULL;
}
