bt_if.c

bluetooth 驱动

  }

  *(int *)buf = len;
  
  memcpy((int *)buf+1, data, len);

#ifndef BT_USERSTACK 
  if (ioctl(bt_cfd, BT_SEND_DFU_COMMAND, buf) < 0)
  {
    perror(__FUNCTION__);
    return -1;
  }

  return 0;
#else
  fprintf(stderr, __FUNCTION__ ": Not yet implemented...\n");
  errno = EPERM;
  return -1;
#endif
}

int
bt_retrieve_dfu_response(int bt_cfd, int len, unsigned char *data)
{
  *(int *)data = len - sizeof(int);

#ifndef BT_USERSTACK 
  if (ioctl(bt_cfd, BT_RETRIEVE_DFU_RESPONSE, data) < 0)
  {
    perror(__FUNCTION__);
    return -1;
  }

  len = *(int *)data;
  
  memmove(data, (int *)data+1, len);
  return len;
#else
  fprintf(stderr, __FUNCTION__ ": Not yet implemented...\n");
  errno = EPERM;
  return -1;
#endif
}

int bt_ping(int bt_cfd, unsigned char bd[6], 
	    unsigned char *data, unsigned short len)
{
  int ret_val;
  struct ping_struct ping;
  
  print_data(__FUNCTION__ " BD : ", bd, 6);
  memcpy(ping.bd, bd, 6);
  ping.len = len;  
  memcpy(ping.data, data, len);
  
#ifndef BT_USERSTACK 
  if ((ret_val = ioctl(bt_cfd, BTPING, &ping)) < 0)
  {
    printf("Error : [%s (%d)]\n", error_msg(ret_val), MSG_GET_CODE(-ret_val));
  }
  else
    printf("Success!\n");
#else
  ret_val = l2ca_ping(bd, data, len);
#endif
  return ret_val;
}

int 
bt_getinfo(int bt_cfd, unsigned char bd[6], unsigned short type)
{
  int ret_val;
  unsigned char msg[8];
  
  memcpy(msg, bd, 6);
  msg[6] = (unsigned char)(type >> 8);
  msg[7] = (unsigned char)(type & 0xff);

#ifndef BT_USERSTACK 
  if ((ret_val = ioctl(bt_cfd, BTGETINFO, &msg)) < 0)
  {
    printf("Error : [%s (%d)]\n", error_msg(ret_val), MSG_GET_CODE(-ret_val));
  }
  else
    printf("Success!\n");
#else
  ret_val = l2ca_getinfo(bd, type);
#endif
  return ret_val;
}

/* input is a nullterminated string */

int bt_testcmd(int bt_cfd, unsigned char *cmd)
{
  int ret_val = 0;
  unsigned char len = strlen(cmd);
  unsigned char tmp[261];

  tmp[0] = len;
  memcpy(tmp+1, cmd, len+1); /* don't forget nullterminate... */

#ifndef BT_USERSTACK 
  if ((ret_val = ioctl(bt_cfd, BTTESTCOMMAND, tmp)) < 0)
  {
    printf("Error : [%s (%d)]\n", error_msg(ret_val), MSG_GET_CODE(-ret_val));
  }
  else
    printf("Success!\n");
#else
  ret_val = test_process_cmd(&tmp[1], tmp[0]);
#endif
  return ret_val;
}

int bt_force_msswitch_as_server(int bt_cfd, int enable)
{
  syslog(LOG_INFO, __FUNCTION__ ": %d", enable);
#ifndef BT_USERSTACK 
  if (ioctl(bt_cfd, BTSETMSSWITCH, &enable) < 0)
  {
    perror(__FUNCTION__);
    return -1;
  }
#else
  hci_force_msswitch(enable);
#endif
  return 0;
}

int bt_set_max_conections(int bt_cfd, int connections)
{
  syslog(LOG_INFO, __FUNCTION__ ": %d", connections);
#ifndef BT_USERSTACK 
  if (ioctl(bt_cfd, BTSETMAXCONNECTIONS, &connections) < 0)
  {
    perror(__FUNCTION__);
    return -1;
  }

  return 0;
#else
  {
    int ret_val = hci_set_max_connections(connections);

    if (ret_val >= 0)
    {
      return ret_val;
    }

    errno = -ret_val;
    return -1;
  }
#endif
}

/* ============================================================ */
/* HCI functions */


