/* * *  BlueZ - Bluetooth protocol stack for Linux * *  Copyright (C) 2000-2001  Qualcomm Incorporated *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com> *  Copyright (C) 2002-2008  Marcel Holtmann <marcel@holtmann.org> * * *  This program is free software; you can redistribute it and/or modify *  it under the terms of the GNU General Public License as published by *  the Free Software Foundation; either version 2 of the License, or *  (at your option) any later version. * *  This program is distributed in the hope that it will be useful, *  but WITHOUT ANY WARRANTY; without even the implied warranty of *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the *  GNU General Public License for more details. * *  You should have received a copy of the GNU General Public License *  along with this program; if not, write to the Free Software *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA * */#ifdef HAVE_CONFIG_H#include <config.h>#endif#include <stdio.h>#include <errno.h>#include <fcntl.h>#include <unistd.h>#include <stdlib.h>#include <string.h>#include <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 <bluetooth/bluetooth.h>#include <bluetooth/hci.h>#include <bluetooth/hci_lib.h>#ifndef N_HCI#define N_HCI	15#endif#define HCIUARTSETPROTO		_IOW('U', 200, int)#define HCIUARTGETPROTO		_IOR('U', 201, int)#define HCIUARTGETDEVICE	_IOR('U', 202, int)#define HCI_UART_H4	0#define HCI_UART_BCSP	1#define HCI_UART_3WIRE	2#define HCI_UART_H4DS	3struct uart_t {	char *type;	int  m_id;	int  p_id;	int  proto;	int  init_speed;	int  speed;	int  flags;	char *bdaddr;	int  (*init) (int fd, struct uart_t *u, struct termios *ti);};#define FLOW_CTL	0x0001static volatile sig_atomic_t __io_canceled = 0;static void sig_hup(int sig){}static void sig_term(int sig){	__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;	}}static int set_speed(int fd, struct termios *ti, int speed){	cfsetospeed(ti, uart_speed(speed));	return tcsetattr(fd, TCSANOW, ti);}/*  * Read an HCI event from the given file descriptor. */static 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;}/*  * 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){	struct timespec tm = {0, 50000};	char cmd[4];	unsigned char resp[100];		/* Response */	int n;	memset(resp,'\0', 100);	/* It is possible to get software version with manufacturer specific 	   HCI command HCI_VS_TI_Version_Number. But the only thing you get more	   is if this is point-to-point or point-to-multipoint module */	/* Get Manufacturer and LMP version */	cmd[0] = HCI_COMMAND_PKT;	cmd[1] = 0x01;	cmd[2] = 0x10;	cmd[3] = 0x00;	do {		n = write(fd, cmd, 4);		if (n < 0) {			perror("Failed to write init command (READ_LOCAL_VERSION_INFORMATION)");			return -1;		}		if (n < 4) {			fprintf(stderr, "Wanted to write 4 bytes, could only write %d. Stop\n", n);			return -1;		}		/* Read reply. */		if (read_hci_event(fd, resp, 100) < 0) {			perror("Failed to read init response (READ_LOCAL_VERSION_INFORMATION)");			return -1;		}		/* Wait for command complete event for our Opcode */	} while (resp[4] != cmd[1] && resp[5] != cmd[2]);	/* Verify manufacturer */	if ((resp[11] & 0xFF) != 0x0d)		fprintf(stderr,"WARNING : module's manufacturer is not Texas Instrument\n");	/* Print LMP version */	fprintf(stderr, "Texas module LMP version : 0x%02x\n", resp[10] & 0xFF);	/* Print LMP subversion */	fprintf(stderr, "Texas module LMP sub-version : 0x%02x%02x\n", resp[14] & 0xFF, resp[13] & 0xFF);	nanosleep(&tm, NULL);	return 0;}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 */int serial_fd;static void bcsp_tshy_sig_alarm(int sig){	static int retries=0;	unsigned char bcsp_sync_pkt[10] = {0xc0,0x00,0x41,0x00,0xbe,0xda,0xdc,0xed,0xed,0xc0};	int len;	if (retries < 10) {		retries++;		len = write(serial_fd, &bcsp_sync_pkt, 10);		alarm(1);		return;	}	tcflush(serial_fd, TCIOFLUSH);	fprintf(stderr, "BCSP initialization timed out\n");	exit(1);}static void bcsp_tconf_sig_alarm(int sig){	static int retries=0;	unsigned char bcsp_conf_pkt[10] = {0xc0,0x00,0x41,0x00,0xbe,0xad,0xef,0xac,0xed,0xc0};	int len;	if (retries < 10){		retries++;		len = write(serial_fd, &bcsp_conf_pkt, 10);		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;