[android源码分析]enable_native中的hci dev注册和up

2、enableNative的分析

         enable Native是真正的蓝牙使能的函数，蓝牙打开的一系列操作都是通过他来真正实现的。可以认为，这个函数蓝牙使能的主干，其余几个方面都可以认为是旁枝末节而已，因此，无论如何，我们必须了解到这个函数真正的精髓所在。

         先来看jni层究竟是如何实现这个函数的：

 static jint enableNative(JNIEnv *env, jobject object) {
 #ifdef HAVE_BLUETOOTH
 LOGV("%s", __FUNCTION__);
 //可以看到其实很简单，就是调用bt_enable函数
     return bt_enable();
 #endif
     return -1;
 }
     bt_enable是libbluedroid.so这个动态库中的一个函数，所以，很容易就可以找到对应的源码：system/bluetooth/bluedroid/bluetooth.c
 int bt_enable() {
 ……
 //这里是通过rfkill来设置蓝牙芯片的电压，也就是通常所说的上电
 //这里是通过向对应的rfkill的state文件置1，各家的方案都有各家的做法，但实现的接口是统一的
     if (set_bluetooth_power(1) < 0) goto out;
     //启动hciattach service，这个是在init.rc中定义的service，在前面的文章中我已经有说明过。
     //hciattach的作用是用来初始化蓝牙芯片，他包含了串口的波特率的初始化，fw的download等一系列的操作，各家的方案又会有所差异，所以，我就不详细分析了，大家知道这个是做些什么操作的即可
     LOGI("Starting hciattach daemon");
     if (property_set("ctl.start", "hciattach") < 0) {
         LOGE("Failed to start hciattach");
         set_bluetooth_power(0);
         goto out;
     }

     // Try for 10 seconds, this can only succeed once hciattach has sent the
 // firmware and then turned on hci device via HCIUARTSETPROTO ioctl
 //这里其实有一个小的bug，注释是10s的尝试时间，事实上每次等待的时间是100ms，总共时间就已经到100s了，不过也无伤大雅了。
 //这里就是通过ioctl去进行hcidev的up，我们可以理解只有hciattach把芯片全部初始化完成，这里才能够成功up，否则就会出错，我们就需要去不停的进行尝试。
 //你肯定会有疑问，hciattach那边是如何控制这边的出错的啊？其实很简单，在hciattach初始化要结束的时候才会去创建hcidev，若是连hcidev都没有，up必然会出错了，呵呵，具体的细节下面再详细分析了
 //hciattach对hcidev的影响见2.1
 //hcidev up的详细分析见2.2
 for (attempt = 1000; attempt > 0;  attempt--) {
     //创建socket，没什么好说的
         hci_sock = create_hci_sock();
         if (hci_sock < 0) goto out;
         //通过ioctl来进行up
         ret = ioctl(hci_sock, HCIDEVUP, HCI_DEV_ID);

         LOGI("bt_enable: ret: %d, errno: %d", ret, errno);
         if (!ret) {
             break;
         } else if (errno == EALREADY) {
             LOGW("Bluetoothd already started, unexpectedly!");
             break;
         }

         close(hci_sock);
         usleep(100000);  // 100 ms retry delay
     }
     if (attempt == 0) {
         LOGE("%s: Timeout waiting for HCI device to come up, error- %d, ",
             __FUNCTION__, ret);
 //若出错，停止hciattach service
         if (property_set("ctl.stop", "hciattach") < 0) {
             LOGE("Error stopping hciattach");
         }
 //把芯片的电压关闭掉
         set_bluetooth_power(0);
         goto out;
     }

 LOGI("Starting bluetoothd deamon");
 //启动bluetoothd service，详细的分析见2.2
     if (property_set("ctl.start", "bluetoothd") < 0) {
         LOGE("Failed to start bluetoothd");
         set_bluetooth_power(0);
         goto out;
     }

     ret = 0;

 out:
     if (hci_sock >= 0) close(hci_sock);
     return ret;
 }

2.1、hciattach中的hci dev的注册。

我们已经说了hciattach每一家的方案都是不同的，其中涉及到各家的代码实现就不详细分析了，这里我们为了使下面的hci dev up的流程分析得更加清楚，会说明一下在每家蓝牙初始化结束之后都会进行的hci device的注册流程。

在verdor蓝牙初始化结束之后会调用如下函数，这个函数就是对hci dev的注册，proto就是各家的方案不同了，比如h4，h5之类的

 if (ioctl(fd, HCIUARTSETPROTO, u->proto) < 0) {
     perror("Can't set device");
     return -1;
 }

