116e3887fSMarcel Holtmann /* 216e3887fSMarcel Holtmann * 316e3887fSMarcel Holtmann * Bluetooth HCI UART driver for Intel devices 416e3887fSMarcel Holtmann * 516e3887fSMarcel Holtmann * Copyright (C) 2015 Intel Corporation 616e3887fSMarcel Holtmann * 716e3887fSMarcel Holtmann * 816e3887fSMarcel Holtmann * This program is free software; you can redistribute it and/or modify 916e3887fSMarcel Holtmann * it under the terms of the GNU General Public License as published by 1016e3887fSMarcel Holtmann * the Free Software Foundation; either version 2 of the License, or 1116e3887fSMarcel Holtmann * (at your option) any later version. 1216e3887fSMarcel Holtmann * 1316e3887fSMarcel Holtmann * This program is distributed in the hope that it will be useful, 1416e3887fSMarcel Holtmann * but WITHOUT ANY WARRANTY; without even the implied warranty of 1516e3887fSMarcel Holtmann * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1616e3887fSMarcel Holtmann * GNU General Public License for more details. 1716e3887fSMarcel Holtmann * 1816e3887fSMarcel Holtmann * You should have received a copy of the GNU General Public License 1916e3887fSMarcel Holtmann * along with this program; if not, write to the Free Software 2016e3887fSMarcel Holtmann * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 2116e3887fSMarcel Holtmann * 2216e3887fSMarcel Holtmann */ 2316e3887fSMarcel Holtmann 2416e3887fSMarcel Holtmann #include <linux/kernel.h> 2516e3887fSMarcel Holtmann #include <linux/errno.h> 2616e3887fSMarcel Holtmann #include <linux/skbuff.h> 27ca93cee5SLoic Poulain #include <linux/firmware.h> 281ab1f239SLoic Poulain #include <linux/module.h> 29ca93cee5SLoic Poulain #include <linux/wait.h> 301ab1f239SLoic Poulain #include <linux/tty.h> 311ab1f239SLoic Poulain #include <linux/platform_device.h> 321ab1f239SLoic Poulain #include <linux/gpio/consumer.h> 331ab1f239SLoic Poulain #include <linux/acpi.h> 34765ea3abSLoic Poulain #include <linux/interrupt.h> 3574cdad37SLoic Poulain #include <linux/pm_runtime.h> 3616e3887fSMarcel Holtmann 3716e3887fSMarcel Holtmann #include <net/bluetooth/bluetooth.h> 3816e3887fSMarcel Holtmann #include <net/bluetooth/hci_core.h> 3916e3887fSMarcel Holtmann 4016e3887fSMarcel Holtmann #include "hci_uart.h" 41ca93cee5SLoic Poulain #include "btintel.h" 42ca93cee5SLoic Poulain 43ca93cee5SLoic Poulain #define STATE_BOOTLOADER 0 44ca93cee5SLoic Poulain #define STATE_DOWNLOADING 1 45ca93cee5SLoic Poulain #define STATE_FIRMWARE_LOADED 2 46ca93cee5SLoic Poulain #define STATE_FIRMWARE_FAILED 3 47ca93cee5SLoic Poulain #define STATE_BOOTING 4 48b98469f4SLoic Poulain #define STATE_LPM_ENABLED 5 49b98469f4SLoic Poulain #define STATE_TX_ACTIVE 6 5089436546SLoic Poulain #define STATE_SUSPENDED 7 5189436546SLoic Poulain #define STATE_LPM_TRANSACTION 8 52b98469f4SLoic Poulain 5389436546SLoic Poulain #define HCI_LPM_WAKE_PKT 0xf0 54b98469f4SLoic Poulain #define HCI_LPM_PKT 0xf1 55b98469f4SLoic Poulain #define HCI_LPM_MAX_SIZE 10 56b98469f4SLoic Poulain #define HCI_LPM_HDR_SIZE HCI_EVENT_HDR_SIZE 57b98469f4SLoic Poulain 58b98469f4SLoic Poulain #define LPM_OP_TX_NOTIFY 0x00 5989436546SLoic Poulain #define LPM_OP_SUSPEND_ACK 0x02 6089436546SLoic Poulain #define LPM_OP_RESUME_ACK 0x03 61b98469f4SLoic Poulain 6274cdad37SLoic Poulain #define LPM_SUSPEND_DELAY_MS 1000 6374cdad37SLoic Poulain 64b98469f4SLoic Poulain struct hci_lpm_pkt { 65b98469f4SLoic Poulain __u8 opcode; 66b98469f4SLoic Poulain __u8 dlen; 67b98469f4SLoic Poulain __u8 data[0]; 68b98469f4SLoic Poulain } __packed; 69ca93cee5SLoic Poulain 701ab1f239SLoic Poulain struct intel_device { 711ab1f239SLoic Poulain struct list_head list; 721ab1f239SLoic Poulain struct platform_device *pdev; 731ab1f239SLoic Poulain struct gpio_desc *reset; 74aa6802dfSLoic Poulain struct hci_uart *hu; 75aa6802dfSLoic Poulain struct mutex hu_lock; 76765ea3abSLoic Poulain int irq; 771ab1f239SLoic Poulain }; 781ab1f239SLoic Poulain 791ab1f239SLoic Poulain static LIST_HEAD(intel_device_list); 8067c8bde0SLoic Poulain static DEFINE_MUTEX(intel_device_list_lock); 811ab1f239SLoic Poulain 82ca93cee5SLoic Poulain struct intel_data { 83ca93cee5SLoic Poulain struct sk_buff *rx_skb; 84ca93cee5SLoic Poulain struct sk_buff_head txq; 8574cdad37SLoic Poulain struct work_struct busy_work; 8674cdad37SLoic Poulain struct hci_uart *hu; 87ca93cee5SLoic Poulain unsigned long flags; 88ca93cee5SLoic Poulain }; 89ca93cee5SLoic Poulain 90ff289559SLoic Poulain static u8 intel_convert_speed(unsigned int speed) 91ff289559SLoic Poulain { 92ff289559SLoic Poulain switch (speed) { 93ff289559SLoic Poulain case 9600: 94ff289559SLoic Poulain return 0x00; 95ff289559SLoic Poulain case 19200: 96ff289559SLoic Poulain return 0x01; 97ff289559SLoic Poulain case 38400: 98ff289559SLoic Poulain return 0x02; 99ff289559SLoic Poulain case 57600: 100ff289559SLoic Poulain return 0x03; 101ff289559SLoic Poulain case 115200: 102ff289559SLoic Poulain return 0x04; 103ff289559SLoic Poulain case 230400: 104ff289559SLoic Poulain return 0x05; 105ff289559SLoic Poulain case 460800: 106ff289559SLoic Poulain return 0x06; 107ff289559SLoic Poulain case 921600: 108ff289559SLoic Poulain return 0x07; 109ff289559SLoic Poulain case 1843200: 110ff289559SLoic Poulain return 0x08; 111ff289559SLoic Poulain case 3250000: 112ff289559SLoic Poulain return 0x09; 113ff289559SLoic Poulain case 2000000: 114ff289559SLoic Poulain return 0x0a; 115ff289559SLoic Poulain case 3000000: 116ff289559SLoic Poulain return 0x0b; 117ff289559SLoic Poulain default: 118ff289559SLoic Poulain return 0xff; 119ff289559SLoic Poulain } 120ff289559SLoic Poulain } 121ff289559SLoic Poulain 1221ab1f239SLoic Poulain static int intel_wait_booting(struct hci_uart *hu) 1231ab1f239SLoic Poulain { 1241ab1f239SLoic Poulain struct intel_data *intel = hu->priv; 1251ab1f239SLoic Poulain int err; 1261ab1f239SLoic Poulain 1271ab1f239SLoic Poulain err = wait_on_bit_timeout(&intel->flags, STATE_BOOTING, 1281ab1f239SLoic Poulain TASK_INTERRUPTIBLE, 1291ab1f239SLoic Poulain msecs_to_jiffies(1000)); 1301ab1f239SLoic Poulain 1311ab1f239SLoic Poulain if (err == 1) { 132f44e78a5SLoic Poulain bt_dev_err(hu->hdev, "Device boot interrupted"); 1331ab1f239SLoic Poulain return -EINTR; 1341ab1f239SLoic Poulain } 1351ab1f239SLoic Poulain 1361ab1f239SLoic Poulain if (err) { 137f44e78a5SLoic Poulain bt_dev_err(hu->hdev, "Device boot timeout"); 1381ab1f239SLoic Poulain return -ETIMEDOUT; 1391ab1f239SLoic Poulain } 1401ab1f239SLoic Poulain 1411ab1f239SLoic Poulain return err; 1421ab1f239SLoic Poulain } 1431ab1f239SLoic Poulain 144a9cb0fe4SLoic Poulain #ifdef CONFIG_PM 14589436546SLoic Poulain static int intel_wait_lpm_transaction(struct hci_uart *hu) 14689436546SLoic Poulain { 14789436546SLoic Poulain struct intel_data *intel = hu->priv; 14889436546SLoic Poulain int err; 14989436546SLoic Poulain 15089436546SLoic Poulain err = wait_on_bit_timeout(&intel->flags, STATE_LPM_TRANSACTION, 15189436546SLoic Poulain TASK_INTERRUPTIBLE, 15289436546SLoic Poulain msecs_to_jiffies(1000)); 15389436546SLoic Poulain 15489436546SLoic Poulain if (err == 1) { 15589436546SLoic Poulain bt_dev_err(hu->hdev, "LPM transaction interrupted"); 15689436546SLoic Poulain return -EINTR; 15789436546SLoic Poulain } 15889436546SLoic Poulain 15989436546SLoic Poulain if (err) { 16089436546SLoic Poulain bt_dev_err(hu->hdev, "LPM transaction timeout"); 16189436546SLoic Poulain return -ETIMEDOUT; 16289436546SLoic Poulain } 16389436546SLoic Poulain 16489436546SLoic Poulain return err; 16589436546SLoic Poulain } 16689436546SLoic Poulain 16789436546SLoic Poulain static int intel_lpm_suspend(struct hci_uart *hu) 16889436546SLoic Poulain { 16989436546SLoic Poulain static const u8 suspend[] = { 0x01, 0x01, 0x01 }; 17089436546SLoic Poulain struct intel_data *intel = hu->priv; 17189436546SLoic Poulain struct sk_buff *skb; 17289436546SLoic Poulain 17389436546SLoic Poulain if (!test_bit(STATE_LPM_ENABLED, &intel->flags) || 17489436546SLoic Poulain test_bit(STATE_SUSPENDED, &intel->flags)) 17589436546SLoic Poulain return 0; 17689436546SLoic Poulain 17789436546SLoic Poulain if (test_bit(STATE_TX_ACTIVE, &intel->flags)) 17889436546SLoic Poulain return -EAGAIN; 17989436546SLoic Poulain 18089436546SLoic Poulain bt_dev_dbg(hu->hdev, "Suspending"); 18189436546SLoic Poulain 18289436546SLoic Poulain skb = bt_skb_alloc(sizeof(suspend), GFP_KERNEL); 18389436546SLoic Poulain if (!skb) { 18489436546SLoic Poulain bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 18589436546SLoic Poulain return -ENOMEM; 18689436546SLoic Poulain } 18789436546SLoic Poulain 18889436546SLoic Poulain memcpy(skb_put(skb, sizeof(suspend)), suspend, sizeof(suspend)); 189*618e8bc2SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_LPM_PKT; 19089436546SLoic Poulain 19189436546SLoic Poulain set_bit(STATE_LPM_TRANSACTION, &intel->flags); 19289436546SLoic Poulain 19330e945fbSLoic Poulain /* LPM flow is a priority, enqueue packet at list head */ 19430e945fbSLoic Poulain skb_queue_head(&intel->txq, skb); 19589436546SLoic Poulain hci_uart_tx_wakeup(hu); 19689436546SLoic Poulain 19789436546SLoic Poulain intel_wait_lpm_transaction(hu); 19889436546SLoic Poulain /* Even in case of failure, continue and test the suspended flag */ 19989436546SLoic Poulain 20089436546SLoic Poulain clear_bit(STATE_LPM_TRANSACTION, &intel->flags); 20189436546SLoic Poulain 20289436546SLoic Poulain if (!test_bit(STATE_SUSPENDED, &intel->flags)) { 20389436546SLoic Poulain bt_dev_err(hu->hdev, "Device suspend error"); 20489436546SLoic Poulain return -EINVAL; 20589436546SLoic Poulain } 20689436546SLoic Poulain 20789436546SLoic Poulain bt_dev_dbg(hu->hdev, "Suspended"); 20889436546SLoic Poulain 20989436546SLoic Poulain hci_uart_set_flow_control(hu, true); 21089436546SLoic Poulain 21189436546SLoic Poulain return 0; 21289436546SLoic Poulain } 21389436546SLoic Poulain 21489436546SLoic Poulain static int intel_lpm_resume(struct hci_uart *hu) 21589436546SLoic Poulain { 21689436546SLoic Poulain struct intel_data *intel = hu->priv; 21789436546SLoic Poulain struct sk_buff *skb; 21889436546SLoic Poulain 21989436546SLoic Poulain if (!test_bit(STATE_LPM_ENABLED, &intel->flags) || 22089436546SLoic Poulain !test_bit(STATE_SUSPENDED, &intel->flags)) 22189436546SLoic Poulain return 0; 22289436546SLoic Poulain 22389436546SLoic Poulain bt_dev_dbg(hu->hdev, "Resuming"); 22489436546SLoic Poulain 22589436546SLoic Poulain hci_uart_set_flow_control(hu, false); 22689436546SLoic Poulain 22789436546SLoic Poulain skb = bt_skb_alloc(0, GFP_KERNEL); 22889436546SLoic Poulain if (!skb) { 22989436546SLoic Poulain bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 23089436546SLoic Poulain return -ENOMEM; 23189436546SLoic Poulain } 23289436546SLoic Poulain 233*618e8bc2SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_LPM_WAKE_PKT; 23489436546SLoic Poulain 23589436546SLoic Poulain set_bit(STATE_LPM_TRANSACTION, &intel->flags); 23689436546SLoic Poulain 23730e945fbSLoic Poulain /* LPM flow is a priority, enqueue packet at list head */ 23830e945fbSLoic Poulain skb_queue_head(&intel->txq, skb); 23989436546SLoic Poulain hci_uart_tx_wakeup(hu); 24089436546SLoic Poulain 24189436546SLoic Poulain intel_wait_lpm_transaction(hu); 24289436546SLoic Poulain /* Even in case of failure, continue and test the suspended flag */ 24389436546SLoic Poulain 24489436546SLoic Poulain clear_bit(STATE_LPM_TRANSACTION, &intel->flags); 24589436546SLoic Poulain 24689436546SLoic Poulain if (test_bit(STATE_SUSPENDED, &intel->flags)) { 24789436546SLoic Poulain bt_dev_err(hu->hdev, "Device resume error"); 24889436546SLoic Poulain return -EINVAL; 24989436546SLoic Poulain } 25089436546SLoic Poulain 25189436546SLoic Poulain bt_dev_dbg(hu->hdev, "Resumed"); 25289436546SLoic Poulain 25389436546SLoic Poulain return 0; 25489436546SLoic Poulain } 255a9cb0fe4SLoic Poulain #endif /* CONFIG_PM */ 25689436546SLoic Poulain 25789436546SLoic Poulain static int intel_lpm_host_wake(struct hci_uart *hu) 25889436546SLoic Poulain { 25989436546SLoic Poulain static const u8 lpm_resume_ack[] = { LPM_OP_RESUME_ACK, 0x00 }; 26089436546SLoic Poulain struct intel_data *intel = hu->priv; 26189436546SLoic Poulain struct sk_buff *skb; 26289436546SLoic Poulain 26389436546SLoic Poulain hci_uart_set_flow_control(hu, false); 26489436546SLoic Poulain 26589436546SLoic Poulain clear_bit(STATE_SUSPENDED, &intel->flags); 26689436546SLoic Poulain 26789436546SLoic Poulain skb = bt_skb_alloc(sizeof(lpm_resume_ack), GFP_KERNEL); 26889436546SLoic Poulain if (!skb) { 26989436546SLoic Poulain bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 27089436546SLoic Poulain return -ENOMEM; 27189436546SLoic Poulain } 27289436546SLoic Poulain 27389436546SLoic Poulain memcpy(skb_put(skb, sizeof(lpm_resume_ack)), lpm_resume_ack, 27489436546SLoic Poulain sizeof(lpm_resume_ack)); 275*618e8bc2SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_LPM_PKT; 27689436546SLoic Poulain 27730e945fbSLoic Poulain /* LPM flow is a priority, enqueue packet at list head */ 27830e945fbSLoic Poulain skb_queue_head(&intel->txq, skb); 27989436546SLoic Poulain hci_uart_tx_wakeup(hu); 28089436546SLoic Poulain 28189436546SLoic Poulain bt_dev_dbg(hu->hdev, "Resumed by controller"); 28289436546SLoic Poulain 28389436546SLoic Poulain return 0; 28489436546SLoic Poulain } 28589436546SLoic Poulain 286765ea3abSLoic Poulain static irqreturn_t intel_irq(int irq, void *dev_id) 287765ea3abSLoic Poulain { 288765ea3abSLoic Poulain struct intel_device *idev = dev_id; 289765ea3abSLoic Poulain 290765ea3abSLoic Poulain dev_info(&idev->pdev->dev, "hci_intel irq\n"); 291765ea3abSLoic Poulain 292aa6802dfSLoic Poulain mutex_lock(&idev->hu_lock); 293aa6802dfSLoic Poulain if (idev->hu) 294aa6802dfSLoic Poulain intel_lpm_host_wake(idev->hu); 295aa6802dfSLoic Poulain mutex_unlock(&idev->hu_lock); 296aa6802dfSLoic Poulain 29774cdad37SLoic Poulain /* Host/Controller are now LPM resumed, trigger a new delayed suspend */ 29874cdad37SLoic Poulain pm_runtime_get(&idev->pdev->dev); 29974cdad37SLoic Poulain pm_runtime_mark_last_busy(&idev->pdev->dev); 30074cdad37SLoic Poulain pm_runtime_put_autosuspend(&idev->pdev->dev); 30174cdad37SLoic Poulain 302765ea3abSLoic Poulain return IRQ_HANDLED; 303765ea3abSLoic Poulain } 304765ea3abSLoic Poulain 3051ab1f239SLoic Poulain static int intel_set_power(struct hci_uart *hu, bool powered) 3061ab1f239SLoic Poulain { 3071ab1f239SLoic Poulain struct list_head *p; 3081ab1f239SLoic Poulain int err = -ENODEV; 3091ab1f239SLoic Poulain 31067c8bde0SLoic Poulain mutex_lock(&intel_device_list_lock); 3111ab1f239SLoic Poulain 3121ab1f239SLoic Poulain list_for_each(p, &intel_device_list) { 3131ab1f239SLoic Poulain struct intel_device *idev = list_entry(p, struct intel_device, 3141ab1f239SLoic Poulain list); 3151ab1f239SLoic Poulain 3161ab1f239SLoic Poulain /* tty device and pdev device should share the same parent 3171ab1f239SLoic Poulain * which is the UART port. 3181ab1f239SLoic Poulain */ 3191ab1f239SLoic Poulain if (hu->tty->dev->parent != idev->pdev->dev.parent) 3201ab1f239SLoic Poulain continue; 3211ab1f239SLoic Poulain 3221ab1f239SLoic Poulain if (!idev->reset) { 3231ab1f239SLoic Poulain err = -ENOTSUPP; 3241ab1f239SLoic Poulain break; 3251ab1f239SLoic Poulain } 3261ab1f239SLoic Poulain 3271ab1f239SLoic Poulain BT_INFO("hu %p, Switching compatible pm device (%s) to %u", 3281ab1f239SLoic Poulain hu, dev_name(&idev->pdev->dev), powered); 3291ab1f239SLoic Poulain 3301ab1f239SLoic Poulain gpiod_set_value(idev->reset, powered); 331765ea3abSLoic Poulain 332aa6802dfSLoic Poulain /* Provide to idev a hu reference which is used to run LPM 333aa6802dfSLoic Poulain * transactions (lpm suspend/resume) from PM callbacks. 334aa6802dfSLoic Poulain * hu needs to be protected against concurrent removing during 335aa6802dfSLoic Poulain * these PM ops. 336aa6802dfSLoic Poulain */ 337aa6802dfSLoic Poulain mutex_lock(&idev->hu_lock); 338aa6802dfSLoic Poulain idev->hu = powered ? hu : NULL; 339aa6802dfSLoic Poulain mutex_unlock(&idev->hu_lock); 340aa6802dfSLoic Poulain 341765ea3abSLoic Poulain if (idev->irq < 0) 342765ea3abSLoic Poulain break; 343765ea3abSLoic Poulain 344765ea3abSLoic Poulain if (powered && device_can_wakeup(&idev->pdev->dev)) { 345765ea3abSLoic Poulain err = devm_request_threaded_irq(&idev->pdev->dev, 346765ea3abSLoic Poulain idev->irq, NULL, 347765ea3abSLoic Poulain intel_irq, 348765ea3abSLoic Poulain IRQF_ONESHOT, 349765ea3abSLoic Poulain "bt-host-wake", idev); 350765ea3abSLoic Poulain if (err) { 351765ea3abSLoic Poulain BT_ERR("hu %p, unable to allocate irq-%d", 352765ea3abSLoic Poulain hu, idev->irq); 353765ea3abSLoic Poulain break; 354765ea3abSLoic Poulain } 355765ea3abSLoic Poulain 356765ea3abSLoic Poulain device_wakeup_enable(&idev->pdev->dev); 35774cdad37SLoic Poulain 35874cdad37SLoic Poulain pm_runtime_set_active(&idev->pdev->dev); 35974cdad37SLoic Poulain pm_runtime_use_autosuspend(&idev->pdev->dev); 36074cdad37SLoic Poulain pm_runtime_set_autosuspend_delay(&idev->pdev->dev, 36174cdad37SLoic Poulain LPM_SUSPEND_DELAY_MS); 36274cdad37SLoic Poulain pm_runtime_enable(&idev->pdev->dev); 363765ea3abSLoic Poulain } else if (!powered && device_may_wakeup(&idev->pdev->dev)) { 364765ea3abSLoic Poulain devm_free_irq(&idev->pdev->dev, idev->irq, idev); 365765ea3abSLoic Poulain device_wakeup_disable(&idev->pdev->dev); 36674cdad37SLoic Poulain 36774cdad37SLoic Poulain pm_runtime_disable(&idev->pdev->dev); 368765ea3abSLoic Poulain } 3691ab1f239SLoic Poulain } 3701ab1f239SLoic Poulain 37167c8bde0SLoic Poulain mutex_unlock(&intel_device_list_lock); 3721ab1f239SLoic Poulain 3731ab1f239SLoic Poulain return err; 3741ab1f239SLoic Poulain } 3751ab1f239SLoic Poulain 37674cdad37SLoic Poulain static void intel_busy_work(struct work_struct *work) 37774cdad37SLoic Poulain { 37874cdad37SLoic Poulain struct list_head *p; 37974cdad37SLoic Poulain struct intel_data *intel = container_of(work, struct intel_data, 38074cdad37SLoic Poulain busy_work); 38174cdad37SLoic Poulain 38274cdad37SLoic Poulain /* Link is busy, delay the suspend */ 38374cdad37SLoic Poulain mutex_lock(&intel_device_list_lock); 38474cdad37SLoic Poulain list_for_each(p, &intel_device_list) { 38574cdad37SLoic Poulain struct intel_device *idev = list_entry(p, struct intel_device, 38674cdad37SLoic Poulain list); 38774cdad37SLoic Poulain 38874cdad37SLoic Poulain if (intel->hu->tty->dev->parent == idev->pdev->dev.parent) { 38974cdad37SLoic Poulain pm_runtime_get(&idev->pdev->dev); 39074cdad37SLoic Poulain pm_runtime_mark_last_busy(&idev->pdev->dev); 39174cdad37SLoic Poulain pm_runtime_put_autosuspend(&idev->pdev->dev); 39274cdad37SLoic Poulain break; 39374cdad37SLoic Poulain } 39474cdad37SLoic Poulain } 39574cdad37SLoic Poulain mutex_unlock(&intel_device_list_lock); 39674cdad37SLoic Poulain } 39774cdad37SLoic Poulain 398ca93cee5SLoic Poulain static int intel_open(struct hci_uart *hu) 399ca93cee5SLoic Poulain { 400ca93cee5SLoic Poulain struct intel_data *intel; 401ca93cee5SLoic Poulain 402ca93cee5SLoic Poulain BT_DBG("hu %p", hu); 403ca93cee5SLoic Poulain 404ca93cee5SLoic Poulain intel = kzalloc(sizeof(*intel), GFP_KERNEL); 405ca93cee5SLoic Poulain if (!intel) 406ca93cee5SLoic Poulain return -ENOMEM; 407ca93cee5SLoic Poulain 408ca93cee5SLoic Poulain skb_queue_head_init(&intel->txq); 40974cdad37SLoic Poulain INIT_WORK(&intel->busy_work, intel_busy_work); 41074cdad37SLoic Poulain 41174cdad37SLoic Poulain intel->hu = hu; 412ca93cee5SLoic Poulain 413ca93cee5SLoic Poulain hu->priv = intel; 4141ab1f239SLoic Poulain 4151ab1f239SLoic Poulain if (!intel_set_power(hu, true)) 4161ab1f239SLoic Poulain set_bit(STATE_BOOTING, &intel->flags); 4171ab1f239SLoic Poulain 418ca93cee5SLoic Poulain return 0; 419ca93cee5SLoic Poulain } 420ca93cee5SLoic Poulain 421ca93cee5SLoic Poulain static int intel_close(struct hci_uart *hu) 422ca93cee5SLoic Poulain { 423ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 424ca93cee5SLoic Poulain 425ca93cee5SLoic Poulain BT_DBG("hu %p", hu); 426ca93cee5SLoic Poulain 42774cdad37SLoic Poulain cancel_work_sync(&intel->busy_work); 42874cdad37SLoic Poulain 4291ab1f239SLoic Poulain intel_set_power(hu, false); 4301ab1f239SLoic Poulain 431ca93cee5SLoic Poulain skb_queue_purge(&intel->txq); 432ca93cee5SLoic Poulain kfree_skb(intel->rx_skb); 433ca93cee5SLoic Poulain kfree(intel); 434ca93cee5SLoic Poulain 435ca93cee5SLoic Poulain hu->priv = NULL; 436ca93cee5SLoic Poulain return 0; 437ca93cee5SLoic Poulain } 438ca93cee5SLoic Poulain 439ca93cee5SLoic Poulain static int intel_flush(struct hci_uart *hu) 440ca93cee5SLoic Poulain { 441ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 442ca93cee5SLoic Poulain 443ca93cee5SLoic Poulain BT_DBG("hu %p", hu); 444ca93cee5SLoic Poulain 445ca93cee5SLoic Poulain skb_queue_purge(&intel->txq); 446ca93cee5SLoic Poulain 447ca93cee5SLoic Poulain return 0; 448ca93cee5SLoic Poulain } 449ca93cee5SLoic Poulain 450ca93cee5SLoic Poulain static int inject_cmd_complete(struct hci_dev *hdev, __u16 opcode) 451ca93cee5SLoic Poulain { 452ca93cee5SLoic Poulain struct sk_buff *skb; 453ca93cee5SLoic Poulain struct hci_event_hdr *hdr; 454ca93cee5SLoic Poulain struct hci_ev_cmd_complete *evt; 455ca93cee5SLoic Poulain 456ca93cee5SLoic Poulain skb = bt_skb_alloc(sizeof(*hdr) + sizeof(*evt) + 1, GFP_ATOMIC); 457ca93cee5SLoic Poulain if (!skb) 458ca93cee5SLoic Poulain return -ENOMEM; 459ca93cee5SLoic Poulain 460ca93cee5SLoic Poulain hdr = (struct hci_event_hdr *)skb_put(skb, sizeof(*hdr)); 461ca93cee5SLoic Poulain hdr->evt = HCI_EV_CMD_COMPLETE; 462ca93cee5SLoic Poulain hdr->plen = sizeof(*evt) + 1; 463ca93cee5SLoic Poulain 464ca93cee5SLoic Poulain evt = (struct hci_ev_cmd_complete *)skb_put(skb, sizeof(*evt)); 465ca93cee5SLoic Poulain evt->ncmd = 0x01; 466ca93cee5SLoic Poulain evt->opcode = cpu_to_le16(opcode); 467ca93cee5SLoic Poulain 468ca93cee5SLoic Poulain *skb_put(skb, 1) = 0x00; 469ca93cee5SLoic Poulain 470*618e8bc2SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 471ca93cee5SLoic Poulain 472ca93cee5SLoic Poulain return hci_recv_frame(hdev, skb); 473ca93cee5SLoic Poulain } 474ca93cee5SLoic Poulain 475ff289559SLoic Poulain static int intel_set_baudrate(struct hci_uart *hu, unsigned int speed) 476ff289559SLoic Poulain { 477ff289559SLoic Poulain struct intel_data *intel = hu->priv; 478ff289559SLoic Poulain struct hci_dev *hdev = hu->hdev; 479ff289559SLoic Poulain u8 speed_cmd[] = { 0x06, 0xfc, 0x01, 0x00 }; 480ff289559SLoic Poulain struct sk_buff *skb; 4811ab1f239SLoic Poulain int err; 4821ab1f239SLoic Poulain 4831ab1f239SLoic Poulain /* This can be the first command sent to the chip, check 4841ab1f239SLoic Poulain * that the controller is ready. 4851ab1f239SLoic Poulain */ 4861ab1f239SLoic Poulain err = intel_wait_booting(hu); 4871ab1f239SLoic Poulain 4881ab1f239SLoic Poulain clear_bit(STATE_BOOTING, &intel->flags); 4891ab1f239SLoic Poulain 4901ab1f239SLoic Poulain /* In case of timeout, try to continue anyway */ 4911ab1f239SLoic Poulain if (err && err != ETIMEDOUT) 4921ab1f239SLoic Poulain return err; 493ff289559SLoic Poulain 494f44e78a5SLoic Poulain bt_dev_info(hdev, "Change controller speed to %d", speed); 495ff289559SLoic Poulain 496ff289559SLoic Poulain speed_cmd[3] = intel_convert_speed(speed); 497ff289559SLoic Poulain if (speed_cmd[3] == 0xff) { 498f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported speed"); 499ff289559SLoic Poulain return -EINVAL; 500ff289559SLoic Poulain } 501ff289559SLoic Poulain 502ff289559SLoic Poulain /* Device will not accept speed change if Intel version has not been 503ff289559SLoic Poulain * previously requested. 504ff289559SLoic Poulain */ 505ff289559SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT); 506ff289559SLoic Poulain if (IS_ERR(skb)) { 507f44e78a5SLoic Poulain bt_dev_err(hdev, "Reading Intel version information failed (%ld)", 508f44e78a5SLoic Poulain PTR_ERR(skb)); 509ff289559SLoic Poulain return PTR_ERR(skb); 510ff289559SLoic Poulain } 511ff289559SLoic Poulain kfree_skb(skb); 512ff289559SLoic Poulain 513ff289559SLoic Poulain skb = bt_skb_alloc(sizeof(speed_cmd), GFP_KERNEL); 514ff289559SLoic Poulain if (!skb) { 515f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to alloc memory for baudrate packet"); 516ff289559SLoic Poulain return -ENOMEM; 517ff289559SLoic Poulain } 518ff289559SLoic Poulain 519ff289559SLoic Poulain memcpy(skb_put(skb, sizeof(speed_cmd)), speed_cmd, sizeof(speed_cmd)); 520*618e8bc2SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_COMMAND_PKT; 521ff289559SLoic Poulain 522ff289559SLoic Poulain hci_uart_set_flow_control(hu, true); 523ff289559SLoic Poulain 524ff289559SLoic Poulain skb_queue_tail(&intel->txq, skb); 525ff289559SLoic Poulain hci_uart_tx_wakeup(hu); 526ff289559SLoic Poulain 527ff289559SLoic Poulain /* wait 100ms to change baudrate on controller side */ 528ff289559SLoic Poulain msleep(100); 529ff289559SLoic Poulain 530ff289559SLoic Poulain hci_uart_set_baudrate(hu, speed); 531ff289559SLoic Poulain hci_uart_set_flow_control(hu, false); 532ff289559SLoic Poulain 533ff289559SLoic Poulain return 0; 534ff289559SLoic Poulain } 535ff289559SLoic Poulain 536ca93cee5SLoic Poulain static int intel_setup(struct hci_uart *hu) 537ca93cee5SLoic Poulain { 538ca93cee5SLoic Poulain static const u8 reset_param[] = { 0x00, 0x01, 0x00, 0x01, 539ca93cee5SLoic Poulain 0x00, 0x08, 0x04, 0x00 }; 540b98469f4SLoic Poulain static const u8 lpm_param[] = { 0x03, 0x07, 0x01, 0x0b }; 541ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 542b98469f4SLoic Poulain struct intel_device *idev = NULL; 543ca93cee5SLoic Poulain struct hci_dev *hdev = hu->hdev; 544ca93cee5SLoic Poulain struct sk_buff *skb; 545ca93cee5SLoic Poulain struct intel_version *ver; 546ca93cee5SLoic Poulain struct intel_boot_params *params; 547b98469f4SLoic Poulain struct list_head *p; 548ca93cee5SLoic Poulain const struct firmware *fw; 549ca93cee5SLoic Poulain const u8 *fw_ptr; 550ca93cee5SLoic Poulain char fwname[64]; 551ca93cee5SLoic Poulain u32 frag_len; 552ca93cee5SLoic Poulain ktime_t calltime, delta, rettime; 553ca93cee5SLoic Poulain unsigned long long duration; 554ff289559SLoic Poulain unsigned int init_speed, oper_speed; 555ff289559SLoic Poulain int speed_change = 0; 556ca93cee5SLoic Poulain int err; 557ca93cee5SLoic Poulain 558f44e78a5SLoic Poulain bt_dev_dbg(hdev, "start intel_setup"); 559ca93cee5SLoic Poulain 5606d2e50d2SMarcel Holtmann hu->hdev->set_diag = btintel_set_diag; 56135ab8150SMarcel Holtmann hu->hdev->set_bdaddr = btintel_set_bdaddr; 56235ab8150SMarcel Holtmann 563ca93cee5SLoic Poulain calltime = ktime_get(); 564ca93cee5SLoic Poulain 565ff289559SLoic Poulain if (hu->init_speed) 566ff289559SLoic Poulain init_speed = hu->init_speed; 567ff289559SLoic Poulain else 568ff289559SLoic Poulain init_speed = hu->proto->init_speed; 569ff289559SLoic Poulain 570ff289559SLoic Poulain if (hu->oper_speed) 571ff289559SLoic Poulain oper_speed = hu->oper_speed; 572ff289559SLoic Poulain else 573ff289559SLoic Poulain oper_speed = hu->proto->oper_speed; 574ff289559SLoic Poulain 575ff289559SLoic Poulain if (oper_speed && init_speed && oper_speed != init_speed) 576ff289559SLoic Poulain speed_change = 1; 577ff289559SLoic Poulain 5781ab1f239SLoic Poulain /* Check that the controller is ready */ 5791ab1f239SLoic Poulain err = intel_wait_booting(hu); 5801ab1f239SLoic Poulain 5811ab1f239SLoic Poulain clear_bit(STATE_BOOTING, &intel->flags); 5821ab1f239SLoic Poulain 5831ab1f239SLoic Poulain /* In case of timeout, try to continue anyway */ 5841ab1f239SLoic Poulain if (err && err != ETIMEDOUT) 5851ab1f239SLoic Poulain return err; 5861ab1f239SLoic Poulain 587ca93cee5SLoic Poulain set_bit(STATE_BOOTLOADER, &intel->flags); 588ca93cee5SLoic Poulain 589ca93cee5SLoic Poulain /* Read the Intel version information to determine if the device 590ca93cee5SLoic Poulain * is in bootloader mode or if it already has operational firmware 591ca93cee5SLoic Poulain * loaded. 592ca93cee5SLoic Poulain */ 593ca93cee5SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT); 594ca93cee5SLoic Poulain if (IS_ERR(skb)) { 595f44e78a5SLoic Poulain bt_dev_err(hdev, "Reading Intel version information failed (%ld)", 596f44e78a5SLoic Poulain PTR_ERR(skb)); 597ca93cee5SLoic Poulain return PTR_ERR(skb); 598ca93cee5SLoic Poulain } 599ca93cee5SLoic Poulain 600ca93cee5SLoic Poulain if (skb->len != sizeof(*ver)) { 601f44e78a5SLoic Poulain bt_dev_err(hdev, "Intel version event size mismatch"); 602ca93cee5SLoic Poulain kfree_skb(skb); 603ca93cee5SLoic Poulain return -EILSEQ; 604ca93cee5SLoic Poulain } 605ca93cee5SLoic Poulain 606ca93cee5SLoic Poulain ver = (struct intel_version *)skb->data; 607ca93cee5SLoic Poulain if (ver->status) { 608f44e78a5SLoic Poulain bt_dev_err(hdev, "Intel version command failure (%02x)", 609f44e78a5SLoic Poulain ver->status); 610ca93cee5SLoic Poulain err = -bt_to_errno(ver->status); 611ca93cee5SLoic Poulain kfree_skb(skb); 612ca93cee5SLoic Poulain return err; 613ca93cee5SLoic Poulain } 614ca93cee5SLoic Poulain 615ca93cee5SLoic Poulain /* The hardware platform number has a fixed value of 0x37 and 616ca93cee5SLoic Poulain * for now only accept this single value. 617ca93cee5SLoic Poulain */ 618ca93cee5SLoic Poulain if (ver->hw_platform != 0x37) { 619f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported Intel hardware platform (%u)", 620f44e78a5SLoic Poulain ver->hw_platform); 621ca93cee5SLoic Poulain kfree_skb(skb); 622ca93cee5SLoic Poulain return -EINVAL; 623ca93cee5SLoic Poulain } 624ca93cee5SLoic Poulain 625ca93cee5SLoic Poulain /* At the moment only the hardware variant iBT 3.0 (LnP/SfP) is 626ca93cee5SLoic Poulain * supported by this firmware loading method. This check has been 627ca93cee5SLoic Poulain * put in place to ensure correct forward compatibility options 628ca93cee5SLoic Poulain * when newer hardware variants come along. 629ca93cee5SLoic Poulain */ 630ca93cee5SLoic Poulain if (ver->hw_variant != 0x0b) { 631f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported Intel hardware variant (%u)", 632f44e78a5SLoic Poulain ver->hw_variant); 633ca93cee5SLoic Poulain kfree_skb(skb); 634ca93cee5SLoic Poulain return -EINVAL; 635ca93cee5SLoic Poulain } 636ca93cee5SLoic Poulain 6377feb99e1SMarcel Holtmann btintel_version_info(hdev, ver); 638ca93cee5SLoic Poulain 639ca93cee5SLoic Poulain /* The firmware variant determines if the device is in bootloader 640ca93cee5SLoic Poulain * mode or is running operational firmware. The value 0x06 identifies 641ca93cee5SLoic Poulain * the bootloader and the value 0x23 identifies the operational 642ca93cee5SLoic Poulain * firmware. 643ca93cee5SLoic Poulain * 644ca93cee5SLoic Poulain * When the operational firmware is already present, then only 645ca93cee5SLoic Poulain * the check for valid Bluetooth device address is needed. This 646ca93cee5SLoic Poulain * determines if the device will be added as configured or 647ca93cee5SLoic Poulain * unconfigured controller. 648ca93cee5SLoic Poulain * 649ca93cee5SLoic Poulain * It is not possible to use the Secure Boot Parameters in this 650ca93cee5SLoic Poulain * case since that command is only available in bootloader mode. 651ca93cee5SLoic Poulain */ 652ca93cee5SLoic Poulain if (ver->fw_variant == 0x23) { 653ca93cee5SLoic Poulain kfree_skb(skb); 654ca93cee5SLoic Poulain clear_bit(STATE_BOOTLOADER, &intel->flags); 655ca93cee5SLoic Poulain btintel_check_bdaddr(hdev); 656ca93cee5SLoic Poulain return 0; 657ca93cee5SLoic Poulain } 658ca93cee5SLoic Poulain 659ca93cee5SLoic Poulain /* If the device is not in bootloader mode, then the only possible 660ca93cee5SLoic Poulain * choice is to return an error and abort the device initialization. 661ca93cee5SLoic Poulain */ 662ca93cee5SLoic Poulain if (ver->fw_variant != 0x06) { 663f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported Intel firmware variant (%u)", 664f44e78a5SLoic Poulain ver->fw_variant); 665ca93cee5SLoic Poulain kfree_skb(skb); 666ca93cee5SLoic Poulain return -ENODEV; 667ca93cee5SLoic Poulain } 668ca93cee5SLoic Poulain 669ca93cee5SLoic Poulain kfree_skb(skb); 670ca93cee5SLoic Poulain 671ca93cee5SLoic Poulain /* Read the secure boot parameters to identify the operating 672ca93cee5SLoic Poulain * details of the bootloader. 673ca93cee5SLoic Poulain */ 674ca93cee5SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc0d, 0, NULL, HCI_INIT_TIMEOUT); 675ca93cee5SLoic Poulain if (IS_ERR(skb)) { 676f44e78a5SLoic Poulain bt_dev_err(hdev, "Reading Intel boot parameters failed (%ld)", 677f44e78a5SLoic Poulain PTR_ERR(skb)); 678ca93cee5SLoic Poulain return PTR_ERR(skb); 679ca93cee5SLoic Poulain } 680ca93cee5SLoic Poulain 681ca93cee5SLoic Poulain if (skb->len != sizeof(*params)) { 682f44e78a5SLoic Poulain bt_dev_err(hdev, "Intel boot parameters size mismatch"); 683ca93cee5SLoic Poulain kfree_skb(skb); 684ca93cee5SLoic Poulain return -EILSEQ; 685ca93cee5SLoic Poulain } 686ca93cee5SLoic Poulain 687ca93cee5SLoic Poulain params = (struct intel_boot_params *)skb->data; 688ca93cee5SLoic Poulain if (params->status) { 689f44e78a5SLoic Poulain bt_dev_err(hdev, "Intel boot parameters command failure (%02x)", 690f44e78a5SLoic Poulain params->status); 691ca93cee5SLoic Poulain err = -bt_to_errno(params->status); 692ca93cee5SLoic Poulain kfree_skb(skb); 693ca93cee5SLoic Poulain return err; 694ca93cee5SLoic Poulain } 695ca93cee5SLoic Poulain 696f44e78a5SLoic Poulain bt_dev_info(hdev, "Device revision is %u", 697ca93cee5SLoic Poulain le16_to_cpu(params->dev_revid)); 698ca93cee5SLoic Poulain 699f44e78a5SLoic Poulain bt_dev_info(hdev, "Secure boot is %s", 700ca93cee5SLoic Poulain params->secure_boot ? "enabled" : "disabled"); 701ca93cee5SLoic Poulain 702f44e78a5SLoic Poulain bt_dev_info(hdev, "Minimum firmware build %u week %u %u", 703ca93cee5SLoic Poulain params->min_fw_build_nn, params->min_fw_build_cw, 704ca93cee5SLoic Poulain 2000 + params->min_fw_build_yy); 705ca93cee5SLoic Poulain 706ca93cee5SLoic Poulain /* It is required that every single firmware fragment is acknowledged 707ca93cee5SLoic Poulain * with a command complete event. If the boot parameters indicate 708ca93cee5SLoic Poulain * that this bootloader does not send them, then abort the setup. 709ca93cee5SLoic Poulain */ 710ca93cee5SLoic Poulain if (params->limited_cce != 0x00) { 711f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported Intel firmware loading method (%u)", 712f44e78a5SLoic Poulain params->limited_cce); 713ca93cee5SLoic Poulain kfree_skb(skb); 714ca93cee5SLoic Poulain return -EINVAL; 715ca93cee5SLoic Poulain } 716ca93cee5SLoic Poulain 717ca93cee5SLoic Poulain /* If the OTP has no valid Bluetooth device address, then there will 718ca93cee5SLoic Poulain * also be no valid address for the operational firmware. 719ca93cee5SLoic Poulain */ 720ca93cee5SLoic Poulain if (!bacmp(¶ms->otp_bdaddr, BDADDR_ANY)) { 721f44e78a5SLoic Poulain bt_dev_info(hdev, "No device address configured"); 722ca93cee5SLoic Poulain set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks); 723ca93cee5SLoic Poulain } 724ca93cee5SLoic Poulain 725ca93cee5SLoic Poulain /* With this Intel bootloader only the hardware variant and device 726ca93cee5SLoic Poulain * revision information are used to select the right firmware. 727ca93cee5SLoic Poulain * 728ca93cee5SLoic Poulain * Currently this bootloader support is limited to hardware variant 729ca93cee5SLoic Poulain * iBT 3.0 (LnP/SfP) which is identified by the value 11 (0x0b). 730ca93cee5SLoic Poulain */ 731ca93cee5SLoic Poulain snprintf(fwname, sizeof(fwname), "intel/ibt-11-%u.sfi", 732ca93cee5SLoic Poulain le16_to_cpu(params->dev_revid)); 733ca93cee5SLoic Poulain 734ca93cee5SLoic Poulain err = request_firmware(&fw, fwname, &hdev->dev); 735ca93cee5SLoic Poulain if (err < 0) { 736f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to load Intel firmware file (%d)", 737f44e78a5SLoic Poulain err); 738ca93cee5SLoic Poulain kfree_skb(skb); 739ca93cee5SLoic Poulain return err; 740ca93cee5SLoic Poulain } 741ca93cee5SLoic Poulain 742f44e78a5SLoic Poulain bt_dev_info(hdev, "Found device firmware: %s", fwname); 743ca93cee5SLoic Poulain 7441cfbabddSLoic Poulain /* Save the DDC file name for later */ 7451cfbabddSLoic Poulain snprintf(fwname, sizeof(fwname), "intel/ibt-11-%u.ddc", 7461cfbabddSLoic Poulain le16_to_cpu(params->dev_revid)); 7471cfbabddSLoic Poulain 748ca93cee5SLoic Poulain kfree_skb(skb); 749ca93cee5SLoic Poulain 750ca93cee5SLoic Poulain if (fw->size < 644) { 751f44e78a5SLoic Poulain bt_dev_err(hdev, "Invalid size of firmware file (%zu)", 752f44e78a5SLoic Poulain fw->size); 753ca93cee5SLoic Poulain err = -EBADF; 754ca93cee5SLoic Poulain goto done; 755ca93cee5SLoic Poulain } 756ca93cee5SLoic Poulain 757ca93cee5SLoic Poulain set_bit(STATE_DOWNLOADING, &intel->flags); 758ca93cee5SLoic Poulain 759ca93cee5SLoic Poulain /* Start the firmware download transaction with the Init fragment 760ca93cee5SLoic Poulain * represented by the 128 bytes of CSS header. 761ca93cee5SLoic Poulain */ 76209df123dSMarcel Holtmann err = btintel_secure_send(hdev, 0x00, 128, fw->data); 763ca93cee5SLoic Poulain if (err < 0) { 764f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to send firmware header (%d)", err); 765ca93cee5SLoic Poulain goto done; 766ca93cee5SLoic Poulain } 767ca93cee5SLoic Poulain 768ca93cee5SLoic Poulain /* Send the 256 bytes of public key information from the firmware 769ca93cee5SLoic Poulain * as the PKey fragment. 770ca93cee5SLoic Poulain */ 77109df123dSMarcel Holtmann err = btintel_secure_send(hdev, 0x03, 256, fw->data + 128); 772ca93cee5SLoic Poulain if (err < 0) { 773f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to send firmware public key (%d)", 774f44e78a5SLoic Poulain err); 775ca93cee5SLoic Poulain goto done; 776ca93cee5SLoic Poulain } 777ca93cee5SLoic Poulain 778ca93cee5SLoic Poulain /* Send the 256 bytes of signature information from the firmware 779ca93cee5SLoic Poulain * as the Sign fragment. 780ca93cee5SLoic Poulain */ 78109df123dSMarcel Holtmann err = btintel_secure_send(hdev, 0x02, 256, fw->data + 388); 782ca93cee5SLoic Poulain if (err < 0) { 783f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to send firmware signature (%d)", 784f44e78a5SLoic Poulain err); 785ca93cee5SLoic Poulain goto done; 786ca93cee5SLoic Poulain } 787ca93cee5SLoic Poulain 788ca93cee5SLoic Poulain fw_ptr = fw->data + 644; 789ca93cee5SLoic Poulain frag_len = 0; 790ca93cee5SLoic Poulain 791ca93cee5SLoic Poulain while (fw_ptr - fw->data < fw->size) { 792ca93cee5SLoic Poulain struct hci_command_hdr *cmd = (void *)(fw_ptr + frag_len); 793ca93cee5SLoic Poulain 794ca93cee5SLoic Poulain frag_len += sizeof(*cmd) + cmd->plen; 795ca93cee5SLoic Poulain 796f44e78a5SLoic Poulain bt_dev_dbg(hdev, "Patching %td/%zu", (fw_ptr - fw->data), 797f44e78a5SLoic Poulain fw->size); 798ca93cee5SLoic Poulain 799ca93cee5SLoic Poulain /* The parameter length of the secure send command requires 800ca93cee5SLoic Poulain * a 4 byte alignment. It happens so that the firmware file 801ca93cee5SLoic Poulain * contains proper Intel_NOP commands to align the fragments 802ca93cee5SLoic Poulain * as needed. 803ca93cee5SLoic Poulain * 804ca93cee5SLoic Poulain * Send set of commands with 4 byte alignment from the 805ca93cee5SLoic Poulain * firmware data buffer as a single Data fragement. 806ca93cee5SLoic Poulain */ 807ca93cee5SLoic Poulain if (frag_len % 4) 808ca93cee5SLoic Poulain continue; 809ca93cee5SLoic Poulain 810ca93cee5SLoic Poulain /* Send each command from the firmware data buffer as 811ca93cee5SLoic Poulain * a single Data fragment. 812ca93cee5SLoic Poulain */ 81309df123dSMarcel Holtmann err = btintel_secure_send(hdev, 0x01, frag_len, fw_ptr); 814ca93cee5SLoic Poulain if (err < 0) { 815f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to send firmware data (%d)", 816f44e78a5SLoic Poulain err); 817ca93cee5SLoic Poulain goto done; 818ca93cee5SLoic Poulain } 819ca93cee5SLoic Poulain 820ca93cee5SLoic Poulain fw_ptr += frag_len; 821ca93cee5SLoic Poulain frag_len = 0; 822ca93cee5SLoic Poulain } 823ca93cee5SLoic Poulain 824ca93cee5SLoic Poulain set_bit(STATE_FIRMWARE_LOADED, &intel->flags); 825ca93cee5SLoic Poulain 826f44e78a5SLoic Poulain bt_dev_info(hdev, "Waiting for firmware download to complete"); 827ca93cee5SLoic Poulain 828ca93cee5SLoic Poulain /* Before switching the device into operational mode and with that 829ca93cee5SLoic Poulain * booting the loaded firmware, wait for the bootloader notification 830ca93cee5SLoic Poulain * that all fragments have been successfully received. 831ca93cee5SLoic Poulain * 832ca93cee5SLoic Poulain * When the event processing receives the notification, then the 833ca93cee5SLoic Poulain * STATE_DOWNLOADING flag will be cleared. 834ca93cee5SLoic Poulain * 835ca93cee5SLoic Poulain * The firmware loading should not take longer than 5 seconds 836ca93cee5SLoic Poulain * and thus just timeout if that happens and fail the setup 837ca93cee5SLoic Poulain * of this device. 838ca93cee5SLoic Poulain */ 839ca93cee5SLoic Poulain err = wait_on_bit_timeout(&intel->flags, STATE_DOWNLOADING, 840ca93cee5SLoic Poulain TASK_INTERRUPTIBLE, 841ca93cee5SLoic Poulain msecs_to_jiffies(5000)); 842ca93cee5SLoic Poulain if (err == 1) { 843f44e78a5SLoic Poulain bt_dev_err(hdev, "Firmware loading interrupted"); 844ca93cee5SLoic Poulain err = -EINTR; 845ca93cee5SLoic Poulain goto done; 846ca93cee5SLoic Poulain } 847ca93cee5SLoic Poulain 848ca93cee5SLoic Poulain if (err) { 849f44e78a5SLoic Poulain bt_dev_err(hdev, "Firmware loading timeout"); 850ca93cee5SLoic Poulain err = -ETIMEDOUT; 851ca93cee5SLoic Poulain goto done; 852ca93cee5SLoic Poulain } 853ca93cee5SLoic Poulain 854ca93cee5SLoic Poulain if (test_bit(STATE_FIRMWARE_FAILED, &intel->flags)) { 855f44e78a5SLoic Poulain bt_dev_err(hdev, "Firmware loading failed"); 856ca93cee5SLoic Poulain err = -ENOEXEC; 857ca93cee5SLoic Poulain goto done; 858ca93cee5SLoic Poulain } 859ca93cee5SLoic Poulain 860ca93cee5SLoic Poulain rettime = ktime_get(); 861ca93cee5SLoic Poulain delta = ktime_sub(rettime, calltime); 862ca93cee5SLoic Poulain duration = (unsigned long long) ktime_to_ns(delta) >> 10; 863ca93cee5SLoic Poulain 864f44e78a5SLoic Poulain bt_dev_info(hdev, "Firmware loaded in %llu usecs", duration); 865ca93cee5SLoic Poulain 866ca93cee5SLoic Poulain done: 867ca93cee5SLoic Poulain release_firmware(fw); 868ca93cee5SLoic Poulain 869ca93cee5SLoic Poulain if (err < 0) 870ca93cee5SLoic Poulain return err; 871ca93cee5SLoic Poulain 872ff289559SLoic Poulain /* We need to restore the default speed before Intel reset */ 873ff289559SLoic Poulain if (speed_change) { 874ff289559SLoic Poulain err = intel_set_baudrate(hu, init_speed); 875ff289559SLoic Poulain if (err) 876ff289559SLoic Poulain return err; 877ff289559SLoic Poulain } 878ff289559SLoic Poulain 879ca93cee5SLoic Poulain calltime = ktime_get(); 880ca93cee5SLoic Poulain 881ca93cee5SLoic Poulain set_bit(STATE_BOOTING, &intel->flags); 882ca93cee5SLoic Poulain 883ca93cee5SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc01, sizeof(reset_param), reset_param, 884ca93cee5SLoic Poulain HCI_INIT_TIMEOUT); 885ca93cee5SLoic Poulain if (IS_ERR(skb)) 886ca93cee5SLoic Poulain return PTR_ERR(skb); 887ca93cee5SLoic Poulain 888ca93cee5SLoic Poulain kfree_skb(skb); 889ca93cee5SLoic Poulain 890ca93cee5SLoic Poulain /* The bootloader will not indicate when the device is ready. This 891ca93cee5SLoic Poulain * is done by the operational firmware sending bootup notification. 892ca93cee5SLoic Poulain * 893ca93cee5SLoic Poulain * Booting into operational firmware should not take longer than 894ca93cee5SLoic Poulain * 1 second. However if that happens, then just fail the setup 895ca93cee5SLoic Poulain * since something went wrong. 896ca93cee5SLoic Poulain */ 897f44e78a5SLoic Poulain bt_dev_info(hdev, "Waiting for device to boot"); 898ca93cee5SLoic Poulain 8991ab1f239SLoic Poulain err = intel_wait_booting(hu); 9001ab1f239SLoic Poulain if (err) 9011ab1f239SLoic Poulain return err; 902ca93cee5SLoic Poulain 9031ab1f239SLoic Poulain clear_bit(STATE_BOOTING, &intel->flags); 904ca93cee5SLoic Poulain 905ca93cee5SLoic Poulain rettime = ktime_get(); 906ca93cee5SLoic Poulain delta = ktime_sub(rettime, calltime); 907ca93cee5SLoic Poulain duration = (unsigned long long) ktime_to_ns(delta) >> 10; 908ca93cee5SLoic Poulain 909f44e78a5SLoic Poulain bt_dev_info(hdev, "Device booted in %llu usecs", duration); 910ca93cee5SLoic Poulain 911b98469f4SLoic Poulain /* Enable LPM if matching pdev with wakeup enabled */ 91267c8bde0SLoic Poulain mutex_lock(&intel_device_list_lock); 913b98469f4SLoic Poulain list_for_each(p, &intel_device_list) { 914b98469f4SLoic Poulain struct intel_device *dev = list_entry(p, struct intel_device, 915b98469f4SLoic Poulain list); 916b98469f4SLoic Poulain if (hu->tty->dev->parent == dev->pdev->dev.parent) { 917b98469f4SLoic Poulain if (device_may_wakeup(&dev->pdev->dev)) 918b98469f4SLoic Poulain idev = dev; 919b98469f4SLoic Poulain break; 920b98469f4SLoic Poulain } 921b98469f4SLoic Poulain } 92267c8bde0SLoic Poulain mutex_unlock(&intel_device_list_lock); 923b98469f4SLoic Poulain 924b98469f4SLoic Poulain if (!idev) 925b98469f4SLoic Poulain goto no_lpm; 926b98469f4SLoic Poulain 927f44e78a5SLoic Poulain bt_dev_info(hdev, "Enabling LPM"); 928b98469f4SLoic Poulain 929b98469f4SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc8b, sizeof(lpm_param), lpm_param, 930b98469f4SLoic Poulain HCI_CMD_TIMEOUT); 931b98469f4SLoic Poulain if (IS_ERR(skb)) { 932f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to enable LPM"); 933b98469f4SLoic Poulain goto no_lpm; 934b98469f4SLoic Poulain } 935b98469f4SLoic Poulain kfree_skb(skb); 936b98469f4SLoic Poulain 937b98469f4SLoic Poulain set_bit(STATE_LPM_ENABLED, &intel->flags); 938b98469f4SLoic Poulain 939b98469f4SLoic Poulain no_lpm: 9401cfbabddSLoic Poulain /* Ignore errors, device can work without DDC parameters */ 9411cfbabddSLoic Poulain btintel_load_ddc_config(hdev, fwname); 9421cfbabddSLoic Poulain 943ff289559SLoic Poulain skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_CMD_TIMEOUT); 944ff289559SLoic Poulain if (IS_ERR(skb)) 945ff289559SLoic Poulain return PTR_ERR(skb); 946ff289559SLoic Poulain kfree_skb(skb); 947ff289559SLoic Poulain 948ff289559SLoic Poulain if (speed_change) { 949ff289559SLoic Poulain err = intel_set_baudrate(hu, oper_speed); 950ff289559SLoic Poulain if (err) 951ff289559SLoic Poulain return err; 952ff289559SLoic Poulain } 953ff289559SLoic Poulain 954f44e78a5SLoic Poulain bt_dev_info(hdev, "Setup complete"); 955ff289559SLoic Poulain 956ca93cee5SLoic Poulain clear_bit(STATE_BOOTLOADER, &intel->flags); 957ca93cee5SLoic Poulain 958ca93cee5SLoic Poulain return 0; 959ca93cee5SLoic Poulain } 960ca93cee5SLoic Poulain 961ca93cee5SLoic Poulain static int intel_recv_event(struct hci_dev *hdev, struct sk_buff *skb) 962ca93cee5SLoic Poulain { 963ca93cee5SLoic Poulain struct hci_uart *hu = hci_get_drvdata(hdev); 964ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 965ca93cee5SLoic Poulain struct hci_event_hdr *hdr; 966ca93cee5SLoic Poulain 9671ab1f239SLoic Poulain if (!test_bit(STATE_BOOTLOADER, &intel->flags) && 9681ab1f239SLoic Poulain !test_bit(STATE_BOOTING, &intel->flags)) 969ca93cee5SLoic Poulain goto recv; 970ca93cee5SLoic Poulain 971ca93cee5SLoic Poulain hdr = (void *)skb->data; 972ca93cee5SLoic Poulain 973ca93cee5SLoic Poulain /* When the firmware loading completes the device sends 974ca93cee5SLoic Poulain * out a vendor specific event indicating the result of 975ca93cee5SLoic Poulain * the firmware loading. 976ca93cee5SLoic Poulain */ 977ca93cee5SLoic Poulain if (skb->len == 7 && hdr->evt == 0xff && hdr->plen == 0x05 && 978ca93cee5SLoic Poulain skb->data[2] == 0x06) { 979ca93cee5SLoic Poulain if (skb->data[3] != 0x00) 980ca93cee5SLoic Poulain set_bit(STATE_FIRMWARE_FAILED, &intel->flags); 981ca93cee5SLoic Poulain 982ca93cee5SLoic Poulain if (test_and_clear_bit(STATE_DOWNLOADING, &intel->flags) && 983ca93cee5SLoic Poulain test_bit(STATE_FIRMWARE_LOADED, &intel->flags)) { 984ca93cee5SLoic Poulain smp_mb__after_atomic(); 985ca93cee5SLoic Poulain wake_up_bit(&intel->flags, STATE_DOWNLOADING); 986ca93cee5SLoic Poulain } 987ca93cee5SLoic Poulain 988ca93cee5SLoic Poulain /* When switching to the operational firmware the device 989ca93cee5SLoic Poulain * sends a vendor specific event indicating that the bootup 990ca93cee5SLoic Poulain * completed. 991ca93cee5SLoic Poulain */ 992ca93cee5SLoic Poulain } else if (skb->len == 9 && hdr->evt == 0xff && hdr->plen == 0x07 && 993ca93cee5SLoic Poulain skb->data[2] == 0x02) { 994ca93cee5SLoic Poulain if (test_and_clear_bit(STATE_BOOTING, &intel->flags)) { 995ca93cee5SLoic Poulain smp_mb__after_atomic(); 996ca93cee5SLoic Poulain wake_up_bit(&intel->flags, STATE_BOOTING); 997ca93cee5SLoic Poulain } 998ca93cee5SLoic Poulain } 999ca93cee5SLoic Poulain recv: 1000ca93cee5SLoic Poulain return hci_recv_frame(hdev, skb); 1001ca93cee5SLoic Poulain } 1002ca93cee5SLoic Poulain 1003b98469f4SLoic Poulain static void intel_recv_lpm_notify(struct hci_dev *hdev, int value) 1004b98469f4SLoic Poulain { 1005b98469f4SLoic Poulain struct hci_uart *hu = hci_get_drvdata(hdev); 1006b98469f4SLoic Poulain struct intel_data *intel = hu->priv; 1007b98469f4SLoic Poulain 1008f44e78a5SLoic Poulain bt_dev_dbg(hdev, "TX idle notification (%d)", value); 1009b98469f4SLoic Poulain 101074cdad37SLoic Poulain if (value) { 1011b98469f4SLoic Poulain set_bit(STATE_TX_ACTIVE, &intel->flags); 101274cdad37SLoic Poulain schedule_work(&intel->busy_work); 101374cdad37SLoic Poulain } else { 1014b98469f4SLoic Poulain clear_bit(STATE_TX_ACTIVE, &intel->flags); 1015b98469f4SLoic Poulain } 101674cdad37SLoic Poulain } 1017b98469f4SLoic Poulain 1018b98469f4SLoic Poulain static int intel_recv_lpm(struct hci_dev *hdev, struct sk_buff *skb) 1019b98469f4SLoic Poulain { 1020b98469f4SLoic Poulain struct hci_lpm_pkt *lpm = (void *)skb->data; 102189436546SLoic Poulain struct hci_uart *hu = hci_get_drvdata(hdev); 102289436546SLoic Poulain struct intel_data *intel = hu->priv; 1023b98469f4SLoic Poulain 1024b98469f4SLoic Poulain switch (lpm->opcode) { 1025b98469f4SLoic Poulain case LPM_OP_TX_NOTIFY: 10261b197574SLoic Poulain if (lpm->dlen < 1) { 10271b197574SLoic Poulain bt_dev_err(hu->hdev, "Invalid LPM notification packet"); 10281b197574SLoic Poulain break; 10291b197574SLoic Poulain } 1030b98469f4SLoic Poulain intel_recv_lpm_notify(hdev, lpm->data[0]); 1031b98469f4SLoic Poulain break; 103289436546SLoic Poulain case LPM_OP_SUSPEND_ACK: 103389436546SLoic Poulain set_bit(STATE_SUSPENDED, &intel->flags); 103489436546SLoic Poulain if (test_and_clear_bit(STATE_LPM_TRANSACTION, &intel->flags)) { 103589436546SLoic Poulain smp_mb__after_atomic(); 103689436546SLoic Poulain wake_up_bit(&intel->flags, STATE_LPM_TRANSACTION); 103789436546SLoic Poulain } 103889436546SLoic Poulain break; 103989436546SLoic Poulain case LPM_OP_RESUME_ACK: 104089436546SLoic Poulain clear_bit(STATE_SUSPENDED, &intel->flags); 104189436546SLoic Poulain if (test_and_clear_bit(STATE_LPM_TRANSACTION, &intel->flags)) { 104289436546SLoic Poulain smp_mb__after_atomic(); 104389436546SLoic Poulain wake_up_bit(&intel->flags, STATE_LPM_TRANSACTION); 104489436546SLoic Poulain } 104589436546SLoic Poulain break; 1046b98469f4SLoic Poulain default: 1047f44e78a5SLoic Poulain bt_dev_err(hdev, "Unknown LPM opcode (%02x)", lpm->opcode); 1048b98469f4SLoic Poulain break; 1049b98469f4SLoic Poulain } 1050b98469f4SLoic Poulain 1051b98469f4SLoic Poulain kfree_skb(skb); 1052b98469f4SLoic Poulain 1053b98469f4SLoic Poulain return 0; 1054b98469f4SLoic Poulain } 1055b98469f4SLoic Poulain 1056b98469f4SLoic Poulain #define INTEL_RECV_LPM \ 1057b98469f4SLoic Poulain .type = HCI_LPM_PKT, \ 1058b98469f4SLoic Poulain .hlen = HCI_LPM_HDR_SIZE, \ 1059b98469f4SLoic Poulain .loff = 1, \ 1060b98469f4SLoic Poulain .lsize = 1, \ 1061b98469f4SLoic Poulain .maxlen = HCI_LPM_MAX_SIZE 1062b98469f4SLoic Poulain 1063ca93cee5SLoic Poulain static const struct h4_recv_pkt intel_recv_pkts[] = { 1064ca93cee5SLoic Poulain { H4_RECV_ACL, .recv = hci_recv_frame }, 1065ca93cee5SLoic Poulain { H4_RECV_SCO, .recv = hci_recv_frame }, 1066ca93cee5SLoic Poulain { H4_RECV_EVENT, .recv = intel_recv_event }, 1067b98469f4SLoic Poulain { INTEL_RECV_LPM, .recv = intel_recv_lpm }, 1068ca93cee5SLoic Poulain }; 1069ca93cee5SLoic Poulain 1070ca93cee5SLoic Poulain static int intel_recv(struct hci_uart *hu, const void *data, int count) 1071ca93cee5SLoic Poulain { 1072ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 1073ca93cee5SLoic Poulain 1074ca93cee5SLoic Poulain if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 1075ca93cee5SLoic Poulain return -EUNATCH; 1076ca93cee5SLoic Poulain 1077ca93cee5SLoic Poulain intel->rx_skb = h4_recv_buf(hu->hdev, intel->rx_skb, data, count, 1078ca93cee5SLoic Poulain intel_recv_pkts, 1079ca93cee5SLoic Poulain ARRAY_SIZE(intel_recv_pkts)); 1080ca93cee5SLoic Poulain if (IS_ERR(intel->rx_skb)) { 1081ca93cee5SLoic Poulain int err = PTR_ERR(intel->rx_skb); 1082f44e78a5SLoic Poulain bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err); 1083ca93cee5SLoic Poulain intel->rx_skb = NULL; 1084ca93cee5SLoic Poulain return err; 1085ca93cee5SLoic Poulain } 1086ca93cee5SLoic Poulain 1087ca93cee5SLoic Poulain return count; 1088ca93cee5SLoic Poulain } 1089ca93cee5SLoic Poulain 1090ca93cee5SLoic Poulain static int intel_enqueue(struct hci_uart *hu, struct sk_buff *skb) 1091ca93cee5SLoic Poulain { 1092ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 109374cdad37SLoic Poulain struct list_head *p; 1094ca93cee5SLoic Poulain 1095ca93cee5SLoic Poulain BT_DBG("hu %p skb %p", hu, skb); 1096ca93cee5SLoic Poulain 109774cdad37SLoic Poulain /* Be sure our controller is resumed and potential LPM transaction 109874cdad37SLoic Poulain * completed before enqueuing any packet. 109974cdad37SLoic Poulain */ 110074cdad37SLoic Poulain mutex_lock(&intel_device_list_lock); 110174cdad37SLoic Poulain list_for_each(p, &intel_device_list) { 110274cdad37SLoic Poulain struct intel_device *idev = list_entry(p, struct intel_device, 110374cdad37SLoic Poulain list); 110474cdad37SLoic Poulain 110574cdad37SLoic Poulain if (hu->tty->dev->parent == idev->pdev->dev.parent) { 110674cdad37SLoic Poulain pm_runtime_get_sync(&idev->pdev->dev); 110774cdad37SLoic Poulain pm_runtime_mark_last_busy(&idev->pdev->dev); 110874cdad37SLoic Poulain pm_runtime_put_autosuspend(&idev->pdev->dev); 110974cdad37SLoic Poulain break; 111074cdad37SLoic Poulain } 111174cdad37SLoic Poulain } 111274cdad37SLoic Poulain mutex_unlock(&intel_device_list_lock); 111374cdad37SLoic Poulain 1114ca93cee5SLoic Poulain skb_queue_tail(&intel->txq, skb); 1115ca93cee5SLoic Poulain 1116ca93cee5SLoic Poulain return 0; 1117ca93cee5SLoic Poulain } 1118ca93cee5SLoic Poulain 1119ca93cee5SLoic Poulain static struct sk_buff *intel_dequeue(struct hci_uart *hu) 1120ca93cee5SLoic Poulain { 1121ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 1122ca93cee5SLoic Poulain struct sk_buff *skb; 1123ca93cee5SLoic Poulain 1124ca93cee5SLoic Poulain skb = skb_dequeue(&intel->txq); 1125ca93cee5SLoic Poulain if (!skb) 1126ca93cee5SLoic Poulain return skb; 1127ca93cee5SLoic Poulain 1128ca93cee5SLoic Poulain if (test_bit(STATE_BOOTLOADER, &intel->flags) && 1129*618e8bc2SMarcel Holtmann (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT)) { 1130ca93cee5SLoic Poulain struct hci_command_hdr *cmd = (void *)skb->data; 1131ca93cee5SLoic Poulain __u16 opcode = le16_to_cpu(cmd->opcode); 1132ca93cee5SLoic Poulain 1133ca93cee5SLoic Poulain /* When the 0xfc01 command is issued to boot into 1134ca93cee5SLoic Poulain * the operational firmware, it will actually not 1135ca93cee5SLoic Poulain * send a command complete event. To keep the flow 1136ca93cee5SLoic Poulain * control working inject that event here. 1137ca93cee5SLoic Poulain */ 1138ca93cee5SLoic Poulain if (opcode == 0xfc01) 1139ca93cee5SLoic Poulain inject_cmd_complete(hu->hdev, opcode); 1140ca93cee5SLoic Poulain } 1141ca93cee5SLoic Poulain 1142ca93cee5SLoic Poulain /* Prepend skb with frame type */ 1143*618e8bc2SMarcel Holtmann memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 1144ca93cee5SLoic Poulain 1145ca93cee5SLoic Poulain return skb; 1146ca93cee5SLoic Poulain } 1147ca93cee5SLoic Poulain 1148ca93cee5SLoic Poulain static const struct hci_uart_proto intel_proto = { 1149ca93cee5SLoic Poulain .id = HCI_UART_INTEL, 1150ca93cee5SLoic Poulain .name = "Intel", 1151aee61f7aSMarcel Holtmann .manufacturer = 2, 1152ca93cee5SLoic Poulain .init_speed = 115200, 1153ff289559SLoic Poulain .oper_speed = 3000000, 1154ca93cee5SLoic Poulain .open = intel_open, 1155ca93cee5SLoic Poulain .close = intel_close, 1156ca93cee5SLoic Poulain .flush = intel_flush, 1157ca93cee5SLoic Poulain .setup = intel_setup, 1158ff289559SLoic Poulain .set_baudrate = intel_set_baudrate, 1159ca93cee5SLoic Poulain .recv = intel_recv, 1160ca93cee5SLoic Poulain .enqueue = intel_enqueue, 1161ca93cee5SLoic Poulain .dequeue = intel_dequeue, 1162ca93cee5SLoic Poulain }; 1163ca93cee5SLoic Poulain 11641ab1f239SLoic Poulain #ifdef CONFIG_ACPI 11651ab1f239SLoic Poulain static const struct acpi_device_id intel_acpi_match[] = { 11661ab1f239SLoic Poulain { "INT33E1", 0 }, 11671ab1f239SLoic Poulain { }, 11681ab1f239SLoic Poulain }; 11691ab1f239SLoic Poulain MODULE_DEVICE_TABLE(acpi, intel_acpi_match); 11701ab1f239SLoic Poulain #endif 11711ab1f239SLoic Poulain 117274cdad37SLoic Poulain #ifdef CONFIG_PM 1173f7552473SLoic Poulain static int intel_suspend_device(struct device *dev) 1174aa6802dfSLoic Poulain { 1175aa6802dfSLoic Poulain struct intel_device *idev = dev_get_drvdata(dev); 1176aa6802dfSLoic Poulain 1177aa6802dfSLoic Poulain mutex_lock(&idev->hu_lock); 1178aa6802dfSLoic Poulain if (idev->hu) 1179aa6802dfSLoic Poulain intel_lpm_suspend(idev->hu); 1180aa6802dfSLoic Poulain mutex_unlock(&idev->hu_lock); 1181aa6802dfSLoic Poulain 1182aa6802dfSLoic Poulain return 0; 1183aa6802dfSLoic Poulain } 1184aa6802dfSLoic Poulain 1185f7552473SLoic Poulain static int intel_resume_device(struct device *dev) 1186aa6802dfSLoic Poulain { 1187aa6802dfSLoic Poulain struct intel_device *idev = dev_get_drvdata(dev); 1188aa6802dfSLoic Poulain 1189aa6802dfSLoic Poulain mutex_lock(&idev->hu_lock); 1190aa6802dfSLoic Poulain if (idev->hu) 1191aa6802dfSLoic Poulain intel_lpm_resume(idev->hu); 1192aa6802dfSLoic Poulain mutex_unlock(&idev->hu_lock); 1193aa6802dfSLoic Poulain 1194aa6802dfSLoic Poulain return 0; 1195aa6802dfSLoic Poulain } 1196aa6802dfSLoic Poulain #endif 1197aa6802dfSLoic Poulain 1198f7552473SLoic Poulain #ifdef CONFIG_PM_SLEEP 1199f7552473SLoic Poulain static int intel_suspend(struct device *dev) 1200f7552473SLoic Poulain { 1201f7552473SLoic Poulain struct intel_device *idev = dev_get_drvdata(dev); 1202f7552473SLoic Poulain 1203f7552473SLoic Poulain if (device_may_wakeup(dev)) 1204f7552473SLoic Poulain enable_irq_wake(idev->irq); 1205f7552473SLoic Poulain 1206f7552473SLoic Poulain return intel_suspend_device(dev); 1207f7552473SLoic Poulain } 1208f7552473SLoic Poulain 1209f7552473SLoic Poulain static int intel_resume(struct device *dev) 1210f7552473SLoic Poulain { 1211f7552473SLoic Poulain struct intel_device *idev = dev_get_drvdata(dev); 1212f7552473SLoic Poulain 1213f7552473SLoic Poulain if (device_may_wakeup(dev)) 1214f7552473SLoic Poulain disable_irq_wake(idev->irq); 1215f7552473SLoic Poulain 1216f7552473SLoic Poulain return intel_resume_device(dev); 1217f7552473SLoic Poulain } 1218f7552473SLoic Poulain #endif 1219f7552473SLoic Poulain 1220aa6802dfSLoic Poulain static const struct dev_pm_ops intel_pm_ops = { 1221aa6802dfSLoic Poulain SET_SYSTEM_SLEEP_PM_OPS(intel_suspend, intel_resume) 1222f7552473SLoic Poulain SET_RUNTIME_PM_OPS(intel_suspend_device, intel_resume_device, NULL) 1223aa6802dfSLoic Poulain }; 1224aa6802dfSLoic Poulain 12251ab1f239SLoic Poulain static int intel_probe(struct platform_device *pdev) 12261ab1f239SLoic Poulain { 12271ab1f239SLoic Poulain struct intel_device *idev; 12281ab1f239SLoic Poulain 12291ab1f239SLoic Poulain idev = devm_kzalloc(&pdev->dev, sizeof(*idev), GFP_KERNEL); 12301ab1f239SLoic Poulain if (!idev) 12311ab1f239SLoic Poulain return -ENOMEM; 12321ab1f239SLoic Poulain 1233aa6802dfSLoic Poulain mutex_init(&idev->hu_lock); 1234aa6802dfSLoic Poulain 12351ab1f239SLoic Poulain idev->pdev = pdev; 12361ab1f239SLoic Poulain 12371ab1f239SLoic Poulain idev->reset = devm_gpiod_get_optional(&pdev->dev, "reset", 12381ab1f239SLoic Poulain GPIOD_OUT_LOW); 12391ab1f239SLoic Poulain if (IS_ERR(idev->reset)) { 12401ab1f239SLoic Poulain dev_err(&pdev->dev, "Unable to retrieve gpio\n"); 12411ab1f239SLoic Poulain return PTR_ERR(idev->reset); 12421ab1f239SLoic Poulain } 12431ab1f239SLoic Poulain 1244765ea3abSLoic Poulain idev->irq = platform_get_irq(pdev, 0); 1245765ea3abSLoic Poulain if (idev->irq < 0) { 1246765ea3abSLoic Poulain struct gpio_desc *host_wake; 1247765ea3abSLoic Poulain 1248765ea3abSLoic Poulain dev_err(&pdev->dev, "No IRQ, falling back to gpio-irq\n"); 1249765ea3abSLoic Poulain 1250765ea3abSLoic Poulain host_wake = devm_gpiod_get_optional(&pdev->dev, "host-wake", 1251765ea3abSLoic Poulain GPIOD_IN); 1252765ea3abSLoic Poulain if (IS_ERR(host_wake)) { 1253765ea3abSLoic Poulain dev_err(&pdev->dev, "Unable to retrieve IRQ\n"); 1254765ea3abSLoic Poulain goto no_irq; 1255765ea3abSLoic Poulain } 1256765ea3abSLoic Poulain 1257765ea3abSLoic Poulain idev->irq = gpiod_to_irq(host_wake); 1258765ea3abSLoic Poulain if (idev->irq < 0) { 1259765ea3abSLoic Poulain dev_err(&pdev->dev, "No corresponding irq for gpio\n"); 1260765ea3abSLoic Poulain goto no_irq; 1261765ea3abSLoic Poulain } 1262765ea3abSLoic Poulain } 1263765ea3abSLoic Poulain 1264765ea3abSLoic Poulain /* Only enable wake-up/irq when controller is powered */ 1265765ea3abSLoic Poulain device_set_wakeup_capable(&pdev->dev, true); 1266765ea3abSLoic Poulain device_wakeup_disable(&pdev->dev); 1267765ea3abSLoic Poulain 1268765ea3abSLoic Poulain no_irq: 12691ab1f239SLoic Poulain platform_set_drvdata(pdev, idev); 12701ab1f239SLoic Poulain 12711ab1f239SLoic Poulain /* Place this instance on the device list */ 127267c8bde0SLoic Poulain mutex_lock(&intel_device_list_lock); 12731ab1f239SLoic Poulain list_add_tail(&idev->list, &intel_device_list); 127467c8bde0SLoic Poulain mutex_unlock(&intel_device_list_lock); 12751ab1f239SLoic Poulain 1276765ea3abSLoic Poulain dev_info(&pdev->dev, "registered, gpio(%d)/irq(%d).\n", 1277765ea3abSLoic Poulain desc_to_gpio(idev->reset), idev->irq); 12781ab1f239SLoic Poulain 12791ab1f239SLoic Poulain return 0; 12801ab1f239SLoic Poulain } 12811ab1f239SLoic Poulain 12821ab1f239SLoic Poulain static int intel_remove(struct platform_device *pdev) 12831ab1f239SLoic Poulain { 12841ab1f239SLoic Poulain struct intel_device *idev = platform_get_drvdata(pdev); 12851ab1f239SLoic Poulain 1286765ea3abSLoic Poulain device_wakeup_disable(&pdev->dev); 1287765ea3abSLoic Poulain 128867c8bde0SLoic Poulain mutex_lock(&intel_device_list_lock); 12891ab1f239SLoic Poulain list_del(&idev->list); 129067c8bde0SLoic Poulain mutex_unlock(&intel_device_list_lock); 12911ab1f239SLoic Poulain 12921ab1f239SLoic Poulain dev_info(&pdev->dev, "unregistered.\n"); 12931ab1f239SLoic Poulain 12941ab1f239SLoic Poulain return 0; 12951ab1f239SLoic Poulain } 12961ab1f239SLoic Poulain 12971ab1f239SLoic Poulain static struct platform_driver intel_driver = { 12981ab1f239SLoic Poulain .probe = intel_probe, 12991ab1f239SLoic Poulain .remove = intel_remove, 13001ab1f239SLoic Poulain .driver = { 13011ab1f239SLoic Poulain .name = "hci_intel", 13021ab1f239SLoic Poulain .acpi_match_table = ACPI_PTR(intel_acpi_match), 1303aa6802dfSLoic Poulain .pm = &intel_pm_ops, 13041ab1f239SLoic Poulain }, 13051ab1f239SLoic Poulain }; 13061ab1f239SLoic Poulain 1307ca93cee5SLoic Poulain int __init intel_init(void) 1308ca93cee5SLoic Poulain { 13091ab1f239SLoic Poulain platform_driver_register(&intel_driver); 13101ab1f239SLoic Poulain 1311ca93cee5SLoic Poulain return hci_uart_register_proto(&intel_proto); 1312ca93cee5SLoic Poulain } 1313ca93cee5SLoic Poulain 1314ca93cee5SLoic Poulain int __exit intel_deinit(void) 1315ca93cee5SLoic Poulain { 13161ab1f239SLoic Poulain platform_driver_unregister(&intel_driver); 13171ab1f239SLoic Poulain 1318ca93cee5SLoic Poulain return hci_uart_unregister_proto(&intel_proto); 1319ca93cee5SLoic Poulain } 1320