~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise : revision 29

1

/******************************************************************************

2

3

*

4

* This program is distributed in the hope that it will be useful, but WITHOUT

5

* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

6

* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

7

* more details.

8

*

9

* You should have received a copy of the GNU General Public License along with

10

* this program; if not, write to the Free Software Foundation, Inc.,

11

* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

12

*

13

* The full GNU General Public License is included in this distribution in the

14

* file called LICENSE.

15

*

16

* Contact Information:

17

* wlanfae <wlanfae@realtek.com>

18

******************************************************************************/

19

#include "../rtl_core.h"

20

#include <linux/types.h>

21

22

#ifdef RTL8192SE

23

/*---------------------------Define Local Constant---------------------------*/

24

#define _POWERON_DELAY_

25

#define _PRE_EXECUTE_READ_CMD_

26

27

#define EFUSE_REPEAT_THRESHOLD_ 3

28

#define EFUSE_ERROE_HANDLE 1

29

30

31

typedef struct _EFUSE_MAP_A{

32

u8 offset;

33

u8 word_start;

34

u8 byte_start;

35

u8 byte_cnts;

36

37

}EFUSE_MAP, *PEFUSE_MAP;

38

39

typedef struct PG_PKT_STRUCT_A{

40

u8 offset;

41

u8 word_en;

42

u8 data[8];

43

}PGPKT_STRUCT,*PPGPKT_STRUCT;

44

45

typedef enum _EFUSE_DATA_ITEM{

46

EFUSE_CHIP_ID=0,

47

EFUSE_LDO_SETTING,

48

EFUSE_CLK_SETTING,

49

EFUSE_SDIO_SETTING,

50

EFUSE_CCCR,

51

EFUSE_SDIO_MODE,

52

EFUSE_OCR,

53

EFUSE_F0CIS,

54

EFUSE_F1CIS,

55

EFUSE_MAC_ADDR,

56

EFUSE_EEPROM_VER,

57

EFUSE_CHAN_PLAN,

58

EFUSE_TXPW_TAB

59

} EFUSE_DATA_ITEM;

60

61

struct efuse_priv

62

{

63

u8 id[2];

64

u8 ldo_setting[2];

65

u8 clk_setting[2];

66

u8 cccr;

67

u8 sdio_mode;

68

u8 ocr[3];

69

u8 cis0[17];

70

u8 cis1[48];

71

u8 mac_addr[6];

72

u8 eeprom_verno;

73

u8 channel_plan;

74

u8 tx_power_b[14];

75

u8 tx_power_g[14];

76

};

77

78

/*---------------------------Define Local Constant---------------------------*/

79

80

81

/*------------------------Define global variable-----------------------------*/

82

const u8 MAX_PGPKT_SIZE = 9;

83

const u8 PGPKT_DATA_SIZE = 8;

84

const u32 EFUSE_MAX_SIZE = 512;

85

86

const u8 EFUSE_OOB_PROTECT_BYTES = 15;

87

88

89

const EFUSE_MAP RTL8712_SDIO_EFUSE_TABLE[]={

90

/*ID*/ {0 ,0 ,0 ,2 },

91

/*LDO Setting*/ {0 ,1 ,0 ,2 },

92

/*CLK Setting*/ {0 ,2 ,0 ,2 },

93

/*SDIO Setting*/{1 ,0 ,0 ,1 },

94

/*CCCR*/ {1 ,0 ,1 ,1 },

95

/*SDIO MODE*/ {1 ,1 ,0 ,1 },

96

/*OCR*/ {1 ,1 ,1 ,3 },

97

/*CCIS*/ {1 ,3 ,0 ,17 },

98

/*F1CIS*/ {3 ,3 ,1 ,48 },

99

/*MAC Addr*/ {10 ,0 ,0 ,6 },

100

/*EEPROM ver*/ {10 ,3 ,0 ,1 },

101

/*Channel plan*/{10 ,3 ,1 ,1 },

102

/*TxPwIndex */ {11 ,0 ,0 ,28 }

103

};

104

105

/*------------------------Define global variable-----------------------------*/

106

107

108

/*------------------------Define local variable------------------------------*/

109

110

/*------------------------Define local variable------------------------------*/

111

112

113

/*--------------------Define function prototype-----------------------*/

114

extern void

115

EFUSE_Initialize(struct net_device* dev);

116

extern u8

117

EFUSE_Read1Byte(struct net_device* dev, u16 Address);

118

extern void

119

EFUSE_Write1Byte(struct net_device* dev, u16 Address,u8 Value);

120

121

static void

122

efuse_ShadowRead1Byte(struct net_device* dev,u16 Offset,u8 *Value);

123

static void

124

efuse_ShadowRead2Byte(struct net_device* dev, u16 Offset,u16 *Value );

125

static void

126

efuse_ShadowRead4Byte(struct net_device* dev, u16 Offset,u32 *Value );

127

static void

128

efuse_ShadowWrite1Byte(struct net_device* dev, u16 Offset, u8 Value);

129

static void

130

efuse_ShadowWrite2Byte(struct net_device* dev, u16 Offset,u16 Value);

131

static void

132

efuse_ShadowWrite4Byte(struct net_device* dev, u16 Offset,u32 Value);

133

134

static u8

135

efuse_OneByteRead(struct net_device* dev,u16 addr,u8 *data);

136

static u8

137

efuse_OneByteWrite(struct net_device* dev,u16 addr, u8 data);

138

139

static void

140

efuse_ReadAllMap(struct net_device* dev,u8 *Efuse);

141

#ifdef TO_DO_LIST

142

static void

143

efuse_WriteAllMap(struct net_device* dev,u8 *eeprom,u32 eeprom_size);

144

static bool

145

efuse_ParsingMap(char* szStr,u32* pu4bVal,u32* pu4bMove);

146

#endif

147

static u8

148

efuse_PgPacketRead( struct net_device* dev,u8 offset,u8 *data);

149

static u8

150

efuse_PgPacketWrite(struct net_device* dev,u8 offset,u8 word_en,u8 *data);

151

static void

152

efuse_WordEnableDataRead( u8 word_en,u8 *sourdata,u8 *targetdata);

153

static u8

154

efuse_WordEnableDataWrite( struct net_device* dev, u16 efuse_addr, u8 word_en, u8 *data);

155

static void

156

efuse_PowerSwitch(struct net_device* dev,u8 PwrState);

157

static u16

158

efuse_GetCurrentSize(struct net_device* dev);

159

static u8

160

efuse_CalculateWordCnts(u8 word_en);

161

#if 0

162

static void

163

efuse_ResetLoader(struct net_device* dev);

164

#endif

165

#ifdef TO_DO_LIST

166

static void efuse_reg_ctrl(struct net_device* dev, u8 bPowerOn);

167

#endif

168

/*--------------------Define function prototype-----------------------*/

169

170

171

172

extern void

173

EFUSE_Initialize(struct net_device* dev)

174

{

175

u8 Bytetemp = {0x00};

176

u8 temp = {0x00};

177

178

Bytetemp = read_nic_byte(dev, SYS_FUNC_EN+1);

179

temp = Bytetemp | 0x20;

180

write_nic_byte(dev, SYS_FUNC_EN+1, temp);

181

182

Bytetemp = read_nic_byte(dev, SYS_ISO_CTRL+1);

183

temp = Bytetemp & 0xFE;

184

write_nic_byte(dev, SYS_ISO_CTRL+1, temp);

185

186

187

Bytetemp = read_nic_byte(dev, EFUSE_TEST+3);

188

temp = Bytetemp | 0x80;

189

write_nic_byte(dev, EFUSE_TEST+3, temp);

190

191

write_nic_byte(dev, 0x2F8, 0x3);

192

193

write_nic_byte(dev, EFUSE_CTRL+3, 0x72);

194

195

} /* EFUSE_Initialize */

196

197

198

extern u8

199

EFUSE_Read1Byte(struct net_device* dev, u16 Address)

200

{

201

u8 data;

202

u8 Bytetemp = {0x00};

203

u8 temp = {0x00};

204

u32 k=0;

205

206

if (Address < EFUSE_REAL_CONTENT_LEN)

207

{

208

temp = Address & 0xFF;

209

write_nic_byte(dev, EFUSE_CTRL+1, temp);

210

Bytetemp = read_nic_byte(dev, EFUSE_CTRL+2);

211

temp = ((Address >> 8) & 0x03) | (Bytetemp & 0xFC);

212

write_nic_byte(dev, EFUSE_CTRL+2, temp);

213

214

Bytetemp = read_nic_byte(dev, EFUSE_CTRL+3);

215

temp = Bytetemp & 0x7F;

216

write_nic_byte(dev, EFUSE_CTRL+3, temp);

217

218

Bytetemp = read_nic_byte(dev, EFUSE_CTRL+3);

219

while(!(Bytetemp & 0x80))

220

{

221

Bytetemp = read_nic_byte(dev, EFUSE_CTRL+3);

222

k++;

223

if(k==1000)

224

{

225

k=0;

226

break;

227

}

228

}

229

data=read_nic_byte(dev, EFUSE_CTRL);

230

return data;

231

}

232

else

233

return 0xFF;

234

235

} /* EFUSE_Read1Byte */

