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