Index: libs/libmythtv/firewirechannel.cpp
===================================================================
--- libs/libmythtv/firewirechannel.cpp	(revision 19589)
+++ libs/libmythtv/firewirechannel.cpp	(working copy)
@@ -60,6 +60,7 @@
 
     // Fetch tuning data from the database.
     QString tvformat, modulation, freqtable, freqid, dtv_si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -70,6 +71,7 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff,
         mplexid, commfree))
     {
         VERBOSE(VB_IMPORTANT, loc + " " + QString(
Index: libs/libmythtv/dtvconfparserhelpers.h
===================================================================
--- libs/libmythtv/dtvconfparserhelpers.h	(revision 19589)
+++ libs/libmythtv/dtvconfparserhelpers.h	(working copy)
@@ -74,14 +74,11 @@
   public:
     enum
     {
-        kTunerTypeQPSK    = 0,
-        kTunerTypeQAM     = 1,
-        kTunerTypeOFDM    = 2,
+        kTunerTypeQPSK    = 0,         // DVB-S
+        kTunerTypeQAM     = 1,         // DVB-C
+        kTunerTypeOFDM    = 2,         // DVB-T
         kTunerTypeATSC    = 3,
-        kTunerTypeDVB_S   = (1 << 2), // same as QPSK but for new API
-        kTunerTypeDVB_C   = (1 << 3), // same as QAM  but for new API
-        kTunerTypeDVB_T   = (1 << 4), // same as OFDM but for new API
-        kTunerTypeDVB_S2  = (1 << 5),
+        kTunerTypeDVB_S2  = (1 << 30), // In S2API DVB-S2 is only a capability
         kTunerTypeUnknown = (1 << 31),
     };
 
@@ -95,8 +92,6 @@
     {
         return ((kTunerTypeQPSK   == value) ||
                 (kTunerTypeQAM    == value) ||
-                (kTunerTypeDVB_S  == value) ||
-                (kTunerTypeDVB_C  == value) ||
                 (kTunerTypeDVB_S2 == value));
     }
 
@@ -191,7 +186,7 @@
     static const DTVParamHelperStruct confTable[];
     static const DTVParamHelperStruct vdrTable[];
     static const DTVParamHelperStruct parseTable[];
-    static const uint kDBStrCnt = 10;
+    static const uint kDBStrCnt = 12;
     static const char *dbStr[kDBStrCnt];
 
   public:
@@ -207,6 +202,8 @@
         kFEC_7_8,
         kFEC_8_9,
         kFECAuto,
+        kFEC_3_5,
+        kFEC_9_10,
     };
 
     DTVCodeRate(int _default = kFECAuto) : DTVParamHelper(_default) { }
@@ -245,14 +242,15 @@
         kModulationQAMAuto = 6,
         kModulation8VSB    = 7,
         kModulation16VSB   = 8,
-        kModulation2VSB    = 9,
-        kModulation4VSB    = 10,
-        kModulationBPSK    = 11,
-        kModulation16APSK  = 12,
-        kModulation32APSK  = 13,
-        kModulation8PSK    = 14,
-        kModulation16PSK   = 15,
+        kModulation8PSK    = 9,
+        kModulation16APSK  = 10,
+        kModulation32APSK  = 11,
+        kModulationDQPSK   = 12,
+        kModulation2VSB    = 13,
+        kModulation4VSB    = 14,
+        kModulationBPSK    = 15,
         kModulationAnalog  = 16, /* for analog channel scanner */
+        kModulation16PSK   = 17,
     };
 
     DTVModulation(int _default = kModulationQAMAuto)
@@ -414,4 +412,99 @@
         { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
 };
 
+class DTVModulationSystem : public DTVParamHelper
+{
+  protected:
+    static const DTVParamHelperStruct confTable[];
+    static const DTVParamHelperStruct vdrTable[];
+    static const DTVParamHelperStruct parseTable[];
+    static const uint kDBStrCnt = 2;
+    static const char *dbStr[kDBStrCnt];
+
+  public:
+    enum
+    {
+        kModulationSystemDVBS,
+        kModulationSystemDVBS2,
+    };
+
+    DTVModulationSystem(int _default = kModulationSystemDVBS)
+        : DTVParamHelper(_default) { }
+
+    bool ParseConf(const QString &_value)
+       { return ParseParam(_value, value, confTable); }
+    bool ParseVDR(const QString &_value)
+       { return ParseParam(_value, value, vdrTable); }
+    bool Parse(const QString &_value)
+       { return ParseParam(_value, value, parseTable); }
+
+    QString toString() const { return toString(value); }
+
+    static QString toString(int _value)
+        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
+};
+
+class DTVRollOff : public DTVParamHelper
+{
+  protected:
+    static const DTVParamHelperStruct confTable[];
+    static const DTVParamHelperStruct vdrTable[];
+    static const DTVParamHelperStruct parseTable[];
+    static const uint kDBStrCnt = 4;
+    static const char *dbStr[kDBStrCnt];
+
+  public:
+    enum
+    {
+        kRollOff35,
+        kRollOff20,
+        kRollOff25,
+        kRollOffAuto,
+    };
+
+    DTVRollOff(int _default = kRollOff35)
+        : DTVParamHelper(_default) { }
+
+    bool ParseConf(const QString &_value)
+       { return ParseParam(_value, value, confTable); }
+    bool ParseVDR(const QString &_value)
+       { return ParseParam(_value, value, vdrTable); }
+    bool Parse(const QString &_value)
+       { return ParseParam(_value, value, parseTable); }
+
+    QString toString() const { return toString(value); }
+
+    static QString toString(int _value)
+        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
+};
+
+class DTVPilot : public DTVParamHelper
+{
+  protected:
+    static const DTVParamHelperStruct confTable[];
+    static const DTVParamHelperStruct vdrTable[];
+    static const DTVParamHelperStruct parseTable[];
+    static const uint kDBStrCnt = 3;
+    static const char *dbStr[kDBStrCnt];
+
+  public:
+    enum
+    {
+        kPilotOn,
+        kPilotOff,
+        kPilotAuto,
+    };
+
+    DTVPilot(int _default = kPilotAuto)
+        : DTVParamHelper(_default) { }
+
+    bool ParseConf(const QString &_value)
+       { return ParseParam(_value, value, confTable); }
+
+    QString toString() const { return toString(value); }
+
+    static QString toString(int _value)
+        { return DTVParamHelper::toString(dbStr, _value, kDBStrCnt); }
+};
+
 #endif // _DTVCONFPARSERHELPERS_H_
Index: libs/libmythtv/channelscan/channelimporter.cpp
===================================================================
--- libs/libmythtv/channelscan/channelimporter.cpp	(revision 19589)
+++ libs/libmythtv/channelscan/channelimporter.cpp	(working copy)
@@ -468,7 +468,6 @@
 
     bool is_dvbs =
         (DTVTunerType::kTunerTypeQPSK   == tuner_type) ||
-        (DTVTunerType::kTunerTypeDVB_S  == tuner_type) ||
         (DTVTunerType::kTunerTypeDVB_S2 == tuner_type);
 
     uint freq_mult = (is_dvbs) ? 1 : 1000;
Index: libs/libmythtv/channelscan/scaninfo.cpp
===================================================================
--- libs/libmythtv/channelscan/scaninfo.cpp	(revision 19589)
+++ libs/libmythtv/channelscan/scaninfo.cpp	(working copy)
@@ -76,7 +76,8 @@
         "       hp_code_rate,      lp_code_rate,   modulation, "
         "       transmission_mode, guard_interval, hierarchy, "
         "       modulation,        bandwidth,      sistandard, "
-        "       tuner_type,        transportid "
+        "       tuner_type,        transportid, "
+        "       msystem,           rolloff "
         "FROM channelscan_dtv_multiplex "
         "WHERE scanid = :SCANID");
     query.bindValue(":SCANID", scanid);
@@ -97,7 +98,8 @@
             query.value(6).toString(),  query.value(7).toString(),
             query.value(8).toString(),  query.value(9).toString(),
             query.value(10).toString(), query.value(11).toString(),
-            query.value(12).toString());
+            query.value(12).toString(), query.value(16).toString(),
+            query.value(17).toString());
 
         query2.prepare(
             "SELECT "
Index: libs/libmythtv/channelscan/channelscan_sm.cpp
===================================================================
--- libs/libmythtv/channelscan/channelscan_sm.cpp	(revision 19589)
+++ libs/libmythtv/channelscan/channelscan_sm.cpp	(working copy)
@@ -1439,7 +1439,8 @@
             startChan["coderate_hp"],    startChan["coderate_lp"],
             startChan["constellation"],  startChan["trans_mode"],
             startChan["guard_interval"], startChan["hierarchy"],
-            startChan["modulation"],     startChan["bandwidth"]);
+            startChan["modulation"],     startChan["bandwidth"],
+            startChan["msystem"],        startChan["rolloff"]);
     }
 
     if (ok)
Index: libs/libmythtv/channelscan/modulationsetting.h
===================================================================
--- libs/libmythtv/channelscan/modulationsetting.h	(revision 19589)
+++ libs/libmythtv/channelscan/modulationsetting.h	(working copy)
@@ -58,9 +58,7 @@
     {
         addSelection(QObject::tr("Auto"),"auto",true);
         addSelection("QPSK","qpsk");
-#ifdef FE_GET_EXTENDED_INFO
         addSelection("8PSK","8psk");
-#endif
         addSelection("QAM 16","qam_16");
         addSelection("QAM 32","qam_32");
         addSelection("QAM 64","qam_64");
Index: libs/libmythtv/channelscan/channelscanmiscsettings.h
===================================================================
--- libs/libmythtv/channelscan/channelscanmiscsettings.h	(revision 19589)
+++ libs/libmythtv/channelscan/channelscanmiscsettings.h	(working copy)
@@ -146,11 +146,13 @@
         addSelection("1/2");
         addSelection("2/3");
         addSelection("3/4");
+        addSelection("3/5");
         addSelection("4/5");
         addSelection("5/6");
         addSelection("6/7");
         addSelection("7/8");
         addSelection("8/9");
+        addSelection("9/10");
     }
 };
 
@@ -165,6 +167,38 @@
     }
 };
 
+class ScanModulationSystem: public ComboBoxSetting, public TransientStorage
+{
+  public:
+    ScanModulationSystem() : ScanModulationSystemSetting(this)
+    {
+        setLabel(QObject::tr("Modul. System"));
+        setHelpText(QObject::tr("Modulation System (Default: DVB-S)"));
+        addSelection("DVB-S","dvbs",true);
+        addSelection("DVB-S2","dvbs2");
+    };
+};
+
+
+class ScanRollOff: public ComboBoxSetting
+{
+  public:
+    ScanRollOff(Storage *_storage) : ComboBoxSetting(_storage)
+    {
+        setLabel(QObject::tr("Roll-off"));
+        setHelpText(QObject::tr(
+                        "Roll-off (Default: Auto):\n"
+                        "The  DVB-S2  standard  in  addition \n"
+                        " to  the  single  DVB-S    35%  roll-off\n"
+                        " factor,  provides  two  additional roll-off\n"
+                        " factors to further increase transponder efficiency"));
+        addSelection(QObject::tr("Auto"),"auto");
+        addSelection("0.35","0.35",true);
+        addSelection("0.20");
+        addSelection("0.25");
+    }
+};
+
 class ScanCodeRateLP: public ScanFecSetting, public TransientStorage
 {
   public:
Index: libs/libmythtv/channelscan/channelscanner.cpp
===================================================================
--- libs/libmythtv/channelscan/channelscanner.cpp	(revision 19589)
+++ libs/libmythtv/channelscan/channelscanner.cpp	(working copy)
@@ -143,6 +143,7 @@
     }
     else if ((ScanTypeSetting::NITAddScan_DVBT == scantype) ||
              (ScanTypeSetting::NITAddScan_DVBS == scantype) ||
+             (ScanTypeSetting::NITAddScan_DVBS2 == scantype) ||
              (ScanTypeSetting::NITAddScan_DVBC == scantype))
     {
         VERBOSE(VB_SIPARSER, LOC + "ScanTransports()");
@@ -219,6 +220,7 @@
     DTVConfParser::cardtype_t type = DTVConfParser::UNKNOWN;
     type = (CardUtil::DVBT == cardtype) ? DTVConfParser::OFDM : type;
     type = (CardUtil::QPSK == cardtype) ? DTVConfParser::QPSK : type;
+    type = (CardUtil::DVBS2 == cardtype) ? DTVConfParser::DVBS2 : type;
     type = (CardUtil::DVBC == cardtype) ? DTVConfParser::QAM  : type;
     type = ((CardUtil::ATSC == cardtype) ||
             (CardUtil::HDHOMERUN == cardtype)) ? DTVConfParser::ATSC : type;
@@ -302,6 +304,7 @@
         QString sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper();
         bool need_nit = (("QAM"  == sub_type) ||
                          ("QPSK" == sub_type) ||
+                         ("DVB_S2" == sub_type) ||
                          ("OFDM" == sub_type));
 
         // Ugh, Some DVB drivers don't fully support signal monitoring...
Index: libs/libmythtv/channelscan/panedvbs2.h
===================================================================
--- libs/libmythtv/channelscan/panedvbs2.h	(revision 19589)
+++ libs/libmythtv/channelscan/panedvbs2.h	(working copy)
@@ -22,9 +22,11 @@
         left->addChild( pfrequency  = new ScanFrequency());
         left->addChild( ppolarity   = new ScanPolarity());
         left->addChild( psymbolrate = new ScanSymbolRate());
-        right->addChild(pfec        = new ScanFec());
+        left->addChild( pfec        = new ScanFec());
+        right->addChild(pmsystem    = new ScanModulationSystem());
         right->addChild(pmodulation = new ScanModulation());
         right->addChild(pinversion  = new ScanInversion());
+        right->addChild(prolloff    = new ScanRollOff());
         addChild(left);
         addChild(right);     
     }
