Line data    Source code

       1             : // ---------------------------------------------------------------------------
       2             : // USB EPROM/Flash Programmer
       3             : //
       4             : // Copyright (2023) Robson Martins
       5             : //
       6             : // This work is licensed under a Creative Commons Attribution-NonCommercial-
       7             : // ShareAlike 4.0 International License.
       8             : // ---------------------------------------------------------------------------
       9             : /**
      10             :  * @ingroup Software
      11             :  * @file backend/devices/device.cpp
      12             :  * @brief Implementation of the Base class of a Device.
      13             :  *
      14             :  * @author Robson Martins (https://www.robsonmartins.com)
      15             :  */
      16             : // ---------------------------------------------------------------------------
      17             : 
      18             : #include <QMap>
      19             : #include <QTextStream>
      20             : #include <QLoggingCategory>
      21             : 
      22             : #include "backend/devices/device.hpp"
      23             : 
      24             : // ---------------------------------------------------------------------------
      25             : // Logging
      26             : 
      27        1062 : Q_LOGGING_CATEGORY(device, "device")
      28             : 
      29             : #define DEBUG qCDebug(device)
      30             : #define INFO qCInfo(device)
      31             : #define WARNING qCWarning(device)
      32             : #define CRITICAL qCCritical(device)
      33             : #define FATAL qCFatal(device)
      34             : 
      35             : // ---------------------------------------------------------------------------
      36             : 
      37             : // clang-format off
      38             : /* @brief List of Manufacturers. */
      39             : const QMap<uint8_t, QString> kManufacturerList = {
      40             :     {0x01, "AMD"                    },
      41             :     {0x02, "Macronix"               },
      42             :     {0x04, "Fujitsu"                },
      43             :     {0x07, "Maxwell"                },
      44             :     {0x0C, "Microchip"              },
      45             :     {0x29, "Microchip"              },
      46             :     {0x15, "NXP/Philips/Signetics"  },
      47             :     {0x1C, "EON"                    },
      48             :     {0x1E, "Atmel"                  },
      49             :     {0x1F, "Atmel"                  },
      50             :     {0x20, "ST"                     },
      51             :     {0x31, "Catalyst"               },
      52             :     {0x37, "AMIC"                   },
      53             :     {0x38, "Winbond"                },
      54             :     {0x40, "SyncMOS"                },
      55             :     {0x42, "SyncMOS"                },
      56             :     {0x49, "Toshiba"                },
      57             :     {0x4A, "Macronix/MXIC"          },
      58             :     {0xC2, "Macronix/MXIC"          },
      59             :     {0x50, "Spansion"               },
      60             :     {0x7F, "Adesto"                 },
      61             :     {0x89, "Intel/Texas Instruments"},
      62             :     {0x8F, "Fairchild/National"     },
      63             :     {0x9D, "Xicor"                  },
      64             :     {0xAD, "Hyundai"                },
      65             :     {0xB0, "Sharp"                  },
      66             :     {0xBF, "SST/Sanyo"              },
      67             :     {0xC8, "GigaDevice"             },
      68             :     {0xDA, "ASD/WinBond"            },
      69             :     {0xEF, "ISSI"                   }
      70             : };
      71             : // clang-format on
      72             : 
      73             : // ---------------------------------------------------------------------------
      74             : 
      75           1 : TDeviceID::TDeviceID() : manufacturer(0), device(0) {}
      76             : 
      77         256 : QString TDeviceID::getManufacturerName(void) const {
      78         256 :     if (!kManufacturerList.contains(manufacturer)) {
      79         226 :         return Device::tr("Unknown");
      80             :     }
      81          30 :     return kManufacturerList.value(manufacturer);
      82             : }
      83             : 
      84             : // ---------------------------------------------------------------------------
      85             : 
      86          13 : TDeviceCapabilities::TDeviceCapabilities()
      87          13 :     : hasProgram(false),
      88          13 :       hasVerify(false),
      89          13 :       hasErase(false),
      90          13 :       hasGetId(false),
      91          13 :       hasRead(false),
      92          13 :       hasBlankCheck(false),
      93          13 :       hasUnprotect(false),
      94          13 :       hasProtect(false),
      95          13 :       hasSectorSize(false),
      96          13 :       hasFastProg(false),
      97          13 :       hasSkipFF(false),
      98          13 :       hasVDD(false),
      99          13 :       hasVPP(false) {}
     100             : 
     101             : // ---------------------------------------------------------------------------
     102             : 
     103          13 : TDeviceInformation::TDeviceInformation()
     104          13 :     : deviceType(kDeviceParallelMemory), name("") {}
     105             : 
     106          44 : QString TDeviceInformation::toString() const {
     107          44 :     QString result;
     108          44 :     QTextStream ts(&result);
     109          44 :     ts << "Name: " << name;
     110          44 :     ts << "; Type: ";
     111          44 :     switch (deviceType) {
     112          44 :         case kDeviceParallelMemory:
     113          44 :             ts << "Parallel Memory";
     114          44 :             break;
     115           0 :         case kDeviceSerialMemory:
     116           0 :             ts << "Serial Memory";
     117           0 :             break;
     118           0 :         default:
     119           0 :             ts << "Unknown";
     120           0 :             break;
     121             :     }
     122          44 :     ts << "; Capabilities: [";
     123          44 :     ts << "hasProgram=" << (capability.hasProgram ? 1 : 0);
     124          44 :     ts << ", hasVerify=" << (capability.hasVerify ? 1 : 0);
     125          44 :     ts << ", hasErase=" << (capability.hasErase ? 1 : 0);
     126          44 :     ts << ", hasGetId=" << (capability.hasGetId ? 1 : 0);
     127          44 :     ts << ", hasRead=" << (capability.hasRead ? 1 : 0);
     128          44 :     ts << ", hasBlankCheck=" << (capability.hasBlankCheck ? 1 : 0);
     129          44 :     ts << ", hasUnprotect=" << (capability.hasUnprotect ? 1 : 0);
     130          44 :     ts << ", hasProtect=" << (capability.hasProtect ? 1 : 0);
     131          44 :     ts << ", hasSectorSize=" << (capability.hasSectorSize ? 1 : 0);
     132          44 :     ts << ", hasFastProg=" << (capability.hasFastProg ? 1 : 0);
     133          44 :     ts << ", hasSkipFF=" << (capability.hasSkipFF ? 1 : 0);
     134          44 :     ts << ", hasVDD=" << (capability.hasVDD ? 1 : 0);
     135          44 :     ts << ", hasVPP=" << (capability.hasVPP ? 1 : 0);
     136          44 :     ts << "]";
     137          88 :     return result;
     138          44 : }
     139             : 
     140             : // ---------------------------------------------------------------------------
     141             : 
     142          13 : Device::Device(QObject *parent)
     143             :     : QObject(parent),
     144          13 :       maxAttemptsProg_(1),
     145          13 :       canceling_(false),
     146          13 :       size_(0),
     147          13 :       twp_(1),
     148          13 :       twc_(1),
     149          13 :       vddRd_(5.0f),
     150          13 :       vddWr_(5.0f),
     151          13 :       vpp_(12.0f),
     152          13 :       vee_(12.0f),
     153          13 :       skipFF_(false),
     154          13 :       fastProg_(false),
     155          13 :       sectorSize_(0),
     156          13 :       algo_(kCmdDeviceAlgorithmUnknown),
     157          13 :       runner_(this) {
     158          13 :     info_.deviceType = kDeviceParallelMemory;
     159          13 :     info_.name = "Device";
     160          13 :     info_.capability.hasProgram = false;
     161          13 :     info_.capability.hasVerify = false;
     162          13 :     info_.capability.hasErase = false;
     163          13 :     info_.capability.hasGetId = false;
     164          13 :     info_.capability.hasRead = false;
     165          13 :     info_.capability.hasBlankCheck = false;
     166          13 :     info_.capability.hasUnprotect = false;
     167          13 :     info_.capability.hasProtect = false;
     168          13 :     info_.capability.hasSectorSize = false;
     169          13 :     info_.capability.hasFastProg = false;
     170          13 :     info_.capability.hasSkipFF = false;
     171          13 :     info_.capability.hasVDD = true;
     172          13 :     info_.capability.hasVPP = false;
     173          13 :     flags_.skipFF = false;
     174          13 :     flags_.progWithVpp = false;
     175          13 :     flags_.vppOePin = false;
     176          13 :     flags_.pgmCePin = false;
     177          13 :     flags_.pgmPositive = false;
     178          13 :     flags_.is16bit = false;
     179          13 : }
     180             : 
     181          13 : Device::~Device() {}
     182             : 
     183           0 : bool Device::is16Bit() const {
     184           0 :     return flags_.is16bit;
     185             : }
     186             : 
     187          40 : void Device::setPort(const QString &path) {
     188          40 :     if (port_ == path) return;
     189          13 :     port_ = path;
     190             : }
     191             : 
     192          40 : QString Device::getPort() const {
     193          40 :     return port_;
     194             : }
     195             : 
     196         520 : uint8_t Device::getBufferSize() const {
     197         520 :     return runner_.getBufferSize();
     198             : }
     199             : 
     200          40 : void Device::setBufferSize(uint8_t value) {
     201          40 :     runner_.setBufferSize(value);
     202          40 : }
     203             : 
     204          41 : void Device::setSize(uint32_t value) {
     205          41 :     if (size_ != value) {
     206          27 :         if (value) size_ = value;
     207             :     }
     208          82 :     DEBUG << "Size: " << QString("%1").arg(size_);
     209          41 : }
     210             : 
     211          40 : uint32_t Device::getSize() const {
     212          40 :     return size_;
     213             : }
     214             : 
     215          40 : void Device::setTwp(uint32_t us) {
     216          40 :     if (twp_ != us) {
     217          12 :         if (us) twp_ = us;
     218             :     }
     219          80 :     DEBUG << "tWP: " << QString("%1").arg(twp_);
     220          40 : }
     221             : 
     222          40 : uint32_t Device::getTwp() const {
     223          40 :     return twp_;
     224             : }
     225             : 
     226          40 : void Device::setTwc(uint32_t us) {
     227          40 :     if (twc_ != us) {
     228          12 :         if (us) twc_ = us;
     229             :     }
     230          80 :     DEBUG << "tWC: " << QString("%1").arg(twc_);
     231          40 : }
     232             : 
     233          40 : uint32_t Device::getTwc() const {
     234          40 :     return twc_;
     235             : }
     236             : 
     237          40 : void Device::setVddRd(float value) {
     238          40 :     if (vddRd_ != value) {
     239          13 :         if (value >= 0.0f) vddRd_ = value;
     240             :     }
     241          80 :     DEBUG << "VDD Read: " << QString("%1").arg(vddRd_, 4, 'f', 2);
     242          40 : }
     243             : 
     244          40 : float Device::getVddRd() const {
     245          40 :     return vddRd_;
     246             : }
     247             : 
     248          40 : void Device::setVddWr(float value) {
     249          40 :     if (vddWr_ != value) {
     250          13 :         if (value >= 0.0f) vddWr_ = value;
     251             :     }
     252          80 :     DEBUG << "VDD Prog: " << QString("%1").arg(vddWr_, 4, 'f', 2);
     253          40 : }
     254             : 
     255          40 : float Device::getVddWr() const {
     256          40 :     return vddWr_;
     257             : }
     258             : 
     259          40 : void Device::setVpp(float value) {
     260          40 :     if (vpp_ != value) {
     261          13 :         if (value >= 0.0f) vpp_ = value;
     262             :     }
     263          80 :     DEBUG << "VPP: " << QString("%1").arg(vpp_, 4, 'f', 2);
     264          40 : }
     265             : 
     266          40 : float Device::getVpp() const {
     267          40 :     return vpp_;
     268             : }
     269             : 
     270          40 : void Device::setVee(float value) {
     271          40 :     if (vee_ != value) {
     272          13 :         if (value >= 0.0f) vee_ = value;
     273             :     }
     274          80 :     DEBUG << "VEE: " << QString("%1").arg(vee_, 4, 'f', 2);
     275          40 : }
     276             : 
     277          40 : float Device::getVee() const {
     278          40 :     return vee_;
     279             : }
     280             : 
     281          80 : void Device::setSkipFF(bool value) {
     282          80 :     if (skipFF_ != value) skipFF_ = value;
     283         160 :     DEBUG << "Skip 0xFF: " << QString("%1").arg(skipFF_ ? 1 : 0);
     284          80 : }
     285             : 
     286          40 : bool Device::getSkipFF() const {
     287          40 :     return skipFF_;
     288             : }
     289             : 
     290          86 : void Device::setFastProg(bool value) {
     291          86 :     if (fastProg_ != value) fastProg_ = value;
     292         172 :     DEBUG << "Fast Prog/Erase: " << QString("%1").arg(fastProg_ ? 1 : 0);
     293          86 : }
     294             : 
     295          40 : bool Device::getFastProg() const {
     296          40 :     return fastProg_;
     297             : }
     298             : 
     299          84 : void Device::setSectorSize(uint16_t value) {
     300          84 :     if (sectorSize_ != value) sectorSize_ = value;
     301         168 :     DEBUG << "Sector Size: " << QString("%1").arg(sectorSize_);
     302          84 : }
     303             : 
     304          40 : uint16_t Device::getSectorSize() const {
     305          40 :     return sectorSize_;
     306             : }
     307             : 
     308          40 : TDeviceInformation Device::getInfo() const {
     309          40 :     return info_;
     310             : }
     311             : 
     312          40 : void Device::cancel() {
     313          40 :     if (canceling_) return;
     314          40 :     canceling_ = true;
     315             : }
     316             : 
     317           0 : bool Device::getId(TDeviceID &result) {
     318             :     (void)result;
     319           0 :     return false;
     320             : }
     321             : 
     322           0 : bool Device::read(QByteArray &buffer) {
     323             :     (void)buffer;
     324           0 :     return false;
     325             : }
     326             : 
     327           0 : bool Device::program(const QByteArray &buffer, bool verify) {
     328             :     (void)buffer;
     329             :     (void)verify;
     330           0 :     return false;
     331             : }
     332             : 
     333           0 : bool Device::verify(const QByteArray &buffer) {
     334             :     (void)buffer;
     335           0 :     return false;
     336             : }
     337             : 
     338           0 : bool Device::erase(bool check) {
     339             :     (void)check;
     340           0 :     return false;
     341             : }
     342             : 
     343           0 : bool Device::blankCheck() {
     344           0 :     return false;
     345             : }
     346             : 
     347           0 : bool Device::unprotect() {
     348           0 :     return false;
     349             : }
     350             : 
     351           0 : bool Device::protect() {
     352           0 :     return false;
     353             : }