csu3_am335x/EVSE/GPL/plc-utils.LNX.2.1.20/source/serial/int6kuart.c

/*====================================================================*
*
*   Copyright (c) 2013 Qualcomm Atheros, Inc.
*
*   All rights reserved.
*
*====================================================================*/

/*====================================================================*
 *
 *   int6kuart.c - Qualcomm Atheros Serial Line Device Manager;
 *
 *   Contributor(s):
 *	Charles Maier <cmaier@qca.qualcomm.com>
 *	Mathieu Olivari <mathieu@qca.qualcomm.com>
 *
 *--------------------------------------------------------------------*/

/*====================================================================*
 *   system header files;
 *--------------------------------------------------------------------*/

#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#if defined (WIN32)
#	include <net/ethernet.h>
#elif defined (__linux__)
#	include <net/ethernet.h>
#elif defined (__APPLE__)
#	include <net/ethernet.h>
#elif defined (__OpenBSD__)
#	include <sys/socket.h>
#	include <net/if.h>
#	include <net/if_arp.h>
#	include <netinet/in.h>
#	include <netinet/if_ether.h>
#else
#error "Unknown Environment"
#endif

/*====================================================================*
 *   custom header files;
 *--------------------------------------------------------------------*/

#include "../tools/getoptv.h"
#include "../tools/putoptv.h"
#include "../tools/number.h"
#include "../tools/memory.h"
#include "../tools/endian.h"
#include "../tools/files.h"
#include "../tools/flags.h"
#include "../tools/error.h"
#include "../tools/types.h"
#include "../serial/serial.h"
#include "../plc/plc.h"

/*====================================================================*
 *   custom source files;
 *--------------------------------------------------------------------*/

#ifndef MAKEFILE
#include "../tools/getoptv.c"
#include "../tools/putoptv.c"
#include "../tools/version.c"
#include "../tools/uintspec.c"
#include "../tools/basespec.c"
#include "../tools/synonym.c"
#include "../tools/todigit.c"
#include "../tools/error.c"
#include "../tools/checksum32.c"
#include "../tools/hexencode.c"
#include "../tools/hexdump.c"
#include "../tools/hexstring.c"
#include "../tools/hexdecode.c"
#include "../tools/error.c"
#endif

#ifndef MAKEFILE
#include "../serial/openport.c"
#include "../serial/closeport.c"
#include "../serial/serial.c"
#endif

/*====================================================================*
 *   program constants;
 *--------------------------------------------------------------------*/

#define FRAME_MIN_CHAR 120
#define FRAME_MAX_CHAR 1496

/*====================================================================*
 *   program variables;
 *--------------------------------------------------------------------*/

typedef struct uart 

{ 
	struct _file_ port; 
	struct _file_ pib; 
	struct _file_ nvm; 
	struct _file_ eth; 
	char const * string; 
	char PIBVersion [3]; 
	char IMGVersion [128]; 
	byte MACAddress [ETHER_ADDR_LEN]; 
	char NMKDigest [16]; 
	byte NMKNumber; 
	byte module; 
	uint16_t bfsize; 
	uint16_t snooze; 
	uint16_t timeout; 
	unsigned flags; 
} 

uart; 

/*====================================================================*
 *
 *   void at_writenvm (struct uart * uart);
 *
 *   read firmware image from file and send to device using command 
 *   "ATWPF"; the file descriptor is "nvm" member of struct uart;
 *
 *--------------------------------------------------------------------*/

static void at_writenvm (struct uart * uart) 