@@ -35,6 +37,8 @@
     QString fec(void)        const { return pfec->getValue();        }
     QString polarity(void)   const { return ppolarity->getValue();   }
     QString modulation(void) const { return pmodulation->getValue(); }
+    QString rolloff(void)    const { return prolloff->getValue();    }
+    QString msystem(void)    const { return pmsystem->getValue();    }
 
   protected:
     ScanFrequency  *pfrequency;
@@ -43,6 +47,8 @@
     ScanFec        *pfec;
     ScanPolarity   *ppolarity;
     ScanModulation *pmodulation;
+    ScanRollOff    *prolloff;
+    ScanModulationSystem    *pmsystem;
 };
 
 #endif // _PANE_DVBS2_H_
Index: libs/libmythtv/channelscan/scanwizardconfig.cpp
===================================================================
--- libs/libmythtv/channelscan/scanwizardconfig.cpp	(revision 19589)
+++ libs/libmythtv/channelscan/scanwizardconfig.cpp	(working copy)
@@ -133,6 +133,12 @@
         addSelection(tr("Import channels.conf"),
                      QString::number(DVBUtilsImport));
         break;
+    case CardUtil::DVBS2:
+        addSelection(tr("Full Scan (Tuned)"),
+                     QString::number(NITAddScan_DVBS2));
+        addSelection(tr("Import channels.conf"),
+                     QString::number(DVBUtilsImport));
+        break;
     case CardUtil::QAM:
         addSelection(tr("Full Scan (Tuned)"),
                      QString::number(NITAddScan_DVBC));
@@ -329,6 +335,19 @@
         startChan["modulation"] = "qpsk";
         startChan["polarity"]   = pane->polarity();
     }
+    else if (ScanTypeSetting::NITAddScan_DVBS2 == st)
+    {
+        const PaneDVBS2 *pane = paneDVBS2;
+
+        startChan["std"]        = "dvb";
+        startChan["frequency"]  = pane->frequency();
+        startChan["inversion"]  = pane->inversion();
+        startChan["symbolrate"] = pane->symbolrate();
+        startChan["fec"]        = pane->fec();
+        startChan["modulation"] = pane->modulation();;
+        startChan["polarity"]   = pane->polarity();
+        startChan["rolloff"]    = pane->rolloff();
+    }
     else if (ScanTypeSetting::NITAddScan_DVBC == st)
     {
         const PaneDVBC *pane = paneDVBC;
Index: libs/libmythtv/dtvconfparserhelpers.cpp
===================================================================
--- libs/libmythtv/dtvconfparserhelpers.cpp	(revision 19589)
+++ libs/libmythtv/dtvconfparserhelpers.cpp	(working copy)
@@ -47,9 +47,6 @@
     dtv_tt_canonical_str[kTunerTypeQAM]     = "QAM";
     dtv_tt_canonical_str[kTunerTypeOFDM]    = "OFDM";
     dtv_tt_canonical_str[kTunerTypeATSC]    = "ATSC";
-    dtv_tt_canonical_str[kTunerTypeDVB_S]   = "DVB_S";
-    dtv_tt_canonical_str[kTunerTypeDVB_C]   = "DVB_C";
-    dtv_tt_canonical_str[kTunerTypeDVB_T]   = "DVB_T";
     dtv_tt_canonical_str[kTunerTypeDVB_S2]  = "DVB_S2";
     dtv_tt_canonical_str[kTunerTypeUnknown] = "UNKNOWN";
 }
@@ -69,9 +66,6 @@
     { "QAM",     kTunerTypeQAM     },
     { "OFDM",    kTunerTypeOFDM    },
     { "ATSC",    kTunerTypeATSC    },
-    { "DVB_S",   kTunerTypeDVB_S   },
-    { "DVB_C",   kTunerTypeDVB_C   },
-    { "DVB_T",   kTunerTypeDVB_T   },
     { "DVB_S2",  kTunerTypeDVB_S2  },
     { "UNKNOWN", kTunerTypeUnknown },
     { NULL,      kTunerTypeUnknown },
@@ -154,7 +148,9 @@
     { "FEC_6_7",  kFEC_6_7  },
     { "FEC_7_8",  kFEC_7_8  },
     { "FEC_8_9",  kFEC_8_9  },
-    { "FEC_NONE", kFECNone },
+    { "FEC_3_5",  kFEC_3_5  },
+    { "FEC_9_10", kFEC_9_10 },
+    { "FEC_NONE", kFECNone  },
     { NULL,       kFECAuto },
 };
 
@@ -164,11 +160,13 @@
     { "12",  kFEC_1_2 },
     { "23",  kFEC_2_3 },
     { "34",  kFEC_3_4 },
+    { "35",  kFEC_3_5 },
     { "45",  kFEC_4_5 },
     { "56",  kFEC_5_6 },
     { "67",  kFEC_6_7 },
     { "78",  kFEC_7_8 },
     { "89",  kFEC_8_9 },
+    { "910", kFEC_9_10},
     { "0",   kFECNone },
     { NULL,  kFECAuto }
 };
@@ -184,6 +182,8 @@
     { "6/7",  kFEC_6_7 },
     { "7/8",  kFEC_7_8 },
     { "8/9",  kFEC_8_9 },
+    { "3/5",  kFEC_3_5 },
+    { "9/10", kFEC_9_10},
     { "none", kFECNone },
     { NULL,   kFECAuto }
 };
@@ -199,7 +199,9 @@
      "6/7",  ///< kFEC_6_7
      "7/8",  ///< kFEC_7_8
      "8/9",  ///< kFEC_8_9
-     "auto"  ///< kFECAuto
+     "3/5",  ///< kFEC_3_5
+     "9/10", ///< kFEC_9_10
+     "auto", ///< kFECAuto
 };
 
 const DTVParamHelperStruct DTVModulation::confTable[] =
@@ -220,6 +222,7 @@
    { "32APSK",   kModulation32APSK  },
    { "8PSK",     kModulation8PSK    },
    { "16PSK",    kModulation16PSK   },
+   { "DQPSK",    kModulationDQPSK   },
    { "analog",   kModulationAnalog  },
    { NULL,       kModulationQAMAuto },
 };
@@ -232,6 +235,12 @@
    { "64",  kModulationQAM64   },
    { "128", kModulationQAM128  },
    { "256", kModulationQAM256  },
+   { "2",   kModulationQPSK    },
+   { "10",  kModulation8VSB    },
+   { "11",  kModulation16VSB   },
+   { "6",   kModulation16APSK  },
+   { "7",   kModulation32APSK  },
+   { "5",   kModulation8PSK    },
    { "0",   kModulationQPSK    },
    { NULL,  kModulationQAMAuto },
 };
@@ -254,6 +263,7 @@
    { "32apsk",   kModulation32APSK  },
    { "8psk",     kModulation8PSK    },
    { "16psk",    kModulation16PSK   },
+   { "dqpsk",    kModulationDQPSK   },
    // alternates
    { "a",        kModulationQAMAuto },
    { "qam_auto", kModulationQAMAuto },
@@ -272,6 +282,7 @@
    { "32-apsk",  kModulation32APSK  },
    { "8-psk",    kModulation8PSK    },
    { "16-psk",   kModulation16PSK   },
+   { "dq-psk",   kModulationDQPSK   },
    { NULL,       kModulationQAMAuto },
 };
 
@@ -293,6 +304,7 @@
     "32apsk",  ///< kModulation32APSK
     "8psk",    ///< kModulation8PSK
     "16psk",   ///< kModulation16PSK
+    "dqpsk",   ///< kModulationDQPSK
 };
 
 const DTVParamHelperStruct DTVTransmitMode::confTable[] =
@@ -420,3 +432,65 @@
    "r", ///< kPolarityRight
    "l"  ///< kPolarityLeft
 };
+
+const DTVParamHelperStruct DTVModulationSystem::confTable[] =
+{
+   { "SYS_DVBS",  kModulationSystemDVBS  },
+   { "SYS_DVBS2", kModulationSystemDVBS2 },
+   { NULL,        kModulationSystemDVBS  },
+};
+
+const DTVParamHelperStruct DTVModulationSystem::vdrTable[] =
+{
+   { "0",  kModulationSystemDVBS  },
+   { "1",  kModulationSystemDVBS2 },
+   { NULL, kModulationSystemDVBS  },
+};
+
+const DTVParamHelperStruct DTVModulationSystem::parseTable[] =
+{
+   { "dvbs2", kModulationSystemDVBS2 },
+   { "dvbs",  kModulationSystemDVBS  },
+   { NULL,    kModulationSystemDVBS  },
+};
+
+const char *DTVModulationSystem::dbStr[DTVModulationSystem::kDBStrCnt] =
+{
+    "dvbs",  ///< kModulationSystemDVBS
+    "dvbs2", ///< kModulationSystemDVBS2
+};
+
+const DTVParamHelperStruct DTVRollOff::confTable[] =
+{
+   { "ROLLOFF_35",   kRollOff35   },
+   { "ROLLOFF_20",   kRollOff20   },
+   { "ROLLOFF_25",   kRollOff25   },
+   { "ROLLOFF_AUTO", kRollOffAuto },
+   { NULL,           kRollOffAuto },
+};
+
+const DTVParamHelperStruct DTVRollOff::vdrTable[] =
+{
+   { "35",   kRollOff35   },
+   { "20",   kRollOff20   },
+   { "25",   kRollOff25   },
+   { "0",    kRollOffAuto },
+   { NULL,   kRollOff35   },
+};
+
+const DTVParamHelperStruct DTVRollOff::parseTable[] =
+{
+   { "0.35",   kRollOff35   },
+   { "0.20",   kRollOff20   },
+   { "0.25",   kRollOff25   },
+   { "auto",   kRollOffAuto },
+   { NULL,     kRollOff35   },
+};
+
+const char *DTVRollOff::dbStr[DTVRollOff::kDBStrCnt] =
+{
+   "0.35",   ///< kRollOff35
+   "0.20",   ///< kRollOff20
+   "0.25",   ///< kRollOff25
+   "auto",   ///< kRollOffAuto
+};
Index: libs/libmythtv/dtvconfparser.cpp
===================================================================
--- libs/libmythtv/dtvconfparser.cpp	(revision 19589)
+++ libs/libmythtv/dtvconfparser.cpp	(working copy)
@@ -112,7 +112,7 @@
         {
             if ((type == OFDM) && (str == "T"))
                 ok &= ParseVDR(list, channelNo);
-            else if ((type == QPSK) && (str == "S"))
+            else if (((type == QPSK) || (type == DVBS2)) && (str == "S"))
                 ok &= ParseVDR(list, channelNo);
             else if ((type == QAM) && (str == "C"))
                 ok &= ParseVDR(list, channelNo);
@@ -121,7 +121,7 @@
             ok &= ParseConfOFDM(list);
         else if (type == ATSC)
             ok &= ParseConfATSC(list);
-        else if (type == QPSK)
+        else if ((type == QPSK) || (type == DVBS2))
             ok &= ParseConfQPSK(list);
         else if (type == QAM)
             ok &= ParseConfQAM(list);
@@ -213,6 +213,7 @@
     PARSE_SKIP(unknown);
     PARSE_SKIP(unknown);
     PARSE_UINT(chan.serviceid);
+    mux.modulation = DTVModulation::kModulationQPSK;
 
     AddChannel(mux, chan);
 
@@ -274,6 +275,10 @@
             case 'R':
             case 'L':
                 mux.polarity.ParseVDR(ori);
+            case 'S':
+                mux.msystem.ParseVDR(params);
+            case 'O':
+                mux.rolloff.ParseVDR(params);
                 break;
             default:
                 return false;
Index: libs/libmythtv/dtvmultiplex.h
===================================================================
--- libs/libmythtv/dtvmultiplex.h	(revision 19589)
+++ libs/libmythtv/dtvmultiplex.h	(working copy)
@@ -49,31 +49,40 @@
         const QString &symbol_rate,  const QString &fec_inner,
         const QString &modulation,   const QString &polarity);
 
+    bool ParseDVB_S2(
+        const QString &frequency,    const QString &inversion,
+        const QString &symbol_rate,  const QString &fec_inner,
+        const QString &modulation,   const QString &polarity,
+        const QString &msystem,      const QString &rolloff);
+
     bool ParseTuningParams(
         DTVTunerType type,
         QString frequency,    QString inversion,      QString symbolrate,
         QString fec,          QString polarity,
         QString hp_code_rate, QString lp_code_rate,   QString constellation,
         QString trans_mode,   QString guard_interval, QString hierarchy,
-        QString modulation,   QString bandwidth);
+        QString modulation,   QString bandwidth,
+        QString msystem,      QString rolloff);
 
     QString toString() const;
 
   public:
     // Basic tuning
