/* * *  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 <sys/uio.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	3#define HCI_UART_LL	4struct 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);	int  (*post) (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;	}}int set_speed(int fd, struct termios *ti, int speed){	cfsetospeed(ti, uart_speed(speed));	cfsetispeed(ti, uart_speed(speed));	return tcsetattr(fd, TCSANOW, ti);}/*  * 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;}/*  * 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;}extern int texas_init(int fd, struct termios *ti);extern int texas_post(int fd, struct termios *ti);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);}extern int texasalt_init(int fd, int speed);static int texasalt(int fd, struct uart_t *u, struct termios *ti){	return texasalt_init(fd, u->speed);}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;		}		if (!memcmp(bcspp, bcspsync, 4)) {			len = write(fd, &bcsp_sync_resp_pkt,10);		} 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;	}	/* State = garrulous */	return 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