Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 // Copyright (c) 2018 MediaTek Inc.
0003 
0004 /*
0005  * Bluetooth support for MediaTek serial devices
0006  *
0007  * Author: Sean Wang <sean.wang@mediatek.com>
0008  *
0009  */
0010 
0011 #include <asm/unaligned.h>
0012 #include <linux/atomic.h>
0013 #include <linux/clk.h>
0014 #include <linux/firmware.h>
0015 #include <linux/gpio/consumer.h>
0016 #include <linux/iopoll.h>
0017 #include <linux/kernel.h>
0018 #include <linux/module.h>
0019 #include <linux/of.h>
0020 #include <linux/of_device.h>
0021 #include <linux/pinctrl/consumer.h>
0022 #include <linux/pm_runtime.h>
0023 #include <linux/regulator/consumer.h>
0024 #include <linux/serdev.h>
0025 #include <linux/skbuff.h>
0026 
0027 #include <net/bluetooth/bluetooth.h>
0028 #include <net/bluetooth/hci_core.h>
0029 
0030 #include "h4_recv.h"
0031 #include "btmtk.h"
0032 
0033 #define VERSION "0.2"
0034 
0035 #define MTK_STP_TLR_SIZE    2
0036 
0037 #define BTMTKUART_TX_STATE_ACTIVE   1
0038 #define BTMTKUART_TX_STATE_WAKEUP   2
0039 #define BTMTKUART_TX_WAIT_VND_EVT   3
0040 #define BTMTKUART_REQUIRED_WAKEUP   4
0041 
0042 #define BTMTKUART_FLAG_STANDALONE_HW     BIT(0)
0043 
0044 struct mtk_stp_hdr {
0045     u8  prefix;
0046     __be16  dlen;
0047     u8  cs;
0048 } __packed;
0049 
0050 struct btmtkuart_data {
0051     unsigned int flags;
0052     const char *fwname;
0053 };
0054 
0055 struct btmtkuart_dev {
0056     struct hci_dev *hdev;
0057     struct serdev_device *serdev;
0058 
0059     struct clk *clk;
0060     struct clk *osc;
0061     struct regulator *vcc;
0062     struct gpio_desc *reset;
0063     struct gpio_desc *boot;
0064     struct pinctrl *pinctrl;
0065     struct pinctrl_state *pins_runtime;
0066     struct pinctrl_state *pins_boot;
0067     speed_t desired_speed;
0068     speed_t curr_speed;
0069 
0070     struct work_struct tx_work;
0071     unsigned long tx_state;
0072     struct sk_buff_head txq;
0073 
0074     struct sk_buff *rx_skb;
0075     struct sk_buff *evt_skb;
0076 
0077     u8  stp_pad[6];
0078     u8  stp_cursor;
0079     u16 stp_dlen;
0080 
0081     const struct btmtkuart_data *data;
0082 };
0083 
0084 #define btmtkuart_is_standalone(bdev)   \
0085     ((bdev)->data->flags & BTMTKUART_FLAG_STANDALONE_HW)
0086 #define btmtkuart_is_builtin_soc(bdev)  \
0087     !((bdev)->data->flags & BTMTKUART_FLAG_STANDALONE_HW)
0088 
0089 static int mtk_hci_wmt_sync(struct hci_dev *hdev,
0090                 struct btmtk_hci_wmt_params *wmt_params)
0091 {
0092     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0093     struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
0094     u32 hlen, status = BTMTK_WMT_INVALID;
0095     struct btmtk_hci_wmt_evt *wmt_evt;
0096     struct btmtk_hci_wmt_cmd *wc;
0097     struct btmtk_wmt_hdr *hdr;
0098     int err;
0099 
0100     /* Send the WMT command and wait until the WMT event returns */
0101     hlen = sizeof(*hdr) + wmt_params->dlen;
0102     if (hlen > 255) {
0103         err = -EINVAL;
0104         goto err_free_skb;
0105     }
0106 
0107     wc = kzalloc(hlen, GFP_KERNEL);
0108     if (!wc) {
0109         err = -ENOMEM;
0110         goto err_free_skb;
0111     }
0112 
0113     hdr = &wc->hdr;
0114     hdr->dir = 1;
0115     hdr->op = wmt_params->op;
0116     hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
0117     hdr->flag = wmt_params->flag;
0118     memcpy(wc->data, wmt_params->data, wmt_params->dlen);
0119 
0120     set_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
0121 
0122     err = __hci_cmd_send(hdev, 0xfc6f, hlen, wc);
0123     if (err < 0) {
0124         clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
0125         goto err_free_wc;
0126     }
0127 
0128     /* The vendor specific WMT commands are all answered by a vendor
0129      * specific event and will not have the Command Status or Command
0130      * Complete as with usual HCI command flow control.
0131      *
0132      * After sending the command, wait for BTMTKUART_TX_WAIT_VND_EVT
0133      * state to be cleared. The driver specific event receive routine
0134      * will clear that state and with that indicate completion of the
0135      * WMT command.
0136      */
0137     err = wait_on_bit_timeout(&bdev->tx_state, BTMTKUART_TX_WAIT_VND_EVT,
0138                   TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
0139     if (err == -EINTR) {
0140         bt_dev_err(hdev, "Execution of wmt command interrupted");
0141         clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
0142         goto err_free_wc;
0143     }
0144 
0145     if (err) {
0146         bt_dev_err(hdev, "Execution of wmt command timed out");
0147         clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
0148         err = -ETIMEDOUT;
0149         goto err_free_wc;
0150     }
0151 
0152     /* Parse and handle the return WMT event */
0153     wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
0154     if (wmt_evt->whdr.op != hdr->op) {
0155         bt_dev_err(hdev, "Wrong op received %d expected %d",
0156                wmt_evt->whdr.op, hdr->op);
0157         err = -EIO;
0158         goto err_free_wc;
0159     }
0160 
0161     switch (wmt_evt->whdr.op) {
0162     case BTMTK_WMT_SEMAPHORE:
0163         if (wmt_evt->whdr.flag == 2)
0164             status = BTMTK_WMT_PATCH_UNDONE;
0165         else
0166             status = BTMTK_WMT_PATCH_DONE;
0167         break;
0168     case BTMTK_WMT_FUNC_CTRL:
0169         wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
0170         if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
0171             status = BTMTK_WMT_ON_DONE;
0172         else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
0173             status = BTMTK_WMT_ON_PROGRESS;
0174         else
0175             status = BTMTK_WMT_ON_UNDONE;
0176         break;
0177     }
0178 
0179     if (wmt_params->status)
0180         *wmt_params->status = status;
0181 
0182 err_free_wc:
0183     kfree(wc);
0184 err_free_skb:
0185     kfree_skb(bdev->evt_skb);
0186     bdev->evt_skb = NULL;
0187 
0188     return err;
0189 }
0190 
0191 static int btmtkuart_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
0192 {
0193     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0194     struct hci_event_hdr *hdr = (void *)skb->data;
0195     int err;
0196 
0197     /* When someone waits for the WMT event, the skb is being cloned
0198      * and being processed the events from there then.
0199      */
0200     if (test_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state)) {
0201         bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
0202         if (!bdev->evt_skb) {
0203             err = -ENOMEM;
0204             goto err_out;
0205         }
0206     }
0207 
0208     err = hci_recv_frame(hdev, skb);
0209     if (err < 0)
0210         goto err_free_skb;
0211 
0212     if (hdr->evt == HCI_EV_WMT) {
0213         if (test_and_clear_bit(BTMTKUART_TX_WAIT_VND_EVT,
0214                        &bdev->tx_state)) {
0215             /* Barrier to sync with other CPUs */
0216             smp_mb__after_atomic();
0217             wake_up_bit(&bdev->tx_state, BTMTKUART_TX_WAIT_VND_EVT);
0218         }
0219     }
0220 
0221     return 0;
0222 
0223 err_free_skb:
0224     kfree_skb(bdev->evt_skb);
0225     bdev->evt_skb = NULL;
0226 
0227 err_out:
0228     return err;
0229 }
0230 
0231 static const struct h4_recv_pkt mtk_recv_pkts[] = {
0232     { H4_RECV_ACL,      .recv = hci_recv_frame },
0233     { H4_RECV_SCO,      .recv = hci_recv_frame },
0234     { H4_RECV_EVENT,    .recv = btmtkuart_recv_event },
0235 };
0236 
0237 static void btmtkuart_tx_work(struct work_struct *work)
0238 {
0239     struct btmtkuart_dev *bdev = container_of(work, struct btmtkuart_dev,
0240                            tx_work);
0241     struct serdev_device *serdev = bdev->serdev;
0242     struct hci_dev *hdev = bdev->hdev;
0243 
0244     while (1) {
0245         clear_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state);
0246 
0247         while (1) {
0248             struct sk_buff *skb = skb_dequeue(&bdev->txq);
0249             int len;
0250 
0251             if (!skb)
0252                 break;
0253 
0254             len = serdev_device_write_buf(serdev, skb->data,
0255                               skb->len);
0256             hdev->stat.byte_tx += len;
0257 
0258             skb_pull(skb, len);
0259             if (skb->len > 0) {
0260                 skb_queue_head(&bdev->txq, skb);
0261                 break;
0262             }
0263 
0264             switch (hci_skb_pkt_type(skb)) {
0265             case HCI_COMMAND_PKT:
0266                 hdev->stat.cmd_tx++;
0267                 break;
0268             case HCI_ACLDATA_PKT:
0269                 hdev->stat.acl_tx++;
0270                 break;
0271             case HCI_SCODATA_PKT:
0272                 hdev->stat.sco_tx++;
0273                 break;
0274             }
0275 
0276             kfree_skb(skb);
0277         }
0278 
0279         if (!test_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state))
0280             break;
0281     }
0282 
0283     clear_bit(BTMTKUART_TX_STATE_ACTIVE, &bdev->tx_state);
0284 }
0285 
0286 static void btmtkuart_tx_wakeup(struct btmtkuart_dev *bdev)
0287 {
0288     if (test_and_set_bit(BTMTKUART_TX_STATE_ACTIVE, &bdev->tx_state))
0289         set_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state);
0290 
0291     schedule_work(&bdev->tx_work);
0292 }
0293 
0294 static const unsigned char *
0295 mtk_stp_split(struct btmtkuart_dev *bdev, const unsigned char *data, int count,
0296           int *sz_h4)
0297 {
0298     struct mtk_stp_hdr *shdr;
0299 
0300     /* The cursor is reset when all the data of STP is consumed out */
0301     if (!bdev->stp_dlen && bdev->stp_cursor >= 6)
0302         bdev->stp_cursor = 0;
0303 
0304     /* Filling pad until all STP info is obtained */
0305     while (bdev->stp_cursor < 6 && count > 0) {
0306         bdev->stp_pad[bdev->stp_cursor] = *data;
0307         bdev->stp_cursor++;
0308         data++;
0309         count--;
0310     }
0311 
0312     /* Retrieve STP info and have a sanity check */
0313     if (!bdev->stp_dlen && bdev->stp_cursor >= 6) {
0314         shdr = (struct mtk_stp_hdr *)&bdev->stp_pad[2];
0315         bdev->stp_dlen = be16_to_cpu(shdr->dlen) & 0x0fff;
0316 
0317         /* Resync STP when unexpected data is being read */
0318         if (shdr->prefix != 0x80 || bdev->stp_dlen > 2048) {
0319             bt_dev_err(bdev->hdev, "stp format unexpect (%d, %d)",
0320                    shdr->prefix, bdev->stp_dlen);
0321             bdev->stp_cursor = 2;
0322             bdev->stp_dlen = 0;
0323         }
0324     }
0325 
0326     /* Directly quit when there's no data found for H4 can process */
0327     if (count <= 0)
0328         return NULL;
0329 
0330     /* Tranlate to how much the size of data H4 can handle so far */
0331     *sz_h4 = min_t(int, count, bdev->stp_dlen);
0332 
0333     /* Update the remaining size of STP packet */
0334     bdev->stp_dlen -= *sz_h4;
0335 
0336     /* Data points to STP payload which can be handled by H4 */
0337     return data;
0338 }
0339 
0340 static int btmtkuart_recv(struct hci_dev *hdev, const u8 *data, size_t count)
0341 {
0342     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0343     const unsigned char *p_left = data, *p_h4;
0344     int sz_left = count, sz_h4, adv;
0345     int err;
0346 
0347     while (sz_left > 0) {
0348         /*  The serial data received from MT7622 BT controller is
0349          *  at all time padded around with the STP header and tailer.
0350          *
0351          *  A full STP packet is looking like
0352          *   -----------------------------------
0353          *  | STP header  |  H:4   | STP tailer |
0354          *   -----------------------------------
0355          *  but it doesn't guarantee to contain a full H:4 packet which
0356          *  means that it's possible for multiple STP packets forms a
0357          *  full H:4 packet that means extra STP header + length doesn't
0358          *  indicate a full H:4 frame, things can fragment. Whose length
0359          *  recorded in STP header just shows up the most length the
0360          *  H:4 engine can handle currently.
0361          */
0362 
0363         p_h4 = mtk_stp_split(bdev, p_left, sz_left, &sz_h4);
0364         if (!p_h4)
0365             break;
0366 
0367         adv = p_h4 - p_left;
0368         sz_left -= adv;
0369         p_left += adv;
0370 
0371         bdev->rx_skb = h4_recv_buf(bdev->hdev, bdev->rx_skb, p_h4,
0372                        sz_h4, mtk_recv_pkts,
0373                        ARRAY_SIZE(mtk_recv_pkts));
0374         if (IS_ERR(bdev->rx_skb)) {
0375             err = PTR_ERR(bdev->rx_skb);
0376             bt_dev_err(bdev->hdev,
0377                    "Frame reassembly failed (%d)", err);
0378             bdev->rx_skb = NULL;
0379             return err;
0380         }
0381 
0382         sz_left -= sz_h4;
0383         p_left += sz_h4;
0384     }
0385 
0386     return 0;
0387 }
0388 
0389 static int btmtkuart_receive_buf(struct serdev_device *serdev, const u8 *data,
0390                  size_t count)
0391 {
0392     struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
0393     int err;
0394 
0395     err = btmtkuart_recv(bdev->hdev, data, count);
0396     if (err < 0)
0397         return err;
0398 
0399     bdev->hdev->stat.byte_rx += count;
0400 
0401     return count;
0402 }
0403 
0404 static void btmtkuart_write_wakeup(struct serdev_device *serdev)
0405 {
0406     struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
0407 
0408     btmtkuart_tx_wakeup(bdev);
0409 }
0410 
0411 static const struct serdev_device_ops btmtkuart_client_ops = {
0412     .receive_buf = btmtkuart_receive_buf,
0413     .write_wakeup = btmtkuart_write_wakeup,
0414 };
0415 
0416 static int btmtkuart_open(struct hci_dev *hdev)
0417 {
0418     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0419     struct device *dev;
0420     int err;
0421 
0422     err = serdev_device_open(bdev->serdev);
0423     if (err) {
0424         bt_dev_err(hdev, "Unable to open UART device %s",
0425                dev_name(&bdev->serdev->dev));
0426         goto err_open;
0427     }
0428 
0429     if (btmtkuart_is_standalone(bdev)) {
0430         if (bdev->curr_speed != bdev->desired_speed)
0431             err = serdev_device_set_baudrate(bdev->serdev,
0432                              115200);
0433         else
0434             err = serdev_device_set_baudrate(bdev->serdev,
0435                              bdev->desired_speed);
0436 
0437         if (err < 0) {
0438             bt_dev_err(hdev, "Unable to set baudrate UART device %s",
0439                    dev_name(&bdev->serdev->dev));
0440             goto  err_serdev_close;
0441         }
0442 
0443         serdev_device_set_flow_control(bdev->serdev, false);
0444     }
0445 
0446     bdev->stp_cursor = 2;
0447     bdev->stp_dlen = 0;
0448 
0449     dev = &bdev->serdev->dev;
0450 
0451     /* Enable the power domain and clock the device requires */
0452     pm_runtime_enable(dev);
0453     err = pm_runtime_resume_and_get(dev);
0454     if (err < 0)
0455         goto err_disable_rpm;
0456 
0457     err = clk_prepare_enable(bdev->clk);
0458     if (err < 0)
0459         goto err_put_rpm;
0460 
0461     return 0;
0462 
0463 err_put_rpm:
0464     pm_runtime_put_sync(dev);
0465 err_disable_rpm:
0466     pm_runtime_disable(dev);
0467 err_serdev_close:
0468     serdev_device_close(bdev->serdev);
0469 err_open:
0470     return err;
0471 }
0472 
0473 static int btmtkuart_close(struct hci_dev *hdev)
0474 {
0475     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0476     struct device *dev = &bdev->serdev->dev;
0477 
0478     /* Shutdown the clock and power domain the device requires */
0479     clk_disable_unprepare(bdev->clk);
0480     pm_runtime_put_sync(dev);
0481     pm_runtime_disable(dev);
0482 
0483     serdev_device_close(bdev->serdev);
0484 
0485     return 0;
0486 }
0487 
0488 static int btmtkuart_flush(struct hci_dev *hdev)
0489 {
0490     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0491 
0492     /* Flush any pending characters */
0493     serdev_device_write_flush(bdev->serdev);
0494     skb_queue_purge(&bdev->txq);
0495 
0496     cancel_work_sync(&bdev->tx_work);
0497 
0498     kfree_skb(bdev->rx_skb);
0499     bdev->rx_skb = NULL;
0500 
0501     bdev->stp_cursor = 2;
0502     bdev->stp_dlen = 0;
0503 
0504     return 0;
0505 }
0506 
0507 static int btmtkuart_func_query(struct hci_dev *hdev)
0508 {
0509     struct btmtk_hci_wmt_params wmt_params;
0510     int status, err;
0511     u8 param = 0;
0512 
0513     /* Query whether the function is enabled */
0514     wmt_params.op = BTMTK_WMT_FUNC_CTRL;
0515     wmt_params.flag = 4;
0516     wmt_params.dlen = sizeof(param);
0517     wmt_params.data = &param;
0518     wmt_params.status = &status;
0519 
0520     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0521     if (err < 0) {
0522         bt_dev_err(hdev, "Failed to query function status (%d)", err);
0523         return err;
0524     }
0525 
0526     return status;
0527 }
0528 
0529 static int btmtkuart_change_baudrate(struct hci_dev *hdev)
0530 {
0531     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0532     struct btmtk_hci_wmt_params wmt_params;
0533     __le32 baudrate;
0534     u8 param;
0535     int err;
0536 
0537     /* Indicate the device to enter the probe state the host is
0538      * ready to change a new baudrate.
0539      */
0540     baudrate = cpu_to_le32(bdev->desired_speed);
0541     wmt_params.op = BTMTK_WMT_HIF;
0542     wmt_params.flag = 1;
0543     wmt_params.dlen = 4;
0544     wmt_params.data = &baudrate;
0545     wmt_params.status = NULL;
0546 
0547     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0548     if (err < 0) {
0549         bt_dev_err(hdev, "Failed to device baudrate (%d)", err);
0550         return err;
0551     }
0552 
0553     err = serdev_device_set_baudrate(bdev->serdev,
0554                      bdev->desired_speed);
0555     if (err < 0) {
0556         bt_dev_err(hdev, "Failed to set up host baudrate (%d)",
0557                err);
0558         return err;
0559     }
0560 
0561     serdev_device_set_flow_control(bdev->serdev, false);
0562 
0563     /* Send a dummy byte 0xff to activate the new baudrate */
0564     param = 0xff;
0565     err = serdev_device_write_buf(bdev->serdev, &param, sizeof(param));
0566     if (err < 0 || err < sizeof(param))
0567         return err;
0568 
0569     serdev_device_wait_until_sent(bdev->serdev, 0);
0570 
0571     /* Wait some time for the device changing baudrate done */
0572     usleep_range(20000, 22000);
0573 
0574     /* Test the new baudrate */
0575     wmt_params.op = BTMTK_WMT_TEST;
0576     wmt_params.flag = 7;
0577     wmt_params.dlen = 0;
0578     wmt_params.data = NULL;
0579     wmt_params.status = NULL;
0580 
0581     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0582     if (err < 0) {
0583         bt_dev_err(hdev, "Failed to test new baudrate (%d)",
0584                err);
0585         return err;
0586     }
0587 
0588     bdev->curr_speed = bdev->desired_speed;
0589 
0590     return 0;
0591 }
0592 
0593 static int btmtkuart_setup(struct hci_dev *hdev)
0594 {
0595     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0596     struct btmtk_hci_wmt_params wmt_params;
0597     ktime_t calltime, delta, rettime;
0598     struct btmtk_tci_sleep tci_sleep;
0599     unsigned long long duration;
0600     struct sk_buff *skb;
0601     int err, status;
0602     u8 param = 0x1;
0603 
0604     calltime = ktime_get();
0605 
0606     /* Wakeup MCUSYS is required for certain devices before we start to
0607      * do any setups.
0608      */
0609     if (test_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state)) {
0610         wmt_params.op = BTMTK_WMT_WAKEUP;
0611         wmt_params.flag = 3;
0612         wmt_params.dlen = 0;
0613         wmt_params.data = NULL;
0614         wmt_params.status = NULL;
0615 
0616         err = mtk_hci_wmt_sync(hdev, &wmt_params);
0617         if (err < 0) {
0618             bt_dev_err(hdev, "Failed to wakeup the chip (%d)", err);
0619             return err;
0620         }
0621 
0622         clear_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state);
0623     }
0624 
0625     if (btmtkuart_is_standalone(bdev))
0626         btmtkuart_change_baudrate(hdev);
0627 
0628     /* Query whether the firmware is already download */
0629     wmt_params.op = BTMTK_WMT_SEMAPHORE;
0630     wmt_params.flag = 1;
0631     wmt_params.dlen = 0;
0632     wmt_params.data = NULL;
0633     wmt_params.status = &status;
0634 
0635     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0636     if (err < 0) {
0637         bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
0638         return err;
0639     }
0640 
0641     if (status == BTMTK_WMT_PATCH_DONE) {
0642         bt_dev_info(hdev, "Firmware already downloaded");
0643         goto ignore_setup_fw;
0644     }
0645 
0646     /* Setup a firmware which the device definitely requires */
0647     err = btmtk_setup_firmware(hdev, bdev->data->fwname, mtk_hci_wmt_sync);
0648     if (err < 0)
0649         return err;
0650 
0651 ignore_setup_fw:
0652     /* Query whether the device is already enabled */
0653     err = readx_poll_timeout(btmtkuart_func_query, hdev, status,
0654                  status < 0 || status != BTMTK_WMT_ON_PROGRESS,
0655                  2000, 5000000);
0656     /* -ETIMEDOUT happens */
0657     if (err < 0)
0658         return err;
0659 
0660     /* The other errors happen in btusb_mtk_func_query */
0661     if (status < 0)
0662         return status;
0663 
0664     if (status == BTMTK_WMT_ON_DONE) {
0665         bt_dev_info(hdev, "function already on");
0666         goto ignore_func_on;
0667     }
0668 
0669     /* Enable Bluetooth protocol */
0670     wmt_params.op = BTMTK_WMT_FUNC_CTRL;
0671     wmt_params.flag = 0;
0672     wmt_params.dlen = sizeof(param);
0673     wmt_params.data = &param;
0674     wmt_params.status = NULL;
0675 
0676     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0677     if (err < 0) {
0678         bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
0679         return err;
0680     }
0681 
0682 ignore_func_on:
0683     /* Apply the low power environment setup */
0684     tci_sleep.mode = 0x5;
0685     tci_sleep.duration = cpu_to_le16(0x640);
0686     tci_sleep.host_duration = cpu_to_le16(0x640);
0687     tci_sleep.host_wakeup_pin = 0;
0688     tci_sleep.time_compensation = 0;
0689 
0690     skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
0691                  HCI_INIT_TIMEOUT);
0692     if (IS_ERR(skb)) {
0693         err = PTR_ERR(skb);
0694         bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
0695         return err;
0696     }
0697     kfree_skb(skb);
0698 
0699     rettime = ktime_get();
0700     delta = ktime_sub(rettime, calltime);
0701     duration = (unsigned long long)ktime_to_ns(delta) >> 10;
0702 
0703     bt_dev_info(hdev, "Device setup in %llu usecs", duration);
0704 
0705     return 0;
0706 }
0707 
0708 static int btmtkuart_shutdown(struct hci_dev *hdev)
0709 {
0710     struct btmtk_hci_wmt_params wmt_params;
0711     u8 param = 0x0;
0712     int err;
0713 
0714     /* Disable the device */
0715     wmt_params.op = BTMTK_WMT_FUNC_CTRL;
0716     wmt_params.flag = 0;
0717     wmt_params.dlen = sizeof(param);
0718     wmt_params.data = &param;
0719     wmt_params.status = NULL;
0720 
0721     err = mtk_hci_wmt_sync(hdev, &wmt_params);
0722     if (err < 0) {
0723         bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
0724         return err;
0725     }
0726 
0727     return 0;
0728 }
0729 
0730 static int btmtkuart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
0731 {
0732     struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
0733     struct mtk_stp_hdr *shdr;
0734     int err, dlen, type = 0;
0735 
0736     /* Prepend skb with frame type */
0737     memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
0738 
0739     /* Make sure that there is enough rooms for STP header and trailer */
0740     if (unlikely(skb_headroom(skb) < sizeof(*shdr)) ||
0741         (skb_tailroom(skb) < MTK_STP_TLR_SIZE)) {
0742         err = pskb_expand_head(skb, sizeof(*shdr), MTK_STP_TLR_SIZE,
0743                        GFP_ATOMIC);
0744         if (err < 0)
0745             return err;
0746     }
0747 
0748     /* Add the STP header */
0749     dlen = skb->len;
0750     shdr = skb_push(skb, sizeof(*shdr));
0751     shdr->prefix = 0x80;
0752     shdr->dlen = cpu_to_be16((dlen & 0x0fff) | (type << 12));
0753     shdr->cs = 0;       /* MT7622 doesn't care about checksum value */
0754 
0755     /* Add the STP trailer */
0756     skb_put_zero(skb, MTK_STP_TLR_SIZE);
0757 
0758     skb_queue_tail(&bdev->txq, skb);
0759 
0760     btmtkuart_tx_wakeup(bdev);
0761     return 0;
0762 }
0763 
0764 static int btmtkuart_parse_dt(struct serdev_device *serdev)
0765 {
0766     struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
0767     struct device_node *node = serdev->dev.of_node;
0768     u32 speed = 921600;
0769     int err;
0770 
0771     if (btmtkuart_is_standalone(bdev)) {
0772         of_property_read_u32(node, "current-speed", &speed);
0773 
0774         bdev->desired_speed = speed;
0775 
0776         bdev->vcc = devm_regulator_get(&serdev->dev, "vcc");
0777         if (IS_ERR(bdev->vcc)) {
0778             err = PTR_ERR(bdev->vcc);
0779             return err;
0780         }
0781 
0782         bdev->osc = devm_clk_get_optional(&serdev->dev, "osc");
0783         if (IS_ERR(bdev->osc)) {
0784             err = PTR_ERR(bdev->osc);
0785             return err;
0786         }
0787 
0788         bdev->boot = devm_gpiod_get_optional(&serdev->dev, "boot",
0789                              GPIOD_OUT_LOW);
0790         if (IS_ERR(bdev->boot)) {
0791             err = PTR_ERR(bdev->boot);
0792             return err;
0793         }
0794 
0795         bdev->pinctrl = devm_pinctrl_get(&serdev->dev);
0796         if (IS_ERR(bdev->pinctrl)) {
0797             err = PTR_ERR(bdev->pinctrl);
0798             return err;
0799         }
0800 
0801         bdev->pins_boot = pinctrl_lookup_state(bdev->pinctrl,
0802                                "default");
0803         if (IS_ERR(bdev->pins_boot) && !bdev->boot) {
0804             err = PTR_ERR(bdev->pins_boot);
0805             dev_err(&serdev->dev,
0806                 "Should assign RXD to LOW at boot stage\n");
0807             return err;
0808         }
0809 
0810         bdev->pins_runtime = pinctrl_lookup_state(bdev->pinctrl,
0811                               "runtime");
0812         if (IS_ERR(bdev->pins_runtime)) {
0813             err = PTR_ERR(bdev->pins_runtime);
0814             return err;
0815         }
0816 
0817         bdev->reset = devm_gpiod_get_optional(&serdev->dev, "reset",
0818                               GPIOD_OUT_LOW);
0819         if (IS_ERR(bdev->reset)) {
0820             err = PTR_ERR(bdev->reset);
0821             return err;
0822         }
0823     } else if (btmtkuart_is_builtin_soc(bdev)) {
0824         bdev->clk = devm_clk_get(&serdev->dev, "ref");
0825         if (IS_ERR(bdev->clk))
0826             return PTR_ERR(bdev->clk);
0827     }
0828 
0829     return 0;
0830 }
0831 
0832 static int btmtkuart_probe(struct serdev_device *serdev)
0833 {
0834     struct btmtkuart_dev *bdev;
0835     struct hci_dev *hdev;
0836     int err;
0837 
0838     bdev = devm_kzalloc(&serdev->dev, sizeof(*bdev), GFP_KERNEL);
0839     if (!bdev)
0840         return -ENOMEM;
0841 
0842     bdev->data = of_device_get_match_data(&serdev->dev);
0843     if (!bdev->data)
0844         return -ENODEV;
0845 
0846     bdev->serdev = serdev;
0847     serdev_device_set_drvdata(serdev, bdev);
0848 
0849     serdev_device_set_client_ops(serdev, &btmtkuart_client_ops);
0850 
0851     err = btmtkuart_parse_dt(serdev);
0852     if (err < 0)
0853         return err;
0854 
0855     INIT_WORK(&bdev->tx_work, btmtkuart_tx_work);
0856     skb_queue_head_init(&bdev->txq);
0857 
0858     /* Initialize and register HCI device */
0859     hdev = hci_alloc_dev();
0860     if (!hdev) {
0861         dev_err(&serdev->dev, "Can't allocate HCI device\n");
0862         return -ENOMEM;
0863     }
0864 
0865     bdev->hdev = hdev;
0866 
0867     hdev->bus = HCI_UART;
0868     hci_set_drvdata(hdev, bdev);
0869 
0870     hdev->open     = btmtkuart_open;
0871     hdev->close    = btmtkuart_close;
0872     hdev->flush    = btmtkuart_flush;
0873     hdev->setup    = btmtkuart_setup;
0874     hdev->shutdown = btmtkuart_shutdown;
0875     hdev->send     = btmtkuart_send_frame;
0876     hdev->set_bdaddr = btmtk_set_bdaddr;
0877     SET_HCIDEV_DEV(hdev, &serdev->dev);
0878 
0879     hdev->manufacturer = 70;
0880     set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
0881 
0882     if (btmtkuart_is_standalone(bdev)) {
0883         err = clk_prepare_enable(bdev->osc);
0884         if (err < 0)
0885             goto err_hci_free_dev;
0886 
0887         if (bdev->boot) {
0888             gpiod_set_value_cansleep(bdev->boot, 1);
0889         } else {
0890             /* Switch to the specific pin state for the booting
0891              * requires.
0892              */
0893             pinctrl_select_state(bdev->pinctrl, bdev->pins_boot);
0894         }
0895 
0896         /* Power on */
0897         err = regulator_enable(bdev->vcc);
0898         if (err < 0)
0899             goto err_clk_disable_unprepare;
0900 
0901         /* Reset if the reset-gpios is available otherwise the board
0902          * -level design should be guaranteed.
0903          */
0904         if (bdev->reset) {
0905             gpiod_set_value_cansleep(bdev->reset, 1);
0906             usleep_range(1000, 2000);
0907             gpiod_set_value_cansleep(bdev->reset, 0);
0908         }
0909 
0910         /* Wait some time until device got ready and switch to the pin
0911          * mode the device requires for UART transfers.
0912          */
0913         msleep(50);
0914 
0915         if (bdev->boot)
0916             devm_gpiod_put(&serdev->dev, bdev->boot);
0917 
0918         pinctrl_select_state(bdev->pinctrl, bdev->pins_runtime);
0919 
0920         /* A standalone device doesn't depends on power domain on SoC,
0921          * so mark it as no callbacks.
0922          */
0923         pm_runtime_no_callbacks(&serdev->dev);
0924 
0925         set_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state);
0926     }
0927 
0928     err = hci_register_dev(hdev);
0929     if (err < 0) {
0930         dev_err(&serdev->dev, "Can't register HCI device\n");
0931         goto err_regulator_disable;
0932     }
0933 
0934     return 0;
0935 
0936 err_regulator_disable:
0937     if (btmtkuart_is_standalone(bdev))
0938         regulator_disable(bdev->vcc);
0939 err_clk_disable_unprepare:
0940     if (btmtkuart_is_standalone(bdev))
0941         clk_disable_unprepare(bdev->osc);
0942 err_hci_free_dev:
0943     hci_free_dev(hdev);
0944 
0945     return err;
0946 }
0947 
0948 static void btmtkuart_remove(struct serdev_device *serdev)
0949 {
0950     struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
0951     struct hci_dev *hdev = bdev->hdev;
0952 
0953     if (btmtkuart_is_standalone(bdev)) {
0954         regulator_disable(bdev->vcc);
0955         clk_disable_unprepare(bdev->osc);
0956     }
0957 
0958     hci_unregister_dev(hdev);
0959     hci_free_dev(hdev);
0960 }
0961 
0962 static const struct btmtkuart_data mt7622_data = {
0963     .fwname = FIRMWARE_MT7622,
0964 };
0965 
0966 static const struct btmtkuart_data mt7663_data = {
0967     .flags = BTMTKUART_FLAG_STANDALONE_HW,
0968     .fwname = FIRMWARE_MT7663,
0969 };
0970 
0971 static const struct btmtkuart_data mt7668_data = {
0972     .flags = BTMTKUART_FLAG_STANDALONE_HW,
0973     .fwname = FIRMWARE_MT7668,
0974 };
0975 
0976 #ifdef CONFIG_OF
0977 static const struct of_device_id mtk_of_match_table[] = {
0978     { .compatible = "mediatek,mt7622-bluetooth", .data = &mt7622_data},
0979     { .compatible = "mediatek,mt7663u-bluetooth", .data = &mt7663_data},
0980     { .compatible = "mediatek,mt7668u-bluetooth", .data = &mt7668_data},
0981     { }
0982 };
0983 MODULE_DEVICE_TABLE(of, mtk_of_match_table);
0984 #endif
0985 
0986 static struct serdev_device_driver btmtkuart_driver = {
0987     .probe = btmtkuart_probe,
0988     .remove = btmtkuart_remove,
0989     .driver = {
0990         .name = "btmtkuart",
0991         .of_match_table = of_match_ptr(mtk_of_match_table),
0992     },
0993 };
0994 
0995 module_serdev_device_driver(btmtkuart_driver);
0996 
0997 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
0998 MODULE_DESCRIPTION("MediaTek Bluetooth Serial driver ver " VERSION);
0999 MODULE_VERSION(VERSION);
1000 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!