btmtksdio.c 26 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118
  1. // SPDX-License-Identifier: GPL-2.0
  2. // Copyright (c) 2019 MediaTek Inc.
  3. /*
  4. * Bluetooth support for MediaTek SDIO devices
  5. *
  6. * This file is written based on btsdio.c and btmtkuart.c.
  7. *
  8. * Author: Sean Wang <sean.wang@mediatek.com>
  9. *
  10. */
  11. #include <asm/unaligned.h>
  12. #include <linux/atomic.h>
  13. #include <linux/firmware.h>
  14. #include <linux/init.h>
  15. #include <linux/iopoll.h>
  16. #include <linux/kernel.h>
  17. #include <linux/module.h>
  18. #include <linux/pm_runtime.h>
  19. #include <linux/skbuff.h>
  20. #include <linux/mmc/host.h>
  21. #include <linux/mmc/sdio_ids.h>
  22. #include <linux/mmc/sdio_func.h>
  23. #include <net/bluetooth/bluetooth.h>
  24. #include <net/bluetooth/hci_core.h>
  25. #include "h4_recv.h"
  26. #define VERSION "0.1"
  27. #define FIRMWARE_MT7663 "mediatek/mt7663pr2h.bin"
  28. #define FIRMWARE_MT7668 "mediatek/mt7668pr2h.bin"
  29. #define MTKBTSDIO_AUTOSUSPEND_DELAY 8000
  30. static bool enable_autosuspend;
  31. struct btmtksdio_data {
  32. const char *fwname;
  33. };
  34. static const struct btmtksdio_data mt7663_data = {
  35. .fwname = FIRMWARE_MT7663,
  36. };
  37. static const struct btmtksdio_data mt7668_data = {
  38. .fwname = FIRMWARE_MT7668,
  39. };
  40. static const struct sdio_device_id btmtksdio_table[] = {
  41. {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7663),
  42. .driver_data = (kernel_ulong_t)&mt7663_data },
  43. {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7668),
  44. .driver_data = (kernel_ulong_t)&mt7668_data },
  45. { } /* Terminating entry */
  46. };
  47. MODULE_DEVICE_TABLE(sdio, btmtksdio_table);
  48. #define MTK_REG_CHLPCR 0x4 /* W1S */
  49. #define C_INT_EN_SET BIT(0)
  50. #define C_INT_EN_CLR BIT(1)
  51. #define C_FW_OWN_REQ_SET BIT(8) /* For write */
  52. #define C_COM_DRV_OWN BIT(8) /* For read */
  53. #define C_FW_OWN_REQ_CLR BIT(9)
  54. #define MTK_REG_CSDIOCSR 0x8
  55. #define SDIO_RE_INIT_EN BIT(0)
  56. #define SDIO_INT_CTL BIT(2)
  57. #define MTK_REG_CHCR 0xc
  58. #define C_INT_CLR_CTRL BIT(1)
  59. /* CHISR have the same bits field definition with CHIER */
  60. #define MTK_REG_CHISR 0x10
  61. #define MTK_REG_CHIER 0x14
  62. #define FW_OWN_BACK_INT BIT(0)
  63. #define RX_DONE_INT BIT(1)
  64. #define TX_EMPTY BIT(2)
  65. #define TX_FIFO_OVERFLOW BIT(8)
  66. #define RX_PKT_LEN GENMASK(31, 16)
  67. #define MTK_REG_CTDR 0x18
  68. #define MTK_REG_CRDR 0x1c
  69. #define MTK_SDIO_BLOCK_SIZE 256
  70. #define BTMTKSDIO_TX_WAIT_VND_EVT 1
  71. enum {
  72. MTK_WMT_PATCH_DWNLD = 0x1,
  73. MTK_WMT_TEST = 0x2,
  74. MTK_WMT_WAKEUP = 0x3,
  75. MTK_WMT_HIF = 0x4,
  76. MTK_WMT_FUNC_CTRL = 0x6,
  77. MTK_WMT_RST = 0x7,
  78. MTK_WMT_SEMAPHORE = 0x17,
  79. };
  80. enum {
  81. BTMTK_WMT_INVALID,
  82. BTMTK_WMT_PATCH_UNDONE,
  83. BTMTK_WMT_PATCH_DONE,
  84. BTMTK_WMT_ON_UNDONE,
  85. BTMTK_WMT_ON_DONE,
  86. BTMTK_WMT_ON_PROGRESS,
  87. };
  88. struct mtkbtsdio_hdr {
  89. __le16 len;
  90. __le16 reserved;
  91. u8 bt_type;
  92. } __packed;
  93. struct mtk_wmt_hdr {
  94. u8 dir;
  95. u8 op;
  96. __le16 dlen;
  97. u8 flag;
  98. } __packed;
  99. struct mtk_hci_wmt_cmd {
  100. struct mtk_wmt_hdr hdr;
  101. u8 data[256];
  102. } __packed;
  103. struct btmtk_hci_wmt_evt {
  104. struct hci_event_hdr hhdr;
  105. struct mtk_wmt_hdr whdr;
  106. } __packed;
  107. struct btmtk_hci_wmt_evt_funcc {
  108. struct btmtk_hci_wmt_evt hwhdr;
  109. __be16 status;
  110. } __packed;
  111. struct btmtk_tci_sleep {
  112. u8 mode;
  113. __le16 duration;
  114. __le16 host_duration;
  115. u8 host_wakeup_pin;
  116. u8 time_compensation;
  117. } __packed;
  118. struct btmtk_hci_wmt_params {
  119. u8 op;
  120. u8 flag;
  121. u16 dlen;
  122. const void *data;
  123. u32 *status;
  124. };
  125. struct btmtksdio_dev {
  126. struct hci_dev *hdev;
  127. struct sdio_func *func;
  128. struct device *dev;
  129. struct work_struct tx_work;
  130. unsigned long tx_state;
  131. struct sk_buff_head txq;
  132. struct sk_buff *evt_skb;
  133. const struct btmtksdio_data *data;
  134. };
  135. static int mtk_hci_wmt_sync(struct hci_dev *hdev,
  136. struct btmtk_hci_wmt_params *wmt_params)
  137. {
  138. struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
  139. struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
  140. u32 hlen, status = BTMTK_WMT_INVALID;
  141. struct btmtk_hci_wmt_evt *wmt_evt;
  142. struct mtk_hci_wmt_cmd wc;
  143. struct mtk_wmt_hdr *hdr;
  144. int err;
  145. hlen = sizeof(*hdr) + wmt_params->dlen;
  146. if (hlen > 255)
  147. return -EINVAL;
  148. hdr = (struct mtk_wmt_hdr *)&wc;
  149. hdr->dir = 1;
  150. hdr->op = wmt_params->op;
  151. hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
  152. hdr->flag = wmt_params->flag;
  153. memcpy(wc.data, wmt_params->data, wmt_params->dlen);
  154. set_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
  155. err = __hci_cmd_send(hdev, 0xfc6f, hlen, &wc);
  156. if (err < 0) {
  157. clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
  158. return err;
  159. }
  160. /* The vendor specific WMT commands are all answered by a vendor
  161. * specific event and will not have the Command Status or Command
  162. * Complete as with usual HCI command flow control.
  163. *
  164. * After sending the command, wait for BTMTKSDIO_TX_WAIT_VND_EVT
  165. * state to be cleared. The driver specific event receive routine
  166. * will clear that state and with that indicate completion of the
  167. * WMT command.
  168. */
  169. err = wait_on_bit_timeout(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT,
  170. TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
  171. if (err == -EINTR) {
  172. bt_dev_err(hdev, "Execution of wmt command interrupted");
  173. clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
  174. return err;
  175. }
  176. if (err) {
  177. bt_dev_err(hdev, "Execution of wmt command timed out");
  178. clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
  179. return -ETIMEDOUT;
  180. }
  181. /* Parse and handle the return WMT event */
  182. wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
  183. if (wmt_evt->whdr.op != hdr->op) {
  184. bt_dev_err(hdev, "Wrong op received %d expected %d",
  185. wmt_evt->whdr.op, hdr->op);
  186. err = -EIO;
  187. goto err_free_skb;
  188. }
  189. switch (wmt_evt->whdr.op) {
  190. case MTK_WMT_SEMAPHORE:
  191. if (wmt_evt->whdr.flag == 2)
  192. status = BTMTK_WMT_PATCH_UNDONE;
  193. else
  194. status = BTMTK_WMT_PATCH_DONE;
  195. break;
  196. case MTK_WMT_FUNC_CTRL:
  197. wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
  198. if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
  199. status = BTMTK_WMT_ON_DONE;
  200. else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
  201. status = BTMTK_WMT_ON_PROGRESS;
  202. else
  203. status = BTMTK_WMT_ON_UNDONE;
  204. break;
  205. }
  206. if (wmt_params->status)
  207. *wmt_params->status = status;
  208. err_free_skb:
  209. kfree_skb(bdev->evt_skb);
  210. bdev->evt_skb = NULL;
  211. return err;
  212. }
  213. static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev,
  214. struct sk_buff *skb)
  215. {
  216. struct mtkbtsdio_hdr *sdio_hdr;
  217. int err;
  218. /* Make sure that there are enough rooms for SDIO header */
  219. if (unlikely(skb_headroom(skb) < sizeof(*sdio_hdr))) {
  220. err = pskb_expand_head(skb, sizeof(*sdio_hdr), 0,
  221. GFP_ATOMIC);
  222. if (err < 0)
  223. return err;
  224. }
  225. /* Prepend MediaTek SDIO Specific Header */
  226. skb_push(skb, sizeof(*sdio_hdr));
  227. sdio_hdr = (void *)skb->data;
  228. sdio_hdr->len = cpu_to_le16(skb->len);
  229. sdio_hdr->reserved = cpu_to_le16(0);
  230. sdio_hdr->bt_type = hci_skb_pkt_type(skb);
  231. err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data,
  232. round_up(skb->len, MTK_SDIO_BLOCK_SIZE));
  233. if (err < 0)
  234. goto err_skb_pull;
  235. bdev->hdev->stat.byte_tx += skb->len;
  236. kfree_skb(skb);
  237. return 0;
  238. err_skb_pull:
  239. skb_pull(skb, sizeof(*sdio_hdr));
  240. return err;
  241. }
  242. static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev)
  243. {
  244. return sdio_readl(bdev->func, MTK_REG_CHLPCR, NULL);
  245. }
  246. static void btmtksdio_tx_work(struct work_struct *work)
  247. {
  248. struct btmtksdio_dev *bdev = container_of(work, struct btmtksdio_dev,
  249. tx_work);
  250. struct sk_buff *skb;
  251. int err;
  252. pm_runtime_get_sync(bdev->dev);
  253. sdio_claim_host(bdev->func);
  254. while ((skb = skb_dequeue(&bdev->txq))) {
  255. err = btmtksdio_tx_packet(bdev, skb);
  256. if (err < 0) {
  257. bdev->hdev->stat.err_tx++;
  258. skb_queue_head(&bdev->txq, skb);
  259. break;
  260. }
  261. }
  262. sdio_release_host(bdev->func);
  263. pm_runtime_mark_last_busy(bdev->dev);
  264. pm_runtime_put_autosuspend(bdev->dev);
  265. }
  266. static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
  267. {
  268. struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
  269. struct hci_event_hdr *hdr = (void *)skb->data;
  270. int err;
  271. /* Fix up the vendor event id with 0xff for vendor specific instead
  272. * of 0xe4 so that event send via monitoring socket can be parsed
  273. * properly.
  274. */
  275. if (hdr->evt == 0xe4)
  276. hdr->evt = HCI_EV_VENDOR;
  277. /* When someone waits for the WMT event, the skb is being cloned
  278. * and being processed the events from there then.
  279. */
  280. if (test_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state)) {
  281. bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
  282. if (!bdev->evt_skb) {
  283. err = -ENOMEM;
  284. goto err_out;
  285. }
  286. }
  287. err = hci_recv_frame(hdev, skb);
  288. if (err < 0)
  289. goto err_free_skb;
  290. if (hdr->evt == HCI_EV_VENDOR) {
  291. if (test_and_clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT,
  292. &bdev->tx_state)) {
  293. /* Barrier to sync with other CPUs */
  294. smp_mb__after_atomic();
  295. wake_up_bit(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT);
  296. }
  297. }
  298. return 0;
  299. err_free_skb:
  300. kfree_skb(bdev->evt_skb);
  301. bdev->evt_skb = NULL;
  302. err_out:
  303. return err;
  304. }
  305. static const struct h4_recv_pkt mtk_recv_pkts[] = {
  306. { H4_RECV_ACL, .recv = hci_recv_frame },
  307. { H4_RECV_SCO, .recv = hci_recv_frame },
  308. { H4_RECV_EVENT, .recv = btmtksdio_recv_event },
  309. };
  310. static int btmtksdio_rx_packet(struct btmtksdio_dev *bdev, u16 rx_size)
  311. {
  312. const struct h4_recv_pkt *pkts = mtk_recv_pkts;
  313. int pkts_count = ARRAY_SIZE(mtk_recv_pkts);
  314. struct mtkbtsdio_hdr *sdio_hdr;
  315. int err, i, pad_size;
  316. struct sk_buff *skb;
  317. u16 dlen;
  318. if (rx_size < sizeof(*sdio_hdr))
  319. return -EILSEQ;
  320. /* A SDIO packet is exactly containing a Bluetooth packet */
  321. skb = bt_skb_alloc(rx_size, GFP_KERNEL);
  322. if (!skb)
  323. return -ENOMEM;
  324. skb_put(skb, rx_size);
  325. err = sdio_readsb(bdev->func, skb->data, MTK_REG_CRDR, rx_size);
  326. if (err < 0)
  327. goto err_kfree_skb;
  328. sdio_hdr = (void *)skb->data;
  329. /* We assume the default error as -EILSEQ simply to make the error path
  330. * be cleaner.
  331. */
  332. err = -EILSEQ;
  333. if (rx_size != le16_to_cpu(sdio_hdr->len)) {
  334. bt_dev_err(bdev->hdev, "Rx size in sdio header is mismatched ");
  335. goto err_kfree_skb;
  336. }
  337. hci_skb_pkt_type(skb) = sdio_hdr->bt_type;
  338. /* Remove MediaTek SDIO header */
  339. skb_pull(skb, sizeof(*sdio_hdr));
  340. /* We have to dig into the packet to get payload size and then know how
  341. * many padding bytes at the tail, these padding bytes should be removed
  342. * before the packet is indicated to the core layer.
  343. */
  344. for (i = 0; i < pkts_count; i++) {
  345. if (sdio_hdr->bt_type == (&pkts[i])->type)
  346. break;
  347. }
  348. if (i >= pkts_count) {
  349. bt_dev_err(bdev->hdev, "Invalid bt type 0x%02x",
  350. sdio_hdr->bt_type);
  351. goto err_kfree_skb;
  352. }
  353. /* Remaining bytes cannot hold a header*/
  354. if (skb->len < (&pkts[i])->hlen) {
  355. bt_dev_err(bdev->hdev, "The size of bt header is mismatched");
  356. goto err_kfree_skb;
  357. }
  358. switch ((&pkts[i])->lsize) {
  359. case 1:
  360. dlen = skb->data[(&pkts[i])->loff];
  361. break;
  362. case 2:
  363. dlen = get_unaligned_le16(skb->data +
  364. (&pkts[i])->loff);
  365. break;
  366. default:
  367. goto err_kfree_skb;
  368. }
  369. pad_size = skb->len - (&pkts[i])->hlen - dlen;
  370. /* Remaining bytes cannot hold a payload */
  371. if (pad_size < 0) {
  372. bt_dev_err(bdev->hdev, "The size of bt payload is mismatched");
  373. goto err_kfree_skb;
  374. }
  375. /* Remove padding bytes */
  376. skb_trim(skb, skb->len - pad_size);
  377. /* Complete frame */
  378. (&pkts[i])->recv(bdev->hdev, skb);
  379. bdev->hdev->stat.byte_rx += rx_size;
  380. return 0;
  381. err_kfree_skb:
  382. kfree_skb(skb);
  383. return err;
  384. }
  385. static void btmtksdio_interrupt(struct sdio_func *func)
  386. {
  387. struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
  388. u32 int_status;
  389. u16 rx_size;
  390. /* It is required that the host gets ownership from the device before
  391. * accessing any register, however, if SDIO host is not being released,
  392. * a potential deadlock probably happens in a circular wait between SDIO
  393. * IRQ work and PM runtime work. So, we have to explicitly release SDIO
  394. * host here and claim again after the PM runtime work is all done.
  395. */
  396. sdio_release_host(bdev->func);
  397. pm_runtime_get_sync(bdev->dev);
  398. sdio_claim_host(bdev->func);
  399. /* Disable interrupt */
  400. sdio_writel(func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
  401. int_status = sdio_readl(func, MTK_REG_CHISR, NULL);
  402. /* Ack an interrupt as soon as possible before any operation on
  403. * hardware.
  404. *
  405. * Note that we don't ack any status during operations to avoid race
  406. * condition between the host and the device such as it's possible to
  407. * mistakenly ack RX_DONE for the next packet and then cause interrupts
  408. * not be raised again but there is still pending data in the hardware
  409. * FIFO.
  410. */
  411. sdio_writel(func, int_status, MTK_REG_CHISR, NULL);
  412. if (unlikely(!int_status))
  413. bt_dev_err(bdev->hdev, "CHISR is 0");
  414. if (int_status & FW_OWN_BACK_INT)
  415. bt_dev_dbg(bdev->hdev, "Get fw own back");
  416. if (int_status & TX_EMPTY)
  417. schedule_work(&bdev->tx_work);
  418. else if (unlikely(int_status & TX_FIFO_OVERFLOW))
  419. bt_dev_warn(bdev->hdev, "Tx fifo overflow");
  420. if (int_status & RX_DONE_INT) {
  421. rx_size = (int_status & RX_PKT_LEN) >> 16;
  422. if (btmtksdio_rx_packet(bdev, rx_size) < 0)
  423. bdev->hdev->stat.err_rx++;
  424. }
  425. /* Enable interrupt */
  426. sdio_writel(func, C_INT_EN_SET, MTK_REG_CHLPCR, NULL);
  427. pm_runtime_mark_last_busy(bdev->dev);
  428. pm_runtime_put_autosuspend(bdev->dev);
  429. }
  430. static int btmtksdio_open(struct hci_dev *hdev)
  431. {
  432. struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
  433. int err;
  434. u32 status;
  435. sdio_claim_host(bdev->func);
  436. err = sdio_enable_func(bdev->func);
  437. if (err < 0)
  438. goto err_release_host;
  439. /* Get ownership from the device */
  440. sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err);
  441. if (err < 0)
  442. goto err_disable_func;
  443. err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
  444. status & C_COM_DRV_OWN, 2000, 1000000);
  445. if (err < 0) {
  446. bt_dev_err(bdev->hdev, "Cannot get ownership from device");
  447. goto err_disable_func;
  448. }
  449. /* Disable interrupt & mask out all interrupt sources */
  450. sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, &err);
  451. if (err < 0)
  452. goto err_disable_func;
  453. sdio_writel(bdev->func, 0, MTK_REG_CHIER, &err);
  454. if (err < 0)
  455. goto err_disable_func;
  456. err = sdio_claim_irq(bdev->func, btmtksdio_interrupt);
  457. if (err < 0)
  458. goto err_disable_func;
  459. err = sdio_set_block_size(bdev->func, MTK_SDIO_BLOCK_SIZE);
  460. if (err < 0)
  461. goto err_release_irq;
  462. /* SDIO CMD 5 allows the SDIO device back to idle state an
  463. * synchronous interrupt is supported in SDIO 4-bit mode
  464. */
  465. sdio_writel(bdev->func, SDIO_INT_CTL | SDIO_RE_INIT_EN,
  466. MTK_REG_CSDIOCSR, &err);
  467. if (err < 0)
  468. goto err_release_irq;
  469. /* Setup write-1-clear for CHISR register */
  470. sdio_writel(bdev->func, C_INT_CLR_CTRL, MTK_REG_CHCR, &err);
  471. if (err < 0)
  472. goto err_release_irq;
  473. /* Setup interrupt sources */
  474. sdio_writel(bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW,
  475. MTK_REG_CHIER, &err);
  476. if (err < 0)
  477. goto err_release_irq;
  478. /* Enable interrupt */
  479. sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, &err);
  480. if (err < 0)
  481. goto err_release_irq;
  482. sdio_release_host(bdev->func);
  483. return 0;
  484. err_release_irq:
  485. sdio_release_irq(bdev->func);
  486. err_disable_func:
  487. sdio_disable_func(bdev->func);
  488. err_release_host:
  489. sdio_release_host(bdev->func);
  490. return err;
  491. }
  492. static int btmtksdio_close(struct hci_dev *hdev)
  493. {
  494. struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
  495. u32 status;
  496. int err;
  497. sdio_claim_host(bdev->func);
  498. /* Disable interrupt */
  499. sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
  500. sdio_release_irq(bdev->func);
  501. /* Return ownership to the device */
  502. sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, NULL);
  503. err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
  504. !(status & C_COM_DRV_OWN), 2000, 1000000);
  505. if (err < 0)
  506. bt_dev_err(bdev->hdev, "Cannot return ownership to device");
  507. sdio_disable_func(bdev->func);
  508. sdio_release_host(bdev->func);
  509. return 0;
  510. }
  511. static int btmtksdio_flush(struct hci_dev *hdev)
  512. {
  513. struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
  514. skb_queue_purge(&bdev->txq);
  515. cancel_work_sync(&bdev->tx_work);
  516. return 0;
  517. }
  518. static int btmtksdio_func_query(struct hci_dev *hdev)
  519. {
  520. struct btmtk_hci_wmt_params wmt_params;
  521. int status, err;
  522. u8 param = 0;
  523. /* Query whether the function is enabled */
  524. wmt_params.op = MTK_WMT_FUNC_CTRL;
  525. wmt_params.flag = 4;
  526. wmt_params.dlen = sizeof(param);
  527. wmt_params.data = &param;
  528. wmt_params.status = &status;
  529. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  530. if (err < 0) {
  531. bt_dev_err(hdev, "Failed to query function status (%d)", err);
  532. return err;
  533. }
  534. return status;
  535. }
  536. static int mtk_setup_firmware(struct hci_dev *hdev, const char *fwname)
  537. {
  538. struct btmtk_hci_wmt_params wmt_params;
  539. const struct firmware *fw;
  540. const u8 *fw_ptr;
  541. size_t fw_size;
  542. int err, dlen;
  543. u8 flag, param;
  544. err = request_firmware(&fw, fwname, &hdev->dev);
  545. if (err < 0) {
  546. bt_dev_err(hdev, "Failed to load firmware file (%d)", err);
  547. return err;
  548. }
  549. /* Power on data RAM the firmware relies on. */
  550. param = 1;
  551. wmt_params.op = MTK_WMT_FUNC_CTRL;
  552. wmt_params.flag = 3;
  553. wmt_params.dlen = sizeof(param);
  554. wmt_params.data = &param;
  555. wmt_params.status = NULL;
  556. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  557. if (err < 0) {
  558. bt_dev_err(hdev, "Failed to power on data RAM (%d)", err);
  559. goto free_fw;
  560. }
  561. fw_ptr = fw->data;
  562. fw_size = fw->size;
  563. /* The size of patch header is 30 bytes, should be skip */
  564. if (fw_size < 30) {
  565. err = -EINVAL;
  566. goto free_fw;
  567. }
  568. fw_size -= 30;
  569. fw_ptr += 30;
  570. flag = 1;
  571. wmt_params.op = MTK_WMT_PATCH_DWNLD;
  572. wmt_params.status = NULL;
  573. while (fw_size > 0) {
  574. dlen = min_t(int, 250, fw_size);
  575. /* Tell device the position in sequence */
  576. if (fw_size - dlen <= 0)
  577. flag = 3;
  578. else if (fw_size < fw->size - 30)
  579. flag = 2;
  580. wmt_params.flag = flag;
  581. wmt_params.dlen = dlen;
  582. wmt_params.data = fw_ptr;
  583. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  584. if (err < 0) {
  585. bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
  586. err);
  587. goto free_fw;
  588. }
  589. fw_size -= dlen;
  590. fw_ptr += dlen;
  591. }
  592. wmt_params.op = MTK_WMT_RST;
  593. wmt_params.flag = 4;
  594. wmt_params.dlen = 0;
  595. wmt_params.data = NULL;
  596. wmt_params.status = NULL;
  597. /* Activate funciton the firmware providing to */
  598. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  599. if (err < 0) {
  600. bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
  601. goto free_fw;
  602. }
  603. /* Wait a few moments for firmware activation done */
  604. usleep_range(10000, 12000);
  605. free_fw:
  606. release_firmware(fw);
  607. return err;
  608. }
  609. static int btmtksdio_setup(struct hci_dev *hdev)
  610. {
  611. struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
  612. struct btmtk_hci_wmt_params wmt_params;
  613. ktime_t calltime, delta, rettime;
  614. struct btmtk_tci_sleep tci_sleep;
  615. unsigned long long duration;
  616. struct sk_buff *skb;
  617. int err, status;
  618. u8 param = 0x1;
  619. calltime = ktime_get();
  620. /* Query whether the firmware is already download */
  621. wmt_params.op = MTK_WMT_SEMAPHORE;
  622. wmt_params.flag = 1;
  623. wmt_params.dlen = 0;
  624. wmt_params.data = NULL;
  625. wmt_params.status = &status;
  626. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  627. if (err < 0) {
  628. bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
  629. return err;
  630. }
  631. if (status == BTMTK_WMT_PATCH_DONE) {
  632. bt_dev_info(hdev, "Firmware already downloaded");
  633. goto ignore_setup_fw;
  634. }
  635. /* Setup a firmware which the device definitely requires */
  636. err = mtk_setup_firmware(hdev, bdev->data->fwname);
  637. if (err < 0)
  638. return err;
  639. ignore_setup_fw:
  640. /* Query whether the device is already enabled */
  641. err = readx_poll_timeout(btmtksdio_func_query, hdev, status,
  642. status < 0 || status != BTMTK_WMT_ON_PROGRESS,
  643. 2000, 5000000);
  644. /* -ETIMEDOUT happens */
  645. if (err < 0)
  646. return err;
  647. /* The other errors happen in btusb_mtk_func_query */
  648. if (status < 0)
  649. return status;
  650. if (status == BTMTK_WMT_ON_DONE) {
  651. bt_dev_info(hdev, "function already on");
  652. goto ignore_func_on;
  653. }
  654. /* Enable Bluetooth protocol */
  655. wmt_params.op = MTK_WMT_FUNC_CTRL;
  656. wmt_params.flag = 0;
  657. wmt_params.dlen = sizeof(param);
  658. wmt_params.data = &param;
  659. wmt_params.status = NULL;
  660. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  661. if (err < 0) {
  662. bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
  663. return err;
  664. }
  665. ignore_func_on:
  666. /* Apply the low power environment setup */
  667. tci_sleep.mode = 0x5;
  668. tci_sleep.duration = cpu_to_le16(0x640);
  669. tci_sleep.host_duration = cpu_to_le16(0x640);
  670. tci_sleep.host_wakeup_pin = 0;
  671. tci_sleep.time_compensation = 0;
  672. skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
  673. HCI_INIT_TIMEOUT);
  674. if (IS_ERR(skb)) {
  675. err = PTR_ERR(skb);
  676. bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
  677. return err;
  678. }
  679. kfree_skb(skb);
  680. rettime = ktime_get();
  681. delta = ktime_sub(rettime, calltime);
  682. duration = (unsigned long long)ktime_to_ns(delta) >> 10;
  683. pm_runtime_set_autosuspend_delay(bdev->dev,
  684. MTKBTSDIO_AUTOSUSPEND_DELAY);
  685. pm_runtime_use_autosuspend(bdev->dev);
  686. err = pm_runtime_set_active(bdev->dev);
  687. if (err < 0)
  688. return err;
  689. /* Default forbid runtime auto suspend, that can be allowed by
  690. * enable_autosuspend flag or the PM runtime entry under sysfs.
  691. */
  692. pm_runtime_forbid(bdev->dev);
  693. pm_runtime_enable(bdev->dev);
  694. if (enable_autosuspend)
  695. pm_runtime_allow(bdev->dev);
  696. bt_dev_info(hdev, "Device setup in %llu usecs", duration);
  697. return 0;
  698. }
  699. static int btmtksdio_shutdown(struct hci_dev *hdev)
  700. {
  701. struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
  702. struct btmtk_hci_wmt_params wmt_params;
  703. u8 param = 0x0;
  704. int err;
  705. /* Get back the state to be consistent with the state
  706. * in btmtksdio_setup.
  707. */
  708. pm_runtime_get_sync(bdev->dev);
  709. /* Disable the device */
  710. wmt_params.op = MTK_WMT_FUNC_CTRL;
  711. wmt_params.flag = 0;
  712. wmt_params.dlen = sizeof(param);
  713. wmt_params.data = &param;
  714. wmt_params.status = NULL;
  715. err = mtk_hci_wmt_sync(hdev, &wmt_params);
  716. if (err < 0) {
  717. bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
  718. return err;
  719. }
  720. pm_runtime_put_noidle(bdev->dev);
  721. pm_runtime_disable(bdev->dev);
  722. return 0;
  723. }
  724. static int btmtksdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
  725. {
  726. struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
  727. switch (hci_skb_pkt_type(skb)) {
  728. case HCI_COMMAND_PKT:
  729. hdev->stat.cmd_tx++;
  730. break;
  731. case HCI_ACLDATA_PKT:
  732. hdev->stat.acl_tx++;
  733. break;
  734. case HCI_SCODATA_PKT:
  735. hdev->stat.sco_tx++;
  736. break;
  737. default:
  738. return -EILSEQ;
  739. }
  740. skb_queue_tail(&bdev->txq, skb);
  741. schedule_work(&bdev->tx_work);
  742. return 0;
  743. }
  744. static int btmtksdio_probe(struct sdio_func *func,
  745. const struct sdio_device_id *id)
  746. {
  747. struct btmtksdio_dev *bdev;
  748. struct hci_dev *hdev;
  749. int err;
  750. bdev = devm_kzalloc(&func->dev, sizeof(*bdev), GFP_KERNEL);
  751. if (!bdev)
  752. return -ENOMEM;
  753. bdev->data = (void *)id->driver_data;
  754. if (!bdev->data)
  755. return -ENODEV;
  756. bdev->dev = &func->dev;
  757. bdev->func = func;
  758. INIT_WORK(&bdev->tx_work, btmtksdio_tx_work);
  759. skb_queue_head_init(&bdev->txq);
  760. /* Initialize and register HCI device */
  761. hdev = hci_alloc_dev();
  762. if (!hdev) {
  763. dev_err(&func->dev, "Can't allocate HCI device\n");
  764. return -ENOMEM;
  765. }
  766. bdev->hdev = hdev;
  767. hdev->bus = HCI_SDIO;
  768. hci_set_drvdata(hdev, bdev);
  769. hdev->open = btmtksdio_open;
  770. hdev->close = btmtksdio_close;
  771. hdev->flush = btmtksdio_flush;
  772. hdev->setup = btmtksdio_setup;
  773. hdev->shutdown = btmtksdio_shutdown;
  774. hdev->send = btmtksdio_send_frame;
  775. SET_HCIDEV_DEV(hdev, &func->dev);
  776. hdev->manufacturer = 70;
  777. set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
  778. sdio_set_drvdata(func, bdev);
  779. err = hci_register_dev(hdev);
  780. if (err < 0) {
  781. dev_err(&func->dev, "Can't register HCI device\n");
  782. hci_free_dev(hdev);
  783. return err;
  784. }
  785. /* pm_runtime_enable would be done after the firmware is being
  786. * downloaded because the core layer probably already enables
  787. * runtime PM for this func such as the case host->caps &
  788. * MMC_CAP_POWER_OFF_CARD.
  789. */
  790. if (pm_runtime_enabled(bdev->dev))
  791. pm_runtime_disable(bdev->dev);
  792. /* As explaination in drivers/mmc/core/sdio_bus.c tells us:
  793. * Unbound SDIO functions are always suspended.
  794. * During probe, the function is set active and the usage count
  795. * is incremented. If the driver supports runtime PM,
  796. * it should call pm_runtime_put_noidle() in its probe routine and
  797. * pm_runtime_get_noresume() in its remove routine.
  798. *
  799. * So, put a pm_runtime_put_noidle here !
  800. */
  801. pm_runtime_put_noidle(bdev->dev);
  802. return 0;
  803. }
  804. static void btmtksdio_remove(struct sdio_func *func)
  805. {
  806. struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
  807. struct hci_dev *hdev;
  808. if (!bdev)
  809. return;
  810. /* Be consistent the state in btmtksdio_probe */
  811. pm_runtime_get_noresume(bdev->dev);
  812. hdev = bdev->hdev;
  813. sdio_set_drvdata(func, NULL);
  814. hci_unregister_dev(hdev);
  815. hci_free_dev(hdev);
  816. }
  817. #ifdef CONFIG_PM
  818. static int btmtksdio_runtime_suspend(struct device *dev)
  819. {
  820. struct sdio_func *func = dev_to_sdio_func(dev);
  821. struct btmtksdio_dev *bdev;
  822. u32 status;
  823. int err;
  824. bdev = sdio_get_drvdata(func);
  825. if (!bdev)
  826. return 0;
  827. sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
  828. sdio_claim_host(bdev->func);
  829. sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err);
  830. if (err < 0)
  831. goto out;
  832. err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
  833. !(status & C_COM_DRV_OWN), 2000, 1000000);
  834. out:
  835. bt_dev_info(bdev->hdev, "status (%d) return ownership to device", err);
  836. sdio_release_host(bdev->func);
  837. return err;
  838. }
  839. static int btmtksdio_runtime_resume(struct device *dev)
  840. {
  841. struct sdio_func *func = dev_to_sdio_func(dev);
  842. struct btmtksdio_dev *bdev;
  843. u32 status;
  844. int err;
  845. bdev = sdio_get_drvdata(func);
  846. if (!bdev)
  847. return 0;
  848. sdio_claim_host(bdev->func);
  849. sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err);
  850. if (err < 0)
  851. goto out;
  852. err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
  853. status & C_COM_DRV_OWN, 2000, 1000000);
  854. out:
  855. bt_dev_info(bdev->hdev, "status (%d) get ownership from device", err);
  856. sdio_release_host(bdev->func);
  857. return err;
  858. }
  859. static UNIVERSAL_DEV_PM_OPS(btmtksdio_pm_ops, btmtksdio_runtime_suspend,
  860. btmtksdio_runtime_resume, NULL);
  861. #define BTMTKSDIO_PM_OPS (&btmtksdio_pm_ops)
  862. #else /* CONFIG_PM */
  863. #define BTMTKSDIO_PM_OPS NULL
  864. #endif /* CONFIG_PM */
  865. static struct sdio_driver btmtksdio_driver = {
  866. .name = "btmtksdio",
  867. .probe = btmtksdio_probe,
  868. .remove = btmtksdio_remove,
  869. .id_table = btmtksdio_table,
  870. .drv = {
  871. .owner = THIS_MODULE,
  872. .pm = BTMTKSDIO_PM_OPS,
  873. }
  874. };
  875. module_sdio_driver(btmtksdio_driver);
  876. module_param(enable_autosuspend, bool, 0644);
  877. MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default");
  878. MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
  879. MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION);
  880. MODULE_VERSION(VERSION);
  881. MODULE_LICENSE("GPL");
  882. MODULE_FIRMWARE(FIRMWARE_MT7663);
  883. MODULE_FIRMWARE(FIRMWARE_MT7668);