Ticket #9726: mythtv-0.27-unicable.patch

.27/mythtv/libs/libmythtv/diseqc.cpp

@@ -68 +68 @@
 #define DISEQC_CMD_WRITE_N0   0x38
 #define DISEQC_CMD_WRITE_N1   0x39
 #define DISEQC_CMD_WRITE_FREQ 0x58
+#define DISEQC_CMD_ODU        0x5A
+#define DISEQC_CMD_ODU_MDU    0x5C
 #define DISEQC_CMD_HALT       0x60
 #define DISEQC_CMD_LMT_OFF    0x63
 #define DISEQC_CMD_LMT_E      0x66
@@ -85 +87 @@
 
 #define LOC      QString("DiSEqCDevTree: ")
 
+bool diseqc_bus_already_reset = false;
+
 QString DiSEqCDevDevice::TableToString(uint type, const TypeTable *table)
 {
     for (; !table->name.isEmpty(); table++)
@@ -563 +567 @@
     return lnb;
 }
 
+/** \fn DiSEqCDevTree::FindSCR(const DiSEqCDevSettings&)
+ *  \brief Returns the SCR device object selected by the configuration chain.
+ *  \param settings Configuration chain in effect.
+ *  \return Pointer to SCR object if found, NULL otherwise.
+ */
+DiSEqCDevSCR *DiSEqCDevTree::FindSCR(const DiSEqCDevSettings &settings)
+{
+    DiSEqCDevDevice *node = m_root;
+    DiSEqCDevSCR    *scr  = NULL;
+
+    while (node)
+    {
+        scr = dynamic_cast<DiSEqCDevSCR*>(node);
+
+        if (scr)
+            break;
+
+        node = node->GetSelectedChild(settings);
+    }
+
+    return scr;
+}
+
 
 /** \fn DiSEqCDevTree::FindDevice(uint)
  *  \brief Returns a device by ID.
@@ -635 +662 @@
         return false;
     }
 
+    bool resend_cmd = false;
+
 #ifndef USING_DVB
 
     (void) adr;
@@ -661 +690 @@
 
     LOG(VB_CHANNEL, LOG_INFO, LOC + "Sending DiSEqC Command: " + cmdstr);
 
+    if (repeats >= 10)
+    {
+        repeats = repeats - 10;
+        resend_cmd = true;
+    }
+
     // send the command
     for (uint i = 0; i <= repeats; i++)
     {
@@ -670 +705 @@
             return false;
         }
 
-        mcmd.msg[0] |= DISEQC_FRM_REPEAT;
+        if (!resend_cmd)
+            mcmd.msg[0] |= DISEQC_FRM_REPEAT;
+
         usleep(DISEQC_SHORT_WAIT);
     }
 
@@ -684 +721 @@
  *  \param hard_reset If true, the bus will be power cycled.
  *  \return True if successful.
  */
-bool DiSEqCDevTree::ResetDiseqc(bool hard_reset)
+bool DiSEqCDevTree::ResetDiseqc(bool hard_reset, bool is_SCR)
 {
     Reset();
 
@@ -696 +733 @@
 
         SetVoltage(SEC_VOLTAGE_OFF);
         usleep(DISEQC_POWER_OFF_WAIT);
+        diseqc_bus_already_reset = false;
     }
 
-    // make sure the bus is powered
-    SetVoltage(SEC_VOLTAGE_18);
-    usleep(DISEQC_POWER_ON_WAIT);
-    // some DiSEqC devices need more time. see #8465
-    usleep(DISEQC_POWER_ON_WAIT);
-
-    // issue a global reset command
-    LOG(VB_CHANNEL, LOG_INFO, LOC + "Resetting DiSEqC Bus");
-    if (!SendCommand(DISEQC_ADR_ALL, DISEQC_CMD_RESET))
+    if (!diseqc_bus_already_reset || !is_SCR)
     {
-        LOG(VB_GENERAL, LOG_ERR, LOC + "DiSEqC reset failed" + ENO);
-        return false;
+        // make sure the bus is powered
+        SetVoltage(SEC_VOLTAGE_18);
+        usleep(DISEQC_POWER_ON_WAIT);
+        // some DiSEqC devices need more time. see #8465
+        usleep(DISEQC_POWER_ON_WAIT);
+
+        // issue a global reset command
+        LOG(VB_CHANNEL, LOG_INFO, LOC + "Resetting DiSEqC Bus");
+        if (!SendCommand(DISEQC_ADR_ALL, DISEQC_CMD_RESET))
+        {
+            LOG(VB_GENERAL, LOG_ERR, LOC + "DiSEqC reset failed" + ENO);
+            return false;
+        }
+        
+        if (is_SCR)
+            diseqc_bus_already_reset = true;
+    }
+    else
+    {
+        LOG(VB_CHANNEL, LOG_INFO, LOC + "Skiping reset: already done for this SCR bus");
     }
 
     usleep(DISEQC_LONG_WAIT);
