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

#ifndef MMECODE_SOURCE
#define MMECODE_SOURCE

#include <stdio.h>
#include <stdint.h>

#include "../mme/mme.h"
#include "../tools/symbol.h"
#include "../tools/endian.h"
#include "../tools/error.h"

#ifndef MMEPASSFAIL

static struct mme_code 

{ 
	uint16_t type; 
	uint8_t code; 
	char const * text; 
} 

mme_codes [] = 

{ 
	{ 
		0x8001, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0x8005, 
		0x01, 
		"Read Stopped"
	}, 
	{ 
		0x8005, 
		0x03, 
		"Stopped with Valid Read"
	}, 
	{ 
		0x8005, 
		0x05, 
		"Reached End"
	}, 
	{ 
		0x8005, 
		0x07, 
		"Stopped, Valid Read, Reached End - All Done! Go Away!"
	}, 
	{ 
		0x8005, 
		0x80, 
		"Bad Index"
	}, 
	{ 
		0x8005, 
		0x81, 
		"Bad Word Count"
	}, 
	{ 
		0x8005, 
		0x82, 
		"No Stop Before Read"
	}, 
	{ 
		0x8005, 
		0x83, 
		"Bad MME"
	}, 

#ifdef SOFTLOADER

	{ 
		0xA005, 
		0x14, 
		"Bad Checksum"
	}, 
	{ 
		0xA005, 
		0x1C, 
		"Bad Length"
	}, 
	{ 
		0xA005, 
		0x38, 
		"Bad Address"
	}, 
	{ 
		0xA005, 
		0x3C, 
		"Bad Data Alignment"
	}, 

#else

	{ 
		0xA005, 
		0x10, 
		"Bad Offset"
	}, 
	{ 
		0xA005, 
		0x14, 
		"Bad Length"
	}, 

#endif

	{ 
		0xA009, 
		0x10, 
		"Bad Offset"
	}, 
	{ 
		0xA009, 
		0x14, 
		"Bad Length"
	}, 
	{ 
		0xA00D, 
		0x10, 
		"Bad Module ID"
	}, 

#ifdef SOFTLOADER 

	{ 
		0xA00D, 
		0x14, 
		"Bad Image Checksum"
	}, 
	{ 
		0xA00D, 
		0x1C, 
		"Bad Image Length"
	}, 
	{ 
		0xA00D, 
		0x38, 
		"Bad Image Load Address"
	}, 
	{ 
		0xA00D, 
		0x3C, 
		"Bad Data Alignment"
	}, 
	{ 
		0xA00D, 
		0x40, 
		"Bad Start Address"
	}, 

#else

	{ 
		0xA00D, 
		0x38, 
		"Bad Checksum"
	}, 
	{ 
		0xA00D, 
		0x40, 
		"Failed to Lock NVM"
	}, 

#endif

	{ 
		0xA011, 
		0x10, 
		"No Flash Memory"
	}, 
	{ 
		0xA01D, 
		0x01, 
		"Device Failed to Reset"
	}, 
	{ 
		0xA01D, 
		0x02, 
		"Device is Busy"
	}, 
	{ 
		0xA021, 
		0x10, 
		"Bad Module"
	}, 
	{ 
		0xA021, 
		0x12, 
		"Bad Length"
	}, 
	{ 
		0xA021, 
		0x14, 
		"Bad Checksum"
	}, 
	{ 
		0xA021, 
		0x20, 
		"Bad Offset"
	}, 
	{ 
		0xA021, 
		0x40, 
		"Operation Blocked"
	}, 
	{ 
		0xA021, 
		0x50, 
		"Fail to lock NVM"
	}, 
	{ 
		0xA025, 
		0x10, 
		"Bad Module"
	}, 
	{ 
		0xA025, 
		0x12, 
		"Bad Length"
	}, 
	{ 
		0xA025, 
		0x14, 
		"Bad Checksum"
	}, 
	{ 
		0xA025, 
		0x20, 
		"Bad Offset"
	}, 
	{ 
		0xA025, 
		0x50, 
		"Fail to lock NVM"
	}, 
	{ 
		0xA025, 
		0x58, 
		"DAK Mismatch"
	}, 
	{ 
		0xA029, 
		0x10, 
		"Bad Module"
	}, 
	{ 
		0xA029, 
		0x14, 
		"No Flash Memory"
	}, 
	{ 
		0xA029, 
		0x18, 
		"Not enough NVRAM"
	}, 
	{ 
		0xA029, 
		0x1C, 
		"Bad Header Checksum"
	}, 
	{ 
		0xA029, 
		0x20, 
		"Bad Image Checksum"
	}, 
	{ 
		0xA029, 
		0x24, 
		"Bad PIB"
	}, 
	{ 
		0xA029, 
		0x28, 
		"Softloader Too Large"
	}, 
	{ 
		0xA029, 
		0x2C, 
		"Firmware Too Large"
	}, 
	{ 
		0xA029, 
		0x42, 
		"Firmware without PIB"
	}, 
	{ 
		0xA029, 
		0x44, 
		"Bad PIB Checksum"
	}, 
	{ 
		0xA029, 
		0x46, 
		"DAK Not Zero"
	}, 
	{ 
		0xA029, 
		0x48, 
		"MAC Mismatch"
	}, 
	{ 
		0xA029, 
		0x50, 
		"MFG HFID Mismatch"
	}, 
	{ 
		0xA029, 
		0x52, 
		"Bad Bind Factory Defaults"
	}, 
	{ 
		0xA029, 
		0x54, 
		"Bad Bind Template PIB"
	}, 
	{ 
		0xA029, 
		0x56, 
		"Bad Bind Working PIB"
	}, 
	{ 
		0xA029, 
		0x58, 
		"Error Computing PIB Checksum"
	}, 
	{ 
		0xA029, 
		0x5A, 
		"Bad Bind Scratch PIB"
	}, 
	{ 
		0xA029, 
		0x5C, 
		"No Firmware Version"
	}, 
	{ 
		0xA029, 
		0x5E, 
		"Version Mismatch"
	}, 
	{ 
		0xA029, 
		0x60, 
		"Bad 01PIB Checksum"
	}, 
	{ 
		0xA029, 
		0x62, 
		"Bad 02PIB Checksum"
	}, 
	{ 
		0xA029, 
		0x64, 
		"Bad WPIB Checksum"
	}, 
	{ 
		0xA029, 
		0x66, 
		"Bad Firmware Revision"
	}, 
	{ 
		0xA029, 
		0x68, 
		"Unssupported Firmware"
	}, 

#if 1

/*
 * [CFM] What are these? 
 */

	{ 
		0xA029, 
		0x70, 
		"No Bound Parameter Block"
	}, 
	{ 
		0xA029, 
		0x72, 
		"No Network Management Data Slot"
	}, 

#endif

	{ 
		0xA02D, 
		0x01, 
		"Read Failed"
	}, 
	{ 
		0xA031, 
		0x01, 
		"Bad Control"
	}, 
	{ 
		0xA031, 
		0x02, 
		"Bad Direction"
	}, 
	{ 
		0xA031, 
		0x10, 
		"Bad Link ID"
	}, 
	{ 
		0xA031, 
		0x20, 
		"Bad MAC Address"
	}, 
	{ 
		0xA035, 
		0x10, 
		"Bad Control"
	}, 
	{ 
		0xA041, 
		0x01, 
		"Read Failed"
	}, 
	{ 
		0xA049, 
		0x01, 
		"Loopback Failed"
	}, 
	{ 
		0xA049, 
		0x12, 
		"Bad Message Length"
	}, 
	{ 
		0xA049, 
		0x20, 
		"Bad Transmit Duration"
	}, 
	{ 
		0xA049, 
		0x24, 
		"Already Set"
	}, 
	{ 
		0xA04D, 
		0x01, 
		"Read Failed"
	}, 
	{ 
		0xA051, 
		0x10, 
		"Bad EKS"
	}, 
	{ 
		0xA051, 
		0x11, 
		"Bad PEKS"
	}, 
	{ 
		0xA051, 
		0x12, 
		"Bad PEKS Encrypted Payload"
	}, 
	{ 
		0xA051, 
		0x13, 
		"Remote Failure"
	}, 
	{ 
		0xA051, 
		0x14, 
		"Bad Remote Answer"
	}, 
	{ 
		0xA051, 
		0x15, 
		"Remote Decryption Failed"
	}, 
	{ 
		0xA055, 
		0x01, 
		"Read Failed"
	}, 
	{ 
		0xA059, 
		0x10, 
		"No Flash Memory"
	}, 
	{ 
		0xA05D, 
		0x30, 
		"Bad Checksum"
	}, 
	{ 
		0xA05D, 
		0x34, 
		"BIST Failed"
	}, 
	{ 
		0xA065, 
		0x10, 
		"No Flash Memory"
	}, 
	{ 
		0xA069, 
		0x01, 
		"Read Failed"
	}, 
	{ 
		0xA069, 
		0x02, 
		"Not Supported"
	}, 
	{ 
		0xA06D, 
		0x01, 
		"Bad Control"
	}, 
	{ 
		0xA06D, 
		0x02, 
		"Success Write"
	}, 
	{ 
		0xA06D, 
		0x03, 
		"Bad Write Parameter"
	}, 
	{ 
		0xA06D, 
		0x04, 
		"Bad Port Index"
	}, 
	{ 
		0xA071, 
		0x01, 
		"Bad MAC Address"
	}, 
	{ 
		0xA071, 
		0x02, 
		"Bad Time Slot"
	}, 
	{ 
		0xA079, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0xA07D, 
		0x01, 
		"Reset Failed"
	}, 
	{ 
		0xA07D, 
		0x02, 
		"Failed to Lock NVM"
	}, 
	{ 
		0xA081, 
		0x10, 
		"Bad Module ID"
	}, 
	{ 
		0xA081, 
		0x14, 
		"No Flash Memory"
	}, 
	{ 
		0xA081, 
		0x18, 
		"Not Enough Flash Memory"
	}, 
	{ 
		0xA081, 
		0x1C, 
		"Bad Image Header Checksum"
	}, 
	{ 
		0xA081, 
		0x20, 
		"Bad Image Checksum"
	}, 
	{ 
		0xA081, 
		0x24, 
		"Bad PIB"
	}, 
	{ 
		0xA081, 
		0x28, 
		"Softloader Too Large"
	}, 
	{ 
		0xA081, 
		0x2C, 
		"Firmware File Too Large"
	}, 
	{ 
		0xA081, 
		0x42, 
		"Firmware without PIB"
	}, 
	{ 
		0xA081, 
		0x44, 
		"Bad PIB Checksum"
	}, 
	{ 
		0xA081, 
		0x46, 
		"DAK Not Zero"
	}, 
	{ 
		0xA081, 
		0x48, 
		"DAC Mismatch"
	}, 
	{ 
		0xA081, 
		0x50, 
		"MFG HFID Mismatch"
	}, 
	{ 
		0xA081, 
		0x52, 
		"Bad Bind Factory Defaults"
	}, 
	{ 
		0xA081, 
		0x54, 
		"Bad Bind Template PIB"
	}, 
	{ 
		0xA081, 
		0x56, 
		"Bad Bind Working PIB"
	}, 
	{ 
		0xA081, 
		0x58, 
		"DAK Mismatch"
	}, 
	{ 
		0xA081, 
		0x5A, 
		"Failed to Lock NVM"
	}, 
	{ 
		0xA085, 
		0x01, 
		"Bad Request Type"
	}, 
	{ 
		0xA085, 
		0x02, 
		"Bad Address Type"
	}, 
	{ 
		0xA085, 
		0x03, 
		"No Such Address"
	}, 
	{ 
		0xA085, 
		0x04, 
		"Table Overflow"
	}, 
	{ 
		0xA085, 
		0x05, 
		"Bad Group Memberhip Info"
	}, 
	{ 
		0xA085, 
		0x06, 
		"Flash Save Error"
	}, 
	{ 
		0xA085, 
		0x07, 
		"Table Not Available"
	}, 
	{ 
		0xA089, 
		0x01, 
		"Bad Control"
	}, 
	{ 
		0xA089, 
		0x02, 
		"Bad Volatility"
	}, 
	{ 
		0xA089, 
		0x03, 
		"Bad Classifier"
	}, 
	{ 
		0xA089, 
		0x04, 
		"Too Many Classifiers"
	}, 
	{ 
		0xA089, 
		0x05, 
		"Duplicate Classifier"
	}, 
	{ 
		0xA089, 
		0x06, 
		"Classifier Not Found"
	}, 
	{ 
		0xA089, 
		0x07, 
		"Link Update In Progress"
	}, 
	{ 
		0xA089, 
		0x08, 
		"Bad Configuration"
	}, 
	{ 
		0xA089, 
		0x10, 
		"Invalid CSPEC Version"
	}, 
	{ 
		0xA089, 
		0x11, 
		"Invalid CSPEC"
	}, 
	{ 
		0xA089, 
		0x1F, 
		"Invalid CSPEC - Proposed *"
	}, 
	{ 
		0xA08D, 
		0x10, 
		"Refused Host Connetcion *"
	}, 
	{ 
		0xA08D, 
		0x11, 
		"Refused AVLN Size *"
	}, 
	{ 
		0xA08F, 
		0x10, 
		"Error"
	}, 
	{ 
		0xA091, 
		0x01, 
		"Unknown Peer Address"
	}, 
	{ 
		0xA091, 
		0x02, 
		"Unknown Slot Number"
	}, 
	{ 
		0xA095, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0xA099, 
		0x01, 
		"Destination Address Misaligned"
	}, 
	{ 
		0xA099, 
		0x02, 
		"Entry Point Misaligned"
	}, 
	{ 
		0xA099, 
		0x04, 
		"Entry Point Out-of-Bounds"
	}, 
	{ 
		0xA099, 
		0x08, 
		"Bad Checksum"
	}, 
	{ 
		0xA099, 
		0x10, 
		"Out of Memory"
	}, 
	{ 
		0xA099, 
		0x20, 
		"Offset or Length Mismatch"
	}, 
	{ 
		0xA099, 
		0x40, 
		"Memory not Operational"
	}, 
	{ 
		0xA099, 
		0x80, 
		"Bad Length"
	}, 

#if 1

/*
 * [MPM] Not sure if this should be included
 */

	{ 
		0xA09D, 
		0x00, 
		"Can't Read *"
	}, 

#endif

	{ 
		0xA09D, 
		0x01, 
		"Can't Write *"
	}, 
	{ 
		0xA09D, 
		0x02, 
		"Can't Read Switch *"
	}, 
	{ 
		0xA09D, 
		0x03, 
		"Can't Write Switch *"
	}, 
	{ 
		0xA0A1, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0xA0A5, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0xA0A9, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0xA0AD, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0xA0B1, 
		0x10, 
		"Bad Number of Module Operations"
	}, 
	{ 
		0xA0B1, 
		0x11, 
		"Bad Module Operation ID"
	}, 
	{ 
		0xA0B1, 
		0x12, 
		"Bad Session ID"
	}, 
	{ 
		0xA0B1, 
		0x13, 
		"Bad Num Module Operation Specific Data"
	}, 
	{ 
		0xA0B1, 
		0x14, 
		"Module ID not found"
	}, 
	{ 
		0xA0B1, 
		0x15, 
		"Bad Module Length"
	}, 
	{ 
		0xA0B1, 
		0x16, 
		"Bad Module Index"
	}, 
	{ 
		0xA0B1, 
		0x17, 
		"Bad Data Length"
	}, 
	{ 
		0xA0B1, 
		0x18, 
		"Unexpected Offset"
	}, 
	{ 
		0xA0B1, 
		0x19, 
		"Bad Commit Action Code"
	}, 
	{ 
		0xA0B1, 
		0x1A, 
		"Operation Block by previous Commit"
	}, 
	{ 
		0xA0B1, 
		0x1B, 
		"Duplicate ModuleID/SubID"
	}, 
	{ 
		0xA0B1, 
		0x1C, 
		"Bad ModuleID/SubID"
	}, 
	{ 
		0xA0B1, 
		0x20, 
		"No Flash Memory"
	}, 
	{ 
		0xA0B1, 
		0x21, 
		"Not Enough Flash Memory"
	}, 
	{ 
		0xA0B1, 
		0x22, 
		"Unsupported Flash memory Type"
	}, 
	{ 
		0xA0B1, 
		0x23, 
		"Can't Lock Flash Memory"
	}, 
	{ 
		0xA0B1, 
		0x24, 
		"Can't Write Flash Memory"
	}, 
	{ 
		0xA0B1, 
		0x30, 
		"Bad Module Checksum"
	}, 
	{ 
		0xA0B1, 
		0x31, 
		"Individual Module Error"
	}, 
	{ 
		0xA0B1, 
		0x32, 
		"Module not available in NVM or Memory"
	}, 
	{ 
		0xA0B1, 
		0x40, 
		"Bad Header Checksum"
	}, 
	{ 
		0xA0B1, 
		0x41, 
		"Bad Firmware Image Checksum"
	}, 
	{ 
		0xA0B1, 
		0x42, 
		"Softloader Image is Too Large"
	}, 
	{ 
		0xA0B1, 
		0x43, 
		"Firmware Image is Too Large"
	}, 
	{ 
		0xA0B1, 
		0x44, 
		"Bad PIB Checksum"
	}, 
	{ 
		0xA0B1, 
		0x45, 
		"No Firmware Version"
	}, 
	{ 
		0xA0B1, 
		0x46, 
		"FW Commit but no PIB"
	}, 
	{ 
		0xA0B1, 
		0x47, 
		"Major Version Mismatch"
	}, 
	{ 
		0xA0B1, 
		0x48, 
		"Minor Version Mismatch"
	}, 
	{ 
		0xA0B1, 
		0x50, 
		"Bad PIB"
	}, 
	{ 
		0xA0B1, 
		0x51, 
		"DAK Not Zero"
	}, 
	{ 
		0xA0B1, 
		0x52, 
		"MAC Mismatch"
	}, 
	{ 
		0xA0B1, 
		0x53, 
		"DAK Mismatch"
	}, 
	{ 
		0xA0B1, 
		0x54, 
		"Manufacturer HFID Mismatch"
	}, 
	{ 
		0xA0B1, 
		0x55, 
		"Bad Bind to Factory Default PIB"
	}, 
	{ 
		0xA0B1, 
		0x56, 
		"Bad Bind to Template PIB"
	}, 
	{ 
		0xA0B1, 
		0x57, 
		"Bad Bind to Working PIB"
	}, 
	{ 
		0xA0B1, 
		0x58, 
		"Bad Bind Scratch PIB"
	}, 
	{ 
		0xA0B1, 
		0x59, 
		"Error Generating Checksum Scratch PIB"
	}, 
	{ 
		0xA0B1, 
		0x5A, 
		"Checksum Error O1 PIB"
	}, 
	{ 
		0xA0B1, 
		0x5B, 
		"Checksum Error O2 PIB"
	}, 
	{ 
		0xA0B1, 
		0x5C, 
		"Checksum Error Working PIB"
	}, 
	{ 
		0xA0B1, 
		0x61, 
		"Unexpected Module Operation"
	}, 
	{ 
		0xA0B1, 
		0x62, 
		"Not Enough Resources"
	}, 
	{ 
		0xA0B1, 
		0x63, 
		"Received Module Data Out of Order"
	}, 
	{ 
		0xA0B1, 
		0x64, 
		"No PIB Version"
	}, 
	{ 
		0xA0B1, 
		0x70, 
		"Module Length Mismatch with Module Info"
	}, 
	{ 
		0xA0B1, 
		0x71, 
		"No NVM Softloader Present in Flash Memory"
	}, 
	{ 
		0xA0B1, 
		0x72, 
		"Cookie Mismatch"
	}, 
	{ 
		0xA0B1, 
		0x73, 
		"Blocked Previous Read"
	}, 
	{ 
		0xA0B1, 
		0xFF, 
		"Unknown Error"
	}, 
	{ 
		0xA0B9, 
		0x01, 
		"Request Failed *"
	}, 
	{ 
		0xA0BD, 
		0x01, 
		"Bad Control"
	}, 
	{ 
		0xA0BD, 
		0x10, 
		"Bad Output GPIO Index"
	}, 
	{ 
		0xA0BD, 
		0x20, 
		"Pattern Number Not Found"
	}, 
	{ 
		0xA0C1, 
		0x01, 
		"Bad Control"
	}, 
	{ 
		0xA0C1, 
		0x02, 
		"Bad Volatility"
	}, 
	{ 
		0xA0C1, 
		0x03, 
		"Bad Classifier"
	}, 
	{ 
		0xA0C1, 
		0x04, 
		"Already too many Classifiers"
	}, 
	{ 
		0xA0C1, 
		0x05, 
		"Classifier exists with different Classification Action"
	}, 
	{ 
		0xA0C1, 
		0x06, 
		"Not Found"
	}, 
	{ 
		0xA0C1, 
		0x07, 
		"Link Already in Progress"
	}, 
	{ 
		0xA0C1, 
		0x08, 
		"Bad Configuration"
	}, 
	{ 
		0xA0C1, 
		0x10, 
		"Bad CSPEC Version"
	}, 
	{ 
		0xA0C1, 
		0x11, 
		"Bad CSPEC"
	}, 
	{ 
		0xA0C1, 
		0x1F, 
		"Bad CSPEC_PropCSPEC"
	}, 
	{ 
		0xA0C1, 
		0x20, 
		"Out of Local Resources"
	}, 
	{ 
		0xA0C1, 
		0x2F, 
		"No Local Resource_PropCSPEC"
	}, 
	{ 
		0xA0C1, 
		0x30, 
		"Bad Peer"
	}, 
	{ 
		0xA0C1, 
		0x31, 
		"Peer Confirm Timed out"
	}, 
	{ 
		0xA0C1, 
		0x40, 
		"Peer rejection"
	}, 
	{ 
		0XA0C1, 
		0x4F, 
		"Peer Rejection_PropCSPEC"
	}, 
	{ 
		0xA0C5, 
		0x01, 
		"Bad Control"
	}, 
	{ 
		0xA0C5, 
		0x02, 
		"Bad Volatility"
	}, 
	{ 
		0xA0C5, 
		0x03, 
		"Bad Classifier"
	}, 
	{ 
		0xA0C5, 
		0x04, 
		"Already too many Classifiers"
	}, 
	{ 
		0xA0C5, 
		0x05, 
		"Classifier exists with different Classification Action"
	}, 
	{ 
		0xA0C5, 
		0x06, 
		"Not Found"
	}, 
	{ 
		0xA0C5, 
		0x07, 
		"Link Already in Progress"
	}, 
	{ 
		0xA0C5, 
		0x08, 
		"Bad Configuration"
	}, 
	{ 
		0xA0C5, 
		0x10, 
		"Bad CSPEC Version"
	}, 
	{ 
		0xA0C5, 
		0x11, 
		"Bad CSPEC"
	}, 
	{ 
		0xA0C5, 
		0x1F, 
		"Bad CSPEC_PropCSPEC"
	}, 
	{ 
		0xA0C5, 
		0x20, 
		"Out of Local Resources"
	}, 
	{ 
		0xA0C5, 
		0x2F, 
		"No Local Resource_PropCSPEC"
	}, 
	{ 
		0xA0C5, 
		0x30, 
		"Bad Peer"
	}, 
	{ 
		0xA0C5, 
		0x31, 
		"Peer Confirm Timed out"
	}, 
	{ 
		0xA0C5, 
		0x40, 
		"Peer rejection"
	}, 
	{ 
		0xA0C5, 
		0x4F, 
		"Peer Rejection_PropCSPEC"
	}, 
	{ 
		0xA0C9, 
		0x06, 
		"CID Not Found"
	}, 
	{ 
		0xA0C9, 
		0x07, 
		"Link Update in Progress. Try again later"
	}, 
	{ 
		0xA0C9, 
		0x31, 
		"Peer Confirm Timed out"
	}, 
	{ 
		0xA0CD, 
		0x01, 
		"Bad Request Type"
	}, 
	{ 
		0xA0CD, 
		0x04, 
		"Too Many Requests", 
	}, 
	{ 
		0xA0CD, 
		0x06, 
		"CID Not Found"
	}, 
	{ 
		0xA0CD, 
		0x10, 
		"Bad CSPEC Version"
	}, 
	{ 
		0xA0CD, 
		0x31, 
		"Peer Confirm Timed out"
	}, 
	{ 
		0xA0D1, 
		0x01, 
		"Unsupported"
	}, 
	{ 
		0xA0D1, 
		0x02, 
		"Process Failed"
	}, 
	{ 
		0xA0D9, 
		0x01, 
		"Bad VersionID or InfoID"
	}, 
	{ 
		0xA0D9, 
		0x02, 
		"Unknown Error"
	}, 
	{ 
		0xA0DD, 
		0x01, 
		"No Enumeration Table"
	}, 
	{ 
		0xA0E1, 
		0x01, 
		"Abort Standby Mode"
	}, 
	{ 
		0xA0E1, 
		0x02, 
		"Wait and Try Again"
	}, 
	{ 
		0xA0E1, 
		0x03, 
		"Feature Disabled"
	}, 
	{ 
		0xA0E1, 
		0x04, 
		"Bad Operation ID"
	}, 
	{ 
		0xA0E1, 
		0x05, 
		"Bad Sleep Schedule"
	}, 
	{ 
		0xA0E1, 
		0x06, 
		"Bad Scan Time"
	}, 
	{ 
		0xA0E5, 
		0x01, 
		"Feature Disabled"
	}, 

/*
 * [MPM] 0xA0F1 was missing
 */

	{ 
		0xA0F1, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0xA0F1, 
		0x02, 
		"Microcontroller Busy"
	}, 
	{ 
		0xA0F1, 
		0x03, 
		"Feature Disabled"
	}, 
	{ 
		0xA0F1, 
		0x04, 
		"Bad Parameter"
	}, 
	{ 
		0xA0F5, 
		0x01, 
		"Bad Request Type"
	}, 
	{ 
		0xA0F5, 
		0x02, 
		"FMI Not Zero"
	}, 
	{ 
		0xA0F5, 
		0x03, 
		"Bad Command"
	}, 
	{ 
		0xA0F5, 
		0x04, 
		"Bad Index"
	}, 
	{ 
		0xA0F5, 
		0x05, 
		"Bad Value Count"
	}, 
	{ 
		0xA0F5, 
		0x06, 
		"Capture Already Started"
	}, 
	{ 
		0xA0F5, 
		0x07, 
		"Data Invalid"
	}, 
	{ 
		0xA0F5, 
		0x08, 
		"Bad Gain Value"
	}, 
	{ 
		0xA0F5, 
		0x09, 
		"Bad Coupling"
	}, 
	{ 
		0xA0F5, 
		0x10, 
		"Bad MAC Address"
	}, 
	{ 
		0xA0F5, 
		0x11, 
		"Bad Tone Map Index"
	}, 
	{ 
		0xA0F5, 
		0x12, 
		"Capture Failed"
	}, 
	{ 
		0xA0F5, 
		0x13, 
		"No Data Available"
	}, 
	{ 
		0xA0F9, 
		0x01, 
		"Get Property Failure"
	}, 
	{ 
		0xA0F9, 
		0x02, 
		"Unsupported Property"
	}, 
	{ 
		0xA0F9, 
		0x03, 
		"Unsupported Property Version"
	}, 
	{ 
		0xA101, 
		0x01, 
		"Set Property Failure"
	}, 
	{ 
		0xA101, 
		0x02, 
		"Unsupported Property"
	}, 
	{ 
		0xA101, 
		0x03, 
		"Unsupported Property Version"
	}, 
	{ 
		0xA101, 
		0x04, 
		"Property Not Persistent"
	}, 
	{ 
		0xA101, 
		0x05, 
		"Flash Memory Failure"
	}, 
	{ 
		0xA101, 
		0x06, 
		"Bad Option for Supported Property"
	}, 
	{ 
		0xA101, 
		0x07, 
		"Bad Property Data"
	}, 
	{ 
		0xA101, 
		0x08, 
		"Bad Property Data Length"
	}, 
	{ 
		0xA105, 
		0x01, 
		"Buffer Not Available"
	}, 
	{ 
		0xA109, 
		0x01, 
		"No Flash Memory"
	}, 
	{ 
		0xA109, 
		0x02, 
		"Bad Flash Sector"
	}, 
	{ 
		0xA109, 
		0x03, 
		"Current DAK Mismatch"
	}, 
	{ 
		0xA109, 
		0x04, 
		"Flash is Busy"
	}, 
	{ 
		0xA109, 
		0x05, 
		"No Access to Flash"
	}, 
	{ 
		0xA109, 
		0x06, 
		"Unsupported Chip"
	}, 
	{ 
		0xA109, 
		0x07, 
		"Unspecified Error"
	}, 
	{ 
		0xA10D, 
		0x01, 
		"Option Not Supported"
	}, 
	{ 
		0xA10D, 
		0x02, 
		"No Flash Memory"
	}, 
	{ 
		0xA10D, 
		0x03, 
		"Pending Self Test"
	}, 
	{ 
		0xA10D, 
		0x04, 
		"Flash Activity Conflict"
	}, 
	{ 
		0xA10D, 
		0x05, 
		"Bad Parameter"
	}, 
	{ 
		0xA111, 
		0x01, 
		"Option Not Supported"
	}, 
	{ 
		0xA111, 
		0x02, 
		"Self Test Finished"
	}, 
	{ 
		0xA111, 
		0x03, 
		"Self Test Pending"
	}, 
	{ 
		0xA111, 
		0x04, 
		"Self Test In Progress"
	}, 
	{ 
		0xA111, 
		0x05, 
		"Self Test No Result"
	}, 
	{ 
		0xA111, 
		0x06, 
		"Self Test Aborted"
	}, 
	{ 
		0xA111, 
		0x07, 
		"No Flash Memory"
	}, 
	{ 
		0xA115, 
		0x01, 
		"Interface Not Supported"
	}, 
	{ 
		0xA115, 
		0x02, 
		"Slave Not Found"
	}, 
	{ 
		0xA115, 
		0x03, 
		"Wrong Parameter"
	}, 
	{ 
		0xA119, 
		0x01, 
		"Bad Version"
	}, 
	{ 
		0xA119, 
		0x02, 
		"Bad Argument"
	}, 
	{ 
		0xA119, 
		0x03, 
		"Too Many Slaves"
	}, 
	{ 
		0xA119, 
		0x04, 
		"Too Many VLAN IDs"
	}, 
	{ 
		0xA119, 
		0x05, 
		"No Such Slave"
	}, 
	{ 
		0xA119, 
		0x06, 
		"Flash Operation Blocked"
	}, 
	{ 
		0xA119, 
		0x07, 
		"Unsupported Operation"
	}, 
	{ 
		0xA119, 
		0x08, 
		"Flash Activity Conflict"
	}, 
	{ 
		0xA119, 
		0x09, 
		"Table Busy"
	}, 
	{ 
		0xA119, 
		0x0A, 
		"One Slave Has Duplicate VLAN ID"
	}, 
	{ 
		0xA119, 
		0x0B, 
		"Multiple Slaves Have Same VLAN ID"
	}, 
	{ 
		0xA119, 
		0x0C, 
		"Multiple Configurations for One Slave"
	}, 
	{ 
		0xA119, 
		0x0D, 
		"Can't set VLAN ID for Local Station"
	}, 
	{ 
		0xA119, 
		0x0E, 
		"Bad Data Offset"
	}, 
	{ 
		0xA119, 
		0x0F, 
		"Bad Data Length"
	}, 
	{ 
		0xA119, 
		0x10, 
		"VLAN ID Has Been Configured"
	}, 
	{ 
		0xA119, 
		0x11, 
		"Bad MME Source"
	}, 
	{ 
		0xA119, 
		0x12, 
		"VLAN ID out of range"
	}, 
	{ 
		0xA119, 
		0x13, 
		"Cannot remove nonexistent VLAN ID"
	}, 
	{ 
		0xA149, 
		0x1, 
		"Bad Key Length"
	}, 
	{ 
		0xA149, 
		0x2, 
		"Bad Key"
	}, 
	{ 
		0xA149, 
		0x3, 
		"Bad Access Type"
	}, 
	{ 
		0xA149, 
		0x4, 
		"Bad Level Control"
	}, 
	{ 
		0xA151, 
		0x01, 
		"Bad DA"
	}, 
	{ 
		0xA151, 
		0x02, 
		"Wire Tap Enabled By Another Host"
	}, 
	{ 
		0xA151, 
		0x03, 
		"Configuration Security Is Level 1 or Higher"
	}, 
	{ 
		0xA151, 
		0x04, 
		"Bad Time Period"
	}, 
	{ 
		0xA151, 
		0x05, 
		"Bad Settings"
	}, 
	{ 
		0xA151, 
		0x06, 
		"MME Buffer Allocation Failed"
	}, 
	{ 
		0xA151, 
		0x07, 
		"WireTap Feature Turned OFF in PIB" /*
*[MPM] Check for Error Code 0xA155
*/
	}, 
	{ 
		0xA155, 
		0x02, 
		"RBAT Is Full"
	}, 
	{ 
		0xA155, 
		0x04, 
		"LBAT Is Full"
	}, 
	{ 
		0xA155, 
		0x08, 
		"Bad DA MAC"
	}, 
	{ 
		0xA155, 
		0x10, 
		"Bad PLC MAc"
	}, 
	{ 
		0xA155, 
		0x20, 
		"Bad Interface ID"
	}, 
	{ 
		0xA155, 
		0x40, 
		"Bad Operation"
	}, 
	{ 
		0xA15B, 
		0x01, 
		"Request Failed"
	}, 
	{ 
		0xA15B, 
		0x02, 
		"Abort"
	}, 
	{ 
		0xA201, 
		0x01, 
		"Bad Request Type"
	}, 
	{ 
		0xA201, 
		0x02, 
		"Data Collection Disabled"
	} 
}; 