236

237

238

extern void

239

EFUSE_Write1Byte(struct net_device* dev, u16 Address,u8 Value)

240

{

241

u8 Bytetemp = {0x00};

242

u8 temp = {0x00};

243

u32 k=0;

244

245

246

if( Address < EFUSE_REAL_CONTENT_LEN)

247

{

248

write_nic_byte(dev, EFUSE_CTRL, Value);

249

250

temp = Address & 0xFF;

251

write_nic_byte(dev, EFUSE_CTRL+1, temp);

252

Bytetemp = read_nic_byte(dev, EFUSE_CTRL+2);

253

254

temp = ((Address >> 8) & 0x03) | (Bytetemp & 0xFC);

255

write_nic_byte(dev, EFUSE_CTRL+2, temp);

256

257

Bytetemp = read_nic_byte(dev, EFUSE_CTRL+3);

258

temp = Bytetemp | 0x80;

259

write_nic_byte(dev, EFUSE_CTRL+3, temp);

260

261

Bytetemp = read_nic_byte(dev, EFUSE_CTRL+3);

262

while(Bytetemp & 0x80)

263

{

264

Bytetemp = read_nic_byte(dev, EFUSE_CTRL+3);

265

k++;

266

if(k==100)

267

{

268

k=0;

269

break;

270

}

271

}

272

}

273

274

} /* EFUSE_Write1Byte */

275

276

277

#ifdef EFUSE_FOR_92SU

278

void do_93c46(struct net_device* dev, u8 addorvalue)

279

{

280

u8 cs[1] = {0x88};

281

u8 cssk[1] = {0x8c};

282

u8 csdi[1] = {0x8a};

283

u8 csskdi[1] = {0x8e};

284

u8 count;

285

286

for(count=0 ; count<8 ; count++)

287

{

288

if((addorvalue&0x80)!=0)

289

{

290

write_nic_byte(dev, EPROM_CMD, csdi[0]);

291

write_nic_byte(dev, EPROM_CMD, csskdi[0]);

292

}

293

else

294

{

295

write_nic_byte(dev, EPROM_CMD, cs[0]);

296

write_nic_byte(dev, EPROM_CMD, cssk[0]);

297

}

298

addorvalue = addorvalue << 1;

299

}

300

}

301

302

303

u16 Read93C46(struct net_device* dev, u16 Reg )

304

{

305

306

u8 clear[1] = {0x0};

307

u8 cs[1] = {0x88};

308

u8 cssk[1] = {0x8c};

309

u8 csdi[1] = {0x8a};

310

u8 csskdi[1] = {0x8e};

311

u8 EepromSEL[1]={0x00};

312

u8 address;

313

314

u16 storedataF[1] = {0x0};

315

u8 t,data[1],storedata[1];

316

317

318

address = (u8)Reg;

319

320

*EepromSEL= read_nic_byte(dev, EPROM_CMD);

321

322

if((*EepromSEL & 0x10) == 0x10)

323

{

324

address = address | 0x80;

325

326

write_nic_byte(dev, EPROM_CMD, csdi[0]);

327

write_nic_byte(dev, EPROM_CMD, csskdi[0]);

328

do_93c46(dev, address);

329

}

330

331

332

for(t=0 ; t<16 ; t++)

333

{

334

write_nic_byte(dev, EPROM_CMD, cs[0]);

335

write_nic_byte(dev, EPROM_CMD, cssk[0]);

336

*data= read_nic_byte(dev, EPROM_CMD);

337

338

if(*data & 0x8d)

339

{

340

*data = *data & 0x01;

341

*storedata = *data;

342

}

343

else

344

{

345

*data = *data & 0x01 ;

346

*storedata = *data;

347

}

348

*storedataF = (*storedataF << 1 ) + *storedata;

349

}

350

write_nic_byte(dev, EPROM_CMD, cs[0]);

351

write_nic_byte(dev, EPROM_CMD, clear[0]);

352

353

return *storedataF;

354

}

355

356

357

void

358

ReadEFuseByte(struct net_device* dev,u16 _offset, u8 *pbuf)

359

{

360

361

u32 value32;

362

u8 readbyte;

363

u16 retry;

364

365

366

write_nic_byte(dev, EFUSE_CTRL+1, (_offset & 0xff));

367

readbyte = read_nic_byte(dev, EFUSE_CTRL+2);

368

write_nic_byte(dev, EFUSE_CTRL+2, ((_offset >> 8) & 0x03) | (readbyte & 0xfc));

369

370

readbyte = read_nic_byte(dev, EFUSE_CTRL+3);

371

write_nic_byte(dev, EFUSE_CTRL+3, (readbyte & 0x7f));

372

373

retry = 0;

374

value32 = read_nic_dword(dev, EFUSE_CTRL);

375

while(!(((value32 >> 24) & 0xff) & 0x80) && (retry<10000))

376

{

377

value32 = read_nic_dword(dev, EFUSE_CTRL);

378

retry++;

379

}

380

*pbuf = (u8)(value32 & 0xff);

381

}

382

383

384

#define EFUSE_READ_SWITCH 1

385

void

386

ReadEFuse(struct net_device* dev, u16 _offset, u16 _size_byte, u8 *pbuf)

387

{

388

struct r8192_priv *priv = rtllib_priv(dev);

389

u8 efuseTbl[EFUSE_MAP_LEN];

390

u8 rtemp8[1];

391

u16 eFuse_Addr = 0;

392

u8 offset, wren;

393

u16 i, j;

394

u16 eFuseWord[EFUSE_MAX_SECTION][EFUSE_MAX_WORD_UNIT];

395

u16 efuse_utilized = 0;

396

u16 efuse_usage = 0;

397

#ifdef EFUSE_REPG_WORKAROUND

398

u16 sec1_addr = 0, sec5_addr = 0;

399

#endif

400

401

if((_offset + _size_byte)>EFUSE_MAP_LEN)

402

{

403

printk("ReadEFuse(): Invalid offset with read bytes!!\n");

404

return;

405

}

406

407

for (i = 0; i < EFUSE_MAX_SECTION; i++)

408

for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++)

409

eFuseWord[i][j]=0xFFFF;

410

411

for (i = 0; i < EFUSE_MAP_LEN; i++)

412

efuseTbl[i] = 0xFF;

413

414

ReadEFuseByte(dev, eFuse_Addr, rtemp8);

415

if(*rtemp8 != 0xFF)

416

{

417

efuse_utilized++;

418

eFuse_Addr++;

419

}

420

while((*rtemp8 != 0xFF) && (eFuse_Addr < EFUSE_REAL_CONTENT_LEN))

421

{

422

offset = ((*rtemp8 >> 4) & 0x0f);

423

#ifdef EFUSE_REPG_WORKAROUND

424

if (IS_HARDWARE_TYPE_8192SE(dev))

425

{

426

if (offset == 1)

427

{

428

sec1_addr = eFuse_Addr;

429

}

430

else if (offset == 5)

431

{

432

sec5_addr = eFuse_Addr;

433

}

434

435

if (sec1_addr > sec5_addr)

436

{

437

priv->efuse_RePGSec1Flag = false;

438

}

439

else

440

{

441

priv->efuse_RePGSec1Flag = true;

442

}

443

}

444

#endif

445

if(offset < EFUSE_MAX_SECTION){

446

wren = (*rtemp8 & 0x0f);

447

for(i=0; i<4; i++){

448

if(!(wren & 0x01)){

449

ReadEFuseByte(dev, eFuse_Addr, rtemp8); eFuse_Addr++;

450

efuse_utilized++;

451

eFuseWord[offset][i] = (*rtemp8 & 0xff);

452

if(eFuse_Addr >= EFUSE_REAL_CONTENT_LEN) break;

453

ReadEFuseByte(dev, eFuse_Addr, rtemp8); eFuse_Addr++;

454

efuse_utilized++;

455

eFuseWord[offset][i] |= (((u16)*rtemp8 << 8) & 0xff00);

456

if(eFuse_Addr >= EFUSE_REAL_CONTENT_LEN) break;

457

}

458

wren >>= 1;

459

}

460

}

461

ReadEFuseByte(dev, eFuse_Addr, rtemp8);

462

if(*rtemp8 != 0xFF && (eFuse_Addr < 512))

463

{

464

efuse_utilized++;

465

eFuse_Addr++;

466

}

467

}

468

469

for(i=0; i<EFUSE_MAX_SECTION; i++){

470

for(j=0; j<EFUSE_MAX_WORD_UNIT; j++){

471

efuseTbl[(i*8)+(j*2)]=(eFuseWord[i][j] & 0xff);

472

efuseTbl[(i*8)+((j*2)+1)]=((eFuseWord[i][j] >> 8) & 0xff);

473

#ifdef FUSE_REPG_WORKAROUND

474

if ((i == 1) && (priv->efuse_RePGSec1Flag == true))

475

{

476

priv->efuse_RePGData[j*2]=(eFuseWord[i][j] & 0xff);

477

priv->efuse_RePGData[(j*2)+1]=((eFuseWord[i][j] >> 8) & 0xff);

478

}

479

#endif

480

}

481

}

