path: root/tools/btconfig.c

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/** Bluetooth configuration for dream (debug only)  */

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/uio.h>
#include <unistd.h>

#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
#include <bluetooth/sco.h>

int vendor_setup_pcm(int sock) {
    /* Use vendor-specific HCI commands to set up SCO over HCI pr PCM */
    int rc;
    unsigned char type = HCI_COMMAND_PKT;
    hci_command_hdr hdr;
    /* HCI_VS_Write_SCO_Configuration_Island3
    * This command is used to configure the codec interface paramters and
    * includes configuration of the PCM clock rate which is relevant when BT
    * core is generating the clock. This command MUST be used by the host in
    * order to use PCM interface.
    * */
    hdr.opcode = 0xFD06;
    unsigned char cmd[] = {
        0x00, 0x08,         // clock rate: 2048 kHz
        0x01,               // BRF6300 is input (slave)
        0x40, 0x1f, 00, 00, // frame sync frequency: 8kHz
        0x01, 00,           // frame sync duty cycle: 1 PCM clock
        0x01,               // frame sync edge: falling
        0x00,               // frame sync polarity: active high
        0x00,               // reserved
        // CHANNEL 1
        0x10, 0x00,         // out sample size: 16 bits
        0x00, 0x00,         // out sample offset in frame: 0 PCM clock cycle
        0x00,               // out edge: rising
        0x0E, 0x00,         // in sample size: 14 bits
        0x01, 0x00,         // in sample offset in frame: 1 PCM clock cycle
        0x00,               // in edge: rising
        0x00,               // reserved
        // CHANNEL 2  (not used)
        0x00, 0x00,
        0x00, 0x00,
        0x00,
        0x00, 0x00,
        0x00, 0x00,
        0x00,
        0x00,
        };
    hdr.plen = sizeof(cmd);
    struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &cmd, sizeof(cmd) },
    };
    int total_len = 1 + sizeof(hdr) + sizeof(cmd);
    errno = 0;
    rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
    if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
    }
    return 0;
}

int vendor_status(int sock) {
    /* Use vendor-specific HCI command to get system status */
    int rc;
    unsigned char type = HCI_COMMAND_PKT;
    hci_command_hdr hdr;
    /* HCI_VS_Get_System_Status */
    hdr.opcode = 0xFE1F;
    unsigned char cmd[] = {};
    hdr.plen = sizeof(cmd);
    struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &cmd, sizeof(cmd) },
    };
    int total_len = 1 + sizeof(hdr) + sizeof(cmd);
    errno = 0;
    rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
    if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
    }
    return 0;
}

int vendor_sleep(int sock, int enable) {
    /* Use vendor-specific HCI command to go into deep sleep mode */
    int rc;
    unsigned char type = HCI_COMMAND_PKT;
    hci_command_hdr hdr;
    /* HCI_VS_Sleep_Mode_Configuration */
    hdr.opcode = 0xFD0C;
    unsigned char cmd[] = {
        0x01,   // big sleep (1 enable)
        enable ? 0x01 : 0x00,   // deep sleep (1 enable)
        0x00,   // deep sleep protocol mode: HCILL
        0xFF,   // reserved
        0xFF,   // output pull: don't change
        0xFF,   // input pull: don't change
        0x00,   // reserved
        0x00,   // deep sleep timeouut: 0
    };
    hdr.plen = sizeof(cmd);
    struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &cmd, sizeof(cmd) },
    };
    int total_len = 1 + sizeof(hdr) + sizeof(cmd);
    errno = 0;
    rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
    if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
    }
    return 0;
}

int vendor_uart_baudrate(int sock, uint32_t rate) {
    /* Use vendor-specific HCI command to set uart baud rate */
    int rc;
    unsigned char type = HCI_COMMAND_PKT;
    hci_command_hdr hdr;
    printf("Setting baud rate to %d\n", rate);
    /* HCI_VS_Sleep_Mode_Configuration */
    hdr.opcode = 0xFF36;
    hdr.plen = sizeof(rate);
    struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &rate, sizeof(rate) },
    };
    int total_len = 1 + sizeof(hdr) + sizeof(rate);
    errno = 0;
    rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
    if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
    }
    return 0;
}

