自学教程：C++ BT_ERR函数代码示例

static void secure_beacon_recv(struct net_buf_simple *buf){    u8_t *data, *net_id, *auth;    struct bt_mesh_subnet *sub;    u32_t iv_index;    bool new_key, kr_change, iv_change;    u8_t flags;    if (buf->len < 21) {        BT_ERR("Too short secure beacon (len %u)", buf->len);        return;    }    sub = cache_check(buf->data);    if (sub) {        /* We've seen this beacon before - just update the stats */        goto update_stats;    }    /* So we can add to the cache if auth matches */    data = buf->data;    flags = net_buf_simple_pull_u8(buf);    net_id = buf->data;    net_buf_simple_pull(buf, 8);    iv_index = net_buf_simple_pull_be32(buf);    auth = buf->data;    BT_DBG("flags 0x%02x id %s iv_index 0x%08x",           flags, bt_hex(net_id, 8), iv_index);    sub = bt_mesh_subnet_find(net_id, flags, iv_index, auth, &new_key);    if (!sub) {        BT_DBG("No subnet that matched beacon");        return;    }    if (sub->kr_phase == BT_MESH_KR_PHASE_2 && !new_key) {        BT_WARN("Ignoring Phase 2 KR Update secured using old key");        return;    }    cache_add(data, sub);    /* If we have NetKey0 accept initiation only from it */    if (bt_mesh_subnet_get(BT_MESH_KEY_PRIMARY) &&        sub->net_idx != BT_MESH_KEY_PRIMARY) {        BT_WARN("Ignoring secure beacon on non-primary subnet");        goto update_stats;    }    BT_DBG("net_idx 0x%04x iv_index 0x%08x, current iv_index 0x%08x",           sub->net_idx, iv_index, bt_mesh.iv_index);    if (bt_mesh.ivu_initiator &&        bt_mesh.iv_update == BT_MESH_IV_UPDATE(flags)) {        bt_mesh_beacon_ivu_initiator(false);    }    iv_change = bt_mesh_net_iv_update(iv_index, BT_MESH_IV_UPDATE(flags));    kr_change = bt_mesh_kr_update(sub, BT_MESH_KEY_REFRESH(flags), new_key);    if (kr_change) {        bt_mesh_net_beacon_update(sub);    }    if (iv_change) {        /* Update all subnets */        bt_mesh_net_sec_update(NULL);    } else if (kr_change) {        /* Key Refresh without IV Update only impacts one subnet */        bt_mesh_net_sec_update(sub);    }update_stats:    if (bt_mesh_beacon_get() == BT_MESH_BEACON_ENABLED &&        sub->beacons_cur < 0xff) {        sub->beacons_cur++;    }}

static int btusb_setup_intel(struct hci_dev *hdev){	struct sk_buff *skb;	const struct firmware *fw;	const u8 *fw_ptr;	int disable_patch;	struct intel_version *ver;	const u8 mfg_enable[] = { 0x01, 0x00 };	const u8 mfg_disable[] = { 0x00, 0x00 };	const u8 mfg_reset_deactivate[] = { 0x00, 0x01 };	const u8 mfg_reset_activate[] = { 0x00, 0x02 };	BT_DBG("%s", hdev->name);	/* The controller has a bug with the first HCI command sent to it	 * returning number of completed commands as zero. This would stall the	 * command processing in the Bluetooth core.	 *	 * As a workaround, send HCI Reset command first which will reset the	 * number of completed commands and allow normal command processing	 * from now on.	 */	skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);	if (IS_ERR(skb)) {		BT_ERR("%s sending initial HCI reset command failed (%ld)",		       hdev->name, PTR_ERR(skb));		return PTR_ERR(skb);	}	kfree_skb(skb);	/* Read Intel specific controller version first to allow selection of	 * which firmware file to load.	 *	 * The returned information are hardware variant and revision plus	 * firmware variant, revision and build number.	 */	skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT);	if (IS_ERR(skb)) {		BT_ERR("%s reading Intel fw version command failed (%ld)",		       hdev->name, PTR_ERR(skb));		return PTR_ERR(skb);	}	if (skb->len != sizeof(*ver)) {		BT_ERR("%s Intel version event length mismatch", hdev->name);		kfree_skb(skb);		return -EIO;	}	ver = (struct intel_version *)skb->data;	if (ver->status) {		BT_ERR("%s Intel fw version event failed (%02x)", hdev->name,		       ver->status);		kfree_skb(skb);		return -bt_to_errno(ver->status);	}	BT_INFO("%s: read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x",		hdev->name, ver->hw_platform, ver->hw_variant,		ver->hw_revision, ver->fw_variant,  ver->fw_revision,		ver->fw_build_num, ver->fw_build_ww, ver->fw_build_yy,		ver->fw_patch_num);	/* fw_patch_num indicates the version of patch the device currently	 * have. If there is no patch data in the device, it is always 0x00.	 * So, if it is other than 0x00, no need to patch the deivce again.	 */	if (ver->fw_patch_num) {		BT_INFO("%s: Intel device is already patched. patch num: %02x",			hdev->name, ver->fw_patch_num);		kfree_skb(skb);		return 0;	}	/* Opens the firmware patch file based on the firmware version read	 * from the controller. If it fails to open the matching firmware	 * patch file, it tries to open the default firmware patch file.	 * If no patch file is found, allow the device to operate without	 * a patch.	 */	fw = btusb_setup_intel_get_fw(hdev, ver);	if (!fw) {		kfree_skb(skb);		return 0;	}	fw_ptr = fw->data;	/* This Intel specific command enables the manufacturer mode of the	 * controller.	 *	 * Only while this mode is enabled, the driver can download the	 * firmware patch data and configuration parameters.	 */	skb = __hci_cmd_sync(hdev, 0xfc11, 2, mfg_enable, HCI_INIT_TIMEOUT);	if (IS_ERR(skb)) {		BT_ERR("%s entering Intel manufacturer mode failed (%ld)",		       hdev->name, PTR_ERR(skb));		release_firmware(fw);		return PTR_ERR(skb);//.........这里部分代码省略.........

/* Recv data */static int h4_recv(struct hci_uart *hu, void *data, int count){	struct h4_struct *h4 = hu->priv;	register char *ptr;	hci_event_hdr *eh;	hci_acl_hdr   *ah;	hci_sco_hdr   *sh;	register int len, type, dlen;	BT_DBG("hu %p count %d rx_state %ld rx_count %ld", 			hu, count, h4->rx_state, h4->rx_count);	ptr = data;	while (count) {		if (h4->rx_count) {			len = MIN(h4->rx_count, count);			memcpy(skb_put(h4->rx_skb, len), ptr, len);			h4->rx_count -= len; count -= len; ptr += len;			if (h4->rx_count)				continue;			switch (h4->rx_state) {			case H4_W4_DATA:				BT_DBG("Complete data");				BT_DMP(h4->rx_skb->data, h4->rx_skb->len);				hci_recv_frame(h4->rx_skb);				h4->rx_state = H4_W4_PACKET_TYPE;				h4->rx_skb = NULL;				continue;			case H4_W4_EVENT_HDR:				eh = (hci_event_hdr *) h4->rx_skb->data;				BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);				h4_check_data_len(h4, eh->plen);				continue;			case H4_W4_ACL_HDR:				ah = (hci_acl_hdr *) h4->rx_skb->data;				dlen = __le16_to_cpu(ah->dlen);				BT_DBG("ACL header: dlen %d", dlen);				h4_check_data_len(h4, dlen);				continue;			case H4_W4_SCO_HDR:				sh = (hci_sco_hdr *) h4->rx_skb->data;				BT_DBG("SCO header: dlen %d", sh->dlen);				h4_check_data_len(h4, sh->dlen);				continue;			}		}		/* H4_W4_PACKET_TYPE */		switch (*ptr) {		case HCI_EVENT_PKT:			BT_DBG("Event packet");			h4->rx_state = H4_W4_EVENT_HDR;			h4->rx_count = HCI_EVENT_HDR_SIZE;			type = HCI_EVENT_PKT;			break;		case HCI_ACLDATA_PKT:			BT_DBG("ACL packet");			h4->rx_state = H4_W4_ACL_HDR;			h4->rx_count = HCI_ACL_HDR_SIZE;			type = HCI_ACLDATA_PKT;			break;		case HCI_SCODATA_PKT:			BT_DBG("SCO packet");			h4->rx_state = H4_W4_SCO_HDR;			h4->rx_count = HCI_SCO_HDR_SIZE;			type = HCI_SCODATA_PKT;			break;		default:			BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);			hu->hdev.stat.err_rx++;			ptr++; count--;			continue;		};		ptr++; count--;		/* Allocate packet */		h4->rx_skb = bluez_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);		if (!h4->rx_skb) {			BT_ERR("Can't allocate mem for new packet");			h4->rx_state = H4_W4_PACKET_TYPE;			h4->rx_count = 0;			return 0;//.........这里部分代码省略.........

static void btuart_receive(btuart_info_t *info){	unsigned int iobase;	int boguscount = 0;	if (!info) {		BT_ERR("Unknown device");		return;	}	iobase = info->p_dev->resource[0]->start;	do {		info->hdev->stat.byte_rx++;		/* Allocate packet */		if (info->rx_skb == NULL) {			info->rx_state = RECV_WAIT_PACKET_TYPE;			info->rx_count = 0;			if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {				BT_ERR("Can't allocate mem for new packet");				return;			}		}		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {			info->rx_skb->dev = (void *) info->hdev;			bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);			switch (bt_cb(info->rx_skb)->pkt_type) {			case HCI_EVENT_PKT:				info->rx_state = RECV_WAIT_EVENT_HEADER;				info->rx_count = HCI_EVENT_HDR_SIZE;				break;			case HCI_ACLDATA_PKT:				info->rx_state = RECV_WAIT_ACL_HEADER;				info->rx_count = HCI_ACL_HDR_SIZE;				break;			case HCI_SCODATA_PKT:				info->rx_state = RECV_WAIT_SCO_HEADER;				info->rx_count = HCI_SCO_HDR_SIZE;				break;			default:				/* Unknown packet */				BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);				info->hdev->stat.err_rx++;				clear_bit(HCI_RUNNING, &(info->hdev->flags));				kfree_skb(info->rx_skb);				info->rx_skb = NULL;				break;			}		} else {			*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);			info->rx_count--;			if (info->rx_count == 0) {				int dlen;				struct hci_event_hdr *eh;				struct hci_acl_hdr *ah;				struct hci_sco_hdr *sh;				switch (info->rx_state) {				case RECV_WAIT_EVENT_HEADER:					eh = hci_event_hdr(info->rx_skb);					info->rx_state = RECV_WAIT_DATA;					info->rx_count = eh->plen;					break;				case RECV_WAIT_ACL_HEADER:					ah = hci_acl_hdr(info->rx_skb);					dlen = __le16_to_cpu(ah->dlen);					info->rx_state = RECV_WAIT_DATA;					info->rx_count = dlen;					break;				case RECV_WAIT_SCO_HEADER:					sh = hci_sco_hdr(info->rx_skb);					info->rx_state = RECV_WAIT_DATA;					info->rx_count = sh->dlen;					break;				case RECV_WAIT_DATA:					hci_recv_frame(info->rx_skb);					info->rx_skb = NULL;					break;				}//.........这里部分代码省略.........

static int btuart_config(struct pcmcia_device *link){	btuart_info_t *info = link->priv;	int i;	int try;	/* First pass: look for a config entry that looks normal.	   Two tries: without IO aliases, then with aliases */	for (try = 0; try < 2; try++)		if (!pcmcia_loop_config(link, btuart_check_config, &try))			goto found_port;	/* Second pass: try to find an entry that isn't picky about	   its base address, then try to grab any standard serial port	   address, and finally try to get any free port. */	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))		goto found_port;	BT_ERR("No usable port range found");	goto failed;found_port:	i = pcmcia_request_irq(link, btuart_interrupt);	if (i != 0)		goto failed;	i = pcmcia_enable_device(link);	if (i != 0)		goto failed;	if (btuart_open(info) != 0)		goto failed;	return 0;failed:	btuart_release(link);	return -ENODEV;}static void btuart_release(struct pcmcia_device *link){	btuart_info_t *info = link->priv;	btuart_close(info);	pcmcia_disable_device(link);}static const struct pcmcia_device_id btuart_ids[] = {	/* don't use this driver. Use serial_cs + hci_uart instead */	PCMCIA_DEVICE_NULL};MODULE_DEVICE_TABLE(pcmcia, btuart_ids);static struct pcmcia_driver btuart_driver = {	.owner		= THIS_MODULE,	.name		= "btuart_cs",	.probe		= btuart_probe,	.remove		= btuart_detach,	.id_table	= btuart_ids,};static int __init init_btuart_cs(void){	return pcmcia_register_driver(&btuart_driver);}static void __exit exit_btuart_cs(void){	pcmcia_unregister_driver(&btuart_driver);}module_init(init_btuart_cs);module_exit(exit_btuart_cs);

