Add more info to QCanBusDeviceInfo

Added description, serial number and channel for SocketCAN, PeakCAN,
SystecCAN, and VectorCAN plugins. For now, not all plugins do support
all kind of information:

SocketCAN: description and channel
PeakCAN:   description and channel (Windows PCANBasic >= 4.2.0)
SystecCAN: description, serial number, and channel
VectorCAN: description, serial number, and channel

[ChangeLog][QCanBusDeviceInfo] Added description, serial number
and channel to QCanBusDeviceInfo, as far as supported by the
various plugins.

Change-Id: Ib2292e06065eb91848f682ebf69a4cc968f4d4ba
Reviewed-by: Rolf Eike Beer <eb@emlix.com>
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>

12 files changed, 179 insertions, 20 deletions

diff --git a/examples/serialbus/can/connectdialog.cpp b/examples/serialbus/can/connectdialog.cpp
index 5a12592..601ef2c 100644
--- a/examples/serialbus/can/connectdialog.cpp
+++ b/examples/serialbus/can/connectdialog.cpp
@@ -115,6 +115,12 @@ void ConnectDialog::interfaceChanged(const QString &interface)
 
     for (const QCanBusDeviceInfo &info : qAsConst(m_interfaces)) {
         if (info.name() == interface) {
+            m_ui->descriptionLabel->setText(info.description());
+            QString serialNumber = info.serialNumber();
+            if (serialNumber.isEmpty())
+                serialNumber = tr("n/a");
+            m_ui->serialNumberLabel->setText(tr("Serial: %1").arg(serialNumber));
+            m_ui->channelLabel->setText(tr("Channel: %1").arg(info.channel()));
             m_ui->isVirtual->setChecked(info.isVirtual());
             m_ui->isFlexibleDataRateCapable->setChecked(info.hasFlexibleDataRate());
             break;
diff --git a/examples/serialbus/can/connectdialog.ui b/examples/serialbus/can/connectdialog.ui
index def6e59..6d4f261 100644
--- a/examples/serialbus/can/connectdialog.ui
+++ b/examples/serialbus/can/connectdialog.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>441</width>
-    <height>341</height>
+    <width>446</width>
+    <height>395</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -192,6 +192,27 @@
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
+       <widget class="QLabel" name="descriptionLabel">
+        <property name="text">
+         <string/>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="serialNumberLabel">
+        <property name="text">
+         <string/>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="channelLabel">
+        <property name="text">
+         <string/>
+        </property>
+       </widget>
+      </item>
+      <item>
        <widget class="QCheckBox" name="isFlexibleDataRateCapable">
         <property name="text">
          <string>Flexible Data Rate</string>
diff --git a/src/plugins/canbus/peakcan/peakcanbackend.cpp b/src/plugins/canbus/peakcan/peakcanbackend.cpp
index 5460951..7e6fe43 100644
--- a/src/plugins/canbus/peakcan/peakcanbackend.cpp
+++ b/src/plugins/canbus/peakcan/peakcanbackend.cpp
@@ -120,14 +120,30 @@ QList<QCanBusDeviceInfo> PeakCanBackend::interfaces()
     QList<QCanBusDeviceInfo> result;
 
     for (int i = 0; pcanChannels[i].index != PCAN_NONEBUS; ++i) {
-        int value;
-        const TPCANStatus stat = ::CAN_GetValue(pcanChannels[i].index, PCAN_CHANNEL_CONDITION,
+        int value = 0;
+        const TPCANHandle index = pcanChannels[i].index;
+        const TPCANStatus stat = ::CAN_GetValue(index, PCAN_CHANNEL_CONDITION,
                                                 &value, sizeof(value));
         if ((stat == PCAN_ERROR_OK) && (value & PCAN_CHANNEL_AVAILABLE)) {
-            const TPCANStatus fdStat = ::CAN_GetValue(pcanChannels[i].index, PCAN_CHANNEL_FEATURES,
+            const TPCANStatus fdStat = ::CAN_GetValue(index, PCAN_CHANNEL_FEATURES,
                                                       &value, sizeof(value));
             const bool isFd = (fdStat == PCAN_ERROR_OK) && (value & FEATURE_FD_CAPABLE);
-            result.append(createDeviceInfo(QLatin1String(pcanChannels[i].name), false, isFd));
+
+            char description[256] = {0};
+            const TPCANStatus descStat = ::CAN_GetValue(index, PCAN_HARDWARE_NAME,
+                                                        description, sizeof(description));
+            if (descStat != PCAN_ERROR_OK)
+                description[0] = 0;
+
+            int channel = 0;
+            const TPCANStatus chnStat = ::CAN_GetValue(index, PCAN_CONTROLLER_NUMBER,
+                                                       &channel, sizeof(channel));
+            if (chnStat != PCAN_ERROR_OK)
+                channel = 0;
+
+            result.append(std::move(createDeviceInfo(QLatin1String(pcanChannels[i].name),
+                                                     QString(), QLatin1String(description),
+                                                     channel, false, isFd)));
         }
     }
 
diff --git a/src/plugins/canbus/socketcan/socketcanbackend.cpp b/src/plugins/canbus/socketcan/socketcanbackend.cpp
index b43787d..81b7c13 100644
--- a/src/plugins/canbus/socketcan/socketcanbackend.cpp
+++ b/src/plugins/canbus/socketcan/socketcanbackend.cpp
@@ -80,6 +80,8 @@ QT_BEGIN_NAMESPACE
 Q_DECLARE_LOGGING_CATEGORY(QT_CANBUS_PLUGINS_SOCKETCAN)
 
 const char sysClassNetC[] = "/sys/class/net/";
+const char interfaceC[]   = "/device/interface";
+const char devIdC[]       = "/dev_id";
 const char flagsC[]       = "/flags";
 const char mtuC[]         = "/mtu";
 const char typeC[]        = "/type";
@@ -120,6 +122,23 @@ static quint32 flags(const QString &canDevice)
     return result;
 }
 
+static QString deviceDescription(const QString &canDevice)
+{
+    const QString path = QLatin1String(sysClassNetC) + canDevice + QLatin1String(interfaceC);
+    const QByteArray content = fileContent(path);
+    if (content.isEmpty() && isVirtual(canDevice))
+        return QStringLiteral("Virtual CAN");
+
+    return QString::fromUtf8(content);
+}
+
+static int deviceChannel(const QString &canDevice)
+{
+    const QString path = QLatin1String(sysClassNetC) + canDevice + QLatin1String(devIdC);
+    const QByteArray content = fileContent(path);
+    return content.toInt(nullptr, 0);
+}
+
 QList<QCanBusDeviceInfo> SocketCanBackend::interfaces()
 {
     QList<QCanBusDeviceInfo> result;
@@ -136,9 +155,12 @@ QList<QCanBusDeviceInfo> SocketCanBackend::interfaces()
         if (!(flags(deviceName) & DeviceIsActive))
             continue;
 
-        auto info = createDeviceInfo(deviceName, isVirtual(deviceName),
-                                     isFlexibleDataRateCapable(deviceName));
-        result.append(info);
+        const QString serial;
+        const QString description = deviceDescription(deviceName);
+        const int channel = deviceChannel(deviceName);
+        result.append(std::move(createDeviceInfo(deviceName, serial, description,
+                                                 channel, isVirtual(deviceName),
+                                                 isFlexibleDataRateCapable(deviceName))));
     }
 
     std::sort(result.begin(), result.end(),
diff --git a/src/plugins/canbus/systeccan/systeccanbackend.cpp b/src/plugins/canbus/systeccan/systeccanbackend.cpp
index 8b914d6..7041af8 100644
--- a/src/plugins/canbus/systeccan/systeccanbackend.cpp
+++ b/src/plugins/canbus/systeccan/systeccanbackend.cpp
@@ -63,19 +63,49 @@ bool SystecCanBackend::canCreate(QString *errorReason)
     return true;
 }
 
+QCanBusDeviceInfo SystecCanBackend::createDeviceInfo(const QString &serialNumber,
+                                                     const QString &description,
+                                                     uint deviceNumber,
+                                                     int channelNumber)
+{
+    const QString name = QString::fromLatin1("can%1.%2").arg(deviceNumber).arg(channelNumber);
+    return QCanBusDevice::createDeviceInfo(name, serialNumber, description, channelNumber, false, false);
+}
+
+static QString descriptionString(uint productCode)
+{
+    switch (productCode & USBCAN_PRODCODE_MASK_PID) {
+    case USBCAN_PRODCODE_PID_GW001:       return QStringLiteral("USB-CANmodul (G1)");
+    case USBCAN_PRODCODE_PID_GW002:       return QStringLiteral("USB-CANmodul (G2)");
+    case USBCAN_PRODCODE_PID_MULTIPORT:   return QStringLiteral("Multiport CAN-to-USB (G3)");
+    case USBCAN_PRODCODE_PID_BASIC:       return QStringLiteral("USB-CANmodul1 (G3)");
+    case USBCAN_PRODCODE_PID_ADVANCED:    return QStringLiteral("USB-CANmodul2 (G3)");
+    case USBCAN_PRODCODE_PID_USBCAN8:     return QStringLiteral("USB-CANmodul8 (G3)");
+    case USBCAN_PRODCODE_PID_USBCAN16:    return QStringLiteral("USB-CANmodul16 (G3)");
+    case USBCAN_PRODCODE_PID_ADVANCED_G4: return QStringLiteral("USB-CANmodul2 (G4)");
+    case USBCAN_PRODCODE_PID_BASIC_G4:    return QStringLiteral("USB-CANmodul1 (G4)");
+    default:                              return QStringLiteral("Unknown");
+    }
+}
+
 static void DRV_CALLBACK_TYPE ucanEnumCallback(DWORD index, BOOL isUsed,
                                                tUcanHardwareInfoEx *hardwareInfo,
                                                tUcanHardwareInitInfo *initInfo,
                                                void *args)
 {
-    auto result = static_cast<QStringList *>(args);
+    auto result = static_cast<QList<QCanBusDeviceInfo> *>(args);
 
     Q_UNUSED(index);
     Q_UNUSED(isUsed);
 
-    result->append(QString::fromLatin1("can%1.0").arg(hardwareInfo->m_bDeviceNr));
-    if (USBCAN_CHECK_SUPPORT_TWO_CHANNEL(hardwareInfo))
-        result->append(QString::fromLatin1("can%1.1").arg(hardwareInfo->m_bDeviceNr));
+    const QString serialNumber = QString::number(hardwareInfo->m_dwSerialNr);
+    const QString description = descriptionString(hardwareInfo->m_dwProductCode);
+    result->append(std::move(SystecCanBackend::createDeviceInfo(serialNumber, description,
+                                                                hardwareInfo->m_bDeviceNr, 0)));
+    if (USBCAN_CHECK_SUPPORT_TWO_CHANNEL(hardwareInfo)) {
+        result->append(std::move(SystecCanBackend::createDeviceInfo(serialNumber, description,
+                                                                    hardwareInfo->m_bDeviceNr, 1)));
+    }
 
     initInfo->m_fTryNext = true; // continue enumerating with next device
 }
@@ -84,12 +114,8 @@ QList<QCanBusDeviceInfo> SystecCanBackend::interfaces()
 {
     QList<QCanBusDeviceInfo> result;
 
-    QStringList devices;
-    ::UcanEnumerateHardware(&ucanEnumCallback, &devices, false,
-                                                0, ~0, 0, ~0, 0, ~0);
+    ::UcanEnumerateHardware(&ucanEnumCallback, &result, false, 0, ~0, 0, ~0, 0, ~0);
 
-    for (const QString &s : qAsConst(devices))
-        result.append(createDeviceInfo(s, false, false));
     return result;
 }
 
diff --git a/src/plugins/canbus/systeccan/systeccanbackend.h b/src/plugins/canbus/systeccan/systeccanbackend.h
index 7bf20f8..cb62808 100644
--- a/src/plugins/canbus/systeccan/systeccanbackend.h
+++ b/src/plugins/canbus/systeccan/systeccanbackend.h
@@ -69,6 +69,12 @@ public:
     static QList<QCanBusDeviceInfo> interfaces();
     static bool canCreate(QString *errorReason);
 
+    // This function needs to be public as it is accessed by a callback
+    static QCanBusDeviceInfo createDeviceInfo(const QString &serialNumber,
+                                              const QString &description,
+                                              uint deviceNumber,
+                                              int channelNumber);
+
 private:
     SystecCanBackendPrivate * const d_ptr;
 };
diff --git a/src/plugins/canbus/vectorcan/vectorcanbackend.cpp b/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
index 656491c..dc28d7c 100644
--- a/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
+++ b/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
@@ -89,7 +89,12 @@ QList<QCanBusDeviceInfo> VectorCanBackend::interfaces()
 
         const bool isVirtual = config.channel[i].hwType == XL_HWTYPE_VIRTUAL;
         const bool isFd = config.channel[i].channelCapabilities & XL_CHANNEL_FLAG_CANFD_SUPPORT;
-        result.append(createDeviceInfo(QStringLiteral("can") + QString::number(i), isVirtual, isFd));
+        const int channel = config.channel[i].hwChannel;
+        const QString name = QStringLiteral("can") + QString::number(i);
+        const QString serial = QString::number(config.channel[i].serialNumber);
+        const QString description = QLatin1String(config.channel[i].name);
+        result.append(std::move(createDeviceInfo(name, serial, description, channel,
+                                                 isVirtual, isFd)));
     }
 
     VectorCanBackendPrivate::cleanupDriver();
diff --git a/src/serialbus/qcanbusdevice.cpp b/src/serialbus/qcanbusdevice.cpp
index 44a9a65..b1c97a6 100644
--- a/src/serialbus/qcanbusdevice.cpp
+++ b/src/serialbus/qcanbusdevice.cpp
@@ -727,10 +727,27 @@ void QCanBusDevice::setState(QCanBusDevice::CanBusDeviceState newState)
 QCanBusDeviceInfo QCanBusDevice::createDeviceInfo(const QString &name, bool isVirtual,
                                                   bool isFlexibleDataRateCapable)
 {
+    return createDeviceInfo(name, QString(), QString(), 0, isVirtual, isFlexibleDataRateCapable);
+}
+
+/*!
+    \since 5.11
+    Returns a QCanBusDeviceInfo created from the given parameters \a name,
+    \a serialNumber, \a description, \a channel, \a isVirtual, and \a
+    isFlexibleDataRateCapable.
+    \internal
+ */
+QCanBusDeviceInfo QCanBusDevice::createDeviceInfo(const QString &name, const QString &serialNumber,
+                                                  const QString &description, int channel,
+                                                  bool isVirtual, bool isFlexibleDataRateCapable)
+{
     QScopedPointer<QCanBusDeviceInfoPrivate> info(new QCanBusDeviceInfoPrivate);
     info->name = name;
-    info->isVirtual = isVirtual;
+    info->serialNumber = serialNumber;
+    info->description = description;
+    info->channel = channel;
     info->hasFlexibleDataRate = isFlexibleDataRateCapable;
+    info->isVirtual = isVirtual;
     return QCanBusDeviceInfo(*info.take());
 }
 
diff --git a/src/serialbus/qcanbusdevice.h b/src/serialbus/qcanbusdevice.h
index 3a644c6..482e9d0 100644
--- a/src/serialbus/qcanbusdevice.h
+++ b/src/serialbus/qcanbusdevice.h
@@ -146,6 +146,9 @@ protected:
     static QCanBusDeviceInfo createDeviceInfo(const QString &name,
                                               bool isVirtual = false,
                                               bool isFlexibleDataRateCapable = false);
+    static QCanBusDeviceInfo createDeviceInfo(const QString &name, const QString &serialNumber,
+                                              const QString &description, int channel,
+                                              bool isVirtual, bool isFlexibleDataRateCapable);
 };
 
 Q_DECLARE_TYPEINFO(QCanBusDevice::CanBusError, Q_PRIMITIVE_TYPE);