int vendor_setup_pcm2(int sock) {
   int rc;
   unsigned char type = HCI_COMMAND_PKT;
   hci_command_hdr hdr;
   // HCI_VS_Write_CODEC_Config_Enhanced_Island3
   hdr.opcode = 0xFD07;
   unsigned char cmd[] = {
       0x00,            // PCM clock shutdown: disabled
       0x00, 0x00,      // PCM clock start
       0x00, 0x00,      // PCM clock stop
       0x00,            // reserved
       // Channel 1
       0x04,            // din order: MSB first, don't swap bytes, shift sample
       0x04,            // dout order: MSB first, don't swap bytes, shift sample
       0x02,            // dout mode: Hi-Z when idle
       0x00,            // dout duplication: disabled
       0x00, 0x00, 0x00, 0x00, // tx_dup_value
       0x00,            // data quant: bitwise
       0x00,            // reserved
       // Channel 2
       0x00,            // din order
       0x00,            // dout order
       0x00,            // dout mode
       0x00,            // dout duplication
       0x00, 0x00, 0x00, 0x00, // tx_dup_value
       0x00,            // data quant
       0x00,            // reserved
    };
   hdr.plen = sizeof(cmd);
   struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &cmd, sizeof(cmd) },
   };
   int total_len = 1 + sizeof(hdr) + sizeof(cmd);
   errno = 0;
   rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
   if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
   }
   return 0;
}

int vendor_coexist(int sock, int enable) {
    /* Use vendor-specific HCI command to set up WIFI coexistance*/
    int rc;
    unsigned char type = HCI_COMMAND_PKT;
    hci_command_hdr hdr;
    /* HCI_VS_Write_Wlan_Configuration */
    hdr.opcode = 0xFD1D;
    unsigned char cmd[] = {
        0x04,     // enable: SG2.0
        0x01,     // polarity: active high
        0xE9, 0x05, // priority: TDD, page, page scan, inquiry, inquiry scan, sniff, SCO/eSCO
        0x00, 0x00, // connection handle select
        0x00,     // connection handle: disable
        0x00,     // frequency mask: disable
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,  // freq mask: dont change
        0x04,     // wlan0 mux: IO14
        0x01,     // wlan0 input pull: enabled
        0x00,     // wlan1 mux: IO4
        0x01,     // wlan1 input pull: enabled
        0x02,     // wlan2 mux: IO3
        0x01,     // wlan2 input pull: enabled
        0x00,     // wlan3 mux: PA_OFF on IO1
        0xFF,     // wlan3 input pull: don't cahnge
        enable? 0x00 : 0x01,     // wlan interface: enable/disable
    };
    hdr.plen = sizeof(cmd);
    struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &cmd, sizeof(cmd) },
    };
    int total_len = 1 + sizeof(hdr) + sizeof(cmd);
    errno = 0;
    rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
    if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
    }
    return 0;
}

int setup_loopback1(int sock) {
   int rc;
   unsigned char type = HCI_COMMAND_PKT;
   hci_command_hdr hdr;
   // HCI_VS_Set_PCM_Loopback_Configuration_Island3 (0xFD04)
   hdr.opcode = 0xFD04;
   unsigned char cmd[] = {
       0xFF, 0x00,      // delay: 255 frame's
   };
   hdr.plen = sizeof(cmd);
   struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &cmd, sizeof(cmd) },
   };
   int total_len = 1 + sizeof(hdr) + sizeof(cmd);
   errno = 0;
   rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
   if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
   }
   return 0;
}

int setup_loopback2(int sock, int on) {
   int rc;
   unsigned char type = HCI_COMMAND_PKT;
   hci_command_hdr hdr;
   // HCI_VS_Set_PCM_Loopback_Enable (0xFE28)
   hdr.opcode = 0xFE28;
   printf("loopback %s\n", on ? "ON" : "OFF");
   unsigned char cmd[] = {
       on ? 0x01 : 0x00,  // enable
   };
   hdr.plen = sizeof(cmd);
   struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &cmd, sizeof(cmd) },
   };
   int total_len = 1 + sizeof(hdr) + sizeof(cmd);
   errno = 0;
   rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
   if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
   }
   return 0;
}


int write_voice_setting(int sock) {
   int rc;
   unsigned char type = HCI_COMMAND_PKT;
   hci_command_hdr hdr;
   // HCI_Write_Voice_Setting (0x0026)
   hdr.opcode = 0x0026;
   unsigned char cmd[] = {
       0x00, 0x00,
   };
   hdr.plen = sizeof(cmd);
   struct iovec iov[] = {
       { &type, 1 },
       { &hdr, sizeof(hdr) },
       { &cmd, sizeof(cmd) },
   };
   int total_len = 1 + sizeof(hdr) + sizeof(cmd);
   errno = 0;
   rc = writev(sock, iov, sizeof(iov)/sizeof(iov[0]));
   if (rc != total_len) {
       printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
            total_len, rc, strerror(errno), errno);
       return -1;
   }
   return 0;
}