@@ -717 +765 @@
     return true;
 }
 
-void DiSEqCDevTree::Open(int fd_frontend)
+void DiSEqCDevTree::Open(int fd_frontend, bool is_SCR)
 {
     m_fd_frontend = fd_frontend;
 
     // issue reset command
-    ResetDiseqc(false /* do a soft reset */);
+    ResetDiseqc(false, is_SCR);
 }
 
 bool DiSEqCDevTree::SetVoltage(uint voltage)
@@ -784 +832 @@
  *  \brief Represents a node in a DVB-S device network.
  */
 
-const DiSEqCDevDevice::TypeTable DiSEqCDevDevice::dvbdev_lookup[4] =
+const DiSEqCDevDevice::TypeTable DiSEqCDevDevice::dvbdev_lookup[5] =
 {
     { "switch",      kTypeSwitch },
     { "rotor",       kTypeRotor  },
+    { "scr",         kTypeSCR    },
     { "lnb",         kTypeLNB    },
     { QString::null, kTypeLNB    },
 };
@@ -891 +940 @@
             if (node)
                 node->SetDescription("Rotor");
             break;
+        case kTypeSCR:
+            node = new DiSEqCDevSCR(tree, dev_id);
+            if (node)
+                node->SetDescription("Unicable");
+                break;
         case kTypeLNB:
             node = new DiSEqCDevLNB(tree, dev_id);
             if (node)
@@ -2052 +2106 @@
 }
 
 ////////////////////////////////////////
