1107120Sjulian/* 2107120Sjulian * host_controller_baseband.c 3107120Sjulian * 4107120Sjulian * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> 5107120Sjulian * All rights reserved. 6107120Sjulian * 7107120Sjulian * Redistribution and use in source and binary forms, with or without 8107120Sjulian * modification, are permitted provided that the following conditions 9107120Sjulian * are met: 10107120Sjulian * 1. Redistributions of source code must retain the above copyright 11107120Sjulian * notice, this list of conditions and the following disclaimer. 12107120Sjulian * 2. Redistributions in binary form must reproduce the above copyright 13107120Sjulian * notice, this list of conditions and the following disclaimer in the 14107120Sjulian * documentation and/or other materials provided with the distribution. 15107120Sjulian * 16107120Sjulian * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17107120Sjulian * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18107120Sjulian * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19107120Sjulian * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20107120Sjulian * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21107120Sjulian * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22107120Sjulian * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23107120Sjulian * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24107120Sjulian * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25107120Sjulian * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26107120Sjulian * SUCH DAMAGE. 27107120Sjulian * 28121054Semax * $Id: host_controller_baseband.c,v 1.4 2003/08/18 19:19:53 max Exp $ 29107120Sjulian * $FreeBSD$ 30107120Sjulian */ 31107120Sjulian 32121054Semax#include <bluetooth.h> 33107120Sjulian#include <errno.h> 34107120Sjulian#include <stdio.h> 35107120Sjulian#include <string.h> 36107120Sjulian#include "hccontrol.h" 37107120Sjulian 38107120Sjulian/* Convert hex ASCII to int4 */ 39107120Sjulianstatic int 40107120Sjulianhci_hexa2int4(const char *a) 41107120Sjulian{ 42107120Sjulian if ('0' <= *a && *a <= '9') 43107120Sjulian return (*a - '0'); 44107120Sjulian 45107120Sjulian if ('A' <= *a && *a <= 'F') 46107120Sjulian return (*a - 'A' + 0xa); 47107120Sjulian 48107120Sjulian if ('a' <= *a && *a <= 'f') 49107120Sjulian return (*a - 'a' + 0xa); 50107120Sjulian 51107120Sjulian return (-1); 52107120Sjulian} 53107120Sjulian 54107120Sjulian/* Convert hex ASCII to int8 */ 55107120Sjulianstatic int 56107120Sjulianhci_hexa2int8(const char *a) 57107120Sjulian{ 58107120Sjulian int hi = hci_hexa2int4(a); 59107120Sjulian int lo = hci_hexa2int4(a + 1); 60107120Sjulian 61107120Sjulian if (hi < 0 || lo < 0) 62107120Sjulian return (-1); 63107120Sjulian 64107120Sjulian return ((hi << 4) | lo); 65107120Sjulian} 66107120Sjulian 67128079Semax/* Convert ascii hex string to the uint8_t[] */ 68107120Sjulianstatic int 69128079Semaxhci_hexstring2array(char const *s, uint8_t *a, int asize) 70107120Sjulian{ 71107120Sjulian int i, l, b; 72107120Sjulian 73107120Sjulian l = strlen(s) / 2; 74107120Sjulian if (l > asize) 75107120Sjulian l = asize; 76107120Sjulian 77107120Sjulian for (i = 0; i < l; i++) { 78107120Sjulian b = hci_hexa2int8(s + i * 2); 79107120Sjulian if (b < 0) 80107120Sjulian return (-1); 81107120Sjulian 82107120Sjulian a[i] = (b & 0xff); 83107120Sjulian } 84107120Sjulian 85107120Sjulian return (0); 86107120Sjulian} 87107120Sjulian 88107120Sjulian/* Send RESET to the unit */ 89107120Sjulianstatic int 90107120Sjulianhci_reset(int s, int argc, char **argv) 91107120Sjulian{ 92107120Sjulian ng_hci_status_rp rp; 93107120Sjulian int n; 94107120Sjulian 95107120Sjulian n = sizeof(rp); 96107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 97107120Sjulian NG_HCI_OCF_RESET), (char *) &rp, &n) == ERROR) 98107120Sjulian return (ERROR); 99107120Sjulian 100107120Sjulian if (rp.status != 0x00) { 101107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 102107120Sjulian hci_status2str(rp.status), rp.status); 103107120Sjulian return (FAILED); 104107120Sjulian } 105107120Sjulian 106107120Sjulian return (OK); 107107120Sjulian} /* hci_reset */ 108107120Sjulian 109107120Sjulian/* Send Read_PIN_Type command to the unit */ 110107120Sjulianstatic int 111107120Sjulianhci_read_pin_type(int s, int argc, char **argv) 112107120Sjulian{ 113107120Sjulian ng_hci_read_pin_type_rp rp; 114107120Sjulian int n; 115107120Sjulian 116107120Sjulian n = sizeof(rp); 117107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 118107120Sjulian NG_HCI_OCF_READ_PIN_TYPE), 119107120Sjulian (char *) &rp, &n) == ERROR) 120107120Sjulian return (ERROR); 121107120Sjulian 122107120Sjulian if (rp.status != 0x00) { 123107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 124107120Sjulian hci_status2str(rp.status), rp.status); 125107120Sjulian return (FAILED); 126107120Sjulian } 127107120Sjulian 128107120Sjulian fprintf(stdout, "PIN type: %s [%#02x]\n", 129107120Sjulian hci_pin2str(rp.pin_type), rp.pin_type); 130107120Sjulian 131107120Sjulian return (OK); 132107120Sjulian} /* hci_read_pin_type */ 133107120Sjulian 134107120Sjulian/* Send Write_PIN_Type command to the unit */ 135107120Sjulianstatic int 136107120Sjulianhci_write_pin_type(int s, int argc, char **argv) 137107120Sjulian{ 138107120Sjulian ng_hci_write_pin_type_cp cp; 139107120Sjulian ng_hci_write_pin_type_rp rp; 140107120Sjulian int n; 141107120Sjulian 142107120Sjulian /* parse command parameters */ 143107120Sjulian switch (argc) { 144107120Sjulian case 1: 145107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 1) 146107120Sjulian return (USAGE); 147107120Sjulian 148128079Semax cp.pin_type = (uint8_t) n; 149107120Sjulian break; 150107120Sjulian 151107120Sjulian default: 152107120Sjulian return (USAGE); 153107120Sjulian } 154107120Sjulian 155107120Sjulian /* send command */ 156107120Sjulian n = sizeof(rp); 157107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 158107120Sjulian NG_HCI_OCF_WRITE_PIN_TYPE), 159107120Sjulian (char const *) &cp, sizeof(cp), 160107120Sjulian (char *) &rp , &n) == ERROR) 161107120Sjulian return (ERROR); 162107120Sjulian 163107120Sjulian if (rp.status != 0x00) { 164107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 165107120Sjulian hci_status2str(rp.status), rp.status); 166107120Sjulian return (FAILED); 167107120Sjulian } 168107120Sjulian 169107120Sjulian return (OK); 170107120Sjulian} /* hci_write_pin_type */ 171107120Sjulian 172107120Sjulian/* Send Read_Stored_Link_Key command to the unit */ 173107120Sjulianstatic int 174107120Sjulianhci_read_stored_link_key(int s, int argc, char **argv) 175107120Sjulian{ 176107120Sjulian struct { 177107120Sjulian ng_hci_cmd_pkt_t hdr; 178107120Sjulian ng_hci_read_stored_link_key_cp cp; 179107120Sjulian } __attribute__ ((packed)) cmd; 180107120Sjulian 181107120Sjulian struct { 182107120Sjulian ng_hci_event_pkt_t hdr; 183107120Sjulian union { 184107120Sjulian ng_hci_command_compl_ep cc; 185107120Sjulian ng_hci_return_link_keys_ep key; 186128079Semax uint8_t b[NG_HCI_EVENT_PKT_SIZE]; 187107120Sjulian } ep; 188107120Sjulian } __attribute__ ((packed)) event; 189107120Sjulian 190121054Semax int n, n1; 191107120Sjulian 192107120Sjulian /* Send command */ 193107120Sjulian memset(&cmd, 0, sizeof(cmd)); 194107120Sjulian cmd.hdr.type = NG_HCI_CMD_PKT; 195107120Sjulian cmd.hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 196107120Sjulian NG_HCI_OCF_READ_STORED_LINK_KEY)); 197107120Sjulian cmd.hdr.length = sizeof(cmd.cp); 198107120Sjulian 199107120Sjulian switch (argc) { 200107120Sjulian case 1: 201107120Sjulian /* parse BD_ADDR */ 202121054Semax if (!bt_aton(argv[0], &cmd.cp.bdaddr)) { 203121054Semax struct hostent *he = NULL; 204107120Sjulian 205121054Semax if ((he = bt_gethostbyname(argv[0])) == NULL) 206121054Semax return (USAGE); 207121054Semax 208121054Semax memcpy(&cmd.cp.bdaddr, he->h_addr, sizeof(cmd.cp.bdaddr)); 209121054Semax } 210107120Sjulian break; 211107120Sjulian 212107120Sjulian default: 213107120Sjulian cmd.cp.read_all = 1; 214107120Sjulian break; 215107120Sjulian } 216107120Sjulian 217107120Sjulian if (hci_send(s, (char const *) &cmd, sizeof(cmd)) != OK) 218107120Sjulian return (ERROR); 219107120Sjulian 220107120Sjulian /* Receive events */ 221107120Sjulianagain: 222107120Sjulian memset(&event, 0, sizeof(event)); 223107120Sjulian n = sizeof(event); 224107120Sjulian if (hci_recv(s, (char *) &event, &n) != OK) 225107120Sjulian return (ERROR); 226107120Sjulian 227107120Sjulian if (n <= sizeof(event.hdr)) { 228107120Sjulian errno = EMSGSIZE; 229107120Sjulian return (ERROR); 230107120Sjulian } 231107120Sjulian 232107120Sjulian if (event.hdr.type != NG_HCI_EVENT_PKT) { 233107120Sjulian errno = EIO; 234107120Sjulian return (ERROR); 235107120Sjulian } 236107120Sjulian 237107120Sjulian /* Parse event */ 238107120Sjulian switch (event.hdr.event) { 239107120Sjulian case NG_HCI_EVENT_COMMAND_COMPL: { 240107120Sjulian ng_hci_read_stored_link_key_rp *rp = NULL; 241107120Sjulian 242107120Sjulian if (event.ep.cc.opcode == 0x0000 || 243107120Sjulian event.ep.cc.opcode != cmd.hdr.opcode) 244107120Sjulian goto again; 245107120Sjulian 246107120Sjulian rp = (ng_hci_read_stored_link_key_rp *)(event.ep.b + 247107120Sjulian sizeof(event.ep.cc)); 248107120Sjulian 249107120Sjulian fprintf(stdout, "Complete: Status: %s [%#x]\n", 250107120Sjulian hci_status2str(rp->status), rp->status); 251107120Sjulian fprintf(stdout, "Maximum Number of keys: %d\n", 252107120Sjulian le16toh(rp->max_num_keys)); 253107120Sjulian fprintf(stdout, "Number of keys read: %d\n", 254107120Sjulian le16toh(rp->num_keys_read)); 255107120Sjulian } break; 256107120Sjulian 257107120Sjulian case NG_HCI_EVENT_RETURN_LINK_KEYS: { 258107120Sjulian struct _key { 259107120Sjulian bdaddr_t bdaddr; 260128079Semax uint8_t key[NG_HCI_KEY_SIZE]; 261107120Sjulian } __attribute__ ((packed)) *k = NULL; 262107120Sjulian 263107120Sjulian fprintf(stdout, "Event: Number of keys: %d\n", 264107120Sjulian event.ep.key.num_keys); 265107120Sjulian 266107120Sjulian k = (struct _key *)(event.ep.b + sizeof(event.ep.key)); 267107120Sjulian for (n = 0; n < event.ep.key.num_keys; n++) { 268121054Semax fprintf(stdout, "\t%d: %s ", 269121054Semax n + 1, hci_bdaddr2str(&k->bdaddr)); 270107120Sjulian 271121054Semax for (n1 = 0; n1 < sizeof(k->key); n1++) 272121054Semax fprintf(stdout, "%02x", k->key[n1]); 273107120Sjulian fprintf(stdout, "\n"); 274107120Sjulian 275107120Sjulian k ++; 276107120Sjulian } 277107120Sjulian 278107120Sjulian goto again; 279107120Sjulian 280107120Sjulian } break; 281107120Sjulian 282107120Sjulian default: 283107120Sjulian goto again; 284107120Sjulian } 285107120Sjulian 286107120Sjulian return (OK); 287107120Sjulian} /* hci_read_store_link_key */ 288107120Sjulian 289107120Sjulian/* Send Write_Stored_Link_Key command to the unit */ 290107120Sjulianstatic int 291107120Sjulianhci_write_stored_link_key(int s, int argc, char **argv) 292107120Sjulian{ 293107120Sjulian struct { 294107120Sjulian ng_hci_write_stored_link_key_cp p; 295107120Sjulian bdaddr_t bdaddr; 296128079Semax uint8_t key[NG_HCI_KEY_SIZE]; 297107120Sjulian } cp; 298107120Sjulian ng_hci_write_stored_link_key_rp rp; 299121054Semax int32_t n; 300107120Sjulian 301107120Sjulian memset(&cp, 0, sizeof(cp)); 302107120Sjulian 303107120Sjulian switch (argc) { 304107120Sjulian case 2: 305107120Sjulian cp.p.num_keys_write = 1; 306107120Sjulian 307107120Sjulian /* parse BD_ADDR */ 308121054Semax if (!bt_aton(argv[0], &cp.bdaddr)) { 309121054Semax struct hostent *he = NULL; 310107120Sjulian 311121054Semax if ((he = bt_gethostbyname(argv[0])) == NULL) 312121054Semax return (USAGE); 313107120Sjulian 314121054Semax memcpy(&cp.bdaddr, he->h_addr, sizeof(cp.bdaddr)); 315121054Semax } 316121054Semax 317107120Sjulian /* parse key */ 318107120Sjulian if (hci_hexstring2array(argv[1], cp.key, sizeof(cp.key)) < 0) 319107120Sjulian return (USAGE); 320107120Sjulian break; 321107120Sjulian 322107120Sjulian default: 323107120Sjulian return (USAGE); 324107120Sjulian } 325107120Sjulian 326107120Sjulian /* send command */ 327107120Sjulian n = sizeof(rp); 328107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 329107120Sjulian NG_HCI_OCF_WRITE_STORED_LINK_KEY), 330107120Sjulian (char const *) &cp, sizeof(cp), 331107120Sjulian (char *) &rp, &n) == ERROR) 332107120Sjulian return (ERROR); 333107120Sjulian 334107120Sjulian if (rp.status != 0x00) { 335107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 336107120Sjulian hci_status2str(rp.status), rp.status); 337107120Sjulian return (FAILED); 338107120Sjulian } 339107120Sjulian 340107120Sjulian fprintf(stdout, "Number of keys written: %d\n", rp.num_keys_written); 341107120Sjulian 342107120Sjulian return (OK); 343107120Sjulian} /* hci_write_stored_link_key */ 344107120Sjulian 345107120Sjulian 346107120Sjulian/* Send Delete_Stored_Link_Key command to the unit */ 347107120Sjulianstatic int 348107120Sjulianhci_delete_stored_link_key(int s, int argc, char **argv) 349107120Sjulian{ 350107120Sjulian ng_hci_delete_stored_link_key_cp cp; 351107120Sjulian ng_hci_delete_stored_link_key_rp rp; 352121054Semax int32_t n; 353107120Sjulian 354107120Sjulian memset(&cp, 0, sizeof(cp)); 355107120Sjulian 356107120Sjulian switch (argc) { 357107120Sjulian case 1: 358107120Sjulian /* parse BD_ADDR */ 359121054Semax if (!bt_aton(argv[0], &cp.bdaddr)) { 360121054Semax struct hostent *he = NULL; 361107120Sjulian 362121054Semax if ((he = bt_gethostbyname(argv[0])) == NULL) 363121054Semax return (USAGE); 364121054Semax 365121054Semax memcpy(&cp.bdaddr, he->h_addr, sizeof(cp.bdaddr)); 366121054Semax } 367107120Sjulian break; 368107120Sjulian 369107120Sjulian default: 370107120Sjulian cp.delete_all = 1; 371107120Sjulian break; 372107120Sjulian } 373107120Sjulian 374107120Sjulian /* send command */ 375107120Sjulian n = sizeof(cp); 376107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 377107120Sjulian NG_HCI_OCF_DELETE_STORED_LINK_KEY), 378107120Sjulian (char const *) &cp, sizeof(cp), 379107120Sjulian (char *) &rp, &n) == ERROR) 380107120Sjulian return (ERROR); 381107120Sjulian 382107120Sjulian if (rp.status != 0x00) { 383107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 384107120Sjulian hci_status2str(rp.status), rp.status); 385107120Sjulian return (FAILED); 386107120Sjulian } 387107120Sjulian 388107120Sjulian fprintf(stdout, "Number of keys deleted: %d\n", rp.num_keys_deleted); 389107120Sjulian 390107120Sjulian return (OK); 391107120Sjulian} /* hci_delete_stored_link_key */ 392107120Sjulian 393107120Sjulian/* Send Change_Local_Name command to the unit */ 394107120Sjulianstatic int 395107120Sjulianhci_change_local_name(int s, int argc, char **argv) 396107120Sjulian{ 397107120Sjulian ng_hci_change_local_name_cp cp; 398107120Sjulian ng_hci_change_local_name_rp rp; 399107120Sjulian int n; 400107120Sjulian 401107120Sjulian /* parse command parameters */ 402107120Sjulian switch (argc) { 403107120Sjulian case 1: 404107120Sjulian snprintf(cp.name, sizeof(cp.name), "%s", argv[0]); 405107120Sjulian break; 406107120Sjulian 407107120Sjulian default: 408107120Sjulian return (USAGE); 409107120Sjulian } 410107120Sjulian 411107120Sjulian /* send command */ 412107120Sjulian n = sizeof(rp); 413107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 414107120Sjulian NG_HCI_OCF_CHANGE_LOCAL_NAME), 415107120Sjulian (char const *) &cp, sizeof(cp), 416107120Sjulian (char *) &rp, &n) == ERROR) 417107120Sjulian return (ERROR); 418107120Sjulian 419107120Sjulian if (rp.status != 0x00) { 420107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 421107120Sjulian hci_status2str(rp.status), rp.status); 422107120Sjulian return (FAILED); 423107120Sjulian } 424107120Sjulian 425107120Sjulian return (OK); 426107120Sjulian} /* hci_change_local_name */ 427107120Sjulian 428107120Sjulian/* Send Read_Local_Name command to the unit */ 429107120Sjulianstatic int 430107120Sjulianhci_read_local_name(int s, int argc, char **argv) 431107120Sjulian{ 432107120Sjulian ng_hci_read_local_name_rp rp; 433107120Sjulian int n; 434107120Sjulian 435107120Sjulian n = sizeof(rp); 436107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 437107120Sjulian NG_HCI_OCF_READ_LOCAL_NAME), 438107120Sjulian (char *) &rp, &n) == ERROR) 439107120Sjulian return (ERROR); 440107120Sjulian 441107120Sjulian if (rp.status != 0x00) { 442107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 443107120Sjulian hci_status2str(rp.status), rp.status); 444107120Sjulian return (FAILED); 445107120Sjulian } 446107120Sjulian 447107120Sjulian fprintf(stdout, "Local name: %s\n", rp.name); 448107120Sjulian 449107120Sjulian return (OK); 450107120Sjulian} /* hci_read_local_name */ 451107120Sjulian 452107120Sjulian/* Send Read_Connection_Accept_Timeout to the unit */ 453107120Sjulianstatic int 454107120Sjulianhci_read_connection_accept_timeout(int s, int argc, char **argv) 455107120Sjulian{ 456107120Sjulian ng_hci_read_con_accept_timo_rp rp; 457107120Sjulian int n; 458107120Sjulian 459107120Sjulian n = sizeof(rp); 460107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 461107120Sjulian NG_HCI_OCF_READ_CON_ACCEPT_TIMO), 462107120Sjulian (char *) &rp, &n) == ERROR) 463107120Sjulian return (ERROR); 464107120Sjulian 465107120Sjulian if (rp.status != 0x00) { 466107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 467107120Sjulian hci_status2str(rp.status), rp.status); 468107120Sjulian return (FAILED); 469107120Sjulian } 470107120Sjulian 471107120Sjulian rp.timeout = le16toh(rp.timeout); 472107120Sjulian fprintf(stdout, "Connection accept timeout: %.2f msec [%d slots]\n", 473107120Sjulian rp.timeout * 0.625, rp.timeout); 474107120Sjulian 475107120Sjulian return (OK); 476107120Sjulian} /* hci_read_connection_accept_timeout */ 477107120Sjulian 478107120Sjulian/* Send Write_Connection_Accept_Timeout to the unit */ 479107120Sjulianstatic int 480107120Sjulianhci_write_connection_accept_timeout(int s, int argc, char **argv) 481107120Sjulian{ 482107120Sjulian ng_hci_write_con_accept_timo_cp cp; 483107120Sjulian ng_hci_write_con_accept_timo_rp rp; 484107120Sjulian int n; 485107120Sjulian 486107120Sjulian /* parse command parameters */ 487107120Sjulian switch (argc) { 488107120Sjulian case 1: 489107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 1 || n > 0xb540) 490107120Sjulian return (USAGE); 491107120Sjulian 492128079Semax cp.timeout = (uint16_t) n; 493107120Sjulian cp.timeout = htole16(cp.timeout); 494107120Sjulian break; 495107120Sjulian 496107120Sjulian default: 497107120Sjulian return (USAGE); 498107120Sjulian } 499107120Sjulian 500107120Sjulian /* send command */ 501107120Sjulian n = sizeof(rp); 502107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 503107120Sjulian NG_HCI_OCF_WRITE_CON_ACCEPT_TIMO), 504107120Sjulian (char const *) &cp, sizeof(cp), 505107120Sjulian (char *) &rp, &n) == ERROR) 506107120Sjulian return (ERROR); 507107120Sjulian 508107120Sjulian if (rp.status != 0x00) { 509107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 510107120Sjulian hci_status2str(rp.status), rp.status); 511107120Sjulian return (FAILED); 512107120Sjulian } 513107120Sjulian 514107120Sjulian return (OK); 515107120Sjulian} /* hci_write_connection_accept_timeout */ 516107120Sjulian 517107120Sjulian/* Send Read_Page_Timeout command to the unit */ 518107120Sjulianstatic int 519107120Sjulianhci_read_page_timeout(int s, int argc, char **argv) 520107120Sjulian{ 521107120Sjulian ng_hci_read_page_timo_rp rp; 522107120Sjulian int n; 523107120Sjulian 524107120Sjulian n = sizeof(rp); 525107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 526107120Sjulian NG_HCI_OCF_READ_PAGE_TIMO), 527107120Sjulian (char *) &rp, &n) == ERROR) 528107120Sjulian return (ERROR); 529107120Sjulian 530107120Sjulian if (rp.status != 0x00) { 531107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 532107120Sjulian hci_status2str(rp.status), rp.status); 533107120Sjulian return (FAILED); 534107120Sjulian } 535107120Sjulian 536107120Sjulian rp.timeout = le16toh(rp.timeout); 537107120Sjulian fprintf(stdout, "Page timeout: %.2f msec [%d slots]\n", 538107120Sjulian rp.timeout * 0.625, rp.timeout); 539107120Sjulian 540107120Sjulian return (OK); 541107120Sjulian} /* hci_read_page_timeoout */ 542107120Sjulian 543107120Sjulian/* Send Write_Page_Timeout command to the unit */ 544107120Sjulianstatic int 545107120Sjulianhci_write_page_timeout(int s, int argc, char **argv) 546107120Sjulian{ 547107120Sjulian ng_hci_write_page_timo_cp cp; 548107120Sjulian ng_hci_write_page_timo_rp rp; 549107120Sjulian int n; 550107120Sjulian 551107120Sjulian /* parse command parameters */ 552107120Sjulian switch (argc) { 553107120Sjulian case 1: 554107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 1 || n > 0xffff) 555107120Sjulian return (USAGE); 556107120Sjulian 557128079Semax cp.timeout = (uint16_t) n; 558107120Sjulian cp.timeout = htole16(cp.timeout); 559107120Sjulian break; 560107120Sjulian 561107120Sjulian default: 562107120Sjulian return (USAGE); 563107120Sjulian } 564107120Sjulian 565107120Sjulian /* send command */ 566107120Sjulian n = sizeof(rp); 567107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 568107120Sjulian NG_HCI_OCF_WRITE_PAGE_TIMO), 569107120Sjulian (char const *) &cp, sizeof(cp), 570107120Sjulian (char *) &rp, &n) == ERROR) 571107120Sjulian return (ERROR); 572107120Sjulian 573107120Sjulian if (rp.status != 0x00) { 574107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 575107120Sjulian hci_status2str(rp.status), rp.status); 576107120Sjulian return (FAILED); 577107120Sjulian } 578107120Sjulian 579107120Sjulian return (OK); 580107120Sjulian} /* hci_write_page_timeout */ 581107120Sjulian 582107120Sjulian/* Send Read_Scan_Enable command to the unit */ 583107120Sjulianstatic int 584107120Sjulianhci_read_scan_enable(int s, int argc, char **argv) 585107120Sjulian{ 586107120Sjulian ng_hci_read_scan_enable_rp rp; 587107120Sjulian int n; 588107120Sjulian 589107120Sjulian n = sizeof(rp); 590107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 591107120Sjulian NG_HCI_OCF_READ_SCAN_ENABLE), 592107120Sjulian (char *) &rp, &n) == ERROR) 593107120Sjulian return (ERROR); 594107120Sjulian 595107120Sjulian if (rp.status != 0x00) { 596107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 597107120Sjulian hci_status2str(rp.status), rp.status); 598107120Sjulian return (FAILED); 599107120Sjulian } 600107120Sjulian 601107120Sjulian fprintf(stdout, "Scan enable: %s [%#02x]\n", 602107120Sjulian hci_scan2str(rp.scan_enable), rp.scan_enable); 603107120Sjulian 604107120Sjulian return (OK); 605107120Sjulian} /* hci_read_scan_enable */ 606107120Sjulian 607107120Sjulian/* Send Write_Scan_Enable command to the unit */ 608107120Sjulianstatic int 609107120Sjulianhci_write_scan_enable(int s, int argc, char **argv) 610107120Sjulian{ 611107120Sjulian ng_hci_write_scan_enable_cp cp; 612107120Sjulian ng_hci_write_scan_enable_rp rp; 613107120Sjulian int n; 614107120Sjulian 615107120Sjulian /* parse command parameters */ 616107120Sjulian switch (argc) { 617107120Sjulian case 1: 618107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 3) 619107120Sjulian return (USAGE); 620107120Sjulian 621128079Semax cp.scan_enable = (uint8_t) n; 622107120Sjulian break; 623107120Sjulian 624107120Sjulian default: 625107120Sjulian return (USAGE); 626107120Sjulian } 627107120Sjulian 628107120Sjulian n = sizeof(rp); 629107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 630107120Sjulian NG_HCI_OCF_WRITE_SCAN_ENABLE), 631107120Sjulian (char const *) &cp, sizeof(cp), 632107120Sjulian (char *) &rp, &n) == ERROR) 633107120Sjulian return (ERROR); 634107120Sjulian 635107120Sjulian if (rp.status != 0x00) { 636107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 637107120Sjulian hci_status2str(rp.status), rp.status); 638107120Sjulian return (FAILED); 639107120Sjulian } 640107120Sjulian 641107120Sjulian return (OK); 642107120Sjulian} /* hci_write_scan_enable */ 643107120Sjulian 644107120Sjulian/* Send Read_Page_Scan_Activity command to the unit */ 645107120Sjulianstatic int 646107120Sjulianhci_read_page_scan_activity(int s, int argc, char **argv) 647107120Sjulian{ 648107120Sjulian ng_hci_read_page_scan_activity_rp rp; 649107120Sjulian int n; 650107120Sjulian 651107120Sjulian n = sizeof(rp); 652107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 653107120Sjulian NG_HCI_OCF_READ_PAGE_SCAN_ACTIVITY), 654107120Sjulian (char *) &rp, &n) == ERROR) 655107120Sjulian return (ERROR); 656107120Sjulian 657107120Sjulian if (rp.status != 0x00) { 658107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 659107120Sjulian hci_status2str(rp.status), rp.status); 660107120Sjulian return (FAILED); 661107120Sjulian } 662107120Sjulian 663107120Sjulian rp.page_scan_interval = le16toh(rp.page_scan_interval); 664107120Sjulian rp.page_scan_window = le16toh(rp.page_scan_window); 665107120Sjulian 666107120Sjulian fprintf(stdout, "Page Scan Interval: %.2f msec [%d slots]\n", 667107120Sjulian rp.page_scan_interval * 0.625, rp.page_scan_interval); 668107120Sjulian fprintf(stdout, "Page Scan Window: %.2f msec [%d slots]\n", 669107120Sjulian rp.page_scan_window * 0.625, rp.page_scan_window); 670107120Sjulian 671107120Sjulian return (OK); 672107120Sjulian} /* hci_read_page_scan_activity */ 673107120Sjulian 674107120Sjulian/* Send Write_Page_Scan_Activity command to the unit */ 675107120Sjulianstatic int 676107120Sjulianhci_write_page_scan_activity(int s, int argc, char **argv) 677107120Sjulian{ 678107120Sjulian ng_hci_write_page_scan_activity_cp cp; 679107120Sjulian ng_hci_write_page_scan_activity_rp rp; 680107120Sjulian int n; 681107120Sjulian 682107120Sjulian /* parse command parameters */ 683107120Sjulian switch (argc) { 684107120Sjulian case 2: 685107120Sjulian /* page scan interval */ 686107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0x12 || n > 0x1000) 687107120Sjulian return (USAGE); 688107120Sjulian 689128079Semax cp.page_scan_interval = (uint16_t) n; 690107120Sjulian 691107120Sjulian /* page scan window */ 692131216Semax if (sscanf(argv[1], "%d", &n) != 1 || n < 0x12 || n > 0x1000) 693107120Sjulian return (USAGE); 694107120Sjulian 695128079Semax cp.page_scan_window = (uint16_t) n; 696107120Sjulian 697107120Sjulian if (cp.page_scan_window > cp.page_scan_interval) 698107120Sjulian return (USAGE); 699107120Sjulian 700107120Sjulian cp.page_scan_interval = htole16(cp.page_scan_interval); 701107120Sjulian cp.page_scan_window = htole16(cp.page_scan_window); 702107120Sjulian break; 703107120Sjulian 704107120Sjulian default: 705107120Sjulian return (USAGE); 706107120Sjulian } 707107120Sjulian 708107120Sjulian /* send command */ 709107120Sjulian n = sizeof(rp); 710107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 711107120Sjulian NG_HCI_OCF_WRITE_PAGE_SCAN_ACTIVITY), 712107120Sjulian (char const *) &cp, sizeof(cp), 713107120Sjulian (char *) &rp, &n) == ERROR) 714107120Sjulian return (ERROR); 715107120Sjulian 716107120Sjulian if (rp.status != 0x00) { 717107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 718107120Sjulian hci_status2str(rp.status), rp.status); 719107120Sjulian return (FAILED); 720107120Sjulian } 721107120Sjulian 722107120Sjulian return (OK); 723107120Sjulian} /* hci_write_page_scan_activity */ 724107120Sjulian 725107120Sjulian/* Send Read_Inquiry_Scan_Activity command to the unit */ 726107120Sjulianstatic int 727107120Sjulianhci_read_inquiry_scan_activity(int s, int argc, char **argv) 728107120Sjulian{ 729107120Sjulian ng_hci_read_inquiry_scan_activity_rp rp; 730107120Sjulian int n; 731107120Sjulian 732107120Sjulian n = sizeof(rp); 733107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 734107120Sjulian NG_HCI_OCF_READ_INQUIRY_SCAN_ACTIVITY), 735107120Sjulian (char *) &rp, &n) == ERROR) 736107120Sjulian return (ERROR); 737107120Sjulian 738107120Sjulian if (rp.status != 0x00) { 739107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 740107120Sjulian hci_status2str(rp.status), rp.status); 741107120Sjulian return (FAILED); 742107120Sjulian } 743107120Sjulian 744107120Sjulian rp.inquiry_scan_interval = le16toh(rp.inquiry_scan_interval); 745107120Sjulian rp.inquiry_scan_window = le16toh(rp.inquiry_scan_window); 746107120Sjulian 747107120Sjulian fprintf(stdout, "Inquiry Scan Interval: %.2f msec [%d slots]\n", 748107120Sjulian rp.inquiry_scan_interval * 0.625, rp.inquiry_scan_interval); 749107120Sjulian fprintf(stdout, "Inquiry Scan Window: %.2f msec [%d slots]\n", 750107120Sjulian rp.inquiry_scan_window * 0.625, rp.inquiry_scan_interval); 751107120Sjulian 752107120Sjulian return (OK); 753107120Sjulian} /* hci_read_inquiry_scan_activity */ 754107120Sjulian 755107120Sjulian/* Send Write_Inquiry_Scan_Activity command to the unit */ 756107120Sjulianstatic int 757107120Sjulianhci_write_inquiry_scan_activity(int s, int argc, char **argv) 758107120Sjulian{ 759107120Sjulian ng_hci_write_inquiry_scan_activity_cp cp; 760107120Sjulian ng_hci_write_inquiry_scan_activity_rp rp; 761107120Sjulian int n; 762107120Sjulian 763107120Sjulian /* parse command parameters */ 764107120Sjulian switch (argc) { 765107120Sjulian case 2: 766107120Sjulian /* inquiry scan interval */ 767107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0x12 || n > 0x1000) 768107120Sjulian return (USAGE); 769107120Sjulian 770128079Semax cp.inquiry_scan_interval = (uint16_t) n; 771107120Sjulian 772107120Sjulian /* inquiry scan window */ 773131216Semax if (sscanf(argv[1], "%d", &n) != 1 || n < 0x12 || n > 0x1000) 774107120Sjulian return (USAGE); 775107120Sjulian 776128079Semax cp.inquiry_scan_window = (uint16_t) n; 777107120Sjulian 778107120Sjulian if (cp.inquiry_scan_window > cp.inquiry_scan_interval) 779107120Sjulian return (USAGE); 780107120Sjulian 781107120Sjulian cp.inquiry_scan_interval = 782107120Sjulian htole16(cp.inquiry_scan_interval); 783107120Sjulian cp.inquiry_scan_window = htole16(cp.inquiry_scan_window); 784107120Sjulian break; 785107120Sjulian 786107120Sjulian default: 787107120Sjulian return (USAGE); 788107120Sjulian } 789107120Sjulian 790107120Sjulian /* send command */ 791107120Sjulian n = sizeof(rp); 792107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 793107120Sjulian NG_HCI_OCF_WRITE_INQUIRY_SCAN_ACTIVITY), 794107120Sjulian (char const *) &cp, sizeof(cp), 795107120Sjulian (char *) &rp, &n) == ERROR) 796107120Sjulian return (ERROR); 797107120Sjulian 798107120Sjulian if (rp.status != 0x00) { 799107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 800107120Sjulian hci_status2str(rp.status), rp.status); 801107120Sjulian return (FAILED); 802107120Sjulian } 803107120Sjulian 804107120Sjulian return (OK); 805107120Sjulian} /* hci_write_inquiry_scan_activity */ 806107120Sjulian 807107120Sjulian/* Send Read_Authentication_Enable command to the unit */ 808107120Sjulianstatic int 809107120Sjulianhci_read_authentication_enable(int s, int argc, char **argv) 810107120Sjulian{ 811107120Sjulian ng_hci_read_auth_enable_rp rp; 812107120Sjulian int n; 813107120Sjulian 814107120Sjulian n = sizeof(rp); 815107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 816107120Sjulian NG_HCI_OCF_READ_AUTH_ENABLE), 817107120Sjulian (char *) &rp, &n) == ERROR) 818107120Sjulian return (ERROR); 819107120Sjulian 820107120Sjulian if (rp.status != 0x00) { 821107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 822107120Sjulian hci_status2str(rp.status), rp.status); 823107120Sjulian return (FAILED); 824107120Sjulian } 825107120Sjulian 826107120Sjulian fprintf(stdout, "Authentication Enable: %s [%d]\n", 827107120Sjulian rp.auth_enable? "Enabled" : "Disabled", rp.auth_enable); 828107120Sjulian 829107120Sjulian return (OK); 830107120Sjulian} /* hci_read_authentication_enable */ 831107120Sjulian 832107120Sjulian/* Send Write_Authentication_Enable command to the unit */ 833107120Sjulianstatic int 834107120Sjulianhci_write_authentication_enable(int s, int argc, char **argv) 835107120Sjulian{ 836107120Sjulian ng_hci_write_auth_enable_cp cp; 837107120Sjulian ng_hci_write_auth_enable_rp rp; 838107120Sjulian int n; 839107120Sjulian 840107120Sjulian /* parse command parameters */ 841107120Sjulian switch (argc) { 842107120Sjulian case 1: 843107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 1) 844107120Sjulian return (USAGE); 845107120Sjulian 846128079Semax cp.auth_enable = (uint8_t) n; 847107120Sjulian break; 848107120Sjulian 849107120Sjulian default: 850107120Sjulian return (USAGE); 851107120Sjulian } 852107120Sjulian 853107120Sjulian /* send command */ 854107120Sjulian n = sizeof(rp); 855107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 856107120Sjulian NG_HCI_OCF_WRITE_AUTH_ENABLE), 857107120Sjulian (char const *) &cp, sizeof(cp), 858107120Sjulian (char *) &rp, &n) == ERROR) 859107120Sjulian return (ERROR); 860107120Sjulian 861107120Sjulian if (rp.status != 0x00) { 862107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 863107120Sjulian hci_status2str(rp.status), rp.status); 864107120Sjulian return (FAILED); 865107120Sjulian } 866107120Sjulian 867107120Sjulian return (OK); 868107120Sjulian} /* hci_write_authentication_enable */ 869107120Sjulian 870107120Sjulian/* Send Read_Encryption_Mode command to the unit */ 871107120Sjulianstatic int 872107120Sjulianhci_read_encryption_mode(int s, int argc, char **argv) 873107120Sjulian{ 874107120Sjulian ng_hci_read_encryption_mode_rp rp; 875107120Sjulian int n; 876107120Sjulian 877107120Sjulian n = sizeof(rp); 878107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 879107120Sjulian NG_HCI_OCF_READ_ENCRYPTION_MODE), 880107120Sjulian (char *) &rp, &n) == ERROR) 881107120Sjulian return (ERROR); 882107120Sjulian 883107120Sjulian if (rp.status != 0x00) { 884107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 885107120Sjulian hci_status2str(rp.status), rp.status); 886107120Sjulian return (FAILED); 887107120Sjulian } 888107120Sjulian 889107120Sjulian fprintf(stdout, "Encryption mode: %s [%#02x]\n", 890107120Sjulian hci_encrypt2str(rp.encryption_mode, 0), rp.encryption_mode); 891107120Sjulian 892107120Sjulian return (OK); 893107120Sjulian} /* hci_read_encryption_mode */ 894107120Sjulian 895107120Sjulian/* Send Write_Encryption_Mode command to the unit */ 896107120Sjulianstatic int 897107120Sjulianhci_write_encryption_mode(int s, int argc, char **argv) 898107120Sjulian{ 899107120Sjulian ng_hci_write_encryption_mode_cp cp; 900107120Sjulian ng_hci_write_encryption_mode_rp rp; 901107120Sjulian int n; 902107120Sjulian 903107120Sjulian /* parse command parameters */ 904107120Sjulian switch (argc) { 905107120Sjulian case 1: 906107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 2) 907107120Sjulian return (USAGE); 908107120Sjulian 909128079Semax cp.encryption_mode = (uint8_t) n; 910107120Sjulian break; 911107120Sjulian 912107120Sjulian default: 913107120Sjulian return (USAGE); 914107120Sjulian } 915107120Sjulian 916107120Sjulian /* send command */ 917107120Sjulian n = sizeof(rp); 918107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 919107120Sjulian NG_HCI_OCF_WRITE_ENCRYPTION_MODE), 920107120Sjulian (char const *) &cp, sizeof(cp), 921107120Sjulian (char *) &rp, &n) == ERROR) 922107120Sjulian return (ERROR); 923107120Sjulian 924107120Sjulian if (rp.status != 0x00) { 925107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 926107120Sjulian hci_status2str(rp.status), rp.status); 927107120Sjulian return (FAILED); 928107120Sjulian } 929107120Sjulian 930107120Sjulian return (OK); 931107120Sjulian} /* hci_write_encryption_mode */ 932107120Sjulian 933107120Sjulian/* Send Read_Class_Of_Device command to the unit */ 934107120Sjulianstatic int 935107120Sjulianhci_read_class_of_device(int s, int argc, char **argv) 936107120Sjulian{ 937107120Sjulian ng_hci_read_unit_class_rp rp; 938107120Sjulian int n; 939107120Sjulian 940107120Sjulian n = sizeof(rp); 941107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 942107120Sjulian NG_HCI_OCF_READ_UNIT_CLASS), 943107120Sjulian (char *) &rp, &n) == ERROR) 944107120Sjulian return (ERROR); 945107120Sjulian 946107120Sjulian if (rp.status != 0x00) { 947107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 948107120Sjulian hci_status2str(rp.status), rp.status); 949107120Sjulian return (FAILED); 950107120Sjulian } 951107120Sjulian 952107120Sjulian fprintf(stdout, "Class: %02x:%02x:%02x\n", 953107120Sjulian rp.uclass[2], rp.uclass[1], rp.uclass[0]); 954107120Sjulian 955107120Sjulian return (0); 956107120Sjulian} /* hci_read_class_of_device */ 957107120Sjulian 958107120Sjulian/* Send Write_Class_Of_Device command to the unit */ 959107120Sjulianstatic int 960107120Sjulianhci_write_class_of_device(int s, int argc, char **argv) 961107120Sjulian{ 962107120Sjulian ng_hci_write_unit_class_cp cp; 963107120Sjulian ng_hci_write_unit_class_rp rp; 964107120Sjulian int n0, n1, n2; 965107120Sjulian 966107120Sjulian /* parse command parameters */ 967107120Sjulian switch (argc) { 968107120Sjulian case 1: 969107120Sjulian if (sscanf(argv[0], "%x:%x:%x", &n2, &n1, &n0) != 3) 970107120Sjulian return (USAGE); 971107120Sjulian 972107120Sjulian cp.uclass[0] = (n0 & 0xff); 973107120Sjulian cp.uclass[1] = (n1 & 0xff); 974107120Sjulian cp.uclass[2] = (n2 & 0xff); 975107120Sjulian break; 976107120Sjulian 977107120Sjulian default: 978107120Sjulian return (USAGE); 979107120Sjulian } 980107120Sjulian 981107120Sjulian /* send command */ 982107120Sjulian n0 = sizeof(rp); 983107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 984107120Sjulian NG_HCI_OCF_WRITE_UNIT_CLASS), 985107120Sjulian (char const *) &cp, sizeof(cp), 986107120Sjulian (char *) &rp, &n0) == ERROR) 987107120Sjulian return (ERROR); 988107120Sjulian 989107120Sjulian if (rp.status != 0x00) { 990107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 991107120Sjulian hci_status2str(rp.status), rp.status); 992107120Sjulian return (FAILED); 993107120Sjulian } 994107120Sjulian 995107120Sjulian return (OK); 996107120Sjulian} /* hci_write_class_of_device */ 997107120Sjulian 998107120Sjulian/* Send Read_Voice_Settings command to the unit */ 999107120Sjulianstatic int 1000107120Sjulianhci_read_voice_settings(int s, int argc, char **argv) 1001107120Sjulian{ 1002107120Sjulian ng_hci_read_voice_settings_rp rp; 1003107120Sjulian int n, 1004107120Sjulian input_coding, 1005107120Sjulian input_data_format, 1006107120Sjulian input_sample_size; 1007107120Sjulian 1008107120Sjulian n = sizeof(rp); 1009107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1010107120Sjulian NG_HCI_OCF_READ_VOICE_SETTINGS), 1011107120Sjulian (char *) &rp, &n) == ERROR) 1012107120Sjulian return (ERROR); 1013107120Sjulian 1014107120Sjulian if (rp.status != 0x00) { 1015107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1016107120Sjulian hci_status2str(rp.status), rp.status); 1017107120Sjulian return (FAILED); 1018107120Sjulian } 1019107120Sjulian 1020107120Sjulian rp.settings = le16toh(rp.settings); 1021107120Sjulian 1022107120Sjulian input_coding = (rp.settings & 0x0300) >> 8; 1023107120Sjulian input_data_format = (rp.settings & 0x00c0) >> 6; 1024107120Sjulian input_sample_size = (rp.settings & 0x0020) >> 5; 1025107120Sjulian 1026107120Sjulian fprintf(stdout, "Voice settings: %#04x\n", rp.settings); 1027107120Sjulian fprintf(stdout, "Input coding: %s [%d]\n", 1028107120Sjulian hci_coding2str(input_coding), input_coding); 1029107120Sjulian fprintf(stdout, "Input data format: %s [%d]\n", 1030107120Sjulian hci_vdata2str(input_data_format), input_data_format); 1031107120Sjulian 1032107120Sjulian if (input_coding == 0x00) /* Only for Linear PCM */ 1033107120Sjulian fprintf(stdout, "Input sample size: %d bit [%d]\n", 1034107120Sjulian input_sample_size? 16 : 8, input_sample_size); 1035107120Sjulian 1036107120Sjulian return (OK); 1037107120Sjulian} /* hci_read_voice_settings */ 1038107120Sjulian 1039107120Sjulian/* Send Write_Voice_Settings command to the unit */ 1040107120Sjulianstatic int 1041107120Sjulianhci_write_voice_settings(int s, int argc, char **argv) 1042107120Sjulian{ 1043107120Sjulian ng_hci_write_voice_settings_cp cp; 1044107120Sjulian ng_hci_write_voice_settings_rp rp; 1045107120Sjulian int n; 1046107120Sjulian 1047107120Sjulian /* parse command parameters */ 1048107120Sjulian switch (argc) { 1049107120Sjulian case 1: 1050107120Sjulian if (sscanf(argv[0], "%x", &n) != 1) 1051107120Sjulian return (USAGE); 1052107120Sjulian 1053128079Semax cp.settings = (uint16_t) n; 1054107120Sjulian cp.settings = htole16(cp.settings); 1055107120Sjulian break; 1056107120Sjulian 1057107120Sjulian default: 1058107120Sjulian return (USAGE); 1059107120Sjulian } 1060107120Sjulian 1061107120Sjulian /* send command */ 1062107120Sjulian n = sizeof(rp); 1063107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1064107120Sjulian NG_HCI_OCF_WRITE_VOICE_SETTINGS), 1065107120Sjulian (char const *) &cp, sizeof(cp), 1066107120Sjulian (char *) &rp, &n) == ERROR) 1067107120Sjulian return (ERROR); 1068107120Sjulian 1069107120Sjulian if (rp.status != 0x00) { 1070107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1071107120Sjulian hci_status2str(rp.status), rp.status); 1072107120Sjulian return (FAILED); 1073107120Sjulian } 1074107120Sjulian 1075107120Sjulian return (OK); 1076107120Sjulian} /* hci_write_voice_settings */ 1077107120Sjulian 1078107120Sjulian/* Send Read_Number_Broadcast_Restransmissions */ 1079107120Sjulianstatic int 1080107120Sjulianhci_read_number_broadcast_retransmissions(int s, int argc, char **argv) 1081107120Sjulian{ 1082107120Sjulian ng_hci_read_num_broadcast_retrans_rp rp; 1083107120Sjulian int n; 1084107120Sjulian 1085107120Sjulian n = sizeof(rp); 1086107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1087107120Sjulian NG_HCI_OCF_READ_NUM_BROADCAST_RETRANS), 1088107120Sjulian (char *) &rp, &n) == ERROR) 1089107120Sjulian return (ERROR); 1090107120Sjulian 1091107120Sjulian if (rp.status != 0x00) { 1092107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1093107120Sjulian hci_status2str(rp.status), rp.status); 1094107120Sjulian return (FAILED); 1095107120Sjulian } 1096107120Sjulian 1097107120Sjulian fprintf(stdout, "Number of broadcast retransmissions: %d\n", 1098107120Sjulian rp.counter); 1099107120Sjulian 1100107120Sjulian return (OK); 1101107120Sjulian} /* hci_read_number_broadcast_retransmissions */ 1102107120Sjulian 1103107120Sjulian/* Send Write_Number_Broadcast_Restransmissions */ 1104107120Sjulianstatic int 1105107120Sjulianhci_write_number_broadcast_retransmissions(int s, int argc, char **argv) 1106107120Sjulian{ 1107107120Sjulian ng_hci_write_num_broadcast_retrans_cp cp; 1108107120Sjulian ng_hci_write_num_broadcast_retrans_rp rp; 1109107120Sjulian int n; 1110107120Sjulian 1111107120Sjulian /* parse command parameters */ 1112107120Sjulian switch (argc) { 1113107120Sjulian case 1: 1114107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 0xff) 1115107120Sjulian return (USAGE); 1116107120Sjulian 1117128079Semax cp.counter = (uint8_t) n; 1118107120Sjulian break; 1119107120Sjulian 1120107120Sjulian default: 1121107120Sjulian return (USAGE); 1122107120Sjulian } 1123107120Sjulian 1124107120Sjulian /* send command */ 1125107120Sjulian n = sizeof(rp); 1126107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1127107120Sjulian NG_HCI_OCF_WRITE_NUM_BROADCAST_RETRANS), 1128107120Sjulian (char const *) &cp, sizeof(cp), 1129107120Sjulian (char *) &rp, &n) == ERROR) 1130107120Sjulian return (ERROR); 1131107120Sjulian 1132107120Sjulian if (rp.status != 0x00) { 1133107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1134107120Sjulian hci_status2str(rp.status), rp.status); 1135107120Sjulian return (FAILED); 1136107120Sjulian } 1137107120Sjulian 1138107120Sjulian return (OK); 1139107120Sjulian} /* hci_write_number_broadcast_retransmissions */ 1140107120Sjulian 1141107120Sjulian/* Send Read_Hold_Mode_Activity command to the unit */ 1142107120Sjulianstatic int 1143107120Sjulianhci_read_hold_mode_activity(int s, int argc, char **argv) 1144107120Sjulian{ 1145107120Sjulian ng_hci_read_hold_mode_activity_rp rp; 1146107120Sjulian int n; 1147107120Sjulian char buffer[1024]; 1148107120Sjulian 1149107120Sjulian n = sizeof(rp); 1150107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1151107120Sjulian NG_HCI_OCF_READ_HOLD_MODE_ACTIVITY), 1152107120Sjulian (char *) &rp, &n) == ERROR) 1153107120Sjulian return (ERROR); 1154107120Sjulian 1155107120Sjulian if (rp.status != 0x00) { 1156107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1157107120Sjulian hci_status2str(rp.status), rp.status); 1158107120Sjulian return (FAILED); 1159107120Sjulian } 1160107120Sjulian 1161107120Sjulian fprintf(stdout, "Hold Mode Activities: %#02x\n", rp.hold_mode_activity); 1162107120Sjulian if (rp.hold_mode_activity == 0) 1163107120Sjulian fprintf(stdout, "Maintain current Power State"); 1164107120Sjulian else 1165107120Sjulian fprintf(stdout, "%s", hci_hmode2str(rp.hold_mode_activity, 1166107120Sjulian buffer, sizeof(buffer))); 1167107120Sjulian 1168107120Sjulian fprintf(stdout, "\n"); 1169107120Sjulian 1170107120Sjulian return (OK); 1171107120Sjulian} /* hci_read_hold_mode_activity */ 1172107120Sjulian 1173107120Sjulian/* Send Write_Hold_Mode_Activity command to the unit */ 1174107120Sjulianstatic int 1175107120Sjulianhci_write_hold_mode_activity(int s, int argc, char **argv) 1176107120Sjulian{ 1177107120Sjulian ng_hci_write_hold_mode_activity_cp cp; 1178107120Sjulian ng_hci_write_hold_mode_activity_rp rp; 1179107120Sjulian int n; 1180107120Sjulian 1181107120Sjulian /* parse command parameters */ 1182107120Sjulian switch (argc) { 1183107120Sjulian case 1: 1184107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 4) 1185107120Sjulian return (USAGE); 1186107120Sjulian 1187128079Semax cp.hold_mode_activity = (uint8_t) n; 1188107120Sjulian break; 1189107120Sjulian 1190107120Sjulian default: 1191107120Sjulian return (USAGE); 1192107120Sjulian } 1193107120Sjulian 1194107120Sjulian /* send command */ 1195107120Sjulian n = sizeof(rp); 1196107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1197107120Sjulian NG_HCI_OCF_WRITE_HOLD_MODE_ACTIVITY), 1198107120Sjulian (char const *) &cp, sizeof(cp), 1199107120Sjulian (char *) &rp, &n) == ERROR) 1200107120Sjulian return (ERROR); 1201107120Sjulian 1202107120Sjulian if (rp.status != 0x00) { 1203107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1204107120Sjulian hci_status2str(rp.status), rp.status); 1205107120Sjulian return (FAILED); 1206107120Sjulian } 1207107120Sjulian 1208107120Sjulian return (OK); 1209107120Sjulian} /* hci_write_hold_mode_activity */ 1210107120Sjulian 1211107120Sjulian/* Send Read_SCO_Flow_Control_Enable command to the unit */ 1212107120Sjulianstatic int 1213107120Sjulianhci_read_sco_flow_control_enable(int s, int argc, char **argv) 1214107120Sjulian{ 1215107120Sjulian ng_hci_read_sco_flow_control_rp rp; 1216107120Sjulian int n; 1217107120Sjulian 1218107120Sjulian n = sizeof(rp); 1219107120Sjulian if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1220107120Sjulian NG_HCI_OCF_READ_SCO_FLOW_CONTROL), 1221107120Sjulian (char *) &rp, &n) == ERROR) 1222107120Sjulian return (ERROR); 1223107120Sjulian 1224107120Sjulian if (rp.status != 0x00) { 1225107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1226107120Sjulian hci_status2str(rp.status), rp.status); 1227107120Sjulian return (FAILED); 1228107120Sjulian } 1229107120Sjulian 1230107120Sjulian fprintf(stdout, "SCO flow control %s [%d]\n", 1231107120Sjulian rp.flow_control? "enabled" : "disabled", rp.flow_control); 1232107120Sjulian 1233107120Sjulian return (OK); 1234107120Sjulian} /* hci_read_sco_flow_control_enable */ 1235107120Sjulian 1236107120Sjulian/* Send Write_SCO_Flow_Control_Enable command to the unit */ 1237107120Sjulianstatic int 1238107120Sjulianhci_write_sco_flow_control_enable(int s, int argc, char **argv) 1239107120Sjulian{ 1240107120Sjulian ng_hci_write_sco_flow_control_cp cp; 1241107120Sjulian ng_hci_write_sco_flow_control_rp rp; 1242107120Sjulian int n; 1243107120Sjulian 1244107120Sjulian /* parse command parameters */ 1245107120Sjulian switch (argc) { 1246107120Sjulian case 1: 1247107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 1) 1248107120Sjulian return (USAGE); 1249107120Sjulian 1250128079Semax cp.flow_control = (uint8_t) n; 1251107120Sjulian break; 1252107120Sjulian 1253107120Sjulian default: 1254107120Sjulian return (USAGE); 1255107120Sjulian } 1256107120Sjulian 1257107120Sjulian /* send command */ 1258107120Sjulian n = sizeof(rp); 1259107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1260107120Sjulian NG_HCI_OCF_WRITE_SCO_FLOW_CONTROL), 1261107120Sjulian (char const *) &cp, sizeof(cp), 1262107120Sjulian (char *) &rp, &n) == ERROR) 1263107120Sjulian return (ERROR); 1264107120Sjulian 1265107120Sjulian if (rp.status != 0x00) { 1266107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1267107120Sjulian hci_status2str(rp.status), rp.status); 1268107120Sjulian return (FAILED); 1269107120Sjulian } 1270107120Sjulian 1271107120Sjulian return (OK); 1272107120Sjulian} /* hci_write_sco_flow_control_enable */ 1273107120Sjulian 1274107120Sjulian/* Send Read_Link_Supervision_Timeout command to the unit */ 1275107120Sjulianstatic int 1276107120Sjulianhci_read_link_supervision_timeout(int s, int argc, char **argv) 1277107120Sjulian{ 1278107120Sjulian ng_hci_read_link_supervision_timo_cp cp; 1279107120Sjulian ng_hci_read_link_supervision_timo_rp rp; 1280107120Sjulian int n; 1281107120Sjulian 1282107120Sjulian switch (argc) { 1283107120Sjulian case 1: 1284107120Sjulian /* connection handle */ 1285107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) 1286107120Sjulian return (USAGE); 1287107120Sjulian 1288128079Semax cp.con_handle = (uint16_t) (n & 0x0fff); 1289107120Sjulian cp.con_handle = htole16(cp.con_handle); 1290107120Sjulian break; 1291107120Sjulian 1292107120Sjulian default: 1293107120Sjulian return (USAGE); 1294107120Sjulian } 1295107120Sjulian 1296107120Sjulian /* send command */ 1297107120Sjulian n = sizeof(rp); 1298107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1299107120Sjulian NG_HCI_OCF_READ_LINK_SUPERVISION_TIMO), 1300107120Sjulian (char const *) &cp, sizeof(cp), 1301107120Sjulian (char *) &rp, &n) == ERROR) 1302107120Sjulian return (ERROR); 1303107120Sjulian 1304107120Sjulian if (rp.status != 0x00) { 1305107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1306107120Sjulian hci_status2str(rp.status), rp.status); 1307107120Sjulian return (FAILED); 1308107120Sjulian } 1309107120Sjulian 1310107120Sjulian rp.timeout = le16toh(rp.timeout); 1311107120Sjulian 1312107120Sjulian fprintf(stdout, "Connection handle: %d\n", le16toh(rp.con_handle)); 1313107120Sjulian fprintf(stdout, "Link supervision timeout: %.2f msec [%d slots]\n", 1314107120Sjulian rp.timeout * 0.625, rp.timeout); 1315107120Sjulian 1316107120Sjulian return (OK); 1317107120Sjulian} /* hci_read_link_supervision_timeout */ 1318107120Sjulian 1319107120Sjulian/* Send Write_Link_Supervision_Timeout command to the unit */ 1320107120Sjulianstatic int 1321107120Sjulianhci_write_link_supervision_timeout(int s, int argc, char **argv) 1322107120Sjulian{ 1323107120Sjulian ng_hci_write_link_supervision_timo_cp cp; 1324107120Sjulian ng_hci_write_link_supervision_timo_rp rp; 1325107120Sjulian int n; 1326107120Sjulian 1327107120Sjulian switch (argc) { 1328107120Sjulian case 2: 1329107120Sjulian /* connection handle */ 1330107120Sjulian if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) 1331107120Sjulian return (USAGE); 1332107120Sjulian 1333128079Semax cp.con_handle = (uint16_t) (n & 0x0fff); 1334107120Sjulian cp.con_handle = htole16(cp.con_handle); 1335107120Sjulian 1336107120Sjulian /* link supervision timeout */ 1337131216Semax if (sscanf(argv[1], "%d", &n) != 1 || n < 0 || n > 0xffff) 1338107120Sjulian return (USAGE); 1339107120Sjulian 1340128079Semax cp.timeout = (uint16_t) (n & 0x0fff); 1341107120Sjulian cp.timeout = htole16(cp.timeout); 1342107120Sjulian break; 1343107120Sjulian 1344107120Sjulian default: 1345107120Sjulian return (USAGE); 1346107120Sjulian } 1347107120Sjulian 1348107120Sjulian /* send command */ 1349107120Sjulian n = sizeof(rp); 1350107120Sjulian if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1351107120Sjulian NG_HCI_OCF_WRITE_LINK_SUPERVISION_TIMO), 1352107120Sjulian (char const *) &cp, sizeof(cp), 1353107120Sjulian (char *) &rp, &n) == ERROR) 1354107120Sjulian return (ERROR); 1355107120Sjulian 1356107120Sjulian if (rp.status != 0x00) { 1357107120Sjulian fprintf(stdout, "Status: %s [%#02x]\n", 1358107120Sjulian hci_status2str(rp.status), rp.status); 1359107120Sjulian return (FAILED); 1360107120Sjulian } 1361107120Sjulian 1362107120Sjulian return (OK); 1363107120Sjulian} /* hci_write_link_supervision_timeout */ 1364107120Sjulian 1365121054Semax/* Send Read_Page_Scan_Period_Mode command to the unit */ 1366121054Semaxstatic int 1367121054Semaxhci_read_page_scan_period_mode(int s, int argc, char **argv) 1368121054Semax{ 1369121054Semax ng_hci_read_page_scan_period_rp rp; 1370121054Semax int n; 1371121054Semax 1372121054Semax n = sizeof(rp); 1373121054Semax if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1374121054Semax NG_HCI_OCF_READ_PAGE_SCAN_PERIOD), 1375121054Semax (char *) &rp, &n) == ERROR) 1376121054Semax return (ERROR); 1377121054Semax 1378121054Semax if (rp.status != 0x00) { 1379121054Semax fprintf(stdout, "Status: %s [%#02x]\n", 1380121054Semax hci_status2str(rp.status), rp.status); 1381121054Semax return (FAILED); 1382121054Semax } 1383121054Semax 1384121054Semax fprintf(stdout, "Page scan period mode: %#02x\n", 1385121054Semax rp.page_scan_period_mode); 1386121054Semax 1387121054Semax return (OK); 1388121054Semax} /* hci_read_page_scan_period_mode */ 1389121054Semax 1390121054Semax/* Send Write_Page_Scan_Period_Mode command to the unit */ 1391121054Semaxstatic int 1392121054Semaxhci_write_page_scan_period_mode(int s, int argc, char **argv) 1393121054Semax{ 1394121054Semax ng_hci_write_page_scan_period_cp cp; 1395121054Semax ng_hci_write_page_scan_period_rp rp; 1396121054Semax int n; 1397121054Semax 1398121054Semax /* parse command arguments */ 1399121054Semax switch (argc) { 1400121054Semax case 1: 1401121054Semax if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 2) 1402121054Semax return (USAGE); 1403121054Semax 1404121054Semax cp.page_scan_period_mode = (n & 0xff); 1405121054Semax break; 1406121054Semax 1407121054Semax default: 1408121054Semax return (USAGE); 1409121054Semax } 1410121054Semax 1411121054Semax /* send command */ 1412121054Semax n = sizeof(rp); 1413121054Semax if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1414121054Semax NG_HCI_OCF_WRITE_PAGE_SCAN_PERIOD), 1415121054Semax (char const *) &cp, sizeof(cp), 1416121054Semax (char *) &rp, &n) == ERROR) 1417121054Semax return (ERROR); 1418121054Semax 1419121054Semax if (rp.status != 0x00) { 1420121054Semax fprintf(stdout, "Status: %s [%#02x]\n", 1421121054Semax hci_status2str(rp.status), rp.status); 1422121054Semax return (FAILED); 1423121054Semax } 1424121054Semax 1425121054Semax return (OK); 1426121054Semax} /* hci_write_page_scan_period_mode */ 1427121054Semax 1428121054Semax/* Send Read_Page_Scan_Mode command to the unit */ 1429121054Semaxstatic int 1430121054Semaxhci_read_page_scan_mode(int s, int argc, char **argv) 1431121054Semax{ 1432121054Semax ng_hci_read_page_scan_rp rp; 1433121054Semax int n; 1434121054Semax 1435121054Semax n = sizeof(rp); 1436121054Semax if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1437121054Semax NG_HCI_OCF_READ_PAGE_SCAN), 1438121054Semax (char *) &rp, &n) == ERROR) 1439121054Semax return (ERROR); 1440121054Semax 1441121054Semax if (rp.status != 0x00) { 1442121054Semax fprintf(stdout, "Status: %s [%#02x]\n", 1443121054Semax hci_status2str(rp.status), rp.status); 1444121054Semax return (FAILED); 1445121054Semax } 1446121054Semax 1447121054Semax fprintf(stdout, "Page scan mode: %#02x\n", rp.page_scan_mode); 1448121054Semax 1449121054Semax return (OK); 1450121054Semax} /* hci_read_page_scan_mode */ 1451121054Semax 1452121054Semax/* Send Write_Page_Scan_Mode command to the unit */ 1453121054Semaxstatic int 1454121054Semaxhci_write_page_scan_mode(int s, int argc, char **argv) 1455121054Semax{ 1456121054Semax ng_hci_write_page_scan_cp cp; 1457121054Semax ng_hci_write_page_scan_rp rp; 1458121054Semax int n; 1459121054Semax 1460121054Semax /* parse command arguments */ 1461121054Semax switch (argc) { 1462121054Semax case 1: 1463121054Semax if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 3) 1464121054Semax return (USAGE); 1465121054Semax 1466121054Semax cp.page_scan_mode = (n & 0xff); 1467121054Semax break; 1468121054Semax 1469121054Semax default: 1470121054Semax return (USAGE); 1471121054Semax } 1472121054Semax 1473121054Semax /* send command */ 1474121054Semax n = sizeof(rp); 1475121054Semax if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, 1476121054Semax NG_HCI_OCF_WRITE_PAGE_SCAN), 1477121054Semax (char const *) &cp, sizeof(cp), 1478121054Semax (char *) &rp, &n) == ERROR) 1479121054Semax return (ERROR); 1480121054Semax 1481121054Semax if (rp.status != 0x00) { 1482121054Semax fprintf(stdout, "Status: %s [%#02x]\n", 1483121054Semax hci_status2str(rp.status), rp.status); 1484121054Semax return (FAILED); 1485121054Semax } 1486121054Semax 1487121054Semax return (OK); 1488121054Semax} /* hci_write_page_scan_mode */ 1489121054Semax 1490107120Sjulianstruct hci_command host_controller_baseband_commands[] = { 1491107120Sjulian{ 1492107120Sjulian"reset", 1493107120Sjulian"\nThe Reset command will reset the Host Controller and the Link Manager.\n" \ 1494107120Sjulian"After the reset is completed, the current operational state will be lost,\n" \ 1495107120Sjulian"the Bluetooth unit will enter standby mode and the Host Controller will\n" \ 1496107120Sjulian"automatically revert to the default values for the parameters for which\n" \ 1497107120Sjulian"default values are defined in the specification.", 1498107120Sjulian&hci_reset 1499107120Sjulian}, 1500107120Sjulian{ 1501107120Sjulian"read_pin_type", 1502107120Sjulian"\nThe Read_PIN_Type command is used for the Host to read whether the Link\n" \ 1503107120Sjulian"Manager assumes that the Host supports variable PIN codes only a fixed PIN\n" \ 1504107120Sjulian"code.", 1505107120Sjulian&hci_read_pin_type 1506107120Sjulian}, 1507107120Sjulian{ 1508107120Sjulian"write_pin_type <pin_type>", 1509107120Sjulian"\nThe Write_PIN_Type command is used for the Host to write to the Host\n" \ 1510107120Sjulian"Controller whether the Host supports variable PIN codes or only a fixed PIN\n"\ 1511107120Sjulian"code.\n\n" \ 1512107120Sjulian"\t<pin_type> - dd; 0 - Variable; 1 - Fixed", 1513107120Sjulian&hci_write_pin_type 1514107120Sjulian}, 1515107120Sjulian{ 1516133178Semax"read_stored_link_key [<BD_ADDR>]", 1517107120Sjulian"\nThe Read_Stored_Link_Key command provides the ability to read one or\n" \ 1518107120Sjulian"more link keys stored in the Bluetooth Host Controller. The Bluetooth Host\n" \ 1519107120Sjulian"Controller can store a limited number of link keys for other Bluetooth\n" \ 1520107120Sjulian"devices.\n\n" \ 1521133178Semax"\t<BD_ADDR> - xx:xx:xx:xx:xx:xx BD_ADDR or name", 1522107120Sjulian&hci_read_stored_link_key 1523107120Sjulian}, 1524107120Sjulian{ 1525133178Semax"write_stored_link_key <BD_ADDR> <key>", 1526107120Sjulian"\nThe Write_Stored_Link_Key command provides the ability to write one\n" \ 1527107120Sjulian"or more link keys to be stored in the Bluetooth Host Controller. The\n" \ 1528107120Sjulian"Bluetooth Host Controller can store a limited number of link keys for other\n"\ 1529107120Sjulian"Bluetooth devices. If no additional space is available in the Bluetooth\n"\ 1530107120Sjulian"Host Controller then no additional link keys will be stored.\n\n" \ 1531133178Semax"\t<BD_ADDR> - xx:xx:xx:xx:xx:xx BD_ADDR or name\n" \ 1532133178Semax"\t<key> - xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx up to 16 bytes link key", 1533107120Sjulian&hci_write_stored_link_key 1534107120Sjulian}, 1535107120Sjulian{ 1536133178Semax"delete_stored_link_key [<BD_ADDR>]", 1537107120Sjulian"\nThe Delete_Stored_Link_Key command provides the ability to remove one\n" \ 1538107120Sjulian"or more of the link keys stored in the Bluetooth Host Controller. The\n" \ 1539107120Sjulian"Bluetooth Host Controller can store a limited number of link keys for other\n"\ 1540107120Sjulian"Bluetooth devices.\n\n" \ 1541133178Semax"\t<BD_ADDR> - xx:xx:xx:xx:xx:xx BD_ADDR or name", 1542107120Sjulian&hci_delete_stored_link_key 1543107120Sjulian}, 1544107120Sjulian{ 1545107120Sjulian"change_local_name <name>", 1546107120Sjulian"\nThe Change_Local_Name command provides the ability to modify the user\n" \ 1547107120Sjulian"friendly name for the Bluetooth unit.\n\n" \ 1548107120Sjulian"\t<name> - string", 1549107120Sjulian&hci_change_local_name 1550107120Sjulian}, 1551107120Sjulian{ 1552107120Sjulian"read_local_name", 1553107120Sjulian"\nThe Read_Local_Name command provides the ability to read the\n" \ 1554107120Sjulian"stored user-friendly name for the Bluetooth unit.", 1555107120Sjulian&hci_read_local_name 1556107120Sjulian}, 1557107120Sjulian{ 1558107120Sjulian"read_connection_accept_timeout", 1559107120Sjulian"\nThis command will read the value for the Connection_Accept_Timeout\n" \ 1560107120Sjulian"configuration parameter. The Connection_Accept_Timeout configuration\n" \ 1561107120Sjulian"parameter allows the Bluetooth hardware to automatically deny a\n" \ 1562107120Sjulian"connection request after a specified time period has occurred and\n" \ 1563107120Sjulian"the new connection is not accepted. Connection Accept Timeout\n" \ 1564107120Sjulian"measured in Number of Baseband slots.", 1565107120Sjulian&hci_read_connection_accept_timeout 1566107120Sjulian}, 1567107120Sjulian{ 1568107120Sjulian"write_connection_accept_timeout <timeout>", 1569107120Sjulian"\nThis command will write the value for the Connection_Accept_Timeout\n" \ 1570107120Sjulian"configuration parameter.\n\n" \ 1571107120Sjulian"\t<timeout> - dddd; measured in number of baseband slots.", 1572107120Sjulian&hci_write_connection_accept_timeout 1573107120Sjulian}, 1574107120Sjulian{ 1575107120Sjulian"read_page_timeout", 1576107120Sjulian"\nThis command will read the value for the Page_Timeout configuration\n" \ 1577107120Sjulian"parameter. The Page_Timeout configuration parameter defines the\n" \ 1578107120Sjulian"maximum time the local Link Manager will wait for a baseband page\n" \ 1579107120Sjulian"response from the remote unit at a locally initiated connection\n" \ 1580107120Sjulian"attempt. Page Timeout measured in Number of Baseband slots.", 1581107120Sjulian&hci_read_page_timeout 1582107120Sjulian}, 1583107120Sjulian{ 1584107120Sjulian"write_page_timeout <timeout>", 1585107120Sjulian"\nThis command will write the value for the Page_Timeout configuration\n" \ 1586107120Sjulian"parameter.\n\n" \ 1587107120Sjulian"\t<timeout> - dddd; measured in number of baseband slots.", 1588107120Sjulian&hci_write_page_timeout 1589107120Sjulian}, 1590107120Sjulian{ 1591107120Sjulian"read_scan_enable", 1592107120Sjulian"\nThis command will read the value for the Scan_Enable parameter. The\n" \ 1593107120Sjulian"Scan_Enable parameter controls whether or not the Bluetooth uint\n" \ 1594107120Sjulian"will periodically scan for page attempts and/or inquiry requests\n" \ 1595107120Sjulian"from other Bluetooth unit.\n\n" \ 1596107120Sjulian"\t0x00 - No Scans enabled.\n" \ 1597107120Sjulian"\t0x01 - Inquiry Scan enabled. Page Scan disabled.\n" \ 1598107120Sjulian"\t0x02 - Inquiry Scan disabled. Page Scan enabled.\n" \ 1599107120Sjulian"\t0x03 - Inquiry Scan enabled. Page Scan enabled.", 1600107120Sjulian&hci_read_scan_enable 1601107120Sjulian}, 1602107120Sjulian{ 1603107120Sjulian"write_scan_enable <scan_enable>", 1604107120Sjulian"\nThis command will write the value for the Scan_Enable parameter.\n" \ 1605107120Sjulian"The Scan_Enable parameter controls whether or not the Bluetooth\n" \ 1606107120Sjulian"unit will periodically scan for page attempts and/or inquiry\n" \ 1607107120Sjulian"requests from other Bluetooth unit.\n\n" \ 1608107120Sjulian"\t<scan_enable> - dd;\n" \ 1609107120Sjulian"\t0 - No Scans enabled.\n" \ 1610107120Sjulian"\t1 - Inquiry Scan enabled. Page Scan disabled.\n" \ 1611107120Sjulian"\t2 - Inquiry Scan disabled. Page Scan enabled.\n" \ 1612107120Sjulian"\t3 - Inquiry Scan enabled. Page Scan enabled.", 1613107120Sjulian&hci_write_scan_enable 1614107120Sjulian}, 1615107120Sjulian{ 1616107120Sjulian"read_page_scan_activity", 1617107120Sjulian"\nThis command will read the value for Page_Scan_Activity configuration\n" \ 1618107120Sjulian"parameters. The Page_Scan_Interval configuration parameter defines the\n" \ 1619107120Sjulian"amount of time between consecutive page scans. This time interval is \n" \ 1620107120Sjulian"defined from when the Host Controller started its last page scan until\n" \ 1621107120Sjulian"it begins the next page scan. The Page_Scan_Window configuration parameter\n" \ 1622107120Sjulian"defines the amount of time for the duration of the page scan. The\n" \ 1623107120Sjulian"Page_Scan_Window can only be less than or equal to the Page_Scan_Interval.", 1624107120Sjulian&hci_read_page_scan_activity 1625107120Sjulian}, 1626107120Sjulian{ 1627107120Sjulian"write_page_scan_activity interval(dddd) window(dddd)", 1628107120Sjulian"\nThis command will write the value for Page_Scan_Activity configuration\n" \ 1629107120Sjulian"parameter. The Page_Scan_Interval configuration parameter defines the\n" \ 1630107120Sjulian"amount of time between consecutive page scans. This is defined as the time\n" \ 1631107120Sjulian"interval from when the Host Controller started its last page scan until it\n" \ 1632107120Sjulian"begins the next page scan. The Page_Scan_Window configuration parameter\n" \ 1633107120Sjulian"defines the amount of time for the duration of the page scan. \n" \ 1634107120Sjulian"The Page_Scan_Window can only be less than or equal to the Page_Scan_Interval.\n\n" \ 1635228976Suqs"\t<interval> - Range: 0x0012 -- 0x100, Time = N * 0.625 msec\n" \ 1636229075Sstefanf"\t<window> - Range: 0x0012 -- 0x100, Time = N * 0.625 msec", 1637107120Sjulian&hci_write_page_scan_activity 1638107120Sjulian}, 1639107120Sjulian{ 1640107120Sjulian"read_inquiry_scan_activity", 1641107120Sjulian"\nThis command will read the value for Inquiry_Scan_Activity configuration\n" \ 1642107120Sjulian"parameter. The Inquiry_Scan_Interval configuration parameter defines the\n" \ 1643107120Sjulian"amount of time between consecutive inquiry scans. This is defined as the\n" \ 1644107120Sjulian"time interval from when the Host Controller started its last inquiry scan\n" \ 1645107120Sjulian"until it begins the next inquiry scan.", 1646107120Sjulian&hci_read_inquiry_scan_activity 1647107120Sjulian}, 1648107120Sjulian{ 1649107120Sjulian"write_inquiry_scan_activity interval(dddd) window(dddd)", 1650107120Sjulian"\nThis command will write the value for Inquiry_Scan_Activity configuration\n"\ 1651107120Sjulian"parameter. The Inquiry_Scan_Interval configuration parameter defines the\n" \ 1652107120Sjulian"amount of time between consecutive inquiry scans. This is defined as the\n" \ 1653107120Sjulian"time interval from when the Host Controller started its last inquiry scan\n" \ 1654107120Sjulian"until it begins the next inquiry scan. The Inquiry_Scan_Window configuration\n" \ 1655107120Sjulian"parameter defines the amount of time for the duration of the inquiry scan.\n" \ 1656107120Sjulian"The Inquiry_Scan_Window can only be less than or equal to the Inquiry_Scan_Interval.\n\n" \ 1657228976Suqs"\t<interval> - Range: 0x0012 -- 0x100, Time = N * 0.625 msec\n" \ 1658229075Sstefanf"\t<window> - Range: 0x0012 -- 0x100, Time = N * 0.625 msec", 1659107120Sjulian&hci_write_inquiry_scan_activity 1660107120Sjulian}, 1661107120Sjulian{ 1662107120Sjulian"read_authentication_enable", 1663107120Sjulian"\nThis command will read the value for the Authentication_Enable parameter.\n"\ 1664107120Sjulian"The Authentication_Enable parameter controls if the local unit requires\n"\ 1665107120Sjulian"to authenticate the remote unit at connection setup (between the\n" \ 1666107120Sjulian"Create_Connection command or acceptance of an incoming ACL connection\n"\ 1667107120Sjulian"and the corresponding Connection Complete event). At connection setup, only\n"\ 1668107120Sjulian"the unit(s) with the Authentication_Enable parameter enabled will try to\n"\ 1669107120Sjulian"authenticate the other unit.", 1670107120Sjulian&hci_read_authentication_enable 1671107120Sjulian}, 1672107120Sjulian{ 1673107120Sjulian"write_authentication_enable enable(0|1)", 1674107120Sjulian"\nThis command will write the value for the Authentication_Enable parameter.\n"\ 1675107120Sjulian"The Authentication_Enable parameter controls if the local unit requires to\n"\ 1676107120Sjulian"authenticate the remote unit at connection setup (between the\n" \ 1677107120Sjulian"Create_Connection command or acceptance of an incoming ACL connection\n" \ 1678107120Sjulian"and the corresponding Connection Complete event). At connection setup, only\n"\ 1679107120Sjulian"the unit(s) with the Authentication_Enable parameter enabled will try to\n"\ 1680107120Sjulian"authenticate the other unit.", 1681107120Sjulian&hci_write_authentication_enable 1682107120Sjulian}, 1683107120Sjulian{ 1684107120Sjulian"read_encryption_mode", 1685107120Sjulian"\nThis command will read the value for the Encryption_Mode parameter. The\n" \ 1686107120Sjulian"Encryption_Mode parameter controls if the local unit requires encryption\n" \ 1687107120Sjulian"to the remote unit at connection setup (between the Create_Connection\n" \ 1688107120Sjulian"command or acceptance of an incoming ACL connection and the corresponding\n" \ 1689107120Sjulian"Connection Complete event). At connection setup, only the unit(s) with\n" \ 1690107120Sjulian"the Authentication_Enable parameter enabled and Encryption_Mode parameter\n" \ 1691107120Sjulian"enabled will try to encrypt the connection to the other unit.\n\n" \ 1692107120Sjulian"\t<encryption_mode>:\n" \ 1693107120Sjulian"\t0x00 - Encryption disabled.\n" \ 1694107120Sjulian"\t0x01 - Encryption only for point-to-point packets.\n" \ 1695107120Sjulian"\t0x02 - Encryption for both point-to-point and broadcast packets.", 1696107120Sjulian&hci_read_encryption_mode 1697107120Sjulian}, 1698107120Sjulian{ 1699107120Sjulian"write_encryption_mode mode(0|1|2)", 1700107120Sjulian"\tThis command will write the value for the Encryption_Mode parameter.\n" \ 1701107120Sjulian"The Encryption_Mode parameter controls if the local unit requires\n" \ 1702107120Sjulian"encryption to the remote unit at connection setup (between the\n" \ 1703107120Sjulian"Create_Connection command or acceptance of an incoming ACL connection\n" \ 1704107120Sjulian"and the corresponding Connection Complete event). At connection setup,\n" \ 1705107120Sjulian"only the unit(s) with the Authentication_Enable parameter enabled and\n" \ 1706107120Sjulian"Encryption_Mode parameter enabled will try to encrypt the connection to\n" \ 1707107120Sjulian"the other unit.\n\n" \ 1708107120Sjulian"\t<encryption_mode> (dd)\n" \ 1709107120Sjulian"\t0 - Encryption disabled.\n" \ 1710107120Sjulian"\t1 - Encryption only for point-to-point packets.\n" \ 1711107120Sjulian"\t2 - Encryption for both point-to-point and broadcast packets.", 1712107120Sjulian&hci_write_encryption_mode 1713107120Sjulian}, 1714107120Sjulian{ 1715107120Sjulian"read_class_of_device", 1716107120Sjulian"\nThis command will read the value for the Class_of_Device parameter.\n" \ 1717107120Sjulian"The Class_of_Device parameter is used to indicate the capabilities of\n" \ 1718107120Sjulian"the local unit to other units.", 1719107120Sjulian&hci_read_class_of_device 1720107120Sjulian}, 1721107120Sjulian{ 1722107120Sjulian"write_class_of_device class(xx:xx:xx)", 1723107120Sjulian"\nThis command will write the value for the Class_of_Device parameter.\n" \ 1724107120Sjulian"The Class_of_Device parameter is used to indicate the capabilities of \n" \ 1725107120Sjulian"the local unit to other units.\n\n" \ 1726107120Sjulian"\t<class> (xx:xx:xx) - class of device", 1727107120Sjulian&hci_write_class_of_device 1728107120Sjulian}, 1729107120Sjulian{ 1730107120Sjulian"read_voice_settings", 1731107120Sjulian"\nThis command will read the values for the Voice_Setting parameter.\n" \ 1732107120Sjulian"The Voice_Setting parameter controls all the various settings for voice\n" \ 1733107120Sjulian"connections. These settings apply to all voice connections, and cannot be\n" \ 1734107120Sjulian"set for individual voice connections. The Voice_Setting parameter controls\n" \ 1735107120Sjulian"the configuration for voice connections: Input Coding, Air coding format,\n" \ 1736107120Sjulian"input data format, Input sample size, and linear PCM parameter.", 1737107120Sjulian&hci_read_voice_settings 1738107120Sjulian}, 1739107120Sjulian{ 1740107120Sjulian"write_voice_settings settings(xxxx)", 1741107120Sjulian"\nThis command will write the values for the Voice_Setting parameter.\n" \ 1742107120Sjulian"The Voice_Setting parameter controls all the various settings for voice\n" \ 1743107120Sjulian"connections. These settings apply to all voice connections, and cannot be\n" \ 1744107120Sjulian"set for individual voice connections. The Voice_Setting parameter controls\n" \ 1745107120Sjulian"the configuration for voice connections: Input Coding, Air coding format,\n" \ 1746107120Sjulian"input data format, Input sample size, and linear PCM parameter.\n\n" \ 1747107120Sjulian"\t<voice_settings> (xxxx) - voice settings", 1748107120Sjulian&hci_write_voice_settings 1749107120Sjulian}, 1750107120Sjulian{ 1751107120Sjulian"read_number_broadcast_retransmissions", 1752107120Sjulian"\nThis command will read the unit's parameter value for the Number of\n" \ 1753107120Sjulian"Broadcast Retransmissions. Broadcast packets are not acknowledged and are\n" \ 1754107120Sjulian"unreliable.", 1755107120Sjulian&hci_read_number_broadcast_retransmissions 1756107120Sjulian}, 1757107120Sjulian{ 1758107120Sjulian"write_number_broadcast_retransmissions count(dd)", 1759107120Sjulian"\nThis command will write the unit's parameter value for the Number of\n" \ 1760107120Sjulian"Broadcast Retransmissions. Broadcast packets are not acknowledged and are\n" \ 1761107120Sjulian"unreliable.\n\n" \ 1762107120Sjulian"\t<count> (dd) - number of broadcast retransimissions", 1763107120Sjulian&hci_write_number_broadcast_retransmissions 1764107120Sjulian}, 1765107120Sjulian{ 1766107120Sjulian"read_hold_mode_activity", 1767107120Sjulian"\nThis command will read the value for the Hold_Mode_Activity parameter.\n" \ 1768107120Sjulian"The Hold_Mode_Activity value is used to determine what activities should\n" \ 1769107120Sjulian"be suspended when the unit is in hold mode.", 1770107120Sjulian&hci_read_hold_mode_activity 1771107120Sjulian}, 1772107120Sjulian{ 1773107120Sjulian"write_hold_mode_activity settings(0|1|2|4)", 1774107120Sjulian"\nThis command will write the value for the Hold_Mode_Activity parameter.\n" \ 1775107120Sjulian"The Hold_Mode_Activity value is used to determine what activities should\n" \ 1776107120Sjulian"be suspended when the unit is in hold mode.\n\n" \ 1777107120Sjulian"\t<settings> (dd) - bit mask:\n" \ 1778107120Sjulian"\t0 - Maintain current Power State. Default\n" \ 1779107120Sjulian"\t1 - Suspend Page Scan.\n" \ 1780107120Sjulian"\t2 - Suspend Inquiry Scan.\n" \ 1781107120Sjulian"\t4 - Suspend Periodic Inquiries.", 1782107120Sjulian&hci_write_hold_mode_activity 1783107120Sjulian}, 1784107120Sjulian{ 1785107120Sjulian"read_sco_flow_control_enable", 1786107120Sjulian"\nThe Read_SCO_Flow_Control_Enable command provides the ability to read\n" \ 1787107120Sjulian"the SCO_Flow_Control_Enable setting. By using this setting, the Host can\n" \ 1788107120Sjulian"decide if the Host Controller will send Number Of Completed Packets events\n" \ 1789107120Sjulian"for SCO Connection Handles. This setting allows the Host to enable and\n" \ 1790107120Sjulian"disable SCO flow control.", 1791107120Sjulian&hci_read_sco_flow_control_enable 1792107120Sjulian}, 1793107120Sjulian{ 1794107120Sjulian"write_sco_flow_control_enable enable(0|1)", 1795107120Sjulian"\nThe Write_SCO_Flow_Control_Enable command provides the ability to write\n" \ 1796107120Sjulian"the SCO_Flow_Control_Enable setting. By using this setting, the Host can\n" \ 1797107120Sjulian"decide if the Host Controller will send Number Of Completed Packets events\n" \ 1798107120Sjulian"for SCO Connection Handles. This setting allows the Host to enable and\n" \ 1799107120Sjulian"disable SCO flow control. The SCO_Flow_Control_Enable setting can only be\n" \ 1800107120Sjulian"changed if no connections exist.", 1801107120Sjulian&hci_write_sco_flow_control_enable 1802107120Sjulian}, 1803107120Sjulian{ 1804107120Sjulian"read_link_supervision_timeout <connection_handle>", 1805107120Sjulian"\nThis command will read the value for the Link_Supervision_Timeout\n" \ 1806107120Sjulian"parameter for the device. The Link_Supervision_Timeout parameter is used\n" \ 1807107120Sjulian"by the master or slave Bluetooth device to monitor link loss. If, for any\n" \ 1808107120Sjulian"reason, no Baseband packets are received from that Connection Handle for a\n" \ 1809107120Sjulian"duration longer than the Link_Supervision_Timeout, the connection is\n" 1810107120Sjulian"disconnected.\n\n" \ 1811107120Sjulian"\t<connection_handle> - dddd; connection handle\n", 1812107120Sjulian&hci_read_link_supervision_timeout 1813107120Sjulian}, 1814107120Sjulian{ 1815107120Sjulian"write_link_supervision_timeout <connection_handle> <timeout>", 1816107120Sjulian"\nThis command will write the value for the Link_Supervision_Timeout\n" \ 1817107120Sjulian"parameter for the device. The Link_Supervision_Timeout parameter is used\n" \ 1818107120Sjulian"by the master or slave Bluetooth device to monitor link loss. If, for any\n" \ 1819107120Sjulian"reason, no Baseband packets are received from that connection handle for a\n" \ 1820107120Sjulian"duration longer than the Link_Supervision_Timeout, the connection is\n" \ 1821107120Sjulian"disconnected.\n\n" \ 1822107120Sjulian"\t<connection_handle> - dddd; connection handle\n" \ 1823107120Sjulian"\t<timeout> - dddd; timeout measured in number of baseband slots\n", 1824107120Sjulian&hci_write_link_supervision_timeout 1825107120Sjulian}, 1826121054Semax{ 1827121054Semax"read_page_scan_period_mode", 1828121054Semax"\nThis command is used to read the mandatory Page_Scan_Period_Mode of the\n" \ 1829121054Semax"local Bluetooth device. Every time an inquiry response message is sent, the\n"\ 1830121054Semax"Bluetooth device will start a timer (T_mandatory_pscan), the value of which\n"\ 1831121054Semax"is dependent on the Page_Scan_Period_Mode. As long as this timer has not\n" \ 1832121054Semax"expired, the Bluetooth device will use the Page_Scan_Period_Mode for all\n" \ 1833121054Semax"following page scans.", 1834121054Semax&hci_read_page_scan_period_mode 1835121054Semax}, 1836121054Semax{ 1837121054Semax"write_page_scan_period_mode <page_scan_period_mode>", 1838121054Semax"\nThis command is used to write the mandatory Page_Scan_Period_Mode of the\n" \ 1839121054Semax"local Bluetooth device. Every time an inquiry response message is sent, the\n"\ 1840121054Semax"Bluetooth device will start a timer (T_mandatory_pscan), the value of which\n"\ 1841121054Semax"is dependent on the Page_Scan_Period_Mode. As long as this timer has not\n" \ 1842121054Semax"expired, the Bluetooth device will use the Page_Scan_Period_Mode for all\n" \ 1843121054Semax"following page scans.\n\n" \ 1844121054Semax"\t<page_scan_period_mode> - dd; page scan period mode:\n" \ 1845121054Semax"\t0x00 - P0 (Default)\n" \ 1846121054Semax"\t0x01 - P1\n" \ 1847121054Semax"\t0x02 - P2", 1848121054Semax&hci_write_page_scan_period_mode 1849121054Semax}, 1850121054Semax{ 1851121054Semax"read_page_scan_mode", 1852121054Semax"\nThis command is used to read the default page scan mode of the local\n" \ 1853121054Semax"Bluetooth device. The Page_Scan_Mode parameter indicates the page scan mode\n"\ 1854121054Semax"that is used for the default page scan. Currently one mandatory page scan\n"\ 1855121054Semax"mode and three optional page scan modes are defined. Following an inquiry\n" \ 1856121054Semax"response, if the Baseband timer T_mandatory_pscan has not expired, the\n" \ 1857121054Semax"mandatory page scan mode must be applied.", 1858121054Semax&hci_read_page_scan_mode 1859121054Semax}, 1860121054Semax{ 1861121054Semax"write_page_scan_mode <page_scan_mode>", 1862121054Semax"\nThis command is used to write the default page scan mode of the local\n" \ 1863121054Semax"Bluetooth device. The Page_Scan_Mode parameter indicates the page scan mode\n"\ 1864121054Semax"that is used for the default page scan. Currently, one mandatory page scan\n"\ 1865121054Semax"mode and three optional page scan modes are defined. Following an inquiry\n"\ 1866121054Semax"response, if the Baseband timer T_mandatory_pscan has not expired, the\n" \ 1867121054Semax"mandatory page scan mode must be applied.\n\n" \ 1868121054Semax"\t<page_scan_mode> - dd; page scan mode:\n" \ 1869121054Semax"\t0x00 - Mandatory Page Scan Mode (Default)\n" \ 1870121054Semax"\t0x01 - Optional Page Scan Mode I\n" \ 1871121054Semax"\t0x02 - Optional Page Scan Mode II\n" \ 1872121054Semax"\t0x03 - Optional Page Scan Mode III", 1873121054Semax&hci_write_page_scan_mode 1874121054Semax}, 1875107120Sjulian{ NULL, } 1876107120Sjulian}; 1877107120Sjulian 1878