diff --git a/uim.c b/uim.c
index 923060c..16c070e 100644
--- a/uim.c
+++ b/uim.c
@@ -27,6 +27,10 @@
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/utsname.h>
+#ifdef ANDROID
+#include <private/android_filesystem_config.h>
+#include <cutils/log.h>
+#endif
 
 #include "uim.h"
 
@@ -41,19 +45,56 @@
 struct termios ti;
 int line_discipline;
 
+/* BD address as string and a pointer to array of hex bytes */
+char uim_bd_address[17];
+bdaddr_t *bd_addr;
+
 /* File descriptor for the UART device*/
 int dev_fd;
 
 /* Maintains the state of N_TI_WL line discipline installation*/
 unsigned char st_state = INSTALL_N_TI_WL;
-unsigned char prev_st_state = UNINSTALL_N_TI_WL;
+unsigned char prev_st_state = INSTALL_N_TI_WL;
+
+/* from kernel's include/linux/rfkill.h
+ * the header in itself not included because of the
+ * version mismatch of android kernel headers project
+ */
+
+/**
+ * enum rfkill_operation - operation types
+ * @RFKILL_OP_ADD: a device was added
+ * @RFKILL_OP_DEL: a device was removed
+ * @RFKILL_OP_CHANGE: a device's state changed -- userspace changes one device
+ * @RFKILL_OP_CHANGE_ALL: userspace changes all devices (of a type, or all)
+ */
+enum rfkill_operation {
+        RFKILL_OP_ADD = 0,
+        RFKILL_OP_DEL,
+        RFKILL_OP_CHANGE,
+        RFKILL_OP_CHANGE_ALL,
+};
+
+/**
+ * struct rfkill_event - events for userspace on /dev/rfkill
+ * @idx: index of dev rfkill
+ * @type: type of the rfkill struct
+ * @op: operation code
+ * @hard: hard state (0/1)
+ * @soft: soft state (0/1)
+ *
+ * Structure used for userspace communication on /dev/rfkill,
+ * used for events from the kernel and control to the kernel.
+ */
 
 struct rfkill_event {
-uint32_t idx;
-uint8_t  type;
-uint8_t  op;
-uint8_t  soft, hard;
+	uint32_t idx;
+	uint8_t  type;
+	uint8_t  op;
+	uint8_t  soft, hard;
 } __packed;
+
+/* to read events and filter notifications for us */
 struct rfkill_event rf_event;
 int 	rfkill_idx;
 
@@ -81,6 +122,56 @@
 #endif
 
 /*****************************************************************************/
+#ifdef ANDROID                 /* library for android to do insmod/rmmod  */
+
+/* Function to insert the kernel module into the system*/
+static int insmod(const char *filename, const char *args)
+{
+        void *module;
+        unsigned int size;
+        int ret = -1;
+
+        UIM_START_FUNC();
+
+        module = (void *)load_file(filename, &size);
+        if (!module)
+                return ret;
+
+        ret = init_module(module, size, args);
+        free(module);
+
+        return ret;
+}
+
+/* Function to remove the kernel module from the system*/
+static int rmmod(const char *modname)
+{
+        int ret = -1;
+        int maxtry = MAX_TRY;
+
+        UIM_START_FUNC();
+
+        /* Retry MAX_TRY number of times in case of
+ 	 * failure
+	 */
+        while (maxtry-- > 0) {
+                ret = delete_module(modname, O_NONBLOCK | O_EXCL);
+                if (ret < 0 && errno == EAGAIN)
+                        sleep(1);
+                else
+                        break;
+        }
+
+        /* Failed to remove the module
+	*/
+        if (ret != 0)
+                UIM_ERR("Unable to unload driver module \"%s\": %s",
+                                modname, strerror(errno));
+        return ret;
+}
+#endif /*ANDROID*/
+
+/*****************************************************************************/
 /* Function to read the HCI event from the given file descriptor
  *
  * This will parse the response received and returns error
@@ -111,9 +202,9 @@
 			return -1;
 		}
 
-		if (buf[0] == RESP_PREFIX)
+		if (buf[0] == RESP_PREFIX) {
 			break;
-
+		}
 	}
 	count++;
 
@@ -149,7 +240,7 @@
  */
 static int read_command_complete(int fd, unsigned short opcode)
 {
-	struct command_complete_t resp;
+	command_complete_t resp;
 
 	UIM_START_FUNC();
 
@@ -287,7 +378,9 @@
 int st_uart_config()
 {
 	int ldisc, len;
-	struct uim_speed_change_cmd cmd;
+	uim_speed_change_cmd cmd;
+
+	uim_bdaddr_change_cmd addr_cmd;	
 
 	UIM_START_FUNC();
 
@@ -353,6 +446,35 @@
 
 				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();
 #endif
@@ -369,39 +491,60 @@
 		}
 
 		UIM_DBG(" Installed N_TI_WL Line displine");
-	} else {
+	}
+	else {
 		/* UNINSTALL_N_TI_WL - When the Signal is received from KIM */
 		/* closing UART fd */
-		UIM_DBG(" Uninstalled N_TI_WL Line displine");
 		close(dev_fd);
 	}
 	prev_st_state = st_state;
 	return 0;
 }