我们来看HCIUARTSETPROTO最终会调用什么：

 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
                     unsigned int cmd, unsigned long arg)
 {……
     case HCIUARTSETPROTO:
         //检测hu->flags是否设置HCI_UART_PROTO_SET是否置位，没有就会进入到if内，并置位。显然，开始我们是没有的
         if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
             //重要的就是这个函数了
             err = hci_uart_set_proto(hu, arg);
             if (err) {
                 //有erro，把这个标志位清空
                 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
                 return err;
             }
         } else
             return -EBUSY;
         break;
 ……}
 static int hci_uart_set_proto(struct hci_uart *hu, int id)
 {
     struct hci_uart_proto *p;
     int err;
     //首先是proto的一些初始化，各家都不相同，我们就不分析了
     p = hci_uart_get_proto(id);
     if (!p)
         return -EPROTONOSUPPORT;

     err = p->open(hu);
     if (err)
         return err;

     hu->proto = p;
     //重点关注一下dev的register
     err = hci_uart_register_dev(hu);
 ……

     return 0;
 }

 static int hci_uart_register_dev(struct hci_uart *hu)
 {
     struct hci_dev *hdev;

     BT_DBG("");
     //申请hci dev的结构体空间
     /* Initialize and register HCI device */
     hdev = hci_alloc_dev();
     if (!hdev) {
         BT_ERR("Can't allocate HCI device");
         return -ENOMEM;
     }
     //初始化hdev的一些成员
     hu->hdev = hdev;

     hdev->bus = HCI_UART;
     hdev->driver_data = hu;

     hdev->open  = hci_uart_open;
     hdev->close = hci_uart_close;
     hdev->flush = hci_uart_flush;
     hdev->send  = hci_uart_send_frame;
     hdev->destruct = hci_uart_destruct;
     hdev->parent = hu->tty->dev;

     hdev->owner = THIS_MODULE;
     //reset默认为0，就是设置为HCI_QUIRK_NO_RESET
     if (!reset)
         set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);
     //这里根据各家的方案会有所不同，一般是没有设置的
     if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
         set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
     //把这个device注册到hci，见2.1.1
     if (hci_register_dev(hdev) < 0) {
         BT_ERR("Can't register HCI device");
         hci_free_dev(hdev);
         return -ENODEV;
     }

     return 0;
 }

2.1.1hci device的注册

 /* Register HCI device */
 int hci_register_dev(struct hci_dev *hdev)
 {
     struct list_head *head = &hci_dev_list, *p;
     int i, id = 0;

     BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name,
                         hdev->bus, hdev->owner);
     //首先要保证这个device已经初始化了一些必要的内容，比如open，close和destruct函数
     if (!hdev->open || !hdev->close || !hdev->destruct)
         return -EINVAL;
 //抓住写的锁
     write_lock_bh(&hci_dev_list_lock);
 //在hci_dev_list中找第一个可用的device id
     /* Find first available device id */
     list_for_each(p, &hci_dev_list) {
         if (list_entry(p, struct hci_dev, list)->id != id)
             break;
         head = p; id++;
     }
     //一般而言，我们都是第一个，也就是hci0了
     sprintf(hdev->name, "hci%d", id);
     hdev->id = id;
 //把hdev->list插入到hci_dev_list这个双向链表中
     list_add(&hdev->list, head);
     //hdev的ref cnt +1
     atomic_set(&hdev->refcnt, 1);
     //初始化一个锁
     spin_lock_init(&hdev->lock);

     hdev->flags = 0;
     //packet type
     hdev->pkt_type  = (HCI_DM1 | HCI_DH1 | HCI_HV1);
     hdev->esco_type = (ESCO_HV1);
     hdev->link_mode = (HCI_LM_ACCEPT);
     //iocapability初始化为no input no output
     //很显然，这些初始化的内容都比较保守，所以，我们可以期待在不久的将来，他们会全部或者部分被修改掉
     hdev->io_capability = 0x03; /* No Input No Output */
     //idle和sniff mode相关的参数设置
     hdev->idle_timeout = 0;
     hdev->sniff_max_interval = 800;
     hdev->sniff_min_interval = 80;
     //初始化了3个队列和task，分别是cmd，tx，rx
     tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev);
     tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev);
     tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev);

     skb_queue_head_init(&hdev->rx_q);
     skb_queue_head_init(&hdev->cmd_q);
     skb_queue_head_init(&hdev->raw_q);
     //初始化一个cmd的timer
     setup_timer(&hdev->cmd_timer, hci_cmd_timer, (unsigned long) hdev);

     for (i = 0; i < NUM_REASSEMBLY; i++)
         hdev->reassembly[i] = NULL;
     //初始化一个wait 队列
     init_waitqueue_head(&hdev->req_wait_q);
     mutex_init(&hdev->req_lock);
     //初始化inquiry，connect的cache
     inquiry_cache_init(hdev);

     hci_conn_hash_init(hdev);
     //初始化几个list
     INIT_LIST_HEAD(&hdev->blacklist);
     INIT_LIST_HEAD(&hdev->uuids);
     INIT_LIST_HEAD(&hdev->link_keys);
     INIT_LIST_HEAD(&hdev->remote_oob_data);
     INIT_LIST_HEAD(&hdev->adv_entries);
     //在启动一个adv的timer
     setup_timer(&hdev->adv_timer, hci_clear_adv_cache,
                         (unsigned long) hdev);
     memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));

     atomic_set(&hdev->promisc, 0);
     //释放锁
     write_unlock_bh(&hci_dev_list_lock);
     //创建一个单任务的工作队列
     hdev->workqueue = create_singlethread_workqueue(hdev->name);
     if (!hdev->workqueue)
         goto nomem;
     hdev->tfm = crypto_alloc_blkcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
     if (IS_ERR(hdev->tfm))
         BT_INFO("Failed to load transform for ecb(aes): %ld",
                             PTR_ERR(hdev->tfm));

     hci_register_sysfs(hdev);
     //申请rfkill
     hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev,
                 RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev);
     if (hdev->rfkill) {
         if (rfkill_register(hdev->rfkill) < 0) {
             rfkill_destroy(hdev->rfkill);
             hdev->rfkill = NULL;
         }
     }
     //会发送一个DEV_REG出去，若是有监听的，那么就会做相应的处理,kernel中是没有啦，但是在bluez中是有的，等bluez分析完成，我们再来分析这里
     hci_notify(hdev, HCI_DEV_REG);
 ……
 }

