/*
|
*
|
* BlueZ - Bluetooth protocol stack for Linux
|
*
|
* Copyright (C) 2000-2001 Qualcomm Incorporated
|
* Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
|
* Copyright (C) 2002-2010 Marcel Holtmann <marcel@holtmann.org>
|
*
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
*
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
#include <config.h>
|
#endif
|
|
#define _GNU_SOURCE
|
#include <stdio.h>
|
#include <errno.h>
|
#include <fcntl.h>
|
#include <unistd.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <signal.h>
|
#include <syslog.h>
|
#include <termios.h>
|
#include <time.h>
|
#include <sys/time.h>
|
#include <sys/poll.h>
|
#include <sys/param.h>
|
#include <sys/ioctl.h>
|
#include <sys/socket.h>
|
#include <sys/uio.h>
|
|
#include "hciattach.h"
|
|
#ifdef NEED_PPOLL
|
#include "ppoll.h"
|
#endif
|
|
struct uart_t {
|
char *type;
|
int m_id;
|
int p_id;
|
int proto;
|
int init_speed;
|
int speed;
|
int flags;
|
int pm;
|
char *bdaddr;
|
int (*init) (int fd, struct uart_t *u, struct termios *ti);
|
int (*post) (int fd, struct uart_t *u, struct termios *ti);
|
};
|
|
#define FLOW_CTL 0x0001
|
#define ENABLE_PM 1
|
#define DISABLE_PM 0
|
|
static volatile sig_atomic_t __io_canceled = 0;
|
|
static void sig_hup(int sig)
|
{
|
printf("sig hup.\n");
|
}
|
|
static void sig_term(int sig)
|
{
|
switch (sig) {
|
case SIGINT:
|
printf("sig int.\n");
|
break;
|
case SIGTERM:
|
printf("sig term.\n");
|
break;
|
}
|
__io_canceled = 1;
|
}
|
|
static void sig_alarm(int sig)
|
{
|
fprintf(stderr, "Initialization timed out.\n");
|
exit(1);
|
}
|
|
static int uart_speed(int s)
|
{
|
switch (s) {
|
case 9600:
|
return B9600;
|
case 19200:
|
return B19200;
|
case 38400:
|
return B38400;
|
case 57600:
|
return B57600;
|
case 115200:
|
return B115200;
|
case 230400:
|
return B230400;
|
case 460800:
|
return B460800;
|
case 500000:
|
return B500000;
|
case 576000:
|
return B576000;
|
case 921600:
|
return B921600;
|
case 1000000:
|
return B1000000;
|
case 1152000:
|
return B1152000;
|
case 1500000:
|
return B1500000;
|
case 2000000:
|
return B2000000;
|
#ifdef B2500000
|
case 2500000:
|
return B2500000;
|
#endif
|
#ifdef B3000000
|
case 3000000:
|
return B3000000;
|
#endif
|
#ifdef B3500000
|
case 3500000:
|
return B3500000;
|
#endif
|
#ifdef B4000000
|
case 4000000:
|
return B4000000;
|
#endif
|
default:
|
return B57600;
|
}
|
}
|
|
int set_speed(int fd, struct termios *ti, int speed)
|
{
|
if (cfsetospeed(ti, uart_speed(speed)) < 0)
|
return -errno;
|
|
if (cfsetispeed(ti, uart_speed(speed)) < 0)
|
return -errno;
|
|
if (tcsetattr(fd, TCSANOW, ti) < 0)
|
return -errno;
|
|
return 0;
|
}
|
|
/*
|
* Read an HCI event from the given file descriptor.
|
*/
|
int read_hci_event(int fd, unsigned char* buf, int size)
|
{
|
int remain, r;
|
int count = 0;
|
|
if (size <= 0)
|
return -1;
|
|
/* The first byte identifies the packet type. For HCI event packets, it
|
* should be 0x04, so we read until we get to the 0x04. */
|
while (1) {
|
r = read(fd, buf, 1);
|
if (r <= 0)
|
return -1;
|
if (buf[0] == 0x04)
|
break;
|
}
|
count++;
|
|
/* The next two bytes are the event code and parameter total length. */
|
while (count < 3) {
|
r = read(fd, buf + count, 3 - count);
|
if (r <= 0)
|
return -1;
|
count += r;
|
}
|
|
/* Now we read the parameters. */
|
if (buf[2] < (size - 3))
|
remain = buf[2];
|
else
|
remain = size - 3;
|
|
while ((count - 3) < remain) {
|
r = read(fd, buf + count, remain - (count - 3));
|
if (r <= 0)
|
return -1;
|
count += r;
|
}
|
|
return count;
|
}
|
|
#if 0
|
/*
|
* Ericsson specific initialization
|
*/
|
static int ericsson(int fd, struct uart_t *u, struct termios *ti)
|
{
|
struct timespec tm = {0, 50000};
|
char cmd[5];
|
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x09;
|
cmd[2] = 0xfc;
|
cmd[3] = 0x01;
|
|
switch (u->speed) {
|
case 57600:
|
cmd[4] = 0x03;
|
break;
|
case 115200:
|
cmd[4] = 0x02;
|
break;
|
case 230400:
|
cmd[4] = 0x01;
|
break;
|
case 460800:
|
cmd[4] = 0x00;
|
break;
|
case 921600:
|
cmd[4] = 0x20;
|
break;
|
case 2000000:
|
cmd[4] = 0x25;
|
break;
|
case 3000000:
|
cmd[4] = 0x27;
|
break;
|
case 4000000:
|
cmd[4] = 0x2B;
|
break;
|
default:
|
cmd[4] = 0x03;
|
u->speed = 57600;
|
fprintf(stderr, "Invalid speed requested, using %d bps instead\n", u->speed);
|
break;
|
}
|
|
/* Send initialization command */
|
if (write(fd, cmd, 5) != 5) {
|
perror("Failed to write init command");
|
return -1;
|
}
|
|
nanosleep(&tm, NULL);
|
return 0;
|
}
|
|
/*
|
* Digianswer specific initialization
|
*/
|
static int digi(int fd, struct uart_t *u, struct termios *ti)
|
{
|
struct timespec tm = {0, 50000};
|
char cmd[5];
|
|
/* DigiAnswer set baud rate command */
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x07;
|
cmd[2] = 0xfc;
|
cmd[3] = 0x01;
|
|
switch (u->speed) {
|
case 57600:
|
cmd[4] = 0x08;
|
break;
|
case 115200:
|
cmd[4] = 0x09;
|
break;
|
default:
|
cmd[4] = 0x09;
|
u->speed = 115200;
|
break;
|
}
|
|
/* Send initialization command */
|
if (write(fd, cmd, 5) != 5) {
|
perror("Failed to write init command");
|
return -1;
|
}
|
|
nanosleep(&tm, NULL);
|
return 0;
|
}
|
|
static int texas(int fd, struct uart_t *u, struct termios *ti)
|
{
|
return texas_init(fd, ti);
|
}
|
|
static int texas2(int fd, struct uart_t *u, struct termios *ti)
|
{
|
return texas_post(fd, ti);
|
}
|
|
static int texasalt(int fd, struct uart_t *u, struct termios *ti)
|
{
|
return texasalt_init(fd, u->speed, ti);
|
}
|
#endif
|
|
|
|
static int read_check(int fd, void *buf, int count)
|
{
|
int res;
|
|
do {
|
res = read(fd, buf, count);
|
if (res != -1) {
|
buf += res;
|
count -= res;
|
}
|
} while (count && (errno == 0 || errno == EINTR));
|
|
if (count)
|
return -1;
|
|
return 0;
|
}
|
|
/*
|
* BCSP specific initialization
|
*/
|
static int serial_fd;
|
static int bcsp_max_retries = 10;
|
|
static void bcsp_tshy_sig_alarm(int sig)
|
{
|
unsigned char bcsp_sync_pkt[10] = {0xc0,0x00,0x41,0x00,0xbe,0xda,0xdc,0xed,0xed,0xc0};
|
static int retries = 0;
|
|
if (retries < bcsp_max_retries) {
|
retries++;
|
if (write(serial_fd, &bcsp_sync_pkt, 10) < 0)
|
return;
|
alarm(1);
|
return;
|
}
|
|
tcflush(serial_fd, TCIOFLUSH);
|
fprintf(stderr, "BCSP initialization timed out\n");
|
exit(1);
|
}
|
|
static void bcsp_tconf_sig_alarm(int sig)
|
{
|
unsigned char bcsp_conf_pkt[10] = {0xc0,0x00,0x41,0x00,0xbe,0xad,0xef,0xac,0xed,0xc0};
|
static int retries = 0;
|
|
if (retries < bcsp_max_retries){
|
retries++;
|
if (write(serial_fd, &bcsp_conf_pkt, 10) < 0)
|
return;
|
alarm(1);
|
return;
|
}
|
|
tcflush(serial_fd, TCIOFLUSH);
|
fprintf(stderr, "BCSP initialization timed out\n");
|
exit(1);
|
}
|
|
static int bcsp(int fd, struct uart_t *u, struct termios *ti)
|
{
|
unsigned char byte, bcsph[4], bcspp[4],
|
bcsp_sync_resp_pkt[10] = {0xc0,0x00,0x41,0x00,0xbe,0xac,0xaf,0xef,0xee,0xc0},
|
bcsp_conf_resp_pkt[10] = {0xc0,0x00,0x41,0x00,0xbe,0xde,0xad,0xd0,0xd0,0xc0},
|
bcspsync[4] = {0xda, 0xdc, 0xed, 0xed},
|
bcspsyncresp[4] = {0xac,0xaf,0xef,0xee},
|
bcspconf[4] = {0xad,0xef,0xac,0xed},
|
bcspconfresp[4] = {0xde,0xad,0xd0,0xd0};
|
struct sigaction sa;
|
int len;
|
|
if (set_speed(fd, ti, u->speed) < 0) {
|
perror("Can't set default baud rate");
|
return -1;
|
}
|
|
ti->c_cflag |= PARENB;
|
ti->c_cflag &= ~(PARODD);
|
|
if (tcsetattr(fd, TCSANOW, ti) < 0) {
|
perror("Can't set port settings");
|
return -1;
|
}
|
|
alarm(0);
|
|
serial_fd = fd;
|
memset(&sa, 0, sizeof(sa));
|
sa.sa_flags = SA_NOCLDSTOP;
|
sa.sa_handler = bcsp_tshy_sig_alarm;
|
sigaction(SIGALRM, &sa, NULL);
|
|
/* State = shy */
|
|
bcsp_tshy_sig_alarm(0);
|
while (1) {
|
do {
|
if (read_check(fd, &byte, 1) == -1){
|
perror("Failed to read");
|
return -1;
|
}
|
} while (byte != 0xC0);
|
|
do {
|
if ( read_check(fd, &bcsph[0], 1) == -1){
|
perror("Failed to read");
|
return -1;
|
}
|
} while (bcsph[0] == 0xC0);
|
|
if ( read_check(fd, &bcsph[1], 3) == -1){
|
perror("Failed to read");
|
return -1;
|
}
|
|
if (((bcsph[0] + bcsph[1] + bcsph[2]) & 0xFF) != (unsigned char)~bcsph[3])
|
continue;
|
if (bcsph[1] != 0x41 || bcsph[2] != 0x00)
|
continue;
|
|
if (read_check(fd, &bcspp, 4) == -1){
|
perror("Failed to read");
|
return -1;
|
}
|
|
if (!memcmp(bcspp, bcspsync, 4)) {
|
if (write(fd, &bcsp_sync_resp_pkt,10) < 0)
|
return -1;
|
} else if (!memcmp(bcspp, bcspsyncresp, 4))
|
break;
|
}
|
|
/* State = curious */
|
|
alarm(0);
|
sa.sa_handler = bcsp_tconf_sig_alarm;
|
sigaction(SIGALRM, &sa, NULL);
|
alarm(1);
|
|
while (1) {
|
do {
|
if (read_check(fd, &byte, 1) == -1){
|
perror("Failed to read");
|
return -1;
|
}
|
} while (byte != 0xC0);
|
|
do {
|
if (read_check(fd, &bcsph[0], 1) == -1){
|
perror("Failed to read");
|
return -1;
|
}
|
} while (bcsph[0] == 0xC0);
|
|
if (read_check(fd, &bcsph[1], 3) == -1){
|
perror("Failed to read");
|
return -1;
|
}
|
|
if (((bcsph[0] + bcsph[1] + bcsph[2]) & 0xFF) != (unsigned char)~bcsph[3])
|
continue;
|
|
if (bcsph[1] != 0x41 || bcsph[2] != 0x00)
|
continue;
|
|
if (read_check(fd, &bcspp, 4) == -1){
|
perror("Failed to read");
|
return -1;
|
}
|
|
if (!memcmp(bcspp, bcspsync, 4))
|
len = write(fd, &bcsp_sync_resp_pkt, 10);
|
else if (!memcmp(bcspp, bcspconf, 4))
|
len = write(fd, &bcsp_conf_resp_pkt, 10);
|
else if (!memcmp(bcspp, bcspconfresp, 4))
|
break;
|
else
|
continue;
|
|
if (len < 0)
|
return -errno;
|
}
|
|
/* State = garrulous */
|
|
return 0;
|
}
|
|
#if 0
|
/*
|
* CSR specific initialization
|
* Inspired strongly by code in OpenBT and experimentations with Brainboxes
|
* Pcmcia card.
|
* Jean Tourrilhes <jt@hpl.hp.com> - 14.11.01
|
*/
|
static int csr(int fd, struct uart_t *u, struct termios *ti)
|
{
|
struct timespec tm = {0, 10000000}; /* 10ms - be generous */
|
unsigned char cmd[30]; /* Command */
|
unsigned char resp[30]; /* Response */
|
int clen = 0; /* Command len */
|
static int csr_seq = 0; /* Sequence number of command */
|
int divisor;
|
|
/* It seems that if we set the CSR UART speed straight away, it
|
* won't work, the CSR UART gets into a state where we can't talk
|
* to it anymore.
|
* On the other hand, doing a read before setting the CSR speed
|
* seems to be ok.
|
* Therefore, the strategy is to read the build ID (useful for
|
* debugging) and only then set the CSR UART speed. Doing like
|
* this is more complex but at least it works ;-)
|
* The CSR UART control may be slow to wake up or something because
|
* every time I read its speed, its bogus...
|
* Jean II */
|
|
/* Try to read the build ID of the CSR chip */
|
clen = 5 + (5 + 6) * 2;
|
/* HCI header */
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x00; /* CSR command */
|
cmd[2] = 0xfc; /* MANUFACTURER_SPEC */
|
cmd[3] = 1 + (5 + 6) * 2; /* len */
|
/* CSR MSG header */
|
cmd[4] = 0xC2; /* first+last+channel=BCC */
|
/* CSR BCC header */
|
cmd[5] = 0x00; /* type = GET-REQ */
|
cmd[6] = 0x00; /* - msB */
|
cmd[7] = 5 + 4; /* len */
|
cmd[8] = 0x00; /* - msB */
|
cmd[9] = csr_seq & 0xFF;/* seq num */
|
cmd[10] = (csr_seq >> 8) & 0xFF; /* - msB */
|
csr_seq++;
|
cmd[11] = 0x19; /* var_id = CSR_CMD_BUILD_ID */
|
cmd[12] = 0x28; /* - msB */
|
cmd[13] = 0x00; /* status = STATUS_OK */
|
cmd[14] = 0x00; /* - msB */
|
/* CSR BCC payload */
|
memset(cmd + 15, 0, 6 * 2);
|
|
/* Send command */
|
do {
|
if (write(fd, cmd, clen) != clen) {
|
perror("Failed to write init command (GET_BUILD_ID)");
|
return -1;
|
}
|
|
/* Read reply. */
|
if (read_hci_event(fd, resp, 100) < 0) {
|
perror("Failed to read init response (GET_BUILD_ID)");
|
return -1;
|
}
|
|
/* Event code 0xFF is for vendor-specific events, which is
|
* what we're looking for. */
|
} while (resp[1] != 0xFF);
|
|
#ifdef CSR_DEBUG
|
{
|
char temp[512];
|
int i;
|
for (i=0; i < rlen; i++)
|
sprintf(temp + (i*3), "-%02X", resp[i]);
|
fprintf(stderr, "Reading CSR build ID %d [%s]\n", rlen, temp + 1);
|
// In theory, it should look like :
|
// 04-FF-13-FF-01-00-09-00-00-00-19-28-00-00-73-00-00-00-00-00-00-00
|
}
|
#endif
|
/* Display that to user */
|
fprintf(stderr, "CSR build ID 0x%02X-0x%02X\n",
|
resp[15] & 0xFF, resp[14] & 0xFF);
|
|
/* Try to read the current speed of the CSR chip */
|
clen = 5 + (5 + 4)*2;
|
/* -- HCI header */
|
cmd[3] = 1 + (5 + 4)*2; /* len */
|
/* -- CSR BCC header -- */
|
cmd[9] = csr_seq & 0xFF; /* seq num */
|
cmd[10] = (csr_seq >> 8) & 0xFF; /* - msB */
|
csr_seq++;
|
cmd[11] = 0x02; /* var_id = CONFIG_UART */
|
cmd[12] = 0x68; /* - msB */
|
|
#ifdef CSR_DEBUG
|
/* Send command */
|
do {
|
if (write(fd, cmd, clen) != clen) {
|
perror("Failed to write init command (GET_BUILD_ID)");
|
return -1;
|
}
|
|
/* Read reply. */
|
if (read_hci_event(fd, resp, 100) < 0) {
|
perror("Failed to read init response (GET_BUILD_ID)");
|
return -1;
|
}
|
|
/* Event code 0xFF is for vendor-specific events, which is
|
* what we're looking for. */
|
} while (resp[1] != 0xFF);
|
|
{
|
char temp[512];
|
int i;
|
for (i=0; i < rlen; i++)
|
sprintf(temp + (i*3), "-%02X", resp[i]);
|
fprintf(stderr, "Reading CSR UART speed %d [%s]\n", rlen, temp+1);
|
}
|
#endif
|
|
if (u->speed > 1500000) {
|
fprintf(stderr, "Speed %d too high. Remaining at %d baud\n",
|
u->speed, u->init_speed);
|
u->speed = u->init_speed;
|
} else if (u->speed != 57600 && uart_speed(u->speed) == B57600) {
|
/* Unknown speed. Why oh why can't we just pass an int to the kernel? */
|
fprintf(stderr, "Speed %d unrecognised. Remaining at %d baud\n",
|
u->speed, u->init_speed);
|
u->speed = u->init_speed;
|
}
|
if (u->speed == u->init_speed)
|
return 0;
|
|
/* Now, create the command that will set the UART speed */
|
/* CSR BCC header */
|
cmd[5] = 0x02; /* type = SET-REQ */
|
cmd[6] = 0x00; /* - msB */
|
cmd[9] = csr_seq & 0xFF; /* seq num */
|
cmd[10] = (csr_seq >> 8) & 0xFF;/* - msB */
|
csr_seq++;
|
|
divisor = (u->speed*64+7812)/15625;
|
|
/* No parity, one stop bit -> divisor |= 0x0000; */
|
cmd[15] = (divisor) & 0xFF; /* divider */
|
cmd[16] = (divisor >> 8) & 0xFF; /* - msB */
|
/* The rest of the payload will be 0x00 */
|
|
#ifdef CSR_DEBUG
|
{
|
char temp[512];
|
int i;
|
for(i = 0; i < clen; i++)
|
sprintf(temp + (i*3), "-%02X", cmd[i]);
|
fprintf(stderr, "Writing CSR UART speed %d [%s]\n", clen, temp + 1);
|
// In theory, it should look like :
|
// 01-00-FC-13-C2-02-00-09-00-03-00-02-68-00-00-BF-0E-00-00-00-00-00-00
|
// 01-00-FC-13-C2-02-00-09-00-01-00-02-68-00-00-D8-01-00-00-00-00-00-00
|
}
|
#endif
|
|
/* Send the command to set the CSR UART speed */
|
if (write(fd, cmd, clen) != clen) {
|
perror("Failed to write init command (SET_UART_SPEED)");
|
return -1;
|
}
|
|
nanosleep(&tm, NULL);
|
return 0;
|
}
|
|
/*
|
* Silicon Wave specific initialization
|
* Thomas Moser <thomas.moser@tmoser.ch>
|
*/
|
static int swave(int fd, struct uart_t *u, struct termios *ti)
|
{
|
struct timespec tm = { 0, 500000 };
|
char cmd[10], rsp[100];
|
int r;
|
|
// Silicon Wave set baud rate command
|
// see HCI Vendor Specific Interface from Silicon Wave
|
// first send a "param access set" command to set the
|
// appropriate data fields in RAM. Then send a "HCI Reset
|
// Subcommand", e.g. "soft reset" to make the changes effective.
|
|
cmd[0] = HCI_COMMAND_PKT; // it's a command packet
|
cmd[1] = 0x0B; // OCF 0x0B = param access set
|
cmd[2] = 0xfc; // OGF bx111111 = vendor specific
|
cmd[3] = 0x06; // 6 bytes of data following
|
cmd[4] = 0x01; // param sub command
|
cmd[5] = 0x11; // tag 17 = 0x11 = HCI Transport Params
|
cmd[6] = 0x03; // length of the parameter following
|
cmd[7] = 0x01; // HCI Transport flow control enable
|
cmd[8] = 0x01; // HCI Transport Type = UART
|
|
switch (u->speed) {
|
case 19200:
|
cmd[9] = 0x03;
|
break;
|
case 38400:
|
cmd[9] = 0x02;
|
break;
|
case 57600:
|
cmd[9] = 0x01;
|
break;
|
case 115200:
|
cmd[9] = 0x00;
|
break;
|
default:
|
u->speed = 115200;
|
cmd[9] = 0x00;
|
break;
|
}
|
|
/* Send initialization command */
|
if (write(fd, cmd, 10) != 10) {
|
perror("Failed to write init command");
|
return -1;
|
}
|
|
// We should wait for a "GET Event" to confirm the success of
|
// the baud rate setting. Wait some time before reading. Better:
|
// read with timeout, parse data
|
// until correct answer, else error handling ... todo ...
|
|
nanosleep(&tm, NULL);
|
|
r = read(fd, rsp, sizeof(rsp));
|
if (r > 0) {
|
// guess it's okay, but we should parse the reply. But since
|
// I don't react on an error anyway ... todo
|
// Response packet format:
|
// 04 Event
|
// FF Vendor specific
|
// 07 Parameter length
|
// 0B Subcommand
|
// 01 Setevent
|
// 11 Tag specifying HCI Transport Layer Parameter
|
// 03 length
|
// 01 flow on
|
// 01 Hci Transport type = Uart
|
// xx Baud rate set (see above)
|
} else {
|
// ups, got error.
|
return -1;
|
}
|
|
// we probably got the reply. Now we must send the "soft reset"
|
// which is standard HCI RESET.
|
|
cmd[0] = HCI_COMMAND_PKT; // it's a command packet
|
cmd[1] = 0x03;
|
cmd[2] = 0x0c;
|
cmd[3] = 0x00;
|
|
/* Send reset command */
|
if (write(fd, cmd, 4) != 4) {
|
perror("Can't write Silicon Wave reset cmd.");
|
return -1;
|
}
|
|
nanosleep(&tm, NULL);
|
|
// now the uart baud rate on the silicon wave module is set and effective.
|
// change our own baud rate as well. Then there is a reset event comming in
|
// on the *new* baud rate. This is *undocumented*! The packet looks like this:
|
// 04 FF 01 0B (which would make that a confirmation of 0x0B = "Param
|
// subcommand class". So: change to new baud rate, read with timeout, parse
|
// data, error handling. BTW: all param access in Silicon Wave is done this way.
|
// Maybe this code would belong in a seperate file, or at least code reuse...
|
|
return 0;
|
}
|
|
/*
|
* ST Microelectronics specific initialization
|
* Marcel Holtmann <marcel@holtmann.org>
|
*/
|
static int st(int fd, struct uart_t *u, struct termios *ti)
|
{
|
struct timespec tm = {0, 50000};
|
char cmd[5];
|
|
/* ST Microelectronics set baud rate command */
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x46; // OCF = Hci_Cmd_ST_Set_Uart_Baud_Rate
|
cmd[2] = 0xfc; // OGF = Vendor specific
|
cmd[3] = 0x01;
|
|
switch (u->speed) {
|
case 9600:
|
cmd[4] = 0x09;
|
break;
|
case 19200:
|
cmd[4] = 0x0b;
|
break;
|
case 38400:
|
cmd[4] = 0x0d;
|
break;
|
case 57600:
|
cmd[4] = 0x0e;
|
break;
|
case 115200:
|
cmd[4] = 0x10;
|
break;
|
case 230400:
|
cmd[4] = 0x12;
|
break;
|
case 460800:
|
cmd[4] = 0x13;
|
break;
|
case 921600:
|
cmd[4] = 0x14;
|
break;
|
default:
|
cmd[4] = 0x10;
|
u->speed = 115200;
|
break;
|
}
|
|
/* Send initialization command */
|
if (write(fd, cmd, 5) != 5) {
|
perror("Failed to write init command");
|
return -1;
|
}
|
|
nanosleep(&tm, NULL);
|
return 0;
|
}
|
|
static int stlc2500(int fd, struct uart_t *u, struct termios *ti)
|
{
|
bdaddr_t bdaddr;
|
unsigned char resp[10];
|
int n;
|
int rvalue;
|
|
/* STLC2500 has an ericsson core */
|
rvalue = ericsson(fd, u, ti);
|
if (rvalue != 0)
|
return rvalue;
|
|
#ifdef STLC2500_DEBUG
|
fprintf(stderr, "Setting speed\n");
|
#endif
|
if (set_speed(fd, ti, u->speed) < 0) {
|
perror("Can't set baud rate");
|
return -1;
|
}
|
|
#ifdef STLC2500_DEBUG
|
fprintf(stderr, "Speed set...\n");
|
#endif
|
|
/* Read reply */
|
if ((n = read_hci_event(fd, resp, 10)) < 0) {
|
fprintf(stderr, "Failed to set baud rate on chip\n");
|
return -1;
|
}
|
|
#ifdef STLC2500_DEBUG
|
for (i = 0; i < n; i++) {
|
fprintf(stderr, "resp[%d] = %02x\n", i, resp[i]);
|
}
|
#endif
|
|
str2ba(u->bdaddr, &bdaddr);
|
return stlc2500_init(fd, &bdaddr);
|
}
|
|
static int bgb2xx(int fd, struct uart_t *u, struct termios *ti)
|
{
|
bdaddr_t bdaddr;
|
|
str2ba(u->bdaddr, &bdaddr);
|
|
return bgb2xx_init(fd, &bdaddr);
|
}
|
|
/*
|
* Broadcom specific initialization
|
* Extracted from Jungo openrg
|
*/
|
static int bcm2035(int fd, struct uart_t *u, struct termios *ti)
|
{
|
int n;
|
unsigned char cmd[30], resp[30];
|
|
/* Reset the BT Chip */
|
memset(cmd, 0, sizeof(cmd));
|
memset(resp, 0, sizeof(resp));
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x03;
|
cmd[2] = 0x0c;
|
cmd[3] = 0x00;
|
|
/* Send command */
|
if (write(fd, cmd, 4) != 4) {
|
fprintf(stderr, "Failed to write reset command\n");
|
return -1;
|
}
|
|
/* Read reply */
|
if ((n = read_hci_event(fd, resp, 4)) < 0) {
|
fprintf(stderr, "Failed to reset chip\n");
|
return -1;
|
}
|
|
if (u->bdaddr != NULL) {
|
/* Set BD_ADDR */
|
memset(cmd, 0, sizeof(cmd));
|
memset(resp, 0, sizeof(resp));
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x01;
|
cmd[2] = 0xfc;
|
cmd[3] = 0x06;
|
str2ba(u->bdaddr, (bdaddr_t *) (cmd + 4));
|
|
/* Send command */
|
if (write(fd, cmd, 10) != 10) {
|
fprintf(stderr, "Failed to write BD_ADDR command\n");
|
return -1;
|
}
|
|
/* Read reply */
|
if ((n = read_hci_event(fd, resp, 10)) < 0) {
|
fprintf(stderr, "Failed to set BD_ADDR\n");
|
return -1;
|
}
|
}
|
|
/* Read the local version info */
|
memset(cmd, 0, sizeof(cmd));
|
memset(resp, 0, sizeof(resp));
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x01;
|
cmd[2] = 0x10;
|
cmd[3] = 0x00;
|
|
/* Send command */
|
if (write(fd, cmd, 4) != 4) {
|
fprintf(stderr, "Failed to write \"read local version\" "
|
"command\n");
|
return -1;
|
}
|
|
/* Read reply */
|
if ((n = read_hci_event(fd, resp, 4)) < 0) {
|
fprintf(stderr, "Failed to read local version\n");
|
return -1;
|
}
|
|
/* Read the local supported commands info */
|
memset(cmd, 0, sizeof(cmd));
|
memset(resp, 0, sizeof(resp));
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x02;
|
cmd[2] = 0x10;
|
cmd[3] = 0x00;
|
|
/* Send command */
|
if (write(fd, cmd, 4) != 4) {
|
fprintf(stderr, "Failed to write \"read local supported "
|
"commands\" command\n");
|
return -1;
|
}
|
|
/* Read reply */
|
if ((n = read_hci_event(fd, resp, 4)) < 0) {
|
fprintf(stderr, "Failed to read local supported commands\n");
|
return -1;
|
}
|
|
/* Set the baud rate */
|
memset(cmd, 0, sizeof(cmd));
|
memset(resp, 0, sizeof(resp));
|
cmd[0] = HCI_COMMAND_PKT;
|
cmd[1] = 0x18;
|
cmd[2] = 0xfc;
|
cmd[3] = 0x02;
|
switch (u->speed) {
|
case 57600:
|
cmd[4] = 0x00;
|
cmd[5] = 0xe6;
|
break;
|
case 230400:
|
cmd[4] = 0x22;
|
cmd[5] = 0xfa;
|
break;
|
case 460800:
|
cmd[4] = 0x22;
|
cmd[5] = 0xfd;
|
break;
|
case 921600:
|
cmd[4] = 0x55;
|
cmd[5] = 0xff;
|
break;
|
default:
|
/* Default is 115200 */
|
cmd[4] = 0x00;
|
cmd[5] = 0xf3;
|
break;
|
}
|
fprintf(stderr, "Baud rate parameters: DHBR=0x%2x,DLBR=0x%2x\n",
|
cmd[4], cmd[5]);
|
|
/* Send command */
|
if (write(fd, cmd, 6) != 6) {
|
fprintf(stderr, "Failed to write \"set baud rate\" command\n");
|
return -1;
|
}
|
|
if ((n = read_hci_event(fd, resp, 6)) < 0) {
|
fprintf(stderr, "Failed to set baud rate\n");
|
return -1;
|
}
|
|
return 0;
|
}
|
#endif
|
|
static int realtek_init(int fd, struct uart_t *u, struct termios *ti)
|
{
|
|
fprintf(stderr, "Realtek Bluetooth init uart with init speed:%d, final_speed:%d, type:HCI UART %s\n", u->init_speed, u->speed, (u->proto == HCI_UART_H4)? "H4":"H5" );
|
return rtk_init(fd, u->proto, u->speed, ti);
|
}
|
|
static int realtek_post(int fd, struct uart_t *u, struct termios *ti)
|
{
|
fprintf(stderr, "Realtek Bluetooth post process\n");
|
return rtk_post(fd, u->proto, ti);
|
}
|
|
struct uart_t uart[] = {
|
{ "any", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200, FLOW_CTL, DISABLE_PM, NULL, NULL },
|
{ "bcsp", 0x0000, 0x0000, HCI_UART_BCSP, 115200, 115200, 0, DISABLE_PM, NULL, bcsp },
|
|
#if 0
|
{ "ericsson", 0x0000, 0x0000, HCI_UART_H4, 57600, 115200, FLOW_CTL, NULL, ericsson },
|
{ "digi", 0x0000, 0x0000, HCI_UART_H4, 9600, 115200, FLOW_CTL, NULL, digi },
|
|
|
/* Xircom PCMCIA cards: Credit Card Adapter and Real Port Adapter */
|
{ "xircom", 0x0105, 0x080a, HCI_UART_H4, 115200, 115200, FLOW_CTL, NULL, NULL },
|
|
/* CSR Casira serial adapter or BrainBoxes serial dongle (BL642) */
|
{ "csr", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200, FLOW_CTL, NULL, csr },
|
|
/* BrainBoxes PCMCIA card (BL620) */
|
{ "bboxes", 0x0160, 0x0002, HCI_UART_H4, 115200, 460800, FLOW_CTL, NULL, csr },
|
|
/* Silicon Wave kits */
|
{ "swave", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200, FLOW_CTL, NULL, swave },
|
|
/* Texas Instruments Bluelink (BRF) modules */
|
{ "texas", 0x0000, 0x0000, HCI_UART_LL, 115200, 115200, FLOW_CTL, NULL, texas, texas2 },
|
{ "texasalt", 0x0000, 0x0000, HCI_UART_LL, 115200, 115200, FLOW_CTL, NULL, texasalt, NULL },
|
|
/* ST Microelectronics minikits based on STLC2410/STLC2415 */
|
{ "st", 0x0000, 0x0000, HCI_UART_H4, 57600, 115200, FLOW_CTL, NULL, st },
|
|
/* ST Microelectronics minikits based on STLC2500 */
|
{ "stlc2500", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200, FLOW_CTL, "00:80:E1:00:AB:BA", stlc2500 },
|
|
/* Philips generic Ericsson IP core based */
|
{ "philips", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200, FLOW_CTL, NULL, NULL },
|
|
/* Philips BGB2xx Module */
|
{ "bgb2xx", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200, FLOW_CTL, "BD:B2:10:00:AB:BA", bgb2xx },
|
|
/* Sphinx Electronics PICO Card */
|
{ "picocard", 0x025e, 0x1000, HCI_UART_H4, 115200, 115200, FLOW_CTL, NULL, NULL },
|
|
/* Inventel BlueBird Module */
|
{ "inventel", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200, FLOW_CTL, NULL, NULL },
|
|
/* COM One Platinium Bluetooth PC Card */
|
{ "comone", 0xffff, 0x0101, HCI_UART_BCSP, 115200, 115200, 0, NULL, bcsp },
|
|
/* TDK Bluetooth PC Card and IBM Bluetooth PC Card II */
|
{ "tdk", 0x0105, 0x4254, HCI_UART_BCSP, 115200, 115200, 0, NULL, bcsp },
|
|
/* Socket Bluetooth CF Card (Rev G) */
|
{ "socket", 0x0104, 0x0096, HCI_UART_BCSP, 230400, 230400, 0, NULL, bcsp },
|
|
/* 3Com Bluetooth Card (Version 3.0) */
|
{ "3com", 0x0101, 0x0041, HCI_UART_H4, 115200, 115200, FLOW_CTL, NULL, csr },
|
|
/* AmbiCom BT2000C Bluetooth PC/CF Card */
|
{ "bt2000c", 0x022d, 0x2000, HCI_UART_H4, 57600, 460800, FLOW_CTL, NULL, csr },
|
|
/* Zoom Bluetooth PCMCIA Card */
|
{ "zoom", 0x0279, 0x950b, HCI_UART_BCSP, 115200, 115200, 0, NULL, bcsp },
|
|
/* Sitecom CN-504 PCMCIA Card */
|
{ "sitecom", 0x0279, 0x950b, HCI_UART_BCSP, 115200, 115200, 0, NULL, bcsp },
|
|
/* Billionton PCBTC1 PCMCIA Card */
|
{ "billionton", 0x0279, 0x950b, HCI_UART_BCSP, 115200, 115200, 0, NULL, bcsp },
|
|
/* Broadcom BCM2035 */
|
{ "bcm2035", 0x0A5C, 0x2035, HCI_UART_H4, 115200, 460800, FLOW_CTL, NULL, bcm2035 },
|
|
#endif
|
|
/* Realtek Bluetooth H4*/
|
/* H4 will set 115200 baudrate and flow control enable by default*/
|
{ "rtk_h4", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200, 0, DISABLE_PM, NULL, realtek_init, realtek_post},
|
|
/* Realtek Bluetooth H5*/
|
/* H5 will set 115200 baudrate and flow control disable by default */
|
{ "rtk_h5", 0x0000, 0x0000, HCI_UART_3WIRE, 115200,115200, 0, DISABLE_PM, NULL, realtek_init, realtek_post},
|
|
{ NULL, 0 }
|
};
|
|
static struct uart_t * get_by_id(int m_id, int p_id)
|
{
|
int i;
|
for (i = 0; uart[i].type; i++) {
|
if (uart[i].m_id == m_id && uart[i].p_id == p_id)
|
return &uart[i];
|
}
|
return NULL;
|
}
|
|
static struct uart_t * get_by_type(char *type)
|
{
|
int i;
|
for (i = 0; uart[i].type; i++) {
|
if (!strcmp(uart[i].type, type))
|
return &uart[i];
|
}
|
return NULL;
|
}
|
|
/* Initialize UART driver */
|
static int init_uart(char *dev, struct uart_t *u, int send_break, int raw)
|
{
|
struct termios ti;
|
int fd, i;
|
unsigned long flags = 0;
|
|
if (raw)
|
flags |= 1 << HCI_UART_RAW_DEVICE;
|
|
fd = open(dev, O_RDWR | O_NOCTTY);
|
if (fd < 0) {
|
perror("Can't open serial port");
|
return -1;
|
}
|
|
tcflush(fd, TCIOFLUSH);
|
|
if (tcgetattr(fd, &ti) < 0) {
|
perror("Can't get port settings");
|
return -1;
|
}
|
|
cfmakeraw(&ti);
|
|
ti.c_cflag |= CLOCAL;
|
if (u->flags & FLOW_CTL)
|
ti.c_cflag |= CRTSCTS;
|
else
|
ti.c_cflag &= ~CRTSCTS;
|
|
if (tcsetattr(fd, TCSANOW, &ti) < 0) {
|
perror("Can't set port settings");
|
return -1;
|
}
|
|
/* Set initial baudrate */
|
if (set_speed(fd, &ti, u->init_speed) < 0) {
|
perror("Can't set initial baud rate");
|
return -1;
|
}
|
|
tcflush(fd, TCIOFLUSH);
|
|
if (send_break) {
|
tcsendbreak(fd, 0);
|
usleep(500000);
|
}
|
|
if (u->init && u->init(fd, u, &ti) < 0)
|
return -1;
|
|
tcflush(fd, TCIOFLUSH);
|
|
/* Set actual baudrate */
|
if (set_speed(fd, &ti, u->speed) < 0) {
|
perror("Can't set baud rate");
|
return -1;
|
}
|
|
/* Set TTY to N_HCI line discipline */
|
i = N_HCI;
|
if (ioctl(fd, TIOCSETD, &i) < 0) {
|
perror("Can't set line discipline");
|
return -1;
|
}
|
|
if (flags && ioctl(fd, HCIUARTSETFLAGS, flags) < 0) {
|
perror("Can't set UART flags");
|
return -1;
|
}
|
|
if (ioctl(fd, HCIUARTSETPROTO, u->proto) < 0) {
|
perror("Can't set device");
|
return -1;
|
}
|
|
if (u->post && u->post(fd, u, &ti) < 0)
|
return -1;
|
|
return fd;
|
}
|
|
static void usage(void)
|
{
|
printf("hciattach - HCI UART driver initialization utility\n");
|
printf("Usage:\n");
|
printf("\thciattach [-n] [-p] [-b] [-r] [-t timeout] [-s initial_speed] <tty> <type | id> [speed] [flow|noflow] [bdaddr]\n");
|
printf("\thciattach -l\n");
|
}
|
|
int main(int argc, char *argv[])
|
{
|
struct uart_t *u = NULL;
|
int detach, printpid, raw, opt, i, n, ld, err;
|
int to = 10;
|
int init_speed = 0;
|
int send_break = 0;
|
pid_t pid;
|
struct sigaction sa;
|
struct pollfd p;
|
sigset_t sigs;
|
char dev[PATH_MAX];
|
|
detach = 1;
|
printpid = 0;
|
raw = 0;
|
|
while ((opt=getopt(argc, argv, "bnpt:s:lr")) != EOF) {
|
switch(opt) {
|
case 'b':
|
send_break = 1;
|
break;
|
|
case 'n':
|
detach = 0;
|
break;
|
|
case 'p':
|
printpid = 1;
|
break;
|
|
case 't':
|
to = atoi(optarg);
|
break;
|
|
case 's':
|
init_speed = atoi(optarg);
|
break;
|
|
case 'l':
|
for (i = 0; uart[i].type; i++) {
|
printf("%-10s0x%04x,0x%04x\n", uart[i].type,
|
uart[i].m_id, uart[i].p_id);
|
}
|
exit(0);
|
|
case 'r':
|
raw = 1;
|
break;
|
|
default:
|
usage();
|
exit(1);
|
}
|
}
|
|
n = argc - optind;
|
if (n < 2) {
|
usage();
|
exit(1);
|
}
|
|
for (n = 0; optind < argc; n++, optind++) {
|
char *opt;
|
|
opt = argv[optind];
|
|
switch(n) {
|
case 0:
|
dev[0] = 0;
|
if (!strchr(opt, '/'))
|
strcpy(dev, "/dev/");
|
strcat(dev, opt);
|
break;
|
|
case 1:
|
if (strchr(argv[optind], ',')) {
|
int m_id, p_id;
|
sscanf(argv[optind], "%x,%x", &m_id, &p_id);
|
u = get_by_id(m_id, p_id);
|
} else {
|
u = get_by_type(opt);
|
}
|
|
if (!u) {
|
fprintf(stderr, "Unknown device type or id\n");
|
exit(1);
|
}
|
|
break;
|
|
case 2:
|
u->speed = atoi(argv[optind]);
|
break;
|
|
case 3:
|
if (!strcmp("flow", argv[optind]))
|
u->flags |= FLOW_CTL;
|
else
|
u->flags &= ~FLOW_CTL;
|
break;
|
|
case 4:
|
if (!strcmp("sleep", argv[optind]))
|
u->pm = ENABLE_PM;
|
else
|
u->pm = DISABLE_PM;
|
break;
|
|
case 5:
|
u->bdaddr = argv[optind];
|
break;
|
}
|
}
|
|
if (!u) {
|
fprintf(stderr, "Unknown device type or id\n");
|
exit(1);
|
}
|
|
/* If user specified a initial speed, use that instead of
|
the hardware's default */
|
if (init_speed)
|
u->init_speed = init_speed;
|
|
memset(&sa, 0, sizeof(sa));
|
sa.sa_flags = SA_NOCLDSTOP;
|
sa.sa_handler = sig_alarm;
|
sigaction(SIGALRM, &sa, NULL);
|
|
/* 10 seconds should be enough for initialization */
|
alarm(to);
|
bcsp_max_retries = to;
|
|
n = init_uart(dev, u, send_break, raw);
|
if (n < 0) {
|
perror("Can't initialize device");
|
exit(1);
|
}
|
|
printf("Device setup complete\n");
|
|
alarm(0);
|
|
memset(&sa, 0, sizeof(sa));
|
sa.sa_flags = SA_NOCLDSTOP;
|
sa.sa_handler = SIG_IGN;
|
sigaction(SIGCHLD, &sa, NULL);
|
sigaction(SIGPIPE, &sa, NULL);
|
|
sa.sa_handler = sig_term;
|
sigaction(SIGTERM, &sa, NULL);
|
sigaction(SIGINT, &sa, NULL);
|
|
sa.sa_handler = sig_hup;
|
sigaction(SIGHUP, &sa, NULL);
|
|
if (detach) {
|
if ((pid = fork())) {
|
if (printpid)
|
printf("%d\n", pid);
|
return 0;
|
}
|
|
for (i = 0; i < 20; i++)
|
if (i != n)
|
close(i);
|
}
|
|
p.fd = n;
|
p.events = POLLERR | POLLHUP;
|
|
sigfillset(&sigs);
|
sigdelset(&sigs, SIGCHLD);
|
sigdelset(&sigs, SIGPIPE);
|
sigdelset(&sigs, SIGTERM);
|
sigdelset(&sigs, SIGINT);
|
sigdelset(&sigs, SIGHUP);
|
|
while (!__io_canceled) {
|
p.revents = 0;
|
err = ppoll(&p, 1, NULL, &sigs);
|
if (err < 0 && errno == EINTR) {
|
printf("Got EINTR.\n");
|
continue;
|
} if (err)
|
break;
|
}
|
|
/* Restore TTY line discipline */
|
printf("Restore TTY line discipline\n");
|
ld = N_TTY;
|
if (ioctl(n, TIOCSETD, &ld) < 0) {
|
perror("Can't restore line discipline");
|
exit(1);
|
}
|
|
return 0;
|
}
|