-    uint64_t         frequency;
-    uint64_t         symbolrate;
-    DTVInversion     inversion;
-    DTVBandwidth     bandwidth;
-    DTVCodeRate      hp_code_rate;  ///< High Priority FEC rate
-    DTVCodeRate      lp_code_rate;  ///< Low Priority FEC rate
-    //DTVModulation    constellation; ///< Modulation for OFDM, TODO Remove
-    DTVModulation    modulation;
-    DTVTransmitMode  trans_mode;
-    DTVGuardInterval guard_interval;
-    DTVHierarchy     hierarchy;
-    DTVPolarity      polarity;
-    DTVCodeRate      fec; ///< Inner Forward Error Correction rate
+    uint64_t            frequency;
+    uint64_t            symbolrate;
+    DTVInversion        inversion;
+    DTVBandwidth        bandwidth;
+    DTVCodeRate         hp_code_rate;  ///< High Priority FEC rate
+    DTVCodeRate         lp_code_rate;  ///< Low Priority FEC rate
+    //DTVModulation     constellation; ///< Modulation for OFDM, TODO Remove
+    DTVModulation       modulation;
+    DTVTransmitMode     trans_mode;
+    DTVGuardInterval    guard_interval;
+    DTVHierarchy        hierarchy;
+    DTVPolarity         polarity;
+    DTVCodeRate         fec; ///< Inner Forward Error Correction rate
+    DTVModulationSystem msystem;
+    DTVRollOff          rolloff;
 
     // Optional additional info
     uint             mplex;
Index: libs/libmythtv/channelutil.h
===================================================================
--- libs/libmythtv/channelutil.h	(revision 19589)
+++ libs/libmythtv/channelutil.h	(working copy)
@@ -67,7 +67,8 @@
         signed char trans_mode,
         QString     inner_FEC,    QString     constellation,
         signed char hierarchy,    QString     hp_code_rate,
-        QString     lp_code_rate, QString     guard_interval);
+        QString     lp_code_rate, QString     guard_interval,
+        QString     msystem,      QString     rolloff);
 
     static uint    CreateMultiplex(uint sourceid, const DTVMultiplex&,
                                    int transport_id, int network_id);
@@ -85,11 +86,13 @@
     static int     GetBetterMplexID(int current_mplexid,
                                     int transport_id, int network_id);
 
-    static bool    GetTuningParams(uint mplexid,
+    static bool    GetTuningParams(uint      mplexid,
                                    QString  &modulation,
                                    uint64_t &frequency,
                                    uint     &dvb_transportid,
                                    uint     &dvb_networkid,
+                                   QString  &dvb_msystem, 
+                                   QString  &dvb_rolloff,
                                    QString  &si_std);
 
     static bool    GetATSCChannel(uint sourceid, const QString &channum,
@@ -156,9 +159,10 @@
         QString &tvformat,        QString       &modulation,
         QString &freqtable,       QString       &freqid,
         int     &finetune,        uint64_t      &frequency,
-        QString &dtv_si_std,      int     &mpeg_prog_num,
+        QString &dtv_si_std,      int           &mpeg_prog_num,
         uint    &atsc_major,      uint          &atsc_minor,
         uint    &dvb_transportid, uint          &dvb_networkid,
+        QString &dvb_msystem,     QString       &dvb_rolloff, 
         uint    &mplexid,         bool          &commfree);
     static bool    GetChannelSettings(int chanid, bool &useonairguide,
                                     bool &hidden);
Index: libs/libmythtv/cardutil.h
===================================================================
--- libs/libmythtv/cardutil.h	(revision 19589)
+++ libs/libmythtv/cardutil.h	(working copy)
@@ -54,6 +54,7 @@
         HDHOMERUN = 10,
         FREEBOX   = 11,
         HDPVR     = 12,
+        DVBS2     = 13,
     };
 
     static enum CARD_TYPES toCardType(const QString &name)
@@ -84,6 +85,8 @@
             return FREEBOX;
         if ("HDPVR" == name)
             return HDPVR;
+        if ("DVB_S2" == name)
+            return DVBS2;
         return ERROR_UNKNOWN;
     }
 
Index: libs/libmythtv/scanwizardhelpers.h
===================================================================
--- libs/libmythtv/scanwizardhelpers.h	(revision 19589)
+++ libs/libmythtv/scanwizardhelpers.h	(working copy)
@@ -243,6 +243,7 @@
         // seen in the Network Information Tables to the scan.
         NITAddScan_OFDM,
         NITAddScan_QPSK,
+        NITAddScan_DVBS2,
         NITAddScan_QAM,
         // Scan of all transports already in the database
         FullTransportScan,
@@ -274,6 +275,7 @@
     QString GetATSCFormat(const QString&)    const;
     QString GetFrequencyStandard(void)       const;
     QString GetModulation(void)              const;
+    QString GetRollOff(void)                 const;
     QString GetFrequencyTable(void)          const;
     bool    DoIgnoreSignalTimeout(void)      const;
     QString GetFilename(void)                const;
@@ -510,9 +512,7 @@
     {
         addSelection(QObject::tr("Auto"),"auto",true);
         addSelection("QPSK","qpsk");
-#ifdef FE_GET_EXTENDED_INFO
         addSelection("8PSK","8psk");
-#endif
         addSelection("QAM 16","qam_16");
         addSelection("QAM 32","qam_32");
         addSelection("QAM 64","qam_64");
@@ -531,6 +531,48 @@
     };
 };
 
+class ScanModulationSystemSetting: public ComboBoxSetting
+{
+  public:
+    ScanModulationSystemSetting(Storage *_storage) : ComboBoxSetting(_storage)
+    {
+        addSelection("DVB-S","dvbs",true);
+        addSelection("DVB-S2","dvbs2");
+    };
+};
+
+class ScanModulationSystem: public ScanModulationSystemSetting, public TransientStorage
+{
+  public:
+    ScanModulationSystem() : ScanModulationSystemSetting(this)
+    {
+        setLabel(QObject::tr("Modul. System"));
+        setHelpText(QObject::tr("Modulation System (Default: DVB-S)"));
+    };
+};
+
+class ScanRollOffSetting: public ComboBoxSetting
+{
+  public:
+    ScanRollOffSetting(Storage *_storage) : ComboBoxSetting(_storage)
+    {
+        addSelection(QObject::tr("Auto"),"auto");
+        addSelection("0.35","0.35",true);
+        addSelection("0.20","0.20");
+        addSelection("0.25","0.25");
+    };
+};
+
+class ScanRollOff: public ScanRollOffSetting, public TransientStorage
+{
+  public:
+    ScanRollOff() : ScanRollOffSetting(this)
+    {
+        setLabel(QObject::tr("RollOff"));
+        setHelpText(QObject::tr("RollOff (Default: 0.35)"));
+    };
+};
+
 class ScanConstellation: public ScanModulationSetting,
                          public TransientStorage
 {
@@ -552,11 +594,13 @@
         addSelection("1/2");
         addSelection("2/3");
         addSelection("3/4");
+        addSelection("3/5");
         addSelection("4/5");
         addSelection("5/6");
         addSelection("6/7");
         addSelection("7/8");
         addSelection("8/9");
+        addSelection("9/10");
     }
 };
 
@@ -692,9 +736,11 @@
         left->addChild( pfrequency  = new ScanFrequency());
         left->addChild( ppolarity   = new ScanPolarity());
         left->addChild( psymbolrate = new ScanSymbolRate());
-        right->addChild(pfec        = new ScanFec());
+        left->addChild( pfec        = new ScanFec());
+        right->addChild(pmsystem    = new ScanModulationSystem());
         right->addChild(pmodulation = new ScanModulation());
         right->addChild(pinversion  = new ScanInversion());
+        right->addChild(prolloff    = new ScanRollOff());
         addChild(left);
         addChild(right);
     }
@@ -704,15 +750,19 @@
     QString inversion(void)  const { return pinversion->getValue();  }
     QString fec(void)        const { return pfec->getValue();        }
     QString polarity(void)   const { return ppolarity->getValue();   }
+    QString msystem(void)    const { return pmsystem->getValue();    }
     QString modulation(void) const { return pmodulation->getValue(); }
+    QString rolloff(void)    const { return prolloff->getValue();    }
 
   protected:
-    ScanFrequency  *pfrequency;
-    ScanSymbolRate *psymbolrate;
-    ScanInversion  *pinversion;
-    ScanFec        *pfec;
-    ScanPolarity   *ppolarity;
-    ScanModulation *pmodulation;
+    ScanFrequency        *pfrequency;
+    ScanSymbolRate       *psymbolrate;
+    ScanInversion        *pinversion;
+    ScanFec              *pfec;
+    ScanPolarity         *ppolarity;
+    ScanModulation       *pmodulation;
+    ScanModulationSystem *pmsystem;
+    ScanRollOff          *prolloff;
 };
 
 class QPSKPane : public HorizontalConfigurationGroup
Index: libs/libmythtv/scanwizardscanner.cpp
===================================================================
--- libs/libmythtv/scanwizardscanner.cpp	(revision 19589)
+++ libs/libmythtv/scanwizardscanner.cpp	(working copy)
@@ -362,9 +362,10 @@
 
         ok = scanner->ScanTransports(sourceid, freq_std, mod, tbl);
     }
-    else if ((ScanTypeSetting::NITAddScan_OFDM == scantype) ||
-             (ScanTypeSetting::NITAddScan_QPSK == scantype) ||
-             (ScanTypeSetting::NITAddScan_QAM  == scantype))
+    else if ((ScanTypeSetting::NITAddScan_OFDM  == scantype) ||
+             (ScanTypeSetting::NITAddScan_QPSK  == scantype) ||
+             (ScanTypeSetting::NITAddScan_DVBS2 == scantype) ||
+             (ScanTypeSetting::NITAddScan_QAM   == scantype))
     {
         VERBOSE(VB_SIPARSER, LOC + "ScanTransports()");
 
@@ -440,9 +441,10 @@
     channels.clear();
 
     DTVConfParser::cardtype_t type = DTVConfParser::UNKNOWN;
-    type = (CardUtil::OFDM == cardtype) ? DTVConfParser::OFDM : type;
-    type = (CardUtil::QPSK == cardtype) ? DTVConfParser::QPSK : type;
-    type = (CardUtil::QAM  == cardtype) ? DTVConfParser::QAM  : type;
+    type = (CardUtil::OFDM  == cardtype) ? DTVConfParser::OFDM : type;
+    type = (CardUtil::QPSK  == cardtype) ? DTVConfParser::QPSK : type;
+    type = (CardUtil::DVBS2 == cardtype) ? DTVConfParser::DVBS2 : type;
+    type = (CardUtil::QAM   == cardtype) ? DTVConfParser::QAM  : type;
     type = ((CardUtil::ATSC == cardtype)||(CardUtil::HDHOMERUN == cardtype)) ?
         DTVConfParser::ATSC : type;
 
@@ -488,9 +490,10 @@
     if ("DVB" == card_type)
     {
         QString sub_type = CardUtil::ProbeDVBType(device).toUpper();
-        bool need_nit = (("QAM"  == sub_type) ||
-                         ("QPSK" == sub_type) ||
-                         ("OFDM" == sub_type));
+        bool need_nit = (("QAM"    == sub_type) ||
+                         ("QPSK"   == sub_type) ||
+                         ("DVB_S2" == sub_type) ||
+                         ("OFDM"   == sub_type));
 
         // Ugh, Some DVB drivers don't fully support signal monitoring...
         if ((ScanTypeSetting::TransportScan     == scantype) ||
Index: libs/libmythtv/hdhrchannel.cpp
===================================================================
--- libs/libmythtv/hdhrchannel.cpp	(revision 19589)
+++ libs/libmythtv/hdhrchannel.cpp	(working copy)
@@ -291,6 +291,7 @@
 
     // Fetch tuning data from the database.
     QString tvformat, modulation, freqtable, freqid, si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -301,6 +302,7 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff,
         mplexid, commfree))
     {
         return false;
@@ -369,10 +371,13 @@
     uint64_t frequency;
     uint     transportid;
     uint     dvb_networkid;
-
+    QString  dvb_msystem; 
+    QString  dvb_rolloff;
+    
     if (!ChannelUtil::GetTuningParams(
             mplexid, modulation, frequency,
-            transportid, dvb_networkid, si_std))
+            transportid, dvb_networkid, 
+            dvb_msystem, dvb_rolloff, si_std))
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR + "TuneMultiplex(): " +
                 QString("Could not find tuning parameters for multiplex %1.")
Index: libs/libmythtv/siscan.cpp
===================================================================
--- libs/libmythtv/siscan.cpp	(revision 19589)
+++ libs/libmythtv/siscan.cpp	(working copy)
@@ -901,12 +901,40 @@
     nextIt = transport_scan_items_it_t( scanTransports.end() );
 
     DTVMultiplex tuning;