static int vhci_create_device(struct vhci_data *data, __u8 opcode){	struct hci_dev *hdev;	struct sk_buff *skb;	__u8 dev_type;	/* bits 0-1 are dev_type (BR/EDR or AMP) */	dev_type = opcode & 0x03;	if (dev_type != HCI_BREDR && dev_type != HCI_AMP)		return -EINVAL;	/* bits 2-5 are reserved (must be zero) */	if (opcode & 0x3c)		return -EINVAL;	skb = bt_skb_alloc(4, GFP_KERNEL);	if (!skb)		return -ENOMEM;	hdev = hci_alloc_dev();	if (!hdev) {		kfree_skb(skb);		return -ENOMEM;	}	data->hdev = hdev;	hdev->bus = HCI_VIRTUAL;	hdev->dev_type = dev_type;	hci_set_drvdata(hdev, data);	hdev->open  = vhci_open_dev;	hdev->close = vhci_close_dev;	hdev->flush = vhci_flush;	hdev->send  = vhci_send_frame;	/* bit 6 is for external configuration */	if (opcode & 0x40)		set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);	/* bit 7 is for raw device */	if (opcode & 0x80)		set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);	if (hci_register_dev(hdev) < 0) {		BT_ERR("Can't register HCI device");		hci_free_dev(hdev);		data->hdev = NULL;		kfree_skb(skb);		return -EBUSY;	}	bt_cb(skb)->pkt_type = HCI_VENDOR_PKT;	*skb_put(skb, 1) = 0xff;	*skb_put(skb, 1) = opcode;	put_unaligned_le16(hdev->id, skb_put(skb, 2));	skb_queue_tail(&data->readq, skb);	wake_up_interruptible(&data->read_wait);	return 0;}

