companion/src/storage/storage.h

   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 #ifndef _STORAGE_H_
  22 #define _STORAGE_H_
  23
  24 #include "radiodata.h"
  25 #include <QString>
  26 #include <QDebug>
  27
  28 enum StorageType
  29 {
  30   STORAGE_TYPE_UNKNOWN,
  31   STORAGE_TYPE_BIN,
  32   STORAGE_TYPE_HEX,
  33   STORAGE_TYPE_EEPE,
  34   STORAGE_TYPE_EEPM,
  35   STORAGE_TYPE_XML,
  36   STORAGE_TYPE_SDCARD,
  37   STORAGE_TYPE_OTX
  38 };
  39
  40 StorageType getStorageType(const QString & filename);
  41
  42 class StorageFormat
  43 {
  44   public:
  45     StorageFormat(const QString & filename, uint8_t version=0):
  46       filename(filename),
  47       version(version),
  48       board(Board::BOARD_UNKNOWN)
  49     {
  50     }
  51     virtual ~StorageFormat() {}
  52     virtual bool load(RadioData & radioData) = 0;
  53     virtual bool write(const RadioData & radioData) = 0;
  54
  55     QString error() {
  56       return _error;
  57     }
  58
  59     QString warning() {
  60       return _warning;
  61     }
  62
  63     virtual QString name() = 0;
  64
  65     virtual Board::Type getBoard()
  66     {
  67       return board;
  68     }
  69
  70     static uint32_t getFourCC(Board::Type board)
  71     {
  72       switch (board) {
  73         case Board::BOARD_X12S:
  74         case Board::BOARD_X10:
  75           return 0x3478746F;
  76         case Board::BOARD_TARANIS_X7:
  77           return 0x3678746F;
  78         case Board::BOARD_TARANIS_X9E:
  79           return 0x3578746F;
  80         case Board::BOARD_TARANIS_X9D:
  81         case Board::BOARD_TARANIS_X9DP:
  82           return 0x3378746F;
  83         case Board::BOARD_SKY9X:
  84         case Board::BOARD_AR9X:
  85         case Board::BOARD_9XRPRO:
  86           return 0x3278746F;
  87         case Board::BOARD_MEGA2560:
  88         case Board::BOARD_GRUVIN9X:
  89           return 0x3178746F;
  90         default:
  91           return 0;
  92       }
  93     }
  94
  95     uint32_t getFourCC()
  96     {
  97       return getFourCC(board);
  98     }
  99
 100     virtual bool isBoardCompatible(Board::Type board)
 101     {
 102       return getFourCC() == getFourCC(board);
 103     }
 104
 105   protected:
 106     void setError(const QString & error)
 107     {
 108       qDebug() << qPrintable(QString("[%1] error: %2").arg(name()).arg(error));
 109       _error = error;
 110     }
 111
 112     void setWarning(const QString & warning)
 113     {
 114       qDebug() << qPrintable(QString("[%1] warning: %2").arg(name()).arg(warning));
 115       _warning = warning;
 116     }
 117
 118     QString filename;
 119     uint8_t version;
 120     QString _error;
 121     QString _warning;
 122     Board::Type board;
 123 };
 124
 125 class StorageFactory
 126 {
 127   public:
 128     StorageFactory()
 129     {
 130     }
 131     virtual ~StorageFactory() {}
 132     virtual QString name() = 0;
 133     virtual bool probe(const QString & filename) = 0;
 134     virtual StorageFormat * instance(const QString & filename) = 0;
 135 };
 136
 137 template <class T>
 138 class DefaultStorageFactory : public StorageFactory
 139 {
 140   public:
 141     DefaultStorageFactory(const QString & name):
 142       StorageFactory(),
 143       _name(name)
 144     {
 145     }
 146
 147     virtual QString name()
 148     {
 149       return _name;
 150     }
 151
 152     virtual bool probe(const QString & filename)
 153     {
 154       return filename.toLower().endsWith("." + _name);
 155     }
 156
 157     virtual StorageFormat * instance(const QString & filename)
 158     {
 159       return new T(filename);
 160     }
 161
 162     QString _name;
 163 };
 164
 165 class Storage : public StorageFormat
 166 {
 167   public:
 168     Storage(const QString & filename):
 169       StorageFormat(filename)
 170     {
 171     }
 172
 173     virtual QString name() { return "storage"; }
 174
 175     void setError(const QString & error)
 176     {
 177       _error = error;
 178     }
 179
 180     void setWarning(const QString & warning)
 181     {
 182       _warning = warning;
 183     }
 184
 185     virtual bool load(RadioData & radioData);
 186     virtual bool write(const RadioData & radioData);
 187 };
 188
 189 void registerStorageFactories();
 190 void unregisterStorageFactories();
 191
 192 #if 0
 193 unsigned long LoadBackup(RadioData &radioData, uint8_t *eeprom, int esize, int index);
 194 unsigned long LoadEeprom(RadioData &radioData, const uint8_t *eeprom, int size);
 195 unsigned long LoadEepromXml(RadioData &radioData, QDomDocument &doc);
 196 #endif
 197
 198 bool convertEEprom(const QString & sourceEEprom, const QString & destinationEEprom, const QString & firmware);
 199
 200 #endif // _STORAGE_H_