#endif

/*====================================================================*
 *
 *   void MMETest ();
 *
 *   mme.h
 *
 *   check the order of the MME type and code fields;
 *
 *--------------------------------------------------------------------*/

void MMETest () 

{ 
	unsigned mme; 
	for (mme = 1; mme < SIZEOF (mme_codes); mme++) 
	{ 
		if (mme_codes [mme].type > mme_codes [mme - 1].type) 
		{ 
			continue; 
		} 
		if (mme_codes [mme].type < mme_codes [mme - 1].type) 
		{ 
			error (0, 0, "TYPE 0x%04X CODE 0x%02X is out of order.", mme_codes [mme].type, mme_codes [mme].code); 
			continue; 
		} 
		if (mme_codes [mme].code > mme_codes [mme - 1].code) 
		{ 
			continue; 
		} 
		if (mme_codes [mme].code < mme_codes [mme - 1].code) 
		{ 
			error (0, 0, "TYPE 0x%04X CODE 0x%02X is out of order.", mme_codes [mme].type, mme_codes [mme].code); 
			continue; 
		} 
		error (0, 0, "TYPE 0x%04X CODE 0x%02X is a duplcate.", mme_codes [mme].type, mme_codes [mme].code); 
	} 
	return; 
} 

/*====================================================================*
 *
 *   char const * MMECode (uint16_t MMTYPE, uint8_t MSTATUS) 
 *
 *   mme.h  
 *
 *   return text for a given message type and status code; search is
 *   performed using two nested binary searches; 
 *
 *   D
 *   a given vendor specific status code may mean something different 
 *   for each message type; this table maps message types and codes to 
 *   strings; it is bulky but takes less space than many small tables;
 *   define MMEPASSFAIL as 0 to suppress the table without disturbing 
 *   other code;
 *
 *   the bootloader and firmware share some message types but return 
 *   different status codes for the same message type and error; two 
 *   MMEs in particular, VS_WR_MEM and VS_ST_MAC are normally used 
 *   only with the Bootloader and so we define SOFTLOADER as 1
 *   causing Bootloader/Softloader codes to replace the firmware
 *   codes;
 *
 *   Contributor(s):
 *	Charles Maier <cmaier@qca.qualcomm.com>
 *
 *--------------------------------------------------------------------*/