int
bt_inquiry(int bt_cfd, int nbr_rsp, int t)
{
  int retval = 0;
#ifdef BTD_USERSTACK
  char inq_lap[6];

  printf("Inquiring...\n");

  inq_lap[0] = 0x33;
  inq_lap[1] = 0x8b;
  inq_lap[2] = 0x9e;

  retval = hci_inquiry(inq_lap, t, nbr_rsp);
#else
  int i;
  inquiry_results *inq_res;

  if (!(inq_res = malloc(sizeof *inq_res + nbr_rsp * 6)))
  {
    fprintf(stderr, __FUNCTION__ ": Failed to allocate result structure!\n");
    return -ENOMEM;
  }

  inq_res->nbr_of_units = nbr_rsp;
  inq_res->inq_time = t;

  if ((retval = ioctl(bt_cfd, HCIINQUIRY, inq_res)) < 0)
  {
    printf("Inquiry failed [%s (%d)]\n", error_msg(retval), MSG_GET_CODE(-retval));
    free(inq_res);
    return retval;
  }

  for (i = 0; i < inq_res->nbr_of_units; i++)
  {
    printf("BD %d: %02x:%02x:%02x:%02x:%02x:%02x\n",i,
           inq_res->bd_addr[0+6*i], inq_res->bd_addr[1+6*i],
           inq_res->bd_addr[2+6*i], inq_res->bd_addr[3+6*i],
           inq_res->bd_addr[4+6*i], inq_res->bd_addr[5+6*i]);
  }

  free(inq_res);
#endif
  return retval;
}

void
bt_set_bd_addr(int bt_cfd, unsigned char *bd)
{
  printf("Setting BD address to: %02X:%02X:%02X:%02X:%02X:%02X\n",
         bd[0], bd[1], bd[2],
         bd[3], bd[4], bd[5]);
    
#ifndef BT_USERSTACK
  if (ioctl(bt_cfd, HCIWRITEBDADDR, bd) < 0)
  {
    perror(__FUNCTION__);
  }
#else
  hci_set_bd_addr(bd);
#endif 
  printf("Please reset HW to activate bd change\n");
}

/* The HCISETBAUDRATE ioctl is redirected to the correct 
   vendor function in the kernel */

int bt_set_baudrate(int bt_cfd, const char *speedstr)
{
  int result;
  unsigned long spd = speedstrtoli(speedstr);

  syslog(LOG_INFO, __FUNCTION__ ": %lu baud", spd);
#ifdef BT_USERSTACK
  tcflush(phys_fd, TCIOFLUSH);
  result = hci_set_baudrate(spd);
  usleep(10000);
#else
  if ((result = ioctl(bt_cfd, HCISETBAUDRATE, &spd)) < 0)
  {
    perror(__FUNCTION__);
    exit(1);
  }
#endif
  return result;
}

void
read_local_bd(int bt_cfd, unsigned char *bd_addr)
{
#ifndef BT_USERSTACK
  if (ioctl(bt_cfd, HCIREADLOCALBDADDR, bd_addr) < 0)
  {
    perror(__FUNCTION__);
  }
#else
  int i;
  BD_ADDR rev_bd;

  hci_read_local_bd(rev_bd);

  /* return as big endian */
  for (i = 0; i < 6; i++)
  {
    bd_addr[i] = rev_bd[5-i];
  }
#endif
}

void
enable_dut(int bt_cfd)
{
  printf("Enable device under test mode\n");
#ifndef BT_USERSTACK
  if (ioctl(bt_cfd, HCIENABLEDUT) < 0)
  {
    perror(__FUNCTION__);
  }
#else
  hci_enable_dut();
#endif
  printf("done.\n");
}

void
read_remote_bd(int bt_cfd, int line, unsigned char *bd_addr)
{
#ifndef BT_USERSTACK
  *(int*)bd_addr = line;

  if (ioctl(bt_cfd, BTREADREMOTEBDADDR, bd_addr) < 0)
  {
    perror(__FUNCTION__);
  }
#else
  BD_ADDR rev_bd;
  int i;

  get_remote_bd(line, rev_bd);

  /* return as big endian */
  for (i = 0; i < 6; i++) {
    bd_addr[i] = rev_bd[5-i];
  }
#endif
}

int bt_write_scan_enable(int bt_cfd, unsigned int flags)
{
  int result;

  syslog(LOG_INFO, "Setting write_scan_enable: 0x%x", flags);

#ifdef BT_USERSTACK
  result = hci_write_scan_enable(flags);
#else

  if ((result = ioctl(bt_cfd, HCIWRITESCANENABLE, &flags)) < 0)
  { 
    perror(__FUNCTION__);
    exit(1);
  }
#endif	
  return result;
}

void
bt_write_pagescan_activity(int bt_cfd, unsigned int interval, 
                           unsigned int wind)
{
  /* improves reliability when doing a connect */

  syslog(LOG_INFO, "Setting write_pagescan_activity: int:0x%x wind:0x%x", 
	 interval, wind);


#ifdef BT_USERSTACK
  hci_write_pagescan_activity(interval, wind);
#else
  {
    unsigned int tmp[2];

    tmp[0] = interval;
    tmp[1] = wind;

    if (ioctl(bt_cfd, HCIWRITEPAGESCANACTIVITY, &tmp) < 0)
    { 
      perror(__FUNCTION__);
      exit(1);
    }
  }
#endif
}