static void bnep_net_set_mc_list(struct net_device *dev){#ifdef CONFIG_BT_BNEP_MC_FILTER	struct bnep_session *s = netdev_priv(dev);	struct sock *sk = s->sock->sk;	struct bnep_set_filter_req *r;	struct sk_buff *skb;	int size;	BT_DBG("%s mc_count %d", dev->name, netdev_mc_count(dev));	size = sizeof(*r) + (BNEP_MAX_MULTICAST_FILTERS + 1) * ETH_ALEN * 2;	skb  = alloc_skb(size, GFP_ATOMIC);	if (!skb) {		BT_ERR("%s Multicast list allocation failed", dev->name);		return;	}	r = (void *) skb->data;	__skb_put(skb, sizeof(*r));	r->type = BNEP_CONTROL;	r->ctrl = BNEP_FILTER_MULTI_ADDR_SET;	if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {		u8 start[ETH_ALEN] = { 0x01 };		/* Request all addresses */		memcpy(__skb_put(skb, ETH_ALEN), start, ETH_ALEN);		memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);		r->len = htons(ETH_ALEN * 2);	} else {		struct netdev_hw_addr *ha;		int i, len = skb->len;		if (dev->flags & IFF_BROADCAST) {			memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);			memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);		}		/* FIXME: We should group addresses here. */		i = 0;		netdev_for_each_mc_addr(ha, dev) {			if (i == BNEP_MAX_MULTICAST_FILTERS)				break;#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))			memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN);			memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN);#else			memcpy(__skb_put(skb, ETH_ALEN), ha->dmi_addr, ETH_ALEN);			memcpy(__skb_put(skb, ETH_ALEN), ha->dmi_addr, ETH_ALEN);#endif			i++;		}		r->len = htons(skb->len - len);	}	skb_queue_tail(&sk->sk_write_queue, skb);	wake_up_interruptible(sk_sleep(sk));#endif}

static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *id){	const struct firmware *firmware;	struct usb_device *udev = interface_to_usbdev(intf);	struct usb_host_endpoint *bulk_out_ep;	struct usb_host_endpoint *bulk_in_ep;	struct hci_dev *hdev;	struct bfusb_data *data;	BT_DBG("intf %p id %p", intf, id);	/* Check number of endpoints */	if (intf->cur_altsetting->desc.bNumEndpoints < 2)		return -EIO;	bulk_out_ep = &intf->cur_altsetting->endpoint[0];	bulk_in_ep  = &intf->cur_altsetting->endpoint[1];	if (!bulk_out_ep || !bulk_in_ep) {		BT_ERR("Bulk endpoints not found");		goto done;	}	/* Initialize control structure and load firmware */	data = kzalloc(sizeof(struct bfusb_data), GFP_KERNEL);	if (!data) {		BT_ERR("Can't allocate memory for control structure");		goto done;	}	data->udev = udev;	data->bulk_in_ep    = bulk_in_ep->desc.bEndpointAddress;	data->bulk_out_ep   = bulk_out_ep->desc.bEndpointAddress;	data->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);	rwlock_init(&data->lock);	data->reassembly = NULL;	skb_queue_head_init(&data->transmit_q);	skb_queue_head_init(&data->pending_q);	skb_queue_head_init(&data->completed_q);	if (request_firmware(&firmware, "bfubase.frm", &udev->dev) < 0) {		BT_ERR("Firmware request failed");		goto error;	}	BT_DBG("firmware data %p size %zu", firmware->data, firmware->size);	if (bfusb_load_firmware(data, firmware->data, firmware->size) < 0) {		BT_ERR("Firmware loading failed");		goto release;	}	release_firmware(firmware);	/* Initialize and register HCI device */	hdev = hci_alloc_dev();	if (!hdev) {		BT_ERR("Can't allocate HCI device");		goto error;	}	data->hdev = hdev;	hdev->type = HCI_USB;	hdev->driver_data = data;	SET_HCIDEV_DEV(hdev, &intf->dev);	hdev->open     = bfusb_open;	hdev->close    = bfusb_close;	hdev->flush    = bfusb_flush;	hdev->send     = bfusb_send_frame;	hdev->destruct = bfusb_destruct;	hdev->ioctl    = bfusb_ioctl;	hdev->owner = THIS_MODULE;	if (hci_register_dev(hdev) < 0) {		BT_ERR("Can't register HCI device");		hci_free_dev(hdev);		goto error;	}	usb_set_intfdata(intf, data);	return 0;release:	release_firmware(firmware);error:	kfree(data);done:	return -EIO;}

static void __exit vhci_exit(void){	if (misc_deregister(&vhci_miscdev) < 0)		BT_ERR("Can't unregister misc device with minor %d", minor);}

static int bfusb_send_frame(struct sk_buff *skb){	struct hci_dev *hdev = (struct hci_dev *) skb->dev;	struct bfusb_data *data;	struct sk_buff *nskb;	unsigned char buf[3];	int sent = 0, size, count;	BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, bt_cb(skb)->pkt_type, skb->len);	if (!hdev) {		BT_ERR("Frame for unknown HCI device (hdev=NULL)");		return -ENODEV;	}	if (!test_bit(HCI_RUNNING, &hdev->flags))		return -EBUSY;	data = hdev->driver_data;	switch (bt_cb(skb)->pkt_type) {	case HCI_COMMAND_PKT:		hdev->stat.cmd_tx++;		break;	case HCI_ACLDATA_PKT:		hdev->stat.acl_tx++;		break;	case HCI_SCODATA_PKT:		hdev->stat.sco_tx++;		break;	};	/* Prepend skb with frame type */	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);	count = skb->len;	/* Max HCI frame size seems to be 1511 + 1 */	nskb = bt_skb_alloc(count + 32, GFP_ATOMIC);	if (!nskb) {		BT_ERR("Can't allocate memory for new packet");		return -ENOMEM;	}	nskb->dev = (void *) data;	while (count) {		size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE);		buf[0] = 0xc1 | ((sent == 0) ? 0x04 : 0) | ((count == size) ? 0x08 : 0);		buf[1] = 0x00;		buf[2] = (size == BFUSB_MAX_BLOCK_SIZE) ? 0 : size;		memcpy(skb_put(nskb, 3), buf, 3);		skb_copy_from_linear_data_offset(skb, sent, skb_put(nskb, size), size);		sent  += size;		count -= size;	}	/* Don't send frame with multiple size of bulk max packet */	if ((nskb->len % data->bulk_pkt_size) == 0) {		buf[0] = 0xdd;		buf[1] = 0x00;		memcpy(skb_put(nskb, 2), buf, 2);	}	read_lock(&data->lock);	skb_queue_tail(&data->transmit_q, nskb);	bfusb_tx_wakeup(data);	read_unlock(&data->lock);	kfree_skb(skb);	return 0;}

static int bfusb_load_firmware(struct bfusb_data *data,			       const unsigned char *firmware, int count){	unsigned char *buf;	int err, pipe, len, size, sent = 0;	BT_DBG("bfusb %p udev %p", data, data->udev);	BT_INFO("BlueFRITZ! USB loading firmware");	pipe = usb_sndctrlpipe(data->udev, 0);	if (usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,				0, 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT) < 0) {		BT_ERR("Can't change to loading configuration");		return -EBUSY;	}	data->udev->toggle[0] = data->udev->toggle[1] = 0;	buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_ATOMIC);	if (!buf) {		BT_ERR("Can't allocate memory chunk for firmware");		return -ENOMEM;	}	pipe = usb_sndbulkpipe(data->udev, data->bulk_out_ep);	while (count) {		size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3);		memcpy(buf, firmware + sent, size);		err = usb_bulk_msg(data->udev, pipe, buf, size,					&len, BFUSB_BLOCK_TIMEOUT);		if (err || (len != size)) {			BT_ERR("Error in firmware loading");			goto error;		}		sent  += size;		count -= size;	}	err = usb_bulk_msg(data->udev, pipe, NULL, 0,					&len, BFUSB_BLOCK_TIMEOUT);	if (err < 0) {		BT_ERR("Error in null packet request");		goto error;	}	pipe = usb_sndctrlpipe(data->udev, 0);	err = usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,				0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);	if (err < 0) {		BT_ERR("Can't change to running configuration");		goto error;	}	data->udev->toggle[0] = data->udev->toggle[1] = 0;	BT_INFO("BlueFRITZ! USB device ready");	kfree(buf);	return 0;error:	kfree(buf);	pipe = usb_sndctrlpipe(data->udev, 0);	usb_control_msg(data->udev, pipe, USB_REQ_SET_CONFIGURATION,				0, 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);	return err;}

static void bfusb_rx_complete(struct urb *urb){	struct sk_buff *skb = (struct sk_buff *) urb->context;	struct bfusb_data *data = (struct bfusb_data *) skb->dev;	unsigned char *buf = urb->transfer_buffer;	int count = urb->actual_length;	int err, hdr, len;	BT_DBG("bfusb %p urb %p skb %p len %d", data, urb, skb, skb->len);	read_lock(&data->lock);	if (!test_bit(HCI_RUNNING, &data->hdev->flags))		goto unlock;	if (urb->status || !count)		goto resubmit;	data->hdev->stat.byte_rx += count;	skb_put(skb, count);	while (count) {		hdr = buf[0] | (buf[1] << 8);		if (hdr & 0x4000) {			len = 0;			count -= 2;			buf   += 2;		} else {			len = (buf[2] == 0) ? 256 : buf[2];			count -= 3;			buf   += 3;		}		if (count < len) {			BT_ERR("%s block extends over URB buffer ranges",					data->hdev->name);		}		if ((hdr & 0xe1) == 0xc1)			bfusb_recv_block(data, hdr, buf, len);		count -= len;		buf   += len;	}	skb_unlink(skb, &data->pending_q);	kfree_skb(skb);	bfusb_rx_submit(data, urb);	read_unlock(&data->lock);	return;resubmit:	urb->dev = data->udev;	err = usb_submit_urb(urb, GFP_ATOMIC);	if (err) {		BT_ERR("%s bulk resubmit failed urb %p err %d",					data->hdev->name, urb, err);	}unlock:	read_unlock(&data->lock);}