{ 
	extern struct command command; 
	byte memory [UART_BLOCKSIZE]; 
	signed mblock = sizeof (memory); 
	uint16_t mlength = 0; 
	uint32_t moffset = 0; 
	uint32_t mchksum; 
	uint16_t olength = 0; 
	uint32_t ooffset = 0; 
	uint32_t ochksum; 
	while ((mblock = read (uart->nvm.file, memory, mblock)) > 0) 
	{ 
		clearcommand (); 
		insert ('A'); 
		insert ('T'); 
		insert ('W'); 
		insert ('P'); 
		insert ('F'); 
		insert ('1'); 
		insert (','); 
		mchksum = checksum32 (memory, (size_t) (mblock), 0); 
		mlength = (uint16_t) (mblock); 
		mlength = HTOBE16 (mlength); 
		decode (& mlength, sizeof (mlength)); 
		mlength = BE16TOH (mlength); 
		insert (','); 
		moffset = HTOBE32 (moffset); 
		decode (& moffset, sizeof (moffset)); 
		moffset = BE32TOH (moffset); 
		insert (','); 
		mchksum = HTOBE32 (mchksum); 
		decode (& mchksum, sizeof (mchksum)); 
		mchksum = BE32TOH (mchksum); 
		insert (','); 
		decode (memory, mlength); 
		insert ('\r'); 
		sendcommand (& uart->port, uart->flags); 
		readcommand (& uart->port, uart->flags); 
		mustbe ('O'); 
		mustbe ('K'); 
		mustbe ('1'); 
		mustbe (','); 
		olength = (uint16_t) (hextoint (sizeof (olength))); 
		if (olength != mlength) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, EINVAL, "[%s]: expected length %X", command.buffer, mlength); 
		} 
		mustbe (','); 
		ooffset = (uint32_t) (hextoint (sizeof (ooffset))); 
		if (ooffset != moffset) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, EINVAL, "[%s]: expected offset %X", command.buffer, moffset); 
		} 
		mustbe (','); 
		ochksum = (uint32_t) (hextoint (sizeof (ochksum))); 
		if (ochksum != mchksum) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, EINVAL, "[%s]: expected checksum %X (%X)", command.buffer, mchksum, ochksum); 
		} 
		mustbe (','); 
		encode (memory, mblock); 
		mustbe ('\r'); 
		moffset += mlength; 
		if (_allclr (uart->flags, (UART_VERBOSE | UART_SILENCE))) 
		{ 
			write (STDOUT_FILENO, ".", 1); 
		} 
	} 

#ifndef WIN32	

	if (_allclr (uart->flags, (UART_VERBOSE | UART_SILENCE))) 
	{ 
		write (STDOUT_FILENO, "\n", 1); 
	} 

#endif

	return; 
} 

/*====================================================================*
 *
 *   void at_writepib (struct uart * uart);
 *
 *   read parameter block file and send to device using command 
 *   "ATWPF"; the file descriptor is "pib" member of struct uart;
 *
 *--------------------------------------------------------------------*/

static void at_writepib (struct uart * uart) 

{ 
	extern struct command command; 
	byte memory [UART_BLOCKSIZE]; 
	signed mblock = sizeof (memory); 
	uint16_t mlength = 0; 
	uint16_t moffset = 0; 
	uint32_t mchksum; 
	uint16_t olength = 0; 
	uint16_t ooffset = 0; 
	uint32_t ochksum; 
	while ((mblock = read (uart->pib.file, memory, mblock)) > 0) 
	{ 
		clearcommand (); 
		insert ('A'); 
		insert ('T'); 
		insert ('W'); 
		insert ('P'); 
		insert ('F'); 
		insert ('2'); 
		insert (','); 
		mchksum = checksum32 (memory, (size_t) (mblock), 0); 
		mlength = (uint16_t) (mblock); 
		mlength = HTOBE16 (mlength); 
		decode (& mlength, sizeof (mlength)); 
		mlength = BE16TOH (mlength); 
		insert (','); 
		moffset = HTOBE16 (moffset); 
		decode (& moffset, sizeof (moffset)); 
		moffset = BE16TOH (moffset); 
		insert (','); 
		mchksum = HTOBE32 (mchksum); 
		decode (& mchksum, sizeof (mchksum)); 
		mchksum = BE32TOH (mchksum); 
		insert (','); 
		decode (memory, mlength); 
		insert ('\r'); 
		sendcommand (& uart->port, uart->flags); 
		readcommand (& uart->port, uart->flags); 
		mustbe ('O'); 
		mustbe ('K'); 
		mustbe ('2'); 
		mustbe (','); 
		olength = (uint16_t) (hextoint (sizeof (olength))); 
		if (olength != mlength) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, EINVAL, "[%s]: expected length %X", command.buffer, mlength); 
		} 
		mustbe (','); 
		ooffset = (uint16_t) (hextoint (sizeof (ooffset))); 
		if (ooffset != moffset) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, EINVAL, "[%s]: expected offset %X", command.buffer, moffset); 
		} 
		mustbe (','); 
		ochksum = (uint32_t) (hextoint (sizeof (ochksum))); 
		if (ochksum != mchksum) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, EINVAL, "[%s]: expected checksum %X (%X)", command.buffer, mchksum, ochksum); 
		} 
		mustbe (','); 
		encode (memory, mblock); 
		mustbe ('\r'); 
		moffset += mlength; 
		if (_allclr (uart->flags, (UART_VERBOSE | UART_SILENCE))) 
		{ 
			write (STDOUT_FILENO, ".", 1); 
		} 
	} 

