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_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_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 void
hw_disk_instance_delete(device_instance *instance)
{
hw_disk_instance *data = device_instance_data(instance);
DITRACE(disk, ("delete - instance=%ld\n",
(unsigned long)device_instance_to_external(instance)));
free(data);
}
static int
hw_pal_instance_read_callback (hw_instance *instance,
void *buf,
unsigned_word len)
{
DITRACE (pal, ("read - %s (%ld)", (const char*) buf, (long int) len));
return sim_io_read_stdin (buf, len);
}
static int
hw_pal_instance_write_callback (hw_instance *instance,
const void *buf,
unsigned_word len)
{
int i;
const char *chp = buf;
hw_pal_device *hw_pal = hw_instance_data (instance);
DITRACE (pal, ("write - %s (%ld)", (const char*) buf, (long int) len));
for (i = 0; i < len; i++)
write_hw_pal (hw_pal, chp[i]);
sim_io_flush_stdoutput ();
return i;
}
static int
hw_eeprom_instance_read(device_instance *instance,
void *buf,
unsigned_word len)
{
hw_eeprom_instance *data = device_instance_data(instance);
int i;
if (data->eeprom->state != read_reset)
DITRACE(eeprom, ("eeprom not idle during instance read\n"));
for (i = 0; i < len; i++) {
((unsigned8*)buf)[i] = data->eeprom->memory[data->pos];
data->pos = (data->pos + 1) % data->eeprom->sizeof_memory;
}
return len;
}
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;
}
static int
hw_eeprom_instance_write(device_instance *instance,
const void *buf,
unsigned_word len)
{
hw_eeprom_instance *data = device_instance_data(instance);
int i;
if (data->eeprom->state != read_reset)
DITRACE(eeprom, ("eeprom not idle during instance write\n"));
for (i = 0; i < len; i++) {
data->eeprom->memory[data->pos] = ((unsigned8*)buf)[i];
data->pos = (data->pos + 1) % data->eeprom->sizeof_memory;
}
dump_eeprom(data->me, data->eeprom);
return len;
}
static int
hw_disk_instance_read(device_instance *instance,
void *buf,
unsigned_word len)
{
hw_disk_instance *data = device_instance_data(instance);
DITRACE(disk, ("read - instance=%ld len=%ld\n",
(unsigned long)device_instance_to_external(instance),
(long)len));
if ((data->pos + len) < data->pos)
return -1; /* overflow */
if (fseek(data->disk->image, data->pos, SEEK_SET) < 0)
return -1;
if (fread(buf, len, 1, data->disk->image) != 1)
return -1;
data->pos = ftell(data->disk->image);
return len;
}
static device_instance *
hw_disk_create_instance(device *me,
const char *path,
const char *args)
{
device_instance *instance;
hw_disk_device *disk = device_data(me);
hw_disk_instance *data = ZALLOC(hw_disk_instance);
data->disk = disk;
data->pos = 0;
instance = device_create_instance_from(me, NULL,
data,
path, args,
&hw_disk_instance_callbacks);
DITRACE(disk, ("create - path=%s(%s) instance=%ld\n",
path, args,
(unsigned long)device_instance_to_external(instance)));
return pk_disklabel_create_instance(instance, args);
}