char const * MMECode (uint16_t MMTYPE, uint8_t MSTATUS) 

{ 

#ifndef MMEPASSFAIL

	size_t lower = 0; 
	size_t upper = SIZEOF (mme_codes); 
	MMTYPE = LE16TOH (MMTYPE); 
	while (lower < upper) 
	{ 
		size_t index = (lower +  upper) >> 1; 
		signed order = MMTYPE - mme_codes [index].type; 
		if (order < 0) 
		{ 
			upper = index - 0; 
			continue; 
		} 
		if (order > 0) 
		{ 
			lower = index +  1; 
			continue; 
		} 
		for (lower = index; lower > 0; lower--) 
		{ 
			if (mme_codes [lower - 1].type != mme_codes [index].type) 
			{ 
				break; 
			} 
		} 
		for (upper = index; upper < SIZEOF (mme_codes); upper++) 
		{ 
			if (mme_codes [upper +  0].type != mme_codes [index].type) 
			{ 
				break; 
			} 
		} 
		while (lower < upper) 
		{ 
			index = (lower +  upper) >> 1; 
			order = MSTATUS - mme_codes [index].code; 
			if (order < 0) 
			{ 
				upper = index - 0; 
				continue; 
			} 
			if (order > 0) 
			{ 
				lower = index +  1; 
				continue; 
			} 
			return (mme_codes [index].text); 
		} 
	} 

#endif

	return ((MSTATUS)? ("Failure"): ("Success")); 
} 

#endif