int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags)
{
struct udevice *dev = desc->dev;
struct dm_gpio_ops *ops = gpio_get_ops(dev);
int ret;
ret = check_reserved(desc, "set_dir");
if (ret)
return ret;
if (flags & GPIOD_IS_OUT) {
int value = flags & GPIOD_IS_OUT_ACTIVE ? 1 : 0;
if (flags & GPIOD_ACTIVE_LOW)
value = !value;
ret = ops->direction_output(dev, desc->offset, value);
} else if (flags & GPIOD_IS_IN) {
ret = ops->direction_input(dev, desc->offset);
}
if (ret)
return ret;
/*
* Update desc->flags here, so that GPIO_ACTIVE_LOW is honoured in
* futures
*/
desc->flags = flags;
return 0;
}
/* set GPIO port 'offset' as an input */
static int sb_gpio_direction_input(struct udevice *dev, unsigned offset)
{
debug("%s: offset:%u\n", __func__, offset);
if (check_reserved(dev, offset, __func__))
return -1;
return sandbox_gpio_set_direction(dev, offset, 0);
}
/* read GPIO IN value of port 'offset' */
static int sb_gpio_get_value(struct udevice *dev, unsigned offset)
{
debug("%s: offset:%u\n", __func__, offset);
if (check_reserved(dev, offset, __func__))
return -1;
return sandbox_gpio_get_value(dev, offset);
}
expr_rec process_literal(void)
{
expr_rec t;
check_reserved(token_buffer);
/*Convert literal to a numeric representation and build semantic record*/
t.kind = LITERALEXPR;
(void) sscanf(token_buffer,"%d", & t.val);
return t;
}
/* set GPIO port 'offset' as an output, with polarity 'value' */
static int sb_gpio_direction_output(struct udevice *dev, unsigned offset,
int value)
{
debug("%s: offset:%u, value = %d\n", __func__, offset, value);
if (check_reserved(dev, offset, __func__))
return -1;
return sandbox_gpio_set_direction(dev, offset, 1) |
sandbox_gpio_set_value(dev, offset, value);
}
static int sb_gpio_free(struct udevice *dev, unsigned offset)
{
struct gpio_state *state = dev_get_priv(dev);
debug("%s: offset:%u\n", __func__, offset);
if (check_reserved(dev, offset, __func__))
return -1;
state[offset].label = NULL;
return set_gpio_flag(dev, offset, GPIOF_RESERVED, 0);
}
int dm_gpio_set_value(const struct gpio_desc *desc, int value)
{
int ret;
ret = check_reserved(desc, "set_value");
if (ret)
return ret;
if (desc->flags & GPIOD_ACTIVE_LOW)
value = !value;
gpio_get_ops(desc->dev)->set_value(desc->dev, desc->offset, value);
return 0;
}
int dm_gpio_get_value(const struct gpio_desc *desc)
{
int value;
int ret;
ret = check_reserved(desc, "get_value");
if (ret)
return ret;
value = gpio_get_ops(desc->dev)->get_value(desc->dev, desc->offset);
return desc->flags & GPIOD_ACTIVE_LOW ? !value : value;
}
int dm_gpio_get_open_drain(struct gpio_desc *desc)
{
struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
int ret;
ret = check_reserved(desc, "get_open_drain");
if (ret)
return ret;
if (ops->set_open_drain)
return ops->get_open_drain(desc->dev, desc->offset);
else
return -ENOSYS;
}
/**
* gpio_direction_input() - [COMPAT] Set GPIO direction to input
* gpio: GPIO number
*
* This function implements the API that's compatible with current
* GPIO API used in U-Boot. The request is forwarded to particular
* GPIO driver. Returns 0 on success, negative value on error.
*/
int gpio_direction_input(unsigned gpio)
{
struct gpio_desc desc;
int ret;
ret = gpio_to_device(gpio, &desc);
if (ret)
return ret;
ret = check_reserved(&desc, "dir_input");
if (ret)
return ret;
return gpio_get_ops(desc.dev)->direction_input(desc.dev, desc.offset);
}
/* write GPIO OUT value to port 'offset' */
static int sb_gpio_set_value(struct udevice *dev, unsigned offset, int value)
{
debug("%s: offset:%u, value = %d\n", __func__, offset, value);
if (check_reserved(dev, offset, __func__))
return -1;
if (!sandbox_gpio_get_direction(dev, offset)) {
printf("sandbox_gpio: error: set_value on input gpio %u\n",
offset);
return -1;
}
return sandbox_gpio_set_value(dev, offset, value);
}
int dm_gpio_set_open_drain(struct gpio_desc *desc, int value)
{
struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
int ret;
ret = check_reserved(desc, "set_open_drain");
if (ret)
return ret;
if (ops->set_open_drain)
ret = ops->set_open_drain(desc->dev, desc->offset, value);
else
return 0; /* feature not supported -> ignore setting */
return ret;
}
/*returns next token from source file*/
token scanner()
{
char c;
clear_buffer();
while(TRUE)
{
c = getc(fin);
if(c == EOF)
return SCANEOF;
else if(isspace(c))
{
if (c == '\n')
line_num = line_num + 1;
}
else if (isalpha(c))
{
buffer_char (c);
c = getc (fin);
while (isalnum(c) || c == '_')
{
buffer_char(c);
c = getc(fin);
}
ungetc(c, fin);
return check_reserved();
}
else if (isdigit(c))
{
buffer_char(c);
c = getc(fin);
while(isdigit(c))
{
buffer_char(c);
c = getc(fin);
}
ungetc(c,fin);
return INTLITERAL;
}
else if (c == '(')
return LPAREN;
else if (c == ')')
return RPAREN;
else if (c == '{')
return LCURL;
else if (c == '}')
return RCURL;
else if (c == ',')
return COMMA;
else if (c == ';')
return SEMICOLON;
else if (c == '+')
return PLUSOP;
else if (c == '-')
return MINUSOP;
else if (c == '*')
return MULTOP;
else if (c == '/')
{
c = getc(fin);
if(c == '/')
{
do
c = getc(fin);
while (c != '\n');
line_num = line_num + 1;
}
else
{
ungetc(c, fin);
return DIVOP;
}
}
else if (c == '=')
{
c = getc(fin);
if(c == '=')
{
return EQUALS;
}
else
{
ungetc(c, fin);
lexical_error();
}
}
else if (c == '!')
{
c = getc(fin);
if(c == '=')
{
return NOTEQ;
}
else
{
ungetc(c, fin);
lexical_error();
}
}
else if (c == '<')
{
c = getc(fin);
if(c == '=')
{
return LESSEQ;
}
else
{
ungetc(c, fin);
return LESS;
}
}
else if (c == '>')
{
c = getc(fin);
if(c == '=')
{
return GREATEQ;
}
else
{
ungetc(c, fin);
return GREATER;
}
}
else if (c == ':')
{
c = getc(fin);
if(c == '=')
return ASSIGNOP;
else
{
ungetc(c, fin);
lexical_error();
}
}
else
lexical_error();
}
}
token scanner(void)
{
int in_char,c;
clear_buffer();
if (feof(archivo))
return SCANEOF;
while (feof(archivo)==0){
in_char=fgetc(archivo);
if (isspace(in_char))
continue; /*do nothing */
else if (isalpha(in_char)){
/*
ID::=LETTER | ID LETTER
| ID DIGIT
| ID UNDERSCORE
*/
buffer_char(in_char);
for (c= fgetc(archivo);isalnum(c)||c=='-';c=fgetc(archivo))
buffer_char(c);
//ungetc(c,stdin);
return check_reserved();
}else if (isdigit(in_char)){
/*
INTLITERAL :: = DIGIT |
INTLITERAL DIGIT
*/
buffer_char(in_char);
for (c=fgetc(archivo);isdigit(c);c=fgetc(archivo))
buffer_char(c);
//ungetc(c,stdin);
return INTLITERAL;
}else if (in_char== '(')
return LPAREN;
else if (in_char==')')
return RPAREN;
else if (in_char==';')
return SEMICOLON ;
else if (in_char==',')
return COMMA ;
else if (in_char=='+')
return PLUSOP;
else if (in_char==':'){
/*looking for ":="*/
c=fgetc(archivo);
if (c=='=')
return ASSIGNOP ;
else{
//ungetc(c,stdin);
lexical_error(in_char);
}
}
else if (in_char=='-'){
/*is it --;comment start */
c=fgetc(archivo);
if (c=='-'){
do
in_char=fgetc(archivo);
while (in_char!='\n');
} else{
//ungetc(c,stdin);
return MINUSOP;
}
}else
lexical_error(in_char);
}
}