#ifndef WIN32

	if (_allclr (uart->flags, (UART_VERBOSE | UART_SILENCE))) 
	{ 
		write (STDOUT_FILENO, "\n", 1); 
	} 

#endif

	return; 
} 

/*====================================================================*
 *
 *   void at_readpib (struct uart * uart);
 *
 *   read parameter block from device and save to file using command 
 *   "ATRP"; the file descriptor is "pib" member of struct uart;
 *
 *--------------------------------------------------------------------*/

static void at_readpib (struct uart * uart) 

{ 
	extern struct command command; 
	byte memory [UART_BLOCKSIZE]; 
	signed mblock = sizeof (memory); 
	uint16_t mextent = 0; 
	uint16_t mlength = 0; 
	uint16_t moffset = 0; 
	uint16_t olength = 0; 
	uint16_t ooffset = 0; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('R'); 
	insert ('P'); 
	insert ('2'); 
	insert (','); 
	insert ('4'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	mustbe ('2'); 
	mustbe (','); 
	mustbe ('4'); 
	mustbe (','); 
	encode (& mextent, sizeof (mextent)); 
	mextent = LE16TOH (mextent); 
	mustbe ('\r'); 
	while (mextent) 
	{ 
		clearcommand (); 
		insert ('A'); 
		insert ('T'); 
		insert ('R'); 
		insert ('P'); 
		if (mblock > mextent) 
		{ 
			mblock = mextent; 
		} 
		mlength = (uint16_t) (mblock); 
		mlength = HTOBE16 (mlength); 
		decode (& mlength, sizeof (mlength)); 
		mlength = BE16TOH (mlength); 
		insert (','); 
		moffset = HTOBE16 (moffset); 
		decode (& moffset, sizeof (moffset)); 
		moffset = BE16TOH (moffset); 
		insert ('\r'); 
		sendcommand (& uart->port, uart->flags); 
		readcommand (& uart->port, uart->flags); 
		mustbe ('O'); 
		mustbe ('K'); 
		olength = (uint16_t) (hextoint (sizeof (olength))); 
		if (olength != mlength) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, EINVAL, "[%s]: have %d bytes but wanted %d", command.buffer, olength, mlength); 
		} 
		mustbe (','); 
		ooffset = (uint16_t) (hextoint (sizeof (ooffset))); 
		if (ooffset != moffset) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, EINVAL, "[%s]: expected offset %X", command.buffer, moffset); 
		} 
		mustbe (','); 
		encode (memory, mblock); 
		if (write (uart->pib.file, memory, mblock) < mblock) 
		{ 
			command.buffer [command.offset] = (char) (0); 
			error (1, errno, "[%s]: expected length %d", command.buffer, mblock); 
		} 
		mustbe ('\r'); 
		moffset += mblock; 
		mextent -= mblock; 
		if (_allclr (uart->flags, (UART_VERBOSE | UART_SILENCE))) 
		{ 
			write (STDOUT_FILENO, ".", 1); 
		} 
	} 

#ifndef WIN32

	if (_allclr (uart->flags, (UART_VERBOSE | UART_SILENCE))) 
	{ 
		write (STDOUT_FILENO, "\n", 1); 
	} 

#endif

	return; 
} 

/*====================================================================*
 *
 *   void at_wake (struct uart * uart);
 *
 *   send wake command "+++" to enter command mode; 
 *
 *--------------------------------------------------------------------*/

static void at_wake (struct uart * uart) 