+
+#ifdef ANDROID
 int remove_modules()
 {
 	int err = 0;
+        UIM_VER(" Removing gps_drv ");
+        if (rmmod("gps_drv") != 0) {
+                UIM_ERR(" Error removing gps_drv module");
+                err = -1;
+        } else {
+                UIM_DBG(" Removed gps_drv module");
+        }
 
-	UIM_VER(" Removing bt_drv ");
-	if (system("rmmod bt_drv") != 0) {
-		UIM_ERR(" Error removing bt_drv module");
-		err = -1;
-	} else {
-		UIM_DBG(" Removed bt_drv module");
-	}
+        UIM_VER(" Removing fm_drv ");
+        if (rmmod("fm_drv") != 0) {
+                UIM_ERR(" Error removing fm_drv module");
+                err = -1;
+        } else {
+                UIM_DBG(" Removed fm_drv module");
+        }
+        UIM_DBG(" Removed fm_drv module");
 
-	/*Remove the Shared Transport */
-	UIM_VER(" Removing st_drv ");
+        UIM_VER(" Removing bt_drv ");
 
-	if (system("rmmod st_drv") != 0) {
-		UIM_ERR(" Error removing st_drv module");
-		err = -1;
-	} else {
-		UIM_DBG(" Removed st_drv module ");
-	}
+        if (rmmod("bt_drv") != 0) {
+                UIM_ERR(" Error removing bt_drv module");
+                err = -1;
+        } else {
+                UIM_DBG(" Removed bt_drv module");
+        }
+        UIM_DBG(" Removed bt_drv module");
 
+        /*Remove the Shared Transport */
+        UIM_VER(" Removing st_drv ");
+
+        if (rmmod("st_drv") != 0) {
+                UIM_ERR(" Error removing st_drv module");
+                err = -1;
+        } else {
+                UIM_DBG(" Removed st_drv module ");
+        }
+        UIM_DBG(" Removed st_drv module ");
 	return err;
 }
+#endif
 
 int change_rfkill_perms(void)
 {
@@ -409,12 +552,10 @@
 	char path[64];
 	char buf[16];
 	for (id = 0; id < 50; id++) {
-		snprintf(path, sizeof(path),
-			"/sys/class/rfkill/rfkill%d/type", id);
+		snprintf(path, sizeof(path), "/sys/class/rfkill/rfkill%d/type", id);
 		fd = open(path, O_RDONLY);
 		if (fd < 0) {
-			UIM_DBG("open(%s) failed: %s (%d)\n",
-				path, strerror(errno), errno);
+			UIM_DBG("open(%s) failed: %s (%d)\n", path, strerror(errno), errno);
 			continue;
 		}
 		sz = read(fd, &buf, sizeof(buf));
@@ -425,9 +566,21 @@
 			break;
 		}
 	}
-	if (id == 50)
+	if (id == 50) {
 		return -1;
+	}
 
+#ifdef ANDROID
+	sprintf(path, "/sys/class/rfkill/rfkill%d/state", id);
+	sz = chown(path, AID_BLUETOOTH, AID_BLUETOOTH);
+	if (sz < 0) {
+		UIM_ERR("change mode failed for %s (%d)\n", path, errno);
+		return -1;
+	}
+
+	/*
+	 * bluetooth group's user system needs write permission
+	 */
 	sz = chmod(path, 0660);
 	if (sz < 0) {
 		UIM_ERR("change mode failed for %s (%d)\n", path, errno);
@@ -435,120 +588,220 @@
 	}
 	UIM_DBG("changed permissions for %s(%d) \n", path, sz);
 	/* end of change_perms */
-
+#endif
 	return 0;
 }