-
+    DTVModulation modulation;
+    DTVModulationSystem msystem;
     DTVTunerType type;
 
     if (std == "dvb")
     {
-        ok = type.Parse(mod);
+        if (!modulation.Parse(*(startChan.find("modulation"))))
+        {
+            VERBOSE(VB_IMPORTANT, LOC + "Wrong modulation.");
+            return false;
+        }
+
+        if (modulation == DTVModulation::kModulationQPSK)
+        {
+            type = DTVTunerType::kTunerTypeQPSK;
+            ok = true;
+            if (startChan.find("msystem") != startChan.end())
+            {
+                if (!msystem.Parse(*(startChan.find("msystem"))))
+                {
+                    VERBOSE(VB_IMPORTANT, LOC + "Wrong modulation system.");
+                    return false;
+                }
+                if (msystem == DTVModulationSystem::kModulationSystemDVBS2)
+                    type = DTVTunerType::kTunerTypeDVB_S2;
+            }
+        }
+        else if (modulation == DTVModulation::kModulation8PSK)
+        {
+            type = DTVTunerType::kTunerTypeDVB_S2;
+            ok = true;
+        }
+        else
+            ok = type.Parse(mod);
     }
     else if (std == "atsc")
     {
@@ -924,7 +952,8 @@
             startChan["coderate_hp"],    startChan["coderate_lp"],
             startChan["constellation"],  startChan["trans_mode"],
             startChan["guard_interval"], startChan["hierarchy"],
-            startChan["modulation"],     startChan["bandwidth"]);
+            startChan["modulation"],     startChan["bandwidth"],
+            startChan["msystem"],        startChan["rolloff"]);
     }
 
     if (ok)
@@ -1564,7 +1593,7 @@
     const uint transportid, const uint networkid)
 {
     uint64_t    db_freq;
-    QString     tmp_modulation;
+    QString     tmp_modulation, tmp_msystem, tmp_rolloff;
     QString     tmp_si_std;
     uint        tmp_transportid, tmp_networkid;
     int         mplexid;
@@ -1578,7 +1607,7 @@
 
     if (!ChannelUtil::GetTuningParams(
             (uint)mplexid, tmp_modulation,
-            db_freq, tmp_transportid, tmp_networkid, tmp_si_std))
+            db_freq, tmp_transportid, tmp_networkid, tmp_msystem, tmp_rolloff, tmp_si_std))
     {
         return tuning_freq;
     }
Index: libs/libmythtv/dtvconfparser.h
===================================================================
--- libs/libmythtv/dtvconfparser.h	(revision 19589)
+++ libs/libmythtv/dtvconfparser.h	(working copy)
@@ -80,7 +80,7 @@
 {
   public:
     enum return_t   { ERROR_CARDTYPE, ERROR_OPEN, ERROR_PARSE, OK };
-    enum cardtype_t { ATSC, OFDM, QPSK, QAM, UNKNOWN };
+    enum cardtype_t { ATSC, OFDM, QPSK, DVBS2, QAM, UNKNOWN };
 
     DTVConfParser(enum cardtype_t _type, uint sourceid, const QString &_file);
     virtual ~DTVConfParser() { }
Index: libs/libmythtv/channelbase.cpp
===================================================================
--- libs/libmythtv/channelbase.cpp	(revision 19589)
+++ libs/libmythtv/channelbase.cpp	(working copy)
@@ -190,6 +190,7 @@
 
     // Fetch tuning data from the database.
     QString tvformat, modulation, freqtable, freqid, dtv_si_std;
+    QString msystem, rolloff; 
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -201,6 +202,7 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff,
         mplexid, commfree))
     {
         VERBOSE(VB_IMPORTANT, loc + " " + QString(
Index: libs/libmythtv/dvbchannel.h
===================================================================
--- libs/libmythtv/dvbchannel.h	(revision 19589)
+++ libs/libmythtv/dvbchannel.h	(working copy)
@@ -117,7 +117,6 @@
     QString           frontend_name;
     DTVTunerType      card_type;
     uint64_t          capabilities;
-    uint64_t          ext_modulations;
     uint64_t          frequency_minimum;
     uint64_t          frequency_maximum;
     uint              symbol_rate_minimum;
Index: libs/libmythtv/channelutil.cpp
===================================================================
--- libs/libmythtv/channelutil.cpp	(revision 19589)
+++ libs/libmythtv/channelutil.cpp	(working copy)
@@ -77,7 +77,7 @@
         "WHERE sourceid     = :SOURCEID   "
         "  AND sistandard   = :SISTANDARD ";
 
-    if (sistandard.toLower() != "dvb")
+    if (sistandard.toLower().left(3) != "dvb")
         qstr += "AND frequency    = :FREQUENCY   ";
     else
     {
@@ -91,7 +91,7 @@
     query.bindValue(":SOURCEID",          db_source_id);
     query.bindValue(":SISTANDARD",        sistandard);
 
-    if (sistandard.toLower() != "dvb")
+    if (sistandard.toLower().left(3) != "dvb")
         query.bindValue(":FREQUENCY",     frequency);
     else
     {
@@ -121,7 +121,8 @@
     signed char trans_mode,
     QString     inner_FEC,     QString      constellation,
     signed char hierarchy,     QString      hp_code_rate,
-    QString     lp_code_rate,  QString      guard_interval)
+    QString     lp_code_rate,  QString      guard_interval,
+    QString     msystem,       QString      rolloff)
 {
     MSqlQuery query(MSqlQuery::InitCon());
 
@@ -135,7 +136,7 @@
         // DVB specific
         transport_id,  network_id);
 
-    bool isDVB = (sistandard.toLower() == "dvb");
+    bool isDVB = (sistandard.toLower().left(3) == "dvb");
 
     QString updateStr =
         "UPDATE dtv_multiplex "
@@ -165,6 +166,10 @@
         "lp_code_rate     = :LP_CODE_RATE, " : "";
     updateStr += (!guard_interval.isNull()) ?
         "guard_interval   = :GUARD_INTERVAL, " : "";
+    updateStr += (!msystem.isNull()) ?
+        "msystem          = :MSYSTEM, " : "";
+    updateStr += (!rolloff.isNull()) ?
+        "rolloff          = :ROLLOFF, " : "";
 
     updateStr = updateStr.left(updateStr.length()-2) + " ";
 
@@ -194,6 +199,8 @@
     insertStr += (!hp_code_rate.isNull())   ? "hp_code_rate, "      : "";
     insertStr += (!lp_code_rate.isNull())   ? "lp_code_rate, "      : "";
     insertStr += (!guard_interval.isNull()) ? "guard_interval, "    : "";
+    insertStr += (!msystem.isNull())        ? "msystem, "           : "";
+    insertStr += (!rolloff.isNull())        ? "rolloff, "           : "";
     insertStr = insertStr.left(insertStr.length()-2) + ") ";
 
     insertStr +=
@@ -213,6 +220,8 @@
     insertStr += (!hp_code_rate.isNull())   ? ":HP_CODE_RATE, "     : "";
     insertStr += (!lp_code_rate.isNull())   ? ":LP_CODE_RATE, "     : "";
     insertStr += (!guard_interval.isNull()) ? ":GUARD_INTERVAL, "   : "";
+    insertStr += (!msystem.isNull())        ? ":MSYSTEM, "          : "";
+    insertStr += (!rolloff.isNull())        ? ":ROLLOFF, "          : "";
     insertStr = insertStr.left(insertStr.length()-2) + ");";
 
     query.prepare((mplex) ? updateStr : insertStr);
@@ -254,6 +263,10 @@
         query.bindValue(":LP_CODE_RATE",  lp_code_rate);
     if (!guard_interval.isNull())
         query.bindValue(":GUARD_INTERVAL",guard_interval);
+    if (!msystem.isNull())
+        query.bindValue(":MSYSTEM",       msystem);
+    if (!rolloff.isNull())
+        query.bindValue(":ROLLOFF",       rolloff);
 
     if (!query.exec() || !query.isActive())
     {
@@ -292,9 +305,13 @@
         {
             QString dummy_mod;
             QString dummy_sistd;
+            QString dummy_msystem;
+            QString dummy_rolloff;
             uint dummy_tsid, dummy_netid;
             ChannelUtil::GetTuningParams(mux, dummy_mod, freq,
-                                         dummy_tsid, dummy_netid, dummy_sistd);
+                                         dummy_tsid, dummy_netid,
+                                         dummy_msystem, dummy_rolloff,
+                                         dummy_sistd);
         }
 
         mux = ChannelUtil::CreateMultiplex(
@@ -307,7 +324,8 @@
             cd.TransmissionModeString()[0].toAscii(),
             QString(),                         cd.ConstellationString(),
             cd.HierarchyString()[0].toAscii(), cd.CodeRateHPString(),
-            cd.CodeRateLPString(),             cd.GuardIntervalString());
+            cd.CodeRateLPString(),             cd.GuardIntervalString(),
+            QString(),                         QString());
 
         if (mux)
             muxes.push_back(mux);
@@ -334,7 +352,8 @@
             -1,
             cd.FECInnerString(),  QString(),
             -1,                   QString(),
-            QString(),            QString());
+            QString(),                   QString(),
+            cd.ModulationSystemString(), cd.RollOffString());
 
         if (mux)
             muxes.push_back(mux);
@@ -357,6 +376,7 @@
             -1,
             cd.FECInnerString(),  QString::null,
             -1,                   QString::null,
+            QString::null,        QString::null,
             QString::null,        QString::null);
 
         if (mux)
@@ -377,6 +397,7 @@
         -1,
         QString::null,      QString::null,
         -1,                 QString::null,
+        QString::null,      QString::null,
         QString::null,      QString::null);
 }
 
@@ -390,7 +411,8 @@
     signed char trans_mode,
     QString     inner_FEC,    QString     constellation,
     signed char hierarchy,    QString     hp_code_rate,
-    QString     lp_code_rate, QString     guard_interval)
+    QString     lp_code_rate, QString     guard_interval,
+    QString     msystem,      QString     rolloff)
 {
     return insert_dtv_multiplex(
         sourceid,           sistandard,
@@ -402,7 +424,8 @@
         trans_mode,
         inner_FEC,          constellation,
         hierarchy,          hp_code_rate,
-        lp_code_rate,       guard_interval);
+        lp_code_rate,       guard_interval,
+        msystem,            rolloff);
 }
 
 uint ChannelUtil::CreateMultiplex(uint sourceid, const DTVMultiplex &mux,
@@ -418,7 +441,8 @@
         mux.trans_mode.toChar().toAscii(),
         mux.fec.toString(),               mux.modulation.toString(),
         mux.hierarchy.toChar().toAscii(), mux.hp_code_rate.toString(),
-        mux.lp_code_rate.toString(),      mux.guard_interval.toString());
+        mux.lp_code_rate.toString(),      mux.guard_interval.toString(),
+        mux.msystem.toString(),           mux.rolloff.toString());
 }
 
 
@@ -706,6 +730,8 @@
                                   uint64_t &frequency,
                                   uint     &dvb_transportid,
                                   uint     &dvb_networkid,
+                                  QString  &dvb_msystem, 
+                                  QString  &dvb_rolloff,
                                   QString  &si_std)
 {
     if (!mplexid || (mplexid == 32767)) /* 32767 deals with old lineups */
@@ -713,7 +739,7 @@
 
     MSqlQuery query(MSqlQuery::InitCon());
     query.prepare(
-        "SELECT transportid, networkid, frequency, modulation, sistandard "
+        "SELECT transportid, networkid, frequency, modulation, sistandard, msystem, rolloff "
         "FROM dtv_multiplex "
         "WHERE mplexid = :MPLEXID");
     query.bindValue(":MPLEXID", mplexid);
@@ -732,7 +758,9 @@
     frequency       = (uint64_t) query.value(2).toDouble(); // Qt 3.1 compat
     modulation      = query.value(3).toString();
     si_std          = query.value(4).toString();
-
+    dvb_msystem     = query.value(5).toString(); 
+ 	dvb_rolloff     = query.value(6).toString(); 
+ 	
     return true;
 }
 
@@ -1483,6 +1511,7 @@
     QString &dtv_si_std,      int           &mpeg_prog_num,
     uint    &atsc_major,      uint          &atsc_minor,
     uint    &dvb_transportid, uint          &dvb_networkid,