{ 
	clearcommand (); 
	insert ('+'); 
	insert ('+'); 
	insert ('+'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void at_command (struct uart * uart);
 *
 *   send custom command; use this function to send any serial line
 *   command that may not be supported by this program;
 *
 *--------------------------------------------------------------------*/

static void at_command (struct uart * uart) 

{ 
	clearcommand (); 
	while (* uart->string) 
	{ 
		insert (* uart->string++); 
	} 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	clearcommand (); 
	return; 
} 

/*====================================================================*
 *
 *   void at_respond (struct uart * uart);
 *
 *   send command "AT" to test command mode; this command does nothing
 *   but echo "OK";
 *
 *--------------------------------------------------------------------*/

static void at_respond (struct uart * uart) 

{ 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void atz (struct uart * uart);
 *
 *   send command "ATZ" to reset the device; no response is expected;
 *
 *--------------------------------------------------------------------*/

static void atz (struct uart * uart) 

{ 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('Z'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	return; 
} 

/*====================================================================*
 *
 *   void atrv (struct uart * uart);
 *
 *   read and display the firmware image version using command "ATRV";
 *   return the version string in IMGVersion member of struct uart;
 *
 *--------------------------------------------------------------------*/

static void atrv (struct uart * uart) 

{ 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('R'); 
	insert ('V'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	mustbe ('\"'); 
	string (uart->IMGVersion); 
	mustbe ('\"'); 
	mustbe ('\r'); 
	printf ("%s\n", uart->IMGVersion); 
	return; 
} 

/*====================================================================*
 *
 *   void atrpm (struct uart * uart);
 *
 *   read and display the PIB version and MAC address using command 
 *   "ATRPM"; return version string in PIBVersion member and address
 *   string in MACAddress member of struct
 *   
 *
 *--------------------------------------------------------------------*/

static void atrpm (struct uart * uart) 

{ 
	char mac [ETHER_ADDR_LEN * 3]; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('R'); 
	insert ('P'); 
	insert ('M'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	mustbe ('\"'); 
	string (uart->PIBVersion); 
	mustbe ('\"'); 
	mustbe (','); 
	encode (uart->MACAddress, sizeof (uart->MACAddress)); 
	mustbe ('\r'); 
	printf ("%s %s\n", uart->PIBVersion, hexstring (mac, sizeof (mac), uart->MACAddress, sizeof (uart->MACAddress))); 
	return; 
} 

/*====================================================================*
 *
 *   void atsk1 (struct uart * uart);
 *
 *   send Set Key command "ATSK"; ask device for NMK; encode returned
 *   key into uart-NMK;
 *
 *--------------------------------------------------------------------*/

static void atsk1 (struct uart * uart) 

{ 
	char key [48]; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('S'); 
	insert ('K'); 
	insert ('?'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	encode (uart->NMKDigest, sizeof (uart->NMKDigest)); 
	mustbe ('\r'); 
	printf ("%s\n", hexstring (key, sizeof (key), uart->NMKDigest, sizeof (uart->NMKDigest))); 
	return; 
} 

/*====================================================================*
 *
 *   void atsk2 (struct uart * uart);
 *
 *   send Set Key command "ATSK"; send device the NMK; encode returned 
 *
 *--------------------------------------------------------------------*/

static void atsk2 (struct uart * uart) 

{ 
	char key [48]; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('S'); 
	insert ('K'); 
	decode (uart->NMKDigest, sizeof (uart->NMKDigest)); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	encode (uart->NMKDigest, sizeof (uart->NMKDigest)); 
	mustbe ('\r'); 
	printf ("%s\n", hexstring (key, sizeof (key), uart->NMKDigest, sizeof (uart->NMKDigest))); 
	return; 
} 

/*====================================================================*
 *
 *   void atdst1 (struct uart * uart);
 *
 *   read transparent mode destination MAC address command "ATDST?";
 *
 *--------------------------------------------------------------------*/

static void atdst1 (struct uart * uart) 

{ 
	char mac [ETHER_ADDR_LEN * 3]; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('D'); 
	insert ('S'); 
	insert ('T'); 
	insert ('?'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	encode (uart->MACAddress, sizeof (uart->MACAddress)); 
	mustbe ('\r'); 
	printf ("%s\n", hexstring (mac, sizeof (mac), uart->MACAddress, sizeof (uart->MACAddress))); 
	return; 
} 

/*====================================================================*
 *
 *   void atdst2 (struct uart * uart);
 *
 *   read transparent mode destination MAC address command "ATDST?";
 *
 *--------------------------------------------------------------------*/

static void atdst2 (struct uart * uart) 

{ 
	char mac [ETHER_ADDR_LEN * 3]; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('D'); 
	insert ('S'); 
	insert ('T'); 
	decode (uart->MACAddress, sizeof (uart->MACAddress)); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	encode (uart->MACAddress, sizeof (uart->MACAddress)); 
	mustbe ('\r'); 
	printf ("%s\n", hexstring (mac, sizeof (mac), uart->MACAddress, sizeof (uart->MACAddress))); 
	return; 
} 

/*====================================================================*
 *
 *   void atni (struct uart * uart);
 *
 *   reset device to factory default pib command "ATNI";
 *
 *--------------------------------------------------------------------*/

static void atni (struct uart * uart) 

{ 
	unsigned count; 
	unsigned index; 
	uint16_t rxrate; 
	uint16_t txrate; 
	byte address [ETHER_ADDR_LEN]; 
	char mac [ETHER_ADDR_LEN * 3]; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('N'); 
	insert ('I'); 
	insert ('?'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	count = (unsigned) (hextoint (sizeof (unsigned))); 
	while (count--) 
	{ 
		mustbe (','); 
		index = (unsigned) (hextoint (sizeof (index))); 
		mustbe (','); 
		encode (address, sizeof (address)); 
		mustbe (','); 
		txrate = (uint16_t) (hextoint (sizeof (rxrate))); 
		mustbe (','); 
		rxrate = (uint16_t) (hextoint (sizeof (txrate))); 
		printf ("%d %s %3d RX %3d TX\n", index, hexstring (mac, sizeof (mac), address, sizeof (address)), rxrate, txrate); 
	} 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void atfd (struct uart * uart);
 *
 *   reset device to factory default pib command "ATFD";
 *
 *--------------------------------------------------------------------*/

static void atfd (struct uart * uart) 

{ 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('F'); 
	insert ('D'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void atps (struct uart * uart);
 *
 *   etner power save mode command "ATPS";
 *
 *--------------------------------------------------------------------*/

static void atps (struct uart * uart) 

{ 
	extern struct command command; 
	uint16_t result; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('P'); 
	insert ('S'); 
	uart->snooze = HTOBE16 (uart->snooze); 
	decode (& uart->snooze, sizeof (uart->snooze)); 
	uart->snooze = BE16TOH (uart->snooze); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	result = (uint16_t) (hextoint (sizeof (result))); 
	if (result != uart->snooze) 
	{ 
		error (1, EINVAL, "[%s]: expected timeout %04X", command.buffer, uart->snooze); 
	} 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void ato (struct uart * uart);
 *
 *   exit command mode and enter tyransparent mode command "ATO";
 *
 *--------------------------------------------------------------------*/

static void ato (struct uart * uart) 

{ 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('O'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void athsc (struct uart * uart);
 *
 *   exit command mode; enter high speed command mode "ATHSC";
 *
 *--------------------------------------------------------------------*/

static void athsc (struct uart * uart) 

{ 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('H'); 
	insert ('S'); 
	insert ('C'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void atwnv (struct uart * uart);
 *
 *   write PIB and/or IMG to NVM "ATWNVx";
 *
 *--------------------------------------------------------------------*/

static void atwnv (struct uart * uart) 

{ 
	extern struct command command; 
	byte result; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('W'); 
	insert ('N'); 
	insert ('V'); 
	decode (& uart->module, sizeof (uart->module)); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	result = (byte) (hextoint (sizeof (result))); 
	if (result != uart->module) 
	{ 
		error (1, EINVAL, "[%s]: expected module %d", command.buffer, uart->module); 
	} 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void atbsz1 (struct uart * uart);
 *
 *   get transparent mode buffer size "ATBSZ?";
 *
 *--------------------------------------------------------------------*/

static void atbsz1 (struct uart * uart) 

{ 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('B'); 
	insert ('S'); 
	insert ('Z'); 
	insert ('?'); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	uart->bfsize = (uint16_t) (hextoint (sizeof (uart->bfsize))); 
	mustbe ('\r'); 
	printf ("%d\n", uart->bfsize); 
	return; 
} 

/*====================================================================*
 *
 *   void atbsz2 (struct uart * uart);
 *
 *   set transparent mode buffer size "ATBSZn";
 *
 *--------------------------------------------------------------------*/

static void atbsz2 (struct uart * uart) 

{ 
	extern struct command command; 
	uint16_t result; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('B'); 
	insert ('S'); 
	insert ('Z'); 
	uart->bfsize = HTOBE16 (uart->bfsize); 
	decode (& uart->bfsize, sizeof (uart->bfsize)); 
	uart->bfsize = BE16TOH (uart->bfsize); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	result = (uint16_t) (hextoint (sizeof (result))); 
	if (result != uart->bfsize) 
	{ 
		error (1, EINVAL, "[%s]: expected buffer size %04X", command.buffer, uart->bfsize); 
	} 
	mustbe ('\r'); 
	printf ("%d\n", uart->bfsize); 
	return; 
} 

/*====================================================================*
 *
 *   void atto (struct uart * uart);
 *
 *   set transparent mode buffer timeout "ATTO";
 *
 *--------------------------------------------------------------------*/

static void atto (struct uart * uart) 

{ 
	extern struct command command; 
	uint16_t result; 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('T'); 
	insert ('O'); 
	uart->timeout = HTOBE16 (uart->timeout); 
	decode (& uart->timeout, sizeof (uart->timeout)); 
	uart->timeout = BE16TOH (uart->timeout); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	mustbe ('O'); 
	mustbe ('K'); 
	result = (uint16_t) (hextoint (sizeof (result))); 
	if (result != uart->timeout) 
	{ 
		error (1, EINVAL, "[%s]: expected timeout %04X", command.buffer, uart->timeout); 
	} 
	mustbe ('\r'); 
	return; 
} 

/*====================================================================*
 *
 *   void atm (struct uart * uart);
 *
 *--------------------------------------------------------------------*/

static void atm (struct uart * uart) 

{ 
	extern struct command command; 
	uint8_t buffer [ETHER_MAX_LEN +  ETHER_MAX_LEN +  512]; 
	unsigned length = (unsigned) (readframe (uart->eth.file, buffer, sizeof (buffer))); 
	if (length < FRAME_MIN_CHAR) 
	{ 
		error (1, ENOTSUP, "Frame specification of %d bytes less than %d minimum", (length >> 1), (FRAME_MIN_CHAR >> 1)); 
	} 
	if (length > FRAME_MAX_CHAR) 
	{ 
		error (1, ENOTSUP, "Frame specification of %d bytes more than %d maximum", (length >> 1), (FRAME_MAX_CHAR >> 1)); 
	} 
	clearcommand (); 
	insert ('A'); 
	insert ('T'); 
	insert ('M'); 
	memcpy (command.buffer +  command.length, buffer, length); 
	command.length += (signed) (length); 
	insert ('\r'); 
	sendcommand (& uart->port, uart->flags); 
	readcommand (& uart->port, uart->flags); 
	write (STDOUT_FILENO, command.buffer, command.length); 
	write (STDOUT_FILENO, "\n", sizeof (char)); 
	return; 
} 

/*====================================================================*
 *
 *   void manager (struct uart * uart);
 *
 *   examine flagword in struct uart and perform requested operations
 *   in the order that bits are tested; the order that bits are tested
 *   may be changed as needed;
 *
 *--------------------------------------------------------------------*/

static void manager (struct uart * uart) 

{ 
	if (_anyset (uart->flags, UART_WAKE)) 
	{ 
		at_wake (uart); 
	} 
	if (_anyset (uart->flags, UART_COMMAND)) 
	{ 
		at_command (uart); 
	} 
	if (_anyset (uart->flags, UART_RESPOND)) 
	{ 
		at_respond (uart); 
	} 
	if (_anyset (uart->flags, UART_ATRV)) 
	{ 
		atrv (uart); 
	} 
	if (_anyset (uart->flags, UART_ATRPM)) 
	{ 
		atrpm (uart); 
	} 
	if (_anyset (uart->flags, UART_ATDST1)) 
	{ 
		atdst1 (uart); 
	} 
	if (_anyset (uart->flags, UART_ATDST2)) 
	{ 
		atdst2 (uart); 
	} 
	if (_anyset (uart->flags, UART_ATZ)) 
	{ 
		atz (uart); 
	} 
	if (_anyset (uart->flags, UART_ATFD)) 
	{ 
		atfd (uart); 
	} 
	if (_anyset (uart->flags, UART_ATPS)) 
	{ 
		atps (uart); 
	} 
	if (_anyset (uart->flags, UART_ATO)) 
	{ 
		ato (uart); 
	} 
	if (_anyset (uart->flags, UART_ATNI)) 
	{ 
		atni (uart); 
	} 
	if (_anyset (uart->flags, UART_ATHSC)) 
	{ 
		athsc (uart); 
	} 
	if (_anyset (uart->flags, UART_ATSK1)) 
	{ 
		atsk1 (uart); 
	} 
	if (_anyset (uart->flags, UART_ATSK2)) 
	{ 
		atsk2 (uart); 
	} 
	if (_anyset (uart->flags, UART_ATRP)) 
	{ 
		at_readpib (uart); 
	} 
	if (_anyset (uart->flags, UART_ATWPF1)) 
	{ 
		at_writenvm (uart); 
	} 
	if (_anyset (uart->flags, UART_ATWPF2)) 
	{ 
		at_writepib (uart); 
	} 
	if (_anyset (uart->flags, UART_ATWNV)) 
	{ 
		atwnv (uart); 
	} 
	if (_anyset (uart->flags, UART_ATBSZ1)) 
	{ 
		atbsz1 (uart); 
	} 
	if (_anyset (uart->flags, UART_ATBSZ2)) 
	{ 
		atbsz2 (uart); 
	} 
	if (_anyset (uart->flags, UART_ATM)) 
	{ 
		atm (uart); 
	} 
	if (_anyset (uart->flags, UART_ATTO)) 
	{ 
		atto (uart); 
	} 
	return; 
} 

/*====================================================================*
 *
 *   int main (int argc, char const * argv []);
 *
 *--------------------------------------------------------------------*/

int main (int argc, char const * argv []) 

{ 
	static char const * optv [] = 
	{ 
		"bc:C:dD:F:HiImM:n:N:Op:P:qrRS:s:tTvwW:zZ:", 
		"", 
		"Qualcomm Atheros Serial Line Device Manager", 
		"b\tset default host baud rate", 
		"c s\tsend custom serial line command (s)", 
		"C x\tcommit module (x) to NVM [ATWNVx]", 
		"d\tget destination mac address [ATDST?]", 
		"D x\tset destination mac address [ATDSTx]", 
		"F f\tframe file is (s)", 
		"H\tplace device in High Speed Command Mode [ATHSC]", 
		"i\tget network information [ATNI]", 
		"I\tget PIB version and MAC address [ATRPM]", 
		"m\tget network membership key [ATSK?]", 
		"M x\tset network membership key [ATSKx]", 
		"N f\twrite NVM file (f) to SDRAM [ATWFP1]", 
		"O\tplace device in Transparent Mode [ATO]", 
		"p f\tread PIB from SDRAM to file (f) [ATRP]", 
		"P f\twrite PIB file (f) to SDRAM [ATWFP2]", 
		"q\tplace program in quiet mode", 
		"r\tget parameter/firmware revision [ATRV]", 
		"R\treset device [ATZ]", 
		"s f\tserial port is (f) [" DEVICE "]", 
		"S n\tenter power save mode for (n) seconds [ATPS]", 
		"t\ttest device [AT]", 
		"T\treset to factory defaults [ATFD]", 
		"v\tplace program verbose mode", 
		"w\tplace device in Command Mode [+++]", 
		"W x\tset Transparent Mode aggregation timeout [ATTO]", 
		"z\tget Transparent Mode buffer size [ATBSZ?]", 
		"Z n\tset Transparent Mode buffer size [ATBSZn]", 
		(char const *) (0)
	}; 
	struct uart uart = 
	{ 
		{ 
			0, 
			DEVICE
		}, 
		{ 
			- 1, 
			"nvmfile"
		}, 
		{ 
			- 1, 
			"pibfile"
		}, 
		{ 
			- 1, 
			"ethfile"
		}, 
		(char *) (0), 
		{ 
			0
		}, 
		{ 
			0
		}, 
		{ 
			0
		}, 
		{ 
			0
		}, 
		(uint8_t) (0), 
		(uint8_t) (0), 
		(uint16_t) (0), 
		(uint16_t) (0), 
		(uint16_t) (0), 
		(unsigned) (0)
	}; 
	signed c; 
	if (getenv (UART_PORT)) 
	{ 
		uart.port.name = strdup (getenv (UART_PORT)); 
	} 
	while (~ (c = getoptv (argc, argv, optv))) 
	{ 
		switch (c) 
		{ 
		case 'b': 
			_setbits (uart.flags, UART_DEFAULT); 
			break; 
		case 'c': 
			_setbits (uart.flags, UART_COMMAND); 
			uart.string = optarg; 
			break; 
		case 'C': 
			_setbits (uart.flags, UART_ATWNV); 
			uart.module = (byte) (basespec (optarg, 16, sizeof (uart.module))); 
			break; 
		case 'd': 
			_setbits (uart.flags, UART_ATDST1); 
			break; 
		case 'D': 
			_setbits (uart.flags, UART_ATDST2); 
			if (! hexencode (uart.MACAddress, sizeof (uart.MACAddress), optarg)) 
			{ 
				error (1, errno, PLC_BAD_MAC, optarg); 
			} 
			break; 
		case 'F': 
			if ((uart.eth.file = open (uart.eth.name = optarg, O_BINARY | O_RDONLY)) == - 1) 
			{ 
				error (1, errno, "%s", uart.eth.name); 
			} 
			_setbits (uart.flags, UART_ATM); 
			break; 
		case 'H': 
			_setbits (uart.flags, UART_ATHSC); 
			break; 
		case 'i': 
			_setbits (uart.flags, UART_ATNI); 
			break; 
		case 'I': 
			_setbits (uart.flags, UART_ATRPM); 
			break; 
		case 'm': 
			_setbits (uart.flags, UART_ATSK1); 
			break; 
		case 'M': 
			_setbits (uart.flags, UART_ATSK2); 
			if (! hexencode (uart.NMKDigest, sizeof (uart.NMKDigest), optarg)) 
			{ 
				error (1, errno, PLC_BAD_NMK, optarg); 
			} 
			break; 
		case 'N': 
			if ((uart.nvm.file = open (uart.nvm.name = optarg, O_BINARY | O_RDONLY)) == - 1) 
			{ 
				error (1, errno, "%s", uart.nvm.name); 
			} 
			_setbits (uart.flags, UART_ATWPF1); 
			break; 
		case 'O': 
			_setbits (uart.flags, UART_ATO); 
			break; 
		case 'P': 
			if ((uart.pib.file = open (uart.pib.name = optarg, O_BINARY | O_RDONLY)) == - 1) 
			{ 
				error (1, errno, "%s", uart.pib.name); 
			} 
			_setbits (uart.flags, UART_ATWPF2); 
			break; 
		case 'p': 
			if ((uart.pib.file = open (uart.pib.name = optarg, O_BINARY | O_CREAT | O_RDWR | O_TRUNC, FILE_FILEMODE)) == - 1) 
			{ 
				error (1, errno, "%s", uart.pib.name); 
			} 

#ifndef WIN32

			chown (optarg, getuid (), getgid ()); 

#endif

			_setbits (uart.flags, UART_ATRP); 
			break; 
		case 'q': 
			_setbits (uart.flags, UART_SILENCE); 
			break; 
		case 'r': 
			_setbits (uart.flags, UART_ATRV); 
			break; 
		case 'R': 
			_setbits (uart.flags, UART_ATZ); 
			break; 
		case 'S': 
			_setbits (uart.flags, UART_ATPS); 
			uart.snooze = (uint16_t) (uintspec (optarg, 1, 900)); 
			break; 
		case 's': 
			uart.port.name = optarg; 
			break; 
		case 'T': 
			_setbits (uart.flags, UART_ATFD); 
			break; 
		case 't': 
			_setbits (uart.flags, UART_RESPOND); 
			break; 
		case 'v': 
			_setbits (uart.flags, UART_VERBOSE); 
			break; 
		case 'w': 
			_setbits (uart.flags, UART_WAKE); 
			break; 
		case 'W': 
			_setbits (uart.flags, UART_ATTO); 
			uart.timeout = (unsigned) (uintspec (optarg, 1, 2000)); 
			break; 
		case 'z': 
			_setbits (uart.flags, UART_ATBSZ1); 
			break; 
		case 'Z': 
			_setbits (uart.flags, UART_ATBSZ2); 
			uart.bfsize = (uint16_t) (uintspec (optarg, 1, 1500)); 
			break; 
		default: 
			break; 
		} 
	} 
	argc -= optind; 
	argv += optind; 
	if (argc) 
	{ 
		error (1, ENOTSUP, ERROR_TOOMANY); 
	} 
	openport (& uart.port, uart.flags); 
	manager (& uart); 
	closeport (& uart.port); 
	exit (0); 
}