p1load/osint_linux.c

551 lines
13 KiB
C
Raw Normal View History

2015-01-24 23:34:20 -05:00
/**
* @file osint_linux.c
*
* Serial I/O functions used by PLoadLib.c
*
* Copyright (c) 2009 by John Steven Denson
* Modified in 2011 by David Michael Betz
* GPIO reset code by Michael Rychlik
2015-01-24 23:34:20 -05:00
*
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <unistd.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <sys/timeb.h>
#include <sys/select.h>
#include <sys/types.h>
#include <dirent.h>
#include <limits.h>
#include <signal.h>
#include "osint.h"
#ifdef RASPBERRY_PI
#include "gpio_sysfs.h"
#endif
2015-01-24 23:34:20 -05:00
typedef int HANDLE;
static HANDLE hSerial = -1;
static struct termios old_sparm;
static int continue_terminal = 1;
2015-01-24 23:34:20 -05:00
#ifdef RASPBERRY_PI
2015-01-27 17:10:16 -05:00
static int propellerResetGpioPin = 17;
static int propellerResetGpioLevel = 0;
#endif
/* Normally we use DTR for reset */
static reset_method_t reset_method = RESET_WITH_DTR;
2015-01-24 23:34:20 -05:00
int use_reset_method(char* method)
2015-01-24 23:34:20 -05:00
{
if (strcasecmp(method, "dtr") == 0)
reset_method = RESET_WITH_DTR;
else if (strcasecmp(method, "rts") == 0)
reset_method = RESET_WITH_RTS;
#ifdef RASPBERRY_PI
2015-01-27 17:10:16 -05:00
else if (strncasecmp(method, "gpio", 4) == 0)
{
reset_method = RESET_WITH_GPIO;
char *token;
token = strtok(method, ",");
if (token)
{
2015-01-27 21:49:45 -05:00
token = strtok(NULL, ",");
if (token)
{
propellerResetGpioPin = atoi(token);
}
token = strtok(NULL, ",");
if (token)
{
propellerResetGpioLevel = atoi(token);
}
}
2015-02-10 16:55:23 -05:00
//printf ("Using GPIO pin %d as Propeller reset ", propellerResetGpioPin);
if (propellerResetGpioLevel)
{
printf ("(HIGH).\n");
}
else
{
printf ("(LOW).\n");
}
gpio_export(propellerResetGpioPin);
gpio_write(propellerResetGpioPin, propellerResetGpioLevel ^ 1);
gpio_direction(propellerResetGpioPin, 1);
}
#endif
else {
return -1;
}
return 0;
2015-01-24 23:34:20 -05:00
}
static void chk(char *fun, int sts)
{
if (sts != 0)
printf("%s failed\n", fun);
}
int serial_find(const char* prefix, int (*check)(const char* port, void* data), void* data)
{
char path[PATH_MAX];
int prefixlen = strlen(prefix);
struct dirent *entry;
DIR *dirp;
if (!(dirp = opendir("/dev")))
return -1;
while ((entry = readdir(dirp)) != NULL) {
if (strncmp(entry->d_name, prefix, prefixlen) == 0) {
sprintf(path, "/dev/%s", entry->d_name);
if ((*check)(path, data) == 0) {
closedir(dirp);
return 0;
}
}
}
closedir(dirp);
return -1;
}
static void sigint_handler(int signum)
{
serial_done();
continue_terminal = 0;
2015-01-24 23:34:20 -05:00
}
/**
* open serial port
* @param port - COMn port name
* @param baud - baud rate
* @returns hSerial - file handle to serial port
2015-01-24 23:34:20 -05:00
*/
int serial_init(const char* port, unsigned long baud)
{
/* open the port */
#ifdef MACOSX
hSerial = open(port, O_RDWR | O_NOCTTY | O_NONBLOCK);
#else
hSerial = open(port, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
#endif
if(hSerial == -1) {
//printf("error: opening '%s' -- %s\n", port, strerror(errno));
return 0;
}
signal(SIGINT, sigint_handler);
atexit(serial_done);
2015-01-24 23:34:20 -05:00
/* set the terminal to exclusive mode */
if (ioctl(hSerial, TIOCEXCL) != 0) {
//printf("error: can't open terminal for exclusive access\n");
close(hSerial);
return 0;
}
/* get the current options */
chk("tcgetattr", tcgetattr(hSerial, &old_sparm));
/* set the baud rate */
if (!serial_baud(baud)) {
close(hSerial);
return 0;
}
return 1;
}
/**
* change the baud rate of the serial port
* @param baud - baud rate
* @returns 1 for success and 0 for failure
*/
int serial_baud(unsigned long baud)
{
struct termios sparm;
int tbaud;
2015-01-24 23:34:20 -05:00
switch(baud) {
case 0: // default
tbaud = B115200;
break;
#ifdef B921600
case 921600:
tbaud = B921600;
break;
#endif
#ifdef B576000
case 576000:
tbaud = B576000;
break;
#endif
#ifdef B500000
case 500000:
tbaud = B500000;
break;
#endif
#ifdef B460800
case 460800:
tbaud = B460800;
break;
#endif
#ifdef B230400
case 230400:
tbaud = B230400;
break;
#endif
case 115200:
tbaud = B115200;
break;
case 57600:
tbaud = B57600;
break;
case 38400:
tbaud = B38400;
break;
default:
printf("Unsupported baudrate. Use ");
#ifdef B921600
printf("921600, ");
#endif
#ifdef B576000
printf("576000, ");
#endif
#ifdef B500000
printf("500000, ");
#endif
#ifdef B460800
printf("460800, ");
#endif
#ifdef B230400
printf("230400, ");
#endif
printf("115200, 57600, or 38400\n");
2015-01-24 23:34:20 -05:00
serial_done();
exit(2);
break;
}
2015-01-24 23:34:20 -05:00
/* get the current options */
chk("tcgetattr", tcgetattr(hSerial, &sparm));
2015-01-24 23:34:20 -05:00
/* set raw input */
2015-02-08 11:52:12 -05:00
cfmakeraw(&sparm);
sparm.c_cc[VTIME] = 0;
sparm.c_cc[VMIN] = 1;
2015-02-08 11:52:12 -05:00
chk("cfsetspeed", cfsetspeed(&sparm, tbaud));
2015-01-24 23:34:20 -05:00
/* set the options */
chk("tcflush", tcflush(hSerial, TCIFLUSH));
chk("tcsetattr", tcsetattr(hSerial, TCSANOW, &sparm));
fcntl(hSerial, F_SETFL, 0);
2015-01-24 23:34:20 -05:00
return 1;
}
/**
* close serial port
*/
void serial_done(void)
{
if (hSerial != -1) {
ioctl(hSerial, TIOCNXCL);
2015-01-24 23:34:20 -05:00
tcflush(hSerial, TCIOFLUSH);
tcsetattr(hSerial, TCSANOW, &old_sparm);
ioctl(hSerial, TIOCNXCL);
close(hSerial);
hSerial = -1;
}
#ifdef RASPBERRY_PI
if (reset_method == RESET_WITH_GPIO)
{
// gpio_unexport(propellerResetGpioPin);
}
#endif
2015-01-24 23:34:20 -05:00
}
/**
* receive a buffer
* @param buff - char pointer to buffer
* @param n - number of bytes in buffer to read
* @returns number of bytes read
*/
int rx(uint8_t* buff, int n)
{
ssize_t bytes = read(hSerial, buff, n);
if(bytes < 1) {
printf("Error reading port: %d\n", (int)bytes);
return 0;
}
return (int)bytes;
}
/**
* transmit a buffer
* @param buff - char pointer to buffer
* @param n - number of bytes in buffer to send
* @returns zero on failure
*/
int tx(uint8_t* buff, int n)
{
ssize_t bytes;
#if 0
int j = 0;
while(j < n) {
printf("%02x ",buff[j++]);
}
printf("tx %d byte(s)\n",n);
#endif
bytes = write(hSerial, buff, n);
if(bytes != n) {
printf("Error writing port\n");
return 0;
}
return (int)bytes;
}
/**
* receive a buffer with a timeout
* @param buff - char pointer to buffer
* @param n - number of bytes in buffer to read
* @param timeout - timeout in milliseconds
* @returns number of bytes read or SERIAL_TIMEOUT
*/
int rx_timeout(uint8_t* buff, int n, int timeout)
{
ssize_t bytes = 0;
struct timeval toval;
fd_set set;
FD_ZERO(&set);
FD_SET(hSerial, &set);
toval.tv_sec = timeout / 1000;
toval.tv_usec = (timeout % 1000) * 1000;
if (select(hSerial + 1, &set, NULL, NULL, &toval) > 0) {
if (FD_ISSET(hSerial, &set))
bytes = read(hSerial, buff, n);
}
return (int)(bytes > 0 ? bytes : SERIAL_TIMEOUT);
}
/**
* assert_reset ... Asserts the Propellers reset signal via DTR, RTS or GPIO pin.
* @returns void
*/
static void assert_reset(void)
{
int cmd;
switch (reset_method)
{
case RESET_WITH_DTR:
cmd = TIOCM_DTR;
ioctl(hSerial, TIOCMBIS, &cmd); /* assert bit */
break;
case RESET_WITH_RTS:
cmd = TIOCM_RTS;
ioctl(hSerial, TIOCMBIS, &cmd); /* assert bit */
break;
#ifdef RASPBERRY_PI
case RESET_WITH_GPIO:
gpio_write(propellerResetGpioPin, propellerResetGpioLevel);
break;
#endif
default:
// should be reached
break;
}
}
/**
* deassert_reset ... Deasserts the Propellers reset signal via DTR, RTS or GPIO pin.
* @returns void
*/
static void deassert_reset(void)
{
int cmd;
switch (reset_method)
{
case RESET_WITH_DTR:
cmd = TIOCM_DTR;
ioctl(hSerial, TIOCMBIC, &cmd); /* assert bit */
break;
case RESET_WITH_RTS:
cmd = TIOCM_RTS;
ioctl(hSerial, TIOCMBIC, &cmd); /* assert bit */
break;
#ifdef RASPBERRY_PI
case RESET_WITH_GPIO:
gpio_write(propellerResetGpioPin, propellerResetGpioLevel ^ 1);
break;
#endif
default:
// should be reached
break;
}
}
/**
* hwreset ... resets Propeller hardware.
2015-01-24 23:34:20 -05:00
* @returns void
*/
void hwreset(void)
{
assert_reset();
2015-01-24 23:34:20 -05:00
msleep(10);
deassert_reset();
msleep(100);
2015-01-24 23:34:20 -05:00
tcflush(hSerial, TCIFLUSH);
}
/**
* sleep for ms milliseconds
* @param ms - time to wait in milliseconds
*/
void msleep(int ms)
{
#if 0
volatile struct timeb t0, t1;
do {
ftime((struct timeb*)&t0);
do {
ftime((struct timeb*)&t1);
} while (t1.millitm == t0.millitm);
} while(ms-- > 0);
#else
usleep(ms * 1000);
#endif
}
#define ESC 0x1b /* escape from terminal mode */
/**
* simple terminal emulator
*/
void terminal_mode(int check_for_exit, int pst_mode)
2015-01-24 23:34:20 -05:00
{
struct termios oldt, newt;
char buf[128], realbuf[256];
2015-01-24 23:34:20 -05:00
ssize_t cnt;
fd_set set;
int exit_char = 0xdead; /* not a valid character */
int sawexit_char = 0;
int sawexit_valid = 0;
int exitcode = 0;
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO);
2015-01-24 23:34:20 -05:00
newt.c_iflag &= ~(ICRNL | INLCR);
newt.c_oflag &= ~OPOST;
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
if (check_for_exit)
{
exit_char = 0xff;
}
#if 0
/* make it possible to detect breaks */
tcgetattr(hSerial, &newt);
newt.c_iflag &= ~IGNBRK;
newt.c_iflag |= PARMRK;
tcsetattr(hSerial, TCSANOW, &newt);
#endif
do {
FD_ZERO(&set);
FD_SET(hSerial, &set);
FD_SET(STDIN_FILENO, &set);
if (select(hSerial + 1, &set, NULL, NULL, NULL) > 0) {
if (FD_ISSET(hSerial, &set)) {
if ((cnt = read(hSerial, buf, sizeof(buf))) > 0) {
int i;
// check for breaks
ssize_t realbytes = 0;
for (i = 0; i < cnt; i++) {
if (sawexit_valid)
{
exitcode = buf[i];
continue_terminal = 0;
}
else if (sawexit_char) {
if (buf[i] == 0) {
sawexit_valid = 1;
} else {
realbuf[realbytes++] = exit_char;
realbuf[realbytes++] = buf[i];
2015-01-24 23:34:20 -05:00
sawexit_char = 0;
}
} else if (((int)buf[i] & 0xff) == exit_char) {
sawexit_char = 1;
} else {
realbuf[realbytes++] = buf[i];
if (pst_mode && buf[i] == '\r')
realbuf[realbytes++] = '\n';
2015-01-24 23:34:20 -05:00
}
}
write(fileno(stdout), realbuf, realbytes);
2015-01-24 23:34:20 -05:00
}
}
if (FD_ISSET(STDIN_FILENO, &set)) {
if ((cnt = read(STDIN_FILENO, buf, sizeof(buf))) > 0) {
int i;
for (i = 0; i < cnt; ++i) {
//printf("%02x\n", buf[i]);
if (buf[i] == ESC)
goto done;
}
write(hSerial, buf, cnt);
}
}
}
} while (continue_terminal);
done:
tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
if (sawexit_valid)
{
exit(exitcode);
}
}