+    QString &dvb_msystem,     QString       &dvb_rolloff, 
     uint    &mplexid,
     bool    &commfree)
 {
@@ -1493,6 +1522,7 @@
     mpeg_prog_num = -1;
     atsc_major    = atsc_minor = mplexid = 0;
     dvb_networkid = dvb_transportid = 0;
+    dvb_msystem   = dvb_rolloff = QString::null;
     commfree      = false;
 
     MSqlQuery query(MSqlQuery::InitCon());
@@ -1533,9 +1563,10 @@
 
     if (!mplexid || (mplexid == 32767)) /* 32767 deals with old lineups */
         return true;
-
+  
     return GetTuningParams(mplexid, modulation, frequency,
-                           dvb_transportid, dvb_networkid, dtv_si_std);
+                           dvb_transportid, dvb_networkid,
+                           dvb_msystem, dvb_rolloff, dtv_si_std);
 }
 
 bool ChannelUtil::GetChannelSettings(int chanid, bool &useonairguide,
Index: libs/libmythtv/mpeg/dvbdescriptors.h
===================================================================
--- libs/libmythtv/mpeg/dvbdescriptors.h	(revision 19589)
+++ libs/libmythtv/mpeg/dvbdescriptors.h	(working copy)
@@ -685,13 +685,16 @@
     // FEC_inner                4  12.4
     enum
     {
-        kInnerFEC_1_2_ConvolutionCodeRate = 0x1,
-        kInnerFEC_2_3_ConvolutionCodeRate = 0x2,
-        kInnerFEC_3_4_ConvolutionCodeRate = 0x3,
-        kInnerFEC_5_6_ConvolutionCodeRate = 0x4,
-        kInnerFEC_7_8_ConvolutionCodeRate = 0x5,
-        kInnerFEC_8_9_ConvolutionCodeRate = 0x6,
-        kInnerFEC_None                    = 0xF,
+        kInnerFEC_1_2_ConvolutionCodeRate  = 0x1,
+        kInnerFEC_2_3_ConvolutionCodeRate  = 0x2,
+        kInnerFEC_3_4_ConvolutionCodeRate  = 0x3,
+        kInnerFEC_5_6_ConvolutionCodeRate  = 0x4,
+        kInnerFEC_7_8_ConvolutionCodeRate  = 0x5,
+        kInnerFEC_8_9_ConvolutionCodeRate  = 0x6,
+        kInnerFEC_3_5_ConvolutionCodeRate  = 0x7,
+        kInnerFEC_4_5_ConvolutionCodeRate  = 0x8,
+        kInnerFEC_9_10_ConvolutionCodeRate = 0x9,
+        kInnerFEC_None                     = 0xF,
     };
     uint FECInner() const { return _data[12] & 0xf; }
     QString FECInnerString() const { return coderate_inner(FECInner()); }
@@ -745,15 +748,35 @@
     bool IsLinearPolarization()   const { return !((_data[8]>>6)&0x1); }
     bool IsHorizontalLeftPolarization() const { return (_data[8]>>5)&0x1; }
     bool IsVerticalRightPolarization() const { return !((_data[8]>>5)&0x1); }
-    // modulation               5   8.3
+    // rolloff                  2   8.3
+    uint RollOff() const { return (_data[8]>>3)&0x3; }
+    QString RollOffString()  const
+    {
+        static QString ps[] = { "0.35", "0.20", "0.25", "auto" };
+        return ps[RollOff()];
+    }
+    // modulation system        3   8.5
     enum
     {
+        kModulationSystemDVBS  = 0x0,
+        kModulationSystemDVBS2 = 0x1,
+    };
+    uint ModulationSystem() const { return _data[8]>>2&0x1; }
+    QString ModulationSystemString() const
+    {
+        static QString mss[] = { "dvbs", "dvbs2" };
+        return (mss[ModulationSystem()]);
+    }
+    // modulation               4   8.6
+
+    enum
+    {
         kModulationQPSK_NS = 0x0, // Non standard QPSK for Bell ExpressVu
         kModulationQPSK   = 0x1,
         kModulation8PSK   = 0x2,
         kModulationQAM16  = 0x3,
     };
-    uint Modulation() const { return _data[8]&0x1f; }
+    uint Modulation() const { return _data[8]&0x3; }
     QString ModulationString() const
     {
         static QString ms[] = { "qpsk", "qpsk", "8psk", "qam_16" };
@@ -773,13 +796,17 @@
     // FEC_inner                4  12.4
     enum
     {
-        kInnerFEC_1_2_ConvolutionCodeRate = 0x1,
-        kInnerFEC_2_3_ConvolutionCodeRate = 0x2,
-        kInnerFEC_3_4_ConvolutionCodeRate = 0x3,
-        kInnerFEC_5_6_ConvolutionCodeRate = 0x4,
-        kInnerFEC_7_8_ConvolutionCodeRate = 0x5,
-        kInnerFEC_8_9_ConvolutionCodeRate = 0x6,
-        kInnerFEC_None                    = 0xF,
+        kInnerFEC_1_2_ConvolutionCodeRate  = 0x1,
+        kInnerFEC_2_3_ConvolutionCodeRate  = 0x2,
+        kInnerFEC_3_4_ConvolutionCodeRate  = 0x3,
+        kInnerFEC_5_6_ConvolutionCodeRate  = 0x4,
+        kInnerFEC_7_8_ConvolutionCodeRate  = 0x5,
+        kInnerFEC_8_9_ConvolutionCodeRate  = 0x6,
+        kInnerFEC_3_5_ConvolutionCodeRate  = 0x7,
+        kInnerFEC_4_5_ConvolutionCodeRate  = 0x8,
+        kInnerFEC_9_10_ConvolutionCodeRate = 0x9,
+        kInnerFEC_Auto                     = 0xA,
+        kInnerFEC_None                     = 0xF,
     };
     uint FECInner() const { return _data[12] & 0xf; }
     QString FECInnerString() const { return coderate_inner(FECInner()); }
@@ -1765,7 +1792,10 @@
         case 0x3:  return "3/4";
         case 0x4:  return "5/6";
         case 0x5:  return "7/8";
-        case 0x8:  return "8/9";
+        case 0x6:  return "8/9";
+        case 0x7:  return "3/5";
+        case 0x8:  return "4/5";
+        case 0x9:  return "9/10";
         case 0xf:  return "none";
         default:   return "auto"; // not actually defined in spec
     }
Index: libs/libmythtv/mpeg/dvbdescriptors.cpp
===================================================================
--- libs/libmythtv/mpeg/dvbdescriptors.cpp	(revision 19589)
+++ libs/libmythtv/mpeg/dvbdescriptors.cpp	(working copy)
@@ -369,8 +369,10 @@
     QString str = QString("SatelliteDeliverySystemDescriptor: ");
 
     str.append(QString("Frequency: %1\n").arg(FrequencyHz()));
-    str.append(QString("      Mod=%1, SymbR=%2, FECInner=%3, Orbit=%4, Pol=%5")
+    str.append(QString("      ModSys=%1, Mod=%2, RollOff=%3. SymbR=%4, FECInner=%5, Orbit=%6, Pol=%7")
+        .arg(ModulationSystemString())
         .arg(ModulationString())
+        .arg(RollOffString())
         .arg(SymbolRateHz())
         .arg(FECInnerString())
         .arg(OrbitalPositionString())
Index: libs/libmythtv/v4lchannel.cpp
===================================================================
--- libs/libmythtv/v4lchannel.cpp	(revision 19589)
+++ libs/libmythtv/v4lchannel.cpp	(working copy)
@@ -453,6 +453,7 @@
 
     // Fetch tuning data from the database.
     QString tvformat, modulation, freqtable, freqid, dtv_si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -463,6 +464,7 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         dtv_si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff, 
         mplexid, commfree))
     {
         return false;
@@ -738,10 +740,13 @@
     uint64_t frequency;
     uint     transportid;
     uint     dvb_networkid;
-
+    QString  dvb_msystem; 
+    QString  dvb_rolloff;
+    
     if (!ChannelUtil::GetTuningParams(
             mplexid, modulation, frequency,
-            transportid, dvb_networkid, si_std))
+            transportid, dvb_networkid, 
+            dvb_msystem, dvb_rolloff, si_std))
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR + "TuneMultiplex(): " +
                 QString("Could not find tuning parameters for multiplex %1.")
Index: libs/libmythtv/dvbtypes.h
===================================================================
--- libs/libmythtv/dvbtypes.h	(revision 19589)
+++ libs/libmythtv/dvbtypes.h	(working copy)
@@ -20,13 +20,17 @@
 #include <linux/dvb/dmx.h>
 
 #if (DVB_API_VERSION != 3 && DVB_API_VERSION != 5)
-#    error "DVB driver includes with API version 3 not found!"
+#    error "DVB driver includes with API version 3 or 5 not found!"
 #endif
 
 #ifndef DVB_API_VERSION_MINOR
 #    define DVB_API_VERSION_MINOR 0
 #endif
 
+#if (DVB_API_VERSION == 5)
+#    define USE_DVB_V5
+#endif
+
 #if ((DVB_API_VERSION == 3 && DVB_API_VERSION_MINOR >= 1) || (DVB_API_VERSION > 3))
 #    define USE_ATSC
 #else
@@ -39,11 +43,7 @@
 #    define VSB_16        (fe_modulation)(QAM_AUTO+2)
 #endif
 
-#ifdef FE_GET_EXTENDED_INFO
-  #define dvb_fe_params dvb_frontend_parameters_new
-#else
-  #define dvb_fe_params dvb_frontend_parameters
-#endif
+#define dvb_fe_params dvb_frontend_parameters
 
 class QString;
 QString toString(fe_status);
Index: libs/libmythtv/dvbchannel.cpp
===================================================================
--- libs/libmythtv/dvbchannel.cpp	(revision 19589)
+++ libs/libmythtv/dvbchannel.cpp	(working copy)
@@ -49,11 +49,21 @@
 
 static void drain_dvb_events(int fd);
 static bool wait_for_backend(int fd, int timeout_ms);
+
 static struct dvb_fe_params dtvmultiplex_to_dvbparams(
     DTVTunerType, const DTVMultiplex&);
 static DTVMultiplex dvbparams_to_dtvmultiplex(
     DTVTunerType, const dvb_fe_params&);
 
+#ifdef USE_DVB_V5
+static bool dtvmultiplex_to_dtvproperties(
+    DTVTunerType, const DTVMultiplex&, struct dtv_properties*, bool do_tune);
+static bool dtvmultiplex_to_dtvproperties(
+    DTVTunerType, const DTVMultiplex&, struct dtv_properties*);
+static DTVMultiplex dtvproperties_to_dtvmultiplex(
+    DTVTunerType, const dtv_properties&);
+#endif
+
 #define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(device)
 #define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \
                  .arg(GetCardID()).arg(device)
@@ -167,7 +177,6 @@
         frontend_name       = master->frontend_name;
         card_type           = master->card_type;
         capabilities        = master->capabilities;
-        ext_modulations     = master->ext_modulations;
         frequency_minimum   = master->frequency_minimum;
         frequency_maximum   = master->frequency_maximum;
         symbol_rate_minimum = master->symbol_rate_minimum;
@@ -210,59 +219,16 @@
         return false;
     }
 
-#ifdef FE_GET_EXTENDED_INFO
-    if (info.caps & FE_HAS_EXTENDED_INFO)
-    {
-        bool ok = true;
-        dvb_fe_caps_extended extinfo;
-        bzero(&extinfo, sizeof(extinfo));
-        if (ioctl(fd_frontend, FE_GET_EXTENDED_INFO, &extinfo) < 0)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    "Failed to get frontend extended information." + ENO);
-
-            ok = false;
-        }
-
-        if (ok && (extinfo.modulations & MOD_8PSK))
-        {
-            if (ioctl(fd_frontend, FE_SET_STANDARD, FE_DVB_S2) < 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR +
-                        "Failed to set frontend standard to DVB-S2." + ENO);
-
-                ok = false;
-            }
-            else if (ioctl(fd_frontend, FE_GET_INFO, &info) < 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR +
-                        "Failed to get frontend information." + ENO);
-
-                ok = false;
-            }
-        }
-
-        if (!ok)
-        {
-            close(fd_frontend);
-            fd_frontend = -1;
-            return false;
-        }
-
-        ext_modulations   = extinfo.modulations;
-    }
-#endif
-
     frontend_name       = info.name;
-    card_type           = info.type;
     capabilities        = info.caps;
     frequency_minimum   = info.frequency_min;
     frequency_maximum   = info.frequency_max;
     symbol_rate_minimum = info.symbol_rate_min;
     symbol_rate_maximum = info.symbol_rate_max;
+    card_type.Parse(CardUtil::ProbeDVBType(device));
 
