greg/dmrconfig
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
b76a115054
dmrconfig/serial.c
Greg Shuflin b76a115054 Some in-progress work
2021-11-14 23:52:00 -08:00

777 lines
22 KiB
C
Raw Blame History

/*
* Interface to virtual serial USB port.
*
* Copyright (C) 2018 Serge Vakulenko, KK6ABQ
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include "util.h"
#if defined(__WIN32__) || defined(WIN32)
#include <windows.h>
#include <setupapi.h>
#include <malloc.h>
static void *fd = INVALID_HANDLE_VALUE;
static DCB saved_mode;
#else
#include <termios.h>
static int fd = -1;
static struct termios saved_mode;
#endif
#ifdef __linux__
# include <libudev.h>
#endif
#ifdef __APPLE__
# include <CoreFoundation/CoreFoundation.h>
# include <IOKit/usb/IOUSBLib.h>
# include <IOKit/serial/IOSerialKeys.h>
#endif
//static char *dev_path;
static const unsigned char CMD_PRG[] = "PROGRAM";
static const unsigned char CMD_PRG2[] = "\2";
static const unsigned char CMD_QX[] = "QX\6";
static const unsigned char CMD_ACK[] = "\6";
static const unsigned char CMD_READ[] = "Raaaan";
static const unsigned char CMD_WRITE[] = "Waaaan...";
static const unsigned char CMD_END[] = "END";
#if defined(__WIN32__) || defined(WIN32)
// No need for this function.
#else
//
// Encode the speed in bits per second into bit value
// accepted by cfsetspeed() function.
// Return -1 when speed is not supported.
//
static int baud_encode(int bps)
{
// Linux: only a limited set of values permitted.
switch (bps) {
#ifdef B75
case 75: return B75;
#endif
#ifdef B110
case 110: return B110;
#endif
#ifdef B134
case 134: return B134;
#endif
#ifdef B150
case 150: return B150;
#endif
#ifdef B200
case 200: return B200;
#endif
#ifdef B300
case 300: return B300;
#endif
#ifdef B600
case 600: return B600;
#endif
#ifdef B1200
case 1200: return B1200;
#endif
#ifdef B1800
case 1800: return B1800;
#endif
#ifdef B2400
case 2400: return B2400;
#endif
#ifdef B4800
case 4800: return B4800;
#endif
#ifdef B9600
case 9600: return B9600;
#endif
#ifdef B19200
case 19200: return B19200;
#endif
#ifdef B38400
case 38400: return B38400;
#endif
#ifdef B57600
case 57600: return B57600;
#endif
#ifdef B115200
case 115200: return B115200;
#endif
#ifdef B230400
case 230400: return B230400;
#endif
#ifdef B460800
case 460800: return B460800;
#endif
#ifdef B500000
case 500000: return B500000;
#endif
#ifdef B576000
case 576000: return B576000;
#endif
#ifdef B921600
case 921600: return B921600;
#endif
#ifdef B1000000
case 1000000: return B1000000;
#endif
#ifdef B1152000
case 1152000: return B1152000;
#endif
#ifdef B1500000
case 1500000: return B1500000;
#endif
#ifdef B2000000
case 2000000: return B2000000;
#endif
#ifdef B2500000
case 2500000: return B2500000;
#endif
#ifdef B3000000
case 3000000: return B3000000;
#endif
#ifdef B3500000
case 3500000: return B3500000;
#endif
#ifdef B4000000
case 4000000: return B4000000;
#endif
}
return -1;
}
#endif /* WIN32 */
//
// Send data to device.
// Return number of bytes, or -1 on error.
//
int serial_write(const unsigned char *data, int len)
{
#if defined(__WIN32__) || defined(WIN32)
DWORD written;
if (! WriteFile(fd, data, len, &written, 0))
return -1;
return written;
#else
return write(fd, data, len);
#endif
}
//
// Receive data from device.
// Return number of bytes, or -1 on error.
//
int serial_read(unsigned char *data, int len, int timeout_msec)
{
#if defined(__WIN32__) || defined(WIN32)
DWORD got;
COMMTIMEOUTS ctmo;
// Reset the Windows RX timeout to the current timeout_msec
// value, as it may have changed since the last read.
//
memset(&ctmo, 0, sizeof(ctmo));
ctmo.ReadIntervalTimeout = 0;
ctmo.ReadTotalTimeoutMultiplier = 0;
ctmo.ReadTotalTimeoutConstant = timeout_msec;
if (! SetCommTimeouts(fd, &ctmo)) {
fprintf(stderr, "Cannot set timeouts in serial_read()\n");
return -1;
}
if (! ReadFile(fd, data, len, &got, 0)) {
fprintf(stderr, "serial_read: read error\n");
exit(-1);
}
#else
struct timeval timeout, to2;
long got;
fd_set rfds;
timeout.tv_sec = timeout_msec / 1000;
timeout.tv_usec = timeout_msec % 1000 * 1000;
again:
to2 = timeout;
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
got = select(fd + 1, &rfds, 0, 0, &to2);
if (got < 0) {
if (errno == EINTR || errno == EAGAIN) {
if (trace_flag > 0)
printf("serial_read: retry on select\n");
goto again;
}
fprintf(stderr, "serial_read: select error: %s\n", strerror(errno));
exit(-1);
}
#endif
if (got == 0) {
if (trace_flag > 0)
printf("serial_read: no characters to read\n");
return 0;
}
#if ! defined(__WIN32__) && ! defined(WIN32)
got = read(fd, data, (len > 1024) ? 1024 : len);
if (got < 0) {
fprintf(stderr, "serial_read: read error\n");
exit(-1);
}
#endif
return got;
}
//
// Open the serial port.
// Return -1 on error.
//
int serial_open(const char *devname, int baud_rate)
{
#if defined(__WIN32__) || defined(WIN32)
DCB new_mode;
#else
struct termios new_mode;
#endif
#if defined(__WIN32__) || defined(WIN32)
// Check for the Windows device syntax and bend a DOS device
// into that syntax to allow higher COM numbers than 9
//
if (devname[0] != '\\') {
// Prepend device prefix: COM23 -> \\.\COM23
char *buf = alloca(5 + strlen(devname));
if (! buf) {
fprintf(stderr, "%s: Out of memory\n", devname);
return -1;
}
strcpy(buf, "\\\\.\\");
strcat(buf, devname);
devname = buf;
}
// Open port
fd = CreateFile(devname, GENERIC_READ | GENERIC_WRITE,
0, 0, OPEN_EXISTING, 0, 0);
if (fd == INVALID_HANDLE_VALUE) {
fprintf(stderr, "%s: Cannot open\n", devname);
return -1;
}
// Set serial attributes
memset(&saved_mode, 0, sizeof(saved_mode));
if (! GetCommState(fd, &saved_mode)) {
fprintf(stderr, "%s: Cannot get state\n", devname);
return -1;
}
new_mode = saved_mode;
new_mode.fDtrControl = DTR_CONTROL_ENABLE;
new_mode.BaudRate = baud_rate;
new_mode.ByteSize = 8;
new_mode.StopBits = ONESTOPBIT;
new_mode.Parity = 0;
new_mode.fParity = FALSE;
new_mode.fOutX = FALSE;
new_mode.fInX = FALSE;
new_mode.fOutxCtsFlow = FALSE;
new_mode.fOutxDsrFlow = FALSE;
new_mode.fRtsControl = RTS_CONTROL_ENABLE;
new_mode.fNull = FALSE;
new_mode.fAbortOnError = FALSE;
new_mode.fBinary = TRUE;
if (! SetCommState(fd, &new_mode)) {
fprintf(stderr, "%s: Cannot set state\n", devname);
return -1;
}
#else
// Encode baud rate.
int baud_code = baud_encode(baud_rate);
if (baud_code < 0) {
fprintf(stderr, "%s: Bad baud rate %d\n", devname, baud_rate);
return -1;
}
// Open port
fd = open(devname, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd < 0) {
perror(devname);
return -1;
}
// Set serial attributes
memset(&saved_mode, 0, sizeof(saved_mode));
tcgetattr(fd, &saved_mode);
// 8n1, ignore parity
memset(&new_mode, 0, sizeof(new_mode));
new_mode.c_cflag = CS8 | CLOCAL | CREAD;
new_mode.c_iflag = IGNBRK;
new_mode.c_oflag = 0;
new_mode.c_lflag = 0;
new_mode.c_cc[VTIME] = 0;
new_mode.c_cc[VMIN] = 1;
cfsetispeed(&new_mode, baud_code);
cfsetospeed(&new_mode, baud_code);
tcflush(fd, TCIFLUSH);
tcsetattr(fd, TCSANOW, &new_mode);
// Clear O_NONBLOCK flag.
int flags = fcntl(fd, F_GETFL, 0);
if (flags >= 0)
fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
#endif
return 0;
}
//
// Find a device path by vid/pid.
//
char *find_path(int vid, int pid)
{
char *result = 0;
#if defined(__linux__)
// Create the udev object.
struct udev *udev = udev_new();
if (! udev) {
printf("Can't create udev\n");
return 0;
}
// Create a list of the devices in the 'tty' subsystem.
struct udev_enumerate *enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "tty");
udev_enumerate_scan_devices(enumerate);
struct udev_list_entry *devices = udev_enumerate_get_list_entry(enumerate);
// For each item enumerated, figure out its information.
struct udev_list_entry *dev_list_entry;
udev_list_entry_foreach(dev_list_entry, devices) {
// Get the filename of the /sys entry for the device
// and create a udev_device object (dev) representing it.
const char *syspath = udev_list_entry_get_name(dev_list_entry);
struct udev_device *comport = udev_device_new_from_syspath(udev, syspath);
//printf("syspath = %s\n", syspath);
// Get the parent device with the subsystem/devtype pair
// of "usb"/"usb_device".
struct udev_device *parent = udev_device_get_parent_with_subsystem_devtype(comport,
"usb", "usb_device");
if (! parent) {
//printf("Unable to find parent usb device.\n");
continue;
}
// Get the path to the device node in /dev.
const char *devpath = udev_device_get_devnode(comport);
//printf("devpath = %s\n", devpath);
//printf("parent = %s\n", udev_device_get_devnode(parent));
const char *idVendor = udev_device_get_sysattr_value(parent, "idVendor");
const char *idProduct = udev_device_get_sysattr_value(parent, "idProduct");
if (! idVendor || ! idProduct) {
// No vendor and product ID.
continue;
}
//printf("vid = %s\n", idVendor);
//printf("pid = %s\n", idProduct);
unsigned vendor_id = strtoul(idVendor, 0, 16);
unsigned product_id = strtoul(idProduct, 0, 16);
if (vendor_id != vid || product_id != pid) {
// Wrong ID.
continue;
}
// Print names of vendor and product.
//const char *vendor = udev_device_get_sysattr_value(parent, "manufacturer");
//const char *product = udev_device_get_sysattr_value(parent, "product");
//printf("vendor = %s\n", vendor);
//printf("product = %s\n", product);
// Return result.
udev_device_unref(parent);
result = strdup(devpath);
break;
}
// Free the enumerator object
udev_enumerate_unref(enumerate);
udev_unref(udev);
#elif defined(__APPLE__)
// Create a list of the devices in the 'IOSerialBSDClient' class.
CFMutableDictionaryRef dict = IOServiceMatching(kIOSerialBSDServiceValue);
if (! dict) {
printf("Cannot create IO Service dictionary.\n");
return 0;
}
io_iterator_t devices = IO_OBJECT_NULL;
kern_return_t ret = IOServiceGetMatchingServices(kIOMasterPortDefault,
dict, &devices);
if (ret != KERN_SUCCESS) {
printf("Cannot find matching IO services.\n");
return 0;
}
// For each matching device, print out its information.
io_object_t device;
while ((device = IOIteratorNext(devices)) != MACH_PORT_NULL) {
// Get device path.
char devname[1024];
CFStringRef ref = (CFStringRef) IORegistryEntrySearchCFProperty(device,
kIOServicePlane, CFSTR(kIOCalloutDeviceKey),
kCFAllocatorDefault, kIORegistryIterateRecursively);
if (! ref || ! CFStringGetCString(ref, devname, sizeof(devname), kCFStringEncodingUTF8)) {
// Cannot get device path.
continue;
}
//printf("%s\n", devname);
// Get device parent.
io_registry_entry_t parent = 0;
if (KERN_SUCCESS != IORegistryEntryGetParentEntry(device, kIOServicePlane, &parent)) {
//printf("Cannot get device parent.\n");
continue;
}
// Get device grandparent.
io_registry_entry_t grandparent = 0;
if (KERN_SUCCESS != IORegistryEntryGetParentEntry(parent, kIOServicePlane, &grandparent)) {
//printf("Cannot get device grandparent.\n");
continue;
}
// Get vendor ID.
int vendor_id;
ref = IORegistryEntryCreateCFProperty(grandparent,
CFSTR(kUSBVendorID), kCFAllocatorDefault, 0);
if (! ref || ! CFNumberGetValue((CFNumberRef)ref, kCFNumberIntType, &vendor_id)) {
//printf("Cannot get vendor ID.\n");
continue;
}
// Get product ID.
int product_id;
ref = IORegistryEntryCreateCFProperty(grandparent,
CFSTR(kUSBProductID), kCFAllocatorDefault, 0);
if (! ref || ! CFNumberGetValue((CFNumberRef)ref, kCFNumberIntType, &product_id)) {
//printf("Cannot get product ID.\n");
continue;
}
if (vendor_id != vid || product_id != pid) {
// Wrong ID.
continue;
}
result = strdup(devname);
break;
}
// Free the iterator object
IOObjectRelease(devices);
#else
// Prepare a pattern for device name matching.
char pattern[128];
int pattern_len;
sprintf(pattern, "\\\\?\\usb#vid_%04x&pid_%04x", vid, pid);
pattern_len = strlen(pattern);
// Get access to serial device information.
static GUID guid = { 0xa5dcbf10, 0x6530, 0x11d2, { 0x90, 0x1f, 0x00, 0xc0, 0x4f, 0xb9, 0x51, 0xed } };
HDEVINFO devinfo = SetupDiGetClassDevs(&guid, NULL, NULL,
DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
if (devinfo == INVALID_HANDLE_VALUE) {
printf("Cannot get devinfo!\n");
return 0;
}
// Loop through available devices with a given GUID.
int index;
SP_INTERFACE_DEVICE_DATA iface;
iface.cbSize = sizeof(iface);
for (index=0; SetupDiEnumDeviceInterfaces(devinfo, NULL, &guid, index, &iface); ++index) {
// Obtain a required size of device detail structure.
DWORD needed;
SetupDiGetDeviceInterfaceDetail(devinfo, &iface, NULL, 0, &needed, NULL);
// Allocate the device detail structure.
PSP_INTERFACE_DEVICE_DETAIL_DATA detail = (PSP_INTERFACE_DEVICE_DETAIL_DATA)alloca(needed);
detail->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
SP_DEVINFO_DATA did = { sizeof(SP_DEVINFO_DATA) };
// Get device information.
if (!SetupDiGetDeviceInterfaceDetail(devinfo, &iface, detail, needed, NULL, &did)) {
//printf("Device %d: cannot get path!\n", index);
continue;
}
//printf("Device %d: path %s\n", index, detail->DevicePath);
// Check vid/pid.
if (strncmp(detail->DevicePath, pattern, pattern_len) != 0) {
//printf("Wrong vid/pid.\n");
continue;
}
// Figure out the COM port name.
HKEY key = SetupDiOpenDevRegKey(devinfo, &did, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
static char comname[128];
DWORD size = sizeof(comname), type = REG_SZ;
if (ERROR_SUCCESS != RegQueryValueEx(key, "PortName",
NULL, &type, (LPBYTE)comname, &size)) {
//printf("Cannot find 'portname' in registry!\n");
RegCloseKey(key);
continue;
}
RegCloseKey(key);
//printf("COM port: %s\n", comname);
// Required device found.
result = comname;
break;
}
SetupDiDestroyDeviceInfoList(devinfo);
#endif
return result;
}
//
// Connect to the specified device.
// Initiate the programming session.
//
//
// Send the command sequence and get back a response.
//
static int send_recv(const unsigned char *cmd, int cmdlen,
unsigned char *response, int reply_len)
{
unsigned char *p;
int len, i, got;
//
// Send command.
//
if (trace_flag > 0) {
fprintf(stderr, "----Send [%d] %02x", cmdlen, cmd[0]);
for (i=1; i<cmdlen; ++i)
fprintf(stderr, "-%02x", cmd[i]);
fprintf(stderr, "\n");
}
if (serial_write(cmd, cmdlen) < 0) {
//fprintf(stderr, "%s: write error\n", dev_path);
fprintf(stderr, "serial write error\n");
exit(-1);
}
//
// Get response.
//
p = response;
len = 0;
while (len < reply_len) {
got = serial_read(p, reply_len - len, 1000);
if (! got)
return 0;
p += got;
len += got;
}
if (trace_flag > 0) {
fprintf(stderr, "----Recv [%d] %02x", reply_len, response[0]);
for (i=1; i<reply_len; ++i)
fprintf(stderr, "-%02x", response[i]);
fprintf(stderr, "\n");
}
return 1;
}
//
// Close the serial port.
//
void serial_close()
{
#if defined(__WIN32__) || defined(WIN32)
if (fd != INVALID_HANDLE_VALUE) {
unsigned char ack[1];
send_recv(CMD_END, 3, ack, 1);
SetCommState(fd, &saved_mode);
CloseHandle(fd);
fd = INVALID_HANDLE_VALUE;
}
#else
if (fd >= 0) {
unsigned char ack[1];
send_recv(CMD_END, 3, ack, 1);
tcsetattr(fd, TCSANOW, &saved_mode);
close(fd);
fd = -1;
}
#endif
}
//
// Query and return the device identification string.
// On error, return NULL.
//
const char *serial_identify(char* dev_path)
{
static unsigned char reply[16];
unsigned char ack[3];
int retry = 0;
if (serial_open(dev_path, 115200) < 0) {
return 0;
}
again:
#if defined(__WIN32__) || defined(WIN32)
//TODO: flush pending input and output buffers.
#else
tcflush(fd, TCIOFLUSH);
#endif
send_recv(CMD_PRG, 7, ack, 3);
if (memcmp(ack, CMD_QX, 3) != 0) {
if (++retry >= 10) {
fprintf(stderr, "%s: Wrong PRG acknowledge %02x-%02x-%02x, expected %02x-%02x-%02x\n",
__func__, ack[0], ack[1], ack[2], CMD_QX[0], CMD_QX[1], CMD_QX[2]);
return 0;
}
usleep(500000);
goto again;
}
// Reply:
// 49 44 38 36 38 55 56 45 00 56 31 30 32 00 00 06
// I D 8 6 8 U V E V 1 0 2
send_recv(CMD_PRG2, 1, reply, 16);
if (reply[0] != 'I' || reply[15] != CMD_ACK[0]) {
if (++retry >= 10) {
fprintf(stderr, "%s: Wrong PRG2 reply %02x-...-%02x, expected %02x-...-%02x\n",
__func__, reply[0], reply[15], 'I', CMD_ACK[0]);
return 0;
}
usleep(500000);
goto again;
}
// Terminate the string.
reply[8] = 0;
return (char*)&reply[1];
}
void c_serial_read_region(int addr, unsigned char *data, int nbytes)
{
static const int DATASZ = 64;
unsigned char cmd[6], reply[8 + DATASZ];
int n, i, retry = 0;
for (n=0; n<nbytes; n+=DATASZ) {
// Read command: 52 aa aa aa aa 10
cmd[0] = CMD_READ[0];
cmd[1] = (addr + n) >> 24;
cmd[2] = (addr + n) >> 16;
cmd[3] = (addr + n) >> 8;
cmd[4] = addr + n;
cmd[5] = DATASZ;
again:
send_recv(cmd, 6, reply, sizeof(reply));
if (reply[0] != CMD_WRITE[0] || reply[7+DATASZ] != CMD_ACK[0]) {
fprintf(stderr, "%s: Wrong read reply %02x-...-%02x, expected %02x-...-%02x\n",
__func__, reply[0], reply[7+DATASZ], CMD_WRITE[0], CMD_ACK[0]);
exit(-1);
}
// Compute checksum.
unsigned char sum = reply[1];
for (i=2; i<6+DATASZ; i++)
sum += reply[i];
if (reply[6+DATASZ] != sum) {
fprintf(stderr, "%s: Wrong read checksum %02x, expected %02x\n",
__func__, sum, reply[6+DATASZ]);
if (retry++ < 3)
goto again;
exit(-1);
}
memcpy(data + n, reply + 6, DATASZ);
}
}
void c_serial_write_region(int addr, unsigned char *data, int nbytes)
{
//static const int DATASZ = 64;
static const int DATASZ = 16;
unsigned char ack, cmd[8 + DATASZ];
int n, i;
for (n=0; n<nbytes; n+=DATASZ) {
// Write command: 57 aa aa aa aa 10 .. .. ss nn
cmd[0] = CMD_WRITE[0];
cmd[1] = (addr + n) >> 24;
cmd[2] = (addr + n) >> 16;
cmd[3] = (addr + n) >> 8;
cmd[4] = addr + n;
cmd[5] = DATASZ;
memcpy(cmd + 6, data + n, DATASZ);
// Compute checksum.
unsigned char sum = cmd[1];
for (i=2; i<6+DATASZ; i++)
sum += cmd[i];
cmd[6 + DATASZ] = sum;
cmd[7 + DATASZ] = CMD_ACK[0];
send_recv(cmd, 8 + DATASZ, &ack, 1);
if (ack != CMD_ACK[0]) {
fprintf(stderr, "%s: Wrong acknowledge %#x, expected %#x\n",
__func__, ack, CMD_ACK[0]);
exit(-1);
}
}
}
Reference in New Issue View Git Blame Copy Permalink