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