tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Bluetooth: Use new hci_skb_pkt_* wrappers for drivers

The new hci_skb_pkt_* wrappers are mainly intented for drivers to
require less knowledge about bt_cb(sbk) handling. So after converting
the core packet handling, convert all drivers.

Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
Signed-off-by: Johan Hedberg <johan.hedberg@intel.com>

Marcel Holtmann 618e8bc2 d79f34e3

+127 -116
+5 -4
drivers/bluetooth/bfusb.c
··· 324 324 return -ENOMEM; 325 325 } 326 326 327 - bt_cb(skb)->pkt_type = pkt_type; 327 + hci_skb_pkt_type(skb) = pkt_type; 328 328 329 329 data->reassembly = skb; 330 330 } else { ··· 469 469 unsigned char buf[3]; 470 470 int sent = 0, size, count; 471 471 472 - BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, bt_cb(skb)->pkt_type, skb->len); 472 + BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, 473 + hci_skb_pkt_type(skb), skb->len); 473 474 474 - switch (bt_cb(skb)->pkt_type) { 475 + switch (hci_skb_pkt_type(skb)) { 475 476 case HCI_COMMAND_PKT: 476 477 hdev->stat.cmd_tx++; 477 478 break; ··· 485 484 } 486 485 487 486 /* Prepend skb with frame type */ 488 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 487 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 489 488 490 489 count = skb->len; 491 490
+13 -12
drivers/bluetooth/bluecard_cs.c
··· 261 261 if (!skb) 262 262 break; 263 263 264 - if (bt_cb(skb)->pkt_type & 0x80) { 264 + if (hci_skb_pkt_type(skb) & 0x80) { 265 265 /* Disable RTS */ 266 266 info->ctrl_reg |= REG_CONTROL_RTS; 267 267 outb(info->ctrl_reg, iobase + REG_CONTROL); ··· 279 279 /* Mark the buffer as dirty */ 280 280 clear_bit(ready_bit, &(info->tx_state)); 281 281 282 - if (bt_cb(skb)->pkt_type & 0x80) { 282 + if (hci_skb_pkt_type(skb) & 0x80) { 283 283 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 284 284 DEFINE_WAIT(wait); 285 285 286 286 unsigned char baud_reg; 287 287 288 - switch (bt_cb(skb)->pkt_type) { 288 + switch (hci_skb_pkt_type(skb)) { 289 289 case PKT_BAUD_RATE_460800: 290 290 baud_reg = REG_CONTROL_BAUD_RATE_460800; 291 291 break; ··· 402 402 403 403 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 404 404 405 - bt_cb(info->rx_skb)->pkt_type = buf[i]; 405 + hci_skb_pkt_type(info->rx_skb) = buf[i]; 406 406 407 - switch (bt_cb(info->rx_skb)->pkt_type) { 407 + switch (hci_skb_pkt_type(info->rx_skb)) { 408 408 409 409 case 0x00: 410 410 /* init packet */ ··· 436 436 437 437 default: 438 438 /* unknown packet */ 439 - BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 439 + BT_ERR("Unknown HCI packet with type 0x%02x received", 440 + hci_skb_pkt_type(info->rx_skb)); 440 441 info->hdev->stat.err_rx++; 441 442 442 443 kfree_skb(info->rx_skb); ··· 579 578 switch (baud) { 580 579 case 460800: 581 580 cmd[4] = 0x00; 582 - bt_cb(skb)->pkt_type = PKT_BAUD_RATE_460800; 581 + hci_skb_pkt_type(skb) = PKT_BAUD_RATE_460800; 583 582 break; 584 583 case 230400: 585 584 cmd[4] = 0x01; 586 - bt_cb(skb)->pkt_type = PKT_BAUD_RATE_230400; 585 + hci_skb_pkt_type(skb) = PKT_BAUD_RATE_230400; 587 586 break; 588 587 case 115200: 589 588 cmd[4] = 0x02; 590 - bt_cb(skb)->pkt_type = PKT_BAUD_RATE_115200; 589 + hci_skb_pkt_type(skb) = PKT_BAUD_RATE_115200; 591 590 break; 592 591 case 57600: 593 592 /* Fall through... */ 594 593 default: 595 594 cmd[4] = 0x03; 596 - bt_cb(skb)->pkt_type = PKT_BAUD_RATE_57600; 595 + hci_skb_pkt_type(skb) = PKT_BAUD_RATE_57600; 597 596 break; 598 597 } 599 598 ··· 661 660 { 662 661 struct bluecard_info *info = hci_get_drvdata(hdev); 663 662 664 - switch (bt_cb(skb)->pkt_type) { 663 + switch (hci_skb_pkt_type(skb)) { 665 664 case HCI_COMMAND_PKT: 666 665 hdev->stat.cmd_tx++; 667 666 break; ··· 674 673 } 675 674 676 675 /* Prepend skb with frame type */ 677 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 676 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 678 677 skb_queue_tail(&(info->txq), skb); 679 678 680 679 bluecard_write_wakeup(info);
+2 -2
drivers/bluetooth/bpa10x.c
··· 295 295 return -ENOMEM; 296 296 297 297 /* Prepend skb with frame type */ 298 - *skb_push(skb, 1) = bt_cb(skb)->pkt_type; 298 + *skb_push(skb, 1) = hci_skb_pkt_type(skb); 299 299 300 - switch (bt_cb(skb)->pkt_type) { 300 + switch (hci_skb_pkt_type(skb)) { 301 301 case HCI_COMMAND_PKT: 302 302 dr = kmalloc(sizeof(*dr), GFP_ATOMIC); 303 303 if (!dr) {
+6 -5
drivers/bluetooth/bt3c_cs.c
··· 246 246 247 247 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 248 248 249 - bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L); 249 + hci_skb_pkt_type(info->rx_skb) = inb(iobase + DATA_L); 250 250 inb(iobase + DATA_H); 251 251 252 - switch (bt_cb(info->rx_skb)->pkt_type) { 252 + switch (hci_skb_pkt_type(info->rx_skb)) { 253 253 254 254 case HCI_EVENT_PKT: 255 255 info->rx_state = RECV_WAIT_EVENT_HEADER; ··· 268 268 269 269 default: 270 270 /* Unknown packet */ 271 - BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 271 + BT_ERR("Unknown HCI packet with type 0x%02x received", 272 + hci_skb_pkt_type(info->rx_skb)); 272 273 info->hdev->stat.err_rx++; 273 274 274 275 kfree_skb(info->rx_skb); ··· 412 411 struct bt3c_info *info = hci_get_drvdata(hdev); 413 412 unsigned long flags; 414 413 415 - switch (bt_cb(skb)->pkt_type) { 414 + switch (hci_skb_pkt_type(skb)) { 416 415 case HCI_COMMAND_PKT: 417 416 hdev->stat.cmd_tx++; 418 417 break; ··· 425 424 } 426 425 427 426 /* Prepend skb with frame type */ 428 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 427 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 429 428 skb_queue_tail(&(info->txq), skb); 430 429 431 430 spin_lock_irqsave(&(info->lock), flags);
+4 -4
drivers/bluetooth/btmrvl_main.c
··· 196 196 if (len) 197 197 memcpy(skb_put(skb, len), param, len); 198 198 199 - bt_cb(skb)->pkt_type = MRVL_VENDOR_PKT; 199 + hci_skb_pkt_type(skb) = MRVL_VENDOR_PKT; 200 200 201 201 skb_queue_head(&priv->adapter->tx_queue, skb); 202 202 ··· 387 387 skb->data[0] = (skb->len & 0x0000ff); 388 388 skb->data[1] = (skb->len & 0x00ff00) >> 8; 389 389 skb->data[2] = (skb->len & 0xff0000) >> 16; 390 - skb->data[3] = bt_cb(skb)->pkt_type; 390 + skb->data[3] = hci_skb_pkt_type(skb); 391 391 392 392 if (priv->hw_host_to_card) 393 393 ret = priv->hw_host_to_card(priv, skb->data, skb->len); ··· 434 434 { 435 435 struct btmrvl_private *priv = hci_get_drvdata(hdev); 436 436 437 - BT_DBG("type=%d, len=%d", skb->pkt_type, skb->len); 437 + BT_DBG("type=%d, len=%d", hci_skb_pkt_type(skb), skb->len); 438 438 439 - switch (bt_cb(skb)->pkt_type) { 439 + switch (hci_skb_pkt_type(skb)) { 440 440 case HCI_COMMAND_PKT: 441 441 hdev->stat.cmd_tx++; 442 442 break;
+2 -2
drivers/bluetooth/btmrvl_sdio.c
··· 698 698 case HCI_ACLDATA_PKT: 699 699 case HCI_SCODATA_PKT: 700 700 case HCI_EVENT_PKT: 701 - bt_cb(skb)->pkt_type = type; 701 + hci_skb_pkt_type(skb) = type; 702 702 skb_put(skb, buf_len); 703 703 skb_pull(skb, SDIO_HEADER_LEN); 704 704 ··· 713 713 break; 714 714 715 715 case MRVL_VENDOR_PKT: 716 - bt_cb(skb)->pkt_type = HCI_VENDOR_PKT; 716 + hci_skb_pkt_type(skb) = HCI_VENDOR_PKT; 717 717 skb_put(skb, buf_len); 718 718 skb_pull(skb, SDIO_HEADER_LEN); 719 719
+3 -3
drivers/bluetooth/btsdio.c
··· 86 86 skb->data[0] = (skb->len & 0x0000ff); 87 87 skb->data[1] = (skb->len & 0x00ff00) >> 8; 88 88 skb->data[2] = (skb->len & 0xff0000) >> 16; 89 - skb->data[3] = bt_cb(skb)->pkt_type; 89 + skb->data[3] = hci_skb_pkt_type(skb); 90 90 91 91 err = sdio_writesb(data->func, REG_TDAT, skb->data, skb->len); 92 92 if (err < 0) { ··· 158 158 159 159 data->hdev->stat.byte_rx += len; 160 160 161 - bt_cb(skb)->pkt_type = hdr[3]; 161 + hci_skb_pkt_type(skb) = hdr[3]; 162 162 163 163 err = hci_recv_frame(data->hdev, skb); 164 164 if (err < 0) ··· 252 252 253 253 BT_DBG("%s", hdev->name); 254 254 255 - switch (bt_cb(skb)->pkt_type) { 255 + switch (hci_skb_pkt_type(skb)) { 256 256 case HCI_COMMAND_PKT: 257 257 hdev->stat.cmd_tx++; 258 258 break;
+6 -5
drivers/bluetooth/btuart_cs.c
··· 200 200 201 201 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 202 202 203 - bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX); 203 + hci_skb_pkt_type(info->rx_skb) = inb(iobase + UART_RX); 204 204 205 - switch (bt_cb(info->rx_skb)->pkt_type) { 205 + switch (hci_skb_pkt_type(info->rx_skb)) { 206 206 207 207 case HCI_EVENT_PKT: 208 208 info->rx_state = RECV_WAIT_EVENT_HEADER; ··· 221 221 222 222 default: 223 223 /* Unknown packet */ 224 - BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 224 + BT_ERR("Unknown HCI packet with type 0x%02x received", 225 + hci_skb_pkt_type(info->rx_skb)); 225 226 info->hdev->stat.err_rx++; 226 227 227 228 kfree_skb(info->rx_skb); ··· 425 424 { 426 425 struct btuart_info *info = hci_get_drvdata(hdev); 427 426 428 - switch (bt_cb(skb)->pkt_type) { 427 + switch (hci_skb_pkt_type(skb)) { 429 428 case HCI_COMMAND_PKT: 430 429 hdev->stat.cmd_tx++; 431 430 break; ··· 438 437 } 439 438 440 439 /* Prepend skb with frame type */ 441 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 440 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 442 441 skb_queue_tail(&(info->txq), skb); 443 442 444 443 btuart_write_wakeup(info);
+24 -24
drivers/bluetooth/btusb.c
··· 437 437 break; 438 438 } 439 439 440 - bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 441 - bt_cb(skb)->expect = HCI_EVENT_HDR_SIZE; 440 + hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 441 + hci_skb_expect(skb) = HCI_EVENT_HDR_SIZE; 442 442 } 443 443 444 - len = min_t(uint, bt_cb(skb)->expect, count); 444 + len = min_t(uint, hci_skb_expect(skb), count); 445 445 memcpy(skb_put(skb, len), buffer, len); 446 446 447 447 count -= len; 448 448 buffer += len; 449 - bt_cb(skb)->expect -= len; 449 + hci_skb_expect(skb) -= len; 450 450 451 451 if (skb->len == HCI_EVENT_HDR_SIZE) { 452 452 /* Complete event header */ 453 - bt_cb(skb)->expect = hci_event_hdr(skb)->plen; 453 + hci_skb_expect(skb) = hci_event_hdr(skb)->plen; 454 454 455 - if (skb_tailroom(skb) < bt_cb(skb)->expect) { 455 + if (skb_tailroom(skb) < hci_skb_expect(skb)) { 456 456 kfree_skb(skb); 457 457 skb = NULL; 458 458 ··· 461 461 } 462 462 } 463 463 464 - if (bt_cb(skb)->expect == 0) { 464 + if (!hci_skb_expect(skb)) { 465 465 /* Complete frame */ 466 466 data->recv_event(data->hdev, skb); 467 467 skb = NULL; ··· 492 492 break; 493 493 } 494 494 495 - bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 496 - bt_cb(skb)->expect = HCI_ACL_HDR_SIZE; 495 + hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 496 + hci_skb_expect(skb) = HCI_ACL_HDR_SIZE; 497 497 } 498 498 499 - len = min_t(uint, bt_cb(skb)->expect, count); 499 + len = min_t(uint, hci_skb_expect(skb), count); 500 500 memcpy(skb_put(skb, len), buffer, len); 501 501 502 502 count -= len; 503 503 buffer += len; 504 - bt_cb(skb)->expect -= len; 504 + hci_skb_expect(skb) -= len; 505 505 506 506 if (skb->len == HCI_ACL_HDR_SIZE) { 507 507 __le16 dlen = hci_acl_hdr(skb)->dlen; 508 508 509 509 /* Complete ACL header */ 510 - bt_cb(skb)->expect = __le16_to_cpu(dlen); 510 + hci_skb_expect(skb) = __le16_to_cpu(dlen); 511 511 512 - if (skb_tailroom(skb) < bt_cb(skb)->expect) { 512 + if (skb_tailroom(skb) < hci_skb_expect(skb)) { 513 513 kfree_skb(skb); 514 514 skb = NULL; 515 515 ··· 518 518 } 519 519 } 520 520 521 - if (bt_cb(skb)->expect == 0) { 521 + if (!hci_skb_expect(skb)) { 522 522 /* Complete frame */ 523 523 hci_recv_frame(data->hdev, skb); 524 524 skb = NULL; ··· 549 549 break; 550 550 } 551 551 552 - bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 553 - bt_cb(skb)->expect = HCI_SCO_HDR_SIZE; 552 + hci_skb_pkt_type(skb) = HCI_SCODATA_PKT; 553 + hci_skb_expect(skb) = HCI_SCO_HDR_SIZE; 554 554 } 555 555 556 - len = min_t(uint, bt_cb(skb)->expect, count); 556 + len = min_t(uint, hci_skb_expect(skb), count); 557 557 memcpy(skb_put(skb, len), buffer, len); 558 558 559 559 count -= len; 560 560 buffer += len; 561 - bt_cb(skb)->expect -= len; 561 + hci_skb_expect(skb) -= len; 562 562 563 563 if (skb->len == HCI_SCO_HDR_SIZE) { 564 564 /* Complete SCO header */ 565 - bt_cb(skb)->expect = hci_sco_hdr(skb)->dlen; 565 + hci_skb_expect(skb) = hci_sco_hdr(skb)->dlen; 566 566 567 - if (skb_tailroom(skb) < bt_cb(skb)->expect) { 567 + if (skb_tailroom(skb) < hci_skb_expect(skb)) { 568 568 kfree_skb(skb); 569 569 skb = NULL; 570 570 ··· 573 573 } 574 574 } 575 575 576 - if (bt_cb(skb)->expect == 0) { 576 + if (!hci_skb_expect(skb)) { 577 577 /* Complete frame */ 578 578 hci_recv_frame(data->hdev, skb); 579 579 skb = NULL; ··· 1257 1257 1258 1258 BT_DBG("%s", hdev->name); 1259 1259 1260 - switch (bt_cb(skb)->pkt_type) { 1260 + switch (hci_skb_pkt_type(skb)) { 1261 1261 case HCI_COMMAND_PKT: 1262 1262 urb = alloc_ctrl_urb(hdev, skb); 1263 1263 if (IS_ERR(urb)) ··· 1853 1853 1854 1854 *skb_put(skb, 1) = 0x00; 1855 1855 1856 - bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 1856 + hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 1857 1857 1858 1858 return hci_recv_frame(hdev, skb); 1859 1859 } ··· 1945 1945 1946 1946 BT_DBG("%s", hdev->name); 1947 1947 1948 - switch (bt_cb(skb)->pkt_type) { 1948 + switch (hci_skb_pkt_type(skb)) { 1949 1949 case HCI_COMMAND_PKT: 1950 1950 if (test_bit(BTUSB_BOOTLOADER, &data->flags)) { 1951 1951 struct hci_command_hdr *cmd = (void *)skb->data;
+4 -4
drivers/bluetooth/btwilink.c
··· 249 249 hst = hci_get_drvdata(hdev); 250 250 251 251 /* Prepend skb with frame type */ 252 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 252 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 253 253 254 - BT_DBG("%s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type, 255 - skb->len); 254 + BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb), 255 + skb->len); 256 256 257 257 /* Insert skb to shared transport layer's transmit queue. 258 258 * Freeing skb memory is taken care in shared transport layer, ··· 268 268 269 269 /* ST accepted our skb. So, Go ahead and do rest */ 270 270 hdev->stat.byte_tx += len; 271 - ti_st_tx_complete(hst, bt_cb(skb)->pkt_type); 271 + ti_st_tx_complete(hst, hci_skb_pkt_type(skb)); 272 272 273 273 return 0; 274 274 }
+6 -5
drivers/bluetooth/dtl1_cs.c
··· 239 239 info->rx_count = nsh->len + (nsh->len & 0x0001); 240 240 break; 241 241 case RECV_WAIT_DATA: 242 - bt_cb(info->rx_skb)->pkt_type = nsh->type; 242 + hci_skb_pkt_type(info->rx_skb) = nsh->type; 243 243 244 244 /* remove PAD byte if it exists */ 245 245 if (nsh->len & 0x0001) { ··· 250 250 /* remove NSH */ 251 251 skb_pull(info->rx_skb, NSHL); 252 252 253 - switch (bt_cb(info->rx_skb)->pkt_type) { 253 + switch (hci_skb_pkt_type(info->rx_skb)) { 254 254 case 0x80: 255 255 /* control data for the Nokia Card */ 256 256 dtl1_control(info, info->rx_skb); ··· 259 259 case 0x83: 260 260 case 0x84: 261 261 /* send frame to the HCI layer */ 262 - bt_cb(info->rx_skb)->pkt_type &= 0x0f; 262 + hci_skb_pkt_type(info->rx_skb) &= 0x0f; 263 263 hci_recv_frame(info->hdev, info->rx_skb); 264 264 break; 265 265 default: 266 266 /* unknown packet */ 267 - BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 267 + BT_ERR("Unknown HCI packet with type 0x%02x received", 268 + hci_skb_pkt_type(info->rx_skb)); 268 269 kfree_skb(info->rx_skb); 269 270 break; 270 271 } ··· 387 386 struct sk_buff *s; 388 387 struct nsh nsh; 389 388 390 - switch (bt_cb(skb)->pkt_type) { 389 + switch (hci_skb_pkt_type(skb)) { 391 390 case HCI_COMMAND_PKT: 392 391 hdev->stat.cmd_tx++; 393 392 nsh.type = 0x81;
+3 -3
drivers/bluetooth/hci_ath.c
··· 205 205 { 206 206 struct ath_struct *ath = hu->priv; 207 207 208 - if (bt_cb(skb)->pkt_type == HCI_SCODATA_PKT) { 208 + if (hci_skb_pkt_type(skb) == HCI_SCODATA_PKT) { 209 209 kfree_skb(skb); 210 210 return 0; 211 211 } ··· 213 213 /* Update power management enable flag with parameters of 214 214 * HCI sleep enable vendor specific HCI command. 215 215 */ 216 - if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) { 216 + if (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT) { 217 217 struct hci_command_hdr *hdr = (void *)skb->data; 218 218 219 219 if (__le16_to_cpu(hdr->opcode) == HCI_OP_ATH_SLEEP) ··· 223 223 BT_DBG("hu %p skb %p", hu, skb); 224 224 225 225 /* Prepend skb with frame type */ 226 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 226 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 227 227 228 228 skb_queue_tail(&ath->txq, skb); 229 229 set_bit(HCI_UART_SENDING, &hu->tx_state);
+1 -1
drivers/bluetooth/hci_bcm.c
··· 472 472 bt_dev_dbg(hu->hdev, "hu %p skb %p", hu, skb); 473 473 474 474 /* Prepend skb with frame type */ 475 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 475 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 476 476 skb_queue_tail(&bcm->txq, skb); 477 477 478 478 return 0;
+15 -10
drivers/bluetooth/hci_bcsp.c
··· 155 155 return 0; 156 156 } 157 157 158 - switch (bt_cb(skb)->pkt_type) { 158 + switch (hci_skb_pkt_type(skb)) { 159 159 case HCI_ACLDATA_PKT: 160 160 case HCI_COMMAND_PKT: 161 161 skb_queue_tail(&bcsp->rel, skb); ··· 231 231 if (!nskb) 232 232 return NULL; 233 233 234 - bt_cb(nskb)->pkt_type = pkt_type; 234 + hci_skb_pkt_type(nskb) = pkt_type; 235 235 236 236 bcsp_slip_msgdelim(nskb); 237 237 ··· 291 291 292 292 skb = skb_dequeue(&bcsp->unrel); 293 293 if (skb != NULL) { 294 - struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, bt_cb(skb)->pkt_type); 294 + struct sk_buff *nskb; 295 + 296 + nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, 297 + hci_skb_pkt_type(skb)); 295 298 if (nskb) { 296 299 kfree_skb(skb); 297 300 return nskb; ··· 313 310 if (bcsp->unack.qlen < BCSP_TXWINSIZE) { 314 311 skb = skb_dequeue(&bcsp->rel); 315 312 if (skb != NULL) { 316 - struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, 317 - bt_cb(skb)->pkt_type); 313 + struct sk_buff *nskb; 314 + 315 + nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, 316 + hci_skb_pkt_type(skb)); 318 317 if (nskb) { 319 318 __skb_queue_tail(&bcsp->unack, skb); 320 319 mod_timer(&bcsp->tbcsp, jiffies + HZ / 4); ··· 417 412 if (!nskb) 418 413 return; 419 414 memcpy(skb_put(nskb, 4), conf_rsp_pkt, 4); 420 - bt_cb(nskb)->pkt_type = BCSP_LE_PKT; 415 + hci_skb_pkt_type(nskb) = BCSP_LE_PKT; 421 416 422 417 skb_queue_head(&bcsp->unrel, nskb); 423 418 hci_uart_tx_wakeup(hu); ··· 499 494 bcsp_pkt_cull(bcsp); 500 495 if ((bcsp->rx_skb->data[1] & 0x0f) == 6 && 501 496 bcsp->rx_skb->data[0] & 0x80) { 502 - bt_cb(bcsp->rx_skb)->pkt_type = HCI_ACLDATA_PKT; 497 + hci_skb_pkt_type(bcsp->rx_skb) = HCI_ACLDATA_PKT; 503 498 pass_up = 1; 504 499 } else if ((bcsp->rx_skb->data[1] & 0x0f) == 5 && 505 500 bcsp->rx_skb->data[0] & 0x80) { 506 - bt_cb(bcsp->rx_skb)->pkt_type = HCI_EVENT_PKT; 501 + hci_skb_pkt_type(bcsp->rx_skb) = HCI_EVENT_PKT; 507 502 pass_up = 1; 508 503 } else if ((bcsp->rx_skb->data[1] & 0x0f) == 7) { 509 - bt_cb(bcsp->rx_skb)->pkt_type = HCI_SCODATA_PKT; 504 + hci_skb_pkt_type(bcsp->rx_skb) = HCI_SCODATA_PKT; 510 505 pass_up = 1; 511 506 } else if ((bcsp->rx_skb->data[1] & 0x0f) == 1 && 512 507 !(bcsp->rx_skb->data[0] & 0x80)) { ··· 528 523 hdr.evt = 0xff; 529 524 hdr.plen = bcsp->rx_skb->len; 530 525 memcpy(skb_push(bcsp->rx_skb, HCI_EVENT_HDR_SIZE), &hdr, HCI_EVENT_HDR_SIZE); 531 - bt_cb(bcsp->rx_skb)->pkt_type = HCI_EVENT_PKT; 526 + hci_skb_pkt_type(bcsp->rx_skb) = HCI_EVENT_PKT; 532 527 533 528 hci_recv_frame(hu->hdev, bcsp->rx_skb); 534 529 } else {
+8 -8
drivers/bluetooth/hci_h4.c
··· 108 108 BT_DBG("hu %p skb %p", hu, skb); 109 109 110 110 /* Prepend skb with frame type */ 111 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 111 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 112 112 skb_queue_tail(&h4->txq, skb); 113 113 114 114 return 0; ··· 184 184 if (!skb) 185 185 return ERR_PTR(-ENOMEM); 186 186 187 - bt_cb(skb)->pkt_type = (&pkts[i])->type; 188 - bt_cb(skb)->expect = (&pkts[i])->hlen; 187 + hci_skb_pkt_type(skb) = (&pkts[i])->type; 188 + hci_skb_expect(skb) = (&pkts[i])->hlen; 189 189 break; 190 190 } 191 191 ··· 197 197 buffer += 1; 198 198 } 199 199 200 - len = min_t(uint, bt_cb(skb)->expect - skb->len, count); 200 + len = min_t(uint, hci_skb_expect(skb) - skb->len, count); 201 201 memcpy(skb_put(skb, len), buffer, len); 202 202 203 203 count -= len; 204 204 buffer += len; 205 205 206 206 /* Check for partial packet */ 207 - if (skb->len < bt_cb(skb)->expect) 207 + if (skb->len < hci_skb_expect(skb)) 208 208 continue; 209 209 210 210 for (i = 0; i < pkts_count; i++) { 211 - if (bt_cb(skb)->pkt_type == (&pkts[i])->type) 211 + if (hci_skb_pkt_type(skb) == (&pkts[i])->type) 212 212 break; 213 213 } 214 214 ··· 228 228 case 1: 229 229 /* Single octet variable length */ 230 230 dlen = skb->data[(&pkts[i])->loff]; 231 - bt_cb(skb)->expect += dlen; 231 + hci_skb_expect(skb) += dlen; 232 232 233 233 if (skb_tailroom(skb) < dlen) { 234 234 kfree_skb(skb); ··· 239 239 /* Double octet variable length */ 240 240 dlen = get_unaligned_le16(skb->data + 241 241 (&pkts[i])->loff); 242 - bt_cb(skb)->expect += dlen; 242 + hci_skb_expect(skb) += dlen; 243 243 244 244 if (skb_tailroom(skb) < dlen) { 245 245 kfree_skb(skb);
+7 -7
drivers/bluetooth/hci_h5.c
··· 107 107 if (!nskb) 108 108 return; 109 109 110 - bt_cb(nskb)->pkt_type = HCI_3WIRE_LINK_PKT; 110 + hci_skb_pkt_type(nskb) = HCI_3WIRE_LINK_PKT; 111 111 112 112 memcpy(skb_put(nskb, len), data, len); 113 113 ··· 360 360 case HCI_EVENT_PKT: 361 361 case HCI_ACLDATA_PKT: 362 362 case HCI_SCODATA_PKT: 363 - bt_cb(h5->rx_skb)->pkt_type = H5_HDR_PKT_TYPE(hdr); 363 + hci_skb_pkt_type(h5->rx_skb) = H5_HDR_PKT_TYPE(hdr); 364 364 365 365 /* Remove Three-wire header */ 366 366 skb_pull(h5->rx_skb, 4); ··· 562 562 return 0; 563 563 } 564 564 565 - switch (bt_cb(skb)->pkt_type) { 565 + switch (hci_skb_pkt_type(skb)) { 566 566 case HCI_ACLDATA_PKT: 567 567 case HCI_COMMAND_PKT: 568 568 skb_queue_tail(&h5->rel, skb); ··· 573 573 break; 574 574 575 575 default: 576 - BT_ERR("Unknown packet type %u", bt_cb(skb)->pkt_type); 576 + BT_ERR("Unknown packet type %u", hci_skb_pkt_type(skb)); 577 577 kfree_skb(skb); 578 578 break; 579 579 } ··· 642 642 if (!nskb) 643 643 return NULL; 644 644 645 - bt_cb(nskb)->pkt_type = pkt_type; 645 + hci_skb_pkt_type(nskb) = pkt_type; 646 646 647 647 h5_slip_delim(nskb); 648 648 ··· 697 697 698 698 skb = skb_dequeue(&h5->unrel); 699 699 if (skb) { 700 - nskb = h5_prepare_pkt(hu, bt_cb(skb)->pkt_type, 700 + nskb = h5_prepare_pkt(hu, hci_skb_pkt_type(skb), 701 701 skb->data, skb->len); 702 702 if (nskb) { 703 703 kfree_skb(skb); ··· 715 715 716 716 skb = skb_dequeue(&h5->rel); 717 717 if (skb) { 718 - nskb = h5_prepare_pkt(hu, bt_cb(skb)->pkt_type, 718 + nskb = h5_prepare_pkt(hu, hci_skb_pkt_type(skb), 719 719 skb->data, skb->len); 720 720 if (nskb) { 721 721 __skb_queue_tail(&h5->unack, skb);
+7 -7
drivers/bluetooth/hci_intel.c
··· 186 186 } 187 187 188 188 memcpy(skb_put(skb, sizeof(suspend)), suspend, sizeof(suspend)); 189 - bt_cb(skb)->pkt_type = HCI_LPM_PKT; 189 + hci_skb_pkt_type(skb) = HCI_LPM_PKT; 190 190 191 191 set_bit(STATE_LPM_TRANSACTION, &intel->flags); 192 192 ··· 230 230 return -ENOMEM; 231 231 } 232 232 233 - bt_cb(skb)->pkt_type = HCI_LPM_WAKE_PKT; 233 + hci_skb_pkt_type(skb) = HCI_LPM_WAKE_PKT; 234 234 235 235 set_bit(STATE_LPM_TRANSACTION, &intel->flags); 236 236 ··· 272 272 273 273 memcpy(skb_put(skb, sizeof(lpm_resume_ack)), lpm_resume_ack, 274 274 sizeof(lpm_resume_ack)); 275 - bt_cb(skb)->pkt_type = HCI_LPM_PKT; 275 + hci_skb_pkt_type(skb) = HCI_LPM_PKT; 276 276 277 277 /* LPM flow is a priority, enqueue packet at list head */ 278 278 skb_queue_head(&intel->txq, skb); ··· 467 467 468 468 *skb_put(skb, 1) = 0x00; 469 469 470 - bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 470 + hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 471 471 472 472 return hci_recv_frame(hdev, skb); 473 473 } ··· 517 517 } 518 518 519 519 memcpy(skb_put(skb, sizeof(speed_cmd)), speed_cmd, sizeof(speed_cmd)); 520 - bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 520 + hci_skb_pkt_type(skb) = HCI_COMMAND_PKT; 521 521 522 522 hci_uart_set_flow_control(hu, true); 523 523 ··· 1126 1126 return skb; 1127 1127 1128 1128 if (test_bit(STATE_BOOTLOADER, &intel->flags) && 1129 - (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT)) { 1129 + (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT)) { 1130 1130 struct hci_command_hdr *cmd = (void *)skb->data; 1131 1131 __u16 opcode = le16_to_cpu(cmd->opcode); 1132 1132 ··· 1140 1140 } 1141 1141 1142 1142 /* Prepend skb with frame type */ 1143 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 1143 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 1144 1144 1145 1145 return skb; 1146 1146 }
+3 -2
drivers/bluetooth/hci_ldisc.c
··· 162 162 break; 163 163 } 164 164 165 - hci_uart_tx_complete(hu, bt_cb(skb)->pkt_type); 165 + hci_uart_tx_complete(hu, hci_skb_pkt_type(skb)); 166 166 kfree_skb(skb); 167 167 } 168 168 ··· 248 248 { 249 249 struct hci_uart *hu = hci_get_drvdata(hdev); 250 250 251 - BT_DBG("%s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 251 + BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb), 252 + skb->len); 252 253 253 254 hu->proto->enqueue(hu, skb); 254 255
+2 -2
drivers/bluetooth/hci_ll.c
··· 307 307 BT_DBG("hu %p skb %p", hu, skb); 308 308 309 309 /* Prepend skb with frame type */ 310 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 310 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 311 311 312 312 /* lock hcill state */ 313 313 spin_lock_irqsave(&ll->hcill_lock, flags); ··· 493 493 return -ENOMEM; 494 494 } 495 495 496 - bt_cb(ll->rx_skb)->pkt_type = type; 496 + hci_skb_pkt_type(ll->rx_skb) = type; 497 497 } 498 498 499 499 return count;
+2 -2
drivers/bluetooth/hci_qca.c
··· 678 678 qca->tx_ibs_state); 679 679 680 680 /* Prepend skb with frame type */ 681 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 681 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 682 682 683 683 /* Don't go to sleep in middle of patch download or 684 684 * Out-Of-Band(GPIOs control) sleep is selected. ··· 873 873 874 874 /* Assign commands to change baudrate and packet type. */ 875 875 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd)); 876 - bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 876 + hci_skb_pkt_type(skb) = HCI_COMMAND_PKT; 877 877 878 878 skb_queue_tail(&qca->txq, skb); 879 879 hci_uart_tx_wakeup(hu);
+4 -4
drivers/bluetooth/hci_vhci.c
··· 80 80 { 81 81 struct vhci_data *data = hci_get_drvdata(hdev); 82 82 83 - memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 83 + memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 84 84 skb_queue_tail(&data->readq, skb); 85 85 86 86 wake_up_interruptible(&data->read_wait); ··· 140 140 return -EBUSY; 141 141 } 142 142 143 - bt_cb(skb)->pkt_type = HCI_VENDOR_PKT; 143 + hci_skb_pkt_type(skb) = HCI_VENDOR_PKT; 144 144 145 145 *skb_put(skb, 1) = 0xff; 146 146 *skb_put(skb, 1) = opcode; ··· 183 183 return -ENODEV; 184 184 } 185 185 186 - bt_cb(skb)->pkt_type = pkt_type; 186 + hci_skb_pkt_type(skb) = pkt_type; 187 187 188 188 ret = hci_recv_frame(data->hdev, skb); 189 189 break; ··· 234 234 235 235 data->hdev->stat.byte_tx += len; 236 236 237 - switch (bt_cb(skb)->pkt_type) { 237 + switch (hci_skb_pkt_type(skb)) { 238 238 case HCI_COMMAND_PKT: 239 239 data->hdev->stat.cmd_tx++; 240 240 break;