1 /**
2  * Copyright (c) 2014 Redpine Signals Inc.
3  *
4  * Permission to use, copy, modify, and/or distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  *
16  */
17 
18 #include <linux/module.h>
19 #include "rsi_sdio.h"
20 #include "rsi_common.h"
21 #include "rsi_coex.h"
22 #include "rsi_hal.h"
23 
24 /* Default operating mode is wlan STA + BT */
25 static u16 dev_oper_mode = DEV_OPMODE_STA_BT_DUAL;
26 module_param(dev_oper_mode, ushort, 0444);
27 MODULE_PARM_DESC(dev_oper_mode,
28 		 "1[Wi-Fi], 4[BT], 8[BT LE], 5[Wi-Fi STA + BT classic]\n"
29 		 "9[Wi-Fi STA + BT LE], 13[Wi-Fi STA + BT classic + BT LE]\n"
30 		 "6[AP + BT classic], 14[AP + BT classic + BT LE]");
31 
32 /**
33  * rsi_sdio_set_cmd52_arg() - This function prepares cmd 52 read/write arg.
34  * @rw: Read/write
35  * @func: function number
36  * @raw: indicates whether to perform read after write
37  * @address: address to which to read/write
38  * @writedata: data to write
39  *
40  * Return: argument
41  */
42 static u32 rsi_sdio_set_cmd52_arg(bool rw,
43 				  u8 func,
44 				  u8 raw,
45 				  u32 address,
46 				  u8 writedata)
47 {
48 	return ((rw & 1) << 31) | ((func & 0x7) << 28) |
49 		((raw & 1) << 27) | (1 << 26) |
50 		((address & 0x1FFFF) << 9) | (1 << 8) |
51 		(writedata & 0xFF);
52 }
53 
54 /**
55  * rsi_cmd52writebyte() - This function issues cmd52 byte write onto the card.
56  * @card: Pointer to the mmc_card.
57  * @address: Address to write.
58  * @byte: Data to write.
59  *
60  * Return: Write status.
61  */
62 static int rsi_cmd52writebyte(struct mmc_card *card,
63 			      u32 address,
64 			      u8 byte)
65 {
66 	struct mmc_command io_cmd;
67 	u32 arg;
68 
69 	memset(&io_cmd, 0, sizeof(io_cmd));
70 	arg = rsi_sdio_set_cmd52_arg(1, 0, 0, address, byte);
71 	io_cmd.opcode = SD_IO_RW_DIRECT;
72 	io_cmd.arg = arg;
73 	io_cmd.flags = MMC_RSP_R5 | MMC_CMD_AC;
74 
75 	return mmc_wait_for_cmd(card->host, &io_cmd, 0);
76 }
77 
78 /**
79  * rsi_cmd52readbyte() - This function issues cmd52 byte read onto the card.
80  * @card: Pointer to the mmc_card.
81  * @address: Address to read from.
82  * @byte: Variable to store read value.
83  *
84  * Return: Read status.
85  */
86 static int rsi_cmd52readbyte(struct mmc_card *card,
87 			     u32 address,
88 			     u8 *byte)
89 {
90 	struct mmc_command io_cmd;
91 	u32 arg;
92 	int err;
93 
94 	memset(&io_cmd, 0, sizeof(io_cmd));
95 	arg = rsi_sdio_set_cmd52_arg(0, 0, 0, address, 0);
96 	io_cmd.opcode = SD_IO_RW_DIRECT;
97 	io_cmd.arg = arg;
98 	io_cmd.flags = MMC_RSP_R5 | MMC_CMD_AC;
99 
100 	err = mmc_wait_for_cmd(card->host, &io_cmd, 0);
101 	if ((!err) && (byte))
102 		*byte =  io_cmd.resp[0] & 0xFF;
103 	return err;
104 }
105 
106 /**
107  * rsi_issue_sdiocommand() - This function issues sdio commands.
108  * @func: Pointer to the sdio_func structure.
109  * @opcode: Opcode value.
110  * @arg: Arguments to pass.
111  * @flags: Flags which are set.
112  * @resp: Pointer to store response.
113  *
114  * Return: err: command status as 0 or -1.
115  */
116 static int rsi_issue_sdiocommand(struct sdio_func *func,
117 				 u32 opcode,
118 				 u32 arg,
119 				 u32 flags,
120 				 u32 *resp)
121 {
122 	struct mmc_command cmd;
123 	struct mmc_host *host;
124 	int err;
125 
126 	host = func->card->host;
127 
128 	memset(&cmd, 0, sizeof(struct mmc_command));
129 	cmd.opcode = opcode;
130 	cmd.arg = arg;
131 	cmd.flags = flags;
132 	err = mmc_wait_for_cmd(host, &cmd, 3);
133 
134 	if ((!err) && (resp))
135 		*resp = cmd.resp[0];
136 
137 	return err;
138 }
139 
140 /**
141  * rsi_handle_interrupt() - This function is called upon the occurence
142  *			    of an interrupt.
143  * @function: Pointer to the sdio_func structure.
144  *
145  * Return: None.
146  */
147 static void rsi_handle_interrupt(struct sdio_func *function)
148 {
149 	struct rsi_hw *adapter = sdio_get_drvdata(function);
150 	struct rsi_91x_sdiodev *dev =
151 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
152 
153 	if (adapter->priv->fsm_state == FSM_FW_NOT_LOADED)
154 		return;
155 
156 	dev->sdio_irq_task = current;
157 	rsi_interrupt_handler(adapter);
158 	dev->sdio_irq_task = NULL;
159 }
160 
161 /**
162  * rsi_reset_card() - This function resets and re-initializes the card.
163  * @pfunction: Pointer to the sdio_func structure.
164  *
165  * Return: None.
166  */
167 static void rsi_reset_card(struct sdio_func *pfunction)
168 {
169 	int ret = 0;
170 	int err;
171 	struct mmc_card *card = pfunction->card;
172 	struct mmc_host *host = card->host;
173 	u8 cmd52_resp;
174 	u32 clock, resp, i;
175 	u16 rca;
176 
177 	/* Reset 9110 chip */
178 	ret = rsi_cmd52writebyte(pfunction->card,
179 				 SDIO_CCCR_ABORT,
180 				 (1 << 3));
181 
182 	/* Card will not send any response as it is getting reset immediately
183 	 * Hence expect a timeout status from host controller
184 	 */
185 	if (ret != -ETIMEDOUT)
186 		rsi_dbg(ERR_ZONE, "%s: Reset failed : %d\n", __func__, ret);
187 
188 	/* Wait for few milli seconds to get rid of residue charges if any */
189 	msleep(20);
190 
191 	/* Initialize the SDIO card */
192 	host->ios.chip_select = MMC_CS_DONTCARE;
193 	host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
194 	host->ios.power_mode = MMC_POWER_UP;
195 	host->ios.bus_width = MMC_BUS_WIDTH_1;
196 	host->ios.timing = MMC_TIMING_LEGACY;
197 	host->ops->set_ios(host, &host->ios);
198 
199 	/*
200 	 * This delay should be sufficient to allow the power supply
201 	 * to reach the minimum voltage.
202 	 */
203 	msleep(20);
204 
205 	host->ios.clock = host->f_min;
206 	host->ios.power_mode = MMC_POWER_ON;
207 	host->ops->set_ios(host, &host->ios);
208 
209 	/*
210 	 * This delay must be at least 74 clock sizes, or 1 ms, or the
211 	 * time required to reach a stable voltage.
212 	 */
213 	msleep(20);
214 
215 	/* Issue CMD0. Goto idle state */
216 	host->ios.chip_select = MMC_CS_HIGH;
217 	host->ops->set_ios(host, &host->ios);
218 	msleep(20);
219 	err = rsi_issue_sdiocommand(pfunction,
220 				    MMC_GO_IDLE_STATE,
221 				    0,
222 				    (MMC_RSP_NONE | MMC_CMD_BC),
223 				    NULL);
224 	host->ios.chip_select = MMC_CS_DONTCARE;
225 	host->ops->set_ios(host, &host->ios);
226 	msleep(20);
227 	host->use_spi_crc = 0;
228 
229 	if (err)
230 		rsi_dbg(ERR_ZONE, "%s: CMD0 failed : %d\n", __func__, err);
231 
232 	/* Issue CMD5, arg = 0 */
233 	err = rsi_issue_sdiocommand(pfunction,	SD_IO_SEND_OP_COND, 0,
234 				    (MMC_RSP_R4 | MMC_CMD_BCR), &resp);
235 	if (err)
236 		rsi_dbg(ERR_ZONE, "%s: CMD5 failed : %d\n", __func__, err);
237 	card->ocr = resp;
238 
239 	/* Issue CMD5, arg = ocr. Wait till card is ready  */
240 	for (i = 0; i < 100; i++) {
241 		err = rsi_issue_sdiocommand(pfunction, SD_IO_SEND_OP_COND,
242 					    card->ocr,
243 					    (MMC_RSP_R4 | MMC_CMD_BCR), &resp);
244 		if (err) {
245 			rsi_dbg(ERR_ZONE, "%s: CMD5 failed : %d\n",
246 				__func__, err);
247 			break;
248 		}
249 
250 		if (resp & MMC_CARD_BUSY)
251 			break;
252 		msleep(20);
253 	}
254 
255 	if ((i == 100) || (err)) {
256 		rsi_dbg(ERR_ZONE, "%s: card in not ready : %d %d\n",
257 			__func__, i, err);
258 		return;
259 	}
260 
261 	/* Issue CMD3, get RCA */
262 	err = rsi_issue_sdiocommand(pfunction,
263 				    SD_SEND_RELATIVE_ADDR,
264 				    0,
265 				    (MMC_RSP_R6 | MMC_CMD_BCR),
266 				    &resp);
267 	if (err) {
268 		rsi_dbg(ERR_ZONE, "%s: CMD3 failed : %d\n", __func__, err);
269 		return;
270 	}
271 	rca = resp >> 16;
272 	host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
273 	host->ops->set_ios(host, &host->ios);
274 
275 	/* Issue CMD7, select card  */
276 	err = rsi_issue_sdiocommand(pfunction,
277 				    MMC_SELECT_CARD,
278 				    (rca << 16),
279 				    (MMC_RSP_R1 | MMC_CMD_AC),
280 				    NULL);
281 	if (err) {
282 		rsi_dbg(ERR_ZONE, "%s: CMD7 failed : %d\n", __func__, err);
283 		return;
284 	}
285 
286 	/* Enable high speed */
287 	if (card->host->caps & MMC_CAP_SD_HIGHSPEED) {
288 		rsi_dbg(ERR_ZONE, "%s: Set high speed mode\n", __func__);
289 		err = rsi_cmd52readbyte(card, SDIO_CCCR_SPEED, &cmd52_resp);
290 		if (err) {
291 			rsi_dbg(ERR_ZONE, "%s: CCCR speed reg read failed: %d\n",
292 				__func__, err);
293 		} else {
294 			err = rsi_cmd52writebyte(card,
295 						 SDIO_CCCR_SPEED,
296 						 (cmd52_resp | SDIO_SPEED_EHS));
297 			if (err) {
298 				rsi_dbg(ERR_ZONE,
299 					"%s: CCR speed regwrite failed %d\n",
300 					__func__, err);
301 				return;
302 			}
303 			host->ios.timing = MMC_TIMING_SD_HS;
304 			host->ops->set_ios(host, &host->ios);
305 		}
306 	}
307 
308 	/* Set clock */
309 	if (mmc_card_hs(card))
310 		clock = 50000000;
311 	else
312 		clock = card->cis.max_dtr;
313 
314 	if (clock > host->f_max)
315 		clock = host->f_max;
316 
317 	host->ios.clock = clock;
318 	host->ops->set_ios(host, &host->ios);
319 
320 	if (card->host->caps & MMC_CAP_4_BIT_DATA) {
321 		/* CMD52: Set bus width & disable card detect resistor */
322 		err = rsi_cmd52writebyte(card,
323 					 SDIO_CCCR_IF,
324 					 (SDIO_BUS_CD_DISABLE |
325 					  SDIO_BUS_WIDTH_4BIT));
326 		if (err) {
327 			rsi_dbg(ERR_ZONE, "%s: Set bus mode failed : %d\n",
328 				__func__, err);
329 			return;
330 		}
331 		host->ios.bus_width = MMC_BUS_WIDTH_4;
332 		host->ops->set_ios(host, &host->ios);
333 	}
334 }
335 
336 /**
337  * rsi_setclock() - This function sets the clock frequency.
338  * @adapter: Pointer to the adapter structure.
339  * @freq: Clock frequency.
340  *
341  * Return: None.
342  */
343 static void rsi_setclock(struct rsi_hw *adapter, u32 freq)
344 {
345 	struct rsi_91x_sdiodev *dev =
346 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
347 	struct mmc_host *host = dev->pfunction->card->host;
348 	u32 clock;
349 
350 	clock = freq * 1000;
351 	if (clock > host->f_max)
352 		clock = host->f_max;
353 	host->ios.clock = clock;
354 	host->ops->set_ios(host, &host->ios);
355 }
356 
357 /**
358  * rsi_setblocklength() - This function sets the host block length.
359  * @adapter: Pointer to the adapter structure.
360  * @length: Block length to be set.
361  *
362  * Return: status: 0 on success, -1 on failure.
363  */
364 static int rsi_setblocklength(struct rsi_hw *adapter, u32 length)
365 {
366 	struct rsi_91x_sdiodev *dev =
367 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
368 	int status;
369 	rsi_dbg(INIT_ZONE, "%s: Setting the block length\n", __func__);
370 
371 	status = sdio_set_block_size(dev->pfunction, length);
372 	dev->pfunction->max_blksize = 256;
373 	adapter->block_size = dev->pfunction->max_blksize;
374 
375 	rsi_dbg(INFO_ZONE,
376 		"%s: Operational blk length is %d\n", __func__, length);
377 	return status;
378 }
379 
380 /**
381  * rsi_setupcard() - This function queries and sets the card's features.
382  * @adapter: Pointer to the adapter structure.
383  *
384  * Return: status: 0 on success, -1 on failure.
385  */
386 static int rsi_setupcard(struct rsi_hw *adapter)
387 {
388 	struct rsi_91x_sdiodev *dev =
389 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
390 	int status = 0;
391 
392 	rsi_setclock(adapter, 50000);
393 
394 	dev->tx_blk_size = 256;
395 	status = rsi_setblocklength(adapter, dev->tx_blk_size);
396 	if (status)
397 		rsi_dbg(ERR_ZONE,
398 			"%s: Unable to set block length\n", __func__);
399 	return status;
400 }
401 
402 /**
403  * rsi_sdio_read_register() - This function reads one byte of information
404  *			      from a register.
405  * @adapter: Pointer to the adapter structure.
406  * @addr: Address of the register.
407  * @data: Pointer to the data that stores the data read.
408  *
409  * Return: 0 on success, -1 on failure.
410  */
411 int rsi_sdio_read_register(struct rsi_hw *adapter,
412 			   u32 addr,
413 			   u8 *data)
414 {
415 	struct rsi_91x_sdiodev *dev =
416 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
417 	u8 fun_num = 0;
418 	int status;
419 
420 	if (likely(dev->sdio_irq_task != current))
421 		sdio_claim_host(dev->pfunction);
422 
423 	if (fun_num == 0)
424 		*data = sdio_f0_readb(dev->pfunction, addr, &status);
425 	else
426 		*data = sdio_readb(dev->pfunction, addr, &status);
427 
428 	if (likely(dev->sdio_irq_task != current))
429 		sdio_release_host(dev->pfunction);
430 
431 	return status;
432 }
433 
434 /**
435  * rsi_sdio_write_register() - This function writes one byte of information
436  *			       into a register.
437  * @adapter: Pointer to the adapter structure.
438  * @function: Function Number.
439  * @addr: Address of the register.
440  * @data: Pointer to the data tha has to be written.
441  *
442  * Return: 0 on success, -1 on failure.
443  */
444 int rsi_sdio_write_register(struct rsi_hw *adapter,
445 			    u8 function,
446 			    u32 addr,
447 			    u8 *data)
448 {
449 	struct rsi_91x_sdiodev *dev =
450 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
451 	int status = 0;
452 
453 	if (likely(dev->sdio_irq_task != current))
454 		sdio_claim_host(dev->pfunction);
455 
456 	if (function == 0)
457 		sdio_f0_writeb(dev->pfunction, *data, addr, &status);
458 	else
459 		sdio_writeb(dev->pfunction, *data, addr, &status);
460 
461 	if (likely(dev->sdio_irq_task != current))
462 		sdio_release_host(dev->pfunction);
463 
464 	return status;
465 }
466 
467 /**
468  * rsi_sdio_ack_intr() - This function acks the interrupt received.
469  * @adapter: Pointer to the adapter structure.
470  * @int_bit: Interrupt bit to write into register.
471  *
472  * Return: None.
473  */
474 void rsi_sdio_ack_intr(struct rsi_hw *adapter, u8 int_bit)
475 {
476 	int status;
477 	status = rsi_sdio_write_register(adapter,
478 					 1,
479 					 (SDIO_FUN1_INTR_CLR_REG |
480 					  RSI_SD_REQUEST_MASTER),
481 					 &int_bit);
482 	if (status)
483 		rsi_dbg(ERR_ZONE, "%s: unable to send ack\n", __func__);
484 }
485 
486 
487 
488 /**
489  * rsi_sdio_read_register_multiple() - This function read multiple bytes of
490  *				       information from the SD card.
491  * @adapter: Pointer to the adapter structure.
492  * @addr: Address of the register.
493  * @count: Number of multiple bytes to be read.
494  * @data: Pointer to the read data.
495  *
496  * Return: 0 on success, -1 on failure.
497  */
498 static int rsi_sdio_read_register_multiple(struct rsi_hw *adapter,
499 					   u32 addr,
500 					   u8 *data,
501 					   u16 count)
502 {
503 	struct rsi_91x_sdiodev *dev =
504 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
505 	u32 status;
506 
507 	if (likely(dev->sdio_irq_task != current))
508 		sdio_claim_host(dev->pfunction);
509 
510 	status =  sdio_readsb(dev->pfunction, data, addr, count);
511 
512 	if (likely(dev->sdio_irq_task != current))
513 		sdio_release_host(dev->pfunction);
514 
515 	if (status != 0)
516 		rsi_dbg(ERR_ZONE, "%s: Synch Cmd53 read failed\n", __func__);
517 	return status;
518 }
519 
520 /**
521  * rsi_sdio_write_register_multiple() - This function writes multiple bytes of
522  *					information to the SD card.
523  * @adapter: Pointer to the adapter structure.
524  * @addr: Address of the register.
525  * @data: Pointer to the data that has to be written.
526  * @count: Number of multiple bytes to be written.
527  *
528  * Return: 0 on success, -1 on failure.
529  */
530 int rsi_sdio_write_register_multiple(struct rsi_hw *adapter,
531 				     u32 addr,
532 				     u8 *data,
533 				     u16 count)
534 {
535 	struct rsi_91x_sdiodev *dev =
536 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
537 	int status;
538 
539 	if (dev->write_fail > 1) {
540 		rsi_dbg(ERR_ZONE, "%s: Stopping card writes\n", __func__);
541 		return 0;
542 	} else if (dev->write_fail == 1) {
543 		/**
544 		 * Assuming it is a CRC failure, we want to allow another
545 		 *  card write
546 		 */
547 		rsi_dbg(ERR_ZONE, "%s: Continue card writes\n", __func__);
548 		dev->write_fail++;
549 	}
550 
551 	if (likely(dev->sdio_irq_task != current))
552 		sdio_claim_host(dev->pfunction);
553 
554 	status = sdio_writesb(dev->pfunction, addr, data, count);
555 
556 	if (likely(dev->sdio_irq_task != current))
557 		sdio_release_host(dev->pfunction);
558 
559 	if (status) {
560 		rsi_dbg(ERR_ZONE, "%s: Synch Cmd53 write failed %d\n",
561 			__func__, status);
562 		dev->write_fail = 2;
563 	} else {
564 		memcpy(dev->prev_desc, data, FRAME_DESC_SZ);
565 	}
566 	return status;
567 }
568 
569 static int rsi_sdio_load_data_master_write(struct rsi_hw *adapter,
570 					   u32 base_address,
571 					   u32 instructions_sz,
572 					   u16 block_size,
573 					   u8 *ta_firmware)
574 {
575 	u32 num_blocks, offset, i;
576 	u16 msb_address, lsb_address;
577 	u8 *temp_buf;
578 	int status;
579 
580 	num_blocks = instructions_sz / block_size;
581 	msb_address = base_address >> 16;
582 
583 	rsi_dbg(INFO_ZONE, "ins_size: %d, num_blocks: %d\n",
584 		instructions_sz, num_blocks);
585 
586 	temp_buf = kmalloc(block_size, GFP_KERNEL);
587 	if (!temp_buf)
588 		return -ENOMEM;
589 
590 	/* Loading DM ms word in the sdio slave */
591 	status = rsi_sdio_master_access_msword(adapter, msb_address);
592 	if (status < 0) {
593 		rsi_dbg(ERR_ZONE, "%s: Unable to set ms word reg\n", __func__);
594 		goto out_free;
595 	}
596 
597 	for (offset = 0, i = 0; i < num_blocks; i++, offset += block_size) {
598 		memcpy(temp_buf, ta_firmware + offset, block_size);
599 		lsb_address = (u16)base_address;
600 		status = rsi_sdio_write_register_multiple
601 					(adapter,
602 					 lsb_address | RSI_SD_REQUEST_MASTER,
603 					 temp_buf, block_size);
604 		if (status < 0) {
605 			rsi_dbg(ERR_ZONE, "%s: failed to write\n", __func__);
606 			goto out_free;
607 		}
608 		rsi_dbg(INFO_ZONE, "%s: loading block: %d\n", __func__, i);
609 		base_address += block_size;
610 
611 		if ((base_address >> 16) != msb_address) {
612 			msb_address += 1;
613 
614 			/* Loading DM ms word in the sdio slave */
615 			status = rsi_sdio_master_access_msword(adapter,
616 							       msb_address);
617 			if (status < 0) {
618 				rsi_dbg(ERR_ZONE,
619 					"%s: Unable to set ms word reg\n",
620 					__func__);
621 				goto out_free;
622 			}
623 		}
624 	}
625 
626 	if (instructions_sz % block_size) {
627 		memset(temp_buf, 0, block_size);
628 		memcpy(temp_buf, ta_firmware + offset,
629 		       instructions_sz % block_size);
630 		lsb_address = (u16)base_address;
631 		status = rsi_sdio_write_register_multiple
632 					(adapter,
633 					 lsb_address | RSI_SD_REQUEST_MASTER,
634 					 temp_buf,
635 					 instructions_sz % block_size);
636 		if (status < 0)
637 			goto out_free;
638 		rsi_dbg(INFO_ZONE,
639 			"Written Last Block in Address 0x%x Successfully\n",
640 			offset | RSI_SD_REQUEST_MASTER);
641 	}
642 
643 	status = 0;
644 out_free:
645 	kfree(temp_buf);
646 	return status;
647 }
648 
649 #define FLASH_SIZE_ADDR                 0x04000016
650 static int rsi_sdio_master_reg_read(struct rsi_hw *adapter, u32 addr,
651 				    u32 *read_buf, u16 size)
652 {
653 	u32 addr_on_bus, *data;
654 	u16 ms_addr;
655 	int status;
656 
657 	data = kzalloc(RSI_MASTER_REG_BUF_SIZE, GFP_KERNEL);
658 	if (!data)
659 		return -ENOMEM;
660 
661 	ms_addr = (addr >> 16);
662 	status = rsi_sdio_master_access_msword(adapter, ms_addr);
663 	if (status < 0) {
664 		rsi_dbg(ERR_ZONE,
665 			"%s: Unable to set ms word to common reg\n",
666 			__func__);
667 		goto err;
668 	}
669 	addr &= 0xFFFF;
670 
671 	addr_on_bus = (addr & 0xFF000000);
672 	if ((addr_on_bus == (FLASH_SIZE_ADDR & 0xFF000000)) ||
673 	    (addr_on_bus == 0x0))
674 		addr_on_bus = (addr & ~(0x3));
675 	else
676 		addr_on_bus = addr;
677 
678 	/* Bring TA out of reset */
679 	status = rsi_sdio_read_register_multiple
680 					(adapter,
681 					 (addr_on_bus | RSI_SD_REQUEST_MASTER),
682 					 (u8 *)data, 4);
683 	if (status < 0) {
684 		rsi_dbg(ERR_ZONE, "%s: AHB register read failed\n", __func__);
685 		goto err;
686 	}
687 	if (size == 2) {
688 		if ((addr & 0x3) == 0)
689 			*read_buf = *data;
690 		else
691 			*read_buf  = (*data >> 16);
692 		*read_buf = (*read_buf & 0xFFFF);
693 	} else if (size == 1) {
694 		if ((addr & 0x3) == 0)
695 			*read_buf = *data;
696 		else if ((addr & 0x3) == 1)
697 			*read_buf = (*data >> 8);
698 		else if ((addr & 0x3) == 2)
699 			*read_buf = (*data >> 16);
700 		else
701 			*read_buf = (*data >> 24);
702 		*read_buf = (*read_buf & 0xFF);
703 	} else {
704 		*read_buf = *data;
705 	}
706 
707 err:
708 	kfree(data);
709 	return status;
710 }
711 
712 static int rsi_sdio_master_reg_write(struct rsi_hw *adapter,
713 				     unsigned long addr,
714 				     unsigned long data, u16 size)
715 {
716 	unsigned long *data_aligned;
717 	int status;
718 
719 	data_aligned = kzalloc(RSI_MASTER_REG_BUF_SIZE, GFP_KERNEL);
720 	if (!data_aligned)
721 		return -ENOMEM;
722 
723 	if (size == 2) {
724 		*data_aligned = ((data << 16) | (data & 0xFFFF));
725 	} else if (size == 1) {
726 		u32 temp_data = data & 0xFF;
727 
728 		*data_aligned = ((temp_data << 24) | (temp_data << 16) |
729 				 (temp_data << 8) | temp_data);
730 	} else {
731 		*data_aligned = data;
732 	}
733 	size = 4;
734 
735 	status = rsi_sdio_master_access_msword(adapter, (addr >> 16));
736 	if (status < 0) {
737 		rsi_dbg(ERR_ZONE,
738 			"%s: Unable to set ms word to common reg\n",
739 			__func__);
740 		kfree(data_aligned);
741 		return -EIO;
742 	}
743 	addr = addr & 0xFFFF;
744 
745 	/* Bring TA out of reset */
746 	status = rsi_sdio_write_register_multiple
747 					(adapter,
748 					 (addr | RSI_SD_REQUEST_MASTER),
749 					 (u8 *)data_aligned, size);
750 	if (status < 0)
751 		rsi_dbg(ERR_ZONE,
752 			"%s: Unable to do AHB reg write\n", __func__);
753 
754 	kfree(data_aligned);
755 	return status;
756 }
757 
758 /**
759  * rsi_sdio_host_intf_write_pkt() - This function writes the packet to device.
760  * @adapter: Pointer to the adapter structure.
761  * @pkt: Pointer to the data to be written on to the device.
762  * @len: length of the data to be written on to the device.
763  *
764  * Return: 0 on success, -1 on failure.
765  */
766 static int rsi_sdio_host_intf_write_pkt(struct rsi_hw *adapter,
767 					u8 *pkt,
768 					u32 len)
769 {
770 	struct rsi_91x_sdiodev *dev =
771 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
772 	u32 block_size = dev->tx_blk_size;
773 	u32 num_blocks, address, length;
774 	u32 queueno;
775 	int status;
776 
777 	queueno = ((pkt[1] >> 4) & 0xf);
778 	if (queueno == RSI_BT_MGMT_Q || queueno == RSI_BT_DATA_Q)
779 		queueno = RSI_BT_Q;
780 
781 	num_blocks = len / block_size;
782 
783 	if (len % block_size)
784 		num_blocks++;
785 
786 	address = (num_blocks * block_size | (queueno << 12));
787 	length  = num_blocks * block_size;
788 
789 	status = rsi_sdio_write_register_multiple(adapter,
790 						  address,
791 						  (u8 *)pkt,
792 						  length);
793 	if (status)
794 		rsi_dbg(ERR_ZONE, "%s: Unable to write onto the card: %d\n",
795 			__func__, status);
796 	rsi_dbg(DATA_TX_ZONE, "%s: Successfully written onto card\n", __func__);
797 	return status;
798 }
799 
800 /**
801  * rsi_sdio_host_intf_read_pkt() - This function reads the packet
802 				   from the device.
803  * @adapter: Pointer to the adapter data structure.
804  * @pkt: Pointer to the packet data to be read from the the device.
805  * @length: Length of the data to be read from the device.
806  *
807  * Return: 0 on success, -1 on failure.
808  */
809 int rsi_sdio_host_intf_read_pkt(struct rsi_hw *adapter,
810 				u8 *pkt,
811 				u32 length)
812 {
813 	int status = -EINVAL;
814 
815 	if (!length) {
816 		rsi_dbg(ERR_ZONE, "%s: Pkt size is zero\n", __func__);
817 		return status;
818 	}
819 
820 	status = rsi_sdio_read_register_multiple(adapter,
821 						 length,
822 						 (u8 *)pkt,
823 						 length); /*num of bytes*/
824 
825 	if (status)
826 		rsi_dbg(ERR_ZONE, "%s: Failed to read frame: %d\n", __func__,
827 			status);
828 	return status;
829 }
830 
831 /**
832  * rsi_init_sdio_interface() - This function does init specific to SDIO.
833  *
834  * @adapter: Pointer to the adapter data structure.
835  * @pkt: Pointer to the packet data to be read from the the device.
836  *
837  * Return: 0 on success, -1 on failure.
838  */
839 
840 static int rsi_init_sdio_interface(struct rsi_hw *adapter,
841 				   struct sdio_func *pfunction)
842 {
843 	struct rsi_91x_sdiodev *rsi_91x_dev;
844 	int status = -ENOMEM;
845 
846 	rsi_91x_dev = kzalloc(sizeof(*rsi_91x_dev), GFP_KERNEL);
847 	if (!rsi_91x_dev)
848 		return status;
849 
850 	adapter->rsi_dev = rsi_91x_dev;
851 
852 	sdio_claim_host(pfunction);
853 
854 	pfunction->enable_timeout = 100;
855 	status = sdio_enable_func(pfunction);
856 	if (status) {
857 		rsi_dbg(ERR_ZONE, "%s: Failed to enable interface\n", __func__);
858 		sdio_release_host(pfunction);
859 		return status;
860 	}
861 
862 	rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__);
863 
864 	rsi_91x_dev->pfunction = pfunction;
865 	adapter->device = &pfunction->dev;
866 
867 	sdio_set_drvdata(pfunction, adapter);
868 
869 	status = rsi_setupcard(adapter);
870 	if (status) {
871 		rsi_dbg(ERR_ZONE, "%s: Failed to setup card\n", __func__);
872 		goto fail;
873 	}
874 
875 	rsi_dbg(INIT_ZONE, "%s: Setup card succesfully\n", __func__);
876 
877 	status = rsi_init_sdio_slave_regs(adapter);
878 	if (status) {
879 		rsi_dbg(ERR_ZONE, "%s: Failed to init slave regs\n", __func__);
880 		goto fail;
881 	}
882 	sdio_release_host(pfunction);
883 
884 	adapter->determine_event_timeout = rsi_sdio_determine_event_timeout;
885 	adapter->check_hw_queue_status = rsi_sdio_check_buffer_status;
886 
887 #ifdef CONFIG_RSI_DEBUGFS
888 	adapter->num_debugfs_entries = MAX_DEBUGFS_ENTRIES;
889 #endif
890 	return status;
891 fail:
892 	sdio_disable_func(pfunction);
893 	sdio_release_host(pfunction);
894 	return status;
895 }
896 
897 static int rsi_sdio_reinit_device(struct rsi_hw *adapter)
898 {
899 	struct rsi_91x_sdiodev *sdev = adapter->rsi_dev;
900 	struct sdio_func *pfunction = sdev->pfunction;
901 	int ii;
902 
903 	for (ii = 0; ii < NUM_SOFT_QUEUES; ii++)
904 		skb_queue_purge(&adapter->priv->tx_queue[ii]);
905 
906 	/* Initialize device again */
907 	sdio_claim_host(pfunction);
908 
909 	sdio_release_irq(pfunction);
910 	rsi_reset_card(pfunction);
911 
912 	sdio_enable_func(pfunction);
913 	rsi_setupcard(adapter);
914 	rsi_init_sdio_slave_regs(adapter);
915 	sdio_claim_irq(pfunction, rsi_handle_interrupt);
916 	rsi_hal_device_init(adapter);
917 
918 	sdio_release_host(pfunction);
919 
920 	return 0;
921 }
922 
923 static struct rsi_host_intf_ops sdio_host_intf_ops = {
924 	.write_pkt		= rsi_sdio_host_intf_write_pkt,
925 	.read_pkt		= rsi_sdio_host_intf_read_pkt,
926 	.master_access_msword	= rsi_sdio_master_access_msword,
927 	.read_reg_multiple	= rsi_sdio_read_register_multiple,
928 	.write_reg_multiple	= rsi_sdio_write_register_multiple,
929 	.master_reg_read	= rsi_sdio_master_reg_read,
930 	.master_reg_write	= rsi_sdio_master_reg_write,
931 	.load_data_master_write	= rsi_sdio_load_data_master_write,
932 	.reinit_device          = rsi_sdio_reinit_device,
933 };
934 
935 /**
936  * rsi_probe() - This function is called by kernel when the driver provided
937  *		 Vendor and device IDs are matched. All the initialization
938  *		 work is done here.
939  * @pfunction: Pointer to the sdio_func structure.
940  * @id: Pointer to sdio_device_id structure.
941  *
942  * Return: 0 on success, 1 on failure.
943  */
944 static int rsi_probe(struct sdio_func *pfunction,
945 		     const struct sdio_device_id *id)
946 {
947 	struct rsi_hw *adapter;
948 	struct rsi_91x_sdiodev *sdev;
949 	int status;
950 
951 	rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__);
952 
953 	adapter = rsi_91x_init(dev_oper_mode);
954 	if (!adapter) {
955 		rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n",
956 			__func__);
957 		return -EINVAL;
958 	}
959 	adapter->rsi_host_intf = RSI_HOST_INTF_SDIO;
960 	adapter->host_intf_ops = &sdio_host_intf_ops;
961 
962 	if (rsi_init_sdio_interface(adapter, pfunction)) {
963 		rsi_dbg(ERR_ZONE, "%s: Failed to init sdio interface\n",
964 			__func__);
965 		status = -EIO;
966 		goto fail_free_adapter;
967 	}
968 	sdev = (struct rsi_91x_sdiodev *)adapter->rsi_dev;
969 	rsi_init_event(&sdev->rx_thread.event);
970 	status = rsi_create_kthread(adapter->priv, &sdev->rx_thread,
971 				    rsi_sdio_rx_thread, "SDIO-RX-Thread");
972 	if (status) {
973 		rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__);
974 		goto fail_kill_thread;
975 	}
976 	skb_queue_head_init(&sdev->rx_q.head);
977 	sdev->rx_q.num_rx_pkts = 0;
978 
979 	sdio_claim_host(pfunction);
980 	if (sdio_claim_irq(pfunction, rsi_handle_interrupt)) {
981 		rsi_dbg(ERR_ZONE, "%s: Failed to request IRQ\n", __func__);
982 		sdio_release_host(pfunction);
983 		status = -EIO;
984 		goto fail_claim_irq;
985 	}
986 	sdio_release_host(pfunction);
987 	rsi_dbg(INIT_ZONE, "%s: Registered Interrupt handler\n", __func__);
988 
989 	if (rsi_hal_device_init(adapter)) {
990 		rsi_dbg(ERR_ZONE, "%s: Failed in device init\n", __func__);
991 		status = -EINVAL;
992 		goto fail_dev_init;
993 	}
994 	rsi_dbg(INFO_ZONE, "===> RSI Device Init Done <===\n");
995 
996 	if (rsi_sdio_master_access_msword(adapter, MISC_CFG_BASE_ADDR)) {
997 		rsi_dbg(ERR_ZONE, "%s: Unable to set ms word reg\n", __func__);
998 		status = -EIO;
999 		goto fail_dev_init;
1000 	}
1001 
1002 	adapter->priv->hibernate_resume = false;
1003 	adapter->priv->reinit_hw = false;
1004 	return 0;
1005 
1006 fail_dev_init:
1007 	sdio_claim_host(pfunction);
1008 	sdio_release_irq(pfunction);
1009 	sdio_release_host(pfunction);
1010 fail_claim_irq:
1011 	rsi_kill_thread(&sdev->rx_thread);
1012 fail_kill_thread:
1013 	sdio_claim_host(pfunction);
1014 	sdio_disable_func(pfunction);
1015 	sdio_release_host(pfunction);
1016 fail_free_adapter:
1017 	rsi_91x_deinit(adapter);
1018 	rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__);
1019 	return status;
1020 }
1021 
1022 static void ulp_read_write(struct rsi_hw *adapter, u16 addr, u32 data,
1023 			   u16 len_in_bits)
1024 {
1025 	rsi_sdio_master_reg_write(adapter, RSI_GSPI_DATA_REG1,
1026 				  ((addr << 6) | ((data >> 16) & 0xffff)), 2);
1027 	rsi_sdio_master_reg_write(adapter, RSI_GSPI_DATA_REG0,
1028 				  (data & 0xffff), 2);
1029 	rsi_sdio_master_reg_write(adapter, RSI_GSPI_CTRL_REG0,
1030 				  RSI_GSPI_CTRL_REG0_VALUE, 2);
1031 	rsi_sdio_master_reg_write(adapter, RSI_GSPI_CTRL_REG1,
1032 				  ((len_in_bits - 1) | RSI_GSPI_TRIG), 2);
1033 	msleep(20);
1034 }
1035 
1036 /*This function resets and re-initializes the chip.*/
1037 static void rsi_reset_chip(struct rsi_hw *adapter)
1038 {
1039 	u8 *data;
1040 	u8 sdio_interrupt_status = 0;
1041 	u8 request = 1;
1042 	int ret;
1043 
1044 	data = kzalloc(sizeof(u32), GFP_KERNEL);
1045 	if (!data)
1046 		return;
1047 
1048 	rsi_dbg(INFO_ZONE, "Writing disable to wakeup register\n");
1049 	ret =  rsi_sdio_write_register(adapter, 0, SDIO_WAKEUP_REG, &request);
1050 	if (ret < 0) {
1051 		rsi_dbg(ERR_ZONE,
1052 			"%s: Failed to write SDIO wakeup register\n", __func__);
1053 		goto err;
1054 	}
1055 	msleep(20);
1056 	ret =  rsi_sdio_read_register(adapter, RSI_FN1_INT_REGISTER,
1057 				      &sdio_interrupt_status);
1058 	if (ret < 0) {
1059 		rsi_dbg(ERR_ZONE, "%s: Failed to Read Intr Status Register\n",
1060 			__func__);
1061 		goto err;
1062 	}
1063 	rsi_dbg(INFO_ZONE, "%s: Intr Status Register value = %d\n",
1064 		__func__, sdio_interrupt_status);
1065 
1066 	/* Put Thread-Arch processor on hold */
1067 	if (rsi_sdio_master_access_msword(adapter, TA_BASE_ADDR)) {
1068 		rsi_dbg(ERR_ZONE,
1069 			"%s: Unable to set ms word to common reg\n",
1070 			__func__);
1071 		goto err;
1072 	}
1073 
1074 	put_unaligned_le32(TA_HOLD_THREAD_VALUE, data);
1075 	if (rsi_sdio_write_register_multiple(adapter, TA_HOLD_THREAD_REG |
1076 					     RSI_SD_REQUEST_MASTER,
1077 					     data, 4)) {
1078 		rsi_dbg(ERR_ZONE,
1079 			"%s: Unable to hold Thread-Arch processor threads\n",
1080 			__func__);
1081 		goto err;
1082 	}
1083 
1084 	/* This msleep will ensure Thread-Arch processor to go to hold
1085 	 * and any pending dma transfers to rf spi in device to finish.
1086 	 */
1087 	msleep(100);
1088 
1089 	ulp_read_write(adapter, RSI_ULP_RESET_REG, RSI_ULP_WRITE_0, 32);
1090 	ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_1, RSI_ULP_WRITE_2, 32);
1091 	ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_2, RSI_ULP_WRITE_0, 32);
1092 	ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_1, RSI_ULP_WRITE_50,
1093 		       32);
1094 	ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_2, RSI_ULP_WRITE_0,
1095 		       32);
1096 	ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_ENABLE,
1097 		       RSI_ULP_TIMER_ENABLE, 32);
1098 	/* This msleep will be sufficient for the ulp
1099 	 * read write operations to complete for chip reset.
1100 	 */
1101 	msleep(500);
1102 err:
1103 	kfree(data);
1104 	return;
1105 }
1106 
1107 /**
1108  * rsi_disconnect() - This function performs the reverse of the probe function.
1109  * @pfunction: Pointer to the sdio_func structure.
1110  *
1111  * Return: void.
1112  */
1113 static void rsi_disconnect(struct sdio_func *pfunction)
1114 {
1115 	struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1116 	struct rsi_91x_sdiodev *dev;
1117 
1118 	if (!adapter)
1119 		return;
1120 
1121 	dev = (struct rsi_91x_sdiodev *)adapter->rsi_dev;
1122 
1123 	rsi_kill_thread(&dev->rx_thread);
1124 	sdio_claim_host(pfunction);
1125 	sdio_release_irq(pfunction);
1126 	sdio_release_host(pfunction);
1127 	mdelay(10);
1128 
1129 	rsi_mac80211_detach(adapter);
1130 	mdelay(10);
1131 
1132 	/* Reset Chip */
1133 	rsi_reset_chip(adapter);
1134 
1135 	/* Resetting to take care of the case, where-in driver is re-loaded */
1136 	sdio_claim_host(pfunction);
1137 	rsi_reset_card(pfunction);
1138 	sdio_disable_func(pfunction);
1139 	sdio_release_host(pfunction);
1140 	dev->write_fail = 2;
1141 	rsi_91x_deinit(adapter);
1142 	rsi_dbg(ERR_ZONE, "##### RSI SDIO device disconnected #####\n");
1143 
1144 }
1145 
1146 #ifdef CONFIG_PM
1147 static int rsi_set_sdio_pm_caps(struct rsi_hw *adapter)
1148 {
1149 	struct rsi_91x_sdiodev *dev =
1150 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
1151 	struct sdio_func *func = dev->pfunction;
1152 	int ret;
1153 
1154 	ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1155 	if (ret)
1156 		rsi_dbg(ERR_ZONE, "Set sdio keep pwr flag failed: %d\n", ret);
1157 
1158 	return ret;
1159 }
1160 
1161 static int rsi_sdio_disable_interrupts(struct sdio_func *pfunc)
1162 {
1163 	struct rsi_hw *adapter = sdio_get_drvdata(pfunc);
1164 	u8 isr_status = 0, data = 0;
1165 	int ret;
1166 	unsigned long t1;
1167 
1168 	rsi_dbg(INFO_ZONE, "Waiting for interrupts to be cleared..");
1169 	t1 = jiffies;
1170 	do {
1171 		rsi_sdio_read_register(adapter, RSI_FN1_INT_REGISTER,
1172 				       &isr_status);
1173 		rsi_dbg(INFO_ZONE, ".");
1174 	} while ((isr_status) && (jiffies_to_msecs(jiffies - t1) < 20));
1175 	rsi_dbg(INFO_ZONE, "Interrupts cleared\n");
1176 
1177 	sdio_claim_host(pfunc);
1178 	ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data);
1179 	if (ret < 0) {
1180 		rsi_dbg(ERR_ZONE,
1181 			"%s: Failed to read int enable register\n",
1182 			__func__);
1183 		goto done;
1184 	}
1185 
1186 	data &= RSI_INT_ENABLE_MASK;
1187 	ret = rsi_cmd52writebyte(pfunc->card, RSI_INT_ENABLE_REGISTER, data);
1188 	if (ret < 0) {
1189 		rsi_dbg(ERR_ZONE,
1190 			"%s: Failed to write to int enable register\n",
1191 			__func__);
1192 		goto done;
1193 	}
1194 	ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data);
1195 	if (ret < 0) {
1196 		rsi_dbg(ERR_ZONE,
1197 			"%s: Failed to read int enable register\n",
1198 			__func__);
1199 		goto done;
1200 	}
1201 	rsi_dbg(INFO_ZONE, "int enable reg content = %x\n", data);
1202 
1203 done:
1204 	sdio_release_host(pfunc);
1205 	return ret;
1206 }
1207 
1208 static int rsi_sdio_enable_interrupts(struct sdio_func *pfunc)
1209 {
1210 	u8 data;
1211 	int ret;
1212 	struct rsi_hw *adapter = sdio_get_drvdata(pfunc);
1213 	struct rsi_common *common = adapter->priv;
1214 
1215 	sdio_claim_host(pfunc);
1216 	ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data);
1217 	if (ret < 0) {
1218 		rsi_dbg(ERR_ZONE,
1219 			"%s: Failed to read int enable register\n", __func__);
1220 		goto done;
1221 	}
1222 
1223 	data |= ~RSI_INT_ENABLE_MASK & 0xff;
1224 
1225 	ret = rsi_cmd52writebyte(pfunc->card, RSI_INT_ENABLE_REGISTER, data);
1226 	if (ret < 0) {
1227 		rsi_dbg(ERR_ZONE,
1228 			"%s: Failed to write to int enable register\n",
1229 			__func__);
1230 		goto done;
1231 	}
1232 
1233 	if ((common->wow_flags & RSI_WOW_ENABLED) &&
1234 	    (common->wow_flags & RSI_WOW_NO_CONNECTION))
1235 		rsi_dbg(ERR_ZONE,
1236 			"##### Device can not wake up through WLAN\n");
1237 
1238 	ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data);
1239 	if (ret < 0) {
1240 		rsi_dbg(ERR_ZONE,
1241 			"%s: Failed to read int enable register\n", __func__);
1242 		goto done;
1243 	}
1244 	rsi_dbg(INFO_ZONE, "int enable reg content = %x\n", data);
1245 
1246 done:
1247 	sdio_release_host(pfunc);
1248 	return ret;
1249 }
1250 
1251 static int rsi_suspend(struct device *dev)
1252 {
1253 	int ret;
1254 	struct sdio_func *pfunction = dev_to_sdio_func(dev);
1255 	struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1256 	struct rsi_common *common;
1257 
1258 	if (!adapter) {
1259 		rsi_dbg(ERR_ZONE, "Device is not ready\n");
1260 		return -ENODEV;
1261 	}
1262 	common = adapter->priv;
1263 	rsi_sdio_disable_interrupts(pfunction);
1264 
1265 	ret = rsi_set_sdio_pm_caps(adapter);
1266 	if (ret)
1267 		rsi_dbg(INFO_ZONE,
1268 			"Setting power management caps failed\n");
1269 	common->fsm_state = FSM_CARD_NOT_READY;
1270 
1271 	return 0;
1272 }
1273 
1274 static int rsi_resume(struct device *dev)
1275 {
1276 	struct sdio_func *pfunction = dev_to_sdio_func(dev);
1277 	struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1278 	struct rsi_common *common = adapter->priv;
1279 
1280 	common->fsm_state = FSM_MAC_INIT_DONE;
1281 	rsi_sdio_enable_interrupts(pfunction);
1282 
1283 	return 0;
1284 }
1285 
1286 static int rsi_freeze(struct device *dev)
1287 {
1288 	int ret;
1289 	struct sdio_func *pfunction = dev_to_sdio_func(dev);
1290 	struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1291 	struct rsi_common *common;
1292 	struct rsi_91x_sdiodev *sdev;
1293 
1294 	rsi_dbg(INFO_ZONE, "SDIO Bus freeze ===>\n");
1295 
1296 	if (!adapter) {
1297 		rsi_dbg(ERR_ZONE, "Device is not ready\n");
1298 		return -ENODEV;
1299 	}
1300 	common = adapter->priv;
1301 	sdev = (struct rsi_91x_sdiodev *)adapter->rsi_dev;
1302 
1303 	if ((common->wow_flags & RSI_WOW_ENABLED) &&
1304 	    (common->wow_flags & RSI_WOW_NO_CONNECTION))
1305 		rsi_dbg(ERR_ZONE,
1306 			"##### Device can not wake up through WLAN\n");
1307 
1308 	ret = rsi_sdio_disable_interrupts(pfunction);
1309 
1310 	if (sdev->write_fail)
1311 		rsi_dbg(INFO_ZONE, "###### Device is not ready #######\n");
1312 
1313 	ret = rsi_set_sdio_pm_caps(adapter);
1314 	if (ret)
1315 		rsi_dbg(INFO_ZONE, "Setting power management caps failed\n");
1316 
1317 	rsi_dbg(INFO_ZONE, "***** RSI module freezed *****\n");
1318 
1319 	return 0;
1320 }
1321 
1322 static int rsi_thaw(struct device *dev)
1323 {
1324 	struct sdio_func *pfunction = dev_to_sdio_func(dev);
1325 	struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1326 	struct rsi_common *common = adapter->priv;
1327 
1328 	rsi_dbg(ERR_ZONE, "SDIO Bus thaw =====>\n");
1329 
1330 	common->hibernate_resume = true;
1331 	common->fsm_state = FSM_CARD_NOT_READY;
1332 	common->iface_down = true;
1333 
1334 	rsi_sdio_enable_interrupts(pfunction);
1335 
1336 	rsi_dbg(INFO_ZONE, "***** RSI module thaw done *****\n");
1337 
1338 	return 0;
1339 }
1340 
1341 static void rsi_shutdown(struct device *dev)
1342 {
1343 	struct sdio_func *pfunction = dev_to_sdio_func(dev);
1344 	struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1345 	struct rsi_91x_sdiodev *sdev =
1346 		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
1347 	struct ieee80211_hw *hw = adapter->hw;
1348 	struct cfg80211_wowlan *wowlan = hw->wiphy->wowlan_config;
1349 
1350 	rsi_dbg(ERR_ZONE, "SDIO Bus shutdown =====>\n");
1351 
1352 	if (rsi_config_wowlan(adapter, wowlan))
1353 		rsi_dbg(ERR_ZONE, "Failed to configure WoWLAN\n");
1354 
1355 	rsi_sdio_disable_interrupts(sdev->pfunction);
1356 
1357 	if (sdev->write_fail)
1358 		rsi_dbg(INFO_ZONE, "###### Device is not ready #######\n");
1359 
1360 	if (rsi_set_sdio_pm_caps(adapter))
1361 		rsi_dbg(INFO_ZONE, "Setting power management caps failed\n");
1362 
1363 	rsi_dbg(INFO_ZONE, "***** RSI module shut down *****\n");
1364 }
1365 
1366 static int rsi_restore(struct device *dev)
1367 {
1368 	struct sdio_func *pfunction = dev_to_sdio_func(dev);
1369 	struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1370 	struct rsi_common *common = adapter->priv;
1371 
1372 	rsi_dbg(INFO_ZONE, "SDIO Bus restore ======>\n");
1373 	common->hibernate_resume = true;
1374 	common->fsm_state = FSM_FW_NOT_LOADED;
1375 	common->iface_down = true;
1376 
1377 	adapter->sc_nvifs = 0;
1378 	ieee80211_restart_hw(adapter->hw);
1379 
1380 	common->wow_flags = 0;
1381 	common->iface_down = false;
1382 
1383 	rsi_dbg(INFO_ZONE, "RSI module restored\n");
1384 
1385 	return 0;
1386 }
1387 static const struct dev_pm_ops rsi_pm_ops = {
1388 	.suspend = rsi_suspend,
1389 	.resume = rsi_resume,
1390 	.freeze = rsi_freeze,
1391 	.thaw = rsi_thaw,
1392 	.restore = rsi_restore,
1393 };
1394 #endif
1395 
1396 static const struct sdio_device_id rsi_dev_table[] =  {
1397 	{ SDIO_DEVICE(RSI_SDIO_VID_9113, RSI_SDIO_PID_9113) },
1398 	{ /* Blank */},
1399 };
1400 
1401 static struct sdio_driver rsi_driver = {
1402 	.name       = "RSI-SDIO WLAN",
1403 	.probe      = rsi_probe,
1404 	.remove     = rsi_disconnect,
1405 	.id_table   = rsi_dev_table,
1406 #ifdef CONFIG_PM
1407 	.drv = {
1408 		.pm = &rsi_pm_ops,
1409 		.shutdown   = rsi_shutdown,
1410 	}
1411 #endif
1412 };
1413 
1414 /**
1415  * rsi_module_init() - This function registers the sdio module.
1416  * @void: Void.
1417  *
1418  * Return: 0 on success.
1419  */
1420 static int rsi_module_init(void)
1421 {
1422 	int ret;
1423 
1424 	ret = sdio_register_driver(&rsi_driver);
1425 	rsi_dbg(INIT_ZONE, "%s: Registering driver\n", __func__);
1426 	return ret;
1427 }
1428 
1429 /**
1430  * rsi_module_exit() - This function unregisters the sdio module.
1431  * @void: Void.
1432  *
1433  * Return: None.
1434  */
1435 static void rsi_module_exit(void)
1436 {
1437 	sdio_unregister_driver(&rsi_driver);
1438 	rsi_dbg(INFO_ZONE, "%s: Unregistering driver\n", __func__);
1439 }
1440 
1441 module_init(rsi_module_init);
1442 module_exit(rsi_module_exit);
1443 
1444 MODULE_AUTHOR("Redpine Signals Inc");
1445 MODULE_DESCRIPTION("Common SDIO layer for RSI drivers");
1446 MODULE_SUPPORTED_DEVICE("RSI-91x");
1447 MODULE_DEVICE_TABLE(sdio, rsi_dev_table);
1448 MODULE_FIRMWARE(FIRMWARE_RSI9113);
1449 MODULE_VERSION("0.1");
1450 MODULE_LICENSE("Dual BSD/GPL");
1451