至此，hci device的注册流程就已经完全ok了。

2.2、hci dev up的流程分析

  hci device的up是通过HCIDEVUP这个ioctl来实现的，他实现的代码在kernel/net/bluetooth/hci_sock.c中：

 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 {
 ……
     case HCIDEVUP:
 //主要就是这个open函数
         return hci_dev_open(arg);
 ……}

 int hci_dev_open(__u16 dev)
 {
 ……
 //在hciattach没有完成的时候，我们基本都是在这里直接return
     hdev = hci_dev_get(dev);
     if (!hdev)
         return -ENODEV;

     BT_DBG("%s %p", hdev->name, hdev);
 //抓住锁
     hci_req_lock(hdev);
 //看rfkill是否正常，这里是在hci dev注册的时候就会申请的
     if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) {
         ret = -ERFKILL;
         goto done;
     }
 //检查是否已经up了，若已经up了，当然就不需要做什么了
     if (test_bit(HCI_UP, &hdev->flags)) {
         ret = -EALREADY;
         goto done;
     }
 //这个就没有设置了
     if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
         set_bit(HCI_RAW, &hdev->flags);
 //目前把非BR/EDR的控制器都设置HCI_RAW
     /* Treat all non BR/EDR controllers as raw devices for now */
     if (hdev->dev_type != HCI_BREDR)
         set_bit(HCI_RAW, &hdev->flags);
 //调用dev的open函数
 //在hci_uart_register_dev函数中，我们有初始化hdev->open  = hci_uart_open
 //所以直接去看hci_uart_open函数即可，其实很简单，就是hdev->flags的HCI_RUNNING位置1
     if (hdev->open(hdev)) {
         ret = -EIO;
         goto done;
     }
 //若不是HCI_RAW
     if (!test_bit(HCI_RAW, &hdev->flags)) {
         //设置cmd的count为1
         atomic_set(&hdev->cmd_cnt, 1);
         //为flags的HCI_INIT置位
         set_bit(HCI_INIT, &hdev->flags);
         //初始好的最后一个cmd置为0
         hdev->init_last_cmd = 0;
         //hci的初始化，timeout是10s
         //这里是一些hci cmd和response的交互，我们会在2.1.1中进行详细分析
         ret = __hci_request(hdev, hci_init_req, 0,
                     msecs_to_jiffies(HCI_INIT_TIMEOUT));
         //若是支援le，则需要继续le的一些初始化，这里就暂不分析了
         if (lmp_host_le_capable(hdev))
             ret = __hci_request(hdev, hci_le_init_req, 0,
                     msecs_to_jiffies(HCI_INIT_TIMEOUT));
         //把HCI_INIT标志位清除
         clear_bit(HCI_INIT, &hdev->flags);
     }

     if (!ret) {
     //若是初始化成功，hdev的ref+1
         hci_dev_hold(hdev);
     //设置hdev的HCI_UP位
         set_bit(HCI_UP, &hdev->flags);
     //通知HCI_DEV_UP,若是有人需要监测dev的up，则这里就会得到通知，从而进行下一步的操作，和dev_reg是一样的，在kernel中是没有，但是在bluez中仍然是有的。
         hci_notify(hdev, HCI_DEV_UP);
         //看flags中的HCI_SETUP位是否被置位，若是没有，则调用mgmt_powered函数通知bluez去做一些处理，这个在register dev的时候就会置位，所以，这里我们不会再调用了
         if (!test_bit(HCI_SETUP, &hdev->flags))
             mgmt_powered(hdev->id, 1);
     } else {
         /* Init failed, cleanup */
         //一些错误的处理，不详细分析了，和register是对应的
 ……
 }

至此，整个这个流程中的hci device的注册和up就已经全部分析完成了，细心的童鞋会发现其实这之中的cmd和event的交互我们并没有详细分析，而这恰恰是一个很重要的过程，晓东将会在另一篇文章中和大家详细分析，若是想学习的童鞋最好先去把bluetooth的spec学习一下，否则估计你是很难看懂了哦~~