482

for(i=0; i<_size_byte; i++)

483

pbuf[i] = efuseTbl[_offset+i];

484

priv->EfuseUsedBytes = efuse_utilized;

485

efuse_usage = (u8)((efuse_utilized*100)/EFUSE_REAL_CONTENT_LEN);

486

priv->EfuseUsedPercentage = efuse_usage;

487

}

488

#endif

489

490

extern bool EFUSE_ShadowUpdateChk(struct net_device *dev)

491

{

492

struct r8192_priv *priv = rtllib_priv(dev);

493

u8 SectionIdx, i, Base;

494

u16 WordsNeed = 0, HdrNum = 0, TotalBytes = 0, EfuseUsed = 0;

495

bool bWordChanged, bResult = true;

496

497

for (SectionIdx = 0; SectionIdx < 16; SectionIdx++) {

498

Base = SectionIdx * 8;

499

bWordChanged = false;

500

501

for (i = 0; i < 8; i=i+2) {

502

if((priv->EfuseMap[EFUSE_INIT_MAP][Base+i] !=

503

priv->EfuseMap[EFUSE_MODIFY_MAP][Base+i]) ||

504

(priv->EfuseMap[EFUSE_INIT_MAP][Base+i+1] !=

505

priv->EfuseMap[EFUSE_MODIFY_MAP][Base+i+1])) {

506

WordsNeed++;

507

bWordChanged = true;

508

}

509

}

510

511

if( bWordChanged == true )

512

HdrNum++;

513

}

514

515

TotalBytes = HdrNum + WordsNeed * 2;

516

EfuseUsed = priv->EfuseUsedBytes;

517

518

if ((TotalBytes + EfuseUsed) >= (EFUSE_MAX_SIZE - EFUSE_OOB_PROTECT_BYTES))

519

bResult = false;

520

521

return bResult;

522

}

523

524

extern void

525

EFUSE_ShadowRead( struct net_device* dev, u8 Type, u16 Offset, u32 *Value)

526

{

527

528

if (Type == 1)

529

efuse_ShadowRead1Byte(dev, Offset, (u8 *)Value);

530

else if (Type == 2)

531

efuse_ShadowRead2Byte(dev, Offset, (u16 *)Value);

532

else if (Type == 4)

533

efuse_ShadowRead4Byte(dev, Offset, (u32 *)Value);

534

535

}

536

537

538

extern void

539

EFUSE_ShadowWrite( struct net_device* dev, u8 Type, u16 Offset,u32 Value)

540

{

541

542

if (Offset >= 0x18 && Offset <= 0x1F)

543

return;

544

545

if (Type == 1)

546

efuse_ShadowWrite1Byte(dev, Offset, (u8)Value);

547

else if (Type == 2)

548

efuse_ShadowWrite2Byte(dev, Offset, (u16)Value);

549

else if (Type == 4)

550

efuse_ShadowWrite4Byte(dev, Offset, (u32)Value);

551

552

}

553

554

555

extern bool EFUSE_ShadowUpdate(struct net_device* dev)

556

{

557

struct r8192_priv *priv = rtllib_priv(dev);

558

u16 i, offset, base = 0;

559

u8 word_en = 0x0F;

560

bool first_pg = false;

561

562

if (!EFUSE_ShadowUpdateChk(dev)) {

563

efuse_ReadAllMap(dev, &priv->EfuseMap[EFUSE_INIT_MAP][0]);

564

memcpy(&priv->EfuseMap[EFUSE_MODIFY_MAP][0],

565

(void *)&priv->EfuseMap[EFUSE_INIT_MAP][0], HWSET_MAX_SIZE_92S);

566

567

printk("<---EFUSE_ShadowUpdate(): Efuse out of capacity!!\n");

568

return false;

569

}

570

571

efuse_PowerSwitch(dev, true);

572

573

for (offset = 0; offset < 16; offset++)

574

{

575

if(IS_HARDWARE_TYPE_8192SE(dev)){

576

if (offset == 3)

577

continue;

578

}

579

word_en = 0x0F;

580

base = offset * 8;

581

582

for (i = 0; i < 8; i++)

583

{

584

if (offset == 0 && priv->EfuseMap[EFUSE_INIT_MAP][base+i] == 0xFF)

585

{

586

first_pg = true;

587

}

588

589

if (first_pg == true && offset == 1 && IS_HARDWARE_TYPE_8192SE(dev))

590

{

591

continue;

592

}

593

594

if (first_pg == true)

595

{

596

word_en &= ~(BIT(i/2));

597

priv->EfuseMap[EFUSE_INIT_MAP][base+i] =

598

priv->EfuseMap[EFUSE_MODIFY_MAP][base+i];

599

}else

600

{

601

if ( priv->EfuseMap[EFUSE_INIT_MAP][base+i] !=

602

priv->EfuseMap[EFUSE_MODIFY_MAP][base+i])

603

{

604

word_en &= ~(EFUSE_BIT(i/2));

605

606

priv->EfuseMap[EFUSE_INIT_MAP][base+i] =

607

priv->EfuseMap[EFUSE_MODIFY_MAP][base+i];

608

}

609

}

610

}

611

612

if (word_en != 0x0F)

613

{

614

u8 tmpdata[8];

615

616

memcpy(tmpdata, &(priv->EfuseMap[EFUSE_MODIFY_MAP][base]), 8);

617

efuse_PgPacketWrite(dev,(u8)offset,word_en,tmpdata);

618

}

619

620

}

621

if (first_pg == true && IS_HARDWARE_TYPE_8192SE(dev))

622

{

623

u8 tmpdata[8];

624

625

memcpy(tmpdata, (&priv->EfuseMap[EFUSE_MODIFY_MAP][8]), 8);

626

efuse_PgPacketWrite(dev, 1, 0x0, tmpdata);

627

#if 0

628

u1Byte tmpdata[8] = {0xFF, 0xFF, 0xEC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF};

629

630

efuse_PgPacketWrite(pAdapter, 1, 0xD, tmpdata);

631

#endif

632

}

633

634

635

efuse_PowerSwitch(dev, false);

636

efuse_ReadAllMap(dev, &priv->EfuseMap[EFUSE_INIT_MAP][0]);

637

memcpy(&priv->EfuseMap[EFUSE_MODIFY_MAP][0],

638

(void *)&priv->EfuseMap[EFUSE_INIT_MAP][0], HWSET_MAX_SIZE_92S);

639

640

return true;

641

}

642

643

644

extern void EFUSE_ShadowMapUpdate(struct net_device* dev)

645

{

646

struct r8192_priv *priv = rtllib_priv(dev);

647

648

if (priv->AutoloadFailFlag == true){

649

memset(&(priv->EfuseMap[EFUSE_INIT_MAP][0]), 0xff, 128);

650

}else{

651

efuse_ReadAllMap(dev, &priv->EfuseMap[EFUSE_INIT_MAP][0]);

652

}

653

memcpy(&priv->EfuseMap[EFUSE_MODIFY_MAP][0],

654

&priv->EfuseMap[EFUSE_INIT_MAP][0], HWSET_MAX_SIZE_92S);

655

656

}

657

658

659

extern void

660

EFUSE_ForceWriteVendorId( struct net_device* dev)

661

{

662

u8 tmpdata[8] = {0xFF, 0xFF, 0xEC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF};

663

664

efuse_PowerSwitch(dev, true);

665

666

efuse_PgPacketWrite(dev, 1, 0xD, tmpdata);

667

668

efuse_PowerSwitch(dev, false);

669

670

}

671

672

extern void

673

EFUSE_RePgSection1(struct net_device* dev)

674

{

675

#ifdef EFUSE_REPG_WORKAROUND

676

677

struct r8192_priv *priv = rtllib_priv(dev);

678

679

if (priv->efuse_RePGSec1Flag == true)

680

{

681

efuse_PowerSwitch(dev, true);

682

RT_TRACE(COMP_INIT, "EFUSE REPG: %p, %u\n", priv->efuse_RePGData, 8);

683

684

efuse_PgPacketWrite(dev, 1, 0x0d, priv->efuse_RePGData);

685

efuse_PowerSwitch(dev, false);

686

priv->efuse_RePGSec1Flag = false;

687

}

688

#endif

689

}

690

691

692

static void

693

efuse_ShadowRead1Byte(struct net_device* dev, u16 Offset, u8 *Value)

694

{

695

struct r8192_priv *priv = rtllib_priv(dev);

696

697

*Value = priv->EfuseMap[EFUSE_MODIFY_MAP][Offset];

698

699

}

700

701

static void

702

efuse_ShadowRead2Byte(struct net_device* dev, u16 Offset, u16 *Value)

703

{

704

struct r8192_priv *priv = rtllib_priv(dev);

705

706

*Value = priv->EfuseMap[EFUSE_MODIFY_MAP][Offset];

707

*Value |= priv->EfuseMap[EFUSE_MODIFY_MAP][Offset+1]<<8;

708

709

}