static int vendor_specific_sco_setup(int hcifd, int over_hci) {
    /* Use vendor-specific HCI commands to set up SCO over HCI or PCM */
    int rc;
    unsigned char type = HCI_COMMAND_PKT;
    hci_command_hdr hdr;
    /* HCI_VS_Write_SCO_Configuration.
     * Once this command is issued, it is valid for all new SCO channels
     * created. It is used to determine the following paramters
     * SCO Connection type - Host (voice over HCI) or Codec
     * TX packet length used for flow control calculations
     * TX Buffer max latency determines how much time the data can be in the TX
     * buffer before being flushed out. Applicable only if flow control is
     * disabled.
     */
    hdr.opcode = 0xFE10;
    hdr.plen = 0x05;
    struct hci_sco_t {
        unsigned char conn_type;
        unsigned char packet_size;
        unsigned char max_latency[2];
        unsigned char bad_crc;
    } __attribute__((packed)) hci_sco;
    hci_sco.packet_size = 0x00; /* packet size--keep current setting */
    hci_sco.max_latency[0] = 0x00;
    hci_sco.max_latency[1] = 0x00; /* max latency--keep current setting */
    hci_sco.bad_crc     = 0xFF; /* bad CRC handling--keep current setting */
    struct iovec iov[3] = {
        { &type, 1 },
        { &hdr, sizeof(hdr) },
        { &hci_sco, sizeof(hci_sco) }
    };
    int total_len = 1 + sizeof(hdr) + sizeof(hci_sco);
    printf("Setting Vendor-specific SCO over %s.\n",
         (over_hci ? "HCI" : "PCM"));
    errno = 0;
    hci_sco.conn_type = (unsigned char)(over_hci ? 0x01 : 0x00);
    rc = writev(hcifd, iov, sizeof(iov)/sizeof(iov[0]));
    if (rc != total_len) {
        printf("Can't write %d bytes (wrote %d) to HCI socket: %s (%d)!\n",
             total_len, rc, strerror(errno), errno);
        return -1;
    }
    return 0;
}

int get_hci_sock() {
    int sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
    struct sockaddr_hci addr;
    int opt;

    if(sock < 0) {
        printf("Can't create raw socket!\n");
        return -1;
    }

    opt = 1;
    printf("Setting data direction.\n");
    if (setsockopt(sock, SOL_HCI, HCI_DATA_DIR, &opt, sizeof(opt)) < 0) {
        printf("Error setting data direction\n");
        return -1;
    }

    /* Bind socket to the HCI device */
    addr.hci_family = AF_BLUETOOTH;
    addr.hci_dev = 0;  // hci0
    printf("Binding to HCI device.\n");
    if(bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        printf("Can't attach to device hci0. %s(%d)\n",
             strerror(errno),
             errno);
        return -1;
    }
    return sock;
}

static const int num_devices = 3;
static const char device_names[3][20] = {
    "moto",
    "jabra250",
    "jabra125",
};
static const bdaddr_t device_addrs[3] = {
    {0xE1, 0x9C, 0x97, 0x2E, 0x0B, 0x00},
    {0x5E, 0x88, 0x26, 0xA4, 0x07, 0x00},
    {0xE3, 0xFD, 0x93, 0x8F, 0x16, 0x00},
};

void print_bdaddr(const bdaddr_t* bdaddr) {
    uint8_t* b = (uint8_t*)bdaddr;
    printf("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
            b[5], b[4], b[3], b[2], b[1], b[0]);
}

const bdaddr_t* get_remote_address(char* name) {
    int i;
    for (i=0; i<num_devices; i++) {
        if (strcmp(name, device_names[i]) == 0) {
            printf("Using ");
            print_bdaddr(&device_addrs[i]);
            return &device_addrs[i];
        }
    }
    printf("Unknown device: %s\n", name);
    for (i=0; i<num_devices; i++) {
        printf("%s ", device_names[i]);
        print_bdaddr(&device_addrs[i]);
    }
    exit(1);
}

