#include "init.h"
#include "stm32.h"
#include "port.h"
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
struct gpio_list {
struct gpio_list *next;
int gpio;
int input; /* 1 if direction of gpio should be changed back to input. */
int exported; /* 0 if gpio should be unexported. */
};
#ifdef __linux__
static int write_to(const char *filename, const char *value)
{
int fd, ret;
fd = open(filename, O_WRONLY);
if (fd < 0) {
fprintf(stderr, "Cannot open file \"%s\"\n", filename);
return 0;
}
ret = write(fd, value, strlen(value));
if (ret < 0) {
fprintf(stderr, "Error writing in file \"%s\"\n", filename);
close(fd);
return 0;
}
close(fd);
return 1;
}
static int read_from(const char *filename, char *buf, size_t len)
{
int fd, ret;
size_t n = 0;
fd = open(filename, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "Cannot open file \"%s\"\n", filename);
return 0;
}
do {
ret = read(fd, buf + n, len - n);
if (ret < 0) {
if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)
continue; /* try again */
fprintf(stderr, "Error reading in file \"%s\"\n", filename);
close(fd);
return 0;
}
n += ret;
} while (n < len && ret);
close(fd);
return n;
}
static int drive_gpio(int n, int level, struct gpio_list **gpio_to_release) {
char num[16]; /* sized to carry MAX_INT */
char file[48]; /* sized to carry longest filename */
char dir;
struct stat buf;
struct gpio_list *_new;
int ret;
int exported = 1;
int input = 0;
sprintf(file, "/sys/class/gpio/gpio%d/value", n);
ret = stat(file, &buf);
if (ret) {
/* file miss, GPIO not exported yet */
sprintf(num, "%d", n);
ret = write_to("/sys/class/gpio/export", num);
if (!ret)
return 0;
ret = stat(file, &buf);
if (ret) {
fprintf(stderr, "GPIO %d not available\n", n);
return 0;
}
exported = 0;
}
sprintf(file, "/sys/class/gpio/gpio%d/direction", n);
ret = stat(file, &buf);
if (!ret)
if (read_from(file, &dir, sizeof(dir)))
if (dir == 'i')
input = 1;
if (exported == 0 || input == 1) {
_new = (struct gpio_list *)malloc(sizeof(struct gpio_list));
if (_new == NULL) {
fprintf(stderr, "Out of memory\n");
return 0;
}
_new->gpio = n;
_new->exported = exported;
_new->input = input;
_new->next = *gpio_to_release;
*gpio_to_release = _new;
}
return write_to(file, level ? "high" : "low");
}
static int release_gpio(int n, int input, int exported) {
char num[16]; /* sized to carry MAX_INT */
char file[48]; /* sized to carry longest filename */
sprintf(num, "%d", n);
if (input) {
sprintf(file, "/sys/class/gpio/gpio%d/direction", n);
write_to(file, "in");
}
if (!exported) write_to("/sys/class/gpio/unexport", num);
return 1;
}
#else
static int drive_gpio(int, int, struct gpio_list**) {
fprintf(stderr, "GPIO control only available in Linux\n");
return 0;
}
#endif
static int gpio_sequence(Port&port, const char *seq, size_t len_seq) {
struct gpio_list *gpio_to_release = NULL;
#ifdef __linux__
struct gpio_list *to_free;
#endif
int ret = 0, level, gpio;
int sleep_time = 0;
int delimiter = 0;
const char *sig_str = NULL;
const char *s = seq;
size_t l = len_seq;
fprintf(diag, "\nGPIO sequence start\n");
while (ret == 0 && *s && l > 0) {
sig_str = NULL;
sleep_time = 0;
delimiter = 0;
if (*s == '-') {
level = 0;
s++;
l--;
} else
level = 1;
if (isdigit(*s)) {
gpio = atoi(s);
while (isdigit(*s)) {
s++;
l--;
}
} else if (l >= 3 && !strncmp(s, "rts", 3)) {
sig_str = s;
gpio = -GPIO_RTS;
s += 3;
l -= 3;
} else if (l >= 3 && !strncmp(s, "dtr", 3)) {
sig_str = s;
gpio = -GPIO_DTR;
s += 3;
l -= 3;
} else if (l >= 3 && !strncmp(s, "brk", 3)) {
sig_str = s;
gpio = -GPIO_BRK;
s += 3;
l -= 3;
} else if (*s && (l > 0)) {
delimiter = 1;
/* The ',' delimiter adds a 100 ms delay between signal toggles.
* i.e -rts,dtr will reset rts, wait 100 ms, set dtr.
*
* The '&' delimiter adds no delay between signal toggles.
* i.e -rts&dtr will reset rts and immediately set dtr.
*
* Example: -rts&dtr,,,rts,-dtr will reset rts and set dtr
* without delay, then wait 300 ms, set rts, wait 100 ms, reset dtr.
*/
if (*s == ',') {
s++;
l--;
sleep_time = 100000;
} else if (*s == '&') {
s++;
l--;
} else {
fprintf(stderr, "Character \'%c\' is not a valid signal or separator\n", *s);
ret = 1;
break;
}
} else {
/* E.g. modifier without signal */
fprintf(stderr, "Invalid sequence %.*s\n", (int) len_seq, seq);
ret = 1;
break;
}
if (!delimiter) { /* actual gpio/port signal driving */
if (gpio < 0) {
gpio = -gpio;
fprintf(diag, " setting port signal %.3s to %i... ", sig_str, level);
ret = (port.gpio(serial_gpio_t(gpio), level));
fprintf(diag,ret?"Error!\n":"OK\n");
} else {
fprintf(diag, " setting gpio %i to %i... ", gpio, level);
ret = (drive_gpio(gpio, level, &gpio_to_release) != 1);
fprintf(diag,ret?"Error!\n":"OK\n");
}
}
if (sleep_time) {
fprintf(diag, " delay %i us\n", sleep_time);
Sleep(sleep_time/1000);
}
}
#if defined(__linux__)
while (gpio_to_release) {
release_gpio(gpio_to_release->gpio, gpio_to_release->input, gpio_to_release->exported);
to_free = gpio_to_release;
gpio_to_release = gpio_to_release->next;
free(to_free);
}
#endif
fprintf(diag, "GPIO sequence end\n\n");
return ret;
}
static int gpio_bl_entry(Port&port, const char *seq) {
if (!seq || seq[0] == ':') return 1;
const char *s = strchr(seq, ':');
if (!s) return gpio_sequence(port, seq, strlen(seq));
return gpio_sequence(port, seq, s - seq);
}
int gpio_bl_exit(Port&port, const char *seq) {
if (!seq) return 1;
const char *s = strchr(seq, ':');
if (!s || !s[1]) return 1;
return gpio_sequence(port, s + 1, strlen(s + 1));
}
int init_bl_entry(Port&port, const char *seq) {
if (seq) return gpio_bl_entry(port, seq);
return 0;
}
int init_bl_exit(stm32&stm, Port&port, const char *seq) {
if (seq && strchr(seq, ':')) return gpio_bl_exit(port, seq);
return stm.reset_device();
}
| Detected encoding: ASCII (7 bit) | 2
|