-    VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.")
-            .arg(device).arg(frontend_name));
+    VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2', type '%3'.")
+            .arg(device).arg(frontend_name).arg(card_type));
 
     // Turn on the power to the LNB
     if (card_type == DTVTunerType::kTunerTypeQPSK ||
@@ -309,7 +275,9 @@
 bool DVBChannel::TuneMultiplex(uint mplexid, QString inputname)
 {
     DTVMultiplex tuning;
-    if (!tuning.FillFromDB(card_type, mplexid))
+    bool ok = true;
+    ok = tuning.FillFromDB(card_type, mplexid);
+    if (!ok)
         return false;
 
     CheckOptions(tuning);
@@ -365,6 +333,7 @@
 
     // Get the input data for the channel
     QString tvformat, modulation, freqtable, freqid, si_std;
+    QString msystem, rolloff;
     int finetune;
     uint64_t frequency;
     int mpeg_prog_num;
@@ -375,6 +344,7 @@
         tvformat, modulation, freqtable, freqid,
         finetune, frequency,
         si_std, mpeg_prog_num, atsc_major, atsc_minor, tsid, netid,
+        msystem, rolloff, 
         mplexid, commfree))
     {
         VERBOSE(VB_IMPORTANT, loc_err +
@@ -394,7 +364,8 @@
     if (!mplexid || !tuning.FillFromDB(card_type, mplexid))
     {
         VERBOSE(VB_IMPORTANT, loc_err +
-                "Failed to initialize multiplex options");
+                QString("Failed to initialize multiplex options (card_type=%1, mplexid=%2)").
+                        arg(card_type).arg(mplexid));
 
         return false;
     }
@@ -509,7 +480,11 @@
 
     if (card_type.IsFECVariable() && !CheckCodeRate(tuning.fec))
     {
-        VERBOSE(VB_GENERAL, LOC_WARN + "Unsupported fec_inner parameter.");
+        VERBOSE(VB_GENERAL, LOC_WARN + 
+        		QString("Unsupported fec_inner parameter (fec=%1, caps=%2, card_type=%3).")
+        		.arg(tuning.fec)
+        		.arg(capabilities)
+        		.arg(card_type));
     }
 
     if (card_type.IsModulationVariable() && !CheckModulation(tuning.modulation))
@@ -575,17 +550,28 @@
 bool DVBChannel::CheckCodeRate(DTVCodeRate rate) const
 {
     const uint64_t caps = capabilities;
+
+    /* Hmm... there are no FE_CAN_FEC_3_5 or FE_CAN_FEC_9_10 capabilities
+     * in S2API defined yet.
+     * So, let's assume that every DVB-S2 device can do them... */
+    if (card_type == DTVTunerType::kTunerTypeDVB_S2)
+    {
+    	if ((DTVCodeRate::kFEC_3_5  == rate) ||
+    		(DTVCodeRate::kFEC_9_10 == rate))
+    		return true;
+    }
+    
     return
-        ((DTVCodeRate::kFECNone == rate))                            ||
-        ((DTVCodeRate::kFEC_1_2 == rate) && (caps & FE_CAN_FEC_1_2)) ||
-        ((DTVCodeRate::kFEC_2_3 == rate) && (caps & FE_CAN_FEC_2_3)) ||
-        ((DTVCodeRate::kFEC_3_4 == rate) && (caps & FE_CAN_FEC_3_4)) ||
-        ((DTVCodeRate::kFEC_4_5 == rate) && (caps & FE_CAN_FEC_4_5)) ||
-        ((DTVCodeRate::kFEC_5_6 == rate) && (caps & FE_CAN_FEC_5_6)) ||
-        ((DTVCodeRate::kFEC_6_7 == rate) && (caps & FE_CAN_FEC_6_7)) ||
-        ((DTVCodeRate::kFEC_7_8 == rate) && (caps & FE_CAN_FEC_7_8)) ||
-        ((DTVCodeRate::kFEC_8_9 == rate) && (caps & FE_CAN_FEC_8_9)) ||
-        ((DTVCodeRate::kFECAuto == rate) && (caps & FE_CAN_FEC_AUTO));
+        ((DTVCodeRate::kFECNone  == rate))                             ||
+        ((DTVCodeRate::kFEC_1_2  == rate) && (caps & FE_CAN_FEC_1_2))  ||
+        ((DTVCodeRate::kFEC_2_3  == rate) && (caps & FE_CAN_FEC_2_3))  ||
+        ((DTVCodeRate::kFEC_3_4  == rate) && (caps & FE_CAN_FEC_3_4))  ||
+        ((DTVCodeRate::kFEC_4_5  == rate) && (caps & FE_CAN_FEC_4_5))  ||
+        ((DTVCodeRate::kFEC_5_6  == rate) && (caps & FE_CAN_FEC_5_6))  ||
+        ((DTVCodeRate::kFEC_6_7  == rate) && (caps & FE_CAN_FEC_6_7))  ||
+        ((DTVCodeRate::kFEC_7_8  == rate) && (caps & FE_CAN_FEC_7_8))  ||
+        ((DTVCodeRate::kFEC_8_9  == rate) && (caps & FE_CAN_FEC_8_9))  ||
+        ((DTVCodeRate::kFECAuto  == rate) && (caps & FE_CAN_FEC_AUTO));
 }
 
 /**
@@ -596,15 +582,6 @@
     const DTVModulation m = modulation;
     const uint64_t      c = capabilities;
 
-#ifdef FE_GET_EXTENDED_INFO
-    if ((c & FE_HAS_EXTENDED_INFO)            &&
-        (DTVModulation::kModulation8PSK == m) &&
-        (ext_modulations & DTVModulation::kModulation8PSK))
-    {
-        return true;
-    }
-#endif // FE_GET_EXTENDED_INFO
-
     return
         ((DTVModulation::kModulationQPSK    == m) && (c & FE_CAN_QPSK))     ||
         ((DTVModulation::kModulationQAM16   == m) && (c & FE_CAN_QAM_16))   ||
@@ -640,6 +617,7 @@
 bool DVBChannel::Tune(const DTVMultiplex &tuning, QString inputname)
 {
     int inputid = inputname.isEmpty() ? currentInputID : GetInputByName(inputname);
+
     if (inputid < 0)
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR + QString("Tune(): Invalid input '%1'.")
@@ -671,6 +649,7 @@
                       bool same_input)
 {
     QMutexLocker lock(&tune_lock);
+    uint64_t frequency = tuning.frequency;
 
     if (master)
     {
@@ -680,7 +659,27 @@
     }
 
     bool reset = (force_reset || first_tune);
+#ifdef USE_DVB_V5
+    struct dtv_properties cmds;
+
+    //clear card cache
+    dtv_property props[11];
+    memset(&props, 0, sizeof(props));
+    props[0].cmd = DTV_CLEAR;
+    cmds.num = 1;
+    cmds.props = props;
+    if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
+                "Clearing tuner cache failed." + ENO);
+        return false;
+    }
+    if ((!dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds)) || 
+    	(cmds.num < 2)) 
+    	return false;    
+#else
     struct dvb_fe_params params = dtvmultiplex_to_dvbparams(card_type, tuning);
+#endif
 
     bool is_dvbs = (DTVTunerType::kTunerTypeQPSK   == card_type ||
                     DTVTunerType::kTunerTypeDVB_S2 == card_type);
@@ -737,13 +736,24 @@
             // make sure we tune to frequency, if the lnb has changed
             reset = first_tune = true;
         }
-        
-        params.frequency = lnb->GetIntermediateFrequency(
-            diseqc_settings, tuning);
 
+        frequency = lnb->GetIntermediateFrequency(diseqc_settings, tuning);
+#ifdef USE_DVB_V5
+        for (uint i = 0; i < cmds.num; i++)
+        {
+            if (cmds.props[i].cmd == DTV_FREQUENCY)
+            {
+                cmds.props[i].u.data = frequency;
+                break;
+            }
+        }
+#else
+        params.frequency = frequency;
+
         // if card can auto-FEC, use it -- sometimes NITs are inaccurate
         if (capabilities & FE_CAN_FEC_AUTO)
             params.u.qpsk.fec_inner = FEC_AUTO;
+#endif
     }
 
     VERBOSE(VB_CHANNEL, LOC + "Old Params: " +
@@ -758,28 +768,24 @@
     if (reset || !prev_tuning.IsEqual(card_type, tuning, 500 * freq_mult))
     {
         VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning to %1%2")
-                .arg(params.frequency).arg(suffix));
+                .arg(frequency).arg(suffix));
 
-#ifdef FE_GET_EXTENDED_INFO
-        if (card_type == DTVTunerType::kTunerTypeDVB_S2)
+#ifdef USE_DVB_V5
+        VERBOSE(VB_CHANNEL, LOC + QString("Tune(): Tuning with %1 properties...").arg(cmds.num));
+        if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmds) < 0)
         {
-            if (ioctl(fd_frontend, FE_SET_FRONTEND2, &params) < 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
-                        "Setting Frontend(2) tuning parameters failed." + ENO);
-                return false;
-            }
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
+                    "Setting Frontend tuning parameters failed." + ENO);
+            return false;
         }
-        else
-#endif // FE_GET_EXTENDED_INFO
+#else
+        if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
         {
-            if (ioctl(fd_frontend, FE_SET_FRONTEND, &params) < 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
-                        "Setting Frontend tuning parameters failed." + ENO);
-                return false;
-            }
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Tune(): " +
+                    "Setting Frontend tuning parameters failed." + ENO);
+            return false;
         }
+#endif
 
         // Extra delay to add for broken DVB drivers
         if (tuning_delay)
@@ -835,8 +841,14 @@
         return false;
     }
 
+#ifdef USE_DVB_V5
+    struct dtv_properties cmds;
+    cmds.num = 0;
+    return ioctl(fd_frontend, FE_GET_PROPERTY, &cmds) >= 0;
+#else
     dvb_fe_params params;
     return ioctl(fd_frontend, FE_GET_FRONTEND, &params) >= 0;
+#endif
 }
 
 /** \fn DVBChannel::ProbeTuningParams(DTVMultiplex&) const
@@ -868,8 +880,19 @@
         return false;
     }
 
+    int fe_ok;
+#ifdef USE_DVB_V5
+    struct dtv_properties cmds;
+    dtv_property props[11];
+    memset(&props, 0, sizeof(props));
+    cmds.props = props;
+    dtvmultiplex_to_dtvproperties(card_type, tuning, &cmds, false);
+    fe_ok = ioctl(fd_frontend, FE_GET_PROPERTY, &cmds);
+#else
     dvb_fe_params params;
-    if (ioctl(fd_frontend, FE_GET_FRONTEND, &params) < 0)
+    fe_ok = ioctl(fd_frontend, FE_GET_FRONTEND, &params);
+#endif
+    if (fe_ok < 0)
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR +
                 "Getting Frontend tuning parameters failed." + ENO);
@@ -880,7 +903,11 @@
     uint    mplex      = tuning.mplex;
     QString sistandard = tuning.sistandard; sistandard.detach();
 
+#ifdef USE_DVB_V5
+    tuning = dtvproperties_to_dtvmultiplex(card_type, cmds);
+#else
     tuning = dvbparams_to_dtvmultiplex(card_type, params);
+#endif
 
     tuning.mplex       = mplex;
     tuning.sistandard  = sistandard;
@@ -967,9 +994,7 @@
     // We use uint16_t for sig because this is correct for DVB API 4.0,
     // and works better than the correct int16_t for the 3.x API
     uint16_t sig = 0;
-
     int ret = ioctl(fd_frontend, FE_READ_SIGNAL_STRENGTH, &sig);
-
     if (ok)
         *ok = (0 == ret);
 
@@ -987,7 +1012,6 @@
 
     uint16_t snr = 0;
     int ret = ioctl(fd_frontend, FE_READ_SNR, &snr);
-
     if (ok)
         *ok = (0 == ret);
 
@@ -1002,7 +1026,6 @@
 
     uint32_t ber = 0;
     int ret = ioctl(fd_frontend, FE_READ_BER, &ber);
-
     if (ok)
         *ok = (0 == ret);
 
@@ -1017,7 +1040,6 @@
 
     uint32_t ublocks = 0;
     int ret = ioctl(fd_frontend, FE_READ_UNCORRECTED_BLOCKS, &ublocks);
-
     if (ok)
         *ok = (0 == ret);
 
@@ -1111,14 +1133,8 @@
 
     if (DTVTunerType::kTunerTypeDVB_S2 == tuner_type)
     {
-#ifdef FE_GET_EXTENDED_INFO
-        params.u.qpsk2.symbol_rate = tuning.symbolrate;
-        params.u.qpsk2.fec_inner   = (fe_code_rate_t) (int) tuning.fec;
-        params.u.qpsk2.modulation  = (fe_modulation_t) (int) tuning.modulation;
-#else // if !FE_GET_EXTENDED_INFO
         VERBOSE(VB_IMPORTANT, "DVBChan Error, MythTV was compiled without "
                 "DVB-S2 headers being present so DVB-S2 tuning will fail.");
-#endif // !FE_GET_EXTENDED_INFO
     }
 
     if (DTVTunerType::kTunerTypeQAM  == tuner_type)
@@ -1199,3 +1215,258 @@
 
     return tuning;
 }
+
+
+#ifdef USE_DVB_V5
+static DTVMultiplex dtvproperties_to_dtvmultiplex(
+    DTVTunerType tuner_type, const dtv_properties &cmds)
+{
+    DTVMultiplex tuning;
+
+    for (uint i = 0; i < cmds.num; i++)
+    {
+        switch (cmds.props[i].cmd)
+        {
+            case DTV_MODULATION:
+                tuning.modulation = cmds.props[i].u.data;
+                break;
+            case DTV_DELIVERY_SYSTEM:
+                switch (cmds.props[i].u.data)
+                {
+                    case SYS_DVBS:
+                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS;
+                        break;
+                    case SYS_DVBS2:
+                        tuning.msystem = DTVModulationSystem::kModulationSystemDVBS2;
+                        break;
+                    case SYS_DVBT:
+                    case SYS_DVBC_ANNEX_AC:
+                    case SYS_DVBC_ANNEX_B:
+#ifdef USE_ATSC
+                    case SYS_ATSC:
+#endif
+                        break;
+                    default:
+                        VERBOSE(VB_IMPORTANT, "Unknown DVB delivery system." + ENO);
+                };
+                break;
+            case DTV_FREQUENCY:
+                if (tuning.modulation == DTVModulation::kModulationQPSK ||
+                    tuning.modulation == DTVModulation::kModulation8PSK)
+                    tuning.frequency = cmds.props[i].u.data / 1000UL;
+                else
+                    tuning.frequency = cmds.props[i].u.data;
+                break;
+            case DTV_SYMBOL_RATE:
+                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
+                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
+                    tuner_type == DTVTunerType::kTunerTypeQAM)
+                {
+                    if (tuning.modulation == DTVModulation::kModulationQPSK ||
+                        tuning.modulation == DTVModulation::kModulation8PSK)
+                        tuning.symbolrate = cmds.props[i].u.data / 1000UL;
+                    else
+                        tuning.symbolrate = cmds.props[i].u.data;
+                };
+                break;
+            case DTV_INNER_FEC:
+                if (tuner_type == DTVTunerType::kTunerTypeQPSK   ||
+                    tuner_type == DTVTunerType::kTunerTypeDVB_S2 ||
+                    tuner_type == DTVTunerType::kTunerTypeQAM)
+                {
+                    tuning.symbolrate = cmds.props[i].u.data;
+                }
+                break;
+            case DTV_PILOT:
+                break;
+            case DTV_ROLLOFF:
+                if (tuner_type == DTVTunerType::kTunerTypeDVB_S2)
+                    tuning.rolloff = cmds.props[i].u.data;
+                break;
+            case DTV_INVERSION:
+                tuning.inversion = cmds.props[i].u.data;
+                break;
+            case DTV_BANDWIDTH_HZ:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.bandwidth = cmds.props[i].u.data;
+                break;
+            case DTV_CODE_RATE_HP:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.hp_code_rate = cmds.props[i].u.data;
+                break;
+            case DTV_CODE_RATE_LP:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.lp_code_rate = cmds.props[i].u.data;
+                break;
+            case DTV_TRANSMISSION_MODE:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.trans_mode = cmds.props[i].u.data;
+                break;
+            case DTV_GUARD_INTERVAL:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.guard_interval = cmds.props[i].u.data;
+                break;
+            case DTV_HIERARCHY:
+                if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+                    tuning.hierarchy = cmds.props[i].u.data;
+                break;
+            case DTV_TUNE:
+                break;
+            default:
+                VERBOSE(VB_IMPORTANT, "Unknown DTV command." + ENO);
+        }
+    }
+    return tuning;
+}
+
+static bool dtvmultiplex_to_dtvproperties(
+    DTVTunerType tuner_type,
+    const DTVMultiplex &tuning,
+    struct dtv_properties *cmdseq)
+{
+    return dtvmultiplex_to_dtvproperties(tuner_type, tuning, cmdseq, true);
+}
+
+static bool dtvmultiplex_to_dtvproperties(
+    DTVTunerType tuner_type,
+    const DTVMultiplex &tuning,
+    struct dtv_properties *cmdseq,
+    bool do_tune)
+{
+    if (tuner_type == DTVTunerType::kTunerTypeQPSK ||
+        (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
+         tuning.modulation == DTVModulation::kModulationQPSK))
+    {
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = SYS_DVBS;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = tuning.modulation;
+        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
+        cmdseq->props[3].u.data = tuning.symbolrate;
+        cmdseq->props[4].cmd    = DTV_INNER_FEC;
+        cmdseq->props[4].u.data = tuning.fec;
+        cmdseq->props[5].cmd    = DTV_INVERSION;
+        cmdseq->props[5].u.data = tuning.inversion;
+        if (do_tune)
+        {
+            cmdseq->props[6].cmd    = DTV_TUNE;
+            cmdseq->num = 7;
+        }
+        else
+        {
+            cmdseq->num = 6;
+        }
+    }
+    else if (tuner_type == DTVTunerType::kTunerTypeDVB_S2 &&
+             tuning.modulation == DTVModulation::kModulation8PSK)
+    {
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = SYS_DVBS2;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = tuning.modulation;
+        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
+        cmdseq->props[3].u.data = tuning.symbolrate;
+        cmdseq->props[4].cmd    = DTV_INNER_FEC;
+        cmdseq->props[4].u.data = tuning.fec;
+        cmdseq->props[5].cmd    = DTV_INVERSION;
+        cmdseq->props[5].u.data = tuning.inversion;
+        cmdseq->props[6].cmd    = DTV_PILOT;
+        cmdseq->props[6].u.data = PILOT_AUTO;
+        cmdseq->props[7].cmd    = DTV_ROLLOFF;
+        if (tuning.msystem == DTVModulationSystem::kModulationSystemDVBS2)
+            cmdseq->props[7].u.data = tuning.rolloff;
+        else
+            cmdseq->props[7].u.data = DTVRollOff::kRollOff35;
+        if (do_tune)
+        {
+            cmdseq->props[8].cmd = DTV_TUNE;
+            cmdseq->num = 9;
+        }
+        else
+            cmdseq->num = 8;
+    }
+    else if (tuner_type == DTVTunerType::kTunerTypeQAM)
+    {
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = (fe_delivery_system_t) (int) tuning.msystem;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
+        cmdseq->props[3].cmd    = DTV_SYMBOL_RATE;
+        cmdseq->props[3].u.data = tuning.symbolrate;
+        cmdseq->props[4].cmd    = DTV_INNER_FEC;
+        cmdseq->props[4].u.data = (fe_code_rate_t) (int) tuning.fec;
+        cmdseq->props[5].cmd    = DTV_INVERSION;
+        cmdseq->props[5].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
+        if (do_tune)
+        {
+            cmdseq->props[6].cmd    = DTV_TUNE;
+            cmdseq->num = 7;
+        }
+        else
+            cmdseq->num = 6;
+    }
+    else if (tuner_type == DTVTunerType::kTunerTypeOFDM)
+    {
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = SYS_DVBC_ANNEX_AC;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;
+        cmdseq->props[3].cmd    = DTV_INVERSION;
+        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
+        cmdseq->props[4].cmd    = DTV_BANDWIDTH_HZ;
+        cmdseq->props[4].u.data = (fe_bandwidth_t) (int) tuning.bandwidth;
+        cmdseq->props[5].cmd    = DTV_CODE_RATE_HP;
+        cmdseq->props[5].u.data = (fe_code_rate_t) (int) tuning.hp_code_rate;
+        cmdseq->props[6].cmd    = DTV_CODE_RATE_LP;
+        cmdseq->props[6].u.data = (fe_code_rate_t) (int) tuning.lp_code_rate;
+        cmdseq->props[7].cmd    = DTV_TRANSMISSION_MODE;
+        cmdseq->props[7].u.data = (fe_transmit_mode_t) (int) tuning.trans_mode;
+        cmdseq->props[8].cmd    = DTV_GUARD_INTERVAL;
+        cmdseq->props[8].u.data = (fe_guard_interval_t) (int) tuning.guard_interval;
+        cmdseq->props[9].cmd    = DTV_HIERARCHY;
+        cmdseq->props[9].u.data = (fe_hierarchy_t) (int) tuning.hierarchy;
+        if (do_tune)
+        {
+            cmdseq->props[10].cmd    = DTV_TUNE;
+            cmdseq->num = 11;
+        }
+        else
+            cmdseq->num = 10;
+    }
+#ifdef USE_ATSC
+    else if (tuner_type == DTVTunerType::kTunerTypeATSC)
+    {
+        cmdseq->props[0].cmd    = DTV_DELIVERY_SYSTEM;
+        cmdseq->props[0].u.data = SYS_ATSC;
+        cmdseq->props[1].cmd    = DTV_FREQUENCY;
+        cmdseq->props[1].u.data = tuning.frequency * 1000UL;
+        cmdseq->props[2].cmd    = DTV_MODULATION;
+        cmdseq->props[2].u.data = (fe_modulation_t) (int) tuning.modulation;;
+        cmdseq->props[3].cmd    = DTV_INVERSION;
+        cmdseq->props[3].u.data = (fe_spectral_inversion_t) (int) tuning.inversion;
+        if (do_tune)
+        {
+            cmdseq->props[4].cmd    = DTV_TUNE;
+            cmdseq->num = 5;
+        }
+        else
+            cmdseq->num = 4;
+    }
+#endif
+    else
+    {
+        VERBOSE(VB_IMPORTANT, "Unknown tuner type." + ENO);
+        return false;
+    }
+    return true;
+}
+#endif
+
Index: libs/libmythtv/cardutil.cpp
===================================================================
--- libs/libmythtv/cardutil.cpp	(revision 19589)
+++ libs/libmythtv/cardutil.cpp	(working copy)
@@ -245,6 +245,16 @@
     close(fd_frontend);
 
     DTVTunerType type(info.type);
+#ifdef USE_DVB_V5    
+    if (type == DTVTunerType::kTunerTypeQPSK) 
+    {
+    	/* We basically have a DVB-S device. Check capabilities to see if
+    	 * the device is capable of doing DVB-S2. 
+    	 * Caution: Needs "Add missing S2 caps flag to S2API" patch in S2API. */
+    	if (info.caps & FE_CAN_2G_MODULATION)
+     	    type = DTVTunerType::kTunerTypeDVB_S2;     		
+ 	}
+#endif
     ret = (type.toString() != "UNKNOWN") ? type.toString().toUpper() : ret;
 #endif // USING_DVB
 