+
+/** \class DiSEqCDevSCR
+ *  \brief Unicable / SCR Class.
+ */
+
+const DiSEqCDevDevice::TypeTable DiSEqCDevSCR::SCRPositionTable[3] =
+{
+    { "A",            kTypeScrPosA },
+    { "B",            kTypeScrPosB },
+    { QString::null,  kTypeScrPosA },
+};
+
+DiSEqCDevSCR::DiSEqCDevSCR(DiSEqCDevTree &tree, uint devid)
+    : DiSEqCDevDevice(tree, devid)
+    , m_scr_userband(0)
+    , m_scr_frequency(1400)
+    , m_scr_pin(-1)
+    , m_child(0)
+{
+    Reset();
+}
+
+DiSEqCDevSCR::~DiSEqCDevSCR()
+{
+    if (m_child)
+        delete m_child;
+}
+
+void DiSEqCDevSCR::Reset(void)
+{
+    if (m_child)
+        m_child->Reset();
+}
+
+bool DiSEqCDevSCR::Execute(const DiSEqCDevSettings &settings, const DTVMultiplex &tuning)
+{
+    // retrieve LNB info
+    DiSEqCDevLNB *lnb = m_tree.FindLNB(settings);
+    if (!lnb)
+    {
+        LOG(VB_GENERAL, LOG_ERR, LOC + "SCR: No LNB for this configuration!");
+        return false;
+    }
+
+    bool     high_band  = lnb->IsHighBand(tuning);
+    bool     horizontal = lnb->IsHorizontal(tuning);
+    uint32_t frequency  = lnb->GetIntermediateFrequency(settings, tuning);
+    uint t = (frequency / 1000 + m_scr_frequency + 2) / 4 - 350;
+
+    // retrieve position settings
+    dvbdev_pos_t scr_position = (dvbdev_pos_t) settings.GetValue(GetDeviceID());
+
+    // check parameters
+    if (m_scr_userband > 8)
+    {
+        LOG(VB_GENERAL, LOG_INFO, QString("SCR: Userband ID=%1 is out of standard range!")
+        .arg(m_scr_userband));
+    }
+
+    if (t >= 1024)
+    {
+        LOG(VB_GENERAL, LOG_ERR, LOC + "SCR: T out of range!");
+        return false;
+    }
+
+    LOG(VB_GENERAL, LOG_INFO, QString("SCR: Tuning to %1kHz, %2, %3 using UB=%4, FREQ=%5MHz, POS=%6%7")
+            .arg(tuning.frequency)
+            .arg(high_band ? "HiBand" : "LoBand")
+            .arg(horizontal ? "H" : "V")
+            .arg(m_scr_userband)
+            .arg(m_scr_frequency)
+            .arg((scr_position) ? "B" : "A")
+            .arg((m_scr_pin >= 0 && m_scr_pin <= 255) ?
+                     QString(", PIN=%1").arg(m_scr_pin) : QString("")));
+
+    // build command
+    unsigned char data[3];
+    data[0] = t >> 8 | m_scr_userband << 5;
+    data[1] = t & 0x00FF;
+
+    if (high_band)
+        data[0] |= (1 << 2);
+
+    if (horizontal)
+        data[0] |= (1 << 3);
+
+    if (scr_position)
+        data[0] |= (1 << 4);
+
+    // send command
+    if (m_scr_pin >= 0 && m_scr_pin <= 255)
+    {
+        data[2] = m_scr_pin;
+        return SendCommand(DISEQC_CMD_ODU_MDU, m_repeat, 3, data);
+    } else {
+        return SendCommand(DISEQC_CMD_ODU, m_repeat, 2, data);
+    }
+}
+
+bool DiSEqCDevSCR::PowerOff(void) const
+{
+    // check parameters
+    if (m_scr_userband > 8)
+    {
+        LOG(VB_GENERAL, LOG_INFO, QString("SCR: Userband ID=%1 is out of standard range!")
+        .arg(m_scr_userband));
+    }
+
+    LOG(VB_CHANNEL, LOG_INFO, LOC + QString("SCR: Power off UB=%1%7")
+            .arg(m_scr_userband)
+            .arg((m_scr_pin >= 0 && m_scr_pin <= 255)
+                 ? QString(", PIN=%1").arg(m_scr_pin)
+                 : QString("")));
+
+    // build command
+    unsigned char data[3];
+    data[0] = (uint8_t) (m_scr_userband << 5);
+    data[1] = 0x00;
+
+    // send command
+    if (m_scr_pin >= 0 && m_scr_pin <= 255)
+    {
+        data[2] = m_scr_pin;
+        return SendCommand(DISEQC_CMD_ODU_MDU, m_repeat, 3, data);
+    } else {
+        return SendCommand(DISEQC_CMD_ODU, m_repeat, 2, data);
+    }
+}
+
+bool DiSEqCDevSCR::SendCommand(uint cmd, uint repeats, uint data_len,
+                               unsigned char *data) const
+{
+    (void) repeats;
+
+    // power on bus
+    if (!m_tree.SetVoltage(SEC_VOLTAGE_18))
+        return false;
+    usleep(DISEQC_LONG_WAIT);
+
+    // send command
+    bool ret = m_tree.SendCommand(DISEQC_ADR_SW_ALL, cmd, repeats, data_len, data);
+
+    // power off bus
+    if (!m_tree.SetVoltage(SEC_VOLTAGE_13))
+        return false;
+
+    return ret;
+}
+
+uint DiSEqCDevSCR::GetVoltage(const DiSEqCDevSettings &settings,
+                              const DTVMultiplex      &tuning) const
+{
+    return SEC_VOLTAGE_13;
+}
+
+uint32_t DiSEqCDevSCR::GetIntermediateFrequency(const uint32_t frequency) const
+{
+    uint t = (frequency / 1000 + m_scr_frequency + 2) / 4 - 350;
+    return ((t + 350) * 4) * 1000 - frequency;
+}
+
+bool DiSEqCDevSCR::Load(void)
+{
+    // populate scr parameters from db
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(
+        "SELECT scr_userband,    scr_frequency, "
+        "       scr_pin,         cmd_repeat "
+        "FROM diseqc_tree "
+        "WHERE diseqcid = :DEVID");
+    query.bindValue(":DEVID", GetDeviceID());
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("DiSEqCDevSCR::Load 1", query);
+        return false;
+    }
+    else if (query.next())
+    {
+        m_scr_userband  = query.value(0).toUInt();
+        m_scr_frequency = query.value(1).toUInt();
+        m_scr_pin       = query.value(2).toInt();
+        m_repeat        = query.value(3).toUInt();
+    }
+
+    // load children from db
+    if (m_child)
+    {
+        delete m_child;
+        m_child = NULL;
+    }
+
+    query.prepare(
+        "SELECT diseqcid "
+        "FROM diseqc_tree "
+        "WHERE parentid = :DEVID");
+    query.bindValue(":DEVID", GetDeviceID());
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("DiSEqCDevSCR::Load 2", query);
+        return false;
+    }
+    else if (query.next())
+    {
+        uint child_dev_id = query.value(0).toUInt();
+        SetChild(0, CreateById(m_tree, child_dev_id));
+    }
+
+    return true;
+}
+
+bool DiSEqCDevSCR::Store(void) const
+{
+    MSqlQuery query(MSqlQuery::InitCon());
+
+    // insert new or update old
+    if (IsRealDeviceID())
+    {
+        query.prepare(
+            "UPDATE diseqc_tree "
+            "SET parentid        = :PARENT,  "
+            "    ordinal         = :ORDINAL, "
+            "    type            = 'scr',    "
+            "    description     = :DESC,    "
+            "    scr_userband    = :USERBAND, "
+            "    scr_frequency   = :FREQUENCY, "
+            "    scr_pin         = :PIN, "
+            "    cmd_repeat      = :REPEAT   "
+            "WHERE diseqcid = :DEVID");
+        query.bindValue(":DEVID",   GetDeviceID());
+    }
+    else
+    {
+        query.prepare(
+            "INSERT INTO diseqc_tree"
+            " ( parentid,      ordinal,         type, "
+            "   description,   scr_userband,    scr_frequency, "
+            "   scr_pin,       cmd_repeat) "
+            "VALUES "
+            " (:PARENT,       :ORDINAL,         'scr', "
+            "  :DESC,         :USERBAND,        :FREQUENCY,"
+            "  :PIN,          :REPEAT) ");
+    }
+
+    if (m_parent)
+        query.bindValue(":PARENT", m_parent->GetDeviceID());
+
+    query.bindValue(":ORDINAL",   m_ordinal);
+    query.bindValue(":DESC",      GetDescription());
+    query.bindValue(":USERBAND",  m_scr_userband);
+    query.bindValue(":FREQUENCY", m_scr_frequency);
+    query.bindValue(":PIN",       m_scr_pin);
+    query.bindValue(":REPEAT",    m_repeat);
+
+    // update dev_id
+    if (!query.exec())
+    {
+        MythDB::DBError("DiSEqCDevSCR::Store", query);
+        return false;
+    }
+
+    // figure out devid if we did an insert
+    if (!IsRealDeviceID())
+        SetDeviceID(query.lastInsertId().toUInt());
+
+    // chain to child
+    if (m_child)
+        return m_child->Store();
+
+    return true;
+}
+
+bool DiSEqCDevSCR::SetChild(uint ordinal, DiSEqCDevDevice *device)
+{
+    if (ordinal)
+        return false;
+
+    DiSEqCDevDevice *old_child = m_child;
+    m_child = NULL;
+    if (old_child)
+        delete old_child;
+
+    m_child = device;
+    if (m_child)
+    {
+        m_child->SetOrdinal(ordinal);
+        m_child->SetParent(this);
+    }
+
+    return true;
+}
+
+////////////////////////////////////////
 
 /** \class DiSEqCDevLNB
  *  \brief LNB Class.

.27/mythtv/libs/libmythtv/diseqc.h

@@ -27 +27 @@
 class DiSEqCDevDevice;
 class DiSEqCDevRotor;
 class DiSEqCDevLNB;
+class DiSEqCDevSCR;
 
 typedef QMap<uint, double>         uint_to_dbl_t;
 typedef QMap<double, uint>         dbl_to_uint_t;
@@ -85 +86 @@
 
     DiSEqCDevRotor  *FindRotor(const DiSEqCDevSettings &settings, uint index = 0);
     DiSEqCDevLNB    *FindLNB(const DiSEqCDevSettings &settings);
+    DiSEqCDevSCR    *FindSCR(const DiSEqCDevSettings &settings);
     DiSEqCDevDevice *FindDevice(uint dev_id);
 
     /** \brief Retrieves the root node in the tree. */