710

711

static void

712

efuse_ShadowRead4Byte(struct net_device* dev, u16 Offset, u32 *Value)

713

{

714

struct r8192_priv *priv = rtllib_priv(dev);

715

716

*Value = priv->EfuseMap[EFUSE_MODIFY_MAP][Offset];

717

*Value |= priv->EfuseMap[EFUSE_MODIFY_MAP][Offset+1]<<8;

718

*Value |= priv->EfuseMap[EFUSE_MODIFY_MAP][Offset+2]<<16;

719

*Value |= priv->EfuseMap[EFUSE_MODIFY_MAP][Offset+3]<<24;

720

721

}

722

723

724

725

static void

726

efuse_ShadowWrite1Byte(struct net_device* dev, u16 Offset, u8 Value)

727

{

728

struct r8192_priv *priv = rtllib_priv(dev);

729

730

priv->EfuseMap[EFUSE_MODIFY_MAP][Offset] = Value;

731

732

}

733

734

static void

735

efuse_ShadowWrite2Byte(struct net_device* dev, u16 Offset, u16 Value)

736

{

737

struct r8192_priv *priv = rtllib_priv(dev);

738

739

priv->EfuseMap[EFUSE_MODIFY_MAP][Offset] = Value&0x00FF;

740

priv->EfuseMap[EFUSE_MODIFY_MAP][Offset+1] = Value>>8;

741

742

}

743

744

static void

745

efuse_ShadowWrite4Byte(struct net_device* dev, u16 Offset, u32 Value)

746

{

747

struct r8192_priv *priv = rtllib_priv(dev);

748

749

priv->EfuseMap[EFUSE_MODIFY_MAP][Offset] = (u8)(Value&0x000000FF);

750

priv->EfuseMap[EFUSE_MODIFY_MAP][Offset+1] = (u8)((Value>>8)&0x0000FF);

751

priv->EfuseMap[EFUSE_MODIFY_MAP][Offset+2] = (u8)((Value>>16)&0x00FF);

752

priv->EfuseMap[EFUSE_MODIFY_MAP][Offset+3] = (u8)((Value>>24)&0xFF);

753

754

}

755

756

757

static u8

758

efuse_OneByteRead(struct net_device* dev, u16 addr,u8 *data)

759

{

760

u8 tmpidx = 0;

761

u8 bResult;

762

763

write_nic_byte(dev, EFUSE_CTRL+1, (u8)(addr&0xff));

764

write_nic_byte(dev, EFUSE_CTRL+2, ((u8)((addr>>8) &0x03) ) |

765

(read_nic_byte(dev, EFUSE_CTRL+2)&0xFC ));

766

767

write_nic_byte(dev, EFUSE_CTRL+3, 0x72);

768

769

while(!(0x80 &read_nic_byte(dev, EFUSE_CTRL+3))&&(tmpidx<100))

770

{

771

tmpidx++;

772

}

773

if(tmpidx<100)

774

{

775

*data=read_nic_byte(dev, EFUSE_CTRL);

776

bResult = true;

777

}

778

else

779

{

780

*data = 0xff;

781

bResult = false;

782

}

783

return bResult;

784

}

785

786

static u8

787

efuse_OneByteWrite(struct net_device* dev, u16 addr, u8 data)

788

{

789

u8 tmpidx = 0;

790

u8 bResult;

791

792

793

794

write_nic_byte(dev, EFUSE_CTRL+1, (u8)(addr&0xff));

795

write_nic_byte(dev, EFUSE_CTRL+2,

796

read_nic_byte(dev, EFUSE_CTRL+2)|(u8)((addr>>8)&0x03) );

797

798

write_nic_byte(dev, EFUSE_CTRL, data);

799

write_nic_byte(dev, EFUSE_CTRL+3, 0xF2);

800

801

while((0x80 & read_nic_byte(dev, EFUSE_CTRL+3)) && (tmpidx<100) ){

802

tmpidx++;

803

}

804

805

if(tmpidx<100)

806

{

807

bResult = true;

808

}

809

else

810

{

811

bResult = false;

812

}

813

814

return bResult;

815

}

816

817

818

static void

819

efuse_ReadAllMap(struct net_device* dev, u8 *Efuse)

820

{

821

822

efuse_PowerSwitch(dev, true);

823

ReadEFuse(dev, 0, 128, Efuse);

824

efuse_PowerSwitch(dev, false);

825

#if 0

826

RT_TRACE(COMP_INIT, "efuse_ResetLoader\n");

827

efuse_ResetLoader(dev);

828

829

write_nic_byte(dev, EFUSE_CLK, 0x03);

830

831

ReadEFuse(dev, 0, 128, Efuse);

832

833

write_nic_byte(dev, EFUSE_CLK, 0x02);

834

#if 0

835

for(offset = 0;offset<16;offset++)

836

{

837

PlatformFillMemory((PVOID)pg_data, 8, 0xff);

838

efuse_PgPacketRead(pAdapter,offset,pg_data);

839

840

PlatformMoveMemory((PVOID)&Efuse[offset*8], (PVOID)pg_data, 8);

841

}

842

#endif

843

844

if (Efuse[0] != 0x29 || Efuse[1] != 0x81)

845

{

846

if (index ++ < 5)

847

{

848

RT_TRACE(COMP_INIT, "EFUSE R FAIL %d\n", index);

849

efuse_ReadAllMap(dev, Efuse);

850

}

851

}

852

else

853

{

854

index = 0;

855

}

856

857

#endif

858

}

859

860

861

#ifdef TO_DO_LIST

862

static void

863

efuse_WriteAllMap(struct net_device* dev,u8 *eeprom, u32 eeprom_size)

864

{

865

unsigned char word_en = 0x00;

866

867

unsigned char tmpdata[8];

868

unsigned char offset;

869

870

efuse_PowerSwitch(dev, true);

871

872

for(offset=0 ; offset< eeprom_size/PGPKT_DATA_SIZE ; offset++)

873

{

874

if (IS_HARDWARE_TYPE_8192SE(dev))

875

{

876

if (offset == 3/* || offset > 9*/)

877

continue;

878

else

879

word_en = 0x00;

880

}

881

882

memcpy(tmpdata, (eeprom+(offset*PGPKT_DATA_SIZE)), 8);

883

884

885

efuse_PgPacketWrite(dev,offset,word_en,tmpdata);

886

887

888

}

889

890

efuse_PowerSwitch(dev, false);

891

892

}

893

#endif

894

static u8

895

efuse_PgPacketRead( struct net_device* dev, u8 offset, u8 *data)

896

{

897

u8 ReadState = PG_STATE_HEADER;

898

899

bool bContinual = true;

900

bool bDataEmpty = true ;

901

902

u8 efuse_data,word_cnts=0;

903

u16 efuse_addr = 0;

904

u8 hoffset=0,hworden=0;

905

u8 tmpidx=0;

906

u8 tmpdata[8];

907

908

if(data==NULL) return false;

909

if(offset>15) return false;

910

911

memset(data, 0xff, sizeof(u8)*PGPKT_DATA_SIZE);

912

memset(tmpdata, 0xff, sizeof(u8)*PGPKT_DATA_SIZE);

913

914

915

while(bContinual && (efuse_addr < EFUSE_MAX_SIZE) )

916

{

917

if(ReadState & PG_STATE_HEADER)

918

{

919

if(efuse_OneByteRead(dev, efuse_addr ,&efuse_data)&&(efuse_data!=0xFF)){

920

hoffset = (efuse_data>>4) & 0x0F;

921

hworden = efuse_data & 0x0F;

922

word_cnts = efuse_CalculateWordCnts(hworden);

923

bDataEmpty = true ;

924

925

if(hoffset==offset){

926

for(tmpidx = 0;tmpidx< word_cnts*2 ;tmpidx++){

927

if(efuse_OneByteRead(dev, efuse_addr+1+tmpidx ,&efuse_data) ){

928

tmpdata[tmpidx] = efuse_data;

929

if(efuse_data!=0xff){

930

bDataEmpty = false;

931

}

932

}

933

}

934

if(bDataEmpty==false){

935

ReadState = PG_STATE_DATA;

936

}else{

937

efuse_addr = efuse_addr + (word_cnts*2)+1;

938

ReadState = PG_STATE_HEADER;

939

}

940

}

941

else{

942

efuse_addr = efuse_addr + (word_cnts*2)+1;

943

ReadState = PG_STATE_HEADER;

944

}

945

946

}

947

else{

948

bContinual = false ;

949

}

950

}

951

else if(ReadState & PG_STATE_DATA)

952

{

953

efuse_WordEnableDataRead(hworden,tmpdata,data);

954

efuse_addr = efuse_addr + (word_cnts*2)+1;

955

ReadState = PG_STATE_HEADER;

956

}

957

958

}

959

960

961

if( (data[0]==0xff) &&(data[1]==0xff) && (data[2]==0xff) && (data[3]==0xff) &&

962

(data[4]==0xff) &&(data[5]==0xff) && (data[6]==0xff) && (data[7]==0xff))

963

return false;

964

else

965

return true;

966

967

}

