tools/bcmtool_4343w.c

   1 /*****************************************************************************
   2 **
   3 **  Name:          bcmtool.c
   4 **
   5 **  Description:   Download a patchram files for the HCD format
   6 **
   7 **  Copyright (c) 2000-2009, Broadcom Corp., All Rights Reserved.
   8 ******************************************************************************/
   9
  10 #include <stdio.h>
  11 #include <errno.h>
  12 #include <sys/types.h>
  13 #include <sys/stat.h>
  14 #include <fcntl.h>
  15 #include <stdlib.h>
  16 #include <time.h>
  17 #include <string.h>
  18 #include <signal.h>
  19 #include <unistd.h>
  20 #include <sys/termios.h>
  21 #include <sys/ioctl.h>
  22 #include <limits.h>
  23
  24 #define N_HCI   15
  25 #define HCI_UART_H4             0
  26 #define HCI_UART_BCSP   1
  27 #define HCI_UART_3WIRE  2
  28 #define HCI_UART_H4DS   3
  29 #define HCI_UART_LL             4
  30 #define HCIUARTSETPROTO         _IOW('U', 200, int)
  31 #define HCIUARTGETPROTO         _IOR('U', 201, int)
  32 #define HCIUARTGETDEVICE        _IOR('U', 202, int)
  33
  34 /* BT_WAKE Polarity - 0=Active Low, 1= Active High */
  35 #define HCILP_BT_WAKE_POLARITY        1
  36
  37 /* HOST_WAKE Polarity - 0=Active Low, 1= Active High */
  38 #define HCILP_HOST_WAKE_POLARITY      1
  39
  40 /* Local Feature */
  41 #define BCM_DISABLE_RF_PWRCTRL        FALSE
  42
  43 #define RELEASE_DATE "2011.02.07"
  44 #define DEBUG 1
  45
  46 typedef unsigned char UINT8;
  47 typedef unsigned short UINT16;
  48 typedef unsigned long UINT32;
  49 typedef signed long INT32;
  50 typedef signed char INT8;
  51 typedef signed short INT16;
  52 typedef unsigned char BOOLEAN;
  53
  54 #define FALSE    0
  55 #define TRUE     (!FALSE)
  56
  57 #define BD_ADDR_LEN     6       /* Device address length */
  58 typedef UINT8 BD_ADDR[BD_ADDR_LEN];     /* Device address */
  59
  60 #define HCI_GRP_LINK_CONTROL_CMDS                 (0x01 << 10)
  61 #define HCI_GRP_LINK_POLICY_CMDS                  (0x02 << 10)
  62 #define HCI_GRP_HOST_CONT_BASEBAND_CMDS           (0x03 << 10)
  63 #define HCI_GRP_INFORMATIONAL_PARAMS              (0x04 << 10)
  64 #define HCI_GRP_STATUS_PARAMS                     (0x05 << 10)
  65 #define HCI_GRP_TESTING_CMDS                      (0x06 << 10)
  66 #define HCI_GRP_L2CAP_CMDS                        (0x07 << 10)
  67 #define HCI_GRP_L2CAP_HCI_EVTS                    (0x08 << 10)
  68 #define HCI_GRP_VENDOR_SPECIFIC                   (0x3F << 10)
  69
  70 #define HCI_RESET                                 (0x0003 | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
  71 #define HCI_SET_EVENT_FILTER                      (0x0005 | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
  72 #define HCI_READ_LOCAL_NAME                       (0x0014 | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
  73 #define HCI_READ_SCAN_ENABLE                      (0x0019 | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
  74 #define HCI_WRITE_SCAN_ENABLE                     (0x001A | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
  75
  76 #define HCI_READ_LOCAL_VERSION_INFO               (0x0001 | HCI_GRP_INFORMATIONAL_PARAMS)
  77 #define HCI_READ_LOCAL_FEATURES                   (0x0003 | HCI_GRP_INFORMATIONAL_PARAMS)
  78
  79 #define HCI_ENABLE_DEV_UNDER_TEST_MODE            (0x0003 | HCI_GRP_TESTING_CMDS)
  80
  81 #define HCI_BRCM_SUPER_PEEK_POKE                  (0x000A | HCI_GRP_VENDOR_SPECIFIC)
  82 #define VSC_WRITE_BD_ADDR                         (0x0001 | HCI_GRP_VENDOR_SPECIFIC)
  83 #define VSC_HCI_CMD_SET_LOC_FEATURES_CMD          (0x000B | HCI_GRP_VENDOR_SPECIFIC)
  84 #define HCI_BRCM_UPDATE_BAUDRATE_CMD              (0x0018 | HCI_GRP_VENDOR_SPECIFIC)
  85 #define HCI_BRCM_WRITE_SCO_PCM_INT_PARAM          (0x001C | HCI_GRP_VENDOR_SPECIFIC)
  86 #define VSC_WRITE_PCM_DATA_FORMAT_PARAM           (0x001E | HCI_GRP_VENDOR_SPECIFIC)
  87 #define HCI_BRCM_WRITE_SLEEP_MODE                 (0x0027 | HCI_GRP_VENDOR_SPECIFIC)
  88 #define HCI_BRCM_DOWNLOAD_MINI_DRV                (0x002E | HCI_GRP_VENDOR_SPECIFIC)
  89 #define VSC_WRITE_UART_CLOCK_SETTING              (0x0045 | HCI_GRP_VENDOR_SPECIFIC)
  90 #define HCI_VSC_WRITE_RAM                         (0x004C | HCI_GRP_VENDOR_SPECIFIC)
  91 #define HCI_VSC_LAUNCH_RAM                        (0x004E | HCI_GRP_VENDOR_SPECIFIC)
  92
  93 #define VOICE_SETTING_MU_LAW_MD                   0x0100
  94 #define VOICE_SETTING_LINEAR_MD                   0x0060
  95
  96 #define HCI_ARM_MEM_PEEK                          0x04
  97 #define HCI_ARM_MEM_POKE                          0x05
  98
  99 #define BTUI_MAX_STRING_LENGTH_PER_LINE           255
 100 #define HCI_BRCM_WRITE_SLEEP_MODE_LENGTH          12
 101
 102 #define HCI_BRCM_UPDATE_BAUD_RATE_ENCODED_LENGTH    0x02
 103 #define HCI_BRCM_UPDATE_BAUD_RATE_UNENCODED_LENGTH  0x06
 104
 105 #define VSC_WRITE_UART_CLOCK_SETTING_LEN          1
 106
 107 /* print string with time stamp */
 108 #define TDEBUG0(m)                               if(debug_mode) {print_time();fprintf(stderr,m);}
 109 #define TDEBUG1(m,n1)                            if(debug_mode) {print_time();fprintf(stderr,m,n1);}
 110 #define TDEBUG2(m,n1,n2)                         if(debug_mode) {print_time();fprintf(stderr,m,n1,n2);}
 111 #define TDEBUG3(m,n1,n2,n3)                      if(debug_mode) {print_time();fprintf(stderr,m,n1,n2,n3);}
 112 #define TDEBUG4(m,n1,n2,n3,n4)                   if(debug_mode) {print_time();fprintf(stderr,m,n1,n2,n3,n4);}
 113 #define TDEBUG5(m,n1,n2,n3,n4,n5)                if(debug_mode) {print_time();fprintf(stderr,m,n1,n2,n3,n4,n5);}
 114 #define TDEBUG6(m,n1,n2,n3,n4,n5,n6)             if(debug_mode) {print_time();fprintf(stderr,m,n1,n2,n3,n4,n5,n6);}
 115
 116 /* print just string */
 117 #define DEBUG0(m)                               if(debug_mode) {fprintf(stderr,m);}
 118 #define DEBUG1(m,n1)                            if(debug_mode) {fprintf(stderr,m,n1);}
 119 #define DEBUG2(m,n1,n2)                         if(debug_mode) {fprintf(stderr,m,n1,n2);}
 120 #define DEBUG3(m,n1,n2,n3)                      if(debug_mode) {fprintf(stderr,m,n1,n2,n3);}
 121 #define DEBUG4(m,n1,n2,n3,n4)                   if(debug_mode) {fprintf(stderr,m,n1,n2,n3,n4);}
 122 #define DEBUG5(m,n1,n2,n3,n4,n5)                if(debug_mode) {fprintf(stderr,m,n1,n2,n3,n4,n5);}
 123 #define DEBUG6(m,n1,n2,n3,n4,n5,n6)             if(debug_mode) {fprintf(stderr,m,n1,n2,n3,n4,n5,n6);}
 124
 125 #define STREAM_TO_UINT8(u8, p)   {u8 = (UINT8)(*(p)); (p) += 1;}
 126 #define STREAM_TO_UINT16(u16, p) {u16 = ((UINT16)(*(p)) + (((UINT16)(*((p) + 1))) << 8)); (p) += 2;}
 127 #define STREAM_TO_UINT32(u32, p) {u32 = (((UINT32)(*(p))) + ((((UINT32)(*((p) + 1)))) << 8) + ((((UINT32)(*((p) + 2)))) << 16) + ((((UINT32)(*((p) + 3)))) << 24)); (p) += 4;}
 128
 129 #define ROTATE_BD_ADDR(p1, p2)    \
 130                                                                         do                 \
 131                                                                         {                                                       \
 132                                                                                 p1[0] = p2[5];          \
 133                                                                                 p1[1] = p2[4];          \
 134                                                                                 p1[2] = p2[3];          \
 135                                                                                 p1[3] = p2[2];          \
 136                                                                                 p1[4] = p2[1];          \
 137                                                                                 p1[5] = p2[0];          \
 138                                                                         } while (0)
 139
 140 UINT8 vsc_for_pcm_config[5] = { 0x00, 0x00, 0x03, 0x03, 0x00 };
 141
 142 /*
 143                     Byte1 -- 0 for MSb first
 144                     Byte2 -- 0 Fill value
 145                     Byte3 -- 1 Fill option (0:0's, 1:1's , 2:Signed, 3:Programmable)
 146                     Byte4 -- 1 Number of fill bits
 147                     Byte5 -- 1 Right justified (0 for left justified)
 148 */
 149
 150 UINT8 vsc_for_sco_pcm[5] = { 0x00, 0x01, 0x00, 0x01, 0x01 };
 151
 152 /*
 153                     Neverland : PCM, 256, short, master ,master
 154                     Volance   : PCM, 256, short, master ,master
 155
 156                     Byte1 -- 0 for PCM 1 for UART or USB
 157                     Byte2 -- 0 : 128, 1: 256, 2:512, 3:1024, 4:2048 Khz
 158                     Byte3 -- 0 for short frame sync 1 for long frame sync
 159                     Byte4 -- 0 Clock direction 0 for same as sync 1 for opposite direction
 160                     Byte5 -- 0 for slave 1 for master
 161 */
 162
 163 int fd;                         /* HCI handle */
 164
 165 BOOLEAN debug_mode = FALSE;     /* Debug Mode Enable */
 166
 167 BOOLEAN use_two_stop_bits = FALSE;     /* Flag of two stop bits for tty */
 168
 169 BOOLEAN use_high_speed_download_mode = TRUE;     /* Flag of High Speed download mode */
 170
 171 unsigned char buffer[1024];
 172
 173 typedef enum {
 174         BCM_UNKNOWN = 0,
 175         BCM4330,
 176         BCM4334W,
 177         BCM4343W,
 178 } bcm_product_type;
 179
 180 bcm_product_type bcm_target_product = BCM_UNKNOWN;
 181
 182 static struct {
 183         bcm_product_type bcm_product;
 184         char *name;
 185 } bcm_product_table[] = {
 186         { BCM_UNKNOWN,  "UNKNOWN"},
 187         { BCM4330,      "BCM4330"},
 188         { BCM4334W,     "BCM4334W"},
 189         { BCM4343W,     "BCM4343W"},
 190         { 0, NULL }
 191 };
 192
 193 struct termios termios;
 194
 195 void ChangeBaudRate(UINT32 baudrate);
 196
 197 void exit_err(UINT8 err)
 198 {
 199         if (use_high_speed_download_mode)
 200                 ChangeBaudRate(115200);
 201
 202         exit(err);
 203 }
 204
 205 void print_time(void)
 206 {
 207 #if 0
 208         struct timespec tp;
 209         int rs;
 210
 211         rs = clock_gettime(CLOCK_REALTIME, &tp);
 212         fprintf(stderr, "[%04d : %06d]\n", tp.tv_sec, tp.tv_nsec / 1000);
 213         return;
 214 #endif
 215 }
 216
 217 void dump(unsigned char *out, int len)
 218 {
 219         int i;
 220
 221         for (i = 0; i < len; i++) {
 222                 if (!(i % 16)) {
 223                         DEBUG0("\n");
 224                 }
 225                 DEBUG1("%02x ", out[i]);
 226         }
 227         DEBUG0("\n\n");
 228 }
 229
 230 UINT8 SendCommand(UINT16 opcode, UINT8 param_len, UINT8 * p_param_buf)
 231 {
 232         UINT8 pbuf[255] = { 0, };
 233         UINT8 i = 0;
 234
 235         pbuf[0] = 0x1;
 236         pbuf[1] = (UINT8) (opcode);
 237         pbuf[2] = (UINT8) (opcode >> 8);
 238         pbuf[3] = param_len;
 239
 240         for (i = 0; i < param_len; i++) {
 241                 pbuf[i + 4] = *p_param_buf++;
 242         }
 243
 244         DEBUG1("Send %d", param_len + 4);
 245
 246         dump(pbuf, param_len + 4);
 247
 248         if (write(fd, pbuf, param_len + 4) < 0)
 249                 DEBUG0("Fail to write pbuf");
 250
 251         return 0;
 252 }
 253
 254 void expired(int sig)
 255 {
 256         static UINT8 count = 0;
 257         DEBUG0("expired try again\n");
 258         SendCommand(HCI_RESET, 0, NULL);
 259         alarm(1);
 260         count++;
 261
 262         if (count > 3) {
 263                 fprintf(stderr, "[ERR] HCI reset time expired\n");
 264                 exit(1);
 265         }
 266 }
 267
 268 void read_event(int fd, unsigned char *buffer)
 269 {
 270         int i = 0;
 271         int len = 3;
 272         int count;
 273
 274         while ((count = read(fd, &buffer[i], len)) < len) {
 275                 i += count;
 276                 len -= count;
 277         }
 278
 279         i += count;
 280         len = buffer[2];
 281
 282         while ((count = read(fd, &buffer[i], len)) < len) {
 283                 i += count;
 284                 len -= count;
 285         }
 286
 287 #ifdef DEBUG
 288         count += i;
 289
 290         DEBUG1("\nreceived %d", count);
 291         dump(buffer, count);
 292 #endif
 293 }
 294
 295 INT32 filesize(char *name)
 296 {
 297         INT32 size;
 298         int flag;
 299         struct stat buf;
 300
 301         flag = stat(name, &buf);
 302         if (flag == -1)
 303                 return -1;
 304
 305         size = buf.st_size;
 306         return (size);
 307 }
 308
 309 void DisplayProgress(int total, int val)
 310 {
 311 #if 0
 312 #define PROGRESS_NUM 20
 313
 314         int p;
 315         int i;
 316         char text[PROGRESS_NUM + 2] = { 0, };
 317
 318         text[0] = '[';
 319         text[PROGRESS_NUM + 1] = ']';
 320         p = (val * PROGRESS_NUM) / total;
 321
 322         for (i = 1; i <= p; i++) {
 323                 text[i] = '=';
 324         }
 325
 326         for (i = p + 1; i <= PROGRESS_NUM; i++) {
 327                 text[i] = ' ';
 328         }
 329
 330         for (i = 0; i <= (PROGRESS_NUM + 1); i++) {
 331                 fprintf(stderr, "%c", text[i]);
 332         }
 333
 334         if (p >= PROGRESS_NUM)
 335                 fprintf(stderr, "  %6d/%6d\n", val, total);
 336         else
 337                 fprintf(stderr, "  %6d/%6d\r", val, total);
 338 #else
 339         if (val == total)
 340                 fprintf(stderr, " %6d/%6d\n", val, total);
 341         else
 342                 fprintf(stderr, " %6d/%6d\r", val, total);
 343 #endif
 344 }
 345
 346 UINT8 DownloadPatchram(char *patchram1)
 347 {
 348         UINT32 len;
 349         char prm[128] = { 0, };
 350         FILE *pFile = NULL;
 351         size_t size;
 352
 353 #if 0
 354         INT32 FileSize = 0;
 355 #endif
 356         INT32 SentSize = 0;
 357
 358         DEBUG1("\n%s\n", patchram1);
 359
 360         /* HCI reset */
 361         DEBUG0("HCI reset\n");
 362         SendCommand(HCI_RESET, 0, NULL);
 363         alarm(1);
 364         read_event(fd, buffer);
 365         alarm(0);
 366
 367         if (use_high_speed_download_mode)
 368                 ChangeBaudRate(3000000);
 369
 370         strcpy(prm, patchram1);
 371
 372         fprintf(stderr, "Download Start\n");
 373
 374         if ((pFile = fopen(prm, "r")) == NULL) {
 375                 fprintf(stderr, "file %s could not be opened, error %d\n", prm,
 376                         errno);
 377                 exit_err(1);
 378         }
 379
 380 #if 0
 381         FileSize = filesize(prm);
 382 #endif
 383
 384         SendCommand(HCI_BRCM_DOWNLOAD_MINI_DRV, 0, NULL);
 385         read_event(fd, buffer);
 386
 387         usleep(50000);
 388
 389         while (fread(&buffer[1], sizeof(UINT8), 3, pFile)) {
 390                 buffer[0] = 0x01;
 391
 392                 len = buffer[3];
 393
 394                 size = fread(&buffer[4], sizeof(UINT8), len, pFile);
 395                 fprintf(stderr, "fread size: %d\n", (int) size);
 396
 397                 size = write(fd, buffer, len + 4);
 398                 fprintf(stderr, "write size: %d\n", (int) size);
 399
 400                 /* dispaly progress */
 401                 SentSize += (len + 3);
 402 #if 0
 403                 DisplayProgress(FileSize, SentSize);
 404 #endif
 405                 /* dispaly progress */
 406
 407                 read_event(fd, buffer);
 408
 409         }
 410         fclose(pFile);
 411
 412         if (bcm_target_product == BCM4343W) {
 413                 fprintf(stderr, "Delay 200ms for BCM4343W Wireless Charging Feature\n");
 414                 usleep(200000);         /*200ms delay */
 415         } else {
 416                 usleep(100000);         /*100ms delay */
 417         }
 418
 419         tcflush(fd, TCIOFLUSH);
 420         tcgetattr(fd, &termios);
 421         cfmakeraw(&termios);
 422         termios.c_cflag |= CRTSCTS;
 423
 424         if (use_two_stop_bits)
 425                 termios.c_cflag |= CSTOPB;
 426
 427         tcsetattr(fd, TCSANOW, &termios);
 428         tcflush(fd, TCIOFLUSH);
 429         tcsetattr(fd, TCSANOW, &termios);
 430         tcflush(fd, TCIOFLUSH);
 431         tcflush(fd, TCIOFLUSH);
 432         cfsetospeed(&termios, B115200);
 433         cfsetispeed(&termios, B115200);
 434         tcsetattr(fd, TCSANOW, &termios);
 435
 436         /* Send HCI_RESET Command and process event */
 437         DEBUG0("HCI reset\n");
 438         SendCommand(HCI_RESET, 0, NULL);
 439         alarm(1);
 440         read_event(fd, buffer);
 441         alarm(0);
 442         fprintf(stderr, "Download Complete\n");
 443
 444         return 0;
 445 }
 446
 447 void SetScanEnable(void)
 448 {
 449         UINT8 scan_data[1];
 450
 451         /* 0x00: No scan enabled                            */
 452         /* 0x01: Inquiry scan enabled  | Page scan disabled */
 453         /* 0x02: Inquiry scan disabled | Page scan enabled  */
 454         /* 0x03: Inquiry scan enabled  | Page scan enabled  */
 455
 456         scan_data[0] = 0x03;
 457         SendCommand(HCI_WRITE_SCAN_ENABLE, 1, &scan_data[0]);
 458         read_event(fd, buffer);
 459 }
 460
 461 /* This patch has been added to write PCM setting for Ponte */
 462 void SetAudio_for_PCM(void)
 463 {
 464         fprintf(stderr, "Write Audio parameter for PCM\n");
 465
 466         vsc_for_pcm_config[0] = 0x0;
 467         vsc_for_pcm_config[1] = 0x0;
 468         vsc_for_pcm_config[2] = 0x3; /* PCM format 16bit */
 469         vsc_for_pcm_config[3] = 0x0;
 470         vsc_for_pcm_config[4] = 0x0;
 471
 472         DEBUG5("vsc_for_pcm_config = {%d,%d,%d,%d,%d}\n", vsc_for_pcm_config[0],
 473                vsc_for_pcm_config[1], vsc_for_pcm_config[2],
 474                vsc_for_pcm_config[3], vsc_for_pcm_config[4]);
 475
 476         SendCommand(VSC_WRITE_PCM_DATA_FORMAT_PARAM, 5,
 477                     (UINT8 *) vsc_for_pcm_config);
 478         read_event(fd, buffer);
 479 }
 480
 481 void SetAudio(void)
 482 {
 483         fprintf(stderr, "Write Audio parameter\n");
 484
 485         DEBUG5("vsc_for_sco_pcm = {%d,%d,%d,%d,%d}\n", vsc_for_sco_pcm[0],
 486                vsc_for_sco_pcm[1], vsc_for_sco_pcm[2],
 487                vsc_for_sco_pcm[3], vsc_for_sco_pcm[4]);
 488
 489         SendCommand(HCI_BRCM_WRITE_SCO_PCM_INT_PARAM, 5,
 490                     (UINT8 *) vsc_for_sco_pcm);
 491         read_event(fd, buffer);
 492
 493         DEBUG5("vsc_for_pcm_config = {%d,%d,%d,%d,%d}\n", vsc_for_pcm_config[0],
 494                vsc_for_pcm_config[1], vsc_for_pcm_config[2],
 495                vsc_for_pcm_config[3], vsc_for_pcm_config[4]);
 496
 497         SendCommand(VSC_WRITE_PCM_DATA_FORMAT_PARAM, 5,
 498                     (UINT8 *) vsc_for_pcm_config);
 499         read_event(fd, buffer);
 500 }
 501
 502 void SetPcmConf(UINT8 p0, UINT8 p1, UINT8 p2, UINT8 p3, UINT8 p4)
 503 {
 504         vsc_for_pcm_config[0] = p0;
 505         vsc_for_pcm_config[1] = p1;
 506         vsc_for_pcm_config[2] = p2;
 507         vsc_for_pcm_config[3] = p3;
 508         vsc_for_pcm_config[4] = p4;
 509 }
 510
 511 void SetScoConf(UINT8 p0, UINT8 p1, UINT8 p2, UINT8 p3, UINT8 p4)
 512 {
 513         vsc_for_sco_pcm[0] = p0;
 514         vsc_for_sco_pcm[1] = p1;
 515         vsc_for_sco_pcm[2] = p2;
 516         vsc_for_sco_pcm[3] = p3;
 517         vsc_for_sco_pcm[4] = p4;
 518 }
 519
 520 void HCILP_Enable(BOOLEAN on)
 521 {
 522         /* Host Stack Idle Threshold */
 523         UINT8 hcilp_idle_threshold = 0x01;
 524
 525         /* Host Controller Idle Threshold */
 526         UINT8 hcilp_hc_idle_threshold = 0x01;
 527
 528         if (bcm_target_product == BCM4343W) {
 529                 hcilp_idle_threshold = 0x0A;
 530                 hcilp_hc_idle_threshold = 0x0A;
 531         }
 532
 533         fprintf(stderr, "Set Low Power mode %d for %s\n", on,
 534                                 bcm_product_table[bcm_target_product].name);
 535
 536         UINT8 data[HCI_BRCM_WRITE_SLEEP_MODE_LENGTH] = {
 537                 0x01,           /* Sleep Mode algorithm 1 */
 538                 hcilp_idle_threshold,   /* Host Idle Treshold */
 539                 hcilp_hc_idle_threshold,        /* Host Controller Idle Treshold*//* this should be less than scan interval. */
 540                 HCILP_BT_WAKE_POLARITY, /* BT_WAKE Polarity - 0=Active Low, 1= Active High */
 541                 HCILP_HOST_WAKE_POLARITY,       /* HOST_WAKE Polarity - 0=Active Low, 1= Active High */
 542                 0x01,           /* Allow host Sleep during SCO */
 543                 0x01,           /* Combine Sleep Mode and LPM - The device will not sleep in mode 0 if this flag is set to 1, */
 544                 0x00,           /* UART_TXD Tri-State : 0x00 = Do not tri-state UART_TXD in sleep mode */
 545                 0x00,           /* NA to Mode 1 */
 546                 0x00,           /* NA to Mode 1 */
 547                 0x00,           /* NA*/
 548                 0x00,           /* NA*/
 549         };
 550
 551         if (on) {
 552                 data[0] = 0x01;
 553         } else {
 554                 data[0] = 0x00;
 555         }
 556
 557         SendCommand(HCI_BRCM_WRITE_SLEEP_MODE, HCI_BRCM_WRITE_SLEEP_MODE_LENGTH,
 558                     (UINT8 *) data);
 559         read_event(fd, buffer);
 560 }
 561
 562 UINT32 uart_speed(UINT32 Speed)
 563 {
 564         switch (Speed) {
 565         case 115200:
 566                 return B115200;
 567         case 230400:
 568                 return B230400;
 569         case 460800:
 570                 return B460800;
 571         case 921600:
 572                 return B921600;
 573         case 1000000:
 574                 return B1000000;
 575         case 1500000:
 576                 return B1500000;
 577         case 2000000:
 578                 return B2000000;
 579         case 2500000:
 580                 return B2500000;
 581         case 3000000:
 582                 return B3000000;
 583         case 4000000:
 584                 return B4000000;
 585         default:
 586                 return B115200;
 587         }
 588 }
 589
 590 void ChangeBaudRate(UINT32 baudrate)
 591 {
 592         UINT8 hci_data[HCI_BRCM_UPDATE_BAUD_RATE_UNENCODED_LENGTH] =
 593             { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 594         UINT8 uart_clock_24 = 0x2;      /* 0x1 - UART Clock 48MHz, 0x2 - UART Clock 24MHz */
 595         UINT8 uart_clock_48 = 0x1;      /* 0x1 - UART Clock 48MHz, 0x2 - UART Clock 24MHz */
 596
 597         switch (baudrate) {
 598         case 115200:
 599         case 230400:
 600         case 460800:
 601         case 921600:
 602         case 1000000:
 603         case 1500000:
 604         case 2000000:
 605         case 2500000:
 606                 /* Write UART Clock setting of 24MHz */
 607                 DEBUG0("Change UART_CLOCK 24Mhz\n");
 608                 SendCommand(VSC_WRITE_UART_CLOCK_SETTING,
 609                             VSC_WRITE_UART_CLOCK_SETTING_LEN,
 610                             (UINT8 *) & uart_clock_24);
 611                 read_event(fd, buffer);
 612                 break;
 613
 614         case 3000000:
 615         case 4000000:
 616                 /* Write UART Clock setting of 48MHz */
 617                 DEBUG0("Change UART_CLOCK 48Mhz\n");
 618                 SendCommand(VSC_WRITE_UART_CLOCK_SETTING,
 619                             VSC_WRITE_UART_CLOCK_SETTING_LEN,
 620                             (UINT8 *) & uart_clock_48);
 621                 read_event(fd, buffer);
 622                 break;
 623
 624         default:
 625                 fprintf(stderr, "Not Support baudrate = %ld\n", baudrate);
 626                 exit_err(1);
 627                 break;
 628         }
 629
 630         hci_data[2] = baudrate & 0xFF;
 631         hci_data[3] = (baudrate >> 8) & 0xFF;
 632         hci_data[4] = (baudrate >> 16) & 0xFF;
 633         hci_data[5] = (baudrate >> 24) & 0xFF;
 634
 635         DEBUG1("Change Baudrate %ld\n", baudrate);
 636
 637         SendCommand(HCI_BRCM_UPDATE_BAUDRATE_CMD,
 638                     HCI_BRCM_UPDATE_BAUD_RATE_UNENCODED_LENGTH,
 639                     (UINT8 *) hci_data);
 640         read_event(fd, buffer);
 641
 642         tcflush(fd, TCIOFLUSH);
 643         tcgetattr(fd, &termios);
 644         cfmakeraw(&termios);
 645         termios.c_cflag |= CRTSCTS;
 646
 647         if (use_two_stop_bits)
 648                 termios.c_cflag |= CSTOPB;
 649
 650         tcsetattr(fd, TCSANOW, &termios);
 651         tcflush(fd, TCIOFLUSH);
 652         tcsetattr(fd, TCSANOW, &termios);
 653         tcflush(fd, TCIOFLUSH);
 654         tcflush(fd, TCIOFLUSH);
 655         cfsetospeed(&termios, uart_speed(baudrate));
 656         cfsetispeed(&termios, uart_speed(baudrate));
 657         tcsetattr(fd, TCSANOW, &termios);
 658
 659 }
 660
 661 void EnableTestMode(void)
 662 {
 663         UINT8 filter_data[] = { 0x02, 0x00, 0x02 };
 664
 665         /* bt sleep  disable */
 666         HCILP_Enable(FALSE);
 667
 668         /* Enable both Inquiry & Page Scans */
 669         SetScanEnable();
 670
 671         /* Set Event Filter: Enable Auto Connect */
 672         SendCommand(HCI_SET_EVENT_FILTER, 0x03, (UINT8 *) filter_data);
 673         read_event(fd, buffer);
 674
 675         /* Enable Device under test */
 676         SendCommand(HCI_ENABLE_DEV_UNDER_TEST_MODE, 0x0, NULL);
 677         read_event(fd, buffer);
 678
 679         fprintf(stderr, "Enable Device Under Test\n");
 680 }
 681
 682 void GetLocalName(void)
 683 {
 684         UINT8 *data = NULL;
 685
 686         /* HCI reset */
 687         DEBUG0("HCI reset\n");
 688         SendCommand(HCI_RESET, 0, NULL);
 689         alarm(1);
 690         read_event(fd, buffer);
 691         alarm(0);
 692
 693         DEBUG0("Read Local Name\n");
 694         SendCommand(HCI_READ_LOCAL_NAME, 0, NULL);
 695         read_event(fd, buffer);
 696
 697         data = &buffer[7];
 698
 699         fprintf(stderr, "Chip Name is %s\n", data);
 700 }
 701
 702 void SetLocalFeatures(void)
 703 {
 704         UINT8 *data = NULL;
 705
 706         DEBUG0("Read Local Feature\n");
 707         SendCommand(HCI_READ_LOCAL_FEATURES, 0, NULL);
 708         read_event(fd, buffer);
 709
 710         data = &buffer[7];
 711
 712 #if (BCM_DISABLE_RF_PWRCTRL == TRUE)
 713         fprintf(stderr, "Remove Power Control\n");
 714         data[2] &= 0xFB;        /* Power contrel */
 715 #endif
 716         DEBUG0("Write Local Feature\n");
 717         SendCommand(VSC_HCI_CMD_SET_LOC_FEATURES_CMD, 0x08, (UINT8 *) data);
 718         read_event(fd, buffer);
 719 }
 720
 721 void EnbleHCI(void)
 722 {
 723         int i = N_HCI;
 724         int proto = HCI_UART_H4;
 725
 726         if (ioctl(fd, TIOCSETD, &i) < 0) {
 727                 fprintf(stderr, "Can't set line discipline\n");
 728                 return;
 729         }
 730
 731         if (ioctl(fd, HCIUARTSETPROTO, proto) < 0) {
 732                 fprintf(stderr, "Can't set hci protocol\n");
 733                 return;
 734         }
 735         fprintf(stderr, "Done setting line discpline\n");
 736         return;
 737
 738 }
 739
 740 void SetBcmProductType(char *bcm_product_name)
 741 {
 742         int i = 0;
 743
 744         if (bcm_product_name == NULL) {
 745                 bcm_target_product = BCM_UNKNOWN;
 746                 return;
 747         }
 748
 749         for (i = 0; bcm_product_table[i].name != NULL; i++) {
 750                 if (!strcasecmp(bcm_product_table[i].name,bcm_product_name)) {
 751                         bcm_target_product = bcm_product_table[i].bcm_product;
 752                         fprintf(stderr, "Detected name is %s\n",
 753                                                 bcm_product_table[i].name);
 754                 }
 755         }
 756
 757         return;
 758 }
 759
 760 void print_usage(void)
 761 {
 762         fprintf(stderr, "\n");
 763         fprintf(stderr, "BRCM BT tool for Linux    release %s\n", RELEASE_DATE);
 764         fprintf(stderr, "\n");
 765         fprintf(stderr,
 766                 " Usage: bcmtool <tty Device> <command> [command parameter],....\n\n");
 767         fprintf(stderr,
 768                 "  -FILE    Patchram file name     EX) -FILE=BCM43xx_xxx.hcd\n");
 769         fprintf(stderr,
 770                 "  -BAUD    Set Baudrate           EX) -BAUD=3000000\n");
 771         fprintf(stderr,
 772                 "  -ADDR    BD addr file name      EX) -ADDR=.bdaddr\n");
 773         fprintf(stderr, "  -SCO     Enable SCO/PCM config  EX) -SCO\n");
 774         fprintf(stderr, "  -PCM_SETTING     Write PCM config EX) -PCM_SETTING\n");
 775         fprintf(stderr,
 776                 "  -SETSCO  SCO/PCM values verify  EX) -SETSCO=0,1,0,1,1,0,0,3,3,0\n");
 777         fprintf(stderr, "  -LP      Enable Low power       EX) -LP\n");
 778         fprintf(stderr, "  -FEATURE Set local Feature      EX) -FEATURE\n");
 779         fprintf(stderr, "  -GETNAME Get local Name         EX) -GETNAME\n");
 780         fprintf(stderr,
 781                 "  -DUT     Enable DUT mode(do not use with -LP) EX) -DUT\n");
 782         fprintf(stderr,
 783                 "  -ATTACH  Attach BT controller to BlueZ stack  EX) -ATTACH\n");
 784         fprintf(stderr, "  -DEBUG   Debug message          EX) -DEBUG\n");
 785         fprintf(stderr, "  -CSTOPB  Set two stop bits for tty EX) -CSTOPB\n");
 786         fprintf(stderr, "  -SLOWDOWN Set low speed download mode \n");
 787         fprintf(stderr, "       default is High speed mode EX) -SLOWDOWN\n");
 788         fprintf(stderr, "  -TYPE    BCM Product name       EX) -TYPE=BCM4343W\n");
 789
 790         fprintf(stderr, "\n");
 791 }
 792
 793 int main(int argc, char *argv[])
 794 {
 795         UINT8 i = 0;
 796
 797         if (argc < 2) {
 798                 print_usage();
 799                 exit(1);
 800         } else {
 801                 fprintf(stderr, "BRCM BT tool for Linux    release %s\n",
 802                         RELEASE_DATE);
 803         }
 804
 805         /* Open dev port */
 806         if ((fd = open(argv[1], O_RDWR | O_NOCTTY)) == -1) {
 807                 fprintf(stderr, "port %s could not be opened, error %d\n",
 808                         argv[1], errno);
 809                 exit(2);
 810         }
 811
 812         tcflush(fd, TCIOFLUSH);
 813         tcgetattr(fd, &termios);
 814         cfmakeraw(&termios);
 815         termios.c_cflag |= CRTSCTS;
 816
 817         if (use_two_stop_bits)
 818                 termios.c_cflag |= CSTOPB;
 819
 820         tcsetattr(fd, TCSANOW, &termios);
 821         tcflush(fd, TCIOFLUSH);
 822         tcsetattr(fd, TCSANOW, &termios);
 823         tcflush(fd, TCIOFLUSH);
 824         tcflush(fd, TCIOFLUSH);
 825         cfsetospeed(&termios, B115200);
 826         cfsetispeed(&termios, B115200);
 827         tcsetattr(fd, TCSANOW, &termios);
 828
 829         signal(SIGALRM, expired);
 830
 831         for (i = 2; i < argc; i++) {
 832                 char *ptr = argv[i];
 833
 834                 if (strstr(ptr, "-DEBUG")) {
 835                         debug_mode = TRUE;
 836                         DEBUG0("DEBUG On\n");
 837
 838                 } else if (strstr(ptr, "-CSTOPB")) {
 839                         use_two_stop_bits = TRUE;
 840                         DEBUG0("Use two stop bits for tty\n");
 841
 842                 } else if (strstr(ptr, "-SLOWDOWN")) {
 843                         use_high_speed_download_mode = FALSE;
 844                         DEBUG0("Disable High Speed Download mode\n");
 845
 846                 } else if (strstr(ptr, "-TYPE=")) {
 847                         char bcm_product_name[128];
 848                         ptr +=6;
 849
 850                         strncpy(bcm_product_name,ptr,8);
 851
 852                         SetBcmProductType(bcm_product_name);
 853                 }
 854         }
 855
 856         for (i = 2; i < argc; i++) {
 857                 char *ptr = argv[i];
 858
 859                 if (ptr == NULL)
 860                         continue;
 861
 862                 fprintf(stderr, "[%d] %s\n", i - 1, ptr);
 863
 864                 if (strstr(ptr, "-FILE=")) {
 865                         char prm_name[128];
 866
 867                         ptr += 6;
 868
 869                         strncpy(prm_name, ptr, 127);
 870                         DownloadPatchram(prm_name);
 871
 872                 } else if (strstr(ptr, "-BAUD=")) {
 873                         UINT32 baudrate;
 874
 875                         ptr += 6;
 876                         baudrate = atoi(ptr);
 877
 878                         ChangeBaudRate(baudrate);
 879                 } else if (strstr(ptr, "-ADDR=")) {
 880                         char *bdaddr_filename;
 881                         FILE *pFile = NULL;
 882
 883                         int bdaddr[10]; /* Displayed BD Address */
 884
 885                         BD_ADDR local_addr;     /* BD Address for write */
 886
 887 #if 0
 888                         ptr += 6;
 889                         if (sscanf
 890                             (ptr, "%02X:%02X:%02X:%02X:%02X:%02X", &bdaddr[0],
 891                              &bdaddr[1], &bdaddr[2], &bdaddr[3], &bdaddr[4],
 892                              &bdaddr[5]) != 6) {
 893                                 fprintf(stderr, "-ADDR: Parameter error");
 894                                 exit_err(1);
 895                         }
 896                         bte_write_bdaddr(bdaddr);
 897 #endif
 898                         ptr += 6;
 899                         bdaddr_filename = ptr;
 900
 901                         if (bdaddr_filename) {
 902                                 pFile = fopen(bdaddr_filename, "r");
 903                         }
 904
 905                         if (pFile) {
 906 //                              char *ptr;
 907
 908                                 char text[BTUI_MAX_STRING_LENGTH_PER_LINE];
 909
 910                                 if (!fgets(text, BTUI_MAX_STRING_LENGTH_PER_LINE, pFile))
 911                                         fprintf(stderr, "fail to fgets");
 912
 913                                 sscanf(text, "%02x%02x", &bdaddr[0],
 914                                        &bdaddr[1]);
 915
 916                                 if (!fgets(text, BTUI_MAX_STRING_LENGTH_PER_LINE, pFile))
 917                                         fprintf(stderr, "fail to fgets");
 918
 919                                 sscanf(text, "%02x", &bdaddr[2]);
 920
 921                                 if (!fgets(text, BTUI_MAX_STRING_LENGTH_PER_LINE, pFile))
 922                                         fprintf(stderr, "fail to fgets");
 923
 924                                 sscanf(text, "%02x%02x%02x", &bdaddr[3],
 925                                        &bdaddr[4], &bdaddr[5]);
 926
 927                                 fprintf(stderr,
 928                                         "Writing B/D Address = %02X:%02X:%02X:%02X:%02X:%02X\n",
 929                                         bdaddr[0], bdaddr[1], bdaddr[2],
 930                                         bdaddr[3], bdaddr[4], bdaddr[5]);
 931
 932                                 ROTATE_BD_ADDR(local_addr, bdaddr);
 933
 934                                 SendCommand(VSC_WRITE_BD_ADDR, BD_ADDR_LEN,
 935                                             (UINT8 *) local_addr);
 936                                 read_event(fd, buffer);
 937                         } else {
 938                                 fprintf(stderr, "-ADDR: file open fail\n");
 939                                 exit_err(1);
 940                         }
 941                 } else if (strstr(ptr, "-PCM_SETTING")) {
 942                         SetAudio_for_PCM();
 943
 944                 } else if (strstr(ptr, "-SCO")) {
 945                         SetAudio();
 946
 947                 } else if (strstr(ptr, "-SETSCO=")) {
 948                         ptr += 8;
 949                         int value[10];
 950
 951                         if (sscanf
 952                             (ptr, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", &value[0],
 953                              &value[1], &value[2], &value[3], &value[4],
 954                              &value[5], &value[6], &value[7], &value[8],
 955                              &value[9]) != 10) {
 956                                 DEBUG0("PCM / SCO configuration value err\n");
 957                                 DEBUG0
 958                                     ("SCO_Routing,PCM_Interface_Rate,Frame_Type,Sync_Mode,Clock_Mode,LSB_First,Fill_bits,Fill_Method,Fill_Num,Right_Justify\n");
 959                                 exit_err(1);
 960                         }
 961
 962                         SetScoConf(value[0], value[1], value[2], value[3],
 963                                    value[4]);
 964                         SetPcmConf(value[5], value[6], value[7], value[8],
 965                                    value[9]);
 966                         SetAudio();
 967                 } else if (strstr(ptr, "-LP")) {
 968                         HCILP_Enable(TRUE);
 969                 } else if (strstr(ptr, "-DUT")) {
 970                         EnableTestMode();
 971                 } else if (strstr(ptr, "-FEATURE")) {
 972                         SetLocalFeatures();
 973                 } else if (strstr(ptr, "-GETNAME")) {
 974                         GetLocalName();
 975                 } else if (strstr(ptr, "-ATTACH")) {
 976                         EnbleHCI();
 977                         while (1) {
 978                                 sleep(UINT_MAX);
 979                         }
 980                 } else if (strstr(ptr, "-DEBUG")) {
 981                 } else if (strstr(ptr, "-CSTOPB")) {
 982                 } else if (strstr(ptr, "-SLOWDOWN")) {
 983                 } else if (strstr(ptr, "-TYPE")) {
 984                 } else {
 985                         fprintf(stderr, "Invalid parameter(s)!\n");
 986                         exit_err(1);
 987                 }
 988         }
 989
 990         fprintf(stderr, "EXIT\n");
 991         close(fd);
 992         exit(0);
 993
 994         return 0;
 995 }