OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
98a497b3e9
binutils-gdb/sim/ppc/device.c
Michael Meissner 93fac32455 Changes from Andrew
1995-12-15 20:20:13 +00:00

1156 lines
26 KiB
C
Raw Blame History

/* This file is part of the program psim.
Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef _DEVICE_C_
#define _DEVICE_C_
#include <stdio.h>
#include "device_table.h"
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#else
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#endif
#include <ctype.h>
typedef struct _device_property_entry device_property_entry;
struct _device_property_entry {
const char *name;
device_property_entry *next;
device_property *value;
};
/* A device */
struct _device {
/* my name is ... */
const char *name;
const char *full_name;
/* device tree */
device *parent;
device *children;
device *sibling;
/* hw/sw callbacks */
void *data; /* device specific data */
const device_callbacks *callback;
/* device properties */
device_property_entry *properties;
};
device INLINE_DEVICE *
device_create(const char *name,
device *parent)
{
device_descriptor *descr;
int name_len;
char *chp;
chp = strchr(name, '@');
name_len = (chp == NULL ? strlen(name) : chp - name);
for (descr = device_table; descr->name != NULL; descr++) {
if (strncmp(name, descr->name, name_len) == 0
&& (descr->name[name_len] == '\0'
|| descr->name[name_len] == '@')) {
void *data = (descr->creator != NULL
? descr->creator(name, parent)
: NULL);
return device_create_from(name, data, descr->callbacks, parent);
}
}
error("device_create() unknown device %s\n", name);
return NULL;
}
device INLINE_DEVICE *
device_create_from(const char *name,
void *data,
const device_callbacks *callbacks,
device *parent)
{
device *new_device = ZALLOC(device);
new_device->data = data;
new_device->name = strdup(name);
new_device->callback = callbacks;
new_device->parent = parent;
return new_device;
}
device INLINE_DEVICE *
device_parent(device *me)
{
return me->parent;
}
const char INLINE_DEVICE *
device_name(device *me)
{
return me->name;
}
void INLINE_DEVICE *
device_data(device *me)
{
return me->data;
}
void INLINE_DEVICE
device_traverse_properties(device *me,
device_traverse_property_function *traverse,
void *data)
{
device_property_entry *entry = me->properties;
while (entry != NULL) {
traverse(me, entry->name, data);
entry = entry->next;
}
}
void INLINE_DEVICE
device_init(device *me,
psim *system)
{
me->callback->init(me, system);
}
void INLINE_DEVICE
device_attach_address(device *me,
const char *name,
attach_type attach,
int space,
unsigned_word addr,
unsigned nr_bytes,
access_type access,
device *who) /*callback/default*/
{
me->callback->attach_address(me, name, attach, space,
addr, nr_bytes, access, who);
}
void INLINE_DEVICE
device_detach_address(device *me,
const char *name,
attach_type attach,
int space,
unsigned_word addr,
unsigned nr_bytes,
access_type access,
device *who) /*callback/default*/
{
me->callback->detach_address(me, name, attach, space,
addr, nr_bytes, access, who);
}
unsigned INLINE_DEVICE
device_io_read_buffer(device *me,
void *dest,
int space,
unsigned_word addr,
unsigned nr_bytes,
cpu *processor,
unsigned_word cia)
{
return me->callback->io_read_buffer(me, dest, space,
addr, nr_bytes,
processor, cia);
}
unsigned INLINE_DEVICE
device_io_write_buffer(device *me,
const void *source,
int space,
unsigned_word addr,
unsigned nr_bytes,
cpu *processor,
unsigned_word cia)
{
return me->callback->io_write_buffer(me, source, space,
addr, nr_bytes,
processor, cia);
}
unsigned INLINE_DEVICE
device_dma_read_buffer(device *me,
void *dest,
int space,
unsigned_word addr,
unsigned nr_bytes)
{
return me->callback->dma_read_buffer(me, dest, space,
addr, nr_bytes);
}
unsigned INLINE_DEVICE
device_dma_write_buffer(device *me,
const void *source,
int space,
unsigned_word addr,
unsigned nr_bytes,
int violate_read_only_section)
{
return me->callback->dma_write_buffer(me, source, space,
addr, nr_bytes,
violate_read_only_section);
}
void INLINE_DEVICE
device_attach_interrupt(device *me,
device *who,
int interrupt_line,
const char *name)
{
me->callback->attach_interrupt(me, who, interrupt_line, name);
}
void INLINE_DEVICE
device_detach_interrupt(device *me,
device *who,
int interrupt_line,
const char *name)
{
me->callback->detach_interrupt(me, who, interrupt_line, name);
}
void INLINE_DEVICE
device_interrupt(device *me,
device *who,
int interrupt_line,
int interrupt_status,
cpu *processor,
unsigned_word cia)
{
me->callback->interrupt(me, who, interrupt_line, interrupt_status,
processor, cia);
}
void INLINE_DEVICE
device_interrupt_ack(device *me,
int interrupt_line,
int interrupt_status)
{
me->callback->interrupt_ack(me, interrupt_line, interrupt_status);
}
void EXTERN_DEVICE
device_ioctl(device *me,
psim *system,
cpu *processor,
unsigned_word cia,
...)
{
va_list ap;
va_start(ap, cia);
me->callback->ioctl(me, system, processor, cia, ap);
va_end(ap);
}
/* Manipulate properties attached to devices */
device_property STATIC_INLINE_DEVICE *
device_add_property(device *me,
const char *property,
device_property_type type,
const void *array,
int sizeof_array)
{
device_property_entry *new_entry = 0;
device_property *new_value = 0;
void *new_array = 0;
/* find the list end */
device_property_entry **insertion_point = &me->properties;
while (*insertion_point != NULL) {
if (strcmp((**insertion_point).name, property) == 0)
return (**insertion_point).value;
insertion_point = &(**insertion_point).next;
}
/* alloc data for the new property */
new_entry = ZALLOC(device_property_entry);
new_value = ZALLOC(device_property);
new_array = (sizeof_array > 0
? zalloc(sizeof_array)
: (void*)0);
/* insert the new property into the list */
*insertion_point = new_entry;
new_entry->name = strdup(property);
new_entry->value = new_value;
new_value->type = type;
new_value->sizeof_array = sizeof_array;
new_value->array = new_array;
if (sizeof_array > 0)
memcpy(new_array, array, sizeof_array);
return new_value;
}
void INLINE_DEVICE
device_add_array_property(device *me,
const char *property,
const void *array,
int sizeof_array)
{
TRACE(trace_devices,
("device_add_array_property(me=0x%lx, property=%s, ...)\n",
(long)me, property));
device_add_property(me, property,
array_property, array, sizeof_array);
}
void INLINE_DEVICE
device_add_integer_property(device *me,
const char *property,
signed32 integer)
{
TRACE(trace_devices,
("device_add_integer_property(me=0x%lx, property=%s, integer=%ld)\n",
(long)me, property, (long)integer));
H2BE(integer);
device_add_property(me, property, integer_property,
&integer, sizeof(integer));
}
void INLINE_DEVICE
device_add_boolean_property(device *me,
const char *property,
int boolean)
{
signed32 new_boolean = (boolean ? -1 : 0);
TRACE(trace_devices,
("device_add_boolean(me=0x%lx, property=%s, boolean=%d)\n",
(long)me, property, boolean));
device_add_property(me, property, boolean_property,
&new_boolean, sizeof(new_boolean));
}
void INLINE_DEVICE
device_add_null_property(device *me,
const char *property)
{
TRACE(trace_devices,
("device_add_null(me=0x%lx, property=%s)\n",
(long)me, property));
device_add_property(me, property, null_property,
NULL, 0);
}
void INLINE_DEVICE
device_add_string_property(device *me,
const char *property,
const char *string)
{
TRACE(trace_devices,
("device_add_property(me=0x%lx, property=%s, string=%s)\n",
(long)me, property, string));
device_add_property(me, property, string_property,
string, strlen(string) + 1);
}
const device_property INLINE_DEVICE *
device_find_property(device *me,
const char *property)
{
if (me != (device*)0) {
device_property_entry *entry = me->properties;
while (entry != (device_property_entry*)0) {
if (strcmp(entry->name, property) == 0)
return entry->value;
entry = entry->next;
}
}
return (device_property*)0;
}
const char INLINE_DEVICE *
device_find_next_property(device *me,
const char *property)
{
if (me != NULL) {
if (property == NULL || strcmp(property, "") == 0) {
return (me->properties != NULL
? me->properties->name
: NULL);
}
else {
device_property_entry *entry = me->properties;
while (entry != NULL) {
if (strcmp(entry->name, property) == 0)
return (entry->next != NULL
? entry->next->name
: NULL);
entry = entry->next;
}
}
}
return NULL;
}
const device_property INLINE_DEVICE *
device_find_array_property(device *me,
const char *property)
{
const device_property *node;
TRACE(trace_devices,
("device_find_integer(me=0x%lx, property=%s)\n",
(long)me, property));
node = device_find_property(me, property);
if (node == (device_property*)0
|| node->type != array_property)
error("%s property %s not found or of wrong type\n",
me->name, property);
return node;
}
signed_word INLINE_DEVICE
device_find_integer_property(device *me,
const char *property)
{
const device_property *node;
signed32 integer;
TRACE(trace_devices,
("device_find_integer(me=0x%lx, property=%s)\n",
(long)me, property));
node = device_find_property(me, property);
if (node == (device_property*)0
|| node->type != integer_property)
error("%s property %s not found or of wrong type\n",
me->name, property);
ASSERT(sizeof(integer) == node->sizeof_array);
memcpy(&integer, node->array, sizeof(integer));
BE2H(integer);
return integer;
}
int INLINE_DEVICE
device_find_boolean_property(device *me,
const char *property)
{
const device_property *node;
unsigned32 boolean;
TRACE(trace_devices,
("device_find_boolean(me=0x%lx, property=%s)\n",
(long)me, property));
node = device_find_property(me, property);
if (node == (device_property*)0
|| node->type != boolean_property)
error("%s property %s not found or of wrong type\n",
me->name, property);
ASSERT(sizeof(boolean) == node->sizeof_array);
memcpy(&boolean, node->array, sizeof(boolean));
return boolean;
}
const char INLINE_DEVICE *
device_find_string_property(device *me,
const char *property)
{
const device_property *node;
const char *string;
TRACE(trace_devices,
("device_find_string(me=0x%lx, property=%s)\n",
(long)me, property));
node = device_find_property(me, property);
if (node == (device_property*)0
|| node->type != string_property)
error("%s property %s not found or of wrong type\n",
me->name, property);
string = node->array;
ASSERT(strlen(string) + 1 == node->sizeof_array);
return string;
}
/* determine the full name of the device. If buf is specified it is
stored in there. Failing that, a safe area of memory is allocated */
const char STATIC_INLINE_DEVICE *
device_tree_full_name(device *leaf,
char *buf,
unsigned sizeof_buf)
{
/* get a buffer */
char full_name[1024];
if (buf == (char*)0) {
buf = full_name;
sizeof_buf = sizeof(full_name);
}
/* construct a name */
if (leaf->parent == NULL) {
if (sizeof_buf < 1)
error("device_full_name() buffer overflow\n");
*buf = '\0';
}
else {
device_tree_full_name(leaf->parent, buf, sizeof_buf);
if (strlen(buf) + strlen("/") + strlen(leaf->name) + 1 > sizeof_buf)
error("device_full_name() buffer overflow\n");
strcat(buf, "/");
strcat(buf, leaf->name);
}
/* return it usefully */
if (buf == full_name)
buf = strdup(full_name);
return buf;
}
/* find/create a node in the device tree */
typedef enum {
device_tree_return_null = 2,
device_tree_abort = 3,
} device_tree_action;
device STATIC_INLINE_DEVICE *
device_tree_find_node(device *root,
const char *path,
const char *full_path,
device_tree_action action)
{
const char *name;
int strlen_name;
device *child;
/* strip off any leading `/', `../' or `./' */
while (1) {
if (strncmp(path, "/", strlen("/")) == 0) {
while (root != NULL && root->parent != NULL)
root = root->parent;
path += strlen("/");
}
else if (strncmp(path, "./", strlen("./")) == 0) {
root = root;
path += strlen("./");
}
else if (strncmp(path, "../", strlen("../")) == 0) {
if (root != NULL && root->parent != NULL)
root = root->parent;
path += strlen("../");
}
else {
break;
}
}
/* parse the driver_name/unit-address */
ASSERT(*path != '/');
name = path;
while (isalnum(*path)
|| *path == ',' || *path == ',' || *path == '_'
|| *path == '+' || *path == '-')
path++;
if ((*path != '/' && *path != '@' && *path != ':' && *path != '\0')
|| (name == path && *name != '\0'))
error("device_tree: path %s invalid at %s\n", full_path, path);
/* parse the unit-address */
if (*path == '@') {
path++;
while ((*path != '\0' && *path != ':' && *path != '/')
|| (*path == ':' && path[-1] == '\\')
|| (*path == '/' && path[-1] == '\\'))
path++;
}
strlen_name = path - name;
/* skip the device-arguments */
if (*path == ':') {
path++;
while ((*path != '\0' && *path != '/' && *path != ':' && *path != '@')
|| (*path == '/' && path[-1] == '\\')
|| (*path == ':' && path[-1] == '\\')
|| (*path == '@' && path[-1] == '\\'))
path++;
}
/* sanity checks */
if (*path != '\0' && *path != '/')
error("device_tree: path %s invalid at %s\n", full_path, path);
/* leaf? and growing? */
if (name[0] == '\0') {
return root;
}
else if (root != NULL) {
for (child = root->children;
child != NULL;
child = child->sibling) {
if (strncmp(name, child->name, strlen_name) == 0
&& strlen(child->name) == strlen_name) {
if (*path == '\0')
return child;
else
return device_tree_find_node(child,
path + 1/* / */,
full_path,
action);
}
}
}
/* search failed, take default action */
switch (action) {
case device_tree_return_null:
return NULL;
case device_tree_abort:
error("device_tree_find_node() could not find %s in tree\n",
full_path);
return NULL;
default:
error("device_tree_find_node() invalid default action %d\n", action);
return NULL;
}
}
/* grow the device tree */
device INLINE_DEVICE *
device_tree_add_device(device *root,
const char *prefix,
device *new_sub_tree)
{
device *parent;
TRACE(trace_device_tree,
("device_tree_add_device(root=0x%lx, prefix=%s, dev=0x%lx)\n",
(long)root, prefix, (long)new_sub_tree));
/* find our parent */
parent = device_tree_find_node(root,
prefix,
prefix, /* full-path */
device_tree_abort);
/* create/insert a new child */
new_sub_tree->parent = parent;
if (parent != NULL) {
device **sibling = &parent->children;
while ((*sibling) != NULL)
sibling = &(*sibling)->sibling;
*sibling = new_sub_tree;
}
return new_sub_tree;
}
device INLINE_DEVICE *
device_tree_find_device(device *root,
const char *path)
{
device *node;
TRACE(trace_device_tree,
("device_tree_find_device_tree(root=0x%lx, path=%s)\n",
(long)root, path));
node = device_tree_find_node(root,
path,
path, /* full-name */
device_tree_return_null);
return node;
}
/* init all the devices */
void STATIC_INLINE_DEVICE
device_tree_init_device(device *root,
void *data)
{
psim *system;
system = (psim*)data;
TRACE(trace_device_tree,
("device_tree_init() initializing device=0x%lx:%s\n",
(long)root, root->full_name));
device_init(root, system);
}
void INLINE_DEVICE
device_tree_init(device *root,
psim *system)
{
TRACE(trace_device_tree,
("device_tree_init(root=0x%lx, system=0x%lx)\n", (long)root, (long)system));
device_tree_traverse(root, device_tree_init_device, NULL, system);
TRACE(trace_device_tree,
("device_tree_init() = void\n"));
}
/* traverse a device tree applying prefix/postfix functions to it */
void INLINE_DEVICE
device_tree_traverse(device *root,
device_tree_traverse_function *prefix,
device_tree_traverse_function *postfix,
void *data)
{
device *child;
if (prefix != NULL)
prefix(root, data);
for (child = root->children; child != NULL; child = child->sibling) {
device_tree_traverse(child, prefix, postfix, data);
}
if (postfix != NULL)
postfix(root, data);
}
/* dump out a device node and addresses */
void INLINE_DEVICE
device_tree_dump(device *device,
void *ignore_data_argument)
{
printf_filtered("(device_tree@0x%lx\n", (long)device);
printf_filtered(" (parent 0x%lx)\n", (long)device->parent);
printf_filtered(" (children 0x%lx)\n", (long)device->children);
printf_filtered(" (sibling 0x%lx)\n", (long)device->sibling);
printf_filtered(" (name %s)\n", device->name);
error("FIXME - need to print out properties\n");
printf_filtered(")\n");
}
/* lookup/create a device various formats */
void STATIC_INLINE_DEVICE
u_strcat(char *buf,
unsigned_word uw)
{
if (MASKED64(uw, 32, 63) == uw
|| WITH_HOST_WORD_BITSIZE == 64) {
char *end = strchr(buf, '\0');
sprintf(end, "0x%x", (unsigned)uw);
}
else {
char *end = strchr(buf, '\0');
sprintf(end, "0x%x%08x",
(unsigned)EXTRACTED64(uw, 0, 31),
(unsigned)EXTRACTED64(uw, 32, 63));
}
}
void STATIC_INLINE_DEVICE
c_strcat(char *buf,
const char *c)
{
char *end = strchr(buf, '\0');
while (*c) {
if (*c == '/' || *c == ',')
*end++ = '\\';
*end++ = *c++;
}
*end = '\0';
}
device INLINE_DEVICE *
device_tree_add_found(device *root,
const char *prefix,
const char *name)
{
device *parent;
device *new_device;
device *new_node;
TRACE(trace_device_tree,
("device_tree_add_found(root=0x%lx, prefix=%s, name=%x)\n",
(long)root, prefix, name));
parent = device_tree_find_node(root, prefix, prefix,
device_tree_abort);
new_device = device_tree_find_device(parent, name);
if (new_device != NULL)
return new_device;
else {
new_device = device_create(name, parent);
new_node = device_tree_add_device(parent, "", new_device);
ASSERT(new_device == new_node);
return new_node;
}
}
device INLINE_DEVICE *
device_tree_add_found_c(device *root,
const char *prefix,
const char *name,
const char *c1)
{
char buf[1024];
strcpy(buf, name);
strcat(buf, "@");
c_strcat(buf, c1);
if (strlen(buf) + 1 >= sizeof(buf))
error("device_tree_add_found_c - buffer overflow\n");
return device_tree_add_found(root, prefix, buf);
}
device INLINE_DEVICE *
device_tree_add_found_c_uw(device *root,
const char *prefix,
const char *name,
const char *c1,
unsigned_word uw2)
{
char buf[1024];
strcpy(buf, name);
strcat(buf, "@");
c_strcat(buf, c1);
strcat(buf, ",");
u_strcat(buf, uw2);
if (strlen(buf) + 1 >= sizeof(buf))
error("device_tree_add_found_* - buffer overflow\n");
return device_tree_add_found(root, prefix, buf);
}
device INLINE_DEVICE *
device_tree_add_found_uw_u(device *root,
const char *prefix,
const char *name,
unsigned_word uw1,
unsigned u2)
{
char buf[1024];
strcpy(buf, name);
strcat(buf, "@");
u_strcat(buf, uw1);
strcat(buf, ",");
u_strcat(buf, u2);
if (strlen(buf) + 1 >= sizeof(buf))
error("device_tree_add_found_* - buffer overflow\n");
return device_tree_add_found(root, prefix, buf);
}
device INLINE_DEVICE *
device_tree_add_found_uw_u_u(device *root,
const char *prefix,
const char *name,
unsigned_word uw1,
unsigned u2,
unsigned u3)
{
char buf[1024];
strcpy(buf, name);
strcat(buf, "@");
u_strcat(buf, uw1);
strcat(buf, ",");
u_strcat(buf, u2);
strcat(buf, ",");
u_strcat(buf, u3);
if (strlen(buf) + 1 >= sizeof(buf))
error("device_tree_add_found_* - buffer overflow\n");
return device_tree_add_found(root, prefix, buf);
}
device INLINE_DEVICE *
device_tree_add_found_uw_u_u_c(device *root,
const char *prefix,
const char *name,
unsigned_word uw1,
unsigned u2,
unsigned u3,
const char *c4)
{
char buf[1024];
strcpy(buf, name);
strcat(buf, "@");
u_strcat(buf, uw1);
strcat(buf, ",");
u_strcat(buf, u2);
strcat(buf, ",");
u_strcat(buf, u3);
strcat(buf, ",");
c_strcat(buf, c4);
if (strlen(buf) + 1 >= sizeof(buf))
error("device_tree_add_found_* - buffer overflow\n");
return device_tree_add_found(root, prefix, buf);
}
device INLINE_DEVICE *
device_tree_add_found_uw_uw_u_u_c(device *root,
const char *prefix,
const char *name,
unsigned_word uw1,
unsigned_word uw2,
unsigned u3,
unsigned u4,
const char *c5)
{
char buf[1024];
strcpy(buf, name);
strcat(buf, "@");
u_strcat(buf, uw1);
strcat(buf, ",");
u_strcat(buf, uw2);
strcat(buf, ",");
u_strcat(buf, u3);
strcat(buf, ",");
u_strcat(buf, u4);
strcat(buf, ",");
c_strcat(buf, c5);
if (strlen(buf) + 1 >= sizeof(buf))
error("device_tree_add_found_* - buffer overflow\n");
return device_tree_add_found(root, prefix, buf);
}
device INLINE_DEVICE *
device_tree_add_found_uw_uw_u_u_u(device *root,
const char *prefix,
const char *name,
unsigned_word uw1,
unsigned_word uw2,
unsigned u3,
unsigned u4,
unsigned u5)
{
char buf[1024];
strcpy(buf, name);
strcat(buf, "@");
u_strcat(buf, uw1);
strcat(buf, ",");
u_strcat(buf, uw2);
strcat(buf, ",");
u_strcat(buf, u3);
strcat(buf, ",");
u_strcat(buf, u4);
strcat(buf, ",");
u_strcat(buf, u5);
if (strlen(buf) + 1 >= sizeof(buf))
error("device_tree_add_found_* - buffer overflow\n");
return device_tree_add_found(root, prefix, buf);
}
/* Parse a device name, various formats */
#define SCAN_INIT(NAME) \
char *START = (char*)0; \
char *END = (char*)0; \
int COUNT = -1; \
/* find the first element */ \
END = strchr(NAME, '@'); \
if (END == (char*)0) \
return COUNT; \
COUNT += 1; \
START = END + 1
#define SCAN_END \
return COUNT
#define SCAN_U(U) \
do { \
*U = strtoul(START, &END, 0); \
if (START == END) \
return COUNT; \
COUNT += 1; \
if (*END != ',') \
return COUNT; \
START = END + 1; \
} while (0)
#define SCAN_P(P) \
do { \
*P = (void*)(unsigned)strtouq(START, END, 0); \
if (START == END) \
return COUNT; \
COUNT += 1; \
if (*END != ',') \
return COUNT; \
START = END + 1; \
} while (0)
#define SCAN_C(C, SIZE) \
do { \
char *chp = C; \
END = START; \
while (*END != '\0' && *END != ',') { \
if (*END == '\\') \
END += 1; \
*chp = *END; \
chp += 1; \
END += 1; \
if ((SIZE) <= ((END) - (START))) \
return COUNT; /* overflow */ \
} \
*chp = '\0'; \
if (START == END) \
return COUNT; \
COUNT += 1; \
if (*END != ',') \
return COUNT; \
START = END + 1; \
} while (0)
int INLINE_DEVICE
scand_c(const char *name,
char *c1,
unsigned c1size)
{
SCAN_INIT(name);
SCAN_C(c1, c1size);
SCAN_END;
}
int INLINE_DEVICE
scand_c_uw_u(const char *name,
char *c1,
unsigned c1size,
unsigned_word *uw2,
unsigned *u3)
{
SCAN_INIT(name);
SCAN_C(c1, c1size);
SCAN_U(uw2);
SCAN_U(u3);
SCAN_END;
}
int INLINE_DEVICE
scand_uw(const char *name,
unsigned_word *uw1)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_END;
}
int INLINE_DEVICE
scand_uw_c(const char *name,
unsigned_word *uw1,
char *c2,
unsigned c2size)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_C(c2, c2size);
SCAN_END;
}
int INLINE_DEVICE
scand_uw_u(const char *name,
unsigned_word *uw1,
unsigned *u2)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_U(u2);
SCAN_END;
}
int INLINE_DEVICE
scand_uw_u_u(const char *name,
unsigned_word *uw1,
unsigned *u2,
unsigned *u3)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_U(u2);
SCAN_U(u3);
SCAN_END;
}
int INLINE_DEVICE
scand_uw_u_u_c(const char *name,
unsigned_word *uw1,
unsigned *u2,
unsigned *u3,
char *c4,
unsigned c4size)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_U(u2);
SCAN_U(u3);
SCAN_C(c4, c4size);
SCAN_END;
}
int INLINE_DEVICE
scand_uw_uw(const char *name,
unsigned_word *uw1,
unsigned_word *uw2)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_U(uw2);
SCAN_END;
}
int INLINE_DEVICE
scand_uw_uw_u(const char *name,
unsigned_word *uw1,
unsigned_word *uw2,
unsigned *u3)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_U(uw2);
SCAN_U(u3);
SCAN_END;
}
int INLINE_DEVICE
scand_uw_uw_u_u_c(const char *name,
unsigned_word *uw1,
unsigned_word *uw2,
unsigned *u3,
unsigned *u4,
char *c5,
unsigned c5size)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_U(uw2);
SCAN_U(u3);
SCAN_U(u4);
SCAN_C(c5, c5size);
SCAN_END;
}
int INLINE_DEVICE
scand_uw_uw_u_u_u(const char *name,
unsigned_word *uw1,
unsigned_word *uw2,
unsigned *u3,
unsigned *u4,
unsigned *u5)
{
SCAN_INIT(name);
SCAN_U(uw1);
SCAN_U(uw2);
SCAN_U(u3);
SCAN_U(u4);
SCAN_U(u5);
SCAN_END;
}
#endif /* _DEVICE_C_ */
Reference in New Issue View Git Blame Copy Permalink