968

969

970

static u8 efuse_PgPacketWrite(struct net_device* dev, u8 offset, u8 word_en,u8 *data)

971

{

972

u8 WriteState = PG_STATE_HEADER;

973

bool bContinual = true,bDataEmpty=true, bResult = true;

974

u16 efuse_addr = 0;

975

u8 efuse_data;

976

977

u8 pg_header = 0;

978

979

u8 tmp_word_cnts=0,target_word_cnts=0;

980

u8 tmp_header,match_word_en,tmp_word_en;

981

982

PGPKT_STRUCT target_pkt;

983

PGPKT_STRUCT tmp_pkt;

984

985

u8 originaldata[sizeof(u8)*8];

986

u8 tmpindex = 0,badworden = 0x0F;

987

988

static u32 repeat_times = 0;

989

990

if (efuse_GetCurrentSize(dev) >= EFUSE_MAX_SIZE - EFUSE_OOB_PROTECT_BYTES) {

991

printk("efuse_PgPacketWrite error \n");

992

return false;

993

}

994

995

target_pkt.offset = offset;

996

target_pkt.word_en= word_en;

997

998

memset(target_pkt.data,0xFF,sizeof(u8)*8);

999

1000

efuse_WordEnableDataRead(word_en,data,target_pkt.data);

1001

target_word_cnts = efuse_CalculateWordCnts(target_pkt.word_en);

1002

1003

printk("EFUSE Power ON\n");

1004

1005

while (bContinual && (efuse_addr < (EFUSE_MAX_SIZE - EFUSE_OOB_PROTECT_BYTES)))

1006

{

1007

if(WriteState==PG_STATE_HEADER)

1008

{

1009

bDataEmpty=true;

1010

badworden = 0x0F;

1011

printk("EFUSE PG_STATE_HEADER\n");

1012

if ( efuse_OneByteRead(dev, efuse_addr ,&efuse_data) &&

1013

(efuse_data!=0xFF))

1014

{

1015

tmp_header = efuse_data;

1016

1017

tmp_pkt.offset = (tmp_header>>4) & 0x0F;

1018

tmp_pkt.word_en = tmp_header & 0x0F;

1019

tmp_word_cnts = efuse_CalculateWordCnts(tmp_pkt.word_en);

1020

1021

if(tmp_pkt.offset != target_pkt.offset)

1022

{

1023

efuse_addr = efuse_addr + (tmp_word_cnts*2) +1;

1024

#if (EFUSE_ERROE_HANDLE == 1)

1025

WriteState = PG_STATE_HEADER;

1026

#endif

1027

}

1028

else

1029

{

1030

for(tmpindex=0 ; tmpindex<(tmp_word_cnts*2) ; tmpindex++)

1031

{

1032

if(efuse_OneByteRead(dev, (efuse_addr+1+tmpindex) ,&efuse_data)&&(efuse_data != 0xFF)){

1033

bDataEmpty = false;

1034

}

1035

}

1036

if(bDataEmpty == false)

1037

{

1038

efuse_addr = efuse_addr + (tmp_word_cnts*2) +1;

1039

#if (EFUSE_ERROE_HANDLE == 1)

1040

WriteState=PG_STATE_HEADER;

1041

#endif

1042

}

1043

else

1044

{

1045

match_word_en = 0x0F;

1046

if( !( (target_pkt.word_en&BIT0)|(tmp_pkt.word_en&BIT0) ))

1047

{

1048

match_word_en &= (~BIT0);

1049

}

1050

if( !( (target_pkt.word_en&BIT1)|(tmp_pkt.word_en&BIT1) ))

1051

{

1052

match_word_en &= (~BIT1);

1053

}

1054

if( !( (target_pkt.word_en&BIT2)|(tmp_pkt.word_en&BIT2) ))

1055

{

1056

match_word_en &= (~BIT2);

1057

}

1058

if( !( (target_pkt.word_en&BIT3)|(tmp_pkt.word_en&BIT3) ))

1059

{

1060

match_word_en &= (~BIT3);

1061

}

1062

1063

if((match_word_en&0x0F)!=0x0F)

1064

{

1065

badworden = efuse_WordEnableDataWrite(dev,efuse_addr+1, tmp_pkt.word_en ,target_pkt.data);

1066

1067

if(0x0F != (badworden&0x0F))

1068

{

1069

u8 reorg_offset = offset;

1070

u8 reorg_worden=badworden;

1071

efuse_PgPacketWrite(dev,reorg_offset,reorg_worden,originaldata);

1072

}

1073

1074

tmp_word_en = 0x0F;

1075

if( (target_pkt.word_en&BIT0)^(match_word_en&BIT0) )

1076

{

1077

tmp_word_en &= (~BIT0);

1078

}

1079

if( (target_pkt.word_en&BIT1)^(match_word_en&BIT1) )

1080

{

1081

tmp_word_en &= (~BIT1);

1082

}

1083

if( (target_pkt.word_en&BIT2)^(match_word_en&BIT2) )

1084

{

1085

tmp_word_en &= (~BIT2);

1086

}

1087

if( (target_pkt.word_en&BIT3)^(match_word_en&BIT3) )

1088

{

1089

tmp_word_en &=(~BIT3);

1090

}

1091

1092

if((tmp_word_en&0x0F)!=0x0F){

1093

efuse_addr = efuse_GetCurrentSize(dev);

1094

target_pkt.offset = offset;

1095

target_pkt.word_en= tmp_word_en;

1096

}else{

1097

bContinual = false;

1098

}

1099

#if (EFUSE_ERROE_HANDLE == 1)

1100

WriteState=PG_STATE_HEADER;

1101

repeat_times++;

1102

if(repeat_times>EFUSE_REPEAT_THRESHOLD_){

1103

bContinual = false;

1104

bResult = false;

1105

}

1106

#endif

1107

}

1108

else{

1109

efuse_addr = efuse_addr + (2*tmp_word_cnts) +1;

1110

target_pkt.offset = offset;

1111

target_pkt.word_en= target_pkt.word_en;

1112

#if (EFUSE_ERROE_HANDLE == 1)

1113

WriteState=PG_STATE_HEADER;

1114

#endif

1115

}

1116

}

1117

}

1118

printk("EFUSE PG_STATE_HEADER-1\n");

1119

}

1120

else

1121

{

1122

pg_header = ((target_pkt.offset << 4)&0xf0) |target_pkt.word_en;

1123

1124

efuse_OneByteWrite(dev,efuse_addr, pg_header);

1125

efuse_OneByteRead(dev,efuse_addr, &tmp_header);

1126

1127

if(tmp_header == pg_header)

1128

{

1129

WriteState = PG_STATE_DATA;

1130

}

1131

#if (EFUSE_ERROE_HANDLE == 1)

1132

else if(tmp_header == 0xFF){

1133

WriteState = PG_STATE_HEADER;

1134

repeat_times++;

1135

if(repeat_times>EFUSE_REPEAT_THRESHOLD_){

1136

bContinual = false;

1137

bResult = false;

1138

}

1139

}

1140

#endif

1141

else

1142

{

1143

tmp_pkt.offset = (tmp_header>>4) & 0x0F;

1144

tmp_pkt.word_en= tmp_header & 0x0F;

1145

tmp_word_cnts = efuse_CalculateWordCnts(tmp_pkt.word_en);

1146

1147

memset(originaldata,0xff,sizeof(u8)*8);

1148

1149

if(efuse_PgPacketRead( dev, tmp_pkt.offset,originaldata))

1150

{

1151

badworden = efuse_WordEnableDataWrite(dev,efuse_addr+1,tmp_pkt.word_en,originaldata);

1152

if(0x0F != (badworden&0x0F))

1153

{

1154

u8 reorg_offset = tmp_pkt.offset;

1155

u8 reorg_worden=badworden;

1156

efuse_PgPacketWrite(dev,reorg_offset,reorg_worden,originaldata);

1157

efuse_addr = efuse_GetCurrentSize(dev);

1158

}

1159

else{

1160

efuse_addr = efuse_addr + (tmp_word_cnts*2) +1;

1161

}

1162

}

1163

else

1164

{

1165

efuse_addr = efuse_addr + (tmp_word_cnts*2) +1;

1166

}

1167

1168

#if (EFUSE_ERROE_HANDLE == 1)

1169

WriteState=PG_STATE_HEADER;

1170

repeat_times++;

1171

if(repeat_times>EFUSE_REPEAT_THRESHOLD_){

1172

bContinual = false;

1173

bResult = false;

1174

}

1175

#endif

1176

1177

printk("EFUSE PG_STATE_HEADER-2\n");

1178

}

1179

1180

}

1181

1182

}

1183

else if(WriteState==PG_STATE_DATA)

1184

{

1185

printk("EFUSE PG_STATE_DATA\n");

1186

badworden = 0x0f;

1187

badworden = efuse_WordEnableDataWrite(dev,efuse_addr+1,target_pkt.word_en,target_pkt.data);

1188

if((badworden&0x0F)==0x0F)

1189

{

1190

bContinual = false;

1191

}

1192

else

1193

{

1194

efuse_addr = efuse_addr + (2*target_word_cnts) +1;

1195

1196

target_pkt.offset = offset;

1197

target_pkt.word_en= badworden;

1198

target_word_cnts = efuse_CalculateWordCnts(target_pkt.word_en);

1199

#if (EFUSE_ERROE_HANDLE == 1)

1200

WriteState=PG_STATE_HEADER;

1201

repeat_times++;

1202

if(repeat_times>EFUSE_REPEAT_THRESHOLD_){

1203

bContinual = false;

1204

bResult = false;

1205

}

1206

#endif

1207

printk("EFUSE PG_STATE_HEADER-3\n");

1208

}

1209

}

1210

}

1211

1212

1213

return true;

1214

}