static inline int bfusb_recv_block(struct bfusb_data *data, int hdr, unsigned char *buf, int len){	BT_DBG("bfusb %p hdr 0x%02x data %p len %d", data, hdr, buf, len);	if (hdr & 0x10) {		BT_ERR("%s error in block", data->hdev->name);		kfree_skb(data->reassembly);		data->reassembly = NULL;		return -EIO;	}	if (hdr & 0x04) {		struct sk_buff *skb;		unsigned char pkt_type;		int pkt_len = 0;		if (data->reassembly) {			BT_ERR("%s unexpected start block", data->hdev->name);			kfree_skb(data->reassembly);			data->reassembly = NULL;		}		if (len < 1) {			BT_ERR("%s no packet type found", data->hdev->name);			return -EPROTO;		}		pkt_type = *buf++; len--;		switch (pkt_type) {		case HCI_EVENT_PKT:			if (len >= HCI_EVENT_HDR_SIZE) {				struct hci_event_hdr *hdr = (struct hci_event_hdr *) buf;				pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen;			} else {				BT_ERR("%s event block is too short", data->hdev->name);				return -EILSEQ;			}			break;		case HCI_ACLDATA_PKT:			if (len >= HCI_ACL_HDR_SIZE) {				struct hci_acl_hdr *hdr = (struct hci_acl_hdr *) buf;				pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen);			} else {				BT_ERR("%s data block is too short", data->hdev->name);				return -EILSEQ;			}			break;		case HCI_SCODATA_PKT:			if (len >= HCI_SCO_HDR_SIZE) {				struct hci_sco_hdr *hdr = (struct hci_sco_hdr *) buf;				pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen;			} else {				BT_ERR("%s audio block is too short", data->hdev->name);				return -EILSEQ;			}			break;		}		skb = bt_skb_alloc(pkt_len, GFP_ATOMIC);		if (!skb) {			BT_ERR("%s no memory for the packet", data->hdev->name);			return -ENOMEM;		}		skb->dev = (void *) data->hdev;		bt_cb(skb)->pkt_type = pkt_type;		data->reassembly = skb;	} else {		if (!data->reassembly) {			BT_ERR("%s unexpected continuation block", data->hdev->name);			return -EIO;		}	}	if (len > 0)		memcpy(skb_put(data->reassembly, len), buf, len);	if (hdr & 0x08) {		hci_recv_frame(data->reassembly);		data->reassembly = NULL;	}	return 0;}

//.........这里部分代码省略.........			switch (ibs->rx_state) {			case HCI_IBS_W4_DATA:				BT_DBG("Complete data");				hci_recv_frame(ibs->rx_skb);				ibs->rx_state = HCI_IBS_W4_PACKET_TYPE;				ibs->rx_skb = NULL;				continue;			case HCI_IBS_W4_EVENT_HDR:				eh = (struct hci_event_hdr *) ibs->rx_skb->data;				BT_DBG("Event header: evt 0x%2.2x plen %d",					eh->evt, eh->plen);				ibs_check_data_len(ibs, eh->plen);				continue;			case HCI_IBS_W4_ACL_HDR:				ah = (struct hci_acl_hdr *) ibs->rx_skb->data;				dlen = __le16_to_cpu(ah->dlen);				BT_DBG("ACL header: dlen %d", dlen);				ibs_check_data_len(ibs, dlen);				continue;			case HCI_IBS_W4_SCO_HDR:				sh = (struct hci_sco_hdr *) ibs->rx_skb->data;				BT_DBG("SCO header: dlen %d", sh->dlen);				ibs_check_data_len(ibs, sh->dlen);				continue;			}		}		/* HCI_IBS_W4_PACKET_TYPE */		switch (*ptr) {		case HCI_EVENT_PKT:			BT_DBG("Event packet");			ibs->rx_state = HCI_IBS_W4_EVENT_HDR;			ibs->rx_count = HCI_EVENT_HDR_SIZE;			type = HCI_EVENT_PKT;			break;		case HCI_ACLDATA_PKT:			BT_DBG("ACL packet");			ibs->rx_state = HCI_IBS_W4_ACL_HDR;			ibs->rx_count = HCI_ACL_HDR_SIZE;			type = HCI_ACLDATA_PKT;			break;		case HCI_SCODATA_PKT:			BT_DBG("SCO packet");			ibs->rx_state = HCI_IBS_W4_SCO_HDR;			ibs->rx_count = HCI_SCO_HDR_SIZE;			type = HCI_SCODATA_PKT;			break;		/* HCI_IBS signals */		case HCI_IBS_SLEEP_IND:			BT_DBG("HCI_IBS_SLEEP_IND packet");			ibs_device_want_to_sleep(hu);			ptr++; count--;			continue;		case HCI_IBS_WAKE_IND:			BT_DBG("HCI_IBS_WAKE_IND packet");			ibs_device_want_to_wakeup(hu);			ptr++; count--;			continue;		case HCI_IBS_WAKE_ACK:			BT_DBG("HCI_IBS_WAKE_ACK packet");			ibs_device_woke_up(hu);			ptr++; count--;			continue;		default:			BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);			hu->hdev->stat.err_rx++;			ptr++; count--;			continue;		};		ptr++; count--;		/* Allocate packet */		ibs->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);		if (!ibs->rx_skb) {			BT_ERR("Can't allocate mem for new packet");			ibs->rx_state = HCI_IBS_W4_PACKET_TYPE;			ibs->rx_count = 0;			return 0;		}		ibs->rx_skb->dev = (void *) hu->hdev;		bt_cb(ibs->rx_skb)->pkt_type = type;	}

