1 #include <stdio.h>
2 #include <unistd.h>
3 #include <stdlib.h>
4
5 #include "RKComm.h"
6 #include "RKLog.h"
7 #include "RKAndroidDevice.h"
8
CRKComm(CRKLog * pLog)9 CRKComm::CRKComm(CRKLog *pLog)
10 {
11 m_log = pLog;
12 m_bEmmc = false;
13 m_hDev = m_hLbaDev = -1;
14 }
~CRKComm()15 CRKComm::~CRKComm()
16 {
17 }
18
CRKUsbComm(CRKLog * pLog)19 CRKUsbComm::CRKUsbComm(CRKLog *pLog): CRKComm(pLog)
20 {
21 //char bootmode[100];
22 //property_get("ro.bootmode", bootmode, "unknown");
23 //if(!strcmp(bootmode, "emmc"))
24 // m_bEmmc = true;
25 //else
26 // m_bEmmc = false;
27 char *emmc_point = getenv(EMMC_POINT_NAME);
28 m_hLbaDev = open(emmc_point, O_RDWR | O_SYNC, 0);
29 if (m_hLbaDev < 0)
30 {
31 if (pLog)
32 {
33 pLog->Record(_T("INFO:is nand devices..."));
34 }
35 m_bEmmc = false;
36 }
37 else
38 {
39 if (pLog)
40 {
41 pLog->Record(_T("INFO:is emmc devices..."));
42 }
43 m_bEmmc = true;
44 close(m_hLbaDev);
45 }
46
47 m_log = pLog;
48
49 if (m_bEmmc)
50 {
51 if (pLog)
52 {
53 pLog->Record(_T("INFO:CRKUsbComm-->is emmc."));
54 }
55 m_hDev = open(EMMC_DRIVER_DEV_VENDOR, O_RDWR, 0);
56 if (m_hDev < 0)
57 {
58 if (pLog)
59 {
60 pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%s"), EMMC_DRIVER_DEV_VENDOR, strerror(errno));
61 pLog->Record(_T("ERROR:CRKUsbComm-->try to read %s."), EMMC_DRIVER_DEV);
62 }
63
64 m_hDev = open(EMMC_DRIVER_DEV, O_RDWR, 0);
65 if (m_hDev < 0)
66 {
67 if (pLog)
68 {
69 pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%s"), EMMC_DRIVER_DEV, strerror(errno));
70 pLog->Record(_T("ERROR:CRKUsbComm-->please to check drmboot.ko."));
71 }
72 }
73 else
74 {
75 if (pLog)
76 {
77 pLog->Record(_T("INFO:CRKUsbComm-->%s=%d"), EMMC_DRIVER_DEV, m_hDev);
78 }
79 }
80 }
81 else
82 {
83 if (pLog)
84 {
85 pLog->Record(_T("INFO:CRKUsbComm-->%s=%d"), EMMC_DRIVER_DEV_VENDOR, m_hDev);
86 }
87 }
88 //get EMMC_DRIVER_DEV_LBA from
89 m_hLbaDev = open(emmc_point, O_RDWR | O_SYNC, 0);
90 if (m_hLbaDev < 0)
91 {
92 if (pLog)
93 {
94 pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%d"), emmc_point, errno);
95 }
96 }
97 else
98 {
99 if (pLog)
100 {
101 pLog->Record(_T("INFO:CRKUsbComm-->%s=%d"), emmc_point, m_hLbaDev);
102 }
103 }
104 }
105 else
106 {
107 if (pLog)
108 {
109 pLog->Record(_T("INFO:CRKUsbComm-->is nand."));
110 }
111 m_hDev = open(NAND_DRIVER_DEV_VENDOR, O_RDWR, 0);
112 if (m_hDev < 0)
113 {
114 if (pLog)
115 {
116 pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%d"), NAND_DRIVER_DEV_VENDOR, strerror(errno));
117 pLog->Record(_T("ERROR:CRKUsbComm-->try to read from %s."), NAND_DRIVER_DEV_VENDOR);
118 }
119 m_hDev = open(NAND_DRIVER_DEV, O_RDWR, 0);
120 if (pLog)
121 {
122 pLog->Record(_T("ERROR:CRKUsbComm-->open %s failed,err=%d"), NAND_DRIVER_DEV, strerror(errno));
123 }
124 else
125 {
126 if (pLog)
127 {
128 pLog->Record(_T("INFO:CRKUsbComm-->%s=%d"), NAND_DRIVER_DEV, m_hDev);
129 }
130 }
131 }
132 else
133 {
134 if (pLog)
135 {
136 pLog->Record(_T("INFO:CRKUsbComm-->%s=%d"), NAND_DRIVER_DEV_VENDOR, m_hDev);
137 }
138 }
139 }
140
141 }
RKU_ReopenLBAHandle()142 void CRKUsbComm::RKU_ReopenLBAHandle()
143 {
144 if (m_bEmmc)
145 {
146 return;
147 }
148 if (m_hLbaDev > 0)
149 {
150 close(m_hLbaDev);
151 m_hLbaDev = -1;
152 }
153 // if (m_bEmmc)
154 // {
155 // m_hLbaDev= open(EMMC_DRIVER_DEV_LBA,O_RDWR|O_SYNC,0);
156 // if (m_hLbaDev<0)
157 // {
158 // if (m_log)
159 // m_log->Record(_T("ERROR:RKU_ReopenLBAHandle-->open %s failed,err=%d"),EMMC_DRIVER_DEV_LBA,errno);
160 // }
161 // else
162 // {
163 // if (m_log)
164 // m_log->Record(_T("INFO:RKU_ReopenLBAHandle-->%s=%d"),EMMC_DRIVER_DEV_LBA,m_hLbaDev);
165 // }
166
167 // }
168 // else
169 // {
170 m_hLbaDev = open(NAND_DRIVER_DEV_LBA, O_RDWR | O_SYNC, 0);
171 if (m_hLbaDev < 0)
172 {
173 if (m_log)
174 {
175 m_log->Record(_T("ERROR:RKU_ReopenLBAHandle-->open %s failed,err=%d"), NAND_DRIVER_DEV_LBA, errno);
176 }
177 }
178 else
179 {
180 if (m_log)
181 {
182 m_log->Record(_T("INFO:RKU_ReopenLBAHandle-->%s=%d"), NAND_DRIVER_DEV_LBA, m_hLbaDev);
183 }
184 }
185 // }
186
187 }
RKU_ShowNandLBADevice()188 int CRKUsbComm::RKU_ShowNandLBADevice()
189 {
190 if (m_bEmmc)
191 {
192 return ERR_SUCCESS;
193 }
194 BYTE blockState[64];
195 memset(blockState, 0, 64);
196 int iRet;
197 iRet = RKU_TestBadBlock(0, 0, MAX_TEST_BLOCKS, blockState);
198 if (iRet != ERR_SUCCESS)
199 {
200 if (m_log)
201 {
202 m_log->Record(_T("ERROR:RKU_ShowNandLBADevice-->RKU_TestBadBlock failed,ret=%d"), iRet);
203 }
204 }
205 return iRet;
206 }
207
RKU_IsEmmcFlash()208 bool CRKUsbComm::RKU_IsEmmcFlash()
209 {
210 return m_bEmmc ? true : false;
211 }
212
~CRKUsbComm()213 CRKUsbComm::~CRKUsbComm()
214 {
215 if (m_hDev > 0)
216 {
217 close(m_hDev);
218 }
219 if (m_hLbaDev > 0)
220 {
221 // if (!m_bEmmc)
222 // {
223 // CtrlNandLbaRead(false);
224 // CtrlNandLbaWrite(false);
225 // }
226 close(m_hLbaDev);
227 }
228 }
229
RKU_EraseBlock(BYTE ucFlashCS,DWORD dwPos,DWORD dwCount,BYTE ucEraseType)230 int CRKUsbComm::RKU_EraseBlock(BYTE ucFlashCS, DWORD dwPos, DWORD dwCount, BYTE ucEraseType)
231 {
232 return ERR_SUCCESS;
233 }
RKU_ReadChipInfo(BYTE * lpBuffer)234 int CRKUsbComm::RKU_ReadChipInfo(BYTE *lpBuffer)
235 {
236 return ERR_SUCCESS;
237 }
RKU_ReadFlashID(BYTE * lpBuffer)238 int CRKUsbComm::RKU_ReadFlashID(BYTE *lpBuffer)
239 {
240 return ERR_SUCCESS;
241 }
242
rknand_print_hex_data(char * s,unsigned int * buf,unsigned int len)243 void rknand_print_hex_data(char *s, unsigned int *buf, unsigned int len)
244 {
245 unsigned int i, j, count;
246
247 printf("%s\n", s);
248 for (i = 0; i < len; i += 4)
249 {
250 printf("%08x %08x %08x %08x\n", buf[i], buf[i + 1], buf[i + 2], buf[i + 3]);
251 }
252 }
253
254
RKU_ReadFlashInfo(BYTE * lpBuffer,UINT * puiRead)255 int CRKUsbComm::RKU_ReadFlashInfo(BYTE *lpBuffer, UINT *puiRead)
256 {
257 long long ret;
258
259 #if 0 //close by chad.ma
260 if (m_hDev < 0)
261 {
262 return ERR_DEVICE_OPEN_FAILED;
263 }
264
265 ret = ioctl(m_hDev, GET_FLASH_INFO_IO, lpBuffer);
266 if (ret)
267 {
268 if (m_log)
269 {
270 m_log->Record(_T("ERROR:RKU_ReadFlashInfo ioctl failed,err=%d"), errno);
271 }
272 return ERR_FAILED;
273 }
274 *puiRead = 11;
275 #else
276 /////////////////////////////////////////////////////////////////
277 // get flashsize directly
278 m_log->Record(_T("INFO: m_bEmmc = %d, m_hLbaDev = %d"), m_bEmmc, m_hLbaDev);
279
280 if (m_hLbaDev < 0)
281 {
282 m_hLbaDev = open(NAND_DRIVER_DEV_LBA, O_RDWR | O_SYNC, 0);
283 if (m_hLbaDev < 0)
284 {
285 if (m_log)
286 {
287 m_log->Record(_T("ERROR:RKU_ReadFlashInfo-->open %s failed,err=%d"), NAND_DRIVER_DEV_LBA, errno);
288 }
289 return ERR_FAILED;
290 }
291 else
292 {
293 if (m_log)
294 {
295 m_log->Record(_T("INFO:RKU_ReadFlashInfo-->open %s ok,handle=%d"), NAND_DRIVER_DEV_LBA, m_hLbaDev);
296 }
297
298 ret = lseek64(m_hLbaDev, 0, SEEK_END);
299
300 if (ret < 0)
301 {
302 if (m_log)
303 {
304 m_log->Record(_T("ERROR:RKU_ReadFlashInfo-->get %s file length fail"), NAND_DRIVER_DEV_LBA);
305 }
306 return ERR_FAILED;
307 }
308 else
309 {
310 char str[20] = {0};
311 lseek64(m_hLbaDev, 0, SEEK_SET); //reset the cfo to begin
312 snprintf(str, sizeof(str), "%d", ret / 1024);
313 *(UINT *)lpBuffer = (ret / 1024);
314 }
315 }
316 }
317 else
318 {
319 ret = lseek64(m_hLbaDev, 0, SEEK_END);
320 m_log->Record(_T("INFO: lseek64 result = %lld"), ret);
321 if (ret < 0)
322 {
323 if (m_log)
324 {
325 if (m_bEmmc)
326 m_log->Record(_T("ERROR:RKU_ReadFlashInfo-->get %s file length fail"),
327 getenv(EMMC_POINT_NAME));
328 else
329 m_log->Record(_T("ERROR:RKU_ReadFlashInfo-->get %s file length fail"),
330 NAND_DRIVER_DEV_LBA);
331 }
332 return ERR_FAILED;
333 }
334 else
335 {
336 char str[20] = {0};
337 lseek64(m_hLbaDev, 0, SEEK_SET); //reset the cfo to begin
338 snprintf(str, sizeof(str), "%d", ret / 1024);
339 *(UINT *)lpBuffer = (ret / 1024);
340 }
341 }
342 #endif
343 return ERR_SUCCESS;
344 }
RKU_ReadLBA(DWORD dwPos,DWORD dwCount,BYTE * lpBuffer,BYTE bySubCode)345 int CRKUsbComm::RKU_ReadLBA(DWORD dwPos, DWORD dwCount, BYTE *lpBuffer, BYTE bySubCode)
346 {
347 long long ret;
348 long long dwPosBuf;
349 if (m_hLbaDev < 0)
350 {
351 if (!m_bEmmc)
352 {
353 m_hLbaDev = open(NAND_DRIVER_DEV_LBA, O_RDWR | O_SYNC, 0);
354 if (m_hLbaDev < 0)
355 {
356 if (m_log)
357 {
358 m_log->Record(_T("ERROR:RKU_ReadLBA-->open %s failed,err=%d"), NAND_DRIVER_DEV_LBA, errno);
359 }
360 return ERR_DEVICE_OPEN_FAILED;
361 }
362 else
363 {
364 if (m_log)
365 {
366 m_log->Record(_T("INFO:RKU_ReadLBA-->open %s ok,handle=%d"), NAND_DRIVER_DEV_LBA, m_hLbaDev);
367 }
368 }
369 }
370 else
371 {
372 return ERR_DEVICE_OPEN_FAILED;
373 }
374 }
375 if (m_bEmmc && !CRKAndroidDevice::bGptFlag)
376 {
377 dwPos += 8192;
378 }
379
380 dwPosBuf = dwPos;
381
382 ret = lseek64(m_hLbaDev, (off64_t)dwPosBuf * 512, SEEK_SET);
383 if (ret < 0)
384 {
385 if (m_log)
386 {
387 m_log->Record(_T("ERROR:RKU_ReadLBA seek failed,err=%d,ret=%lld."), errno, ret);
388 m_log->Record(_T("the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf * 512);
389 }
390 return ERR_FAILED;
391 }
392 ret = read(m_hLbaDev, lpBuffer, dwCount * 512);
393 if (ret != dwCount * 512)
394 {
395 if (m_log)
396 {
397 m_log->Record(_T("ERROR:RKU_ReadLBA read failed,err=%d"), errno);
398 }
399 return ERR_FAILED;
400 }
401 return ERR_SUCCESS;
402 }
RKU_ReadSector(DWORD dwPos,DWORD dwCount,BYTE * lpBuffer)403 int CRKUsbComm::RKU_ReadSector(DWORD dwPos, DWORD dwCount, BYTE *lpBuffer)
404 {
405 int ret;
406 if (m_hDev < 0)
407 {
408 return ERR_DEVICE_OPEN_FAILED;
409 }
410 DWORD *pOffsetSec = (DWORD *)(lpBuffer);
411 DWORD *pCountSec = (DWORD *)(lpBuffer + 4);
412 *pOffsetSec = dwPos;
413 *pCountSec = dwCount;
414 ret = ioctl(m_hDev, READ_SECTOR_IO, lpBuffer);
415 if (ret)
416 {
417 if (m_log)
418 {
419 m_log->Record(_T("ERROR:RKU_ReadSector failed,err=%d"), errno);
420 }
421 return ERR_FAILED;
422 }
423 return ERR_SUCCESS;
424 }
RKU_ResetDevice(BYTE bySubCode)425 int CRKUsbComm::RKU_ResetDevice(BYTE bySubCode)
426 {
427 return ERR_SUCCESS;
428 }
429
RKU_TestBadBlock(BYTE ucFlashCS,DWORD dwPos,DWORD dwCount,BYTE * lpBuffer)430 int CRKUsbComm::RKU_TestBadBlock(BYTE ucFlashCS, DWORD dwPos, DWORD dwCount, BYTE *lpBuffer)
431 {
432 int ret;
433 if (m_hDev < 0)
434 {
435 return ERR_DEVICE_OPEN_FAILED;
436 }
437 ret = ioctl(m_hDev, GET_BAD_BLOCK_IO, lpBuffer);
438 if (ret)
439 {
440 if (m_log)
441 {
442 m_log->Record(_T("ERROR:RKU_TestBadBlock failed,err=%d"), errno);
443 }
444 return ERR_FAILED;
445 }
446 if (m_log)
447 {
448 string strOutput;
449 m_log->PrintBuffer(strOutput, lpBuffer, 64);
450 m_log->Record(_T("INFO:BadBlockState:\r\n%s"), strOutput.c_str());
451 }
452 return ERR_SUCCESS;
453 }
RKU_TestDeviceReady(DWORD * dwTotal,DWORD * dwCurrent,BYTE bySubCode)454 int CRKUsbComm::RKU_TestDeviceReady(DWORD *dwTotal, DWORD *dwCurrent, BYTE bySubCode)
455 {
456 return ERR_DEVICE_READY;
457 }
RKU_WriteLBA(DWORD dwPos,DWORD dwCount,BYTE * lpBuffer,BYTE bySubCode)458 int CRKUsbComm::RKU_WriteLBA(DWORD dwPos, DWORD dwCount, BYTE *lpBuffer, BYTE bySubCode)
459 {
460 long long ret;
461 long long dwPosBuf;
462 if (m_hLbaDev < 0)
463 {
464 if (!m_bEmmc)
465 {
466 m_hLbaDev = open(NAND_DRIVER_DEV_LBA, O_RDWR | O_SYNC, 0);
467 if (m_hLbaDev < 0)
468 {
469 if (m_log)
470 {
471 m_log->Record(_T("ERROR:RKU_WriteLBA-->open %s failed,err=%d"), NAND_DRIVER_DEV_LBA, errno);
472 }
473 return ERR_DEVICE_OPEN_FAILED;
474 }
475 else
476 {
477 if (m_log)
478 {
479 m_log->Record(_T("INFO:RKU_WriteLBA-->open %s ok,handle=%d"), NAND_DRIVER_DEV_LBA, m_hLbaDev);
480 }
481 }
482 }
483 else
484 {
485 return ERR_DEVICE_OPEN_FAILED;
486 }
487 }
488 if (m_bEmmc && !CRKAndroidDevice::bGptFlag)
489 {
490 dwPos += 8192;
491 }
492
493 dwPosBuf = dwPos;
494
495 ret = lseek64(m_hLbaDev, (off64_t)dwPosBuf * 512, SEEK_SET);
496 if (ret < 0)
497 {
498 if (m_log)
499 {
500 m_log->Record(_T("ERROR:RKU_WriteLBA seek failed,err=%d,ret:%lld"), errno, ret);
501 m_log->Record(_T("the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf * 512);
502 }
503
504 return ERR_FAILED;
505 }
506
507 ret = write(m_hLbaDev, lpBuffer, dwCount * 512);
508 if (ret != dwCount * 512)
509 {
510 sleep(1);
511 if (m_log)
512 {
513 m_log->Record(_T("ERROR:RKU_WriteLBA write failed,err=%d"), errno);
514 }
515 return ERR_FAILED;
516 }
517
518 return ERR_SUCCESS;
519 }
520
RKU_LoaderWriteLBA(DWORD dwPos,DWORD dwCount,BYTE * lpBuffer,BYTE bySubCode)521 int CRKUsbComm::RKU_LoaderWriteLBA(DWORD dwPos, DWORD dwCount, BYTE *lpBuffer, BYTE bySubCode)
522 {
523 long long ret;
524 long long dwPosBuf;
525 if (m_hLbaDev < 0)
526 {
527 if (!m_bEmmc)
528 {
529 m_hLbaDev = open(NAND_DRIVER_DEV_LBA, O_RDWR | O_SYNC, 0);
530 if (m_hLbaDev < 0)
531 {
532 if (m_log)
533 {
534 m_log->Record(_T("ERROR:RKU_WriteLBA-->open %s failed,err=%d"), NAND_DRIVER_DEV_LBA, errno);
535 }
536 return ERR_DEVICE_OPEN_FAILED;
537 }
538 else
539 {
540 if (m_log)
541 {
542 m_log->Record(_T("INFO:RKU_WriteLBA-->open %s ok,handle=%d"), NAND_DRIVER_DEV_LBA, m_hLbaDev);
543 }
544 }
545 }
546 else
547 {
548 return ERR_DEVICE_OPEN_FAILED;
549 }
550 }
551
552 dwPosBuf = dwPos;
553 //if (m_log)
554 // m_log->Record(_T("INFO: dwPosBuf = %d ,will seek to pos = 0x%08x"), dwPosBuf, dwPosBuf*512);
555
556 ret = lseek64(m_hLbaDev, (off64_t)dwPosBuf * 512, SEEK_SET);
557 if (ret < 0)
558 {
559 if (m_log)
560 {
561 m_log->Record(_T("ERROR:RKU_WriteLBA seek failed,err=%d,ret:%lld"), errno, ret);
562 m_log->Record(_T("the dwPosBuf = dwPosBuf*512,dwPosBuf:%lld!"), dwPosBuf * 512);
563 }
564
565 return ERR_FAILED;
566 }
567
568 ret = write(m_hLbaDev, lpBuffer, dwCount * 512);
569 if (ret != dwCount * 512)
570 {
571 sleep(1);
572 if (m_log)
573 {
574 m_log->Record(_T("ERROR:RKU_WriteLBA write failed,err=%d"), errno);
575 }
576 return ERR_FAILED;
577 }
578
579 return ERR_SUCCESS;
580 }
581
RKU_WriteSector(DWORD dwPos,DWORD dwCount,BYTE * lpBuffer)582 int CRKUsbComm::RKU_WriteSector(DWORD dwPos, DWORD dwCount, BYTE *lpBuffer)
583 {
584 int ret;
585 if (m_hDev < 0)
586 {
587 return ERR_DEVICE_OPEN_FAILED;
588 }
589 DWORD *pOffset = (DWORD *)(lpBuffer);
590 DWORD *pCount = (DWORD *)(lpBuffer + 4);
591 *pOffset = dwPos;
592 *pCount = dwCount;
593 ret = ioctl(m_hDev, WRITE_SECTOR_IO, lpBuffer);
594 if (ret)
595 {
596 if (m_log)
597 {
598 m_log->Record(_T("ERROR:RKU_WriteSector failed,err=%d"), errno);
599 }
600 return ERR_FAILED;
601 }
602 return ERR_SUCCESS;
603 }
604
RKU_EndWriteSector(BYTE * lpBuffer)605 int CRKUsbComm::RKU_EndWriteSector(BYTE *lpBuffer)
606 {
607 int ret;
608 if (m_hDev < 0)
609 {
610 return ERR_DEVICE_OPEN_FAILED;
611 }
612 ret = ioctl(m_hDev, END_WRITE_SECTOR_IO, lpBuffer);
613 if (ret)
614 {
615 if (m_log)
616 {
617 m_log->Record(_T("ERROR:RKU_EndWriteSector failed,err=%d"), errno);
618 }
619 return ERR_FAILED;
620 }
621 return ERR_SUCCESS;
622 }
RKU_GetLockFlag(BYTE * lpBuffer)623 int CRKUsbComm::RKU_GetLockFlag(BYTE *lpBuffer)
624 {
625 int ret;
626 if (m_hDev < 0)
627 {
628 return ERR_DEVICE_OPEN_FAILED;
629 }
630 ret = ioctl(m_hDev, GET_LOCK_FLAG_IO, lpBuffer);
631 if (ret)
632 {
633 if (m_log)
634 {
635 m_log->Record(_T("ERROR:RKU_GetLockFlag failed,err=%d"), errno);
636 }
637 return ERR_FAILED;
638 }
639 DWORD *pFlag = (DWORD *)lpBuffer;
640 if (m_log)
641 {
642 m_log->Record(_T("INFO:LockFlag:0x%08x"), *pFlag);
643 }
644 return ERR_SUCCESS;
645 }
RKU_GetPublicKey(BYTE * lpBuffer)646 int CRKUsbComm::RKU_GetPublicKey(BYTE *lpBuffer)
647 {
648 int ret;
649 if (m_hDev < 0)
650 {
651 return ERR_DEVICE_OPEN_FAILED;
652 }
653 ret = ioctl(m_hDev, GET_PUBLIC_KEY_IO, lpBuffer);
654 if (ret)
655 {
656 if (m_log)
657 {
658 m_log->Record(_T("ERROR:RKU_GetPublicKey failed,err=%d"), errno);
659 }
660 return ERR_FAILED;
661 }
662 return ERR_SUCCESS;
663 }
CtrlNandLbaWrite(bool bEnable)664 bool CRKUsbComm::CtrlNandLbaWrite(bool bEnable)
665 {
666 int ret;
667 if (m_bEmmc)
668 {
669 return false;
670 }
671 if (m_hLbaDev < 0)
672 {
673 return false;
674 }
675 if (bEnable)
676 {
677 ret = ioctl(m_hLbaDev, ENABLE_NAND_LBA_WRITE_IO);
678 }
679 else
680 {
681 ret = ioctl(m_hLbaDev, DISABLE_NAND_LBA_WRITE_IO);
682 }
683 if (ret)
684 {
685 if (m_log)
686 {
687 m_log->Record(_T("ERROR:CtrlNandLbaWrite failed,enable=%d,err=%d"), bEnable, errno);
688 }
689 return false;
690 }
691
692 return true;
693 }
CtrlNandLbaRead(bool bEnable)694 bool CRKUsbComm::CtrlNandLbaRead(bool bEnable)
695 {
696 int ret;
697 if (m_bEmmc)
698 {
699 return false;
700 }
701 if (m_hLbaDev < 0)
702 {
703 return false;
704 }
705 if (bEnable)
706 {
707 ret = ioctl(m_hLbaDev, ENABLE_NAND_LBA_READ_IO);
708 }
709 else
710 {
711 ret = ioctl(m_hLbaDev, DISABLE_NAND_LBA_READ_IO);
712 }
713 if (ret)
714 {
715 if (m_log)
716 {
717 m_log->Record(_T("ERROR:CtrlNandLbaRead failed,enable=%d,err=%d"), bEnable, errno);
718 }
719 return false;
720 }
721 return true;
722 }
723
724
725
726
727