1215

1216

1217

static void

1218

efuse_WordEnableDataRead( u8 word_en,u8 *sourdata,u8 *targetdata)

1219

{

1220

1221

1222

1223

if (!(word_en&BIT0))

1224

{

1225

targetdata[0] = sourdata[0];

1226

targetdata[1] = sourdata[1];

1227

}

1228

if (!(word_en&BIT1))

1229

{

1230

targetdata[2] = sourdata[2];

1231

targetdata[3] = sourdata[3];

1232

}

1233

if (!(word_en&BIT2))

1234

{

1235

targetdata[4] = sourdata[4];

1236

targetdata[5] = sourdata[5];

1237

}

1238

if (!(word_en&BIT3))

1239

{

1240

targetdata[6] = sourdata[6];

1241

targetdata[7] = sourdata[7];

1242

}

1243

}

1244

1245

1246

static u8

1247

efuse_WordEnableDataWrite( struct net_device* dev, u16 efuse_addr, u8 word_en, u8 *data)

1248

{

1249

u16 tmpaddr = 0;

1250

u16 start_addr = efuse_addr;

1251

u8 badworden = 0x0F;

1252

u8 tmpdata[8];

1253

1254

memset(tmpdata,0xff,PGPKT_DATA_SIZE);

1255

1256

1257

1258

if(!(word_en&BIT0))

1259

{

1260

tmpaddr = start_addr;

1261

efuse_OneByteWrite(dev,start_addr++, data[0]);

1262

efuse_OneByteWrite(dev,start_addr++, data[1]);

1263

1264

efuse_OneByteRead(dev,tmpaddr, &tmpdata[0]);

1265

efuse_OneByteRead(dev,tmpaddr+1, &tmpdata[1]);

1266

if((data[0]!=tmpdata[0])||(data[1]!=tmpdata[1])){

1267

badworden &= (~BIT0);

1268

}

1269

}

1270

if(!(word_en&BIT1))

1271

{

1272

tmpaddr = start_addr;

1273

efuse_OneByteWrite(dev,start_addr++, data[2]);

1274

efuse_OneByteWrite(dev,start_addr++, data[3]);

1275

1276

efuse_OneByteRead(dev,tmpaddr , &tmpdata[2]);

1277

efuse_OneByteRead(dev,tmpaddr+1, &tmpdata[3]);

1278

if((data[2]!=tmpdata[2])||(data[3]!=tmpdata[3])){

1279

badworden &=( ~BIT1);

1280

}

1281

}

1282

if(!(word_en&BIT2))

1283

{

1284

tmpaddr = start_addr;

1285

efuse_OneByteWrite(dev,start_addr++, data[4]);

1286

efuse_OneByteWrite(dev,start_addr++, data[5]);

1287

1288

efuse_OneByteRead(dev,tmpaddr, &tmpdata[4]);

1289

efuse_OneByteRead(dev,tmpaddr+1, &tmpdata[5]);

1290

if((data[4]!=tmpdata[4])||(data[5]!=tmpdata[5])){

1291

badworden &=( ~BIT2);

1292

}

1293

}

1294

if(!(word_en&BIT3))

1295

{

1296

tmpaddr = start_addr;

1297

efuse_OneByteWrite(dev,start_addr++, data[6]);

1298

efuse_OneByteWrite(dev,start_addr++, data[7]);

1299

1300

efuse_OneByteRead(dev,tmpaddr, &tmpdata[6]);

1301

efuse_OneByteRead(dev,tmpaddr+1, &tmpdata[7]);

1302

if((data[6]!=tmpdata[6])||(data[7]!=tmpdata[7])){

1303

badworden &=( ~BIT3);

1304

}

1305

}

1306

return badworden;

1307

}

1308

1309

1310

static void

1311

efuse_PowerSwitch(struct net_device* dev, u8 PwrState)

1312

{

1313

u8 tempval;

1314

if (PwrState == true)

1315

{

1316

tempval = read_nic_byte(dev, EFUSE_TEST+3);

1317

write_nic_byte(dev, EFUSE_TEST+3, (tempval | 0x80));

1318

1319

write_nic_byte(dev, EFUSE_CLK, 0x03);

1320

}

1321

else

1322

{

1323

tempval = read_nic_byte(dev, EFUSE_TEST+3);

1324

write_nic_byte(dev, EFUSE_TEST+3, (tempval & 0x7F));

1325

1326

write_nic_byte(dev, EFUSE_CLK, 0x02);

1327

}

1328

1329

} /* efuse_PowerSwitch */

1330

1331

1332

static u16

1333

efuse_GetCurrentSize(struct net_device* dev)

1334

{

1335

bool bContinual = true;

1336

1337

u16 efuse_addr = 0;

1338

u8 hoffset=0,hworden=0;

1339

u8 efuse_data,word_cnts=0;

1340

1341

1342

while ( bContinual &&

1343

efuse_OneByteRead(dev, efuse_addr ,&efuse_data) &&

1344

(efuse_addr < EFUSE_MAX_SIZE) )

1345

{

1346

if(efuse_data!=0xFF)

1347

{

1348

hoffset = (efuse_data>>4) & 0x0F;

1349

hworden = efuse_data & 0x0F;

1350

word_cnts = efuse_CalculateWordCnts(hworden);

1351

efuse_addr = efuse_addr + (word_cnts*2)+1;

1352

}

1353

else

1354

{

1355

bContinual = false ;

1356

}

1357

}

1358

1359

1360

return efuse_addr;

1361

1362

}

1363

1364

1365

static u8

1366

efuse_CalculateWordCnts(u8 word_en)

1367

{

1368

u8 word_cnts = 0;

1369

if(!(word_en & BIT0)) word_cnts++;

1370

if(!(word_en & BIT1)) word_cnts++;

1371

if(!(word_en & BIT2)) word_cnts++;

1372

if(!(word_en & BIT3)) word_cnts++;

1373

return word_cnts;

1374

}

1375

1376

1377

#if 0

1378

static void efuse_ResetLoader(struct net_device* dev)

1379

{

1380

u16 tmpU2b;

1381

1382

tmpU2b = read_nic_word(dev, SYS_FUNC_EN);

1383

write_nic_word(dev, SYS_FUNC_EN, (tmpU2b&~(BIT12)));

1384

mdelay(10);

1385

write_nic_word(dev, SYS_FUNC_EN, (tmpU2b|BIT12));

1386

mdelay(10);

1387

1388

}

1389

#endif

1390

1391

#ifdef TO_DO_LIST

1392

extern bool

1393

EFUSE_ProgramMap(struct net_device* dev, char* pFileName,u8 TableType)

1394

{

1395

struct r8192_priv *priv = rtllib_priv(dev);

1396

s4Byte nLinesRead, ithLine;

1397

RT_STATUS rtStatus = RT_STATUS_SUCCESS;

1398

char* szLine;

1399

u32 u4bRegValue, u4RegMask;

1400

u32 u4bMove;

1401

u16 index = 0;

1402

u16 i;

1403

u8 eeprom[HWSET_MAX_SIZE_92S];

1404

1405

rtStatus = PlatformReadFile(

1406

dev,

1407

pFileName,

1408

(u8*)(priv->BufOfLines),

1409

MAX_LINES_HWCONFIG_TXT,

1410

MAX_BYTES_LINE_HWCONFIG_TXT,

1411

&nLinesRead

1412

);

1413

1414

if(rtStatus == RT_STATUS_SUCCESS)

1415

{

1416

memcp(pHalData->BufOfLines3, pHalData->BufOfLines,

1417

nLinesRead*MAX_BYTES_LINE_HWCONFIG_TXT);

1418

pHalData->nLinesRead3 = nLinesRead;

1419

}

1420

1421

if(rtStatus == RT_STATUS_SUCCESS)

1422

{

1423

printk("szEepromFile(): read %s ok\n", pFileName);

1424

for(ithLine = 0; ithLine < nLinesRead; ithLine++)

1425

{

1426

szLine = pHalData->BufOfLines[ithLine];

1427

printk("Line-%d String =%s\n", ithLine, szLine);

1428

1429

if(!IsCommentString(szLine))

1430

{

1431

for (i = 0; i < 8; i++)

1432

{

1433

u32 j;

1434

1435

efuse_ParsingMap(szLine, &u4bRegValue, &u4bMove);

1436

1437

szLine += u4bMove;

1438

eeprom[index++] = (u8)(u4bRegValue&0xff);

1439

eeprom[index++] = (u8)((u4bRegValue>>8)&0xff);

1440

1441

printk("Addr-%d = %x\n", (ithLine*8+i), u4bRegValue);

1442

}

1443

}

1444

1445

}

1446

1447

}

1448

else

1449

{

1450

printk("szEepromFile(): Fail read%s\n", pFileName);

1451

return RT_STATUS_FAILURE;

1452

}

1453

1454

1455

1456

if (TableType == 1)

1457

{

1458

efuse_WriteAllMap(dev, eeprom, HWSET_MAX_SIZE_92S);

1459

}

1460

else

1461

{

1462

for (i = 0; i < HWSET_MAX_SIZE_92S; i++)

1463

EFUSE_ShadowWrite(dev, 1, i, (u32)eeprom[i]);

1464

}

1465

1466

return rtStatus;

1467

} /* EFUSE_ProgramMap */

