1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Marvell BT-over-SDIO driver: SDIO interface related functions.
4 *
5 * Copyright (C) 2009, Marvell International Ltd.
6 **/
7
8 #include <linux/firmware.h>
9 #include <linux/slab.h>
10 #include <linux/suspend.h>
11
12 #include <linux/mmc/sdio_ids.h>
13 #include <linux/mmc/sdio_func.h>
14 #include <linux/module.h>
15 #include <linux/devcoredump.h>
16
17 #include <net/bluetooth/bluetooth.h>
18 #include <net/bluetooth/hci_core.h>
19
20 #include "btmrvl_drv.h"
21 #include "btmrvl_sdio.h"
22
23 #define VERSION "1.0"
24
25 static struct memory_type_mapping mem_type_mapping_tbl[] = {
26 {"ITCM", NULL, 0, 0xF0},
27 {"DTCM", NULL, 0, 0xF1},
28 {"SQRAM", NULL, 0, 0xF2},
29 {"APU", NULL, 0, 0xF3},
30 {"CIU", NULL, 0, 0xF4},
31 {"ICU", NULL, 0, 0xF5},
32 {"MAC", NULL, 0, 0xF6},
33 {"EXT7", NULL, 0, 0xF7},
34 {"EXT8", NULL, 0, 0xF8},
35 {"EXT9", NULL, 0, 0xF9},
36 {"EXT10", NULL, 0, 0xFA},
37 {"EXT11", NULL, 0, 0xFB},
38 {"EXT12", NULL, 0, 0xFC},
39 {"EXT13", NULL, 0, 0xFD},
40 {"EXTLAST", NULL, 0, 0xFE},
41 };
42
43 static const struct of_device_id btmrvl_sdio_of_match_table[] __maybe_unused = {
44 { .compatible = "marvell,sd8897-bt" },
45 { .compatible = "marvell,sd8997-bt" },
46 { }
47 };
48
btmrvl_wake_irq_bt(int irq,void * priv)49 static irqreturn_t btmrvl_wake_irq_bt(int irq, void *priv)
50 {
51 struct btmrvl_sdio_card *card = priv;
52 struct device *dev = &card->func->dev;
53 struct btmrvl_plt_wake_cfg *cfg = card->plt_wake_cfg;
54
55 dev_info(dev, "wake by bt\n");
56 cfg->wake_by_bt = true;
57 disable_irq_nosync(irq);
58
59 pm_wakeup_event(dev, 0);
60 pm_system_wakeup();
61
62 return IRQ_HANDLED;
63 }
64
65 /* This function parses device tree node using mmc subnode devicetree API.
66 * The device node is saved in card->plt_of_node.
67 * If the device tree node exists and includes interrupts attributes, this
68 * function will request platform specific wakeup interrupt.
69 */
btmrvl_sdio_probe_of(struct device * dev,struct btmrvl_sdio_card * card)70 static int btmrvl_sdio_probe_of(struct device *dev,
71 struct btmrvl_sdio_card *card)
72 {
73 struct btmrvl_plt_wake_cfg *cfg;
74 int ret;
75
76 if (!dev->of_node ||
77 !of_match_node(btmrvl_sdio_of_match_table, dev->of_node)) {
78 dev_info(dev, "sdio device tree data not available\n");
79 return -1;
80 }
81
82 card->plt_of_node = dev->of_node;
83
84 card->plt_wake_cfg = devm_kzalloc(dev, sizeof(*card->plt_wake_cfg),
85 GFP_KERNEL);
86 cfg = card->plt_wake_cfg;
87 if (cfg && card->plt_of_node) {
88 cfg->irq_bt = irq_of_parse_and_map(card->plt_of_node, 0);
89 if (!cfg->irq_bt) {
90 dev_err(dev, "fail to parse irq_bt from device tree\n");
91 cfg->irq_bt = -1;
92 } else {
93 ret = devm_request_irq(dev, cfg->irq_bt,
94 btmrvl_wake_irq_bt,
95 IRQF_NO_AUTOEN, "bt_wake", card);
96 if (ret) {
97 dev_err(dev,
98 "Failed to request irq_bt %d (%d)\n",
99 cfg->irq_bt, ret);
100 }
101
102 /* Configure wakeup (enabled by default) */
103 ret = devm_device_init_wakeup(dev);
104 if (ret)
105 return dev_err_probe(dev, ret, "Failed to init wakeup\n");
106 }
107 }
108
109 return 0;
110 }
111
112 /* The btmrvl_sdio_remove() callback function is called
113 * when user removes this module from kernel space or ejects
114 * the card from the slot. The driver handles these 2 cases
115 * differently.
116 * If the user is removing the module, a MODULE_SHUTDOWN_REQ
117 * command is sent to firmware and interrupt will be disabled.
118 * If the card is removed, there is no need to send command
119 * or disable interrupt.
120 *
121 * The variable 'user_rmmod' is used to distinguish these two
122 * scenarios. This flag is initialized as FALSE in case the card
123 * is removed, and will be set to TRUE for module removal when
124 * module_exit function is called.
125 */
126 static u8 user_rmmod;
127 static u8 sdio_ireg;
128
129 static const struct btmrvl_sdio_card_reg btmrvl_reg_8688 = {
130 .cfg = 0x03,
131 .host_int_mask = 0x04,
132 .host_intstatus = 0x05,
133 .card_status = 0x20,
134 .sq_read_base_addr_a0 = 0x10,
135 .sq_read_base_addr_a1 = 0x11,
136 .card_fw_status0 = 0x40,
137 .card_fw_status1 = 0x41,
138 .card_rx_len = 0x42,
139 .card_rx_unit = 0x43,
140 .io_port_0 = 0x00,
141 .io_port_1 = 0x01,
142 .io_port_2 = 0x02,
143 .int_read_to_clear = false,
144 };
145 static const struct btmrvl_sdio_card_reg btmrvl_reg_87xx = {
146 .cfg = 0x00,
147 .host_int_mask = 0x02,
148 .host_intstatus = 0x03,
149 .card_status = 0x30,
150 .sq_read_base_addr_a0 = 0x40,
151 .sq_read_base_addr_a1 = 0x41,
152 .card_revision = 0x5c,
153 .card_fw_status0 = 0x60,
154 .card_fw_status1 = 0x61,
155 .card_rx_len = 0x62,
156 .card_rx_unit = 0x63,
157 .io_port_0 = 0x78,
158 .io_port_1 = 0x79,
159 .io_port_2 = 0x7a,
160 .int_read_to_clear = false,
161 };
162
163 static const struct btmrvl_sdio_card_reg btmrvl_reg_8887 = {
164 .cfg = 0x00,
165 .host_int_mask = 0x08,
166 .host_intstatus = 0x0C,
167 .card_status = 0x5C,
168 .sq_read_base_addr_a0 = 0x6C,
169 .sq_read_base_addr_a1 = 0x6D,
170 .card_revision = 0xC8,
171 .card_fw_status0 = 0x88,
172 .card_fw_status1 = 0x89,
173 .card_rx_len = 0x8A,
174 .card_rx_unit = 0x8B,
175 .io_port_0 = 0xE4,
176 .io_port_1 = 0xE5,
177 .io_port_2 = 0xE6,
178 .int_read_to_clear = true,
179 .host_int_rsr = 0x04,
180 .card_misc_cfg = 0xD8,
181 };
182
183 static const struct btmrvl_sdio_card_reg btmrvl_reg_8897 = {
184 .cfg = 0x00,
185 .host_int_mask = 0x02,
186 .host_intstatus = 0x03,
187 .card_status = 0x50,
188 .sq_read_base_addr_a0 = 0x60,
189 .sq_read_base_addr_a1 = 0x61,
190 .card_revision = 0xbc,
191 .card_fw_status0 = 0xc0,
192 .card_fw_status1 = 0xc1,
193 .card_rx_len = 0xc2,
194 .card_rx_unit = 0xc3,
195 .io_port_0 = 0xd8,
196 .io_port_1 = 0xd9,
197 .io_port_2 = 0xda,
198 .int_read_to_clear = true,
199 .host_int_rsr = 0x01,
200 .card_misc_cfg = 0xcc,
201 .fw_dump_ctrl = 0xe2,
202 .fw_dump_start = 0xe3,
203 .fw_dump_end = 0xea,
204 };
205
206 static const struct btmrvl_sdio_card_reg btmrvl_reg_89xx = {
207 .cfg = 0x00,
208 .host_int_mask = 0x08,
209 .host_intstatus = 0x0c,
210 .card_status = 0x5c,
211 .sq_read_base_addr_a0 = 0xf8,
212 .sq_read_base_addr_a1 = 0xf9,
213 .card_revision = 0xc8,
214 .card_fw_status0 = 0xe8,
215 .card_fw_status1 = 0xe9,
216 .card_rx_len = 0xea,
217 .card_rx_unit = 0xeb,
218 .io_port_0 = 0xe4,
219 .io_port_1 = 0xe5,
220 .io_port_2 = 0xe6,
221 .int_read_to_clear = true,
222 .host_int_rsr = 0x04,
223 .card_misc_cfg = 0xd8,
224 .fw_dump_ctrl = 0xf0,
225 .fw_dump_start = 0xf1,
226 .fw_dump_end = 0xf8,
227 };
228
229 static const struct btmrvl_sdio_device btmrvl_sdio_sd8688 = {
230 .helper = "mrvl/sd8688_helper.bin",
231 .firmware = "mrvl/sd8688.bin",
232 .reg = &btmrvl_reg_8688,
233 .support_pscan_win_report = false,
234 .sd_blksz_fw_dl = 64,
235 .supports_fw_dump = false,
236 };
237
238 static const struct btmrvl_sdio_device btmrvl_sdio_sd8787 = {
239 .helper = NULL,
240 .firmware = "mrvl/sd8787_uapsta.bin",
241 .reg = &btmrvl_reg_87xx,
242 .support_pscan_win_report = false,
243 .sd_blksz_fw_dl = 256,
244 .supports_fw_dump = false,
245 };
246
247 static const struct btmrvl_sdio_device btmrvl_sdio_sd8797 = {
248 .helper = NULL,
249 .firmware = "mrvl/sd8797_uapsta.bin",
250 .reg = &btmrvl_reg_87xx,
251 .support_pscan_win_report = false,
252 .sd_blksz_fw_dl = 256,
253 .supports_fw_dump = false,
254 };
255
256 static const struct btmrvl_sdio_device btmrvl_sdio_sd8887 = {
257 .helper = NULL,
258 .firmware = "mrvl/sd8887_uapsta.bin",
259 .reg = &btmrvl_reg_8887,
260 .support_pscan_win_report = true,
261 .sd_blksz_fw_dl = 256,
262 .supports_fw_dump = false,
263 };
264
265 static const struct btmrvl_sdio_device btmrvl_sdio_sd8897 = {
266 .helper = NULL,
267 .firmware = "mrvl/sd8897_uapsta.bin",
268 .reg = &btmrvl_reg_8897,
269 .support_pscan_win_report = true,
270 .sd_blksz_fw_dl = 256,
271 .supports_fw_dump = true,
272 };
273
274 static const struct btmrvl_sdio_device btmrvl_sdio_sd8977 = {
275 .helper = NULL,
276 .firmware = "mrvl/sdsd8977_combo_v2.bin",
277 .reg = &btmrvl_reg_89xx,
278 .support_pscan_win_report = true,
279 .sd_blksz_fw_dl = 256,
280 .supports_fw_dump = true,
281 };
282
283 static const struct btmrvl_sdio_device btmrvl_sdio_sd8987 = {
284 .helper = NULL,
285 .firmware = "mrvl/sd8987_uapsta.bin",
286 .reg = &btmrvl_reg_89xx,
287 .support_pscan_win_report = true,
288 .sd_blksz_fw_dl = 256,
289 .supports_fw_dump = true,
290 };
291
292 static const struct btmrvl_sdio_device btmrvl_sdio_sd8997 = {
293 .helper = NULL,
294 .firmware = "mrvl/sdsd8997_combo_v4.bin",
295 .reg = &btmrvl_reg_89xx,
296 .support_pscan_win_report = true,
297 .sd_blksz_fw_dl = 256,
298 .supports_fw_dump = true,
299 };
300
301 static const struct sdio_device_id btmrvl_sdio_ids[] = {
302 /* Marvell SD8688 Bluetooth device */
303 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8688_BT),
304 .driver_data = (unsigned long)&btmrvl_sdio_sd8688 },
305 /* Marvell SD8787 Bluetooth device */
306 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8787_BT),
307 .driver_data = (unsigned long)&btmrvl_sdio_sd8787 },
308 /* Marvell SD8787 Bluetooth AMP device */
309 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8787_BT_AMP),
310 .driver_data = (unsigned long)&btmrvl_sdio_sd8787 },
311 /* Marvell SD8797 Bluetooth device */
312 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8797_BT),
313 .driver_data = (unsigned long)&btmrvl_sdio_sd8797 },
314 /* Marvell SD8887 Bluetooth device */
315 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8887_BT),
316 .driver_data = (unsigned long)&btmrvl_sdio_sd8887 },
317 /* Marvell SD8897 Bluetooth device */
318 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8897_BT),
319 .driver_data = (unsigned long)&btmrvl_sdio_sd8897 },
320 /* Marvell SD8977 Bluetooth device */
321 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8977_BT),
322 .driver_data = (unsigned long)&btmrvl_sdio_sd8977 },
323 /* Marvell SD8987 Bluetooth device */
324 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8987_BT),
325 .driver_data = (unsigned long)&btmrvl_sdio_sd8987 },
326 /* Marvell SD8997 Bluetooth device */
327 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8997_BT),
328 .driver_data = (unsigned long)&btmrvl_sdio_sd8997 },
329
330 { } /* Terminating entry */
331 };
332
333 MODULE_DEVICE_TABLE(sdio, btmrvl_sdio_ids);
334
btmrvl_sdio_get_rx_unit(struct btmrvl_sdio_card * card)335 static int btmrvl_sdio_get_rx_unit(struct btmrvl_sdio_card *card)
336 {
337 u8 reg;
338 int ret;
339
340 reg = sdio_readb(card->func, card->reg->card_rx_unit, &ret);
341 if (!ret)
342 card->rx_unit = reg;
343
344 return ret;
345 }
346
btmrvl_sdio_read_fw_status(struct btmrvl_sdio_card * card,u16 * dat)347 static int btmrvl_sdio_read_fw_status(struct btmrvl_sdio_card *card, u16 *dat)
348 {
349 u8 fws0, fws1;
350 int ret;
351
352 *dat = 0;
353
354 fws0 = sdio_readb(card->func, card->reg->card_fw_status0, &ret);
355 if (ret)
356 return -EIO;
357
358 fws1 = sdio_readb(card->func, card->reg->card_fw_status1, &ret);
359 if (ret)
360 return -EIO;
361
362 *dat = (((u16) fws1) << 8) | fws0;
363
364 return 0;
365 }
366
btmrvl_sdio_read_rx_len(struct btmrvl_sdio_card * card,u16 * dat)367 static int btmrvl_sdio_read_rx_len(struct btmrvl_sdio_card *card, u16 *dat)
368 {
369 u8 reg;
370 int ret;
371
372 reg = sdio_readb(card->func, card->reg->card_rx_len, &ret);
373 if (!ret)
374 *dat = (u16) reg << card->rx_unit;
375
376 return ret;
377 }
378
btmrvl_sdio_enable_host_int_mask(struct btmrvl_sdio_card * card,u8 mask)379 static int btmrvl_sdio_enable_host_int_mask(struct btmrvl_sdio_card *card,
380 u8 mask)
381 {
382 int ret;
383
384 sdio_writeb(card->func, mask, card->reg->host_int_mask, &ret);
385 if (ret) {
386 BT_ERR("Unable to enable the host interrupt!");
387 ret = -EIO;
388 }
389
390 return ret;
391 }
392
btmrvl_sdio_disable_host_int_mask(struct btmrvl_sdio_card * card,u8 mask)393 static int btmrvl_sdio_disable_host_int_mask(struct btmrvl_sdio_card *card,
394 u8 mask)
395 {
396 u8 host_int_mask;
397 int ret;
398
399 host_int_mask = sdio_readb(card->func, card->reg->host_int_mask, &ret);
400 if (ret)
401 return -EIO;
402
403 host_int_mask &= ~mask;
404
405 sdio_writeb(card->func, host_int_mask, card->reg->host_int_mask, &ret);
406 if (ret < 0) {
407 BT_ERR("Unable to disable the host interrupt!");
408 return -EIO;
409 }
410
411 return 0;
412 }
413
btmrvl_sdio_poll_card_status(struct btmrvl_sdio_card * card,u8 bits)414 static int btmrvl_sdio_poll_card_status(struct btmrvl_sdio_card *card, u8 bits)
415 {
416 unsigned int tries;
417 u8 status;
418 int ret;
419
420 for (tries = 0; tries < MAX_POLL_TRIES * 1000; tries++) {
421 status = sdio_readb(card->func, card->reg->card_status, &ret);
422 if (ret)
423 goto failed;
424 if ((status & bits) == bits)
425 return ret;
426
427 udelay(1);
428 }
429
430 ret = -ETIMEDOUT;
431
432 failed:
433 BT_ERR("FAILED! ret=%d", ret);
434
435 return ret;
436 }
437
btmrvl_sdio_verify_fw_download(struct btmrvl_sdio_card * card,int pollnum)438 static int btmrvl_sdio_verify_fw_download(struct btmrvl_sdio_card *card,
439 int pollnum)
440 {
441 u16 firmwarestat;
442 int tries, ret;
443
444 /* Wait for firmware to become ready */
445 for (tries = 0; tries < pollnum; tries++) {
446 sdio_claim_host(card->func);
447 ret = btmrvl_sdio_read_fw_status(card, &firmwarestat);
448 sdio_release_host(card->func);
449 if (ret < 0)
450 continue;
451
452 if (firmwarestat == FIRMWARE_READY)
453 return 0;
454
455 msleep(100);
456 }
457
458 return -ETIMEDOUT;
459 }
460
btmrvl_sdio_download_helper(struct btmrvl_sdio_card * card)461 static int btmrvl_sdio_download_helper(struct btmrvl_sdio_card *card)
462 {
463 const struct firmware *fw_helper = NULL;
464 const u8 *helper = NULL;
465 int ret;
466 void *tmphlprbuf = NULL;
467 int tmphlprbufsz, hlprblknow, helperlen;
468 u8 *helperbuf;
469 u32 tx_len;
470
471 ret = request_firmware(&fw_helper, card->helper,
472 &card->func->dev);
473 if ((ret < 0) || !fw_helper) {
474 BT_ERR("request_firmware(helper) failed, error code = %d",
475 ret);
476 ret = -ENOENT;
477 goto done;
478 }
479
480 helper = fw_helper->data;
481 helperlen = fw_helper->size;
482
483 BT_DBG("Downloading helper image (%d bytes), block size %d bytes",
484 helperlen, SDIO_BLOCK_SIZE);
485
486 tmphlprbufsz = ALIGN_SZ(BTM_UPLD_SIZE, BTSDIO_DMA_ALIGN);
487
488 tmphlprbuf = kzalloc(tmphlprbufsz, GFP_KERNEL);
489 if (!tmphlprbuf) {
490 BT_ERR("Unable to allocate buffer for helper."
491 " Terminating download");
492 ret = -ENOMEM;
493 goto done;
494 }
495
496 helperbuf = (u8 *) ALIGN_ADDR(tmphlprbuf, BTSDIO_DMA_ALIGN);
497
498 /* Perform helper data transfer */
499 tx_len = (FIRMWARE_TRANSFER_NBLOCK * SDIO_BLOCK_SIZE)
500 - SDIO_HEADER_LEN;
501 hlprblknow = 0;
502
503 do {
504 ret = btmrvl_sdio_poll_card_status(card,
505 CARD_IO_READY | DN_LD_CARD_RDY);
506 if (ret < 0) {
507 BT_ERR("Helper download poll status timeout @ %d",
508 hlprblknow);
509 goto done;
510 }
511
512 /* Check if there is more data? */
513 if (hlprblknow >= helperlen)
514 break;
515
516 if (helperlen - hlprblknow < tx_len)
517 tx_len = helperlen - hlprblknow;
518
519 /* Little-endian */
520 helperbuf[0] = ((tx_len & 0x000000ff) >> 0);
521 helperbuf[1] = ((tx_len & 0x0000ff00) >> 8);
522 helperbuf[2] = ((tx_len & 0x00ff0000) >> 16);
523 helperbuf[3] = ((tx_len & 0xff000000) >> 24);
524
525 memcpy(&helperbuf[SDIO_HEADER_LEN], &helper[hlprblknow],
526 tx_len);
527
528 /* Now send the data */
529 ret = sdio_writesb(card->func, card->ioport, helperbuf,
530 FIRMWARE_TRANSFER_NBLOCK * SDIO_BLOCK_SIZE);
531 if (ret < 0) {
532 BT_ERR("IO error during helper download @ %d",
533 hlprblknow);
534 goto done;
535 }
536
537 hlprblknow += tx_len;
538 } while (true);
539
540 BT_DBG("Transferring helper image EOF block");
541
542 memset(helperbuf, 0x0, SDIO_BLOCK_SIZE);
543
544 ret = sdio_writesb(card->func, card->ioport, helperbuf,
545 SDIO_BLOCK_SIZE);
546 if (ret < 0) {
547 BT_ERR("IO error in writing helper image EOF block");
548 goto done;
549 }
550
551 ret = 0;
552
553 done:
554 kfree(tmphlprbuf);
555 release_firmware(fw_helper);
556 return ret;
557 }
558
btmrvl_sdio_download_fw_w_helper(struct btmrvl_sdio_card * card)559 static int btmrvl_sdio_download_fw_w_helper(struct btmrvl_sdio_card *card)
560 {
561 const struct firmware *fw_firmware = NULL;
562 const u8 *firmware = NULL;
563 int firmwarelen, tmpfwbufsz, ret;
564 unsigned int tries, offset;
565 u8 base0, base1;
566 void *tmpfwbuf = NULL;
567 u8 *fwbuf;
568 u16 len, blksz_dl = card->sd_blksz_fw_dl;
569 int txlen = 0, tx_blocks = 0, count = 0;
570
571 ret = request_firmware(&fw_firmware, card->firmware,
572 &card->func->dev);
573 if ((ret < 0) || !fw_firmware) {
574 BT_ERR("request_firmware(firmware) failed, error code = %d",
575 ret);
576 ret = -ENOENT;
577 goto done;
578 }
579
580 firmware = fw_firmware->data;
581 firmwarelen = fw_firmware->size;
582
583 BT_DBG("Downloading FW image (%d bytes)", firmwarelen);
584
585 tmpfwbufsz = ALIGN_SZ(BTM_UPLD_SIZE, BTSDIO_DMA_ALIGN);
586 tmpfwbuf = kzalloc(tmpfwbufsz, GFP_KERNEL);
587 if (!tmpfwbuf) {
588 BT_ERR("Unable to allocate buffer for firmware."
589 " Terminating download");
590 ret = -ENOMEM;
591 goto done;
592 }
593
594 /* Ensure aligned firmware buffer */
595 fwbuf = (u8 *) ALIGN_ADDR(tmpfwbuf, BTSDIO_DMA_ALIGN);
596
597 /* Perform firmware data transfer */
598 offset = 0;
599 do {
600 ret = btmrvl_sdio_poll_card_status(card,
601 CARD_IO_READY | DN_LD_CARD_RDY);
602 if (ret < 0) {
603 BT_ERR("FW download with helper poll status"
604 " timeout @ %d", offset);
605 goto done;
606 }
607
608 /* Check if there is more data ? */
609 if (offset >= firmwarelen)
610 break;
611
612 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
613 base0 = sdio_readb(card->func,
614 card->reg->sq_read_base_addr_a0, &ret);
615 if (ret) {
616 BT_ERR("BASE0 register read failed:"
617 " base0 = 0x%04X(%d)."
618 " Terminating download",
619 base0, base0);
620 ret = -EIO;
621 goto done;
622 }
623 base1 = sdio_readb(card->func,
624 card->reg->sq_read_base_addr_a1, &ret);
625 if (ret) {
626 BT_ERR("BASE1 register read failed:"
627 " base1 = 0x%04X(%d)."
628 " Terminating download",
629 base1, base1);
630 ret = -EIO;
631 goto done;
632 }
633
634 len = (((u16) base1) << 8) | base0;
635 if (len)
636 break;
637
638 udelay(10);
639 }
640
641 if (!len)
642 break;
643 else if (len > BTM_UPLD_SIZE) {
644 BT_ERR("FW download failure @%d, invalid length %d",
645 offset, len);
646 ret = -EINVAL;
647 goto done;
648 }
649
650 txlen = len;
651
652 if (len & BIT(0)) {
653 count++;
654 if (count > MAX_WRITE_IOMEM_RETRY) {
655 BT_ERR("FW download failure @%d, "
656 "over max retry count", offset);
657 ret = -EIO;
658 goto done;
659 }
660 BT_ERR("FW CRC error indicated by the helper: "
661 "len = 0x%04X, txlen = %d", len, txlen);
662 len &= ~BIT(0);
663 /* Set txlen to 0 so as to resend from same offset */
664 txlen = 0;
665 } else {
666 count = 0;
667
668 /* Last block ? */
669 if (firmwarelen - offset < txlen)
670 txlen = firmwarelen - offset;
671
672 tx_blocks = DIV_ROUND_UP(txlen, blksz_dl);
673
674 memcpy(fwbuf, &firmware[offset], txlen);
675 }
676
677 ret = sdio_writesb(card->func, card->ioport, fwbuf,
678 tx_blocks * blksz_dl);
679
680 if (ret < 0) {
681 BT_ERR("FW download, writesb(%d) failed @%d",
682 count, offset);
683 sdio_writeb(card->func, HOST_CMD53_FIN,
684 card->reg->cfg, &ret);
685 if (ret)
686 BT_ERR("writeb failed (CFG)");
687 }
688
689 offset += txlen;
690 } while (true);
691
692 BT_INFO("FW download over, size %d bytes", offset);
693
694 ret = 0;
695
696 done:
697 kfree(tmpfwbuf);
698 release_firmware(fw_firmware);
699 return ret;
700 }
701
btmrvl_sdio_card_to_host(struct btmrvl_private * priv)702 static int btmrvl_sdio_card_to_host(struct btmrvl_private *priv)
703 {
704 u16 buf_len = 0;
705 int ret, num_blocks, blksz;
706 struct sk_buff *skb = NULL;
707 u32 type;
708 u8 *payload;
709 struct hci_dev *hdev = priv->btmrvl_dev.hcidev;
710 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
711
712 if (!card || !card->func) {
713 BT_ERR("card or function is NULL!");
714 ret = -EINVAL;
715 goto exit;
716 }
717
718 /* Read the length of data to be transferred */
719 ret = btmrvl_sdio_read_rx_len(card, &buf_len);
720 if (ret < 0) {
721 BT_ERR("read rx_len failed");
722 ret = -EIO;
723 goto exit;
724 }
725
726 blksz = SDIO_BLOCK_SIZE;
727 num_blocks = DIV_ROUND_UP(buf_len, blksz);
728
729 if (buf_len <= SDIO_HEADER_LEN
730 || (num_blocks * blksz) > ALLOC_BUF_SIZE) {
731 BT_ERR("invalid packet length: %d", buf_len);
732 ret = -EINVAL;
733 goto exit;
734 }
735
736 /* Allocate buffer */
737 skb = bt_skb_alloc(num_blocks * blksz + BTSDIO_DMA_ALIGN, GFP_KERNEL);
738 if (!skb) {
739 BT_ERR("No free skb");
740 ret = -ENOMEM;
741 goto exit;
742 }
743
744 if ((unsigned long) skb->data & (BTSDIO_DMA_ALIGN - 1)) {
745 skb_put(skb, (unsigned long) skb->data &
746 (BTSDIO_DMA_ALIGN - 1));
747 skb_pull(skb, (unsigned long) skb->data &
748 (BTSDIO_DMA_ALIGN - 1));
749 }
750
751 payload = skb->data;
752
753 ret = sdio_readsb(card->func, payload, card->ioport,
754 num_blocks * blksz);
755 if (ret < 0) {
756 BT_ERR("readsb failed: %d", ret);
757 ret = -EIO;
758 goto exit;
759 }
760
761 /* This is SDIO specific header length: byte[2][1][0], type: byte[3]
762 * (HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor)
763 */
764
765 buf_len = payload[0];
766 buf_len |= payload[1] << 8;
767 buf_len |= payload[2] << 16;
768
769 if (buf_len > blksz * num_blocks) {
770 BT_ERR("Skip incorrect packet: hdrlen %d buffer %d",
771 buf_len, blksz * num_blocks);
772 ret = -EIO;
773 goto exit;
774 }
775
776 type = payload[3];
777
778 switch (type) {
779 case HCI_ACLDATA_PKT:
780 case HCI_SCODATA_PKT:
781 case HCI_EVENT_PKT:
782 hci_skb_pkt_type(skb) = type;
783 skb_put(skb, buf_len);
784 skb_pull(skb, SDIO_HEADER_LEN);
785
786 if (type == HCI_EVENT_PKT) {
787 if (btmrvl_check_evtpkt(priv, skb))
788 hci_recv_frame(hdev, skb);
789 } else {
790 hci_recv_frame(hdev, skb);
791 }
792
793 hdev->stat.byte_rx += buf_len;
794 break;
795
796 case MRVL_VENDOR_PKT:
797 hci_skb_pkt_type(skb) = HCI_VENDOR_PKT;
798 skb_put(skb, buf_len);
799 skb_pull(skb, SDIO_HEADER_LEN);
800
801 if (btmrvl_process_event(priv, skb))
802 hci_recv_frame(hdev, skb);
803
804 hdev->stat.byte_rx += buf_len;
805 break;
806
807 default:
808 BT_ERR("Unknown packet type:%d", type);
809 BT_ERR("hex: %*ph", blksz * num_blocks, payload);
810
811 kfree_skb(skb);
812 skb = NULL;
813 break;
814 }
815
816 exit:
817 if (ret) {
818 hdev->stat.err_rx++;
819 kfree_skb(skb);
820 }
821
822 return ret;
823 }
824
btmrvl_sdio_process_int_status(struct btmrvl_private * priv)825 static int btmrvl_sdio_process_int_status(struct btmrvl_private *priv)
826 {
827 ulong flags;
828 u8 ireg;
829 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
830
831 spin_lock_irqsave(&priv->driver_lock, flags);
832 ireg = sdio_ireg;
833 sdio_ireg = 0;
834 spin_unlock_irqrestore(&priv->driver_lock, flags);
835
836 sdio_claim_host(card->func);
837 if (ireg & DN_LD_HOST_INT_STATUS) {
838 if (priv->btmrvl_dev.tx_dnld_rdy)
839 BT_DBG("tx_done already received: "
840 " int_status=0x%x", ireg);
841 else
842 priv->btmrvl_dev.tx_dnld_rdy = true;
843 }
844
845 if (ireg & UP_LD_HOST_INT_STATUS)
846 btmrvl_sdio_card_to_host(priv);
847
848 sdio_release_host(card->func);
849
850 return 0;
851 }
852
btmrvl_sdio_read_to_clear(struct btmrvl_sdio_card * card,u8 * ireg)853 static int btmrvl_sdio_read_to_clear(struct btmrvl_sdio_card *card, u8 *ireg)
854 {
855 struct btmrvl_adapter *adapter = card->priv->adapter;
856 int ret;
857
858 ret = sdio_readsb(card->func, adapter->hw_regs, 0, SDIO_BLOCK_SIZE);
859 if (ret) {
860 BT_ERR("sdio_readsb: read int hw_regs failed: %d", ret);
861 return ret;
862 }
863
864 *ireg = adapter->hw_regs[card->reg->host_intstatus];
865 BT_DBG("hw_regs[%#x]=%#x", card->reg->host_intstatus, *ireg);
866
867 return 0;
868 }
869
btmrvl_sdio_write_to_clear(struct btmrvl_sdio_card * card,u8 * ireg)870 static int btmrvl_sdio_write_to_clear(struct btmrvl_sdio_card *card, u8 *ireg)
871 {
872 int ret;
873
874 *ireg = sdio_readb(card->func, card->reg->host_intstatus, &ret);
875 if (ret) {
876 BT_ERR("sdio_readb: read int status failed: %d", ret);
877 return ret;
878 }
879
880 if (*ireg) {
881 /*
882 * DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS
883 * Clear the interrupt status register and re-enable the
884 * interrupt.
885 */
886 BT_DBG("int_status = 0x%x", *ireg);
887
888 sdio_writeb(card->func, ~(*ireg) & (DN_LD_HOST_INT_STATUS |
889 UP_LD_HOST_INT_STATUS),
890 card->reg->host_intstatus, &ret);
891 if (ret) {
892 BT_ERR("sdio_writeb: clear int status failed: %d", ret);
893 return ret;
894 }
895 }
896
897 return 0;
898 }
899
btmrvl_sdio_interrupt(struct sdio_func * func)900 static void btmrvl_sdio_interrupt(struct sdio_func *func)
901 {
902 struct btmrvl_private *priv;
903 struct btmrvl_sdio_card *card;
904 ulong flags;
905 u8 ireg = 0;
906 int ret;
907
908 card = sdio_get_drvdata(func);
909 if (!card || !card->priv) {
910 BT_ERR("sbi_interrupt(%p) card or priv is NULL, card=%p",
911 func, card);
912 return;
913 }
914
915 priv = card->priv;
916
917 if (priv->surprise_removed)
918 return;
919
920 if (card->reg->int_read_to_clear)
921 ret = btmrvl_sdio_read_to_clear(card, &ireg);
922 else
923 ret = btmrvl_sdio_write_to_clear(card, &ireg);
924
925 if (ret)
926 return;
927
928 spin_lock_irqsave(&priv->driver_lock, flags);
929 sdio_ireg |= ireg;
930 spin_unlock_irqrestore(&priv->driver_lock, flags);
931
932 btmrvl_interrupt(priv);
933 }
934
btmrvl_sdio_register_dev(struct btmrvl_sdio_card * card)935 static int btmrvl_sdio_register_dev(struct btmrvl_sdio_card *card)
936 {
937 struct sdio_func *func;
938 u8 reg;
939 int ret;
940
941 if (!card || !card->func) {
942 BT_ERR("Error: card or function is NULL!");
943 ret = -EINVAL;
944 goto failed;
945 }
946
947 func = card->func;
948
949 sdio_claim_host(func);
950
951 ret = sdio_enable_func(func);
952 if (ret) {
953 BT_ERR("sdio_enable_func() failed: ret=%d", ret);
954 ret = -EIO;
955 goto release_host;
956 }
957
958 ret = sdio_claim_irq(func, btmrvl_sdio_interrupt);
959 if (ret) {
960 BT_ERR("sdio_claim_irq failed: ret=%d", ret);
961 ret = -EIO;
962 goto disable_func;
963 }
964
965 ret = sdio_set_block_size(card->func, SDIO_BLOCK_SIZE);
966 if (ret) {
967 BT_ERR("cannot set SDIO block size");
968 ret = -EIO;
969 goto release_irq;
970 }
971
972 reg = sdio_readb(func, card->reg->io_port_0, &ret);
973 if (ret < 0) {
974 ret = -EIO;
975 goto release_irq;
976 }
977
978 card->ioport = reg;
979
980 reg = sdio_readb(func, card->reg->io_port_1, &ret);
981 if (ret < 0) {
982 ret = -EIO;
983 goto release_irq;
984 }
985
986 card->ioport |= (reg << 8);
987
988 reg = sdio_readb(func, card->reg->io_port_2, &ret);
989 if (ret < 0) {
990 ret = -EIO;
991 goto release_irq;
992 }
993
994 card->ioport |= (reg << 16);
995
996 BT_DBG("SDIO FUNC%d IO port: 0x%x", func->num, card->ioport);
997
998 if (card->reg->int_read_to_clear) {
999 reg = sdio_readb(func, card->reg->host_int_rsr, &ret);
1000 if (ret < 0) {
1001 ret = -EIO;
1002 goto release_irq;
1003 }
1004 sdio_writeb(func, reg | 0x3f, card->reg->host_int_rsr, &ret);
1005 if (ret < 0) {
1006 ret = -EIO;
1007 goto release_irq;
1008 }
1009
1010 reg = sdio_readb(func, card->reg->card_misc_cfg, &ret);
1011 if (ret < 0) {
1012 ret = -EIO;
1013 goto release_irq;
1014 }
1015 sdio_writeb(func, reg | 0x10, card->reg->card_misc_cfg, &ret);
1016 if (ret < 0) {
1017 ret = -EIO;
1018 goto release_irq;
1019 }
1020 }
1021
1022 sdio_set_drvdata(func, card);
1023
1024 sdio_release_host(func);
1025
1026 return 0;
1027
1028 release_irq:
1029 sdio_release_irq(func);
1030
1031 disable_func:
1032 sdio_disable_func(func);
1033
1034 release_host:
1035 sdio_release_host(func);
1036
1037 failed:
1038 return ret;
1039 }
1040
btmrvl_sdio_unregister_dev(struct btmrvl_sdio_card * card)1041 static int btmrvl_sdio_unregister_dev(struct btmrvl_sdio_card *card)
1042 {
1043 if (card && card->func) {
1044 sdio_claim_host(card->func);
1045 sdio_release_irq(card->func);
1046 sdio_disable_func(card->func);
1047 sdio_release_host(card->func);
1048 sdio_set_drvdata(card->func, NULL);
1049 }
1050
1051 return 0;
1052 }
1053
btmrvl_sdio_enable_host_int(struct btmrvl_sdio_card * card)1054 static int btmrvl_sdio_enable_host_int(struct btmrvl_sdio_card *card)
1055 {
1056 int ret;
1057
1058 if (!card || !card->func)
1059 return -EINVAL;
1060
1061 sdio_claim_host(card->func);
1062
1063 ret = btmrvl_sdio_enable_host_int_mask(card, HIM_ENABLE);
1064
1065 btmrvl_sdio_get_rx_unit(card);
1066
1067 sdio_release_host(card->func);
1068
1069 return ret;
1070 }
1071
btmrvl_sdio_disable_host_int(struct btmrvl_sdio_card * card)1072 static int btmrvl_sdio_disable_host_int(struct btmrvl_sdio_card *card)
1073 {
1074 int ret;
1075
1076 if (!card || !card->func)
1077 return -EINVAL;
1078
1079 sdio_claim_host(card->func);
1080
1081 ret = btmrvl_sdio_disable_host_int_mask(card, HIM_DISABLE);
1082
1083 sdio_release_host(card->func);
1084
1085 return ret;
1086 }
1087
btmrvl_sdio_host_to_card(struct btmrvl_private * priv,u8 * payload,u16 nb)1088 static int btmrvl_sdio_host_to_card(struct btmrvl_private *priv,
1089 u8 *payload, u16 nb)
1090 {
1091 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
1092 int ret = 0;
1093 int blksz;
1094 int i = 0;
1095 u8 *buf = NULL;
1096 void *tmpbuf = NULL;
1097 int tmpbufsz;
1098
1099 if (!card || !card->func) {
1100 BT_ERR("card or function is NULL!");
1101 return -EINVAL;
1102 }
1103
1104 blksz = DIV_ROUND_UP(nb, SDIO_BLOCK_SIZE) * SDIO_BLOCK_SIZE;
1105
1106 buf = payload;
1107 if ((unsigned long) payload & (BTSDIO_DMA_ALIGN - 1) ||
1108 nb < blksz) {
1109 tmpbufsz = ALIGN_SZ(blksz, BTSDIO_DMA_ALIGN) +
1110 BTSDIO_DMA_ALIGN;
1111 tmpbuf = kzalloc(tmpbufsz, GFP_KERNEL);
1112 if (!tmpbuf)
1113 return -ENOMEM;
1114 buf = (u8 *) ALIGN_ADDR(tmpbuf, BTSDIO_DMA_ALIGN);
1115 memcpy(buf, payload, nb);
1116 }
1117
1118 sdio_claim_host(card->func);
1119
1120 do {
1121 /* Transfer data to card */
1122 ret = sdio_writesb(card->func, card->ioport, buf,
1123 blksz);
1124 if (ret < 0) {
1125 i++;
1126 BT_ERR("i=%d writesb failed: %d", i, ret);
1127 BT_ERR("hex: %*ph", nb, payload);
1128 ret = -EIO;
1129 if (i > MAX_WRITE_IOMEM_RETRY)
1130 goto exit;
1131 }
1132 } while (ret);
1133
1134 priv->btmrvl_dev.tx_dnld_rdy = false;
1135
1136 exit:
1137 sdio_release_host(card->func);
1138 kfree(tmpbuf);
1139
1140 return ret;
1141 }
1142
btmrvl_sdio_download_fw(struct btmrvl_sdio_card * card)1143 static int btmrvl_sdio_download_fw(struct btmrvl_sdio_card *card)
1144 {
1145 int ret;
1146 u8 fws0;
1147 int pollnum = MAX_POLL_TRIES;
1148
1149 if (!card || !card->func) {
1150 BT_ERR("card or function is NULL!");
1151 return -EINVAL;
1152 }
1153
1154 if (!btmrvl_sdio_verify_fw_download(card, 1)) {
1155 BT_DBG("Firmware already downloaded!");
1156 return 0;
1157 }
1158
1159 sdio_claim_host(card->func);
1160
1161 /* Check if other function driver is downloading the firmware */
1162 fws0 = sdio_readb(card->func, card->reg->card_fw_status0, &ret);
1163 if (ret) {
1164 BT_ERR("Failed to read FW downloading status!");
1165 ret = -EIO;
1166 goto done;
1167 }
1168 if (fws0) {
1169 BT_DBG("BT not the winner (%#x). Skip FW downloading", fws0);
1170
1171 /* Give other function more time to download the firmware */
1172 pollnum *= 10;
1173 } else {
1174 if (card->helper) {
1175 ret = btmrvl_sdio_download_helper(card);
1176 if (ret) {
1177 BT_ERR("Failed to download helper!");
1178 ret = -EIO;
1179 goto done;
1180 }
1181 }
1182
1183 if (btmrvl_sdio_download_fw_w_helper(card)) {
1184 BT_ERR("Failed to download firmware!");
1185 ret = -EIO;
1186 goto done;
1187 }
1188 }
1189
1190 /*
1191 * winner or not, with this test the FW synchronizes when the
1192 * module can continue its initialization
1193 */
1194 if (btmrvl_sdio_verify_fw_download(card, pollnum)) {
1195 BT_ERR("FW failed to be active in time!");
1196 ret = -ETIMEDOUT;
1197 goto done;
1198 }
1199
1200 sdio_release_host(card->func);
1201
1202 return 0;
1203
1204 done:
1205 sdio_release_host(card->func);
1206 return ret;
1207 }
1208
btmrvl_sdio_wakeup_fw(struct btmrvl_private * priv)1209 static int btmrvl_sdio_wakeup_fw(struct btmrvl_private *priv)
1210 {
1211 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
1212 int ret = 0;
1213
1214 if (!card || !card->func) {
1215 BT_ERR("card or function is NULL!");
1216 return -EINVAL;
1217 }
1218
1219 sdio_claim_host(card->func);
1220
1221 sdio_writeb(card->func, HOST_POWER_UP, card->reg->cfg, &ret);
1222
1223 sdio_release_host(card->func);
1224
1225 BT_DBG("wake up firmware");
1226
1227 return ret;
1228 }
1229
btmrvl_sdio_dump_regs(struct btmrvl_private * priv)1230 static void btmrvl_sdio_dump_regs(struct btmrvl_private *priv)
1231 {
1232 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
1233 int ret = 0;
1234 unsigned int reg, reg_start, reg_end;
1235 char buf[256], *ptr;
1236 u8 loop, func, data;
1237 int MAX_LOOP = 2;
1238
1239 btmrvl_sdio_wakeup_fw(priv);
1240 sdio_claim_host(card->func);
1241
1242 for (loop = 0; loop < MAX_LOOP; loop++) {
1243 memset(buf, 0, sizeof(buf));
1244 ptr = buf;
1245
1246 if (loop == 0) {
1247 /* Read the registers of SDIO function0 */
1248 func = loop;
1249 reg_start = 0;
1250 reg_end = 9;
1251 } else {
1252 func = 2;
1253 reg_start = 0;
1254 reg_end = 0x09;
1255 }
1256
1257 ptr += sprintf(ptr, "SDIO Func%d (%#x-%#x): ",
1258 func, reg_start, reg_end);
1259 for (reg = reg_start; reg <= reg_end; reg++) {
1260 if (func == 0)
1261 data = sdio_f0_readb(card->func, reg, &ret);
1262 else
1263 data = sdio_readb(card->func, reg, &ret);
1264
1265 if (!ret) {
1266 ptr += sprintf(ptr, "%02x ", data);
1267 } else {
1268 ptr += sprintf(ptr, "ERR");
1269 break;
1270 }
1271 }
1272
1273 BT_INFO("%s", buf);
1274 }
1275
1276 sdio_release_host(card->func);
1277 }
1278
1279 /* This function read/write firmware */
1280 static enum
btmrvl_sdio_rdwr_firmware(struct btmrvl_private * priv,u8 doneflag)1281 rdwr_status btmrvl_sdio_rdwr_firmware(struct btmrvl_private *priv,
1282 u8 doneflag)
1283 {
1284 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
1285 int ret, tries;
1286 u8 ctrl_data = 0;
1287
1288 sdio_writeb(card->func, FW_DUMP_HOST_READY, card->reg->fw_dump_ctrl,
1289 &ret);
1290
1291 if (ret) {
1292 BT_ERR("SDIO write err");
1293 return RDWR_STATUS_FAILURE;
1294 }
1295
1296 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1297 ctrl_data = sdio_readb(card->func, card->reg->fw_dump_ctrl,
1298 &ret);
1299
1300 if (ret) {
1301 BT_ERR("SDIO read err");
1302 return RDWR_STATUS_FAILURE;
1303 }
1304
1305 if (ctrl_data == FW_DUMP_DONE)
1306 break;
1307 if (doneflag && ctrl_data == doneflag)
1308 return RDWR_STATUS_DONE;
1309 if (ctrl_data != FW_DUMP_HOST_READY) {
1310 BT_INFO("The ctrl reg was changed, re-try again!");
1311 sdio_writeb(card->func, FW_DUMP_HOST_READY,
1312 card->reg->fw_dump_ctrl, &ret);
1313 if (ret) {
1314 BT_ERR("SDIO write err");
1315 return RDWR_STATUS_FAILURE;
1316 }
1317 }
1318 usleep_range(100, 200);
1319 }
1320
1321 if (ctrl_data == FW_DUMP_HOST_READY) {
1322 BT_ERR("Fail to pull ctrl_data");
1323 return RDWR_STATUS_FAILURE;
1324 }
1325
1326 return RDWR_STATUS_SUCCESS;
1327 }
1328
1329 /* This function dump sdio register and memory data */
btmrvl_sdio_coredump(struct device * dev)1330 static void btmrvl_sdio_coredump(struct device *dev)
1331 {
1332 struct sdio_func *func = dev_to_sdio_func(dev);
1333 struct btmrvl_sdio_card *card;
1334 struct btmrvl_private *priv;
1335 int ret = 0;
1336 unsigned int reg, reg_start, reg_end;
1337 enum rdwr_status stat;
1338 u8 *dbg_ptr, *end_ptr, *fw_dump_data, *fw_dump_ptr;
1339 u8 dump_num = 0, idx, i, read_reg, doneflag = 0;
1340 u32 memory_size, fw_dump_len = 0;
1341 int size = 0;
1342
1343 card = sdio_get_drvdata(func);
1344 priv = card->priv;
1345
1346 /* dump sdio register first */
1347 btmrvl_sdio_dump_regs(priv);
1348
1349 if (!card->supports_fw_dump) {
1350 BT_ERR("Firmware dump not supported for this card!");
1351 return;
1352 }
1353
1354 for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) {
1355 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
1356
1357 if (entry->mem_ptr) {
1358 vfree(entry->mem_ptr);
1359 entry->mem_ptr = NULL;
1360 }
1361 entry->mem_size = 0;
1362 }
1363
1364 btmrvl_sdio_wakeup_fw(priv);
1365 sdio_claim_host(card->func);
1366
1367 BT_INFO("== btmrvl firmware dump start ==");
1368
1369 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag);
1370 if (stat == RDWR_STATUS_FAILURE)
1371 goto done;
1372
1373 reg = card->reg->fw_dump_start;
1374 /* Read the number of the memories which will dump */
1375 dump_num = sdio_readb(card->func, reg, &ret);
1376
1377 if (ret) {
1378 BT_ERR("SDIO read memory length err");
1379 goto done;
1380 }
1381
1382 /* Read the length of every memory which will dump */
1383 for (idx = 0; idx < dump_num; idx++) {
1384 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
1385
1386 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag);
1387 if (stat == RDWR_STATUS_FAILURE)
1388 goto done;
1389
1390 memory_size = 0;
1391 reg = card->reg->fw_dump_start;
1392 for (i = 0; i < 4; i++) {
1393 read_reg = sdio_readb(card->func, reg, &ret);
1394 if (ret) {
1395 BT_ERR("SDIO read err");
1396 goto done;
1397 }
1398 memory_size |= (read_reg << i*8);
1399 reg++;
1400 }
1401
1402 if (memory_size == 0) {
1403 BT_INFO("Firmware dump finished!");
1404 sdio_writeb(card->func, FW_DUMP_READ_DONE,
1405 card->reg->fw_dump_ctrl, &ret);
1406 if (ret) {
1407 BT_ERR("SDIO Write MEMDUMP_FINISH ERR");
1408 goto done;
1409 }
1410 break;
1411 }
1412
1413 BT_INFO("%s_SIZE=0x%x", entry->mem_name, memory_size);
1414 entry->mem_ptr = vzalloc(memory_size + 1);
1415 entry->mem_size = memory_size;
1416 if (!entry->mem_ptr) {
1417 BT_ERR("Vzalloc %s failed", entry->mem_name);
1418 goto done;
1419 }
1420
1421 fw_dump_len += (strlen("========Start dump ") +
1422 strlen(entry->mem_name) +
1423 strlen("========\n") +
1424 (memory_size + 1) +
1425 strlen("\n========End dump========\n"));
1426
1427 dbg_ptr = entry->mem_ptr;
1428 end_ptr = dbg_ptr + memory_size;
1429
1430 doneflag = entry->done_flag;
1431 BT_INFO("Start %s output, please wait...",
1432 entry->mem_name);
1433
1434 do {
1435 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag);
1436 if (stat == RDWR_STATUS_FAILURE)
1437 goto done;
1438
1439 reg_start = card->reg->fw_dump_start;
1440 reg_end = card->reg->fw_dump_end;
1441 for (reg = reg_start; reg <= reg_end; reg++) {
1442 *dbg_ptr = sdio_readb(card->func, reg, &ret);
1443 if (ret) {
1444 BT_ERR("SDIO read err");
1445 goto done;
1446 }
1447 if (dbg_ptr < end_ptr)
1448 dbg_ptr++;
1449 else
1450 BT_ERR("Allocated buffer not enough");
1451 }
1452
1453 if (stat == RDWR_STATUS_DONE) {
1454 BT_INFO("%s done: size=0x%tx",
1455 entry->mem_name,
1456 dbg_ptr - entry->mem_ptr);
1457 break;
1458 }
1459 } while (1);
1460 }
1461
1462 BT_INFO("== btmrvl firmware dump end ==");
1463
1464 done:
1465 sdio_release_host(card->func);
1466
1467 if (fw_dump_len == 0)
1468 return;
1469
1470 fw_dump_data = vzalloc(fw_dump_len + 1);
1471 if (!fw_dump_data) {
1472 BT_ERR("Vzalloc fw_dump_data fail!");
1473 return;
1474 }
1475 fw_dump_ptr = fw_dump_data;
1476
1477 /* Dump all the memory data into single file, a userspace script will
1478 * be used to split all the memory data to multiple files
1479 */
1480 BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump start");
1481 for (idx = 0; idx < dump_num; idx++) {
1482 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
1483
1484 if (entry->mem_ptr) {
1485 size += scnprintf(fw_dump_ptr + size,
1486 fw_dump_len + 1 - size,
1487 "========Start dump %s========\n",
1488 entry->mem_name);
1489
1490 memcpy(fw_dump_ptr + size, entry->mem_ptr,
1491 entry->mem_size);
1492 size += entry->mem_size;
1493
1494 size += scnprintf(fw_dump_ptr + size,
1495 fw_dump_len + 1 - size,
1496 "\n========End dump========\n");
1497
1498 vfree(mem_type_mapping_tbl[idx].mem_ptr);
1499 mem_type_mapping_tbl[idx].mem_ptr = NULL;
1500 }
1501 }
1502
1503 /* fw_dump_data will be free in device coredump release function
1504 * after 5 min
1505 */
1506 dev_coredumpv(&card->func->dev, fw_dump_data, fw_dump_len, GFP_KERNEL);
1507 BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump end");
1508 }
1509
btmrvl_sdio_probe(struct sdio_func * func,const struct sdio_device_id * id)1510 static int btmrvl_sdio_probe(struct sdio_func *func,
1511 const struct sdio_device_id *id)
1512 {
1513 int ret = 0;
1514 struct btmrvl_private *priv = NULL;
1515 struct btmrvl_sdio_card *card = NULL;
1516
1517 BT_INFO("vendor=0x%x, device=0x%x, class=%d, fn=%d",
1518 id->vendor, id->device, id->class, func->num);
1519
1520 card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL);
1521 if (!card)
1522 return -ENOMEM;
1523
1524 card->func = func;
1525
1526 if (id->driver_data) {
1527 struct btmrvl_sdio_device *data = (void *) id->driver_data;
1528 card->helper = data->helper;
1529 card->firmware = data->firmware;
1530 card->reg = data->reg;
1531 card->sd_blksz_fw_dl = data->sd_blksz_fw_dl;
1532 card->support_pscan_win_report = data->support_pscan_win_report;
1533 card->supports_fw_dump = data->supports_fw_dump;
1534 }
1535
1536 if (btmrvl_sdio_register_dev(card) < 0) {
1537 BT_ERR("Failed to register BT device!");
1538 return -ENODEV;
1539 }
1540
1541 /* Disable the interrupts on the card */
1542 btmrvl_sdio_disable_host_int(card);
1543
1544 if (btmrvl_sdio_download_fw(card)) {
1545 BT_ERR("Downloading firmware failed!");
1546 ret = -ENODEV;
1547 goto unreg_dev;
1548 }
1549
1550 btmrvl_sdio_enable_host_int(card);
1551
1552 /* Device tree node parsing and platform specific configuration*/
1553 btmrvl_sdio_probe_of(&func->dev, card);
1554
1555 priv = btmrvl_add_card(card);
1556 if (!priv) {
1557 BT_ERR("Initializing card failed!");
1558 ret = -ENODEV;
1559 goto disable_host_int;
1560 }
1561
1562 card->priv = priv;
1563
1564 /* Initialize the interface specific function pointers */
1565 priv->hw_host_to_card = btmrvl_sdio_host_to_card;
1566 priv->hw_wakeup_firmware = btmrvl_sdio_wakeup_fw;
1567 priv->hw_process_int_status = btmrvl_sdio_process_int_status;
1568
1569 if (btmrvl_register_hdev(priv)) {
1570 BT_ERR("Register hdev failed!");
1571 ret = -ENODEV;
1572 goto disable_host_int;
1573 }
1574
1575 return 0;
1576
1577 disable_host_int:
1578 btmrvl_sdio_disable_host_int(card);
1579 unreg_dev:
1580 btmrvl_sdio_unregister_dev(card);
1581 return ret;
1582 }
1583
btmrvl_sdio_remove(struct sdio_func * func)1584 static void btmrvl_sdio_remove(struct sdio_func *func)
1585 {
1586 struct btmrvl_sdio_card *card;
1587
1588 if (func) {
1589 card = sdio_get_drvdata(func);
1590 if (card) {
1591 /* Send SHUTDOWN command & disable interrupt
1592 * if user removes the module.
1593 */
1594 if (user_rmmod) {
1595 btmrvl_send_module_cfg_cmd(card->priv,
1596 MODULE_SHUTDOWN_REQ);
1597 btmrvl_sdio_disable_host_int(card);
1598 }
1599
1600 BT_DBG("unregister dev");
1601 card->priv->surprise_removed = true;
1602 btmrvl_sdio_unregister_dev(card);
1603 btmrvl_remove_card(card->priv);
1604 }
1605 }
1606 }
1607
btmrvl_sdio_suspend(struct device * dev)1608 static int btmrvl_sdio_suspend(struct device *dev)
1609 {
1610 struct sdio_func *func = dev_to_sdio_func(dev);
1611 struct btmrvl_sdio_card *card;
1612 struct btmrvl_private *priv;
1613 mmc_pm_flag_t pm_flags;
1614 struct hci_dev *hcidev;
1615
1616 if (func) {
1617 pm_flags = sdio_get_host_pm_caps(func);
1618 BT_DBG("%s: suspend: PM flags = 0x%x", sdio_func_id(func),
1619 pm_flags);
1620 if (!(pm_flags & MMC_PM_KEEP_POWER)) {
1621 BT_ERR("%s: cannot remain alive while suspended",
1622 sdio_func_id(func));
1623 return -ENOSYS;
1624 }
1625 card = sdio_get_drvdata(func);
1626 if (!card || !card->priv) {
1627 BT_ERR("card or priv structure is not valid");
1628 return 0;
1629 }
1630 } else {
1631 BT_ERR("sdio_func is not specified");
1632 return 0;
1633 }
1634
1635 /* Enable platform specific wakeup interrupt */
1636 if (card->plt_wake_cfg && card->plt_wake_cfg->irq_bt >= 0 &&
1637 device_may_wakeup(dev)) {
1638 card->plt_wake_cfg->wake_by_bt = false;
1639 enable_irq(card->plt_wake_cfg->irq_bt);
1640 enable_irq_wake(card->plt_wake_cfg->irq_bt);
1641 }
1642
1643 priv = card->priv;
1644 priv->adapter->is_suspending = true;
1645 hcidev = priv->btmrvl_dev.hcidev;
1646 BT_DBG("%s: SDIO suspend", hcidev->name);
1647 hci_suspend_dev(hcidev);
1648
1649 if (priv->adapter->hs_state != HS_ACTIVATED) {
1650 if (btmrvl_enable_hs(priv)) {
1651 BT_ERR("HS not activated, suspend failed!");
1652 /* Disable platform specific wakeup interrupt */
1653 if (card->plt_wake_cfg &&
1654 card->plt_wake_cfg->irq_bt >= 0 &&
1655 device_may_wakeup(dev)) {
1656 disable_irq_wake(card->plt_wake_cfg->irq_bt);
1657 disable_irq(card->plt_wake_cfg->irq_bt);
1658 }
1659
1660 priv->adapter->is_suspending = false;
1661 return -EBUSY;
1662 }
1663 }
1664
1665 priv->adapter->is_suspending = false;
1666 priv->adapter->is_suspended = true;
1667
1668 /* We will keep the power when hs enabled successfully */
1669 if (priv->adapter->hs_state == HS_ACTIVATED) {
1670 BT_DBG("suspend with MMC_PM_KEEP_POWER");
1671 return sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1672 }
1673
1674 BT_DBG("suspend without MMC_PM_KEEP_POWER");
1675 return 0;
1676 }
1677
btmrvl_sdio_resume(struct device * dev)1678 static int btmrvl_sdio_resume(struct device *dev)
1679 {
1680 struct sdio_func *func = dev_to_sdio_func(dev);
1681 struct btmrvl_sdio_card *card;
1682 struct btmrvl_private *priv;
1683 mmc_pm_flag_t pm_flags;
1684 struct hci_dev *hcidev;
1685
1686 if (func) {
1687 pm_flags = sdio_get_host_pm_caps(func);
1688 BT_DBG("%s: resume: PM flags = 0x%x", sdio_func_id(func),
1689 pm_flags);
1690 card = sdio_get_drvdata(func);
1691 if (!card || !card->priv) {
1692 BT_ERR("card or priv structure is not valid");
1693 return 0;
1694 }
1695 } else {
1696 BT_ERR("sdio_func is not specified");
1697 return 0;
1698 }
1699 priv = card->priv;
1700
1701 if (!priv->adapter->is_suspended) {
1702 BT_DBG("device already resumed");
1703 return 0;
1704 }
1705
1706 priv->hw_wakeup_firmware(priv);
1707 priv->adapter->hs_state = HS_DEACTIVATED;
1708 hcidev = priv->btmrvl_dev.hcidev;
1709 BT_DBG("%s: HS DEACTIVATED in resume!", hcidev->name);
1710 priv->adapter->is_suspended = false;
1711 BT_DBG("%s: SDIO resume", hcidev->name);
1712 hci_resume_dev(hcidev);
1713
1714 /* Disable platform specific wakeup interrupt */
1715 if (card->plt_wake_cfg && card->plt_wake_cfg->irq_bt >= 0 &&
1716 device_may_wakeup(dev)) {
1717 disable_irq_wake(card->plt_wake_cfg->irq_bt);
1718 disable_irq(card->plt_wake_cfg->irq_bt);
1719 if (card->plt_wake_cfg->wake_by_bt)
1720 /* Undo our disable, since interrupt handler already
1721 * did this.
1722 */
1723 enable_irq(card->plt_wake_cfg->irq_bt);
1724 }
1725
1726 return 0;
1727 }
1728
1729 static const struct dev_pm_ops btmrvl_sdio_pm_ops = {
1730 .suspend = btmrvl_sdio_suspend,
1731 .resume = btmrvl_sdio_resume,
1732 };
1733
1734 static struct sdio_driver bt_mrvl_sdio = {
1735 .name = "btmrvl_sdio",
1736 .id_table = btmrvl_sdio_ids,
1737 .probe = btmrvl_sdio_probe,
1738 .remove = btmrvl_sdio_remove,
1739 .drv = {
1740 .coredump = btmrvl_sdio_coredump,
1741 .pm = &btmrvl_sdio_pm_ops,
1742 }
1743 };
1744
btmrvl_sdio_init_module(void)1745 static int __init btmrvl_sdio_init_module(void)
1746 {
1747 if (sdio_register_driver(&bt_mrvl_sdio) != 0) {
1748 BT_ERR("SDIO Driver Registration Failed");
1749 return -ENODEV;
1750 }
1751
1752 /* Clear the flag in case user removes the card. */
1753 user_rmmod = 0;
1754
1755 return 0;
1756 }
1757
btmrvl_sdio_exit_module(void)1758 static void __exit btmrvl_sdio_exit_module(void)
1759 {
1760 /* Set the flag as user is removing this module. */
1761 user_rmmod = 1;
1762
1763 sdio_unregister_driver(&bt_mrvl_sdio);
1764 }
1765
1766 module_init(btmrvl_sdio_init_module);
1767 module_exit(btmrvl_sdio_exit_module);
1768
1769 MODULE_AUTHOR("Marvell International Ltd.");
1770 MODULE_DESCRIPTION("Marvell BT-over-SDIO driver ver " VERSION);
1771 MODULE_VERSION(VERSION);
1772 MODULE_LICENSE("GPL v2");
1773 MODULE_FIRMWARE("mrvl/sd8688_helper.bin");
1774 MODULE_FIRMWARE("mrvl/sd8688.bin");
1775 MODULE_FIRMWARE("mrvl/sd8787_uapsta.bin");
1776 MODULE_FIRMWARE("mrvl/sd8797_uapsta.bin");
1777 MODULE_FIRMWARE("mrvl/sd8887_uapsta.bin");
1778 MODULE_FIRMWARE("mrvl/sd8897_uapsta.bin");
1779 MODULE_FIRMWARE("mrvl/sdsd8977_combo_v2.bin");
1780 MODULE_FIRMWARE("mrvl/sd8987_uapsta.bin");
1781 MODULE_FIRMWARE("mrvl/sdsd8997_combo_v4.bin");
1782