diff options
author | Bartlomiej Zolnierkiewicz <bzolnier@gmail.com> | 2009-10-21 16:44:35 -0400 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@suse.de> | 2009-12-11 15:23:12 -0500 |
commit | 44c68c23b16c85127d187fd720f95aa2e7a94d2e (patch) | |
tree | 467612eb4cbb0d2cc3fe2ba9a27ba31088b24be0 /drivers | |
parent | 782f1111256557c75415f57cd360ebf9d1377a55 (diff) |
Staging: rt28x0: remove optional loading of EEPROM from file in eFuse mode
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/staging/rt2860/common/cmm_profile.c | 10 | ||||
-rw-r--r-- | drivers/staging/rt2860/common/ee_efuse.c | 788 | ||||
-rw-r--r-- | drivers/staging/rt2860/common/eeprom.c | 3 | ||||
-rw-r--r-- | drivers/staging/rt2860/common/rtmp_init.c | 9 | ||||
-rw-r--r-- | drivers/staging/rt2860/rt_linux.c | 20 | ||||
-rw-r--r-- | drivers/staging/rt2860/rtmp.h | 21 |
6 files changed, 1 insertions, 850 deletions
diff --git a/drivers/staging/rt2860/common/cmm_profile.c b/drivers/staging/rt2860/common/cmm_profile.c index 056cffda42b..117ee077728 100644 --- a/drivers/staging/rt2860/common/cmm_profile.c +++ b/drivers/staging/rt2860/common/cmm_profile.c | |||
@@ -1194,16 +1194,6 @@ NDIS_STATUS RTMPSetProfileParameters( | |||
1194 | retval = RT_CfgSetCountryRegion(pAd, tmpbuf, BAND_5G); | 1194 | retval = RT_CfgSetCountryRegion(pAd, tmpbuf, BAND_5G); |
1195 | DBGPRINT(RT_DEBUG_TRACE, ("CountryRegionABand=%d\n", pAd->CommonCfg.CountryRegionForABand)); | 1195 | DBGPRINT(RT_DEBUG_TRACE, ("CountryRegionABand=%d\n", pAd->CommonCfg.CountryRegionForABand)); |
1196 | } | 1196 | } |
1197 | #ifdef RTMP_EFUSE_SUPPORT | ||
1198 | #ifdef RT30xx | ||
1199 | //EfuseBufferMode | ||
1200 | if(RTMPGetKeyParameter("EfuseBufferMode", tmpbuf, 25, pBuffer, TRUE)) | ||
1201 | { | ||
1202 | pAd->bEEPROMFile = (UCHAR) simple_strtol(tmpbuf, 0, 10); | ||
1203 | DBGPRINT(RT_DEBUG_TRACE, ("EfuseBufferMode=%d\n", pAd->bUseEfuse)); | ||
1204 | } | ||
1205 | #endif // RT30xx // | ||
1206 | #endif // RTMP_EFUSE_SUPPORT // | ||
1207 | //CountryCode | 1197 | //CountryCode |
1208 | if(RTMPGetKeyParameter("CountryCode", tmpbuf, 25, pBuffer, TRUE)) | 1198 | if(RTMPGetKeyParameter("CountryCode", tmpbuf, 25, pBuffer, TRUE)) |
1209 | { | 1199 | { |
diff --git a/drivers/staging/rt2860/common/ee_efuse.c b/drivers/staging/rt2860/common/ee_efuse.c index 5807cc4ff96..4bff473ccf3 100644 --- a/drivers/staging/rt2860/common/ee_efuse.c +++ b/drivers/staging/rt2860/common/ee_efuse.c | |||
@@ -67,21 +67,6 @@ typedef union _EFUSE_CTRL_STRUC { | |||
67 | UINT32 word; | 67 | UINT32 word; |
68 | } EFUSE_CTRL_STRUC, *PEFUSE_CTRL_STRUC; | 68 | } EFUSE_CTRL_STRUC, *PEFUSE_CTRL_STRUC; |
69 | 69 | ||
70 | static VOID eFuseWritePhysical( | ||
71 | IN PRTMP_ADAPTER pAd, | ||
72 | PUSHORT lpInBuffer, | ||
73 | ULONG nInBufferSize, | ||
74 | PUCHAR lpOutBuffer, | ||
75 | ULONG nOutBufferSize); | ||
76 | |||
77 | |||
78 | static NTSTATUS eFuseWriteRegistersFromBin( | ||
79 | IN PRTMP_ADAPTER pAd, | ||
80 | IN USHORT Offset, | ||
81 | IN USHORT Length, | ||
82 | IN USHORT* pData); | ||
83 | |||
84 | |||
85 | /* | 70 | /* |
86 | ======================================================================== | 71 | ======================================================================== |
87 | 72 | ||
@@ -281,164 +266,6 @@ static VOID eFuseReadPhysical( | |||
281 | 266 | ||
282 | ======================================================================== | 267 | ======================================================================== |
283 | */ | 268 | */ |
284 | static VOID eFusePhysicalWriteRegisters( | ||
285 | IN PRTMP_ADAPTER pAd, | ||
286 | IN USHORT Offset, | ||
287 | IN USHORT Length, | ||
288 | OUT USHORT* pData) | ||
289 | { | ||
290 | EFUSE_CTRL_STRUC eFuseCtrlStruc; | ||
291 | int i; | ||
292 | USHORT efuseDataOffset; | ||
293 | UINT32 data, eFuseDataBuffer[4]; | ||
294 | |||
295 | //Step0. Write 16-byte of data to EFUSE_DATA0-3 (0x590-0x59C), where EFUSE_DATA0 is the LSB DW, EFUSE_DATA3 is the MSB DW. | ||
296 | |||
297 | ///////////////////////////////////////////////////////////////// | ||
298 | //read current values of 16-byte block | ||
299 | RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word); | ||
300 | |||
301 | //Step0. Write 10-bit of address to EFSROM_AIN (0x580, bit25:bit16). The address must be 16-byte alignment. | ||
302 | eFuseCtrlStruc.field.EFSROM_AIN = Offset & 0xfff0; | ||
303 | |||
304 | //Step1. Write EFSROM_MODE (0x580, bit7:bit6) to 1. | ||
305 | eFuseCtrlStruc.field.EFSROM_MODE = 1; | ||
306 | |||
307 | //Step2. Write EFSROM_KICK (0x580, bit30) to 1 to kick-off physical read procedure. | ||
308 | eFuseCtrlStruc.field.EFSROM_KICK = 1; | ||
309 | |||
310 | NdisMoveMemory(&data, &eFuseCtrlStruc, 4); | ||
311 | RTMP_IO_WRITE32(pAd, EFUSE_CTRL, data); | ||
312 | |||
313 | //Step3. Polling EFSROM_KICK(0x580, bit30) until it become 0 again. | ||
314 | i = 0; | ||
315 | while(i < 500) | ||
316 | { | ||
317 | RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word); | ||
318 | |||
319 | if(eFuseCtrlStruc.field.EFSROM_KICK == 0) | ||
320 | break; | ||
321 | RTMPusecDelay(2); | ||
322 | i++; | ||
323 | } | ||
324 | |||
325 | //Step4. Read 16-byte of data from EFUSE_DATA0-3 (0x59C-0x590) | ||
326 | efuseDataOffset = EFUSE_DATA3; | ||
327 | for(i=0; i< 4; i++) | ||
328 | { | ||
329 | RTMP_IO_READ32(pAd, efuseDataOffset, (PUINT32) &eFuseDataBuffer[i]); | ||
330 | efuseDataOffset -= 4; | ||
331 | } | ||
332 | |||
333 | //Update the value, the offset is multiple of 2, length is 2 | ||
334 | efuseDataOffset = (Offset & 0xc) >> 2; | ||
335 | data = pData[0] & 0xffff; | ||
336 | //The offset should be 0x***10 or 0x***00 | ||
337 | if((Offset % 4) != 0) | ||
338 | { | ||
339 | eFuseDataBuffer[efuseDataOffset] = (eFuseDataBuffer[efuseDataOffset] & 0xffff) | (data << 16); | ||
340 | } | ||
341 | else | ||
342 | { | ||
343 | eFuseDataBuffer[efuseDataOffset] = (eFuseDataBuffer[efuseDataOffset] & 0xffff0000) | data; | ||
344 | } | ||
345 | |||
346 | efuseDataOffset = EFUSE_DATA3; | ||
347 | for(i=0; i< 4; i++) | ||
348 | { | ||
349 | RTMP_IO_WRITE32(pAd, efuseDataOffset, eFuseDataBuffer[i]); | ||
350 | efuseDataOffset -= 4; | ||
351 | } | ||
352 | ///////////////////////////////////////////////////////////////// | ||
353 | |||
354 | //Step1. Write 10-bit of address to EFSROM_AIN (0x580, bit25:bit16). The address must be 16-byte alignment. | ||
355 | |||
356 | RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word); | ||
357 | |||
358 | eFuseCtrlStruc.field.EFSROM_AIN = Offset & 0xfff0; | ||
359 | |||
360 | //Step2. Write EFSROM_MODE (0x580, bit7:bit6) to 3. | ||
361 | eFuseCtrlStruc.field.EFSROM_MODE = 3; | ||
362 | |||
363 | //Step3. Write EFSROM_KICK (0x580, bit30) to 1 to kick-off physical write procedure. | ||
364 | eFuseCtrlStruc.field.EFSROM_KICK = 1; | ||
365 | |||
366 | NdisMoveMemory(&data, &eFuseCtrlStruc, 4); | ||
367 | RTMP_IO_WRITE32(pAd, EFUSE_CTRL, data); | ||
368 | |||
369 | //Step4. Polling EFSROM_KICK(0x580, bit30) until it become 0 again. It¡¦s done. | ||
370 | i = 0; | ||
371 | |||
372 | while(i < 500) | ||
373 | { | ||
374 | RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word); | ||
375 | |||
376 | if(eFuseCtrlStruc.field.EFSROM_KICK == 0) | ||
377 | break; | ||
378 | |||
379 | RTMPusecDelay(2); | ||
380 | i++; | ||
381 | } | ||
382 | } | ||
383 | |||
384 | /* | ||
385 | ======================================================================== | ||
386 | |||
387 | Routine Description: | ||
388 | |||
389 | Arguments: | ||
390 | |||
391 | Return Value: | ||
392 | |||
393 | Note: | ||
394 | |||
395 | ======================================================================== | ||
396 | */ | ||
397 | static VOID eFuseWritePhysical( | ||
398 | IN PRTMP_ADAPTER pAd, | ||
399 | PUSHORT lpInBuffer, | ||
400 | ULONG nInBufferSize, | ||
401 | PUCHAR lpOutBuffer, | ||
402 | ULONG nOutBufferSize | ||
403 | ) | ||
404 | { | ||
405 | USHORT* pInBuf = (USHORT*)lpInBuffer; | ||
406 | int i; | ||
407 | //USHORT* pOutBuf = (USHORT*)ioBuffer; | ||
408 | USHORT Offset = pInBuf[0]; // addr | ||
409 | USHORT Length = pInBuf[1]; // length | ||
410 | USHORT* pValueX = &pInBuf[2]; // value ... | ||
411 | |||
412 | DBGPRINT(RT_DEBUG_TRACE, ("eFuseWritePhysical Offset=0x%x, length=%d\n", Offset, Length)); | ||
413 | |||
414 | { | ||
415 | // Little-endian S | S Big-endian | ||
416 | // addr 3 2 1 0 | 0 1 2 3 | ||
417 | // Ori-V D C B A | A B C D | ||
418 | // After swapping | ||
419 | // D C B A | D C B A | ||
420 | // Both the little and big-endian use the same sequence to write data. | ||
421 | // Therefore, we only need swap data when read the data. | ||
422 | for (i=0; i<Length; i+=2) | ||
423 | { | ||
424 | eFusePhysicalWriteRegisters(pAd, Offset+i, 2, &pValueX[i/2]); | ||
425 | } | ||
426 | } | ||
427 | } | ||
428 | |||
429 | /* | ||
430 | ======================================================================== | ||
431 | |||
432 | Routine Description: | ||
433 | |||
434 | Arguments: | ||
435 | |||
436 | Return Value: | ||
437 | |||
438 | Note: | ||
439 | |||
440 | ======================================================================== | ||
441 | */ | ||
442 | INT set_eFuseGetFreeBlockCount_Proc( | 269 | INT set_eFuseGetFreeBlockCount_Proc( |
443 | IN PRTMP_ADAPTER pAd, | 270 | IN PRTMP_ADAPTER pAd, |
444 | IN PSTRING arg) | 271 | IN PSTRING arg) |
@@ -492,442 +319,12 @@ USHORT InBuf[3]; | |||
492 | return TRUE; | 319 | return TRUE; |
493 | } | 320 | } |
494 | 321 | ||
495 | |||
496 | INT set_eFuseLoadFromBin_Proc( | ||
497 | IN PRTMP_ADAPTER pAd, | ||
498 | IN PSTRING arg) | ||
499 | { | ||
500 | PSTRING src; | ||
501 | RTMP_OS_FD srcf; | ||
502 | RTMP_OS_FS_INFO osfsInfo; | ||
503 | INT retval, memSize; | ||
504 | PSTRING buffer, memPtr; | ||
505 | INT i = 0,j=0,k=1; | ||
506 | USHORT *PDATA; | ||
507 | USHORT DATA; | ||
508 | |||
509 | memSize = 128 + MAX_EEPROM_BIN_FILE_SIZE + sizeof(USHORT) * 8; | ||
510 | memPtr = kmalloc(memSize, MEM_ALLOC_FLAG); | ||
511 | if (memPtr == NULL) | ||
512 | return FALSE; | ||
513 | |||
514 | NdisZeroMemory(memPtr, memSize); | ||
515 | src = memPtr; // kmalloc(128, MEM_ALLOC_FLAG); | ||
516 | buffer = src + 128; // kmalloc(MAX_EEPROM_BIN_FILE_SIZE, MEM_ALLOC_FLAG); | ||
517 | PDATA = (USHORT*)(buffer + MAX_EEPROM_BIN_FILE_SIZE); // kmalloc(sizeof(USHORT)*8,MEM_ALLOC_FLAG); | ||
518 | |||
519 | if(strlen(arg)>0) | ||
520 | NdisMoveMemory(src, arg, strlen(arg)); | ||
521 | else | ||
522 | NdisMoveMemory(src, EFUSE_EEPROM_DEFULT_FILE, strlen(EFUSE_EEPROM_DEFULT_FILE)); | ||
523 | DBGPRINT(RT_DEBUG_TRACE, ("FileName=%s\n",src)); | ||
524 | |||
525 | RtmpOSFSInfoChange(&osfsInfo, TRUE); | ||
526 | |||
527 | srcf = RtmpOSFileOpen(src, O_RDONLY, 0); | ||
528 | if (IS_FILE_OPEN_ERR(srcf)) | ||
529 | { | ||
530 | DBGPRINT(RT_DEBUG_ERROR, ("--> Error opening file %s\n", src)); | ||
531 | retval = FALSE; | ||
532 | goto recoverFS; | ||
533 | } | ||
534 | else | ||
535 | { | ||
536 | // The object must have a read method | ||
537 | while(RtmpOSFileRead(srcf, &buffer[i], 1)==1) | ||
538 | { | ||
539 | i++; | ||
540 | if(i>MAX_EEPROM_BIN_FILE_SIZE) | ||
541 | { | ||
542 | DBGPRINT(RT_DEBUG_ERROR, ("--> Error reading file %s, file size too large[>%d]\n", src, MAX_EEPROM_BIN_FILE_SIZE)); | ||
543 | retval = FALSE; | ||
544 | goto closeFile; | ||
545 | } | ||
546 | } | ||
547 | |||
548 | retval = RtmpOSFileClose(srcf); | ||
549 | if (retval) | ||
550 | DBGPRINT(RT_DEBUG_TRACE, ("--> Error closing file %s\n", src)); | ||
551 | } | ||
552 | |||
553 | |||
554 | RtmpOSFSInfoChange(&osfsInfo, FALSE); | ||
555 | |||
556 | for(j=0;j<i;j++) | ||
557 | { | ||
558 | DBGPRINT(RT_DEBUG_TRACE, ("%02X ",buffer[j]&0xff)); | ||
559 | if((j+1)%2==0) | ||
560 | PDATA[j/2%8]=((buffer[j]<<8)&0xff00)|(buffer[j-1]&0xff); | ||
561 | if(j%16==0) | ||
562 | { | ||
563 | k=buffer[j]; | ||
564 | } | ||
565 | else | ||
566 | { | ||
567 | k&=buffer[j]; | ||
568 | if((j+1)%16==0) | ||
569 | { | ||
570 | DBGPRINT(RT_DEBUG_TRACE, (" result=%02X,blk=%02x\n",k,j/16)); | ||
571 | if(k!=0xff) | ||
572 | eFuseWriteRegistersFromBin(pAd,(USHORT)j-15, 16, PDATA); | ||
573 | else | ||
574 | { | ||
575 | if(eFuseReadRegisters(pAd,j, 2,(PUSHORT)&DATA)!=0x3f) | ||
576 | eFuseWriteRegistersFromBin(pAd,(USHORT)j-15, 16, PDATA); | ||
577 | } | ||
578 | /* | ||
579 | for(l=0;l<8;l++) | ||
580 | printk("%04x ",PDATA[l]); | ||
581 | printk("\n"); | ||
582 | */ | ||
583 | NdisZeroMemory(PDATA,16); | ||
584 | } | ||
585 | } | ||
586 | } | ||
587 | |||
588 | return TRUE; | ||
589 | |||
590 | closeFile: | ||
591 | if (srcf) | ||
592 | RtmpOSFileClose(srcf); | ||
593 | |||
594 | recoverFS: | ||
595 | RtmpOSFSInfoChange(&osfsInfo, FALSE); | ||
596 | |||
597 | |||
598 | if (memPtr) | ||
599 | kfree(memPtr); | ||
600 | |||
601 | return retval; | ||
602 | } | ||
603 | |||
604 | |||
605 | static NTSTATUS eFuseWriteRegistersFromBin( | ||
606 | IN PRTMP_ADAPTER pAd, | ||
607 | IN USHORT Offset, | ||
608 | IN USHORT Length, | ||
609 | IN USHORT* pData) | ||
610 | { | ||
611 | USHORT i; | ||
612 | USHORT eFuseData; | ||
613 | USHORT LogicalAddress, BlkNum = 0xffff; | ||
614 | UCHAR EFSROM_AOUT,Loop=0; | ||
615 | EFUSE_CTRL_STRUC eFuseCtrlStruc; | ||
616 | USHORT efuseDataOffset; | ||
617 | UINT32 data,tempbuffer; | ||
618 | USHORT addr,tmpaddr, InBuf[3], tmpOffset; | ||
619 | UINT32 buffer[4]; | ||
620 | BOOLEAN bWriteSuccess = TRUE; | ||
621 | BOOLEAN bNotWrite=TRUE; | ||
622 | BOOLEAN bAllocateNewBlk=TRUE; | ||
623 | |||
624 | DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegistersFromBin Offset=%x, pData=%04x:%04x:%04x:%04x\n", Offset, *pData,*(pData+1),*(pData+2),*(pData+3))); | ||
625 | |||
626 | do | ||
627 | { | ||
628 | //Step 0. find the entry in the mapping table | ||
629 | //The address of EEPROM is 2-bytes alignment. | ||
630 | //The last bit is used for alignment, so it must be 0. | ||
631 | Loop++; | ||
632 | tmpOffset = Offset & 0xfffe; | ||
633 | EFSROM_AOUT = eFuseReadRegisters(pAd, tmpOffset, 2, &eFuseData); | ||
634 | |||
635 | if( EFSROM_AOUT == 0x3f) | ||
636 | { //find available logical address pointer | ||
637 | //the logical address does not exist, find an empty one | ||
638 | //from the first address of block 45=16*45=0x2d0 to the last address of block 47 | ||
639 | //==>48*16-3(reserved)=2FC | ||
640 | bAllocateNewBlk=TRUE; | ||
641 | for (i=EFUSE_USAGE_MAP_START; i<=EFUSE_USAGE_MAP_END; i+=2) | ||
642 | { | ||
643 | //Retrive the logical block nubmer form each logical address pointer | ||
644 | //It will access two logical address pointer each time. | ||
645 | eFusePhysicalReadRegisters(pAd, i, 2, &LogicalAddress); | ||
646 | if( (LogicalAddress & 0xff) == 0) | ||
647 | {//Not used logical address pointer | ||
648 | BlkNum = i-EFUSE_USAGE_MAP_START; | ||
649 | break; | ||
650 | } | ||
651 | else if(( (LogicalAddress >> 8) & 0xff) == 0) | ||
652 | {//Not used logical address pointer | ||
653 | if (i != EFUSE_USAGE_MAP_END) | ||
654 | { | ||
655 | BlkNum = i-EFUSE_USAGE_MAP_START+1; | ||
656 | } | ||
657 | break; | ||
658 | } | ||
659 | } | ||
660 | } | ||
661 | else | ||
662 | { | ||
663 | bAllocateNewBlk=FALSE; | ||
664 | BlkNum = EFSROM_AOUT; | ||
665 | } | ||
666 | |||
667 | DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegisters BlkNum = %d \n", BlkNum)); | ||
668 | |||
669 | if(BlkNum == 0xffff) | ||
670 | { | ||
671 | DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegisters: out of free E-fuse space!!!\n")); | ||
672 | return FALSE; | ||
673 | } | ||
674 | //Step 1.1.0 | ||
675 | //If the block is not existing in mapping table, create one | ||
676 | //and write down the 16-bytes data to the new block | ||
677 | if(bAllocateNewBlk) | ||
678 | { | ||
679 | DBGPRINT(RT_DEBUG_TRACE, ("Allocate New Blk\n")); | ||
680 | efuseDataOffset = EFUSE_DATA3; | ||
681 | for(i=0; i< 4; i++) | ||
682 | { | ||
683 | DBGPRINT(RT_DEBUG_TRACE, ("Allocate New Blk, Data%d=%04x%04x\n",3-i,pData[2*i+1],pData[2*i])); | ||
684 | tempbuffer=((pData[2*i+1]<<16)&0xffff0000)|pData[2*i]; | ||
685 | |||
686 | |||
687 | RTMP_IO_WRITE32(pAd, efuseDataOffset,tempbuffer); | ||
688 | efuseDataOffset -= 4; | ||
689 | |||
690 | } | ||
691 | ///////////////////////////////////////////////////////////////// | ||
692 | |||
693 | //Step1.1.1. Write 10-bit of address to EFSROM_AIN (0x580, bit25:bit16). The address must be 16-byte alignment. | ||
694 | RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word); | ||
695 | eFuseCtrlStruc.field.EFSROM_AIN = BlkNum* 0x10 ; | ||
696 | |||
697 | //Step1.1.2. Write EFSROM_MODE (0x580, bit7:bit6) to 3. | ||
698 | eFuseCtrlStruc.field.EFSROM_MODE = 3; | ||
699 | |||
700 | //Step1.1.3. Write EFSROM_KICK (0x580, bit30) to 1 to kick-off physical write procedure. | ||
701 | eFuseCtrlStruc.field.EFSROM_KICK = 1; | ||
702 | |||
703 | NdisMoveMemory(&data, &eFuseCtrlStruc, 4); | ||
704 | |||
705 | RTMP_IO_WRITE32(pAd, EFUSE_CTRL, data); | ||
706 | |||
707 | //Step1.1.4. Polling EFSROM_KICK(0x580, bit30) until it become 0 again. It¡¦s done. | ||
708 | i = 0; | ||
709 | while(i < 100) | ||
710 | { | ||
711 | RTMP_IO_READ32(pAd, EFUSE_CTRL, (PUINT32) &eFuseCtrlStruc); | ||
712 | |||
713 | if(eFuseCtrlStruc.field.EFSROM_KICK == 0) | ||
714 | break; | ||
715 | |||
716 | RTMPusecDelay(2); | ||
717 | i++; | ||
718 | } | ||
719 | |||
720 | } | ||
721 | else | ||
722 | { //Step1.2. | ||
723 | //If the same logical number is existing, check if the writting data and the data | ||
724 | //saving in this block are the same. | ||
725 | ///////////////////////////////////////////////////////////////// | ||
726 | //read current values of 16-byte block | ||
727 | RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word); | ||
728 | |||
729 | //Step1.2.0. Write 10-bit of address to EFSROM_AIN (0x580, bit25:bit16). The address must be 16-byte alignment. | ||
730 | eFuseCtrlStruc.field.EFSROM_AIN = Offset & 0xfff0; | ||
731 | |||
732 | //Step1.2.1. Write EFSROM_MODE (0x580, bit7:bit6) to 1. | ||
733 | eFuseCtrlStruc.field.EFSROM_MODE = 0; | ||
734 | |||
735 | //Step1.2.2. Write EFSROM_KICK (0x580, bit30) to 1 to kick-off physical read procedure. | ||
736 | eFuseCtrlStruc.field.EFSROM_KICK = 1; | ||
737 | |||
738 | NdisMoveMemory(&data, &eFuseCtrlStruc, 4); | ||
739 | RTMP_IO_WRITE32(pAd, EFUSE_CTRL, data); | ||
740 | |||
741 | //Step1.2.3. Polling EFSROM_KICK(0x580, bit30) until it become 0 again. | ||
742 | i = 0; | ||
743 | while(i < 500) | ||
744 | { | ||
745 | RTMP_IO_READ32(pAd, EFUSE_CTRL, (PUINT32) &eFuseCtrlStruc); | ||
746 | |||
747 | if(eFuseCtrlStruc.field.EFSROM_KICK == 0) | ||
748 | break; | ||
749 | RTMPusecDelay(2); | ||
750 | i++; | ||
751 | } | ||
752 | |||
753 | //Step1.2.4. Read 16-byte of data from EFUSE_DATA0-3 (0x59C-0x590) | ||
754 | efuseDataOffset = EFUSE_DATA3; | ||
755 | for(i=0; i< 4; i++) | ||
756 | { | ||
757 | RTMP_IO_READ32(pAd, efuseDataOffset, (PUINT32) &buffer[i]); | ||
758 | efuseDataOffset -= 4; | ||
759 | } | ||
760 | //Step1.2.5. Check if the data of efuse and the writing data are the same. | ||
761 | for(i =0; i<4; i++) | ||
762 | { | ||
763 | tempbuffer=((pData[2*i+1]<<16)&0xffff0000)|pData[2*i]; | ||
764 | DBGPRINT(RT_DEBUG_TRACE, ("buffer[%d]=%x,pData[%d]=%x,pData[%d]=%x,tempbuffer=%x\n",i,buffer[i],2*i,pData[2*i],2*i+1,pData[2*i+1],tempbuffer)); | ||
765 | |||
766 | if(((buffer[i]&0xffff0000)==(pData[2*i+1]<<16))&&((buffer[i]&0xffff)==pData[2*i])) | ||
767 | bNotWrite&=TRUE; | ||
768 | else | ||
769 | { | ||
770 | bNotWrite&=FALSE; | ||
771 | break; | ||
772 | } | ||
773 | } | ||
774 | if(!bNotWrite) | ||
775 | { | ||
776 | printk("The data is not the same\n"); | ||
777 | |||
778 | for(i =0; i<8; i++) | ||
779 | { | ||
780 | addr = BlkNum * 0x10 ; | ||
781 | |||
782 | InBuf[0] = addr+2*i; | ||
783 | InBuf[1] = 2; | ||
784 | InBuf[2] = pData[i]; | ||
785 | |||
786 | eFuseWritePhysical(pAd, &InBuf[0], 6, NULL, 2); | ||
787 | } | ||
788 | |||
789 | } | ||
790 | else | ||
791 | return TRUE; | ||
792 | } | ||
793 | |||
794 | |||
795 | |||
796 | //Step 2. Write mapping table | ||
797 | addr = EFUSE_USAGE_MAP_START+BlkNum; | ||
798 | |||
799 | tmpaddr = addr; | ||
800 | |||
801 | if(addr % 2 != 0) | ||
802 | addr = addr -1; | ||
803 | InBuf[0] = addr; | ||
804 | InBuf[1] = 2; | ||
805 | |||
806 | //convert the address from 10 to 8 bit ( bit7, 6 = parity and bit5 ~ 0 = bit9~4), and write to logical map entry | ||
807 | tmpOffset = Offset; | ||
808 | tmpOffset >>= 4; | ||
809 | tmpOffset |= ((~((tmpOffset & 0x01) ^ ( tmpOffset >> 1 & 0x01) ^ (tmpOffset >> 2 & 0x01) ^ (tmpOffset >> 3 & 0x01))) << 6) & 0x40; | ||
810 | tmpOffset |= ((~( (tmpOffset >> 2 & 0x01) ^ (tmpOffset >> 3 & 0x01) ^ (tmpOffset >> 4 & 0x01) ^ ( tmpOffset >> 5 & 0x01))) << 7) & 0x80; | ||
811 | |||
812 | // write the logical address | ||
813 | if(tmpaddr%2 != 0) | ||
814 | InBuf[2] = tmpOffset<<8; | ||
815 | else | ||
816 | InBuf[2] = tmpOffset; | ||
817 | |||
818 | eFuseWritePhysical(pAd,&InBuf[0], 6, NULL, 0); | ||
819 | |||
820 | //Step 3. Compare data if not the same, invalidate the mapping entry, then re-write the data until E-fuse is exhausted | ||
821 | bWriteSuccess = TRUE; | ||
822 | for(i =0; i<8; i++) | ||
823 | { | ||
824 | addr = BlkNum * 0x10 ; | ||
825 | |||
826 | InBuf[0] = addr+2*i; | ||
827 | InBuf[1] = 2; | ||
828 | InBuf[2] = 0x0; | ||
829 | |||
830 | eFuseReadPhysical(pAd, &InBuf[0], 4, &InBuf[2], 2); | ||
831 | DBGPRINT(RT_DEBUG_TRACE, ("addr=%x, buffer[i]=%x,InBuf[2]=%x\n",InBuf[0],pData[i],InBuf[2])); | ||
832 | if(pData[i] != InBuf[2]) | ||
833 | { | ||
834 | bWriteSuccess = FALSE; | ||
835 | break; | ||
836 | } | ||
837 | } | ||
838 | |||
839 | //Step 4. invlidate mapping entry and find a free mapping entry if not succeed | ||
840 | |||
841 | if (!bWriteSuccess&&Loop<2) | ||
842 | { | ||
843 | DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegistersFromBin::Not bWriteSuccess BlkNum = %d\n", BlkNum)); | ||
844 | |||
845 | // the offset of current mapping entry | ||
846 | addr = EFUSE_USAGE_MAP_START+BlkNum; | ||
847 | |||
848 | //find a new mapping entry | ||
849 | BlkNum = 0xffff; | ||
850 | for (i=EFUSE_USAGE_MAP_START; i<=EFUSE_USAGE_MAP_END; i+=2) | ||
851 | { | ||
852 | eFusePhysicalReadRegisters(pAd, i, 2, &LogicalAddress); | ||
853 | if( (LogicalAddress & 0xff) == 0) | ||
854 | { | ||
855 | BlkNum = i-EFUSE_USAGE_MAP_START; | ||
856 | break; | ||
857 | } | ||
858 | else if(( (LogicalAddress >> 8) & 0xff) == 0) | ||
859 | { | ||
860 | if (i != EFUSE_USAGE_MAP_END) | ||
861 | { | ||
862 | BlkNum = i+1-EFUSE_USAGE_MAP_START; | ||
863 | } | ||
864 | break; | ||
865 | } | ||
866 | } | ||
867 | DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegistersFromBin::Not bWriteSuccess new BlkNum = %d\n", BlkNum)); | ||
868 | if(BlkNum == 0xffff) | ||
869 | { | ||
870 | DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegistersFromBin: out of free E-fuse space!!!\n")); | ||
871 | return FALSE; | ||
872 | } | ||
873 | |||
874 | //invalidate the original mapping entry if new entry is not found | ||
875 | tmpaddr = addr; | ||
876 | |||
877 | if(addr % 2 != 0) | ||
878 | addr = addr -1; | ||
879 | InBuf[0] = addr; | ||
880 | InBuf[1] = 2; | ||
881 | |||
882 | eFuseReadPhysical(pAd, &InBuf[0], 4, &InBuf[2], 2); | ||
883 | |||
884 | // write the logical address | ||
885 | if(tmpaddr%2 != 0) | ||
886 | { | ||
887 | // Invalidate the high byte | ||
888 | for (i=8; i<15; i++) | ||
889 | { | ||
890 | if( ( (InBuf[2] >> i) & 0x01) == 0) | ||
891 | { | ||
892 | InBuf[2] |= (0x1 <<i); | ||
893 | break; | ||
894 | } | ||
895 | } | ||
896 | } | ||
897 | else | ||
898 | { | ||
899 | // invalidate the low byte | ||
900 | for (i=0; i<8; i++) | ||
901 | { | ||
902 | if( ( (InBuf[2] >> i) & 0x01) == 0) | ||
903 | { | ||
904 | InBuf[2] |= (0x1 <<i); | ||
905 | break; | ||
906 | } | ||
907 | } | ||
908 | } | ||
909 | eFuseWritePhysical(pAd, &InBuf[0], 6, NULL, 0); | ||
910 | } | ||
911 | |||
912 | } | ||
913 | while(!bWriteSuccess&&Loop<2); | ||
914 | |||
915 | return TRUE; | ||
916 | } | ||
917 | |||
918 | |||
919 | int rtmp_ee_efuse_read16( | 322 | int rtmp_ee_efuse_read16( |
920 | IN RTMP_ADAPTER *pAd, | 323 | IN RTMP_ADAPTER *pAd, |
921 | IN USHORT Offset, | 324 | IN USHORT Offset, |
922 | OUT USHORT *pValue) | 325 | OUT USHORT *pValue) |
923 | { | 326 | { |
924 | if(pAd->bFroceEEPROMBuffer || pAd->bEEPROMFile) | 327 | eFuseReadRegisters(pAd, Offset, 2, pValue); |
925 | { | ||
926 | DBGPRINT(RT_DEBUG_TRACE, ("Read from EEPROM Buffer\n")); | ||
927 | NdisMoveMemory(pValue, &(pAd->EEPROMImage[Offset]), 2); | ||
928 | } | ||
929 | else | ||
930 | eFuseReadRegisters(pAd, Offset, 2, pValue); | ||
931 | return (*pValue); | 328 | return (*pValue); |
932 | } | 329 | } |
933 | 330 | ||
@@ -944,177 +341,6 @@ int RtmpEfuseSupportCheck( | |||
944 | return 0; | 341 | return 0; |
945 | } | 342 | } |
946 | 343 | ||
947 | INT set_eFuseBufferModeWriteBack_Proc( | ||
948 | IN PRTMP_ADAPTER pAd, | ||
949 | IN PSTRING arg) | ||
950 | { | ||
951 | UINT Enable; | ||
952 | |||
953 | |||
954 | if(strlen(arg)>0) | ||
955 | { | ||
956 | Enable= simple_strtol(arg, 0, 16); | ||
957 | } | ||
958 | else | ||
959 | return FALSE; | ||
960 | if(Enable==1) | ||
961 | { | ||
962 | DBGPRINT(RT_DEBUG_TRACE, ("set_eFuseBufferMode_Proc:: Call WRITEEEPROMBUF")); | ||
963 | eFuseWriteEeeppromBuf(pAd); | ||
964 | } | ||
965 | else | ||
966 | return FALSE; | ||
967 | return TRUE; | ||
968 | } | ||
969 | |||
970 | |||
971 | /* | ||
972 | ======================================================================== | ||
973 | |||
974 | Routine Description: | ||
975 | Load EEPROM from bin file for eFuse mode | ||
976 | |||
977 | Arguments: | ||
978 | Adapter Pointer to our adapter | ||
979 | |||
980 | Return Value: | ||
981 | NDIS_STATUS_SUCCESS firmware image load ok | ||
982 | NDIS_STATUS_FAILURE image not found | ||
983 | |||
984 | IRQL = PASSIVE_LEVEL | ||
985 | |||
986 | ======================================================================== | ||
987 | */ | ||
988 | INT eFuseLoadEEPROM( | ||
989 | IN PRTMP_ADAPTER pAd) | ||
990 | { | ||
991 | PSTRING src = NULL; | ||
992 | INT retval; | ||
993 | RTMP_OS_FD srcf; | ||
994 | RTMP_OS_FS_INFO osFSInfo; | ||
995 | |||
996 | |||
997 | src=EFUSE_BUFFER_PATH; | ||
998 | DBGPRINT(RT_DEBUG_TRACE, ("FileName=%s\n",src)); | ||
999 | |||
1000 | |||
1001 | RtmpOSFSInfoChange(&osFSInfo, TRUE); | ||
1002 | |||
1003 | if (src && *src) | ||
1004 | { | ||
1005 | srcf = RtmpOSFileOpen(src, O_RDONLY, 0); | ||
1006 | if (IS_FILE_OPEN_ERR(srcf)) | ||
1007 | { | ||
1008 | DBGPRINT(RT_DEBUG_ERROR, ("--> Error %ld opening %s\n", -PTR_ERR(srcf),src)); | ||
1009 | return FALSE; | ||
1010 | } | ||
1011 | else | ||
1012 | { | ||
1013 | |||
1014 | memset(pAd->EEPROMImage, 0x00, MAX_EEPROM_BIN_FILE_SIZE); | ||
1015 | |||
1016 | |||
1017 | retval =RtmpOSFileRead(srcf, (PSTRING)pAd->EEPROMImage, MAX_EEPROM_BIN_FILE_SIZE); | ||
1018 | if (retval > 0) | ||
1019 | { | ||
1020 | RTMPSetProfileParameters(pAd, (PSTRING)pAd->EEPROMImage); | ||
1021 | retval = NDIS_STATUS_SUCCESS; | ||
1022 | } | ||
1023 | else | ||
1024 | DBGPRINT(RT_DEBUG_ERROR, ("Read file \"%s\" failed(errCode=%d)!\n", src, retval)); | ||
1025 | |||
1026 | } | ||
1027 | |||
1028 | |||
1029 | } | ||
1030 | else | ||
1031 | { | ||
1032 | DBGPRINT(RT_DEBUG_ERROR, ("--> Error src or srcf is null\n")); | ||
1033 | return FALSE; | ||
1034 | |||
1035 | } | ||
1036 | |||
1037 | retval=RtmpOSFileClose(srcf); | ||
1038 | |||
1039 | if (retval) | ||
1040 | { | ||
1041 | DBGPRINT(RT_DEBUG_TRACE, ("--> Error %d closing %s\n", -retval, src)); | ||
1042 | } | ||
1043 | |||
1044 | |||
1045 | RtmpOSFSInfoChange(&osFSInfo, FALSE); | ||
1046 | |||
1047 | return TRUE; | ||
1048 | } | ||
1049 | |||
1050 | INT eFuseWriteEeeppromBuf( | ||
1051 | IN PRTMP_ADAPTER pAd) | ||
1052 | { | ||
1053 | |||
1054 | PSTRING src = NULL; | ||
1055 | INT retval; | ||
1056 | RTMP_OS_FD srcf; | ||
1057 | RTMP_OS_FS_INFO osFSInfo; | ||
1058 | |||
1059 | |||
1060 | src=EFUSE_BUFFER_PATH; | ||
1061 | DBGPRINT(RT_DEBUG_TRACE, ("FileName=%s\n",src)); | ||
1062 | |||
1063 | RtmpOSFSInfoChange(&osFSInfo, TRUE); | ||
1064 | |||
1065 | |||
1066 | |||
1067 | if (src && *src) | ||
1068 | { | ||
1069 | srcf = RtmpOSFileOpen(src, O_WRONLY|O_CREAT, 0); | ||
1070 | |||
1071 | if (IS_FILE_OPEN_ERR(srcf)) | ||
1072 | { | ||
1073 | DBGPRINT(RT_DEBUG_ERROR, ("--> Error %ld opening %s\n", -PTR_ERR(srcf),src)); | ||
1074 | return FALSE; | ||
1075 | } | ||
1076 | else | ||
1077 | { | ||
1078 | /* | ||
1079 | // The object must have a read method | ||
1080 | if (srcf->f_op && srcf->f_op->write) | ||
1081 | { | ||
1082 | // The object must have a read method | ||
1083 | srcf->f_op->write(srcf, pAd->EEPROMImage, 1024, &srcf->f_pos); | ||
1084 | |||
1085 | } | ||
1086 | else | ||
1087 | { | ||
1088 | DBGPRINT(RT_DEBUG_ERROR, ("--> Error!! System doest not support read function\n")); | ||
1089 | return FALSE; | ||
1090 | } | ||
1091 | */ | ||
1092 | |||
1093 | RtmpOSFileWrite(srcf, (PSTRING)pAd->EEPROMImage,MAX_EEPROM_BIN_FILE_SIZE); | ||
1094 | |||
1095 | } | ||
1096 | |||
1097 | |||
1098 | } | ||
1099 | else | ||
1100 | { | ||
1101 | DBGPRINT(RT_DEBUG_ERROR, ("--> Error src or srcf is null\n")); | ||
1102 | return FALSE; | ||
1103 | |||
1104 | } | ||
1105 | |||
1106 | retval=RtmpOSFileClose(srcf); | ||
1107 | |||
1108 | if (retval) | ||
1109 | { | ||
1110 | DBGPRINT(RT_DEBUG_TRACE, ("--> Error %d closing %s\n", -retval, src)); | ||
1111 | } | ||
1112 | |||
1113 | RtmpOSFSInfoChange(&osFSInfo, FALSE); | ||
1114 | return TRUE; | ||
1115 | } | ||
1116 | |||
1117 | |||
1118 | VOID eFuseGetFreeBlockCount(IN PRTMP_ADAPTER pAd, | 344 | VOID eFuseGetFreeBlockCount(IN PRTMP_ADAPTER pAd, |
1119 | PUINT EfuseFreeBlock) | 345 | PUINT EfuseFreeBlock) |
1120 | { | 346 | { |
@@ -1151,18 +377,6 @@ INT eFuse_init( | |||
1151 | UINT EfuseFreeBlock=0; | 377 | UINT EfuseFreeBlock=0; |
1152 | DBGPRINT(RT_DEBUG_ERROR, ("NVM is Efuse and its size =%x[%x-%x] \n",EFUSE_USAGE_MAP_SIZE,EFUSE_USAGE_MAP_START,EFUSE_USAGE_MAP_END)); | 378 | DBGPRINT(RT_DEBUG_ERROR, ("NVM is Efuse and its size =%x[%x-%x] \n",EFUSE_USAGE_MAP_SIZE,EFUSE_USAGE_MAP_START,EFUSE_USAGE_MAP_END)); |
1153 | eFuseGetFreeBlockCount(pAd, &EfuseFreeBlock); | 379 | eFuseGetFreeBlockCount(pAd, &EfuseFreeBlock); |
1154 | //If the used block of efuse is less than 5. We assume the default value | ||
1155 | // of this efuse is empty and change to the buffer mode in odrder to | ||
1156 | //bring up interfaces successfully. | ||
1157 | if(EfuseFreeBlock > (EFUSE_USAGE_MAP_END-5)) | ||
1158 | { | ||
1159 | DBGPRINT(RT_DEBUG_ERROR, ("NVM is Efuse and the information is too less to bring up interface. Force to use EEPROM Buffer Mode\n")); | ||
1160 | pAd->bFroceEEPROMBuffer = TRUE; | ||
1161 | eFuseLoadEEPROM(pAd); | ||
1162 | } | ||
1163 | else | ||
1164 | pAd->bFroceEEPROMBuffer = FALSE; | ||
1165 | DBGPRINT(RT_DEBUG_TRACE, ("NVM is Efuse and force to use EEPROM Buffer Mode=%x\n",pAd->bFroceEEPROMBuffer)); | ||
1166 | 380 | ||
1167 | return 0; | 381 | return 0; |
1168 | } | 382 | } |
diff --git a/drivers/staging/rt2860/common/eeprom.c b/drivers/staging/rt2860/common/eeprom.c index d7a2664bb73..39276ca64c1 100644 --- a/drivers/staging/rt2860/common/eeprom.c +++ b/drivers/staging/rt2860/common/eeprom.c | |||
@@ -69,10 +69,7 @@ INT RtmpChipOpsEepromHook( | |||
69 | return 0 ; | 69 | return 0 ; |
70 | } | 70 | } |
71 | else | 71 | else |
72 | { | ||
73 | pAd->bFroceEEPROMBuffer = FALSE; | ||
74 | DBGPRINT(RT_DEBUG_TRACE, ("NVM is EEPROM\n")); | 72 | DBGPRINT(RT_DEBUG_TRACE, ("NVM is EEPROM\n")); |
75 | } | ||
76 | #endif // RTMP_EFUSE_SUPPORT // | 73 | #endif // RTMP_EFUSE_SUPPORT // |
77 | #endif // RT30xx // | 74 | #endif // RT30xx // |
78 | 75 | ||
diff --git a/drivers/staging/rt2860/common/rtmp_init.c b/drivers/staging/rt2860/common/rtmp_init.c index 9e1c73dbfb2..fe8327b9b13 100644 --- a/drivers/staging/rt2860/common/rtmp_init.c +++ b/drivers/staging/rt2860/common/rtmp_init.c | |||
@@ -694,15 +694,6 @@ VOID NICReadEEPROMParameters( | |||
694 | 694 | ||
695 | if (pAd->chipOps.eeinit) | 695 | if (pAd->chipOps.eeinit) |
696 | pAd->chipOps.eeinit(pAd); | 696 | pAd->chipOps.eeinit(pAd); |
697 | #ifdef RTMP_EFUSE_SUPPORT | ||
698 | #ifdef RT30xx | ||
699 | if(!pAd->bFroceEEPROMBuffer && pAd->bEEPROMFile) | ||
700 | { | ||
701 | DBGPRINT(RT_DEBUG_TRACE, ("--> NICReadEEPROMParameters::(Efuse)Load to EEPROM Buffer Mode\n")); | ||
702 | eFuseLoadEEPROM(pAd); | ||
703 | } | ||
704 | #endif // RT30xx // | ||
705 | #endif // RTMP_EFUSE_SUPPORT // | ||
706 | 697 | ||
707 | // Init EEPROM Address Number, before access EEPROM; if 93c46, EEPROMAddressNum=6, else if 93c66, EEPROMAddressNum=8 | 698 | // Init EEPROM Address Number, before access EEPROM; if 93c46, EEPROMAddressNum=6, else if 93c66, EEPROMAddressNum=8 |
708 | RTMP_IO_READ32(pAd, E2PROM_CSR, &data); | 699 | RTMP_IO_READ32(pAd, E2PROM_CSR, &data); |
diff --git a/drivers/staging/rt2860/rt_linux.c b/drivers/staging/rt2860/rt_linux.c index b5783608660..cdda24724c5 100644 --- a/drivers/staging/rt2860/rt_linux.c +++ b/drivers/staging/rt2860/rt_linux.c | |||
@@ -1065,26 +1065,6 @@ int RtmpOSFileWrite(RTMP_OS_FD osfd, char *pDataPtr, int writeLen) | |||
1065 | return osfd->f_op->write(osfd, pDataPtr, (size_t)writeLen, &osfd->f_pos); | 1065 | return osfd->f_op->write(osfd, pDataPtr, (size_t)writeLen, &osfd->f_pos); |
1066 | } | 1066 | } |
1067 | 1067 | ||
1068 | |||
1069 | void RtmpOSFSInfoChange(RTMP_OS_FS_INFO *pOSFSInfo, BOOLEAN bSet) | ||
1070 | { | ||
1071 | if (bSet) | ||
1072 | { | ||
1073 | // Save uid and gid used for filesystem access. | ||
1074 | // Set user and group to 0 (root) | ||
1075 | pOSFSInfo->fsuid = current_fsuid(); | ||
1076 | pOSFSInfo->fsgid = current_fsgid(); | ||
1077 | pOSFSInfo->fs = get_fs(); | ||
1078 | set_fs(KERNEL_DS); | ||
1079 | } | ||
1080 | else | ||
1081 | { | ||
1082 | set_fs(pOSFSInfo->fs); | ||
1083 | } | ||
1084 | } | ||
1085 | |||
1086 | |||
1087 | |||
1088 | /******************************************************************************* | 1068 | /******************************************************************************* |
1089 | 1069 | ||
1090 | Task create/management/kill related functions. | 1070 | Task create/management/kill related functions. |
diff --git a/drivers/staging/rt2860/rtmp.h b/drivers/staging/rt2860/rtmp.h index 3ec50b5f61c..c43c8eafae4 100644 --- a/drivers/staging/rt2860/rtmp.h +++ b/drivers/staging/rt2860/rtmp.h | |||
@@ -2258,8 +2258,6 @@ struct _RTMP_ADAPTER | |||
2258 | #ifdef RT30xx | 2258 | #ifdef RT30xx |
2259 | #ifdef RTMP_EFUSE_SUPPORT | 2259 | #ifdef RTMP_EFUSE_SUPPORT |
2260 | BOOLEAN bUseEfuse; | 2260 | BOOLEAN bUseEfuse; |
2261 | BOOLEAN bEEPROMFile; | ||
2262 | BOOLEAN bFroceEEPROMBuffer; | ||
2263 | UCHAR EEPROMImage[1024]; | 2261 | UCHAR EEPROMImage[1024]; |
2264 | #endif // RTMP_EFUSE_SUPPORT // | 2262 | #endif // RTMP_EFUSE_SUPPORT // |
2265 | #endif // RT30xx // | 2263 | #endif // RT30xx // |
@@ -4021,10 +4019,6 @@ INT set_eFusedump_Proc( | |||
4021 | IN PRTMP_ADAPTER pAd, | 4019 | IN PRTMP_ADAPTER pAd, |
4022 | IN PSTRING arg); | 4020 | IN PSTRING arg); |
4023 | 4021 | ||
4024 | INT set_eFuseLoadFromBin_Proc( | ||
4025 | IN PRTMP_ADAPTER pAd, | ||
4026 | IN PSTRING arg); | ||
4027 | |||
4028 | VOID eFusePhysicalReadRegisters( | 4022 | VOID eFusePhysicalReadRegisters( |
4029 | IN PRTMP_ADAPTER pAd, | 4023 | IN PRTMP_ADAPTER pAd, |
4030 | IN USHORT Offset, | 4024 | IN USHORT Offset, |
@@ -4034,16 +4028,6 @@ VOID eFusePhysicalReadRegisters( | |||
4034 | int RtmpEfuseSupportCheck( | 4028 | int RtmpEfuseSupportCheck( |
4035 | IN RTMP_ADAPTER *pAd); | 4029 | IN RTMP_ADAPTER *pAd); |
4036 | 4030 | ||
4037 | INT set_eFuseBufferModeWriteBack_Proc( | ||
4038 | IN PRTMP_ADAPTER pAd, | ||
4039 | IN PSTRING arg); | ||
4040 | |||
4041 | INT eFuseLoadEEPROM( | ||
4042 | IN PRTMP_ADAPTER pAd); | ||
4043 | |||
4044 | INT eFuseWriteEeeppromBuf( | ||
4045 | IN PRTMP_ADAPTER pAd); | ||
4046 | |||
4047 | VOID eFuseGetFreeBlockCount(IN PRTMP_ADAPTER pAd, | 4031 | VOID eFuseGetFreeBlockCount(IN PRTMP_ADAPTER pAd, |
4048 | PUINT EfuseFreeBlock); | 4032 | PUINT EfuseFreeBlock); |
4049 | 4033 | ||
@@ -5632,10 +5616,5 @@ int RtmpOSFileWrite( | |||
5632 | IN char *pDataPtr, | 5616 | IN char *pDataPtr, |
5633 | IN int writeLen); | 5617 | IN int writeLen); |
5634 | 5618 | ||
5635 | void RtmpOSFSInfoChange( | ||
5636 | IN RTMP_OS_FS_INFO *pOSFSInfo, | ||
5637 | IN BOOLEAN bSet); | ||
5638 | |||
5639 | |||
5640 | #endif // __RTMP_H__ | 5619 | #endif // __RTMP_H__ |
5641 | 5620 | ||