1468

1469

#endif

1470

1471

bool IsHexDigit( char chTmp)

1472

{

1473

if( (chTmp >= '0' && chTmp <= '9') ||

1474

(chTmp >= 'a' && chTmp <= 'f') ||

1475

(chTmp >= 'A' && chTmp <= 'F') )

1476

{

1477

return true;

1478

}

1479

else

1480

{

1481

return false;

1482

}

1483

}

1484

1485

u32 MapCharToHexDigit(char chTmp)

1486

{

1487

if(chTmp >= '0' && chTmp <= '9')

1488

return (chTmp - '0');

1489

else if(chTmp >= 'a' && chTmp <= 'f')

1490

return (10 + (chTmp - 'a'));

1491

else if(chTmp >= 'A' && chTmp <= 'F')

1492

return (10 + (chTmp - 'A'));

1493

else

1494

return 0;

1495

}

1496

1497

#ifdef TO_DO_LIST

1498

static bool

1499

efuse_ParsingMap(char* szStr,u32* pu4bVal,u32* pu4bMove)

1500

{

1501

char* szScan = szStr;

1502

1503

if(szStr == NULL || pu4bVal == NULL || pu4bMove == NULL)

1504

{

1505

return false;

1506

}

1507

1508

*pu4bMove = 0;

1509

*pu4bVal = 0;

1510

1511

while( *szScan != '\0' &&

1512

(*szScan == ' ' || *szScan == '\t') )

1513

{

1514

szScan++;

1515

(*pu4bMove)++;

1516

}

1517

1518

if(!IsHexDigit(*szScan))

1519

{

1520

return false;

1521

}

1522

1523

do

1524

{

1525

(*pu4bVal) <<= 4;

1526

*pu4bVal += MapCharToHexDigit(*szScan);

1527

1528

szScan++;

1529

(*pu4bMove)++;

1530

} while(IsHexDigit(*szScan));

1531

1532

return true;

1533

1534

} /* efuse_ParsingMap */

1535

#endif

1536

1537

int efuse_one_byte_rw(struct net_device* dev, u8 bRead, u16 addr, u8 *data)

1538

{

1539

u32 bResult;

1540

u8 tmpidx = 0;

1541

u8 tmpv8=0;

1542

1543

1544

write_nic_byte(dev, EFUSE_CTRL+1, (u8)(addr&0xff));

1545

tmpv8 = ((u8)((addr>>8) &0x03) ) | (read_nic_byte(dev, EFUSE_CTRL+2)&0xFC );

1546

write_nic_byte(dev, EFUSE_CTRL+2, tmpv8);

1547

1548

if(true==bRead){

1549

1550

write_nic_byte(dev, EFUSE_CTRL+3, 0x72);

1551

1552

while(!(0x80 & read_nic_byte(dev, EFUSE_CTRL+3)) && (tmpidx<100) ){

1553

tmpidx++;

1554

}

1555

if(tmpidx<100){

1556

*data=read_nic_byte(dev, EFUSE_CTRL);

1557

bResult = true;

1558

}

1559

else

1560

{

1561

*data = 0;

1562

bResult = false;

1563

}

1564

1565

}

1566

else{

1567

write_nic_byte(dev, EFUSE_CTRL, *data);

1568

1569

write_nic_byte(dev, EFUSE_CTRL+3, 0xF2);

1570

1571

while((0x80 & read_nic_byte(dev, EFUSE_CTRL+3)) && (tmpidx<100) ){

1572

tmpidx++;

1573

}

1574

if(tmpidx<100)

1575

{

1576

*data=read_nic_byte(dev, EFUSE_CTRL);

1577

bResult = true;

1578

}

1579

else

1580

{

1581

*data = 0;

1582

bResult = false;

1583

}

1584

1585

}

1586

return bResult;

1587

}

1588

void efuse_access(struct net_device* dev, u8 bRead,u16 start_addr, u8 cnts, u8 *data)

1589

{

1590

u8 efuse_clk_ori,efuse_clk_new;

1591

u32 i = 0;

1592

1593

if(start_addr>0x200) return;

1594

efuse_clk_ori = read_nic_byte(dev,SYS_FUNC_EN+1);

1595

efuse_clk_new = efuse_clk_ori|0x20;

1596

1597

if(efuse_clk_new!= efuse_clk_ori){

1598

write_nic_byte(dev, SYS_FUNC_EN+1, efuse_clk_new);

1599

}

1600

#ifdef _POWERON_DELAY_

1601

mdelay(10);

1602

#endif

1603

write_nic_byte(dev, EFUSE_TEST+3, (read_nic_byte(dev, EFUSE_TEST+3)|0x80));

1604

write_nic_byte(dev, EFUSE_CLK_CTRL, (read_nic_byte(dev, EFUSE_CLK_CTRL)|0x03));

1605

1606

#ifdef _PRE_EXECUTE_READ_CMD_

1607

{

1608

unsigned char tmpdata;

1609

efuse_OneByteRead(dev, 0,&tmpdata);

1610

}

1611

#endif

1612

1613

for(i=0;i<cnts;i++){

1614

efuse_one_byte_rw(dev,bRead, start_addr+i , data+i);

1615

}

1616

write_nic_byte(dev, EFUSE_TEST+3, read_nic_byte(dev, EFUSE_TEST+3)&0x7f);

1617

write_nic_byte(dev, EFUSE_CLK_CTRL, read_nic_byte(dev, EFUSE_CLK_CTRL)&0xfd);

1618

1619

if(efuse_clk_new != efuse_clk_ori) write_nic_byte(dev, 0x10250003, efuse_clk_ori);

1620

1621

}

1622

1623

#ifdef TO_DO_LIST

1624

static void efuse_reg_ctrl(struct net_device* dev, u8 bPowerOn)

1625

{

1626

if(true==bPowerOn){

1627

write_nic_byte(dev, SYS_FUNC_EN+1, read_nic_byte(dev,SYS_FUNC_EN+1)|0x20);

1628

#ifdef _POWERON_DELAY_

1629

mdelay(10);

1630

#endif

1631

write_nic_byte(dev, EFUSE_TEST+4, (read_nic_byte(dev, EFUSE_TEST+4)|0x80));

1632

write_nic_byte(dev, EFUSE_CLK_CTRL, (read_nic_byte(dev, EFUSE_CLK_CTRL)|0x03));

1633

#ifdef _PRE_EXECUTE_READ_CMD_

1634

{

1635

unsigned char tmpdata;

1636

efuse_OneByteRead(dev, 0,&tmpdata);

1637

}

1638

1639

#endif

1640

}

1641

else{

1642

write_nic_byte(dev, EFUSE_TEST+4, read_nic_byte(dev, EFUSE_TEST+4)&0x7f);

1643

write_nic_byte(dev, EFUSE_CLK_CTRL, read_nic_byte(dev, EFUSE_CLK_CTRL)&0xfd);

1644

1645

}

1646

1647

1648

}

1649

#endif

1650

1651

void efuse_read_data(struct net_device* dev,u8 efuse_read_item,u8 *data,u32 data_size)

1652

