1 /*
2  * NXP Wireless LAN device driver: SDIO specific handling
3  *
4  * Copyright 2011-2020 NXP
5  *
6  * This software file (the "File") is distributed by NXP
7  * under the terms of the GNU General Public License Version 2, June 1991
8  * (the "License").  You may use, redistribute and/or modify this File in
9  * accordance with the terms and conditions of the License, a copy of which
10  * is available by writing to the Free Software Foundation, Inc.,
11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
13  *
14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
17  * this warranty disclaimer.
18  */
19 
20 #include <linux/firmware.h>
21 
22 #include "decl.h"
23 #include "ioctl.h"
24 #include "util.h"
25 #include "fw.h"
26 #include "main.h"
27 #include "wmm.h"
28 #include "11n.h"
29 #include "sdio.h"
30 
31 
32 #define SDIO_VERSION	"1.0"
33 
34 static void mwifiex_sdio_work(struct work_struct *work);
35 
36 static struct mwifiex_if_ops sdio_ops;
37 
38 static const struct mwifiex_sdio_card_reg mwifiex_reg_sd87xx = {
39 	.start_rd_port = 1,
40 	.start_wr_port = 1,
41 	.base_0_reg = 0x0040,
42 	.base_1_reg = 0x0041,
43 	.poll_reg = 0x30,
44 	.host_int_enable = UP_LD_HOST_INT_MASK | DN_LD_HOST_INT_MASK,
45 	.host_int_rsr_reg = 0x1,
46 	.host_int_mask_reg = 0x02,
47 	.host_int_status_reg = 0x03,
48 	.status_reg_0 = 0x60,
49 	.status_reg_1 = 0x61,
50 	.sdio_int_mask = 0x3f,
51 	.data_port_mask = 0x0000fffe,
52 	.io_port_0_reg = 0x78,
53 	.io_port_1_reg = 0x79,
54 	.io_port_2_reg = 0x7A,
55 	.max_mp_regs = 64,
56 	.rd_bitmap_l = 0x04,
57 	.rd_bitmap_u = 0x05,
58 	.wr_bitmap_l = 0x06,
59 	.wr_bitmap_u = 0x07,
60 	.rd_len_p0_l = 0x08,
61 	.rd_len_p0_u = 0x09,
62 	.card_misc_cfg_reg = 0x6c,
63 	.func1_dump_reg_start = 0x0,
64 	.func1_dump_reg_end = 0x9,
65 	.func1_scratch_reg = 0x60,
66 	.func1_spec_reg_num = 5,
67 	.func1_spec_reg_table = {0x28, 0x30, 0x34, 0x38, 0x3c},
68 };
69 
70 static const struct mwifiex_sdio_card_reg mwifiex_reg_sd8897 = {
71 	.start_rd_port = 0,
72 	.start_wr_port = 0,
73 	.base_0_reg = 0x60,
74 	.base_1_reg = 0x61,
75 	.poll_reg = 0x50,
76 	.host_int_enable = UP_LD_HOST_INT_MASK | DN_LD_HOST_INT_MASK |
77 			CMD_PORT_UPLD_INT_MASK | CMD_PORT_DNLD_INT_MASK,
78 	.host_int_rsr_reg = 0x1,
79 	.host_int_status_reg = 0x03,
80 	.host_int_mask_reg = 0x02,
81 	.status_reg_0 = 0xc0,
82 	.status_reg_1 = 0xc1,
83 	.sdio_int_mask = 0xff,
84 	.data_port_mask = 0xffffffff,
85 	.io_port_0_reg = 0xD8,
86 	.io_port_1_reg = 0xD9,
87 	.io_port_2_reg = 0xDA,
88 	.max_mp_regs = 184,
89 	.rd_bitmap_l = 0x04,
90 	.rd_bitmap_u = 0x05,
91 	.rd_bitmap_1l = 0x06,
92 	.rd_bitmap_1u = 0x07,
93 	.wr_bitmap_l = 0x08,
94 	.wr_bitmap_u = 0x09,
95 	.wr_bitmap_1l = 0x0a,
96 	.wr_bitmap_1u = 0x0b,
97 	.rd_len_p0_l = 0x0c,
98 	.rd_len_p0_u = 0x0d,
99 	.card_misc_cfg_reg = 0xcc,
100 	.card_cfg_2_1_reg = 0xcd,
101 	.cmd_rd_len_0 = 0xb4,
102 	.cmd_rd_len_1 = 0xb5,
103 	.cmd_rd_len_2 = 0xb6,
104 	.cmd_rd_len_3 = 0xb7,
105 	.cmd_cfg_0 = 0xb8,
106 	.cmd_cfg_1 = 0xb9,
107 	.cmd_cfg_2 = 0xba,
108 	.cmd_cfg_3 = 0xbb,
109 	.fw_dump_host_ready = 0xee,
110 	.fw_dump_ctrl = 0xe2,
111 	.fw_dump_start = 0xe3,
112 	.fw_dump_end = 0xea,
113 	.func1_dump_reg_start = 0x0,
114 	.func1_dump_reg_end = 0xb,
115 	.func1_scratch_reg = 0xc0,
116 	.func1_spec_reg_num = 8,
117 	.func1_spec_reg_table = {0x4C, 0x50, 0x54, 0x55, 0x58,
118 				 0x59, 0x5c, 0x5d},
119 };
120 
121 static const struct mwifiex_sdio_card_reg mwifiex_reg_sd8977 = {
122 	.start_rd_port = 0,
123 	.start_wr_port = 0,
124 	.base_0_reg = 0xF8,
125 	.base_1_reg = 0xF9,
126 	.poll_reg = 0x5C,
127 	.host_int_enable = UP_LD_HOST_INT_MASK | DN_LD_HOST_INT_MASK |
128 		CMD_PORT_UPLD_INT_MASK | CMD_PORT_DNLD_INT_MASK,
129 	.host_int_rsr_reg = 0x4,
130 	.host_int_status_reg = 0x0C,
131 	.host_int_mask_reg = 0x08,
132 	.status_reg_0 = 0xE8,
133 	.status_reg_1 = 0xE9,
134 	.sdio_int_mask = 0xff,
135 	.data_port_mask = 0xffffffff,
136 	.io_port_0_reg = 0xE4,
137 	.io_port_1_reg = 0xE5,
138 	.io_port_2_reg = 0xE6,
139 	.max_mp_regs = 196,
140 	.rd_bitmap_l = 0x10,
141 	.rd_bitmap_u = 0x11,
142 	.rd_bitmap_1l = 0x12,
143 	.rd_bitmap_1u = 0x13,
144 	.wr_bitmap_l = 0x14,
145 	.wr_bitmap_u = 0x15,
146 	.wr_bitmap_1l = 0x16,
147 	.wr_bitmap_1u = 0x17,
148 	.rd_len_p0_l = 0x18,
149 	.rd_len_p0_u = 0x19,
150 	.card_misc_cfg_reg = 0xd8,
151 	.card_cfg_2_1_reg = 0xd9,
152 	.cmd_rd_len_0 = 0xc0,
153 	.cmd_rd_len_1 = 0xc1,
154 	.cmd_rd_len_2 = 0xc2,
155 	.cmd_rd_len_3 = 0xc3,
156 	.cmd_cfg_0 = 0xc4,
157 	.cmd_cfg_1 = 0xc5,
158 	.cmd_cfg_2 = 0xc6,
159 	.cmd_cfg_3 = 0xc7,
160 	.fw_dump_host_ready = 0xcc,
161 	.fw_dump_ctrl = 0xf0,
162 	.fw_dump_start = 0xf1,
163 	.fw_dump_end = 0xf8,
164 	.func1_dump_reg_start = 0x10,
165 	.func1_dump_reg_end = 0x17,
166 	.func1_scratch_reg = 0xe8,
167 	.func1_spec_reg_num = 13,
168 	.func1_spec_reg_table = {0x08, 0x58, 0x5C, 0x5D,
169 				 0x60, 0x61, 0x62, 0x64,
170 				 0x65, 0x66, 0x68, 0x69,
171 				 0x6a},
172 };
173 
174 static const struct mwifiex_sdio_card_reg mwifiex_reg_sd8997 = {
175 	.start_rd_port = 0,
176 	.start_wr_port = 0,
177 	.base_0_reg = 0xF8,
178 	.base_1_reg = 0xF9,
179 	.poll_reg = 0x5C,
180 	.host_int_enable = UP_LD_HOST_INT_MASK | DN_LD_HOST_INT_MASK |
181 			CMD_PORT_UPLD_INT_MASK | CMD_PORT_DNLD_INT_MASK,
182 	.host_int_rsr_reg = 0x4,
183 	.host_int_status_reg = 0x0C,
184 	.host_int_mask_reg = 0x08,
185 	.status_reg_0 = 0xE8,
186 	.status_reg_1 = 0xE9,
187 	.sdio_int_mask = 0xff,
188 	.data_port_mask = 0xffffffff,
189 	.io_port_0_reg = 0xE4,
190 	.io_port_1_reg = 0xE5,
191 	.io_port_2_reg = 0xE6,
192 	.max_mp_regs = 196,
193 	.rd_bitmap_l = 0x10,
194 	.rd_bitmap_u = 0x11,
195 	.rd_bitmap_1l = 0x12,
196 	.rd_bitmap_1u = 0x13,
197 	.wr_bitmap_l = 0x14,
198 	.wr_bitmap_u = 0x15,
199 	.wr_bitmap_1l = 0x16,
200 	.wr_bitmap_1u = 0x17,
201 	.rd_len_p0_l = 0x18,
202 	.rd_len_p0_u = 0x19,
203 	.card_misc_cfg_reg = 0xd8,
204 	.card_cfg_2_1_reg = 0xd9,
205 	.cmd_rd_len_0 = 0xc0,
206 	.cmd_rd_len_1 = 0xc1,
207 	.cmd_rd_len_2 = 0xc2,
208 	.cmd_rd_len_3 = 0xc3,
209 	.cmd_cfg_0 = 0xc4,
210 	.cmd_cfg_1 = 0xc5,
211 	.cmd_cfg_2 = 0xc6,
212 	.cmd_cfg_3 = 0xc7,
213 	.fw_dump_host_ready = 0xcc,
214 	.fw_dump_ctrl = 0xf0,
215 	.fw_dump_start = 0xf1,
216 	.fw_dump_end = 0xf8,
217 	.func1_dump_reg_start = 0x10,
218 	.func1_dump_reg_end = 0x17,
219 	.func1_scratch_reg = 0xe8,
220 	.func1_spec_reg_num = 13,
221 	.func1_spec_reg_table = {0x08, 0x58, 0x5C, 0x5D,
222 				 0x60, 0x61, 0x62, 0x64,
223 				 0x65, 0x66, 0x68, 0x69,
224 				 0x6a},
225 };
226 
227 static const struct mwifiex_sdio_card_reg mwifiex_reg_sd8887 = {
228 	.start_rd_port = 0,
229 	.start_wr_port = 0,
230 	.base_0_reg = 0x6C,
231 	.base_1_reg = 0x6D,
232 	.poll_reg = 0x5C,
233 	.host_int_enable = UP_LD_HOST_INT_MASK | DN_LD_HOST_INT_MASK |
234 			CMD_PORT_UPLD_INT_MASK | CMD_PORT_DNLD_INT_MASK,
235 	.host_int_rsr_reg = 0x4,
236 	.host_int_status_reg = 0x0C,
237 	.host_int_mask_reg = 0x08,
238 	.status_reg_0 = 0x90,
239 	.status_reg_1 = 0x91,
240 	.sdio_int_mask = 0xff,
241 	.data_port_mask = 0xffffffff,
242 	.io_port_0_reg = 0xE4,
243 	.io_port_1_reg = 0xE5,
244 	.io_port_2_reg = 0xE6,
245 	.max_mp_regs = 196,
246 	.rd_bitmap_l = 0x10,
247 	.rd_bitmap_u = 0x11,
248 	.rd_bitmap_1l = 0x12,
249 	.rd_bitmap_1u = 0x13,
250 	.wr_bitmap_l = 0x14,
251 	.wr_bitmap_u = 0x15,
252 	.wr_bitmap_1l = 0x16,
253 	.wr_bitmap_1u = 0x17,
254 	.rd_len_p0_l = 0x18,
255 	.rd_len_p0_u = 0x19,
256 	.card_misc_cfg_reg = 0xd8,
257 	.card_cfg_2_1_reg = 0xd9,
258 	.cmd_rd_len_0 = 0xc0,
259 	.cmd_rd_len_1 = 0xc1,
260 	.cmd_rd_len_2 = 0xc2,
261 	.cmd_rd_len_3 = 0xc3,
262 	.cmd_cfg_0 = 0xc4,
263 	.cmd_cfg_1 = 0xc5,
264 	.cmd_cfg_2 = 0xc6,
265 	.cmd_cfg_3 = 0xc7,
266 	.func1_dump_reg_start = 0x10,
267 	.func1_dump_reg_end = 0x17,
268 	.func1_scratch_reg = 0x90,
269 	.func1_spec_reg_num = 13,
270 	.func1_spec_reg_table = {0x08, 0x58, 0x5C, 0x5D, 0x60,
271 				 0x61, 0x62, 0x64, 0x65, 0x66,
272 				 0x68, 0x69, 0x6a},
273 };
274 
275 static const struct mwifiex_sdio_card_reg mwifiex_reg_sd8987 = {
276 	.start_rd_port = 0,
277 	.start_wr_port = 0,
278 	.base_0_reg = 0xF8,
279 	.base_1_reg = 0xF9,
280 	.poll_reg = 0x5C,
281 	.host_int_enable = UP_LD_HOST_INT_MASK | DN_LD_HOST_INT_MASK |
282 			CMD_PORT_UPLD_INT_MASK | CMD_PORT_DNLD_INT_MASK,
283 	.host_int_rsr_reg = 0x4,
284 	.host_int_status_reg = 0x0C,
285 	.host_int_mask_reg = 0x08,
286 	.status_reg_0 = 0xE8,
287 	.status_reg_1 = 0xE9,
288 	.sdio_int_mask = 0xff,
289 	.data_port_mask = 0xffffffff,
290 	.io_port_0_reg = 0xE4,
291 	.io_port_1_reg = 0xE5,
292 	.io_port_2_reg = 0xE6,
293 	.max_mp_regs = 196,
294 	.rd_bitmap_l = 0x10,
295 	.rd_bitmap_u = 0x11,
296 	.rd_bitmap_1l = 0x12,
297 	.rd_bitmap_1u = 0x13,
298 	.wr_bitmap_l = 0x14,
299 	.wr_bitmap_u = 0x15,
300 	.wr_bitmap_1l = 0x16,
301 	.wr_bitmap_1u = 0x17,
302 	.rd_len_p0_l = 0x18,
303 	.rd_len_p0_u = 0x19,
304 	.card_misc_cfg_reg = 0xd8,
305 	.card_cfg_2_1_reg = 0xd9,
306 	.cmd_rd_len_0 = 0xc0,
307 	.cmd_rd_len_1 = 0xc1,
308 	.cmd_rd_len_2 = 0xc2,
309 	.cmd_rd_len_3 = 0xc3,
310 	.cmd_cfg_0 = 0xc4,
311 	.cmd_cfg_1 = 0xc5,
312 	.cmd_cfg_2 = 0xc6,
313 	.cmd_cfg_3 = 0xc7,
314 	.fw_dump_host_ready = 0xcc,
315 	.fw_dump_ctrl = 0xf9,
316 	.fw_dump_start = 0xf1,
317 	.fw_dump_end = 0xf8,
318 	.func1_dump_reg_start = 0x10,
319 	.func1_dump_reg_end = 0x17,
320 	.func1_scratch_reg = 0xE8,
321 	.func1_spec_reg_num = 13,
322 	.func1_spec_reg_table = {0x08, 0x58, 0x5C, 0x5D, 0x60,
323 				 0x61, 0x62, 0x64, 0x65, 0x66,
324 				 0x68, 0x69, 0x6a},
325 };
326 
327 static const struct mwifiex_sdio_device mwifiex_sdio_sd8786 = {
328 	.firmware = SD8786_DEFAULT_FW_NAME,
329 	.reg = &mwifiex_reg_sd87xx,
330 	.max_ports = 16,
331 	.mp_agg_pkt_limit = 8,
332 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K,
333 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_16K,
334 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_16K,
335 	.supports_sdio_new_mode = false,
336 	.has_control_mask = true,
337 	.can_dump_fw = false,
338 	.can_auto_tdls = false,
339 	.can_ext_scan = false,
340 };
341 
342 static const struct mwifiex_sdio_device mwifiex_sdio_sd8787 = {
343 	.firmware = SD8787_DEFAULT_FW_NAME,
344 	.reg = &mwifiex_reg_sd87xx,
345 	.max_ports = 16,
346 	.mp_agg_pkt_limit = 8,
347 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K,
348 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_16K,
349 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_16K,
350 	.supports_sdio_new_mode = false,
351 	.has_control_mask = true,
352 	.can_dump_fw = false,
353 	.can_auto_tdls = false,
354 	.can_ext_scan = true,
355 };
356 
357 static const struct mwifiex_sdio_device mwifiex_sdio_sd8797 = {
358 	.firmware = SD8797_DEFAULT_FW_NAME,
359 	.reg = &mwifiex_reg_sd87xx,
360 	.max_ports = 16,
361 	.mp_agg_pkt_limit = 8,
362 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K,
363 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_16K,
364 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_16K,
365 	.supports_sdio_new_mode = false,
366 	.has_control_mask = true,
367 	.can_dump_fw = false,
368 	.can_auto_tdls = false,
369 	.can_ext_scan = true,
370 };
371 
372 static const struct mwifiex_sdio_device mwifiex_sdio_sd8897 = {
373 	.firmware = SD8897_DEFAULT_FW_NAME,
374 	.reg = &mwifiex_reg_sd8897,
375 	.max_ports = 32,
376 	.mp_agg_pkt_limit = 16,
377 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K,
378 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_MAX,
379 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_MAX,
380 	.supports_sdio_new_mode = true,
381 	.has_control_mask = false,
382 	.can_dump_fw = true,
383 	.can_auto_tdls = false,
384 	.can_ext_scan = true,
385 };
386 
387 static const struct mwifiex_sdio_device mwifiex_sdio_sd8977 = {
388 	.firmware = SD8977_DEFAULT_FW_NAME,
389 	.reg = &mwifiex_reg_sd8977,
390 	.max_ports = 32,
391 	.mp_agg_pkt_limit = 16,
392 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K,
393 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_MAX,
394 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_MAX,
395 	.supports_sdio_new_mode = true,
396 	.has_control_mask = false,
397 	.can_dump_fw = true,
398 	.fw_dump_enh = true,
399 	.can_auto_tdls = false,
400 	.can_ext_scan = true,
401 };
402 
403 static const struct mwifiex_sdio_device mwifiex_sdio_sd8997 = {
404 	.firmware = SD8997_DEFAULT_FW_NAME,
405 	.reg = &mwifiex_reg_sd8997,
406 	.max_ports = 32,
407 	.mp_agg_pkt_limit = 16,
408 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K,
409 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_MAX,
410 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_MAX,
411 	.supports_sdio_new_mode = true,
412 	.has_control_mask = false,
413 	.can_dump_fw = true,
414 	.fw_dump_enh = true,
415 	.can_auto_tdls = false,
416 	.can_ext_scan = true,
417 };
418 
419 static const struct mwifiex_sdio_device mwifiex_sdio_sd8887 = {
420 	.firmware = SD8887_DEFAULT_FW_NAME,
421 	.reg = &mwifiex_reg_sd8887,
422 	.max_ports = 32,
423 	.mp_agg_pkt_limit = 16,
424 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K,
425 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_32K,
426 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_32K,
427 	.supports_sdio_new_mode = true,
428 	.has_control_mask = false,
429 	.can_dump_fw = false,
430 	.can_auto_tdls = true,
431 	.can_ext_scan = true,
432 };
433 
434 static const struct mwifiex_sdio_device mwifiex_sdio_sd8987 = {
435 	.firmware = SD8987_DEFAULT_FW_NAME,
436 	.reg = &mwifiex_reg_sd8987,
437 	.max_ports = 32,
438 	.mp_agg_pkt_limit = 16,
439 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K,
440 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_MAX,
441 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_MAX,
442 	.supports_sdio_new_mode = true,
443 	.has_control_mask = false,
444 	.can_dump_fw = true,
445 	.fw_dump_enh = true,
446 	.can_auto_tdls = true,
447 	.can_ext_scan = true,
448 };
449 
450 static const struct mwifiex_sdio_device mwifiex_sdio_sd8801 = {
451 	.firmware = SD8801_DEFAULT_FW_NAME,
452 	.reg = &mwifiex_reg_sd87xx,
453 	.max_ports = 16,
454 	.mp_agg_pkt_limit = 8,
455 	.supports_sdio_new_mode = false,
456 	.has_control_mask = true,
457 	.tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K,
458 	.mp_tx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_16K,
459 	.mp_rx_agg_buf_size = MWIFIEX_MP_AGGR_BUF_SIZE_16K,
460 	.can_dump_fw = false,
461 	.can_auto_tdls = false,
462 	.can_ext_scan = true,
463 };
464 
465 static struct memory_type_mapping generic_mem_type_map[] = {
466 	{"DUMP", NULL, 0, 0xDD},
467 };
468 
469 static struct memory_type_mapping mem_type_mapping_tbl[] = {
470 	{"ITCM", NULL, 0, 0xF0},
471 	{"DTCM", NULL, 0, 0xF1},
472 	{"SQRAM", NULL, 0, 0xF2},
473 	{"APU", NULL, 0, 0xF3},
474 	{"CIU", NULL, 0, 0xF4},
475 	{"ICU", NULL, 0, 0xF5},
476 	{"MAC", NULL, 0, 0xF6},
477 	{"EXT7", NULL, 0, 0xF7},
478 	{"EXT8", NULL, 0, 0xF8},
479 	{"EXT9", NULL, 0, 0xF9},
480 	{"EXT10", NULL, 0, 0xFA},
481 	{"EXT11", NULL, 0, 0xFB},
482 	{"EXT12", NULL, 0, 0xFC},
483 	{"EXT13", NULL, 0, 0xFD},
484 	{"EXTLAST", NULL, 0, 0xFE},
485 };
486 
487 static const struct of_device_id mwifiex_sdio_of_match_table[] = {
488 	{ .compatible = "marvell,sd8897" },
489 	{ .compatible = "marvell,sd8997" },
490 	{ }
491 };
492 
493 /* This function parse device tree node using mmc subnode devicetree API.
494  * The device node is saved in card->plt_of_node.
495  * if the device tree node exist and include interrupts attributes, this
496  * function will also request platform specific wakeup interrupt.
497  */
498 static int mwifiex_sdio_probe_of(struct device *dev)
499 {
500 	if (!of_match_node(mwifiex_sdio_of_match_table, dev->of_node)) {
501 		dev_err(dev, "required compatible string missing\n");
502 		return -EINVAL;
503 	}
504 
505 	return 0;
506 }
507 
508 /*
509  * SDIO probe.
510  *
511  * This function probes an mwifiex device and registers it. It allocates
512  * the card structure, enables SDIO function number and initiates the
513  * device registration and initialization procedure by adding a logical
514  * interface.
515  */
516 static int
517 mwifiex_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id)
518 {
519 	int ret;
520 	struct sdio_mmc_card *card = NULL;
521 
522 	pr_debug("info: vendor=0x%4.04X device=0x%4.04X class=%d function=%d\n",
523 		 func->vendor, func->device, func->class, func->num);
524 
525 	card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL);
526 	if (!card)
527 		return -ENOMEM;
528 
529 	init_completion(&card->fw_done);
530 
531 	card->func = func;
532 
533 	func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
534 
535 	if (id->driver_data) {
536 		struct mwifiex_sdio_device *data = (void *)id->driver_data;
537 
538 		card->firmware = data->firmware;
539 		card->reg = data->reg;
540 		card->max_ports = data->max_ports;
541 		card->mp_agg_pkt_limit = data->mp_agg_pkt_limit;
542 		card->supports_sdio_new_mode = data->supports_sdio_new_mode;
543 		card->has_control_mask = data->has_control_mask;
544 		card->tx_buf_size = data->tx_buf_size;
545 		card->mp_tx_agg_buf_size = data->mp_tx_agg_buf_size;
546 		card->mp_rx_agg_buf_size = data->mp_rx_agg_buf_size;
547 		card->can_dump_fw = data->can_dump_fw;
548 		card->fw_dump_enh = data->fw_dump_enh;
549 		card->can_auto_tdls = data->can_auto_tdls;
550 		card->can_ext_scan = data->can_ext_scan;
551 		INIT_WORK(&card->work, mwifiex_sdio_work);
552 	}
553 
554 	sdio_claim_host(func);
555 	ret = sdio_enable_func(func);
556 	sdio_release_host(func);
557 
558 	if (ret) {
559 		dev_err(&func->dev, "failed to enable function\n");
560 		return ret;
561 	}
562 
563 	/* device tree node parsing and platform specific configuration*/
564 	if (func->dev.of_node) {
565 		ret = mwifiex_sdio_probe_of(&func->dev);
566 		if (ret)
567 			goto err_disable;
568 	}
569 
570 	ret = mwifiex_add_card(card, &card->fw_done, &sdio_ops,
571 			       MWIFIEX_SDIO, &func->dev);
572 	if (ret) {
573 		dev_err(&func->dev, "add card failed\n");
574 		goto err_disable;
575 	}
576 
577 	return 0;
578 
579 err_disable:
580 	sdio_claim_host(func);
581 	sdio_disable_func(func);
582 	sdio_release_host(func);
583 
584 	return ret;
585 }
586 
587 /*
588  * SDIO resume.
589  *
590  * Kernel needs to suspend all functions separately. Therefore all
591  * registered functions must have drivers with suspend and resume
592  * methods. Failing that the kernel simply removes the whole card.
593  *
594  * If already not resumed, this function turns on the traffic and
595  * sends a host sleep cancel request to the firmware.
596  */
597 static int mwifiex_sdio_resume(struct device *dev)
598 {
599 	struct sdio_func *func = dev_to_sdio_func(dev);
600 	struct sdio_mmc_card *card;
601 	struct mwifiex_adapter *adapter;
602 
603 	card = sdio_get_drvdata(func);
604 	if (!card || !card->adapter) {
605 		dev_err(dev, "resume: invalid card or adapter\n");
606 		return 0;
607 	}
608 
609 	adapter = card->adapter;
610 
611 	if (!test_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags)) {
612 		mwifiex_dbg(adapter, WARN,
613 			    "device already resumed\n");
614 		return 0;
615 	}
616 
617 	clear_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags);
618 
619 	/* Disable Host Sleep */
620 	mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
621 			  MWIFIEX_SYNC_CMD);
622 
623 	mwifiex_disable_wake(adapter);
624 
625 	return 0;
626 }
627 
628 /* Write data into SDIO card register. Caller claims SDIO device. */
629 static int
630 mwifiex_write_reg_locked(struct sdio_func *func, u32 reg, u8 data)
631 {
632 	int ret = -1;
633 
634 	sdio_writeb(func, data, reg, &ret);
635 	return ret;
636 }
637 
638 /* This function writes data into SDIO card register.
639  */
640 static int
641 mwifiex_write_reg(struct mwifiex_adapter *adapter, u32 reg, u8 data)
642 {
643 	struct sdio_mmc_card *card = adapter->card;
644 	int ret;
645 
646 	sdio_claim_host(card->func);
647 	ret = mwifiex_write_reg_locked(card->func, reg, data);
648 	sdio_release_host(card->func);
649 
650 	return ret;
651 }
652 
653 /* This function reads data from SDIO card register.
654  */
655 static int
656 mwifiex_read_reg(struct mwifiex_adapter *adapter, u32 reg, u8 *data)
657 {
658 	struct sdio_mmc_card *card = adapter->card;
659 	int ret = -1;
660 	u8 val;
661 
662 	sdio_claim_host(card->func);
663 	val = sdio_readb(card->func, reg, &ret);
664 	sdio_release_host(card->func);
665 
666 	*data = val;
667 
668 	return ret;
669 }
670 
671 /* This function writes multiple data into SDIO card memory.
672  *
673  * This does not work in suspended mode.
674  */
675 static int
676 mwifiex_write_data_sync(struct mwifiex_adapter *adapter,
677 			u8 *buffer, u32 pkt_len, u32 port)
678 {
679 	struct sdio_mmc_card *card = adapter->card;
680 	int ret;
681 	u8 blk_mode =
682 		(port & MWIFIEX_SDIO_BYTE_MODE_MASK) ? BYTE_MODE : BLOCK_MODE;
683 	u32 blk_size = (blk_mode == BLOCK_MODE) ? MWIFIEX_SDIO_BLOCK_SIZE : 1;
684 	u32 blk_cnt =
685 		(blk_mode ==
686 		 BLOCK_MODE) ? (pkt_len /
687 				MWIFIEX_SDIO_BLOCK_SIZE) : pkt_len;
688 	u32 ioport = (port & MWIFIEX_SDIO_IO_PORT_MASK);
689 
690 	if (test_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags)) {
691 		mwifiex_dbg(adapter, ERROR,
692 			    "%s: not allowed while suspended\n", __func__);
693 		return -1;
694 	}
695 
696 	sdio_claim_host(card->func);
697 
698 	ret = sdio_writesb(card->func, ioport, buffer, blk_cnt * blk_size);
699 
700 	sdio_release_host(card->func);
701 
702 	return ret;
703 }
704 
705 /* This function reads multiple data from SDIO card memory.
706  */
707 static int mwifiex_read_data_sync(struct mwifiex_adapter *adapter, u8 *buffer,
708 				  u32 len, u32 port, u8 claim)
709 {
710 	struct sdio_mmc_card *card = adapter->card;
711 	int ret;
712 	u8 blk_mode = (port & MWIFIEX_SDIO_BYTE_MODE_MASK) ? BYTE_MODE
713 		       : BLOCK_MODE;
714 	u32 blk_size = (blk_mode == BLOCK_MODE) ? MWIFIEX_SDIO_BLOCK_SIZE : 1;
715 	u32 blk_cnt = (blk_mode == BLOCK_MODE) ? (len / MWIFIEX_SDIO_BLOCK_SIZE)
716 			: len;
717 	u32 ioport = (port & MWIFIEX_SDIO_IO_PORT_MASK);
718 
719 	if (claim)
720 		sdio_claim_host(card->func);
721 
722 	ret = sdio_readsb(card->func, buffer, ioport, blk_cnt * blk_size);
723 
724 	if (claim)
725 		sdio_release_host(card->func);
726 
727 	return ret;
728 }
729 
730 /* This function reads the firmware status.
731  */
732 static int
733 mwifiex_sdio_read_fw_status(struct mwifiex_adapter *adapter, u16 *dat)
734 {
735 	struct sdio_mmc_card *card = adapter->card;
736 	const struct mwifiex_sdio_card_reg *reg = card->reg;
737 	u8 fws0, fws1;
738 
739 	if (mwifiex_read_reg(adapter, reg->status_reg_0, &fws0))
740 		return -1;
741 
742 	if (mwifiex_read_reg(adapter, reg->status_reg_1, &fws1))
743 		return -1;
744 
745 	*dat = (u16)((fws1 << 8) | fws0);
746 	return 0;
747 }
748 
749 /* This function checks the firmware status in card.
750  */
751 static int mwifiex_check_fw_status(struct mwifiex_adapter *adapter,
752 				   u32 poll_num)
753 {
754 	int ret = 0;
755 	u16 firmware_stat;
756 	u32 tries;
757 
758 	for (tries = 0; tries < poll_num; tries++) {
759 		ret = mwifiex_sdio_read_fw_status(adapter, &firmware_stat);
760 		if (ret)
761 			continue;
762 		if (firmware_stat == FIRMWARE_READY_SDIO) {
763 			ret = 0;
764 			break;
765 		}
766 
767 		msleep(100);
768 		ret = -1;
769 	}
770 
771 	return ret;
772 }
773 
774 /* This function checks if WLAN is the winner.
775  */
776 static int mwifiex_check_winner_status(struct mwifiex_adapter *adapter)
777 {
778 	int ret = 0;
779 	u8 winner = 0;
780 	struct sdio_mmc_card *card = adapter->card;
781 
782 	if (mwifiex_read_reg(adapter, card->reg->status_reg_0, &winner))
783 		return -1;
784 
785 	if (winner)
786 		adapter->winner = 0;
787 	else
788 		adapter->winner = 1;
789 
790 	return ret;
791 }
792 
793 /*
794  * SDIO remove.
795  *
796  * This function removes the interface and frees up the card structure.
797  */
798 static void
799 mwifiex_sdio_remove(struct sdio_func *func)
800 {
801 	struct sdio_mmc_card *card;
802 	struct mwifiex_adapter *adapter;
803 	struct mwifiex_private *priv;
804 	int ret = 0;
805 	u16 firmware_stat;
806 
807 	card = sdio_get_drvdata(func);
808 	if (!card)
809 		return;
810 
811 	wait_for_completion(&card->fw_done);
812 
813 	adapter = card->adapter;
814 	if (!adapter || !adapter->priv_num)
815 		return;
816 
817 	mwifiex_dbg(adapter, INFO, "info: SDIO func num=%d\n", func->num);
818 
819 	ret = mwifiex_sdio_read_fw_status(adapter, &firmware_stat);
820 	if (!ret && firmware_stat == FIRMWARE_READY_SDIO &&
821 	    !adapter->mfg_mode) {
822 		mwifiex_deauthenticate_all(adapter);
823 
824 		priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
825 		mwifiex_disable_auto_ds(priv);
826 		mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
827 	}
828 
829 	mwifiex_remove_card(adapter);
830 }
831 
832 /*
833  * SDIO suspend.
834  *
835  * Kernel needs to suspend all functions separately. Therefore all
836  * registered functions must have drivers with suspend and resume
837  * methods. Failing that the kernel simply removes the whole card.
838  *
839  * If already not suspended, this function allocates and sends a host
840  * sleep activate request to the firmware and turns off the traffic.
841  */
842 static int mwifiex_sdio_suspend(struct device *dev)
843 {
844 	struct sdio_func *func = dev_to_sdio_func(dev);
845 	struct sdio_mmc_card *card;
846 	struct mwifiex_adapter *adapter;
847 	mmc_pm_flag_t pm_flag = 0;
848 	int ret = 0;
849 
850 	pm_flag = sdio_get_host_pm_caps(func);
851 	pr_debug("cmd: %s: suspend: PM flag = 0x%x\n",
852 		 sdio_func_id(func), pm_flag);
853 	if (!(pm_flag & MMC_PM_KEEP_POWER)) {
854 		dev_err(dev, "%s: cannot remain alive while host is"
855 			" suspended\n", sdio_func_id(func));
856 		return -ENOSYS;
857 	}
858 
859 	card = sdio_get_drvdata(func);
860 	if (!card) {
861 		dev_err(dev, "suspend: invalid card\n");
862 		return 0;
863 	}
864 
865 	/* Might still be loading firmware */
866 	wait_for_completion(&card->fw_done);
867 
868 	adapter = card->adapter;
869 	if (!adapter) {
870 		dev_err(dev, "adapter is not valid\n");
871 		return 0;
872 	}
873 
874 	if (!adapter->is_up)
875 		return -EBUSY;
876 
877 	mwifiex_enable_wake(adapter);
878 
879 	/* Enable the Host Sleep */
880 	if (!mwifiex_enable_hs(adapter)) {
881 		mwifiex_dbg(adapter, ERROR,
882 			    "cmd: failed to suspend\n");
883 		clear_bit(MWIFIEX_IS_HS_ENABLING, &adapter->work_flags);
884 		mwifiex_disable_wake(adapter);
885 		return -EFAULT;
886 	}
887 
888 	mwifiex_dbg(adapter, INFO,
889 		    "cmd: suspend with MMC_PM_KEEP_POWER\n");
890 	ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
891 
892 	/* Indicate device suspended */
893 	set_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags);
894 	clear_bit(MWIFIEX_IS_HS_ENABLING, &adapter->work_flags);
895 
896 	return ret;
897 }
898 
899 static void mwifiex_sdio_coredump(struct device *dev)
900 {
901 	struct sdio_func *func = dev_to_sdio_func(dev);
902 	struct sdio_mmc_card *card;
903 
904 	card = sdio_get_drvdata(func);
905 	if (!test_and_set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
906 			      &card->work_flags))
907 		schedule_work(&card->work);
908 }
909 
910 /* WLAN IDs */
911 static const struct sdio_device_id mwifiex_ids[] = {
912 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8786_WLAN),
913 		.driver_data = (unsigned long) &mwifiex_sdio_sd8786},
914 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8787_WLAN),
915 		.driver_data = (unsigned long) &mwifiex_sdio_sd8787},
916 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8797_WLAN),
917 		.driver_data = (unsigned long) &mwifiex_sdio_sd8797},
918 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8897_WLAN),
919 		.driver_data = (unsigned long) &mwifiex_sdio_sd8897},
920 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8887_WLAN),
921 		.driver_data = (unsigned long)&mwifiex_sdio_sd8887},
922 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8801_WLAN),
923 		.driver_data = (unsigned long)&mwifiex_sdio_sd8801},
924 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8977_WLAN),
925 		.driver_data = (unsigned long)&mwifiex_sdio_sd8977},
926 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8987_WLAN),
927 		.driver_data = (unsigned long)&mwifiex_sdio_sd8987},
928 	{SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8997_WLAN),
929 		.driver_data = (unsigned long)&mwifiex_sdio_sd8997},
930 	{},
931 };
932 
933 MODULE_DEVICE_TABLE(sdio, mwifiex_ids);
934 
935 static const struct dev_pm_ops mwifiex_sdio_pm_ops = {
936 	.suspend = mwifiex_sdio_suspend,
937 	.resume = mwifiex_sdio_resume,
938 };
939 
940 static struct sdio_driver mwifiex_sdio = {
941 	.name = "mwifiex_sdio",
942 	.id_table = mwifiex_ids,
943 	.probe = mwifiex_sdio_probe,
944 	.remove = mwifiex_sdio_remove,
945 	.drv = {
946 		.owner = THIS_MODULE,
947 		.coredump = mwifiex_sdio_coredump,
948 		.pm = &mwifiex_sdio_pm_ops,
949 	}
950 };
951 
952 /*
953  * This function wakes up the card.
954  *
955  * A host power up command is written to the card configuration
956  * register to wake up the card.
957  */
958 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
959 {
960 	mwifiex_dbg(adapter, EVENT,
961 		    "event: wakeup device...\n");
962 
963 	return mwifiex_write_reg(adapter, CONFIGURATION_REG, HOST_POWER_UP);
964 }
965 
966 /*
967  * This function is called after the card has woken up.
968  *
969  * The card configuration register is reset.
970  */
971 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
972 {
973 	mwifiex_dbg(adapter, EVENT,
974 		    "cmd: wakeup device completed\n");
975 
976 	return mwifiex_write_reg(adapter, CONFIGURATION_REG, 0);
977 }
978 
979 static int mwifiex_sdio_dnld_fw(struct mwifiex_adapter *adapter,
980 			struct mwifiex_fw_image *fw)
981 {
982 	struct sdio_mmc_card *card = adapter->card;
983 	int ret;
984 
985 	sdio_claim_host(card->func);
986 	ret = mwifiex_dnld_fw(adapter, fw);
987 	sdio_release_host(card->func);
988 
989 	return ret;
990 }
991 
992 /*
993  * This function is used to initialize IO ports for the
994  * chipsets supporting SDIO new mode eg SD8897.
995  */
996 static int mwifiex_init_sdio_new_mode(struct mwifiex_adapter *adapter)
997 {
998 	u8 reg;
999 	struct sdio_mmc_card *card = adapter->card;
1000 
1001 	adapter->ioport = MEM_PORT;
1002 
1003 	/* enable sdio new mode */
1004 	if (mwifiex_read_reg(adapter, card->reg->card_cfg_2_1_reg, &reg))
1005 		return -1;
1006 	if (mwifiex_write_reg(adapter, card->reg->card_cfg_2_1_reg,
1007 			      reg | CMD53_NEW_MODE))
1008 		return -1;
1009 
1010 	/* Configure cmd port and enable reading rx length from the register */
1011 	if (mwifiex_read_reg(adapter, card->reg->cmd_cfg_0, &reg))
1012 		return -1;
1013 	if (mwifiex_write_reg(adapter, card->reg->cmd_cfg_0,
1014 			      reg | CMD_PORT_RD_LEN_EN))
1015 		return -1;
1016 
1017 	/* Enable Dnld/Upld ready auto reset for cmd port after cmd53 is
1018 	 * completed
1019 	 */
1020 	if (mwifiex_read_reg(adapter, card->reg->cmd_cfg_1, &reg))
1021 		return -1;
1022 	if (mwifiex_write_reg(adapter, card->reg->cmd_cfg_1,
1023 			      reg | CMD_PORT_AUTO_EN))
1024 		return -1;
1025 
1026 	return 0;
1027 }
1028 
1029 /* This function initializes the IO ports.
1030  *
1031  * The following operations are performed -
1032  *      - Read the IO ports (0, 1 and 2)
1033  *      - Set host interrupt Reset-To-Read to clear
1034  *      - Set auto re-enable interrupt
1035  */
1036 static int mwifiex_init_sdio_ioport(struct mwifiex_adapter *adapter)
1037 {
1038 	u8 reg;
1039 	struct sdio_mmc_card *card = adapter->card;
1040 
1041 	adapter->ioport = 0;
1042 
1043 	if (card->supports_sdio_new_mode) {
1044 		if (mwifiex_init_sdio_new_mode(adapter))
1045 			return -1;
1046 		goto cont;
1047 	}
1048 
1049 	/* Read the IO port */
1050 	if (!mwifiex_read_reg(adapter, card->reg->io_port_0_reg, &reg))
1051 		adapter->ioport |= (reg & 0xff);
1052 	else
1053 		return -1;
1054 
1055 	if (!mwifiex_read_reg(adapter, card->reg->io_port_1_reg, &reg))
1056 		adapter->ioport |= ((reg & 0xff) << 8);
1057 	else
1058 		return -1;
1059 
1060 	if (!mwifiex_read_reg(adapter, card->reg->io_port_2_reg, &reg))
1061 		adapter->ioport |= ((reg & 0xff) << 16);
1062 	else
1063 		return -1;
1064 cont:
1065 	mwifiex_dbg(adapter, INFO,
1066 		    "info: SDIO FUNC1 IO port: %#x\n", adapter->ioport);
1067 
1068 	/* Set Host interrupt reset to read to clear */
1069 	if (!mwifiex_read_reg(adapter, card->reg->host_int_rsr_reg, &reg))
1070 		mwifiex_write_reg(adapter, card->reg->host_int_rsr_reg,
1071 				  reg | card->reg->sdio_int_mask);
1072 	else
1073 		return -1;
1074 
1075 	/* Dnld/Upld ready set to auto reset */
1076 	if (!mwifiex_read_reg(adapter, card->reg->card_misc_cfg_reg, &reg))
1077 		mwifiex_write_reg(adapter, card->reg->card_misc_cfg_reg,
1078 				  reg | AUTO_RE_ENABLE_INT);
1079 	else
1080 		return -1;
1081 
1082 	return 0;
1083 }
1084 
1085 /*
1086  * This function sends data to the card.
1087  */
1088 static int mwifiex_write_data_to_card(struct mwifiex_adapter *adapter,
1089 				      u8 *payload, u32 pkt_len, u32 port)
1090 {
1091 	u32 i = 0;
1092 	int ret;
1093 
1094 	do {
1095 		ret = mwifiex_write_data_sync(adapter, payload, pkt_len, port);
1096 		if (ret) {
1097 			i++;
1098 			mwifiex_dbg(adapter, ERROR,
1099 				    "host_to_card, write iomem\t"
1100 				    "(%d) failed: %d\n", i, ret);
1101 			if (mwifiex_write_reg(adapter, CONFIGURATION_REG, 0x04))
1102 				mwifiex_dbg(adapter, ERROR,
1103 					    "write CFG reg failed\n");
1104 
1105 			ret = -1;
1106 			if (i > MAX_WRITE_IOMEM_RETRY)
1107 				return ret;
1108 		}
1109 	} while (ret == -1);
1110 
1111 	return ret;
1112 }
1113 
1114 /*
1115  * This function gets the read port.
1116  *
1117  * If control port bit is set in MP read bitmap, the control port
1118  * is returned, otherwise the current read port is returned and
1119  * the value is increased (provided it does not reach the maximum
1120  * limit, in which case it is reset to 1)
1121  */
1122 static int mwifiex_get_rd_port(struct mwifiex_adapter *adapter, u8 *port)
1123 {
1124 	struct sdio_mmc_card *card = adapter->card;
1125 	const struct mwifiex_sdio_card_reg *reg = card->reg;
1126 	u32 rd_bitmap = card->mp_rd_bitmap;
1127 
1128 	mwifiex_dbg(adapter, DATA,
1129 		    "data: mp_rd_bitmap=0x%08x\n", rd_bitmap);
1130 
1131 	if (card->supports_sdio_new_mode) {
1132 		if (!(rd_bitmap & reg->data_port_mask))
1133 			return -1;
1134 	} else {
1135 		if (!(rd_bitmap & (CTRL_PORT_MASK | reg->data_port_mask)))
1136 			return -1;
1137 	}
1138 
1139 	if ((card->has_control_mask) &&
1140 	    (card->mp_rd_bitmap & CTRL_PORT_MASK)) {
1141 		card->mp_rd_bitmap &= (u32) (~CTRL_PORT_MASK);
1142 		*port = CTRL_PORT;
1143 		mwifiex_dbg(adapter, DATA,
1144 			    "data: port=%d mp_rd_bitmap=0x%08x\n",
1145 			    *port, card->mp_rd_bitmap);
1146 		return 0;
1147 	}
1148 
1149 	if (!(card->mp_rd_bitmap & (1 << card->curr_rd_port)))
1150 		return -1;
1151 
1152 	/* We are now handling the SDIO data ports */
1153 	card->mp_rd_bitmap &= (u32)(~(1 << card->curr_rd_port));
1154 	*port = card->curr_rd_port;
1155 
1156 	if (++card->curr_rd_port == card->max_ports)
1157 		card->curr_rd_port = reg->start_rd_port;
1158 
1159 	mwifiex_dbg(adapter, DATA,
1160 		    "data: port=%d mp_rd_bitmap=0x%08x -> 0x%08x\n",
1161 		    *port, rd_bitmap, card->mp_rd_bitmap);
1162 
1163 	return 0;
1164 }
1165 
1166 /*
1167  * This function gets the write port for data.
1168  *
1169  * The current write port is returned if available and the value is
1170  * increased (provided it does not reach the maximum limit, in which
1171  * case it is reset to 1)
1172  */
1173 static int mwifiex_get_wr_port_data(struct mwifiex_adapter *adapter, u32 *port)
1174 {
1175 	struct sdio_mmc_card *card = adapter->card;
1176 	const struct mwifiex_sdio_card_reg *reg = card->reg;
1177 	u32 wr_bitmap = card->mp_wr_bitmap;
1178 
1179 	mwifiex_dbg(adapter, DATA,
1180 		    "data: mp_wr_bitmap=0x%08x\n", wr_bitmap);
1181 
1182 	if (!(wr_bitmap & card->mp_data_port_mask)) {
1183 		adapter->data_sent = true;
1184 		return -EBUSY;
1185 	}
1186 
1187 	if (card->mp_wr_bitmap & (1 << card->curr_wr_port)) {
1188 		card->mp_wr_bitmap &= (u32) (~(1 << card->curr_wr_port));
1189 		*port = card->curr_wr_port;
1190 		if (++card->curr_wr_port == card->mp_end_port)
1191 			card->curr_wr_port = reg->start_wr_port;
1192 	} else {
1193 		adapter->data_sent = true;
1194 		return -EBUSY;
1195 	}
1196 
1197 	if ((card->has_control_mask) && (*port == CTRL_PORT)) {
1198 		mwifiex_dbg(adapter, ERROR,
1199 			    "invalid data port=%d cur port=%d mp_wr_bitmap=0x%08x -> 0x%08x\n",
1200 			    *port, card->curr_wr_port, wr_bitmap,
1201 			    card->mp_wr_bitmap);
1202 		return -1;
1203 	}
1204 
1205 	mwifiex_dbg(adapter, DATA,
1206 		    "data: port=%d mp_wr_bitmap=0x%08x -> 0x%08x\n",
1207 		    *port, wr_bitmap, card->mp_wr_bitmap);
1208 
1209 	return 0;
1210 }
1211 
1212 /*
1213  * This function polls the card status.
1214  */
1215 static int
1216 mwifiex_sdio_poll_card_status(struct mwifiex_adapter *adapter, u8 bits)
1217 {
1218 	struct sdio_mmc_card *card = adapter->card;
1219 	u32 tries;
1220 	u8 cs;
1221 
1222 	for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1223 		if (mwifiex_read_reg(adapter, card->reg->poll_reg, &cs))
1224 			break;
1225 		else if ((cs & bits) == bits)
1226 			return 0;
1227 
1228 		usleep_range(10, 20);
1229 	}
1230 
1231 	mwifiex_dbg(adapter, ERROR,
1232 		    "poll card status failed, tries = %d\n", tries);
1233 
1234 	return -1;
1235 }
1236 
1237 /*
1238  * This function disables the host interrupt.
1239  *
1240  * The host interrupt mask is read, the disable bit is reset and
1241  * written back to the card host interrupt mask register.
1242  */
1243 static void mwifiex_sdio_disable_host_int(struct mwifiex_adapter *adapter)
1244 {
1245 	struct sdio_mmc_card *card = adapter->card;
1246 	struct sdio_func *func = card->func;
1247 
1248 	sdio_claim_host(func);
1249 	mwifiex_write_reg_locked(func, card->reg->host_int_mask_reg, 0);
1250 	sdio_release_irq(func);
1251 	sdio_release_host(func);
1252 }
1253 
1254 /*
1255  * This function reads the interrupt status from card.
1256  */
1257 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1258 {
1259 	struct sdio_mmc_card *card = adapter->card;
1260 	u8 sdio_ireg;
1261 	unsigned long flags;
1262 
1263 	if (mwifiex_read_data_sync(adapter, card->mp_regs,
1264 				   card->reg->max_mp_regs,
1265 				   REG_PORT | MWIFIEX_SDIO_BYTE_MODE_MASK, 0)) {
1266 		mwifiex_dbg(adapter, ERROR, "read mp_regs failed\n");
1267 		return;
1268 	}
1269 
1270 	sdio_ireg = card->mp_regs[card->reg->host_int_status_reg];
1271 	if (sdio_ireg) {
1272 		/*
1273 		 * DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS
1274 		 * For SDIO new mode CMD port interrupts
1275 		 *	DN_LD_CMD_PORT_HOST_INT_STATUS and/or
1276 		 *	UP_LD_CMD_PORT_HOST_INT_STATUS
1277 		 * Clear the interrupt status register
1278 		 */
1279 		mwifiex_dbg(adapter, INTR,
1280 			    "int: sdio_ireg = %#x\n", sdio_ireg);
1281 		spin_lock_irqsave(&adapter->int_lock, flags);
1282 		adapter->int_status |= sdio_ireg;
1283 		spin_unlock_irqrestore(&adapter->int_lock, flags);
1284 	}
1285 }
1286 
1287 /*
1288  * SDIO interrupt handler.
1289  *
1290  * This function reads the interrupt status from firmware and handles
1291  * the interrupt in current thread (ksdioirqd) right away.
1292  */
1293 static void
1294 mwifiex_sdio_interrupt(struct sdio_func *func)
1295 {
1296 	struct mwifiex_adapter *adapter;
1297 	struct sdio_mmc_card *card;
1298 
1299 	card = sdio_get_drvdata(func);
1300 	if (!card || !card->adapter) {
1301 		pr_err("int: func=%p card=%p adapter=%p\n",
1302 		       func, card, card ? card->adapter : NULL);
1303 		return;
1304 	}
1305 	adapter = card->adapter;
1306 
1307 	if (!adapter->pps_uapsd_mode && adapter->ps_state == PS_STATE_SLEEP)
1308 		adapter->ps_state = PS_STATE_AWAKE;
1309 
1310 	mwifiex_interrupt_status(adapter);
1311 	mwifiex_main_process(adapter);
1312 }
1313 
1314 /*
1315  * This function enables the host interrupt.
1316  *
1317  * The host interrupt enable mask is written to the card
1318  * host interrupt mask register.
1319  */
1320 static int mwifiex_sdio_enable_host_int(struct mwifiex_adapter *adapter)
1321 {
1322 	struct sdio_mmc_card *card = adapter->card;
1323 	struct sdio_func *func = card->func;
1324 	int ret;
1325 
1326 	sdio_claim_host(func);
1327 
1328 	/* Request the SDIO IRQ */
1329 	ret = sdio_claim_irq(func, mwifiex_sdio_interrupt);
1330 	if (ret) {
1331 		mwifiex_dbg(adapter, ERROR,
1332 			    "claim irq failed: ret=%d\n", ret);
1333 		goto out;
1334 	}
1335 
1336 	/* Simply write the mask to the register */
1337 	ret = mwifiex_write_reg_locked(func, card->reg->host_int_mask_reg,
1338 				       card->reg->host_int_enable);
1339 	if (ret) {
1340 		mwifiex_dbg(adapter, ERROR,
1341 			    "enable host interrupt failed\n");
1342 		sdio_release_irq(func);
1343 	}
1344 
1345 out:
1346 	sdio_release_host(func);
1347 	return ret;
1348 }
1349 
1350 /*
1351  * This function sends a data buffer to the card.
1352  */
1353 static int mwifiex_sdio_card_to_host(struct mwifiex_adapter *adapter,
1354 				     u32 *type, u8 *buffer,
1355 				     u32 npayload, u32 ioport)
1356 {
1357 	int ret;
1358 	u32 nb;
1359 
1360 	if (!buffer) {
1361 		mwifiex_dbg(adapter, ERROR,
1362 			    "%s: buffer is NULL\n", __func__);
1363 		return -1;
1364 	}
1365 
1366 	ret = mwifiex_read_data_sync(adapter, buffer, npayload, ioport, 1);
1367 
1368 	if (ret) {
1369 		mwifiex_dbg(adapter, ERROR,
1370 			    "%s: read iomem failed: %d\n", __func__,
1371 			ret);
1372 		return -1;
1373 	}
1374 
1375 	nb = get_unaligned_le16((buffer));
1376 	if (nb > npayload) {
1377 		mwifiex_dbg(adapter, ERROR,
1378 			    "%s: invalid packet, nb=%d npayload=%d\n",
1379 			    __func__, nb, npayload);
1380 		return -1;
1381 	}
1382 
1383 	*type = get_unaligned_le16((buffer + 2));
1384 
1385 	return ret;
1386 }
1387 
1388 /*
1389  * This function downloads the firmware to the card.
1390  *
1391  * Firmware is downloaded to the card in blocks. Every block download
1392  * is tested for CRC errors, and retried a number of times before
1393  * returning failure.
1394  */
1395 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1396 				    struct mwifiex_fw_image *fw)
1397 {
1398 	struct sdio_mmc_card *card = adapter->card;
1399 	const struct mwifiex_sdio_card_reg *reg = card->reg;
1400 	int ret;
1401 	u8 *firmware = fw->fw_buf;
1402 	u32 firmware_len = fw->fw_len;
1403 	u32 offset = 0;
1404 	u8 base0, base1;
1405 	u8 *fwbuf;
1406 	u16 len = 0;
1407 	u32 txlen, tx_blocks = 0, tries;
1408 	u32 i = 0;
1409 
1410 	if (!firmware_len) {
1411 		mwifiex_dbg(adapter, ERROR,
1412 			    "firmware image not found! Terminating download\n");
1413 		return -1;
1414 	}
1415 
1416 	mwifiex_dbg(adapter, INFO,
1417 		    "info: downloading FW image (%d bytes)\n",
1418 		    firmware_len);
1419 
1420 	/* Assume that the allocated buffer is 8-byte aligned */
1421 	fwbuf = kzalloc(MWIFIEX_UPLD_SIZE, GFP_KERNEL);
1422 	if (!fwbuf)
1423 		return -ENOMEM;
1424 
1425 	sdio_claim_host(card->func);
1426 
1427 	/* Perform firmware data transfer */
1428 	do {
1429 		/* The host polls for the DN_LD_CARD_RDY and CARD_IO_READY
1430 		   bits */
1431 		ret = mwifiex_sdio_poll_card_status(adapter, CARD_IO_READY |
1432 						    DN_LD_CARD_RDY);
1433 		if (ret) {
1434 			mwifiex_dbg(adapter, ERROR,
1435 				    "FW download with helper:\t"
1436 				    "poll status timeout @ %d\n", offset);
1437 			goto done;
1438 		}
1439 
1440 		/* More data? */
1441 		if (offset >= firmware_len)
1442 			break;
1443 
1444 		for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1445 			ret = mwifiex_read_reg(adapter, reg->base_0_reg,
1446 					       &base0);
1447 			if (ret) {
1448 				mwifiex_dbg(adapter, ERROR,
1449 					    "dev BASE0 register read failed:\t"
1450 					    "base0=%#04X(%d). Terminating dnld\n",
1451 					    base0, base0);
1452 				goto done;
1453 			}
1454 			ret = mwifiex_read_reg(adapter, reg->base_1_reg,
1455 					       &base1);
1456 			if (ret) {
1457 				mwifiex_dbg(adapter, ERROR,
1458 					    "dev BASE1 register read failed:\t"
1459 					    "base1=%#04X(%d). Terminating dnld\n",
1460 					    base1, base1);
1461 				goto done;
1462 			}
1463 			len = (u16) (((base1 & 0xff) << 8) | (base0 & 0xff));
1464 
1465 			if (len)
1466 				break;
1467 
1468 			usleep_range(10, 20);
1469 		}
1470 
1471 		if (!len) {
1472 			break;
1473 		} else if (len > MWIFIEX_UPLD_SIZE) {
1474 			mwifiex_dbg(adapter, ERROR,
1475 				    "FW dnld failed @ %d, invalid length %d\n",
1476 				    offset, len);
1477 			ret = -1;
1478 			goto done;
1479 		}
1480 
1481 		txlen = len;
1482 
1483 		if (len & BIT(0)) {
1484 			i++;
1485 			if (i > MAX_WRITE_IOMEM_RETRY) {
1486 				mwifiex_dbg(adapter, ERROR,
1487 					    "FW dnld failed @ %d, over max retry\n",
1488 					    offset);
1489 				ret = -1;
1490 				goto done;
1491 			}
1492 			mwifiex_dbg(adapter, ERROR,
1493 				    "CRC indicated by the helper:\t"
1494 				    "len = 0x%04X, txlen = %d\n", len, txlen);
1495 			len &= ~BIT(0);
1496 			/* Setting this to 0 to resend from same offset */
1497 			txlen = 0;
1498 		} else {
1499 			i = 0;
1500 
1501 			/* Set blocksize to transfer - checking for last
1502 			   block */
1503 			if (firmware_len - offset < txlen)
1504 				txlen = firmware_len - offset;
1505 
1506 			tx_blocks = (txlen + MWIFIEX_SDIO_BLOCK_SIZE - 1)
1507 				    / MWIFIEX_SDIO_BLOCK_SIZE;
1508 
1509 			/* Copy payload to buffer */
1510 			memmove(fwbuf, &firmware[offset], txlen);
1511 		}
1512 
1513 		ret = mwifiex_write_data_sync(adapter, fwbuf, tx_blocks *
1514 					      MWIFIEX_SDIO_BLOCK_SIZE,
1515 					      adapter->ioport);
1516 		if (ret) {
1517 			mwifiex_dbg(adapter, ERROR,
1518 				    "FW download, write iomem (%d) failed @ %d\n",
1519 				    i, offset);
1520 			if (mwifiex_write_reg(adapter, CONFIGURATION_REG, 0x04))
1521 				mwifiex_dbg(adapter, ERROR,
1522 					    "write CFG reg failed\n");
1523 
1524 			ret = -1;
1525 			goto done;
1526 		}
1527 
1528 		offset += txlen;
1529 	} while (true);
1530 
1531 	mwifiex_dbg(adapter, MSG,
1532 		    "info: FW download over, size %d bytes\n", offset);
1533 
1534 	ret = 0;
1535 done:
1536 	sdio_release_host(card->func);
1537 	kfree(fwbuf);
1538 	return ret;
1539 }
1540 
1541 /*
1542  * This function decode sdio aggreation pkt.
1543  *
1544  * Based on the the data block size and pkt_len,
1545  * skb data will be decoded to few packets.
1546  */
1547 static void mwifiex_deaggr_sdio_pkt(struct mwifiex_adapter *adapter,
1548 				    struct sk_buff *skb)
1549 {
1550 	u32 total_pkt_len, pkt_len;
1551 	struct sk_buff *skb_deaggr;
1552 	u16 blk_size;
1553 	u8 blk_num;
1554 	u8 *data;
1555 
1556 	data = skb->data;
1557 	total_pkt_len = skb->len;
1558 
1559 	while (total_pkt_len >= (SDIO_HEADER_OFFSET + adapter->intf_hdr_len)) {
1560 		if (total_pkt_len < adapter->sdio_rx_block_size)
1561 			break;
1562 		blk_num = *(data + BLOCK_NUMBER_OFFSET);
1563 		blk_size = adapter->sdio_rx_block_size * blk_num;
1564 		if (blk_size > total_pkt_len) {
1565 			mwifiex_dbg(adapter, ERROR,
1566 				    "%s: error in blk_size,\t"
1567 				    "blk_num=%d, blk_size=%d, total_pkt_len=%d\n",
1568 				    __func__, blk_num, blk_size, total_pkt_len);
1569 			break;
1570 		}
1571 		pkt_len = get_unaligned_le16((data +
1572 					     SDIO_HEADER_OFFSET));
1573 		if ((pkt_len + SDIO_HEADER_OFFSET) > blk_size) {
1574 			mwifiex_dbg(adapter, ERROR,
1575 				    "%s: error in pkt_len,\t"
1576 				    "pkt_len=%d, blk_size=%d\n",
1577 				    __func__, pkt_len, blk_size);
1578 			break;
1579 		}
1580 
1581 		skb_deaggr = mwifiex_alloc_dma_align_buf(pkt_len, GFP_KERNEL);
1582 		if (!skb_deaggr)
1583 			break;
1584 		skb_put(skb_deaggr, pkt_len);
1585 		memcpy(skb_deaggr->data, data + SDIO_HEADER_OFFSET, pkt_len);
1586 		skb_pull(skb_deaggr, adapter->intf_hdr_len);
1587 
1588 		mwifiex_handle_rx_packet(adapter, skb_deaggr);
1589 		data += blk_size;
1590 		total_pkt_len -= blk_size;
1591 	}
1592 }
1593 
1594 /*
1595  * This function decodes a received packet.
1596  *
1597  * Based on the type, the packet is treated as either a data, or
1598  * a command response, or an event, and the correct handler
1599  * function is invoked.
1600  */
1601 static int mwifiex_decode_rx_packet(struct mwifiex_adapter *adapter,
1602 				    struct sk_buff *skb, u32 upld_typ)
1603 {
1604 	u8 *cmd_buf;
1605 	u16 pkt_len;
1606 	struct mwifiex_rxinfo *rx_info;
1607 
1608 	pkt_len = get_unaligned_le16(skb->data);
1609 
1610 	if (upld_typ != MWIFIEX_TYPE_AGGR_DATA) {
1611 		skb_trim(skb, pkt_len);
1612 		skb_pull(skb, adapter->intf_hdr_len);
1613 	}
1614 
1615 	switch (upld_typ) {
1616 	case MWIFIEX_TYPE_AGGR_DATA:
1617 		mwifiex_dbg(adapter, INFO,
1618 			    "info: --- Rx: Aggr Data packet ---\n");
1619 		rx_info = MWIFIEX_SKB_RXCB(skb);
1620 		rx_info->buf_type = MWIFIEX_TYPE_AGGR_DATA;
1621 		if (adapter->rx_work_enabled) {
1622 			skb_queue_tail(&adapter->rx_data_q, skb);
1623 			atomic_inc(&adapter->rx_pending);
1624 			adapter->data_received = true;
1625 		} else {
1626 			mwifiex_deaggr_sdio_pkt(adapter, skb);
1627 			dev_kfree_skb_any(skb);
1628 		}
1629 		break;
1630 
1631 	case MWIFIEX_TYPE_DATA:
1632 		mwifiex_dbg(adapter, DATA,
1633 			    "info: --- Rx: Data packet ---\n");
1634 		if (adapter->rx_work_enabled) {
1635 			skb_queue_tail(&adapter->rx_data_q, skb);
1636 			adapter->data_received = true;
1637 			atomic_inc(&adapter->rx_pending);
1638 		} else {
1639 			mwifiex_handle_rx_packet(adapter, skb);
1640 		}
1641 		break;
1642 
1643 	case MWIFIEX_TYPE_CMD:
1644 		mwifiex_dbg(adapter, CMD,
1645 			    "info: --- Rx: Cmd Response ---\n");
1646 		/* take care of curr_cmd = NULL case */
1647 		if (!adapter->curr_cmd) {
1648 			cmd_buf = adapter->upld_buf;
1649 
1650 			if (adapter->ps_state == PS_STATE_SLEEP_CFM)
1651 				mwifiex_process_sleep_confirm_resp(adapter,
1652 								   skb->data,
1653 								   skb->len);
1654 
1655 			memcpy(cmd_buf, skb->data,
1656 			       min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER,
1657 				     skb->len));
1658 
1659 			dev_kfree_skb_any(skb);
1660 		} else {
1661 			adapter->cmd_resp_received = true;
1662 			adapter->curr_cmd->resp_skb = skb;
1663 		}
1664 		break;
1665 
1666 	case MWIFIEX_TYPE_EVENT:
1667 		mwifiex_dbg(adapter, EVENT,
1668 			    "info: --- Rx: Event ---\n");
1669 		adapter->event_cause = get_unaligned_le32(skb->data);
1670 
1671 		if ((skb->len > 0) && (skb->len  < MAX_EVENT_SIZE))
1672 			memcpy(adapter->event_body,
1673 			       skb->data + MWIFIEX_EVENT_HEADER_LEN,
1674 			       skb->len);
1675 
1676 		/* event cause has been saved to adapter->event_cause */
1677 		adapter->event_received = true;
1678 		adapter->event_skb = skb;
1679 
1680 		break;
1681 
1682 	default:
1683 		mwifiex_dbg(adapter, ERROR,
1684 			    "unknown upload type %#x\n", upld_typ);
1685 		dev_kfree_skb_any(skb);
1686 		break;
1687 	}
1688 
1689 	return 0;
1690 }
1691 
1692 /*
1693  * This function transfers received packets from card to driver, performing
1694  * aggregation if required.
1695  *
1696  * For data received on control port, or if aggregation is disabled, the
1697  * received buffers are uploaded as separate packets. However, if aggregation
1698  * is enabled and required, the buffers are copied onto an aggregation buffer,
1699  * provided there is space left, processed and finally uploaded.
1700  */
1701 static int mwifiex_sdio_card_to_host_mp_aggr(struct mwifiex_adapter *adapter,
1702 					     u16 rx_len, u8 port)
1703 {
1704 	struct sdio_mmc_card *card = adapter->card;
1705 	s32 f_do_rx_aggr = 0;
1706 	s32 f_do_rx_cur = 0;
1707 	s32 f_aggr_cur = 0;
1708 	s32 f_post_aggr_cur = 0;
1709 	struct sk_buff *skb_deaggr;
1710 	struct sk_buff *skb = NULL;
1711 	u32 pkt_len, pkt_type, mport, pind;
1712 	u8 *curr_ptr;
1713 
1714 	if ((card->has_control_mask) && (port == CTRL_PORT)) {
1715 		/* Read the command Resp without aggr */
1716 		mwifiex_dbg(adapter, CMD,
1717 			    "info: %s: no aggregation for cmd\t"
1718 			    "response\n", __func__);
1719 
1720 		f_do_rx_cur = 1;
1721 		goto rx_curr_single;
1722 	}
1723 
1724 	if (!card->mpa_rx.enabled) {
1725 		mwifiex_dbg(adapter, WARN,
1726 			    "info: %s: rx aggregation disabled\n",
1727 			    __func__);
1728 
1729 		f_do_rx_cur = 1;
1730 		goto rx_curr_single;
1731 	}
1732 
1733 	if ((!card->has_control_mask && (card->mp_rd_bitmap &
1734 					 card->reg->data_port_mask)) ||
1735 	    (card->has_control_mask && (card->mp_rd_bitmap &
1736 					(~((u32) CTRL_PORT_MASK))))) {
1737 		/* Some more data RX pending */
1738 		mwifiex_dbg(adapter, INFO,
1739 			    "info: %s: not last packet\n", __func__);
1740 
1741 		if (MP_RX_AGGR_IN_PROGRESS(card)) {
1742 			if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len)) {
1743 				f_aggr_cur = 1;
1744 			} else {
1745 				/* No room in Aggr buf, do rx aggr now */
1746 				f_do_rx_aggr = 1;
1747 				f_post_aggr_cur = 1;
1748 			}
1749 		} else {
1750 			/* Rx aggr not in progress */
1751 			f_aggr_cur = 1;
1752 		}
1753 
1754 	} else {
1755 		/* No more data RX pending */
1756 		mwifiex_dbg(adapter, INFO,
1757 			    "info: %s: last packet\n", __func__);
1758 
1759 		if (MP_RX_AGGR_IN_PROGRESS(card)) {
1760 			f_do_rx_aggr = 1;
1761 			if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len))
1762 				f_aggr_cur = 1;
1763 			else
1764 				/* No room in Aggr buf, do rx aggr now */
1765 				f_do_rx_cur = 1;
1766 		} else {
1767 			f_do_rx_cur = 1;
1768 		}
1769 	}
1770 
1771 	if (f_aggr_cur) {
1772 		mwifiex_dbg(adapter, INFO,
1773 			    "info: current packet aggregation\n");
1774 		/* Curr pkt can be aggregated */
1775 		mp_rx_aggr_setup(card, rx_len, port);
1776 
1777 		if (MP_RX_AGGR_PKT_LIMIT_REACHED(card) ||
1778 		    mp_rx_aggr_port_limit_reached(card)) {
1779 			mwifiex_dbg(adapter, INFO,
1780 				    "info: %s: aggregated packet\t"
1781 				    "limit reached\n", __func__);
1782 			/* No more pkts allowed in Aggr buf, rx it */
1783 			f_do_rx_aggr = 1;
1784 		}
1785 	}
1786 
1787 	if (f_do_rx_aggr) {
1788 		/* do aggr RX now */
1789 		mwifiex_dbg(adapter, DATA,
1790 			    "info: do_rx_aggr: num of packets: %d\n",
1791 			    card->mpa_rx.pkt_cnt);
1792 
1793 		if (card->supports_sdio_new_mode) {
1794 			int i;
1795 			u32 port_count;
1796 
1797 			for (i = 0, port_count = 0; i < card->max_ports; i++)
1798 				if (card->mpa_rx.ports & BIT(i))
1799 					port_count++;
1800 
1801 			/* Reading data from "start_port + 0" to "start_port +
1802 			 * port_count -1", so decrease the count by 1
1803 			 */
1804 			port_count--;
1805 			mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
1806 				 (port_count << 8)) + card->mpa_rx.start_port;
1807 		} else {
1808 			mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
1809 				 (card->mpa_rx.ports << 4)) +
1810 				 card->mpa_rx.start_port;
1811 		}
1812 
1813 		if (card->mpa_rx.pkt_cnt == 1)
1814 			mport = adapter->ioport + card->mpa_rx.start_port;
1815 
1816 		if (mwifiex_read_data_sync(adapter, card->mpa_rx.buf,
1817 					   card->mpa_rx.buf_len, mport, 1))
1818 			goto error;
1819 
1820 		curr_ptr = card->mpa_rx.buf;
1821 
1822 		for (pind = 0; pind < card->mpa_rx.pkt_cnt; pind++) {
1823 			u32 *len_arr = card->mpa_rx.len_arr;
1824 
1825 			/* get curr PKT len & type */
1826 			pkt_len = get_unaligned_le16(&curr_ptr[0]);
1827 			pkt_type = get_unaligned_le16(&curr_ptr[2]);
1828 
1829 			/* copy pkt to deaggr buf */
1830 			skb_deaggr = mwifiex_alloc_dma_align_buf(len_arr[pind],
1831 								 GFP_KERNEL);
1832 			if (!skb_deaggr) {
1833 				mwifiex_dbg(adapter, ERROR, "skb allocation failure\t"
1834 					    "drop pkt len=%d type=%d\n",
1835 					    pkt_len, pkt_type);
1836 				curr_ptr += len_arr[pind];
1837 				continue;
1838 			}
1839 
1840 			skb_put(skb_deaggr, len_arr[pind]);
1841 
1842 			if ((pkt_type == MWIFIEX_TYPE_DATA ||
1843 			     (pkt_type == MWIFIEX_TYPE_AGGR_DATA &&
1844 			      adapter->sdio_rx_aggr_enable)) &&
1845 			    (pkt_len <= len_arr[pind])) {
1846 
1847 				memcpy(skb_deaggr->data, curr_ptr, pkt_len);
1848 
1849 				skb_trim(skb_deaggr, pkt_len);
1850 
1851 				/* Process de-aggr packet */
1852 				mwifiex_decode_rx_packet(adapter, skb_deaggr,
1853 							 pkt_type);
1854 			} else {
1855 				mwifiex_dbg(adapter, ERROR,
1856 					    "drop wrong aggr pkt:\t"
1857 					    "sdio_single_port_rx_aggr=%d\t"
1858 					    "type=%d len=%d max_len=%d\n",
1859 					    adapter->sdio_rx_aggr_enable,
1860 					    pkt_type, pkt_len, len_arr[pind]);
1861 				dev_kfree_skb_any(skb_deaggr);
1862 			}
1863 			curr_ptr += len_arr[pind];
1864 		}
1865 		MP_RX_AGGR_BUF_RESET(card);
1866 	}
1867 
1868 rx_curr_single:
1869 	if (f_do_rx_cur) {
1870 		mwifiex_dbg(adapter, INFO, "info: RX: port: %d, rx_len: %d\n",
1871 			    port, rx_len);
1872 
1873 		skb = mwifiex_alloc_dma_align_buf(rx_len, GFP_KERNEL);
1874 		if (!skb) {
1875 			mwifiex_dbg(adapter, ERROR,
1876 				    "single skb allocated fail,\t"
1877 				    "drop pkt port=%d len=%d\n", port, rx_len);
1878 			if (mwifiex_sdio_card_to_host(adapter, &pkt_type,
1879 						      card->mpa_rx.buf, rx_len,
1880 						      adapter->ioport + port))
1881 				goto error;
1882 			return 0;
1883 		}
1884 
1885 		skb_put(skb, rx_len);
1886 
1887 		if (mwifiex_sdio_card_to_host(adapter, &pkt_type,
1888 					      skb->data, skb->len,
1889 					      adapter->ioport + port))
1890 			goto error;
1891 		if (!adapter->sdio_rx_aggr_enable &&
1892 		    pkt_type == MWIFIEX_TYPE_AGGR_DATA) {
1893 			mwifiex_dbg(adapter, ERROR, "drop wrong pkt type %d\t"
1894 				    "current SDIO RX Aggr not enabled\n",
1895 				    pkt_type);
1896 			dev_kfree_skb_any(skb);
1897 			return 0;
1898 		}
1899 
1900 		mwifiex_decode_rx_packet(adapter, skb, pkt_type);
1901 	}
1902 	if (f_post_aggr_cur) {
1903 		mwifiex_dbg(adapter, INFO,
1904 			    "info: current packet aggregation\n");
1905 		/* Curr pkt can be aggregated */
1906 		mp_rx_aggr_setup(card, rx_len, port);
1907 	}
1908 
1909 	return 0;
1910 error:
1911 	if (MP_RX_AGGR_IN_PROGRESS(card))
1912 		MP_RX_AGGR_BUF_RESET(card);
1913 
1914 	if (f_do_rx_cur && skb)
1915 		/* Single transfer pending. Free curr buff also */
1916 		dev_kfree_skb_any(skb);
1917 
1918 	return -1;
1919 }
1920 
1921 /*
1922  * This function checks the current interrupt status.
1923  *
1924  * The following interrupts are checked and handled by this function -
1925  *      - Data sent
1926  *      - Command sent
1927  *      - Packets received
1928  *
1929  * Since the firmware does not generate download ready interrupt if the
1930  * port updated is command port only, command sent interrupt checking
1931  * should be done manually, and for every SDIO interrupt.
1932  *
1933  * In case of Rx packets received, the packets are uploaded from card to
1934  * host and processed accordingly.
1935  */
1936 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
1937 {
1938 	struct sdio_mmc_card *card = adapter->card;
1939 	const struct mwifiex_sdio_card_reg *reg = card->reg;
1940 	int ret = 0;
1941 	u8 sdio_ireg;
1942 	struct sk_buff *skb;
1943 	u8 port = CTRL_PORT;
1944 	u32 len_reg_l, len_reg_u;
1945 	u32 rx_blocks;
1946 	u16 rx_len;
1947 	unsigned long flags;
1948 	u32 bitmap;
1949 	u8 cr;
1950 
1951 	spin_lock_irqsave(&adapter->int_lock, flags);
1952 	sdio_ireg = adapter->int_status;
1953 	adapter->int_status = 0;
1954 	spin_unlock_irqrestore(&adapter->int_lock, flags);
1955 
1956 	if (!sdio_ireg)
1957 		return ret;
1958 
1959 	/* Following interrupt is only for SDIO new mode */
1960 	if (sdio_ireg & DN_LD_CMD_PORT_HOST_INT_STATUS && adapter->cmd_sent)
1961 		adapter->cmd_sent = false;
1962 
1963 	/* Following interrupt is only for SDIO new mode */
1964 	if (sdio_ireg & UP_LD_CMD_PORT_HOST_INT_STATUS) {
1965 		u32 pkt_type;
1966 
1967 		/* read the len of control packet */
1968 		rx_len = card->mp_regs[reg->cmd_rd_len_1] << 8;
1969 		rx_len |= (u16)card->mp_regs[reg->cmd_rd_len_0];
1970 		rx_blocks = DIV_ROUND_UP(rx_len, MWIFIEX_SDIO_BLOCK_SIZE);
1971 		if (rx_len <= adapter->intf_hdr_len ||
1972 		    (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE) >
1973 		     MWIFIEX_RX_DATA_BUF_SIZE)
1974 			return -1;
1975 		rx_len = (u16) (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE);
1976 		mwifiex_dbg(adapter, INFO, "info: rx_len = %d\n", rx_len);
1977 
1978 		skb = mwifiex_alloc_dma_align_buf(rx_len, GFP_KERNEL);
1979 		if (!skb)
1980 			return -1;
1981 
1982 		skb_put(skb, rx_len);
1983 
1984 		if (mwifiex_sdio_card_to_host(adapter, &pkt_type, skb->data,
1985 					      skb->len, adapter->ioport |
1986 							CMD_PORT_SLCT)) {
1987 			mwifiex_dbg(adapter, ERROR,
1988 				    "%s: failed to card_to_host", __func__);
1989 			dev_kfree_skb_any(skb);
1990 			goto term_cmd;
1991 		}
1992 
1993 		if ((pkt_type != MWIFIEX_TYPE_CMD) &&
1994 		    (pkt_type != MWIFIEX_TYPE_EVENT))
1995 			mwifiex_dbg(adapter, ERROR,
1996 				    "%s:Received wrong packet on cmd port",
1997 				    __func__);
1998 
1999 		mwifiex_decode_rx_packet(adapter, skb, pkt_type);
2000 	}
2001 
2002 	if (sdio_ireg & DN_LD_HOST_INT_STATUS) {
2003 		bitmap = (u32) card->mp_regs[reg->wr_bitmap_l];
2004 		bitmap |= ((u32) card->mp_regs[reg->wr_bitmap_u]) << 8;
2005 		if (card->supports_sdio_new_mode) {
2006 			bitmap |=
2007 				((u32) card->mp_regs[reg->wr_bitmap_1l]) << 16;
2008 			bitmap |=
2009 				((u32) card->mp_regs[reg->wr_bitmap_1u]) << 24;
2010 		}
2011 		card->mp_wr_bitmap = bitmap;
2012 
2013 		mwifiex_dbg(adapter, INTR,
2014 			    "int: DNLD: wr_bitmap=0x%x\n",
2015 			    card->mp_wr_bitmap);
2016 		if (adapter->data_sent &&
2017 		    (card->mp_wr_bitmap & card->mp_data_port_mask)) {
2018 			mwifiex_dbg(adapter, INTR,
2019 				    "info:  <--- Tx DONE Interrupt --->\n");
2020 			adapter->data_sent = false;
2021 		}
2022 	}
2023 
2024 	/* As firmware will not generate download ready interrupt if the port
2025 	   updated is command port only, cmd_sent should be done for any SDIO
2026 	   interrupt. */
2027 	if (card->has_control_mask && adapter->cmd_sent) {
2028 		/* Check if firmware has attach buffer at command port and
2029 		   update just that in wr_bit_map. */
2030 		card->mp_wr_bitmap |=
2031 			(u32) card->mp_regs[reg->wr_bitmap_l] & CTRL_PORT_MASK;
2032 		if (card->mp_wr_bitmap & CTRL_PORT_MASK)
2033 			adapter->cmd_sent = false;
2034 	}
2035 
2036 	mwifiex_dbg(adapter, INTR, "info: cmd_sent=%d data_sent=%d\n",
2037 		    adapter->cmd_sent, adapter->data_sent);
2038 	if (sdio_ireg & UP_LD_HOST_INT_STATUS) {
2039 		bitmap = (u32) card->mp_regs[reg->rd_bitmap_l];
2040 		bitmap |= ((u32) card->mp_regs[reg->rd_bitmap_u]) << 8;
2041 		if (card->supports_sdio_new_mode) {
2042 			bitmap |=
2043 				((u32) card->mp_regs[reg->rd_bitmap_1l]) << 16;
2044 			bitmap |=
2045 				((u32) card->mp_regs[reg->rd_bitmap_1u]) << 24;
2046 		}
2047 		card->mp_rd_bitmap = bitmap;
2048 		mwifiex_dbg(adapter, INTR,
2049 			    "int: UPLD: rd_bitmap=0x%x\n",
2050 			    card->mp_rd_bitmap);
2051 
2052 		while (true) {
2053 			ret = mwifiex_get_rd_port(adapter, &port);
2054 			if (ret) {
2055 				mwifiex_dbg(adapter, INFO,
2056 					    "info: no more rd_port available\n");
2057 				break;
2058 			}
2059 			len_reg_l = reg->rd_len_p0_l + (port << 1);
2060 			len_reg_u = reg->rd_len_p0_u + (port << 1);
2061 			rx_len = ((u16) card->mp_regs[len_reg_u]) << 8;
2062 			rx_len |= (u16) card->mp_regs[len_reg_l];
2063 			mwifiex_dbg(adapter, INFO,
2064 				    "info: RX: port=%d rx_len=%u\n",
2065 				    port, rx_len);
2066 			rx_blocks =
2067 				(rx_len + MWIFIEX_SDIO_BLOCK_SIZE -
2068 				 1) / MWIFIEX_SDIO_BLOCK_SIZE;
2069 			if (rx_len <= adapter->intf_hdr_len ||
2070 			    (card->mpa_rx.enabled &&
2071 			     ((rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE) >
2072 			      card->mpa_rx.buf_size))) {
2073 				mwifiex_dbg(adapter, ERROR,
2074 					    "invalid rx_len=%d\n",
2075 					    rx_len);
2076 				return -1;
2077 			}
2078 
2079 			rx_len = (u16) (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE);
2080 			mwifiex_dbg(adapter, INFO, "info: rx_len = %d\n",
2081 				    rx_len);
2082 
2083 			if (mwifiex_sdio_card_to_host_mp_aggr(adapter, rx_len,
2084 							      port)) {
2085 				mwifiex_dbg(adapter, ERROR,
2086 					    "card_to_host_mpa failed: int status=%#x\n",
2087 					    sdio_ireg);
2088 				goto term_cmd;
2089 			}
2090 		}
2091 	}
2092 
2093 	return 0;
2094 
2095 term_cmd:
2096 	/* terminate cmd */
2097 	if (mwifiex_read_reg(adapter, CONFIGURATION_REG, &cr))
2098 		mwifiex_dbg(adapter, ERROR, "read CFG reg failed\n");
2099 	else
2100 		mwifiex_dbg(adapter, INFO,
2101 			    "info: CFG reg val = %d\n", cr);
2102 
2103 	if (mwifiex_write_reg(adapter, CONFIGURATION_REG, (cr | 0x04)))
2104 		mwifiex_dbg(adapter, ERROR,
2105 			    "write CFG reg failed\n");
2106 	else
2107 		mwifiex_dbg(adapter, INFO, "info: write success\n");
2108 
2109 	if (mwifiex_read_reg(adapter, CONFIGURATION_REG, &cr))
2110 		mwifiex_dbg(adapter, ERROR,
2111 			    "read CFG reg failed\n");
2112 	else
2113 		mwifiex_dbg(adapter, INFO,
2114 			    "info: CFG reg val =%x\n", cr);
2115 
2116 	return -1;
2117 }
2118 
2119 /*
2120  * This function aggregates transmission buffers in driver and downloads
2121  * the aggregated packet to card.
2122  *
2123  * The individual packets are aggregated by copying into an aggregation
2124  * buffer and then downloaded to the card. Previous unsent packets in the
2125  * aggregation buffer are pre-copied first before new packets are added.
2126  * Aggregation is done till there is space left in the aggregation buffer,
2127  * or till new packets are available.
2128  *
2129  * The function will only download the packet to the card when aggregation
2130  * stops, otherwise it will just aggregate the packet in aggregation buffer
2131  * and return.
2132  */
2133 static int mwifiex_host_to_card_mp_aggr(struct mwifiex_adapter *adapter,
2134 					u8 *payload, u32 pkt_len, u32 port,
2135 					u32 next_pkt_len)
2136 {
2137 	struct sdio_mmc_card *card = adapter->card;
2138 	int ret = 0;
2139 	s32 f_send_aggr_buf = 0;
2140 	s32 f_send_cur_buf = 0;
2141 	s32 f_precopy_cur_buf = 0;
2142 	s32 f_postcopy_cur_buf = 0;
2143 	u32 mport;
2144 	int index;
2145 
2146 	if (!card->mpa_tx.enabled ||
2147 	    (card->has_control_mask && (port == CTRL_PORT)) ||
2148 	    (card->supports_sdio_new_mode && (port == CMD_PORT_SLCT))) {
2149 		mwifiex_dbg(adapter, WARN,
2150 			    "info: %s: tx aggregation disabled\n",
2151 			    __func__);
2152 
2153 		f_send_cur_buf = 1;
2154 		goto tx_curr_single;
2155 	}
2156 
2157 	if (next_pkt_len) {
2158 		/* More pkt in TX queue */
2159 		mwifiex_dbg(adapter, INFO,
2160 			    "info: %s: more packets in queue.\n",
2161 			    __func__);
2162 
2163 		if (MP_TX_AGGR_IN_PROGRESS(card)) {
2164 			if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len)) {
2165 				f_precopy_cur_buf = 1;
2166 
2167 				if (!(card->mp_wr_bitmap &
2168 				      (1 << card->curr_wr_port)) ||
2169 				    !MP_TX_AGGR_BUF_HAS_ROOM(
2170 					    card, pkt_len + next_pkt_len))
2171 					f_send_aggr_buf = 1;
2172 			} else {
2173 				/* No room in Aggr buf, send it */
2174 				f_send_aggr_buf = 1;
2175 
2176 				if (!(card->mp_wr_bitmap &
2177 				      (1 << card->curr_wr_port)))
2178 					f_send_cur_buf = 1;
2179 				else
2180 					f_postcopy_cur_buf = 1;
2181 			}
2182 		} else {
2183 			if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len) &&
2184 			    (card->mp_wr_bitmap & (1 << card->curr_wr_port)))
2185 				f_precopy_cur_buf = 1;
2186 			else
2187 				f_send_cur_buf = 1;
2188 		}
2189 	} else {
2190 		/* Last pkt in TX queue */
2191 		mwifiex_dbg(adapter, INFO,
2192 			    "info: %s: Last packet in Tx Queue.\n",
2193 			    __func__);
2194 
2195 		if (MP_TX_AGGR_IN_PROGRESS(card)) {
2196 			/* some packs in Aggr buf already */
2197 			f_send_aggr_buf = 1;
2198 
2199 			if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len))
2200 				f_precopy_cur_buf = 1;
2201 			else
2202 				/* No room in Aggr buf, send it */
2203 				f_send_cur_buf = 1;
2204 		} else {
2205 			f_send_cur_buf = 1;
2206 		}
2207 	}
2208 
2209 	if (f_precopy_cur_buf) {
2210 		mwifiex_dbg(adapter, DATA,
2211 			    "data: %s: precopy current buffer\n",
2212 			    __func__);
2213 		MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
2214 
2215 		if (MP_TX_AGGR_PKT_LIMIT_REACHED(card) ||
2216 		    mp_tx_aggr_port_limit_reached(card))
2217 			/* No more pkts allowed in Aggr buf, send it */
2218 			f_send_aggr_buf = 1;
2219 	}
2220 
2221 	if (f_send_aggr_buf) {
2222 		mwifiex_dbg(adapter, DATA,
2223 			    "data: %s: send aggr buffer: %d %d\n",
2224 			    __func__, card->mpa_tx.start_port,
2225 			    card->mpa_tx.ports);
2226 		if (card->supports_sdio_new_mode) {
2227 			u32 port_count;
2228 			int i;
2229 
2230 			for (i = 0, port_count = 0; i < card->max_ports; i++)
2231 				if (card->mpa_tx.ports & BIT(i))
2232 					port_count++;
2233 
2234 			/* Writing data from "start_port + 0" to "start_port +
2235 			 * port_count -1", so decrease the count by 1
2236 			 */
2237 			port_count--;
2238 			mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
2239 				 (port_count << 8)) + card->mpa_tx.start_port;
2240 		} else {
2241 			mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
2242 				 (card->mpa_tx.ports << 4)) +
2243 				 card->mpa_tx.start_port;
2244 		}
2245 
2246 		if (card->mpa_tx.pkt_cnt == 1)
2247 			mport = adapter->ioport + card->mpa_tx.start_port;
2248 
2249 		ret = mwifiex_write_data_to_card(adapter, card->mpa_tx.buf,
2250 						 card->mpa_tx.buf_len, mport);
2251 
2252 		/* Save the last multi port tx aggreagation info to debug log */
2253 		index = adapter->dbg.last_sdio_mp_index;
2254 		index = (index + 1) % MWIFIEX_DBG_SDIO_MP_NUM;
2255 		adapter->dbg.last_sdio_mp_index = index;
2256 		adapter->dbg.last_mp_wr_ports[index] = mport;
2257 		adapter->dbg.last_mp_wr_bitmap[index] = card->mp_wr_bitmap;
2258 		adapter->dbg.last_mp_wr_len[index] = card->mpa_tx.buf_len;
2259 		adapter->dbg.last_mp_curr_wr_port[index] = card->curr_wr_port;
2260 
2261 		MP_TX_AGGR_BUF_RESET(card);
2262 	}
2263 
2264 tx_curr_single:
2265 	if (f_send_cur_buf) {
2266 		mwifiex_dbg(adapter, DATA,
2267 			    "data: %s: send current buffer %d\n",
2268 			    __func__, port);
2269 		ret = mwifiex_write_data_to_card(adapter, payload, pkt_len,
2270 						 adapter->ioport + port);
2271 	}
2272 
2273 	if (f_postcopy_cur_buf) {
2274 		mwifiex_dbg(adapter, DATA,
2275 			    "data: %s: postcopy current buffer\n",
2276 			    __func__);
2277 		MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
2278 	}
2279 
2280 	return ret;
2281 }
2282 
2283 /*
2284  * This function downloads data from driver to card.
2285  *
2286  * Both commands and data packets are transferred to the card by this
2287  * function.
2288  *
2289  * This function adds the SDIO specific header to the front of the buffer
2290  * before transferring. The header contains the length of the packet and
2291  * the type. The firmware handles the packets based upon this set type.
2292  */
2293 static int mwifiex_sdio_host_to_card(struct mwifiex_adapter *adapter,
2294 				     u8 type, struct sk_buff *skb,
2295 				     struct mwifiex_tx_param *tx_param)
2296 {
2297 	struct sdio_mmc_card *card = adapter->card;
2298 	int ret;
2299 	u32 buf_block_len;
2300 	u32 blk_size;
2301 	u32 port = CTRL_PORT;
2302 	u8 *payload = (u8 *)skb->data;
2303 	u32 pkt_len = skb->len;
2304 
2305 	/* Allocate buffer and copy payload */
2306 	blk_size = MWIFIEX_SDIO_BLOCK_SIZE;
2307 	buf_block_len = (pkt_len + blk_size - 1) / blk_size;
2308 	put_unaligned_le16((u16)pkt_len, payload + 0);
2309 	put_unaligned_le16((u32)type, payload + 2);
2310 
2311 
2312 	/*
2313 	 * This is SDIO specific header
2314 	 *  u16 length,
2315 	 *  u16 type (MWIFIEX_TYPE_DATA = 0, MWIFIEX_TYPE_CMD = 1,
2316 	 *  MWIFIEX_TYPE_EVENT = 3)
2317 	 */
2318 	if (type == MWIFIEX_TYPE_DATA) {
2319 		ret = mwifiex_get_wr_port_data(adapter, &port);
2320 		if (ret) {
2321 			mwifiex_dbg(adapter, ERROR,
2322 				    "%s: no wr_port available\n",
2323 				    __func__);
2324 			return ret;
2325 		}
2326 	} else {
2327 		adapter->cmd_sent = true;
2328 		/* Type must be MWIFIEX_TYPE_CMD */
2329 
2330 		if (pkt_len <= adapter->intf_hdr_len ||
2331 		    pkt_len > MWIFIEX_UPLD_SIZE)
2332 			mwifiex_dbg(adapter, ERROR,
2333 				    "%s: payload=%p, nb=%d\n",
2334 				    __func__, payload, pkt_len);
2335 
2336 		if (card->supports_sdio_new_mode)
2337 			port = CMD_PORT_SLCT;
2338 	}
2339 
2340 	/* Transfer data to card */
2341 	pkt_len = buf_block_len * blk_size;
2342 
2343 	if (tx_param)
2344 		ret = mwifiex_host_to_card_mp_aggr(adapter, payload, pkt_len,
2345 						   port, tx_param->next_pkt_len
2346 						   );
2347 	else
2348 		ret = mwifiex_host_to_card_mp_aggr(adapter, payload, pkt_len,
2349 						   port, 0);
2350 
2351 	if (ret) {
2352 		if (type == MWIFIEX_TYPE_CMD)
2353 			adapter->cmd_sent = false;
2354 		if (type == MWIFIEX_TYPE_DATA) {
2355 			adapter->data_sent = false;
2356 			/* restore curr_wr_port in error cases */
2357 			card->curr_wr_port = port;
2358 			card->mp_wr_bitmap |= (u32)(1 << card->curr_wr_port);
2359 		}
2360 	} else {
2361 		if (type == MWIFIEX_TYPE_DATA) {
2362 			if (!(card->mp_wr_bitmap & (1 << card->curr_wr_port)))
2363 				adapter->data_sent = true;
2364 			else
2365 				adapter->data_sent = false;
2366 		}
2367 	}
2368 
2369 	return ret;
2370 }
2371 
2372 /*
2373  * This function allocates the MPA Tx and Rx buffers.
2374  */
2375 static int mwifiex_alloc_sdio_mpa_buffers(struct mwifiex_adapter *adapter,
2376 				   u32 mpa_tx_buf_size, u32 mpa_rx_buf_size)
2377 {
2378 	struct sdio_mmc_card *card = adapter->card;
2379 	u32 rx_buf_size;
2380 	int ret = 0;
2381 
2382 	card->mpa_tx.buf = kzalloc(mpa_tx_buf_size, GFP_KERNEL);
2383 	if (!card->mpa_tx.buf) {
2384 		ret = -1;
2385 		goto error;
2386 	}
2387 
2388 	card->mpa_tx.buf_size = mpa_tx_buf_size;
2389 
2390 	rx_buf_size = max_t(u32, mpa_rx_buf_size,
2391 			    (u32)SDIO_MAX_AGGR_BUF_SIZE);
2392 	card->mpa_rx.buf = kzalloc(rx_buf_size, GFP_KERNEL);
2393 	if (!card->mpa_rx.buf) {
2394 		ret = -1;
2395 		goto error;
2396 	}
2397 
2398 	card->mpa_rx.buf_size = rx_buf_size;
2399 
2400 error:
2401 	if (ret) {
2402 		kfree(card->mpa_tx.buf);
2403 		kfree(card->mpa_rx.buf);
2404 		card->mpa_tx.buf_size = 0;
2405 		card->mpa_rx.buf_size = 0;
2406 		card->mpa_tx.buf = NULL;
2407 		card->mpa_rx.buf = NULL;
2408 	}
2409 
2410 	return ret;
2411 }
2412 
2413 /*
2414  * This function unregisters the SDIO device.
2415  *
2416  * The SDIO IRQ is released, the function is disabled and driver
2417  * data is set to null.
2418  */
2419 static void
2420 mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2421 {
2422 	struct sdio_mmc_card *card = adapter->card;
2423 
2424 	if (adapter->card) {
2425 		card->adapter = NULL;
2426 		sdio_claim_host(card->func);
2427 		sdio_disable_func(card->func);
2428 		sdio_release_host(card->func);
2429 	}
2430 }
2431 
2432 /*
2433  * This function registers the SDIO device.
2434  *
2435  * SDIO IRQ is claimed, block size is set and driver data is initialized.
2436  */
2437 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2438 {
2439 	int ret;
2440 	struct sdio_mmc_card *card = adapter->card;
2441 	struct sdio_func *func = card->func;
2442 
2443 	/* save adapter pointer in card */
2444 	card->adapter = adapter;
2445 	adapter->tx_buf_size = card->tx_buf_size;
2446 
2447 	sdio_claim_host(func);
2448 
2449 	/* Set block size */
2450 	ret = sdio_set_block_size(card->func, MWIFIEX_SDIO_BLOCK_SIZE);
2451 	sdio_release_host(func);
2452 	if (ret) {
2453 		mwifiex_dbg(adapter, ERROR,
2454 			    "cannot set SDIO block size\n");
2455 		return ret;
2456 	}
2457 
2458 	strcpy(adapter->fw_name, card->firmware);
2459 	if (card->fw_dump_enh) {
2460 		adapter->mem_type_mapping_tbl = generic_mem_type_map;
2461 		adapter->num_mem_types = 1;
2462 	} else {
2463 		adapter->mem_type_mapping_tbl = mem_type_mapping_tbl;
2464 		adapter->num_mem_types = ARRAY_SIZE(mem_type_mapping_tbl);
2465 	}
2466 
2467 	return 0;
2468 }
2469 
2470 /*
2471  * This function initializes the SDIO driver.
2472  *
2473  * The following initializations steps are followed -
2474  *      - Read the Host interrupt status register to acknowledge
2475  *        the first interrupt got from bootloader
2476  *      - Disable host interrupt mask register
2477  *      - Get SDIO port
2478  *      - Initialize SDIO variables in card
2479  *      - Allocate MP registers
2480  *      - Allocate MPA Tx and Rx buffers
2481  */
2482 static int mwifiex_init_sdio(struct mwifiex_adapter *adapter)
2483 {
2484 	struct sdio_mmc_card *card = adapter->card;
2485 	const struct mwifiex_sdio_card_reg *reg = card->reg;
2486 	int ret;
2487 	u8 sdio_ireg;
2488 
2489 	sdio_set_drvdata(card->func, card);
2490 
2491 	/*
2492 	 * Read the host_int_status_reg for ACK the first interrupt got
2493 	 * from the bootloader. If we don't do this we get a interrupt
2494 	 * as soon as we register the irq.
2495 	 */
2496 	mwifiex_read_reg(adapter, card->reg->host_int_status_reg, &sdio_ireg);
2497 
2498 	/* Get SDIO ioport */
2499 	mwifiex_init_sdio_ioport(adapter);
2500 
2501 	/* Initialize SDIO variables in card */
2502 	card->mp_rd_bitmap = 0;
2503 	card->mp_wr_bitmap = 0;
2504 	card->curr_rd_port = reg->start_rd_port;
2505 	card->curr_wr_port = reg->start_wr_port;
2506 
2507 	card->mp_data_port_mask = reg->data_port_mask;
2508 
2509 	card->mpa_tx.buf_len = 0;
2510 	card->mpa_tx.pkt_cnt = 0;
2511 	card->mpa_tx.start_port = 0;
2512 
2513 	card->mpa_tx.enabled = 1;
2514 	card->mpa_tx.pkt_aggr_limit = card->mp_agg_pkt_limit;
2515 
2516 	card->mpa_rx.buf_len = 0;
2517 	card->mpa_rx.pkt_cnt = 0;
2518 	card->mpa_rx.start_port = 0;
2519 
2520 	card->mpa_rx.enabled = 1;
2521 	card->mpa_rx.pkt_aggr_limit = card->mp_agg_pkt_limit;
2522 
2523 	/* Allocate buffers for SDIO MP-A */
2524 	card->mp_regs = kzalloc(reg->max_mp_regs, GFP_KERNEL);
2525 	if (!card->mp_regs)
2526 		return -ENOMEM;
2527 
2528 	/* Allocate skb pointer buffers */
2529 	card->mpa_rx.skb_arr = kcalloc(card->mp_agg_pkt_limit, sizeof(void *),
2530 				       GFP_KERNEL);
2531 	if (!card->mpa_rx.skb_arr) {
2532 		kfree(card->mp_regs);
2533 		return -ENOMEM;
2534 	}
2535 
2536 	card->mpa_rx.len_arr = kcalloc(card->mp_agg_pkt_limit,
2537 				       sizeof(*card->mpa_rx.len_arr),
2538 				       GFP_KERNEL);
2539 	if (!card->mpa_rx.len_arr) {
2540 		kfree(card->mp_regs);
2541 		kfree(card->mpa_rx.skb_arr);
2542 		return -ENOMEM;
2543 	}
2544 
2545 	ret = mwifiex_alloc_sdio_mpa_buffers(adapter,
2546 					     card->mp_tx_agg_buf_size,
2547 					     card->mp_rx_agg_buf_size);
2548 
2549 	/* Allocate 32k MPA Tx/Rx buffers if 64k memory allocation fails */
2550 	if (ret && (card->mp_tx_agg_buf_size == MWIFIEX_MP_AGGR_BUF_SIZE_MAX ||
2551 		    card->mp_rx_agg_buf_size == MWIFIEX_MP_AGGR_BUF_SIZE_MAX)) {
2552 		/* Disable rx single port aggregation */
2553 		adapter->host_disable_sdio_rx_aggr = true;
2554 
2555 		ret = mwifiex_alloc_sdio_mpa_buffers
2556 			(adapter, MWIFIEX_MP_AGGR_BUF_SIZE_32K,
2557 			 MWIFIEX_MP_AGGR_BUF_SIZE_32K);
2558 		if (ret) {
2559 			/* Disable multi port aggregation */
2560 			card->mpa_tx.enabled = 0;
2561 			card->mpa_rx.enabled = 0;
2562 		}
2563 	}
2564 
2565 	adapter->auto_tdls = card->can_auto_tdls;
2566 	adapter->ext_scan = card->can_ext_scan;
2567 	return 0;
2568 }
2569 
2570 /*
2571  * This function resets the MPA Tx and Rx buffers.
2572  */
2573 static void mwifiex_cleanup_mpa_buf(struct mwifiex_adapter *adapter)
2574 {
2575 	struct sdio_mmc_card *card = adapter->card;
2576 
2577 	MP_TX_AGGR_BUF_RESET(card);
2578 	MP_RX_AGGR_BUF_RESET(card);
2579 }
2580 
2581 /*
2582  * This function cleans up the allocated card buffers.
2583  *
2584  * The following are freed by this function -
2585  *      - MP registers
2586  *      - MPA Tx buffer
2587  *      - MPA Rx buffer
2588  */
2589 static void mwifiex_cleanup_sdio(struct mwifiex_adapter *adapter)
2590 {
2591 	struct sdio_mmc_card *card = adapter->card;
2592 
2593 	cancel_work_sync(&card->work);
2594 
2595 	kfree(card->mp_regs);
2596 	kfree(card->mpa_rx.skb_arr);
2597 	kfree(card->mpa_rx.len_arr);
2598 	kfree(card->mpa_tx.buf);
2599 	kfree(card->mpa_rx.buf);
2600 }
2601 
2602 /*
2603  * This function updates the MP end port in card.
2604  */
2605 static void
2606 mwifiex_update_mp_end_port(struct mwifiex_adapter *adapter, u16 port)
2607 {
2608 	struct sdio_mmc_card *card = adapter->card;
2609 	const struct mwifiex_sdio_card_reg *reg = card->reg;
2610 	int i;
2611 
2612 	card->mp_end_port = port;
2613 
2614 	card->mp_data_port_mask = reg->data_port_mask;
2615 
2616 	if (reg->start_wr_port) {
2617 		for (i = 1; i <= card->max_ports - card->mp_end_port; i++)
2618 			card->mp_data_port_mask &=
2619 					~(1 << (card->max_ports - i));
2620 	}
2621 
2622 	card->curr_wr_port = reg->start_wr_port;
2623 
2624 	mwifiex_dbg(adapter, CMD,
2625 		    "cmd: mp_end_port %d, data port mask 0x%x\n",
2626 		    port, card->mp_data_port_mask);
2627 }
2628 
2629 static void mwifiex_sdio_card_reset_work(struct mwifiex_adapter *adapter)
2630 {
2631 	struct sdio_mmc_card *card = adapter->card;
2632 	struct sdio_func *func = card->func;
2633 	int ret;
2634 
2635 	/* Prepare the adapter for the reset. */
2636 	mwifiex_shutdown_sw(adapter);
2637 	clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags);
2638 	clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags);
2639 
2640 	/* Run a HW reset of the SDIO interface. */
2641 	sdio_claim_host(func);
2642 	ret = mmc_hw_reset(func->card->host);
2643 	sdio_release_host(func);
2644 
2645 	switch (ret) {
2646 	case 1:
2647 		dev_dbg(&func->dev, "SDIO HW reset asynchronous\n");
2648 		complete_all(adapter->fw_done);
2649 		break;
2650 	case 0:
2651 		ret = mwifiex_reinit_sw(adapter);
2652 		if (ret)
2653 			dev_err(&func->dev, "reinit failed: %d\n", ret);
2654 		break;
2655 	default:
2656 		dev_err(&func->dev, "SDIO HW reset failed: %d\n", ret);
2657 		break;
2658 	}
2659 }
2660 
2661 /* This function read/write firmware */
2662 static enum
2663 rdwr_status mwifiex_sdio_rdwr_firmware(struct mwifiex_adapter *adapter,
2664 				       u8 doneflag)
2665 {
2666 	struct sdio_mmc_card *card = adapter->card;
2667 	int ret, tries;
2668 	u8 ctrl_data = 0;
2669 
2670 	sdio_writeb(card->func, card->reg->fw_dump_host_ready,
2671 		    card->reg->fw_dump_ctrl, &ret);
2672 	if (ret) {
2673 		mwifiex_dbg(adapter, ERROR, "SDIO Write ERR\n");
2674 		return RDWR_STATUS_FAILURE;
2675 	}
2676 	for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2677 		ctrl_data = sdio_readb(card->func, card->reg->fw_dump_ctrl,
2678 				       &ret);
2679 		if (ret) {
2680 			mwifiex_dbg(adapter, ERROR, "SDIO read err\n");
2681 			return RDWR_STATUS_FAILURE;
2682 		}
2683 		if (ctrl_data == FW_DUMP_DONE)
2684 			break;
2685 		if (doneflag && ctrl_data == doneflag)
2686 			return RDWR_STATUS_DONE;
2687 		if (ctrl_data != card->reg->fw_dump_host_ready) {
2688 			mwifiex_dbg(adapter, WARN,
2689 				    "The ctrl reg was changed, re-try again\n");
2690 			sdio_writeb(card->func, card->reg->fw_dump_host_ready,
2691 				    card->reg->fw_dump_ctrl, &ret);
2692 			if (ret) {
2693 				mwifiex_dbg(adapter, ERROR, "SDIO write err\n");
2694 				return RDWR_STATUS_FAILURE;
2695 			}
2696 		}
2697 		usleep_range(100, 200);
2698 	}
2699 	if (ctrl_data == card->reg->fw_dump_host_ready) {
2700 		mwifiex_dbg(adapter, ERROR,
2701 			    "Fail to pull ctrl_data\n");
2702 		return RDWR_STATUS_FAILURE;
2703 	}
2704 
2705 	return RDWR_STATUS_SUCCESS;
2706 }
2707 
2708 /* This function dump firmware memory to file */
2709 static void mwifiex_sdio_fw_dump(struct mwifiex_adapter *adapter)
2710 {
2711 	struct sdio_mmc_card *card = adapter->card;
2712 	int ret = 0;
2713 	unsigned int reg, reg_start, reg_end;
2714 	u8 *dbg_ptr, *end_ptr, dump_num, idx, i, read_reg, doneflag = 0;
2715 	enum rdwr_status stat;
2716 	u32 memory_size;
2717 
2718 	if (!card->can_dump_fw)
2719 		return;
2720 
2721 	for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) {
2722 		struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
2723 
2724 		if (entry->mem_ptr) {
2725 			vfree(entry->mem_ptr);
2726 			entry->mem_ptr = NULL;
2727 		}
2728 		entry->mem_size = 0;
2729 	}
2730 
2731 	mwifiex_pm_wakeup_card(adapter);
2732 	sdio_claim_host(card->func);
2733 
2734 	mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2735 
2736 	stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag);
2737 	if (stat == RDWR_STATUS_FAILURE)
2738 		goto done;
2739 
2740 	reg = card->reg->fw_dump_start;
2741 	/* Read the number of the memories which will dump */
2742 	dump_num = sdio_readb(card->func, reg, &ret);
2743 	if (ret) {
2744 		mwifiex_dbg(adapter, ERROR, "SDIO read memory length err\n");
2745 		goto done;
2746 	}
2747 
2748 	/* Read the length of every memory which will dump */
2749 	for (idx = 0; idx < dump_num; idx++) {
2750 		struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
2751 
2752 		stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag);
2753 		if (stat == RDWR_STATUS_FAILURE)
2754 			goto done;
2755 
2756 		memory_size = 0;
2757 		reg = card->reg->fw_dump_start;
2758 		for (i = 0; i < 4; i++) {
2759 			read_reg = sdio_readb(card->func, reg, &ret);
2760 			if (ret) {
2761 				mwifiex_dbg(adapter, ERROR, "SDIO read err\n");
2762 				goto done;
2763 			}
2764 			memory_size |= (read_reg << i*8);
2765 			reg++;
2766 		}
2767 
2768 		if (memory_size == 0) {
2769 			mwifiex_dbg(adapter, DUMP, "Firmware dump Finished!\n");
2770 			ret = mwifiex_write_reg(adapter,
2771 						card->reg->fw_dump_ctrl,
2772 						FW_DUMP_READ_DONE);
2773 			if (ret) {
2774 				mwifiex_dbg(adapter, ERROR, "SDIO write err\n");
2775 				return;
2776 			}
2777 			break;
2778 		}
2779 
2780 		mwifiex_dbg(adapter, DUMP,
2781 			    "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
2782 		entry->mem_ptr = vmalloc(memory_size + 1);
2783 		entry->mem_size = memory_size;
2784 		if (!entry->mem_ptr) {
2785 			mwifiex_dbg(adapter, ERROR, "Vmalloc %s failed\n",
2786 				    entry->mem_name);
2787 			goto done;
2788 		}
2789 		dbg_ptr = entry->mem_ptr;
2790 		end_ptr = dbg_ptr + memory_size;
2791 
2792 		doneflag = entry->done_flag;
2793 		mwifiex_dbg(adapter, DUMP,
2794 			    "Start %s output, please wait...\n",
2795 			    entry->mem_name);
2796 
2797 		do {
2798 			stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag);
2799 			if (stat == RDWR_STATUS_FAILURE)
2800 				goto done;
2801 
2802 			reg_start = card->reg->fw_dump_start;
2803 			reg_end = card->reg->fw_dump_end;
2804 			for (reg = reg_start; reg <= reg_end; reg++) {
2805 				*dbg_ptr = sdio_readb(card->func, reg, &ret);
2806 				if (ret) {
2807 					mwifiex_dbg(adapter, ERROR,
2808 						    "SDIO read err\n");
2809 					goto done;
2810 				}
2811 				if (dbg_ptr < end_ptr)
2812 					dbg_ptr++;
2813 				else
2814 					mwifiex_dbg(adapter, ERROR,
2815 						    "Allocated buf not enough\n");
2816 			}
2817 
2818 			if (stat != RDWR_STATUS_DONE)
2819 				continue;
2820 
2821 			mwifiex_dbg(adapter, DUMP, "%s done: size=0x%tx\n",
2822 				    entry->mem_name, dbg_ptr - entry->mem_ptr);
2823 			break;
2824 		} while (1);
2825 	}
2826 	mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2827 
2828 done:
2829 	sdio_release_host(card->func);
2830 }
2831 
2832 static void mwifiex_sdio_generic_fw_dump(struct mwifiex_adapter *adapter)
2833 {
2834 	struct sdio_mmc_card *card = adapter->card;
2835 	struct memory_type_mapping *entry = &generic_mem_type_map[0];
2836 	unsigned int reg, reg_start, reg_end;
2837 	u8 start_flag = 0, done_flag = 0;
2838 	u8 *dbg_ptr, *end_ptr;
2839 	enum rdwr_status stat;
2840 	int ret = -1, tries;
2841 
2842 	if (!card->fw_dump_enh)
2843 		return;
2844 
2845 	if (entry->mem_ptr) {
2846 		vfree(entry->mem_ptr);
2847 		entry->mem_ptr = NULL;
2848 	}
2849 	entry->mem_size = 0;
2850 
2851 	mwifiex_pm_wakeup_card(adapter);
2852 	sdio_claim_host(card->func);
2853 
2854 	mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2855 
2856 	stat = mwifiex_sdio_rdwr_firmware(adapter, done_flag);
2857 	if (stat == RDWR_STATUS_FAILURE)
2858 		goto done;
2859 
2860 	reg_start = card->reg->fw_dump_start;
2861 	reg_end = card->reg->fw_dump_end;
2862 	for (reg = reg_start; reg <= reg_end; reg++) {
2863 		for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2864 			start_flag = sdio_readb(card->func, reg, &ret);
2865 			if (ret) {
2866 				mwifiex_dbg(adapter, ERROR,
2867 					    "SDIO read err\n");
2868 				goto done;
2869 			}
2870 			if (start_flag == 0)
2871 				break;
2872 			if (tries == MAX_POLL_TRIES) {
2873 				mwifiex_dbg(adapter, ERROR,
2874 					    "FW not ready to dump\n");
2875 				ret = -1;
2876 				goto done;
2877 			}
2878 		}
2879 		usleep_range(100, 200);
2880 	}
2881 
2882 	entry->mem_ptr = vmalloc(0xf0000 + 1);
2883 	if (!entry->mem_ptr) {
2884 		ret = -1;
2885 		goto done;
2886 	}
2887 	dbg_ptr = entry->mem_ptr;
2888 	entry->mem_size = 0xf0000;
2889 	end_ptr = dbg_ptr + entry->mem_size;
2890 
2891 	done_flag = entry->done_flag;
2892 	mwifiex_dbg(adapter, DUMP,
2893 		    "Start %s output, please wait...\n", entry->mem_name);
2894 
2895 	while (true) {
2896 		stat = mwifiex_sdio_rdwr_firmware(adapter, done_flag);
2897 		if (stat == RDWR_STATUS_FAILURE)
2898 			goto done;
2899 		for (reg = reg_start; reg <= reg_end; reg++) {
2900 			*dbg_ptr = sdio_readb(card->func, reg, &ret);
2901 			if (ret) {
2902 				mwifiex_dbg(adapter, ERROR,
2903 					    "SDIO read err\n");
2904 				goto done;
2905 			}
2906 			dbg_ptr++;
2907 			if (dbg_ptr >= end_ptr) {
2908 				u8 *tmp_ptr;
2909 
2910 				tmp_ptr = vmalloc(entry->mem_size + 0x4000 + 1);
2911 				if (!tmp_ptr)
2912 					goto done;
2913 
2914 				memcpy(tmp_ptr, entry->mem_ptr,
2915 				       entry->mem_size);
2916 				vfree(entry->mem_ptr);
2917 				entry->mem_ptr = tmp_ptr;
2918 				tmp_ptr = NULL;
2919 				dbg_ptr = entry->mem_ptr + entry->mem_size;
2920 				entry->mem_size += 0x4000;
2921 				end_ptr = entry->mem_ptr + entry->mem_size;
2922 			}
2923 		}
2924 		if (stat == RDWR_STATUS_DONE) {
2925 			entry->mem_size = dbg_ptr - entry->mem_ptr;
2926 			mwifiex_dbg(adapter, DUMP, "dump %s done size=0x%x\n",
2927 				    entry->mem_name, entry->mem_size);
2928 			ret = 0;
2929 			break;
2930 		}
2931 	}
2932 	mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2933 
2934 done:
2935 	if (ret) {
2936 		mwifiex_dbg(adapter, ERROR, "firmware dump failed\n");
2937 		if (entry->mem_ptr) {
2938 			vfree(entry->mem_ptr);
2939 			entry->mem_ptr = NULL;
2940 		}
2941 		entry->mem_size = 0;
2942 	}
2943 	sdio_release_host(card->func);
2944 }
2945 
2946 static void mwifiex_sdio_device_dump_work(struct mwifiex_adapter *adapter)
2947 {
2948 	struct sdio_mmc_card *card = adapter->card;
2949 
2950 	adapter->devdump_data = vzalloc(MWIFIEX_FW_DUMP_SIZE);
2951 	if (!adapter->devdump_data) {
2952 		mwifiex_dbg(adapter, ERROR,
2953 			    "vzalloc devdump data failure!\n");
2954 		return;
2955 	}
2956 
2957 	mwifiex_drv_info_dump(adapter);
2958 	if (card->fw_dump_enh)
2959 		mwifiex_sdio_generic_fw_dump(adapter);
2960 	else
2961 		mwifiex_sdio_fw_dump(adapter);
2962 	mwifiex_prepare_fw_dump_info(adapter);
2963 	mwifiex_upload_device_dump(adapter);
2964 }
2965 
2966 static void mwifiex_sdio_work(struct work_struct *work)
2967 {
2968 	struct sdio_mmc_card *card =
2969 		container_of(work, struct sdio_mmc_card, work);
2970 
2971 	if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2972 			       &card->work_flags))
2973 		mwifiex_sdio_device_dump_work(card->adapter);
2974 	if (test_and_clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET,
2975 			       &card->work_flags))
2976 		mwifiex_sdio_card_reset_work(card->adapter);
2977 }
2978 
2979 /* This function resets the card */
2980 static void mwifiex_sdio_card_reset(struct mwifiex_adapter *adapter)
2981 {
2982 	struct sdio_mmc_card *card = adapter->card;
2983 
2984 	if (!test_and_set_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags))
2985 		schedule_work(&card->work);
2986 }
2987 
2988 /* This function dumps FW information */
2989 static void mwifiex_sdio_device_dump(struct mwifiex_adapter *adapter)
2990 {
2991 	struct sdio_mmc_card *card = adapter->card;
2992 
2993 	if (!test_and_set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2994 			      &card->work_flags))
2995 		schedule_work(&card->work);
2996 }
2997 
2998 /* Function to dump SDIO function registers and SDIO scratch registers in case
2999  * of FW crash
3000  */
3001 static int
3002 mwifiex_sdio_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf)
3003 {
3004 	char *p = drv_buf;
3005 	struct sdio_mmc_card *cardp = adapter->card;
3006 	int ret = 0;
3007 	u8 count, func, data, index = 0, size = 0;
3008 	u8 reg, reg_start, reg_end;
3009 	char buf[256], *ptr;
3010 
3011 	if (!p)
3012 		return 0;
3013 
3014 	mwifiex_dbg(adapter, MSG, "SDIO register dump start\n");
3015 
3016 	mwifiex_pm_wakeup_card(adapter);
3017 
3018 	sdio_claim_host(cardp->func);
3019 
3020 	for (count = 0; count < 5; count++) {
3021 		memset(buf, 0, sizeof(buf));
3022 		ptr = buf;
3023 
3024 		switch (count) {
3025 		case 0:
3026 			/* Read the registers of SDIO function0 */
3027 			func = count;
3028 			reg_start = 0;
3029 			reg_end = 9;
3030 			break;
3031 		case 1:
3032 			/* Read the registers of SDIO function1 */
3033 			func = count;
3034 			reg_start = cardp->reg->func1_dump_reg_start;
3035 			reg_end = cardp->reg->func1_dump_reg_end;
3036 			break;
3037 		case 2:
3038 			index = 0;
3039 			func = 1;
3040 			reg_start = cardp->reg->func1_spec_reg_table[index++];
3041 			size = cardp->reg->func1_spec_reg_num;
3042 			reg_end = cardp->reg->func1_spec_reg_table[size-1];
3043 			break;
3044 		default:
3045 			/* Read the scratch registers of SDIO function1 */
3046 			if (count == 4)
3047 				mdelay(100);
3048 			func = 1;
3049 			reg_start = cardp->reg->func1_scratch_reg;
3050 			reg_end = reg_start + MWIFIEX_SDIO_SCRATCH_SIZE;
3051 		}
3052 
3053 		if (count != 2)
3054 			ptr += sprintf(ptr, "SDIO Func%d (%#x-%#x): ",
3055 				       func, reg_start, reg_end);
3056 		else
3057 			ptr += sprintf(ptr, "SDIO Func%d: ", func);
3058 
3059 		for (reg = reg_start; reg <= reg_end;) {
3060 			if (func == 0)
3061 				data = sdio_f0_readb(cardp->func, reg, &ret);
3062 			else
3063 				data = sdio_readb(cardp->func, reg, &ret);
3064 
3065 			if (count == 2)
3066 				ptr += sprintf(ptr, "(%#x) ", reg);
3067 			if (!ret) {
3068 				ptr += sprintf(ptr, "%02x ", data);
3069 			} else {
3070 				ptr += sprintf(ptr, "ERR");
3071 				break;
3072 			}
3073 
3074 			if (count == 2 && reg < reg_end)
3075 				reg = cardp->reg->func1_spec_reg_table[index++];
3076 			else
3077 				reg++;
3078 		}
3079 
3080 		mwifiex_dbg(adapter, MSG, "%s\n", buf);
3081 		p += sprintf(p, "%s\n", buf);
3082 	}
3083 
3084 	sdio_release_host(cardp->func);
3085 
3086 	mwifiex_dbg(adapter, MSG, "SDIO register dump end\n");
3087 
3088 	return p - drv_buf;
3089 }
3090 
3091 /* sdio device/function initialization, code is extracted
3092  * from init_if handler and register_dev handler.
3093  */
3094 static void mwifiex_sdio_up_dev(struct mwifiex_adapter *adapter)
3095 {
3096 	struct sdio_mmc_card *card = adapter->card;
3097 	u8 sdio_ireg;
3098 
3099 	sdio_claim_host(card->func);
3100 	sdio_enable_func(card->func);
3101 	sdio_set_block_size(card->func, MWIFIEX_SDIO_BLOCK_SIZE);
3102 	sdio_release_host(card->func);
3103 
3104 	/* tx_buf_size might be changed to 3584 by firmware during
3105 	 * data transfer, we will reset to default size.
3106 	 */
3107 	adapter->tx_buf_size = card->tx_buf_size;
3108 
3109 	/* Read the host_int_status_reg for ACK the first interrupt got
3110 	 * from the bootloader. If we don't do this we get a interrupt
3111 	 * as soon as we register the irq.
3112 	 */
3113 	mwifiex_read_reg(adapter, card->reg->host_int_status_reg, &sdio_ireg);
3114 
3115 	mwifiex_init_sdio_ioport(adapter);
3116 }
3117 
3118 static struct mwifiex_if_ops sdio_ops = {
3119 	.init_if = mwifiex_init_sdio,
3120 	.cleanup_if = mwifiex_cleanup_sdio,
3121 	.check_fw_status = mwifiex_check_fw_status,
3122 	.check_winner_status = mwifiex_check_winner_status,
3123 	.prog_fw = mwifiex_prog_fw_w_helper,
3124 	.register_dev = mwifiex_register_dev,
3125 	.unregister_dev = mwifiex_unregister_dev,
3126 	.enable_int = mwifiex_sdio_enable_host_int,
3127 	.disable_int = mwifiex_sdio_disable_host_int,
3128 	.process_int_status = mwifiex_process_int_status,
3129 	.host_to_card = mwifiex_sdio_host_to_card,
3130 	.wakeup = mwifiex_pm_wakeup_card,
3131 	.wakeup_complete = mwifiex_pm_wakeup_card_complete,
3132 
3133 	/* SDIO specific */
3134 	.update_mp_end_port = mwifiex_update_mp_end_port,
3135 	.cleanup_mpa_buf = mwifiex_cleanup_mpa_buf,
3136 	.cmdrsp_complete = mwifiex_sdio_cmdrsp_complete,
3137 	.event_complete = mwifiex_sdio_event_complete,
3138 	.dnld_fw = mwifiex_sdio_dnld_fw,
3139 	.card_reset = mwifiex_sdio_card_reset,
3140 	.reg_dump = mwifiex_sdio_reg_dump,
3141 	.device_dump = mwifiex_sdio_device_dump,
3142 	.deaggr_pkt = mwifiex_deaggr_sdio_pkt,
3143 	.up_dev = mwifiex_sdio_up_dev,
3144 };
3145 
3146 module_driver(mwifiex_sdio, sdio_register_driver, sdio_unregister_driver);
3147 
3148 MODULE_AUTHOR("Marvell International Ltd.");
3149 MODULE_DESCRIPTION("Marvell WiFi-Ex SDIO Driver version " SDIO_VERSION);
3150 MODULE_VERSION(SDIO_VERSION);
3151 MODULE_LICENSE("GPL v2");
3152 MODULE_FIRMWARE(SD8786_DEFAULT_FW_NAME);
3153 MODULE_FIRMWARE(SD8787_DEFAULT_FW_NAME);
3154 MODULE_FIRMWARE(SD8797_DEFAULT_FW_NAME);
3155 MODULE_FIRMWARE(SD8897_DEFAULT_FW_NAME);
3156 MODULE_FIRMWARE(SD8887_DEFAULT_FW_NAME);
3157 MODULE_FIRMWARE(SD8977_DEFAULT_FW_NAME);
3158 MODULE_FIRMWARE(SD8987_DEFAULT_FW_NAME);
3159 MODULE_FIRMWARE(SD8997_DEFAULT_FW_NAME);
3160