btmtkuart.c 26 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138
  1. // SPDX-License-Identifier: GPL-2.0
  2. // Copyright (c) 2018 MediaTek Inc.
  3. /*
  4. * Bluetooth support for MediaTek serial devices
  5. *
  6. * Author: Sean Wang <sean.wang@mediatek.com>
  7. *
  8. */
  9. #include <asm/unaligned.h>
  10. #include <linux/atomic.h>
  11. #include <linux/clk.h>
  12. #include <linux/firmware.h>
  13. #include <linux/gpio/consumer.h>
  14. #include <linux/iopoll.h>
  15. #include <linux/kernel.h>
  16. #include <linux/module.h>
  17. #include <linux/of.h>
  18. #include <linux/of_device.h>
  19. #include <linux/pinctrl/consumer.h>
  20. #include <linux/pm_runtime.h>
  21. #include <linux/regulator/consumer.h>
  22. #include <linux/serdev.h>
  23. #include <linux/skbuff.h>
  24. #include <net/bluetooth/bluetooth.h>
  25. #include <net/bluetooth/hci_core.h>
  26. #include "h4_recv.h"
  27. #define VERSION "0.2"
  28. #define FIRMWARE_MT7622 "mediatek/mt7622pr2h.bin"
  29. #define FIRMWARE_MT7663 "mediatek/mt7663pr2h.bin"
  30. #define FIRMWARE_MT7668 "mediatek/mt7668pr2h.bin"
  31. #define MTK_STP_TLR_SIZE 2
  32. #define BTMTKUART_TX_STATE_ACTIVE 1
  33. #define BTMTKUART_TX_STATE_WAKEUP 2
  34. #define BTMTKUART_TX_WAIT_VND_EVT 3
  35. #define BTMTKUART_REQUIRED_WAKEUP 4
  36. #define BTMTKUART_FLAG_STANDALONE_HW BIT(0)
  37. enum {
  38. MTK_WMT_PATCH_DWNLD = 0x1,
  39. MTK_WMT_TEST = 0x2,
  40. MTK_WMT_WAKEUP = 0x3,
  41. MTK_WMT_HIF = 0x4,
  42. MTK_WMT_FUNC_CTRL = 0x6,
  43. MTK_WMT_RST = 0x7,
  44. MTK_WMT_SEMAPHORE = 0x17,
  45. };
  46. enum {
  47. BTMTK_WMT_INVALID,
  48. BTMTK_WMT_PATCH_UNDONE,
  49. BTMTK_WMT_PATCH_DONE,
  50. BTMTK_WMT_ON_UNDONE,
  51. BTMTK_WMT_ON_DONE,
  52. BTMTK_WMT_ON_PROGRESS,
  53. };
  54. struct mtk_stp_hdr {
  55. u8 prefix;
  56. __be16 dlen;
  57. u8 cs;
  58. } __packed;
  59. struct btmtkuart_data {
  60. unsigned int flags;
  61. const char *fwname;
  62. };
  63. struct mtk_wmt_hdr {
  64. u8 dir;
  65. u8 op;
  66. __le16 dlen;
  67. u8 flag;
  68. } __packed;
  69. struct mtk_hci_wmt_cmd {
  70. struct mtk_wmt_hdr hdr;
  71. u8 data[256];
  72. } __packed;
  73. struct btmtk_hci_wmt_evt {
  74. struct hci_event_hdr hhdr;
  75. struct mtk_wmt_hdr whdr;
  76. } __packed;
  77. struct btmtk_hci_wmt_evt_funcc {
  78. struct btmtk_hci_wmt_evt hwhdr;
  79. __be16 status;
  80. } __packed;
  81. struct btmtk_tci_sleep {
  82. u8 mode;
  83. __le16 duration;
  84. __le16 host_duration;
  85. u8 host_wakeup_pin;
  86. u8 time_compensation;
  87. } __packed;
  88. struct btmtk_hci_wmt_params {
  89. u8 op;
  90. u8 flag;
  91. u16 dlen;
  92. const void *data;
  93. u32 *status;
  94. };
  95. struct btmtkuart_dev {
  96. struct hci_dev *hdev;
  97. struct serdev_device *serdev;
  98. struct clk *clk;
  99. struct clk *osc;
  100. struct regulator *vcc;
  101. struct gpio_desc *reset;
  102. struct gpio_desc *boot;
  103. struct pinctrl *pinctrl;
  104. struct pinctrl_state *pins_runtime;
  105. struct pinctrl_state *pins_boot;
  106. speed_t desired_speed;
  107. speed_t curr_speed;
  108. struct work_struct tx_work;
  109. unsigned long tx_state;
  110. struct sk_buff_head txq;
  111. struct sk_buff *rx_skb;
  112. struct sk_buff *evt_skb;
  113. u8 stp_pad[6];
  114. u8 stp_cursor;
  115. u16 stp_dlen;
  116. const struct btmtkuart_data *data;
  117. };
  118. #define btmtkuart_is_standalone(bdev) \
  119. ((bdev)->data->flags & BTMTKUART_FLAG_STANDALONE_HW)
  120. #define btmtkuart_is_builtin_soc(bdev) \
  121. !((bdev)->data->flags & BTMTKUART_FLAG_STANDALONE_HW)
  122. static int mtk_hci_wmt_sync(struct hci_dev *hdev,
  123. struct btmtk_hci_wmt_params *wmt_params)
  124. {
  125. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  126. struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
  127. u32 hlen, status = BTMTK_WMT_INVALID;
  128. struct btmtk_hci_wmt_evt *wmt_evt;
  129. struct mtk_hci_wmt_cmd wc;
  130. struct mtk_wmt_hdr *hdr;
  131. int err;
  132. hlen = sizeof(*hdr) + wmt_params->dlen;
  133. if (hlen > 255) {
  134. err = -EINVAL;
  135. goto err_free_skb;
  136. }
  137. hdr = (struct mtk_wmt_hdr *)&wc;
  138. hdr->dir = 1;
  139. hdr->op = wmt_params->op;
  140. hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
  141. hdr->flag = wmt_params->flag;
  142. memcpy(wc.data, wmt_params->data, wmt_params->dlen);
  143. set_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
  144. err = __hci_cmd_send(hdev, 0xfc6f, hlen, &wc);
  145. if (err < 0) {
  146. clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
  147. goto err_free_skb;
  148. }
  149. /* The vendor specific WMT commands are all answered by a vendor
  150. * specific event and will not have the Command Status or Command
  151. * Complete as with usual HCI command flow control.
  152. *
  153. * After sending the command, wait for BTMTKUART_TX_WAIT_VND_EVT
  154. * state to be cleared. The driver specific event receive routine
  155. * will clear that state and with that indicate completion of the
  156. * WMT command.
  157. */
  158. err = wait_on_bit_timeout(&bdev->tx_state, BTMTKUART_TX_WAIT_VND_EVT,
  159. TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
  160. if (err == -EINTR) {
  161. bt_dev_err(hdev, "Execution of wmt command interrupted");
  162. clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
  163. goto err_free_skb;
  164. }
  165. if (err) {
  166. bt_dev_err(hdev, "Execution of wmt command timed out");
  167. clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state);
  168. err = -ETIMEDOUT;
  169. goto err_free_skb;
  170. }
  171. /* Parse and handle the return WMT event */
  172. wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
  173. if (wmt_evt->whdr.op != hdr->op) {
  174. bt_dev_err(hdev, "Wrong op received %d expected %d",
  175. wmt_evt->whdr.op, hdr->op);
  176. err = -EIO;
  177. goto err_free_skb;
  178. }
  179. switch (wmt_evt->whdr.op) {
  180. case MTK_WMT_SEMAPHORE:
  181. if (wmt_evt->whdr.flag == 2)
  182. status = BTMTK_WMT_PATCH_UNDONE;
  183. else
  184. status = BTMTK_WMT_PATCH_DONE;
  185. break;
  186. case MTK_WMT_FUNC_CTRL:
  187. wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
  188. if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
  189. status = BTMTK_WMT_ON_DONE;
  190. else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
  191. status = BTMTK_WMT_ON_PROGRESS;
  192. else
  193. status = BTMTK_WMT_ON_UNDONE;
  194. break;
  195. }
  196. if (wmt_params->status)
  197. *wmt_params->status = status;
  198. err_free_skb:
  199. kfree_skb(bdev->evt_skb);
  200. bdev->evt_skb = NULL;
  201. return err;
  202. }
  203. static int mtk_setup_firmware(struct hci_dev *hdev, const char *fwname)
  204. {
  205. struct btmtk_hci_wmt_params wmt_params;
  206. const struct firmware *fw;
  207. const u8 *fw_ptr;
  208. size_t fw_size;
  209. int err, dlen;
  210. u8 flag;
  211. err = request_firmware(&fw, fwname, &hdev->dev);
  212. if (err < 0) {
  213. bt_dev_err(hdev, "Failed to load firmware file (%d)", err);
  214. return err;
  215. }
  216. fw_ptr = fw->data;
  217. fw_size = fw->size;
  218. /* The size of patch header is 30 bytes, should be skip */
  219. if (fw_size < 30) {
  220. err = -EINVAL;
  221. goto free_fw;
  222. }
  223. fw_size -= 30;
  224. fw_ptr += 30;
  225. flag = 1;
  226. wmt_params.op = MTK_WMT_PATCH_DWNLD;
  227. wmt_params.status = NULL;
  228. while (fw_size > 0) {
  229. dlen = min_t(int, 250, fw_size);
  230. /* Tell device the position in sequence */
  231. if (fw_size - dlen <= 0)
  232. flag = 3;
  233. else if (fw_size < fw->size - 30)
  234. flag = 2;
  235. wmt_params.flag = flag;
  236. wmt_params.dlen = dlen;
  237. wmt_params.data = fw_ptr;
  238. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  239. if (err < 0) {
  240. bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
  241. err);
  242. goto free_fw;
  243. }
  244. fw_size -= dlen;
  245. fw_ptr += dlen;
  246. }
  247. wmt_params.op = MTK_WMT_RST;
  248. wmt_params.flag = 4;
  249. wmt_params.dlen = 0;
  250. wmt_params.data = NULL;
  251. wmt_params.status = NULL;
  252. /* Activate funciton the firmware providing to */
  253. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  254. if (err < 0) {
  255. bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
  256. goto free_fw;
  257. }
  258. /* Wait a few moments for firmware activation done */
  259. usleep_range(10000, 12000);
  260. free_fw:
  261. release_firmware(fw);
  262. return err;
  263. }
  264. static int btmtkuart_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
  265. {
  266. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  267. struct hci_event_hdr *hdr = (void *)skb->data;
  268. int err;
  269. /* Fix up the vendor event id with 0xff for vendor specific instead
  270. * of 0xe4 so that event send via monitoring socket can be parsed
  271. * properly.
  272. */
  273. if (hdr->evt == 0xe4)
  274. hdr->evt = HCI_EV_VENDOR;
  275. /* When someone waits for the WMT event, the skb is being cloned
  276. * and being processed the events from there then.
  277. */
  278. if (test_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state)) {
  279. bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
  280. if (!bdev->evt_skb) {
  281. err = -ENOMEM;
  282. goto err_out;
  283. }
  284. }
  285. err = hci_recv_frame(hdev, skb);
  286. if (err < 0)
  287. goto err_free_skb;
  288. if (hdr->evt == HCI_EV_VENDOR) {
  289. if (test_and_clear_bit(BTMTKUART_TX_WAIT_VND_EVT,
  290. &bdev->tx_state)) {
  291. /* Barrier to sync with other CPUs */
  292. smp_mb__after_atomic();
  293. wake_up_bit(&bdev->tx_state, BTMTKUART_TX_WAIT_VND_EVT);
  294. }
  295. }
  296. return 0;
  297. err_free_skb:
  298. kfree_skb(bdev->evt_skb);
  299. bdev->evt_skb = NULL;
  300. err_out:
  301. return err;
  302. }
  303. static const struct h4_recv_pkt mtk_recv_pkts[] = {
  304. { H4_RECV_ACL, .recv = hci_recv_frame },
  305. { H4_RECV_SCO, .recv = hci_recv_frame },
  306. { H4_RECV_EVENT, .recv = btmtkuart_recv_event },
  307. };
  308. static void btmtkuart_tx_work(struct work_struct *work)
  309. {
  310. struct btmtkuart_dev *bdev = container_of(work, struct btmtkuart_dev,
  311. tx_work);
  312. struct serdev_device *serdev = bdev->serdev;
  313. struct hci_dev *hdev = bdev->hdev;
  314. while (1) {
  315. clear_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state);
  316. while (1) {
  317. struct sk_buff *skb = skb_dequeue(&bdev->txq);
  318. int len;
  319. if (!skb)
  320. break;
  321. len = serdev_device_write_buf(serdev, skb->data,
  322. skb->len);
  323. hdev->stat.byte_tx += len;
  324. skb_pull(skb, len);
  325. if (skb->len > 0) {
  326. skb_queue_head(&bdev->txq, skb);
  327. break;
  328. }
  329. switch (hci_skb_pkt_type(skb)) {
  330. case HCI_COMMAND_PKT:
  331. hdev->stat.cmd_tx++;
  332. break;
  333. case HCI_ACLDATA_PKT:
  334. hdev->stat.acl_tx++;
  335. break;
  336. case HCI_SCODATA_PKT:
  337. hdev->stat.sco_tx++;
  338. break;
  339. }
  340. kfree_skb(skb);
  341. }
  342. if (!test_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state))
  343. break;
  344. }
  345. clear_bit(BTMTKUART_TX_STATE_ACTIVE, &bdev->tx_state);
  346. }
  347. static void btmtkuart_tx_wakeup(struct btmtkuart_dev *bdev)
  348. {
  349. if (test_and_set_bit(BTMTKUART_TX_STATE_ACTIVE, &bdev->tx_state))
  350. set_bit(BTMTKUART_TX_STATE_WAKEUP, &bdev->tx_state);
  351. schedule_work(&bdev->tx_work);
  352. }
  353. static const unsigned char *
  354. mtk_stp_split(struct btmtkuart_dev *bdev, const unsigned char *data, int count,
  355. int *sz_h4)
  356. {
  357. struct mtk_stp_hdr *shdr;
  358. /* The cursor is reset when all the data of STP is consumed out */
  359. if (!bdev->stp_dlen && bdev->stp_cursor >= 6)
  360. bdev->stp_cursor = 0;
  361. /* Filling pad until all STP info is obtained */
  362. while (bdev->stp_cursor < 6 && count > 0) {
  363. bdev->stp_pad[bdev->stp_cursor] = *data;
  364. bdev->stp_cursor++;
  365. data++;
  366. count--;
  367. }
  368. /* Retrieve STP info and have a sanity check */
  369. if (!bdev->stp_dlen && bdev->stp_cursor >= 6) {
  370. shdr = (struct mtk_stp_hdr *)&bdev->stp_pad[2];
  371. bdev->stp_dlen = be16_to_cpu(shdr->dlen) & 0x0fff;
  372. /* Resync STP when unexpected data is being read */
  373. if (shdr->prefix != 0x80 || bdev->stp_dlen > 2048) {
  374. bt_dev_err(bdev->hdev, "stp format unexpect (%d, %d)",
  375. shdr->prefix, bdev->stp_dlen);
  376. bdev->stp_cursor = 2;
  377. bdev->stp_dlen = 0;
  378. }
  379. }
  380. /* Directly quit when there's no data found for H4 can process */
  381. if (count <= 0)
  382. return NULL;
  383. /* Tranlate to how much the size of data H4 can handle so far */
  384. *sz_h4 = min_t(int, count, bdev->stp_dlen);
  385. /* Update the remaining size of STP packet */
  386. bdev->stp_dlen -= *sz_h4;
  387. /* Data points to STP payload which can be handled by H4 */
  388. return data;
  389. }
  390. static int btmtkuart_recv(struct hci_dev *hdev, const u8 *data, size_t count)
  391. {
  392. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  393. const unsigned char *p_left = data, *p_h4;
  394. int sz_left = count, sz_h4, adv;
  395. int err;
  396. while (sz_left > 0) {
  397. /* The serial data received from MT7622 BT controller is
  398. * at all time padded around with the STP header and tailer.
  399. *
  400. * A full STP packet is looking like
  401. * -----------------------------------
  402. * | STP header | H:4 | STP tailer |
  403. * -----------------------------------
  404. * but it doesn't guarantee to contain a full H:4 packet which
  405. * means that it's possible for multiple STP packets forms a
  406. * full H:4 packet that means extra STP header + length doesn't
  407. * indicate a full H:4 frame, things can fragment. Whose length
  408. * recorded in STP header just shows up the most length the
  409. * H:4 engine can handle currently.
  410. */
  411. p_h4 = mtk_stp_split(bdev, p_left, sz_left, &sz_h4);
  412. if (!p_h4)
  413. break;
  414. adv = p_h4 - p_left;
  415. sz_left -= adv;
  416. p_left += adv;
  417. bdev->rx_skb = h4_recv_buf(bdev->hdev, bdev->rx_skb, p_h4,
  418. sz_h4, mtk_recv_pkts,
  419. ARRAY_SIZE(mtk_recv_pkts));
  420. if (IS_ERR(bdev->rx_skb)) {
  421. err = PTR_ERR(bdev->rx_skb);
  422. bt_dev_err(bdev->hdev,
  423. "Frame reassembly failed (%d)", err);
  424. bdev->rx_skb = NULL;
  425. return err;
  426. }
  427. sz_left -= sz_h4;
  428. p_left += sz_h4;
  429. }
  430. return 0;
  431. }
  432. static int btmtkuart_receive_buf(struct serdev_device *serdev, const u8 *data,
  433. size_t count)
  434. {
  435. struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
  436. int err;
  437. err = btmtkuart_recv(bdev->hdev, data, count);
  438. if (err < 0)
  439. return err;
  440. bdev->hdev->stat.byte_rx += count;
  441. return count;
  442. }
  443. static void btmtkuart_write_wakeup(struct serdev_device *serdev)
  444. {
  445. struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
  446. btmtkuart_tx_wakeup(bdev);
  447. }
  448. static const struct serdev_device_ops btmtkuart_client_ops = {
  449. .receive_buf = btmtkuart_receive_buf,
  450. .write_wakeup = btmtkuart_write_wakeup,
  451. };
  452. static int btmtkuart_open(struct hci_dev *hdev)
  453. {
  454. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  455. struct device *dev;
  456. int err;
  457. err = serdev_device_open(bdev->serdev);
  458. if (err) {
  459. bt_dev_err(hdev, "Unable to open UART device %s",
  460. dev_name(&bdev->serdev->dev));
  461. goto err_open;
  462. }
  463. if (btmtkuart_is_standalone(bdev)) {
  464. if (bdev->curr_speed != bdev->desired_speed)
  465. err = serdev_device_set_baudrate(bdev->serdev,
  466. 115200);
  467. else
  468. err = serdev_device_set_baudrate(bdev->serdev,
  469. bdev->desired_speed);
  470. if (err < 0) {
  471. bt_dev_err(hdev, "Unable to set baudrate UART device %s",
  472. dev_name(&bdev->serdev->dev));
  473. goto err_serdev_close;
  474. }
  475. serdev_device_set_flow_control(bdev->serdev, false);
  476. }
  477. bdev->stp_cursor = 2;
  478. bdev->stp_dlen = 0;
  479. dev = &bdev->serdev->dev;
  480. /* Enable the power domain and clock the device requires */
  481. pm_runtime_enable(dev);
  482. err = pm_runtime_get_sync(dev);
  483. if (err < 0) {
  484. pm_runtime_put_noidle(dev);
  485. goto err_disable_rpm;
  486. }
  487. err = clk_prepare_enable(bdev->clk);
  488. if (err < 0)
  489. goto err_put_rpm;
  490. return 0;
  491. err_put_rpm:
  492. pm_runtime_put_sync(dev);
  493. err_disable_rpm:
  494. pm_runtime_disable(dev);
  495. err_serdev_close:
  496. serdev_device_close(bdev->serdev);
  497. err_open:
  498. return err;
  499. }
  500. static int btmtkuart_close(struct hci_dev *hdev)
  501. {
  502. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  503. struct device *dev = &bdev->serdev->dev;
  504. /* Shutdown the clock and power domain the device requires */
  505. clk_disable_unprepare(bdev->clk);
  506. pm_runtime_put_sync(dev);
  507. pm_runtime_disable(dev);
  508. serdev_device_close(bdev->serdev);
  509. return 0;
  510. }
  511. static int btmtkuart_flush(struct hci_dev *hdev)
  512. {
  513. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  514. /* Flush any pending characters */
  515. serdev_device_write_flush(bdev->serdev);
  516. skb_queue_purge(&bdev->txq);
  517. cancel_work_sync(&bdev->tx_work);
  518. kfree_skb(bdev->rx_skb);
  519. bdev->rx_skb = NULL;
  520. bdev->stp_cursor = 2;
  521. bdev->stp_dlen = 0;
  522. return 0;
  523. }
  524. static int btmtkuart_func_query(struct hci_dev *hdev)
  525. {
  526. struct btmtk_hci_wmt_params wmt_params;
  527. int status, err;
  528. u8 param = 0;
  529. /* Query whether the function is enabled */
  530. wmt_params.op = MTK_WMT_FUNC_CTRL;
  531. wmt_params.flag = 4;
  532. wmt_params.dlen = sizeof(param);
  533. wmt_params.data = &param;
  534. wmt_params.status = &status;
  535. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  536. if (err < 0) {
  537. bt_dev_err(hdev, "Failed to query function status (%d)", err);
  538. return err;
  539. }
  540. return status;
  541. }
  542. static int btmtkuart_change_baudrate(struct hci_dev *hdev)
  543. {
  544. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  545. struct btmtk_hci_wmt_params wmt_params;
  546. __le32 baudrate;
  547. u8 param;
  548. int err;
  549. /* Indicate the device to enter the probe state the host is
  550. * ready to change a new baudrate.
  551. */
  552. baudrate = cpu_to_le32(bdev->desired_speed);
  553. wmt_params.op = MTK_WMT_HIF;
  554. wmt_params.flag = 1;
  555. wmt_params.dlen = 4;
  556. wmt_params.data = &baudrate;
  557. wmt_params.status = NULL;
  558. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  559. if (err < 0) {
  560. bt_dev_err(hdev, "Failed to device baudrate (%d)", err);
  561. return err;
  562. }
  563. err = serdev_device_set_baudrate(bdev->serdev,
  564. bdev->desired_speed);
  565. if (err < 0) {
  566. bt_dev_err(hdev, "Failed to set up host baudrate (%d)",
  567. err);
  568. return err;
  569. }
  570. serdev_device_set_flow_control(bdev->serdev, false);
  571. /* Send a dummy byte 0xff to activate the new baudrate */
  572. param = 0xff;
  573. err = serdev_device_write_buf(bdev->serdev, &param, sizeof(param));
  574. if (err < 0 || err < sizeof(param))
  575. return err;
  576. serdev_device_wait_until_sent(bdev->serdev, 0);
  577. /* Wait some time for the device changing baudrate done */
  578. usleep_range(20000, 22000);
  579. /* Test the new baudrate */
  580. wmt_params.op = MTK_WMT_TEST;
  581. wmt_params.flag = 7;
  582. wmt_params.dlen = 0;
  583. wmt_params.data = NULL;
  584. wmt_params.status = NULL;
  585. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  586. if (err < 0) {
  587. bt_dev_err(hdev, "Failed to test new baudrate (%d)",
  588. err);
  589. return err;
  590. }
  591. bdev->curr_speed = bdev->desired_speed;
  592. return 0;
  593. }
  594. static int btmtkuart_setup(struct hci_dev *hdev)
  595. {
  596. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  597. struct btmtk_hci_wmt_params wmt_params;
  598. ktime_t calltime, delta, rettime;
  599. struct btmtk_tci_sleep tci_sleep;
  600. unsigned long long duration;
  601. struct sk_buff *skb;
  602. int err, status;
  603. u8 param = 0x1;
  604. calltime = ktime_get();
  605. /* Wakeup MCUSYS is required for certain devices before we start to
  606. * do any setups.
  607. */
  608. if (test_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state)) {
  609. wmt_params.op = MTK_WMT_WAKEUP;
  610. wmt_params.flag = 3;
  611. wmt_params.dlen = 0;
  612. wmt_params.data = NULL;
  613. wmt_params.status = NULL;
  614. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  615. if (err < 0) {
  616. bt_dev_err(hdev, "Failed to wakeup the chip (%d)", err);
  617. return err;
  618. }
  619. clear_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state);
  620. }
  621. if (btmtkuart_is_standalone(bdev))
  622. btmtkuart_change_baudrate(hdev);
  623. /* Query whether the firmware is already download */
  624. wmt_params.op = MTK_WMT_SEMAPHORE;
  625. wmt_params.flag = 1;
  626. wmt_params.dlen = 0;
  627. wmt_params.data = NULL;
  628. wmt_params.status = &status;
  629. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  630. if (err < 0) {
  631. bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
  632. return err;
  633. }
  634. if (status == BTMTK_WMT_PATCH_DONE) {
  635. bt_dev_info(hdev, "Firmware already downloaded");
  636. goto ignore_setup_fw;
  637. }
  638. /* Setup a firmware which the device definitely requires */
  639. err = mtk_setup_firmware(hdev, bdev->data->fwname);
  640. if (err < 0)
  641. return err;
  642. ignore_setup_fw:
  643. /* Query whether the device is already enabled */
  644. err = readx_poll_timeout(btmtkuart_func_query, hdev, status,
  645. status < 0 || status != BTMTK_WMT_ON_PROGRESS,
  646. 2000, 5000000);
  647. /* -ETIMEDOUT happens */
  648. if (err < 0)
  649. return err;
  650. /* The other errors happen in btusb_mtk_func_query */
  651. if (status < 0)
  652. return status;
  653. if (status == BTMTK_WMT_ON_DONE) {
  654. bt_dev_info(hdev, "function already on");
  655. goto ignore_func_on;
  656. }
  657. /* Enable Bluetooth protocol */
  658. wmt_params.op = MTK_WMT_FUNC_CTRL;
  659. wmt_params.flag = 0;
  660. wmt_params.dlen = sizeof(param);
  661. wmt_params.data = &param;
  662. wmt_params.status = NULL;
  663. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  664. if (err < 0) {
  665. bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
  666. return err;
  667. }
  668. ignore_func_on:
  669. /* Apply the low power environment setup */
  670. tci_sleep.mode = 0x5;
  671. tci_sleep.duration = cpu_to_le16(0x640);
  672. tci_sleep.host_duration = cpu_to_le16(0x640);
  673. tci_sleep.host_wakeup_pin = 0;
  674. tci_sleep.time_compensation = 0;
  675. skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
  676. HCI_INIT_TIMEOUT);
  677. if (IS_ERR(skb)) {
  678. err = PTR_ERR(skb);
  679. bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
  680. return err;
  681. }
  682. kfree_skb(skb);
  683. rettime = ktime_get();
  684. delta = ktime_sub(rettime, calltime);
  685. duration = (unsigned long long)ktime_to_ns(delta) >> 10;
  686. bt_dev_info(hdev, "Device setup in %llu usecs", duration);
  687. return 0;
  688. }
  689. static int btmtkuart_shutdown(struct hci_dev *hdev)
  690. {
  691. struct btmtk_hci_wmt_params wmt_params;
  692. u8 param = 0x0;
  693. int err;
  694. /* Disable the device */
  695. wmt_params.op = MTK_WMT_FUNC_CTRL;
  696. wmt_params.flag = 0;
  697. wmt_params.dlen = sizeof(param);
  698. wmt_params.data = &param;
  699. wmt_params.status = NULL;
  700. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  701. if (err < 0) {
  702. bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
  703. return err;
  704. }
  705. return 0;
  706. }
  707. static int btmtkuart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
  708. {
  709. struct btmtkuart_dev *bdev = hci_get_drvdata(hdev);
  710. struct mtk_stp_hdr *shdr;
  711. int err, dlen, type = 0;
  712. /* Prepend skb with frame type */
  713. memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
  714. /* Make sure that there is enough rooms for STP header and trailer */
  715. if (unlikely(skb_headroom(skb) < sizeof(*shdr)) ||
  716. (skb_tailroom(skb) < MTK_STP_TLR_SIZE)) {
  717. err = pskb_expand_head(skb, sizeof(*shdr), MTK_STP_TLR_SIZE,
  718. GFP_ATOMIC);
  719. if (err < 0)
  720. return err;
  721. }
  722. /* Add the STP header */
  723. dlen = skb->len;
  724. shdr = skb_push(skb, sizeof(*shdr));
  725. shdr->prefix = 0x80;
  726. shdr->dlen = cpu_to_be16((dlen & 0x0fff) | (type << 12));
  727. shdr->cs = 0; /* MT7622 doesn't care about checksum value */
  728. /* Add the STP trailer */
  729. skb_put_zero(skb, MTK_STP_TLR_SIZE);
  730. skb_queue_tail(&bdev->txq, skb);
  731. btmtkuart_tx_wakeup(bdev);
  732. return 0;
  733. }
  734. static int btmtkuart_parse_dt(struct serdev_device *serdev)
  735. {
  736. struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
  737. struct device_node *node = serdev->dev.of_node;
  738. u32 speed = 921600;
  739. int err;
  740. if (btmtkuart_is_standalone(bdev)) {
  741. of_property_read_u32(node, "current-speed", &speed);
  742. bdev->desired_speed = speed;
  743. bdev->vcc = devm_regulator_get(&serdev->dev, "vcc");
  744. if (IS_ERR(bdev->vcc)) {
  745. err = PTR_ERR(bdev->vcc);
  746. return err;
  747. }
  748. bdev->osc = devm_clk_get_optional(&serdev->dev, "osc");
  749. if (IS_ERR(bdev->osc)) {
  750. err = PTR_ERR(bdev->osc);
  751. return err;
  752. }
  753. bdev->boot = devm_gpiod_get_optional(&serdev->dev, "boot",
  754. GPIOD_OUT_LOW);
  755. if (IS_ERR(bdev->boot)) {
  756. err = PTR_ERR(bdev->boot);
  757. return err;
  758. }
  759. bdev->pinctrl = devm_pinctrl_get(&serdev->dev);
  760. if (IS_ERR(bdev->pinctrl)) {
  761. err = PTR_ERR(bdev->pinctrl);
  762. return err;
  763. }
  764. bdev->pins_boot = pinctrl_lookup_state(bdev->pinctrl,
  765. "default");
  766. if (IS_ERR(bdev->pins_boot) && !bdev->boot) {
  767. err = PTR_ERR(bdev->pins_boot);
  768. dev_err(&serdev->dev,
  769. "Should assign RXD to LOW at boot stage\n");
  770. return err;
  771. }
  772. bdev->pins_runtime = pinctrl_lookup_state(bdev->pinctrl,
  773. "runtime");
  774. if (IS_ERR(bdev->pins_runtime)) {
  775. err = PTR_ERR(bdev->pins_runtime);
  776. return err;
  777. }
  778. bdev->reset = devm_gpiod_get_optional(&serdev->dev, "reset",
  779. GPIOD_OUT_LOW);
  780. if (IS_ERR(bdev->reset)) {
  781. err = PTR_ERR(bdev->reset);
  782. return err;
  783. }
  784. } else if (btmtkuart_is_builtin_soc(bdev)) {
  785. bdev->clk = devm_clk_get(&serdev->dev, "ref");
  786. if (IS_ERR(bdev->clk))
  787. return PTR_ERR(bdev->clk);
  788. }
  789. return 0;
  790. }
  791. static int btmtkuart_probe(struct serdev_device *serdev)
  792. {
  793. struct btmtkuart_dev *bdev;
  794. struct hci_dev *hdev;
  795. int err;
  796. bdev = devm_kzalloc(&serdev->dev, sizeof(*bdev), GFP_KERNEL);
  797. if (!bdev)
  798. return -ENOMEM;
  799. bdev->data = of_device_get_match_data(&serdev->dev);
  800. if (!bdev->data)
  801. return -ENODEV;
  802. bdev->serdev = serdev;
  803. serdev_device_set_drvdata(serdev, bdev);
  804. serdev_device_set_client_ops(serdev, &btmtkuart_client_ops);
  805. err = btmtkuart_parse_dt(serdev);
  806. if (err < 0)
  807. return err;
  808. INIT_WORK(&bdev->tx_work, btmtkuart_tx_work);
  809. skb_queue_head_init(&bdev->txq);
  810. /* Initialize and register HCI device */
  811. hdev = hci_alloc_dev();
  812. if (!hdev) {
  813. dev_err(&serdev->dev, "Can't allocate HCI device\n");
  814. return -ENOMEM;
  815. }
  816. bdev->hdev = hdev;
  817. hdev->bus = HCI_UART;
  818. hci_set_drvdata(hdev, bdev);
  819. hdev->open = btmtkuart_open;
  820. hdev->close = btmtkuart_close;
  821. hdev->flush = btmtkuart_flush;
  822. hdev->setup = btmtkuart_setup;
  823. hdev->shutdown = btmtkuart_shutdown;
  824. hdev->send = btmtkuart_send_frame;
  825. SET_HCIDEV_DEV(hdev, &serdev->dev);
  826. hdev->manufacturer = 70;
  827. set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
  828. if (btmtkuart_is_standalone(bdev)) {
  829. err = clk_prepare_enable(bdev->osc);
  830. if (err < 0)
  831. goto err_hci_free_dev;
  832. if (bdev->boot) {
  833. gpiod_set_value_cansleep(bdev->boot, 1);
  834. } else {
  835. /* Switch to the specific pin state for the booting
  836. * requires.
  837. */
  838. pinctrl_select_state(bdev->pinctrl, bdev->pins_boot);
  839. }
  840. /* Power on */
  841. err = regulator_enable(bdev->vcc);
  842. if (err < 0)
  843. goto err_clk_disable_unprepare;
  844. /* Reset if the reset-gpios is available otherwise the board
  845. * -level design should be guaranteed.
  846. */
  847. if (bdev->reset) {
  848. gpiod_set_value_cansleep(bdev->reset, 1);
  849. usleep_range(1000, 2000);
  850. gpiod_set_value_cansleep(bdev->reset, 0);
  851. }
  852. /* Wait some time until device got ready and switch to the pin
  853. * mode the device requires for UART transfers.
  854. */
  855. msleep(50);
  856. if (bdev->boot)
  857. devm_gpiod_put(&serdev->dev, bdev->boot);
  858. pinctrl_select_state(bdev->pinctrl, bdev->pins_runtime);
  859. /* A standalone device doesn't depends on power domain on SoC,
  860. * so mark it as no callbacks.
  861. */
  862. pm_runtime_no_callbacks(&serdev->dev);
  863. set_bit(BTMTKUART_REQUIRED_WAKEUP, &bdev->tx_state);
  864. }
  865. err = hci_register_dev(hdev);
  866. if (err < 0) {
  867. dev_err(&serdev->dev, "Can't register HCI device\n");
  868. goto err_regulator_disable;
  869. }
  870. return 0;
  871. err_regulator_disable:
  872. if (btmtkuart_is_standalone(bdev))
  873. regulator_disable(bdev->vcc);
  874. err_clk_disable_unprepare:
  875. if (btmtkuart_is_standalone(bdev))
  876. clk_disable_unprepare(bdev->osc);
  877. err_hci_free_dev:
  878. hci_free_dev(hdev);
  879. return err;
  880. }
  881. static void btmtkuart_remove(struct serdev_device *serdev)
  882. {
  883. struct btmtkuart_dev *bdev = serdev_device_get_drvdata(serdev);
  884. struct hci_dev *hdev = bdev->hdev;
  885. if (btmtkuart_is_standalone(bdev)) {
  886. regulator_disable(bdev->vcc);
  887. clk_disable_unprepare(bdev->osc);
  888. }
  889. hci_unregister_dev(hdev);
  890. hci_free_dev(hdev);
  891. }
  892. static const struct btmtkuart_data mt7622_data = {
  893. .fwname = FIRMWARE_MT7622,
  894. };
  895. static const struct btmtkuart_data mt7663_data = {
  896. .flags = BTMTKUART_FLAG_STANDALONE_HW,
  897. .fwname = FIRMWARE_MT7663,
  898. };
  899. static const struct btmtkuart_data mt7668_data = {
  900. .flags = BTMTKUART_FLAG_STANDALONE_HW,
  901. .fwname = FIRMWARE_MT7668,
  902. };
  903. #ifdef CONFIG_OF
  904. static const struct of_device_id mtk_of_match_table[] = {
  905. { .compatible = "mediatek,mt7622-bluetooth", .data = &mt7622_data},
  906. { .compatible = "mediatek,mt7663u-bluetooth", .data = &mt7663_data},
  907. { .compatible = "mediatek,mt7668u-bluetooth", .data = &mt7668_data},
  908. { }
  909. };
  910. MODULE_DEVICE_TABLE(of, mtk_of_match_table);
  911. #endif
  912. static struct serdev_device_driver btmtkuart_driver = {
  913. .probe = btmtkuart_probe,
  914. .remove = btmtkuart_remove,
  915. .driver = {
  916. .name = "btmtkuart",
  917. .of_match_table = of_match_ptr(mtk_of_match_table),
  918. },
  919. };
  920. module_serdev_device_driver(btmtkuart_driver);
  921. MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
  922. MODULE_DESCRIPTION("MediaTek Bluetooth Serial driver ver " VERSION);
  923. MODULE_VERSION(VERSION);
  924. MODULE_LICENSE("GPL");
  925. MODULE_FIRMWARE(FIRMWARE_MT7622);
  926. MODULE_FIRMWARE(FIRMWARE_MT7663);
  927. MODULE_FIRMWARE(FIRMWARE_MT7668);