{

1653

u8 offset, word_start,byte_start,byte_cnts;

1654

u8 efusedata[EFUSE_REAL_CONTENT_LEN];

1655

u8 *tmpdata = NULL;

1656

1657

u8 pg_pkt_cnts ;

1658

1659

u8 tmpidx;

1660

u8 pg_data[8];

1661

1662

if(efuse_read_item> (sizeof(RTL8712_SDIO_EFUSE_TABLE)/sizeof(EFUSE_MAP))){

1663

return ;

1664

}

1665

1666

offset = RTL8712_SDIO_EFUSE_TABLE[efuse_read_item].offset ;

1667

word_start = RTL8712_SDIO_EFUSE_TABLE[efuse_read_item].word_start;

1668

byte_start = RTL8712_SDIO_EFUSE_TABLE[efuse_read_item].byte_start;

1669

byte_cnts = RTL8712_SDIO_EFUSE_TABLE[efuse_read_item].byte_cnts;

1670

1671

if(data_size!=byte_cnts){

1672

return;

1673

}

1674

1675

pg_pkt_cnts = (byte_cnts /PGPKT_DATA_SIZE) +1;

1676

1677

if(pg_pkt_cnts > 1){

1678

tmpdata = efusedata;

1679

1680

if(tmpdata!=NULL)

1681

{

1682

memset(tmpdata,0xff,pg_pkt_cnts*PGPKT_DATA_SIZE);

1683

1684

for(tmpidx=0;tmpidx<pg_pkt_cnts;tmpidx++)

1685

{

1686

memset(pg_data,0xff,PGPKT_DATA_SIZE);

1687

if(true== efuse_PgPacketRead(dev,offset+tmpidx,pg_data))

1688

{

1689

memcpy(tmpdata+(PGPKT_DATA_SIZE*tmpidx),pg_data,PGPKT_DATA_SIZE);

1690

}

1691

}

1692

memcpy(data,(tmpdata+ (2*word_start)+byte_start ),data_size);

1693

}

1694

}

1695

else

1696

{

1697

memset(pg_data,0xff,PGPKT_DATA_SIZE);

1698

if(true==efuse_PgPacketRead(dev,offset,pg_data)){

1699

memcpy(data,pg_data+ (2*word_start)+byte_start ,data_size);

1700

}

1701

}

1702

1703

}

1704

void efuse_write_data(struct net_device* dev,u8 efuse_write_item,u8 *data,u32 data_size,u32 bWordUnit)

1705

{

1706

u8 offset, word_start,byte_start,byte_cnts;

1707

u8 word_en = 0x0f,word_cnts;

1708

u8 pg_pkt_cnts ;

1709

1710

u8 tmpidx,tmpbitmask;

1711

u8 pg_data[8],tmpbytes=0;

1712

1713

if(efuse_write_item> (sizeof(RTL8712_SDIO_EFUSE_TABLE)/sizeof(EFUSE_MAP))){

1714

return ;

1715

}

1716

1717

offset = RTL8712_SDIO_EFUSE_TABLE[efuse_write_item].offset ;

1718

word_start = RTL8712_SDIO_EFUSE_TABLE[efuse_write_item].word_start;

1719

byte_start = RTL8712_SDIO_EFUSE_TABLE[efuse_write_item].byte_start;

1720

byte_cnts = RTL8712_SDIO_EFUSE_TABLE[efuse_write_item].byte_cnts;

1721

1722

if(data_size > byte_cnts){

1723

return;

1724

}

1725

pg_pkt_cnts = (byte_cnts /PGPKT_DATA_SIZE) +1;

1726

word_cnts = byte_cnts /2 ;

1727

1728

if(byte_cnts %2){

1729

word_cnts+=1;

1730

}

1731

if((byte_start==1)||((byte_cnts%2)==1)){

1732

1733

if((efuse_write_item==EFUSE_F0CIS)||(efuse_write_item==EFUSE_F1CIS)){

1734

memset(pg_data,0xff,PGPKT_DATA_SIZE);

1735

efuse_PgPacketRead(dev,offset,pg_data);

1736

1737

if(efuse_write_item==EFUSE_F0CIS){

1738

word_en = 0x07;

1739

memcpy(pg_data+word_start*2+byte_start,data,sizeof(u8)*2);

1740

efuse_PgPacketWrite(dev,offset,word_en,pg_data+(word_start*2));

1741

1742

word_en = 0x00;

1743

efuse_PgPacketWrite(dev,(offset+1),word_en,data+2);

1744

1745

word_en = 0x00;

1746

efuse_PgPacketRead(dev,offset+2,pg_data);

1747

memcpy(pg_data,data+2+8,sizeof(u8)*7);

1748

1749

efuse_PgPacketWrite(dev,(offset+2),word_en,pg_data);

1750

}

1751

else if(efuse_write_item==EFUSE_F1CIS){

1752

word_en = 0x07;

1753

efuse_PgPacketRead(dev,offset,pg_data);

1754

pg_data[7] = data[0];

1755

efuse_PgPacketWrite(dev,offset,word_en,pg_data+(word_start*2));

1756

1757

word_en = 0x00;

1758

for(tmpidx = 0 ;tmpidx<(word_cnts/4);tmpidx++){

1759

efuse_PgPacketWrite(dev,(offset+1+tmpidx),word_en,data+1+(tmpidx*PGPKT_DATA_SIZE));

1760

}

1761

}

1762

1763

}

1764

else{

1765

memset(pg_data,0xff,PGPKT_DATA_SIZE);

1766

if((efuse_write_item==EFUSE_SDIO_SETTING)||(efuse_write_item==EFUSE_CCCR)){

1767

word_en = 0x0e ;

1768

tmpbytes = 2;

1769

}

1770

else if(efuse_write_item == EFUSE_SDIO_MODE){

1771

word_en = 0x0d ;

1772

tmpbytes = 2;

1773

}

1774

else if(efuse_write_item == EFUSE_OCR){

1775

word_en = 0x09 ;

1776

tmpbytes = 4;

1777

}

1778

else if((efuse_write_item == EFUSE_EEPROM_VER)||(efuse_write_item==EFUSE_CHAN_PLAN)){

1779

word_en = 0x07 ;

1780

tmpbytes = 2;

1781

}

1782

if(bWordUnit==true){

1783

memcpy(pg_data+word_start*2 ,data,sizeof(u8)*tmpbytes);

1784

}

1785

else{

1786

efuse_PgPacketRead(dev,offset,pg_data);

1787

memcpy(pg_data+(2*word_start)+byte_start,data,sizeof(u8)*byte_cnts);

1788

}

1789

1790

efuse_PgPacketWrite(dev,offset,word_en,pg_data+(word_start*2));

1791

1792

}

1793

1794

}

1795

else if(pg_pkt_cnts>1){

1796

if(word_start==0){

1797

word_en = 0x00;

1798

for(tmpidx = 0 ;tmpidx<(word_cnts/4);tmpidx++)

1799

{

1800

efuse_PgPacketWrite(dev,(offset+tmpidx),word_en,data+(tmpidx*PGPKT_DATA_SIZE));

1801

}

1802

word_en = 0x0f;

1803

for(tmpidx= 0; tmpidx<(word_cnts%4) ; tmpidx++)

1804

{

1805

tmpbitmask =tmpidx;

1806

word_en &= (~(EFUSE_BIT(tmpbitmask)));

1807

}

1808

efuse_PgPacketWrite(dev,offset+(word_cnts/4),word_en,data+((word_cnts/4)*PGPKT_DATA_SIZE));

1809

}else

1810

{

1811

1812

}

1813

}

1814

else{

1815

word_en = 0x0f;

1816

for(tmpidx= 0; tmpidx<word_cnts ; tmpidx++)

1817

{

1818

tmpbitmask = word_start + tmpidx ;

1819

word_en &= (~(EFUSE_BIT(tmpbitmask)));

1820

}

1821

efuse_PgPacketWrite(dev,offset,word_en,data);

1822

}

1823

1824

}

1825

1826

void efuset_test_func_read(struct net_device* dev)

1827

{

1828

u8 chipid[2];

1829

u8 ocr[3];

1830

u8 macaddr[6];

1831

u8 txpowertable[28];

1832

1833

memset(chipid,0,sizeof(u8)*2);

1834

efuse_read_data(dev,EFUSE_CHIP_ID,chipid,sizeof(chipid));

1835

1836

memset(ocr,0,sizeof(u8)*3);

1837

efuse_read_data(dev,EFUSE_CCCR,ocr,sizeof(ocr));

1838

1839

memset(macaddr,0,sizeof(u8)*6);

1840

efuse_read_data(dev,EFUSE_MAC_ADDR,macaddr,sizeof(macaddr));

1841

1842

memset(txpowertable,0,sizeof(u8)*28);

1843

efuse_read_data(dev,EFUSE_TXPW_TAB,txpowertable,sizeof(txpowertable));

1844

}

1845

1846

void efuset_test_func_write(struct net_device* dev)

1847

{

1848

u32 bWordUnit = true;

1849

u8 CCCR=0x02,SDIO_SETTING = 0xFF;

1850

u8 tmpdata[2];

1851

1852

u8 macaddr[6] = {0x00,0xe0,0x4c,0x87,0x12,0x66};

1853

efuse_write_data(dev,EFUSE_MAC_ADDR,macaddr,sizeof(macaddr),bWordUnit);

1854

1855

bWordUnit = false;

1856

efuse_write_data(dev,EFUSE_CCCR,&CCCR,sizeof(u8),bWordUnit);

1857

1858

bWordUnit = false;

1859

efuse_write_data(dev,EFUSE_SDIO_SETTING,&SDIO_SETTING,sizeof(u8),bWordUnit);

1860

1861

bWordUnit = true;

1862

tmpdata[0] =SDIO_SETTING ;

1863

tmpdata[1] =CCCR ;

1864

efuse_write_data(dev,EFUSE_SDIO_SETTING,tmpdata,sizeof(tmpdata),bWordUnit);

1865

1866

}

1867

#endif