static void bluecard_receive(bluecard_info_t *info, unsigned int offset){	unsigned int iobase;	unsigned char buf[31];	int i, len;	if (!info) {		BT_ERR("Unknown device");		return;	}#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))	iobase = info->p_dev->resource[0]->start;#else	iobase = info->p_dev->io.BasePort1;#endif	if (test_bit(XMIT_SENDING_READY, &(info->tx_state)))		bluecard_enable_activity_led(info);	len = bluecard_read(iobase, offset, buf, sizeof(buf));	for (i = 0; i < len; i++) {		/* Allocate packet */		if (info->rx_skb == NULL) {			info->rx_state = RECV_WAIT_PACKET_TYPE;			info->rx_count = 0;			if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {				BT_ERR("Can't allocate mem for new packet");				return;			}		}		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {			info->rx_skb->dev = (void *) info->hdev;			bt_cb(info->rx_skb)->pkt_type = buf[i];			switch (bt_cb(info->rx_skb)->pkt_type) {			case 0x00:				/* init packet */				if (offset != 0x00) {					set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));					set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));					set_bit(XMIT_SENDING_READY, &(info->tx_state));					bluecard_write_wakeup(info);				}				kfree_skb(info->rx_skb);				info->rx_skb = NULL;				break;			case HCI_EVENT_PKT:				info->rx_state = RECV_WAIT_EVENT_HEADER;				info->rx_count = HCI_EVENT_HDR_SIZE;				break;			case HCI_ACLDATA_PKT:				info->rx_state = RECV_WAIT_ACL_HEADER;				info->rx_count = HCI_ACL_HDR_SIZE;				break;			case HCI_SCODATA_PKT:				info->rx_state = RECV_WAIT_SCO_HEADER;				info->rx_count = HCI_SCO_HDR_SIZE;				break;			default:				/* unknown packet */				BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);				info->hdev->stat.err_rx++;				kfree_skb(info->rx_skb);				info->rx_skb = NULL;				break;			}		} else {			*skb_put(info->rx_skb, 1) = buf[i];			info->rx_count--;			if (info->rx_count == 0) {				int dlen;				struct hci_event_hdr *eh;				struct hci_acl_hdr *ah;				struct hci_sco_hdr *sh;				switch (info->rx_state) {				case RECV_WAIT_EVENT_HEADER:					eh = hci_event_hdr(info->rx_skb);					info->rx_state = RECV_WAIT_DATA;					info->rx_count = eh->plen;					break;//.........这里部分代码省略.........

int bnep_sock_cleanup(void){	if (bluez_sock_unregister(BTPROTO_BNEP))		BT_ERR("Can't unregister BNEP socket");	return 0;}

static int bluecard_open(bluecard_info_t *info){#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))	unsigned int iobase = info->p_dev->resource[0]->start;#else	unsigned int iobase = info->p_dev->io.BasePort1;#endif	struct hci_dev *hdev;	unsigned char id;	spin_lock_init(&(info->lock));	init_timer(&(info->timer));	info->timer.function = &bluecard_activity_led_timeout;	info->timer.data = (u_long)info;	skb_queue_head_init(&(info->txq));	info->rx_state = RECV_WAIT_PACKET_TYPE;	info->rx_count = 0;	info->rx_skb = NULL;	/* Initialize HCI device */	hdev = hci_alloc_dev();	if (!hdev) {		BT_ERR("Can't allocate HCI device");		return -ENOMEM;	}	info->hdev = hdev;	hdev->bus = HCI_PCCARD;	hci_set_drvdata(hdev, info);	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);	hdev->open     = bluecard_hci_open;	hdev->close    = bluecard_hci_close;	hdev->flush    = bluecard_hci_flush;	hdev->send     = bluecard_hci_send_frame;	hdev->ioctl    = bluecard_hci_ioctl;	id = inb(iobase + 0x30);	if ((id & 0x0f) == 0x02)		set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state));	if (id & 0x10)		set_bit(CARD_HAS_POWER_LED, &(info->hw_state));	if (id & 0x20)		set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state));	/* Reset card */	info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;	outb(info->ctrl_reg, iobase + REG_CONTROL);	/* Turn FPGA off */	outb(0x80, iobase + 0x30);	/* Wait some time */	msleep(10);	/* Turn FPGA on */	outb(0x00, iobase + 0x30);	/* Activate card */	info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU;	outb(info->ctrl_reg, iobase + REG_CONTROL);	/* Enable interrupt */	outb(0xff, iobase + REG_INTERRUPT);	info->ctrl_reg |= REG_CONTROL_INTERRUPT;	outb(info->ctrl_reg, iobase + REG_CONTROL);	if ((id & 0x0f) == 0x03) {		/* Disable RTS */		info->ctrl_reg |= REG_CONTROL_RTS;		outb(info->ctrl_reg, iobase + REG_CONTROL);		/* Set baud rate */		info->ctrl_reg |= 0x03;		outb(info->ctrl_reg, iobase + REG_CONTROL);		/* Enable RTS */		info->ctrl_reg &= ~REG_CONTROL_RTS;		outb(info->ctrl_reg, iobase + REG_CONTROL);		set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));		set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));		set_bit(XMIT_SENDING_READY, &(info->tx_state));	}	/* Start the RX buffers */	outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);	outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);	/* Signal that the hardware is ready */	set_bit(CARD_READY, &(info->hw_state));	/* Drop TX queue *///.........这里部分代码省略.........

/* Recv data */static int ll_recv(struct hci_uart *hu, void *data, int count){	struct ll_struct *ll = hu->priv;	char *ptr;	struct hci_event_hdr *eh;	struct hci_acl_hdr   *ah;	struct hci_sco_hdr   *sh;	int len, type, dlen;	BT_DBG("hu %p count %d rx_state %ld rx_count %ld", hu, count, ll->rx_state, ll->rx_count);	ptr = data;	while (count) {		if (ll->rx_count) {			len = min_t(unsigned int, ll->rx_count, count);			memcpy(skb_put(ll->rx_skb, len), ptr, len);			ll->rx_count -= len; count -= len; ptr += len;			if (ll->rx_count)				continue;			switch (ll->rx_state) {			case HCILL_W4_DATA:				BT_DBG("Complete data");				hci_recv_frame(hu->hdev, ll->rx_skb);				ll->rx_state = HCILL_W4_PACKET_TYPE;				ll->rx_skb = NULL;				continue;			case HCILL_W4_EVENT_HDR:				eh = hci_event_hdr(ll->rx_skb);				BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);				ll_check_data_len(hu->hdev, ll, eh->plen);				continue;			case HCILL_W4_ACL_HDR:				ah = hci_acl_hdr(ll->rx_skb);				dlen = __le16_to_cpu(ah->dlen);				BT_DBG("ACL header: dlen %d", dlen);				ll_check_data_len(hu->hdev, ll, dlen);				continue;			case HCILL_W4_SCO_HDR:				sh = hci_sco_hdr(ll->rx_skb);				BT_DBG("SCO header: dlen %d", sh->dlen);				ll_check_data_len(hu->hdev, ll, sh->dlen);				continue;			}		}		/* HCILL_W4_PACKET_TYPE */		switch (*ptr) {		case HCI_EVENT_PKT:			BT_DBG("Event packet");			ll->rx_state = HCILL_W4_EVENT_HDR;			ll->rx_count = HCI_EVENT_HDR_SIZE;			type = HCI_EVENT_PKT;			break;		case HCI_ACLDATA_PKT:			BT_DBG("ACL packet");			ll->rx_state = HCILL_W4_ACL_HDR;			ll->rx_count = HCI_ACL_HDR_SIZE;			type = HCI_ACLDATA_PKT;			break;		case HCI_SCODATA_PKT:			BT_DBG("SCO packet");			ll->rx_state = HCILL_W4_SCO_HDR;			ll->rx_count = HCI_SCO_HDR_SIZE;			type = HCI_SCODATA_PKT;			break;		/* HCILL signals */		case HCILL_GO_TO_SLEEP_IND:			BT_DBG("HCILL_GO_TO_SLEEP_IND packet");			ll_device_want_to_sleep(hu);			ptr++; count--;			continue;		case HCILL_GO_TO_SLEEP_ACK:			/* shouldn't happen */			BT_ERR("received HCILL_GO_TO_SLEEP_ACK (in state %ld)", ll->hcill_state);			ptr++; count--;			continue;		case HCILL_WAKE_UP_IND:			BT_DBG("HCILL_WAKE_UP_IND packet");			ll_device_want_to_wakeup(hu);			ptr++; count--;			continue;//.........这里部分代码省略.........

static int ath_bluesleep_gpio_config(int on){    int ret = 0;    BT_INFO("%s config: %d", __func__, on);    if (!on) {        if (disable_irq_wake(bsi->host_wake_irq))            BT_ERR("Couldn't disable hostwake IRQ wakeup mode/n");        goto free_host_wake_irq;    }    ret = gpio_request(bsi->host_wake, "bt_host_wake");    if (ret < 0) {        BT_ERR("failed to request gpio pin %d, error %d/n",               bsi->host_wake, ret);        goto gpio_config_failed;    }    /* configure host_wake as input */    ret = gpio_direction_input(bsi->host_wake);    if (ret < 0) {        BT_ERR("failed to config GPIO %d as input pin, err %d/n",               bsi->host_wake, ret);        goto gpio_host_wake;    }    ret = gpio_request(bsi->ext_wake, "bt_ext_wake");    if (ret < 0) {        BT_ERR("failed to request gpio pin %d, error %d/n",               bsi->ext_wake, ret);        goto gpio_host_wake;    }    ret = gpio_direction_output(bsi->ext_wake, 1);    if (ret < 0) {        BT_ERR("failed to config GPIO %d as output pin, err %d/n",               bsi->ext_wake, ret);        goto gpio_ext_wake;    }    gpio_set_value(bsi->ext_wake, 1);    /* Initialize spinlock. */    spin_lock_init(&rw_lock);    /* Initialize timer */    init_timer(&tx_timer);    tx_timer.function = bluesleep_tx_timer_expire;    tx_timer.data = 0;    if (bsi->irq_polarity == POLARITY_LOW) {        ret = request_irq(bsi->host_wake_irq, bluesleep_hostwake_isr,                          IRQF_DISABLED | IRQF_TRIGGER_FALLING,                          "bluetooth hostwake", NULL);    } else  {        ret = request_irq(bsi->host_wake_irq, bluesleep_hostwake_isr,                          IRQF_DISABLED | IRQF_TRIGGER_RISING,                          "bluetooth hostwake", NULL);    }    if (ret  < 0) {        BT_ERR("Couldn't acquire BT_HOST_WAKE IRQ");        goto delete_timer;    }    ret = enable_irq_wake(bsi->host_wake_irq);    if (ret < 0) {        BT_ERR("Couldn't enable BT_HOST_WAKE as wakeup interrupt");        goto free_host_wake_irq;    }    return 0;free_host_wake_irq:    free_irq(bsi->host_wake_irq, NULL);delete_timer:    del_timer(&tx_timer);gpio_ext_wake:    gpio_free(bsi->ext_wake);gpio_host_wake:    gpio_free(bsi->host_wake);gpio_config_failed:    return ret;}

/* Called from HCI core to initialize the device */static int ti_st_open(struct hci_dev *hdev){	unsigned long timeleft;	struct ti_st *hst;	int err, i;	BT_DBG("%s %p", hdev->name, hdev);	if (test_and_set_bit(HCI_RUNNING, &hdev->flags))		return -EBUSY;	/* provide contexts for callbacks from ST */	hst = hci_get_drvdata(hdev);	for (i = 0; i < MAX_BT_CHNL_IDS; i++) {		ti_st_proto[i].priv_data = hst;		ti_st_proto[i].max_frame_size = HCI_MAX_FRAME_SIZE;		ti_st_proto[i].recv = st_receive;		ti_st_proto[i].reg_complete_cb = st_reg_completion_cb;		/* Prepare wait-for-completion handler */		init_completion(&hst->wait_reg_completion);		/* Reset ST registration callback status flag,		 * this value will be updated in		 * st_reg_completion_cb()		 * function whenever it called from ST driver.		 */		hst->reg_status = -EINPROGRESS;		err = st_register(&ti_st_proto[i]);		if (!err)			goto done;		if (err != -EINPROGRESS) {			clear_bit(HCI_RUNNING, &hdev->flags);			BT_ERR("st_register failed %d", err);			return err;		}		/* ST is busy with either protocol		 * registration or firmware download.		 */		BT_DBG("waiting for registration "				"completion signal from ST");		timeleft = wait_for_completion_timeout			(&hst->wait_reg_completion,			 msecs_to_jiffies(BT_REGISTER_TIMEOUT));		if (!timeleft) {			clear_bit(HCI_RUNNING, &hdev->flags);			BT_ERR("Timeout(%d sec),didn't get reg "					"completion signal from ST",					BT_REGISTER_TIMEOUT / 1000);			return -ETIMEDOUT;		}		/* Is ST registration callback		 * called with ERROR status? */		if (hst->reg_status != 0) {			clear_bit(HCI_RUNNING, &hdev->flags);			BT_ERR("ST registration completed with invalid "					"status %d", hst->reg_status);			return -EAGAIN;		}done:		hst->st_write = ti_st_proto[i].write;		if (!hst->st_write) {			BT_ERR("undefined ST write function");			clear_bit(HCI_RUNNING, &hdev->flags);			for (i = 0; i < MAX_BT_CHNL_IDS; i++) {				/* Undo registration with ST */				err = st_unregister(&ti_st_proto[i]);				if (err)					BT_ERR("st_unregister() failed with "							"error %d", err);				hst->st_write = NULL;			}			return -EIO;		}	}	return 0;}

static void dtl1_receive(struct dtl1_info *info){	unsigned int iobase;	struct nsh *nsh;	int boguscount = 0;	if (!info) {		BT_ERR("Unknown device");		return;	}	iobase = info->p_dev->resource[0]->start;	do {		info->hdev->stat.byte_rx++;		/* Allocate packet */		if (info->rx_skb == NULL) {			info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);			if (!info->rx_skb) {				BT_ERR("Can't allocate mem for new packet");				info->rx_state = RECV_WAIT_NSH;				info->rx_count = NSHL;				return;			}		}		*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);		nsh = (struct nsh *)info->rx_skb->data;		info->rx_count--;		if (info->rx_count == 0) {			switch (info->rx_state) {			case RECV_WAIT_NSH:				info->rx_state = RECV_WAIT_DATA;				info->rx_count = nsh->len + (nsh->len & 0x0001);				break;			case RECV_WAIT_DATA:				bt_cb(info->rx_skb)->pkt_type = nsh->type;				/* remove PAD byte if it exists */				if (nsh->len & 0x0001) {					info->rx_skb->tail--;					info->rx_skb->len--;				}				/* remove NSH */				skb_pull(info->rx_skb, NSHL);				switch (bt_cb(info->rx_skb)->pkt_type) {				case 0x80:					/* control data for the Nokia Card */					dtl1_control(info, info->rx_skb);					break;				case 0x82:				case 0x83:				case 0x84:					/* send frame to the HCI layer */					bt_cb(info->rx_skb)->pkt_type &= 0x0f;					hci_recv_frame(info->hdev, info->rx_skb);					break;				default:					/* unknown packet */					BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);					kfree_skb(info->rx_skb);					break;				}				info->rx_state = RECV_WAIT_NSH;				info->rx_count = NSHL;				info->rx_skb = NULL;				break;			}		}		/* Make sure we don't stay here too long */		if (boguscount++ > 32)			break;	} while (inb(iobase + UART_LSR) & UART_LSR_DR);}

static int btuart_open(btuart_info_t *info){	unsigned long flags;	unsigned int iobase = info->p_dev->resource[0]->start;	struct hci_dev *hdev;	spin_lock_init(&(info->lock));	skb_queue_head_init(&(info->txq));	info->rx_state = RECV_WAIT_PACKET_TYPE;	info->rx_count = 0;	info->rx_skb = NULL;	/* Initialize HCI device */	hdev = hci_alloc_dev();	if (!hdev) {		BT_ERR("Can't allocate HCI device");		return -ENOMEM;	}	info->hdev = hdev;	hdev->bus = HCI_PCCARD;	hci_set_drvdata(hdev, info);	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);	hdev->open     = btuart_hci_open;	hdev->close    = btuart_hci_close;	hdev->flush    = btuart_hci_flush;	hdev->send     = btuart_hci_send_frame;	hdev->ioctl    = btuart_hci_ioctl;	spin_lock_irqsave(&(info->lock), flags);	/* Reset UART */	outb(0, iobase + UART_MCR);	/* Turn off interrupts */	outb(0, iobase + UART_IER);	/* Initialize UART */	outb(UART_LCR_WLEN8, iobase + UART_LCR);	/* Reset DLAB */	outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);	/* Turn on interrupts */	// outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);	spin_unlock_irqrestore(&(info->lock), flags);	btuart_change_speed(info, DEFAULT_BAUD_RATE);	/* Timeout before it is safe to send the first HCI packet */	msleep(1000);	/* Register HCI device */	if (hci_register_dev(hdev) < 0) {		BT_ERR("Can't register HCI device");		info->hdev = NULL;		hci_free_dev(hdev);		return -ENODEV;	}	return 0;}