int bt_set_event_filter(int bt_cfd, unsigned char filter[3])
{
  int result;

  syslog(LOG_INFO, "Setting event filter [0x%x 0x%x 0x%x]", 
	 filter[0], filter[1], filter[2]);

#ifdef BT_USERSTACK
  result = hci_set_event_filter((u8*)&filter);
#else

  if ((result = ioctl(bt_cfd, HCISET_EVENT_FILTER, &filter)) < 0)
  { 
    perror(__FUNCTION__);
    exit(1);
  }
#endif
  return result;
}



void
bt_set_classofdevice(int bt_cfd, unsigned short service_class,
		     unsigned char major_class, unsigned char minor_class,
		     unsigned char format)
{
  unsigned char class_of_device[3]; 

  syslog(LOG_INFO, "bt_set_classofdevice : srv class 0x%x, maj class 0x%x, min class 0x%x, format 0x%x", service_class, major_class, minor_class, format);
  switch (format)
  {
  case 0:
    class_of_device[0] = (minor_class << 2);
    class_of_device[1] = ((service_class & 0x7) << 5) | (major_class & 0x1f);
    class_of_device[2] = (service_class  & 0x7f8) >> 3;
    
#ifndef BT_USERSTACK 
    if (ioctl(bt_cfd, HCIWRITECLASSOFDEVICE, class_of_device) < 0)
    {
      perror(__FUNCTION__);
      exit(1);
    }
#else
    hci_write_class_of_device(class_of_device);
#endif
    break;

  case 1:
    syslog(LOG_INFO, __FUNCTION__ ": Unsupported format 0x%02x", format);
    break;

  case 2:
    syslog(LOG_INFO, __FUNCTION__ ": Unsupported format 0x%02x", format);
    break;

  default:
    syslog(LOG_INFO, __FUNCTION__ ": Unsupported format 0x%02x", format);
    break;
  }
}

void
role_switch(int bt_cfd, unsigned char* bd_addr, int role)
{
  int i;
  unsigned char tmp[7];

  syslog(LOG_INFO, "Performing role switch to peer: %02X:%02X:%02X:%02X:%02X:%02X",
         bd_addr[0], bd_addr[1], bd_addr[2],
         bd_addr[3], bd_addr[4], bd_addr[5]);

  for (i = 0; i < 6; i++)
  {
    tmp[5-i] = (unsigned char)*bd_addr++;
  }

  tmp[6] = (unsigned char)role;

#ifndef BT_USERSTACK
  if (ioctl(bt_cfd, HCISWITCHROLE, tmp) < 0)
  {
    perror(__FUNCTION__);
  }
#else
  hci_switch_role(bd_addr, role);
#endif
}

void
set_bt_line_disc(int phys_fd, int bt_disc, char* physdev)
{
#ifndef BT_USERSTACK
  if (ioctl(phys_fd, TIOCSETD, &bt_disc) < 0)
  {
    perror(__FUNCTION__);
    syslog(LOG_INFO, "Forgot to insmod bt.o ? [bt_disc %d]", bt_disc);
    exit(1);
  }
  syslog(LOG_INFO, "Registered bluetooth line discipline on %s", physdev);
#else
  fprintf(stderr, __FUNCTION__ ": ignored in usermode stack\n");
#endif
}


void set_local_hostname(int bt_cfd, const char *local_name)
{
  unsigned char domainname[DOMAIN_NAME_LENGTH+1];
  unsigned char buf[LOCAL_NAME_LENGTH + HOST_NAME_LENGTH + 
		   DOMAIN_NAME_LENGTH + 5];
  int len = 0;

  *buf = '\0';
  *domainname = '\0';

  if (*local_name)
  {
    while (*local_name && len < LOCAL_NAME_LENGTH)
    {
      if (*local_name >= ' ' && *local_name <= 'z')
      {
        buf[len++] = *local_name++;
      }
    }
 
    if (len)
    {
      buf[len++] = ' ';
      buf[len++] = '(';
      buf[len] = '\0';
    }
  }

  gethostname(&buf[len], HOST_NAME_LENGTH);

  if (!strchr(&buf[len], '.'))
  {
    getdomainname(domainname, DOMAIN_NAME_LENGTH);
    if (*domainname)
    {
      strcat(buf, ".");
      strcat(buf, domainname);
    }
  }

  if (len)
  {
    strcat(buf, ")");
  }

  bt_set_local_name(bt_cfd, buf);

}