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> 3516e3887fSMarcel Holtmann 3616e3887fSMarcel Holtmann #include <net/bluetooth/bluetooth.h> 3716e3887fSMarcel Holtmann #include <net/bluetooth/hci_core.h> 3816e3887fSMarcel Holtmann 3916e3887fSMarcel Holtmann #include "hci_uart.h" 40ca93cee5SLoic Poulain #include "btintel.h" 41ca93cee5SLoic Poulain 42ca93cee5SLoic Poulain #define STATE_BOOTLOADER 0 43ca93cee5SLoic Poulain #define STATE_DOWNLOADING 1 44ca93cee5SLoic Poulain #define STATE_FIRMWARE_LOADED 2 45ca93cee5SLoic Poulain #define STATE_FIRMWARE_FAILED 3 46ca93cee5SLoic Poulain #define STATE_BOOTING 4 47b98469f4SLoic Poulain #define STATE_LPM_ENABLED 5 48b98469f4SLoic Poulain #define STATE_TX_ACTIVE 6 49*89436546SLoic Poulain #define STATE_SUSPENDED 7 50*89436546SLoic Poulain #define STATE_LPM_TRANSACTION 8 51b98469f4SLoic Poulain 52*89436546SLoic Poulain #define HCI_LPM_WAKE_PKT 0xf0 53b98469f4SLoic Poulain #define HCI_LPM_PKT 0xf1 54b98469f4SLoic Poulain #define HCI_LPM_MAX_SIZE 10 55b98469f4SLoic Poulain #define HCI_LPM_HDR_SIZE HCI_EVENT_HDR_SIZE 56b98469f4SLoic Poulain 57b98469f4SLoic Poulain #define LPM_OP_TX_NOTIFY 0x00 58*89436546SLoic Poulain #define LPM_OP_SUSPEND_ACK 0x02 59*89436546SLoic Poulain #define LPM_OP_RESUME_ACK 0x03 60b98469f4SLoic Poulain 61b98469f4SLoic Poulain struct hci_lpm_pkt { 62b98469f4SLoic Poulain __u8 opcode; 63b98469f4SLoic Poulain __u8 dlen; 64b98469f4SLoic Poulain __u8 data[0]; 65b98469f4SLoic Poulain } __packed; 66ca93cee5SLoic Poulain 671ab1f239SLoic Poulain struct intel_device { 681ab1f239SLoic Poulain struct list_head list; 691ab1f239SLoic Poulain struct platform_device *pdev; 701ab1f239SLoic Poulain struct gpio_desc *reset; 71765ea3abSLoic Poulain int irq; 721ab1f239SLoic Poulain }; 731ab1f239SLoic Poulain 741ab1f239SLoic Poulain static LIST_HEAD(intel_device_list); 7567c8bde0SLoic Poulain static DEFINE_MUTEX(intel_device_list_lock); 761ab1f239SLoic Poulain 77ca93cee5SLoic Poulain struct intel_data { 78ca93cee5SLoic Poulain struct sk_buff *rx_skb; 79ca93cee5SLoic Poulain struct sk_buff_head txq; 80ca93cee5SLoic Poulain unsigned long flags; 81ca93cee5SLoic Poulain }; 82ca93cee5SLoic Poulain 83ff289559SLoic Poulain static u8 intel_convert_speed(unsigned int speed) 84ff289559SLoic Poulain { 85ff289559SLoic Poulain switch (speed) { 86ff289559SLoic Poulain case 9600: 87ff289559SLoic Poulain return 0x00; 88ff289559SLoic Poulain case 19200: 89ff289559SLoic Poulain return 0x01; 90ff289559SLoic Poulain case 38400: 91ff289559SLoic Poulain return 0x02; 92ff289559SLoic Poulain case 57600: 93ff289559SLoic Poulain return 0x03; 94ff289559SLoic Poulain case 115200: 95ff289559SLoic Poulain return 0x04; 96ff289559SLoic Poulain case 230400: 97ff289559SLoic Poulain return 0x05; 98ff289559SLoic Poulain case 460800: 99ff289559SLoic Poulain return 0x06; 100ff289559SLoic Poulain case 921600: 101ff289559SLoic Poulain return 0x07; 102ff289559SLoic Poulain case 1843200: 103ff289559SLoic Poulain return 0x08; 104ff289559SLoic Poulain case 3250000: 105ff289559SLoic Poulain return 0x09; 106ff289559SLoic Poulain case 2000000: 107ff289559SLoic Poulain return 0x0a; 108ff289559SLoic Poulain case 3000000: 109ff289559SLoic Poulain return 0x0b; 110ff289559SLoic Poulain default: 111ff289559SLoic Poulain return 0xff; 112ff289559SLoic Poulain } 113ff289559SLoic Poulain } 114ff289559SLoic Poulain 1151ab1f239SLoic Poulain static int intel_wait_booting(struct hci_uart *hu) 1161ab1f239SLoic Poulain { 1171ab1f239SLoic Poulain struct intel_data *intel = hu->priv; 1181ab1f239SLoic Poulain int err; 1191ab1f239SLoic Poulain 1201ab1f239SLoic Poulain err = wait_on_bit_timeout(&intel->flags, STATE_BOOTING, 1211ab1f239SLoic Poulain TASK_INTERRUPTIBLE, 1221ab1f239SLoic Poulain msecs_to_jiffies(1000)); 1231ab1f239SLoic Poulain 1241ab1f239SLoic Poulain if (err == 1) { 125f44e78a5SLoic Poulain bt_dev_err(hu->hdev, "Device boot interrupted"); 1261ab1f239SLoic Poulain return -EINTR; 1271ab1f239SLoic Poulain } 1281ab1f239SLoic Poulain 1291ab1f239SLoic Poulain if (err) { 130f44e78a5SLoic Poulain bt_dev_err(hu->hdev, "Device boot timeout"); 1311ab1f239SLoic Poulain return -ETIMEDOUT; 1321ab1f239SLoic Poulain } 1331ab1f239SLoic Poulain 1341ab1f239SLoic Poulain return err; 1351ab1f239SLoic Poulain } 1361ab1f239SLoic Poulain 137*89436546SLoic Poulain static int intel_wait_lpm_transaction(struct hci_uart *hu) 138*89436546SLoic Poulain { 139*89436546SLoic Poulain struct intel_data *intel = hu->priv; 140*89436546SLoic Poulain int err; 141*89436546SLoic Poulain 142*89436546SLoic Poulain err = wait_on_bit_timeout(&intel->flags, STATE_LPM_TRANSACTION, 143*89436546SLoic Poulain TASK_INTERRUPTIBLE, 144*89436546SLoic Poulain msecs_to_jiffies(1000)); 145*89436546SLoic Poulain 146*89436546SLoic Poulain if (err == 1) { 147*89436546SLoic Poulain bt_dev_err(hu->hdev, "LPM transaction interrupted"); 148*89436546SLoic Poulain return -EINTR; 149*89436546SLoic Poulain } 150*89436546SLoic Poulain 151*89436546SLoic Poulain if (err) { 152*89436546SLoic Poulain bt_dev_err(hu->hdev, "LPM transaction timeout"); 153*89436546SLoic Poulain return -ETIMEDOUT; 154*89436546SLoic Poulain } 155*89436546SLoic Poulain 156*89436546SLoic Poulain return err; 157*89436546SLoic Poulain } 158*89436546SLoic Poulain 159*89436546SLoic Poulain static int intel_lpm_suspend(struct hci_uart *hu) 160*89436546SLoic Poulain { 161*89436546SLoic Poulain static const u8 suspend[] = { 0x01, 0x01, 0x01 }; 162*89436546SLoic Poulain struct intel_data *intel = hu->priv; 163*89436546SLoic Poulain struct sk_buff *skb; 164*89436546SLoic Poulain 165*89436546SLoic Poulain if (!test_bit(STATE_LPM_ENABLED, &intel->flags) || 166*89436546SLoic Poulain test_bit(STATE_SUSPENDED, &intel->flags)) 167*89436546SLoic Poulain return 0; 168*89436546SLoic Poulain 169*89436546SLoic Poulain if (test_bit(STATE_TX_ACTIVE, &intel->flags)) 170*89436546SLoic Poulain return -EAGAIN; 171*89436546SLoic Poulain 172*89436546SLoic Poulain bt_dev_dbg(hu->hdev, "Suspending"); 173*89436546SLoic Poulain 174*89436546SLoic Poulain skb = bt_skb_alloc(sizeof(suspend), GFP_KERNEL); 175*89436546SLoic Poulain if (!skb) { 176*89436546SLoic Poulain bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 177*89436546SLoic Poulain return -ENOMEM; 178*89436546SLoic Poulain } 179*89436546SLoic Poulain 180*89436546SLoic Poulain memcpy(skb_put(skb, sizeof(suspend)), suspend, sizeof(suspend)); 181*89436546SLoic Poulain bt_cb(skb)->pkt_type = HCI_LPM_PKT; 182*89436546SLoic Poulain 183*89436546SLoic Poulain set_bit(STATE_LPM_TRANSACTION, &intel->flags); 184*89436546SLoic Poulain 185*89436546SLoic Poulain skb_queue_tail(&intel->txq, skb); 186*89436546SLoic Poulain hci_uart_tx_wakeup(hu); 187*89436546SLoic Poulain 188*89436546SLoic Poulain intel_wait_lpm_transaction(hu); 189*89436546SLoic Poulain /* Even in case of failure, continue and test the suspended flag */ 190*89436546SLoic Poulain 191*89436546SLoic Poulain clear_bit(STATE_LPM_TRANSACTION, &intel->flags); 192*89436546SLoic Poulain 193*89436546SLoic Poulain if (!test_bit(STATE_SUSPENDED, &intel->flags)) { 194*89436546SLoic Poulain bt_dev_err(hu->hdev, "Device suspend error"); 195*89436546SLoic Poulain return -EINVAL; 196*89436546SLoic Poulain } 197*89436546SLoic Poulain 198*89436546SLoic Poulain bt_dev_dbg(hu->hdev, "Suspended"); 199*89436546SLoic Poulain 200*89436546SLoic Poulain hci_uart_set_flow_control(hu, true); 201*89436546SLoic Poulain 202*89436546SLoic Poulain return 0; 203*89436546SLoic Poulain } 204*89436546SLoic Poulain 205*89436546SLoic Poulain static int intel_lpm_resume(struct hci_uart *hu) 206*89436546SLoic Poulain { 207*89436546SLoic Poulain struct intel_data *intel = hu->priv; 208*89436546SLoic Poulain struct sk_buff *skb; 209*89436546SLoic Poulain 210*89436546SLoic Poulain if (!test_bit(STATE_LPM_ENABLED, &intel->flags) || 211*89436546SLoic Poulain !test_bit(STATE_SUSPENDED, &intel->flags)) 212*89436546SLoic Poulain return 0; 213*89436546SLoic Poulain 214*89436546SLoic Poulain bt_dev_dbg(hu->hdev, "Resuming"); 215*89436546SLoic Poulain 216*89436546SLoic Poulain hci_uart_set_flow_control(hu, false); 217*89436546SLoic Poulain 218*89436546SLoic Poulain skb = bt_skb_alloc(0, GFP_KERNEL); 219*89436546SLoic Poulain if (!skb) { 220*89436546SLoic Poulain bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 221*89436546SLoic Poulain return -ENOMEM; 222*89436546SLoic Poulain } 223*89436546SLoic Poulain 224*89436546SLoic Poulain bt_cb(skb)->pkt_type = HCI_LPM_WAKE_PKT; 225*89436546SLoic Poulain 226*89436546SLoic Poulain set_bit(STATE_LPM_TRANSACTION, &intel->flags); 227*89436546SLoic Poulain 228*89436546SLoic Poulain skb_queue_tail(&intel->txq, skb); 229*89436546SLoic Poulain hci_uart_tx_wakeup(hu); 230*89436546SLoic Poulain 231*89436546SLoic Poulain intel_wait_lpm_transaction(hu); 232*89436546SLoic Poulain /* Even in case of failure, continue and test the suspended flag */ 233*89436546SLoic Poulain 234*89436546SLoic Poulain clear_bit(STATE_LPM_TRANSACTION, &intel->flags); 235*89436546SLoic Poulain 236*89436546SLoic Poulain if (test_bit(STATE_SUSPENDED, &intel->flags)) { 237*89436546SLoic Poulain bt_dev_err(hu->hdev, "Device resume error"); 238*89436546SLoic Poulain return -EINVAL; 239*89436546SLoic Poulain } 240*89436546SLoic Poulain 241*89436546SLoic Poulain bt_dev_dbg(hu->hdev, "Resumed"); 242*89436546SLoic Poulain 243*89436546SLoic Poulain return 0; 244*89436546SLoic Poulain } 245*89436546SLoic Poulain 246*89436546SLoic Poulain static int intel_lpm_host_wake(struct hci_uart *hu) 247*89436546SLoic Poulain { 248*89436546SLoic Poulain static const u8 lpm_resume_ack[] = { LPM_OP_RESUME_ACK, 0x00 }; 249*89436546SLoic Poulain struct intel_data *intel = hu->priv; 250*89436546SLoic Poulain struct sk_buff *skb; 251*89436546SLoic Poulain 252*89436546SLoic Poulain hci_uart_set_flow_control(hu, false); 253*89436546SLoic Poulain 254*89436546SLoic Poulain clear_bit(STATE_SUSPENDED, &intel->flags); 255*89436546SLoic Poulain 256*89436546SLoic Poulain skb = bt_skb_alloc(sizeof(lpm_resume_ack), GFP_KERNEL); 257*89436546SLoic Poulain if (!skb) { 258*89436546SLoic Poulain bt_dev_err(hu->hdev, "Failed to alloc memory for LPM packet"); 259*89436546SLoic Poulain return -ENOMEM; 260*89436546SLoic Poulain } 261*89436546SLoic Poulain 262*89436546SLoic Poulain memcpy(skb_put(skb, sizeof(lpm_resume_ack)), lpm_resume_ack, 263*89436546SLoic Poulain sizeof(lpm_resume_ack)); 264*89436546SLoic Poulain bt_cb(skb)->pkt_type = HCI_LPM_PKT; 265*89436546SLoic Poulain 266*89436546SLoic Poulain skb_queue_tail(&intel->txq, skb); 267*89436546SLoic Poulain hci_uart_tx_wakeup(hu); 268*89436546SLoic Poulain 269*89436546SLoic Poulain bt_dev_dbg(hu->hdev, "Resumed by controller"); 270*89436546SLoic Poulain 271*89436546SLoic Poulain return 0; 272*89436546SLoic Poulain } 273*89436546SLoic Poulain 274765ea3abSLoic Poulain static irqreturn_t intel_irq(int irq, void *dev_id) 275765ea3abSLoic Poulain { 276765ea3abSLoic Poulain struct intel_device *idev = dev_id; 277765ea3abSLoic Poulain 278765ea3abSLoic Poulain dev_info(&idev->pdev->dev, "hci_intel irq\n"); 279765ea3abSLoic Poulain 280765ea3abSLoic Poulain return IRQ_HANDLED; 281765ea3abSLoic Poulain } 282765ea3abSLoic Poulain 2831ab1f239SLoic Poulain static int intel_set_power(struct hci_uart *hu, bool powered) 2841ab1f239SLoic Poulain { 2851ab1f239SLoic Poulain struct list_head *p; 2861ab1f239SLoic Poulain int err = -ENODEV; 2871ab1f239SLoic Poulain 28867c8bde0SLoic Poulain mutex_lock(&intel_device_list_lock); 2891ab1f239SLoic Poulain 2901ab1f239SLoic Poulain list_for_each(p, &intel_device_list) { 2911ab1f239SLoic Poulain struct intel_device *idev = list_entry(p, struct intel_device, 2921ab1f239SLoic Poulain list); 2931ab1f239SLoic Poulain 2941ab1f239SLoic Poulain /* tty device and pdev device should share the same parent 2951ab1f239SLoic Poulain * which is the UART port. 2961ab1f239SLoic Poulain */ 2971ab1f239SLoic Poulain if (hu->tty->dev->parent != idev->pdev->dev.parent) 2981ab1f239SLoic Poulain continue; 2991ab1f239SLoic Poulain 3001ab1f239SLoic Poulain if (!idev->reset) { 3011ab1f239SLoic Poulain err = -ENOTSUPP; 3021ab1f239SLoic Poulain break; 3031ab1f239SLoic Poulain } 3041ab1f239SLoic Poulain 3051ab1f239SLoic Poulain BT_INFO("hu %p, Switching compatible pm device (%s) to %u", 3061ab1f239SLoic Poulain hu, dev_name(&idev->pdev->dev), powered); 3071ab1f239SLoic Poulain 3081ab1f239SLoic Poulain gpiod_set_value(idev->reset, powered); 309765ea3abSLoic Poulain 310765ea3abSLoic Poulain if (idev->irq < 0) 311765ea3abSLoic Poulain break; 312765ea3abSLoic Poulain 313765ea3abSLoic Poulain if (powered && device_can_wakeup(&idev->pdev->dev)) { 314765ea3abSLoic Poulain err = devm_request_threaded_irq(&idev->pdev->dev, 315765ea3abSLoic Poulain idev->irq, NULL, 316765ea3abSLoic Poulain intel_irq, 317765ea3abSLoic Poulain IRQF_ONESHOT, 318765ea3abSLoic Poulain "bt-host-wake", idev); 319765ea3abSLoic Poulain if (err) { 320765ea3abSLoic Poulain BT_ERR("hu %p, unable to allocate irq-%d", 321765ea3abSLoic Poulain hu, idev->irq); 322765ea3abSLoic Poulain break; 323765ea3abSLoic Poulain } 324765ea3abSLoic Poulain 325765ea3abSLoic Poulain device_wakeup_enable(&idev->pdev->dev); 326765ea3abSLoic Poulain } else if (!powered && device_may_wakeup(&idev->pdev->dev)) { 327765ea3abSLoic Poulain devm_free_irq(&idev->pdev->dev, idev->irq, idev); 328765ea3abSLoic Poulain device_wakeup_disable(&idev->pdev->dev); 329765ea3abSLoic Poulain } 3301ab1f239SLoic Poulain } 3311ab1f239SLoic Poulain 33267c8bde0SLoic Poulain mutex_unlock(&intel_device_list_lock); 3331ab1f239SLoic Poulain 3341ab1f239SLoic Poulain return err; 3351ab1f239SLoic Poulain } 3361ab1f239SLoic Poulain 337ca93cee5SLoic Poulain static int intel_open(struct hci_uart *hu) 338ca93cee5SLoic Poulain { 339ca93cee5SLoic Poulain struct intel_data *intel; 340ca93cee5SLoic Poulain 341ca93cee5SLoic Poulain BT_DBG("hu %p", hu); 342ca93cee5SLoic Poulain 343ca93cee5SLoic Poulain intel = kzalloc(sizeof(*intel), GFP_KERNEL); 344ca93cee5SLoic Poulain if (!intel) 345ca93cee5SLoic Poulain return -ENOMEM; 346ca93cee5SLoic Poulain 347ca93cee5SLoic Poulain skb_queue_head_init(&intel->txq); 348ca93cee5SLoic Poulain 349ca93cee5SLoic Poulain hu->priv = intel; 3501ab1f239SLoic Poulain 3511ab1f239SLoic Poulain if (!intel_set_power(hu, true)) 3521ab1f239SLoic Poulain set_bit(STATE_BOOTING, &intel->flags); 3531ab1f239SLoic Poulain 354ca93cee5SLoic Poulain return 0; 355ca93cee5SLoic Poulain } 356ca93cee5SLoic Poulain 357ca93cee5SLoic Poulain static int intel_close(struct hci_uart *hu) 358ca93cee5SLoic Poulain { 359ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 360ca93cee5SLoic Poulain 361ca93cee5SLoic Poulain BT_DBG("hu %p", hu); 362ca93cee5SLoic Poulain 3631ab1f239SLoic Poulain intel_set_power(hu, false); 3641ab1f239SLoic Poulain 365ca93cee5SLoic Poulain skb_queue_purge(&intel->txq); 366ca93cee5SLoic Poulain kfree_skb(intel->rx_skb); 367ca93cee5SLoic Poulain kfree(intel); 368ca93cee5SLoic Poulain 369ca93cee5SLoic Poulain hu->priv = NULL; 370ca93cee5SLoic Poulain return 0; 371ca93cee5SLoic Poulain } 372ca93cee5SLoic Poulain 373ca93cee5SLoic Poulain static int intel_flush(struct hci_uart *hu) 374ca93cee5SLoic Poulain { 375ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 376ca93cee5SLoic Poulain 377ca93cee5SLoic Poulain BT_DBG("hu %p", hu); 378ca93cee5SLoic Poulain 379ca93cee5SLoic Poulain skb_queue_purge(&intel->txq); 380ca93cee5SLoic Poulain 381ca93cee5SLoic Poulain return 0; 382ca93cee5SLoic Poulain } 383ca93cee5SLoic Poulain 384ca93cee5SLoic Poulain static int inject_cmd_complete(struct hci_dev *hdev, __u16 opcode) 385ca93cee5SLoic Poulain { 386ca93cee5SLoic Poulain struct sk_buff *skb; 387ca93cee5SLoic Poulain struct hci_event_hdr *hdr; 388ca93cee5SLoic Poulain struct hci_ev_cmd_complete *evt; 389ca93cee5SLoic Poulain 390ca93cee5SLoic Poulain skb = bt_skb_alloc(sizeof(*hdr) + sizeof(*evt) + 1, GFP_ATOMIC); 391ca93cee5SLoic Poulain if (!skb) 392ca93cee5SLoic Poulain return -ENOMEM; 393ca93cee5SLoic Poulain 394ca93cee5SLoic Poulain hdr = (struct hci_event_hdr *)skb_put(skb, sizeof(*hdr)); 395ca93cee5SLoic Poulain hdr->evt = HCI_EV_CMD_COMPLETE; 396ca93cee5SLoic Poulain hdr->plen = sizeof(*evt) + 1; 397ca93cee5SLoic Poulain 398ca93cee5SLoic Poulain evt = (struct hci_ev_cmd_complete *)skb_put(skb, sizeof(*evt)); 399ca93cee5SLoic Poulain evt->ncmd = 0x01; 400ca93cee5SLoic Poulain evt->opcode = cpu_to_le16(opcode); 401ca93cee5SLoic Poulain 402ca93cee5SLoic Poulain *skb_put(skb, 1) = 0x00; 403ca93cee5SLoic Poulain 404ca93cee5SLoic Poulain bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 405ca93cee5SLoic Poulain 406ca93cee5SLoic Poulain return hci_recv_frame(hdev, skb); 407ca93cee5SLoic Poulain } 408ca93cee5SLoic Poulain 409ff289559SLoic Poulain static int intel_set_baudrate(struct hci_uart *hu, unsigned int speed) 410ff289559SLoic Poulain { 411ff289559SLoic Poulain struct intel_data *intel = hu->priv; 412ff289559SLoic Poulain struct hci_dev *hdev = hu->hdev; 413ff289559SLoic Poulain u8 speed_cmd[] = { 0x06, 0xfc, 0x01, 0x00 }; 414ff289559SLoic Poulain struct sk_buff *skb; 4151ab1f239SLoic Poulain int err; 4161ab1f239SLoic Poulain 4171ab1f239SLoic Poulain /* This can be the first command sent to the chip, check 4181ab1f239SLoic Poulain * that the controller is ready. 4191ab1f239SLoic Poulain */ 4201ab1f239SLoic Poulain err = intel_wait_booting(hu); 4211ab1f239SLoic Poulain 4221ab1f239SLoic Poulain clear_bit(STATE_BOOTING, &intel->flags); 4231ab1f239SLoic Poulain 4241ab1f239SLoic Poulain /* In case of timeout, try to continue anyway */ 4251ab1f239SLoic Poulain if (err && err != ETIMEDOUT) 4261ab1f239SLoic Poulain return err; 427ff289559SLoic Poulain 428f44e78a5SLoic Poulain bt_dev_info(hdev, "Change controller speed to %d", speed); 429ff289559SLoic Poulain 430ff289559SLoic Poulain speed_cmd[3] = intel_convert_speed(speed); 431ff289559SLoic Poulain if (speed_cmd[3] == 0xff) { 432f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported speed"); 433ff289559SLoic Poulain return -EINVAL; 434ff289559SLoic Poulain } 435ff289559SLoic Poulain 436ff289559SLoic Poulain /* Device will not accept speed change if Intel version has not been 437ff289559SLoic Poulain * previously requested. 438ff289559SLoic Poulain */ 439ff289559SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT); 440ff289559SLoic Poulain if (IS_ERR(skb)) { 441f44e78a5SLoic Poulain bt_dev_err(hdev, "Reading Intel version information failed (%ld)", 442f44e78a5SLoic Poulain PTR_ERR(skb)); 443ff289559SLoic Poulain return PTR_ERR(skb); 444ff289559SLoic Poulain } 445ff289559SLoic Poulain kfree_skb(skb); 446ff289559SLoic Poulain 447ff289559SLoic Poulain skb = bt_skb_alloc(sizeof(speed_cmd), GFP_KERNEL); 448ff289559SLoic Poulain if (!skb) { 449f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to alloc memory for baudrate packet"); 450ff289559SLoic Poulain return -ENOMEM; 451ff289559SLoic Poulain } 452ff289559SLoic Poulain 453ff289559SLoic Poulain memcpy(skb_put(skb, sizeof(speed_cmd)), speed_cmd, sizeof(speed_cmd)); 454ff289559SLoic Poulain bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 455ff289559SLoic Poulain 456ff289559SLoic Poulain hci_uart_set_flow_control(hu, true); 457ff289559SLoic Poulain 458ff289559SLoic Poulain skb_queue_tail(&intel->txq, skb); 459ff289559SLoic Poulain hci_uart_tx_wakeup(hu); 460ff289559SLoic Poulain 461ff289559SLoic Poulain /* wait 100ms to change baudrate on controller side */ 462ff289559SLoic Poulain msleep(100); 463ff289559SLoic Poulain 464ff289559SLoic Poulain hci_uart_set_baudrate(hu, speed); 465ff289559SLoic Poulain hci_uart_set_flow_control(hu, false); 466ff289559SLoic Poulain 467ff289559SLoic Poulain return 0; 468ff289559SLoic Poulain } 469ff289559SLoic Poulain 470ca93cee5SLoic Poulain static int intel_setup(struct hci_uart *hu) 471ca93cee5SLoic Poulain { 472ca93cee5SLoic Poulain static const u8 reset_param[] = { 0x00, 0x01, 0x00, 0x01, 473ca93cee5SLoic Poulain 0x00, 0x08, 0x04, 0x00 }; 474b98469f4SLoic Poulain static const u8 lpm_param[] = { 0x03, 0x07, 0x01, 0x0b }; 475ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 476b98469f4SLoic Poulain struct intel_device *idev = NULL; 477ca93cee5SLoic Poulain struct hci_dev *hdev = hu->hdev; 478ca93cee5SLoic Poulain struct sk_buff *skb; 479ca93cee5SLoic Poulain struct intel_version *ver; 480ca93cee5SLoic Poulain struct intel_boot_params *params; 481b98469f4SLoic Poulain struct list_head *p; 482ca93cee5SLoic Poulain const struct firmware *fw; 483ca93cee5SLoic Poulain const u8 *fw_ptr; 484ca93cee5SLoic Poulain char fwname[64]; 485ca93cee5SLoic Poulain u32 frag_len; 486ca93cee5SLoic Poulain ktime_t calltime, delta, rettime; 487ca93cee5SLoic Poulain unsigned long long duration; 488ff289559SLoic Poulain unsigned int init_speed, oper_speed; 489ff289559SLoic Poulain int speed_change = 0; 490ca93cee5SLoic Poulain int err; 491ca93cee5SLoic Poulain 492f44e78a5SLoic Poulain bt_dev_dbg(hdev, "start intel_setup"); 493ca93cee5SLoic Poulain 49435ab8150SMarcel Holtmann hu->hdev->set_bdaddr = btintel_set_bdaddr; 49535ab8150SMarcel Holtmann 496ca93cee5SLoic Poulain calltime = ktime_get(); 497ca93cee5SLoic Poulain 498ff289559SLoic Poulain if (hu->init_speed) 499ff289559SLoic Poulain init_speed = hu->init_speed; 500ff289559SLoic Poulain else 501ff289559SLoic Poulain init_speed = hu->proto->init_speed; 502ff289559SLoic Poulain 503ff289559SLoic Poulain if (hu->oper_speed) 504ff289559SLoic Poulain oper_speed = hu->oper_speed; 505ff289559SLoic Poulain else 506ff289559SLoic Poulain oper_speed = hu->proto->oper_speed; 507ff289559SLoic Poulain 508ff289559SLoic Poulain if (oper_speed && init_speed && oper_speed != init_speed) 509ff289559SLoic Poulain speed_change = 1; 510ff289559SLoic Poulain 5111ab1f239SLoic Poulain /* Check that the controller is ready */ 5121ab1f239SLoic Poulain err = intel_wait_booting(hu); 5131ab1f239SLoic Poulain 5141ab1f239SLoic Poulain clear_bit(STATE_BOOTING, &intel->flags); 5151ab1f239SLoic Poulain 5161ab1f239SLoic Poulain /* In case of timeout, try to continue anyway */ 5171ab1f239SLoic Poulain if (err && err != ETIMEDOUT) 5181ab1f239SLoic Poulain return err; 5191ab1f239SLoic Poulain 520ca93cee5SLoic Poulain set_bit(STATE_BOOTLOADER, &intel->flags); 521ca93cee5SLoic Poulain 522ca93cee5SLoic Poulain /* Read the Intel version information to determine if the device 523ca93cee5SLoic Poulain * is in bootloader mode or if it already has operational firmware 524ca93cee5SLoic Poulain * loaded. 525ca93cee5SLoic Poulain */ 526ca93cee5SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT); 527ca93cee5SLoic Poulain if (IS_ERR(skb)) { 528f44e78a5SLoic Poulain bt_dev_err(hdev, "Reading Intel version information failed (%ld)", 529f44e78a5SLoic Poulain PTR_ERR(skb)); 530ca93cee5SLoic Poulain return PTR_ERR(skb); 531ca93cee5SLoic Poulain } 532ca93cee5SLoic Poulain 533ca93cee5SLoic Poulain if (skb->len != sizeof(*ver)) { 534f44e78a5SLoic Poulain bt_dev_err(hdev, "Intel version event size mismatch"); 535ca93cee5SLoic Poulain kfree_skb(skb); 536ca93cee5SLoic Poulain return -EILSEQ; 537ca93cee5SLoic Poulain } 538ca93cee5SLoic Poulain 539ca93cee5SLoic Poulain ver = (struct intel_version *)skb->data; 540ca93cee5SLoic Poulain if (ver->status) { 541f44e78a5SLoic Poulain bt_dev_err(hdev, "Intel version command failure (%02x)", 542f44e78a5SLoic Poulain ver->status); 543ca93cee5SLoic Poulain err = -bt_to_errno(ver->status); 544ca93cee5SLoic Poulain kfree_skb(skb); 545ca93cee5SLoic Poulain return err; 546ca93cee5SLoic Poulain } 547ca93cee5SLoic Poulain 548ca93cee5SLoic Poulain /* The hardware platform number has a fixed value of 0x37 and 549ca93cee5SLoic Poulain * for now only accept this single value. 550ca93cee5SLoic Poulain */ 551ca93cee5SLoic Poulain if (ver->hw_platform != 0x37) { 552f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported Intel hardware platform (%u)", 553f44e78a5SLoic Poulain ver->hw_platform); 554ca93cee5SLoic Poulain kfree_skb(skb); 555ca93cee5SLoic Poulain return -EINVAL; 556ca93cee5SLoic Poulain } 557ca93cee5SLoic Poulain 558ca93cee5SLoic Poulain /* At the moment only the hardware variant iBT 3.0 (LnP/SfP) is 559ca93cee5SLoic Poulain * supported by this firmware loading method. This check has been 560ca93cee5SLoic Poulain * put in place to ensure correct forward compatibility options 561ca93cee5SLoic Poulain * when newer hardware variants come along. 562ca93cee5SLoic Poulain */ 563ca93cee5SLoic Poulain if (ver->hw_variant != 0x0b) { 564f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported Intel hardware variant (%u)", 565f44e78a5SLoic Poulain ver->hw_variant); 566ca93cee5SLoic Poulain kfree_skb(skb); 567ca93cee5SLoic Poulain return -EINVAL; 568ca93cee5SLoic Poulain } 569ca93cee5SLoic Poulain 5707feb99e1SMarcel Holtmann btintel_version_info(hdev, ver); 571ca93cee5SLoic Poulain 572ca93cee5SLoic Poulain /* The firmware variant determines if the device is in bootloader 573ca93cee5SLoic Poulain * mode or is running operational firmware. The value 0x06 identifies 574ca93cee5SLoic Poulain * the bootloader and the value 0x23 identifies the operational 575ca93cee5SLoic Poulain * firmware. 576ca93cee5SLoic Poulain * 577ca93cee5SLoic Poulain * When the operational firmware is already present, then only 578ca93cee5SLoic Poulain * the check for valid Bluetooth device address is needed. This 579ca93cee5SLoic Poulain * determines if the device will be added as configured or 580ca93cee5SLoic Poulain * unconfigured controller. 581ca93cee5SLoic Poulain * 582ca93cee5SLoic Poulain * It is not possible to use the Secure Boot Parameters in this 583ca93cee5SLoic Poulain * case since that command is only available in bootloader mode. 584ca93cee5SLoic Poulain */ 585ca93cee5SLoic Poulain if (ver->fw_variant == 0x23) { 586ca93cee5SLoic Poulain kfree_skb(skb); 587ca93cee5SLoic Poulain clear_bit(STATE_BOOTLOADER, &intel->flags); 588ca93cee5SLoic Poulain btintel_check_bdaddr(hdev); 589ca93cee5SLoic Poulain return 0; 590ca93cee5SLoic Poulain } 591ca93cee5SLoic Poulain 592ca93cee5SLoic Poulain /* If the device is not in bootloader mode, then the only possible 593ca93cee5SLoic Poulain * choice is to return an error and abort the device initialization. 594ca93cee5SLoic Poulain */ 595ca93cee5SLoic Poulain if (ver->fw_variant != 0x06) { 596f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported Intel firmware variant (%u)", 597f44e78a5SLoic Poulain ver->fw_variant); 598ca93cee5SLoic Poulain kfree_skb(skb); 599ca93cee5SLoic Poulain return -ENODEV; 600ca93cee5SLoic Poulain } 601ca93cee5SLoic Poulain 602ca93cee5SLoic Poulain kfree_skb(skb); 603ca93cee5SLoic Poulain 604ca93cee5SLoic Poulain /* Read the secure boot parameters to identify the operating 605ca93cee5SLoic Poulain * details of the bootloader. 606ca93cee5SLoic Poulain */ 607ca93cee5SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc0d, 0, NULL, HCI_INIT_TIMEOUT); 608ca93cee5SLoic Poulain if (IS_ERR(skb)) { 609f44e78a5SLoic Poulain bt_dev_err(hdev, "Reading Intel boot parameters failed (%ld)", 610f44e78a5SLoic Poulain PTR_ERR(skb)); 611ca93cee5SLoic Poulain return PTR_ERR(skb); 612ca93cee5SLoic Poulain } 613ca93cee5SLoic Poulain 614ca93cee5SLoic Poulain if (skb->len != sizeof(*params)) { 615f44e78a5SLoic Poulain bt_dev_err(hdev, "Intel boot parameters size mismatch"); 616ca93cee5SLoic Poulain kfree_skb(skb); 617ca93cee5SLoic Poulain return -EILSEQ; 618ca93cee5SLoic Poulain } 619ca93cee5SLoic Poulain 620ca93cee5SLoic Poulain params = (struct intel_boot_params *)skb->data; 621ca93cee5SLoic Poulain if (params->status) { 622f44e78a5SLoic Poulain bt_dev_err(hdev, "Intel boot parameters command failure (%02x)", 623f44e78a5SLoic Poulain params->status); 624ca93cee5SLoic Poulain err = -bt_to_errno(params->status); 625ca93cee5SLoic Poulain kfree_skb(skb); 626ca93cee5SLoic Poulain return err; 627ca93cee5SLoic Poulain } 628ca93cee5SLoic Poulain 629f44e78a5SLoic Poulain bt_dev_info(hdev, "Device revision is %u", 630ca93cee5SLoic Poulain le16_to_cpu(params->dev_revid)); 631ca93cee5SLoic Poulain 632f44e78a5SLoic Poulain bt_dev_info(hdev, "Secure boot is %s", 633ca93cee5SLoic Poulain params->secure_boot ? "enabled" : "disabled"); 634ca93cee5SLoic Poulain 635f44e78a5SLoic Poulain bt_dev_info(hdev, "Minimum firmware build %u week %u %u", 636ca93cee5SLoic Poulain params->min_fw_build_nn, params->min_fw_build_cw, 637ca93cee5SLoic Poulain 2000 + params->min_fw_build_yy); 638ca93cee5SLoic Poulain 639ca93cee5SLoic Poulain /* It is required that every single firmware fragment is acknowledged 640ca93cee5SLoic Poulain * with a command complete event. If the boot parameters indicate 641ca93cee5SLoic Poulain * that this bootloader does not send them, then abort the setup. 642ca93cee5SLoic Poulain */ 643ca93cee5SLoic Poulain if (params->limited_cce != 0x00) { 644f44e78a5SLoic Poulain bt_dev_err(hdev, "Unsupported Intel firmware loading method (%u)", 645f44e78a5SLoic Poulain params->limited_cce); 646ca93cee5SLoic Poulain kfree_skb(skb); 647ca93cee5SLoic Poulain return -EINVAL; 648ca93cee5SLoic Poulain } 649ca93cee5SLoic Poulain 650ca93cee5SLoic Poulain /* If the OTP has no valid Bluetooth device address, then there will 651ca93cee5SLoic Poulain * also be no valid address for the operational firmware. 652ca93cee5SLoic Poulain */ 653ca93cee5SLoic Poulain if (!bacmp(¶ms->otp_bdaddr, BDADDR_ANY)) { 654f44e78a5SLoic Poulain bt_dev_info(hdev, "No device address configured"); 655ca93cee5SLoic Poulain set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks); 656ca93cee5SLoic Poulain } 657ca93cee5SLoic Poulain 658ca93cee5SLoic Poulain /* With this Intel bootloader only the hardware variant and device 659ca93cee5SLoic Poulain * revision information are used to select the right firmware. 660ca93cee5SLoic Poulain * 661ca93cee5SLoic Poulain * Currently this bootloader support is limited to hardware variant 662ca93cee5SLoic Poulain * iBT 3.0 (LnP/SfP) which is identified by the value 11 (0x0b). 663ca93cee5SLoic Poulain */ 664ca93cee5SLoic Poulain snprintf(fwname, sizeof(fwname), "intel/ibt-11-%u.sfi", 665ca93cee5SLoic Poulain le16_to_cpu(params->dev_revid)); 666ca93cee5SLoic Poulain 667ca93cee5SLoic Poulain err = request_firmware(&fw, fwname, &hdev->dev); 668ca93cee5SLoic Poulain if (err < 0) { 669f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to load Intel firmware file (%d)", 670f44e78a5SLoic Poulain err); 671ca93cee5SLoic Poulain kfree_skb(skb); 672ca93cee5SLoic Poulain return err; 673ca93cee5SLoic Poulain } 674ca93cee5SLoic Poulain 675f44e78a5SLoic Poulain bt_dev_info(hdev, "Found device firmware: %s", fwname); 676ca93cee5SLoic Poulain 677ca93cee5SLoic Poulain kfree_skb(skb); 678ca93cee5SLoic Poulain 679ca93cee5SLoic Poulain if (fw->size < 644) { 680f44e78a5SLoic Poulain bt_dev_err(hdev, "Invalid size of firmware file (%zu)", 681f44e78a5SLoic Poulain fw->size); 682ca93cee5SLoic Poulain err = -EBADF; 683ca93cee5SLoic Poulain goto done; 684ca93cee5SLoic Poulain } 685ca93cee5SLoic Poulain 686ca93cee5SLoic Poulain set_bit(STATE_DOWNLOADING, &intel->flags); 687ca93cee5SLoic Poulain 688ca93cee5SLoic Poulain /* Start the firmware download transaction with the Init fragment 689ca93cee5SLoic Poulain * represented by the 128 bytes of CSS header. 690ca93cee5SLoic Poulain */ 69109df123dSMarcel Holtmann err = btintel_secure_send(hdev, 0x00, 128, fw->data); 692ca93cee5SLoic Poulain if (err < 0) { 693f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to send firmware header (%d)", err); 694ca93cee5SLoic Poulain goto done; 695ca93cee5SLoic Poulain } 696ca93cee5SLoic Poulain 697ca93cee5SLoic Poulain /* Send the 256 bytes of public key information from the firmware 698ca93cee5SLoic Poulain * as the PKey fragment. 699ca93cee5SLoic Poulain */ 70009df123dSMarcel Holtmann err = btintel_secure_send(hdev, 0x03, 256, fw->data + 128); 701ca93cee5SLoic Poulain if (err < 0) { 702f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to send firmware public key (%d)", 703f44e78a5SLoic Poulain err); 704ca93cee5SLoic Poulain goto done; 705ca93cee5SLoic Poulain } 706ca93cee5SLoic Poulain 707ca93cee5SLoic Poulain /* Send the 256 bytes of signature information from the firmware 708ca93cee5SLoic Poulain * as the Sign fragment. 709ca93cee5SLoic Poulain */ 71009df123dSMarcel Holtmann err = btintel_secure_send(hdev, 0x02, 256, fw->data + 388); 711ca93cee5SLoic Poulain if (err < 0) { 712f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to send firmware signature (%d)", 713f44e78a5SLoic Poulain err); 714ca93cee5SLoic Poulain goto done; 715ca93cee5SLoic Poulain } 716ca93cee5SLoic Poulain 717ca93cee5SLoic Poulain fw_ptr = fw->data + 644; 718ca93cee5SLoic Poulain frag_len = 0; 719ca93cee5SLoic Poulain 720ca93cee5SLoic Poulain while (fw_ptr - fw->data < fw->size) { 721ca93cee5SLoic Poulain struct hci_command_hdr *cmd = (void *)(fw_ptr + frag_len); 722ca93cee5SLoic Poulain 723ca93cee5SLoic Poulain frag_len += sizeof(*cmd) + cmd->plen; 724ca93cee5SLoic Poulain 725f44e78a5SLoic Poulain bt_dev_dbg(hdev, "Patching %td/%zu", (fw_ptr - fw->data), 726f44e78a5SLoic Poulain fw->size); 727ca93cee5SLoic Poulain 728ca93cee5SLoic Poulain /* The parameter length of the secure send command requires 729ca93cee5SLoic Poulain * a 4 byte alignment. It happens so that the firmware file 730ca93cee5SLoic Poulain * contains proper Intel_NOP commands to align the fragments 731ca93cee5SLoic Poulain * as needed. 732ca93cee5SLoic Poulain * 733ca93cee5SLoic Poulain * Send set of commands with 4 byte alignment from the 734ca93cee5SLoic Poulain * firmware data buffer as a single Data fragement. 735ca93cee5SLoic Poulain */ 736ca93cee5SLoic Poulain if (frag_len % 4) 737ca93cee5SLoic Poulain continue; 738ca93cee5SLoic Poulain 739ca93cee5SLoic Poulain /* Send each command from the firmware data buffer as 740ca93cee5SLoic Poulain * a single Data fragment. 741ca93cee5SLoic Poulain */ 74209df123dSMarcel Holtmann err = btintel_secure_send(hdev, 0x01, frag_len, fw_ptr); 743ca93cee5SLoic Poulain if (err < 0) { 744f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to send firmware data (%d)", 745f44e78a5SLoic Poulain err); 746ca93cee5SLoic Poulain goto done; 747ca93cee5SLoic Poulain } 748ca93cee5SLoic Poulain 749ca93cee5SLoic Poulain fw_ptr += frag_len; 750ca93cee5SLoic Poulain frag_len = 0; 751ca93cee5SLoic Poulain } 752ca93cee5SLoic Poulain 753ca93cee5SLoic Poulain set_bit(STATE_FIRMWARE_LOADED, &intel->flags); 754ca93cee5SLoic Poulain 755f44e78a5SLoic Poulain bt_dev_info(hdev, "Waiting for firmware download to complete"); 756ca93cee5SLoic Poulain 757ca93cee5SLoic Poulain /* Before switching the device into operational mode and with that 758ca93cee5SLoic Poulain * booting the loaded firmware, wait for the bootloader notification 759ca93cee5SLoic Poulain * that all fragments have been successfully received. 760ca93cee5SLoic Poulain * 761ca93cee5SLoic Poulain * When the event processing receives the notification, then the 762ca93cee5SLoic Poulain * STATE_DOWNLOADING flag will be cleared. 763ca93cee5SLoic Poulain * 764ca93cee5SLoic Poulain * The firmware loading should not take longer than 5 seconds 765ca93cee5SLoic Poulain * and thus just timeout if that happens and fail the setup 766ca93cee5SLoic Poulain * of this device. 767ca93cee5SLoic Poulain */ 768ca93cee5SLoic Poulain err = wait_on_bit_timeout(&intel->flags, STATE_DOWNLOADING, 769ca93cee5SLoic Poulain TASK_INTERRUPTIBLE, 770ca93cee5SLoic Poulain msecs_to_jiffies(5000)); 771ca93cee5SLoic Poulain if (err == 1) { 772f44e78a5SLoic Poulain bt_dev_err(hdev, "Firmware loading interrupted"); 773ca93cee5SLoic Poulain err = -EINTR; 774ca93cee5SLoic Poulain goto done; 775ca93cee5SLoic Poulain } 776ca93cee5SLoic Poulain 777ca93cee5SLoic Poulain if (err) { 778f44e78a5SLoic Poulain bt_dev_err(hdev, "Firmware loading timeout"); 779ca93cee5SLoic Poulain err = -ETIMEDOUT; 780ca93cee5SLoic Poulain goto done; 781ca93cee5SLoic Poulain } 782ca93cee5SLoic Poulain 783ca93cee5SLoic Poulain if (test_bit(STATE_FIRMWARE_FAILED, &intel->flags)) { 784f44e78a5SLoic Poulain bt_dev_err(hdev, "Firmware loading failed"); 785ca93cee5SLoic Poulain err = -ENOEXEC; 786ca93cee5SLoic Poulain goto done; 787ca93cee5SLoic Poulain } 788ca93cee5SLoic Poulain 789ca93cee5SLoic Poulain rettime = ktime_get(); 790ca93cee5SLoic Poulain delta = ktime_sub(rettime, calltime); 791ca93cee5SLoic Poulain duration = (unsigned long long) ktime_to_ns(delta) >> 10; 792ca93cee5SLoic Poulain 793f44e78a5SLoic Poulain bt_dev_info(hdev, "Firmware loaded in %llu usecs", duration); 794ca93cee5SLoic Poulain 795ca93cee5SLoic Poulain done: 796ca93cee5SLoic Poulain release_firmware(fw); 797ca93cee5SLoic Poulain 798ca93cee5SLoic Poulain if (err < 0) 799ca93cee5SLoic Poulain return err; 800ca93cee5SLoic Poulain 801ff289559SLoic Poulain /* We need to restore the default speed before Intel reset */ 802ff289559SLoic Poulain if (speed_change) { 803ff289559SLoic Poulain err = intel_set_baudrate(hu, init_speed); 804ff289559SLoic Poulain if (err) 805ff289559SLoic Poulain return err; 806ff289559SLoic Poulain } 807ff289559SLoic Poulain 808ca93cee5SLoic Poulain calltime = ktime_get(); 809ca93cee5SLoic Poulain 810ca93cee5SLoic Poulain set_bit(STATE_BOOTING, &intel->flags); 811ca93cee5SLoic Poulain 812ca93cee5SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc01, sizeof(reset_param), reset_param, 813ca93cee5SLoic Poulain HCI_INIT_TIMEOUT); 814ca93cee5SLoic Poulain if (IS_ERR(skb)) 815ca93cee5SLoic Poulain return PTR_ERR(skb); 816ca93cee5SLoic Poulain 817ca93cee5SLoic Poulain kfree_skb(skb); 818ca93cee5SLoic Poulain 819ca93cee5SLoic Poulain /* The bootloader will not indicate when the device is ready. This 820ca93cee5SLoic Poulain * is done by the operational firmware sending bootup notification. 821ca93cee5SLoic Poulain * 822ca93cee5SLoic Poulain * Booting into operational firmware should not take longer than 823ca93cee5SLoic Poulain * 1 second. However if that happens, then just fail the setup 824ca93cee5SLoic Poulain * since something went wrong. 825ca93cee5SLoic Poulain */ 826f44e78a5SLoic Poulain bt_dev_info(hdev, "Waiting for device to boot"); 827ca93cee5SLoic Poulain 8281ab1f239SLoic Poulain err = intel_wait_booting(hu); 8291ab1f239SLoic Poulain if (err) 8301ab1f239SLoic Poulain return err; 831ca93cee5SLoic Poulain 8321ab1f239SLoic Poulain clear_bit(STATE_BOOTING, &intel->flags); 833ca93cee5SLoic Poulain 834ca93cee5SLoic Poulain rettime = ktime_get(); 835ca93cee5SLoic Poulain delta = ktime_sub(rettime, calltime); 836ca93cee5SLoic Poulain duration = (unsigned long long) ktime_to_ns(delta) >> 10; 837ca93cee5SLoic Poulain 838f44e78a5SLoic Poulain bt_dev_info(hdev, "Device booted in %llu usecs", duration); 839ca93cee5SLoic Poulain 840b98469f4SLoic Poulain /* Enable LPM if matching pdev with wakeup enabled */ 84167c8bde0SLoic Poulain mutex_lock(&intel_device_list_lock); 842b98469f4SLoic Poulain list_for_each(p, &intel_device_list) { 843b98469f4SLoic Poulain struct intel_device *dev = list_entry(p, struct intel_device, 844b98469f4SLoic Poulain list); 845b98469f4SLoic Poulain if (hu->tty->dev->parent == dev->pdev->dev.parent) { 846b98469f4SLoic Poulain if (device_may_wakeup(&dev->pdev->dev)) 847b98469f4SLoic Poulain idev = dev; 848b98469f4SLoic Poulain break; 849b98469f4SLoic Poulain } 850b98469f4SLoic Poulain } 85167c8bde0SLoic Poulain mutex_unlock(&intel_device_list_lock); 852b98469f4SLoic Poulain 853b98469f4SLoic Poulain if (!idev) 854b98469f4SLoic Poulain goto no_lpm; 855b98469f4SLoic Poulain 856f44e78a5SLoic Poulain bt_dev_info(hdev, "Enabling LPM"); 857b98469f4SLoic Poulain 858b98469f4SLoic Poulain skb = __hci_cmd_sync(hdev, 0xfc8b, sizeof(lpm_param), lpm_param, 859b98469f4SLoic Poulain HCI_CMD_TIMEOUT); 860b98469f4SLoic Poulain if (IS_ERR(skb)) { 861f44e78a5SLoic Poulain bt_dev_err(hdev, "Failed to enable LPM"); 862b98469f4SLoic Poulain goto no_lpm; 863b98469f4SLoic Poulain } 864b98469f4SLoic Poulain kfree_skb(skb); 865b98469f4SLoic Poulain 866b98469f4SLoic Poulain set_bit(STATE_LPM_ENABLED, &intel->flags); 867b98469f4SLoic Poulain 868b98469f4SLoic Poulain no_lpm: 869ff289559SLoic Poulain skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_CMD_TIMEOUT); 870ff289559SLoic Poulain if (IS_ERR(skb)) 871ff289559SLoic Poulain return PTR_ERR(skb); 872ff289559SLoic Poulain kfree_skb(skb); 873ff289559SLoic Poulain 874ff289559SLoic Poulain if (speed_change) { 875ff289559SLoic Poulain err = intel_set_baudrate(hu, oper_speed); 876ff289559SLoic Poulain if (err) 877ff289559SLoic Poulain return err; 878ff289559SLoic Poulain } 879ff289559SLoic Poulain 880f44e78a5SLoic Poulain bt_dev_info(hdev, "Setup complete"); 881ff289559SLoic Poulain 882ca93cee5SLoic Poulain clear_bit(STATE_BOOTLOADER, &intel->flags); 883ca93cee5SLoic Poulain 884ca93cee5SLoic Poulain return 0; 885ca93cee5SLoic Poulain } 886ca93cee5SLoic Poulain 887ca93cee5SLoic Poulain static int intel_recv_event(struct hci_dev *hdev, struct sk_buff *skb) 888ca93cee5SLoic Poulain { 889ca93cee5SLoic Poulain struct hci_uart *hu = hci_get_drvdata(hdev); 890ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 891ca93cee5SLoic Poulain struct hci_event_hdr *hdr; 892ca93cee5SLoic Poulain 8931ab1f239SLoic Poulain if (!test_bit(STATE_BOOTLOADER, &intel->flags) && 8941ab1f239SLoic Poulain !test_bit(STATE_BOOTING, &intel->flags)) 895ca93cee5SLoic Poulain goto recv; 896ca93cee5SLoic Poulain 897ca93cee5SLoic Poulain hdr = (void *)skb->data; 898ca93cee5SLoic Poulain 899ca93cee5SLoic Poulain /* When the firmware loading completes the device sends 900ca93cee5SLoic Poulain * out a vendor specific event indicating the result of 901ca93cee5SLoic Poulain * the firmware loading. 902ca93cee5SLoic Poulain */ 903ca93cee5SLoic Poulain if (skb->len == 7 && hdr->evt == 0xff && hdr->plen == 0x05 && 904ca93cee5SLoic Poulain skb->data[2] == 0x06) { 905ca93cee5SLoic Poulain if (skb->data[3] != 0x00) 906ca93cee5SLoic Poulain set_bit(STATE_FIRMWARE_FAILED, &intel->flags); 907ca93cee5SLoic Poulain 908ca93cee5SLoic Poulain if (test_and_clear_bit(STATE_DOWNLOADING, &intel->flags) && 909ca93cee5SLoic Poulain test_bit(STATE_FIRMWARE_LOADED, &intel->flags)) { 910ca93cee5SLoic Poulain smp_mb__after_atomic(); 911ca93cee5SLoic Poulain wake_up_bit(&intel->flags, STATE_DOWNLOADING); 912ca93cee5SLoic Poulain } 913ca93cee5SLoic Poulain 914ca93cee5SLoic Poulain /* When switching to the operational firmware the device 915ca93cee5SLoic Poulain * sends a vendor specific event indicating that the bootup 916ca93cee5SLoic Poulain * completed. 917ca93cee5SLoic Poulain */ 918ca93cee5SLoic Poulain } else if (skb->len == 9 && hdr->evt == 0xff && hdr->plen == 0x07 && 919ca93cee5SLoic Poulain skb->data[2] == 0x02) { 920ca93cee5SLoic Poulain if (test_and_clear_bit(STATE_BOOTING, &intel->flags)) { 921ca93cee5SLoic Poulain smp_mb__after_atomic(); 922ca93cee5SLoic Poulain wake_up_bit(&intel->flags, STATE_BOOTING); 923ca93cee5SLoic Poulain } 924ca93cee5SLoic Poulain } 925ca93cee5SLoic Poulain recv: 926ca93cee5SLoic Poulain return hci_recv_frame(hdev, skb); 927ca93cee5SLoic Poulain } 928ca93cee5SLoic Poulain 929b98469f4SLoic Poulain static void intel_recv_lpm_notify(struct hci_dev *hdev, int value) 930b98469f4SLoic Poulain { 931b98469f4SLoic Poulain struct hci_uart *hu = hci_get_drvdata(hdev); 932b98469f4SLoic Poulain struct intel_data *intel = hu->priv; 933b98469f4SLoic Poulain 934f44e78a5SLoic Poulain bt_dev_dbg(hdev, "TX idle notification (%d)", value); 935b98469f4SLoic Poulain 936b98469f4SLoic Poulain if (value) 937b98469f4SLoic Poulain set_bit(STATE_TX_ACTIVE, &intel->flags); 938b98469f4SLoic Poulain else 939b98469f4SLoic Poulain clear_bit(STATE_TX_ACTIVE, &intel->flags); 940b98469f4SLoic Poulain } 941b98469f4SLoic Poulain 942b98469f4SLoic Poulain static int intel_recv_lpm(struct hci_dev *hdev, struct sk_buff *skb) 943b98469f4SLoic Poulain { 944b98469f4SLoic Poulain struct hci_lpm_pkt *lpm = (void *)skb->data; 945*89436546SLoic Poulain struct hci_uart *hu = hci_get_drvdata(hdev); 946*89436546SLoic Poulain struct intel_data *intel = hu->priv; 947b98469f4SLoic Poulain 948b98469f4SLoic Poulain switch (lpm->opcode) { 949b98469f4SLoic Poulain case LPM_OP_TX_NOTIFY: 950b98469f4SLoic Poulain if (lpm->dlen) 951b98469f4SLoic Poulain intel_recv_lpm_notify(hdev, lpm->data[0]); 952b98469f4SLoic Poulain break; 953*89436546SLoic Poulain case LPM_OP_SUSPEND_ACK: 954*89436546SLoic Poulain set_bit(STATE_SUSPENDED, &intel->flags); 955*89436546SLoic Poulain if (test_and_clear_bit(STATE_LPM_TRANSACTION, &intel->flags)) { 956*89436546SLoic Poulain smp_mb__after_atomic(); 957*89436546SLoic Poulain wake_up_bit(&intel->flags, STATE_LPM_TRANSACTION); 958*89436546SLoic Poulain } 959*89436546SLoic Poulain break; 960*89436546SLoic Poulain case LPM_OP_RESUME_ACK: 961*89436546SLoic Poulain clear_bit(STATE_SUSPENDED, &intel->flags); 962*89436546SLoic Poulain if (test_and_clear_bit(STATE_LPM_TRANSACTION, &intel->flags)) { 963*89436546SLoic Poulain smp_mb__after_atomic(); 964*89436546SLoic Poulain wake_up_bit(&intel->flags, STATE_LPM_TRANSACTION); 965*89436546SLoic Poulain } 966*89436546SLoic Poulain break; 967b98469f4SLoic Poulain default: 968f44e78a5SLoic Poulain bt_dev_err(hdev, "Unknown LPM opcode (%02x)", lpm->opcode); 969b98469f4SLoic Poulain break; 970b98469f4SLoic Poulain } 971b98469f4SLoic Poulain 972b98469f4SLoic Poulain kfree_skb(skb); 973b98469f4SLoic Poulain 974b98469f4SLoic Poulain return 0; 975b98469f4SLoic Poulain } 976b98469f4SLoic Poulain 977b98469f4SLoic Poulain #define INTEL_RECV_LPM \ 978b98469f4SLoic Poulain .type = HCI_LPM_PKT, \ 979b98469f4SLoic Poulain .hlen = HCI_LPM_HDR_SIZE, \ 980b98469f4SLoic Poulain .loff = 1, \ 981b98469f4SLoic Poulain .lsize = 1, \ 982b98469f4SLoic Poulain .maxlen = HCI_LPM_MAX_SIZE 983b98469f4SLoic Poulain 984ca93cee5SLoic Poulain static const struct h4_recv_pkt intel_recv_pkts[] = { 985ca93cee5SLoic Poulain { H4_RECV_ACL, .recv = hci_recv_frame }, 986ca93cee5SLoic Poulain { H4_RECV_SCO, .recv = hci_recv_frame }, 987ca93cee5SLoic Poulain { H4_RECV_EVENT, .recv = intel_recv_event }, 988b98469f4SLoic Poulain { INTEL_RECV_LPM, .recv = intel_recv_lpm }, 989ca93cee5SLoic Poulain }; 990ca93cee5SLoic Poulain 991ca93cee5SLoic Poulain static int intel_recv(struct hci_uart *hu, const void *data, int count) 992ca93cee5SLoic Poulain { 993ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 994ca93cee5SLoic Poulain 995ca93cee5SLoic Poulain if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 996ca93cee5SLoic Poulain return -EUNATCH; 997ca93cee5SLoic Poulain 998ca93cee5SLoic Poulain intel->rx_skb = h4_recv_buf(hu->hdev, intel->rx_skb, data, count, 999ca93cee5SLoic Poulain intel_recv_pkts, 1000ca93cee5SLoic Poulain ARRAY_SIZE(intel_recv_pkts)); 1001ca93cee5SLoic Poulain if (IS_ERR(intel->rx_skb)) { 1002ca93cee5SLoic Poulain int err = PTR_ERR(intel->rx_skb); 1003f44e78a5SLoic Poulain bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err); 1004ca93cee5SLoic Poulain intel->rx_skb = NULL; 1005ca93cee5SLoic Poulain return err; 1006ca93cee5SLoic Poulain } 1007ca93cee5SLoic Poulain 1008ca93cee5SLoic Poulain return count; 1009ca93cee5SLoic Poulain } 1010ca93cee5SLoic Poulain 1011ca93cee5SLoic Poulain static int intel_enqueue(struct hci_uart *hu, struct sk_buff *skb) 1012ca93cee5SLoic Poulain { 1013ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 1014ca93cee5SLoic Poulain 1015ca93cee5SLoic Poulain BT_DBG("hu %p skb %p", hu, skb); 1016ca93cee5SLoic Poulain 1017ca93cee5SLoic Poulain skb_queue_tail(&intel->txq, skb); 1018ca93cee5SLoic Poulain 1019ca93cee5SLoic Poulain return 0; 1020ca93cee5SLoic Poulain } 1021ca93cee5SLoic Poulain 1022ca93cee5SLoic Poulain static struct sk_buff *intel_dequeue(struct hci_uart *hu) 1023ca93cee5SLoic Poulain { 1024ca93cee5SLoic Poulain struct intel_data *intel = hu->priv; 1025ca93cee5SLoic Poulain struct sk_buff *skb; 1026ca93cee5SLoic Poulain 1027ca93cee5SLoic Poulain skb = skb_dequeue(&intel->txq); 1028ca93cee5SLoic Poulain if (!skb) 1029ca93cee5SLoic Poulain return skb; 1030ca93cee5SLoic Poulain 1031ca93cee5SLoic Poulain if (test_bit(STATE_BOOTLOADER, &intel->flags) && 1032ca93cee5SLoic Poulain (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT)) { 1033ca93cee5SLoic Poulain struct hci_command_hdr *cmd = (void *)skb->data; 1034ca93cee5SLoic Poulain __u16 opcode = le16_to_cpu(cmd->opcode); 1035ca93cee5SLoic Poulain 1036ca93cee5SLoic Poulain /* When the 0xfc01 command is issued to boot into 1037ca93cee5SLoic Poulain * the operational firmware, it will actually not 1038ca93cee5SLoic Poulain * send a command complete event. To keep the flow 1039ca93cee5SLoic Poulain * control working inject that event here. 1040ca93cee5SLoic Poulain */ 1041ca93cee5SLoic Poulain if (opcode == 0xfc01) 1042ca93cee5SLoic Poulain inject_cmd_complete(hu->hdev, opcode); 1043ca93cee5SLoic Poulain } 1044ca93cee5SLoic Poulain 1045ca93cee5SLoic Poulain /* Prepend skb with frame type */ 1046ca93cee5SLoic Poulain memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 1047ca93cee5SLoic Poulain 1048ca93cee5SLoic Poulain return skb; 1049ca93cee5SLoic Poulain } 1050ca93cee5SLoic Poulain 1051ca93cee5SLoic Poulain static const struct hci_uart_proto intel_proto = { 1052ca93cee5SLoic Poulain .id = HCI_UART_INTEL, 1053ca93cee5SLoic Poulain .name = "Intel", 1054ca93cee5SLoic Poulain .init_speed = 115200, 1055ff289559SLoic Poulain .oper_speed = 3000000, 1056ca93cee5SLoic Poulain .open = intel_open, 1057ca93cee5SLoic Poulain .close = intel_close, 1058ca93cee5SLoic Poulain .flush = intel_flush, 1059ca93cee5SLoic Poulain .setup = intel_setup, 1060ff289559SLoic Poulain .set_baudrate = intel_set_baudrate, 1061ca93cee5SLoic Poulain .recv = intel_recv, 1062ca93cee5SLoic Poulain .enqueue = intel_enqueue, 1063ca93cee5SLoic Poulain .dequeue = intel_dequeue, 1064ca93cee5SLoic Poulain }; 1065ca93cee5SLoic Poulain 10661ab1f239SLoic Poulain #ifdef CONFIG_ACPI 10671ab1f239SLoic Poulain static const struct acpi_device_id intel_acpi_match[] = { 10681ab1f239SLoic Poulain { "INT33E1", 0 }, 10691ab1f239SLoic Poulain { }, 10701ab1f239SLoic Poulain }; 10711ab1f239SLoic Poulain MODULE_DEVICE_TABLE(acpi, intel_acpi_match); 10721ab1f239SLoic Poulain 10731ab1f239SLoic Poulain static int intel_acpi_probe(struct intel_device *idev) 10741ab1f239SLoic Poulain { 10751ab1f239SLoic Poulain const struct acpi_device_id *id; 10761ab1f239SLoic Poulain 10771ab1f239SLoic Poulain id = acpi_match_device(intel_acpi_match, &idev->pdev->dev); 10781ab1f239SLoic Poulain if (!id) 10791ab1f239SLoic Poulain return -ENODEV; 10801ab1f239SLoic Poulain 10811ab1f239SLoic Poulain return 0; 10821ab1f239SLoic Poulain } 10831ab1f239SLoic Poulain #else 10841ab1f239SLoic Poulain static int intel_acpi_probe(struct intel_device *idev) 10851ab1f239SLoic Poulain { 10861ab1f239SLoic Poulain return -ENODEV; 10871ab1f239SLoic Poulain } 10881ab1f239SLoic Poulain #endif 10891ab1f239SLoic Poulain 10901ab1f239SLoic Poulain static int intel_probe(struct platform_device *pdev) 10911ab1f239SLoic Poulain { 10921ab1f239SLoic Poulain struct intel_device *idev; 10931ab1f239SLoic Poulain 10941ab1f239SLoic Poulain idev = devm_kzalloc(&pdev->dev, sizeof(*idev), GFP_KERNEL); 10951ab1f239SLoic Poulain if (!idev) 10961ab1f239SLoic Poulain return -ENOMEM; 10971ab1f239SLoic Poulain 10981ab1f239SLoic Poulain idev->pdev = pdev; 10991ab1f239SLoic Poulain 11001ab1f239SLoic Poulain if (ACPI_HANDLE(&pdev->dev)) { 11011ab1f239SLoic Poulain int err = intel_acpi_probe(idev); 11021ab1f239SLoic Poulain if (err) 11031ab1f239SLoic Poulain return err; 11041ab1f239SLoic Poulain } else { 11051ab1f239SLoic Poulain return -ENODEV; 11061ab1f239SLoic Poulain } 11071ab1f239SLoic Poulain 11081ab1f239SLoic Poulain idev->reset = devm_gpiod_get_optional(&pdev->dev, "reset", 11091ab1f239SLoic Poulain GPIOD_OUT_LOW); 11101ab1f239SLoic Poulain if (IS_ERR(idev->reset)) { 11111ab1f239SLoic Poulain dev_err(&pdev->dev, "Unable to retrieve gpio\n"); 11121ab1f239SLoic Poulain return PTR_ERR(idev->reset); 11131ab1f239SLoic Poulain } 11141ab1f239SLoic Poulain 1115765ea3abSLoic Poulain idev->irq = platform_get_irq(pdev, 0); 1116765ea3abSLoic Poulain if (idev->irq < 0) { 1117765ea3abSLoic Poulain struct gpio_desc *host_wake; 1118765ea3abSLoic Poulain 1119765ea3abSLoic Poulain dev_err(&pdev->dev, "No IRQ, falling back to gpio-irq\n"); 1120765ea3abSLoic Poulain 1121765ea3abSLoic Poulain host_wake = devm_gpiod_get_optional(&pdev->dev, "host-wake", 1122765ea3abSLoic Poulain GPIOD_IN); 1123765ea3abSLoic Poulain if (IS_ERR(host_wake)) { 1124765ea3abSLoic Poulain dev_err(&pdev->dev, "Unable to retrieve IRQ\n"); 1125765ea3abSLoic Poulain goto no_irq; 1126765ea3abSLoic Poulain } 1127765ea3abSLoic Poulain 1128765ea3abSLoic Poulain idev->irq = gpiod_to_irq(host_wake); 1129765ea3abSLoic Poulain if (idev->irq < 0) { 1130765ea3abSLoic Poulain dev_err(&pdev->dev, "No corresponding irq for gpio\n"); 1131765ea3abSLoic Poulain goto no_irq; 1132765ea3abSLoic Poulain } 1133765ea3abSLoic Poulain } 1134765ea3abSLoic Poulain 1135765ea3abSLoic Poulain /* Only enable wake-up/irq when controller is powered */ 1136765ea3abSLoic Poulain device_set_wakeup_capable(&pdev->dev, true); 1137765ea3abSLoic Poulain device_wakeup_disable(&pdev->dev); 1138765ea3abSLoic Poulain 1139765ea3abSLoic Poulain no_irq: 11401ab1f239SLoic Poulain platform_set_drvdata(pdev, idev); 11411ab1f239SLoic Poulain 11421ab1f239SLoic Poulain /* Place this instance on the device list */ 114367c8bde0SLoic Poulain mutex_lock(&intel_device_list_lock); 11441ab1f239SLoic Poulain list_add_tail(&idev->list, &intel_device_list); 114567c8bde0SLoic Poulain mutex_unlock(&intel_device_list_lock); 11461ab1f239SLoic Poulain 1147765ea3abSLoic Poulain dev_info(&pdev->dev, "registered, gpio(%d)/irq(%d).\n", 1148765ea3abSLoic Poulain desc_to_gpio(idev->reset), idev->irq); 11491ab1f239SLoic Poulain 11501ab1f239SLoic Poulain return 0; 11511ab1f239SLoic Poulain } 11521ab1f239SLoic Poulain 11531ab1f239SLoic Poulain static int intel_remove(struct platform_device *pdev) 11541ab1f239SLoic Poulain { 11551ab1f239SLoic Poulain struct intel_device *idev = platform_get_drvdata(pdev); 11561ab1f239SLoic Poulain 1157765ea3abSLoic Poulain device_wakeup_disable(&pdev->dev); 1158765ea3abSLoic Poulain 115967c8bde0SLoic Poulain mutex_lock(&intel_device_list_lock); 11601ab1f239SLoic Poulain list_del(&idev->list); 116167c8bde0SLoic Poulain mutex_unlock(&intel_device_list_lock); 11621ab1f239SLoic Poulain 11631ab1f239SLoic Poulain dev_info(&pdev->dev, "unregistered.\n"); 11641ab1f239SLoic Poulain 11651ab1f239SLoic Poulain return 0; 11661ab1f239SLoic Poulain } 11671ab1f239SLoic Poulain 11681ab1f239SLoic Poulain static struct platform_driver intel_driver = { 11691ab1f239SLoic Poulain .probe = intel_probe, 11701ab1f239SLoic Poulain .remove = intel_remove, 11711ab1f239SLoic Poulain .driver = { 11721ab1f239SLoic Poulain .name = "hci_intel", 11731ab1f239SLoic Poulain .acpi_match_table = ACPI_PTR(intel_acpi_match), 11741ab1f239SLoic Poulain }, 11751ab1f239SLoic Poulain }; 11761ab1f239SLoic Poulain 1177ca93cee5SLoic Poulain int __init intel_init(void) 1178ca93cee5SLoic Poulain { 11791ab1f239SLoic Poulain platform_driver_register(&intel_driver); 11801ab1f239SLoic Poulain 1181ca93cee5SLoic Poulain return hci_uart_register_proto(&intel_proto); 1182ca93cee5SLoic Poulain } 1183ca93cee5SLoic Poulain 1184ca93cee5SLoic Poulain int __exit intel_deinit(void) 1185ca93cee5SLoic Poulain { 11861ab1f239SLoic Poulain platform_driver_unregister(&intel_driver); 11871ab1f239SLoic Poulain 1188ca93cee5SLoic Poulain return hci_uart_unregister_proto(&intel_proto); 1189ca93cee5SLoic Poulain } 1190