static irqreturn_t dtl1_interrupt(int irq, void *dev_inst){	struct dtl1_info *info = dev_inst;	unsigned int iobase;	unsigned char msr;	int boguscount = 0;	int iir, lsr;	irqreturn_t r = IRQ_NONE;	if (!info || !info->hdev)		/* our irq handler is shared */		return IRQ_NONE;	iobase = info->p_dev->resource[0]->start;	spin_lock(&(info->lock));	iir = inb(iobase + UART_IIR) & UART_IIR_ID;	while (iir) {		r = IRQ_HANDLED;		/* Clear interrupt */		lsr = inb(iobase + UART_LSR);		switch (iir) {		case UART_IIR_RLSI:			BT_ERR("RLSI");			break;		case UART_IIR_RDI:			/* Receive interrupt */			dtl1_receive(info);			break;		case UART_IIR_THRI:			if (lsr & UART_LSR_THRE) {				/* Transmitter ready for data */				dtl1_write_wakeup(info);			}			break;		default:			BT_ERR("Unhandled IIR=%#x", iir);			break;		}		/* Make sure we don't stay here too long */		if (boguscount++ > 100)			break;		iir = inb(iobase + UART_IIR) & UART_IIR_ID;	}	msr = inb(iobase + UART_MSR);	if (info->ri_latch ^ (msr & UART_MSR_RI)) {		info->ri_latch = msr & UART_MSR_RI;		clear_bit(XMIT_WAITING, &(info->tx_state));		dtl1_write_wakeup(info);		r = IRQ_HANDLED;	}	spin_unlock(&(info->lock));	return r;}

