/*====================================================================*
*
* 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.
*
*--------------------------------------------------------------------*/
/*====================================================================*
*
* 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>
*
*--------------------------------------------------------------------*/
#ifndef MMECODE_SOURCE
#define MMECODE_SOURCE
#include <stdio.h>
#include <stdint.h>
#include "../mme/mme.h"
#include "../tools/symbol.h"
#include "../tools/endian.h"
#ifndef MMEPASSFAIL
static struct mme_code
{
uint16_t type;
uint8_t code;
char const * text;
}
mme_codes [] =
{
{
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,
"Invalid Index"
},
{
0x8005,
0x81,
"Invalid Word Count"
},
{
0x8005,
0x82,
"No Stop Before Read"
},
{
0x8005,
0x83,
"Invalid MME"
},
#ifdef SOFTLOADER
{
0xA005,
0x14,
"Bad Checksum"
},
{
0xA005,
0x1C,
"Bad Length"
},
{
0xA005,
0x38,
"Bad Address"
},
{
0xA005,
0x3C,
"Bad Data Alignment"
},
#else
{
0xA005,
0x10,
"Bad Address"
},
{
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 Command"
},
{
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,
"Unexpected 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,
"Illegal Firmware Revision"
},
{
0xA031,
0x01,
"Bad Control"
},
{
0xA031,
0x02,
"Bad Direction"
},
{
0xA031,
0x10,
"Bad Link ID"
},
{
0xA031,
0x20,
"Bad MAC Address"
},
{
0xA035,
0x10,
"Bad Control"
},
{
0xA049,
0x20,
"Invalid Duration"
},
{
0xA049,
0x12,
"Invalid Length"
},
{
0xA049,
0x24,
"Already Set"
},
{
0xA051,
0x10,
"Bad PEKS"
},
{
0xA051,
0x11,
"Bad PIB"
},
{
0xA051,
0x12,
"Bad PEKS Encrypted Payload"
},
{
0xA051,
0x13,
"Remote Failure"
},
{
0xA051,
0x14,
"Bad Remote Response"
},
{
0xA051,
0x15,
"Remote Decryption Failed"
},
{
0xA059,
0x10,
"No Flash Memory"
},
{
0xA05D,
0x30,
"Bad Checksum"
},
{
0xA05D,
0x34,
"BIST Failed"
},
{
0xA065,
0x10,
"No Flash Memory"
},
{
0xA069,
0x01,
"Failed"
},
{
0xA069,
0x02,
"Not Supported"
},
{
0xA06D,
0x01,
"Bad Control"
},
{
0xA06D,
0x02,
"Success Write"
},
{
0xA06D,
0x03,
"Bad Write Parameter"
},
{
0xA071,
0x01,
"Bad MAC Address"
},
{
0xA071,
0x02,
"Bad TMSLOT"
},
{
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,
"Invalid 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"
},
{
0xA089,
0x01,
"Bad Control"
},
{
0xA089,
0x02,
"Bad Volatility"
},
{
0xA089,
0x03,
"Bad Classifier"
},
{
0xA089,
0x04,
"Classifier table full"
},
{
0xA089,
0x05,
"Classifier exists with different action"
},
{
0xA089,
0x06,
"Classifier not found"
},
{
0xA08D,
0x10,
"Refused"
},
{
0xA08D,
0x11,
"Refused"
},
{
0xA08F,
0x10,
"Error"
},
{
0xA091,
0x01,
"Unknown Peer Address"
},
{
0xA091,
0x02,
"Unknown Slot Number"
},
{
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"
},
{
0xA0B1,
0x10,
"Invalid Number of Module Operations"
},
{
0xA0B1,
0x11,
"Invalid Module Operation ID"
},
{
0xA0B1,
0x12,
"Invalid Session ID"
},
{
0xA0B1,
0x13,
"Invalid Num Module Operation Specific Data"
},
{
0xA0B1,
0x14,
"Module ID not found"
},
{
0xA0B1,
0x15,
"Invalid Module Length"
},
{
0xA0B1,
0x16,
"Invalid Module Index"
},
{
0xA0B1,
0x17,
"Invalid Data Length"
},
{
0xA0B1,
0x18,
"Unexpected Offset"
},
{
0xA0B1,
0x19,
"Invalid Commit Action Code"
},
{
0xA0B1,
0x1A,
"Operation Block by previous Commit"
},
{
0xA0B1,
0x1B,
"Duplicate ModuleID/SubID"
},
{
0xA0B1,
0x1C,
"Invalid 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,
"Invalid Header Checksum"
},
{
0xA0B1,
0x41,
"Invalid Firmware Image Checksum"
},
{
0xA0B1,
0x42,
"Softloader Image is Too Large"
},
{
0xA0B1,
0x43,
"Firmware Image is Too Large"
},
{
0xA0B1,
0x44,
"Invalid 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,
"Invalid 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"
},
{
0xA0C1,
0x03,
"Invalid Classifier"
},
{
0xA0C1,
0x04,
"Already too many Classifiers"
},
{
0xA0C1,
0x05,
"Classifier exists with different Classification Action"
},
{
0xA0C1,
0x07,
"Link Already in Progress"
},
{
0xA0C1,
0x08,
"Invalid Configuration"
},
{
0xA0C1,
0x10,
"Invalid CSPEC Version"
},
{
0xA0C1,
0x11,
"Invalid CSPEC"
},
{
0xA0C1,
0x20,
"Out of Local Resources"
},
{
0xA0C1,
0x30,
"Invalid Peer"
},
{
0xA0C1,
0x31,
"Peer Confirm Timed out"
},
{
0xA0C1,
0x40,
"Peer rejection"
},
{
0xA0C5,
0x01,
"Invalid Modification Control"
},
{
0xA0C5,
0x06,
"CID Not Found"
},
{
0xA0C5,
0x07,
"Link Update in Progress, try again later"
},
{
0xA0C9,
0x06,
"CID Not Found"
},
{
0xA0C9,
0x07,
"Link Update in Progress. Try again later"
},
{
0xA0C9,
0x31,
"Peer Confirm Timed out"
},
{
0xA0CD,
0x01,
"Invalid Request Type"
},
{
0xA0CD,
0x04,
"Too Many Requests",
},
{
0xA0CD,
0x06,
"CID Not Found"
},
{
0xA0CD,
0x10,
"Invalid CSPEC Version"
},
{
0xA0CD,
0x31,
"Peer Confirm Timed out"
},
{
0xA0D1,
0x01,
"Unsupported"
},
{
0xA0D1,
0x02,
"Process Failed"
},
{
0xA0D1,
0x02,
"Process Failed"
},
{
0xA0D9,
0x01,
"Bad VersionID or InfoID"
},
{
0xA0DD,
0x01,
"No Enumeration Table"
},
{
0xA0F5,
0x01,
"Bad Request Type"
},
{
0xA0F5,
0x02,
"FMI Not Zero"
},
{
0xA0F5,
0x03,
"Invalid 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,
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,
"Invalid Property Data"
},
{
0xA101,
0x08,
"Bad Property Data Length"
},
{
0xA105,
0x01,
"Buffer Not Available"
},
{
0xA109,
0x01,
"No Flash Memory"
},
{
0xA109,
0x02,
"Invalid 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,
"Invalid Key Length"
},
{
0xA149,
0x2,
"Invalid Key"
},
{
0xA149,
0x3,
"Invalid Access Type"
},
{
0xA149,
0x4,
"Invalid Level Control"
}
};
#endif
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