libuuu/sdp.cpp

   1 /*
   2 * Copyright 2018 NXP.
   3 *
   4 * Redistribution and use in source and binary forms, with or without modification,
   5 * are permitted provided that the following conditions are met:
   6 *
   7 * Redistributions of source code must retain the above copyright notice, this
   8 * list of conditions and the following disclaimer.
   9 *
  10 * Redistributions in binary form must reproduce the above copyright notice, this
  11 * list of conditions and the following disclaimer in the documentation and/or
  12 * other materials provided with the distribution.
  13 *
  14 * Neither the name of the NXP Semiconductor nor the names of its
  15 * contributors may be used to endorse or promote products derived from this
  16 * software without specific prior written permission.
  17 *
  18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28 * POSSIBILITY OF SUCH DAMAGE.
  29 *
  30 */
  31
  32 #include <string>
  33 #include "config.h"
  34 #include "sdps.h"
  35 #include "hidreport.h"
  36 #include "liberror.h"
  37 #include "libcomm.h"
  38 #include "buffer.h"
  39 #include "sdp.h"
  40 #include "rominfo.h"
  41 #include "libusb.h"
  42 #include "trans.h"
  43
  44 #include <cstring>
  45
  46 int SDPCmdBase::check_ack(HIDReport *report, uint32_t ack)
  47 {
  48         if (get_hab_type(report) == HabUnknown)
  49                 return -1;
  50
  51         uint32_t status;
  52         if (get_status(report, status, 4))
  53                 return -1;
  54
  55         if (ack != status)
  56         {
  57                 set_last_err_string("Status Miss matched");
  58                 return -1;
  59         }
  60         return 0;
  61 }
  62
  63 SDPCmdBase::HAB_t SDPCmdBase::get_hab_type(HIDReport *report)
  64 {
  65         uint32_t status;
  66         if (get_status(report, status, 3))
  67                 return HabUnknown;
  68
  69         if (status == HabEnabled)
  70                 return HabEnabled;
  71
  72         if (status == HabDisabled)
  73                 return HabDisabled;
  74
  75         set_last_err_string("unknown hab type");
  76         return HabUnknown;
  77 }
  78
  79 int SDPCmdBase::get_status(HIDReport *p, uint32_t &status, uint8_t report_id)
  80 {
  81         m_input.resize(1025);
  82         m_input[0] = report_id;
  83         int ret = p->read(m_input);
  84         if (ret < 0)
  85                 return -1;
  86
  87         if (m_input.size() < (1 + sizeof(uint32_t)))
  88         {
  89                 set_last_err_string("HID report size is too small");
  90                 return -1;
  91         }
  92
  93         status = *(uint32_t*)(m_input.data() + 1);
  94         return 0;
  95 }
  96
  97 int SDPCmdBase::init_cmd()
  98 {
  99         memset(&m_spdcmd, 0, sizeof(m_spdcmd));
 100         insert_param_info("-scanlimited", &m_scan_limited, Param::Type::e_uint64);
 101         return 0;
 102 }
 103
 104 IvtHeader *SDPCmdBase::search_ivt_header(shared_ptr<DataBuffer> data, size_t &off, size_t limit)
 105 {
 106         if (limit >= data->size())
 107                 limit = data->size();
 108
 109         for (; off < limit; off += 0x4)
 110         {
 111                 IvtHeader *p = (IvtHeader*)(data->data() + off);
 112                 if (p->IvtBarker == IVT_BARKER_HEADER)
 113                         return p;
 114                 if (p->IvtBarker == IVT_BARKER2_HEADER)
 115                 {
 116                         BootData *pDB = (BootData *) &(data->at(off + p->BootData - p->SelfAddr));
 117
 118                         /*Skip HDMI firmware for i.MX8MQ*/
 119                         if (pDB->PluginFlag & 0xFFFFFFFE)
 120                                 continue;
 121                         return p;
 122                 }
 123         }
 124         off = -1;
 125         return nullptr;
 126 }
 127
 128 int SDPCmdBase::send_cmd(HIDReport *p)
 129 {
 130         return p->write(&m_spdcmd, sizeof(m_spdcmd), 1);
 131 }
 132
 133 SDPDcdCmd::SDPDcdCmd(char *p) : SDPCmdBase(p)
 134 {
 135         insert_param_info("dcd", nullptr, Param::Type::e_null);
 136         insert_param_info("-f", &m_filename, Param::Type::e_string_filename);
 137         insert_param_info("-dcdaddr", &m_dcd_addr, Param::Type::e_uint32);
 138         m_dcd_addr = 0;
 139 }
 140
 141 int SDPDcdCmd::run(CmdCtx*ctx)
 142 {
 143         const ROM_INFO * rom = search_rom_info(ctx->m_config_item);
 144         if (rom == nullptr)
 145         {
 146                 string_ex err;
 147                 err.format("%s:%d can't get rom info", __FUNCTION__, __LINE__);
 148                 set_last_err_string(err);
 149                 return -1;
 150         }
 151         init_cmd();
 152
 153         shared_ptr<FileBuffer> p = get_file_buffer(m_filename, true);
 154
 155         if (!p)
 156                 return -1;
 157
 158         shared_ptr<DataBuffer> buff;
 159         buff = p->request_data(0, m_scan_limited);
 160         if (!buff) return -1;
 161
 162         size_t off = 0;
 163         IvtHeader *pIVT = search_ivt_header(buff, off);
 164         if (pIVT == nullptr)
 165         {
 166                 return 0;
 167         }
 168
 169         if (pIVT->DCDAddress == 0)
 170                 return 0;
 171
 172         uint8_t * pdcd = &(buff->at(off + pIVT->DCDAddress - pIVT->SelfAddr));
 173
 174         if (pdcd[0] != HAB_TAG_DCD)
 175         {
 176                 string_ex err;
 177                 err.format("%s:%d DCD TAG miss matched", __FUNCTION__, __LINE__);
 178                 set_last_err_string(err);
 179                 return -1;
 180         }
 181
 182         uint32_t size = (pdcd[1] << 8) | pdcd[2];
 183
 184         if (size >= m_scan_limited)
 185         {
 186                 set_last_err_string("dcd bigger than 8M");
 187                 return -1;
 188         }
 189
 190         // point maybe change after new requisition buffer.
 191         pdcd = &(buff->at(off + pIVT->DCDAddress - pIVT->SelfAddr));
 192
 193         m_spdcmd.m_cmd = ROM_KERNEL_CMD_DCD_WRITE;
 194         m_spdcmd.m_addr = EndianSwap(m_dcd_addr ? m_dcd_addr : rom->free_addr);
 195         m_spdcmd.m_count = EndianSwap(size);
 196
 197         HIDTrans dev(m_timeout);
 198         if (dev.open(ctx->m_dev))
 199                 return -1;
 200
 201         HIDReport report(&dev);
 202         if (report.write(&m_spdcmd, sizeof(m_spdcmd), 1))
 203                 return -1;
 204
 205         if (report.write(pdcd, size, 2))
 206                 return -1;
 207
 208         if (check_ack(&report, ROM_WRITE_ACK))
 209                 return -1;
 210
 211         return 0;
 212 }
 213
 214 SDPSkipDCDCmd::SDPSkipDCDCmd(char *p) : SDPCmdBase(p)
 215 {
 216         m_spdcmd.m_cmd = ROM_KERNEL_CMD_SKIP_DCD_HEADER;
 217 }
 218
 219 int SDPSkipDCDCmd::run(CmdCtx*ctx)
 220 {
 221         HIDTrans dev(m_timeout);
 222         if (dev.open(ctx->m_dev))
 223                 return -1;
 224
 225         HIDReport report(&dev);
 226         if (report.write(&m_spdcmd, sizeof(m_spdcmd), 1))
 227                 return -1;
 228
 229         if (check_ack(&report, ROM_OK_ACK))
 230                 return -1;
 231
 232         return 0;
 233 }
 234
 235 SDPBootCmd::SDPBootCmd(char *p) : SDPCmdBase(p)
 236 {
 237         insert_param_info("boot", nullptr, Param::Type::e_null);
 238         insert_param_info("-f", &m_filename, Param::Type::e_string_filename);
 239         insert_param_info("-nojump", &m_nojump, Param::Type::e_bool);
 240         insert_param_info("-cleardcd", &m_clear_dcd, Param::Type::e_bool);
 241         insert_param_info("-dcdaddr", &m_dcd_addr, Param::Type::e_uint32);
 242         insert_param_info("-scanlimited", &m_scan_limited, Param::Type::e_uint64);
 243         insert_param_info("-barebox", &m_barebox, Param::Type::e_bool);
 244 }
 245
 246 # define BAREBOX_MAGIC_OFFSET   0x20
 247
 248 bool SDPBootCmd::is_barebox_img(void)
 249 {
 250         shared_ptr<FileBuffer> fbuf= get_file_buffer(m_filename, true);
 251         if (fbuf == nullptr)
 252                 return false;
 253
 254         string barebox_magic ("barebox");
 255
 256         shared_ptr<DataBuffer> dbuf = fbuf->request_data(0, BAREBOX_MAGIC_OFFSET + barebox_magic.length());
 257         if (dbuf == nullptr)
 258                 return false;
 259
 260         string img ((const char *)&dbuf->at(BAREBOX_MAGIC_OFFSET), barebox_magic.length());
 261
 262         return img.compare(barebox_magic) == 0 ? true : false;
 263 }
 264
 265 int SDPBootCmd::load_barebox(CmdCtx *ctx)
 266 {
 267         const ROM_INFO *rom = search_rom_info(ctx->m_config_item);
 268
 269         if (!rom)
 270                 return 0;
 271
 272         // The barebox USB loading mechanism differs between SoCs due to SRAM
 273         // size limitations.
 274         //
 275         // E.g. all i.MX8M SoCs require a two stage loading, first the
 276         // pre-bootloader (PBL) is loaded to the internal SRAM and started. The
 277         // PBL intialize the DDR and uses the BootROM initialized USB
 278         // controller to load the remaining "full barebox image" to the DDR.
 279         //
 280         // On i.MX6 devices this is not the case since the DDR setup is done
 281         // via the DCD and we can load the image directly to the DDR.
 282         //
 283         // The ROM_INFO_NEED_BAREBOX_FULL_IMAGE flag indicates if the two-stage
 284         // load mechanism is required for a specific SoC. So the user can
 285         // always specify '-barebox' no matter if it's required or not:
 286         //
 287         // SDP: boot -barebox -f <barebox.img>
 288         if (!(rom->flags & ROM_INFO_NEED_BAREBOX_FULL_IMAGE))
 289                 return 0;
 290
 291         string str;
 292         str = "SDP: write -f ";
 293         str += m_filename;
 294         str += " -ivt 0";
 295         str += " -barebox-bl33";
 296
 297         SDPWriteCmd wr((char *)str.c_str());
 298         if (wr.parser()) return -1;
 299
 300         return wr.run(ctx);
 301 }
 302
 303 int SDPBootCmd::run(CmdCtx *ctx)
 304 {
 305         string str;
 306         str = "SDP: dcd -f ";
 307         str += m_filename;
 308         if (m_dcd_addr) {
 309                 str += " -dcdaddr ";
 310                 str += std::to_string(m_dcd_addr);
 311         }
 312
 313         if (m_scan_limited != UINT64_MAX)
 314         {
 315                 str += " -scanlimited ";
 316                 str += std::to_string(m_scan_limited);
 317         }
 318
 319         SDPDcdCmd dcd((char *)str.c_str());
 320
 321         if (m_scan_limited != UINT64_MAX)
 322         {
 323                 str += " -scanlimited ";
 324                 str += std::to_string(m_scan_limited);
 325         }
 326
 327         if (dcd.parser()) return -1;
 328         if (dcd.run(ctx)) return -1;
 329
 330         str = "SDP: write -f ";
 331         str += m_filename;
 332         str += " -ivt 0";
 333
 334         if (m_scan_limited != UINT64_MAX)
 335         {
 336                 str += " -scanlimited ";
 337                 str += std::to_string(m_scan_limited);
 338         }
 339
 340         SDPWriteCmd wr((char *)str.c_str());
 341         if (wr.parser()) return -1;
 342         if (wr.run(ctx)) return -1;
 343
 344         str = "SDP: jump -f ";
 345         str += m_filename;
 346         str += " -ivt 0";
 347         if (m_clear_dcd)
 348                 str += " -cleardcd";
 349
 350         if (m_scan_limited != UINT64_MAX)
 351         {
 352                 str += " -scanlimited ";
 353                 str += std::to_string(m_scan_limited);
 354         }
 355
 356         SDPJumpCmd jmp((char *)str.c_str());
 357         if (!m_nojump)
 358         {
 359                 if (jmp.parser()) return -1;
 360                 if (jmp.run(ctx)) return -1;
 361         }
 362
 363         if (m_barebox || is_barebox_img())
 364         {
 365                 if (load_barebox(ctx)) return -1;
 366         }
 367
 368         SDPBootlogCmd log(nullptr);
 369         log.run(ctx);
 370
 371         return 0;
 372 }
 373
 374 SDPStatusCmd::SDPStatusCmd(char *p) : SDPCmdBase(p)
 375 {
 376         m_spdcmd.m_cmd = ROM_KERNEL_CMD_ERROR_STATUS;
 377         insert_param_info("status", nullptr, Param::Type::e_null);
 378 }
 379
 380 int SDPStatusCmd::run(CmdCtx *ctx)
 381 {
 382         HIDTrans dev(m_timeout);
 383         if (dev.open(ctx->m_dev))
 384                 return -1;
 385
 386         HIDReport report(&dev);
 387         if (report.write(&m_spdcmd, sizeof(m_spdcmd), 1))
 388                 return -1;
 389
 390         if (get_hab_type(&report) == HabUnknown)
 391                 return -1;
 392
 393         uint32_t status;
 394         if (get_status(&report, status, 4))
 395                 return -1;
 396
 397         return 0;
 398 }
 399
 400 SDPWriteCmd::SDPWriteCmd(char *p) : SDPCmdBase(p)
 401 {
 402         m_spdcmd.m_cmd = ROM_KERNEL_CMD_WR_FILE;
 403         m_PlugIn = -1;
 404         m_Ivt = -1;
 405         m_max_download_pre_cmd = 0x200000;
 406         m_offset = 0;
 407         m_bIvtReserve = false;
 408         m_download_addr = 0;
 409         m_bskipspl = false;
 410         m_bscanterm = false;
 411         m_barebox_bl33 = false;
 412
 413         insert_param_info("write", nullptr, Param::Type::e_null);
 414         insert_param_info("-f", &m_filename, Param::Type::e_string_filename);
 415         insert_param_info("-ivt", &m_Ivt, Param::Type::e_uint32);
 416         insert_param_info("-addr", &m_download_addr, Param::Type::e_uint32);
 417         insert_param_info("-barebox-bl33", &m_barebox_bl33, Param::Type::e_bool);
 418         insert_param_info("-offset", &m_offset, Param::Type::e_uint32);
 419         insert_param_info("-skipspl", &m_bskipspl, Param::Type::e_bool);
 420         insert_param_info("-skipfhdr", &m_bskipfhdr, Param::Type::e_bool);
 421         insert_param_info("-scanterm", &m_bscanterm, Param::Type::e_bool);
 422 }
 423
 424 int SDPWriteCmd::run(CmdCtx*ctx)
 425 {
 426         size_t size;
 427         uint8_t *pbuff;
 428         ssize_t offset = 0;
 429         bool validate_run = true;
 430
 431         shared_ptr<FileBuffer> p1= get_file_buffer(m_filename, true);
 432
 433         if (p1 == nullptr)
 434                 return -1;
 435
 436         shared_ptr<DataBuffer> fbuff;
 437
 438         fbuff = p1->request_data(0, m_scan_limited);
 439         if (!fbuff) return -1;
 440
 441         if (m_Ivt < 0)
 442         {
 443                 pbuff = fbuff->data();
 444                 size = fbuff->size();
 445
 446                 offset = m_offset;
 447
 448                 if (m_bskipfhdr)
 449                         offset += GetFlashHeaderSize(fbuff, offset);
 450
 451                 size_t pos = 0, length;
 452                 if (m_bscanterm)
 453                 {
 454                         if (IsMBR(fbuff))
 455                         {
 456                                 length = ScanTerm(fbuff, pos);
 457                                 if (length == 0)
 458                                 {
 459                                         set_last_err_string("This wic have NOT terminate tag after bootloader, please use new yocto");
 460                                         return -1;
 461                                 }
 462
 463                                 offset = pos - length;
 464                                 if (offset < 0)
 465                                 {
 466                                         set_last_err_string("This wic boot length is wrong");
 467                                         return -1;
 468                                 }
 469                                 size = pos;
 470                         }
 471                 }
 472
 473                 if (m_bskipspl) {
 474                         const ROM_INFO * rom = search_rom_info(ctx->m_config_item);
 475                         if(! (rom->flags & ROM_INFO_AUTO_SCAN_UBOOT_POS))
 476                         {
 477                                 set_last_err_string("SPL doesn't support auto scan uboot position");
 478                                 return -1;
 479                         }
 480
 481                         size_t off = offset;
 482                         IvtHeader *pIvt = search_ivt_header(fbuff, off, 0x100000);
 483                         if (pIvt)
 484                         {
 485                                 if (pIvt->BootData)
 486                                 {
 487                                         BootData *pDB = (BootData *) &(fbuff->at(off + pIvt->BootData - pIvt->SelfAddr));
 488                                         offset = off + pDB->ImageSize - (pIvt->SelfAddr - pDB->ImageStartAddr);
 489                                 }
 490                         }
 491                         else
 492                         {
 493                                 offset += GetContainerActualSize(fbuff, offset, rom->flags & ROM_INFO_HID_ROMAPI, m_bskipspl);
 494                         }
 495
 496                         if (size_t(offset) >= fbuff->size())
 497                         {
 498                                 set_last_err_string("Unknown Image type, can't use skipspl format");
 499                                 return -1;
 500                         }
 501                 }
 502
 503                 size -= offset;
 504         }
 505         else
 506         {
 507                 size_t off = 0;
 508                 IvtHeader *pIvt = search_ivt_header(fbuff, off);
 509                 for (int i = 0; i < m_Ivt; i++)
 510                 {
 511                         off += sizeof(IvtHeader);
 512                         pIvt = search_ivt_header(fbuff, off, m_scan_limited);
 513                 }
 514                 if (pIvt == nullptr)
 515                 {
 516                         set_last_err_string("Cannot find valid IVT header");
 517                         return -1;
 518                 }
 519
 520                 BootData *pDB = (BootData *) &(fbuff->at(off + pIvt->BootData - pIvt->SelfAddr));
 521
 522                 m_download_addr = pIvt->SelfAddr;
 523                 //size = fbuff->size() - off;
 524                 size = pDB->ImageSize - (pIvt->SelfAddr - pDB->ImageStartAddr);
 525
 526                 if (size >= m_scan_limited)
 527                 {
 528                         set_last_err_string("TODO: image is too big");
 529                         return -1;
 530                 }
 531
 532                 //ImageSize may be bigger than Imagesize because ImageSize include IVT offset
 533                 //Difference boot storage have difference IVT offset.
 534                 if (size > fbuff->size() - off)
 535                         size = fbuff->size() - off;
 536
 537                 if (m_barebox_bl33) {
 538                         if (pIvt->IvtBarker != IVT_BARKER_HEADER) {
 539                                 set_last_err_string("Barebox BL33 loading is only support for IVT Header V2");
 540                                 return -1;
 541                         }
 542                         offset = pIvt->ImageStartAddr - pIvt->SelfAddr;
 543                         size = fbuff->size() - off - offset;
 544                         m_download_addr = 0;
 545
 546                         // Barebox does start as soon as the bl33 was loaded
 547                         // and the check_ack() fails
 548                         validate_run = false;
 549                 }
 550
 551                 pbuff = (uint8_t*)pIvt;
 552         }
 553         return run(ctx, pbuff + offset, size, m_download_addr, validate_run);
 554 }
 555
 556 int SDPWriteCmd::run(CmdCtx *ctx, void *pbuff, size_t size, uint32_t addr, bool validate)
 557 {
 558         HIDTrans dev(m_timeout);
 559         if (dev.open(ctx->m_dev))
 560                 return -1;
 561
 562         HIDReport report(&dev);
 563
 564         report.set_notify_total(size);
 565
 566         const ROM_INFO * rom = search_rom_info(ctx->m_config_item);
 567
 568         size_t max = m_max_download_pre_cmd;
 569
 570         /* SPL needn't split transfer */
 571         if (rom && (rom ->flags & ROM_INFO_HID_SDP_NO_MAX_PER_TRANS))
 572                 max = size;
 573
 574         for (size_t i=0; i < size; i += max)
 575         {
 576                 size_t sz;
 577                 sz = size - i;
 578                 if (sz > max)
 579                         sz = max;
 580
 581                 m_spdcmd.m_addr = EndianSwap((uint32_t)(addr + i)); // force use 32bit endian swap function;
 582                 m_spdcmd.m_count = EndianSwap((uint32_t)sz); //force use 32bit endian swap function;
 583
 584                 report.set_position_base(i);
 585                 report.set_skip_notify(true);
 586
 587                 if (report.write(&m_spdcmd, sizeof(m_spdcmd), 1))
 588                         return -1;
 589
 590                 report.set_skip_notify(false);
 591
 592                 if (report.write(((uint8_t*)pbuff)+i, sz, 2))
 593                         return -1;
 594
 595                 if (validate && check_ack(&report, ROM_STATUS_ACK))
 596                         return -1;
 597         }
 598
 599         return 0;
 600 }
 601
 602 SDPReadMemCmd::SDPReadMemCmd(char *p) : SDPCmdBase(p)
 603 {
 604         m_spdcmd.m_cmd = ROM_KERNEL_CMD_RD_MEM;
 605
 606         insert_param_info("rdmem", nullptr, Param::Type::e_null);
 607         insert_param_info("-addr", &m_mem_addr, Param::Type::e_uint32);
 608         insert_param_info("-format", &m_mem_format, Param::Type::e_uint32);
 609 }
 610
 611 int SDPReadMemCmd::run(CmdCtx *ctx)
 612 {
 613         HIDTrans dev(m_timeout);
 614         if (dev.open(ctx->m_dev))
 615                 return -1;
 616
 617         HIDReport report(&dev);
 618
 619         printf("\nReading address 0x%08X ...\n", m_mem_addr);
 620         m_spdcmd.m_addr = EndianSwap(m_mem_addr);
 621         m_spdcmd.m_format = m_mem_format;
 622         switch (m_mem_format) {
 623                 case 0x8:
 624                         m_spdcmd.m_count = EndianSwap((uint32_t)0x1);
 625                         break;
 626                 case 0x10:
 627                         m_spdcmd.m_count = EndianSwap((uint32_t)0x2);
 628                         break;
 629                 case 0x20:
 630                         m_spdcmd.m_count = EndianSwap((uint32_t)0x4);
 631                         break;
 632                 default:
 633                         set_last_err_string("Invalid format, use <8|16|32>");
 634                         return -1;
 635                         break;
 636         }
 637
 638         if (report.write(&m_spdcmd, sizeof(m_spdcmd), 1))
 639                 return -1;
 640
 641         if (get_hab_type(&report) == HabUnknown)
 642                 return -1;
 643
 644         uint32_t mem_value;
 645         if (get_status(&report, mem_value, 4) == 0)
 646         {
 647                 printf("\nValue of address 0x%08X: ", m_mem_addr);
 648                 switch (m_mem_format) {
 649                         case 0x8:
 650                                 printf("0x%02X\n", mem_value & 0xff);
 651                                 break;
 652                         case 0x10:
 653                                 printf("0x%04X\n", mem_value & 0xffff);
 654                                 break;
 655                         case 0x20:
 656                                 printf("0x%08X\n", mem_value);
 657                                 break;
 658                         default:
 659                                 set_last_err_string("Invalid format, use <8|16|32>");
 660                                 return -1;
 661                 }
 662         }
 663
 664         return 0;
 665 }
 666
 667 SDPWriteMemCmd::SDPWriteMemCmd(char *p) : SDPCmdBase(p)
 668 {
 669         m_spdcmd.m_cmd = ROM_KERNEL_CMD_WR_MEM;
 670
 671         insert_param_info("wrmem", nullptr, Param::Type::e_null);
 672         insert_param_info("-addr", &m_mem_addr, Param::Type::e_uint32);
 673         insert_param_info("-format", &m_mem_format, Param::Type::e_uint32);
 674         insert_param_info("-value", &m_mem_value, Param::Type::e_uint32);
 675 }
 676
 677 int SDPWriteMemCmd::run(CmdCtx *ctx)
 678 {
 679         HIDTrans dev(m_timeout);
 680         if (dev.open(ctx->m_dev))
 681                 return -1;
 682
 683         HIDReport report(&dev);
 684
 685         printf("\nWriting 0x%08X to address 0x%08X ...\n", m_mem_value, m_mem_addr);
 686         m_spdcmd.m_addr = EndianSwap(m_mem_addr);
 687         m_spdcmd.m_format = m_mem_format;
 688         switch (m_mem_format) {
 689                 case 0x8:
 690                         m_spdcmd.m_count = EndianSwap((uint32_t)0x1);
 691                         break;
 692                 case 0x10:
 693                         m_spdcmd.m_count = EndianSwap((uint32_t)0x2);
 694                         break;
 695                 case 0x20:
 696                         m_spdcmd.m_count = EndianSwap((uint32_t)0x4);
 697                         break;
 698                 default:
 699                         set_last_err_string("Invalid format, use <8|16|32>");
 700                         return -1;
 701                         break;
 702         }
 703         m_spdcmd.m_data = EndianSwap(m_mem_value);
 704
 705         if (report.write(&m_spdcmd, sizeof(m_spdcmd), 1))
 706                 return -1;
 707
 708         if (get_hab_type(&report) == HabUnknown)
 709                 return -1;
 710
 711         uint32_t status;
 712
 713         if (get_status(&report, status, 4) < 0 || status != ROM_WRITE_ACK) {
 714
 715                 string_ex err;
 716                 err.format("%s:%d Failed to write to address 0x%X",
 717                                 __FUNCTION__, __LINE__, m_mem_addr);
 718                 set_last_err_string(err);
 719         }
 720
 721         return 0;
 722 }
 723
 724 SDPJumpCmd::SDPJumpCmd(char *p) : SDPCmdBase(p)
 725 {
 726         m_spdcmd.m_cmd = ROM_KERNEL_CMD_JUMP_ADDR;
 727         insert_param_info("jump", nullptr, Param::Type::e_null);
 728         insert_param_info("-f", &m_filename, Param::Type::e_string_filename);
 729         insert_param_info("-ivt", &m_Ivt, Param::Type::e_uint32);
 730         insert_param_info("-plugin", &m_PlugIn, Param::Type::e_bool);
 731         insert_param_info("-addr", &m_jump_addr, Param::Type::e_uint32);
 732         insert_param_info("-cleardcd", &m_clear_dcd, Param::Type::e_bool);
 733 }
 734
 735 int SDPJumpCmd::run(CmdCtx *ctx)
 736 {
 737         const ROM_INFO * rom = search_rom_info(ctx->m_config_item);
 738
 739         HIDTrans dev(m_timeout);
 740         if (dev.open(ctx->m_dev))
 741                 return -1;
 742
 743         HIDReport report(&dev);
 744
 745         if (rom == nullptr)
 746         {
 747                 string_ex err;
 748                 err.format("%s:%d can't get rom info", __FUNCTION__, __LINE__);
 749                 set_last_err_string(err);
 750                 return -1;
 751         }
 752
 753         if (rom->flags & ROM_INFO_SPL_JUMP)
 754         {
 755                 m_spdcmd.m_addr = EndianSwap(m_jump_addr);
 756                 if (report.write(&m_spdcmd, sizeof(m_spdcmd), 1))
 757                         return -1;
 758
 759                 //Omit last return value.
 760                 check_ack(&report, ROM_OK_ACK);
 761                 return 0;
 762         }
 763
 764         shared_ptr<FileBuffer> p1 = get_file_buffer(m_filename, true);
 765         if (!p1)
 766                 return -1;
 767
 768         shared_ptr<DataBuffer> buff;
 769         buff = p1->request_data(0, m_scan_limited);
 770         if (!buff) return -1;
 771
 772         size_t off = 0;
 773         IvtHeader *pIVT = search_ivt_header(buff, off, m_scan_limited);
 774
 775         for (int i = 0; i < m_Ivt; i++)
 776         {
 777                 off += sizeof(IvtHeader);
 778                 pIVT = search_ivt_header(buff, off);
 779         }
 780
 781         if (pIVT == nullptr)
 782         {
 783                 set_last_err_string("Cannot find valid IVT header");
 784                 return -1;
 785         }
 786
 787         m_spdcmd.m_addr = EndianSwap(pIVT->SelfAddr);
 788
 789
 790         if (rom->flags & ROM_INFO_HID_SKIP_DCD && !m_clear_dcd)
 791         {
 792                 SDPSkipDCDCmd skipcmd(nullptr);
 793                 if (skipcmd.run(ctx))
 794                         return -1;
 795         }
 796         else
 797         {       /*Clear DCD*/
 798                 vector<uint8_t> ivt;
 799                 /* Need send out whole report size buffer avoid overwrite other data
 800                  * Some platform require receive whole package for report id = 2
 801                  */
 802                 ivt.resize(report.get_out_package_size());
 803
 804                 size_t sz = buff->size();
 805                 sz -= (uint8_t*)pIVT - (uint8_t*)buff->data();
 806
 807                 if (sz > ivt.size())
 808                         sz = ivt.size();
 809
 810                 memcpy(ivt.data(), pIVT, sz);
 811
 812                 IvtHeader *header = (IvtHeader *)ivt.data();
 813                 header->DCDAddress = 0;
 814
 815                 SDPWriteCmd writecmd(nullptr);
 816                 if(writecmd.run(ctx, header, ivt.size(), pIVT->SelfAddr))
 817                         return -1;
 818         }
 819
 820         if (report.write(&m_spdcmd, sizeof(m_spdcmd), 1))
 821                 return -1;
 822
 823         //Omit last return value.
 824         check_ack(&report, ROM_OK_ACK);
 825
 826         return 0;
 827 }
 828
 829 SDPBootlogCmd::SDPBootlogCmd(char *p) : SDPCmdBase(p)
 830 {
 831         insert_param_info("blog", nullptr, Param::Type::e_null);
 832 }
 833
 834 int SDPBootlogCmd::run(CmdCtx *ctx)
 835 {
 836         HIDTrans dev{2000};
 837
 838         if (dev.open(ctx->m_dev))
 839                 return -1;
 840
 841         HIDReport report(&dev);
 842
 843         vector<uint8_t> v(65);
 844         v[0] = 'I';
 845
 846         uuu_notify nt;
 847         nt.type = uuu_notify::NOTIFY_CMD_INFO;
 848
 849         int ret;
 850         while (1)
 851         {
 852                 ret = report.read(v);
 853                 if (ret)
 854                         return 0;
 855                 else
 856                 {
 857                         nt.str = (char*)(v.data() + 4);
 858                         v[5] = 0;
 859                         call_notify(nt);
 860                         continue;
 861                 }
 862         }
 863         return 0;
 864 }