1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2020 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15 #if defined(CONFIG_MP_INCLUDED)
16 #include <rtw_efuse.h>
17
rtw_efuse_cmd(_adapter * padapter,struct rtw_efuse_phl_arg * pefuse_arg,enum rtw_efuse_phl_cmdid cmdid)18 static u8 rtw_efuse_cmd(_adapter *padapter,
19 struct rtw_efuse_phl_arg *pefuse_arg ,
20 enum rtw_efuse_phl_cmdid cmdid)
21 {
22 u32 i = 0;
23 u8 ret = _FAIL;
24 pefuse_arg->mp_class = RTW_MP_CLASS_EFUSE;
25 pefuse_arg->cmd = cmdid;
26 pefuse_arg->cmd_ok = 0;
27
28
29 rtw_mp_set_phl_cmd(padapter, (void*)pefuse_arg, sizeof(struct rtw_efuse_phl_arg));
30
31 while (i <= 50) {
32 rtw_msleep_os(10);
33 rtw_mp_get_phl_cmd(padapter, (void*)pefuse_arg, sizeof(struct rtw_efuse_phl_arg));
34 if (pefuse_arg->cmd_ok && pefuse_arg->status == RTW_PHL_STATUS_SUCCESS) {
35 RTW_INFO("%s,eFuse GET CMD OK !!!\n", __func__);
36 ret = _SUCCESS;
37 break;
38 } else {
39 rtw_msleep_os(10);
40 if (i > 50) {
41 RTW_INFO("%s, eFuse GET CMD FAIL !!!\n", __func__);
42 break;
43 }
44 i++;
45 }
46 }
47
48 return ret;
49 }
50
rtw_efuse_get_map_size(_adapter * padapter,u16 * size,enum rtw_efuse_phl_cmdid cmdid)51 u32 rtw_efuse_get_map_size(_adapter *padapter , u16 *size , enum rtw_efuse_phl_cmdid cmdid)
52 {
53 struct rtw_efuse_phl_arg *efuse_arg = NULL;
54 u8 res = _FAIL;
55
56 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
57 if (efuse_arg) {
58 _rtw_memset((void *)efuse_arg, 0, sizeof(struct rtw_efuse_phl_arg));
59 rtw_efuse_cmd(padapter, efuse_arg, cmdid);
60 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS) {
61 *size = efuse_arg->io_value;
62 res = _SUCCESS;
63 } else {
64 *size = 0;
65 res = _FAIL;
66 }
67 }
68 if (efuse_arg)
69 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
70
71 return res;
72 }
73
rtw_efuse_get_available_size(_adapter * padapter,u16 * size,u8 efuse_type)74 u32 rtw_efuse_get_available_size(_adapter *padapter , u16 *size, u8 efuse_type)
75 {
76 struct rtw_efuse_phl_arg *efuse_arg = NULL;
77 u8 res = _FAIL;
78
79 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
80
81 if (efuse_arg) {
82 _rtw_memset((void *)efuse_arg, 0, sizeof(struct rtw_efuse_phl_arg));
83
84 if (efuse_type == RTW_EFUSE_WIFI)
85 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_WIFI_GET_AVL_SIZE);
86 else
87 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_BT_GET_AVL_SIZE);
88
89 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS) {
90 *size = efuse_arg->io_value;
91 res = _SUCCESS;
92 } else {
93 *size = 0;
94 res = _FAIL;
95 }
96 }
97 if (efuse_arg)
98 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
99
100 return res;
101 }
102
rtw_efuse_fake2map(_adapter * padapter,u8 efuse_type)103 static u8 rtw_efuse_fake2map(_adapter *padapter, u8 efuse_type)
104 {
105 struct rtw_efuse_phl_arg *efuse_arg = NULL;
106 u8 res = _SUCCESS;
107
108 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
109 if (efuse_arg) {
110 _rtw_memset((void *)efuse_arg, 0, sizeof(struct rtw_efuse_phl_arg));
111
112 if (efuse_type == RTW_EFUSE_WIFI)
113 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_WIFI_UPDATE);
114 else if (efuse_type == RTW_EFUSE_BT)
115 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_BT_UPDATE);
116
117 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS)
118 res = _SUCCESS;
119 else
120 res = _FAIL;
121 }
122 if (efuse_arg)
123 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
124
125 return res;
126 }
127
rtw_efuse_read_map2shadow(_adapter * padapter,u8 efuse_type)128 static u8 rtw_efuse_read_map2shadow(_adapter *padapter, u8 efuse_type)
129 {
130 struct rtw_efuse_phl_arg *efuse_arg = NULL;
131 u8 res = _SUCCESS;
132
133 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
134 if (efuse_arg) {
135 _rtw_memset((void *)efuse_arg, 0, sizeof(struct rtw_efuse_phl_arg));
136 if (efuse_type == RTW_EFUSE_WIFI)
137 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_WIFI_UPDATE_MAP);
138 else if (efuse_type == RTW_EFUSE_BT)
139 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_BT_UPDATE_MAP);
140 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS)
141 res = _SUCCESS;
142 else
143 res = _FAIL;
144 }
145 if (efuse_arg)
146 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
147
148 return res;
149 }
150
rtw_efuse_get_shadow_map(_adapter * padapter,u8 * map,u16 size,u8 efuse_type)151 static u8 rtw_efuse_get_shadow_map(_adapter *padapter, u8 *map, u16 size, u8 efuse_type)
152 {
153 struct rtw_efuse_phl_arg *efuse_arg = NULL;
154 u8 res = _FAIL;
155
156 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
157 if (efuse_arg) {
158
159 efuse_arg->buf_len = size;
160 if (efuse_type == RTW_EFUSE_WIFI)
161 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_SHADOW_MAP2BUF);
162 else if (efuse_type == RTW_EFUSE_BT)
163 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_BT_SHADOW_MAP2BUF);
164 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS) {
165 _rtw_memcpy((void *)map, efuse_arg->poutbuf, size);
166 res = _SUCCESS;
167 } else
168 res = _FAIL;
169 }
170 if (efuse_arg)
171 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
172
173 return res;
174 }
175
rtw_efuse_renew_update(_adapter * padapter,u8 efuse_type)176 static u8 rtw_efuse_renew_update(_adapter *padapter, u8 efuse_type)
177 {
178 struct rtw_efuse_phl_arg *efuse_arg = NULL;
179 u8 res = _SUCCESS;
180
181 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
182 if (efuse_arg) {
183 _rtw_memset((void *)efuse_arg, 0, sizeof(struct rtw_efuse_phl_arg));
184
185 if (efuse_type == RTW_EFUSE_WIFI)
186 rtw_efuse_cmd(padapter, efuse_arg, RTW_MP_EFUSE_CMD_WIFI_SET_RENEW);
187 else if (efuse_type == RTW_EFUSE_BT)
188 RTW_INFO("halmac_get_logical_efuse_size fail\n");
189
190 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS)
191 res = _SUCCESS;
192 else
193 res = _FAIL;
194 }
195 if (efuse_arg)
196 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
197
198 return res;
199 }
200
rtw_file_efuse_ismasked(_adapter * padapter,u16 offset,u8 * maskbuf)201 static bool rtw_file_efuse_ismasked(_adapter *padapter, u16 offset, u8 *maskbuf)
202 {
203 int r = offset / 16;
204 int c = (offset % 16) / 2;
205 int result = 0;
206
207 if (padapter->registrypriv.boffefusemask)
208 return _FALSE;
209
210 if (c < 4) /* Upper double word */
211 result = (maskbuf[r] & (0x10 << c));
212 else
213 result = (maskbuf[r] & (0x01 << (c - 4)));
214
215 return (result > 0) ? 0 : 1;
216 }
217
rtw_efuse_compare_data(_adapter * padapter,u8 addr,u32 len,u8 * dst,u8 * src,u8 efuse_type)218 static u8 rtw_efuse_compare_data(_adapter *padapter,
219 u8 addr, u32 len, u8 *dst, u8 *src, u8 efuse_type)
220 {
221 struct rtw_efuse_phl_arg *efuse_arg = NULL;
222 enum rtw_efuse_phl_cmdid cmdid = RTW_EFUSE_CMD_WIFI_GET_MASK_BUF;
223 u8 res = _FAIL;
224 u16 idx = addr;
225
226 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
227
228 if (efuse_arg) {
229 _rtw_memset((void *)efuse_arg, 0, sizeof(struct rtw_efuse_phl_arg));
230
231
232 if (efuse_type == RTW_EFUSE_WIFI)
233 cmdid = RTW_EFUSE_CMD_WIFI_GET_MASK_BUF;
234 else if (efuse_type == RTW_EFUSE_BT)
235 cmdid = RTW_EFUSE_CMD_BT_GET_MASK_BUF;
236
237 efuse_arg->status = 0;
238 efuse_arg->cmd_ok = 0;
239 efuse_arg->buf_len = 0;
240
241 if (rtw_efuse_cmd(padapter, efuse_arg, cmdid) == _SUCCESS) {
242
243 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "efuse mask buf:",
244 efuse_arg->poutbuf, efuse_arg->buf_len);
245
246 for (; idx <= len; idx++) {
247 if (!rtw_file_efuse_ismasked(padapter, idx, efuse_arg->poutbuf)) {
248 if (_rtw_memcmp((void *)dst+idx , (void *)src+idx, 1)) {
249 RTW_INFO("mask cmp success addr: 0x%x dst: %02x <=> src:%02x\n",
250 idx, dst[idx], src[idx]);
251 res = _SUCCESS;
252 } else {
253 RTW_INFO("mask cmp Fail addr: 0x%x dst: %02x <=> src:%02x\n",
254 idx, dst[idx], src[idx]);
255 res = _FAIL;
256 break;
257 }
258 }
259 }
260 } else {
261 RTW_INFO("rtw_efuse_cmd:%d, status:%d,mask len: %d\n",
262 efuse_arg->cmd_ok, efuse_arg->status, efuse_arg->buf_len);
263 res = _FAIL;
264 }
265 }
266 if (efuse_arg)
267 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
268 return res;
269 }
270
rtw_efuse_map_read(_adapter * adapter,u16 addr,u16 cnts,u8 * data,u8 efuse_type)271 u8 rtw_efuse_map_read(_adapter * adapter, u16 addr, u16 cnts, u8 *data, u8 efuse_type)
272 {
273 struct dvobj_priv *d;
274 u8 *efuse = NULL;
275 u16 size, i;
276 int err = _FAIL;
277 u8 status = _SUCCESS;
278
279 if (efuse_type == RTW_EFUSE_WIFI)
280 err = rtw_efuse_get_map_size(adapter, &size, RTW_EFUSE_CMD_WIFI_GET_LOG_SIZE);
281 else if (efuse_type == RTW_EFUSE_BT)
282 err = rtw_efuse_get_map_size(adapter, &size, RTW_EFUSE_CMD_BT_GET_LOG_SIZE);
283
284 if (err == _FAIL) {
285 status = _FAIL;
286 RTW_INFO("halmac_get_logical_efuse_size fail\n");
287 goto exit;
288 }
289 /* size error handle */
290 if ((addr + cnts) > size) {
291 if (addr < size)
292 cnts = size - addr;
293 else {
294 status = _FAIL;
295 RTW_INFO(" %s() ,addr + cnts) > size fail\n", __func__);
296 goto exit;
297 }
298 }
299
300 efuse = rtw_zmalloc(size);
301 if (efuse) {
302 if (rtw_efuse_read_map2shadow(adapter, efuse_type) == _SUCCESS) {
303 err = rtw_efuse_get_shadow_map(adapter, efuse, size, efuse_type);
304 if (err == _FAIL) {
305 rtw_mfree(efuse, size);
306 status = _FAIL;
307 RTW_INFO(" %s() ,halmac_read_logical_efus map fail\n", __func__);
308 goto exit;
309 }
310 } else {
311 RTW_INFO(" %s() ,rtw_efuse_read_map2shadow FAIL !!!\n", __func__);
312 rtw_mfree(efuse, size);
313 status = _FAIL;
314 goto exit;
315 }
316 if (efuse) {
317 RTW_INFO(" %s() ,cp efuse to data\n", __func__);
318 _rtw_memcpy(data, efuse + addr, cnts);
319 rtw_mfree(efuse, size);
320 }
321 } else {
322 RTW_INFO(" %s() ,alloc efuse fail\n", __func__);
323 goto exit;
324 }
325 status = _SUCCESS;
326 exit:
327
328 return status;
329 }
330
rtw_efuse_map_write(_adapter * adapter,u16 addr,u16 cnts,u8 * data,u8 efuse_type,u8 bpg)331 u8 rtw_efuse_map_write(_adapter * adapter, u16 addr, u16 cnts, u8 *data, u8 efuse_type, u8 bpg)
332 {
333 struct dvobj_priv *d;
334 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
335 u16 size;
336 int err = _FAIL;
337 u8 mask_buf[64] = "";
338 u32 backupRegs[4] = {0};
339 u8 status = _SUCCESS;
340 struct rtw_efuse_phl_arg *efuse_arg = NULL;
341 u16 i = 0;
342
343 efuse_arg = rtw_zmalloc(sizeof(struct rtw_efuse_phl_arg));
344
345 if (efuse_type == RTW_EFUSE_WIFI)
346 err = rtw_efuse_get_map_size(adapter, &size, RTW_EFUSE_CMD_WIFI_GET_LOG_SIZE);
347 else if (efuse_type == RTW_EFUSE_BT)
348 err = rtw_efuse_get_map_size(adapter, &size, RTW_EFUSE_CMD_BT_GET_LOG_SIZE);
349
350 if (err == _FAIL) {
351 status = _FAIL;
352 goto exit;
353 }
354
355 if ((addr + cnts) > size) {
356 status = _FAIL;
357 goto exit;
358 }
359
360 if (efuse_type == RTW_EFUSE_WIFI) {
361 while (i != cnts) {
362 efuse_arg->io_type = 1;
363 efuse_arg->io_offset = addr + i;
364 efuse_arg->io_value = data[i];
365 rtw_efuse_cmd(adapter, efuse_arg, RTW_EFUSE_CMD_WIFI_WRITE);
366 if (i > cnts)
367 break;
368 i++;
369 }
370 } else if (efuse_type == RTW_EFUSE_BT) {
371 while (i != cnts) {
372 efuse_arg->io_type = 1;
373 efuse_arg->io_offset = addr + i;
374 efuse_arg->io_value = data[i];
375 rtw_efuse_cmd(adapter, efuse_arg, RTW_EFUSE_CMD_BT_WRITE);
376 if (i > cnts)
377 break;
378 i++;
379 }
380 }
381
382 if (bpg) {
383 RTW_INFO(" in PG state !!!\n");
384 if (efuse_type == RTW_EFUSE_WIFI)
385 err = rtw_efuse_fake2map(adapter, efuse_type);
386 else if (efuse_type == RTW_EFUSE_BT) {
387 u8 reg2chkbt = 0;
388
389 rtw_phl_write8(dvobj->phl, 0xa3, 0x05);
390 rtw_msleep_os(10);
391 reg2chkbt = rtw_phl_read8(dvobj->phl, 0xa0);
392
393 if (reg2chkbt != 0x04) {
394 RTW_ERR("BT State not Active:0x%x ,can't Write \n", reg2chkbt);
395 goto exit;
396 }
397
398 err = rtw_efuse_fake2map(adapter, efuse_type);
399 }
400
401 if (err == _FAIL) {
402 status = _FAIL;
403 goto exit;
404 }
405 }
406 status = _SUCCESS;
407 exit :
408 if (efuse_arg)
409 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
410
411 return status;
412 }
413
rtw_efuse_map_file_load(_adapter * padapter,u8 * filepath,u8 efuse_type)414 static u8 rtw_efuse_map_file_load(_adapter *padapter, u8 *filepath, u8 efuse_type)
415 {
416 struct rtw_efuse_phl_arg *efuse_arg = NULL;
417 u8 res = _FAIL;
418
419 if (filepath) {
420 RTW_INFO("efuse file path %s len %zu", filepath, strlen(filepath));
421
422 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
423 if (efuse_arg) {
424 _rtw_memset((void *)efuse_arg, 0, sizeof(struct rtw_efuse_phl_arg));
425 _rtw_memcpy(efuse_arg->pfile_path, filepath, strlen(filepath));
426 if (efuse_type == RTW_EFUSE_WIFI)
427 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_FILE_MAP_LOAD);
428 else
429 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_BT_FILE_MAP_LOAD);
430 }
431 }
432 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS)
433 res = _SUCCESS;
434 else
435 res = _FAIL;
436
437 if (efuse_arg)
438 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
439
440 return res;
441 }
442
rtw_efuse_mask_file_load(_adapter * padapter,u8 * filepath,u8 efuse_type)443 static u8 rtw_efuse_mask_file_load(_adapter *padapter, u8 *filepath, u8 efuse_type)
444 {
445 struct rtw_efuse_phl_arg *efuse_arg = NULL;
446 u8 res = _FAIL;
447
448 if (filepath) {
449 RTW_INFO("efuse file path %s len %zu", filepath, strlen(filepath));
450 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
451 if (efuse_arg) {
452 _rtw_memset((void *)efuse_arg, 0, sizeof(struct rtw_efuse_phl_arg));
453 _rtw_memcpy(efuse_arg->pfile_path, filepath, strlen(filepath));
454 if (efuse_type == RTW_EFUSE_WIFI)
455 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_FILE_MASK_LOAD);
456 else
457 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_BT_FILE_MASK_LOAD);
458 }
459 }
460
461 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS)
462 res = _SUCCESS;
463 else
464 res = _FAIL;
465
466 if (efuse_arg)
467 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
468
469 return res;
470 }
471
rtw_ioctl_efuse_get(struct net_device * dev,struct iw_request_info * info,union iwreq_data * wrqu,char * extra)472 int rtw_ioctl_efuse_get(struct net_device *dev,
473 struct iw_request_info *info,
474 union iwreq_data *wrqu, char *extra)
475 {
476 _adapter *padapter = rtw_netdev_priv(dev);
477 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
478 char *pch, *ptmp, *token, *tmp[3] = {0x00, 0x00, 0x00};
479 u16 i = 0, j = 0, mapLen = 0, addr = 0, cnts = 0;
480 int err = 0;
481 char *pextra = NULL;
482 u8 *pre_efuse_map = NULL;
483 u16 max_available_len = 0;
484
485 if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length)) {
486 err = -EFAULT;
487 goto exit;
488 }
489
490 *(extra + wrqu->data.length) = '\0';
491 pch = extra;
492 RTW_INFO("%s: in=%s\n", __FUNCTION__, extra);
493
494 i = 0;
495 /* mac 16 "00e04c871200" rmap,00,2 */
496 while ((token = strsep(&pch, ",")) != NULL) {
497 if (i > 2)
498 break;
499 tmp[i] = token;
500 i++;
501 }
502 pre_efuse_map = rtw_zmalloc(RTW_MAX_EFUSE_MAP_LEN);
503 if (pre_efuse_map == NULL)
504 goto exit;
505
506 if (strcmp(tmp[0], "status") == 0) {
507 //sprintf(extra, "Load File efuse=%s,Load File MAC=%s"
508 // , efuse->file_status == EFUSE_FILE_FAILED ? "FAIL" : "OK"
509 // , pHalData->macaddr_file_status == MACADDR_FILE_FAILED ? "FAIL" : "OK"
510 // );
511 goto exit;
512 } else if (strcmp(tmp[0], "drvmap") == 0) {
513 static u8 drvmaporder = 0;
514 u8 *efuse_data = NULL;
515 u32 shift, cnt;
516 u32 blksz = 0x200; /* The size of one time show, default 512 */
517 //EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
518
519 //efuse_data = efuse->data;
520
521 shift = blksz * drvmaporder;
522 efuse_data += shift;
523 cnt = mapLen - shift;
524
525 if (cnt > blksz) {
526 cnt = blksz;
527 drvmaporder++;
528 } else
529 drvmaporder = 0;
530
531 sprintf(extra, "\n");
532 for (i = 0; i < cnt; i += 16) {
533 pextra = extra + strlen(extra);
534 pextra += sprintf(pextra, "0x%02x\t", shift + i);
535 for (j = 0; j < 8; j++)
536 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
537 pextra += sprintf(pextra, "\t");
538 for (; j < 16; j++)
539 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
540 pextra += sprintf(pextra, "\n");
541 }
542 if ((shift + cnt) < mapLen)
543 pextra += sprintf(pextra, "\t...more (left:%d/%d)\n", mapLen-(shift + cnt), mapLen);
544
545 } else if (strcmp(tmp[0], "realmap") == 0) {
546 static u8 order = 0;
547 u32 shift, cnt;
548 u32 blksz = 0x200; /* The size of one time show, default 512 */
549 u8 *efuse_data = NULL;
550
551 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_WIFI_GET_LOG_SIZE);
552
553 if (pre_efuse_map) {
554 if (rtw_efuse_map_read(padapter, 0, mapLen, pre_efuse_map, RTW_EFUSE_WIFI) == _FAIL) {
555 RTW_INFO("%s: read realmap Fail!!\n", __FUNCTION__);
556 err = -EFAULT;
557 } else {
558 efuse_data = pre_efuse_map;
559
560 _rtw_memset(extra, '\0', strlen(extra));
561 shift = blksz * order;
562 efuse_data += shift;
563 cnt = mapLen - shift;
564 if (cnt > blksz) {
565 cnt = blksz;
566 order++;
567 } else
568 order = 0;
569
570 sprintf(extra, "\n");
571 for (i = 0; i < cnt; i += 16) {
572 pextra = extra + strlen(extra);
573 pextra += sprintf(pextra, "0x%02x\t", shift + i);
574 for (j = 0; j < 8; j++)
575 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
576 pextra += sprintf(pextra, "\t");
577 for (; j < 16; j++)
578 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
579 pextra += sprintf(pextra, "\n");
580
581 if (strlen(extra) > 0x7FF)
582 break;
583 }
584 if ((shift + cnt) < mapLen)
585 pextra += sprintf(pextra, "\t...more (left:%d/%d)\n", mapLen - (shift + cnt), mapLen);
586 }
587 }
588 } else if (strcmp(tmp[0], "rmap") == 0) {
589 u8 *data = NULL;
590 if ((tmp[1] == NULL) || (tmp[2] == NULL)) {
591 RTW_INFO("%s: rmap Fail!! Parameters error!\n", __FUNCTION__);
592 err = -EINVAL;
593 goto exit;
594 }
595 /* rmap addr cnts */
596 addr = simple_strtoul(tmp[1], &ptmp, 16);
597 RTW_INFO("%s: addr=%x\n", __FUNCTION__, addr);
598
599 cnts = simple_strtoul(tmp[2], &ptmp, 10);
600 if (cnts == 0) {
601 RTW_INFO("%s: rmap Fail!! cnts error!\n", __FUNCTION__);
602 err = -EINVAL;
603 goto exit;
604 }
605 RTW_INFO("%s: cnts=%d\n", __FUNCTION__, cnts);
606
607 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_WIFI_GET_LOG_SIZE);
608
609 if ((addr + cnts) > mapLen) {
610 RTW_INFO("%s: addr(0x%X)+cnts(%d) over mapLen %d parameter error!\n", __FUNCTION__, addr, cnts, mapLen);
611 err = -EINVAL;
612 goto exit;
613 }
614
615 if (pre_efuse_map) {
616 if (rtw_efuse_map_read(padapter, addr, cnts, pre_efuse_map, RTW_EFUSE_WIFI) == _FAIL) {
617 RTW_INFO("%s: rtw_efuse_map_read Fail!!\n", __FUNCTION__);
618 err = -EFAULT;
619 } else {
620 data = pre_efuse_map;
621 *extra = 0;
622 pextra = extra;
623 for (i = 0; i < cnts; i++) {
624 pextra += sprintf(pextra, "0x%02X ", data[i]);
625 }
626 }
627 }
628 } else if (strcmp(tmp[0], "wlrfkmap") == 0) {
629 static u8 order = 0;
630 u32 shift, cnt;
631 u32 blksz = 0x200; /* The size of one time show, default 512 */
632 u8 *efuse_data = NULL;
633
634 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_WIFI_GET_LOG_SIZE);
635
636 if (pre_efuse_map) {
637 if (rtw_efuse_get_shadow_map(padapter, pre_efuse_map, mapLen, RTW_EFUSE_WIFI) == _FAIL) {
638 RTW_INFO("%s: read wifi fake map Fail!!\n", __FUNCTION__);
639 err = -EFAULT;
640 } else {
641 efuse_data = pre_efuse_map;
642
643 _rtw_memset(extra, '\0', strlen(extra));
644 shift = blksz * order;
645 efuse_data += shift;
646 cnt = mapLen - shift;
647 if (cnt > blksz) {
648 cnt = blksz;
649 order++;
650 } else
651 order = 0;
652
653 sprintf(extra, "\n");
654 for (i = 0; i < cnt; i += 16) {
655 pextra = extra + strlen(extra);
656 pextra += sprintf(pextra, "0x%02x\t", shift + i);
657 for (j = 0; j < 8; j++)
658 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
659 pextra += sprintf(pextra, "\t");
660 for (; j < 16; j++)
661 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
662 pextra += sprintf(pextra, "\n");
663
664 if (strlen(extra) > 0x7FF)
665 break;
666 }
667 if ((shift + cnt) < mapLen)
668 pextra += sprintf(pextra, "\t...more (left:%d/%d)\n", mapLen - (shift + cnt), mapLen);
669 }
670 }
671 } else if (strcmp(tmp[0], "wlrfkrmap") == 0) {
672 u8 *data = NULL;
673 if ((tmp[1] == NULL) || (tmp[2] == NULL)) {
674 RTW_INFO("%s: rmap Fail!! Parameters error!\n", __FUNCTION__);
675 err = -EINVAL;
676 goto exit;
677 }
678 /* rmap addr cnts */
679 addr = simple_strtoul(tmp[1], &ptmp, 16);
680 RTW_INFO("%s: addr=%x\n", __FUNCTION__, addr);
681
682 cnts = simple_strtoul(tmp[2], &ptmp, 10);
683 if (cnts == 0) {
684 RTW_INFO("%s: rmap Fail!! cnts error!\n", __FUNCTION__);
685 err = -EINVAL;
686 goto exit;
687 }
688 RTW_INFO("%s: cnts=%d\n", __FUNCTION__, cnts);
689
690 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_WIFI_GET_LOG_SIZE);
691
692 if ((addr + cnts) > mapLen) {
693 RTW_INFO("%s: addr(0x%X)+cnts(%d) over mapLen %d parameter error!\n", __FUNCTION__, addr, cnts, mapLen);
694 err = -EINVAL;
695 goto exit;
696 }
697
698 if (pre_efuse_map) {
699 if (rtw_efuse_get_shadow_map(padapter, pre_efuse_map, mapLen, RTW_EFUSE_WIFI) == _FAIL) {
700 RTW_INFO("%s: read wifi fake map Fail!!\n", __FUNCTION__);
701 err = -EFAULT;
702 } else {
703 data = pre_efuse_map;
704 *extra = 0;
705 pextra = extra;
706 for (i = addr; i < addr + cnts; i++)
707 pextra += sprintf(pextra, "0x%02X ", data[i]);
708 }
709 }
710 } else if (strcmp(tmp[0], "btrealmap") == 0) {
711 static u8 order = 0;
712 u32 shift, cnt;
713 u32 blksz = 0x200; /* The size of one time show, default 512 */
714 u8 *efuse_data = NULL;
715
716 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_BT_GET_LOG_SIZE);
717
718 if (pre_efuse_map) {
719 if (rtw_efuse_map_read(padapter, 0, mapLen, pre_efuse_map, RTW_EFUSE_BT) == _FAIL) {
720 RTW_INFO("%s: read BT realmap Fail!!\n", __FUNCTION__);
721 err = -EFAULT;
722 } else {
723 efuse_data = pre_efuse_map;
724
725 _rtw_memset(extra, '\0', strlen(extra));
726 shift = blksz * order;
727 efuse_data += shift;
728 cnt = mapLen - shift;
729 if (cnt > blksz) {
730 cnt = blksz;
731 order++;
732 } else
733 order = 0;
734
735 sprintf(extra, "\n");
736 for (i = 0; i < cnt; i += 16) {
737 pextra = extra + strlen(extra);
738 pextra += sprintf(pextra, "0x%02x\t", shift + i);
739 for (j = 0; j < 8; j++)
740 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
741 pextra += sprintf(pextra, "\t");
742 for (; j < 16; j++)
743 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
744 pextra += sprintf(pextra, "\n");
745
746 if (strlen(extra) > 0x7FF)
747 break;
748 }
749 if ((shift + cnt) < mapLen)
750 pextra += sprintf(pextra, "\t...more (left:%d/%d)\n", mapLen - (shift + cnt), mapLen);
751 }
752 }
753 } else if (strcmp(tmp[0], "btrmap") == 0) {
754 u8 *data = NULL;
755 if ((tmp[1] == NULL) || (tmp[2] == NULL)) {
756 RTW_INFO("%s: btrmap Fail!! Parameters error!\n", __FUNCTION__);
757 err = -EINVAL;
758 goto exit;
759 }
760 /* rmap addr cnts */
761 addr = simple_strtoul(tmp[1], &ptmp, 16);
762 RTW_INFO("%s: addr=%x\n", __FUNCTION__, addr);
763
764 cnts = simple_strtoul(tmp[2], &ptmp, 10);
765 if (cnts == 0) {
766 RTW_INFO("%s: btrmap Fail!! cnts error!\n", __FUNCTION__);
767 err = -EINVAL;
768 goto exit;
769 }
770 RTW_INFO("%s: cnts=%d\n", __FUNCTION__, cnts);
771
772 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_BT_GET_LOG_SIZE);
773
774 if ((addr + cnts) > mapLen) {
775 RTW_INFO("%s: addr(0x%X)+cnts(%d) over mapLen %d parameter error!\n", __FUNCTION__, addr, cnts, mapLen);
776 err = -EINVAL;
777 goto exit;
778 }
779
780 if (pre_efuse_map) {
781 if (rtw_efuse_map_read(padapter, addr, cnts, pre_efuse_map, RTW_EFUSE_BT) == _FAIL) {
782 RTW_INFO("%s: rtw_efuse_map_read Fail!!\n", __FUNCTION__);
783 err = -EFAULT;
784 } else {
785 data = pre_efuse_map;
786 *extra = 0;
787 pextra = extra;
788 for (i = 0; i < cnts; i++)
789 pextra += sprintf(pextra, "0x%02X ", data[i]);
790 }
791 }
792 } else if (strcmp(tmp[0], "btrfkmap") == 0) {
793 static u8 order = 0;
794 u32 shift, cnt;
795 u32 blksz = 0x200; /* The size of one time show, default 512 */
796 u8 *efuse_data = NULL;
797
798 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_BT_GET_LOG_SIZE);
799
800 if (pre_efuse_map) {
801 if (rtw_efuse_get_shadow_map(padapter, pre_efuse_map, mapLen, RTW_EFUSE_BT) == _FAIL) {
802 RTW_INFO("%s: read BT fake map Fail!!\n", __FUNCTION__);
803 err = -EFAULT;
804 } else {
805 efuse_data = pre_efuse_map;
806
807 _rtw_memset(extra, '\0', strlen(extra));
808 shift = blksz * order;
809 efuse_data += shift;
810 cnt = mapLen - shift;
811 if (cnt > blksz) {
812 cnt = blksz;
813 order++;
814 } else
815 order = 0;
816
817 sprintf(extra, "\n");
818 for (i = 0; i < cnt; i += 16) {
819 pextra = extra + strlen(extra);
820 pextra += sprintf(pextra, "0x%02x\t", shift + i);
821 for (j = 0; j < 8; j++)
822 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
823 pextra += sprintf(pextra, "\t");
824 for (; j < 16; j++)
825 pextra += sprintf(pextra, "%02X ", efuse_data[i + j]);
826 pextra += sprintf(pextra, "\n");
827
828 if (strlen(extra) > 0x7FF)
829 break;
830 }
831 if ((shift + cnt) < mapLen)
832 pextra += sprintf(pextra, "\t...more (left:%d/%d)\n", mapLen - (shift + cnt), mapLen);
833 }
834 }
835 } else if (strcmp(tmp[0], "ableraw") == 0) {
836 rtw_efuse_get_available_size(padapter, &max_available_len, RTW_EFUSE_WIFI);
837 sprintf(extra, "[WIFI available raw size]= %d bytes\n", max_available_len);
838 } else if (strcmp(tmp[0], "btableraw") == 0) {
839 rtw_efuse_get_available_size(padapter, &max_available_len, RTW_EFUSE_BT);
840 sprintf(extra, "[BT available raw size]= %d bytes\n", max_available_len);
841 } else if (strcmp(tmp[0], "realraw") == 0) {
842 static u8 raw_order = 0;
843 u32 shift, cnt;
844 u32 blksz = 0x200; /* The size of one time show, default 512 */
845 u8 *realraw_map_data = NULL;
846
847 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_WIFI_GET_SIZE);
848
849 if (pre_efuse_map) {
850 if (rtw_efuse_raw_map_read (padapter, 0, mapLen, pre_efuse_map, RTW_EFUSE_WIFI) == _FAIL) {
851 RTW_INFO("%s: read wifi raw map Fail!!\n", __FUNCTION__);
852 err = -EFAULT;
853 } else {
854 realraw_map_data = pre_efuse_map;
855
856 _rtw_memset(extra, '\0', strlen(extra));
857 shift = blksz * raw_order;
858 realraw_map_data += shift;
859 cnt = mapLen - shift;
860 if (cnt > blksz) {
861 cnt = blksz;
862 raw_order++;
863 } else
864 raw_order = 0;
865
866 sprintf(extra, "\n");
867 for (i = 0; i < cnt; i += 16) {
868 pextra = extra + strlen(extra);
869 pextra += sprintf(pextra, "0x%02x\t", shift + i);
870 for (j = 0; j < 8; j++)
871 pextra += sprintf(pextra, "%02X ", realraw_map_data[i + j]);
872 pextra += sprintf(pextra, "\t");
873 for (; j < 16; j++)
874 pextra += sprintf(pextra, "%02X ", realraw_map_data[i + j]);
875 pextra += sprintf(pextra, "\n");
876
877 if (strlen(extra) > 0x7FF)
878 break;
879 }
880 if ((shift + cnt) < mapLen)
881 pextra += sprintf(pextra, "\t...more (left:%d/%d)\n", mapLen - (shift + cnt), mapLen);
882 }
883 }
884 } else if (strcmp(tmp[0], "btrealraw")== 0) {
885 static u8 raw_order = 0;
886 u32 shift, cnt;
887 u32 blksz = 0x200; /* The size of one time show, default 512 */
888 u8 *realraw_map_data = NULL;
889
890 rtw_efuse_get_map_size(padapter, &mapLen, RTW_EFUSE_CMD_BT_GET_SIZE);
891
892 if (pre_efuse_map) {
893 if (rtw_efuse_raw_map_read (padapter, 0, mapLen, pre_efuse_map, RTW_EFUSE_BT) == _FAIL) {
894 RTW_INFO("%s: read bt raw map Fail!!\n", __FUNCTION__);
895 err = -EFAULT;
896 } else {
897 realraw_map_data = pre_efuse_map;
898
899 _rtw_memset(extra, '\0', strlen(extra));
900 shift = blksz * raw_order;
901 realraw_map_data += shift;
902 cnt = mapLen - shift;
903 if (cnt > blksz) {
904 cnt = blksz;
905 raw_order++;
906 } else
907 raw_order = 0;
908
909 sprintf(extra, "\n");
910 for (i = 0; i < cnt; i += 16) {
911 pextra = extra + strlen(extra);
912 pextra += sprintf(pextra, "0x%02x\t", shift + i);
913 for (j = 0; j < 8; j++)
914 pextra += sprintf(pextra, "%02X ", realraw_map_data[i + j]);
915 pextra += sprintf(pextra, "\t");
916 for (; j < 16; j++)
917 pextra += sprintf(pextra, "%02X ", realraw_map_data[i + j]);
918 pextra += sprintf(pextra, "\n");
919
920 if (strlen(extra) > 0x7FF)
921 break;
922 }
923 if ((shift + cnt) < mapLen)
924 pextra += sprintf(pextra, "\t...more (left:%d/%d)\n", mapLen - (shift + cnt), mapLen);
925 }
926 }
927 } else
928 sprintf(extra, "Command not found!");
929
930 exit:
931 if (pre_efuse_map)
932 rtw_mfree(pre_efuse_map, RTW_MAX_EFUSE_MAP_LEN);
933 if (!err)
934 wrqu->data.length = strlen(extra);
935 RTW_INFO("%s: strlen(extra) =%zu\n", __FUNCTION__, strlen(extra));
936 if (copy_to_user(wrqu->data.pointer, extra, wrqu->data.length))
937 err = -EFAULT;
938
939 return err;
940 }
941
942
rtw_ioctl_efuse_set(struct net_device * dev,struct iw_request_info * info,union iwreq_data * wdata,char * extra)943 int rtw_ioctl_efuse_set(struct net_device *dev,
944 struct iw_request_info *info,
945 union iwreq_data *wdata, char *extra)
946 {
947 struct iw_point *wrqu;
948 struct pwrctrl_priv *pwrctrlpriv ;
949 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
950 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
951
952 u8 ips_mode = IPS_NUM; /* init invalid value */
953 u8 lps_mode = PM_PS_MODE_NUM; /* init invalid value */
954 u32 i = 0, j = 0, jj = 0, kk = 0;
955 u8 *setdata = NULL;
956 u8 *shadowmap = NULL;
957 u8 *setrawdata = NULL;
958 char *pch, *ptmp, *token, *tmp[3] = {0x00, 0x00, 0x00};
959 u16 addr = 0xFF, cnts = 0, max_available_len = 0;
960 u16 wifimaplen;
961 int err = 0;
962 boolean bcmpchk = _TRUE;
963 u8 status = _SUCCESS;
964 u16 size;
965 u8 bpg = true;
966
967 wrqu = (struct iw_point *)wdata;
968 pwrctrlpriv = adapter_to_pwrctl(padapter);
969
970 if (copy_from_user(extra, wrqu->pointer, wrqu->length))
971 return -EFAULT;
972
973 *(extra + wrqu->length) = '\0';
974
975 setdata = rtw_zmalloc(RTW_MAX_EFUSE_MAP_LEN);
976 if (setdata == NULL) {
977 err = -ENOMEM;
978 goto exit;
979 }
980
981 #ifdef CONFIG_LPS
982 lps_mode = pwrctrlpriv->power_mgnt;/* keep org value */
983 rtw_pm_set_lps(padapter, PM_PS_MODE_ACTIVE);
984 #endif
985
986 #ifdef CONFIG_IPS
987 ips_mode = pwrctrlpriv->ips_mode;/* keep org value */
988 rtw_pm_set_ips(padapter, IPS_NONE);
989 #endif
990
991 pch = extra;
992 RTW_INFO("%s: in=%s\n", __FUNCTION__, extra);
993
994 i = 0;
995 while ((token = strsep(&pch, ",")) != NULL) {
996 if (i > 2)
997 break;
998 tmp[i] = token;
999 i++;
1000 }
1001
1002 /* tmp[0],[1],[2] */
1003 /* wmap,addr,00e04c871200 */
1004 if ((strcmp(tmp[0], "wmap") == 0) || (strcmp(tmp[0], "wlwfake") == 0)) {
1005 if ((tmp[1] == NULL) || (tmp[2] == NULL)) {
1006 err = -EINVAL;
1007 goto exit;
1008 }
1009
1010 addr = simple_strtoul(tmp[1], &ptmp, 16);
1011 addr &= 0xFFF;
1012
1013 cnts = strlen(tmp[2]);
1014 if (cnts % 2) {
1015 err = -EINVAL;
1016 goto exit;
1017 }
1018 cnts /= 2;
1019 if (cnts == 0) {
1020 err = -EINVAL;
1021 goto exit;
1022 }
1023
1024 RTW_INFO("%s: addr=0x%X\n", __FUNCTION__, addr);
1025 RTW_INFO("%s: cnts=%d\n", __FUNCTION__, cnts);
1026 RTW_INFO("%s: map data=%s\n", __FUNCTION__, tmp[2]);
1027
1028 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2)
1029 setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]);
1030
1031 err = rtw_efuse_get_map_size(padapter, &size, RTW_EFUSE_CMD_WIFI_GET_LOG_SIZE);
1032 max_available_len = size;
1033
1034 if (err == _FAIL) {
1035 status = _FAIL;
1036 goto exit;
1037 }
1038
1039 if ((addr + cnts) > max_available_len) {
1040 RTW_INFO("%s: addr(0x%X)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
1041 err = -EFAULT;
1042 goto exit;
1043 }
1044
1045 if (strcmp(tmp[0], "wlwfake") == 0)
1046 bpg = false;
1047
1048 if (rtw_efuse_map_write(padapter, addr, cnts, setdata, RTW_EFUSE_WIFI, bpg) == _FAIL) {
1049 RTW_INFO("%s: rtw_efuse_map_write error!!\n", __FUNCTION__);
1050 err = -EFAULT;
1051 goto exit;
1052 }
1053
1054 *extra = 0;
1055 if (bpg) {
1056 RTW_INFO("%s: after rtw_efuse_map_write to _rtw_memcmp\n", __func__);
1057 shadowmap = rtw_zmalloc(size);
1058 if (shadowmap == NULL) {
1059 RTW_INFO("%s: ShadowMapWiFi rtw_zmalloc Fail\n", __func__);
1060 err = 0;
1061 goto exit;
1062 }
1063 if (rtw_efuse_get_shadow_map(padapter, shadowmap, size,RTW_EFUSE_WIFI) == _SUCCESS) {
1064
1065 if (rtw_efuse_compare_data(padapter, addr, cnts, shadowmap, setdata, RTW_EFUSE_WIFI)) {
1066 RTW_INFO("%s: WiFi write map afterf compare success\n", __FUNCTION__);
1067 sprintf(extra, "WiFi write map compare OK\n");
1068 err = 0;
1069 goto exit;
1070 } else {
1071 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "shadowmap :", shadowmap + addr, cnts);
1072 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "map_pged :", setdata, cnts);
1073 sprintf(extra, "WiFi write map compare FAIL\n");
1074 RTW_INFO("%s: WiFi write map compare Fail\n", __FUNCTION__);
1075 err = 0;
1076 goto exit;
1077 }
1078 }
1079 } else {
1080 sprintf(extra, "WiFi write fake map OK\n");
1081 RTW_INFO("%s: WiFi write fake map OK\n", __FUNCTION__);
1082 err = 0;
1083 goto exit;
1084 }
1085 } else if ((strcmp(tmp[0], "btwmap") == 0) || (strcmp(tmp[0], "btwfake") == 0)) {
1086 if ((tmp[1] == NULL) || (tmp[2] == NULL)) {
1087 err = -EINVAL;
1088 goto exit;
1089 }
1090
1091 addr = simple_strtoul(tmp[1], &ptmp, 16);
1092 addr &= 0xFFF;
1093
1094 cnts = strlen(tmp[2]);
1095 if (cnts % 2) {
1096 err = -EINVAL;
1097 goto exit;
1098 }
1099 cnts /= 2;
1100 if (cnts == 0) {
1101 err = -EINVAL;
1102 goto exit;
1103 }
1104
1105 RTW_INFO("%s: addr=0x%X\n", __FUNCTION__, addr);
1106 RTW_INFO("%s: cnts=%d\n", __FUNCTION__, cnts);
1107 RTW_INFO("%s: map data=%s\n", __FUNCTION__, tmp[2]);
1108
1109 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2)
1110 setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]);
1111
1112 err = rtw_efuse_get_map_size(padapter, &size, RTW_EFUSE_CMD_BT_GET_LOG_SIZE);
1113 max_available_len = size;
1114
1115 if (err == _FAIL) {
1116 status = _FAIL;
1117 goto exit;
1118 }
1119
1120 if ((addr + cnts) > max_available_len) {
1121 RTW_INFO("%s: addr(0x%X)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
1122 err = -EFAULT;
1123 goto exit;
1124 }
1125
1126 if (strcmp(tmp[0], "btwfake") == 0)
1127 bpg = false;
1128
1129 if (rtw_efuse_map_write(padapter, addr, cnts, setdata, RTW_EFUSE_BT, bpg) == _FAIL) {
1130 RTW_INFO("%s: rtw_efuse_map_write error!!\n", __FUNCTION__);
1131 err = -EFAULT;
1132 goto exit;
1133 }
1134
1135 *extra = 0;
1136 RTW_INFO("%s: after rtw_efuse_map_write to _rtw_memcmp\n", __func__);
1137 if (bpg) {
1138 shadowmap = rtw_zmalloc(size);
1139 if (shadowmap == NULL) {
1140 RTW_INFO("%s: shadowmap rtw_zmalloc Fail\n", __func__);
1141 err = 0;
1142 goto exit;
1143 }
1144 if (rtw_efuse_get_shadow_map(padapter, shadowmap, size,RTW_EFUSE_BT) == _SUCCESS) {
1145
1146 if (rtw_efuse_compare_data(padapter, addr, cnts, shadowmap, setdata, RTW_EFUSE_BT)) {
1147 RTW_INFO("%s: BT write map afterf compare success\n", __func__);
1148 sprintf(extra, "BT write map compare OK\n");
1149 err = 0;
1150 goto exit;
1151 } else {
1152 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "shadowmap :", shadowmap, cnts);
1153 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "map_pged :", setdata, cnts);
1154 sprintf(extra, "BT write map compare FAIL\n");
1155 RTW_INFO("%s: BT write map compare Fail\n", __func__);
1156 err = 0;
1157 goto exit;
1158 }
1159 }
1160 } else {
1161 sprintf(extra, "BT write fake map OK\n");
1162 RTW_INFO("%s: BT write fake map OK\n", __FUNCTION__);
1163 err = 0;
1164 goto exit;
1165 }
1166 } else if (strcmp(tmp[0], "btwraw") == 0) {
1167 u8 reg2chkbt = 0;
1168
1169 if ((tmp[1] == NULL) || (tmp[2] == NULL)) {
1170 err = -EINVAL;
1171 goto exit;
1172 }
1173
1174 addr = simple_strtoul(tmp[1], &ptmp, 16);
1175 addr &= 0xFFF;
1176
1177 cnts = strlen(tmp[2]);
1178 if (cnts % 2) {
1179 err = -EINVAL;
1180 goto exit;
1181 }
1182 cnts /= 2;
1183 if (cnts == 0) {
1184 err = -EINVAL;
1185 goto exit;
1186 }
1187
1188 RTW_INFO("%s: addr=0x%X\n", __FUNCTION__, addr);
1189 RTW_INFO("%s: cnts=%d\n", __FUNCTION__, cnts);
1190 RTW_INFO("%s: raw data=%s\n", __FUNCTION__, tmp[2]);
1191
1192 rtw_phl_write8(dvobj->phl, 0xa3, 0x05);
1193 rtw_msleep_os(10);
1194 reg2chkbt = rtw_phl_read8(dvobj->phl, 0xa0);
1195 RTW_INFO("%s: btfk2map before read 0xa0 BT Status =0x%x\n", __func__,
1196 rtw_phl_read32(dvobj->phl, 0xa0));
1197
1198 if (reg2chkbt != 0x04) {
1199 sprintf(extra, "Error ! BT State not Active:0x%x ,can't Write \n" , reg2chkbt);
1200 goto exit;
1201 }
1202
1203 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2)
1204 setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk + 1]);
1205
1206 if (rtw_efuse_bt_write_raw_hidden(padapter, addr, cnts, setdata) == _FAIL) {
1207 RTW_INFO("%s: rtw_efuse_bt_write_hidden error!!\n", __FUNCTION__);
1208 err = -EFAULT;
1209 goto exit;
1210 }
1211 } else if (strcmp(tmp[0], "wlfk2map") == 0) {
1212 u16 mapsize = 0;
1213 u8 *map_pged = NULL;
1214
1215 RTW_INFO("%s:do rtw_efuse_fake2map\n", __func__);
1216 rtw_efuse_get_map_size(padapter, &mapsize, RTW_EFUSE_CMD_WIFI_GET_LOG_SIZE);
1217 shadowmap = rtw_zmalloc(mapsize);
1218 if (shadowmap == NULL) {
1219 RTW_INFO("%s: shadowmap rtw_zmalloc Fail\n", __func__);
1220 err = 0;
1221 goto exit;
1222 }
1223 if (rtw_efuse_get_shadow_map(padapter, shadowmap, mapsize, RTW_EFUSE_WIFI) == _FAIL) {
1224 RTW_INFO("%s:rtw_efuse_get_shadow_map Fail\n", __func__);
1225 err = 0;
1226 goto exit;
1227 }
1228
1229 status = rtw_efuse_fake2map(padapter, RTW_EFUSE_WIFI);
1230 if (status == _SUCCESS)
1231 RTW_INFO("WIFI write map OK\n");
1232 else
1233 RTW_INFO("WIFI write map FAIL\n");
1234
1235 map_pged = rtw_zmalloc(mapsize);
1236 if (map_pged == NULL) {
1237 RTW_INFO("%s: map_pged rtw_zmalloc Fail\n", __func__);
1238 err = 0;
1239 goto exit;
1240 }
1241 if (rtw_efuse_map_read(padapter, 0x00, mapsize, map_pged, RTW_EFUSE_WIFI) == _SUCCESS) {
1242
1243 if (rtw_efuse_compare_data(padapter, 0x00, mapsize, map_pged, shadowmap, RTW_EFUSE_WIFI)) {
1244 RTW_INFO("%s: WiFi write map afterf compare success\n", __func__);
1245 sprintf(extra, "WiFi write map compare OK\n");
1246 } else {
1247 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "shadowmap :", shadowmap, mapsize);
1248 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "map_pged :", map_pged, mapsize);
1249 sprintf(extra, "WiFi write map compare FAIL\n");
1250 RTW_INFO("%s: WiFi write map compare Fail\n", __func__);
1251 }
1252 }
1253
1254 if (map_pged)
1255 rtw_mfree(map_pged, mapsize);
1256 err = 0;
1257 goto exit;
1258 } else if (strcmp(tmp[0], "btfk2map") == 0) {
1259 u8 reg2chkbt = 0;
1260 u16 mapsize = 0;
1261 u8 *map_pged = NULL;
1262
1263 RTW_INFO("%s:do rtw_efuse_fake2map\n", __func__);
1264 rtw_efuse_get_map_size(padapter, &mapsize, RTW_EFUSE_CMD_BT_GET_LOG_SIZE);
1265 shadowmap = rtw_zmalloc(mapsize);
1266 if (shadowmap == NULL) {
1267 RTW_INFO("%s: shadowmap rtw_zmalloc Fail\n", __func__);
1268 err = 0;
1269 goto exit;
1270 }
1271 if (rtw_efuse_get_shadow_map(padapter, shadowmap, mapsize, RTW_EFUSE_BT) == _FAIL) {
1272 RTW_INFO("%s:rtw_efuse_get_shadow_map Fail\n", __func__);
1273 err = 0;
1274 goto exit;
1275 }
1276
1277 rtw_phl_write8(dvobj->phl, 0xa3, 0x05);
1278 rtw_msleep_os(10);
1279 reg2chkbt = rtw_phl_read8(dvobj->phl, 0xa0);
1280 RTW_INFO("%s: btfk2map before read 0xa0 BT Status =0x%x\n", __func__,
1281 rtw_phl_read32(dvobj->phl, 0xa0));
1282
1283 if (reg2chkbt != 0x04) {
1284 sprintf(extra, "Error ! BT State not Active:0x%x ,can't Write \n" , reg2chkbt);
1285 goto exit;
1286 }
1287
1288 status = rtw_efuse_fake2map(padapter, RTW_EFUSE_BT);
1289 if (status == _SUCCESS)
1290 RTW_INFO("BT write map OK\n");
1291 else
1292 RTW_INFO("BT write map FAIL\n");
1293
1294 map_pged = rtw_zmalloc(mapsize);
1295 if (map_pged == NULL) {
1296 RTW_INFO("%s: map_pged rtw_zmalloc Fail\n", __func__);
1297 err = 0;
1298 goto exit;
1299 }
1300
1301 if (rtw_efuse_map_read(padapter, 0x00, mapsize, map_pged, RTW_EFUSE_BT) == _SUCCESS) {
1302
1303 if (rtw_efuse_compare_data(padapter, 0x00, mapsize, map_pged, shadowmap, RTW_EFUSE_BT)) {
1304 RTW_INFO("%s: BT write map afterf compare success\n", __func__);
1305 sprintf(extra, "BT write map compare OK\n");
1306 } else {
1307 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "shadowmap :", shadowmap, mapsize);
1308 RTW_MAP_DUMP_SEL(RTW_DBGDUMP, "map_pged :", map_pged, mapsize);
1309 sprintf(extra, "BT write map compare FAIL\n");
1310 RTW_INFO("%s: BT write map compare Fail\n", __func__);
1311 }
1312 }
1313
1314 if (map_pged)
1315 rtw_mfree(map_pged, mapsize);
1316
1317 err = 0;
1318 goto exit;
1319 } else if (strcmp(tmp[0], "update") == 0) {
1320 if (rtw_efuse_renew_update(padapter, RTW_EFUSE_WIFI) == _FAIL) {
1321 RTW_INFO("%s: rtw_efuse_renew_update error!!\n", __FUNCTION__);
1322 sprintf(extra, "WIFI update FAIL\n");
1323 err = -EFAULT;
1324 goto exit;
1325 } else
1326 sprintf(extra, "WIFI update OK\n");
1327
1328 }
1329 exit:
1330 if (setdata)
1331 rtw_mfree(setdata, RTW_MAX_EFUSE_MAP_LEN);
1332 if (shadowmap)
1333 rtw_mfree(shadowmap, size);
1334
1335 wrqu->length = strlen(extra);
1336
1337 if (padapter->registrypriv.mp_mode == 0) {
1338 #ifdef CONFIG_IPS
1339 rtw_pm_set_ips(padapter, ips_mode);
1340 #endif /* CONFIG_IPS */
1341
1342 #ifdef CONFIG_LPS
1343 rtw_pm_set_lps(padapter, lps_mode);
1344 #endif /* CONFIG_LPS */
1345 }
1346
1347 return err;
1348 }
1349
rtw_ioctl_efuse_file_map_load(struct net_device * dev,struct iw_request_info * info,union iwreq_data * wrqu,char * extra)1350 int rtw_ioctl_efuse_file_map_load(struct net_device *dev,
1351 struct iw_request_info *info,
1352 union iwreq_data *wrqu, char *extra)
1353 {
1354 char *rtw_efuse_file_map_path;
1355 u8 Status = 0;
1356 _adapter *padapter= rtw_netdev_priv(dev);
1357 struct mp_priv *pmp_priv = &padapter->mppriv;
1358
1359 if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
1360 return -EFAULT;
1361
1362 rtw_efuse_file_map_path = extra;
1363 if (rtw_is_file_readable(rtw_efuse_file_map_path) == _TRUE) {
1364 RTW_INFO("%s do rtw_efuse_mask_file_read = %s!\n", __func__, rtw_efuse_file_map_path);
1365 Status = rtw_efuse_map_file_load(padapter, rtw_efuse_file_map_path, RTW_EFUSE_WIFI);
1366 if (Status == _TRUE) {
1367 pmp_priv->bloadefusemap = _TRUE;
1368 sprintf(extra, "efuse Map file file_read OK\n");
1369 } else {
1370 pmp_priv->bloadefusemap = _FALSE;
1371 sprintf(extra, "efuse Map file file_read FAIL\n");
1372 }
1373 } else {
1374 sprintf(extra, "efuse file readable FAIL\n");
1375 RTW_INFO("%s rtw_is_file_readable fail!\n", __func__);
1376 }
1377
1378 wrqu->data.length = strlen(extra);
1379 return 0;
1380 }
1381
rtw_ioctl_efuse_file_mask_load(struct net_device * dev,struct iw_request_info * info,union iwreq_data * wrqu,char * extra)1382 int rtw_ioctl_efuse_file_mask_load(struct net_device *dev,
1383 struct iw_request_info *info,
1384 union iwreq_data *wrqu, char *extra)
1385 {
1386 char *rtw_efuse_file_map_path;
1387 u8 Status = 0;
1388 _adapter *padapter= rtw_netdev_priv(dev);
1389 struct mp_priv *pmp_priv = &padapter->mppriv;
1390
1391 if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
1392 return -EFAULT;
1393
1394 rtw_efuse_file_map_path = extra;
1395 if (rtw_is_file_readable(rtw_efuse_file_map_path) == _TRUE) {
1396 RTW_INFO("%s do rtw_efuse_mask_file_read = %s!\n", __func__, rtw_efuse_file_map_path);
1397 Status = rtw_efuse_mask_file_load(padapter, rtw_efuse_file_map_path, RTW_EFUSE_WIFI);
1398 if (Status == _TRUE) {
1399 pmp_priv->bloadefusemap = _TRUE;
1400 sprintf(extra, "efuse Mask file file_read OK\n");
1401 } else {
1402 pmp_priv->bloadefusemap = _FALSE;
1403 sprintf(extra, "efuse Mask file file_read FAIL\n");
1404 }
1405 } else {
1406 sprintf(extra, "efuse file readable FAIL\n");
1407 RTW_INFO("%s rtw_is_file_readable fail!\n", __func__);
1408 }
1409
1410 wrqu->data.length = strlen(extra);
1411 return 0;
1412 }
1413
1414
rtw_ioctl_efuse_bt_file_map_load(struct net_device * dev,struct iw_request_info * info,union iwreq_data * wrqu,char * extra)1415 int rtw_ioctl_efuse_bt_file_map_load(struct net_device *dev,
1416 struct iw_request_info *info,
1417 union iwreq_data *wrqu, char *extra)
1418 {
1419 char *rtw_efuse_file_map_path;
1420 u8 Status = 0;
1421 _adapter *padapter= rtw_netdev_priv(dev);
1422 struct mp_priv *pmp_priv = &padapter->mppriv;
1423
1424 if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
1425 return -EFAULT;
1426
1427 rtw_efuse_file_map_path = extra;
1428 if (rtw_is_file_readable(rtw_efuse_file_map_path) == _TRUE) {
1429 RTW_INFO("%s BT do rtw_efuse_mask_file_read = %s!\n", __func__, rtw_efuse_file_map_path);
1430 Status = rtw_efuse_map_file_load(padapter, rtw_efuse_file_map_path, RTW_EFUSE_BT);
1431 if (Status == _TRUE) {
1432 pmp_priv->bloadefusemap = _TRUE;
1433 sprintf(extra, "BT efuse Map file file_read OK\n");
1434 } else {
1435 pmp_priv->bloadefusemap = _FALSE;
1436 sprintf(extra, "BT efuse Map file file_read FAIL\n");
1437 }
1438 } else {
1439 sprintf(extra, "BT efuse file readable FAIL\n");
1440 RTW_INFO("%s BT rtw_is_file_readable fail!\n", __func__);
1441 }
1442
1443 wrqu->data.length = strlen(extra);
1444 return 0;
1445 }
1446
rtw_ioctl_efuse_bt_file_mask_load(struct net_device * dev,struct iw_request_info * info,union iwreq_data * wrqu,char * extra)1447 int rtw_ioctl_efuse_bt_file_mask_load(struct net_device *dev,
1448 struct iw_request_info *info,
1449 union iwreq_data *wrqu, char *extra)
1450 {
1451 char *rtw_efuse_file_map_path;
1452 u8 Status = 0;
1453 _adapter *padapter= rtw_netdev_priv(dev);
1454 struct mp_priv *pmp_priv = &padapter->mppriv;
1455
1456 if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
1457 return -EFAULT;
1458
1459 rtw_efuse_file_map_path = extra;
1460 if (rtw_is_file_readable(rtw_efuse_file_map_path) == _TRUE) {
1461 RTW_INFO("%s BT mask do rtw_efuse_mask_file_read = %s!\n", __func__, rtw_efuse_file_map_path);
1462 Status = rtw_efuse_mask_file_load(padapter, rtw_efuse_file_map_path, RTW_EFUSE_BT);
1463 if (Status == _TRUE) {
1464 pmp_priv->bloadefusemap = _TRUE;
1465 sprintf(extra, "BT efuse Mask file file_read OK\n");
1466 } else {
1467 pmp_priv->bloadefusemap = _FALSE;
1468 sprintf(extra, "BT efuse Mask file file_read FAIL\n");
1469 }
1470 } else {
1471 sprintf(extra, "BT efuse file readable FAIL\n");
1472 RTW_INFO("%s BT rtw_is_file_readable fail!\n", __func__);
1473 }
1474
1475 wrqu->data.length = strlen(extra);
1476 return 0;
1477 }
1478
rtw_efuse_get_map_from(_adapter * padapter)1479 s8 rtw_efuse_get_map_from(_adapter *padapter)
1480 {
1481 struct rtw_efuse_phl_arg *efuse_arg = NULL;
1482 u8 map_status = -1;
1483
1484 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
1485 if (efuse_arg) {
1486 _rtw_memset((void *)efuse_arg,
1487 0,
1488 sizeof(struct rtw_efuse_phl_arg));
1489 rtw_efuse_cmd(padapter,
1490 efuse_arg,
1491 RTW_MP_EFUSE_CMD_WIFI_GET_MAP_FROM);
1492
1493 if (efuse_arg->cmd_ok &&
1494 efuse_arg->status == RTW_PHL_STATUS_SUCCESS) {
1495 map_status = efuse_arg->io_value;
1496 RTW_INFO("%s: OK value:%d\n",
1497 __func__, map_status);
1498 } else {
1499 map_status = -1;
1500 RTW_INFO("%s: fail !\n", __func__);
1501 }
1502 }
1503 if (efuse_arg)
1504 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
1505
1506 return map_status;
1507 }
1508
rtw_efuse_get_realraw(_adapter * padapter,u8 * map,u16 addr,u16 size,u8 efuse_type)1509 static u8 rtw_efuse_get_realraw(_adapter *padapter, u8 *map, u16 addr, u16 size, u8 efuse_type)
1510 {
1511 struct rtw_efuse_phl_arg *efuse_arg = NULL;
1512 u8 res = _FAIL;
1513
1514 efuse_arg = _rtw_malloc(sizeof(struct rtw_efuse_phl_arg));
1515 if (efuse_arg) {
1516 efuse_arg->io_offset = addr;
1517 efuse_arg->buf_len = size;
1518 if (efuse_type == RTW_EFUSE_WIFI)
1519 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_WIFI_GET_PHY_MAP);
1520 else if (efuse_type == RTW_EFUSE_BT)
1521 rtw_efuse_cmd(padapter, efuse_arg, RTW_EFUSE_CMD_BT_GET_PHY_MAP);
1522 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS) {
1523 _rtw_memcpy((void *)map, efuse_arg->poutbuf, size);
1524 res = _SUCCESS;
1525 } else
1526 res = _FAIL;
1527 }
1528 if (efuse_arg)
1529 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
1530
1531 return res;
1532 }
1533
rtw_efuse_raw_map_read(_adapter * adapter,u16 addr,u16 cnts,u8 * data,u8 efuse_type)1534 u8 rtw_efuse_raw_map_read(_adapter * adapter, u16 addr, u16 cnts, u8 *data, u8 efuse_type)
1535 {
1536 struct dvobj_priv *d;
1537 u8 *efuse = NULL;
1538 u16 size, i;
1539 int err = _FAIL;
1540 u8 status = _SUCCESS;
1541
1542 if (efuse_type == RTW_EFUSE_WIFI)
1543 err = rtw_efuse_get_map_size(adapter, &size, RTW_EFUSE_CMD_WIFI_GET_SIZE);
1544 else if (efuse_type == RTW_EFUSE_BT)
1545 err = rtw_efuse_get_map_size(adapter, &size, RTW_EFUSE_CMD_BT_GET_SIZE);
1546
1547 if (err == _FAIL) {
1548 status = _FAIL;
1549 RTW_INFO("get_efuse_size fail\n");
1550 goto exit;
1551 }
1552 /* size error handle */
1553 if ((addr + cnts) > size) {
1554 if (addr < size)
1555 cnts = size - addr;
1556 else {
1557 status = _FAIL;
1558 RTW_INFO(" %s() ,addr + cnts) > size fail\n", __func__);
1559 goto exit;
1560 }
1561 }
1562
1563 efuse = rtw_zmalloc(size);
1564 if (efuse) {
1565 err = rtw_efuse_get_realraw (adapter, efuse, addr, size, efuse_type);
1566 if (err == _FAIL) {
1567 rtw_mfree(efuse, size);
1568 status = _FAIL;
1569 RTW_INFO(" %s() , phl get realraw fail\n", __func__);
1570 goto exit;
1571 }
1572 if (efuse) {
1573 RTW_INFO(" %s() ,cp efuse to data\n", __func__);
1574 _rtw_memcpy(data, efuse + addr, cnts);
1575 rtw_mfree(efuse, size);
1576 }
1577 } else {
1578 RTW_INFO(" %s() ,alloc efuse fail\n", __func__);
1579 goto exit;
1580 }
1581 status = _SUCCESS;
1582 exit:
1583
1584 return status;
1585 }
1586
rtw_efuse_bt_write_raw_hidden(_adapter * adapter,u16 addr,u16 cnts,u8 * data)1587 u8 rtw_efuse_bt_write_raw_hidden(_adapter * adapter, u16 addr, u16 cnts, u8 *data)
1588 {
1589 u8 status = _SUCCESS;
1590 struct rtw_efuse_phl_arg *efuse_arg = NULL;
1591 u16 i = 0;
1592
1593 efuse_arg = _rtw_zmalloc(sizeof(struct rtw_efuse_phl_arg));
1594
1595 while (i < cnts) {
1596 efuse_arg->io_type = 1;
1597 efuse_arg->io_offset = addr + i;
1598 efuse_arg->io_value = data[i];
1599 rtw_efuse_cmd(adapter, efuse_arg, RTW_EFUSE_CMD_BT_WRITE_HIDDEN);
1600 if (efuse_arg->cmd_ok && efuse_arg->status == RTW_PHL_STATUS_SUCCESS)
1601 status = _SUCCESS;
1602 else{
1603 status = _FAIL;
1604 break;
1605 }
1606 i++;
1607 }
1608 exit :
1609 if (efuse_arg)
1610 _rtw_mfree(efuse_arg, sizeof(struct rtw_efuse_phl_arg));
1611
1612 return status;
1613 }
1614
1615 #endif /*#if defined(CONFIG_MP_INCLUDED)*/
1616
1617