From 8113167ad8bd860b0c8df1eee4afb7b5f2177f02 Mon Sep 17 00:00:00 2001 From: Stefan Eichenberger Date: Fri, 22 Jul 2016 17:33:51 +0200 Subject: [PATCH] bluetooth: add tibluetooth stuff for nbhw16 --- .../tibluetooth/tibluetooth.bb | 28 + .../tibluetooth/tibluetooth/tibluetooth.sh | 36 ++ recipes-connectivity/tiuim/tiuim/uim.c | 537 ++++++++++++++++++ recipes-connectivity/tiuim/tiuim/uim.h | 156 +++++ recipes-connectivity/tiuim/tiuim_1.0.bb | 24 + 5 files changed, 781 insertions(+) create mode 100644 recipes-connectivity/tibluetooth/tibluetooth.bb create mode 100644 recipes-connectivity/tibluetooth/tibluetooth/tibluetooth.sh create mode 100644 recipes-connectivity/tiuim/tiuim/uim.c create mode 100644 recipes-connectivity/tiuim/tiuim/uim.h create mode 100644 recipes-connectivity/tiuim/tiuim_1.0.bb diff --git a/recipes-connectivity/tibluetooth/tibluetooth.bb b/recipes-connectivity/tibluetooth/tibluetooth.bb new file mode 100644 index 0000000..fbfb167 --- /dev/null +++ b/recipes-connectivity/tibluetooth/tibluetooth.bb @@ -0,0 +1,28 @@ +SUMMARY = "Start ti bluetooth" +DESCRIPTION = "TI needs a special startup sequence for the wilink module" +AUTHOR = "Stefan Eichenberger" + +SECTION = "connectivity" +LICENSE = "GPLv2+" +LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6" +PR = "r0" + +RDEPENDS_${PN} = "tiuim" + +inherit update-rc.d + +SRC_URI = " \ + file://tibluetooth.sh \ + " + +S = "${WORKDIR}" + +INHIBIT_PACKAGE_DEBUG_SPLIT = "1" + +INITSCRIPT_NAME = "tibluetooth.sh" +INITSCRIPT_PARAMS = "start 99 S . stop 0 0 1 6 ." + +do_install () { + install -d ${D}${sysconfdir} + install -m 0755 tibluetooth.sh ${D}${sysconfdir} +} diff --git a/recipes-connectivity/tibluetooth/tibluetooth/tibluetooth.sh b/recipes-connectivity/tibluetooth/tibluetooth/tibluetooth.sh new file mode 100644 index 0000000..6cf9b8b --- /dev/null +++ b/recipes-connectivity/tibluetooth/tibluetooth/tibluetooth.sh @@ -0,0 +1,36 @@ +#!/bin/sh + +UIM="uim" +UIM_OPTS="-s 115200 -d /dev/ttyO5 -c" +UIM_PID="/var/run/uim.pid" + +BLUETOOTHD="/usr/lib/bluez5/bluetooth/bluetoothd" +BLUETOOTHD_PID="/var/run/bluetoothd.pid" + + +case $1 in +start) + modprobe st_drv &> /dev/null + eval start-stop-daemon -b -S -q -x $UIM -p $UIM_PID -- "$UIM_OPTS" + modprobe btwilink + eval start-stop-daemon -b -S -q -x $BLUETOOTHD -p $BLUETOOTHD_PID + ;; + +stop) + eval start-stop-daemon --remove-pidfile -K -p $BLUETOOTHD_PID + rmmod btwilink + eval start-stop-daemon --remove-pidfile -K -p $UIM_PID + rmmod st_drv + ;; + +restart) + $0 stop + sleep 1 + $0 start + ;; +*) + echo "Usage: $0 {start|stop|restart}" + exit 1 +esac + + diff --git a/recipes-connectivity/tiuim/tiuim/uim.c b/recipes-connectivity/tiuim/tiuim/uim.c new file mode 100644 index 0000000..4352a36 --- /dev/null +++ b/recipes-connectivity/tiuim/tiuim/uim.c @@ -0,0 +1,537 @@ +/* + * User Mode Init manager - For TI shared transport + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "uim.h" + +/* Maintains the exit state of UIM*/ +static int exiting; +static int line_discipline; +static int dev_fd; + +static char install_sysfs_entry[48]; +static char dev_name_arg[48]; +static long baud_rate_arg; +static int flow_ctrl_arg; + +/* BD address as string and a pointer to array of hex bytes */ +char uim_bd_address[BD_ADDR_LEN]; +bdaddr_t *bd_addr; + +/*****************************************************************************/ +#ifdef UIM_DEBUG +/* Function to Read the firmware version + * module into the system. Currently used for + * debugging purpose, whenever the baud rate is changed + */ +void read_firmware_version(int dev_fd) +{ + int index = 0; + char resp_buffer[20] = { 0 }; + unsigned char buffer[] = { 0x01, 0x01, 0x10, 0x00 }; + + UIM_START_FUNC(); + UIM_VER(" wrote %d bytes", (int)write(dev_fd, buffer, 4)); + UIM_VER(" reading %d bytes", (int)read(dev_fd, resp_buffer, 15)); + + for (index = 0; index < 15; index++) + UIM_VER(" %x ", resp_buffer[index]); + + printf("\n"); +} +#endif + +/*****************************************************************************/ +/* Function to read the HCI event from the given file descriptor + * + * This will parse the response received and returns error + * if the required response is not received + */ +int read_hci_event(int fd, unsigned char *buf, int size) +{ + int remain, rd; + int count = 0; + int reading = 1; + int rd_retry_count = 0; + struct timespec tm = {0, 50*1000*1000}; + + UIM_START_FUNC(); + + UIM_VER(" read_hci_event"); + 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 (reading) { + rd = read(fd, buf, 1); + if (rd <= 0 && rd_retry_count++ < 4) { + nanosleep(&tm, NULL); + continue; + } else if (rd_retry_count >= 4) { + return -1; + } + + if (buf[0] == RESP_PREFIX) { + break; + } + } + count++; + + /* The next two bytes are the event code and parameter total length. */ + while (count < 3) { + rd = read(fd, buf + count, 3 - count); + if (rd <= 0) + return -1; + count += rd; + } + + /* Now we read the parameters. */ + if (buf[2] < (size - 3)) + remain = buf[2]; + else + remain = size - 3; + + while ((count - 3) < remain) { + rd = read(fd, buf + count, remain - (count - 3)); + if (rd <= 0) + return -1; + count += rd; + } + + return count; +} + +/* Function to read the Command complete event + * + * This will read the response for the change speed + * command that was sent to configure the UART speed + * with the custom baud rate + */ +static int read_command_complete(int fd, unsigned short opcode) +{ + command_complete_t resp; + + UIM_START_FUNC(); + + UIM_VER(" Command complete started"); + if (read_hci_event(fd, (unsigned char *)&resp, sizeof(resp)) < 0) { + UIM_ERR("Invalid response"); + return -1; + } + + /* Response should be an event packet */ + if (resp.uart_prefix != HCI_EVENT_PKT) { + UIM_ERR ("Error in response: not an event packet, 0x%02x!", + resp.uart_prefix); + return -1; + } + + /* Response should be a command complete event */ + if (resp.hci_hdr.evt != EVT_CMD_COMPLETE) { + /* event must be event-complete */ + UIM_ERR("Error in response: not a cmd-complete event,0x%02x!", + resp.hci_hdr.evt); + return -1; + } + + if (resp.hci_hdr.plen < 4) { + /* plen >= 4 for EVT_CMD_COMPLETE */ + UIM_ERR("Error in response: plen is not >= 4, but 0x%02x!", + resp.hci_hdr.plen); + return -1; + } + + if (resp.cmd_complete.opcode != (unsigned short)opcode) { + UIM_ERR("Error in response: opcode is 0x%04x, not 0x%04x!", + resp.cmd_complete.opcode, opcode); + return -1; + } + + UIM_DBG("Command complete done"); + return resp.status == 0 ? 0 : -1; +} + +/* Function to set the default baud rate + * + * The default baud rate of 115200 is set to the UART from the host side + * by making a call to this function.This function is also called before + * making a call to set the custom baud rate + */ +static int set_baud_rate(int dev_fd) +{ + UIM_START_FUNC(); + struct termios ti; + + tcflush(dev_fd, TCIOFLUSH); + + /* Get the attributes of UART */ + if (tcgetattr(dev_fd, &ti) < 0) { + UIM_ERR(" Can't get port settings"); + return -1; + } + + /* Change the UART attributes before + * setting the default baud rate*/ + cfmakeraw(&ti); + + ti.c_cflag |= 1; + ti.c_cflag |= CRTSCTS; + + /* Set the attributes of UART after making + * the above changes + */ + tcsetattr(dev_fd, TCSANOW, &ti); + + /* Set the actual default baud rate */ + cfsetospeed(&ti, B115200); + cfsetispeed(&ti, B115200); + tcsetattr(dev_fd, TCSANOW, &ti); + + tcflush(dev_fd, TCIOFLUSH); + UIM_DBG("set_baud_rate() done"); + + return 0; +} + + +/* Function to set the UART custom baud rate. + * + * The UART baud rate has already been + * set to default value 115200 before calling this function. + * The baud rate is then changed to custom baud rate by this function*/ +static int set_custom_baud_rate(int dev_fd, int baud_rate, int flow_ctrl) +{ + UIM_START_FUNC(); + + struct termios ti; + struct termios2 ti2; + + tcflush(dev_fd, TCIOFLUSH); + /* Get the attributes of UART */ + if (tcgetattr(dev_fd, &ti) < 0) { + UIM_ERR(" Can't get port settings"); + return -1; + } + + /*Set the UART flow control */ + if (flow_ctrl) + ti.c_cflag |= CRTSCTS; + else + ti.c_cflag &= ~CRTSCTS; + + /* + * Set the parameters associated with the UART + * The change will occur immediately by using TCSANOW + */ + if (tcsetattr(dev_fd, TCSANOW, &ti) < 0) { + UIM_ERR(" Can't set port settings"); + return -1; + } + + tcflush(dev_fd, TCIOFLUSH); + + /*Set the actual baud rate */ + ioctl(dev_fd, TCGETS2, &ti2); + ti2.c_cflag &= ~CBAUD; + ti2.c_cflag |= BOTHER; + ti2.c_ospeed = baud_rate; + ioctl(dev_fd, TCSETS2, &ti2); + + return 0; +} + +/* Function to configure the UART + * on receiving a notification from the ST KIM driver to install the line + * discipline, this function does UART configuration necessary for the STK + */ +int st_uart_config(unsigned char install) +{ + int ldisc, len; + uim_speed_change_cmd cmd; + char uart_dev_name[UART_DEV_NAME_LEN]; + + uim_bdaddr_change_cmd addr_cmd; + + UIM_START_FUNC(); + + if (install == '1') { + + dev_fd = open(dev_name_arg, O_RDWR); + if (dev_fd < 0) { + UIM_ERR("Can't open %s", uart_dev_name); + return -1; + } + + /* + * Set only the default baud rate. + * This will set the baud rate to default 115200 + */ + if (set_baud_rate(dev_fd) < 0) { + UIM_ERR("set_baudrate() failed"); + close(dev_fd); + return -1; + } + + fcntl(dev_fd, F_SETFL,fcntl(dev_fd, F_GETFL) | O_NONBLOCK); + /* Set only the custom baud rate */ + if (baud_rate_arg != 115200) { + + UIM_VER("Setting speed to %ld", baud_rate_arg); + /* Forming the packet for Change speed command */ + cmd.uart_prefix = HCI_COMMAND_PKT; + cmd.hci_hdr.opcode = HCI_HDR_OPCODE; + cmd.hci_hdr.plen = sizeof(unsigned long); + cmd.speed = baud_rate_arg; + + /* Writing the change speed command to the UART + * This will change the UART speed at the controller + * side + */ + len = write(dev_fd, &cmd, sizeof(cmd)); + if (len < 0) { + UIM_ERR("Failed to write speed-set command"); + close(dev_fd); + return -1; + } + + /* Read the response for the Change speed command */ + if (read_command_complete(dev_fd, HCI_HDR_OPCODE) < 0) { + close(dev_fd); + return -1; + } + + UIM_VER("Speed changing to %ld, %d", baud_rate_arg, flow_ctrl_arg); + /* Set the actual custom baud rate at the host side */ + if (set_custom_baud_rate(dev_fd, baud_rate_arg, flow_ctrl_arg) < 0) { + UIM_ERR("set_custom_baud_rate() failed"); + close(dev_fd); + return -1; + } + + /* Set the uim BD address */ + if (uim_bd_address[0] != 0) { + + memset(&addr_cmd, 0, sizeof(addr_cmd)); + /* Forming the packet for change BD address command*/ + addr_cmd.uart_prefix = HCI_COMMAND_PKT; + addr_cmd.hci_hdr.opcode = WRITE_BD_ADDR_OPCODE; + addr_cmd.hci_hdr.plen = sizeof(bdaddr_t); + memcpy(&addr_cmd.addr, bd_addr, sizeof(bdaddr_t)); + + /* Writing the change BD address command to the UART + * This will change the change BD address at the controller + * side + */ + len = write(dev_fd, &addr_cmd, sizeof(addr_cmd)); + if (len < 0) { + UIM_ERR("Failed to write BD address command"); + close(dev_fd); + return -1; + } + + /* Read the response for the change BD address command */ + if (read_command_complete(dev_fd, WRITE_BD_ADDR_OPCODE) < 0) { + close(dev_fd); + return -1; + } + UIM_VER("BD address changed to %s", uim_bd_address); + } +#ifdef UIM_DEBUG + read_firmware_version(dev_fd); +#endif + } + + /* After the UART speed has been changed, the IOCTL is + * is called to set the line discipline to N_TI_WL + */ + ldisc = N_TI_WL; + if (ioctl(dev_fd, TIOCSETD, &ldisc) < 0) { + UIM_ERR(" Can't set line discipline"); + close(dev_fd); + return -1; + } + UIM_DBG("Installed N_TI_WL Line displine"); + } + else { + UIM_DBG("Un-Installed N_TI_WL Line displine"); + /* UNINSTALL_N_TI_WL - When the Signal is received from KIM */ + /* closing UART fd */ + close(dev_fd); + } + return 0; +} + +/* Function to convert the BD address from ascii to hex value */ +bdaddr_t *strtoba(const char *str) +{ + const char *ptr = str; + int i; + + uint8_t *ba = malloc(sizeof(bdaddr_t)); + if (!ba) + return NULL; + + for (i = 0; i < 6; i++) { + ba[i] = (uint8_t) strtol(ptr, NULL, 16); + if (i != 5 && !(ptr = strchr(ptr, ':'))) + ptr = ":00:00:00:00:00"; + ptr++; + } + + return (bdaddr_t *) ba; +} + +void usage(void) +{ + UIM_ERR("Invalid arguments"); + UIM_ERR("Usage: uim [ -f ] [ -b ] [ -sdc ]" + " options:" + " -s speed (baudrate)" + " -d the uart device" + " -c if flow control should be used"); +} + +/*****************************************************************************/ +int main(int argc, char *argv[]) +{ + int opt; + char *arg_kim_path = NULL, *arg_bd_addr = NULL, *temp_path = KIM_SYSFS_BASE; + int st_fd, err; + unsigned char install; + struct pollfd p; + + UIM_START_FUNC(); + err = 0; + + /* Parse the user input */ + while ((opt = getopt (argc, argv, "f:b:s:d:c")) != -1) { + switch (opt) { + case 'f': + arg_kim_path = optarg; + break; + case 'b': + arg_bd_addr = optarg; + break; + case 's': + baud_rate_arg = atoi(optarg); + break; + case 'd': + strncpy(dev_name_arg, optarg, sizeof(dev_name_arg)); + break; + case 'c': + flow_ctrl_arg = 1; + break; + default: + usage(); + return -1; + } + } + + if (arg_kim_path != NULL) { + temp_path = arg_kim_path; + if( strlen(temp_path) > (sizeof(install_sysfs_entry)-10) ) { + UIM_ERR("Path to sysfs node too long"); + return -1; + } + } + strcpy(install_sysfs_entry, temp_path); + + strcat(install_sysfs_entry, "/install"); + + UIM_DBG("install = %s", install_sysfs_entry); + + if (arg_bd_addr != NULL) { + if (strlen(arg_bd_addr) != BD_ADDR_LEN) { + usage(); + return -1; + } + UIM_DBG("Address = %s", arg_bd_addr); + /* BD address passed as string in xx:xx:xx:xx:xx:xx format */ + strncpy(uim_bd_address, arg_bd_addr, sizeof(uim_bd_address)); + bd_addr = strtoba(uim_bd_address); + } + + line_discipline = N_TI_WL; + + st_fd = open(INSTALL_SYSFS_ENTRY, O_RDONLY); + if (st_fd < 0) { + UIM_DBG("unable to open %s(%s)", INSTALL_SYSFS_ENTRY, strerror(errno)); + return -1; + } + +RE_POLL: + /* read to start proper poll */ + err = read(st_fd, &install, 1); + /* special case where bluetoothd starts before the UIM, and UIM + * needs to turn on bluetooth because of that. + */ + if ((err > 0) && install == '1') { + UIM_DBG("install set previously..."); + st_uart_config(install); + } + + UIM_DBG("begin polling..."); + + memset(&p, 0, sizeof(p)); + p.fd = st_fd; + p.events = POLLERR | POLLPRI; + + while (!exiting) { + p.revents = 0; + err = poll(&p, 1, -1); + UIM_DBG("poll broke due to event %d(PRI:%d/ERR:%d)\n", p.revents, POLLPRI, POLLERR); + if (err < 0 && errno == EINTR) + continue; + if (err) + break; + } + + close(st_fd); + st_fd = open(INSTALL_SYSFS_ENTRY, O_RDONLY); + if (st_fd < 0) { + UIM_DBG("unable to open %s (%s)", INSTALL_SYSFS_ENTRY, strerror(errno)); + return -1; + } + + if (!exiting) + { + err = read(st_fd, &install, 1); + UIM_DBG("read %c from install \n", install); + if (err > 0) + st_uart_config(install); + goto RE_POLL; + } + + close(st_fd); + return 0; +} diff --git a/recipes-connectivity/tiuim/tiuim/uim.h b/recipes-connectivity/tiuim/tiuim/uim.h new file mode 100644 index 0000000..370b4d4 --- /dev/null +++ b/recipes-connectivity/tiuim/tiuim/uim.h @@ -0,0 +1,156 @@ +/* + * User Mode Init manager - For shared transport + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef UIM_H +#define UIM_H + +/* the line discipline ideally should be coming + * from tty.h + */ +#define N_TI_WL 22 + +/* Paramaters to set the baud rate*/ +#define FLOW_CTL 0x0001 +#define BOTHER 0x00001000 +#define ARM_NCCS 19 + +#ifndef TCGETS2 +#define TCGETS2 _IOR('T',0x2A, struct termios2) +#endif +#ifndef TCSETS2 +#define TCSETS2 _IOW('T',0x2B, struct termios2) +#endif + +/*HCI Command and Event information*/ +#define HCI_HDR_OPCODE 0xff36 +#define WRITE_BD_ADDR_OPCODE 0xFC06 +#define RESP_PREFIX 0x04 +#define MAX_TRY 10 + +/* HCI Packet types */ +#define HCI_COMMAND_PKT 0x01 +#define HCI_EVENT_PKT 0x04 + +/* HCI command macros*/ +#define HCI_EVENT_HDR_SIZE 2 +#define HCI_COMMAND_HDR_SIZE 3 +#define HCI_COMMAND_HDR_SIZE 3 + +/* HCI event macros*/ +#define EVT_CMD_COMPLETE_SIZE 3 +#define EVT_CMD_STATUS_SIZE 4 +#define EVT_CMD_COMPLETE 0x0E +#define EVT_CMD_STATUS 0x0F + +/* use it for string lengths and buffers */ +#define UART_DEV_NAME_LEN 32 +/* BD address length in format xx:xx:xx:xx:xx:xx */ +#define BD_ADDR_LEN 17 + +/* the sysfs entries with device configuration set by + * shared transport driver + */ +#define KIM_SYSFS_BASE "/sys/devices/platform/kim" +#define INSTALL_SYSFS_ENTRY install_sysfs_entry +#define DEV_NAME_SYSFS dev_name_sysfs +#define BAUD_RATE_SYSFS baud_rate_sysfs +#define FLOW_CTRL_SYSFS flow_cntrl_sysfs + +#define VERBOSE +/*Debug logs*/ +#define UIM_ERR(fmt, arg...) printf("uim:"fmt"\n" , ##arg) +#if defined(UIM_DEBUG) /* limited debug messages */ +#define UIM_START_FUNC() printf("uim: Inside %s", __FUNCTION__) +#define UIM_DBG(fmt, arg...) printf("uim:"fmt"\n" , ## arg) +#define UIM_VER(fmt, arg...) +#elif defined(VERBOSE) /* very verbose */ +#define UIM_START_FUNC() printf("uim:@ %s\n", __FUNCTION__) +#define UIM_DBG(fmt, arg...) printf("uim:"fmt"\n" , ## arg) +#define UIM_VER(fmt, arg...) printf("uim:"fmt"\n" , ## arg) +#else /* error msgs only */ +#define UIM_START_FUNC() +#define UIM_DBG(fmt, arg...) +#define UIM_VER(fmt, arg...) +#endif + +/*Termios2 structure for setting the Custom baud rate*/ +struct termios2 { + tcflag_t c_iflag; /* input mode flags */ + tcflag_t c_oflag; /* output mode flags */ + tcflag_t c_cflag; /* control mode flags */ + tcflag_t c_lflag; /* local mode flags */ + cc_t c_line; /* line discipline */ + cc_t c_cc[ARM_NCCS]; /* control characters */ + speed_t c_ispeed; /* input speed */ + speed_t c_ospeed; /* output speed */ +}; + +/* HCI command header*/ +typedef struct { + uint16_t opcode; /* OCF & OGF */ + uint8_t plen; +} __attribute__ ((packed)) hci_command_hdr; + +/* HCI event header*/ +typedef struct { + uint8_t evt; + uint8_t plen; +} __attribute__ ((packed)) hci_event_hdr; + +/* HCI command complete event*/ +typedef struct { + uint8_t ncmd; + uint16_t opcode; +} __attribute__ ((packed)) evt_cmd_complete; + +/* HCI event status*/ +typedef struct { + uint8_t status; + uint8_t ncmd; + uint16_t opcode; +} __attribute__ ((packed)) evt_cmd_status; + +/* HCI Event structure to set the cusrom baud rate*/ +typedef struct { + uint8_t uart_prefix; + hci_event_hdr hci_hdr; + evt_cmd_complete cmd_complete; + uint8_t status; + uint8_t data[16]; +} __attribute__ ((packed)) command_complete_t; + +/* HCI Command structure to set the cusrom baud rate*/ +typedef struct { + uint8_t uart_prefix; + hci_command_hdr hci_hdr; + uint32_t speed; +} __attribute__ ((packed)) uim_speed_change_cmd; + +/* BD address structure to set the uim BD address*/ +typedef struct { + unsigned char b[6]; +} __attribute__((packed)) bdaddr_t; + +/* HCI Command structure to set the uim BD address*/ +typedef struct { + uint8_t uart_prefix; + hci_command_hdr hci_hdr; + bdaddr_t addr; +} __attribute__ ((packed)) uim_bdaddr_change_cmd;\ + +#endif /* UIM_H */ diff --git a/recipes-connectivity/tiuim/tiuim_1.0.bb b/recipes-connectivity/tiuim/tiuim_1.0.bb new file mode 100644 index 0000000..6e91b29 --- /dev/null +++ b/recipes-connectivity/tiuim/tiuim_1.0.bb @@ -0,0 +1,24 @@ +SUMMARY = "User Mode Init manager for TI shared transport" +DESCRIPTION = "Userpace utility to initialize" +AUTHOR = "Texas Instruments" + +SECTION = "connectivity" +LICENSE = "GPLv2+" +LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6" +PR = "r0" + +SRC_URI = " \ + file://uim.c \ + file://uim.h \ + " + +S = "${WORKDIR}" + +do_compile() { + ${CC} uim.c -o uim +} + +do_install () { + install -d ${D}${bindir} + install -m 0755 uim ${D}${bindir} +}