    /*====================================================================*
     *
     *   Copyright (c) 2013 Qualcomm Atheros, Inc.
     *
     *   All rights reserved.
     *
     *   Redistribution and use in source and binary forms, with or
     *   without modification, are permitted (subject to the limitations
     *   in the disclaimer below) provided that the following conditions
     *   are met:
     *
     *   * Redistributions of source code must retain the above copyright
     *     notice, this list of conditions and the following disclaimer.
     *
     *   * 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.
     *
     *   * Neither the name of Qualcomm Atheros nor the names of
     *     its contributors may be used to endorse or promote products
     *     derived from this software without specific prior written
     *     permission.
     *
     *   NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
     *   GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE
     *   COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER
     *   OR CONTRIBUTORS 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.
     *
     *--------------------------------------------------------------------*/

    /*====================================================================*
     *
     *   int6kuart.c - 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:",
    		"",
    		"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)) != -1)
    	{
    		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);
    }

[PREV] [HOME] [NEXT]