+
+void *bt_malloc(size_t size)
+{
+        return malloc(size);
+}
+
+/* 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 = bt_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;
+}
+
 /*****************************************************************************/
 int main(int argc, char *argv[])
 {
-	int st_fd, err;
-	char buf[20] = { 0 };
-	struct sigaction sa;
+	int st_fd,err;
 	struct stat file_stat;
-	struct utsname name;
 
-	struct pollfd p;
-	sigset_t sigs;
+#ifndef ANDROID
+	char *tist_ko_path;
+	struct utsname name;
+#endif
+	struct pollfd 	p;
 
 	UIM_START_FUNC();
 	err = 0;
 
 	/* Parse the user input */
-	if (argc == 5) {
-		strcpy(uart_dev_name, argv[1]);
-		uart_baud_rate = atoi(argv[2]);
-		uart_flow_control = atoi(argv[3]);
-		line_discipline = atoi(argv[4]);
+        if ((argc == 5) || (argc == 6)) {
+                strcpy(uart_dev_name, argv[1]);
+                uart_baud_rate = atoi(argv[2]);
+                uart_flow_control = atoi(argv[3]);
+                line_discipline = atoi(argv[4]);
 
-		/* Depending upon the baud rate value, differentiate
-		 * the custom baud rate and default baud rate
-		 */
-		switch (uart_baud_rate) {
-			case 115200:
-				UIM_VER(" Baudrate 115200");
-				break;
-			case 9600:
-			case 19200:
-			case 38400:
-			case 57600:
-			case 230400:
-			case 460800:
-			case 500000:
-			case 576000:
-			case 921600:
-			case 1000000:
-			case 1152000:
-			case 1500000:
-			case 2000000:
-			case 2500000:
-			case 3000000:
-			case 3500000:
-			case 3686400:
-			case 4000000:
-				cust_baud_rate = uart_baud_rate;
-				UIM_VER(" Baudrate %d", cust_baud_rate);
-				break;
-			default:
-				UIM_ERR(" Inavalid Baud Rate");
-				break;
-		}
-	} else {
-		UIM_ERR(" Invalid arguements");
-		UIM_ERR(" Usage: uim [Uart device] [Baud rate] [Flow control] [Line discipline]");
-		return -1;
-	}
+                /* Depending upon the baud rate value, differentiate
+                 * the custom baud rate and default baud rate
+                 */
+                switch (uart_baud_rate) {
+                        case 115200:
+                                UIM_VER(" Baudrate 115200");
+                                break;
+                        case 9600:
+                        case 19200:
+                        case 38400:
+                        case 57600:
+                        case 230400:
+                        case 460800:
+                        case 500000:
+                        case 576000:
+                        case 921600:
+                        case 1000000:
+                        case 1152000:
+                        case 1500000:
+                        case 2000000:
+                        case 2500000:
+                        case 3000000:
+                        case 3500000:
+                        case 3686400:
+                        case 4000000:
+                                cust_baud_rate = uart_baud_rate;
+                                UIM_VER(" Baudrate %d", cust_baud_rate);
+                                break;
+                        default:
+                                UIM_ERR(" Inavalid Baud Rate");
+                                break;
+                }
 
+                memset(&uim_bd_address, 0, sizeof(uim_bd_address));
+        } else {
+                UIM_ERR(" Invalid arguements");
+                UIM_ERR(" Usage: uim [Uart device] [Baud rate] [Flow control] [Line discipline] <bd address>");
+                return -1;
+        }
+
+        if (argc == 6) {
+                /* BD address passed as string in xx:xx:xx:xx:xx:xx format */
+                strcpy(uim_bd_address, argv[5]);
+                bd_addr = strtoba(uim_bd_address);
+        }
+#ifndef ANDROID
 	if (uname (&name) == -1) {
 	   UIM_ERR("cannot get kernel release name");
 	   return -1;
 	}
+#else  /* if ANDROID */
 
+        if (0 == lstat("/st_drv.ko", &file_stat)) {
+                if (insmod("/st_drv.ko", "") < 0) {
+                        UIM_ERR(" Error inserting st_drv module");
+                        return -1;
+                } else {
+                        UIM_DBG(" Inserted st_drv module");
+                }
+        } else {
+                if (0 == lstat("/dev/rfkill", &file_stat)) {
+                        UIM_DBG("ST built into the kernel ?");
+                } else {
+                        UIM_ERR("BT/FM/GPS would be unavailable on system");
+                        UIM_ERR(" rfkill device '/dev/rfkill' not found ");
+                        return -1;
+                }
+        }
+
+	if (change_rfkill_perms() < 0) {
+		/* possible error condition */
+		UIM_ERR("rfkill not enabled in st_drv - BT on from UI might fail\n");
+	}
+
+        if (0 == lstat("/bt_drv.ko", &file_stat)) {
+                if (insmod("/bt_drv.ko", "") < 0) {
+                        UIM_ERR(" Error inserting bt_drv module, NO BT? ");
+                } else {
+                        UIM_DBG(" Inserted bt_drv module");
+                }
+        } else {
+                UIM_DBG("BT driver module un-available... ");
+                UIM_DBG("BT driver built into the kernel ?");
+        }
+
+        if (0 == lstat("/fm_drv.ko", &file_stat)) {
+                if (insmod("/fm_drv.ko", "") < 0) {
+                        UIM_ERR(" Error inserting fm_drv module, NO FM? ");
+                } else {
+                        UIM_DBG(" Inserted fm_drv module");
+                }
+        } else {
+                UIM_DBG("FM driver module un-available... ");
+                UIM_DBG("FM driver built into the kernel ?");
+        }
+
+        if (0 == lstat("/gps_drv.ko", &file_stat)) {
+                if (insmod("/gps_drv.ko", "") < 0) {
+                        UIM_ERR(" Error inserting gps_drv module, NO GPS? ");
+                } else {
+                        UIM_DBG(" Inserted gps_drv module");
+                }
+        } else {
+                UIM_DBG("GPS driver module un-available... ");
+                UIM_DBG("GPS driver built into the kernel ?");
+        }
+
+        if (chmod("/dev/tifm", 0666) < 0) {
+                UIM_ERR("unable to chmod /dev/tifm");
+        }
+#endif
+	/* rfkill device's open/poll/read */
 	st_fd = open("/dev/rfkill", O_RDONLY);
 
 	p.fd = st_fd;
 	p.events = POLLERR | POLLHUP | POLLOUT | POLLIN;
 
-	sigfillset(&sigs);
-	sigdelset(&sigs, SIGCHLD);
-	sigdelset(&sigs, SIGPIPE);
-	sigdelset(&sigs, SIGTERM);
-	sigdelset(&sigs, SIGINT);
-	sigdelset(&sigs, SIGHUP);
-
 RE_POLL:
 	while (!exiting) {
 		p.revents = 0;
-		err = ppoll(&p, 1, NULL, &sigs);
+		err = poll(&p, 1, -1);
 		if (err < 0 && errno == EINTR)
 			continue;
-		if (err)
-			break;
+                if (err)
+                        break;
 	}
-	if (!exiting) {
+	if (!exiting)
+	{
 		err = read(st_fd, &rf_event, sizeof(rf_event));
-		UIM_DBG("rf_event: idx %d, type %d, op %d, hard %d, soft %d with rfkill_idx=%d and state:%d\n", rf_event.idx,
-			rf_event.type, rf_event.op , rf_event.hard,
-			rf_event.soft, rfkill_idx, st_state);
-		if ((rf_event.op == 2) /*&&
-			(rf_event.idx == rfkill_idx)*/) {
-			if (rf_event.hard == 1) {
+		UIM_DBG("rf_event: %d, %d, %d, %d, %d\n", rf_event.idx,
+			rf_event.type, rf_event.op ,rf_event.hard,
+			rf_event.soft);
+		/* Since non-android/ubuntu solution for UIM doesn't insert
+		 * modules, the rfkill entry relevant to TI ST can only be known
+		 * by listening onto each of the RFKILL_OP_ADD event
+		 */
+#ifndef ANDROID
+		if (rf_event.op == RFKILL_OP_ADD) {
+			UIM_DBG("RFKILL_OP_ADD received\n");
+			change_rfkill_perms();
+			goto RE_POLL;
+		}
+#endif
+		if ((rf_event.op == RFKILL_OP_CHANGE) &&
+			(rf_event.idx == rfkill_idx)) {
+			if (rf_event.hard == 1)
 				st_state = UNINSTALL_N_TI_WL;
-				UIM_DBG("UNINSTALL_N_TI_WL");
-			} else {
+			else
 				st_state = INSTALL_N_TI_WL;
-				UIM_DBG("INSTALL_N_TI_WL");
-			}
+
 			if (prev_st_state != st_state)
 				st_uart_config();
 		}
 		goto RE_POLL;
 	}
 
-	if (remove_modules() < 0) {
+#ifdef ANDROID
+	if(remove_modules() < 0) {
 		UIM_ERR(" Error removing modules ");
 		close(st_fd);
 		return -1;
 	}
+#endif
 
 	close(st_fd);
 	return 0;
diff --git a/uim.h b/uim.h
index fff0ff8..ec722df 100644
--- a/uim.h
+++ b/uim.h
@@ -24,18 +24,14 @@
 #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
+#define TCGETS2      _IOR('T',0x2A, struct termios2)
+#define TCSETS2      _IOW('T',0x2B, struct termios2)
 
 /*HCI Command and Event information*/
-#define HCI_HDR_OPCODE  0xff36
-#define RESP_PREFIX	0x04
-#define MAX_TRY		10
+#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
@@ -43,6 +39,7 @@
 
 /* HCI command macros*/
 #define HCI_EVENT_HDR_SIZE      2
+#define HCI_COMMAND_HDR_SIZE	3
 #define HCI_COMMAND_HDR_SIZE    3
 
 /* HCI event macros*/
@@ -51,15 +48,34 @@
 #define EVT_CMD_COMPLETE	0x0E
 #define EVT_CMD_STATUS		0x0F
 
+
 #define VERBOSE
+#ifdef ANDROID
+#define LOG_TAG "uim-rfkill: "
+#define UIM_ERR(fmt, arg...)  LOGE("uim:"fmt"\n" , ##arg)
+#if defined(UIM_DEBUG)          /* limited debug messages */
+#define UIM_START_FUNC()      LOGE("uim: Inside %s", __FUNCTION__)
+#define UIM_DBG(fmt, arg...)  LOGE("uim:"fmt"\n" , ## arg)
+#define UIM_VER(fmt, arg...)
+#elif defined(VERBOSE)          /* very verbose */
+#define UIM_START_FUNC()      LOGE("uim: Inside %s", __FUNCTION__)
+#define UIM_DBG(fmt, arg...)  LOGE("uim:"fmt"\n" , ## arg)
+#define UIM_VER(fmt, arg...)  LOGE("uim:"fmt"\n" , ## arg)
+#else /* error msgs only */
+#define UIM_START_FUNC()
+#define UIM_DBG(fmt, arg...)
+#define UIM_VER(fmt, arg...)
+#endif
+#endif  /* ANDROID */
+
 /*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", __func__)
+#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: Inside %s", __func__)
+#define UIM_START_FUNC()      printf("uim: Inside %s", __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 */
@@ -81,45 +97,57 @@
 };
 
 /* HCI command header*/
-struct hci_command_hdr {
-	uint16_t        opcode;         /* OCF & OGF */
-	uint8_t         plen;
-} __attribute__ ((packed));
+typedef struct {
+        uint16_t        opcode;         /* OCF & OGF */
+        uint8_t         plen;
+} __attribute__ ((packed))      hci_command_hdr;
 
 /* HCI event header*/
-struct hci_event_hdr {
-	uint8_t         evt;
-	uint8_t         plen;
-} __attribute__ ((packed));
+typedef struct {
+        uint8_t         evt;
+        uint8_t         plen;
+} __attribute__ ((packed))      hci_event_hdr;
 
 /* HCI command complete event*/
-struct evt_cmd_complete {
-	uint8_t         ncmd;
-	uint16_t        opcode;
-} __attribute__ ((packed));
+typedef struct {
+        uint8_t         ncmd;
+        uint16_t        opcode;
+} __attribute__ ((packed)) evt_cmd_complete;
 
 /* HCI event status*/
-struct evt_cmd_status {
-	uint8_t         status;
-	uint8_t         ncmd;
-	uint16_t        opcode;
-} __attribute__ ((packed));
+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*/
-struct command_complete_t {
+typedef struct {
 	uint8_t uart_prefix;
-	struct hci_event_hdr hci_hdr;
-	struct evt_cmd_complete cmd_complete;
+	hci_event_hdr hci_hdr;
+	evt_cmd_complete cmd_complete;
 	uint8_t status;
 	uint8_t data[16];
-} __attribute__ ((packed));
+} __attribute__ ((packed)) command_complete_t;
 
 /* HCI Command structure to set the cusrom baud rate*/
-struct uim_speed_change_cmd {
+typedef struct {
 	uint8_t uart_prefix;
-	struct hci_command_hdr hci_hdr;
+	hci_command_hdr hci_hdr;
 	uint32_t speed;
-} __attribute__ ((packed));
+} __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;\
 
 /* Signal received from KIM will install line discipline at first,
  * the next signal received from KIM will un-install the