@@ -337,7 +347,7 @@
 {
     QString ct = card_type.toUpper();
     return (ct == "DVB") || (ct == "QAM") || (ct == "QPSK") ||
-        (ct == "OFDM") || (ct == "ATSC");
+        (ct == "OFDM") || (ct == "ATSC") || (ct == "DVB_S2");
 }
 
 QString get_on_cardid(const QString &to_get, uint cardid)
Index: libs/libmythtv/videosource.cpp
===================================================================
--- libs/libmythtv/videosource.cpp	(revision 19589)
+++ libs/libmythtv/videosource.cpp	(working copy)
@@ -2929,6 +2929,12 @@
             signal_timeout->setValue(60000);
             channel_timeout->setValue(62500);
             break;
+        case CardUtil::DVBS2:
+            cardtype->setValue("DVB-S2");
+            cardname->setValue(frontend_name);
+            signal_timeout->setValue(60000);
+            channel_timeout->setValue(62500);
+            break;
         case CardUtil::QAM:
             cardtype->setValue("DVB-C");
             cardname->setValue(frontend_name);
Index: libs/libmythtv/frequencytables.cpp
===================================================================
--- libs/libmythtv/frequencytables.cpp	(revision 19589)
+++ libs/libmythtv/frequencytables.cpp	(working copy)
@@ -68,7 +68,9 @@
         _tuning.lp_code_rate.toString(),     _tuning.modulation.toString(),
         _tuning.trans_mode.toString(),       _tuning.guard_interval.toString(),
         _tuning.hierarchy.toString(),        _tuning.modulation.toString(),
-        _tuning.bandwidth.toString());
+        _tuning.bandwidth.toString(),        _tuning.msystem.toString(),
+        _tuning.rolloff.toString());
+    tuning.sistandard = _tuning.sistandard;
 }
 
 TransportScanItem::TransportScanItem(uint sourceid,
Index: libs/libmythtv/scanwizard.cpp
===================================================================
--- libs/libmythtv/scanwizard.cpp	(revision 19589)
+++ libs/libmythtv/scanwizard.cpp	(working copy)
@@ -98,6 +98,11 @@
         start_chan = configPane->GetStartChan();
         parse_type = DTVTunerType::kTunerTypeQPSK;
     }
+    else if (scantype == ScanTypeSetting::NITAddScan_DVBS2)
+    {
+        start_chan = configPane->GetStartChan();
+        parse_type = DTVTunerType::kTunerTypeDVB_S2;
+    }
     else if (scantype == ScanTypeSetting::NITAddScan_QAM)
     {
         start_chan = configPane->GetStartChan();
@@ -139,7 +144,8 @@
             start_chan["coderate_hp"],    start_chan["coderate_lp"],
             start_chan["constellation"],  start_chan["trans_mode"],
             start_chan["guard_interval"], start_chan["hierarchy"],
-            start_chan["modulation"],     start_chan["bandwidth"]))
+            start_chan["modulation"],     start_chan["bandwidth"],
+            start_chan["msystem"],        start_chan["rolloff"]))
     {
         MythPopupBox::showOkPopup(
             gContext->GetMainWindow(), tr("ScanWizard"),
Index: libs/libmythtv/transporteditor.cpp
===================================================================
--- libs/libmythtv/transporteditor.cpp	(revision 19589)
+++ libs/libmythtv/transporteditor.cpp	(working copy)
@@ -98,7 +98,7 @@
     MSqlQuery query(MSqlQuery::InitCon());
     query.prepare(
         "SELECT mplexid, modulation, frequency, "
-        "       symbolrate, networkid, transportid, constellation "
+        "       symbolrate, networkid, transportid, constellation, msystem "
         "FROM dtv_multiplex, videosource "
         "WHERE dtv_multiplex.sourceid = :SOURCEID AND "
         "      dtv_multiplex.sourceid = videosource.sourceid "
@@ -129,13 +129,17 @@
         QString tid = query.value(5).toUInt() ?
             QString("tid %1").arg(query.value(5).toUInt(), 5) : "";
 
-        QString hz = (CardUtil::QPSK == cardtype) ? "kHz" : "Hz";
+        QString hz = (CardUtil::QPSK == cardtype ||
+                      CardUtil::DVBS2 == cardtype) ? "kHz" : "Hz";
 
         QString type = "";
         if (CardUtil::OFDM == cardtype)
             type = "(DVB-T)";
         if (CardUtil::QPSK == cardtype)
             type = "(DVB-S)";
+        if (CardUtil::DVBS2 == cardtype)
+            type = (query.value(7).toString() == "dvbs2")?"(DVB-S2)":"(DVB-S)";
+
         if (CardUtil::QAM == cardtype)
             type = "(DVB-C)";
 
@@ -487,6 +491,20 @@
     };
 };
 
+class DVBS2ModulationSystem: public ComboBoxSetting, public MuxDBStorage
+{
+  public:
+    DVBS2ModulationSystem(const MultiplexID *id) :
+        ComboBoxSetting(this), MuxDBStorage(this, id, "msystem")
+    {
+        setLabel(QObject::tr("Modulation system"));
+        setHelpText(QObject::tr("Modulation system (Default: DVB-S)\n"
+                                "Standard selection: DVB-S/DVB-S2"));
+        addSelection(QObject::tr("DVB-S"), "dvbs");
+        addSelection(QObject::tr("DVB-S2"), "dvbs2");
+    };
+};
+
 class Modulation : public ComboBoxSetting, public MuxDBStorage
 {
   public:
@@ -506,6 +524,15 @@
         // no modulation options
         setVisible(false);
     }
+    if (CardUtil::QPSK == nType)
+    {
+        addSelection("QPSK", "qpsk");
+    }
+    if (CardUtil::DVBS2 == nType)
+    {
+        addSelection("QPSK", "qpsk");
+        addSelection("8PSK", "8psk");
+    }
     else if ((CardUtil::QAM == nType) || (CardUtil::OFDM == nType))
     {
         addSelection(QObject::tr("QAM Auto"), "auto");
@@ -576,11 +603,13 @@
         addSelection("1/2");
         addSelection("2/3");
         addSelection("3/4");
+        addSelection("3/5");
         addSelection("4/5");
         addSelection("5/6");
         addSelection("6/7");
         addSelection("7/8");
         addSelection("8/9");
+        addSelection("9/10");
     };
 };
 
