| 1 | |
| 2 | |
| 3 |
|
| 4 | |
| 5 | * Bluetooth support for MediaTek SDIO devices
|
| 6 | *
|
| 7 | * This file is written based on btsdio.c and btmtkuart.c.
|
| 8 | *
|
| 9 | * Author: Sean Wang <[email protected]>
|
| 10 | *
|
| 11 |
|
| 12 |
|
| 13 | #include <linux/unaligned.h>
|
| 14 | #include <linux/atomic.h>
|
| 15 | #include <linux/gpio/consumer.h>
|
| 16 | #include <linux/init.h>
|
| 17 | #include <linux/iopoll.h>
|
| 18 | #include <linux/kernel.h>
|
| 19 | #include <linux/module.h>
|
| 20 | #include <linux/of.h>
|
| 21 | #include <linux/pm_runtime.h>
|
| 22 | #include <linux/skbuff.h>
|
| 23 | #include <linux/usb.h>
|
| 24 |
|
| 25 | #include <linux/mmc/host.h>
|
| 26 | #include <linux/mmc/sdio_ids.h>
|
| 27 | #include <linux/mmc/sdio_func.h>
|
| 28 |
|
| 29 | #include <net/bluetooth/bluetooth.h>
|
| 30 | #include <net/bluetooth/hci_core.h>
|
| 31 |
|
| 32 | #include "hci_uart.h"
|
| 33 | #include "btmtk.h"
|
| 34 |
|
| 35 | #define VERSION "0.1"
|
| 36 |
|
| 37 | #define MTKBTSDIO_AUTOSUSPEND_DELAY 1000
|
| 38 |
|
| 39 | static bool enable_autosuspend = true;
|
| 40 |
|
| 41 | struct btmtksdio_data {
|
| 42 | const char *fwname;
|
| 43 | u16 chipid;
|
| 44 | bool lp_mbox_supported;
|
| 45 | bool pm_runtime_supported;
|
| 46 | };
|
| 47 |
|
| 48 | static const struct btmtksdio_data mt7663_data = {
|
| 49 | .fwname = FIRMWARE_MT7663,
|
| 50 | .chipid = 0x7663,
|
| 51 | .lp_mbox_supported = false,
|
| 52 | .pm_runtime_supported = true,
|
| 53 | };
|
| 54 |
|
| 55 | static const struct btmtksdio_data mt7668_data = {
|
| 56 | .fwname = FIRMWARE_MT7668,
|
| 57 | .chipid = 0x7668,
|
| 58 | .lp_mbox_supported = false,
|
| 59 | .pm_runtime_supported = true,
|
| 60 | };
|
| 61 |
|
| 62 | static const struct btmtksdio_data mt7921_data = {
|
| 63 | .fwname = FIRMWARE_MT7961,
|
| 64 | .chipid = 0x7921,
|
| 65 | .lp_mbox_supported = true,
|
| 66 | .pm_runtime_supported = true,
|
| 67 | };
|
| 68 |
|
| 69 | static const struct btmtksdio_data mt7902_data = {
|
| 70 | .fwname = FIRMWARE_MT7902,
|
| 71 | .chipid = 0x7902,
|
| 72 | .lp_mbox_supported = false,
|
| 73 | .pm_runtime_supported = false,
|
| 74 | };
|
| 75 |
|
| 76 | static const struct sdio_device_id btmtksdio_table[] = {
|
| 77 | {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7663),
|
| 78 | .driver_data = (kernel_ulong_t)&mt7663_data },
|
| 79 | {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7668),
|
| 80 | .driver_data = (kernel_ulong_t)&mt7668_data },
|
| 81 | {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7961),
|
| 82 | .driver_data = (kernel_ulong_t)&mt7921_data },
|
| 83 | {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7902),
|
| 84 | .driver_data = (kernel_ulong_t)&mt7902_data },
|
| 85 | { }
|
| 86 | };
|
| 87 | MODULE_DEVICE_TABLE(sdio, btmtksdio_table);
|
| 88 |
|
| 89 | #define MTK_REG_CHLPCR 0x4
|
| 90 | #define C_INT_EN_SET BIT(0)
|
| 91 | #define C_INT_EN_CLR BIT(1)
|
| 92 | #define C_FW_OWN_REQ_SET BIT(8)
|
| 93 | #define C_COM_DRV_OWN BIT(8)
|
| 94 | #define C_FW_OWN_REQ_CLR BIT(9)
|
| 95 |
|
| 96 | #define MTK_REG_CSDIOCSR 0x8
|
| 97 | #define SDIO_RE_INIT_EN BIT(0)
|
| 98 | #define SDIO_INT_CTL BIT(2)
|
| 99 |
|
| 100 | #define MTK_REG_CHCR 0xc
|
| 101 | #define C_INT_CLR_CTRL BIT(1)
|
| 102 | #define BT_RST_DONE BIT(8)
|
| 103 |
|
| 104 |
|
| 105 | #define MTK_REG_CHISR 0x10
|
| 106 | #define MTK_REG_CHIER 0x14
|
| 107 | #define FW_OWN_BACK_INT BIT(0)
|
| 108 | #define RX_DONE_INT BIT(1)
|
| 109 | #define TX_EMPTY BIT(2)
|
| 110 | #define TX_FIFO_OVERFLOW BIT(8)
|
| 111 | #define FW_MAILBOX_INT BIT(15)
|
| 112 | #define INT_MASK GENMASK(15, 0)
|
| 113 | #define RX_PKT_LEN GENMASK(31, 16)
|
| 114 |
|
| 115 | #define MTK_REG_CSICR 0xc0
|
| 116 | #define CSICR_CLR_MBOX_ACK BIT(0)
|
| 117 | #define MTK_REG_PH2DSM0R 0xc4
|
| 118 | #define PH2DSM0R_DRIVER_OWN BIT(0)
|
| 119 | #define MTK_REG_PD2HRM0R 0xdc
|
| 120 | #define PD2HRM0R_DRV_OWN BIT(0)
|
| 121 |
|
| 122 | #define MTK_REG_CTDR 0x18
|
| 123 |
|
| 124 | #define MTK_REG_CRDR 0x1c
|
| 125 |
|
| 126 | #define MTK_REG_CRPLR 0x24
|
| 127 |
|
| 128 | #define MTK_SDIO_BLOCK_SIZE 256
|
| 129 |
|
| 130 | #define BTMTKSDIO_TX_WAIT_VND_EVT 1
|
| 131 | #define BTMTKSDIO_HW_TX_READY 2
|
| 132 | #define BTMTKSDIO_FUNC_ENABLED 3
|
| 133 | #define BTMTKSDIO_PATCH_ENABLED 4
|
| 134 | #define BTMTKSDIO_HW_RESET_ACTIVE 5
|
| 135 | #define BTMTKSDIO_BT_WAKE_ENABLED 6
|
| 136 |
|
| 137 | struct mtkbtsdio_hdr {
|
| 138 | __le16 len;
|
| 139 | __le16 reserved;
|
| 140 | u8 bt_type;
|
| 141 | } __packed;
|
| 142 |
|
| 143 | struct btmtksdio_dev {
|
| 144 | struct hci_dev *hdev;
|
| 145 | struct sdio_func *func;
|
| 146 | struct device *dev;
|
| 147 |
|
| 148 | struct work_struct txrx_work;
|
| 149 | unsigned long tx_state;
|
| 150 | struct sk_buff_head txq;
|
| 151 |
|
| 152 | struct sk_buff *evt_skb;
|
| 153 |
|
| 154 | const struct btmtksdio_data *data;
|
| 155 |
|
| 156 | struct gpio_desc *reset;
|
| 157 | };
|
| 158 |
|
| 159 | static int mtk_hci_wmt_sync(struct hci_dev *hdev,
|
| 160 | struct btmtk_hci_wmt_params *wmt_params)
|
| 161 | {
|
| 162 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 163 | struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
|
| 164 | struct btmtk_hci_wmt_evt_reg *wmt_evt_reg;
|
| 165 | u32 hlen, status = BTMTK_WMT_INVALID;
|
| 166 | struct btmtk_hci_wmt_evt *wmt_evt;
|
| 167 | struct btmtk_hci_wmt_cmd *wc;
|
| 168 | struct btmtk_wmt_hdr *hdr;
|
| 169 | int err;
|
| 170 |
|
| 171 |
|
| 172 | hlen = sizeof(*hdr) + wmt_params->dlen;
|
| 173 | if (hlen > 255)
|
| 174 | return -EINVAL;
|
| 175 |
|
| 176 | wc = kzalloc(hlen, GFP_KERNEL);
|
| 177 | if (!wc)
|
| 178 | return -ENOMEM;
|
| 179 |
|
| 180 | hdr = &wc->hdr;
|
| 181 | hdr->dir = 1;
|
| 182 | hdr->op = wmt_params->op;
|
| 183 | hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
|
| 184 | hdr->flag = wmt_params->flag;
|
| 185 | memcpy(wc->data, wmt_params->data, wmt_params->dlen);
|
| 186 |
|
| 187 | set_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
|
| 188 |
|
| 189 | err = __hci_cmd_send(hdev, 0xfc6f, hlen, wc);
|
| 190 | if (err < 0) {
|
| 191 | clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
|
| 192 | goto err_free_wc;
|
| 193 | }
|
| 194 |
|
| 195 | |
| 196 | * specific event and will not have the Command Status or Command
|
| 197 | * Complete as with usual HCI command flow control.
|
| 198 | *
|
| 199 | * After sending the command, wait for BTMTKSDIO_TX_WAIT_VND_EVT
|
| 200 | * state to be cleared. The driver specific event receive routine
|
| 201 | * will clear that state and with that indicate completion of the
|
| 202 | * WMT command.
|
| 203 |
|
| 204 | err = wait_on_bit_timeout(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT,
|
| 205 | TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
|
| 206 | if (err == -EINTR) {
|
| 207 | bt_dev_err(hdev, "Execution of wmt command interrupted");
|
| 208 | clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
|
| 209 | goto err_free_wc;
|
| 210 | }
|
| 211 |
|
| 212 | if (err) {
|
| 213 | bt_dev_err(hdev, "Execution of wmt command timed out");
|
| 214 | clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
|
| 215 | err = -ETIMEDOUT;
|
| 216 | goto err_free_wc;
|
| 217 | }
|
| 218 |
|
| 219 |
|
| 220 | wmt_evt = skb_pull_data(bdev->evt_skb, sizeof(*wmt_evt));
|
| 221 | if (!wmt_evt) {
|
| 222 | bt_dev_err(hdev, "WMT event too short (%u bytes)",
|
| 223 | bdev->evt_skb->len);
|
| 224 | err = -EINVAL;
|
| 225 | goto err_free_skb;
|
| 226 | }
|
| 227 |
|
| 228 | if (wmt_evt->whdr.op != hdr->op) {
|
| 229 | bt_dev_err(hdev, "Wrong op received %d expected %d",
|
| 230 | wmt_evt->whdr.op, hdr->op);
|
| 231 | err = -EIO;
|
| 232 | goto err_free_skb;
|
| 233 | }
|
| 234 |
|
| 235 | switch (wmt_evt->whdr.op) {
|
| 236 | case BTMTK_WMT_SEMAPHORE:
|
| 237 | if (wmt_evt->whdr.flag == 2)
|
| 238 | status = BTMTK_WMT_PATCH_UNDONE;
|
| 239 | else
|
| 240 | status = BTMTK_WMT_PATCH_DONE;
|
| 241 | break;
|
| 242 | case BTMTK_WMT_FUNC_CTRL:
|
| 243 | if (!skb_pull_data(bdev->evt_skb,
|
| 244 | sizeof(wmt_evt_funcc->status))) {
|
| 245 | |
| 246 | * the WMT header and no trailing status word; the
|
| 247 | * result is carried in the header's own flag byte.
|
| 248 |
|
| 249 | status = wmt_evt->whdr.flag ? BTMTK_WMT_ON_UNDONE :
|
| 250 | BTMTK_WMT_ON_DONE;
|
| 251 | break;
|
| 252 | }
|
| 253 |
|
| 254 | wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
|
| 255 | if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
|
| 256 | status = BTMTK_WMT_ON_DONE;
|
| 257 | else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
|
| 258 | status = BTMTK_WMT_ON_PROGRESS;
|
| 259 | else
|
| 260 | status = BTMTK_WMT_ON_UNDONE;
|
| 261 | break;
|
| 262 | case BTMTK_WMT_PATCH_DWNLD:
|
| 263 | if (wmt_evt->whdr.flag == 2)
|
| 264 | status = BTMTK_WMT_PATCH_DONE;
|
| 265 | else if (wmt_evt->whdr.flag == 1)
|
| 266 | status = BTMTK_WMT_PATCH_PROGRESS;
|
| 267 | else
|
| 268 | status = BTMTK_WMT_PATCH_UNDONE;
|
| 269 | break;
|
| 270 | case BTMTK_WMT_REGISTER:
|
| 271 | wmt_evt_reg = (struct btmtk_hci_wmt_evt_reg *)wmt_evt;
|
| 272 | if (le16_to_cpu(wmt_evt->whdr.dlen) == 12)
|
| 273 | status = le32_to_cpu(wmt_evt_reg->val);
|
| 274 | break;
|
| 275 | }
|
| 276 |
|
| 277 | if (wmt_params->status)
|
| 278 | *wmt_params->status = status;
|
| 279 |
|
| 280 | err_free_skb:
|
| 281 | kfree_skb(bdev->evt_skb);
|
| 282 | bdev->evt_skb = NULL;
|
| 283 | err_free_wc:
|
| 284 | kfree(wc);
|
| 285 |
|
| 286 | return err;
|
| 287 | }
|
| 288 |
|
| 289 | static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev,
|
| 290 | struct sk_buff *skb)
|
| 291 | {
|
| 292 | struct mtkbtsdio_hdr *sdio_hdr;
|
| 293 | unsigned int len, pad_len;
|
| 294 | int err;
|
| 295 |
|
| 296 | |
| 297 | * that there is enough room for the SDIO header
|
| 298 |
|
| 299 | err = skb_cow_head(skb, sizeof(*sdio_hdr));
|
| 300 | if (err < 0)
|
| 301 | return err;
|
| 302 |
|
| 303 | |
| 304 | * has to provide tailroom for the padding as well
|
| 305 |
|
| 306 | len = skb->len + sizeof(*sdio_hdr);
|
| 307 | pad_len = round_up(len, MTK_SDIO_BLOCK_SIZE) - len;
|
| 308 |
|
| 309 | if (unlikely(skb_tailroom(skb) < pad_len)) {
|
| 310 | err = pskb_expand_head(skb, 0, pad_len, GFP_ATOMIC);
|
| 311 | if (err < 0)
|
| 312 | return err;
|
| 313 | }
|
| 314 |
|
| 315 |
|
| 316 | skb_push(skb, sizeof(*sdio_hdr));
|
| 317 |
|
| 318 | sdio_hdr = (void *)skb->data;
|
| 319 | sdio_hdr->len = cpu_to_le16(skb->len);
|
| 320 | sdio_hdr->reserved = cpu_to_le16(0);
|
| 321 | sdio_hdr->bt_type = hci_skb_pkt_type(skb);
|
| 322 |
|
| 323 |
|
| 324 | skb_put_zero(skb, pad_len);
|
| 325 |
|
| 326 | clear_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
|
| 327 | err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data, skb->len);
|
| 328 | if (err < 0)
|
| 329 | goto err_skb_restore;
|
| 330 |
|
| 331 | bdev->hdev->stat.byte_tx += len;
|
| 332 |
|
| 333 | kfree_skb(skb);
|
| 334 |
|
| 335 | return 0;
|
| 336 |
|
| 337 | err_skb_restore:
|
| 338 | skb_trim(skb, len);
|
| 339 | skb_pull(skb, sizeof(*sdio_hdr));
|
| 340 |
|
| 341 | return err;
|
| 342 | }
|
| 343 |
|
| 344 | static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev)
|
| 345 | {
|
| 346 | return sdio_readl(bdev->func, MTK_REG_CHLPCR, NULL);
|
| 347 | }
|
| 348 |
|
| 349 | static u32 btmtksdio_drv_own_query_79xx(struct btmtksdio_dev *bdev)
|
| 350 | {
|
| 351 | return sdio_readl(bdev->func, MTK_REG_PD2HRM0R, NULL);
|
| 352 | }
|
| 353 |
|
| 354 | static u32 btmtksdio_chcr_query(struct btmtksdio_dev *bdev)
|
| 355 | {
|
| 356 | return sdio_readl(bdev->func, MTK_REG_CHCR, NULL);
|
| 357 | }
|
| 358 |
|
| 359 | static int btmtksdio_fw_pmctrl(struct btmtksdio_dev *bdev)
|
| 360 | {
|
| 361 | u32 status;
|
| 362 | int err;
|
| 363 |
|
| 364 | sdio_claim_host(bdev->func);
|
| 365 |
|
| 366 | if (bdev->data->lp_mbox_supported &&
|
| 367 | test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state)) {
|
| 368 | sdio_writel(bdev->func, CSICR_CLR_MBOX_ACK, MTK_REG_CSICR,
|
| 369 | &err);
|
| 370 | err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev,
|
| 371 | status, !(status & PD2HRM0R_DRV_OWN),
|
| 372 | 2000, 1000000);
|
| 373 | if (err < 0) {
|
| 374 | bt_dev_err(bdev->hdev, "mailbox ACK not cleared");
|
| 375 | goto out;
|
| 376 | }
|
| 377 | }
|
| 378 |
|
| 379 |
|
| 380 | sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err);
|
| 381 | if (err < 0)
|
| 382 | goto out;
|
| 383 |
|
| 384 | err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
|
| 385 | !(status & C_COM_DRV_OWN), 2000, 1000000);
|
| 386 |
|
| 387 | out:
|
| 388 | sdio_release_host(bdev->func);
|
| 389 |
|
| 390 | if (err < 0)
|
| 391 | bt_dev_err(bdev->hdev, "Cannot return ownership to device");
|
| 392 |
|
| 393 | return err;
|
| 394 | }
|
| 395 |
|
| 396 | static int btmtksdio_drv_pmctrl(struct btmtksdio_dev *bdev)
|
| 397 | {
|
| 398 | u32 status;
|
| 399 | int err;
|
| 400 |
|
| 401 | sdio_claim_host(bdev->func);
|
| 402 |
|
| 403 |
|
| 404 | sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err);
|
| 405 | if (err < 0)
|
| 406 | goto out;
|
| 407 |
|
| 408 | err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
|
| 409 | status & C_COM_DRV_OWN, 2000, 1000000);
|
| 410 |
|
| 411 | if (!err && bdev->data->lp_mbox_supported &&
|
| 412 | test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state))
|
| 413 | err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev,
|
| 414 | status, status & PD2HRM0R_DRV_OWN,
|
| 415 | 2000, 1000000);
|
| 416 |
|
| 417 | out:
|
| 418 | sdio_release_host(bdev->func);
|
| 419 |
|
| 420 | if (err < 0)
|
| 421 | bt_dev_err(bdev->hdev, "Cannot get ownership from device");
|
| 422 |
|
| 423 | return err;
|
| 424 | }
|
| 425 |
|
| 426 | static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
|
| 427 | {
|
| 428 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 429 | struct hci_event_hdr *hdr = (void *)skb->data;
|
| 430 | u8 evt = hdr->evt;
|
| 431 | int err;
|
| 432 |
|
| 433 | |
| 434 | * and being processed the events from there then.
|
| 435 |
|
| 436 | if (test_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state)) {
|
| 437 | bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
|
| 438 | if (!bdev->evt_skb) {
|
| 439 | err = -ENOMEM;
|
| 440 | goto err_out;
|
| 441 | }
|
| 442 | }
|
| 443 |
|
| 444 | err = hci_recv_frame(hdev, skb);
|
| 445 | if (err < 0)
|
| 446 | goto err_free_skb;
|
| 447 |
|
| 448 | if (evt == HCI_EV_WMT) {
|
| 449 | if (test_and_clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT,
|
| 450 | &bdev->tx_state)) {
|
| 451 |
|
| 452 | smp_mb__after_atomic();
|
| 453 | wake_up_bit(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT);
|
| 454 | }
|
| 455 | }
|
| 456 |
|
| 457 | return 0;
|
| 458 |
|
| 459 | err_free_skb:
|
| 460 | kfree_skb(bdev->evt_skb);
|
| 461 | bdev->evt_skb = NULL;
|
| 462 |
|
| 463 | err_out:
|
| 464 | return err;
|
| 465 | }
|
| 466 |
|
| 467 | static int btmtksdio_recv_acl(struct hci_dev *hdev, struct sk_buff *skb)
|
| 468 | {
|
| 469 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 470 | u16 handle = le16_to_cpu(hci_acl_hdr(skb)->handle);
|
| 471 |
|
| 472 | switch (handle) {
|
| 473 | case 0xfc6f:
|
| 474 | |
| 475 | * device can no longer suspend and thus disable auto-suspend.
|
| 476 |
|
| 477 | pm_runtime_forbid(bdev->dev);
|
| 478 | fallthrough;
|
| 479 | case 0x05ff:
|
| 480 | case 0x05fe:
|
| 481 |
|
| 482 | return hci_recv_diag(hdev, skb);
|
| 483 | }
|
| 484 |
|
| 485 | return hci_recv_frame(hdev, skb);
|
| 486 | }
|
| 487 |
|
| 488 | static const struct h4_recv_pkt mtk_recv_pkts[] = {
|
| 489 | { H4_RECV_ACL, .recv = btmtksdio_recv_acl },
|
| 490 | { H4_RECV_SCO, .recv = hci_recv_frame },
|
| 491 | { H4_RECV_EVENT, .recv = btmtksdio_recv_event },
|
| 492 | };
|
| 493 |
|
| 494 | static int btmtksdio_rx_packet(struct btmtksdio_dev *bdev, u16 rx_size)
|
| 495 | {
|
| 496 | const struct h4_recv_pkt *pkts = mtk_recv_pkts;
|
| 497 | int pkts_count = ARRAY_SIZE(mtk_recv_pkts);
|
| 498 | struct mtkbtsdio_hdr *sdio_hdr;
|
| 499 | int err, i, pad_size;
|
| 500 | struct sk_buff *skb;
|
| 501 | u16 dlen;
|
| 502 |
|
| 503 | if (rx_size < sizeof(*sdio_hdr))
|
| 504 | return -EILSEQ;
|
| 505 |
|
| 506 |
|
| 507 | skb = bt_skb_alloc(rx_size, GFP_KERNEL);
|
| 508 | if (!skb)
|
| 509 | return -ENOMEM;
|
| 510 |
|
| 511 | skb_put(skb, rx_size);
|
| 512 |
|
| 513 | err = sdio_readsb(bdev->func, skb->data, MTK_REG_CRDR, rx_size);
|
| 514 | if (err < 0)
|
| 515 | goto err_kfree_skb;
|
| 516 |
|
| 517 | sdio_hdr = (void *)skb->data;
|
| 518 |
|
| 519 | |
| 520 | * be cleaner.
|
| 521 |
|
| 522 | err = -EILSEQ;
|
| 523 |
|
| 524 | if (rx_size != le16_to_cpu(sdio_hdr->len)) {
|
| 525 | bt_dev_err(bdev->hdev, "Rx size in sdio header is mismatched ");
|
| 526 | goto err_kfree_skb;
|
| 527 | }
|
| 528 |
|
| 529 | hci_skb_pkt_type(skb) = sdio_hdr->bt_type;
|
| 530 |
|
| 531 |
|
| 532 | skb_pull(skb, sizeof(*sdio_hdr));
|
| 533 |
|
| 534 | |
| 535 | * many padding bytes at the tail, these padding bytes should be removed
|
| 536 | * before the packet is indicated to the core layer.
|
| 537 |
|
| 538 | for (i = 0; i < pkts_count; i++) {
|
| 539 | if (sdio_hdr->bt_type == (&pkts[i])->type)
|
| 540 | break;
|
| 541 | }
|
| 542 |
|
| 543 | if (i >= pkts_count) {
|
| 544 | bt_dev_err(bdev->hdev, "Invalid bt type 0x%02x",
|
| 545 | sdio_hdr->bt_type);
|
| 546 | goto err_kfree_skb;
|
| 547 | }
|
| 548 |
|
| 549 |
|
| 550 | if (skb->len < (&pkts[i])->hlen) {
|
| 551 | bt_dev_err(bdev->hdev, "The size of bt header is mismatched");
|
| 552 | goto err_kfree_skb;
|
| 553 | }
|
| 554 |
|
| 555 | switch ((&pkts[i])->lsize) {
|
| 556 | case 1:
|
| 557 | dlen = skb->data[(&pkts[i])->loff];
|
| 558 | break;
|
| 559 | case 2:
|
| 560 | dlen = get_unaligned_le16(skb->data +
|
| 561 | (&pkts[i])->loff);
|
| 562 | break;
|
| 563 | default:
|
| 564 | goto err_kfree_skb;
|
| 565 | }
|
| 566 |
|
| 567 | pad_size = skb->len - (&pkts[i])->hlen - dlen;
|
| 568 |
|
| 569 |
|
| 570 | if (pad_size < 0) {
|
| 571 | bt_dev_err(bdev->hdev, "The size of bt payload is mismatched");
|
| 572 | goto err_kfree_skb;
|
| 573 | }
|
| 574 |
|
| 575 |
|
| 576 | skb_trim(skb, skb->len - pad_size);
|
| 577 |
|
| 578 |
|
| 579 | (&pkts[i])->recv(bdev->hdev, skb);
|
| 580 |
|
| 581 | bdev->hdev->stat.byte_rx += rx_size;
|
| 582 |
|
| 583 | return 0;
|
| 584 |
|
| 585 | err_kfree_skb:
|
| 586 | kfree_skb(skb);
|
| 587 |
|
| 588 | return err;
|
| 589 | }
|
| 590 |
|
| 591 | static void btmtksdio_txrx_work(struct work_struct *work)
|
| 592 | {
|
| 593 | struct btmtksdio_dev *bdev = container_of(work, struct btmtksdio_dev,
|
| 594 | txrx_work);
|
| 595 | unsigned long txrx_timeout;
|
| 596 | u32 int_status, rx_size;
|
| 597 | struct sk_buff *skb;
|
| 598 | int err;
|
| 599 |
|
| 600 | pm_runtime_get_sync(bdev->dev);
|
| 601 |
|
| 602 | sdio_claim_host(bdev->func);
|
| 603 |
|
| 604 |
|
| 605 | sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
|
| 606 |
|
| 607 | txrx_timeout = jiffies + 5 * HZ;
|
| 608 |
|
| 609 | do {
|
| 610 | int_status = sdio_readl(bdev->func, MTK_REG_CHISR, NULL);
|
| 611 |
|
| 612 | |
| 613 | * hardware.
|
| 614 | *
|
| 615 | * Note that we don't ack any status during operations to avoid race
|
| 616 | * condition between the host and the device such as it's possible to
|
| 617 | * mistakenly ack RX_DONE for the next packet and then cause interrupts
|
| 618 | * not be raised again but there is still pending data in the hardware
|
| 619 | * FIFO.
|
| 620 |
|
| 621 | sdio_writel(bdev->func, int_status, MTK_REG_CHISR, NULL);
|
| 622 | int_status &= INT_MASK;
|
| 623 |
|
| 624 | if ((int_status & FW_MAILBOX_INT) &&
|
| 625 | bdev->data->chipid == 0x7921) {
|
| 626 | sdio_writel(bdev->func, PH2DSM0R_DRIVER_OWN,
|
| 627 | MTK_REG_PH2DSM0R, NULL);
|
| 628 | }
|
| 629 |
|
| 630 | if (int_status & FW_OWN_BACK_INT)
|
| 631 | bt_dev_dbg(bdev->hdev, "Get fw own back");
|
| 632 |
|
| 633 | if (int_status & TX_EMPTY)
|
| 634 | set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
|
| 635 |
|
| 636 | else if (unlikely(int_status & TX_FIFO_OVERFLOW))
|
| 637 | bt_dev_warn(bdev->hdev, "Tx fifo overflow");
|
| 638 |
|
| 639 | if (test_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state)) {
|
| 640 | skb = skb_dequeue(&bdev->txq);
|
| 641 | if (skb) {
|
| 642 | err = btmtksdio_tx_packet(bdev, skb);
|
| 643 | if (err < 0) {
|
| 644 | bdev->hdev->stat.err_tx++;
|
| 645 | skb_queue_head(&bdev->txq, skb);
|
| 646 | }
|
| 647 | }
|
| 648 | }
|
| 649 |
|
| 650 | if (int_status & RX_DONE_INT) {
|
| 651 | rx_size = sdio_readl(bdev->func, MTK_REG_CRPLR, NULL);
|
| 652 | rx_size = (rx_size & RX_PKT_LEN) >> 16;
|
| 653 | if (btmtksdio_rx_packet(bdev, rx_size) < 0)
|
| 654 | bdev->hdev->stat.err_rx++;
|
| 655 | }
|
| 656 | } while (int_status && time_is_after_jiffies(txrx_timeout));
|
| 657 |
|
| 658 |
|
| 659 | if (bdev->func->irq_handler)
|
| 660 | sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, NULL);
|
| 661 |
|
| 662 | sdio_release_host(bdev->func);
|
| 663 |
|
| 664 | pm_runtime_put_autosuspend(bdev->dev);
|
| 665 | }
|
| 666 |
|
| 667 | static void btmtksdio_interrupt(struct sdio_func *func)
|
| 668 | {
|
| 669 | struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
|
| 670 |
|
| 671 | if (test_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state)) {
|
| 672 | if (bdev->hdev->suspended)
|
| 673 | pm_wakeup_event(bdev->dev, 0);
|
| 674 | clear_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state);
|
| 675 | }
|
| 676 |
|
| 677 |
|
| 678 | sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
|
| 679 |
|
| 680 | schedule_work(&bdev->txrx_work);
|
| 681 | }
|
| 682 |
|
| 683 | static int btmtksdio_open(struct hci_dev *hdev)
|
| 684 | {
|
| 685 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 686 | u32 val;
|
| 687 | int err;
|
| 688 |
|
| 689 | sdio_claim_host(bdev->func);
|
| 690 |
|
| 691 | err = sdio_enable_func(bdev->func);
|
| 692 | if (err < 0)
|
| 693 | goto err_release_host;
|
| 694 |
|
| 695 | set_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);
|
| 696 |
|
| 697 | err = btmtksdio_drv_pmctrl(bdev);
|
| 698 | if (err < 0)
|
| 699 | goto err_disable_func;
|
| 700 |
|
| 701 |
|
| 702 | sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, &err);
|
| 703 | if (err < 0)
|
| 704 | goto err_disable_func;
|
| 705 |
|
| 706 | sdio_writel(bdev->func, 0, MTK_REG_CHIER, &err);
|
| 707 | if (err < 0)
|
| 708 | goto err_disable_func;
|
| 709 |
|
| 710 | err = sdio_claim_irq(bdev->func, btmtksdio_interrupt);
|
| 711 | if (err < 0)
|
| 712 | goto err_disable_func;
|
| 713 |
|
| 714 | err = sdio_set_block_size(bdev->func, MTK_SDIO_BLOCK_SIZE);
|
| 715 | if (err < 0)
|
| 716 | goto err_release_irq;
|
| 717 |
|
| 718 | |
| 719 | * synchronous interrupt is supported in SDIO 4-bit mode
|
| 720 |
|
| 721 | val = sdio_readl(bdev->func, MTK_REG_CSDIOCSR, &err);
|
| 722 | if (err < 0)
|
| 723 | goto err_release_irq;
|
| 724 |
|
| 725 | val |= SDIO_INT_CTL;
|
| 726 | sdio_writel(bdev->func, val, MTK_REG_CSDIOCSR, &err);
|
| 727 | if (err < 0)
|
| 728 | goto err_release_irq;
|
| 729 |
|
| 730 |
|
| 731 | val = sdio_readl(bdev->func, MTK_REG_CHCR, &err);
|
| 732 | if (err < 0)
|
| 733 | goto err_release_irq;
|
| 734 |
|
| 735 | val |= C_INT_CLR_CTRL;
|
| 736 | sdio_writel(bdev->func, val, MTK_REG_CHCR, &err);
|
| 737 | if (err < 0)
|
| 738 | goto err_release_irq;
|
| 739 |
|
| 740 |
|
| 741 | sdio_writel(bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW,
|
| 742 | MTK_REG_CHIER, &err);
|
| 743 | if (err < 0)
|
| 744 | goto err_release_irq;
|
| 745 |
|
| 746 |
|
| 747 | sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, &err);
|
| 748 | if (err < 0)
|
| 749 | goto err_release_irq;
|
| 750 |
|
| 751 | sdio_release_host(bdev->func);
|
| 752 |
|
| 753 | return 0;
|
| 754 |
|
| 755 | err_release_irq:
|
| 756 | sdio_release_irq(bdev->func);
|
| 757 |
|
| 758 | err_disable_func:
|
| 759 | sdio_disable_func(bdev->func);
|
| 760 |
|
| 761 | err_release_host:
|
| 762 | sdio_release_host(bdev->func);
|
| 763 |
|
| 764 | return err;
|
| 765 | }
|
| 766 |
|
| 767 | static int btmtksdio_close(struct hci_dev *hdev)
|
| 768 | {
|
| 769 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 770 |
|
| 771 |
|
| 772 | if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
|
| 773 | return 0;
|
| 774 |
|
| 775 | sdio_claim_host(bdev->func);
|
| 776 |
|
| 777 |
|
| 778 | sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
|
| 779 |
|
| 780 | sdio_release_irq(bdev->func);
|
| 781 |
|
| 782 | cancel_work_sync(&bdev->txrx_work);
|
| 783 |
|
| 784 | btmtksdio_fw_pmctrl(bdev);
|
| 785 |
|
| 786 | clear_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);
|
| 787 | sdio_disable_func(bdev->func);
|
| 788 |
|
| 789 | sdio_release_host(bdev->func);
|
| 790 |
|
| 791 | return 0;
|
| 792 | }
|
| 793 |
|
| 794 | static int btmtksdio_flush(struct hci_dev *hdev)
|
| 795 | {
|
| 796 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 797 |
|
| 798 | skb_queue_purge(&bdev->txq);
|
| 799 |
|
| 800 | cancel_work_sync(&bdev->txrx_work);
|
| 801 |
|
| 802 | return 0;
|
| 803 | }
|
| 804 |
|
| 805 | static int btmtksdio_func_query(struct hci_dev *hdev)
|
| 806 | {
|
| 807 | struct btmtk_hci_wmt_params wmt_params;
|
| 808 | int status, err;
|
| 809 | u8 param = 0;
|
| 810 |
|
| 811 |
|
| 812 | wmt_params.op = BTMTK_WMT_FUNC_CTRL;
|
| 813 | wmt_params.flag = 4;
|
| 814 | wmt_params.dlen = sizeof(param);
|
| 815 | wmt_params.data = ¶m;
|
| 816 | wmt_params.status = &status;
|
| 817 |
|
| 818 | err = mtk_hci_wmt_sync(hdev, &wmt_params);
|
| 819 | if (err < 0) {
|
| 820 | bt_dev_err(hdev, "Failed to query function status (%d)", err);
|
| 821 | return err;
|
| 822 | }
|
| 823 |
|
| 824 | return status;
|
| 825 | }
|
| 826 |
|
| 827 | static int mt76xx_setup(struct hci_dev *hdev, const char *fwname)
|
| 828 | {
|
| 829 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 830 | struct btmtk_hci_wmt_params wmt_params;
|
| 831 | struct btmtk_tci_sleep tci_sleep;
|
| 832 | struct sk_buff *skb;
|
| 833 | int err, status;
|
| 834 | u8 param = 0x1;
|
| 835 |
|
| 836 |
|
| 837 | wmt_params.op = BTMTK_WMT_SEMAPHORE;
|
| 838 | wmt_params.flag = 1;
|
| 839 | wmt_params.dlen = 0;
|
| 840 | wmt_params.data = NULL;
|
| 841 | wmt_params.status = &status;
|
| 842 |
|
| 843 | err = mtk_hci_wmt_sync(hdev, &wmt_params);
|
| 844 | if (err < 0) {
|
| 845 | bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
|
| 846 | return err;
|
| 847 | }
|
| 848 |
|
| 849 | if (status == BTMTK_WMT_PATCH_DONE) {
|
| 850 | bt_dev_info(hdev, "Firmware already downloaded");
|
| 851 | goto ignore_setup_fw;
|
| 852 | }
|
| 853 |
|
| 854 |
|
| 855 | err = btmtk_setup_firmware(hdev, fwname, mtk_hci_wmt_sync);
|
| 856 | if (err < 0)
|
| 857 | return err;
|
| 858 |
|
| 859 | ignore_setup_fw:
|
| 860 |
|
| 861 | err = readx_poll_timeout(btmtksdio_func_query, hdev, status,
|
| 862 | status < 0 || status != BTMTK_WMT_ON_PROGRESS,
|
| 863 | 2000, 5000000);
|
| 864 |
|
| 865 | if (err < 0)
|
| 866 | return err;
|
| 867 |
|
| 868 |
|
| 869 | if (status < 0)
|
| 870 | return status;
|
| 871 |
|
| 872 | if (status == BTMTK_WMT_ON_DONE) {
|
| 873 | bt_dev_info(hdev, "function already on");
|
| 874 | goto ignore_func_on;
|
| 875 | }
|
| 876 |
|
| 877 |
|
| 878 | wmt_params.op = BTMTK_WMT_FUNC_CTRL;
|
| 879 | wmt_params.flag = 0;
|
| 880 | wmt_params.dlen = sizeof(param);
|
| 881 | wmt_params.data = ¶m;
|
| 882 | wmt_params.status = NULL;
|
| 883 |
|
| 884 | err = mtk_hci_wmt_sync(hdev, &wmt_params);
|
| 885 | if (err < 0) {
|
| 886 | bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
|
| 887 | return err;
|
| 888 | }
|
| 889 |
|
| 890 | set_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
|
| 891 |
|
| 892 | ignore_func_on:
|
| 893 |
|
| 894 | tci_sleep.mode = 0x5;
|
| 895 | tci_sleep.duration = cpu_to_le16(0x640);
|
| 896 | tci_sleep.host_duration = cpu_to_le16(0x640);
|
| 897 | tci_sleep.host_wakeup_pin = 0;
|
| 898 | tci_sleep.time_compensation = 0;
|
| 899 |
|
| 900 | skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
|
| 901 | HCI_INIT_TIMEOUT);
|
| 902 | if (IS_ERR(skb)) {
|
| 903 | err = PTR_ERR(skb);
|
| 904 | bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
|
| 905 | return err;
|
| 906 | }
|
| 907 | kfree_skb(skb);
|
| 908 |
|
| 909 | return 0;
|
| 910 | }
|
| 911 |
|
| 912 | static int mt79xx_setup(struct hci_dev *hdev, const char *fwname)
|
| 913 | {
|
| 914 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 915 | struct btmtk_hci_wmt_params wmt_params;
|
| 916 | u8 param = 0x1;
|
| 917 | int err;
|
| 918 |
|
| 919 | err = btmtk_setup_firmware_79xx(hdev, fwname, mtk_hci_wmt_sync, 0);
|
| 920 | if (err < 0) {
|
| 921 | bt_dev_err(hdev, "Failed to setup 79xx firmware (%d)", err);
|
| 922 | return err;
|
| 923 | }
|
| 924 |
|
| 925 | err = btmtksdio_fw_pmctrl(bdev);
|
| 926 | if (err < 0)
|
| 927 | return err;
|
| 928 |
|
| 929 | err = btmtksdio_drv_pmctrl(bdev);
|
| 930 | if (err < 0)
|
| 931 | return err;
|
| 932 |
|
| 933 |
|
| 934 | wmt_params.op = BTMTK_WMT_FUNC_CTRL;
|
| 935 | wmt_params.flag = 0;
|
| 936 | wmt_params.dlen = sizeof(param);
|
| 937 | wmt_params.data = ¶m;
|
| 938 | wmt_params.status = NULL;
|
| 939 |
|
| 940 | err = mtk_hci_wmt_sync(hdev, &wmt_params);
|
| 941 | if (err < 0) {
|
| 942 | bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
|
| 943 | return err;
|
| 944 | }
|
| 945 |
|
| 946 | hci_set_msft_opcode(hdev, 0xFD30);
|
| 947 | hci_set_aosp_capable(hdev);
|
| 948 | set_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
|
| 949 |
|
| 950 | return err;
|
| 951 | }
|
| 952 |
|
| 953 | static int btmtksdio_mtk_reg_read(struct hci_dev *hdev, u32 reg, u32 *val)
|
| 954 | {
|
| 955 | struct btmtk_hci_wmt_params wmt_params;
|
| 956 | struct reg_read_cmd reg_read = {
|
| 957 | .type = 1,
|
| 958 | .num = 1,
|
| 959 | };
|
| 960 | u32 status;
|
| 961 | int err;
|
| 962 |
|
| 963 | reg_read.addr = cpu_to_le32(reg);
|
| 964 | wmt_params.op = BTMTK_WMT_REGISTER;
|
| 965 | wmt_params.flag = BTMTK_WMT_REG_READ;
|
| 966 | wmt_params.dlen = sizeof(reg_read);
|
| 967 | wmt_params.data = ®_read;
|
| 968 | wmt_params.status = &status;
|
| 969 |
|
| 970 | err = mtk_hci_wmt_sync(hdev, &wmt_params);
|
| 971 | if (err < 0) {
|
| 972 | bt_dev_err(hdev, "Failed to read reg (%d)", err);
|
| 973 | return err;
|
| 974 | }
|
| 975 |
|
| 976 | *val = status;
|
| 977 |
|
| 978 | return err;
|
| 979 | }
|
| 980 |
|
| 981 | static int btmtksdio_mtk_reg_write(struct hci_dev *hdev, u32 reg, u32 val, u32 mask)
|
| 982 | {
|
| 983 | struct btmtk_hci_wmt_params wmt_params;
|
| 984 | const struct reg_write_cmd reg_write = {
|
| 985 | .type = 1,
|
| 986 | .num = 1,
|
| 987 | .addr = cpu_to_le32(reg),
|
| 988 | .data = cpu_to_le32(val),
|
| 989 | .mask = cpu_to_le32(mask),
|
| 990 | };
|
| 991 | int err, status;
|
| 992 |
|
| 993 | wmt_params.op = BTMTK_WMT_REGISTER;
|
| 994 | wmt_params.flag = BTMTK_WMT_REG_WRITE;
|
| 995 | wmt_params.dlen = sizeof(reg_write);
|
| 996 | wmt_params.data = ®_write;
|
| 997 | wmt_params.status = &status;
|
| 998 |
|
| 999 | err = mtk_hci_wmt_sync(hdev, &wmt_params);
|
| 1000 | if (err < 0)
|
| 1001 | bt_dev_err(hdev, "Failed to write reg (%d)", err);
|
| 1002 |
|
| 1003 | return err;
|
| 1004 | }
|
| 1005 |
|
| 1006 | static int btmtksdio_get_data_path_id(struct hci_dev *hdev, __u8 *data_path_id)
|
| 1007 | {
|
| 1008 |
|
| 1009 | *data_path_id = 1;
|
| 1010 | return 0;
|
| 1011 | }
|
| 1012 |
|
| 1013 | static int btmtksdio_get_codec_config_data(struct hci_dev *hdev,
|
| 1014 | __u8 link, struct bt_codec *codec,
|
| 1015 | __u8 *ven_len, __u8 **ven_data)
|
| 1016 | {
|
| 1017 | int err = 0;
|
| 1018 |
|
| 1019 | if (!ven_data || !ven_len)
|
| 1020 | return -EINVAL;
|
| 1021 |
|
| 1022 | *ven_len = 0;
|
| 1023 | *ven_data = NULL;
|
| 1024 |
|
| 1025 | if (link != ESCO_LINK) {
|
| 1026 | bt_dev_err(hdev, "Invalid link type(%u)", link);
|
| 1027 | return -EINVAL;
|
| 1028 | }
|
| 1029 |
|
| 1030 | *ven_data = kmalloc(sizeof(__u8), GFP_KERNEL);
|
| 1031 | if (!*ven_data) {
|
| 1032 | err = -ENOMEM;
|
| 1033 | goto error;
|
| 1034 | }
|
| 1035 |
|
| 1036 |
|
| 1037 | switch (codec->id) {
|
| 1038 | case 0x02:
|
| 1039 | **ven_data = 0x00;
|
| 1040 | break;
|
| 1041 | case 0x05:
|
| 1042 | **ven_data = 0x01;
|
| 1043 | break;
|
| 1044 | default:
|
| 1045 | err = -EINVAL;
|
| 1046 | bt_dev_err(hdev, "Invalid codec id(%u)", codec->id);
|
| 1047 | goto error;
|
| 1048 | }
|
| 1049 | |
| 1050 | * preset id = 0x00 represents CVSD codec with sampling rate 8K
|
| 1051 | * preset id = 0x01 represents mSBC codec with sampling rate 16K
|
| 1052 |
|
| 1053 | *ven_len = sizeof(__u8);
|
| 1054 | return err;
|
| 1055 |
|
| 1056 | error:
|
| 1057 | kfree(*ven_data);
|
| 1058 | *ven_data = NULL;
|
| 1059 | return err;
|
| 1060 | }
|
| 1061 |
|
| 1062 | static int btmtksdio_sco_setting(struct hci_dev *hdev)
|
| 1063 | {
|
| 1064 | const struct btmtk_sco sco_setting = {
|
| 1065 | .clock_config = 0x49,
|
| 1066 | .channel_format_config = 0x80,
|
| 1067 | };
|
| 1068 | struct sk_buff *skb;
|
| 1069 | u32 val;
|
| 1070 | int err;
|
| 1071 |
|
| 1072 |
|
| 1073 | skb = __hci_cmd_sync(hdev, 0xfc72, sizeof(sco_setting),
|
| 1074 | &sco_setting, HCI_CMD_TIMEOUT);
|
| 1075 | if (IS_ERR(skb))
|
| 1076 | return PTR_ERR(skb);
|
| 1077 |
|
| 1078 | kfree_skb(skb);
|
| 1079 |
|
| 1080 | err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_0, &val);
|
| 1081 | if (err < 0)
|
| 1082 | return err;
|
| 1083 |
|
| 1084 | val |= 0x11000000;
|
| 1085 | err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_0, val, ~0);
|
| 1086 | if (err < 0)
|
| 1087 | return err;
|
| 1088 |
|
| 1089 | err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, &val);
|
| 1090 | if (err < 0)
|
| 1091 | return err;
|
| 1092 |
|
| 1093 | val |= 0x00000101;
|
| 1094 | err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, ~0);
|
| 1095 | if (err < 0)
|
| 1096 | return err;
|
| 1097 |
|
| 1098 | hdev->get_data_path_id = btmtksdio_get_data_path_id;
|
| 1099 | hdev->get_codec_config_data = btmtksdio_get_codec_config_data;
|
| 1100 |
|
| 1101 | return err;
|
| 1102 | }
|
| 1103 |
|
| 1104 | static int btmtksdio_reset_setting(struct hci_dev *hdev)
|
| 1105 | {
|
| 1106 | int err;
|
| 1107 | u32 val;
|
| 1108 |
|
| 1109 | err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, &val);
|
| 1110 | if (err < 0)
|
| 1111 | return err;
|
| 1112 |
|
| 1113 | val |= 0x20;
|
| 1114 | err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, ~0);
|
| 1115 | if (err < 0)
|
| 1116 | return err;
|
| 1117 |
|
| 1118 | err = btmtksdio_mtk_reg_read(hdev, MT7921_BTSYS_RST, &val);
|
| 1119 | if (err < 0)
|
| 1120 | return err;
|
| 1121 |
|
| 1122 | val |= MT7921_BTSYS_RST_WITH_GPIO;
|
| 1123 | return btmtksdio_mtk_reg_write(hdev, MT7921_BTSYS_RST, val, ~0);
|
| 1124 | }
|
| 1125 |
|
| 1126 | static int btmtksdio_setup(struct hci_dev *hdev)
|
| 1127 | {
|
| 1128 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 1129 | ktime_t calltime, delta, rettime;
|
| 1130 | unsigned long long duration;
|
| 1131 | char fwname[64];
|
| 1132 | int err, dev_id;
|
| 1133 | u32 fw_version = 0, val;
|
| 1134 |
|
| 1135 | calltime = ktime_get();
|
| 1136 | set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
|
| 1137 |
|
| 1138 | switch (bdev->data->chipid) {
|
| 1139 | case 0x7902:
|
| 1140 | case 0x7921:
|
| 1141 | if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state)) {
|
| 1142 | err = btmtksdio_mtk_reg_read(hdev, MT7921_DLSTATUS,
|
| 1143 | &val);
|
| 1144 | if (err < 0)
|
| 1145 | return err;
|
| 1146 |
|
| 1147 | val &= ~BT_DL_STATE;
|
| 1148 | err = btmtksdio_mtk_reg_write(hdev, MT7921_DLSTATUS,
|
| 1149 | val, ~0);
|
| 1150 | if (err < 0)
|
| 1151 | return err;
|
| 1152 |
|
| 1153 | btmtksdio_fw_pmctrl(bdev);
|
| 1154 | msleep(20);
|
| 1155 | btmtksdio_drv_pmctrl(bdev);
|
| 1156 |
|
| 1157 | clear_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state);
|
| 1158 | }
|
| 1159 |
|
| 1160 | err = btmtksdio_mtk_reg_read(hdev, 0x70010200, &dev_id);
|
| 1161 | if (err < 0) {
|
| 1162 | bt_dev_err(hdev, "Failed to get device id (%d)", err);
|
| 1163 | return err;
|
| 1164 | }
|
| 1165 |
|
| 1166 | err = btmtksdio_mtk_reg_read(hdev, 0x80021004, &fw_version);
|
| 1167 | if (err < 0) {
|
| 1168 | bt_dev_err(hdev, "Failed to get fw version (%d)", err);
|
| 1169 | return err;
|
| 1170 | }
|
| 1171 |
|
| 1172 | btmtk_fw_get_filename(fwname, sizeof(fwname), dev_id,
|
| 1173 | fw_version, 0);
|
| 1174 |
|
| 1175 | snprintf(fwname, sizeof(fwname),
|
| 1176 | "mediatek/BT_RAM_CODE_MT%04x_1_%x_hdr.bin",
|
| 1177 | dev_id & 0xffff, (fw_version & 0xff) + 1);
|
| 1178 | err = mt79xx_setup(hdev, fwname);
|
| 1179 | if (err < 0)
|
| 1180 | return err;
|
| 1181 |
|
| 1182 |
|
| 1183 | err = btmtksdio_sco_setting(hdev);
|
| 1184 | if (err < 0) {
|
| 1185 | bt_dev_err(hdev, "Failed to enable SCO setting (%d)", err);
|
| 1186 | return err;
|
| 1187 | }
|
| 1188 |
|
| 1189 |
|
| 1190 | hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
|
| 1191 |
|
| 1192 |
|
| 1193 | if (bdev->reset) {
|
| 1194 | err = btmtksdio_reset_setting(hdev);
|
| 1195 | if (err < 0) {
|
| 1196 | bt_dev_err(hdev, "Failed to enable Reset setting (%d)", err);
|
| 1197 | devm_gpiod_put(bdev->dev, bdev->reset);
|
| 1198 | bdev->reset = NULL;
|
| 1199 | }
|
| 1200 | }
|
| 1201 |
|
| 1202 | break;
|
| 1203 | case 0x7663:
|
| 1204 | case 0x7668:
|
| 1205 | err = mt76xx_setup(hdev, bdev->data->fwname);
|
| 1206 | if (err < 0)
|
| 1207 | return err;
|
| 1208 | break;
|
| 1209 | default:
|
| 1210 | return -ENODEV;
|
| 1211 | }
|
| 1212 |
|
| 1213 | rettime = ktime_get();
|
| 1214 | delta = ktime_sub(rettime, calltime);
|
| 1215 | duration = (unsigned long long)ktime_to_ns(delta) >> 10;
|
| 1216 |
|
| 1217 | if (bdev->data->pm_runtime_supported) {
|
| 1218 | pm_runtime_set_autosuspend_delay(bdev->dev,
|
| 1219 | MTKBTSDIO_AUTOSUSPEND_DELAY);
|
| 1220 | pm_runtime_use_autosuspend(bdev->dev);
|
| 1221 |
|
| 1222 | err = pm_runtime_set_active(bdev->dev);
|
| 1223 | if (err < 0)
|
| 1224 | return err;
|
| 1225 |
|
| 1226 | |
| 1227 | * enable_autosuspend flag or the PM runtime entry under sysfs.
|
| 1228 |
|
| 1229 | pm_runtime_forbid(bdev->dev);
|
| 1230 | pm_runtime_enable(bdev->dev);
|
| 1231 |
|
| 1232 | if (enable_autosuspend)
|
| 1233 | pm_runtime_allow(bdev->dev);
|
| 1234 | }
|
| 1235 |
|
| 1236 | bt_dev_info(hdev, "Device setup in %llu usecs", duration);
|
| 1237 |
|
| 1238 | return 0;
|
| 1239 | }
|
| 1240 |
|
| 1241 | static int btmtksdio_shutdown(struct hci_dev *hdev)
|
| 1242 | {
|
| 1243 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 1244 | struct btmtk_hci_wmt_params wmt_params;
|
| 1245 | u8 param = 0x0;
|
| 1246 | int err;
|
| 1247 |
|
| 1248 | |
| 1249 | * in btmtksdio_setup.
|
| 1250 |
|
| 1251 | pm_runtime_get_sync(bdev->dev);
|
| 1252 |
|
| 1253 |
|
| 1254 | if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state))
|
| 1255 | goto ignore_wmt_cmd;
|
| 1256 |
|
| 1257 |
|
| 1258 | wmt_params.op = BTMTK_WMT_FUNC_CTRL;
|
| 1259 | wmt_params.flag = 0;
|
| 1260 | wmt_params.dlen = sizeof(param);
|
| 1261 | wmt_params.data = ¶m;
|
| 1262 | wmt_params.status = NULL;
|
| 1263 |
|
| 1264 | err = mtk_hci_wmt_sync(hdev, &wmt_params);
|
| 1265 | if (err < 0)
|
| 1266 | bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
|
| 1267 |
|
| 1268 | ignore_wmt_cmd:
|
| 1269 | pm_runtime_put_noidle(bdev->dev);
|
| 1270 | pm_runtime_disable(bdev->dev);
|
| 1271 |
|
| 1272 | return 0;
|
| 1273 | }
|
| 1274 |
|
| 1275 | static int btmtksdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
|
| 1276 | {
|
| 1277 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 1278 |
|
| 1279 | switch (hci_skb_pkt_type(skb)) {
|
| 1280 | case HCI_COMMAND_PKT:
|
| 1281 | hdev->stat.cmd_tx++;
|
| 1282 | break;
|
| 1283 |
|
| 1284 | case HCI_ACLDATA_PKT:
|
| 1285 | hdev->stat.acl_tx++;
|
| 1286 | break;
|
| 1287 |
|
| 1288 | case HCI_SCODATA_PKT:
|
| 1289 | hdev->stat.sco_tx++;
|
| 1290 | break;
|
| 1291 |
|
| 1292 | default:
|
| 1293 | return -EILSEQ;
|
| 1294 | }
|
| 1295 |
|
| 1296 | skb_queue_tail(&bdev->txq, skb);
|
| 1297 |
|
| 1298 | schedule_work(&bdev->txrx_work);
|
| 1299 |
|
| 1300 | return 0;
|
| 1301 | }
|
| 1302 |
|
| 1303 | static void btmtksdio_reset(struct hci_dev *hdev)
|
| 1304 | {
|
| 1305 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 1306 | u32 status;
|
| 1307 | int err;
|
| 1308 |
|
| 1309 | if (!bdev->reset || bdev->data->chipid != 0x7921)
|
| 1310 | return;
|
| 1311 |
|
| 1312 | pm_runtime_get_sync(bdev->dev);
|
| 1313 |
|
| 1314 | if (test_and_set_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state))
|
| 1315 | return;
|
| 1316 |
|
| 1317 | sdio_claim_host(bdev->func);
|
| 1318 |
|
| 1319 |
|
| 1320 | if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) {
|
| 1321 | sdio_enable_func(bdev->func);
|
| 1322 | btmtksdio_drv_pmctrl(bdev);
|
| 1323 | }
|
| 1324 |
|
| 1325 | sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
|
| 1326 | skb_queue_purge(&bdev->txq);
|
| 1327 | cancel_work_sync(&bdev->txrx_work);
|
| 1328 |
|
| 1329 | gpiod_set_value_cansleep(bdev->reset, 1);
|
| 1330 | msleep(100);
|
| 1331 | gpiod_set_value_cansleep(bdev->reset, 0);
|
| 1332 |
|
| 1333 | err = readx_poll_timeout(btmtksdio_chcr_query, bdev, status,
|
| 1334 | status & BT_RST_DONE, 100000, 2000000);
|
| 1335 | if (err < 0) {
|
| 1336 | bt_dev_err(hdev, "Failed to reset (%d)", err);
|
| 1337 | goto err;
|
| 1338 | }
|
| 1339 |
|
| 1340 |
|
| 1341 | if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) {
|
| 1342 | btmtksdio_fw_pmctrl(bdev);
|
| 1343 | sdio_disable_func(bdev->func);
|
| 1344 | }
|
| 1345 |
|
| 1346 | clear_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
|
| 1347 | err:
|
| 1348 | sdio_release_host(bdev->func);
|
| 1349 |
|
| 1350 | pm_runtime_put_noidle(bdev->dev);
|
| 1351 | pm_runtime_disable(bdev->dev);
|
| 1352 |
|
| 1353 | hci_reset_dev(hdev);
|
| 1354 | }
|
| 1355 |
|
| 1356 | static bool btmtksdio_sdio_inband_wakeup(struct hci_dev *hdev)
|
| 1357 | {
|
| 1358 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 1359 |
|
| 1360 | return device_may_wakeup(bdev->dev);
|
| 1361 | }
|
| 1362 |
|
| 1363 | static bool btmtksdio_sdio_wakeup(struct hci_dev *hdev)
|
| 1364 | {
|
| 1365 | struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
|
| 1366 | bool may_wakeup = device_may_wakeup(bdev->dev);
|
| 1367 | const struct btmtk_wakeon bt_awake = {
|
| 1368 | .mode = 0x1,
|
| 1369 | .gpo = 0,
|
| 1370 | .active_high = 0x1,
|
| 1371 | .enable_delay = cpu_to_le16(0xc80),
|
| 1372 | .wakeup_delay = cpu_to_le16(0x20),
|
| 1373 | };
|
| 1374 |
|
| 1375 | if (may_wakeup && bdev->data->chipid == 0x7921) {
|
| 1376 | struct sk_buff *skb;
|
| 1377 |
|
| 1378 | skb = __hci_cmd_sync(hdev, 0xfc27, sizeof(bt_awake),
|
| 1379 | &bt_awake, HCI_CMD_TIMEOUT);
|
| 1380 | if (IS_ERR(skb))
|
| 1381 | may_wakeup = false;
|
| 1382 | else
|
| 1383 | kfree_skb(skb);
|
| 1384 | }
|
| 1385 |
|
| 1386 | return may_wakeup;
|
| 1387 | }
|
| 1388 |
|
| 1389 | static int btmtksdio_probe(struct sdio_func *func,
|
| 1390 | const struct sdio_device_id *id)
|
| 1391 | {
|
| 1392 | struct btmtksdio_dev *bdev;
|
| 1393 | struct hci_dev *hdev;
|
| 1394 | struct device_node *old_node;
|
| 1395 | bool restore_node;
|
| 1396 | int err;
|
| 1397 |
|
| 1398 | bdev = devm_kzalloc(&func->dev, sizeof(*bdev), GFP_KERNEL);
|
| 1399 | if (!bdev)
|
| 1400 | return -ENOMEM;
|
| 1401 |
|
| 1402 | bdev->data = (void *)id->driver_data;
|
| 1403 | if (!bdev->data)
|
| 1404 | return -ENODEV;
|
| 1405 |
|
| 1406 | bdev->dev = &func->dev;
|
| 1407 | bdev->func = func;
|
| 1408 |
|
| 1409 | INIT_WORK(&bdev->txrx_work, btmtksdio_txrx_work);
|
| 1410 | skb_queue_head_init(&bdev->txq);
|
| 1411 |
|
| 1412 |
|
| 1413 | hdev = hci_alloc_dev();
|
| 1414 | if (!hdev) {
|
| 1415 | dev_err(&func->dev, "Can't allocate HCI device\n");
|
| 1416 | return -ENOMEM;
|
| 1417 | }
|
| 1418 |
|
| 1419 | bdev->hdev = hdev;
|
| 1420 |
|
| 1421 | hdev->bus = HCI_SDIO;
|
| 1422 | hci_set_drvdata(hdev, bdev);
|
| 1423 |
|
| 1424 | hdev->open = btmtksdio_open;
|
| 1425 | hdev->close = btmtksdio_close;
|
| 1426 | hdev->reset = btmtksdio_reset;
|
| 1427 | hdev->flush = btmtksdio_flush;
|
| 1428 | hdev->setup = btmtksdio_setup;
|
| 1429 | hdev->shutdown = btmtksdio_shutdown;
|
| 1430 | hdev->send = btmtksdio_send_frame;
|
| 1431 | hdev->wakeup = btmtksdio_sdio_wakeup;
|
| 1432 | |
| 1433 | * If SDIO controller supports wake on Bluetooth, sending a wakeon
|
| 1434 | * command is not necessary.
|
| 1435 |
|
| 1436 | if (device_can_wakeup(func->card->host->parent))
|
| 1437 | hdev->wakeup = btmtksdio_sdio_inband_wakeup;
|
| 1438 | else
|
| 1439 | hdev->wakeup = btmtksdio_sdio_wakeup;
|
| 1440 | hdev->set_bdaddr = btmtk_set_bdaddr;
|
| 1441 |
|
| 1442 | SET_HCIDEV_DEV(hdev, &func->dev);
|
| 1443 |
|
| 1444 | hdev->manufacturer = 70;
|
| 1445 | hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP);
|
| 1446 |
|
| 1447 | sdio_set_drvdata(func, bdev);
|
| 1448 |
|
| 1449 | err = hci_register_dev(hdev);
|
| 1450 | if (err < 0) {
|
| 1451 | dev_err(&func->dev, "Can't register HCI device\n");
|
| 1452 | hci_free_dev(hdev);
|
| 1453 | return err;
|
| 1454 | }
|
| 1455 |
|
| 1456 | |
| 1457 | * downloaded because the core layer probably already enables
|
| 1458 | * runtime PM for this func such as the case host->caps &
|
| 1459 | * MMC_CAP_POWER_OFF_CARD.
|
| 1460 |
|
| 1461 | if (pm_runtime_enabled(bdev->dev))
|
| 1462 | pm_runtime_disable(bdev->dev);
|
| 1463 |
|
| 1464 | |
| 1465 | * Unbound SDIO functions are always suspended.
|
| 1466 | * During probe, the function is set active and the usage count
|
| 1467 | * is incremented. If the driver supports runtime PM,
|
| 1468 | * it should call pm_runtime_put_noidle() in its probe routine and
|
| 1469 | * pm_runtime_get_noresume() in its remove routine.
|
| 1470 | *
|
| 1471 | * So, put a pm_runtime_put_noidle here !
|
| 1472 |
|
| 1473 | pm_runtime_put_noidle(bdev->dev);
|
| 1474 |
|
| 1475 | err = devm_device_init_wakeup(bdev->dev);
|
| 1476 | if (err)
|
| 1477 | bt_dev_err(hdev, "failed to initialize device wakeup");
|
| 1478 |
|
| 1479 | restore_node = false;
|
| 1480 | if (!of_device_is_compatible(bdev->dev->of_node, "mediatek,mt7921s-bluetooth")) {
|
| 1481 | restore_node = true;
|
| 1482 | old_node = bdev->dev->of_node;
|
| 1483 | bdev->dev->of_node = of_find_compatible_node(NULL, NULL,
|
| 1484 | "mediatek,mt7921s-bluetooth");
|
| 1485 | }
|
| 1486 |
|
| 1487 | bdev->reset = devm_gpiod_get_optional(bdev->dev, "reset",
|
| 1488 | GPIOD_OUT_LOW);
|
| 1489 | if (IS_ERR(bdev->reset))
|
| 1490 | err = PTR_ERR(bdev->reset);
|
| 1491 |
|
| 1492 | if (restore_node) {
|
| 1493 | of_node_put(bdev->dev->of_node);
|
| 1494 | bdev->dev->of_node = old_node;
|
| 1495 | }
|
| 1496 |
|
| 1497 | return err;
|
| 1498 | }
|
| 1499 |
|
| 1500 | static void btmtksdio_remove(struct sdio_func *func)
|
| 1501 | {
|
| 1502 | struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
|
| 1503 | struct hci_dev *hdev;
|
| 1504 |
|
| 1505 | if (!bdev)
|
| 1506 | return;
|
| 1507 |
|
| 1508 | hdev = bdev->hdev;
|
| 1509 |
|
| 1510 |
|
| 1511 | if (test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
|
| 1512 | btmtksdio_close(hdev);
|
| 1513 |
|
| 1514 | if (bdev->data->pm_runtime_supported)
|
| 1515 | pm_runtime_dont_use_autosuspend(bdev->dev);
|
| 1516 |
|
| 1517 |
|
| 1518 | pm_runtime_get_noresume(bdev->dev);
|
| 1519 |
|
| 1520 | sdio_set_drvdata(func, NULL);
|
| 1521 | hci_unregister_dev(hdev);
|
| 1522 | hci_free_dev(hdev);
|
| 1523 | }
|
| 1524 |
|
| 1525 | static int btmtksdio_runtime_suspend(struct device *dev)
|
| 1526 | {
|
| 1527 | struct sdio_func *func = dev_to_sdio_func(dev);
|
| 1528 | struct btmtksdio_dev *bdev;
|
| 1529 | int err;
|
| 1530 |
|
| 1531 | bdev = sdio_get_drvdata(func);
|
| 1532 | if (!bdev)
|
| 1533 | return 0;
|
| 1534 |
|
| 1535 | if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
|
| 1536 | return 0;
|
| 1537 |
|
| 1538 | sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
|
| 1539 |
|
| 1540 | err = btmtksdio_fw_pmctrl(bdev);
|
| 1541 |
|
| 1542 | bt_dev_dbg(bdev->hdev, "status (%d) return ownership to device", err);
|
| 1543 |
|
| 1544 | return err;
|
| 1545 | }
|
| 1546 |
|
| 1547 | static int btmtksdio_system_suspend(struct device *dev)
|
| 1548 | {
|
| 1549 | struct sdio_func *func = dev_to_sdio_func(dev);
|
| 1550 | struct btmtksdio_dev *bdev;
|
| 1551 |
|
| 1552 | bdev = sdio_get_drvdata(func);
|
| 1553 | if (!bdev)
|
| 1554 | return 0;
|
| 1555 |
|
| 1556 | if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
|
| 1557 | return 0;
|
| 1558 |
|
| 1559 | set_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state);
|
| 1560 |
|
| 1561 | return btmtksdio_runtime_suspend(dev);
|
| 1562 | }
|
| 1563 |
|
| 1564 | static int btmtksdio_runtime_resume(struct device *dev)
|
| 1565 | {
|
| 1566 | struct sdio_func *func = dev_to_sdio_func(dev);
|
| 1567 | struct btmtksdio_dev *bdev;
|
| 1568 | int err;
|
| 1569 |
|
| 1570 | bdev = sdio_get_drvdata(func);
|
| 1571 | if (!bdev)
|
| 1572 | return 0;
|
| 1573 |
|
| 1574 | if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
|
| 1575 | return 0;
|
| 1576 |
|
| 1577 | err = btmtksdio_drv_pmctrl(bdev);
|
| 1578 |
|
| 1579 | bt_dev_dbg(bdev->hdev, "status (%d) get ownership from device", err);
|
| 1580 |
|
| 1581 | return err;
|
| 1582 | }
|
| 1583 |
|
| 1584 | static int btmtksdio_system_resume(struct device *dev)
|
| 1585 | {
|
| 1586 | return btmtksdio_runtime_resume(dev);
|
| 1587 | }
|
| 1588 |
|
| 1589 | static const struct dev_pm_ops btmtksdio_pm_ops = {
|
| 1590 | SYSTEM_SLEEP_PM_OPS(btmtksdio_system_suspend, btmtksdio_system_resume)
|
| 1591 | RUNTIME_PM_OPS(btmtksdio_runtime_suspend, btmtksdio_runtime_resume, NULL)
|
| 1592 | };
|
| 1593 |
|
| 1594 | static struct sdio_driver btmtksdio_driver = {
|
| 1595 | .name = "btmtksdio",
|
| 1596 | .probe = btmtksdio_probe,
|
| 1597 | .remove = btmtksdio_remove,
|
| 1598 | .id_table = btmtksdio_table,
|
| 1599 | .drv = {
|
| 1600 | .pm = pm_ptr(&btmtksdio_pm_ops),
|
| 1601 | }
|
| 1602 | };
|
| 1603 |
|
| 1604 | module_sdio_driver(btmtksdio_driver);
|
| 1605 |
|
| 1606 | module_param(enable_autosuspend, bool, 0644);
|
| 1607 | MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default");
|
| 1608 |
|
| 1609 | MODULE_AUTHOR("Sean Wang <[email protected]>");
|
| 1610 | MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION);
|
| 1611 | MODULE_VERSION(VERSION);
|
| 1612 | MODULE_LICENSE("GPL");
|