void sco_setup(char *device_name) {
    struct sockaddr_sco sco_addr;
    int sco_sock;

    sco_sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);
    if (sco_sock < 0) {
        printf("Could not create SCO socket\n");
        return;
    }

    /* Bind to local address */
    memset(&sco_addr, 0, sizeof(sco_addr));
    sco_addr.sco_family = AF_BLUETOOTH;
    hci_devba(0, &sco_addr.sco_bdaddr);
    printf("Local BDADDR is: ");
    print_bdaddr(&sco_addr.sco_bdaddr);
    printf("Binding...\n");
    if (bind(sco_sock, (struct sockaddr *) &sco_addr, sizeof(sco_addr)) < 0) {
        printf("Could not bind SCO socket\n");
        return;
    }

    memset(&sco_addr, 0, sizeof(sco_addr));
    sco_addr.sco_family = AF_BLUETOOTH;
    memcpy(&sco_addr.sco_bdaddr, get_remote_address(device_name), sizeof(bdaddr_t));
    printf("Connecting SCO socket...\n");
    print_bdaddr(&sco_addr.sco_bdaddr);
    if(connect(sco_sock, (struct sockaddr *)&sco_addr, sizeof(sco_addr)) < 0) {
        printf("Could not connect to SCO socket\n");
        return;
    }

    printf("SCO socket connected\n");

    struct sco_options opts;
    struct sco_conninfo conninfo;

    socklen_t len = sizeof(opts);

    if (getsockopt(sco_sock, SOL_SCO, SCO_OPTIONS, &opts, &len) < 0) {
        printf("Couldn't not get SCO socket options\n");
        return;
    }
    printf("SCO MTU: %d\n", opts.mtu);

    len = sizeof(conninfo);
    if (getsockopt(sco_sock, SOL_SCO, SCO_CONNINFO, &conninfo, &len) < 0) {
        printf("Couldn't get SCO connection options\n");
        return;
    }
    printf("SCO HCI handle: %d\n", conninfo.hci_handle);
    printf("SCO HCI device class: %02x%02x%02x\n",
              conninfo.dev_class[0],
              conninfo.dev_class[1],
              conninfo.dev_class[2]);
}



int main(int argc, char **argv) {
    if (argc == 1) {
        goto usage;
    }

    if (argc >= 2 && strcmp(argv[1], "pcm_setup") == 0 ) {
        int sock = get_hci_sock();
        if (sock < 0) {
            printf("Could not open hci socket\n");
            return -1;
        }
        if (vendor_specific_sco_setup(sock, 0 /* set up over PCM */) < 0) {
            printf("Could not set up SCO\n");
            return -1;
        }
        sleep(1);
        if (vendor_setup_pcm(sock) < 0) {
            printf("Could not setup up PCM\n");
            return -1;
        }
        sleep(1);
    } else if (argc >= 2 && strcmp(argv[1], "pcm_setup2") == 0 ) {
        int sock = get_hci_sock();
        if (sock < 0) {
            printf("Could not open hci socket\n");
            return -1;
        }
        if (vendor_setup_pcm2(sock) < 0) {
            printf("Could not setup up PCM\n");
            return -1;
        }
        sleep(1);
    } else if (argc >= 2 && strcmp(argv[1], "loopback") == 0 ) {
        int enable = 1;
        if (argc > 2) {
            if (strcmp(argv[2], "off") == 0) {
                enable = 0;
            }
        }
        int sock = get_hci_sock();
        if (sock < 0) {
            printf("Could not open hci socket\n");
            return -1;
        }
        setup_loopback1(sock);
        setup_loopback2(sock, enable);
        sleep(1);
    } else if (argc >= 2 && strcmp(argv[1], "sleep") == 0 ) {
        int enable = 1;
        if (argc > 2) {
            if (strcmp(argv[2], "off") == 0) {
                enable = 0;
            }
        }
        int sock = get_hci_sock();
        if (sock < 0) {
            printf("Could not open hci socket\n");
            return -1;
        }
        vendor_sleep(sock, enable);
        sleep(1);
    } else if (argc >= 2 && strcmp(argv[1], "coed") == 0 ) {
        int enable = 1;
        if (argc > 2) {
            if (strcmp(argv[2], "off") == 0) {
                enable = 0;
            }
        }
        int sock = get_hci_sock();
        if (sock < 0) {
            printf("Could not open hci socket\n");
            return -1;
        }
        vendor_coexist(sock, enable);
        sleep(1);
    } else if (argc >= 3 && strcmp(argv[1], "rate") == 0 ) {
        uint32_t rate = atoi(argv[2]);
        int sock = get_hci_sock();
        if (sock < 0) {
            printf("Could not open hci socket\n");
            return -1;
        }
        vendor_uart_baudrate(sock, rate);
        sleep(1);
    } else if (argc >= 2 && strcmp(argv[1], "vs_status") == 0 ) {
        int sock = get_hci_sock();
        if (sock < 0) {
            printf("Could not open hci socket\n");
            return -1;
        }
        vendor_status(sock);
        sleep(1);
    } else if (argc >= 3 && strcmp(argv[1], "sco_setup") == 0 ) {
        sco_setup(argv[2]);
        sleep(100000000);
    } else {
usage:
        printf("Usage:\n");
        printf("\tbtconfig sleep [on|off]\n");
        printf("\tbtconfig vs_status\n");
        printf("\tbtconfig pcm_setup\n");
        printf("\tbtconfig pcm_setup2\n");
        printf("\tbtconfig sco_setup DEVICE_ALIAS\n");
        printf("\tbtconfig loopback [on|off]\n");
        printf("\tbtconfig coed [on|off]\n");
        printf("\tbtconfig rate RATE\n");
        printf("\n");
        return 0;
    }

    return 0;
}