static int btusb_setup_intel_patching(struct hci_dev *hdev,				      const struct firmware *fw,				      const u8 **fw_ptr, int *disable_patch){	struct sk_buff *skb;	struct hci_command_hdr *cmd;	const u8 *cmd_param;	struct hci_event_hdr *evt = NULL;	const u8 *evt_param = NULL;	int remain = fw->size - (*fw_ptr - fw->data);	/* The first byte indicates the types of the patch command or event.	 * 0x01 means HCI command and 0x02 is HCI event. If the first bytes	 * in the current firmware buffer doesn't start with 0x01 or	 * the size of remain buffer is smaller than HCI command header,	 * the firmware file is corrupted and it should stop the patching	 * process.	 */	if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) {		BT_ERR("%s Intel fw corrupted: invalid cmd read", hdev->name);		return -EINVAL;	}	(*fw_ptr)++;	remain--;	cmd = (struct hci_command_hdr *)(*fw_ptr);	*fw_ptr += sizeof(*cmd);	remain -= sizeof(*cmd);	/* Ensure that the remain firmware data is long enough than the length	 * of command parameter. If not, the firmware file is corrupted.	 */	if (remain < cmd->plen) {		BT_ERR("%s Intel fw corrupted: invalid cmd len", hdev->name);		return -EFAULT;	}	/* If there is a command that loads a patch in the firmware	 * file, then enable the patch upon success, otherwise just	 * disable the manufacturer mode, for example patch activation	 * is not required when the default firmware patch file is used	 * because there are no patch data to load.	 */	if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e)		*disable_patch = 0;	cmd_param = *fw_ptr;	*fw_ptr += cmd->plen;	remain -= cmd->plen;	/* This reads the expected events when the above command is sent to the	 * device. Some vendor commands expects more than one events, for	 * example command status event followed by vendor specific event.	 * For this case, it only keeps the last expected event. so the command	 * can be sent with __hci_cmd_sync_ev() which returns the sk_buff of	 * last expected event.	 */	while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) {		(*fw_ptr)++;		remain--;		evt = (struct hci_event_hdr *)(*fw_ptr);		*fw_ptr += sizeof(*evt);		remain -= sizeof(*evt);		if (remain < evt->plen) {			BT_ERR("%s Intel fw corrupted: invalid evt len",			       hdev->name);			return -EFAULT;		}		evt_param = *fw_ptr;		*fw_ptr += evt->plen;		remain -= evt->plen;	}	/* Every HCI commands in the firmware file has its correspond event.	 * If event is not found or remain is smaller than zero, the firmware	 * file is corrupted.	 */	if (!evt || !evt_param || remain < 0) {		BT_ERR("%s Intel fw corrupted: invalid evt read", hdev->name);		return -EFAULT;	}	skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen,				cmd_param, evt->evt, HCI_INIT_TIMEOUT);	if (IS_ERR(skb)) {		BT_ERR("%s sending Intel patch command (0x%4.4x) failed (%ld)",		       hdev->name, cmd->opcode, PTR_ERR(skb));		return PTR_ERR(skb);	}	/* It ensures that the returned event matches the event data read from	 * the firmware file. At fist, it checks the length and then	 * the contents of the event.	 */	if (skb->len != evt->plen) {		BT_ERR("%s mismatch event length (opcode 0x%4.4x)", hdev->name,		       le16_to_cpu(cmd->opcode));//.........这里部分代码省略.........

static int dtl1_open(struct dtl1_info *info){	unsigned long flags;	unsigned int iobase = info->p_dev->resource[0]->start;	struct hci_dev *hdev;	spin_lock_init(&(info->lock));	skb_queue_head_init(&(info->txq));	info->rx_state = RECV_WAIT_NSH;	info->rx_count = NSHL;	info->rx_skb = NULL;	set_bit(XMIT_WAITING, &(info->tx_state));	/* Initialize HCI device */	hdev = hci_alloc_dev();	if (!hdev) {		BT_ERR("Can't allocate HCI device");		return -ENOMEM;	}	info->hdev = hdev;	hdev->bus = HCI_PCCARD;	hci_set_drvdata(hdev, info);	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);	hdev->open  = dtl1_hci_open;	hdev->close = dtl1_hci_close;	hdev->flush = dtl1_hci_flush;	hdev->send  = dtl1_hci_send_frame;	spin_lock_irqsave(&(info->lock), flags);	/* Reset UART */	outb(0, iobase + UART_MCR);	/* Turn off interrupts */	outb(0, iobase + UART_IER);	/* Initialize UART */	outb(UART_LCR_WLEN8, iobase + UART_LCR);	/* Reset DLAB */	outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);	info->ri_latch = inb(info->p_dev->resource[0]->start + UART_MSR)				& UART_MSR_RI;	/* Turn on interrupts */	outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);	spin_unlock_irqrestore(&(info->lock), flags);	/* Timeout before it is safe to send the first HCI packet */	msleep(2000);	/* Register HCI device */	if (hci_register_dev(hdev) < 0) {		BT_ERR("Can't register HCI device");		info->hdev = NULL;		hci_free_dev(hdev);		return -ENODEV;	}	return 0;}