@@ -597,6 +626,21 @@
     };
 };
 
+class DVBS2RollOff: public ComboBoxSetting, public MuxDBStorage
+{
+  public:
+    DVBS2RollOff(const MultiplexID *id) :
+        ComboBoxSetting(this), MuxDBStorage(this, id, "rolloff")
+    {
+        setLabel(QObject::tr("Roll-off"));
+        setHelpText(QObject::tr("Roll-off (Default: 0.35)"));
+        addSelection(QObject::tr("0.35"), "0.35");
+        addSelection(QObject::tr("0.20"), "0.20");
+        addSelection(QObject::tr("0.25"), "0.25");
+        addSelection(QObject::tr("Auto"), "auto");
+    };
+};
+
 class DVBTCoderateLP :
     public DVBForwardErrorCorrectionSelector, public MuxDBStorage
 {
@@ -715,6 +759,20 @@
         right->addChild(new DVBForwardErrorCorrection(id));
         right->addChild(new SignalPolarity(id));
     }
+    else if (CardUtil::DVBS2 == nType)
+    {
+        left->addChild(new DTVStandard(id, true, false));
+        left->addChild(new Frequency(id, true));
+        left->addChild(new DVBSymbolRate(id));
+        left->addChild(new DVBInversion(id));
+        left->addChild(new SignalPolarity(id));
+
+        right = new VerticalConfigurationGroup(false, true, false, false);
+        right->addChild(new DVBS2ModulationSystem(id));
+        right->addChild(new Modulation(id, nType));
+        right->addChild(new DVBForwardErrorCorrection(id));
+        right->addChild(new DVBS2RollOff(id));
+    }
     else if (CardUtil::QAM == nType)
     {
         left->addChild(new DTVStandard(id, true, false));
Index: libs/libmythtv/scanwizardhelpers.cpp
===================================================================
--- libs/libmythtv/scanwizardhelpers.cpp	(revision 19589)
+++ libs/libmythtv/scanwizardhelpers.cpp	(working copy)
@@ -455,6 +455,13 @@
                          QString::number(NITAddScan_QPSK));
             importConf = true;
             break;
+    case CardUtil::DVBS2:
+        addSelection(tr("Full Scan (Tuned)"),
+                     QString::number(NITAddScan_DVBS2));
+        addSelection(tr("Import channels.conf"),
+                     QString::number(DVBUtilsImport));
+        break;
+
         case CardUtil::QAM:
             addSelection(tr("Full Scan (Tuned)"),
                          QString::number(NITAddScan_QAM));
@@ -584,6 +591,8 @@
               paneQAM);
     addTarget(QString::number(ScanTypeSetting::NITAddScan_QPSK),
               paneQPSK);
+    addTarget(QString::number(ScanTypeSetting::NITAddScan_DVBS2),
+              paneDVBS2);
     addTarget(QString::number(ScanTypeSetting::NITAddScan_OFDM),
               paneOFDM);
     addTarget(QString::number(ScanTypeSetting::FullScan_ATSC),
@@ -776,6 +785,20 @@
         startChan["modulation"] = "qpsk";
         startChan["polarity"]   = pane->polarity();
     }
+    else if (ScanTypeSetting::NITAddScan_DVBS2 == st)
+    {
+        const DVBS2Pane *pane = paneDVBS2;
+
+        startChan["std"]        = "dvb";
+        startChan["frequency"]  = pane->frequency();
+        startChan["inversion"]  = pane->inversion();
+        startChan["symbolrate"] = pane->symbolrate();
+        startChan["fec"]        = pane->fec();
+        startChan["msystem"]    = pane->msystem();
+        startChan["modulation"] = pane->modulation();
+        startChan["polarity"]   = pane->polarity();
+        startChan["rolloff"]    = pane->rolloff();
+    }
     else if (ScanTypeSetting::NITAddScan_QAM == st)
     {
         const QAMPane *pane = paneQAM;
Index: libs/libmythtv/dtvmultiplex.cpp
===================================================================
--- libs/libmythtv/dtvmultiplex.cpp	(revision 19589)
+++ libs/libmythtv/dtvmultiplex.cpp	(working copy)
@@ -24,6 +24,8 @@
     fec            = other.fec;
     mplex          = other.mplex;
     sistandard     = other.sistandard;
+    msystem        = other.msystem;
+    rolloff        = other.rolloff;
     sistandard.detach();
     return *this;
 }
@@ -40,7 +42,9 @@
             (guard_interval == m.guard_interval) &&
             (fec == m.fec) &&
             (polarity == m.polarity) &&
-            (hierarchy == m.hierarchy));
+            (hierarchy == m.hierarchy) &&
+            (msystem == m.msystem) &&
+            (rolloff == m.rolloff));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -48,14 +52,15 @@
 
 QString DTVMultiplex::toString() const
 {
-    QString ret = QString("%1 %2 %3 ")
-        .arg(frequency).arg(modulation.toString()).arg(inversion.toString());
+    QString ret = QString("f: %1 mod: %2 inv: %3 fec: %4")
+        .arg(frequency).arg(modulation.toString()).arg(inversion.toString()).arg(fec.toString());
 
-    ret += QString("%1 %2 %3 %4 %5 %6 %7")
+    ret += QString("hp: %1 lp: %2 bandw: %3 transmode: %4 guardi: %5 hier: %6 polar: %7 msys: %8 rolloff: %9")
         .arg(hp_code_rate.toString()).arg(lp_code_rate.toString())
         .arg(bandwidth.toString()).arg(trans_mode.toString())
         .arg(guard_interval.toString()).arg(hierarchy.toString())
-        .arg(polarity.toString());
+        .arg(polarity.toString())
+        .arg(msystem.toString()).arg(rolloff.toString());
 
     return ret;
 }
@@ -102,7 +107,9 @@
         return
             (inversion  == other.inversion)  &&
             (symbolrate == other.symbolrate) &&
-            (fec        == other.fec);
+            (fec        == other.fec)        &&
+            (msystem    == other.msystem)    &&
+            (rolloff    == other.rolloff);
     }
 
     return false;
@@ -152,13 +159,10 @@
     const QString &_symbol_rate, const QString &_fec_inner,
     const QString &_modulation,  const QString &_polarity)
 {
-    bool ok = inversion.Parse(_inversion);
-    if (!ok)
+    if (!inversion.Parse(_inversion))
     {
         VERBOSE(VB_GENERAL, LOC_WARN +
-                "Invalid inversion, falling back to 'auto'");
-
-        ok = true;
+                QString("Invalid inversion '%1' , falling back to 'auto'.").arg(_inversion));
     }
 
     symbolrate = _symbol_rate.toInt();
@@ -166,29 +170,88 @@
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid symbol rate " +
                 QString("parameter '%1', aborting.").arg(_symbol_rate));
-
         return false;
     }
 
-    ok &= fec.Parse(_fec_inner);
-    ok &= modulation.Parse(_modulation);
+    if (!fec.Parse(_fec_inner))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid fec_inner " +
+                QString("parameter '%1', aborting.").arg(_fec_inner));
+        return false;    	
+    }
+    
+    if (!modulation.Parse(_modulation))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid modulation " +
+                QString("parameter '%1', aborting.").arg(_modulation));
+        return false;    	    	
+    }
 
     if (!_polarity.isEmpty())
-        polarity.Parse(_polarity.toLower());
+        if (!polarity.Parse(_polarity.toLower()))
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid polarity " +
+                    QString("parameter '%1', aborting.").arg(_polarity));
+            return false;    	    	        	
+        }
 
-    if (ok)
-        frequency = _frequency.toInt(&ok);
+    bool ok;
+    frequency = _frequency.toInt(&ok);
+    if (!ok)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid frequency " +
+                QString("parameter '%1', aborting.").arg(_frequency));
+        return false;    	    	        	
+    	
+    }
 
-    return ok;
+    return true;
 }
 
+bool DTVMultiplex::ParseDVB_S2(
+    const QString &_frequency,   const QString &_inversion,
+    const QString &_symbol_rate, const QString &_fec_inner,
+    const QString &_modulation,  const QString &_polarity,
+    const QString &_msystem,     const QString &_rolloff)
+{
+	if (!ParseDVB_S_and_C(_frequency,   _inversion,
+		 		  		  _symbol_rate, _fec_inner,
+						  _modulation,  _polarity))
+	{
+		return false;
+	}
+	
+    if (!_msystem.isEmpty())
+    {
+        if (!msystem.Parse(_msystem))
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid modulation system " +
+                    QString("parameter '%1', aborting.").arg(_msystem));
+            return false;
+        }
+    }
+
+    if (!_rolloff.isEmpty())
+    {
+        if(!rolloff.Parse(_rolloff))
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Invalid rolloff " +
+                    QString("parameter '%1', aborting.").arg(_rolloff));
+            return false;
+        }
+    }
+
+    return true;
+}
+
 bool DTVMultiplex::ParseTuningParams(
     DTVTunerType type,
     QString _frequency,    QString _inversion,      QString _symbolrate,
     QString _fec,          QString _polarity,
     QString _hp_code_rate, QString _lp_code_rate,   QString _ofdm_modulation,
     QString _trans_mode,   QString _guard_interval, QString _hierarchy,
-    QString _modulation,   QString _bandwidth)
+    QString _modulation,   QString _bandwidth,
+    QString _msystem,      QString _rolloff)
 {
     if (DTVTunerType::kTunerTypeOFDM == type)
     {
@@ -198,15 +261,22 @@
             _hierarchy);
     }
 
-    if ((DTVTunerType::kTunerTypeQPSK   == type) ||
-        (DTVTunerType::kTunerTypeDVB_S2 == type) ||
-        (DTVTunerType::kTunerTypeQAM    == type))
+    if ((DTVTunerType::kTunerTypeQPSK == type) ||
+    	(DTVTunerType::kTunerTypeQAM  == type))
     {
         return ParseDVB_S_and_C(
             _frequency,       _inversion,     _symbolrate,
             _fec,             _modulation,    _polarity);
     }
 
+    if (DTVTunerType::kTunerTypeDVB_S2 == type)
+    {
+        return ParseDVB_S2(
+            _frequency,       _inversion,     _symbolrate,
+            _fec,             _modulation,    _polarity,
+            _msystem,         _rolloff);
+    }
+
     if (DTVTunerType::kTunerTypeATSC == type)
         return ParseATSC(_frequency, _modulation);
 
@@ -223,7 +293,8 @@
         "       fec,               polarity, "
         "       hp_code_rate,      lp_code_rate,   constellation, "
         "       transmission_mode, guard_interval, hierarchy, "
-        "       modulation,        bandwidth,      sistandard "
+        "       modulation,        bandwidth,      sistandard, "
+        "       msystem,           rolloff "
         "FROM dtv_multiplex "
         "WHERE dtv_multiplex.mplexid = :MPLEXID");
     query.bindValue(":MPLEXID", mplexid);
@@ -256,7 +327,8 @@
         query.value(6).toString(),  query.value(7).toString(),
         query.value(8).toString(),  query.value(9).toString(),
         query.value(10).toString(), query.value(11).toString(),
-        query.value(12).toString());
+        query.value(12).toString(), query.value(14).toString(),
+        query.value(15).toString());
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -318,6 +390,7 @@
         "    mplexid,            frequency,       inversion,  "
         "    symbolrate,         fec,             polarity,   "
         "    hp_code_rate,       lp_code_rate,    modulation, "
+        "    msystem,            rolloff,                     "
         "    transmission_mode,  guard_interval,  hierarchy,  "
         "    bandwidth,          sistandard,      tuner_type  "
         " ) "
@@ -326,6 +399,7 @@
         "   :MPLEXID,           :FREQUENCY,      :INVERSION,  "
         "   :SYMBOLRATE,        :FEC,            :POLARITY,   "
         "   :HP_CODE_RATE,      :LP_CODE_RATE,   :MODULATION, "
+        "   :MSYSTEM,           :ROLLOFF,                     "
         "   :TRANSMISSION_MODE, :GUARD_INTERVAL, :HIERARCHY,  "
         "   :BANDWIDTH,         :SISTANDARD,     :TUNER_TYPE  "
         " );");
@@ -340,6 +414,8 @@
     query.bindValue(":HP_CODE_RATE", hp_code_rate.toString());
     query.bindValue(":LP_CODE_RATE", lp_code_rate.toString());
     query.bindValue(":MODULATION", modulation.toString());
+    query.bindValue(":MSYSTEM", msystem.toString());
+    query.bindValue(":ROLLOFF", rolloff.toString());
     query.bindValue(":TRANSMISSION_MODE", trans_mode.toString());
     query.bindValue(":GUARD_INTERVAL", guard_interval.toString());
     query.bindValue(":HIERARCHY", hierarchy.toString());