@@ -94 +96 @@
     bool SendCommand(uint adr, uint cmd, uint repeats = 0,
                      uint data_len = 0, unsigned char *data = NULL);
 
-    bool ResetDiseqc(bool hard_reset);
+    bool ResetDiseqc(bool hard_reset, bool is_SCR);
 
     // frontend fd
-    void Open(int fd_frontend);
+    void Open(int fd_frontend, bool is_SCR);
     void Close(void) { m_fd_frontend = -1; }
     int  GetFD(void) const { return m_fd_frontend; }
 
@@ -142 +144 @@
     virtual bool Store(void) const = 0;
 
     // Sets
-    enum dvbdev_t { kTypeSwitch = 0, kTypeRotor = 1, kTypeLNB = 2, };
+    enum dvbdev_t
+    {
+        kTypeSwitch = 0,
+        kTypeRotor = 1,
+        kTypeSCR = 2,
+        kTypeLNB = 3,
+    };
     void SetDeviceType(dvbdev_t type)        { m_dev_type = type;    }
     void SetParent(DiSEqCDevDevice* parent)  { m_parent   = parent;  }
     void SetOrdinal(uint ordinal)            { m_ordinal  = ordinal; }
@@ -201 +209 @@
                                    const TypeTable *table);
 
   private:
