src/scsi2sd-util6/scsi2sd-util.cc

   1 //      Copyright (C) 2014 Michael McMaster <michael@codesrc.com>
   2 //
   3 //      This file is part of SCSI2SD.
   4 //
   5 //      SCSI2SD is free software: you can redistribute it and/or modify
   6 //      it under the terms of the GNU General Public License as published by
   7 //      the Free Software Foundation, either version 3 of the License, or
   8 //      (at your option) any later version.
   9 //
  10 //      SCSI2SD is distributed in the hope that it will be useful,
  11 //      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 //      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 //      GNU General Public License for more details.
  14 //
  15 //      You should have received a copy of the GNU General Public License
  16 //      along with SCSI2SD.  If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 // For compilers that support precompilation, includes "wx/wx.h".
  20 #include <wx/wxprec.h>
  21 #ifndef WX_PRECOMP
  22 #include <wx/wx.h>
  23 #endif
  24
  25 #include <wx/app.h>
  26 #include <wx/filedlg.h>
  27 #include <wx/filefn.h>
  28 #include <wx/filename.h>
  29 #include <wx/log.h>
  30 #include <wx/notebook.h>
  31 #include <wx/progdlg.h>
  32 #include <wx/utils.h>
  33 #include <wx/wfstream.h>
  34 #include <wx/windowptr.h>
  35 #include <wx/stdpaths.h>
  36 #include <wx/stream.h>
  37 #include <wx/thread.h>
  38 #include <wx/txtstrm.h>
  39
  40 #include <zipper.hh>
  41
  42 #include "ConfigUtil.hh"
  43 #include "BoardPanel.hh"
  44 #include "TargetPanel.hh"
  45 #include "SCSI2SD_HID.hh"
  46 #include "Dfu.hh"
  47
  48 #include "terminalwx.h"
  49
  50 #include <algorithm>
  51 #include <iomanip>
  52 #include <vector>
  53 #include <set>
  54 #include <sstream>
  55
  56 #if __cplusplus >= 201103L
  57 #include <cstdint>
  58 #include <memory>
  59 using std::shared_ptr;
  60 #else
  61 #include <stdint.h>
  62 #include <tr1/memory>
  63 using std::tr1::shared_ptr;
  64 #endif
  65
  66 using namespace SCSI2SD;
  67
  68 class ProgressWrapper
  69 {
  70 public:
  71         void setProgressDialog(
  72                 const wxWindowPtr<wxGenericProgressDialog>& dlg,
  73                 size_t maxRows)
  74         {
  75                 myProgressDialog = dlg;
  76                 myMaxRows = maxRows;
  77                 myNumRows = 0;
  78         }
  79
  80         void clearProgressDialog()
  81         {
  82                 myProgressDialog->Show(false);
  83                 myProgressDialog.reset();
  84         }
  85
  86         void update(unsigned char arrayId, unsigned short rowNum)
  87         {
  88                 if (!myProgressDialog) return;
  89
  90                 myNumRows++;
  91
  92                 std::stringstream ss;
  93                 ss << "Writing flash array " <<
  94                         static_cast<int>(arrayId) << " row " <<
  95                         static_cast<int>(rowNum);
  96                 wxLogMessage("%s", ss.str());
  97                 myProgressDialog->Update(myNumRows, ss.str());
  98         }
  99
 100 private:
 101         wxWindowPtr<wxGenericProgressDialog> myProgressDialog;
 102         size_t myMaxRows;
 103         size_t myNumRows;
 104 };
 105 static ProgressWrapper TheProgressWrapper;
 106
 107 extern "C"
 108 void ProgressUpdate(unsigned char arrayId, unsigned short rowNum)
 109 {
 110         TheProgressWrapper.update(arrayId, rowNum);
 111 }
 112
 113 namespace
 114 {
 115
 116
 117 class TimerLock
 118 {
 119 public:
 120         TimerLock(wxTimer* timer) :
 121                 myTimer(timer),
 122                 myInterval(myTimer->GetInterval())
 123         {
 124                 myTimer->Stop();
 125         };
 126
 127         virtual ~TimerLock()
 128         {
 129                 if (myTimer && myInterval > 0)
 130                 {
 131                         myTimer->Start(myInterval);
 132                 }
 133         }
 134 private:
 135         wxTimer* myTimer;
 136         int myInterval;
 137 };
 138
 139 class AppFrame : public wxFrame
 140 {
 141 public:
 142         AppFrame() :
 143                 wxFrame(NULL, wxID_ANY, "scsi2sd-util6", wxPoint(50, 50), wxSize(600, 700)),
 144                 myInitialConfig(false),
 145                 myTickCounter(0),
 146                 myLastPollTime(0),
 147                 myConsoleProcess(NULL)
 148         {
 149                 wxMenu *menuFile = new wxMenu();
 150                 menuFile->Append(
 151                         ID_SaveFile,
 152                         _("&Save to file..."),
 153                         _("Save settings to local file."));
 154                 menuFile->Append(
 155                         ID_OpenFile,
 156                         _("&Open file..."),
 157                         _("Load settings from local file."));
 158                 menuFile->AppendSeparator();
 159                 menuFile->Append(
 160                         ID_ConfigDefaults,
 161                         _("Load &Defaults"),
 162                         _("Load default configuration options."));
 163
 164                 menuFile->AppendSeparator();
 165                 myLoadButton = menuFile->Append(
 166                         ID_BtnLoad,
 167                         _("Load from device"),
 168                         _("Load configuration from hardware device"));
 169                 mySaveButton = menuFile->Append(
 170                         ID_BtnSave,
 171                         _("Save to device"),
 172                         _("Save configuration to hardware device"));
 173
 174                 menuFile->AppendSeparator();
 175                 menuFile->Append(
 176                         ID_Firmware,
 177                         _("&Upgrade Firmware..."),
 178                         _("Upgrade or inspect device firmware version."));
 179                 menuFile->Append(wxID_EXIT);
 180
 181                 wxMenu *menuWindow= new wxMenu();
 182                 menuWindow->Append(
 183                         ID_LogWindow,
 184                         _("Show &Log"),
 185                         _("Show debug log window"));
 186
 187                 wxMenu *menuDebug = new wxMenu();
 188                 mySCSILogChk = menuDebug->AppendCheckItem(
 189                         ID_SCSILog,
 190                         _("Log SCSI data"),
 191                         _("Log SCSI commands"));
 192
 193                 mySelfTestChk = menuDebug->AppendCheckItem(
 194                         ID_SelfTest,
 195                         _("SCSI Standalone Self-Test"),
 196                         _("SCSI Standalone Self-Test"));
 197
 198                 wxMenu *menuHelp = new wxMenu();
 199                 menuHelp->Append(wxID_ABOUT);
 200
 201                 wxMenuBar *menuBar = new wxMenuBar();
 202                 menuBar->Append( menuFile, _("&File") );
 203                 menuBar->Append( menuDebug, _("&Debug") );
 204                 menuBar->Append( menuWindow, _("&Window") );
 205                 menuBar->Append( menuHelp, _("&Help") );
 206                 SetMenuBar( menuBar );
 207
 208                 CreateStatusBar();
 209
 210                 {
 211                         wxPanel* cfgPanel = new wxPanel(this);
 212                         wxFlexGridSizer *fgs = new wxFlexGridSizer(3, 1, 15, 15);
 213                         cfgPanel->SetSizer(fgs);
 214
 215                         // Empty space below menu bar.
 216                         fgs->Add(5, 5, wxALL);
 217
 218                         wxNotebook* tabs = new wxNotebook(cfgPanel, ID_Notebook);
 219                         myBoardPanel = new BoardPanel(tabs, ConfigUtil::DefaultBoardConfig());
 220                         tabs->AddPage(myBoardPanel, _("General Settings"));
 221                         for (int i = 0; i < S2S_MAX_TARGETS; ++i)
 222                         {
 223                                 TargetPanel* target =
 224                                         new TargetPanel(tabs, ConfigUtil::Default(i));
 225                                 myTargets.push_back(target);
 226                                 std::stringstream ss;
 227                                 ss << "Device " << (i + 1);
 228                                 tabs->AddPage(target, ss.str());
 229                                 target->Fit();
 230                         }
 231                         tabs->Fit();
 232                         fgs->Add(tabs);
 233
 234                         cfgPanel->Fit();
 235                 }
 236
 237 #ifdef __WINDOWS__
 238                 Fit(); // Needed to reduce window size on Windows
 239 #else
 240                 FitInside(); // Needed on Linux to prevent status bar overlap
 241 #endif
 242
 243                 myLogWindow = new wxLogWindow(this, _("scsi2sd-util6 debug log"), true);
 244                 myLogWindow->PassMessages(false); // Prevent messagebox popups
 245
 246                 myTimer = new wxTimer(this, ID_Timer);
 247                 myTimer->Start(64); //ms, suitable for scsi debug logging
 248         }
 249
 250 private:
 251         Dfu myDfu;
 252         wxLogWindow* myLogWindow;
 253         BoardPanel* myBoardPanel;
 254         std::vector<TargetPanel*> myTargets;
 255         wxMenuItem* mySCSILogChk;
 256         wxMenuItem* mySelfTestChk;
 257         wxMenuItem* myLoadButton;
 258         wxMenuItem* mySaveButton;
 259         wxTimer* myTimer;
 260         shared_ptr<HID> myHID;
 261         bool myInitialConfig;
 262
 263         uint8_t myTickCounter;
 264
 265         time_t myLastPollTime;
 266
 267         wxWindowPtr<TerminalWx> myConsoleTerm;
 268         shared_ptr<wxProcess> myConsoleProcess;
 269         wxInputStream* myConsoleStdout;
 270         wxInputStream* myConsoleStderr;
 271
 272
 273         void mmLogStatus(const std::string& msg)
 274         {
 275                 // We set PassMessages to false on our log window to prevent popups, but
 276                 // this also prevents wxLogStatus from updating the status bar.
 277                 SetStatusText(msg);
 278                 wxLogMessage(this, "%s", msg.c_str());
 279         }
 280
 281         void onConfigChanged(wxCommandEvent& event)
 282         {
 283                 evaluate();
 284         }
 285
 286         void evaluate()
 287         {
 288                 bool valid = true;
 289
 290                 // Check for duplicate SCSI IDs
 291                 std::set<uint8_t> enabledID;
 292
 293                 // Check for overlapping SD sectors.
 294                 std::vector<std::pair<uint32_t, uint64_t> > sdSectors;
 295
 296                 bool isTargetEnabled = false; // Need at least one enabled
 297                 uint32_t autoStartSector = 0;
 298                 for (size_t i = 0; i < myTargets.size(); ++i)
 299                 {
 300                         myTargets[i]->setAutoStartSector(autoStartSector);
 301                         valid = myTargets[i]->evaluate() && valid;
 302
 303                         if (myTargets[i]->isEnabled())
 304                         {
 305                                 isTargetEnabled = true;
 306                                 uint8_t scsiID = myTargets[i]->getSCSIId();
 307                                 if (enabledID.find(scsiID) != enabledID.end())
 308                                 {
 309                                         myTargets[i]->setDuplicateID(true);
 310                                         valid = false;
 311                                 }
 312                                 else
 313                                 {
 314                                         enabledID.insert(scsiID);
 315                                         myTargets[i]->setDuplicateID(false);
 316                                 }
 317
 318                                 auto sdSectorRange = myTargets[i]->getSDSectorRange();
 319                                 for (auto it(sdSectors.begin()); it != sdSectors.end(); ++it)
 320                                 {
 321                                         if (sdSectorRange.first < it->second &&
 322                                                 sdSectorRange.second > it->first)
 323                                         {
 324                                                 valid = false;
 325                                                 myTargets[i]->setSDSectorOverlap(true);
 326                                         }
 327                                         else
 328                                         {
 329                                                 myTargets[i]->setSDSectorOverlap(false);
 330                                         }
 331                                 }
 332                                 sdSectors.push_back(sdSectorRange);
 333                                 autoStartSector = sdSectorRange.second;
 334                         }
 335                         else
 336                         {
 337                                 myTargets[i]->setDuplicateID(false);
 338                                 myTargets[i]->setSDSectorOverlap(false);
 339                         }
 340                 }
 341
 342                 valid = valid && isTargetEnabled; // Need at least one.
 343
 344                 mySaveButton->Enable(valid && myHID);
 345
 346                 myLoadButton->Enable(static_cast<bool>(myHID));
 347         }
 348
 349
 350         enum
 351         {
 352                 ID_ConfigDefaults = wxID_HIGHEST + 1,
 353                 ID_Firmware,
 354                 ID_Timer,
 355                 ID_Notebook,
 356                 ID_BtnLoad,
 357                 ID_BtnSave,
 358                 ID_LogWindow,
 359                 ID_SCSILog,
 360                 ID_SelfTest,
 361                 ID_SaveFile,
 362                 ID_OpenFile,
 363                 ID_ConsoleTerm
 364         };
 365
 366         void OnID_ConfigDefaults(wxCommandEvent& event)
 367         {
 368                 myBoardPanel->setConfig(ConfigUtil::DefaultBoardConfig());
 369                 for (size_t i = 0; i < myTargets.size(); ++i)
 370                 {
 371                         myTargets[i]->setConfig(ConfigUtil::Default(i));
 372                 }
 373         }
 374
 375         void OnID_SaveFile(wxCommandEvent& event)
 376         {
 377                 TimerLock lock(myTimer);
 378
 379
 380
 381                 wxFileDialog dlg(
 382                         this,
 383                         "Save config settings",
 384                         "",
 385                         "",
 386                         "XML files (*.xml)|*.xml",
 387                         wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
 388                 if (dlg.ShowModal() == wxID_CANCEL) return;
 389
 390                 wxFileOutputStream file(dlg.GetPath());
 391                 if (!file.IsOk())
 392                 {
 393                         wxLogError("Cannot save settings to file '%s'.", dlg.GetPath());
 394                         return;
 395                 }
 396
 397                 wxTextOutputStream s(file);
 398
 399                 s << "<SCSI2SD>\n";
 400
 401                 s << ConfigUtil::toXML(myBoardPanel->getConfig());
 402                 for (size_t i = 0; i < myTargets.size(); ++i)
 403                 {
 404                         s << ConfigUtil::toXML(myTargets[i]->getConfig());
 405                 }
 406
 407                 s << "</SCSI2SD>\n";
 408         }
 409
 410         void OnID_OpenFile(wxCommandEvent& event)
 411         {
 412                 TimerLock lock(myTimer);
 413
 414                 wxFileDialog dlg(
 415                         this,
 416                         "Load config settings",
 417                         "",
 418                         "",
 419                         "XML files (*.xml)|*.xml",
 420                         wxFD_OPEN | wxFD_FILE_MUST_EXIST);
 421                 if (dlg.ShowModal() == wxID_CANCEL) return;
 422
 423                 try
 424                 {
 425                         std::pair<S2S_BoardCfg, std::vector<S2S_TargetCfg>> configs(
 426                                 ConfigUtil::fromXML(std::string(dlg.GetPath())));
 427
 428                         myBoardPanel->setConfig(configs.first);
 429
 430                         size_t i;
 431                         for (i = 0; i < configs.second.size() && i < myTargets.size(); ++i)
 432                         {
 433                                 myTargets[i]->setConfig(configs.second[i]);
 434                         }
 435
 436                         for (; i < myTargets.size(); ++i)
 437                         {
 438                                 myTargets[i]->setConfig(ConfigUtil::Default(i));
 439                         }
 440                 }
 441                 catch (std::exception& e)
 442                 {
 443                         wxLogError(
 444                                 "Cannot load settings from file '%s'.\n%s",
 445                                 dlg.GetPath(),
 446                                 e.what());
 447
 448                         wxMessageBox(
 449                                 e.what(),
 450                                 "Load error",
 451                                 wxOK | wxICON_ERROR);
 452                 }
 453         }
 454
 455         void OnID_Firmware(wxCommandEvent& event)
 456         {
 457                 TimerLock lock(myTimer);
 458                 doFirmwareUpdate();
 459         }
 460
 461         void OnID_LogWindow(wxCommandEvent& event)
 462         {
 463                 myLogWindow->Show();
 464         }
 465
 466         void doFirmwareUpdate()
 467         {
 468                 wxFileDialog dlg(
 469                         this,
 470                         "Load firmware file",
 471                         "",
 472                         "",
 473                         "SCSI2SD Firmware files (*.dfu)|*.dfu",
 474                         wxFD_OPEN | wxFD_FILE_MUST_EXIST);
 475                 if (dlg.ShowModal() == wxID_CANCEL) return;
 476
 477                 std::string filename(dlg.GetPath());
 478                 wxLogMessage("Attempting firmware update from file %s", filename);
 479
 480                 wxWindowPtr<wxGenericProgressDialog> progress(
 481                         new wxGenericProgressDialog(
 482                                 "Searching for bootloader",
 483                                 "Searching for bootloader",
 484                                 100,
 485                                 this,
 486                                 wxPD_AUTO_HIDE | wxPD_CAN_ABORT)
 487                                 );
 488                 mmLogStatus("Searching for bootloader");
 489                 bool versionChecked = false;
 490                 while (true)
 491                 {
 492                         try
 493                         {
 494                                 if (!myHID) myHID.reset(HID::Open());
 495                                 if (myHID)
 496                                 {
 497                                         if (!myHID->isCorrectFirmware(filename))
 498                                         {
 499                                                 wxMessageBox(
 500                                                         "Firmware does not match device hardware",
 501                                                         "Wrong filename",
 502                                                         wxOK | wxICON_ERROR);
 503                                                 return;
 504                                         }
 505                                         versionChecked = true;
 506
 507                                         mmLogStatus("Resetting SCSI2SD into bootloader");
 508
 509                                         myHID->enterBootloader();
 510                                         myHID.reset();
 511                                 }
 512
 513
 514                                 if (myDfu.hasDevice() && !versionChecked)
 515                                 {
 516                                         mmLogStatus("STM DFU Bootloader found, checking compatibility");
 517                                         progress->Show(0);
 518                                         if (!checkVersionMarker(filename))
 519                                         {
 520                                                 wxMessageBox(
 521                                                         "Firmware does not match device hardware",
 522                                                         "Wrong filename",
 523                                                         wxOK | wxICON_ERROR);
 524                                                 return;
 525                                         }
 526                                         versionChecked = true;
 527                                 }
 528
 529                                 if (myDfu.hasDevice())
 530                                 {
 531                                         mmLogStatus("STM DFU Bootloader found");
 532                                         progress->Show(10);
 533                                         doDFUUpdate(filename);
 534                                         return;
 535                                 }
 536                         }
 537                         catch (std::exception& e)
 538                         {
 539                                 mmLogStatus(e.what());
 540                                 myHID.reset();
 541                         }
 542                         wxMilliSleep(100);
 543                         if (!progress->Pulse())
 544                         {
 545                                 return; // user cancelled.
 546                         }
 547                 }
 548         }
 549
 550         bool checkVersionMarker(const std::string& firmware)
 551         {
 552                 std::stringstream ss;
 553 #ifdef __WINDOWS__
 554                 ss << "dfu-util ";
 555 #else
 556                 if (wxExecute("which dfu-util", wxEXEC_SYNC) == 0)
 557                 {
 558                         ss << "dfu-util ";
 559                 } else {
 560                         wxFileName exePath(wxStandardPaths::Get().GetExecutablePath());
 561                         ss << '"' << exePath.GetPathWithSep() << "dfu-util\" ";
 562                 }
 563 #endif
 564
 565                 std::string tmpFile =
 566                         wxFileName::CreateTempFileName(
 567                                 _("SCSI2SD_MARKER"), static_cast<wxFile*>(NULL));
 568                 wxRemoveFile(tmpFile); // dfu-util won't overwrite.
 569
 570                 ss << "--alt 2 -s 0x1FFF7800:4 -U \"" << tmpFile << "\"";
 571
 572                 wxLogMessage("Running: %s", ss.str());
 573
 574                 std::string cmd = ss.str();
 575                 long result = wxExecute(
 576                         cmd.c_str(),
 577                         wxEXEC_SYNC
 578                         );
 579                 if (result != 0)
 580                 {
 581                         wxLogMessage("OTP Version check failed.");
 582                         return false;
 583                 }
 584
 585                 // Ok, we now have a file with 8 bytes in it.
 586                 wxFile file(tmpFile);
 587                 if (file.Length() != 4)
 588                 {
 589                         wxLogMessage("OTP Version check file isn't 4 bytes.");
 590                         return false;
 591                 }
 592
 593                 uint8_t data[4];
 594                 if (file.Read(data, sizeof(data)) != sizeof(data))
 595                 {
 596                         wxMessageBox(
 597                                 "Couldn't read file",
 598                                 "Couldn't read file",
 599                                 wxOK | wxICON_ERROR);
 600                         return false;
 601                 }
 602                 wxRemoveFile(tmpFile);
 603
 604                 uint32_t value =
 605                         (((uint32_t)(data[0]))) |
 606                         (((uint32_t)(data[1])) << 8) |
 607                         (((uint32_t)(data[2])) << 16) |
 608                         (((uint32_t)(data[3])) << 24);
 609                 if (value == 0xFFFFFFFF)
 610                 {
 611                         // Not set, ignore.
 612                         wxLogMessage("OTP Hardware version not set. Ignoring.");
 613                         return true;
 614                 }
 615                 else if (value == 0x06002020)
 616                 {
 617                         wxLogMessage("Found V6 2020 hardware marker");
 618                         return firmware.rfind("firmware.V6.2020.dfu") != std::string::npos;
 619                 }
 620                 else if (value == 0x06002019)
 621                 {
 622                         wxLogMessage("Found V6 revF hardware marker");
 623                         return firmware.rfind("firmware.V6.revF.dfu") != std::string::npos ||
 624                                 firmware.rfind("firmware.dfu") != std::string::npos;
 625                 }
 626                 else
 627                 {
 628                         wxLogMessage("Found unknown hardware marker: %u", value);
 629                         return false; // Some unknown version.
 630                 }
 631         }
 632
 633
 634         void doDFUUpdate(const std::string& filename)
 635         {
 636                 if (filename.find(".dfu") == std::string::npos)
 637                 {
 638                         wxMessageBox(
 639                                 "Wrong filename",
 640                                 "SCSI2SD V6 requires a .dfu file",
 641                                 wxOK | wxICON_ERROR);
 642                         return;
 643                 }
 644
 645                 std::stringstream ss;
 646 #ifdef __WINDOWS__
 647                 ss << "dfu-util --download \""
 648                         << filename.c_str() << "\" --alt 0 --reset";
 649 #else
 650                 if (wxExecute("which dfu-util", wxEXEC_SYNC) == 0)
 651                 {
 652                         ss << "dfu-util ";
 653                 } else {
 654                         wxFileName exePath(wxStandardPaths::Get().GetExecutablePath());
 655                         ss << '"' << exePath.GetPathWithSep() << "dfu-util\" ";
 656                 }
 657                 ss << "--download \"" << filename.c_str() << "\" --alt 0 --reset";
 658 #endif
 659
 660                 wxLogMessage("Running: %s", ss.str());
 661
 662                 myConsoleProcess.reset(new wxProcess(this));
 663                 myConsoleProcess->Redirect();
 664                 std::string cmd = ss.str();
 665                 long result = wxExecute(
 666                         cmd.c_str(),
 667                         wxEXEC_ASYNC,
 668                         myConsoleProcess.get()
 669                         );
 670                 if (!result)
 671                 {
 672                         wxMessageBox(
 673                                 "Update failed",
 674                                 "Firmware update failed (dfu-util not found ?) Command = " + cmd,
 675                                 wxOK | wxICON_ERROR);
 676                         mmLogStatus("Firmware update failed");
 677                         myConsoleProcess.reset();
 678                 } else {
 679                         myConsoleStdout = myConsoleProcess->GetInputStream();
 680                         myConsoleStderr = myConsoleProcess->GetErrorStream();
 681                         wxFrame* frame(new wxFrame(this, wxID_ANY, "dfu-util"));
 682                         myConsoleTerm.reset(new TerminalWx(frame, wxID_ANY, wxDefaultPosition));
 683                         frame->Fit();
 684                         frame->Show();
 685                 }
 686         }
 687
 688         void redirectDfuOutput()
 689         {
 690                 if (myConsoleProcess)
 691                 {
 692                         std::stringstream ss;
 693                         while (myConsoleStderr && !myConsoleStderr->Eof() && myConsoleStderr->CanRead())
 694                         {
 695                                 int c = myConsoleStderr->GetC();
 696                                 if (c == '\n')
 697                                 {
 698                                         ss << "\r\n";
 699                                 }
 700                                 else if (c >= 0)
 701                                 {
 702                                         ss << (char) c;
 703                                 }
 704                         }
 705                         while (myConsoleStdout && !myConsoleStdout->Eof() && myConsoleStdout->CanRead())
 706                         {
 707                                 int c = myConsoleStdout->GetC();
 708                                 if (c == '\n')
 709                                 {
 710                                         ss << "\r\n";
 711                                 }
 712                                 else if (c >= 0)
 713                                 {
 714                                         ss << (char) c;
 715                                 }
 716                         }
 717                         myConsoleTerm->DisplayCharsUnsafe(ss.str());
 718                 }
 719         }
 720
 721         void doFinishDfu(wxProcessEvent& event)
 722         {
 723                 redirectDfuOutput();
 724
 725                 if (event.GetExitCode() == 0)
 726                 {
 727                         wxMessageBox(
 728                                 "Update complete",
 729                                 "Firmware update complete. Please reconnect USB cable.",
 730                                 wxOK | wxICON_ERROR);
 731                         mmLogStatus("Firmware update succeeded");
 732                 } else {
 733                         wxMessageBox(
 734                                 "Update failed",
 735                                 "Firmware update failed.",
 736                                 wxOK | wxICON_ERROR);
 737                         mmLogStatus("Firmware update failed");
 738                 }
 739
 740                 myConsoleStdout = myConsoleStderr = NULL;
 741                 myConsoleProcess.reset();
 742                 myConsoleTerm->GetParent()->Close();
 743                 myConsoleTerm->Close();
 744                 myConsoleTerm.reset();
 745
 746         }
 747
 748         void dumpSCSICommand(std::vector<uint8_t> buf)
 749         {
 750                 std::stringstream msg;
 751                 msg << std::hex;
 752                 for (size_t i = 0; i < 32 && i < buf.size(); ++i)
 753                 {
 754                         msg << std::setfill('0') << std::setw(2) <<
 755                         static_cast<int>(buf[i]) << ' ';
 756                 }
 757                 wxLogMessage(this, msg.str().c_str());
 758         }
 759
 760         void logSCSI()
 761         {
 762                 if (!mySCSILogChk->IsChecked() ||
 763                         !myHID)
 764                 {
 765                         return;
 766                 }
 767                 try
 768                 {
 769                         std::vector<uint8_t> info;
 770                         if (myHID->readSCSIDebugInfo(info))
 771                         {
 772                                 dumpSCSICommand(info);
 773                         }
 774                 }
 775                 catch (std::exception& e)
 776                 {
 777                         wxLogWarning(this, e.what());
 778                         myHID.reset();
 779                 }
 780         }
 781
 782         void OnID_Timer(wxTimerEvent& event)
 783         {
 784                 redirectDfuOutput();
 785
 786                 logSCSI();
 787                 time_t now = time(NULL);
 788                 if (now == myLastPollTime) return;
 789                 myLastPollTime = now;
 790
 791                 // Check if we are connected to the HID device.
 792                 try
 793                 {
 794                         if (myHID && !myHID->ping())
 795                         {
 796                                 // Verify the USB HID connection is valid
 797                                 myHID.reset();
 798                         }
 799
 800                         if (!myHID)
 801                         {
 802                                 myHID.reset(HID::Open());
 803                                 if (myHID)
 804                                 {
 805                                         std::stringstream msg;
 806                                         msg << "SCSI2SD Ready, firmware version " <<
 807                                                 myHID->getFirmwareVersionStr();
 808                                         mmLogStatus(msg.str());
 809
 810                                         std::stringstream devInfo;
 811                                         devInfo << "Hardware version: " <<
 812                                                 myHID->getHardwareVersion() << std::endl <<
 813                                                 "Serial Number: " <<
 814                                                 myHID->getSerialNumber();
 815                                         wxLogMessage(this, "%s", devInfo.str());
 816
 817                                         std::vector<uint8_t> csd(myHID->getSD_CSD());
 818                                         std::vector<uint8_t> cid(myHID->getSD_CID());
 819                                         std::stringstream sdinfo;
 820                                         sdinfo << "SD Capacity (512-byte sectors): " <<
 821                                                 myHID->getSDCapacity() << std::endl;
 822
 823                                         sdinfo << "SD CSD Register: ";
 824                                         for (size_t i = 0; i < csd.size(); ++i)
 825                                         {
 826                                                 sdinfo <<
 827                                                         std::hex << std::setfill('0') << std::setw(2) <<
 828                                                         static_cast<int>(csd[i]);
 829                                         }
 830                                         sdinfo << std::endl;
 831                                         sdinfo << "SD CID Register: ";
 832                                         for (size_t i = 0; i < cid.size(); ++i)
 833                                         {
 834                                                 sdinfo <<
 835                                                         std::hex << std::setfill('0') << std::setw(2) <<
 836                                                         static_cast<int>(cid[i]);
 837                                         }
 838
 839                                         wxLogMessage(this, "%s", sdinfo.str());
 840
 841                                         if (mySelfTestChk->IsChecked())
 842                                         {
 843                                                 std::stringstream scsiInfo;
 844                                                 int errcode;
 845                                                 scsiInfo << "SCSI Self-Test: ";
 846                                                 if (myHID->scsiSelfTest(errcode))
 847                                                 {
 848                                                         scsiInfo << "Passed";
 849                                                 }
 850                                                 else
 851                                                 {
 852                                                         scsiInfo << "FAIL (" << errcode << ")";
 853                                                 }
 854                                                 wxLogMessage(this, "%s", scsiInfo.str());
 855                                         }
 856
 857                                         if (!myInitialConfig)
 858                                         {
 859 /* This doesn't work properly, and causes crashes.
 860                                                 wxCommandEvent loadEvent(wxEVT_NULL, ID_BtnLoad);
 861                                                 GetEventHandler()->AddPendingEvent(loadEvent);
 862 */
 863                                         }
 864
 865                                 }
 866                                 else
 867                                 {
 868                                         char ticks[] = {'/', '-', '\\', '|'};
 869                                         std::stringstream ss;
 870                                         ss << "Searching for SCSI2SD device " << ticks[myTickCounter % sizeof(ticks)];
 871                                         myTickCounter++;
 872                                         SetStatusText(ss.str());
 873                                 }
 874                         }
 875                 }
 876                 catch (std::runtime_error& e)
 877                 {
 878                         std::cerr << e.what() << std::endl;
 879                         mmLogStatus(e.what());
 880                 }
 881
 882                 evaluate();
 883         }
 884
 885         void doLoad(wxCommandEvent& event)
 886         {
 887                 TimerLock lock(myTimer);
 888                 if (!myHID) return;
 889
 890                 mmLogStatus("Loading configuration");
 891
 892                 wxWindowPtr<wxGenericProgressDialog> progress(
 893                         new wxGenericProgressDialog(
 894                                 "Load config settings",
 895                                 "Loading config settings",
 896                                 100,
 897                                 this,
 898                                 wxPD_CAN_ABORT | wxPD_REMAINING_TIME)
 899                                 );
 900
 901                 int currentProgress = 0;
 902                 int totalProgress = 2;
 903
 904                 std::vector<uint8_t> cfgData(S2S_CFG_SIZE);
 905                 uint32_t sector = myHID->getSDCapacity() - 2;
 906                 for (size_t i = 0; i < 2; ++i)
 907                 {
 908                         std::stringstream ss;
 909                         ss << "Reading sector " << sector;
 910                         mmLogStatus(ss.str());
 911                         currentProgress += 1;
 912                         if (currentProgress == totalProgress)
 913                         {
 914                                 ss.str("Load Complete.");
 915                                 mmLogStatus("Load Complete.");
 916                         }
 917
 918                         if (!progress->Update(
 919                                         (100 * currentProgress) / totalProgress,
 920                                         ss.str()
 921                                         )
 922                                 )
 923                         {
 924                                 goto abort;
 925                         }
 926
 927                         std::vector<uint8_t> sdData;
 928
 929                         try
 930                         {
 931                                 myHID->readSector(sector++, sdData);
 932                         }
 933                         catch (std::runtime_error& e)
 934                         {
 935                                 mmLogStatus(e.what());
 936                                 goto err;
 937                         }
 938
 939                         std::copy(
 940                                 sdData.begin(),
 941                                 sdData.end(),
 942                                 &cfgData[i * 512]);
 943                 }
 944
 945                 myBoardPanel->setConfig(ConfigUtil::boardConfigFromBytes(&cfgData[0]));
 946                 for (int i = 0; i < S2S_MAX_TARGETS; ++i)
 947                 {
 948                         myTargets[i]->setConfig(
 949                                 ConfigUtil::fromBytes(
 950                                         &cfgData[sizeof(S2S_BoardCfg) + i * sizeof(S2S_TargetCfg)]
 951                                         )
 952                                 );
 953                 }
 954
 955                 myInitialConfig = true;
 956                 goto out;
 957
 958         err:
 959                 mmLogStatus("Load failed");
 960                 progress->Update(100, "Load failed");
 961                 goto out;
 962
 963         abort:
 964                 mmLogStatus("Load Aborted");
 965
 966         out:
 967                 return;
 968
 969         }
 970
 971         void doSave(wxCommandEvent& event)
 972         {
 973                 TimerLock lock(myTimer);
 974                 if (!myHID) return;
 975
 976                 mmLogStatus("Saving configuration");
 977
 978                 wxWindowPtr<wxGenericProgressDialog> progress(
 979                         new wxGenericProgressDialog(
 980                                 "Save config settings",
 981                                 "Saving config settings",
 982                                 100,
 983                                 this,
 984                                 wxPD_CAN_ABORT | wxPD_REMAINING_TIME)
 985                                 );
 986
 987
 988                 int currentProgress = 0;
 989                 int totalProgress = 2;
 990
 991                 std::vector<uint8_t> cfgData(
 992                         ConfigUtil::boardConfigToBytes(myBoardPanel->getConfig())
 993                         );
 994                 for (int i = 0; i < S2S_MAX_TARGETS; ++i)
 995                 {
 996                         std::vector<uint8_t> raw(
 997                                 ConfigUtil::toBytes(myTargets[i]->getConfig())
 998                                 );
 999                         cfgData.insert(cfgData.end(), raw.begin(), raw.end());
1000                 }
1001
1002                 uint32_t sector = myHID->getSDCapacity() - 2;
1003
1004                 for (size_t i = 0; i < 2; ++i)
1005                 {
1006                         std::stringstream ss;
1007                         ss << "Writing SD sector " << sector;
1008                         mmLogStatus(ss.str());
1009                         currentProgress += 1;
1010
1011                         if (currentProgress == totalProgress)
1012                         {
1013                                 ss.str("Save Complete.");
1014                                 mmLogStatus("Save Complete.");
1015                         }
1016                         if (!progress->Update(
1017                                         (100 * currentProgress) / totalProgress,
1018                                         ss.str()
1019                                         )
1020                                 )
1021                         {
1022                                 goto abort;
1023                         }
1024
1025                         try
1026                         {
1027                                 std::vector<uint8_t> buf;
1028                                 buf.insert(buf.end(), &cfgData[i * 512], &cfgData[(i+1) * 512]);
1029                                 myHID->writeSector(sector++, buf);
1030                         }
1031                         catch (std::runtime_error& e)
1032                         {
1033                                 mmLogStatus(e.what());
1034                                 goto err;
1035                         }
1036                 }
1037
1038                 myHID.reset();
1039
1040                 goto out;
1041
1042         err:
1043                 mmLogStatus("Save failed");
1044                 progress->Update(100, "Save failed");
1045                 goto out;
1046
1047         abort:
1048                 mmLogStatus("Save Aborted");
1049
1050         out:
1051                 return;
1052
1053         }
1054
1055         // Note: Don't confuse this with the wxApp::OnExit virtual method
1056         void OnExitEvt(wxCommandEvent& event);
1057
1058         void OnCloseEvt(wxCloseEvent& event);
1059
1060         void OnAbout(wxCommandEvent& event)
1061         {
1062                 wxMessageBox(
1063                         "SCSI2SD (scsi2sd-util6)\n"
1064                         "Copyright (C) 2014-2017 Michael McMaster <michael@codesrc.com>\n"
1065                         "\n"
1066 "This program is free software: you can redistribute it and/or modify\n"
1067 "it under the terms of the GNU General Public License as published by\n"
1068 "the Free Software Foundation, either version 3 of the License, or\n"
1069 "(at your option) any later version.\n"
1070 "\n"
1071 "This program is distributed in the hope that it will be useful,\n"
1072 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1073 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
1074 "GNU General Public License for more details.\n"
1075 "\n"
1076 "You should have received a copy of the GNU General Public License\n"
1077 "along with this program.  If not, see <http://www.gnu.org/licenses/>.\n",
1078
1079                         "About scsi2sd-util6", wxOK | wxICON_INFORMATION );
1080         }
1081
1082         wxDECLARE_EVENT_TABLE();
1083 };
1084
1085 wxBEGIN_EVENT_TABLE(AppFrame, wxFrame)
1086         EVT_MENU(AppFrame::ID_ConfigDefaults, AppFrame::OnID_ConfigDefaults)
1087         EVT_MENU(AppFrame::ID_Firmware, AppFrame::OnID_Firmware)
1088         EVT_MENU(AppFrame::ID_LogWindow, AppFrame::OnID_LogWindow)
1089         EVT_MENU(AppFrame::ID_SaveFile, AppFrame::OnID_SaveFile)
1090         EVT_MENU(AppFrame::ID_OpenFile, AppFrame::OnID_OpenFile)
1091         EVT_MENU(wxID_EXIT, AppFrame::OnExitEvt)
1092         EVT_MENU(wxID_ABOUT, AppFrame::OnAbout)
1093
1094         EVT_TIMER(AppFrame::ID_Timer, AppFrame::OnID_Timer)
1095
1096         EVT_COMMAND(wxID_ANY, ConfigChangedEvent, AppFrame::onConfigChanged)
1097
1098         EVT_MENU(ID_BtnSave, AppFrame::doSave)
1099         EVT_MENU(ID_BtnLoad, AppFrame::doLoad)
1100
1101         EVT_CLOSE(AppFrame::OnCloseEvt)
1102
1103         EVT_END_PROCESS(wxID_ANY, AppFrame::doFinishDfu)
1104
1105 wxEND_EVENT_TABLE()
1106
1107
1108
1109 class App : public wxApp
1110 {
1111 public:
1112         virtual bool OnInit()
1113         {
1114                 AppFrame* frame = new AppFrame();
1115                 frame->Show(true);
1116                 SetTopWindow(frame);
1117                 return true;
1118         }
1119 };
1120 } // namespace
1121
1122 // Main Method
1123 wxIMPLEMENT_APP(App);
1124
1125 void
1126 AppFrame::OnExitEvt(wxCommandEvent& event)
1127 {
1128         wxGetApp().ExitMainLoop();
1129 }
1130
1131 void
1132 AppFrame::OnCloseEvt(wxCloseEvent& event)
1133 {
1134         wxGetApp().ExitMainLoop();
1135 }
1136