static int btusb_send_frame(struct sk_buff *skb){	struct hci_dev *hdev = (struct hci_dev *) skb->dev;	struct btusb_data *data = hci_get_drvdata(hdev);	struct usb_ctrlrequest *dr;	struct urb *urb;	unsigned int pipe;	int err;	BT_DBG("%s", hdev->name);	if (!test_bit(HCI_RUNNING, &hdev->flags))		return -EBUSY;	switch (bt_cb(skb)->pkt_type) {	case HCI_COMMAND_PKT:		urb = usb_alloc_urb(0, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		dr = kmalloc(sizeof(*dr), GFP_ATOMIC);		if (!dr) {			usb_free_urb(urb);			return -ENOMEM;		}		dr->bRequestType = data->cmdreq_type;		dr->bRequest     = 0;		dr->wIndex       = 0;		dr->wValue       = 0;		dr->wLength      = __cpu_to_le16(skb->len);		pipe = usb_sndctrlpipe(data->udev, 0x00);		usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,				skb->data, skb->len, btusb_tx_complete, skb);		hdev->stat.cmd_tx++;		break;	case HCI_ACLDATA_PKT:		if (!data->bulk_tx_ep)			return -ENODEV;		urb = usb_alloc_urb(0, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		pipe = usb_sndbulkpipe(data->udev,					data->bulk_tx_ep->bEndpointAddress);		usb_fill_bulk_urb(urb, data->udev, pipe,				skb->data, skb->len, btusb_tx_complete, skb);		hdev->stat.acl_tx++;		break;	case HCI_SCODATA_PKT:		if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)			return -ENODEV;		urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		pipe = usb_sndisocpipe(data->udev,					data->isoc_tx_ep->bEndpointAddress);		usb_fill_int_urb(urb, data->udev, pipe,				skb->data, skb->len, btusb_isoc_tx_complete,				skb, data->isoc_tx_ep->bInterval);		urb->transfer_flags  = URB_ISO_ASAP;		__fill_isoc_descriptor(urb, skb->len,				le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));		hdev->stat.sco_tx++;		goto skip_waking;	default:		return -EILSEQ;	}	err = inc_tx(data);	if (err) {		usb_anchor_urb(urb, &data->deferred);		schedule_work(&data->waker);		err = 0;		goto done;	}skip_waking:	usb_anchor_urb(urb, &data->tx_anchor);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (err < 0) {		if (err != -EPERM && err != -ENODEV)			BT_ERR("%s urb %p submission failed (%d)",						hdev->name, urb, -err);//.........这里部分代码省略.........

static void bluecard_write_wakeup(bluecard_info_t *info){	if (!info) {		BT_ERR("Unknown device");		return;	}	if (!test_bit(XMIT_SENDING_READY, &(info->tx_state)))		return;	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {		set_bit(XMIT_WAKEUP, &(info->tx_state));		return;	}	do {#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))		unsigned int iobase = info->p_dev->resource[0]->start;#else		unsigned int iobase = info->p_dev->io.BasePort1;#endif		unsigned int offset;		unsigned char command;		unsigned long ready_bit;		register struct sk_buff *skb;		int len;		clear_bit(XMIT_WAKEUP, &(info->tx_state));		if (!pcmcia_dev_present(info->p_dev))			return;		if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) {			if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state)))				break;			offset = 0x10;			command = REG_COMMAND_TX_BUF_TWO;			ready_bit = XMIT_BUF_TWO_READY;		} else {			if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state)))				break;			offset = 0x00;			command = REG_COMMAND_TX_BUF_ONE;			ready_bit = XMIT_BUF_ONE_READY;		}		if (!(skb = skb_dequeue(&(info->txq))))			break;		if (bt_cb(skb)->pkt_type & 0x80) {			/* Disable RTS */			info->ctrl_reg |= REG_CONTROL_RTS;			outb(info->ctrl_reg, iobase + REG_CONTROL);		}		/* Activate LED */		bluecard_enable_activity_led(info);		/* Send frame */		len = bluecard_write(iobase, offset, skb->data, skb->len);		/* Tell the FPGA to send the data */		outb_p(command, iobase + REG_COMMAND);		/* Mark the buffer as dirty */		clear_bit(ready_bit, &(info->tx_state));		if (bt_cb(skb)->pkt_type & 0x80) {			DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);			DEFINE_WAIT(wait);			unsigned char baud_reg;			switch (bt_cb(skb)->pkt_type) {			case PKT_BAUD_RATE_460800:				baud_reg = REG_CONTROL_BAUD_RATE_460800;				break;			case PKT_BAUD_RATE_230400:				baud_reg = REG_CONTROL_BAUD_RATE_230400;				break;			case PKT_BAUD_RATE_115200:				baud_reg = REG_CONTROL_BAUD_RATE_115200;				break;			case PKT_BAUD_RATE_57600:				/* Fall through... */			default:				baud_reg = REG_CONTROL_BAUD_RATE_57600;				break;			}			/* Wait until the command reaches the baseband */			prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);			schedule_timeout(HZ/10);			finish_wait(&wq, &wait);			/* Set baud on baseband */			info->ctrl_reg &= ~0x03;			info->ctrl_reg |= baud_reg;			outb(info->ctrl_reg, iobase + REG_CONTROL);//.........这里部分代码省略.........

static void le_conn_req(struct bt_l2cap *l2cap, uint8_t ident,			struct net_buf *buf){	struct bt_conn *conn = l2cap->chan.chan.conn;	struct bt_l2cap_chan *chan;	struct bt_l2cap_server *server;	struct bt_l2cap_le_conn_req *req = (void *)buf->data;	struct bt_l2cap_le_conn_rsp *rsp;	struct bt_l2cap_sig_hdr *hdr;	uint16_t psm, scid, mtu, mps, credits;	if (buf->len < sizeof(*req)) {		BT_ERR("Too small LE conn req packet size");		return;	}	psm = sys_le16_to_cpu(req->psm);	scid = sys_le16_to_cpu(req->scid);	mtu = sys_le16_to_cpu(req->mtu);	mps = sys_le16_to_cpu(req->mps);	credits = sys_le16_to_cpu(req->credits);	BT_DBG("psm 0x%02x scid 0x%04x mtu %u mps %u credits %u", psm, scid,	       mtu, mps, credits);	if (mtu < L2CAP_LE_MIN_MTU || mps < L2CAP_LE_MIN_MTU) {		BT_ERR("Invalid LE-Conn Req params");		return;	}	buf = bt_l2cap_create_pdu(&le_sig);	if (!buf) {		return;	}	hdr = net_buf_add(buf, sizeof(*hdr));	hdr->code = BT_L2CAP_LE_CONN_RSP;	hdr->ident = ident;	hdr->len = sys_cpu_to_le16(sizeof(*rsp));	rsp = net_buf_add(buf, sizeof(*rsp));	memset(rsp, 0, sizeof(*rsp));	/* Check if there is a server registered */	server = l2cap_server_lookup_psm(psm);	if (!server) {		rsp->result = sys_cpu_to_le16(BT_L2CAP_ERR_PSM_NOT_SUPP);		goto rsp;	}	/* TODO: Add security check */	if (scid < L2CAP_LE_DYN_CID_START || scid > L2CAP_LE_DYN_CID_END) {		rsp->result = sys_cpu_to_le16(BT_L2CAP_ERR_INVALID_SCID);		goto rsp;	}	chan = bt_l2cap_le_lookup_tx_cid(conn, scid);	if (chan) {		rsp->result = sys_cpu_to_le16(BT_L2CAP_ERR_SCID_IN_USE);		goto rsp;	}	/* Request server to accept the new connection and allocate the	 * channel.	 *	 * TODO: Handle different errors, it may be required to respond async.	 */	if (server->accept(conn, &chan) < 0) {		rsp->result = sys_cpu_to_le16(BT_L2CAP_ERR_NO_RESOURCES);		goto rsp;	}	if (l2cap_chan_add(conn, chan)) {		struct bt_l2cap_le_chan *ch = LE_CHAN(chan);		/* Init TX parameters */		l2cap_chan_tx_init(ch);		ch->tx.cid = scid;		ch->tx.mps = mps;		ch->tx.mtu = mtu;		l2cap_chan_tx_give_credits(ch, credits);		/* Init RX parameters */		l2cap_chan_rx_init(ch);		l2cap_chan_rx_give_credits(ch, L2CAP_LE_MAX_CREDITS);		if (chan->ops && chan->ops->connected) {			chan->ops->connected(chan);		}		/* Prepare response protocol data */		rsp->dcid = sys_cpu_to_le16(ch->rx.cid);		rsp->mps = sys_cpu_to_le16(ch->rx.mps);		rsp->mtu = sys_cpu_to_le16(ch->rx.mtu);		rsp->credits = sys_cpu_to_le16(L2CAP_LE_MAX_CREDITS);		rsp->result = BT_L2CAP_SUCCESS;	} else {		rsp->result = sys_cpu_to_le16(BT_L2CAP_ERR_NO_RESOURCES);	}//.........这里部分代码省略.........

int btbcm_patchram(struct hci_dev *hdev, const struct firmware *fw){	const struct hci_command_hdr *cmd;	const u8 *fw_ptr;	size_t fw_size;	struct sk_buff *skb;	u16 opcode;	int err = 0;	/* Start Download */	skb = __hci_cmd_sync(hdev, 0xfc2e, 0, NULL, HCI_INIT_TIMEOUT);	if (IS_ERR(skb)) {		err = PTR_ERR(skb);		BT_ERR("%s: BCM: Download Minidrv command failed (%d)",		       hdev->name, err);		goto done;	}	kfree_skb(skb);	/* 50 msec delay after Download Minidrv completes */	msleep(50);	fw_ptr = fw->data;	fw_size = fw->size;	while (fw_size >= sizeof(*cmd)) {		const u8 *cmd_param;		cmd = (struct hci_command_hdr *)fw_ptr;		fw_ptr += sizeof(*cmd);		fw_size -= sizeof(*cmd);		if (fw_size < cmd->plen) {			BT_ERR("%s: BCM: Patch is corrupted", hdev->name);			err = -EINVAL;			goto done;		}		cmd_param = fw_ptr;		fw_ptr += cmd->plen;		fw_size -= cmd->plen;		opcode = le16_to_cpu(cmd->opcode);		skb = __hci_cmd_sync(hdev, opcode, cmd->plen, cmd_param,				     HCI_INIT_TIMEOUT);		if (IS_ERR(skb)) {			err = PTR_ERR(skb);			BT_ERR("%s: BCM: Patch command %04x failed (%d)",			       hdev->name, opcode, err);			goto done;		}		kfree_skb(skb);	}	/* 250 msec delay after Launch Ram completes */	msleep(250);done:	return err;}