-    static const TypeTable dvbdev_lookup[4];
+    static const TypeTable dvbdev_lookup[5];
 };
 
 class DiSEqCDevSwitch : public DiSEqCDevDevice
@@ -359 +367 @@
     static const TypeTable RotorTypeTable[3];
 };
 
+class DiSEqCDevSCR : public DiSEqCDevDevice
+{
+  public:
+    DiSEqCDevSCR(DiSEqCDevTree &tree, uint devid);
+    ~DiSEqCDevSCR();
+
+    // Commands
+    virtual void Reset(void);
+    virtual bool Execute(const DiSEqCDevSettings&, const DTVMultiplex&);
+    bool         PowerOff(void) const;
+    virtual bool Load(void);
+    virtual bool Store(void) const;
+
+    // Sets
+    enum dvbdev_pos_t
+    {
+        kTypeScrPosA               = 0,
+        kTypeScrPosB               = 1,
+    };
+    void SetUserBand(uint userband)        { m_scr_userband  = userband;   }
+    void SetFrequency(uint freq)           { m_scr_frequency = freq;       }
+    void SetPIN(int pin)                   { m_scr_pin       = pin;        }
+    virtual bool SetChild(uint ordinal, DiSEqCDevDevice* device);
+
+    // Gets
+    uint         GetUserBand(void) const   { return m_scr_userband;        }
+    uint         GetFrequency(void) const  { return m_scr_frequency;       }
+    int          GetPIN(void) const        { return m_scr_pin;             }
+    virtual uint GetChildCount(void) const { return 1;                     }
+    virtual bool IsCommandNeeded(const DiSEqCDevSettings&,
+                                 const DTVMultiplex&) const { return false; }
+    virtual uint GetVoltage(const DiSEqCDevSettings&,
+                            const DTVMultiplex&) const;
+    uint32_t     GetIntermediateFrequency(const uint32_t frequency) const;
+
+    // Non-const Gets
+    virtual DiSEqCDevDevice *GetSelectedChild(const DiSEqCDevSettings&) const
+                                            { return m_child;              }
+    virtual DiSEqCDevDevice *GetChild(uint) { return m_child;              }
+
+    // statics
+    static QString SCRPositionToString(dvbdev_pos_t pos)
+        { return TableToString((uint)pos, SCRPositionTable); }
+
+    static dvbdev_pos_t SCRPositionFromString(const QString &pos)
+        { return (dvbdev_pos_t) TableFromString(pos, SCRPositionTable); }
+
+  protected:
+    bool         SendCommand(uint cmd, uint repeats, uint data_len = 0,
+                             unsigned char *data = NULL) const;
+
+  private:
+    uint         m_scr_userband;  /* 0-7 */
+    uint         m_scr_frequency;
+    int          m_scr_pin;       /* 0-255, -1=disabled */
+
+    DiSEqCDevDevice *m_child;
+
+    static const TypeTable SCRPositionTable[3];
+};
+
 class DiSEqCDevLNB : public DiSEqCDevDevice
 {
   public:

.27/mythtv/libs/libmythtv/diseqcsettings.cpp

@@ -47 +47 @@
                      QString::number((uint) DiSEqCDevDevice::kTypeSwitch));
         addSelection(DeviceTree::tr("Rotor"),
                      QString::number((uint) DiSEqCDevDevice::kTypeRotor));
+        addSelection(DeviceTree::tr("Unicable"),
+                     QString::number((uint) DiSEqCDevDevice::kTypeSCR));
         addSelection(DeviceTree::tr("LNB"),
                      QString::number((uint) DiSEqCDevDevice::kTypeLNB));
     }
