companion/src/storage/firmwareinterface.cpp

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include "hexinterface.h"
  22 #include "splash.h"
  23 #include "firmwareinterface.h"
  24 #include "helpers.h"
  25 #include "storage.h"
  26
  27 #include <QFile>
  28
  29 #define FW_MARK     "FW"
  30 #define VERS_MARK   "VERS"
  31 #define DATE_MARK   "DATE"
  32 #define TIME_MARK   "TIME"
  33 #define EEPR_MARK   "EEPR"
  34 #define FSIZE_MAX   Boards::getFlashSize(Board::BOARD_UNKNOWN)
  35
  36 FirmwareInterface::FirmwareInterface(const QString & filename):
  37   flash(FSIZE_MAX, 0),
  38   flashSize(0),
  39   versionId(0),
  40   eepromVersion(0),
  41   eepromVariant(0),
  42   splashOffset(0),
  43   splashSize(0),
  44   splashWidth(0),
  45   splashHeight(0),
  46   isValidFlag(false)
  47 {
  48   if (!filename.isEmpty()) {
  49     QFile file(filename);
  50     if (file.open(QIODevice::ReadOnly | QIODevice::Text)) { // reading HEX TEXT file
  51       QTextStream inputStream(&file);
  52       flashSize = HexInterface(inputStream).load((uint8_t *)flash.data(), FSIZE_MAX);
  53       file.close();
  54       if (flashSize == 0) {
  55         file.open(QIODevice::ReadOnly);
  56         flashSize = file.read((char *)flash.data(), FSIZE_MAX);
  57       }
  58     }
  59   }
  60
  61   if (flashSize > 0) {
  62     flavour = seekLabel(FW_MARK);
  63     version = seekLabel(VERS_MARK);
  64     if (version.startsWith("opentx-")) {
  65       // old version format
  66       int index = version.lastIndexOf('-');
  67       flavour = version.mid(0, index);
  68       version = version.mid(index+1);
  69     }
  70     date = seekLabel(DATE_MARK);
  71     time = seekLabel(TIME_MARK);
  72     eepromId = seekLabel(EEPR_MARK);
  73
  74     if (eepromId.contains('-')) {
  75       QStringList list = eepromId.split('-');
  76       eepromVersion = list[0].toInt();
  77       eepromVariant = list[1].toInt();
  78     }
  79     else {
  80       eepromVersion = eepromId.toInt();
  81     }
  82
  83     versionId = version2index(version);
  84     seekSplash();
  85     isValidFlag = !version.isEmpty();
  86   }
  87 }
  88
  89 QString FirmwareInterface::seekString(const QString & string)
  90 {
  91   QString result = "";
  92
  93   int start = flash.indexOf(string);
  94   if (start > 0) {
  95     start += string.length();
  96     int end = -1;
  97     for (int i=start; i<start+50; i++) {
  98       char c = flash.at(i);
  99       if (c == '\0' || c == '\036') {
 100         end = i;
 101         break;
 102       }
 103     }
 104     if (end > 0) {
 105       result = flash.mid(start, (end - start)).trimmed();
 106     }
 107   }
 108
 109   return result;
 110 }
 111
 112 QString FirmwareInterface::seekLabel(const QString & label)
 113 {
 114   QString result = seekString(label + "\037\033:");
 115   if (result.isEmpty()) {
 116     result = seekString(label + "\037\075:"); // This is for Horus
 117   }
 118   if (!result.isEmpty()) {
 119     return result;
 120   }
 121   return seekString(label + ":");
 122 }
 123
 124 QString FirmwareInterface::getFlavour() const
 125 {
 126   if (flavour == "opentx-taranis-x9e")
 127     return "opentx-x9e";
 128   else if (flavour == "opentx-x9dp" || flavour == "opentx-taranis-plus")
 129     return "opentx-x9d+";
 130   else if (flavour == "opentx-taranis")
 131     return "opentx-x9d";
 132   else if (flavour == "opentx-horus")
 133     return "opentx-x12s";
 134   else
 135     return flavour;
 136 }
 137
 138 bool FirmwareInterface::isHardwareCompatible(const FirmwareInterface &previousFirmware) const
 139 {
 140   QString newFlavour = getFlavour();
 141   if (newFlavour.isEmpty()) {
 142     return true;
 143   }
 144   QString previousFlavour = previousFirmware.getFlavour();
 145   if (previousFlavour.isEmpty()) {
 146     return true;
 147   }
 148   return (newFlavour == previousFlavour);
 149 }
 150
 151 bool FirmwareInterface::seekSplash(QByteArray splash)
 152 {
 153   int start = flash.indexOf(splash);
 154   if (start>0) {
 155     splashOffset = start;
 156     splashSize = splash.size();
 157     return true;
 158   }
 159   else {
 160     return false;
 161   }
 162 }
 163
 164 bool FirmwareInterface::seekSplash(QByteArray sps, QByteArray spe, int size)
 165 {
 166   int start = 0;
 167   while (start>=0) {
 168     start = flash.indexOf(sps, start+1);
 169     if (start>0) {
 170       int end = start + sps.size() + size;
 171       if (end == flash.indexOf(spe, end)) {
 172         splashOffset = start + sps.size();
 173         splashSize = end - start - sps.size();
 174         return true;
 175       }
 176       else {
 177         qDebug() << flash.indexOf(spe, start) << end << sps.size() << spe;
 178       }
 179     }
 180   }
 181   return false;
 182 }
 183
 184 #define OTX_SPS_9X      "SPS\0\200\100"
 185 #define OTX_SPS_TARANIS "SPS\0\324\100"
 186 #define OTX_SPS_SIZE    6
 187 #define OTX_SPE         "SPE"
 188 #define OTX_SPE_SIZE    4
 189
 190 void FirmwareInterface::seekSplash()
 191 {
 192   splashSize = 0;
 193   splashOffset = 0;
 194   splashWidth = SPLASH_WIDTH;
 195   splashHeight = SPLASH_HEIGHT;
 196   splash_format = QImage::Format_Mono;
 197
 198   if (seekSplash(QByteArray((const char *)gr9x_splash, sizeof(gr9x_splash))) || seekSplash(QByteArray((const char *)gr9xv4_splash, sizeof(gr9xv4_splash)))) {
 199     return;
 200   }
 201
 202   if (seekSplash(QByteArray((const char *)er9x_splash, sizeof(er9x_splash)))) {
 203     return;
 204   }
 205
 206   if (seekSplash(QByteArray((const char *)opentx_splash, sizeof(opentx_splash)))) {
 207     return;
 208   }
 209
 210   if (seekSplash(QByteArray((const char *)opentxtaranis_splash, sizeof(opentxtaranis_splash)))) {
 211     splashWidth = SPLASHX9D_WIDTH;
 212     splashHeight = SPLASHX9D_HEIGHT;
 213     splash_format = QImage::Format_Indexed8;
 214     return;
 215   }
 216
 217   if (seekSplash(QByteArray((const char *)ersky9x_splash, sizeof(ersky9x_splash)))) {
 218     return;
 219   }
 220
 221   if (seekSplash(QByteArray(OTX_SPS_9X, OTX_SPS_SIZE), QByteArray(OTX_SPE, OTX_SPE_SIZE), 1024)) {
 222     return;
 223   }
 224
 225   if (seekSplash(QByteArray(OTX_SPS_TARANIS, OTX_SPS_SIZE), QByteArray(OTX_SPE, OTX_SPE_SIZE), 6784)) {
 226     splashWidth = SPLASHX9D_WIDTH;
 227     splashHeight = SPLASHX9D_HEIGHT;
 228     splash_format = QImage::Format_Indexed8;
 229     return;
 230   }
 231
 232   if (seekSplash(QByteArray(ERSKY9X_SPS, sizeof(ERSKY9X_SPS)), QByteArray(ERSKY9X_SPE, sizeof(ERSKY9X_SPE)), 1030)) {
 233     return;
 234   }
 235
 236   if (seekSplash(QByteArray(ERSPLASH_MARKER, sizeof(ERSPLASH_MARKER)))) {
 237     splashOffset += sizeof(ERSPLASH_MARKER);
 238     splashSize = sizeof(er9x_splash);
 239   }
 240 }
 241
 242 bool FirmwareInterface::setSplash(const QImage & newsplash)
 243 {
 244   if (splashOffset == 0 || splashSize == 0) {
 245     return false;
 246   }
 247
 248   char b[SPLASH_SIZE_MAX] = {0};
 249   QColor color;
 250   QByteArray splash;
 251   if (splash_format == QImage::Format_Indexed8) {
 252     for (unsigned int y=0; y<splashHeight; y++) {
 253       unsigned int idx = (y/2)*splashWidth;
 254       for (unsigned int x=0; x<splashWidth; x++, idx++) {
 255         QRgb gray = qGray(newsplash.pixel(x, y));
 256         uint8_t z = ((255-gray)*15)/255;
 257         if (y & 1) z <<= 4;
 258         b[idx] |= z;
 259       }
 260     }
 261   }
 262   else {
 263     QColor black = QColor(0,0,0);
 264     QImage blackNwhite = newsplash.convertToFormat(QImage::Format_MonoLSB);
 265     for (uint y=0; y<splashHeight; y++) {
 266       for (uint x=0; x<splashWidth; x++) {
 267         color = QColor(blackNwhite.pixel(x,y));
 268         b[splashWidth*(y/8) + x] |= ((color==black ? 1: 0)<<(y % 8));
 269       }
 270     }
 271   }
 272   splash.clear();
 273   splash.append(b, splashSize);
 274   flash.replace(splashOffset, splashSize, splash);
 275   return true;
 276 }
 277
 278 int FirmwareInterface::getSplashWidth()
 279 {
 280   return splashWidth;
 281 }
 282
 283 uint FirmwareInterface::getSplashHeight()
 284 {
 285   return splashHeight;
 286 }
 287
 288 QImage::Format FirmwareInterface::getSplashFormat()
 289 {
 290   return splash_format;
 291 }
 292
 293 QImage FirmwareInterface::getSplash()
 294 {
 295   if (splashOffset == 0 || splashSize == 0) {
 296     return QImage(); // empty image
 297   }
 298
 299   if (splash_format == QImage::Format_Indexed8) {
 300     QImage image(splashWidth, splashHeight, QImage::Format_RGB888);
 301     if (splashOffset > 0) {
 302       for (unsigned int y=0; y<splashHeight; y++) {
 303         unsigned int idx = (y/2)*splashWidth;
 304         for (unsigned int x=0; x<splashWidth; x++, idx++) {
 305           uint8_t byte = flash.at(splashOffset+idx);
 306           unsigned int z = (y & 1) ? (byte >> 4) : (byte & 0x0F);
 307           z = 255-(z*255)/15;
 308           QRgb rgb = qRgb(z, z, z);
 309           image.setPixel(x, y, rgb);
 310         }
 311       }
 312     }
 313     return image;
 314   }
 315   else {
 316     QImage image(splashWidth, splashHeight, QImage::Format_Mono);
 317     if (splashOffset > 0) {
 318       for (unsigned int y=0; y<splashHeight; y++) {
 319         for(unsigned int x=0; x<splashWidth; x++) {
 320           image.setPixel(x, y, (flash.at(splashOffset+(splashWidth*(y/8)+x)) & (1<<(y % 8))) ? 0 : 1);
 321         }
 322       }
 323     }
 324     return image;
 325   }
 326 }
 327
 328 bool FirmwareInterface::hasSplash()
 329 {
 330   return (splashOffset > 0 ? true : false);
 331 }
 332
 333 bool FirmwareInterface::isValid()
 334 {
 335   return isValidFlag;
 336 }
 337
 338 unsigned int FirmwareInterface::save(const QString & filename)
 339 {
 340   uint8_t * binflash  = (uint8_t*)malloc(FSIZE_MAX);
 341   if (binflash == NULL) {
 342     return -1;
 343   }
 344   memcpy(binflash, flash.constData(), flashSize);
 345   QFile file(filename);
 346
 347   int fileType = getStorageType(filename);
 348
 349   if (fileType == STORAGE_TYPE_HEX) {
 350     if (!file.open(QIODevice::ReadWrite | QIODevice::Truncate | QIODevice::Text)) { //reading HEX TEXT file
 351       free(binflash);
 352       return -1;
 353     }
 354     QTextStream outputStream(&file);
 355     HexInterface hex=HexInterface(outputStream);
 356     hex.save(binflash, flashSize);
 357   }
 358   else {
 359     if (!file.open(QIODevice::ReadWrite | QIODevice::Truncate)) { //reading HEX TEXT file
 360       free(binflash);
 361       return -1;
 362     }
 363     file.write((char*)binflash, flashSize);
 364   }
 365
 366   file.close();
 367
 368   free(binflash);
 369   return flashSize;
 370 }