Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
branch: jb
Fetching contributors…

Cannot retrieve contributors at this time

2854 lines (2724 sloc) 87.634 kB
/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 2003-2010 Marcel Holtmann <marcel@holtmann.org>
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
#include "csr.h"
struct psr_data {
uint16_t pskey;
uint8_t *value;
uint8_t size;
struct psr_data *next;
};
static struct psr_data *head = NULL, *tail = NULL;
static struct {
uint16_t id;
char *str;
} csr_map[] = {
{ 66, "HCI 9.8" },
{ 97, "HCI 10.3" },
{ 101, "HCI 10.5" },
{ 111, "HCI 11.0" },
{ 112, "HCI 11.1" },
{ 114, "HCI 11.2" },
{ 115, "HCI 11.3" },
{ 117, "HCI 12.0" },
{ 119, "HCI 12.1" },
{ 133, "HCI 12.2" },
{ 134, "HCI 12.3" },
{ 162, "HCI 12.4" },
{ 165, "HCI 12.5" },
{ 169, "HCI 12.6" },
{ 188, "HCI 12.7" },
{ 218, "HCI 12.8" },
{ 283, "HCI 12.9" },
{ 203, "HCI 13.2" },
{ 204, "HCI 13.2" },
{ 210, "HCI 13.3" },
{ 211, "HCI 13.3" },
{ 213, "HCI 13.4" },
{ 214, "HCI 13.4" },
{ 225, "HCI 13.5" },
{ 226, "HCI 13.5" },
{ 237, "HCI 13.6" },
{ 238, "HCI 13.6" },
{ 242, "HCI 14.0" },
{ 243, "HCI 14.0" },
{ 244, "HCI 14.0" },
{ 245, "HCI 14.0" },
{ 254, "HCI 13.7" },
{ 255, "HCI 13.7" },
{ 264, "HCI 14.1" },
{ 265, "HCI 14.1" },
{ 267, "HCI 14.2" },
{ 268, "HCI 14.2" },
{ 272, "HCI 14.3" },
{ 273, "HCI 14.3" },
{ 274, "HCI 13.8" },
{ 275, "HCI 13.8" },
{ 286, "HCI 13.9" },
{ 287, "HCI 13.9" },
{ 309, "HCI 13.10" },
{ 310, "HCI 13.10" },
{ 313, "HCI 14.4" },
{ 314, "HCI 14.4" },
{ 323, "HCI 14.5" },
{ 324, "HCI 14.5" },
{ 336, "HCI 14.6" },
{ 337, "HCI 14.6" },
{ 351, "HCI 13.11" },
{ 352, "HCI 13.11" },
{ 362, "HCI 15.0" },
{ 363, "HCI 15.0" },
{ 364, "HCI 15.0" },
{ 365, "HCI 15.0" },
{ 373, "HCI 14.7" },
{ 374, "HCI 14.7" },
{ 379, "HCI 15.1" },
{ 380, "HCI 15.1" },
{ 381, "HCI 15.1" },
{ 382, "HCI 15.1" },
{ 392, "HCI 15.2" },
{ 393, "HCI 15.2" },
{ 394, "HCI 15.2" },
{ 395, "HCI 15.2" },
{ 436, "HCI 16.0" },
{ 437, "HCI 16.0" },
{ 438, "HCI 16.0" },
{ 439, "HCI 16.0" },
{ 443, "HCI 15.3" },
{ 444, "HCI 15.3" },
{ 465, "HCI 16.1" },
{ 466, "HCI 16.1" },
{ 467, "HCI 16.1" },
{ 468, "HCI 16.1" },
{ 487, "HCI 14.8" },
{ 488, "HCI 14.8" },
{ 492, "HCI 16.2" },
{ 493, "HCI 16.2" },
{ 495, "HCI 16.2" },
{ 496, "HCI 16.2" },
{ 502, "HCI 16.1.1" },
{ 503, "HCI 16.1.1" },
{ 504, "HCI 16.1.1" },
{ 505, "HCI 16.1.1" },
{ 506, "HCI 16.1.2" },
{ 507, "HCI 16.1.2" },
{ 508, "HCI 16.1.2" },
{ 509, "HCI 16.1.2" },
{ 516, "HCI 16.3" },
{ 517, "HCI 16.3" },
{ 518, "HCI 16.3" },
{ 519, "HCI 16.3" },
{ 523, "HCI 16.4" },
{ 524, "HCI 16.4" },
{ 525, "HCI 16.4" },
{ 526, "HCI 16.4" },
{ 553, "HCI 15.3" },
{ 554, "HCI 15.3" },
{ 562, "HCI 16.5" },
{ 563, "HCI 16.5" },
{ 564, "HCI 16.5" },
{ 565, "HCI 16.5" },
{ 593, "HCI 17.0" },
{ 594, "HCI 17.0" },
{ 595, "HCI 17.0" },
{ 599, "HCI 17.0" },
{ 600, "HCI 17.0" },
{ 608, "HCI 13.10.1" },
{ 609, "HCI 13.10.1" },
{ 613, "HCI 17.1" },
{ 614, "HCI 17.1" },
{ 615, "HCI 17.1" },
{ 616, "HCI 17.1" },
{ 618, "HCI 17.1" },
{ 624, "HCI 17.2" },
{ 625, "HCI 17.2" },
{ 626, "HCI 17.2" },
{ 627, "HCI 17.2" },
{ 637, "HCI 16.6" },
{ 638, "HCI 16.6" },
{ 639, "HCI 16.6" },
{ 640, "HCI 16.6" },
{ 642, "HCI 13.10.2" },
{ 643, "HCI 13.10.2" },
{ 644, "HCI 13.10.3" },
{ 645, "HCI 13.10.3" },
{ 668, "HCI 13.10.4" },
{ 669, "HCI 13.10.4" },
{ 681, "HCI 16.7" },
{ 682, "HCI 16.7" },
{ 683, "HCI 16.7" },
{ 684, "HCI 16.7" },
{ 704, "HCI 16.8" },
{ 718, "HCI 16.4.1" },
{ 719, "HCI 16.4.1" },
{ 720, "HCI 16.4.1" },
{ 721, "HCI 16.4.1" },
{ 722, "HCI 16.7.1" },
{ 723, "HCI 16.7.1" },
{ 724, "HCI 16.7.1" },
{ 725, "HCI 16.7.1" },
{ 731, "HCI 16.7.2" },
{ 732, "HCI 16.7.2" },
{ 733, "HCI 16.7.2" },
{ 734, "HCI 16.7.2" },
{ 735, "HCI 16.4.2" },
{ 736, "HCI 16.4.2" },
{ 737, "HCI 16.4.2" },
{ 738, "HCI 16.4.2" },
{ 750, "HCI 16.7.3" },
{ 751, "HCI 16.7.3" },
{ 752, "HCI 16.7.3" },
{ 753, "HCI 16.7.3" },
{ 760, "HCI 16.7.4" },
{ 761, "HCI 16.7.4" },
{ 762, "HCI 16.7.4" },
{ 763, "HCI 16.7.4" },
{ 770, "HCI 16.9" },
{ 771, "HCI 16.9" },
{ 772, "HCI 16.9" },
{ 773, "HCI 16.9" },
{ 774, "HCI 17.3" },
{ 775, "HCI 17.3" },
{ 776, "HCI 17.3" },
{ 777, "HCI 17.3" },
{ 781, "HCI 16.7.5" },
{ 786, "HCI 16.10" },
{ 787, "HCI 16.10" },
{ 788, "HCI 16.10" },
{ 789, "HCI 16.10" },
{ 791, "HCI 16.4.3" },
{ 792, "HCI 16.4.3" },
{ 793, "HCI 16.4.3" },
{ 794, "HCI 16.4.3" },
{ 798, "HCI 16.11" },
{ 799, "HCI 16.11" },
{ 800, "HCI 16.11" },
{ 801, "HCI 16.11" },
{ 806, "HCI 16.7.5" },
{ 807, "HCI 16.12" },
{ 808, "HCI 16.12" },
{ 809, "HCI 16.12" },
{ 810, "HCI 16.12" },
{ 817, "HCI 16.13" },
{ 818, "HCI 16.13" },
{ 819, "HCI 16.13" },
{ 820, "HCI 16.13" },
{ 823, "HCI 13.10.5" },
{ 824, "HCI 13.10.5" },
{ 826, "HCI 16.14" },
{ 827, "HCI 16.14" },
{ 828, "HCI 16.14" },
{ 829, "HCI 16.14" },
{ 843, "HCI 17.3.1" },
{ 856, "HCI 17.3.2" },
{ 857, "HCI 17.3.2" },
{ 858, "HCI 17.3.2" },
{ 1120, "HCI 17.11" },
{ 1168, "HCI 18.1" },
{ 1169, "HCI 18.1" },
{ 1241, "HCI 18.x" },
{ 1298, "HCI 18.2" },
{ 1354, "HCI 18.2" },
{ 1392, "HCI 18.2" },
{ 1393, "HCI 18.2" },
{ 1501, "HCI 18.2" },
{ 1503, "HCI 18.2" },
{ 1504, "HCI 18.2" },
{ 1505, "HCI 18.2" },
{ 1506, "HCI 18.2" },
{ 1520, "HCI 18.2" },
{ 1586, "HCI 18.2" },
{ 1591, "HCI 18.2" },
{ 1592, "HCI 18.2" },
{ 1593, "HCI 18.2.1" },
{ 1733, "HCI 18.3" },
{ 1734, "HCI 18.3" },
{ 1735, "HCI 18.3" },
{ 1737, "HCI 18.3" },
{ 1915, "HCI 19.2" },
{ 1916, "HCI 19.2" },
{ 1958, "HCI 19.2" },
{ 1981, "Unified 20a" },
{ 1982, "Unified 20a" },
{ 1989, "HCI 18.4" },
{ 2062, "Unified 20a1" },
{ 2063, "Unified 20a1" },
{ 2067, "Unified 18f" },
{ 2068, "Unified 18f" },
{ 2243, "Unified 18e" },
{ 2244, "Unified 18e" },
{ 2258, "Unified 20d" },
{ 2259, "Unified 20d" },
{ 2361, "Unified 20e" },
{ 2362, "Unified 20e" },
{ 2386, "Unified 21a" },
{ 2387, "Unified 21a" },
{ 2423, "Unified 21a" },
{ 2424, "Unified 21a" },
{ 2623, "Unified 21c" },
{ 2624, "Unified 21c" },
{ 2625, "Unified 21c" },
{ 2626, "Unified 21c" },
{ 2627, "Unified 21c" },
{ 2628, "Unified 21c" },
{ 2629, "Unified 21c" },
{ 2630, "Unified 21c" },
{ 2631, "Unified 21c" },
{ 2632, "Unified 21c" },
{ 2633, "Unified 21c" },
{ 2634, "Unified 21c" },
{ 2635, "Unified 21c" },
{ 2636, "Unified 21c" },
{ 2649, "Unified 21c" },
{ 2650, "Unified 21c" },
{ 2651, "Unified 21c" },
{ 2652, "Unified 21c" },
{ 2653, "Unified 21c" },
{ 2654, "Unified 21c" },
{ 2655, "Unified 21c" },
{ 2656, "Unified 21c" },
{ 2658, "Unified 21c" },
{ 3057, "Unified 21d" },
{ 3058, "Unified 21d" },
{ 3059, "Unified 21d" },
{ 3060, "Unified 21d" },
{ 3062, "Unified 21d" },
{ 3063, "Unified 21d" },
{ 3064, "Unified 21d" },
{ 3164, "Unified 21e" },
{ 3413, "Unified 21f" },
{ 3414, "Unified 21f" },
{ 3415, "Unified 21f" },
{ 3424, "Unified 21f" },
{ 3454, "Unified 21f" },
{ 3684, "Unified 21f" },
{ 3764, "Unified 21f" },
{ 4276, "Unified 22b" },
{ 4277, "Unified 22b" },
{ 4279, "Unified 22b" },
{ 4281, "Unified 22b" },
{ 4282, "Unified 22b" },
{ 4283, "Unified 22b" },
{ 4284, "Unified 22b" },
{ 4285, "Unified 22b" },
{ 4289, "Unified 22b" },
{ 4290, "Unified 22b" },
{ 4291, "Unified 22b" },
{ 4292, "Unified 22b" },
{ 4293, "Unified 22b" },
{ 4294, "Unified 22b" },
{ 4295, "Unified 22b" },
{ 4363, "Unified 22c" },
{ 4373, "Unified 22c" },
{ 4374, "Unified 22c" },
{ 4532, "Unified 22d" },
{ 4533, "Unified 22d" },
{ 4698, "Unified 23c" },
{ 4839, "Unified 23c" },
{ 4841, "Unified 23c" },
{ 4866, "Unified 23c" },
{ 4867, "Unified 23c" },
{ 4868, "Unified 23c" },
{ 4869, "Unified 23c" },
{ 4870, "Unified 23c" },
{ 4871, "Unified 23c" },
{ 4872, "Unified 23c" },
{ 4874, "Unified 23c" },
{ 4875, "Unified 23c" },
{ 4876, "Unified 23c" },
{ 4877, "Unified 23c" },
{ 2526, "Marcel 1 (2005-09-26)" },
{ 2543, "Marcel 2 (2005-09-28)" },
{ 2622, "Marcel 3 (2005-10-27)" },
{ 3326, "Marcel 4 (2006-06-16)" },
{ 3612, "Marcel 5 (2006-10-24)" },
{ 4509, "Marcel 6 (2007-06-11)" },
{ 5417, "Marcel 7 (2008-08-26)" },
{ 195, "Sniff 1 (2001-11-27)" },
{ 220, "Sniff 2 (2002-01-03)" },
{ 269, "Sniff 3 (2002-02-22)" },
{ 270, "Sniff 4 (2002-02-26)" },
{ 284, "Sniff 5 (2002-03-12)" },
{ 292, "Sniff 6 (2002-03-20)" },
{ 305, "Sniff 7 (2002-04-12)" },
{ 306, "Sniff 8 (2002-04-12)" },
{ 343, "Sniff 9 (2002-05-02)" },
{ 346, "Sniff 10 (2002-05-03)" },
{ 355, "Sniff 11 (2002-05-16)" },
{ 256, "Sniff 11 (2002-05-16)" },
{ 390, "Sniff 12 (2002-06-26)" },
{ 450, "Sniff 13 (2002-08-16)" },
{ 451, "Sniff 13 (2002-08-16)" },
{ 533, "Sniff 14 (2002-10-11)" },
{ 580, "Sniff 15 (2002-11-14)" },
{ 623, "Sniff 16 (2002-12-12)" },
{ 678, "Sniff 17 (2003-01-29)" },
{ 847, "Sniff 18 (2003-04-17)" },
{ 876, "Sniff 19 (2003-06-10)" },
{ 997, "Sniff 22 (2003-09-05)" },
{ 1027, "Sniff 23 (2003-10-03)" },
{ 1029, "Sniff 24 (2003-10-03)" },
{ 1112, "Sniff 25 (2003-12-03)" },
{ 1113, "Sniff 25 (2003-12-03)" },
{ 1133, "Sniff 26 (2003-12-18)" },
{ 1134, "Sniff 26 (2003-12-18)" },
{ 1223, "Sniff 27 (2004-03-08)" },
{ 1224, "Sniff 27 (2004-03-08)" },
{ 1319, "Sniff 31 (2004-04-22)" },
{ 1320, "Sniff 31 (2004-04-22)" },
{ 1427, "Sniff 34 (2004-06-16)" },
{ 1508, "Sniff 35 (2004-07-19)" },
{ 1509, "Sniff 35 (2004-07-19)" },
{ 1587, "Sniff 36 (2004-08-18)" },
{ 1588, "Sniff 36 (2004-08-18)" },
{ 1641, "Sniff 37 (2004-09-16)" },
{ 1642, "Sniff 37 (2004-09-16)" },
{ 1699, "Sniff 38 (2004-10-07)" },
{ 1700, "Sniff 38 (2004-10-07)" },
{ 1752, "Sniff 39 (2004-11-02)" },
{ 1753, "Sniff 39 (2004-11-02)" },
{ 1759, "Sniff 40 (2004-11-03)" },
{ 1760, "Sniff 40 (2004-11-03)" },
{ 1761, "Sniff 40 (2004-11-03)" },
{ 2009, "Sniff 41 (2005-04-06)" },
{ 2010, "Sniff 41 (2005-04-06)" },
{ 2011, "Sniff 41 (2005-04-06)" },
{ 2016, "Sniff 42 (2005-04-11)" },
{ 2017, "Sniff 42 (2005-04-11)" },
{ 2018, "Sniff 42 (2005-04-11)" },
{ 2023, "Sniff 43 (2005-04-14)" },
{ 2024, "Sniff 43 (2005-04-14)" },
{ 2025, "Sniff 43 (2005-04-14)" },
{ 2032, "Sniff 44 (2005-04-18)" },
{ 2033, "Sniff 44 (2005-04-18)" },
{ 2034, "Sniff 44 (2005-04-18)" },
{ 2288, "Sniff 45 (2005-07-08)" },
{ 2289, "Sniff 45 (2005-07-08)" },
{ 2290, "Sniff 45 (2005-07-08)" },
{ 2388, "Sniff 46 (2005-08-17)" },
{ 2389, "Sniff 46 (2005-08-17)" },
{ 2390, "Sniff 46 (2005-08-17)" },
{ 2869, "Sniff 47 (2006-02-15)" },
{ 2870, "Sniff 47 (2006-02-15)" },
{ 2871, "Sniff 47 (2006-02-15)" },
{ 3214, "Sniff 48 (2006-05-16)" },
{ 3215, "Sniff 48 (2006-05-16)" },
{ 3216, "Sniff 48 (2006-05-16)" },
{ 3356, "Sniff 49 (2006-07-17)" },
{ 3529, "Sniff 50 (2006-09-21)" },
{ 3546, "Sniff 51 (2006-09-29)" },
{ 3683, "Sniff 52 (2006-11-03)" },
{ 0, }
};
char *csr_builddeftostr(uint16_t def)
{
switch (def) {
case 0x0000:
return "NONE";
case 0x0001:
return "CHIP_BASE_BC01";
case 0x0002:
return "CHIP_BASE_BC02";
case 0x0003:
return "CHIP_BC01B";
case 0x0004:
return "CHIP_BC02_EXTERNAL";
case 0x0005:
return "BUILD_HCI";
case 0x0006:
return "BUILD_RFCOMM";
case 0x0007:
return "BT_VER_1_1";
case 0x0008:
return "TRANSPORT_ALL";
case 0x0009:
return "TRANSPORT_BCSP";
case 0x000a:
return "TRANSPORT_H4";
case 0x000b:
return "TRANSPORT_USB";
case 0x000c:
return "MAX_CRYPT_KEY_LEN_56";
case 0x000d:
return "MAX_CRYPT_KEY_LEN_128";
case 0x000e:
return "TRANSPORT_USER";
case 0x000f:
return "CHIP_BC02_KATO";
case 0x0010:
return "TRANSPORT_NONE";
case 0x0012:
return "REQUIRE_8MBIT";
case 0x0013:
return "RADIOTEST";
case 0x0014:
return "RADIOTEST_LITE";
case 0x0015:
return "INSTALL_FLASH";
case 0x0016:
return "INSTALL_EEPROM";
case 0x0017:
return "INSTALL_COMBO_DOT11";
case 0x0018:
return "LOWPOWER_TX";
case 0x0019:
return "TRANSPORT_TWUTL";
case 0x001a:
return "COMPILER_GCC";
case 0x001b:
return "CHIP_BC02_CLOUSEAU";
case 0x001c:
return "CHIP_BC02_TOULOUSE";
case 0x001d:
return "CHIP_BASE_BC3";
case 0x001e:
return "CHIP_BC3_NICKNACK";
case 0x001f:
return "CHIP_BC3_KALIMBA";
case 0x0020:
return "INSTALL_HCI_MODULE";
case 0x0021:
return "INSTALL_L2CAP_MODULE";
case 0x0022:
return "INSTALL_DM_MODULE";
case 0x0023:
return "INSTALL_SDP_MODULE";
case 0x0024:
return "INSTALL_RFCOMM_MODULE";
case 0x0025:
return "INSTALL_HIDIO_MODULE";
case 0x0026:
return "INSTALL_PAN_MODULE";
case 0x0027:
return "INSTALL_IPV4_MODULE";
case 0x0028:
return "INSTALL_IPV6_MODULE";
case 0x0029:
return "INSTALL_TCP_MODULE";
case 0x002a:
return "BT_VER_1_2";
case 0x002b:
return "INSTALL_UDP_MODULE";
case 0x002c:
return "REQUIRE_0_WAIT_STATES";
case 0x002d:
return "CHIP_BC3_PADDYWACK";
case 0x002e:
return "CHIP_BC4_COYOTE";
case 0x002f:
return "CHIP_BC4_ODDJOB";
case 0x0030:
return "TRANSPORT_H4DS";
case 0x0031:
return "CHIP_BASE_BC4";
default:
return "UNKNOWN";
}
}
char *csr_buildidtostr(uint16_t id)
{
static char str[12];
int i;
for (i = 0; csr_map[i].id; i++)
if (csr_map[i].id == id)
return csr_map[i].str;
snprintf(str, 11, "Build %d", id);
return str;
}
char *csr_chipvertostr(uint16_t ver, uint16_t rev)
{
switch (ver) {
case 0x00:
return "BlueCore01a";
case 0x01:
switch (rev) {
case 0x64:
return "BlueCore01b (ES)";
case 0x65:
default:
return "BlueCore01b";
}
case 0x02:
switch (rev) {
case 0x89:
return "BlueCore02-External (ES2)";
case 0x8a:
return "BlueCore02-External";
case 0x28:
return "BlueCore02-ROM/Audio/Flash";
default:
return "BlueCore02";
}
case 0x03:
switch (rev) {
case 0x43:
return "BlueCore3-MM";
case 0x15:
return "BlueCore3-ROM";
case 0xe2:
return "BlueCore3-Flash";
case 0x26:
return "BlueCore4-External";
case 0x30:
return "BlueCore4-ROM";
default:
return "BlueCore3 or BlueCore4";
}
default:
return "Unknown";
}
}
char *csr_pskeytostr(uint16_t pskey)
{
switch (pskey) {
case CSR_PSKEY_BDADDR:
return "Bluetooth address";
case CSR_PSKEY_COUNTRYCODE:
return "Country code";
case CSR_PSKEY_CLASSOFDEVICE:
return "Class of device";
case CSR_PSKEY_DEVICE_DRIFT:
return "Device drift";
case CSR_PSKEY_DEVICE_JITTER:
return "Device jitter";
case CSR_PSKEY_MAX_ACLS:
return "Maximum ACL links";
case CSR_PSKEY_MAX_SCOS:
return "Maximum SCO links";
case CSR_PSKEY_MAX_REMOTE_MASTERS:
return "Maximum remote masters";
case CSR_PSKEY_ENABLE_MASTERY_WITH_SLAVERY:
return "Support master and slave roles simultaneously";
case CSR_PSKEY_H_HC_FC_MAX_ACL_PKT_LEN:
return "Maximum HCI ACL packet length";
case CSR_PSKEY_H_HC_FC_MAX_SCO_PKT_LEN:
return "Maximum HCI SCO packet length";
case CSR_PSKEY_H_HC_FC_MAX_ACL_PKTS:
return "Maximum number of HCI ACL packets";
case CSR_PSKEY_H_HC_FC_MAX_SCO_PKTS:
return "Maximum number of HCI SCO packets";
case CSR_PSKEY_LC_FC_BUFFER_LOW_WATER_MARK:
return "Flow control low water mark";
case CSR_PSKEY_LC_MAX_TX_POWER:
return "Maximum transmit power";
case CSR_PSKEY_TX_GAIN_RAMP:
return "Transmit gain ramp rate";
case CSR_PSKEY_LC_POWER_TABLE:
return "Radio power table";
case CSR_PSKEY_LC_PEER_POWER_PERIOD:
return "Peer transmit power control interval";
case CSR_PSKEY_LC_FC_POOLS_LOW_WATER_MARK:
return "Flow control pool low water mark";
case CSR_PSKEY_LC_DEFAULT_TX_POWER:
return "Default transmit power";
case CSR_PSKEY_LC_RSSI_GOLDEN_RANGE:
return "RSSI at bottom of golden receive range";
case CSR_PSKEY_LC_COMBO_DISABLE_PIO_MASK:
return "Combo: PIO lines and logic to disable transmit";
case CSR_PSKEY_LC_COMBO_PRIORITY_PIO_MASK:
return "Combo: priority activity PIO lines and logic";
case CSR_PSKEY_LC_COMBO_DOT11_CHANNEL_PIO_BASE:
return "Combo: 802.11b channel number base PIO line";
case CSR_PSKEY_LC_COMBO_DOT11_BLOCK_CHANNELS:
return "Combo: channels to block either side of 802.11b";
case CSR_PSKEY_LC_MAX_TX_POWER_NO_RSSI:
return "Maximum transmit power when peer has no RSSI";
case CSR_PSKEY_LC_CONNECTION_RX_WINDOW:
return "Receive window size during connections";
case CSR_PSKEY_LC_COMBO_DOT11_TX_PROTECTION_MODE:
return "Combo: which TX packets shall we protect";
case CSR_PSKEY_LC_ENHANCED_POWER_TABLE:
return "Radio power table";
case CSR_PSKEY_LC_WIDEBAND_RSSI_CONFIG:
return "RSSI configuration for use with wideband RSSI";
case CSR_PSKEY_LC_COMBO_DOT11_PRIORITY_LEAD:
return "Combo: How much notice will we give the Combo Card";
case CSR_PSKEY_BT_CLOCK_INIT:
return "Initial value of Bluetooth clock";
case CSR_PSKEY_TX_MR_MOD_DELAY:
return "TX Mod delay";
case CSR_PSKEY_RX_MR_SYNC_TIMING:
return "RX MR Sync Timing";
case CSR_PSKEY_RX_MR_SYNC_CONFIG:
return "RX MR Sync Configuration";
case CSR_PSKEY_LC_LOST_SYNC_SLOTS:
return "Time in ms for lost sync in low power modes";
case CSR_PSKEY_RX_MR_SAMP_CONFIG:
return "RX MR Sync Configuration";
case CSR_PSKEY_AGC_HYST_LEVELS:
return "AGC hysteresis levels";
case CSR_PSKEY_RX_LEVEL_LOW_SIGNAL:
return "ANA_RX_LVL at low signal strengths";
case CSR_PSKEY_AGC_IQ_LVL_VALUES:
return "ANA_IQ_LVL values for AGC algorithmn";
case CSR_PSKEY_MR_FTRIM_OFFSET_12DB:
return "ANA_RX_FTRIM offset when using 12 dB IF atten ";
case CSR_PSKEY_MR_FTRIM_OFFSET_6DB:
return "ANA_RX_FTRIM offset when using 6 dB IF atten ";
case CSR_PSKEY_NO_CAL_ON_BOOT:
return "Do not calibrate radio on boot";
case CSR_PSKEY_RSSI_HI_TARGET:
return "RSSI high target";
case CSR_PSKEY_PREFERRED_MIN_ATTENUATION:
return "Preferred minimum attenuator setting";
case CSR_PSKEY_LC_COMBO_DOT11_PRIORITY_OVERRIDE:
return "Combo: Treat all packets as high priority";
case CSR_PSKEY_LC_MULTISLOT_HOLDOFF:
return "Time till single slot packets are used for resync";
case CSR_PSKEY_FREE_KEY_PIGEON_HOLE:
return "Link key store bitfield";
case CSR_PSKEY_LINK_KEY_BD_ADDR0:
return "Bluetooth address + link key 0";
case CSR_PSKEY_LINK_KEY_BD_ADDR1:
return "Bluetooth address + link key 1";
case CSR_PSKEY_LINK_KEY_BD_ADDR2:
return "Bluetooth address + link key 2";
case CSR_PSKEY_LINK_KEY_BD_ADDR3:
return "Bluetooth address + link key 3";
case CSR_PSKEY_LINK_KEY_BD_ADDR4:
return "Bluetooth address + link key 4";
case CSR_PSKEY_LINK_KEY_BD_ADDR5:
return "Bluetooth address + link key 5";
case CSR_PSKEY_LINK_KEY_BD_ADDR6:
return "Bluetooth address + link key 6";
case CSR_PSKEY_LINK_KEY_BD_ADDR7:
return "Bluetooth address + link key 7";
case CSR_PSKEY_LINK_KEY_BD_ADDR8:
return "Bluetooth address + link key 8";
case CSR_PSKEY_LINK_KEY_BD_ADDR9:
return "Bluetooth address + link key 9";
case CSR_PSKEY_LINK_KEY_BD_ADDR10:
return "Bluetooth address + link key 10";
case CSR_PSKEY_LINK_KEY_BD_ADDR11:
return "Bluetooth address + link key 11";
case CSR_PSKEY_LINK_KEY_BD_ADDR12:
return "Bluetooth address + link key 12";
case CSR_PSKEY_LINK_KEY_BD_ADDR13:
return "Bluetooth address + link key 13";
case CSR_PSKEY_LINK_KEY_BD_ADDR14:
return "Bluetooth address + link key 14";
case CSR_PSKEY_LINK_KEY_BD_ADDR15:
return "Bluetooth address + link key 15";
case CSR_PSKEY_ENC_KEY_LMIN:
return "Minimum encryption key length";
case CSR_PSKEY_ENC_KEY_LMAX:
return "Maximum encryption key length";
case CSR_PSKEY_LOCAL_SUPPORTED_FEATURES:
return "Local supported features block";
case CSR_PSKEY_LM_USE_UNIT_KEY:
return "Allow use of unit key for authentication?";
case CSR_PSKEY_HCI_NOP_DISABLE:
return "Disable the HCI Command_Status event on boot";
case CSR_PSKEY_LM_MAX_EVENT_FILTERS:
return "Maximum number of event filters";
case CSR_PSKEY_LM_USE_ENC_MODE_BROADCAST:
return "Allow LM to use enc_mode=2";
case CSR_PSKEY_LM_TEST_SEND_ACCEPTED_TWICE:
return "LM sends two LMP_accepted messages in test mode";
case CSR_PSKEY_LM_MAX_PAGE_HOLD_TIME:
return "Maximum time we hold a device around page";
case CSR_PSKEY_AFH_ADAPTATION_RESPONSE_TIME:
return "LM period for AFH adaption";
case CSR_PSKEY_AFH_OPTIONS:
return "Options to configure AFH";
case CSR_PSKEY_AFH_RSSI_RUN_PERIOD:
return "AFH RSSI reading period";
case CSR_PSKEY_AFH_REENABLE_CHANNEL_TIME:
return "AFH good channel adding time";
case CSR_PSKEY_NO_DROP_ON_ACR_MS_FAIL:
return "Complete link if acr barge-in role switch refused";
case CSR_PSKEY_MAX_PRIVATE_KEYS:
return "Max private link keys stored";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR0:
return "Bluetooth address + link key 0";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR1:
return "Bluetooth address + link key 1";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR2:
return "Bluetooth address + link key 2";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR3:
return "Bluetooth address + link key 3";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR4:
return "Bluetooth address + link key 4";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR5:
return "Bluetooth address + link key 5";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR6:
return "Bluetooth address + link key 6";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR7:
return "Bluetooth address + link key 7";
case CSR_PSKEY_LOCAL_SUPPORTED_COMMANDS:
return "Local supported commands";
case CSR_PSKEY_LM_MAX_ABSENCE_INDEX:
return "Maximum absence index allowed";
case CSR_PSKEY_DEVICE_NAME:
return "Local device's \"user friendly\" name";
case CSR_PSKEY_AFH_RSSI_THRESHOLD:
return "AFH RSSI threshold";
case CSR_PSKEY_LM_CASUAL_SCAN_INTERVAL:
return "Scan interval in slots for casual scanning";
case CSR_PSKEY_AFH_MIN_MAP_CHANGE:
return "The minimum amount to change an AFH map by";
case CSR_PSKEY_AFH_RSSI_LP_RUN_PERIOD:
return "AFH RSSI reading period when in low power mode";
case CSR_PSKEY_HCI_LMP_LOCAL_VERSION:
return "The HCI and LMP version reported locally";
case CSR_PSKEY_LMP_REMOTE_VERSION:
return "The LMP version reported remotely";
case CSR_PSKEY_HOLD_ERROR_MESSAGE_NUMBER:
return "Maximum number of queued HCI Hardware Error Events";
case CSR_PSKEY_DFU_ATTRIBUTES:
return "DFU attributes";
case CSR_PSKEY_DFU_DETACH_TO:
return "DFU detach timeout";
case CSR_PSKEY_DFU_TRANSFER_SIZE:
return "DFU transfer size";
case CSR_PSKEY_DFU_ENABLE:
return "DFU enable";
case CSR_PSKEY_DFU_LIN_REG_ENABLE:
return "Linear Regulator enabled at boot in DFU mode";
case CSR_PSKEY_DFUENC_VMAPP_PK_MODULUS_MSB:
return "DFU encryption VM application public key MSB";
case CSR_PSKEY_DFUENC_VMAPP_PK_MODULUS_LSB:
return "DFU encryption VM application public key LSB";
case CSR_PSKEY_DFUENC_VMAPP_PK_M_DASH:
return "DFU encryption VM application M dash";
case CSR_PSKEY_DFUENC_VMAPP_PK_R2N_MSB:
return "DFU encryption VM application public key R2N MSB";
case CSR_PSKEY_DFUENC_VMAPP_PK_R2N_LSB:
return "DFU encryption VM application public key R2N LSB";
case CSR_PSKEY_BCSP_LM_PS_BLOCK:
return "BCSP link establishment block";
case CSR_PSKEY_HOSTIO_FC_PS_BLOCK:
return "HCI flow control block";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO0:
return "Host transport channel 0 settings (BCSP ACK)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO1:
return "Host transport channel 1 settings (BCSP-LE)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO2:
return "Host transport channel 2 settings (BCCMD)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO3:
return "Host transport channel 3 settings (HQ)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO4:
return "Host transport channel 4 settings (DM)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO5:
return "Host transport channel 5 settings (HCI CMD/EVT)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO6:
return "Host transport channel 6 settings (HCI ACL)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO7:
return "Host transport channel 7 settings (HCI SCO)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO8:
return "Host transport channel 8 settings (L2CAP)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO9:
return "Host transport channel 9 settings (RFCOMM)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO10:
return "Host transport channel 10 settings (SDP)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO11:
return "Host transport channel 11 settings (TEST)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO12:
return "Host transport channel 12 settings (DFU)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO13:
return "Host transport channel 13 settings (VM)";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO14:
return "Host transport channel 14 settings";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO15:
return "Host transport channel 15 settings";
case CSR_PSKEY_HOSTIO_UART_RESET_TIMEOUT:
return "UART reset counter timeout";
case CSR_PSKEY_HOSTIO_USE_HCI_EXTN:
return "Use hci_extn to route non-hci channels";
case CSR_PSKEY_HOSTIO_USE_HCI_EXTN_CCFC:
return "Use command-complete flow control for hci_extn";
case CSR_PSKEY_HOSTIO_HCI_EXTN_PAYLOAD_SIZE:
return "Maximum hci_extn payload size";
case CSR_PSKEY_BCSP_LM_CNF_CNT_LIMIT:
return "BCSP link establishment conf message count";
case CSR_PSKEY_HOSTIO_MAP_SCO_PCM:
return "Map SCO over PCM";
case CSR_PSKEY_HOSTIO_AWKWARD_PCM_SYNC:
return "PCM interface synchronisation is difficult";
case CSR_PSKEY_HOSTIO_BREAK_POLL_PERIOD:
return "Break poll period (microseconds)";
case CSR_PSKEY_HOSTIO_MIN_UART_HCI_SCO_SIZE:
return "Minimum SCO packet size sent to host over UART HCI";
case CSR_PSKEY_HOSTIO_MAP_SCO_CODEC:
return "Map SCO over the built-in codec";
case CSR_PSKEY_PCM_CVSD_TX_HI_FREQ_BOOST:
return "High frequency boost for PCM when transmitting CVSD";
case CSR_PSKEY_PCM_CVSD_RX_HI_FREQ_BOOST:
return "High frequency boost for PCM when receiving CVSD";
case CSR_PSKEY_PCM_CONFIG32:
return "PCM interface settings bitfields";
case CSR_PSKEY_USE_OLD_BCSP_LE:
return "Use the old version of BCSP link establishment";
case CSR_PSKEY_PCM_CVSD_USE_NEW_FILTER:
return "CVSD uses the new filter if available";
case CSR_PSKEY_PCM_FORMAT:
return "PCM data format";
case CSR_PSKEY_CODEC_OUT_GAIN:
return "Audio output gain when using built-in codec";
case CSR_PSKEY_CODEC_IN_GAIN:
return "Audio input gain when using built-in codec";
case CSR_PSKEY_CODEC_PIO:
return "PIO to enable when built-in codec is enabled";
case CSR_PSKEY_PCM_LOW_JITTER_CONFIG:
return "PCM interface settings for low jitter master mode";
case CSR_PSKEY_HOSTIO_SCO_PCM_THRESHOLDS:
return "Thresholds for SCO PCM buffers";
case CSR_PSKEY_HOSTIO_SCO_HCI_THRESHOLDS:
return "Thresholds for SCO HCI buffers";
case CSR_PSKEY_HOSTIO_MAP_SCO_PCM_SLOT:
return "Route SCO data to specified slot in pcm frame";
case CSR_PSKEY_UART_BAUDRATE:
return "UART Baud rate";
case CSR_PSKEY_UART_CONFIG_BCSP:
return "UART configuration when using BCSP";
case CSR_PSKEY_UART_CONFIG_H4:
return "UART configuration when using H4";
case CSR_PSKEY_UART_CONFIG_H5:
return "UART configuration when using H5";
case CSR_PSKEY_UART_CONFIG_USR:
return "UART configuration when under VM control";
case CSR_PSKEY_UART_TX_CRCS:
return "Use CRCs for BCSP or H5";
case CSR_PSKEY_UART_ACK_TIMEOUT:
return "Acknowledgement timeout for BCSP and H5";
case CSR_PSKEY_UART_TX_MAX_ATTEMPTS:
return "Max times to send reliable BCSP or H5 message";
case CSR_PSKEY_UART_TX_WINDOW_SIZE:
return "Transmit window size for BCSP and H5";
case CSR_PSKEY_UART_HOST_WAKE:
return "UART host wakeup";
case CSR_PSKEY_HOSTIO_THROTTLE_TIMEOUT:
return "Host interface performance control.";
case CSR_PSKEY_PCM_ALWAYS_ENABLE:
return "PCM port is always enable when chip is running";
case CSR_PSKEY_UART_HOST_WAKE_SIGNAL:
return "Signal to use for uart host wakeup protocol";
case CSR_PSKEY_UART_CONFIG_H4DS:
return "UART configuration when using H4DS";
case CSR_PSKEY_H4DS_WAKE_DURATION:
return "How long to spend waking the host when using H4DS";
case CSR_PSKEY_H4DS_MAXWU:
return "Maximum number of H4DS Wake-Up messages to send";
case CSR_PSKEY_H4DS_LE_TIMER_PERIOD:
return "H4DS Link Establishment Tsync and Tconf period";
case CSR_PSKEY_H4DS_TWU_TIMER_PERIOD:
return "H4DS Twu timer period";
case CSR_PSKEY_H4DS_UART_IDLE_TIMER_PERIOD:
return "H4DS Tuart_idle timer period";
case CSR_PSKEY_ANA_FTRIM:
return "Crystal frequency trim";
case CSR_PSKEY_WD_TIMEOUT:
return "Watchdog timeout (microseconds)";
case CSR_PSKEY_WD_PERIOD:
return "Watchdog period (microseconds)";
case CSR_PSKEY_HOST_INTERFACE:
return "Host interface";
case CSR_PSKEY_HQ_HOST_TIMEOUT:
return "HQ host command timeout";
case CSR_PSKEY_HQ_ACTIVE:
return "Enable host query task?";
case CSR_PSKEY_BCCMD_SECURITY_ACTIVE:
return "Enable configuration security";
case CSR_PSKEY_ANA_FREQ:
return "Crystal frequency";
case CSR_PSKEY_PIO_PROTECT_MASK:
return "Access to PIO pins";
case CSR_PSKEY_PMALLOC_SIZES:
return "pmalloc sizes array";
case CSR_PSKEY_UART_BAUD_RATE:
return "UART Baud rate (pre 18)";
case CSR_PSKEY_UART_CONFIG:
return "UART configuration bitfield";
case CSR_PSKEY_STUB:
return "Stub";
case CSR_PSKEY_TXRX_PIO_CONTROL:
return "TX and RX PIO control";
case CSR_PSKEY_ANA_RX_LEVEL:
return "ANA_RX_LVL register initial value";
case CSR_PSKEY_ANA_RX_FTRIM:
return "ANA_RX_FTRIM register initial value";
case CSR_PSKEY_PSBC_DATA_VERSION:
return "Persistent store version";
case CSR_PSKEY_PCM0_ATTENUATION:
return "Volume control on PCM channel 0";
case CSR_PSKEY_LO_LVL_MAX:
return "Maximum value of LO level control register";
case CSR_PSKEY_LO_ADC_AMPL_MIN:
return "Minimum value of the LO amplitude measured on the ADC";
case CSR_PSKEY_LO_ADC_AMPL_MAX:
return "Maximum value of the LO amplitude measured on the ADC";
case CSR_PSKEY_IQ_TRIM_CHANNEL:
return "IQ calibration channel";
case CSR_PSKEY_IQ_TRIM_GAIN:
return "IQ calibration gain";
case CSR_PSKEY_IQ_TRIM_ENABLE:
return "IQ calibration enable";
case CSR_PSKEY_TX_OFFSET_HALF_MHZ:
return "Transmit offset";
case CSR_PSKEY_GBL_MISC_ENABLES:
return "Global miscellaneous hardware enables";
case CSR_PSKEY_UART_SLEEP_TIMEOUT:
return "Time in ms to deep sleep if nothing received";
case CSR_PSKEY_DEEP_SLEEP_STATE:
return "Deep sleep state usage";
case CSR_PSKEY_IQ_ENABLE_PHASE_TRIM:
return "IQ phase enable";
case CSR_PSKEY_HCI_HANDLE_FREEZE_PERIOD:
return "Time for which HCI handle is frozen after link removal";
case CSR_PSKEY_MAX_FROZEN_HCI_HANDLES:
return "Maximum number of frozen HCI handles";
case CSR_PSKEY_PAGETABLE_DESTRUCTION_DELAY:
return "Delay from freezing buf handle to deleting page table";
case CSR_PSKEY_IQ_TRIM_PIO_SETTINGS:
return "IQ PIO settings";
case CSR_PSKEY_USE_EXTERNAL_CLOCK:
return "Device uses an external clock";
case CSR_PSKEY_DEEP_SLEEP_WAKE_CTS:
return "Exit deep sleep on CTS line activity";
case CSR_PSKEY_FC_HC2H_FLUSH_DELAY:
return "Delay from disconnect to flushing HC->H FC tokens";
case CSR_PSKEY_RX_HIGHSIDE:
return "Disable the HIGHSIDE bit in ANA_CONFIG";
case CSR_PSKEY_TX_PRE_LVL:
return "TX pre-amplifier level";
case CSR_PSKEY_RX_SINGLE_ENDED:
return "RX single ended";
case CSR_PSKEY_TX_FILTER_CONFIG:
return "TX filter configuration";
case CSR_PSKEY_CLOCK_REQUEST_ENABLE:
return "External clock request enable";
case CSR_PSKEY_RX_MIN_ATTEN:
return "Minimum attenuation allowed for receiver";
case CSR_PSKEY_XTAL_TARGET_AMPLITUDE:
return "Crystal target amplitude";
case CSR_PSKEY_PCM_MIN_CPU_CLOCK:
return "Minimum CPU clock speed with PCM port running";
case CSR_PSKEY_HOST_INTERFACE_PIO_USB:
return "USB host interface selection PIO line";
case CSR_PSKEY_CPU_IDLE_MODE:
return "CPU idle mode when radio is active";
case CSR_PSKEY_DEEP_SLEEP_CLEAR_RTS:
return "Deep sleep clears the UART RTS line";
case CSR_PSKEY_RF_RESONANCE_TRIM:
return "Frequency trim for IQ and LNA resonant circuits";
case CSR_PSKEY_DEEP_SLEEP_PIO_WAKE:
return "PIO line to wake the chip from deep sleep";
case CSR_PSKEY_DRAIN_BORE_TIMERS:
return "Energy consumption measurement settings";
case CSR_PSKEY_DRAIN_TX_POWER_BASE:
return "Energy consumption measurement settings";
case CSR_PSKEY_MODULE_ID:
return "Module serial number";
case CSR_PSKEY_MODULE_DESIGN:
return "Module design ID";
case CSR_PSKEY_MODULE_SECURITY_CODE:
return "Module security code";
case CSR_PSKEY_VM_DISABLE:
return "VM disable";
case CSR_PSKEY_MOD_MANUF0:
return "Module manufactuer data 0";
case CSR_PSKEY_MOD_MANUF1:
return "Module manufactuer data 1";
case CSR_PSKEY_MOD_MANUF2:
return "Module manufactuer data 2";
case CSR_PSKEY_MOD_MANUF3:
return "Module manufactuer data 3";
case CSR_PSKEY_MOD_MANUF4:
return "Module manufactuer data 4";
case CSR_PSKEY_MOD_MANUF5:
return "Module manufactuer data 5";
case CSR_PSKEY_MOD_MANUF6:
return "Module manufactuer data 6";
case CSR_PSKEY_MOD_MANUF7:
return "Module manufactuer data 7";
case CSR_PSKEY_MOD_MANUF8:
return "Module manufactuer data 8";
case CSR_PSKEY_MOD_MANUF9:
return "Module manufactuer data 9";
case CSR_PSKEY_DUT_VM_DISABLE:
return "VM disable when entering radiotest modes";
case CSR_PSKEY_USR0:
return "User configuration data 0";
case CSR_PSKEY_USR1:
return "User configuration data 1";
case CSR_PSKEY_USR2:
return "User configuration data 2";
case CSR_PSKEY_USR3:
return "User configuration data 3";
case CSR_PSKEY_USR4:
return "User configuration data 4";
case CSR_PSKEY_USR5:
return "User configuration data 5";
case CSR_PSKEY_USR6:
return "User configuration data 6";
case CSR_PSKEY_USR7:
return "User configuration data 7";
case CSR_PSKEY_USR8:
return "User configuration data 8";
case CSR_PSKEY_USR9:
return "User configuration data 9";
case CSR_PSKEY_USR10:
return "User configuration data 10";
case CSR_PSKEY_USR11:
return "User configuration data 11";
case CSR_PSKEY_USR12:
return "User configuration data 12";
case CSR_PSKEY_USR13:
return "User configuration data 13";
case CSR_PSKEY_USR14:
return "User configuration data 14";
case CSR_PSKEY_USR15:
return "User configuration data 15";
case CSR_PSKEY_USR16:
return "User configuration data 16";
case CSR_PSKEY_USR17:
return "User configuration data 17";
case CSR_PSKEY_USR18:
return "User configuration data 18";
case CSR_PSKEY_USR19:
return "User configuration data 19";
case CSR_PSKEY_USR20:
return "User configuration data 20";
case CSR_PSKEY_USR21:
return "User configuration data 21";
case CSR_PSKEY_USR22:
return "User configuration data 22";
case CSR_PSKEY_USR23:
return "User configuration data 23";
case CSR_PSKEY_USR24:
return "User configuration data 24";
case CSR_PSKEY_USR25:
return "User configuration data 25";
case CSR_PSKEY_USR26:
return "User configuration data 26";
case CSR_PSKEY_USR27:
return "User configuration data 27";
case CSR_PSKEY_USR28:
return "User configuration data 28";
case CSR_PSKEY_USR29:
return "User configuration data 29";
case CSR_PSKEY_USR30:
return "User configuration data 30";
case CSR_PSKEY_USR31:
return "User configuration data 31";
case CSR_PSKEY_USR32:
return "User configuration data 32";
case CSR_PSKEY_USR33:
return "User configuration data 33";
case CSR_PSKEY_USR34:
return "User configuration data 34";
case CSR_PSKEY_USR35:
return "User configuration data 35";
case CSR_PSKEY_USR36:
return "User configuration data 36";
case CSR_PSKEY_USR37:
return "User configuration data 37";
case CSR_PSKEY_USR38:
return "User configuration data 38";
case CSR_PSKEY_USR39:
return "User configuration data 39";
case CSR_PSKEY_USR40:
return "User configuration data 40";
case CSR_PSKEY_USR41:
return "User configuration data 41";
case CSR_PSKEY_USR42:
return "User configuration data 42";
case CSR_PSKEY_USR43:
return "User configuration data 43";
case CSR_PSKEY_USR44:
return "User configuration data 44";
case CSR_PSKEY_USR45:
return "User configuration data 45";
case CSR_PSKEY_USR46:
return "User configuration data 46";
case CSR_PSKEY_USR47:
return "User configuration data 47";
case CSR_PSKEY_USR48:
return "User configuration data 48";
case CSR_PSKEY_USR49:
return "User configuration data 49";
case CSR_PSKEY_USB_VERSION:
return "USB specification version number";
case CSR_PSKEY_USB_DEVICE_CLASS_CODES:
return "USB device class codes";
case CSR_PSKEY_USB_VENDOR_ID:
return "USB vendor identifier";
case CSR_PSKEY_USB_PRODUCT_ID:
return "USB product identifier";
case CSR_PSKEY_USB_MANUF_STRING:
return "USB manufacturer string";
case CSR_PSKEY_USB_PRODUCT_STRING:
return "USB product string";
case CSR_PSKEY_USB_SERIAL_NUMBER_STRING:
return "USB serial number string";
case CSR_PSKEY_USB_CONFIG_STRING:
return "USB configuration string";
case CSR_PSKEY_USB_ATTRIBUTES:
return "USB attributes bitmap";
case CSR_PSKEY_USB_MAX_POWER:
return "USB device maximum power consumption";
case CSR_PSKEY_USB_BT_IF_CLASS_CODES:
return "USB Bluetooth interface class codes";
case CSR_PSKEY_USB_LANGID:
return "USB language strings supported";
case CSR_PSKEY_USB_DFU_CLASS_CODES:
return "USB DFU class codes block";
case CSR_PSKEY_USB_DFU_PRODUCT_ID:
return "USB DFU product ID";
case CSR_PSKEY_USB_PIO_DETACH:
return "USB detach/attach PIO line";
case CSR_PSKEY_USB_PIO_WAKEUP:
return "USB wakeup PIO line";
case CSR_PSKEY_USB_PIO_PULLUP:
return "USB D+ pullup PIO line";
case CSR_PSKEY_USB_PIO_VBUS:
return "USB VBus detection PIO Line";
case CSR_PSKEY_USB_PIO_WAKE_TIMEOUT:
return "Timeout for assertion of USB PIO wake signal";
case CSR_PSKEY_USB_PIO_RESUME:
return "PIO signal used in place of bus resume";
case CSR_PSKEY_USB_BT_SCO_IF_CLASS_CODES:
return "USB Bluetooth SCO interface class codes";
case CSR_PSKEY_USB_SUSPEND_PIO_LEVEL:
return "USB PIO levels to set when suspended";
case CSR_PSKEY_USB_SUSPEND_PIO_DIR:
return "USB PIO I/O directions to set when suspended";
case CSR_PSKEY_USB_SUSPEND_PIO_MASK:
return "USB PIO lines to be set forcibly in suspend";
case CSR_PSKEY_USB_ENDPOINT_0_MAX_PACKET_SIZE:
return "The maxmimum packet size for USB endpoint 0";
case CSR_PSKEY_USB_CONFIG:
return "USB config params for new chips (>bc2)";
case CSR_PSKEY_RADIOTEST_ATTEN_INIT:
return "Radio test initial attenuator";
case CSR_PSKEY_RADIOTEST_FIRST_TRIM_TIME:
return "IQ first calibration period in test";
case CSR_PSKEY_RADIOTEST_SUBSEQUENT_TRIM_TIME:
return "IQ subsequent calibration period in test";
case CSR_PSKEY_RADIOTEST_LO_LVL_TRIM_ENABLE:
return "LO_LVL calibration enable";
case CSR_PSKEY_RADIOTEST_DISABLE_MODULATION:
return "Disable modulation during radiotest transmissions";
case CSR_PSKEY_RFCOMM_FCON_THRESHOLD:
return "RFCOMM aggregate flow control on threshold";
case CSR_PSKEY_RFCOMM_FCOFF_THRESHOLD:
return "RFCOMM aggregate flow control off threshold";
case CSR_PSKEY_IPV6_STATIC_ADDR:
return "Static IPv6 address";
case CSR_PSKEY_IPV4_STATIC_ADDR:
return "Static IPv4 address";
case CSR_PSKEY_IPV6_STATIC_PREFIX_LEN:
return "Static IPv6 prefix length";
case CSR_PSKEY_IPV6_STATIC_ROUTER_ADDR:
return "Static IPv6 router address";
case CSR_PSKEY_IPV4_STATIC_SUBNET_MASK:
return "Static IPv4 subnet mask";
case CSR_PSKEY_IPV4_STATIC_ROUTER_ADDR:
return "Static IPv4 router address";
case CSR_PSKEY_MDNS_NAME:
return "Multicast DNS name";
case CSR_PSKEY_FIXED_PIN:
return "Fixed PIN";
case CSR_PSKEY_MDNS_PORT:
return "Multicast DNS port";
case CSR_PSKEY_MDNS_TTL:
return "Multicast DNS TTL";
case CSR_PSKEY_MDNS_IPV4_ADDR:
return "Multicast DNS IPv4 address";
case CSR_PSKEY_ARP_CACHE_TIMEOUT:
return "ARP cache timeout";
case CSR_PSKEY_HFP_POWER_TABLE:
return "HFP power table";
case CSR_PSKEY_DRAIN_BORE_TIMER_COUNTERS:
return "Energy consumption estimation timer counters";
case CSR_PSKEY_DRAIN_BORE_COUNTERS:
return "Energy consumption estimation counters";
case CSR_PSKEY_LOOP_FILTER_TRIM:
return "Trim value to optimise loop filter";
case CSR_PSKEY_DRAIN_BORE_CURRENT_PEAK:
return "Energy consumption estimation current peak";
case CSR_PSKEY_VM_E2_CACHE_LIMIT:
return "Maximum RAM for caching EEPROM VM application";
case CSR_PSKEY_FORCE_16MHZ_REF_PIO:
return "PIO line to force 16 MHz reference to be assumed";
case CSR_PSKEY_CDMA_LO_REF_LIMITS:
return "Local oscillator frequency reference limits for CDMA";
case CSR_PSKEY_CDMA_LO_ERROR_LIMITS:
return "Local oscillator frequency error limits for CDMA";
case CSR_PSKEY_CLOCK_STARTUP_DELAY:
return "Clock startup delay in milliseconds";
case CSR_PSKEY_DEEP_SLEEP_CORRECTION_FACTOR:
return "Deep sleep clock correction factor";
case CSR_PSKEY_TEMPERATURE_CALIBRATION:
return "Temperature in deg C for a given internal setting";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_INTERNAL_PA:
return "Temperature for given internal PA adjustment";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_PRE_LVL:
return "Temperature for a given TX_PRE_LVL adjustment";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_BB:
return "Temperature for a given TX_BB adjustment";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_ANA_FTRIM:
return "Temperature for given crystal trim adjustment";
case CSR_PSKEY_TEST_DELTA_OFFSET:
return "Frequency offset applied to synthesiser in test mode";
case CSR_PSKEY_RX_DYNAMIC_LVL_OFFSET:
return "Receiver dynamic level offset depending on channel";
case CSR_PSKEY_TEST_FORCE_OFFSET:
return "Force use of exact value in PSKEY_TEST_DELTA_OFFSET";
case CSR_PSKEY_RF_TRAP_BAD_DIVISION_RATIOS:
return "Trap bad division ratios in radio frequency tables";
case CSR_PSKEY_RADIOTEST_CDMA_LO_REF_LIMITS:
return "LO frequency reference limits for CDMA in radiotest";
case CSR_PSKEY_INITIAL_BOOTMODE:
return "Initial device bootmode";
case CSR_PSKEY_ONCHIP_HCI_CLIENT:
return "HCI traffic routed internally";
case CSR_PSKEY_RX_ATTEN_BACKOFF:
return "Receiver attenuation back-off";
case CSR_PSKEY_RX_ATTEN_UPDATE_RATE:
return "Receiver attenuation update rate";
case CSR_PSKEY_SYNTH_TXRX_THRESHOLDS:
return "Local oscillator tuning voltage limits for tx and rx";
case CSR_PSKEY_MIN_WAIT_STATES:
return "Flash wait state indicator";
case CSR_PSKEY_RSSI_CORRECTION:
return "RSSI correction factor.";
case CSR_PSKEY_SCHED_THROTTLE_TIMEOUT:
return "Scheduler performance control.";
case CSR_PSKEY_DEEP_SLEEP_USE_EXTERNAL_CLOCK:
return "Deep sleep uses external 32 kHz clock source";
case CSR_PSKEY_TRIM_RADIO_FILTERS:
return "Trim rx and tx radio filters if true.";
case CSR_PSKEY_TRANSMIT_OFFSET:
return "Transmit offset in units of 62.5 kHz";
case CSR_PSKEY_USB_VM_CONTROL:
return "VM application will supply USB descriptors";
case CSR_PSKEY_MR_ANA_RX_FTRIM:
return "Medium rate value for the ANA_RX_FTRIM register";
case CSR_PSKEY_I2C_CONFIG:
return "I2C configuration";
case CSR_PSKEY_IQ_LVL_RX:
return "IQ demand level for reception";
case CSR_PSKEY_MR_TX_FILTER_CONFIG:
return "TX filter configuration used for enhanced data rate";
case CSR_PSKEY_MR_TX_CONFIG2:
return "TX filter configuration used for enhanced data rate";
case CSR_PSKEY_USB_DONT_RESET_BOOTMODE_ON_HOST_RESET:
return "Don't reset bootmode if USB host resets";
case CSR_PSKEY_LC_USE_THROTTLING:
return "Adjust packet selection on packet error rate";
case CSR_PSKEY_CHARGER_TRIM:
return "Trim value for the current charger";
case CSR_PSKEY_CLOCK_REQUEST_FEATURES:
return "Clock request is tristated if enabled";
case CSR_PSKEY_TRANSMIT_OFFSET_CLASS1:
return "Transmit offset / 62.5 kHz for class 1 radios";
case CSR_PSKEY_TX_AVOID_PA_CLASS1_PIO:
return "PIO line asserted in class1 operation to avoid PA";
case CSR_PSKEY_MR_PIO_CONFIG:
return "PIO line asserted in class1 operation to avoid PA";
case CSR_PSKEY_UART_CONFIG2:
return "The UART Sampling point";
case CSR_PSKEY_CLASS1_IQ_LVL:
return "IQ demand level for class 1 power level";
case CSR_PSKEY_CLASS1_TX_CONFIG2:
return "TX filter configuration used for class 1 tx power";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_INTERNAL_PA_CLASS1:
return "Temperature for given internal PA adjustment";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_EXTERNAL_PA_CLASS1:
return "Temperature for given internal PA adjustment";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_PRE_LVL_MR:
return "Temperature adjustment for TX_PRE_LVL in EDR";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_BB_MR_HEADER:
return "Temperature for a given TX_BB in EDR header";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_BB_MR_PAYLOAD:
return "Temperature for a given TX_BB in EDR payload";
case CSR_PSKEY_RX_MR_EQ_TAPS:
return "Adjust receiver configuration for EDR";
case CSR_PSKEY_TX_PRE_LVL_CLASS1:
return "TX pre-amplifier level in class 1 operation";
case CSR_PSKEY_ANALOGUE_ATTENUATOR:
return "TX analogue attenuator setting";
case CSR_PSKEY_MR_RX_FILTER_TRIM:
return "Trim for receiver used in EDR.";
case CSR_PSKEY_MR_RX_FILTER_RESPONSE:
return "Filter response for receiver used in EDR.";
case CSR_PSKEY_PIO_WAKEUP_STATE:
return "PIO deep sleep wake up state ";
case CSR_PSKEY_MR_TX_IF_ATTEN_OFF_TEMP:
return "TX IF atten off temperature when using EDR.";
case CSR_PSKEY_LO_DIV_LATCH_BYPASS:
return "Bypass latch for LO dividers";
case CSR_PSKEY_LO_VCO_STANDBY:
return "Use standby mode for the LO VCO";
case CSR_PSKEY_SLOW_CLOCK_FILTER_SHIFT:
return "Slow clock sampling filter constant";
case CSR_PSKEY_SLOW_CLOCK_FILTER_DIVIDER:
return "Slow clock filter fractional threshold";
case CSR_PSKEY_USB_ATTRIBUTES_POWER:
return "USB self powered";
case CSR_PSKEY_USB_ATTRIBUTES_WAKEUP:
return "USB responds to wake-up";
case CSR_PSKEY_DFU_ATTRIBUTES_MANIFESTATION_TOLERANT:
return "DFU manifestation tolerant";
case CSR_PSKEY_DFU_ATTRIBUTES_CAN_UPLOAD:
return "DFU can upload";
case CSR_PSKEY_DFU_ATTRIBUTES_CAN_DOWNLOAD:
return "DFU can download";
case CSR_PSKEY_UART_CONFIG_STOP_BITS:
return "UART: stop bits";
case CSR_PSKEY_UART_CONFIG_PARITY_BIT:
return "UART: parity bit";
case CSR_PSKEY_UART_CONFIG_FLOW_CTRL_EN:
return "UART: hardware flow control";
case CSR_PSKEY_UART_CONFIG_RTS_AUTO_EN:
return "UART: RTS auto-enabled";
case CSR_PSKEY_UART_CONFIG_RTS:
return "UART: RTS asserted";
case CSR_PSKEY_UART_CONFIG_TX_ZERO_EN:
return "UART: TX zero enable";
case CSR_PSKEY_UART_CONFIG_NON_BCSP_EN:
return "UART: enable BCSP-specific hardware";
case CSR_PSKEY_UART_CONFIG_RX_RATE_DELAY:
return "UART: RX rate delay";
case CSR_PSKEY_UART_SEQ_TIMEOUT:
return "UART: BCSP ack timeout";
case CSR_PSKEY_UART_SEQ_RETRIES:
return "UART: retry limit in sequencing layer";
case CSR_PSKEY_UART_SEQ_WINSIZE:
return "UART: BCSP transmit window size";
case CSR_PSKEY_UART_USE_CRC_ON_TX:
return "UART: use BCSP CRCs";
case CSR_PSKEY_UART_HOST_INITIAL_STATE:
return "UART: initial host state";
case CSR_PSKEY_UART_HOST_ATTENTION_SPAN:
return "UART: host attention span";
case CSR_PSKEY_UART_HOST_WAKEUP_TIME:
return "UART: host wakeup time";
case CSR_PSKEY_UART_HOST_WAKEUP_WAIT:
return "UART: host wakeup wait";
case CSR_PSKEY_BCSP_LM_MODE:
return "BCSP link establishment mode";
case CSR_PSKEY_BCSP_LM_SYNC_RETRIES:
return "BCSP link establishment sync retries";
case CSR_PSKEY_BCSP_LM_TSHY:
return "BCSP link establishment Tshy";
case CSR_PSKEY_UART_DFU_CONFIG_STOP_BITS:
return "DFU mode UART: stop bits";
case CSR_PSKEY_UART_DFU_CONFIG_PARITY_BIT:
return "DFU mode UART: parity bit";
case CSR_PSKEY_UART_DFU_CONFIG_FLOW_CTRL_EN:
return "DFU mode UART: hardware flow control";
case CSR_PSKEY_UART_DFU_CONFIG_RTS_AUTO_EN:
return "DFU mode UART: RTS auto-enabled";
case CSR_PSKEY_UART_DFU_CONFIG_RTS:
return "DFU mode UART: RTS asserted";
case CSR_PSKEY_UART_DFU_CONFIG_TX_ZERO_EN:
return "DFU mode UART: TX zero enable";
case CSR_PSKEY_UART_DFU_CONFIG_NON_BCSP_EN:
return "DFU mode UART: enable BCSP-specific hardware";
case CSR_PSKEY_UART_DFU_CONFIG_RX_RATE_DELAY:
return "DFU mode UART: RX rate delay";
case CSR_PSKEY_AMUX_AIO0:
return "Multiplexer for AIO 0";
case CSR_PSKEY_AMUX_AIO1:
return "Multiplexer for AIO 1";
case CSR_PSKEY_AMUX_AIO2:
return "Multiplexer for AIO 2";
case CSR_PSKEY_AMUX_AIO3:
return "Multiplexer for AIO 3";
case CSR_PSKEY_LOCAL_NAME_SIMPLIFIED:
return "Local Name (simplified)";
case CSR_PSKEY_EXTENDED_STUB:
return "Extended stub";
default:
return "Unknown";
}
}
char *csr_pskeytoval(uint16_t pskey)
{
switch (pskey) {
case CSR_PSKEY_BDADDR:
return "BDADDR";
case CSR_PSKEY_COUNTRYCODE:
return "COUNTRYCODE";
case CSR_PSKEY_CLASSOFDEVICE:
return "CLASSOFDEVICE";
case CSR_PSKEY_DEVICE_DRIFT:
return "DEVICE_DRIFT";
case CSR_PSKEY_DEVICE_JITTER:
return "DEVICE_JITTER";
case CSR_PSKEY_MAX_ACLS:
return "MAX_ACLS";
case CSR_PSKEY_MAX_SCOS:
return "MAX_SCOS";
case CSR_PSKEY_MAX_REMOTE_MASTERS:
return "MAX_REMOTE_MASTERS";
case CSR_PSKEY_ENABLE_MASTERY_WITH_SLAVERY:
return "ENABLE_MASTERY_WITH_SLAVERY";
case CSR_PSKEY_H_HC_FC_MAX_ACL_PKT_LEN:
return "H_HC_FC_MAX_ACL_PKT_LEN";
case CSR_PSKEY_H_HC_FC_MAX_SCO_PKT_LEN:
return "H_HC_FC_MAX_SCO_PKT_LEN";
case CSR_PSKEY_H_HC_FC_MAX_ACL_PKTS:
return "H_HC_FC_MAX_ACL_PKTS";
case CSR_PSKEY_H_HC_FC_MAX_SCO_PKTS:
return "H_HC_FC_MAX_SCO_PKTS";
case CSR_PSKEY_LC_FC_BUFFER_LOW_WATER_MARK:
return "LC_FC_BUFFER_LOW_WATER_MARK";
case CSR_PSKEY_LC_MAX_TX_POWER:
return "LC_MAX_TX_POWER";
case CSR_PSKEY_TX_GAIN_RAMP:
return "TX_GAIN_RAMP";
case CSR_PSKEY_LC_POWER_TABLE:
return "LC_POWER_TABLE";
case CSR_PSKEY_LC_PEER_POWER_PERIOD:
return "LC_PEER_POWER_PERIOD";
case CSR_PSKEY_LC_FC_POOLS_LOW_WATER_MARK:
return "LC_FC_POOLS_LOW_WATER_MARK";
case CSR_PSKEY_LC_DEFAULT_TX_POWER:
return "LC_DEFAULT_TX_POWER";
case CSR_PSKEY_LC_RSSI_GOLDEN_RANGE:
return "LC_RSSI_GOLDEN_RANGE";
case CSR_PSKEY_LC_COMBO_DISABLE_PIO_MASK:
return "LC_COMBO_DISABLE_PIO_MASK";
case CSR_PSKEY_LC_COMBO_PRIORITY_PIO_MASK:
return "LC_COMBO_PRIORITY_PIO_MASK";
case CSR_PSKEY_LC_COMBO_DOT11_CHANNEL_PIO_BASE:
return "LC_COMBO_DOT11_CHANNEL_PIO_BASE";
case CSR_PSKEY_LC_COMBO_DOT11_BLOCK_CHANNELS:
return "LC_COMBO_DOT11_BLOCK_CHANNELS";
case CSR_PSKEY_LC_MAX_TX_POWER_NO_RSSI:
return "LC_MAX_TX_POWER_NO_RSSI";
case CSR_PSKEY_LC_CONNECTION_RX_WINDOW:
return "LC_CONNECTION_RX_WINDOW";
case CSR_PSKEY_LC_COMBO_DOT11_TX_PROTECTION_MODE:
return "LC_COMBO_DOT11_TX_PROTECTION_MODE";
case CSR_PSKEY_LC_ENHANCED_POWER_TABLE:
return "LC_ENHANCED_POWER_TABLE";
case CSR_PSKEY_LC_WIDEBAND_RSSI_CONFIG:
return "LC_WIDEBAND_RSSI_CONFIG";
case CSR_PSKEY_LC_COMBO_DOT11_PRIORITY_LEAD:
return "LC_COMBO_DOT11_PRIORITY_LEAD";
case CSR_PSKEY_BT_CLOCK_INIT:
return "BT_CLOCK_INIT";
case CSR_PSKEY_TX_MR_MOD_DELAY:
return "TX_MR_MOD_DELAY";
case CSR_PSKEY_RX_MR_SYNC_TIMING:
return "RX_MR_SYNC_TIMING";
case CSR_PSKEY_RX_MR_SYNC_CONFIG:
return "RX_MR_SYNC_CONFIG";
case CSR_PSKEY_LC_LOST_SYNC_SLOTS:
return "LC_LOST_SYNC_SLOTS";
case CSR_PSKEY_RX_MR_SAMP_CONFIG:
return "RX_MR_SAMP_CONFIG";
case CSR_PSKEY_AGC_HYST_LEVELS:
return "AGC_HYST_LEVELS";
case CSR_PSKEY_RX_LEVEL_LOW_SIGNAL:
return "RX_LEVEL_LOW_SIGNAL";
case CSR_PSKEY_AGC_IQ_LVL_VALUES:
return "AGC_IQ_LVL_VALUES";
case CSR_PSKEY_MR_FTRIM_OFFSET_12DB:
return "MR_FTRIM_OFFSET_12DB";
case CSR_PSKEY_MR_FTRIM_OFFSET_6DB:
return "MR_FTRIM_OFFSET_6DB";
case CSR_PSKEY_NO_CAL_ON_BOOT:
return "NO_CAL_ON_BOOT";
case CSR_PSKEY_RSSI_HI_TARGET:
return "RSSI_HI_TARGET";
case CSR_PSKEY_PREFERRED_MIN_ATTENUATION:
return "PREFERRED_MIN_ATTENUATION";
case CSR_PSKEY_LC_COMBO_DOT11_PRIORITY_OVERRIDE:
return "LC_COMBO_DOT11_PRIORITY_OVERRIDE";
case CSR_PSKEY_LC_MULTISLOT_HOLDOFF:
return "LC_MULTISLOT_HOLDOFF";
case CSR_PSKEY_FREE_KEY_PIGEON_HOLE:
return "FREE_KEY_PIGEON_HOLE";
case CSR_PSKEY_LINK_KEY_BD_ADDR0:
return "LINK_KEY_BD_ADDR0";
case CSR_PSKEY_LINK_KEY_BD_ADDR1:
return "LINK_KEY_BD_ADDR1";
case CSR_PSKEY_LINK_KEY_BD_ADDR2:
return "LINK_KEY_BD_ADDR2";
case CSR_PSKEY_LINK_KEY_BD_ADDR3:
return "LINK_KEY_BD_ADDR3";
case CSR_PSKEY_LINK_KEY_BD_ADDR4:
return "LINK_KEY_BD_ADDR4";
case CSR_PSKEY_LINK_KEY_BD_ADDR5:
return "LINK_KEY_BD_ADDR5";
case CSR_PSKEY_LINK_KEY_BD_ADDR6:
return "LINK_KEY_BD_ADDR6";
case CSR_PSKEY_LINK_KEY_BD_ADDR7:
return "LINK_KEY_BD_ADDR7";
case CSR_PSKEY_LINK_KEY_BD_ADDR8:
return "LINK_KEY_BD_ADDR8";
case CSR_PSKEY_LINK_KEY_BD_ADDR9:
return "LINK_KEY_BD_ADDR9";
case CSR_PSKEY_LINK_KEY_BD_ADDR10:
return "LINK_KEY_BD_ADDR10";
case CSR_PSKEY_LINK_KEY_BD_ADDR11:
return "LINK_KEY_BD_ADDR11";
case CSR_PSKEY_LINK_KEY_BD_ADDR12:
return "LINK_KEY_BD_ADDR12";
case CSR_PSKEY_LINK_KEY_BD_ADDR13:
return "LINK_KEY_BD_ADDR13";
case CSR_PSKEY_LINK_KEY_BD_ADDR14:
return "LINK_KEY_BD_ADDR14";
case CSR_PSKEY_LINK_KEY_BD_ADDR15:
return "LINK_KEY_BD_ADDR15";
case CSR_PSKEY_ENC_KEY_LMIN:
return "ENC_KEY_LMIN";
case CSR_PSKEY_ENC_KEY_LMAX:
return "ENC_KEY_LMAX";
case CSR_PSKEY_LOCAL_SUPPORTED_FEATURES:
return "LOCAL_SUPPORTED_FEATURES";
case CSR_PSKEY_LM_USE_UNIT_KEY:
return "LM_USE_UNIT_KEY";
case CSR_PSKEY_HCI_NOP_DISABLE:
return "HCI_NOP_DISABLE";
case CSR_PSKEY_LM_MAX_EVENT_FILTERS:
return "LM_MAX_EVENT_FILTERS";
case CSR_PSKEY_LM_USE_ENC_MODE_BROADCAST:
return "LM_USE_ENC_MODE_BROADCAST";
case CSR_PSKEY_LM_TEST_SEND_ACCEPTED_TWICE:
return "LM_TEST_SEND_ACCEPTED_TWICE";
case CSR_PSKEY_LM_MAX_PAGE_HOLD_TIME:
return "LM_MAX_PAGE_HOLD_TIME";
case CSR_PSKEY_AFH_ADAPTATION_RESPONSE_TIME:
return "AFH_ADAPTATION_RESPONSE_TIME";
case CSR_PSKEY_AFH_OPTIONS:
return "AFH_OPTIONS";
case CSR_PSKEY_AFH_RSSI_RUN_PERIOD:
return "AFH_RSSI_RUN_PERIOD";
case CSR_PSKEY_AFH_REENABLE_CHANNEL_TIME:
return "AFH_REENABLE_CHANNEL_TIME";
case CSR_PSKEY_NO_DROP_ON_ACR_MS_FAIL:
return "NO_DROP_ON_ACR_MS_FAIL";
case CSR_PSKEY_MAX_PRIVATE_KEYS:
return "MAX_PRIVATE_KEYS";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR0:
return "PRIVATE_LINK_KEY_BD_ADDR0";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR1:
return "PRIVATE_LINK_KEY_BD_ADDR1";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR2:
return "PRIVATE_LINK_KEY_BD_ADDR2";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR3:
return "PRIVATE_LINK_KEY_BD_ADDR3";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR4:
return "PRIVATE_LINK_KEY_BD_ADDR4";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR5:
return "PRIVATE_LINK_KEY_BD_ADDR5";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR6:
return "PRIVATE_LINK_KEY_BD_ADDR6";
case CSR_PSKEY_PRIVATE_LINK_KEY_BD_ADDR7:
return "PRIVATE_LINK_KEY_BD_ADDR7";
case CSR_PSKEY_LOCAL_SUPPORTED_COMMANDS:
return "LOCAL_SUPPORTED_COMMANDS";
case CSR_PSKEY_LM_MAX_ABSENCE_INDEX:
return "LM_MAX_ABSENCE_INDEX";
case CSR_PSKEY_DEVICE_NAME:
return "DEVICE_NAME";
case CSR_PSKEY_AFH_RSSI_THRESHOLD:
return "AFH_RSSI_THRESHOLD";
case CSR_PSKEY_LM_CASUAL_SCAN_INTERVAL:
return "LM_CASUAL_SCAN_INTERVAL";
case CSR_PSKEY_AFH_MIN_MAP_CHANGE:
return "AFH_MIN_MAP_CHANGE";
case CSR_PSKEY_AFH_RSSI_LP_RUN_PERIOD:
return "AFH_RSSI_LP_RUN_PERIOD";
case CSR_PSKEY_HCI_LMP_LOCAL_VERSION:
return "HCI_LMP_LOCAL_VERSION";
case CSR_PSKEY_LMP_REMOTE_VERSION:
return "LMP_REMOTE_VERSION";
case CSR_PSKEY_HOLD_ERROR_MESSAGE_NUMBER:
return "HOLD_ERROR_MESSAGE_NUMBER";
case CSR_PSKEY_DFU_ATTRIBUTES:
return "DFU_ATTRIBUTES";
case CSR_PSKEY_DFU_DETACH_TO:
return "DFU_DETACH_TO";
case CSR_PSKEY_DFU_TRANSFER_SIZE:
return "DFU_TRANSFER_SIZE";
case CSR_PSKEY_DFU_ENABLE:
return "DFU_ENABLE";
case CSR_PSKEY_DFU_LIN_REG_ENABLE:
return "DFU_LIN_REG_ENABLE";
case CSR_PSKEY_DFUENC_VMAPP_PK_MODULUS_MSB:
return "DFUENC_VMAPP_PK_MODULUS_MSB";
case CSR_PSKEY_DFUENC_VMAPP_PK_MODULUS_LSB:
return "DFUENC_VMAPP_PK_MODULUS_LSB";
case CSR_PSKEY_DFUENC_VMAPP_PK_M_DASH:
return "DFUENC_VMAPP_PK_M_DASH";
case CSR_PSKEY_DFUENC_VMAPP_PK_R2N_MSB:
return "DFUENC_VMAPP_PK_R2N_MSB";
case CSR_PSKEY_DFUENC_VMAPP_PK_R2N_LSB:
return "DFUENC_VMAPP_PK_R2N_LSB";
case CSR_PSKEY_BCSP_LM_PS_BLOCK:
return "BCSP_LM_PS_BLOCK";
case CSR_PSKEY_HOSTIO_FC_PS_BLOCK:
return "HOSTIO_FC_PS_BLOCK";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO0:
return "HOSTIO_PROTOCOL_INFO0";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO1:
return "HOSTIO_PROTOCOL_INFO1";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO2:
return "HOSTIO_PROTOCOL_INFO2";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO3:
return "HOSTIO_PROTOCOL_INFO3";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO4:
return "HOSTIO_PROTOCOL_INFO4";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO5:
return "HOSTIO_PROTOCOL_INFO5";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO6:
return "HOSTIO_PROTOCOL_INFO6";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO7:
return "HOSTIO_PROTOCOL_INFO7";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO8:
return "HOSTIO_PROTOCOL_INFO8";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO9:
return "HOSTIO_PROTOCOL_INFO9";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO10:
return "HOSTIO_PROTOCOL_INFO10";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO11:
return "HOSTIO_PROTOCOL_INFO11";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO12:
return "HOSTIO_PROTOCOL_INFO12";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO13:
return "HOSTIO_PROTOCOL_INFO13";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO14:
return "HOSTIO_PROTOCOL_INFO14";
case CSR_PSKEY_HOSTIO_PROTOCOL_INFO15:
return "HOSTIO_PROTOCOL_INFO15";
case CSR_PSKEY_HOSTIO_UART_RESET_TIMEOUT:
return "HOSTIO_UART_RESET_TIMEOUT";
case CSR_PSKEY_HOSTIO_USE_HCI_EXTN:
return "HOSTIO_USE_HCI_EXTN";
case CSR_PSKEY_HOSTIO_USE_HCI_EXTN_CCFC:
return "HOSTIO_USE_HCI_EXTN_CCFC";
case CSR_PSKEY_HOSTIO_HCI_EXTN_PAYLOAD_SIZE:
return "HOSTIO_HCI_EXTN_PAYLOAD_SIZE";
case CSR_PSKEY_BCSP_LM_CNF_CNT_LIMIT:
return "BCSP_LM_CNF_CNT_LIMIT";
case CSR_PSKEY_HOSTIO_MAP_SCO_PCM:
return "HOSTIO_MAP_SCO_PCM";
case CSR_PSKEY_HOSTIO_AWKWARD_PCM_SYNC:
return "HOSTIO_AWKWARD_PCM_SYNC";
case CSR_PSKEY_HOSTIO_BREAK_POLL_PERIOD:
return "HOSTIO_BREAK_POLL_PERIOD";
case CSR_PSKEY_HOSTIO_MIN_UART_HCI_SCO_SIZE:
return "HOSTIO_MIN_UART_HCI_SCO_SIZE";
case CSR_PSKEY_HOSTIO_MAP_SCO_CODEC:
return "HOSTIO_MAP_SCO_CODEC";
case CSR_PSKEY_PCM_CVSD_TX_HI_FREQ_BOOST:
return "PCM_CVSD_TX_HI_FREQ_BOOST";
case CSR_PSKEY_PCM_CVSD_RX_HI_FREQ_BOOST:
return "PCM_CVSD_RX_HI_FREQ_BOOST";
case CSR_PSKEY_PCM_CONFIG32:
return "PCM_CONFIG32";
case CSR_PSKEY_USE_OLD_BCSP_LE:
return "USE_OLD_BCSP_LE";
case CSR_PSKEY_PCM_CVSD_USE_NEW_FILTER:
return "PCM_CVSD_USE_NEW_FILTER";
case CSR_PSKEY_PCM_FORMAT:
return "PCM_FORMAT";
case CSR_PSKEY_CODEC_OUT_GAIN:
return "CODEC_OUT_GAIN";
case CSR_PSKEY_CODEC_IN_GAIN:
return "CODEC_IN_GAIN";
case CSR_PSKEY_CODEC_PIO:
return "CODEC_PIO";
case CSR_PSKEY_PCM_LOW_JITTER_CONFIG:
return "PCM_LOW_JITTER_CONFIG";
case CSR_PSKEY_HOSTIO_SCO_PCM_THRESHOLDS:
return "HOSTIO_SCO_PCM_THRESHOLDS";
case CSR_PSKEY_HOSTIO_SCO_HCI_THRESHOLDS:
return "HOSTIO_SCO_HCI_THRESHOLDS";
case CSR_PSKEY_HOSTIO_MAP_SCO_PCM_SLOT:
return "HOSTIO_MAP_SCO_PCM_SLOT";
case CSR_PSKEY_UART_BAUDRATE:
return "UART_BAUDRATE";
case CSR_PSKEY_UART_CONFIG_BCSP:
return "UART_CONFIG_BCSP";
case CSR_PSKEY_UART_CONFIG_H4:
return "UART_CONFIG_H4";
case CSR_PSKEY_UART_CONFIG_H5:
return "UART_CONFIG_H5";
case CSR_PSKEY_UART_CONFIG_USR:
return "UART_CONFIG_USR";
case CSR_PSKEY_UART_TX_CRCS:
return "UART_TX_CRCS";
case CSR_PSKEY_UART_ACK_TIMEOUT:
return "UART_ACK_TIMEOUT";
case CSR_PSKEY_UART_TX_MAX_ATTEMPTS:
return "UART_TX_MAX_ATTEMPTS";
case CSR_PSKEY_UART_TX_WINDOW_SIZE:
return "UART_TX_WINDOW_SIZE";
case CSR_PSKEY_UART_HOST_WAKE:
return "UART_HOST_WAKE";
case CSR_PSKEY_HOSTIO_THROTTLE_TIMEOUT:
return "HOSTIO_THROTTLE_TIMEOUT";
case CSR_PSKEY_PCM_ALWAYS_ENABLE:
return "PCM_ALWAYS_ENABLE";
case CSR_PSKEY_UART_HOST_WAKE_SIGNAL:
return "UART_HOST_WAKE_SIGNAL";
case CSR_PSKEY_UART_CONFIG_H4DS:
return "UART_CONFIG_H4DS";
case CSR_PSKEY_H4DS_WAKE_DURATION:
return "H4DS_WAKE_DURATION";
case CSR_PSKEY_H4DS_MAXWU:
return "H4DS_MAXWU";
case CSR_PSKEY_H4DS_LE_TIMER_PERIOD:
return "H4DS_LE_TIMER_PERIOD";
case CSR_PSKEY_H4DS_TWU_TIMER_PERIOD:
return "H4DS_TWU_TIMER_PERIOD";
case CSR_PSKEY_H4DS_UART_IDLE_TIMER_PERIOD:
return "H4DS_UART_IDLE_TIMER_PERIOD";
case CSR_PSKEY_ANA_FTRIM:
return "ANA_FTRIM";
case CSR_PSKEY_WD_TIMEOUT:
return "WD_TIMEOUT";
case CSR_PSKEY_WD_PERIOD:
return "WD_PERIOD";
case CSR_PSKEY_HOST_INTERFACE:
return "HOST_INTERFACE";
case CSR_PSKEY_HQ_HOST_TIMEOUT:
return "HQ_HOST_TIMEOUT";
case CSR_PSKEY_HQ_ACTIVE:
return "HQ_ACTIVE";
case CSR_PSKEY_BCCMD_SECURITY_ACTIVE:
return "BCCMD_SECURITY_ACTIVE";
case CSR_PSKEY_ANA_FREQ:
return "ANA_FREQ";
case CSR_PSKEY_PIO_PROTECT_MASK:
return "PIO_PROTECT_MASK";
case CSR_PSKEY_PMALLOC_SIZES:
return "PMALLOC_SIZES";
case CSR_PSKEY_UART_BAUD_RATE:
return "UART_BAUD_RATE";
case CSR_PSKEY_UART_CONFIG:
return "UART_CONFIG";
case CSR_PSKEY_STUB:
return "STUB";
case CSR_PSKEY_TXRX_PIO_CONTROL:
return "TXRX_PIO_CONTROL";
case CSR_PSKEY_ANA_RX_LEVEL:
return "ANA_RX_LEVEL";
case CSR_PSKEY_ANA_RX_FTRIM:
return "ANA_RX_FTRIM";
case CSR_PSKEY_PSBC_DATA_VERSION:
return "PSBC_DATA_VERSION";
case CSR_PSKEY_PCM0_ATTENUATION:
return "PCM0_ATTENUATION";
case CSR_PSKEY_LO_LVL_MAX:
return "LO_LVL_MAX";
case CSR_PSKEY_LO_ADC_AMPL_MIN:
return "LO_ADC_AMPL_MIN";
case CSR_PSKEY_LO_ADC_AMPL_MAX:
return "LO_ADC_AMPL_MAX";
case CSR_PSKEY_IQ_TRIM_CHANNEL:
return "IQ_TRIM_CHANNEL";
case CSR_PSKEY_IQ_TRIM_GAIN:
return "IQ_TRIM_GAIN";
case CSR_PSKEY_IQ_TRIM_ENABLE:
return "IQ_TRIM_ENABLE";
case CSR_PSKEY_TX_OFFSET_HALF_MHZ:
return "TX_OFFSET_HALF_MHZ";
case CSR_PSKEY_GBL_MISC_ENABLES:
return "GBL_MISC_ENABLES";
case CSR_PSKEY_UART_SLEEP_TIMEOUT:
return "UART_SLEEP_TIMEOUT";
case CSR_PSKEY_DEEP_SLEEP_STATE:
return "DEEP_SLEEP_STATE";
case CSR_PSKEY_IQ_ENABLE_PHASE_TRIM:
return "IQ_ENABLE_PHASE_TRIM";
case CSR_PSKEY_HCI_HANDLE_FREEZE_PERIOD:
return "HCI_HANDLE_FREEZE_PERIOD";
case CSR_PSKEY_MAX_FROZEN_HCI_HANDLES:
return "MAX_FROZEN_HCI_HANDLES";
case CSR_PSKEY_PAGETABLE_DESTRUCTION_DELAY:
return "PAGETABLE_DESTRUCTION_DELAY";
case CSR_PSKEY_IQ_TRIM_PIO_SETTINGS:
return "IQ_TRIM_PIO_SETTINGS";
case CSR_PSKEY_USE_EXTERNAL_CLOCK:
return "USE_EXTERNAL_CLOCK";
case CSR_PSKEY_DEEP_SLEEP_WAKE_CTS:
return "DEEP_SLEEP_WAKE_CTS";
case CSR_PSKEY_FC_HC2H_FLUSH_DELAY:
return "FC_HC2H_FLUSH_DELAY";
case CSR_PSKEY_RX_HIGHSIDE:
return "RX_HIGHSIDE";
case CSR_PSKEY_TX_PRE_LVL:
return "TX_PRE_LVL";
case CSR_PSKEY_RX_SINGLE_ENDED:
return "RX_SINGLE_ENDED";
case CSR_PSKEY_TX_FILTER_CONFIG:
return "TX_FILTER_CONFIG";
case CSR_PSKEY_CLOCK_REQUEST_ENABLE:
return "CLOCK_REQUEST_ENABLE";
case CSR_PSKEY_RX_MIN_ATTEN:
return "RX_MIN_ATTEN";
case CSR_PSKEY_XTAL_TARGET_AMPLITUDE:
return "XTAL_TARGET_AMPLITUDE";
case CSR_PSKEY_PCM_MIN_CPU_CLOCK:
return "PCM_MIN_CPU_CLOCK";
case CSR_PSKEY_HOST_INTERFACE_PIO_USB:
return "HOST_INTERFACE_PIO_USB";
case CSR_PSKEY_CPU_IDLE_MODE:
return "CPU_IDLE_MODE";
case CSR_PSKEY_DEEP_SLEEP_CLEAR_RTS:
return "DEEP_SLEEP_CLEAR_RTS";
case CSR_PSKEY_RF_RESONANCE_TRIM:
return "RF_RESONANCE_TRIM";
case CSR_PSKEY_DEEP_SLEEP_PIO_WAKE:
return "DEEP_SLEEP_PIO_WAKE";
case CSR_PSKEY_DRAIN_BORE_TIMERS:
return "DRAIN_BORE_TIMERS";
case CSR_PSKEY_DRAIN_TX_POWER_BASE:
return "DRAIN_TX_POWER_BASE";
case CSR_PSKEY_MODULE_ID:
return "MODULE_ID";
case CSR_PSKEY_MODULE_DESIGN:
return "MODULE_DESIGN";
case CSR_PSKEY_MODULE_SECURITY_CODE:
return "MODULE_SECURITY_CODE";
case CSR_PSKEY_VM_DISABLE:
return "VM_DISABLE";
case CSR_PSKEY_MOD_MANUF0:
return "MOD_MANUF0";
case CSR_PSKEY_MOD_MANUF1:
return "MOD_MANUF1";
case CSR_PSKEY_MOD_MANUF2:
return "MOD_MANUF2";
case CSR_PSKEY_MOD_MANUF3:
return "MOD_MANUF3";
case CSR_PSKEY_MOD_MANUF4:
return "MOD_MANUF4";
case CSR_PSKEY_MOD_MANUF5:
return "MOD_MANUF5";
case CSR_PSKEY_MOD_MANUF6:
return "MOD_MANUF6";
case CSR_PSKEY_MOD_MANUF7:
return "MOD_MANUF7";
case CSR_PSKEY_MOD_MANUF8:
return "MOD_MANUF8";
case CSR_PSKEY_MOD_MANUF9:
return "MOD_MANUF9";
case CSR_PSKEY_DUT_VM_DISABLE:
return "DUT_VM_DISABLE";
case CSR_PSKEY_USR0:
return "USR0";
case CSR_PSKEY_USR1:
return "USR1";
case CSR_PSKEY_USR2:
return "USR2";
case CSR_PSKEY_USR3:
return "USR3";
case CSR_PSKEY_USR4:
return "USR4";
case CSR_PSKEY_USR5:
return "USR5";
case CSR_PSKEY_USR6:
return "USR6";
case CSR_PSKEY_USR7:
return "USR7";
case CSR_PSKEY_USR8:
return "USR8";
case CSR_PSKEY_USR9:
return "USR9";
case CSR_PSKEY_USR10:
return "USR10";
case CSR_PSKEY_USR11:
return "USR11";
case CSR_PSKEY_USR12:
return "USR12";
case CSR_PSKEY_USR13:
return "USR13";
case CSR_PSKEY_USR14:
return "USR14";
case CSR_PSKEY_USR15:
return "USR15";
case CSR_PSKEY_USR16:
return "USR16";
case CSR_PSKEY_USR17:
return "USR17";
case CSR_PSKEY_USR18:
return "USR18";
case CSR_PSKEY_USR19:
return "USR19";
case CSR_PSKEY_USR20:
return "USR20";
case CSR_PSKEY_USR21:
return "USR21";
case CSR_PSKEY_USR22:
return "USR22";
case CSR_PSKEY_USR23:
return "USR23";
case CSR_PSKEY_USR24:
return "USR24";
case CSR_PSKEY_USR25:
return "USR25";
case CSR_PSKEY_USR26:
return "USR26";
case CSR_PSKEY_USR27:
return "USR27";
case CSR_PSKEY_USR28:
return "USR28";
case CSR_PSKEY_USR29:
return "USR29";
case CSR_PSKEY_USR30:
return "USR30";
case CSR_PSKEY_USR31:
return "USR31";
case CSR_PSKEY_USR32:
return "USR32";
case CSR_PSKEY_USR33:
return "USR33";
case CSR_PSKEY_USR34:
return "USR34";
case CSR_PSKEY_USR35:
return "USR35";
case CSR_PSKEY_USR36:
return "USR36";
case CSR_PSKEY_USR37:
return "USR37";
case CSR_PSKEY_USR38:
return "USR38";
case CSR_PSKEY_USR39:
return "USR39";
case CSR_PSKEY_USR40:
return "USR40";
case CSR_PSKEY_USR41:
return "USR41";
case CSR_PSKEY_USR42:
return "USR42";
case CSR_PSKEY_USR43:
return "USR43";
case CSR_PSKEY_USR44:
return "USR44";
case CSR_PSKEY_USR45:
return "USR45";
case CSR_PSKEY_USR46:
return "USR46";
case CSR_PSKEY_USR47:
return "USR47";
case CSR_PSKEY_USR48:
return "USR48";
case CSR_PSKEY_USR49:
return "USR49";
case CSR_PSKEY_USB_VERSION:
return "USB_VERSION";
case CSR_PSKEY_USB_DEVICE_CLASS_CODES:
return "USB_DEVICE_CLASS_CODES";
case CSR_PSKEY_USB_VENDOR_ID:
return "USB_VENDOR_ID";
case CSR_PSKEY_USB_PRODUCT_ID:
return "USB_PRODUCT_ID";
case CSR_PSKEY_USB_MANUF_STRING:
return "USB_MANUF_STRING";
case CSR_PSKEY_USB_PRODUCT_STRING:
return "USB_PRODUCT_STRING";
case CSR_PSKEY_USB_SERIAL_NUMBER_STRING:
return "USB_SERIAL_NUMBER_STRING";
case CSR_PSKEY_USB_CONFIG_STRING:
return "USB_CONFIG_STRING";
case CSR_PSKEY_USB_ATTRIBUTES:
return "USB_ATTRIBUTES";
case CSR_PSKEY_USB_MAX_POWER:
return "USB_MAX_POWER";
case CSR_PSKEY_USB_BT_IF_CLASS_CODES:
return "USB_BT_IF_CLASS_CODES";
case CSR_PSKEY_USB_LANGID:
return "USB_LANGID";
case CSR_PSKEY_USB_DFU_CLASS_CODES:
return "USB_DFU_CLASS_CODES";
case CSR_PSKEY_USB_DFU_PRODUCT_ID:
return "USB_DFU_PRODUCT_ID";
case CSR_PSKEY_USB_PIO_DETACH:
return "USB_PIO_DETACH";
case CSR_PSKEY_USB_PIO_WAKEUP:
return "USB_PIO_WAKEUP";
case CSR_PSKEY_USB_PIO_PULLUP:
return "USB_PIO_PULLUP";
case CSR_PSKEY_USB_PIO_VBUS:
return "USB_PIO_VBUS";
case CSR_PSKEY_USB_PIO_WAKE_TIMEOUT:
return "USB_PIO_WAKE_TIMEOUT";
case CSR_PSKEY_USB_PIO_RESUME:
return "USB_PIO_RESUME";
case CSR_PSKEY_USB_BT_SCO_IF_CLASS_CODES:
return "USB_BT_SCO_IF_CLASS_CODES";
case CSR_PSKEY_USB_SUSPEND_PIO_LEVEL:
return "USB_SUSPEND_PIO_LEVEL";
case CSR_PSKEY_USB_SUSPEND_PIO_DIR:
return "USB_SUSPEND_PIO_DIR";
case CSR_PSKEY_USB_SUSPEND_PIO_MASK:
return "USB_SUSPEND_PIO_MASK";
case CSR_PSKEY_USB_ENDPOINT_0_MAX_PACKET_SIZE:
return "USB_ENDPOINT_0_MAX_PACKET_SIZE";
case CSR_PSKEY_USB_CONFIG:
return "USB_CONFIG";
case CSR_PSKEY_RADIOTEST_ATTEN_INIT:
return "RADIOTEST_ATTEN_INIT";
case CSR_PSKEY_RADIOTEST_FIRST_TRIM_TIME:
return "RADIOTEST_FIRST_TRIM_TIME";
case CSR_PSKEY_RADIOTEST_SUBSEQUENT_TRIM_TIME:
return "RADIOTEST_SUBSEQUENT_TRIM_TIME";
case CSR_PSKEY_RADIOTEST_LO_LVL_TRIM_ENABLE:
return "RADIOTEST_LO_LVL_TRIM_ENABLE";
case CSR_PSKEY_RADIOTEST_DISABLE_MODULATION:
return "RADIOTEST_DISABLE_MODULATION";
case CSR_PSKEY_RFCOMM_FCON_THRESHOLD:
return "RFCOMM_FCON_THRESHOLD";
case CSR_PSKEY_RFCOMM_FCOFF_THRESHOLD:
return "RFCOMM_FCOFF_THRESHOLD";
case CSR_PSKEY_IPV6_STATIC_ADDR:
return "IPV6_STATIC_ADDR";
case CSR_PSKEY_IPV4_STATIC_ADDR:
return "IPV4_STATIC_ADDR";
case CSR_PSKEY_IPV6_STATIC_PREFIX_LEN:
return "IPV6_STATIC_PREFIX_LEN";
case CSR_PSKEY_IPV6_STATIC_ROUTER_ADDR:
return "IPV6_STATIC_ROUTER_ADDR";
case CSR_PSKEY_IPV4_STATIC_SUBNET_MASK:
return "IPV4_STATIC_SUBNET_MASK";
case CSR_PSKEY_IPV4_STATIC_ROUTER_ADDR:
return "IPV4_STATIC_ROUTER_ADDR";
case CSR_PSKEY_MDNS_NAME:
return "MDNS_NAME";
case CSR_PSKEY_FIXED_PIN:
return "FIXED_PIN";
case CSR_PSKEY_MDNS_PORT:
return "MDNS_PORT";
case CSR_PSKEY_MDNS_TTL:
return "MDNS_TTL";
case CSR_PSKEY_MDNS_IPV4_ADDR:
return "MDNS_IPV4_ADDR";
case CSR_PSKEY_ARP_CACHE_TIMEOUT:
return "ARP_CACHE_TIMEOUT";
case CSR_PSKEY_HFP_POWER_TABLE:
return "HFP_POWER_TABLE";
case CSR_PSKEY_DRAIN_BORE_TIMER_COUNTERS:
return "DRAIN_BORE_TIMER_COUNTERS";
case CSR_PSKEY_DRAIN_BORE_COUNTERS:
return "DRAIN_BORE_COUNTERS";
case CSR_PSKEY_LOOP_FILTER_TRIM:
return "LOOP_FILTER_TRIM";
case CSR_PSKEY_DRAIN_BORE_CURRENT_PEAK:
return "DRAIN_BORE_CURRENT_PEAK";
case CSR_PSKEY_VM_E2_CACHE_LIMIT:
return "VM_E2_CACHE_LIMIT";
case CSR_PSKEY_FORCE_16MHZ_REF_PIO:
return "FORCE_16MHZ_REF_PIO";
case CSR_PSKEY_CDMA_LO_REF_LIMITS:
return "CDMA_LO_REF_LIMITS";
case CSR_PSKEY_CDMA_LO_ERROR_LIMITS:
return "CDMA_LO_ERROR_LIMITS";
case CSR_PSKEY_CLOCK_STARTUP_DELAY:
return "CLOCK_STARTUP_DELAY";
case CSR_PSKEY_DEEP_SLEEP_CORRECTION_FACTOR:
return "DEEP_SLEEP_CORRECTION_FACTOR";
case CSR_PSKEY_TEMPERATURE_CALIBRATION:
return "TEMPERATURE_CALIBRATION";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_INTERNAL_PA:
return "TEMPERATURE_VS_DELTA_INTERNAL_PA";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_PRE_LVL:
return "TEMPERATURE_VS_DELTA_TX_PRE_LVL";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_BB:
return "TEMPERATURE_VS_DELTA_TX_BB";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_ANA_FTRIM:
return "TEMPERATURE_VS_DELTA_ANA_FTRIM";
case CSR_PSKEY_TEST_DELTA_OFFSET:
return "TEST_DELTA_OFFSET";
case CSR_PSKEY_RX_DYNAMIC_LVL_OFFSET:
return "RX_DYNAMIC_LVL_OFFSET";
case CSR_PSKEY_TEST_FORCE_OFFSET:
return "TEST_FORCE_OFFSET";
case CSR_PSKEY_RF_TRAP_BAD_DIVISION_RATIOS:
return "RF_TRAP_BAD_DIVISION_RATIOS";
case CSR_PSKEY_RADIOTEST_CDMA_LO_REF_LIMITS:
return "RADIOTEST_CDMA_LO_REF_LIMITS";
case CSR_PSKEY_INITIAL_BOOTMODE:
return "INITIAL_BOOTMODE";
case CSR_PSKEY_ONCHIP_HCI_CLIENT:
return "ONCHIP_HCI_CLIENT";
case CSR_PSKEY_RX_ATTEN_BACKOFF:
return "RX_ATTEN_BACKOFF";
case CSR_PSKEY_RX_ATTEN_UPDATE_RATE:
return "RX_ATTEN_UPDATE_RATE";
case CSR_PSKEY_SYNTH_TXRX_THRESHOLDS:
return "SYNTH_TXRX_THRESHOLDS";
case CSR_PSKEY_MIN_WAIT_STATES:
return "MIN_WAIT_STATES";
case CSR_PSKEY_RSSI_CORRECTION:
return "RSSI_CORRECTION";
case CSR_PSKEY_SCHED_THROTTLE_TIMEOUT:
return "SCHED_THROTTLE_TIMEOUT";
case CSR_PSKEY_DEEP_SLEEP_USE_EXTERNAL_CLOCK:
return "DEEP_SLEEP_USE_EXTERNAL_CLOCK";
case CSR_PSKEY_TRIM_RADIO_FILTERS:
return "TRIM_RADIO_FILTERS";
case CSR_PSKEY_TRANSMIT_OFFSET:
return "TRANSMIT_OFFSET";
case CSR_PSKEY_USB_VM_CONTROL:
return "USB_VM_CONTROL";
case CSR_PSKEY_MR_ANA_RX_FTRIM:
return "MR_ANA_RX_FTRIM";
case CSR_PSKEY_I2C_CONFIG:
return "I2C_CONFIG";
case CSR_PSKEY_IQ_LVL_RX:
return "IQ_LVL_RX";
case CSR_PSKEY_MR_TX_FILTER_CONFIG:
return "MR_TX_FILTER_CONFIG";
case CSR_PSKEY_MR_TX_CONFIG2:
return "MR_TX_CONFIG2";
case CSR_PSKEY_USB_DONT_RESET_BOOTMODE_ON_HOST_RESET:
return "USB_DONT_RESET_BOOTMODE_ON_HOST_RESET";
case CSR_PSKEY_LC_USE_THROTTLING:
return "LC_USE_THROTTLING";
case CSR_PSKEY_CHARGER_TRIM:
return "CHARGER_TRIM";
case CSR_PSKEY_CLOCK_REQUEST_FEATURES:
return "CLOCK_REQUEST_FEATURES";
case CSR_PSKEY_TRANSMIT_OFFSET_CLASS1:
return "TRANSMIT_OFFSET_CLASS1";
case CSR_PSKEY_TX_AVOID_PA_CLASS1_PIO:
return "TX_AVOID_PA_CLASS1_PIO";
case CSR_PSKEY_MR_PIO_CONFIG:
return "MR_PIO_CONFIG";
case CSR_PSKEY_UART_CONFIG2:
return "UART_CONFIG2";
case CSR_PSKEY_CLASS1_IQ_LVL:
return "CLASS1_IQ_LVL";
case CSR_PSKEY_CLASS1_TX_CONFIG2:
return "CLASS1_TX_CONFIG2";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_INTERNAL_PA_CLASS1:
return "TEMPERATURE_VS_DELTA_INTERNAL_PA_CLASS1";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_EXTERNAL_PA_CLASS1:
return "TEMPERATURE_VS_DELTA_EXTERNAL_PA_CLASS1";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_PRE_LVL_MR:
return "TEMPERATURE_VS_DELTA_TX_PRE_LVL_MR";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_BB_MR_HEADER:
return "TEMPERATURE_VS_DELTA_TX_BB_MR_HEADER";
case CSR_PSKEY_TEMPERATURE_VS_DELTA_TX_BB_MR_PAYLOAD:
return "TEMPERATURE_VS_DELTA_TX_BB_MR_PAYLOAD";
case CSR_PSKEY_RX_MR_EQ_TAPS:
return "RX_MR_EQ_TAPS";
case CSR_PSKEY_TX_PRE_LVL_CLASS1:
return "TX_PRE_LVL_CLASS1";
case CSR_PSKEY_ANALOGUE_ATTENUATOR:
return "ANALOGUE_ATTENUATOR";
case CSR_PSKEY_MR_RX_FILTER_TRIM:
return "MR_RX_FILTER_TRIM";
case CSR_PSKEY_MR_RX_FILTER_RESPONSE:
return "MR_RX_FILTER_RESPONSE";
case CSR_PSKEY_PIO_WAKEUP_STATE:
return "PIO_WAKEUP_STATE";
case CSR_PSKEY_MR_TX_IF_ATTEN_OFF_TEMP:
return "MR_TX_IF_ATTEN_OFF_TEMP";
case CSR_PSKEY_LO_DIV_LATCH_BYPASS:
return "LO_DIV_LATCH_BYPASS";
case CSR_PSKEY_LO_VCO_STANDBY:
return "LO_VCO_STANDBY";
case CSR_PSKEY_SLOW_CLOCK_FILTER_SHIFT:
return "SLOW_CLOCK_FILTER_SHIFT";
case CSR_PSKEY_SLOW_CLOCK_FILTER_DIVIDER:
return "SLOW_CLOCK_FILTER_DIVIDER";
case CSR_PSKEY_USB_ATTRIBUTES_POWER:
return "USB_ATTRIBUTES_POWER";
case CSR_PSKEY_USB_ATTRIBUTES_WAKEUP:
return "USB_ATTRIBUTES_WAKEUP";
case CSR_PSKEY_DFU_ATTRIBUTES_MANIFESTATION_TOLERANT:
return "DFU_ATTRIBUTES_MANIFESTATION_TOLERANT";
case CSR_PSKEY_DFU_ATTRIBUTES_CAN_UPLOAD:
return "DFU_ATTRIBUTES_CAN_UPLOAD";
case CSR_PSKEY_DFU_ATTRIBUTES_CAN_DOWNLOAD:
return "DFU_ATTRIBUTES_CAN_DOWNLOAD";
case CSR_PSKEY_UART_CONFIG_STOP_BITS:
return "UART_CONFIG_STOP_BITS";
case CSR_PSKEY_UART_CONFIG_PARITY_BIT:
return "UART_CONFIG_PARITY_BIT";
case CSR_PSKEY_UART_CONFIG_FLOW_CTRL_EN:
return "UART_CONFIG_FLOW_CTRL_EN";
case CSR_PSKEY_UART_CONFIG_RTS_AUTO_EN:
return "UART_CONFIG_RTS_AUTO_EN";
case CSR_PSKEY_UART_CONFIG_RTS:
return "UART_CONFIG_RTS";
case CSR_PSKEY_UART_CONFIG_TX_ZERO_EN:
return "UART_CONFIG_TX_ZERO_EN";
case CSR_PSKEY_UART_CONFIG_NON_BCSP_EN:
return "UART_CONFIG_NON_BCSP_EN";
case CSR_PSKEY_UART_CONFIG_RX_RATE_DELAY:
return "UART_CONFIG_RX_RATE_DELAY";
case CSR_PSKEY_UART_SEQ_TIMEOUT:
return "UART_SEQ_TIMEOUT";
case CSR_PSKEY_UART_SEQ_RETRIES:
return "UART_SEQ_RETRIES";
case CSR_PSKEY_UART_SEQ_WINSIZE:
return "UART_SEQ_WINSIZE";
case CSR_PSKEY_UART_USE_CRC_ON_TX:
return "UART_USE_CRC_ON_TX";
case CSR_PSKEY_UART_HOST_INITIAL_STATE:
return "UART_HOST_INITIAL_STATE";
case CSR_PSKEY_UART_HOST_ATTENTION_SPAN:
return "UART_HOST_ATTENTION_SPAN";
case CSR_PSKEY_UART_HOST_WAKEUP_TIME:
return "UART_HOST_WAKEUP_TIME";
case CSR_PSKEY_UART_HOST_WAKEUP_WAIT:
return "UART_HOST_WAKEUP_WAIT";
case CSR_PSKEY_BCSP_LM_MODE:
return "BCSP_LM_MODE";
case CSR_PSKEY_BCSP_LM_SYNC_RETRIES:
return "BCSP_LM_SYNC_RETRIES";
case CSR_PSKEY_BCSP_LM_TSHY:
return "BCSP_LM_TSHY";
case CSR_PSKEY_UART_DFU_CONFIG_STOP_BITS:
return "UART_DFU_CONFIG_STOP_BITS";
case CSR_PSKEY_UART_DFU_CONFIG_PARITY_BIT:
return "UART_DFU_CONFIG_PARITY_BIT";
case CSR_PSKEY_UART_DFU_CONFIG_FLOW_CTRL_EN:
return "UART_DFU_CONFIG_FLOW_CTRL_EN";
case CSR_PSKEY_UART_DFU_CONFIG_RTS_AUTO_EN:
return "UART_DFU_CONFIG_RTS_AUTO_EN";
case CSR_PSKEY_UART_DFU_CONFIG_RTS:
return "UART_DFU_CONFIG_RTS";
case CSR_PSKEY_UART_DFU_CONFIG_TX_ZERO_EN:
return "UART_DFU_CONFIG_TX_ZERO_EN";
case CSR_PSKEY_UART_DFU_CONFIG_NON_BCSP_EN:
return "UART_DFU_CONFIG_NON_BCSP_EN";
case CSR_PSKEY_UART_DFU_CONFIG_RX_RATE_DELAY:
return "UART_DFU_CONFIG_RX_RATE_DELAY";
case CSR_PSKEY_AMUX_AIO0:
return "AMUX_AIO0";
case CSR_PSKEY_AMUX_AIO1:
return "AMUX_AIO1";
case CSR_PSKEY_AMUX_AIO2:
return "AMUX_AIO2";
case CSR_PSKEY_AMUX_AIO3:
return "AMUX_AIO3";
case CSR_PSKEY_LOCAL_NAME_SIMPLIFIED:
return "LOCAL_NAME_SIMPLIFIED";
case CSR_PSKEY_EXTENDED_STUB:
return "EXTENDED_STUB";
default:
return "UNKNOWN";
}
}
int csr_write_varid_valueless(int dd, uint16_t seqnum, uint16_t varid)
{
unsigned char cmd[] = { 0x02, 0x00, 0x09, 0x00,
seqnum & 0xff, seqnum >> 8, varid & 0xff, varid >> 8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char cp[254], rp[254];
struct hci_request rq;
memset(&cp, 0, sizeof(cp));
cp[0] = 0xc2;
memcpy(cp + 1, cmd, sizeof(cmd));
switch (varid) {
case CSR_VARID_COLD_RESET:
case CSR_VARID_WARM_RESET:
case CSR_VARID_COLD_HALT:
case CSR_VARID_WARM_HALT:
return hci_send_cmd(dd, OGF_VENDOR_CMD, 0x00, sizeof(cmd) + 1, cp);
}
memset(&rq, 0, sizeof(rq));
rq.ogf = OGF_VENDOR_CMD;
rq.ocf = 0x00;
rq.event = EVT_VENDOR;
rq.cparam = cp;
rq.clen = sizeof(cmd) + 1;
rq.rparam = rp;
rq.rlen = sizeof(rp);
if (hci_send_req(dd, &rq, 2000) < 0)
return -1;
if (rp[0] != 0xc2) {
errno = EIO;
return -1;
}
if ((rp[9] + (rp[10] << 8)) != 0) {
errno = ENXIO;
return -1;
}
return 0;
}
int csr_write_varid_complex(int dd, uint16_t seqnum, uint16_t varid, uint8_t *value, uint16_t length)
{
unsigned char cmd[] = { 0x02, 0x00, ((length / 2) + 5) & 0xff, ((length / 2) + 5) >> 8,
seqnum & 0xff, seqnum >> 8, varid & 0xff, varid >> 8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char cp[254], rp[254];
struct hci_request rq;
memset(&cp, 0, sizeof(cp));
cp[0] = 0xc2;
memcpy(cp + 1, cmd, sizeof(cmd));
memcpy(cp + 11, value, length);
memset(&rq, 0, sizeof(rq));
rq.ogf = OGF_VENDOR_CMD;
rq.ocf = 0x00;
rq.event = EVT_VENDOR;
rq.cparam = cp;
rq.clen = sizeof(cmd) + length + 1;
rq.rparam = rp;
rq.rlen = sizeof(rp);
if (hci_send_req(dd, &rq, 2000) < 0)
return -1;
if (rp[0] != 0xc2) {
errno = EIO;
return -1;
}
if ((rp[9] + (rp[10] << 8)) != 0) {
errno = ENXIO;
return -1;
}
return 0;
}
int csr_read_varid_complex(int dd, uint16_t seqnum, uint16_t varid, uint8_t *value, uint16_t length)
{
unsigned char cmd[] = { 0x00, 0x00, ((length / 2) + 5) & 0xff, ((length / 2) + 5) >> 8,
seqnum & 0xff, seqnum >> 8, varid & 0xff, varid >> 8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char cp[254], rp[254];
struct hci_request rq;
memset(&cp, 0, sizeof(cp));
cp[0] = 0xc2;
memcpy(cp + 1, cmd, sizeof(cmd));
memcpy(cp + 11, value, length);
memset(&rq, 0, sizeof(rq));
rq.ogf = OGF_VENDOR_CMD;
rq.ocf = 0x00;
rq.event = EVT_VENDOR;
rq.cparam = cp;
rq.clen = sizeof(cmd) + length + 1;
rq.rparam = rp;
rq.rlen = sizeof(rp);
if (hci_send_req(dd, &rq, 2000) < 0)
return -1;
if (rp[0] != 0xc2) {
errno = EIO;
return -1;
}
if ((rp[9] + (rp[10] << 8)) != 0) {
errno = ENXIO;
return -1;
}
memcpy(value, rp + 11, length);
return 0;
}
int csr_read_varid_uint16(int dd, uint16_t seqnum, uint16_t varid, uint16_t *value)
{
unsigned char cmd[] = { 0x00, 0x00, 0x09, 0x00,
seqnum & 0xff, seqnum >> 8, varid & 0xff, varid >> 8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char cp[254], rp[254];
struct hci_request rq;
memset(&cp, 0, sizeof(cp));
cp[0] = 0xc2;
memcpy(cp + 1, cmd, sizeof(cmd));
memset(&rq, 0, sizeof(rq));
rq.ogf = OGF_VENDOR_CMD;
rq.ocf = 0x00;
rq.event = EVT_VENDOR;
rq.cparam = cp;
rq.clen = sizeof(cmd) + 1;
rq.rparam = rp;
rq.rlen = sizeof(rp);
if (hci_send_req(dd, &rq, 2000) < 0)
return -1;
if (rp[0] != 0xc2) {
errno = EIO;
return -1;
}
if ((rp[9] + (rp[10] << 8)) != 0) {
errno = ENXIO;
return -1;
}
*value = rp[11] + (rp[12] << 8);
return 0;
}
int csr_read_varid_uint32(int dd, uint16_t seqnum, uint16_t varid, uint32_t *value)
{
unsigned char cmd[] = { 0x00, 0x00, 0x09, 0x00,
seqnum & 0xff, seqnum >> 8, varid & 0xff, varid >> 8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char cp[254], rp[254];
struct hci_request rq;
memset(&cp, 0, sizeof(cp));
cp[0] = 0xc2;
memcpy(cp + 1, cmd, sizeof(cmd));
memset(&rq, 0, sizeof(rq));
rq.ogf = OGF_VENDOR_CMD;
rq.ocf = 0x00;
rq.event = EVT_VENDOR;
rq.cparam = cp;
rq.clen = sizeof(cmd) + 1;
rq.rparam = rp;
rq.rlen = sizeof(rp);
if (hci_send_req(dd, &rq, 2000) < 0)
return -1;
if (rp[0] != 0xc2) {
errno = EIO;
return -1;
}
if ((rp[9] + (rp[10] << 8)) != 0) {
errno = ENXIO;
return -1;
}
*value = ((rp[11] + (rp[12] << 8)) << 16) + (rp[13] + (rp[14] << 8));
return 0;
}
int csr_read_pskey_complex(int dd, uint16_t seqnum, uint16_t pskey, uint16_t stores, uint8_t *value, uint16_t length)
{
unsigned char cmd[] = { 0x00, 0x00, ((length / 2) + 8) & 0xff, ((length / 2) + 8) >> 8,
seqnum & 0xff, seqnum >> 8, 0x03, 0x70, 0x00, 0x00,
pskey & 0xff, pskey >> 8,
(length / 2) & 0xff, (length / 2) >> 8,
stores & 0xff, stores >> 8, 0x00, 0x00 };
unsigned char cp[254], rp[254];
struct hci_request rq;
memset(&cp, 0, sizeof(cp));
cp[0] = 0xc2;
memcpy(cp + 1, cmd, sizeof(cmd));
memset(&rq, 0, sizeof(rq));
rq.ogf = OGF_VENDOR_CMD;
rq.ocf = 0x00;
rq.event = EVT_VENDOR;
rq.cparam = cp;
rq.clen = sizeof(cmd) + length - 1;
rq.rparam = rp;
rq.rlen = sizeof(rp);
if (hci_send_req(dd, &rq, 2000) < 0)
return -1;
if (rp[0] != 0xc2) {
errno = EIO;
return -1;
}
if ((rp[9] + (rp[10] << 8)) != 0) {
errno = ENXIO;
return -1;
}
memcpy(value, rp + 17, length);
return 0;
}
int csr_write_pskey_complex(int dd, uint16_t seqnum, uint16_t pskey, uint16_t stores, uint8_t *value, uint16_t length)
{
unsigned char cmd[] = { 0x02, 0x00, ((length / 2) + 8) & 0xff, ((length / 2) + 8) >> 8,
seqnum & 0xff, seqnum >> 8, 0x03, 0x70, 0x00, 0x00,
pskey & 0xff, pskey >> 8,
(length / 2) & 0xff, (length / 2) >> 8,
stores & 0xff, stores >> 8, 0x00, 0x00 };
unsigned char cp[254], rp[254];
struct hci_request rq;
memset(&cp, 0, sizeof(cp));
cp[0] = 0xc2;
memcpy(cp + 1, cmd, sizeof(cmd));
memcpy(cp + 17, value, length);
memset(&rq, 0, sizeof(rq));
rq.ogf = OGF_VENDOR_CMD;
rq.ocf = 0x00;
rq.event = EVT_VENDOR;
rq.cparam = cp;
rq.clen = sizeof(cmd) + length - 1;
rq.rparam = rp;
rq.rlen = sizeof(rp);
if (hci_send_req(dd, &rq, 2000) < 0)
return -1;
if (rp[0] != 0xc2) {
errno = EIO;
return -1;
}
if ((rp[9] + (rp[10] << 8)) != 0) {
errno = ENXIO;
return -1;
}
return 0;
}
int csr_read_pskey_uint16(int dd, uint16_t seqnum, uint16_t pskey, uint16_t stores, uint16_t *value)
{
uint8_t array[2] = { 0x00, 0x00 };
int err;
err = csr_read_pskey_complex(dd, seqnum, pskey, stores, array, 2);
*value = array[0] + (array[1] << 8);
return err;
}
int csr_write_pskey_uint16(int dd, uint16_t seqnum, uint16_t pskey, uint16_t stores, uint16_t value)
{
uint8_t array[2] = { value & 0xff, value >> 8 };
return csr_write_pskey_complex(dd, seqnum, pskey, stores, array, 2);
}
int csr_read_pskey_uint32(int dd, uint16_t seqnum, uint16_t pskey, uint16_t stores, uint32_t *value)
{
uint8_t array[4] = { 0x00, 0x00, 0x00, 0x00 };
int err;
err = csr_read_pskey_complex(dd, seqnum, pskey, stores, array, 4);
*value = ((array[0] + (array[1] << 8)) << 16) +
(array[2] + (array[3] << 8));
return err;
}
int csr_write_pskey_uint32(int dd, uint16_t seqnum, uint16_t pskey, uint16_t stores, uint32_t value)
{
uint8_t array[4] = { (value & 0xff0000) >> 16, value >> 24,
value & 0xff, (value & 0xff00) >> 8 };
return csr_write_pskey_complex(dd, seqnum, pskey, stores, array, 4);
}
int psr_put(uint16_t pskey, uint8_t *value, uint16_t size)
{
struct psr_data *item;
item = malloc(sizeof(*item));
if (!item)
return -ENOMEM;
item->pskey = pskey;
if (size > 0) {
item->value = malloc(size);
if (!item->value) {
free(item);
return -ENOMEM;
}
memcpy(item->value, value, size);
item->size = size;
} else {
item->value = NULL;
item->size = 0;
}
item->next = NULL;
if (!head)
head = item;
else
tail->next = item;
tail = item;
return 0;
}
int psr_get(uint16_t *pskey, uint8_t *value, uint16_t *size)
{
struct psr_data *item = head;
if (!head)
return -ENOENT;
*pskey = item->pskey;
if (item->value) {
if (value && item->size > 0)
memcpy(value, item->value, item->size);
free(item->value);
*size = item->size;
} else
*size = 0;
if (head == tail)
tail = NULL;
head = head->next;
free(item);
return 0;
}
static int parse_line(char *str)
{
uint8_t array[256];
uint16_t value, pskey, length = 0;
char *off, *end;
pskey = strtol(str + 1, NULL, 16);
off = strstr(str, "=") + 1;
if (!off)
return -EIO;
while (1) {
value = strtol(off, &end, 16);
if (value == 0 && off == end)
break;
array[length++] = value & 0xff;
array[length++] = value >> 8;
if (*end == '\0')
break;
off = end + 1;
}
return psr_put(pskey, array, length);
}
int psr_read(const char *filename)
{
struct stat st;
char *str, *map, *off, *end;
int fd, err = 0;
fd = open(filename, O_RDONLY);
if (fd < 0)
return fd;
if (fstat(fd, &st) < 0) {
err = -errno;
goto close;
}
map = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (!map || map == MAP_FAILED) {
err = -errno;
goto close;
}
off = map;
while (1) {
if (*off == '\r' || *off == '\n') {
off++;
continue;
}
end = strpbrk(off, "\r\n");
if (!end)
break;
str = malloc(end - off + 1);
if (!str)
break;
memset(str, 0, end - off + 1);
strncpy(str, off, end - off);
if (*str == '&')
parse_line(str);
free(str);
off = end + 1;
}
munmap(map, st.st_size);
close:
close(fd);
return err;
}
int psr_print(void)
{
uint8_t array[256];
uint16_t pskey, length;
char *str, val[7];
int i;
while (1) {
if (psr_get(&pskey, array, &length) < 0)
break;
str = csr_pskeytoval(pskey);
if (!strcasecmp(str, "UNKNOWN")) {
sprintf(val, "0x%04x", pskey);
str = NULL;
}
printf("// %s%s\n&%04x =", str ? "PSKEY_" : "",
str ? str : val, pskey);
for (i = 0; i < length / 2; i++)
printf(" %02x%02x", array[i * 2 + 1], array[i * 2]);
printf("\n");
}
return 0;
}
Jump to Line
Something went wrong with that request. Please try again.