1 /* 2 * 3 * Bluetooth HCI UART driver for Broadcom devices 4 * 5 * Copyright (C) 2015 Intel Corporation 6 * 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24 #include <linux/kernel.h> 25 #include <linux/errno.h> 26 #include <linux/skbuff.h> 27 #include <linux/firmware.h> 28 #include <linux/module.h> 29 #include <linux/acpi.h> 30 #include <linux/platform_device.h> 31 #include <linux/clk.h> 32 #include <linux/gpio/consumer.h> 33 #include <linux/tty.h> 34 35 #include <net/bluetooth/bluetooth.h> 36 #include <net/bluetooth/hci_core.h> 37 38 #include "btbcm.h" 39 #include "hci_uart.h" 40 41 struct bcm_device { 42 struct list_head list; 43 44 struct platform_device *pdev; 45 46 const char *name; 47 struct gpio_desc *device_wakeup; 48 struct gpio_desc *shutdown; 49 50 struct clk *clk; 51 bool clk_enabled; 52 53 u32 init_speed; 54 55 #ifdef CONFIG_PM_SLEEP 56 struct hci_uart *hu; 57 bool is_suspended; /* suspend/resume flag */ 58 #endif 59 }; 60 61 struct bcm_data { 62 struct sk_buff *rx_skb; 63 struct sk_buff_head txq; 64 65 struct bcm_device *dev; 66 }; 67 68 /* List of BCM BT UART devices */ 69 static DEFINE_SPINLOCK(bcm_device_lock); 70 static LIST_HEAD(bcm_device_list); 71 72 static int bcm_set_baudrate(struct hci_uart *hu, unsigned int speed) 73 { 74 struct hci_dev *hdev = hu->hdev; 75 struct sk_buff *skb; 76 struct bcm_update_uart_baud_rate param; 77 78 if (speed > 3000000) { 79 struct bcm_write_uart_clock_setting clock; 80 81 clock.type = BCM_UART_CLOCK_48MHZ; 82 83 BT_DBG("%s: Set Controller clock (%d)", hdev->name, clock.type); 84 85 /* This Broadcom specific command changes the UART's controller 86 * clock for baud rate > 3000000. 87 */ 88 skb = __hci_cmd_sync(hdev, 0xfc45, 1, &clock, HCI_INIT_TIMEOUT); 89 if (IS_ERR(skb)) { 90 int err = PTR_ERR(skb); 91 BT_ERR("%s: BCM: failed to write clock command (%d)", 92 hdev->name, err); 93 return err; 94 } 95 96 kfree_skb(skb); 97 } 98 99 BT_DBG("%s: Set Controller UART speed to %d bit/s", hdev->name, speed); 100 101 param.zero = cpu_to_le16(0); 102 param.baud_rate = cpu_to_le32(speed); 103 104 /* This Broadcom specific command changes the UART's controller baud 105 * rate. 106 */ 107 skb = __hci_cmd_sync(hdev, 0xfc18, sizeof(param), ¶m, 108 HCI_INIT_TIMEOUT); 109 if (IS_ERR(skb)) { 110 int err = PTR_ERR(skb); 111 BT_ERR("%s: BCM: failed to write update baudrate command (%d)", 112 hdev->name, err); 113 return err; 114 } 115 116 kfree_skb(skb); 117 118 return 0; 119 } 120 121 /* bcm_device_exists should be protected by bcm_device_lock */ 122 static bool bcm_device_exists(struct bcm_device *device) 123 { 124 struct list_head *p; 125 126 list_for_each(p, &bcm_device_list) { 127 struct bcm_device *dev = list_entry(p, struct bcm_device, list); 128 129 if (device == dev) 130 return true; 131 } 132 133 return false; 134 } 135 136 static int bcm_gpio_set_power(struct bcm_device *dev, bool powered) 137 { 138 if (powered && !IS_ERR(dev->clk) && !dev->clk_enabled) 139 clk_enable(dev->clk); 140 141 gpiod_set_value(dev->shutdown, powered); 142 gpiod_set_value(dev->device_wakeup, powered); 143 144 if (!powered && !IS_ERR(dev->clk) && dev->clk_enabled) 145 clk_disable(dev->clk); 146 147 dev->clk_enabled = powered; 148 149 return 0; 150 } 151 152 static int bcm_open(struct hci_uart *hu) 153 { 154 struct bcm_data *bcm; 155 struct list_head *p; 156 157 BT_DBG("hu %p", hu); 158 159 bcm = kzalloc(sizeof(*bcm), GFP_KERNEL); 160 if (!bcm) 161 return -ENOMEM; 162 163 skb_queue_head_init(&bcm->txq); 164 165 hu->priv = bcm; 166 167 spin_lock(&bcm_device_lock); 168 list_for_each(p, &bcm_device_list) { 169 struct bcm_device *dev = list_entry(p, struct bcm_device, list); 170 171 /* Retrieve saved bcm_device based on parent of the 172 * platform device (saved during device probe) and 173 * parent of tty device used by hci_uart 174 */ 175 if (hu->tty->dev->parent == dev->pdev->dev.parent) { 176 bcm->dev = dev; 177 hu->init_speed = dev->init_speed; 178 #ifdef CONFIG_PM_SLEEP 179 dev->hu = hu; 180 #endif 181 break; 182 } 183 } 184 185 if (bcm->dev) 186 bcm_gpio_set_power(bcm->dev, true); 187 188 spin_unlock(&bcm_device_lock); 189 190 return 0; 191 } 192 193 static int bcm_close(struct hci_uart *hu) 194 { 195 struct bcm_data *bcm = hu->priv; 196 197 BT_DBG("hu %p", hu); 198 199 /* Protect bcm->dev against removal of the device or driver */ 200 spin_lock(&bcm_device_lock); 201 if (bcm_device_exists(bcm->dev)) { 202 bcm_gpio_set_power(bcm->dev, false); 203 #ifdef CONFIG_PM_SLEEP 204 bcm->dev->hu = NULL; 205 #endif 206 } 207 spin_unlock(&bcm_device_lock); 208 209 skb_queue_purge(&bcm->txq); 210 kfree_skb(bcm->rx_skb); 211 kfree(bcm); 212 213 hu->priv = NULL; 214 return 0; 215 } 216 217 static int bcm_flush(struct hci_uart *hu) 218 { 219 struct bcm_data *bcm = hu->priv; 220 221 BT_DBG("hu %p", hu); 222 223 skb_queue_purge(&bcm->txq); 224 225 return 0; 226 } 227 228 static int bcm_setup(struct hci_uart *hu) 229 { 230 char fw_name[64]; 231 const struct firmware *fw; 232 unsigned int speed; 233 int err; 234 235 BT_DBG("hu %p", hu); 236 237 hu->hdev->set_bdaddr = btbcm_set_bdaddr; 238 239 err = btbcm_initialize(hu->hdev, fw_name, sizeof(fw_name)); 240 if (err) 241 return err; 242 243 err = request_firmware(&fw, fw_name, &hu->hdev->dev); 244 if (err < 0) { 245 BT_INFO("%s: BCM: Patch %s not found", hu->hdev->name, fw_name); 246 return 0; 247 } 248 249 err = btbcm_patchram(hu->hdev, fw); 250 if (err) { 251 BT_INFO("%s: BCM: Patch failed (%d)", hu->hdev->name, err); 252 goto finalize; 253 } 254 255 /* Init speed if any */ 256 if (hu->init_speed) 257 speed = hu->init_speed; 258 else if (hu->proto->init_speed) 259 speed = hu->proto->init_speed; 260 else 261 speed = 0; 262 263 if (speed) 264 hci_uart_set_baudrate(hu, speed); 265 266 /* Operational speed if any */ 267 if (hu->oper_speed) 268 speed = hu->oper_speed; 269 else if (hu->proto->oper_speed) 270 speed = hu->proto->oper_speed; 271 else 272 speed = 0; 273 274 if (speed) { 275 err = bcm_set_baudrate(hu, speed); 276 if (!err) 277 hci_uart_set_baudrate(hu, speed); 278 } 279 280 finalize: 281 release_firmware(fw); 282 283 err = btbcm_finalize(hu->hdev); 284 285 return err; 286 } 287 288 static const struct h4_recv_pkt bcm_recv_pkts[] = { 289 { H4_RECV_ACL, .recv = hci_recv_frame }, 290 { H4_RECV_SCO, .recv = hci_recv_frame }, 291 { H4_RECV_EVENT, .recv = hci_recv_frame }, 292 }; 293 294 static int bcm_recv(struct hci_uart *hu, const void *data, int count) 295 { 296 struct bcm_data *bcm = hu->priv; 297 298 if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 299 return -EUNATCH; 300 301 bcm->rx_skb = h4_recv_buf(hu->hdev, bcm->rx_skb, data, count, 302 bcm_recv_pkts, ARRAY_SIZE(bcm_recv_pkts)); 303 if (IS_ERR(bcm->rx_skb)) { 304 int err = PTR_ERR(bcm->rx_skb); 305 BT_ERR("%s: Frame reassembly failed (%d)", hu->hdev->name, err); 306 bcm->rx_skb = NULL; 307 return err; 308 } 309 310 return count; 311 } 312 313 static int bcm_enqueue(struct hci_uart *hu, struct sk_buff *skb) 314 { 315 struct bcm_data *bcm = hu->priv; 316 317 BT_DBG("hu %p skb %p", hu, skb); 318 319 /* Prepend skb with frame type */ 320 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 321 skb_queue_tail(&bcm->txq, skb); 322 323 return 0; 324 } 325 326 static struct sk_buff *bcm_dequeue(struct hci_uart *hu) 327 { 328 struct bcm_data *bcm = hu->priv; 329 330 return skb_dequeue(&bcm->txq); 331 } 332 333 #ifdef CONFIG_PM_SLEEP 334 /* Platform suspend callback */ 335 static int bcm_suspend(struct device *dev) 336 { 337 struct bcm_device *bdev = platform_get_drvdata(to_platform_device(dev)); 338 339 BT_DBG("suspend (%p): is_suspended %d", bdev, bdev->is_suspended); 340 341 spin_lock(&bcm_device_lock); 342 343 if (!bdev->hu) 344 goto unlock; 345 346 if (!bdev->is_suspended) { 347 hci_uart_set_flow_control(bdev->hu, true); 348 349 /* Once this callback returns, driver suspends BT via GPIO */ 350 bdev->is_suspended = true; 351 } 352 353 /* Suspend the device */ 354 if (bdev->device_wakeup) { 355 gpiod_set_value(bdev->device_wakeup, false); 356 BT_DBG("suspend, delaying 15 ms"); 357 mdelay(15); 358 } 359 360 unlock: 361 spin_unlock(&bcm_device_lock); 362 363 return 0; 364 } 365 366 /* Platform resume callback */ 367 static int bcm_resume(struct device *dev) 368 { 369 struct bcm_device *bdev = platform_get_drvdata(to_platform_device(dev)); 370 371 BT_DBG("resume (%p): is_suspended %d", bdev, bdev->is_suspended); 372 373 spin_lock(&bcm_device_lock); 374 375 if (!bdev->hu) 376 goto unlock; 377 378 if (bdev->device_wakeup) { 379 gpiod_set_value(bdev->device_wakeup, true); 380 BT_DBG("resume, delaying 15 ms"); 381 mdelay(15); 382 } 383 384 /* When this callback executes, the device has woken up already */ 385 if (bdev->is_suspended) { 386 bdev->is_suspended = false; 387 388 hci_uart_set_flow_control(bdev->hu, false); 389 } 390 391 unlock: 392 spin_unlock(&bcm_device_lock); 393 394 return 0; 395 } 396 #endif 397 398 static const struct acpi_gpio_params device_wakeup_gpios = { 0, 0, false }; 399 static const struct acpi_gpio_params shutdown_gpios = { 1, 0, false }; 400 401 static const struct acpi_gpio_mapping acpi_bcm_default_gpios[] = { 402 { "device-wakeup-gpios", &device_wakeup_gpios, 1 }, 403 { "shutdown-gpios", &shutdown_gpios, 1 }, 404 { }, 405 }; 406 407 #ifdef CONFIG_ACPI 408 static int bcm_resource(struct acpi_resource *ares, void *data) 409 { 410 struct bcm_device *dev = data; 411 412 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) { 413 struct acpi_resource_uart_serialbus *sb; 414 415 sb = &ares->data.uart_serial_bus; 416 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_UART) 417 dev->init_speed = sb->default_baud_rate; 418 } 419 420 /* Always tell the ACPI core to skip this resource */ 421 return 1; 422 } 423 424 static int bcm_acpi_probe(struct bcm_device *dev) 425 { 426 struct platform_device *pdev = dev->pdev; 427 const struct acpi_device_id *id; 428 struct acpi_device *adev; 429 LIST_HEAD(resources); 430 int ret; 431 432 id = acpi_match_device(pdev->dev.driver->acpi_match_table, &pdev->dev); 433 if (!id) 434 return -ENODEV; 435 436 /* Retrieve GPIO data */ 437 dev->name = dev_name(&pdev->dev); 438 ret = acpi_dev_add_driver_gpios(ACPI_COMPANION(&pdev->dev), 439 acpi_bcm_default_gpios); 440 if (ret) 441 return ret; 442 443 dev->clk = devm_clk_get(&pdev->dev, NULL); 444 445 dev->device_wakeup = devm_gpiod_get_optional(&pdev->dev, 446 "device-wakeup", 447 GPIOD_OUT_LOW); 448 if (IS_ERR(dev->device_wakeup)) 449 return PTR_ERR(dev->device_wakeup); 450 451 dev->shutdown = devm_gpiod_get_optional(&pdev->dev, "shutdown", 452 GPIOD_OUT_LOW); 453 if (IS_ERR(dev->shutdown)) 454 return PTR_ERR(dev->shutdown); 455 456 /* Make sure at-least one of the GPIO is defined and that 457 * a name is specified for this instance 458 */ 459 if ((!dev->device_wakeup && !dev->shutdown) || !dev->name) { 460 dev_err(&pdev->dev, "invalid platform data\n"); 461 return -EINVAL; 462 } 463 464 /* Retrieve UART ACPI info */ 465 adev = ACPI_COMPANION(&dev->pdev->dev); 466 if (!adev) 467 return 0; 468 469 acpi_dev_get_resources(adev, &resources, bcm_resource, dev); 470 471 return 0; 472 } 473 #else 474 static int bcm_acpi_probe(struct bcm_device *dev) 475 { 476 return -EINVAL; 477 } 478 #endif /* CONFIG_ACPI */ 479 480 static int bcm_probe(struct platform_device *pdev) 481 { 482 struct bcm_device *dev; 483 struct acpi_device_id *pdata = pdev->dev.platform_data; 484 int ret; 485 486 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL); 487 if (!dev) 488 return -ENOMEM; 489 490 dev->pdev = pdev; 491 492 if (ACPI_HANDLE(&pdev->dev)) { 493 ret = bcm_acpi_probe(dev); 494 if (ret) 495 return ret; 496 } else if (pdata) { 497 dev->name = pdata->id; 498 } else { 499 return -ENODEV; 500 } 501 502 platform_set_drvdata(pdev, dev); 503 504 dev_info(&pdev->dev, "%s device registered.\n", dev->name); 505 506 /* Place this instance on the device list */ 507 spin_lock(&bcm_device_lock); 508 list_add_tail(&dev->list, &bcm_device_list); 509 spin_unlock(&bcm_device_lock); 510 511 bcm_gpio_set_power(dev, false); 512 513 return 0; 514 } 515 516 static int bcm_remove(struct platform_device *pdev) 517 { 518 struct bcm_device *dev = platform_get_drvdata(pdev); 519 520 spin_lock(&bcm_device_lock); 521 list_del(&dev->list); 522 spin_unlock(&bcm_device_lock); 523 524 acpi_dev_remove_driver_gpios(ACPI_COMPANION(&pdev->dev)); 525 526 dev_info(&pdev->dev, "%s device unregistered.\n", dev->name); 527 528 return 0; 529 } 530 531 static const struct hci_uart_proto bcm_proto = { 532 .id = HCI_UART_BCM, 533 .name = "BCM", 534 .init_speed = 115200, 535 .oper_speed = 4000000, 536 .open = bcm_open, 537 .close = bcm_close, 538 .flush = bcm_flush, 539 .setup = bcm_setup, 540 .set_baudrate = bcm_set_baudrate, 541 .recv = bcm_recv, 542 .enqueue = bcm_enqueue, 543 .dequeue = bcm_dequeue, 544 }; 545 546 #ifdef CONFIG_ACPI 547 static const struct acpi_device_id bcm_acpi_match[] = { 548 { "BCM2E39", 0 }, 549 { "BCM2E67", 0 }, 550 { }, 551 }; 552 MODULE_DEVICE_TABLE(acpi, bcm_acpi_match); 553 #endif 554 555 /* Platform suspend and resume callbacks */ 556 static SIMPLE_DEV_PM_OPS(bcm_pm_ops, bcm_suspend, bcm_resume); 557 558 static struct platform_driver bcm_driver = { 559 .probe = bcm_probe, 560 .remove = bcm_remove, 561 .driver = { 562 .name = "hci_bcm", 563 .acpi_match_table = ACPI_PTR(bcm_acpi_match), 564 .pm = &bcm_pm_ops, 565 }, 566 }; 567 568 int __init bcm_init(void) 569 { 570 platform_driver_register(&bcm_driver); 571 572 return hci_uart_register_proto(&bcm_proto); 573 } 574 575 int __exit bcm_deinit(void) 576 { 577 platform_driver_unregister(&bcm_driver); 578 579 return hci_uart_unregister_proto(&bcm_proto); 580 } 581