@@ -107 +109 @@
 {
   public:
     DeviceRepeatSetting(DiSEqCDevDevice &device) :
-        SpinBoxSetting(this, 0, 5, 1), m_device(device)
+        SpinBoxSetting(this, 0, 15, 1), m_device(device)
     {
         setLabel(DeviceTree::tr("Repeat Count"));
         QString help = DeviceTree::tr(
-            "Number of times to repeat DiSEqC commands sent to this device. "
-            "Larger values may help with less reliable devices.");
+            "Number of repeat (command with repeat flag ON) or resend (the same command) DiSEqC commands."
+            "If value is higher than 10, command will be resend N-10 times"
+            "If value is lower than 10, command will be repeated N times"
+            "Repeat useful for unreliable DiSEqC equipment; resend useful when unreliable DiSEq equipment has broken/unsuported repeat flag support.");
         setHelpText(help);
     }
 
@@ -559 +563 @@
     config.Save();
 }
 
+//////////////////////////////////////// SCRUserBandSetting
+
+class SCRUserBandSetting : public SpinBoxSetting, public Storage
+{
+  public:
+    SCRUserBandSetting(DiSEqCDevSCR &scr) :
+        SpinBoxSetting(this, 0, 8, 1), m_scr(scr)
+    {
+        setLabel(DeviceTree::tr("Userband"));
+        setHelpText(DeviceTree::tr("Unicable userband ID (0-7) or sometimes (1-8)"));
+    }
+
+    virtual void Load(void)
+    {
+        setValue(m_scr.GetUserBand());
+    }
+
+    virtual void Save(void)
+    {
+        m_scr.SetUserBand(intValue());
+    }
+
+    virtual void Save(QString /*destination*/) { }
+
+  private:
+    DiSEqCDevSCR &m_scr;
+};
+
+//////////////////////////////////////// SCRFrequencySetting
+
+class SCRFrequencySetting : public LineEditSetting, public Storage
+{
+  public:
+    SCRFrequencySetting(DiSEqCDevSCR &scr) : LineEditSetting(this), m_scr(scr)
+    {
+        setLabel(DeviceTree::tr("Frequency (MHz)"));
+        setHelpText(DeviceTree::tr("Unicable userband frequency (usually 1210, 1420, 1680 and 2040 MHz)"));
+    }
+
+    virtual void Load(void)
+    {
+        setValue(QString::number(m_scr.GetFrequency()));
+    }
+
+    virtual void Save(void)
+    {
+        m_scr.SetFrequency(getValue().toUInt());
+    }
+
+    virtual void Save(QString /*destination*/) { }
+
+  private:
+    DiSEqCDevSCR &m_scr;
+};
+
+//////////////////////////////////////// SCRPINSetting
+
+class SCRPINSetting : public LineEditSetting, public Storage
+{
+  public:
+    SCRPINSetting(DiSEqCDevSCR &scr) : LineEditSetting(this), m_scr(scr)
+    {
+        setLabel(DeviceTree::tr("PIN code"));
+        setHelpText(DeviceTree::tr("Unicable PIN code (-1 disabled, 0 - 255)"));
+    }
+
+    virtual void Load(void)
+    {
+        setValue(QString::number(m_scr.GetPIN()));
+    }
+
+    virtual void Save(void)
+    {
+        m_scr.SetPIN(getValue().toInt());
+    }
+
+    virtual void Save(QString /*destination*/) { }
+
+  private:
+    DiSEqCDevSCR &m_scr;
+};
+
+//////////////////////////////////////// SCRConfig
+
+SCRConfig::SCRConfig(DiSEqCDevSCR &scr) : m_scr(scr)
+{
+    ConfigurationGroup *group =
+        new VerticalConfigurationGroup(false, false);
+    group->setLabel(DeviceTree::tr("Unicable Configuration"));
+
+    group->addChild(new SCRUserBandSetting(scr));
+    group->addChild(new SCRFrequencySetting(scr));
+    group->addChild(new SCRPINSetting(scr));
+    group->addChild(new DeviceRepeatSetting(scr));
+
+    addChild(group);
+}
+
 //////////////////////////////////////// LnbPresetSetting
 
 class lnb_preset
@@ -949 +1051 @@
         }
         break;
 
+        case DiSEqCDevDevice::kTypeSCR:
+        {
+            DiSEqCDevSCR *scr = dynamic_cast<DiSEqCDevSCR*>(dev);
+            if (scr)
+            {
+                SCRConfig config(*scr);
+                changed = (config.exec() == MythDialog::Accepted);
+            }
+        }
+        break;
+
         case DiSEqCDevDevice::kTypeLNB:
         {
             DiSEqCDevLNB *lnb = dynamic_cast<DiSEqCDevLNB*>(dev);
@@ -978 +1091 @@
     MythListBox *list = new MythListBox(popup);
     list->insertItem(tr("Switch"));
     list->insertItem(tr("Rotor"));
+    list->insertItem(tr("Unicable"));
     list->insertItem(tr("LNB"));
     list->setCurrentRow(0, QItemSelectionModel::Select);
 
@@ -1264 +1378 @@
     DiSEqCDevSettings    &m_settings;
 };
 
