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>

5 files changed, 92 insertions, 17 deletions

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();