diff --git a/src/serialbus/qcanbusdeviceinfo.cpp b/src/serialbus/qcanbusdeviceinfo.cpp
index 30b0e12..25c02e1 100644
--- a/src/serialbus/qcanbusdeviceinfo.cpp
+++ b/src/serialbus/qcanbusdeviceinfo.cpp
@@ -96,6 +96,38 @@ QString QCanBusDeviceInfo::name() const
 }
 
 /*!
+    \since 5.11
+    Returns a textual description of the CAN bus interface, if available.
+    Example output: "PCAN USB Pro FD". If no description is available,
+    an empty string is returned.
+*/
+QString QCanBusDeviceInfo::description() const
+{
+    return d_ptr->description;
+}
+
+/*!
+    \since 5.11
+    Returns the serial number of the CAN bus interface as string, if available.
+    Otherwise, an empty string is returned.
+*/
+QString QCanBusDeviceInfo::serialNumber() const
+{
+    return d_ptr->serialNumber;
+}
+
+/*!
+    \since 5.11
+    Returns the sequential channel number of the CAN bus interface, starting
+    with zero. If the interface has only one channel or if no information about
+    the channel is available, zero is returned.
+*/
+int QCanBusDeviceInfo::channel() const
+{
+    return d_ptr->channel;
+}
+
+/*!
     Returns true, if the CAN bus interface is CAN FD (flexible data rate) capable.
 
     If this information is not available, false is returned.
diff --git a/src/serialbus/qcanbusdeviceinfo.h b/src/serialbus/qcanbusdeviceinfo.h
index 68b68a3..fbe2c71 100644
--- a/src/serialbus/qcanbusdeviceinfo.h
+++ b/src/serialbus/qcanbusdeviceinfo.h
@@ -65,6 +65,9 @@ public:
     }
 
     QString name() const;
+    QString description() const;
+    QString serialNumber() const;
+    int channel() const;
 
     bool hasFlexibleDataRate() const;
     bool isVirtual() const;
diff --git a/src/serialbus/qcanbusdeviceinfo_p.h b/src/serialbus/qcanbusdeviceinfo_p.h
index ae6d71d..78c9e1c 100644
--- a/src/serialbus/qcanbusdeviceinfo_p.h
+++ b/src/serialbus/qcanbusdeviceinfo_p.h
@@ -62,7 +62,9 @@ public:
     }
 
     QString name;
+    QString description;
     QString serialNumber;
+    int  channel = 0;
     bool hasFlexibleDataRate = false;
     bool isVirtual = false;
 };