+//////////////////////////////////////// SCRPositionSetting
+
+class SCRPositionSetting : public ComboBoxSetting, public Storage
+{
+  public:
+    SCRPositionSetting(DiSEqCDevDevice &node, DiSEqCDevSettings &settings)
+        : ComboBoxSetting(this), m_node(node), m_settings(settings)
+    {
+        setLabel("Position");
+        setHelpText(DeviceTree::tr("Unicable satellite position (A/B)"));
+        addSelection(DiSEqCDevSCR::SCRPositionToString(DiSEqCDevSCR::kTypeScrPosA),
+                     QString::number((uint)DiSEqCDevSCR::kTypeScrPosA), true);
+        addSelection(DiSEqCDevSCR::SCRPositionToString(DiSEqCDevSCR::kTypeScrPosB),
+                     QString::number((uint)DiSEqCDevSCR::kTypeScrPosB), false);
+    }
+
+    virtual void Load(void)
+    {
+        double value = m_settings.GetValue(m_node.GetDeviceID());
+        setValue(getValueIndex(QString::number((uint)value)));
+    }
+
+    virtual void Save(void)
+    {
+        m_settings.SetValue(m_node.GetDeviceID(), getValue().toDouble());
+    }
+
+    virtual void Save(QString /*destination*/) { }
+
+  private:
+    DiSEqCDevDevice      &m_node;
+    DiSEqCDevSettings    &m_settings;
+};
+
 //////////////////////////////////////// DTVDeviceConfigGroup
 
 DTVDeviceConfigGroup::DTVDeviceConfigGroup(
@@ -1306 +1454 @@
                 setting = new USALSRotorSetting(*node, m_settings);
             break;
         }
+        case DiSEqCDevDevice::kTypeSCR:
+        {
+            setting = new SCRPositionSetting(*node, m_settings);
+            break;
+        }
         default:
             break;
     }
@@ -1380 +1533 @@
     DISEQC_POSITIONER_X_SWITCH_2   = 9,
     DISEQC_SW21                    = 10,
     DISEQC_SW64                    = 11,
+    DISEQC_SCR                     = 12,
 };
 
 // import old diseqc configuration into tree
@@ -1549 +1703 @@
                 break;
             }
 
