1 /* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2004-2009 Marcel Holtmann <marcel (at) holtmann.org> 6 * 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 21 * 22 */ 23 24 #ifdef HAVE_CONFIG_H 25 #include <config.h> 26 #endif 27 28 #include <stdio.h> 29 #include <errno.h> 30 #include <stdlib.h> 31 #include <getopt.h> 32 #include <sys/socket.h> 33 34 #include <bluetooth/bluetooth.h> 35 #include <bluetooth/hci.h> 36 #include <bluetooth/hci_lib.h> 37 38 #include "csr.h" 39 40 #define CSR_TRANSPORT_UNKNOWN 0 41 #define CSR_TRANSPORT_HCI 1 42 #define CSR_TRANSPORT_USB 2 43 #define CSR_TRANSPORT_BCSP 3 44 #define CSR_TRANSPORT_H4 4 45 #define CSR_TRANSPORT_3WIRE 5 46 47 #define CSR_STORES_PSI (0x0001) 48 #define CSR_STORES_PSF (0x0002) 49 #define CSR_STORES_PSROM (0x0004) 50 #define CSR_STORES_PSRAM (0x0008) 51 #define CSR_STORES_DEFAULT (CSR_STORES_PSI | CSR_STORES_PSF) 52 53 #define CSR_TYPE_NULL 0 54 #define CSR_TYPE_COMPLEX 1 55 #define CSR_TYPE_UINT8 2 56 #define CSR_TYPE_UINT16 3 57 #define CSR_TYPE_UINT32 4 58 59 #define CSR_TYPE_ARRAY CSR_TYPE_COMPLEX 60 #define CSR_TYPE_BDADDR CSR_TYPE_COMPLEX 61 62 static inline int transport_open(int transport, char *device) 63 { 64 switch (transport) { 65 case CSR_TRANSPORT_HCI: 66 return csr_open_hci(device); 67 #ifdef HAVE_LIBUSB 68 case CSR_TRANSPORT_USB: 69 return csr_open_usb(device); 70 #endif 71 case CSR_TRANSPORT_BCSP: 72 return csr_open_bcsp(device); 73 case CSR_TRANSPORT_H4: 74 return csr_open_h4(device); 75 case CSR_TRANSPORT_3WIRE: 76 return csr_open_3wire(device); 77 default: 78 fprintf(stderr, "Unsupported transport\n"); 79 return -1; 80 } 81 } 82 83 static inline int transport_read(int transport, uint16_t varid, uint8_t *value, uint16_t length) 84 { 85 switch (transport) { 86 case CSR_TRANSPORT_HCI: 87 return csr_read_hci(varid, value, length); 88 #ifdef HAVE_LIBUSB 89 case CSR_TRANSPORT_USB: 90 return csr_read_usb(varid, value, length); 91 #endif 92 case CSR_TRANSPORT_BCSP: 93 return csr_read_bcsp(varid, value, length); 94 case CSR_TRANSPORT_H4: 95 return csr_read_h4(varid, value, length); 96 case CSR_TRANSPORT_3WIRE: 97 return csr_read_3wire(varid, value, length); 98 default: 99 errno = EOPNOTSUPP; 100 return -1; 101 } 102 } 103 104 static inline int transport_write(int transport, uint16_t varid, uint8_t *value, uint16_t length) 105 { 106 switch (transport) { 107 case CSR_TRANSPORT_HCI: 108 return csr_write_hci(varid, value, length); 109 #ifdef HAVE_LIBUSB 110 case CSR_TRANSPORT_USB: 111 return csr_write_usb(varid, value, length); 112 #endif 113 case CSR_TRANSPORT_BCSP: 114 return csr_write_bcsp(varid, value, length); 115 case CSR_TRANSPORT_H4: 116 return csr_write_h4(varid, value, length); 117 case CSR_TRANSPORT_3WIRE: 118 return csr_write_3wire(varid, value, length); 119 default: 120 errno = EOPNOTSUPP; 121 return -1; 122 } 123 } 124 125 static inline void transport_close(int transport) 126 { 127 switch (transport) { 128 case CSR_TRANSPORT_HCI: 129 csr_close_hci(); 130 break; 131 #ifdef HAVE_LIBUSB 132 case CSR_TRANSPORT_USB: 133 csr_close_usb(); 134 break; 135 #endif 136 case CSR_TRANSPORT_BCSP: 137 csr_close_bcsp(); 138 break; 139 case CSR_TRANSPORT_H4: 140 csr_close_h4(); 141 break; 142 case CSR_TRANSPORT_3WIRE: 143 csr_close_3wire(); 144 break; 145 } 146 } 147 148 static struct { 149 uint16_t pskey; 150 int type; 151 int size; 152 char *str; 153 } storage[] = { 154 { CSR_PSKEY_BDADDR, CSR_TYPE_BDADDR, 8, "bdaddr" }, 155 { CSR_PSKEY_COUNTRYCODE, CSR_TYPE_UINT16, 0, "country" }, 156 { CSR_PSKEY_CLASSOFDEVICE, CSR_TYPE_UINT32, 0, "devclass" }, 157 { CSR_PSKEY_ENC_KEY_LMIN, CSR_TYPE_UINT16, 0, "keymin" }, 158 { CSR_PSKEY_ENC_KEY_LMAX, CSR_TYPE_UINT16, 0, "keymax" }, 159 { CSR_PSKEY_LOCAL_SUPPORTED_FEATURES, CSR_TYPE_ARRAY, 8, "features" }, 160 { CSR_PSKEY_LOCAL_SUPPORTED_COMMANDS, CSR_TYPE_ARRAY, 18, "commands" }, 161 { CSR_PSKEY_HCI_LMP_LOCAL_VERSION, CSR_TYPE_UINT16, 0, "version" }, 162 { CSR_PSKEY_LMP_REMOTE_VERSION, CSR_TYPE_UINT8, 0, "remver" }, 163 { CSR_PSKEY_HOSTIO_USE_HCI_EXTN, CSR_TYPE_UINT16, 0, "hciextn" }, 164 { CSR_PSKEY_HOSTIO_MAP_SCO_PCM, CSR_TYPE_UINT16, 0, "mapsco" }, 165 { CSR_PSKEY_UART_BAUDRATE, CSR_TYPE_UINT16, 0, "baudrate" }, 166 { CSR_PSKEY_HOST_INTERFACE, CSR_TYPE_UINT16, 0, "hostintf" }, 167 { CSR_PSKEY_ANA_FREQ, CSR_TYPE_UINT16, 0, "anafreq" }, 168 { CSR_PSKEY_ANA_FTRIM, CSR_TYPE_UINT16, 0, "anaftrim" }, 169 { CSR_PSKEY_USB_VENDOR_ID, CSR_TYPE_UINT16, 0, "usbvid" }, 170 { CSR_PSKEY_USB_PRODUCT_ID, CSR_TYPE_UINT16, 0, "usbpid" }, 171 { CSR_PSKEY_USB_DFU_PRODUCT_ID, CSR_TYPE_UINT16, 0, "dfupid" }, 172 { CSR_PSKEY_INITIAL_BOOTMODE, CSR_TYPE_UINT16, 0, "bootmode" }, 173 { 0x0000 }, 174 }; 175 176 static char *storestostr(uint16_t stores) 177 { 178 switch (stores) { 179 case 0x0000: 180 return "Default"; 181 case 0x0001: 182 return "psi"; 183 case 0x0002: 184 return "psf"; 185 case 0x0004: 186 return "psrom"; 187 case 0x0008: 188 return "psram"; 189 default: 190 return "Unknown"; 191 } 192 } 193 194 static char *memorytostr(uint16_t type) 195 { 196 switch (type) { 197 case 0x0000: 198 return "Flash memory"; 199 case 0x0001: 200 return "EEPROM"; 201 case 0x0002: 202 return "RAM (transient)"; 203 case 0x0003: 204 return "ROM (or \"read-only\" flash memory)"; 205 default: 206 return "Unknown"; 207 } 208 } 209 210 #define OPT_RANGE(min, max) \ 211 if (argc < (min)) { errno = EINVAL; return -1; } \ 212 if (argc > (max)) { errno = E2BIG; return -1; } 213 214 static struct option help_options[] = { 215 { "help", 0, 0, 'h' }, 216 { 0, 0, 0, 0 } 217 }; 218 219 static int opt_help(int argc, char *argv[], int *help) 220 { 221 int opt; 222 223 while ((opt=getopt_long(argc, argv, "+h", help_options, NULL)) != EOF) { 224 switch (opt) { 225 case 'h': 226 if (help) 227 *help = 1; 228 break; 229 } 230 } 231 232 return optind; 233 } 234 235 #define OPT_HELP(range, help) \ 236 opt_help(argc, argv, (help)); \ 237 argc -= optind; argv += optind; optind = 0; \ 238 OPT_RANGE((range), (range)) 239 240 static int cmd_builddef(int transport, int argc, char *argv[]) 241 { 242 uint8_t array[8]; 243 uint16_t def = 0x0000, nextdef = 0x0000; 244 int err = 0; 245 246 OPT_HELP(0, NULL); 247 248 printf("Build definitions:\n"); 249 250 while (1) { 251 memset(array, 0, sizeof(array)); 252 array[0] = def & 0xff; 253 array[1] = def >> 8; 254 255 err = transport_read(transport, CSR_VARID_GET_NEXT_BUILDDEF, array, 8); 256 if (err < 0) { 257 errno = -err; 258 break; 259 } 260 261 nextdef = array[2] | (array[3] << 8); 262 263 if (nextdef == 0x0000) 264 break; 265 266 def = nextdef; 267 268 printf("0x%04x - %s\n", def, csr_builddeftostr(def)); 269 } 270 271 return err; 272 } 273 274 static int cmd_keylen(int transport, int argc, char *argv[]) 275 { 276 uint8_t array[8]; 277 uint16_t handle, keylen; 278 int err; 279 280 OPT_HELP(1, NULL); 281 282 handle = atoi(argv[0]); 283 284 memset(array, 0, sizeof(array)); 285 array[0] = handle & 0xff; 286 array[1] = handle >> 8; 287 288 err = transport_read(transport, CSR_VARID_CRYPT_KEY_LENGTH, array, 8); 289 if (err < 0) { 290 errno = -err; 291 return -1; 292 } 293 294 handle = array[0] | (array[1] << 8); 295 keylen = array[2] | (array[3] << 8); 296 297 printf("Crypt key length: %d bit\n", keylen * 8); 298 299 return 0; 300 } 301 302 static int cmd_clock(int transport, int argc, char *argv[]) 303 { 304 uint8_t array[8]; 305 uint32_t clock; 306 int err; 307 308 OPT_HELP(0, NULL); 309 310 memset(array, 0, sizeof(array)); 311 312 err = transport_read(transport, CSR_VARID_BT_CLOCK, array, 8); 313 if (err < 0) { 314 errno = -err; 315 return -1; 316 } 317 318 clock = array[2] | (array[3] << 8) | (array[0] << 16) | (array[1] << 24); 319 320 printf("Bluetooth clock: 0x%04x (%d)\n", clock, clock); 321 322 return 0; 323 } 324 325 static int cmd_rand(int transport, int argc, char *argv[]) 326 { 327 uint8_t array[8]; 328 uint16_t rand; 329 int err; 330 331 OPT_HELP(0, NULL); 332 333 memset(array, 0, sizeof(array)); 334 335 err = transport_read(transport, CSR_VARID_RAND, array, 8); 336 if (err < 0) { 337 errno = -err; 338 return -1; 339 } 340 341 rand = array[0] | (array[1] << 8); 342 343 printf("Random number: 0x%02x (%d)\n", rand, rand); 344 345 return 0; 346 } 347 348 static int cmd_chiprev(int transport, int argc, char *argv[]) 349 { 350 uint8_t array[8]; 351 uint16_t rev; 352 char *str; 353 int err; 354 355 OPT_HELP(0, NULL); 356 357 memset(array, 0, sizeof(array)); 358 359 err = transport_read(transport, CSR_VARID_CHIPREV, array, 8); 360 if (err < 0) { 361 errno = -err; 362 return -1; 363 } 364 365 rev = array[0] | (array[1] << 8); 366 367 switch (rev) { 368 case 0x64: 369 str = "BC1 ES"; 370 break; 371 case 0x65: 372 str = "BC1"; 373 break; 374 case 0x89: 375 str = "BC2-External A"; 376 break; 377 case 0x8a: 378 str = "BC2-External B"; 379 break; 380 case 0x28: 381 str = "BC2-ROM"; 382 break; 383 case 0x43: 384 str = "BC3-Multimedia"; 385 break; 386 case 0x15: 387 str = "BC3-ROM"; 388 break; 389 case 0xe2: 390 str = "BC3-Flash"; 391 break; 392 case 0x26: 393 str = "BC4-External"; 394 break; 395 case 0x30: 396 str = "BC4-ROM"; 397 break; 398 default: 399 str = "NA"; 400 break; 401 } 402 403 printf("Chip revision: 0x%04x (%s)\n", rev, str); 404 405 return 0; 406 } 407 408 static int cmd_buildname(int transport, int argc, char *argv[]) 409 { 410 uint8_t array[130]; 411 char name[64]; 412 unsigned int i; 413 int err; 414 415 OPT_HELP(0, NULL); 416 417 memset(array, 0, sizeof(array)); 418 419 err = transport_read(transport, CSR_VARID_READ_BUILD_NAME, array, 128); 420 if (err < 0) { 421 errno = -err; 422 return -1; 423 } 424 425 for (i = 0; i < sizeof(name); i++) 426 name[i] = array[(i * 2) + 4]; 427 428 printf("Build name: %s\n", name); 429 430 return 0; 431 } 432 433 static int cmd_panicarg(int transport, int argc, char *argv[]) 434 { 435 uint8_t array[8]; 436 uint16_t error; 437 int err; 438 439 OPT_HELP(0, NULL); 440 441 memset(array, 0, sizeof(array)); 442 443 err = transport_read(transport, CSR_VARID_PANIC_ARG, array, 8); 444 if (err < 0) { 445 errno = -err; 446 return -1; 447 } 448 449 error = array[0] | (array[1] << 8); 450 451 printf("Panic code: 0x%02x (%s)\n", error, 452 error < 0x100 ? "valid" : "invalid"); 453 454 return 0; 455 } 456 457 static int cmd_faultarg(int transport, int argc, char *argv[]) 458 { 459 uint8_t array[8]; 460 uint16_t error; 461 int err; 462 463 OPT_HELP(0, NULL); 464 465 memset(array, 0, sizeof(array)); 466 467 err = transport_read(transport, CSR_VARID_FAULT_ARG, array, 8); 468 if (err < 0) { 469 errno = -err; 470 return -1; 471 } 472 473 error = array[0] | (array[1] << 8); 474 475 printf("Fault code: 0x%02x (%s)\n", error, 476 error < 0x100 ? "valid" : "invalid"); 477 478 return 0; 479 } 480 481 static int cmd_coldreset(int transport, int argc, char *argv[]) 482 { 483 return transport_write(transport, CSR_VARID_COLD_RESET, NULL, 0); 484 } 485 486 static int cmd_warmreset(int transport, int argc, char *argv[]) 487 { 488 return transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0); 489 } 490 491 static int cmd_disabletx(int transport, int argc, char *argv[]) 492 { 493 return transport_write(transport, CSR_VARID_DISABLE_TX, NULL, 0); 494 } 495 496 static int cmd_enabletx(int transport, int argc, char *argv[]) 497 { 498 return transport_write(transport, CSR_VARID_ENABLE_TX, NULL, 0); 499 } 500 501 static int cmd_singlechan(int transport, int argc, char *argv[]) 502 { 503 uint8_t array[8]; 504 uint16_t channel; 505 506 OPT_HELP(1, NULL); 507 508 channel = atoi(argv[0]); 509 510 if (channel > 2401 && channel < 2481) 511 channel -= 2402; 512 513 if (channel > 78) { 514 errno = EINVAL; 515 return -1; 516 } 517 518 memset(array, 0, sizeof(array)); 519 array[0] = channel & 0xff; 520 array[1] = channel >> 8; 521 522 return transport_write(transport, CSR_VARID_SINGLE_CHAN, array, 8); 523 } 524 525 static int cmd_hoppingon(int transport, int argc, char *argv[]) 526 { 527 return transport_write(transport, CSR_VARID_HOPPING_ON, NULL, 0); 528 } 529 530 static int cmd_rttxdata1(int transport, int argc, char *argv[]) 531 { 532 uint8_t array[8]; 533 uint16_t freq, level; 534 535 OPT_HELP(2, NULL); 536 537 freq = atoi(argv[0]); 538 539 if (!strncasecmp(argv[1], "0x", 2)) 540 level = strtol(argv[1], NULL, 16); 541 else 542 level = atoi(argv[1]); 543 544 memset(array, 0, sizeof(array)); 545 array[0] = 0x04; 546 array[1] = 0x00; 547 array[2] = freq & 0xff; 548 array[3] = freq >> 8; 549 array[4] = level & 0xff; 550 array[5] = level >> 8; 551 552 return transport_write(transport, CSR_VARID_RADIOTEST, array, 8); 553 } 554 555 static int cmd_radiotest(int transport, int argc, char *argv[]) 556 { 557 uint8_t array[8]; 558 uint16_t freq, level, test; 559 560 OPT_HELP(3, NULL); 561 562 freq = atoi(argv[0]); 563 564 if (!strncasecmp(argv[1], "0x", 2)) 565 level = strtol(argv[1], NULL, 16); 566 else 567 level = atoi(argv[1]); 568 569 test = atoi(argv[2]); 570 571 memset(array, 0, sizeof(array)); 572 array[0] = test & 0xff; 573 array[1] = test >> 8; 574 array[2] = freq & 0xff; 575 array[3] = freq >> 8; 576 array[4] = level & 0xff; 577 array[5] = level >> 8; 578 579 return transport_write(transport, CSR_VARID_RADIOTEST, array, 8); 580 } 581 582 static int cmd_memtypes(int transport, int argc, char *argv[]) 583 { 584 uint8_t array[8]; 585 uint16_t type, stores[4] = { 0x0001, 0x0002, 0x0004, 0x0008 }; 586 int i, err; 587 588 OPT_HELP(0, NULL); 589 590 for (i = 0; i < 4; i++) { 591 memset(array, 0, sizeof(array)); 592 array[0] = stores[i] & 0xff; 593 array[1] = stores[i] >> 8; 594 595 err = transport_read(transport, CSR_VARID_PS_MEMORY_TYPE, array, 8); 596 if (err < 0) 597 continue; 598 599 type = array[2] + (array[3] << 8); 600 601 printf("%s (0x%04x) = %s (%d)\n", storestostr(stores[i]), 602 stores[i], memorytostr(type), type); 603 } 604 605 return 0; 606 } 607 608 static struct option pskey_options[] = { 609 { "stores", 1, 0, 's' }, 610 { "reset", 0, 0, 'r' }, 611 { "help", 0, 0, 'h' }, 612 { 0, 0, 0, 0 } 613 }; 614 615 static int opt_pskey(int argc, char *argv[], uint16_t *stores, int *reset, int *help) 616 { 617 int opt; 618 619 while ((opt=getopt_long(argc, argv, "+s:rh", pskey_options, NULL)) != EOF) { 620 switch (opt) { 621 case 's': 622 if (!stores) 623 break; 624 if (!strcasecmp(optarg, "default")) 625 *stores = 0x0000; 626 else if (!strcasecmp(optarg, "implementation")) 627 *stores = 0x0001; 628 else if (!strcasecmp(optarg, "factory")) 629 *stores = 0x0002; 630 else if (!strcasecmp(optarg, "rom")) 631 *stores = 0x0004; 632 else if (!strcasecmp(optarg, "ram")) 633 *stores = 0x0008; 634 else if (!strcasecmp(optarg, "psi")) 635 *stores = 0x0001; 636 else if (!strcasecmp(optarg, "psf")) 637 *stores = 0x0002; 638 else if (!strcasecmp(optarg, "psrom")) 639 *stores = 0x0004; 640 else if (!strcasecmp(optarg, "psram")) 641 *stores = 0x0008; 642 else if (!strncasecmp(optarg, "0x", 2)) 643 *stores = strtol(optarg, NULL, 16); 644 else 645 *stores = atoi(optarg); 646 break; 647 648 case 'r': 649 if (reset) 650 *reset = 1; 651 break; 652 653 case 'h': 654 if (help) 655 *help = 1; 656 break; 657 } 658 } 659 660 return optind; 661 } 662 663 #define OPT_PSKEY(min, max, stores, reset, help) \ 664 opt_pskey(argc, argv, (stores), (reset), (help)); \ 665 argc -= optind; argv += optind; optind = 0; \ 666 OPT_RANGE((min), (max)) 667 668 static int cmd_psget(int transport, int argc, char *argv[]) 669 { 670 uint8_t array[128]; 671 uint16_t pskey, length, value, stores = CSR_STORES_DEFAULT; 672 uint32_t val32; 673 int i, err, reset = 0; 674 675 memset(array, 0, sizeof(array)); 676 677 OPT_PSKEY(1, 1, &stores, &reset, NULL); 678 679 if (strncasecmp(argv[0], "0x", 2)) { 680 pskey = atoi(argv[0]); 681 682 for (i = 0; storage[i].pskey; i++) { 683 if (strcasecmp(storage[i].str, argv[0])) 684 continue; 685 686 pskey = storage[i].pskey; 687 break; 688 } 689 } else 690 pskey = strtol(argv[0] + 2, NULL, 16); 691 692 memset(array, 0, sizeof(array)); 693 array[0] = pskey & 0xff; 694 array[1] = pskey >> 8; 695 array[2] = stores & 0xff; 696 array[3] = stores >> 8; 697 698 err = transport_read(transport, CSR_VARID_PS_SIZE, array, 8); 699 if (err < 0) 700 return err; 701 702 length = array[2] + (array[3] << 8); 703 if (length + 6 > (int) sizeof(array) / 2) 704 return -EIO; 705 706 memset(array, 0, sizeof(array)); 707 array[0] = pskey & 0xff; 708 array[1] = pskey >> 8; 709 array[2] = length & 0xff; 710 array[3] = length >> 8; 711 array[4] = stores & 0xff; 712 array[5] = stores >> 8; 713 714 err = transport_read(transport, CSR_VARID_PS, array, (length + 3) * 2); 715 if (err < 0) 716 return err; 717 718 switch (length) { 719 case 1: 720 value = array[6] | (array[7] << 8); 721 printf("%s: 0x%04x (%d)\n", csr_pskeytostr(pskey), value, value); 722 break; 723 724 case 2: 725 val32 = array[8] | (array[9] << 8) | (array[6] << 16) | (array[7] << 24); 726 printf("%s: 0x%08x (%d)\n", csr_pskeytostr(pskey), val32, val32); 727 break; 728 729 default: 730 printf("%s:", csr_pskeytostr(pskey)); 731 for (i = 0; i < length; i++) 732 printf(" 0x%02x%02x", array[(i * 2) + 6], array[(i * 2) + 7]); 733 printf("\n"); 734 break; 735 } 736 737 if (reset) 738 transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0); 739 740 return err; 741 } 742 743 static int cmd_psset(int transport, int argc, char *argv[]) 744 { 745 uint8_t array[128]; 746 uint16_t pskey, length, value, stores = CSR_STORES_PSRAM; 747 uint32_t val32; 748 int i, err, reset = 0; 749 750 memset(array, 0, sizeof(array)); 751 752 OPT_PSKEY(2, 81, &stores, &reset, NULL); 753 754 if (strncasecmp(argv[0], "0x", 2)) { 755 pskey = atoi(argv[0]); 756 757 for (i = 0; storage[i].pskey; i++) { 758 if (strcasecmp(storage[i].str, argv[0])) 759 continue; 760 761 pskey = storage[i].pskey; 762 break; 763 } 764 } else 765 pskey = strtol(argv[0] + 2, NULL, 16); 766 767 memset(array, 0, sizeof(array)); 768 array[0] = pskey & 0xff; 769 array[1] = pskey >> 8; 770 array[2] = stores & 0xff; 771 array[3] = stores >> 8; 772 773 err = transport_read(transport, CSR_VARID_PS_SIZE, array, 8); 774 if (err < 0) 775 return err; 776 777 length = array[2] + (array[3] << 8); 778 if (length + 6 > (int) sizeof(array) / 2) 779 return -EIO; 780 781 memset(array, 0, sizeof(array)); 782 array[0] = pskey & 0xff; 783 array[1] = pskey >> 8; 784 array[2] = length & 0xff; 785 array[3] = length >> 8; 786 array[4] = stores & 0xff; 787 array[5] = stores >> 8; 788 789 argc--; 790 argv++; 791 792 switch (length) { 793 case 1: 794 if (argc != 1) { 795 errno = E2BIG; 796 return -1; 797 } 798 799 if (!strncasecmp(argv[0], "0x", 2)) 800 value = strtol(argv[0] + 2, NULL, 16); 801 else 802 value = atoi(argv[0]); 803 804 array[6] = value & 0xff; 805 array[7] = value >> 8; 806 break; 807 808 case 2: 809 if (argc != 1) { 810 errno = E2BIG; 811 return -1; 812 } 813 814 if (!strncasecmp(argv[0], "0x", 2)) 815 val32 = strtol(argv[0] + 2, NULL, 16); 816 else 817 val32 = atoi(argv[0]); 818 819 array[6] = (val32 & 0xff0000) >> 16; 820 array[7] = val32 >> 24; 821 array[8] = val32 & 0xff; 822 array[9] = (val32 & 0xff00) >> 8; 823 break; 824 825 default: 826 if (argc != length * 2) { 827 errno = EINVAL; 828 return -1; 829 } 830 831 for (i = 0; i < length * 2; i++) 832 if (!strncasecmp(argv[0], "0x", 2)) 833 array[i + 6] = strtol(argv[i] + 2, NULL, 16); 834 else 835 array[i + 6] = atoi(argv[i]); 836 break; 837 } 838 839 err = transport_write(transport, CSR_VARID_PS, array, (length + 3) * 2); 840 if (err < 0) 841 return err; 842 843 if (reset) 844 transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0); 845 846 return err; 847 } 848 849 static int cmd_psclr(int transport, int argc, char *argv[]) 850 { 851 uint8_t array[8]; 852 uint16_t pskey, stores = CSR_STORES_PSRAM; 853 int i, err, reset = 0; 854 855 OPT_PSKEY(1, 1, &stores, &reset, NULL); 856 857 if (strncasecmp(argv[0], "0x", 2)) { 858 pskey = atoi(argv[0]); 859 860 for (i = 0; storage[i].pskey; i++) { 861 if (strcasecmp(storage[i].str, argv[0])) 862 continue; 863 864 pskey = storage[i].pskey; 865 break; 866 } 867 } else 868 pskey = strtol(argv[0] + 2, NULL, 16); 869 870 memset(array, 0, sizeof(array)); 871 array[0] = pskey & 0xff; 872 array[1] = pskey >> 8; 873 array[2] = stores & 0xff; 874 array[3] = stores >> 8; 875 876 err = transport_write(transport, CSR_VARID_PS_CLR_STORES, array, 8); 877 if (err < 0) 878 return err; 879 880 if (reset) 881 transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0); 882 883 return err; 884 } 885 886 static int cmd_pslist(int transport, int argc, char *argv[]) 887 { 888 uint8_t array[8]; 889 uint16_t pskey = 0x0000, length, stores = CSR_STORES_DEFAULT; 890 int err, reset = 0; 891 892 OPT_PSKEY(0, 0, &stores, &reset, NULL); 893 894 while (1) { 895 memset(array, 0, sizeof(array)); 896 array[0] = pskey & 0xff; 897 array[1] = pskey >> 8; 898 array[2] = stores & 0xff; 899 array[3] = stores >> 8; 900 901 err = transport_read(transport, CSR_VARID_PS_NEXT, array, 8); 902 if (err < 0) 903 break; 904 905 pskey = array[4] + (array[5] << 8); 906 if (pskey == 0x0000) 907 break; 908 909 memset(array, 0, sizeof(array)); 910 array[0] = pskey & 0xff; 911 array[1] = pskey >> 8; 912 array[2] = stores & 0xff; 913 array[3] = stores >> 8; 914 915 err = transport_read(transport, CSR_VARID_PS_SIZE, array, 8); 916 if (err < 0) 917 continue; 918 919 length = array[2] + (array[3] << 8); 920 921 printf("0x%04x - %s (%d bytes)\n", pskey, 922 csr_pskeytostr(pskey), length * 2); 923 } 924 925 if (reset) 926 transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0); 927 928 return 0; 929 } 930 931 static int cmd_psread(int transport, int argc, char *argv[]) 932 { 933 uint8_t array[256]; 934 uint16_t pskey = 0x0000, length, stores = CSR_STORES_DEFAULT; 935 char *str, val[7]; 936 int i, err, reset = 0; 937 938 OPT_PSKEY(0, 0, &stores, &reset, NULL); 939 940 while (1) { 941 memset(array, 0, sizeof(array)); 942 array[0] = pskey & 0xff; 943 array[1] = pskey >> 8; 944 array[2] = stores & 0xff; 945 array[3] = stores >> 8; 946 947 err = transport_read(transport, CSR_VARID_PS_NEXT, array, 8); 948 if (err < 0) 949 break; 950 951 pskey = array[4] + (array[5] << 8); 952 if (pskey == 0x0000) 953 break; 954 955 memset(array, 0, sizeof(array)); 956 array[0] = pskey & 0xff; 957 array[1] = pskey >> 8; 958 array[2] = stores & 0xff; 959 array[3] = stores >> 8; 960 961 err = transport_read(transport, CSR_VARID_PS_SIZE, array, 8); 962 if (err < 0) 963 continue; 964 965 length = array[2] + (array[3] << 8); 966 if (length + 6 > (int) sizeof(array) / 2) 967 continue; 968 969 memset(array, 0, sizeof(array)); 970 array[0] = pskey & 0xff; 971 array[1] = pskey >> 8; 972 array[2] = length & 0xff; 973 array[3] = length >> 8; 974 array[4] = stores & 0xff; 975 array[5] = stores >> 8; 976 977 err = transport_read(transport, CSR_VARID_PS, array, (length + 3) * 2); 978 if (err < 0) 979 continue; 980 981 str = csr_pskeytoval(pskey); 982 if (!strcasecmp(str, "UNKNOWN")) { 983 sprintf(val, "0x%04x", pskey); 984 str = NULL; 985 } 986 987 printf("// %s%s\n&%04x =", str ? "PSKEY_" : "", 988 str ? str : val, pskey); 989 for (i = 0; i < length; i++) 990 printf(" %02x%02x", array[(i * 2) + 7], array[(i * 2) + 6]); 991 printf("\n"); 992 } 993 994 if (reset) 995 transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0); 996 997 return 0; 998 } 999 1000 static int cmd_psload(int transport, int argc, char *argv[]) 1001 { 1002 uint8_t array[256]; 1003 uint16_t pskey, length, size, stores = CSR_STORES_PSRAM; 1004 char *str, val[7]; 1005 int err, reset = 0; 1006 1007 OPT_PSKEY(1, 1, &stores, &reset, NULL); 1008 1009 psr_read(argv[0]); 1010 1011 memset(array, 0, sizeof(array)); 1012 size = sizeof(array) - 6; 1013 1014 while (psr_get(&pskey, array + 6, &size) == 0) { 1015 str = csr_pskeytoval(pskey); 1016 if (!strcasecmp(str, "UNKNOWN")) { 1017 sprintf(val, "0x%04x", pskey); 1018 str = NULL; 1019 } 1020 1021 printf("Loading %s%s ... ", str ? "PSKEY_" : "", 1022 str ? str : val); 1023 fflush(stdout); 1024 1025 length = size / 2; 1026 1027 array[0] = pskey & 0xff; 1028 array[1] = pskey >> 8; 1029 array[2] = length & 0xff; 1030 array[3] = length >> 8; 1031 array[4] = stores & 0xff; 1032 array[5] = stores >> 8; 1033 1034 err = transport_write(transport, CSR_VARID_PS, array, size + 6); 1035 1036 printf("%s\n", err < 0 ? "failed" : "done"); 1037 1038 memset(array, 0, sizeof(array)); 1039 size = sizeof(array) - 6; 1040 } 1041 1042 if (reset) 1043 transport_write(transport, CSR_VARID_WARM_RESET, NULL, 0); 1044 1045 return 0; 1046 } 1047 1048 static int cmd_pscheck(int transport, int argc, char *argv[]) 1049 { 1050 uint8_t array[256]; 1051 uint16_t pskey, size; 1052 int i; 1053 1054 OPT_HELP(1, NULL); 1055 1056 psr_read(argv[0]); 1057 1058 while (psr_get(&pskey, array, &size) == 0) { 1059 printf("0x%04x =", pskey); 1060 for (i = 0; i < size; i++) 1061 printf(" 0x%02x", array[i]); 1062 printf("\n"); 1063 } 1064 1065 return 0; 1066 } 1067 1068 static struct { 1069 char *str; 1070 int (*func)(int transport, int argc, char *argv[]); 1071 char *arg; 1072 char *doc; 1073 } commands[] = { 1074 { "builddef", cmd_builddef, "", "Get build definitions" }, 1075 { "keylen", cmd_keylen, "<handle>", "Get current crypt key length" }, 1076 { "clock", cmd_clock, "", "Get local Bluetooth clock" }, 1077 { "rand", cmd_rand, "", "Get random number" }, 1078 { "chiprev", cmd_chiprev, "", "Get chip revision" }, 1079 { "buildname", cmd_buildname, "", "Get the full build name" }, 1080 { "panicarg", cmd_panicarg, "", "Get panic code argument" }, 1081 { "faultarg", cmd_faultarg, "", "Get fault code argument" }, 1082 { "coldreset", cmd_coldreset, "", "Perform cold reset" }, 1083 { "warmreset", cmd_warmreset, "", "Perform warm reset" }, 1084 { "disabletx", cmd_disabletx, "", "Disable TX on the device" }, 1085 { "enabletx", cmd_enabletx, "", "Enable TX on the device" }, 1086 { "singlechan",cmd_singlechan,"<channel>", "Lock radio on specific channel" }, 1087 { "hoppingon", cmd_hoppingon, "", "Revert to channel hopping" }, 1088 { "rttxdata1", cmd_rttxdata1, "<freq> <level>", "TXData1 radio test" }, 1089 { "radiotest", cmd_radiotest, "<freq> <level> <id>", "Run radio tests" }, 1090 { "memtypes", cmd_memtypes, NULL, "Get memory types" }, 1091 { "psget", cmd_psget, "<key>", "Get value for PS key" }, 1092 { "psset", cmd_psset, "<key> <value>", "Set value for PS key" }, 1093 { "psclr", cmd_psclr, "<key>", "Clear value for PS key" }, 1094 { "pslist", cmd_pslist, NULL, "List all PS keys" }, 1095 { "psread", cmd_psread, NULL, "Read all PS keys" }, 1096 { "psload", cmd_psload, "<file>", "Load all PS keys from PSR file" }, 1097 { "pscheck", cmd_pscheck, "<file>", "Check PSR file" }, 1098 { NULL } 1099 }; 1100 1101 static void usage(void) 1102 { 1103 int i, pos = 0; 1104 1105 printf("bccmd - Utility for the CSR BCCMD interface\n\n"); 1106 printf("Usage:\n" 1107 "\tbccmd [options] <command>\n\n"); 1108 1109 printf("Options:\n" 1110 "\t-t <transport> Select the transport\n" 1111 "\t-d <device> Select the device\n" 1112 "\t-h, --help Display help\n" 1113 "\n"); 1114 1115 printf("Transports:\n" 1116 "\tHCI USB BCSP H4 3WIRE\n\n"); 1117 1118 printf("Commands:\n"); 1119 for (i = 0; commands[i].str; i++) 1120 printf("\t%-10s %-20s\t%s\n", commands[i].str, 1121 commands[i].arg ? commands[i].arg : " ", 1122 commands[i].doc); 1123 printf("\n"); 1124 1125 printf("Keys:\n\t"); 1126 for (i = 0; storage[i].pskey; i++) { 1127 printf("%s ", storage[i].str); 1128 pos += strlen(storage[i].str) + 1; 1129 if (pos > 60) { 1130 printf("\n\t"); 1131 pos = 0; 1132 } 1133 } 1134 printf("\n"); 1135 } 1136 1137 static struct option main_options[] = { 1138 { "transport", 1, 0, 't' }, 1139 { "device", 1, 0, 'd' }, 1140 { "help", 0, 0, 'h' }, 1141 { 0, 0, 0, 0 } 1142 }; 1143 1144 int main(int argc, char *argv[]) 1145 { 1146 char *device = NULL; 1147 int i, err, opt, transport = CSR_TRANSPORT_HCI; 1148 1149 while ((opt=getopt_long(argc, argv, "+t:d:i:h", main_options, NULL)) != EOF) { 1150 switch (opt) { 1151 case 't': 1152 if (!strcasecmp(optarg, "hci")) 1153 transport = CSR_TRANSPORT_HCI; 1154 else if (!strcasecmp(optarg, "usb")) 1155 transport = CSR_TRANSPORT_USB; 1156 else if (!strcasecmp(optarg, "bcsp")) 1157 transport = CSR_TRANSPORT_BCSP; 1158 else if (!strcasecmp(optarg, "h4")) 1159 transport = CSR_TRANSPORT_H4; 1160 else if (!strcasecmp(optarg, "h5")) 1161 transport = CSR_TRANSPORT_3WIRE; 1162 else if (!strcasecmp(optarg, "3wire")) 1163 transport = CSR_TRANSPORT_3WIRE; 1164 else if (!strcasecmp(optarg, "twutl")) 1165 transport = CSR_TRANSPORT_3WIRE; 1166 else 1167 transport = CSR_TRANSPORT_UNKNOWN; 1168 break; 1169 1170 case 'd': 1171 case 'i': 1172 device = strdup(optarg); 1173 break; 1174 1175 case 'h': 1176 default: 1177 usage(); 1178 exit(0); 1179 } 1180 } 1181 1182 argc -= optind; 1183 argv += optind; 1184 optind = 0; 1185 1186 if (argc < 1) { 1187 usage(); 1188 exit(1); 1189 } 1190 1191 if (transport_open(transport, device) < 0) 1192 exit(1); 1193 1194 if (device) 1195 free(device); 1196 1197 for (i = 0; commands[i].str; i++) { 1198 if (strcasecmp(commands[i].str, argv[0])) 1199 continue; 1200 1201 err = commands[i].func(transport, argc, argv); 1202 1203 transport_close(transport); 1204 1205 if (err < 0) { 1206 fprintf(stderr, "Can't execute command: %s (%d)\n", 1207 strerror(errno), errno); 1208 exit(1); 1209 } 1210 1211 exit(0); 1212 } 1213 1214 fprintf(stderr, "Unsupported command\n"); 1215 1216 transport_close(transport); 1217 1218 exit(1); 1219 } 1220
