static int device_load_cassette(mess_image *image)
{
casserr_t err;
int cassette_flags;
struct mess_cassetteimg *tag;
const struct IODevice *dev;
const struct CassetteFormat **formats;
const struct CassetteOptions *create_opts;
const char *extension;
int is_writable;
tag = get_cassimg(image);
/* figure out the cassette format */
dev = device_find(Machine->devices, IO_CASSETTE);
formats = device_get_info_ptr(&dev->devclass, DEVINFO_PTR_CASSETTE_FORMATS);
if (image_has_been_created(image))
{
/* creating an image */
create_opts = (const struct CassetteOptions *) device_get_info_ptr(&dev->devclass, DEVINFO_PTR_CASSETTE_OPTIONS);
err = cassette_create(image, &mess_ioprocs, &wavfile_format, create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &tag->cassette);
if (err)
goto error;
}
else
{
/* opening an image */
do
{
is_writable = image_is_writable(image);
cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY;
extension = image_filetype(image);
err = cassette_open_choices(image, &mess_ioprocs, extension, formats, cassette_flags, &tag->cassette);
/* this is kind of a hack */
if (err && is_writable)
image_make_readonly(image);
}
while(err && is_writable);
if (err)
goto error;
}
/* set to default state, but only change the UI state */
cassette_change_state(image, get_default_state(dev), CASSETTE_MASK_UISTATE);
/* reset the position */
tag->position = 0.0;
tag->position_time = timer_get_time();
return INIT_PASS;
error:
return INIT_FAIL;
}
static int internal_floppy_device_load(mess_image *image, mame_file *file, int create_format, option_resolution *create_args)
{
floperr_t err;
struct mess_flopimg *flopimg;
const struct IODevice *dev;
const struct FloppyFormat *floppy_options;
int floppy_flags, i;
const char *extension;
/* look up instance data */
flopimg = get_flopimg(image);
/* figure out the floppy options */
dev = image_device(image);
floppy_options = device_get_info_ptr(&dev->devclass, DEVINFO_PTR_FLOPPY_OPTIONS);
if (image_has_been_created(image))
{
/* creating an image */
assert(create_format >= 0);
err = floppy_create(file, &mess_ioprocs, &floppy_options[create_format], create_args, &flopimg->floppy);
if (err)
goto error;
}
else
{
/* opening an image */
floppy_flags = image_is_writable(image) ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY;
extension = image_filetype(image);
err = floppy_open_choices(file, &mess_ioprocs, extension, floppy_options, floppy_flags, &flopimg->floppy);
if (err)
goto error;
}
/* if we can get head and track counts, then set the geometry accordingly */
if (floppy_callbacks(flopimg->floppy)->get_heads_per_disk
&& floppy_callbacks(flopimg->floppy)->get_tracks_per_disk)
{
floppy_drive_set_geometry_absolute(image,
floppy_get_tracks_per_disk(flopimg->floppy),
floppy_get_heads_per_disk(flopimg->floppy));
}
return INIT_PASS;
error:
for (i = 0; i < sizeof(errmap) / sizeof(errmap[0]); i++)
{
if (err == errmap[i].ferr)
image_seterror(image, errmap[i].ierr, errmap[i].message);
}
return INIT_FAIL;
}
void cassette_device_getinfo(const device_class *devclass, UINT32 state, union devinfo *info)
{
char *s;
int i;
const struct CassetteFormat **formats;
switch(state)
{
/* --- the following bits of info are returned as 64-bit signed integers --- */
case DEVINFO_INT_TYPE: info->i = IO_CASSETTE; break;
case DEVINFO_INT_READABLE: info->i = 1; break;
case DEVINFO_INT_WRITEABLE: info->i = 1; break;
case DEVINFO_INT_CREATABLE: info->i = 1; break;
case DEVINFO_INT_CASSETTE_DEFAULT_STATE: info->i = CASSETTE_PLAY; break;
/* --- the following bits of info are returned as pointers to data or functions --- */
case DEVINFO_PTR_INIT: info->init = device_init_cassette; break;
case DEVINFO_PTR_LOAD: info->load = device_load_cassette; break;
case DEVINFO_PTR_UNLOAD: info->unload = device_unload_cassette; break;
case DEVINFO_PTR_DISPLAY: info->display = device_display_cassette; break;
case DEVINFO_PTR_CASSETTE_FORMATS: info->p = (void *) cassette_default_formats; break;
/* --- the following bits of info are returned as NULL-terminated strings --- */
case DEVINFO_STR_DEV_FILE: strcpy(info->s = device_temp_str(), __FILE__); break;
case DEVINFO_STR_FILE_EXTENSIONS:
formats = device_get_info_ptr(devclass, DEVINFO_PTR_CASSETTE_FORMATS);
info->s = s = device_temp_str();
s[0] = '\0';
s[1] = '\0';
for (i = 0; formats[i]; i++)
specify_extension(s, 256, formats[i]->extensions);
while(s[strlen(s) + 1] != '\0')
{
s += strlen(s);
*(s++) = ',';
}
break;
}
}
void floppy_device_getinfo(const device_class *devclass, UINT32 state, union devinfo *info)
{
char *s;
int i, count;
const struct FloppyFormat *floppy_options;
switch(state)
{
/* --- the following bits of info are returned as 64-bit signed integers --- */
case DEVINFO_INT_TYPE: info->i = IO_FLOPPY; break;
case DEVINFO_INT_READABLE: info->i = 1; break;
case DEVINFO_INT_WRITEABLE: info->i = 1; break;
case DEVINFO_INT_CREATABLE:
floppy_options = device_get_info_ptr(devclass, DEVINFO_PTR_FLOPPY_OPTIONS);
info->i = floppy_options->param_guidelines ? 1 : 0;
break;
case DEVINFO_INT_CREATE_OPTCOUNT:
/* count total floppy options */
floppy_options = device_get_info_ptr(devclass, DEVINFO_PTR_FLOPPY_OPTIONS);
for (count = 0; floppy_options[count].construct; count++)
;
info->i = count;
break;
/* --- the following bits of info are returned as NULL-terminated strings --- */
case DEVINFO_STR_FILE_EXTENSIONS:
floppy_options = device_get_info_ptr(devclass, DEVINFO_PTR_FLOPPY_OPTIONS);
s = device_temp_str();
info->s = s;
s[0] = '\0';
s[1] = '\0';
for (i = 0; floppy_options[i].construct; i++)
specify_extension(s, 256, floppy_options[i].extensions);
while(s[strlen(s) + 1] != '\0')
{
s += strlen(s);
*(s++) = ',';
}
break;
/* --- the following bits of info are returned as pointers to data or functions --- */
case DEVINFO_PTR_INIT: info->init = device_init_floppy; break;
case DEVINFO_PTR_LOAD: info->load = device_load_floppy; break;
case DEVINFO_PTR_CREATE: info->create = device_create_floppy; break;
case DEVINFO_PTR_UNLOAD: info->unload = device_unload_floppy; break;
case DEVINFO_PTR_CREATE_OPTGUIDE: info->p = (void *) floppy_option_guide; break;
default:
floppy_options = device_get_info_ptr(devclass, DEVINFO_PTR_FLOPPY_OPTIONS);
if ((state >= DEVINFO_STR_CREATE_OPTNAME) && (state < DEVINFO_STR_CREATE_OPTNAME + DEVINFO_CREATE_OPTMAX))
{
info->s = (void *) floppy_options[state - DEVINFO_STR_CREATE_OPTNAME].name;
}
else if ((state >= DEVINFO_STR_CREATE_OPTDESC) && (state < DEVINFO_STR_CREATE_OPTDESC + DEVINFO_CREATE_OPTMAX))
{
info->s = (void *) floppy_options[state - DEVINFO_STR_CREATE_OPTDESC].description;
}
else if ((state >= DEVINFO_STR_CREATE_OPTEXTS) && (state < DEVINFO_STR_CREATE_OPTEXTS + DEVINFO_CREATE_OPTMAX))
{
info->s = (void *) floppy_options[state - DEVINFO_STR_CREATE_OPTEXTS].extensions;
}
else if ((state >= DEVINFO_PTR_CREATE_OPTSPEC) && (state < DEVINFO_PTR_CREATE_OPTSPEC + DEVINFO_CREATE_OPTMAX))
{
info->p = (void *) floppy_options[state - DEVINFO_PTR_CREATE_OPTSPEC].param_guidelines;
}
break;
}
}
static void machine_config_detokenize(machine_config *config, const machine_config_token *tokens, const device_config *owner, int depth)
{
UINT32 entrytype = MCONFIG_TOKEN_INVALID;
astring *tempstring = astring_alloc();
device_config *device = NULL;
/* loop over tokens until we hit the end */
while (entrytype != MCONFIG_TOKEN_END)
{
device_custom_config_func custom;
int size, offset, bits;
UINT32 data32, clock;
device_type devtype;
const char *tag;
UINT64 data64;
/* unpack the token from the first entry */
TOKEN_GET_UINT32_UNPACK1(tokens, entrytype, 8);
switch (entrytype)
{
/* end */
case MCONFIG_TOKEN_END:
break;
/* including */
case MCONFIG_TOKEN_INCLUDE:
machine_config_detokenize(config, TOKEN_GET_PTR(tokens, tokenptr), owner, depth + 1);
break;
/* device management */
case MCONFIG_TOKEN_DEVICE_ADD:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, clock, 32);
devtype = TOKEN_GET_PTR(tokens, devtype);
tag = TOKEN_GET_STRING(tokens);
device = device_list_add(&config->devicelist, owner, devtype, device_build_tag(tempstring, owner, tag), clock);
break;
case MCONFIG_TOKEN_DEVICE_REMOVE:
tag = TOKEN_GET_STRING(tokens);
remove_device(&config->devicelist, device_build_tag(tempstring, owner, tag));
device = NULL;
break;
case MCONFIG_TOKEN_DEVICE_MODIFY:
tag = TOKEN_GET_STRING(tokens);
device = (device_config *)device_list_find_by_tag(config->devicelist, device_build_tag(tempstring, owner, tag));
if (device == NULL)
fatalerror("Unable to find device: tag=%s\n", astring_c(tempstring));
break;
case MCONFIG_TOKEN_DEVICE_CLOCK:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT64_UNPACK2(tokens, entrytype, 8, device->clock, 32);
break;
case MCONFIG_TOKEN_DEVICE_MAP:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, data32, 8);
device->address_map[data32] = TOKEN_GET_PTR(tokens, addrmap);
break;
case MCONFIG_TOKEN_DEVICE_CONFIG:
assert(device != NULL);
device->static_config = TOKEN_GET_PTR(tokens, voidptr);
break;
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_1:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_2:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_3:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_4:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_5:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_6:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_7:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_8:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_9:
case MCONFIG_TOKEN_DEVICE_CONFIG_CUSTOM_FREE:
assert(device != NULL);
custom = (device_custom_config_func)devtype_get_info_fct(device->type, DEVINFO_FCT_CUSTOM_CONFIG);
assert(custom != NULL);
tokens = (*custom)(device, entrytype, tokens);
break;
case MCONFIG_TOKEN_DEVICE_CONFIG_DATA32:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, size, 4, offset, 12);
data32 = TOKEN_GET_UINT32(tokens);
switch (size)
{
case 1: *(UINT8 *) ((UINT8 *)device->inline_config + offset) = data32; break;
case 2: *(UINT16 *)((UINT8 *)device->inline_config + offset) = data32; break;
case 4: *(UINT32 *)((UINT8 *)device->inline_config + offset) = data32; break;
}
break;
case MCONFIG_TOKEN_DEVICE_CONFIG_DATA64:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, size, 4, offset, 12);
TOKEN_EXTRACT_UINT64(tokens, data64);
switch (size)
{
case 1: *(UINT8 *) ((UINT8 *)device->inline_config + offset) = data64; break;
case 2: *(UINT16 *)((UINT8 *)device->inline_config + offset) = data64; break;
case 4: *(UINT32 *)((UINT8 *)device->inline_config + offset) = data64; break;
case 8: *(UINT64 *)((UINT8 *)device->inline_config + offset) = data64; break;
}
break;
case MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32:
assert(device != NULL);
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK4(tokens, entrytype, 8, size, 4, bits, 6, offset, 12);
data32 = TOKEN_GET_UINT32(tokens);
switch (size)
{
case 4: *(float *)((UINT8 *)device->inline_config + offset) = (float)(INT32)data32 / (float)(1 << bits); break;
case 8: *(double *)((UINT8 *)device->inline_config + offset) = (double)(INT32)data32 / (double)(1 << bits); break;
}
break;
/* core parameters */
case MCONFIG_TOKEN_DRIVER_DATA:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->driver_data_size, 24);
break;
case MCONFIG_TOKEN_QUANTUM_TIME:
TOKEN_EXTRACT_UINT64(tokens, data64);
config->minimum_quantum = UINT64_ATTOTIME_TO_ATTOTIME(data64);
break;
case MCONFIG_TOKEN_QUANTUM_PERFECT_CPU:
config->perfect_cpu_quantum = TOKEN_GET_STRING(tokens);
break;
case MCONFIG_TOKEN_WATCHDOG_VBLANK:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->watchdog_vblank_count, 24);
break;
case MCONFIG_TOKEN_WATCHDOG_TIME:
TOKEN_EXTRACT_UINT64(tokens, data64);
config->watchdog_time = UINT64_ATTOTIME_TO_ATTOTIME(data64);
break;
/* core functions */
case MCONFIG_TOKEN_MACHINE_START:
config->machine_start = TOKEN_GET_PTR(tokens, machine_start);
break;
case MCONFIG_TOKEN_MACHINE_RESET:
config->machine_reset = TOKEN_GET_PTR(tokens, machine_reset);
break;
case MCONFIG_TOKEN_NVRAM_HANDLER:
config->nvram_handler = TOKEN_GET_PTR(tokens, nvram_handler);
break;
case MCONFIG_TOKEN_MEMCARD_HANDLER:
config->memcard_handler = TOKEN_GET_PTR(tokens, memcard_handler);
break;
/* core video parameters */
case MCONFIG_TOKEN_VIDEO_ATTRIBUTES:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->video_attributes, 24);
break;
case MCONFIG_TOKEN_GFXDECODE:
config->gfxdecodeinfo = TOKEN_GET_PTR(tokens, gfxdecode);
break;
case MCONFIG_TOKEN_PALETTE_LENGTH:
TOKEN_UNGET_UINT32(tokens);
TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->total_colors, 24);
break;
case MCONFIG_TOKEN_DEFAULT_LAYOUT:
config->default_layout = TOKEN_GET_STRING(tokens);
break;
/* core video functions */
case MCONFIG_TOKEN_PALETTE_INIT:
config->init_palette = TOKEN_GET_PTR(tokens, palette_init);
break;
case MCONFIG_TOKEN_VIDEO_START:
config->video_start = TOKEN_GET_PTR(tokens, video_start);
break;
case MCONFIG_TOKEN_VIDEO_RESET:
config->video_reset = TOKEN_GET_PTR(tokens, video_reset);
break;
case MCONFIG_TOKEN_VIDEO_EOF:
config->video_eof = TOKEN_GET_PTR(tokens, video_eof);
break;
case MCONFIG_TOKEN_VIDEO_UPDATE:
config->video_update = TOKEN_GET_PTR(tokens, video_update);
break;
/* core sound functions */
case MCONFIG_TOKEN_SOUND_START:
config->sound_start = TOKEN_GET_PTR(tokens, sound_start);
break;
case MCONFIG_TOKEN_SOUND_RESET:
config->sound_reset = TOKEN_GET_PTR(tokens, sound_reset);
break;
default:
fatalerror("Invalid token %d in machine config\n", entrytype);
break;
}
}
/* if we are the outermost level, process any device-specific machine configurations */
if (depth == 0)
for (device = config->devicelist; device != NULL; device = device->next)
{
tokens = (const machine_config_token *)device_get_info_ptr(device, DEVINFO_PTR_MACHINE_CONFIG);
if (tokens != NULL)
machine_config_detokenize(config, tokens, device, depth + 1);
}
astring_free(tempstring);
}
struct IODevice *devices_allocate(const game_driver *gamedrv)
{
struct SystemConfigurationParamBlock params;
device_getinfo_handler handlers[64];
int count_overrides[sizeof(handlers) / sizeof(handlers[0])];
int createimage_optcount, count, i, j, position;
const char *file_extensions, *info_string;
char *converted_file_extensions;
struct IODevice *devices = NULL;
memset(handlers, 0, sizeof(handlers));
memset(count_overrides, 0, sizeof(count_overrides));
if (gamedrv->sysconfig_ctor)
{
memset(¶ms, 0, sizeof(params));
params.device_slotcount = sizeof(handlers) / sizeof(handlers[0]);
params.device_handlers = handlers;
params.device_countoverrides = count_overrides;
gamedrv->sysconfig_ctor(¶ms);
}
/* count the amount of handlers that we have available */
for (count = 0; handlers[count]; count++)
;
count++; /* for our purposes, include the tailing empty device */
devices = (struct IODevice *) auto_malloc(count * sizeof(struct IODevice));
memset(devices, 0, count * sizeof(struct IODevice));
position = 0;
for (i = 0; i < count; i++)
{
devices[i].type = IO_COUNT;
if (handlers[i])
{
devices[i].devclass.get_info = handlers[i];
devices[i].devclass.gamedrv = gamedrv;
/* convert file extensions from comma delimited to null delimited */
converted_file_extensions = NULL;
file_extensions = device_get_info_string(&devices[i].devclass, DEVINFO_STR_FILE_EXTENSIONS);
if (file_extensions)
{
converted_file_extensions = auto_malloc(strlen(file_extensions) + 2);
for (j = 0; file_extensions[j]; j++)
converted_file_extensions[j] = (file_extensions[j] != ',') ? file_extensions[j] : '\0';
converted_file_extensions[j + 0] = '\0';
converted_file_extensions[j + 1] = '\0';
}
info_string = device_get_info_string(&devices[i].devclass, DEVINFO_STR_DEV_TAG);
devices[i].tag = info_string ? auto_strdup(info_string) : NULL;
devices[i].type = device_get_info_int(&devices[i].devclass, DEVINFO_INT_TYPE);
devices[i].count = device_get_info_int(&devices[i].devclass, DEVINFO_INT_COUNT);
devices[i].position = position;
devices[i].file_extensions = converted_file_extensions;
devices[i].readable = device_get_info_int(&devices[i].devclass, DEVINFO_INT_READABLE) ? 1 : 0;
devices[i].writeable = device_get_info_int(&devices[i].devclass, DEVINFO_INT_WRITEABLE) ? 1 : 0;
devices[i].creatable = device_get_info_int(&devices[i].devclass, DEVINFO_INT_CREATABLE) ? 1 : 0;
devices[i].reset_on_load = device_get_info_int(&devices[i].devclass, DEVINFO_INT_RESET_ON_LOAD) ? 1 : 0;
devices[i].must_be_loaded = device_get_info_int(&devices[i].devclass, DEVINFO_INT_MUST_BE_LOADED) ? 1 : 0;
devices[i].load_at_init = device_get_info_int(&devices[i].devclass, DEVINFO_INT_LOAD_AT_INIT) ? 1 : 0;
devices[i].not_working = device_get_info_int(&devices[i].devclass, DEVINFO_INT_NOT_WORKING) ? 1 : 0;
devices[i].init = (device_init_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_INIT);
devices[i].exit = (device_exit_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_EXIT);
devices[i].load = (device_load_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_LOAD);
devices[i].create = (device_create_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_CREATE);
devices[i].unload = (device_unload_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_UNLOAD);
devices[i].imgverify = (device_verify_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_VERIFY);
devices[i].partialhash = (device_partialhash_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_PARTIAL_HASH);
devices[i].getdispositions = (device_getdispositions_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_GET_DISPOSITIONS);
devices[i].display = (device_display_handler) device_get_info_fct(&devices[i].devclass, DEVINFO_PTR_DISPLAY);
devices[i].name = default_device_name;
devices[i].createimage_optguide = (const struct OptionGuide *) device_get_info_ptr(&devices[i].devclass, DEVINFO_PTR_CREATE_OPTGUIDE);
createimage_optcount = (int) device_get_info_int(&devices[i].devclass, DEVINFO_INT_CREATE_OPTCOUNT);
if (createimage_optcount > 0)
{
if (createimage_optcount > DEVINFO_CREATE_OPTMAX)
fatalerror("DEVINFO_INT_CREATE_OPTCOUNT: Too many options");
devices[i].createimage_options = auto_malloc((createimage_optcount + 1) *
sizeof(*devices[i].createimage_options));
for (j = 0; j < createimage_optcount; j++)
{
info_string = device_get_info_string(&devices[i].devclass, DEVINFO_STR_CREATE_OPTNAME + j);
devices[i].createimage_options[j].name = info_string ? auto_strdup(info_string) : NULL;
info_string = device_get_info_string(&devices[i].devclass, DEVINFO_STR_CREATE_OPTDESC + j);
devices[i].createimage_options[j].description = info_string ? auto_strdup(info_string) : NULL;
info_string = device_get_info_string(&devices[i].devclass, DEVINFO_STR_CREATE_OPTEXTS + j);
devices[i].createimage_options[j].extensions = info_string ? auto_strdup(info_string) : NULL;
devices[i].createimage_options[j].optspec = device_get_info_ptr(&devices[i].devclass, DEVINFO_PTR_CREATE_OPTSPEC + j);
}
/* terminate the list */
memset(&devices[i].createimage_options[createimage_optcount], 0,
sizeof(devices[i].createimage_options[createimage_optcount]));
}
position += devices[i].count;
/* overriding the count? */
if (count_overrides[i])
devices[i].count = count_overrides[i];
/* any problems? */
if ((devices[i].type < 0) || (devices[i].type >= IO_COUNT))
goto error;
if ((devices[i].count < 0) || (devices[i].count > MAX_DEV_INSTANCES))
goto error;
/* fill in defaults */
if (!devices[i].getdispositions)
devices[i].getdispositions = default_device_getdispositions;
}
}
return devices;
error:
return NULL;
}