+            case DISEQC_SCR:
+            {
+                // SCR + LNB
+                root = DiSEqCDevDevice::CreateByType(
+                    tree, DiSEqCDevDevice::kTypeSCR);
+                DiSEqCDevSCR *scr = dynamic_cast<DiSEqCDevSCR*>(root);
+                if (scr)
+                {
+                    add_lnbs = 1;
+                }
+                break;
+            }
+
             default:
             {
                 LOG(VB_GENERAL, LOG_ERR, "Unknown DiSEqC device type " +
@@ -1615 +1782 @@
 
                 case DISEQC_POSITIONER_1_2:
                 case DISEQC_POSITIONER_X:
+                case DISEQC_SCR:
                     lnb = dynamic_cast<DiSEqCDevLNB*>(root->GetChild(0));
                     set.SetValue(root->GetDeviceID(), pos);
                     break;

.27/mythtv/libs/libmythtv/diseqcsettings.h

@@ -73 +73 @@
     TransButtonSetting *m_pos;
 };
 
+class SCRConfig : public QObject, public ConfigurationWizard
+{
+    Q_OBJECT
+
+  public:
+    SCRConfig(DiSEqCDevSCR &scr);
+
+  private:
+    DiSEqCDevSCR &m_scr;
+};
+
 class LNBTypeSetting;
 class LNBLOFSwitchSetting;
 class LNBLOFLowSetting;

.27/mythtv/libs/libmythtv/recorders/dvbchannel.cpp

@@ -269 +269 @@
     // Turn on the power to the LNB
     if (tunerType.IsDiSEqCSupported())
     {
+
         diseqc_tree = diseqc_dev.FindTree(GetCardID());
         if (diseqc_tree)
-            diseqc_tree->Open(fd_frontend);
+        {
+            bool is_SCR = false;
+
+            DiSEqCDevSCR *scr = diseqc_tree->FindSCR(diseqc_settings);
+            if (scr)
+            {
+                is_SCR = true;
+                LOG(VB_CHANNEL, LOG_INFO, LOC + "Requested DVB channel is on SCR system");
+            }
+            else
+                LOG(VB_CHANNEL, LOG_INFO, LOC + "Requested DVB channel is on non-SCR system");
+
+            diseqc_tree->Open(fd_frontend, is_SCR);
+        }
     }
 
     first_tune = true;
@@ -685 +699 @@
     // Remove any events in queue before tuning.
     drain_dvb_events(fd_frontend);
 
-    // send DVB-S setup
-    if (diseqc_tree)
-    {
-        // configure for new input
-        if (!same_input)
-            diseqc_settings.Load(inputid);
-
-        // execute diseqc commands
-        if (!diseqc_tree->Execute(diseqc_settings, tuning))
-        {
-            LOG(VB_GENERAL, LOG_ERR, LOC +
-                "Tune(): Failed to setup DiSEqC devices");
-            return false;
-        }
-
-        // retrieve actual intermediate frequency
-        DiSEqCDevLNB *lnb = diseqc_tree->FindLNB(diseqc_settings);
-        if (!lnb)
-        {
-            LOG(VB_GENERAL, LOG_ERR, LOC +
-                "Tune(): No LNB for this configuration");
-            return false;
-        }
-
-        if (lnb->GetDeviceID() != last_lnb_dev_id)
-        {
-            last_lnb_dev_id = lnb->GetDeviceID();
-            // make sure we tune to frequency, if the lnb has changed
-            reset = first_tune = true;
-        }
-
-        intermediate_freq = lnb->GetIntermediateFrequency(
-            diseqc_settings, tuning);
-
-        // if card can auto-FEC, use it -- sometimes NITs are inaccurate
-        if (capabilities & FE_CAN_FEC_AUTO)
-            can_fec_auto = true;
-
-        // Check DVB-S intermediate frequency here since it requires a fully
-        // initialized diseqc tree
-        CheckFrequency(intermediate_freq);
-    }
-
-    LOG(VB_CHANNEL, LOG_INFO, LOC + "Old Params: " + prev_tuning.toString() +
-            "\n\t\t\t" + LOC + "New Params: " + tuning.toString());
+    LOG(VB_CHANNEL, LOG_INFO, LOC + "\nOld Params: " + prev_tuning.toString() +
+            "\nNew Params: " + tuning.toString());
 
     // DVB-S is in kHz, other DVB is in Hz
     bool is_dvbs = ((DTVTunerType::kTunerTypeDVBS1 == tunerType) ||
@@ -743 +714 @@
                 .arg(intermediate_freq ? intermediate_freq : tuning.frequency)
                 .arg(suffix));
 
+        // send DVB-S setup
+        if (diseqc_tree)
+        {
+            // configure for new input
+            if (!same_input)
+                diseqc_settings.Load(inputid);
+
+            // execute diseqc commands
+            if (!diseqc_tree->Execute(diseqc_settings, tuning))
+            {
+                LOG(VB_GENERAL, LOG_ERR, LOC +
+                    "Tune(): Failed to setup DiSEqC devices");
+                return false;
+            }
+
+            // retrieve actual intermediate frequency
+            DiSEqCDevLNB *lnb = diseqc_tree->FindLNB(diseqc_settings);
+            if (!lnb)
+            {
+                LOG(VB_GENERAL, LOG_ERR, LOC +
+                    "Tune(): No LNB for this configuration");
+                return false;
+            }
+
+            if (lnb->GetDeviceID() != last_lnb_dev_id)
+            {
+                last_lnb_dev_id = lnb->GetDeviceID();
+                // make sure we tune to frequency, if the lnb has changed
+                reset = first_tune = true;
+            }
+
+            intermediate_freq = lnb->GetIntermediateFrequency(
+                diseqc_settings, tuning);
+
+            // retrieve scr intermediate frequency
+            DiSEqCDevSCR *scr = diseqc_tree->FindSCR(diseqc_settings);
+            if (lnb && scr)
+            {
+                intermediate_freq = scr->GetIntermediateFrequency(intermediate_freq);
+            }
+
+            // if card can auto-FEC, use it -- sometimes NITs are inaccurate
+            if (capabilities & FE_CAN_FEC_AUTO)
+                can_fec_auto = true;
+
+            // Check DVB-S intermediate frequency here since it requires a fully
+            // initialized diseqc tree
+            CheckFrequency(intermediate_freq);
+        }
+
 #if DVB_API_VERSION >=5
         if (DTVTunerType::kTunerTypeDVBS2 == tunerType)
         {