btmrvl_sdio.c

   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
  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
  43static 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
  49static 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 */
  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)) {
  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 */
 126static u8 user_rmmod;
 127static u8 sdio_ireg;
 128
 129static 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};
 145static 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
 163static 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
 183static 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
 206static 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
 229static 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
 238static 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
 247static 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
 256static 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
 265static 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
 274static 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
 283static 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
 292static 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
 301static 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
 333MODULE_DEVICE_TABLE(sdio, btmrvl_sdio_ids);
 334
 335static 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
 347static 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
 367static 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
 379static 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
 393static 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
 414static 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
 432failed:
 433	BT_ERR("FAILED! ret=%d", ret);
 434
 435	return ret;
 436}
 437
 438static 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
 461static 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
 553done:
 554	kfree(tmphlprbuf);
 555	release_firmware(fw_helper);
 556	return ret;
 557}
 558
 559static 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
 696done:
 697	kfree(tmpfwbuf);
 698	release_firmware(fw_firmware);
 699	return ret;
 700}
 701
 702static 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
 816exit:
 817	if (ret) {
 818		hdev->stat.err_rx++;
 819		kfree_skb(skb);
 820	}
 821
 822	return ret;
 823}
 824
 825static 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
 853static 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
 870static 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
 900static 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
 935static 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
1028release_irq:
1029	sdio_release_irq(func);
1030
1031disable_func:
1032	sdio_disable_func(func);
1033
1034release_host:
1035	sdio_release_host(func);
1036
1037failed:
1038	return ret;
1039}
1040
1041static 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
1054static 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
1072static 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
1088static 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
1136exit:
1137	sdio_release_host(card->func);
1138	kfree(tmpbuf);
1139
1140	return ret;
1141}
1142
1143static 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
1204done:
1205	sdio_release_host(card->func);
1206	return ret;
1207}
1208
1209static 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
1230static 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 */
1280static enum
1281rdwr_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 */
1330static 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
1464done:
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
1510static 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
1577disable_host_int:
1578	btmrvl_sdio_disable_host_int(card);
1579unreg_dev:
1580	btmrvl_sdio_unregister_dev(card);
1581	return ret;
1582}
1583
1584static 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
1608static 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
1678static 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
1729static const struct dev_pm_ops btmrvl_sdio_pm_ops = {
1730	.suspend	= btmrvl_sdio_suspend,
1731	.resume		= btmrvl_sdio_resume,
1732};
1733
1734static 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
1745static 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
1758static 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
1766module_init(btmrvl_sdio_init_module);
1767module_exit(btmrvl_sdio_exit_module);
1768
1769MODULE_AUTHOR("Marvell International Ltd.");
1770MODULE_DESCRIPTION("Marvell BT-over-SDIO driver ver " VERSION);
1771MODULE_VERSION(VERSION);
1772MODULE_LICENSE("GPL v2");
1773MODULE_FIRMWARE("mrvl/sd8688_helper.bin");
1774MODULE_FIRMWARE("mrvl/sd8688.bin");
1775MODULE_FIRMWARE("mrvl/sd8787_uapsta.bin");
1776MODULE_FIRMWARE("mrvl/sd8797_uapsta.bin");
1777MODULE_FIRMWARE("mrvl/sd8887_uapsta.bin");
1778MODULE_FIRMWARE("mrvl/sd8897_uapsta.bin");
1779MODULE_FIRMWARE("mrvl/sdsd8977_combo_v2.bin");
1780MODULE_FIRMWARE("mrvl/sd8987_uapsta.bin");
1781MODULE_FIRMWARE("mrvl/sdsd8997_combo_v4.bin");